sid/NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Resolved conflicts

Browse Source 
Former-commit-id: 4bd4e4f8435d701d16d3864dd030a6c1cff48c47
This commit is contained in:
Lynix
2012-12-02 21:49:14 +01:00
parent 6a3087cc26 d0545eb760
commit 780da2cfa5
46 changed files with 1251 additions and 1283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/Nazara/Core.hpp
View File

@@ -43,6 +43,7 @@
#include <Nazara/Core/File.hpp>
#include <Nazara/Core/Format.hpp>
#include <Nazara/Core/Functor.hpp>
#include <Nazara/Core/HardwareInfo.hpp>
#include <Nazara/Core/Hash.hpp>
#include <Nazara/Core/Hashable.hpp>
#include <Nazara/Core/HashDigest.hpp>
@@ -61,6 +62,7 @@
#include <Nazara/Core/Stream.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Core/TaskScheduler.hpp>
#include <Nazara/Core/Thread.hpp>
#include <Nazara/Core/Tuple.hpp>
#include <Nazara/Core/Unicode.hpp>

21
include/Nazara/Noise/Abstract2DNoise.hpp Normal file
View File

@@ -0,0 +1,21 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_ABSTRACT2DNOISE_HPP
#define NAZARA_ABSTRACT2DNOISE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/MappedNoiseBase.hpp>
class NAZARA_API NzAbstract2DNoise : public NzMappedNoiseBase
{
public:
float GetBasicValue(float x, float y);
float GetMappedValue(float x, float y);
virtual float GetValue(float x, float y, float resolution) = 0;
};
#endif // NAZARA_ABSTRACT2DNOISE_HPP

21
include/Nazara/Noise/Abstract3DNoise.hpp Normal file
View File

@@ -0,0 +1,21 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_ABSTRACT3DNOISE_HPP
#define NAZARA_ABSTRACT3DNOISE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/MappedNoiseBase.hpp>
class NAZARA_API NzAbstract3DNoise : public NzMappedNoiseBase
{
public:
float GetBasicValue(float x, float y, float z);
float GetMappedValue(float x, float y, float z);
virtual float GetValue(float x, float y, float z, float resolution) = 0;
};
#endif // NAZARA_ABSTRACT3DNOISE_HPP

21
include/Nazara/Noise/Abstract4DNoise.hpp Normal file
View File

@@ -0,0 +1,21 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_ABSTRACT4DNOISE_HPP
#define NAZARA_ABSTRACT4DNOISE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/MappedNoiseBase.hpp>
class NAZARA_API NzAbstract4DNoise : public NzMappedNoiseBase
{
public:
float GetBasicValue(float x, float y, float z, float w);
float GetMappedValue(float x, float y, float z, float w);
virtual float GetValue(float x, float y, float z, float w, float resolution) = 0;
};
#endif // NAZARA_ABSTRACT4DNOISE_HPP

12
include/Nazara/Noise/ComplexNoiseBase.hpp
View File

@@ -8,16 +8,19 @@
#define COMPLEXNOISEBASE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
#include <array>
class NAZARA_API NzComplexNoiseBase : public NzNoiseBase
class NAZARA_API NzComplexNoiseBase
{
public:
NzComplexNoiseBase();
~NzComplexNoiseBase() = default;
void SetLacunarity(float lacunarity);
float GetHurstParameter() const;
float GetLacunarity() const;
float GetOctaveNumber() const;
void SetHurstParameter(float h);
void SetLacunarity(float lacunarity);
void SetOctavesNumber(float octaves);
void RecomputeExponentArray();
@@ -25,11 +28,10 @@ class NAZARA_API NzComplexNoiseBase : public NzNoiseBase
float m_lacunarity;
float m_hurst;
float m_octaves;
float exponent_array[30];
std::array<float, 30> m_exponent_array;
float m_sum;
private:
bool m_parametersModified;
};
#endif // COMPLEXNOISEBASE_HPP

28
include/Nazara/Noise/FBM2D.hpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef FBM2D_HPP
#define FBM2D_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract2DNoise.hpp>
class NAZARA_API NzFBM2D : public NzAbstract2DNoise, public NzComplexNoiseBase
{
public:
NzFBM2D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float resolution);
~NzFBM2D();
protected:
private:
NzAbstract2DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
#endif // FBM2D_HPP

29
include/Nazara/Noise/FBM3D.hpp Normal file
View File

@@ -0,0 +1,29 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef FBM3D_HPP
#define FBM3D_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract3DNoise.hpp>
class NAZARA_API NzFBM3D : public NzAbstract3DNoise, public NzComplexNoiseBase
{
public:
NzFBM3D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float z, float resolution);
~NzFBM3D();
protected:
private:
NzAbstract3DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
#endif // FBM3D_HPP

29
include/Nazara/Noise/FBM4D.hpp Normal file
View File

@@ -0,0 +1,29 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef FBM4D_HPP
#define FBM4D_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract4DNoise.hpp>
class NAZARA_API NzFBM4D : public NzAbstract4DNoise, public NzComplexNoiseBase
{
public:
NzFBM4D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float z, float w, float resolution);
~NzFBM4D();
protected:
private:
NzAbstract4DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
#endif // FBM4D_HPP

32
include/Nazara/Noise/HybridMultiFractal3D.hpp Normal file
View File

@@ -0,0 +1,32 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef HYBRIDMULTIFRACTAL3D_HPP
#define HYBRIDMULTIFRACTAL3D_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract3DNoise.hpp>
class NAZARA_API NzHybridMultiFractal3D : public NzAbstract3DNoise, public NzComplexNoiseBase
{
public:
NzHybridMultiFractal3D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float z, float resolution);
~NzHybridMultiFractal3D();
protected:
private:
NzAbstract3DNoise* m_source;
float m_value;
float m_remainder;
float m_offset;
float m_weight;
float m_signal;
nzNoises m_noiseType;
};
#endif // HYBRIDMULTIFRACTAL3D_HPP

32
include/Nazara/Noise/HybridMultiFractal4D.hpp Normal file
View File

@@ -0,0 +1,32 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef HYBRIDMULTIFRACTAL4D_HPP
#define HYBRIDMULTIFRACTAL4D_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract4DNoise.hpp>
class NAZARA_API NzHybridMultiFractal4D : public NzAbstract4DNoise, public NzComplexNoiseBase
{
public:
NzHybridMultiFractal4D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float z, float w, float resolution);
~NzHybridMultiFractal4D();
protected:
private:
NzAbstract4DNoise* m_source;
float m_value;
float m_remainder;
float m_offset;
float m_weight;
float m_signal;
nzNoises m_noiseType;
};
#endif // HYBRIDMULTIFRACTAL4D_HPP

32
include/Nazara/Noise/HybridMultifractal2D.hpp Normal file
View File

@@ -0,0 +1,32 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef HYBRIDMULTIFRACTAL2D_HPP
#define HYBRIDMULTIFRACTAL2D_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract2DNoise.hpp>
class NAZARA_API NzHybridMultiFractal2D : public NzAbstract2DNoise, public NzComplexNoiseBase
{
public:
NzHybridMultiFractal2D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float resolution);
~NzHybridMultiFractal2D();
protected:
private:
NzAbstract2DNoise* m_source;
float m_value;
float m_remainder;
float m_offset;
float m_weight;
float m_signal;
nzNoises m_noiseType;
};
#endif // HYBRIDMULTIFRACTAL2D_HPP

31
include/Nazara/Noise/MappedNoiseBase.hpp Normal file
View File

@@ -0,0 +1,31 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_MAPPEDNOISEBASE_HPP
#define NAZARA_MAPPEDNOISEBASE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
class NAZARA_API NzMappedNoiseBase : public NzNoiseBase
{
public:
NzMappedNoiseBase();
~NzMappedNoiseBase() = default;
float GetGain() const;
float GetOffset() const;
float GetResolution() const;
void SetGain(float gain);
void SetOffset(float offset);
void SetResolution(float resolution);
protected:
float m_gain;
float m_offset;
float m_resolution;
};
#endif // NAZARA_MAPPEDNOISEBASE_HPP

23
include/Nazara/Noise/NoiseBase.hpp
View File

@@ -9,24 +9,33 @@
#include <Nazara/Prerequesites.hpp>
enum nzNoises
{
PERLIN,
SIMPLEX,
CELL
};
class NAZARA_API NzNoiseBase
{
public:
NzNoiseBase(int seed = 0);
NzNoiseBase(unsigned int seed = 0);
~NzNoiseBase() = default;
void SetNewSeed(int seed);
int GetUniformRandomValue();
void SetNewSeed(unsigned int seed);
void ShufflePermutationTable();
unsigned int GetUniformRandomValue();
int fastfloor(float n);
int JenkinsHash(int a, int b, int c);
protected:
int perm[512];
unsigned int perm[512];
private:
int Ua, Uc, Um;
int UcurrentSeed;
int Uprevious, Ulast;
unsigned int Ua, Uc, Um;
unsigned int UcurrentSeed;
unsigned int Uprevious, Ulast;
};

93
include/Nazara/Noise/NoiseMachine.hpp
View File

@@ -1,93 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine - Noise module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NOISEMACHINE_HPP
#define NOISEMACHINE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Math/Vector3.hpp>
#include <Nazara/Math/Vector4.hpp>
class NAZARA_API NzNoiseMachine : public NzComplexNoiseBase
{
public:
NzNoiseMachine(int seed = 0);
~NzNoiseMachine() = default;
float Get2DPerlinNoiseValue (float x, float y, float res);
float Get3DPerlinNoiseValue (float x, float y, float z, float res);
float Get4DPerlinNoiseValue (float x, float y, float z, float w, float res);
float Get2DSimplexNoiseValue(float x, float y, float res);
float Get3DSimplexNoiseValue(float x, float y, float z, float res);
float Get4DSimplexNoiseValue(float x, float y, float z, float w, float res);
float Get2DCellNoiseValue(float x, float y, float res);
float Get3DCellNoiseValue(float x, float y, float z, float res);
float Get4DCellNoiseValue(float x, float y, float z, float w, float res);
float Get2DFBMNoiseValue(float x, float y, float res);
float Get3DFBMNoiseValue(float x, float y, float z, float res);
float Get2DHybridMultiFractalNoiseValue(float x, float y, float res);
float Get3DHybridMultiFractalNoiseValue(float x, float y, float z, float res);
protected:
private:
float gradient2[8][2];
int gradient3[16][3];
int gradient4[32][4];
int lookupTable4D[64][4];
//----------------------- Common variables --------------------------------------
int ii,jj,kk,ll;
int gi0,gi1,gi2,gi3,gi4,gi5,gi6,gi7,gi8,gi9,gi10,gi11,gi12,gi13,gi14,gi15;
//----------------------- Simplex variables --------------------------------------
float n1, n2, n3, n4, n5;
NzVector4f d1,d2,d3,d4,d5,unskewedCubeOrigin,unskewedDistToOrigin;
NzVector4i off1, off2,off3,skewedCubeOrigin;
float c1,c2,c3,c4,c5,c6;
int c;
float SkewCoeff2D;
float UnskewCoeff2D;
float SkewCoeff3D;
float UnskewCoeff3D;
float SkewCoeff4D;
float UnskewCoeff4D;
float sum;
//----------------------- Perlin Variables -------------------------------------
int x0,y0,z0,w0;
float Li1,Li2,Li3,Li4,Li5,Li6,Li7,Li8,Li9,Li10,Li11,Li12,Li13,Li14;
float s[4],t[4],u[4],v[4];
float Cx, Cy, Cz, Cw;
NzVector4f temp;
float tmp;
//---------------------- Complex Noise Variables --------------------------------
bool first;
float value;
float remainder;
float smax;
float smin;
};
#endif // NOISEMACHINE_HPP

21
include/Nazara/Noise/Perlin2D.hpp
View File

@@ -9,30 +9,27 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
#include <Nazara/Noise/Abstract2DNoise.hpp>
#include <Nazara/Math/Vector2.hpp>
template <typename T> class NAZARA_API NzPerlin2D : public NzNoiseBase
class NAZARA_API NzPerlin2D : public NzAbstract2DNoise
{
public:
NzPerlin2D();
T GetValue(T x, T y, T res);
NzPerlin2D(unsigned int seed);
float GetValue(float x, float y, float resolution);
~NzPerlin2D() = default;
protected:
private:
int x0, y0;
int gi0,gi1,gi2,gi3;
int ii, jj;
T gradient2[8][2];
T s,t,u,v;
T Cx,Cy;
T Li1, Li2;
NzVector2<T> temp;
float gradient2[8][2];
float s,t,u,v;
float Cx,Cy;
float Li1, Li2;
NzVector2<float> temp;
};
typedef NzPerlin2D<float> NzPerlin2Df;
typedef NzPerlin2D<double> NzPerlin2Dd;
#include <Nazara/Noise/Perlin2D.inl>
#endif // PERLIN2D_HPP

60
include/Nazara/Noise/Perlin2D.inl
View File

@@ -1,60 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine - Noise module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
NzPerlin2D<T>::NzPerlin2D()
{
T grad2Temp[][2] = {{1,1},{-1,1},{1,-1},{-1,-1},
{1,0},{-1,0},{0,1},{0,-1}};
for(int i(0) ; i < 8 ; ++i)
for(int j(0) ; j < 2 ; ++j)
gradient2[i][j] = grad2Temp[i][j];
}
template <typename T>
T NzPerlin2D<T>::GetValue(T x, T y, T res)
{
x /= res;
y /= res;
x0 = fastfloor(x);
y0 = fastfloor(y);
ii = x0 & 255;
jj = y0 & 255;
gi0 = perm[ii + perm[jj]] & 7;
gi1 = perm[ii + 1 + perm[jj]] & 7;
gi2 = perm[ii + perm[jj + 1]] & 7;
gi3 = perm[ii + 1 + perm[jj + 1]] & 7;
temp.x = x-x0;
temp.y = y-y0;
Cx = temp.x * temp.x * temp.x * (temp.x * (temp.x * 6 - 15) + 10);
Cy = temp.y * temp.y * temp.y * (temp.y * (temp.y * 6 - 15) + 10);
s = gradient2[gi0][0]*temp.x + gradient2[gi0][1]*temp.y;
temp.x = x-(x0+1);
t = gradient2[gi1][0]*temp.x + gradient2[gi1][1]*temp.y;
temp.y = y-(y0+1);
v = gradient2[gi3][0]*temp.x + gradient2[gi3][1]*temp.y;
temp.x = x-x0;
u = gradient2[gi2][0]*temp.x + gradient2[gi2][1]*temp.y;
Li1 = s + Cx*(t-s);
Li2 = u + Cx*(v-u);
return Li1 + Cy*(Li2-Li1);
}
#include <Nazara/Core/DebugOff.hpp>

26
include/Nazara/Noise/Perlin3D.hpp
View File

@@ -9,32 +9,28 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
#include <Nazara/Noise/Abstract3DNoise.hpp>
#include <Nazara/Math/Vector3.hpp>
template <typename T> class NAZARA_API NzPerlin3D : public NzNoiseBase
class NAZARA_API NzPerlin3D : public NzAbstract3DNoise
{
public:
NzPerlin3D();
T GetValue(T x, T y, T z, T res);
NzPerlin3D(unsigned int seed);
float GetValue(float x, float y, float z, float resolution);
~NzPerlin3D() = default;
protected:
private:
int x0,y0,z0;
int gi0,gi1,gi2,gi3,gi4,gi5,gi6,gi7;
int ii,jj,kk;
int gradient3[16][3];
T Li1,Li2,Li3,Li4,Li5,Li6;
T s[2],t[2],u[2],v[2];
T Cx,Cy,Cz;
T nx,ny,nz;
T tmp;
NzVector3<T> temp;
float gradient3[16][3];
float Li1,Li2,Li3,Li4,Li5,Li6;
float s[2],t[2],u[2],v[2];
float Cx,Cy,Cz;
float nx,ny,nz;
float tmp;
NzVector3<float> temp;
};
typedef NzPerlin3D<float> NzPerlin3Df;
typedef NzPerlin3D<double> NzPerlin3Dd;
#include <Nazara/Noise/Perlin3D.inl>
#endif // PERLIN3D_HPP

92
include/Nazara/Noise/Perlin3D.inl
View File

@@ -1,92 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine - Noise module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
NzPerlin3D<T>::NzPerlin3D()
{
int grad3Temp[][3] = {
{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},
{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},
{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1},
{1,1,0},{-1,1,0},{0,-1,1},{0,-1,-1}
};
for(int i(0) ; i < 16 ; ++i)
for(int j(0) ; j < 3 ; ++j)
gradient3[i][j] = grad3Temp[i][j];
}
template <typename T>
T NzPerlin3D<T>::GetValue(T x, T y, T z, T res)
{
x /= res;
y /= res;
z /= res;
x0 = fastfloor(x);
y0 = fastfloor(y);
z0 = fastfloor(z);
ii = x0 & 255;
jj = y0 & 255;
kk = z0 & 255;
gi0 = perm[ii + perm[jj + perm[kk]]] & 15;
gi1 = perm[ii + 1 + perm[jj + perm[kk]]] & 15;
gi2 = perm[ii + perm[jj + 1 + perm[kk]]] & 15;
gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk]]] & 15;
gi4 = perm[ii + perm[jj + perm[kk + 1]]] & 15;
gi5 = perm[ii + 1 + perm[jj + perm[kk + 1]]] & 15;
gi6 = perm[ii + perm[jj + 1 + perm[kk + 1]]] & 15;
gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] & 15;
temp.x = x-x0;
temp.y = y-y0;
temp.z = z-z0;
Cx = temp.x * temp.x * temp.x * (temp.x * (temp.x * 6 - 15) + 10);
Cy = temp.y * temp.y * temp.y * (temp.y * (temp.y * 6 - 15) + 10);
Cz = temp.z * temp.z * temp.z * (temp.z * (temp.z * 6 - 15) + 10);
s[0] = gradient3[gi0][0]*temp.x + gradient3[gi0][1]*temp.y + gradient3[gi0][2]*temp.z;
temp.x = x-(x0+1);
t[0] = gradient3[gi1][0]*temp.x + gradient3[gi1][1]*temp.y + gradient3[gi1][2]*temp.z;
temp.y = y-(y0+1);
v[0] = gradient3[gi3][0]*temp.x + gradient3[gi3][1]*temp.y + gradient3[gi3][2]*temp.z;
temp.x = x-x0;
u[0] = gradient3[gi2][0]*temp.x + gradient3[gi2][1]*temp.y + gradient3[gi2][2]*temp.z;
temp.y = y-y0;
temp.z = z-(z0+1);
s[1] = gradient3[gi4][0]*temp.x + gradient3[gi4][1]*temp.y + gradient3[gi4][2]*temp.z;
temp.x = x-(x0+1);
t[1] = gradient3[gi5][0]*temp.x + gradient3[gi5][1]*temp.y + gradient3[gi5][2]*temp.z;
temp.y = y-(y0+1);
v[1] = gradient3[gi7][0]*temp.x + gradient3[gi7][1]*temp.y + gradient3[gi7][2]*temp.z;
temp.x = x-x0;
u[1] = gradient3[gi6][0]*temp.x + gradient3[gi6][1]*temp.y + gradient3[gi6][2]*temp.z;
Li1 = s[0] + Cx*(t[0]-s[0]);
Li2 = u[0] + Cx*(v[0]-u[0]);
Li3 = s[1] + Cx*(t[1]-s[1]);
Li4 = u[1] + Cx*(v[1]-u[1]);
Li5 = Li1 + Cy*(Li2-Li1);
Li6 = Li3 + Cy*(Li4-Li3);
return Li5 + Cz*(Li6-Li5);
}
#include <Nazara/Core/DebugOff.hpp>

25
include/Nazara/Noise/Perlin4D.hpp
View File

@@ -9,32 +9,27 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
#include <Nazara/Noise/Abstract4DNoise.hpp>
#include <Nazara/Math/Vector4.hpp>
template <typename T> class NAZARA_API NzPerlin4D : public NzNoiseBase
class NAZARA_API NzPerlin4D : public NzAbstract4DNoise
{
public:
NzPerlin4D();
T GetValue(T x, T y, T z, T w, T res);
NzPerlin4D(unsigned int seed);
float GetValue(float x, float y, float z, float w, float resolution);
~NzPerlin4D() = default;
protected:
private:
int x0,y0,z0,w0;
int gi0,gi1,gi2,gi3,gi4,gi5,gi6,gi7,gi8,gi9,gi10,gi11,gi12,gi13,gi14,gi15;
int ii,jj,kk,ll;
int gradient4[32][4];
T Li1,Li2,Li3,Li4,Li5,Li6,Li7,Li8,Li9,Li10,Li11,Li12,Li13,Li14;
T s[4],t[4],u[4],v[4];
T Cx,Cy,Cz,Cw;
T nx,ny,nz,nw;
T tmp;
NzVector4<T> temp;
float gradient4[32][4];
float Li1,Li2,Li3,Li4,Li5,Li6,Li7,Li8,Li9,Li10,Li11,Li12,Li13,Li14;
float s[4],t[4],u[4],v[4];
float Cx,Cy,Cz,Cw;
float tmp;
NzVector4<float> temp;
};
typedef NzPerlin4D<float> NzPerlin4Df;
typedef NzPerlin4D<double> NzPerlin4Dd;
#include <Nazara/Noise/Perlin4D.inl>
#endif // PERLIN4D_HPP

150
include/Nazara/Noise/Perlin4D.inl
View File

@@ -1,150 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine - Noise module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
NzPerlin4D<T>::NzPerlin4D()
{
int grad4Temp[][4] =
{
{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
{0,-1,1,1},{0,-1,1,-1},{0,-1,-1,1},{0,-1,-1,-1},
{1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
{-1,0,1,1},{-1,0,1,-1},{-1,0,-1,1},{-1,0,-1,-1},
{1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
{-1,1,0,1},{-1,1,0,-1},{-1,-1,0,1},{-1,-1,0,-1},
{1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
{-1,1,1,0},{-1,1,-1,0},{-1,-1,1,0},{-1,-1,-1,0}
};
for(int i(0) ; i < 32 ; ++i)
for(int j(0) ; j < 4 ; ++j)
gradient4[i][j] = grad4Temp[i][j];
}
template <typename T>
T NzPerlin4D<T>::GetValue(T x, T y, T z, T w, T res)
{
nx = x/res;
ny = y/res;
nz = z/res;
nw = w/res;
x0 = fastfloor(nx);
y0 = fastfloor(ny);
z0 = fastfloor(nz);
w0 = fastfloor(nw);
ii = x0 & 255;
jj = y0 & 255;
kk = z0 & 255;
ll = w0 & 255;
gi0 = perm[ii + perm[jj + perm[kk + perm[ll ]]]] & 31;
gi1 = perm[ii + 1 + perm[jj + perm[kk + perm[ll ]]]] & 31;
gi2 = perm[ii + perm[jj + 1 + perm[kk + perm[ll ]]]] & 31;
gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll ]]]] & 31;
gi4 = perm[ii + perm[jj + + perm[kk + 1 + perm[ll ]]]] & 31;
gi5 = perm[ii + 1 + perm[jj + + perm[kk + 1 + perm[ll ]]]] & 31;
gi6 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] & 31;
gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] & 31;
gi8 = perm[ii + perm[jj + perm[kk + perm[ll + 1]]]] & 31;
gi9 = perm[ii + 1 + perm[jj + perm[kk + perm[ll + 1]]]] & 31;
gi10 = perm[ii + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31;
gi11 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31;
gi12 = perm[ii + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31;
gi13 = perm[ii + 1 + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31;
gi14 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31;
gi15 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31;
temp.x = nx-x0;
temp.y = ny-y0;
temp.z = nz-z0;
temp.w = nw-w0;
Cx = temp.x * temp.x * temp.x * (temp.x * (temp.x * 6 - 15) + 10);
Cy = temp.y * temp.y * temp.y * (temp.y * (temp.y * 6 - 15) + 10);
Cz = temp.z * temp.z * temp.z * (temp.z * (temp.z * 6 - 15) + 10);
Cw = temp.w * temp.w * temp.w * (temp.w * (temp.w * 6 - 15) + 10);
s[0] = gradient4[gi0][0]*temp.x + gradient4[gi0][1]*temp.y + gradient4[gi0][2]*temp.z + gradient4[gi0][3]*temp.w;
temp.x = nx-(x0+1);
t[0] = gradient4[gi1][0]*temp.x + gradient4[gi1][1]*temp.y + gradient4[gi1][2]*temp.z + gradient4[gi1][3]*temp.w;
temp.y = ny-(y0+1);
v[0] = gradient4[gi3][0]*temp.x + gradient4[gi3][1]*temp.y + gradient4[gi3][2]*temp.z + gradient4[gi3][3]*temp.w;
temp.x = nx-x0;
u[0] = gradient4[gi2][0]*temp.x + gradient4[gi2][1]*temp.y + gradient4[gi2][2]*temp.z + gradient4[gi2][3]*temp.w;
temp.y = ny-y0;
temp.z = nz-(z0+1);
s[1] = gradient4[gi4][0]*temp.x + gradient4[gi4][1]*temp.y + gradient4[gi4][2]*temp.z + gradient4[gi4][3]*temp.w;
temp.x = nx-(x0+1);
t[1] = gradient4[gi5][0]*temp.x + gradient4[gi5][1]*temp.y + gradient4[gi5][2]*temp.z + gradient4[gi5][3]*temp.w;
temp.y = ny-(y0+1);
v[1] = gradient4[gi7][0]*temp.x + gradient4[gi7][1]*temp.y + gradient4[gi7][2]*temp.z + gradient4[gi7][3]*temp.w;
temp.x = nx-x0;
u[1] = gradient4[gi6][0]*temp.x + gradient4[gi6][1]*temp.y + gradient4[gi6][2]*temp.z + gradient4[gi6][3]*temp.w;
temp.y = ny-y0;
temp.z = nz-z0;
temp.w = nw-(w0+1);
s[2] = gradient4[gi8][0]*temp.x + gradient4[gi8][1]*temp.y + gradient4[gi8][2]*temp.z + gradient4[gi8][3]*temp.w;
temp.x = nx-(x0+1);
t[2] = gradient4[gi9][0]*temp.x + gradient4[gi9][1]*temp.y + gradient4[gi9][2]*temp.z + gradient4[gi9][3]*temp.w;
temp.y = ny-(y0+1);
v[2] = gradient4[gi11][0]*temp.x + gradient4[gi11][1]*temp.y + gradient4[gi11][2]*temp.z + gradient4[gi11][3]*temp.w;
temp.x = nx-x0;
u[2] = gradient4[gi10][0]*temp.x + gradient4[gi10][1]*temp.y + gradient4[gi10][2]*temp.z + gradient4[gi10][3]*temp.w;
temp.y = ny-y0;
temp.z = nz-(z0+1);
s[3] = gradient4[gi12][0]*temp.x + gradient4[gi12][1]*temp.y + gradient4[gi12][2]*temp.z + gradient4[gi12][3]*temp.w;
temp.x = nx-(x0+1);
t[3] = gradient4[gi13][0]*temp.x + gradient4[gi13][1]*temp.y + gradient4[gi13][2]*temp.z + gradient4[gi13][3]*temp.w;
temp.y = ny-(y0+1);
v[3] = gradient4[gi15][0]*temp.x + gradient4[gi15][1]*temp.y + gradient4[gi15][2]*temp.z + gradient4[gi15][3]*temp.w;
temp.x = nx-x0;
u[3] = gradient4[gi14][0]*temp.x + gradient4[gi14][1]*temp.y + gradient4[gi14][2]*temp.z + gradient4[gi14][3]*temp.w;
Li1 = s[0] + Cx*(t[0]-s[0]);
Li2 = u[0] + Cx*(v[0]-u[0]);
Li3 = s[1] + Cx*(t[1]-s[1]);
Li4 = u[1] + Cx*(v[1]-u[1]);
Li5 = s[2] + Cx*(t[2]-s[2]);
Li6 = u[2] + Cx*(v[2]-u[2]);
Li7 = s[3] + Cx*(t[3]-s[3]);
Li8 = u[3] + Cx*(v[3]-u[3]);
Li9 = Li1 + Cy*(Li2-Li1);
Li10 = Li3 + Cy*(Li4-Li3);
Li11 = Li5 + Cy*(Li6-Li5);
Li12 = Li7 + Cy*(Li8-Li7);
Li13 = Li9 + Cz*(Li10-Li9);
Li14 = Li11 + Cz*(Li12-Li11);
return Li13 + Cw*(Li14-Li13);
}
#include <Nazara/Core/DebugOff.hpp>

31
include/Nazara/Noise/Simplex2D.hpp
View File

@@ -9,35 +9,30 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
#include <Nazara/Noise/Abstract2DNoise.hpp>
#include <Nazara/Math/Vector2.hpp>
template <typename T> class NAZARA_API NzSimplex2D : public NzNoiseBase
class NAZARA_API NzSimplex2D : public NzAbstract2DNoise
{
public:
NzSimplex2D();
T GetValue(T x, T y, T res);
~NzSimplex2D() = default;
NzSimplex2D(unsigned int seed);
float GetValue(float x, float y, float resolution);
virtual ~NzSimplex2D() = default;
protected:
private:
int ii,jj;
int gi0,gi1,gi2;
NzVector2i skewedCubeOrigin,off1;
T n1,n2,n3;
T c1,c2,c3;
T gradient2[8][2];
T UnskewCoeff2D;
T SkewCoeff2D;
T sum;
NzVector2<T> unskewedCubeOrigin, unskewedDistToOrigin;
NzVector2<T> d1,d2,d3;
float n1,n2,n3;
float c1,c2,c3;
float gradient2[8][2];
float UnskewCoeff2D;
float SkewCoeff2D;
float sum;
NzVector2<float> unskewedCubeOrigin, unskewedDistToOrigin;
NzVector2<float> d1,d2,d3;
};
typedef NzSimplex2D<float> NzSimplex2Df;
typedef NzSimplex2D<double> NzSimplex2Dd;
#include <Nazara/Noise/Simplex2D.inl>
#endif // SIMPLEX2D_HPP

88
include/Nazara/Noise/Simplex2D.inl
View File

@@ -1,88 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine - Noise module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
NzSimplex2D<T>::NzSimplex2D()
{
T grad2Temp[][2] = {{1,1},{-1,1},{1,-1},{-1,-1},
{1,0},{-1,0},{0,1},{0,-1}};
for(int i(0) ; i < 8 ; ++i)
for(int j(0) ; j < 2 ; ++j)
gradient2[i][j] = grad2Temp[i][j];
SkewCoeff2D = 0.5*(sqrt(3.0) - 1.0);
UnskewCoeff2D = (3.0-sqrt(3.0))/6.;
}
template <typename T>
T NzSimplex2D<T>::GetValue(T x, T y, T res)
{
x /= res;
y /= res;
sum = (x + y) * SkewCoeff2D;
skewedCubeOrigin.x = fastfloor(x + sum);
skewedCubeOrigin.y = fastfloor(y + sum);
sum = (skewedCubeOrigin.x + skewedCubeOrigin.y) * UnskewCoeff2D;
unskewedCubeOrigin.x = skewedCubeOrigin.x - sum;
unskewedCubeOrigin.y = skewedCubeOrigin.y - sum;
unskewedDistToOrigin.x = x - unskewedCubeOrigin.x;
unskewedDistToOrigin.y = y - unskewedCubeOrigin.y;
if(unskewedDistToOrigin.x > unskewedDistToOrigin.y)
{
off1.x = 1;
off1.y = 0;
}
else
{
off1.x = 0;
off1.y = 1;
}
d1 = - unskewedDistToOrigin;
d2.x = d1.x + off1.x - UnskewCoeff2D;
d2.y = d1.y + off1.y - UnskewCoeff2D;
d3.x = d1.x + 1.0 - 2 * UnskewCoeff2D;
d3.y = d1.y + 1.0 - 2 * UnskewCoeff2D;
ii = skewedCubeOrigin.x & 255;
jj = skewedCubeOrigin.y & 255;
gi0 = perm[ii + perm[jj ]] & 7;
gi1 = perm[ii + off1.x + perm[jj + off1.y]] & 7;
gi2 = perm[ii + 1 + perm[jj + 1 ]] & 7;
c1 = 0.5 - d1.x * d1.x - d1.y * d1.y;
c2 = 0.5 - d2.x * d2.x - d2.y * d2.y;
c3 = 0.5 - d3.x * d3.x - d3.y * d3.y;
if(c1 < 0)
n1 = 0;
else
n1 = c1*c1*c1*c1*(gradient2[gi0][0] * d1.x + gradient2[gi0][1] * d1.y);
if(c2 < 0)
n2 = 0;
else
n2 = c2*c2*c2*c2*(gradient2[gi1][0] * d2.x + gradient2[gi1][1] * d2.y);
if(c3 < 0)
n3 = 0;
else
n3 = c3*c3*c3*c3*(gradient2[gi2][0] * d3.x + gradient2[gi2][1] * d3.y);
return (n1+n2+n3)*70;
}
#include <Nazara/Core/DebugOff.hpp>

29
include/Nazara/Noise/Simplex3D.hpp
View File

@@ -9,35 +9,30 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
#include <Nazara/Noise/Abstract3DNoise.hpp>
#include <Nazara/Math/Vector3.hpp>
template <typename T> class NAZARA_API NzSimplex3D : public NzNoiseBase
class NAZARA_API NzSimplex3D : public NzAbstract3DNoise
{
public:
NzSimplex3D();
T GetValue(T x, T y, T z, T res);
NzSimplex3D(unsigned int seed);
float GetValue(float x, float y, float z, float resolution);
~NzSimplex3D() = default;
protected:
private:
int ii,jj,kk;
int gi0,gi1,gi2,gi3;
NzVector3i skewedCubeOrigin,off1,off2;
T n1,n2,n3,n4;
T c1,c2,c3,c4;
T gradient3[12][3];
T UnskewCoeff3D;
T SkewCoeff3D;
T sum;
NzVector3<T> unskewedCubeOrigin, unskewedDistToOrigin;
NzVector3<T> d1,d2,d3,d4;
float n1,n2,n3,n4;
float c1,c2,c3,c4;
float gradient3[12][3];
float UnskewCoeff3D;
float SkewCoeff3D;
float sum;
NzVector3<float> unskewedCubeOrigin, unskewedDistToOrigin;
NzVector3<float> d1,d2,d3,d4;
};
typedef NzSimplex3D<float> NzSimplex3Df;
typedef NzSimplex3D<double> NzSimplex3Dd;
#include <Nazara/Noise/Simplex3D.inl>
#endif // SIMPLEX3D_HPP

157
include/Nazara/Noise/Simplex3D.inl
View File

@@ -1,157 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine - Noise module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
NzSimplex3D<T>::NzSimplex3D()
{
SkewCoeff3D = 1/3.;
UnskewCoeff3D = 1/6.;
int grad3Temp[][3] = {{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},
{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},
{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}};
for(int i(0) ; i < 12 ; ++i)
for(int j(0) ; j < 3 ; ++j)
gradient3[i][j] = grad3Temp[i][j];
}
template <typename T>
T NzSimplex3D<T>::GetValue(T x, T y, T z, T res)
{
x /= res;
y /= res;
z /= res;
sum = (x + y + z) * SkewCoeff3D;
skewedCubeOrigin.x = fastfloor(x + sum);
skewedCubeOrigin.y = fastfloor(y + sum);
skewedCubeOrigin.z = fastfloor(z + sum);
sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z) * UnskewCoeff3D;
unskewedCubeOrigin.x = skewedCubeOrigin.x - sum;
unskewedCubeOrigin.y = skewedCubeOrigin.y - sum;
unskewedCubeOrigin.z = skewedCubeOrigin.z - sum;
unskewedDistToOrigin.x = x - unskewedCubeOrigin.x;
unskewedDistToOrigin.y = y - unskewedCubeOrigin.y;
unskewedDistToOrigin.z = z - unskewedCubeOrigin.z;
if(unskewedDistToOrigin.x >= unskewedDistToOrigin.y)
{
if(unskewedDistToOrigin.y >= unskewedDistToOrigin.z)
{
off1.x = 1;
off1.y = 0;
off1.z = 0;
off2.x = 1;
off2.y = 1;
off2.z = 0;
}
else if(unskewedDistToOrigin.x >= unskewedDistToOrigin.z)
{
off1.x = 1;
off1.y = 0;
off1.z = 0;
off2.x = 1;
off2.y = 0;
off2.z = 1;
}
else
{
off1.x = 0;
off1.y = 0;
off1.z = 1;
off2.x = 1;
off2.y = 0;
off2.z = 1;
}
}
else
{
if(unskewedDistToOrigin.y < unskewedDistToOrigin.z)
{
off1.x = 0;
off1.y = 0;
off1.z = 1;
off2.x = 0;
off2.y = 1;
off2.z = 1;
}
else if(unskewedDistToOrigin.x < unskewedDistToOrigin.z)
{
off1.x = 0;
off1.y = 1;
off1.z = 0;
off2.x = 0;
off2.y = 1;
off2.z = 1;
}
else
{
off1.x = 0;
off1.y = 1;
off1.z = 0;
off2.x = 1;
off2.y = 1;
off2.z = 0;
}
}
d1 = unskewedDistToOrigin;
d2.x = d1.x - off1.x + UnskewCoeff3D;
d2.y = d1.y - off1.y + UnskewCoeff3D;
d2.z = d1.z - off1.z + UnskewCoeff3D;
d3.x = d1.x - off2.x + 2*UnskewCoeff3D;
d3.y = d1.y - off2.y + 2*UnskewCoeff3D;
d3.z = d1.z - off2.z + 2*UnskewCoeff3D;
d4.x = d1.x - 1.0 + 3*UnskewCoeff3D;
d4.y = d1.y - 1.0 + 3*UnskewCoeff3D;
d4.z = d1.z - 1.0 + 3*UnskewCoeff3D;
ii = skewedCubeOrigin.x & 255;
jj = skewedCubeOrigin.y & 255;
kk = skewedCubeOrigin.z & 255;
gi0 = perm[ii + perm[jj + perm[kk ]]] % 12;
gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z]]] % 12;
gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z]]] % 12;
gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 ]]] % 12;
c1 = 0.6 - d1.x * d1.x - d1.y * d1.y - d1.z * d1.z;
c2 = 0.6 - d2.x * d2.x - d2.y * d2.y - d2.z * d2.z;
c3 = 0.6 - d3.x * d3.x - d3.y * d3.y - d3.z * d3.z;
c4 = 0.6 - d4.x * d4.x - d4.y * d4.y - d4.z * d4.z;
if(c1 < 0)
n1 = 0;
else
n1 = c1*c1*c1*c1*(gradient3[gi0][0] * d1.x + gradient3[gi0][1] * d1.y + gradient3[gi0][2] * d1.z);
if(c2 < 0)
n2 = 0;
else
n2 = c2*c2*c2*c2*(gradient3[gi1][0] * d2.x + gradient3[gi1][1] * d2.y + gradient3[gi1][2] * d2.z);
if(c3 < 0)
n3 = 0;
else
n3 = c3*c3*c3*c3*(gradient3[gi2][0] * d3.x + gradient3[gi2][1] * d3.y + gradient3[gi2][2] * d3.z);
if(c4 < 0)
n4 = 0;
else
n4 = c4*c4*c4*c4*(gradient3[gi3][0] * d4.x + gradient3[gi3][1] * d4.y + gradient3[gi3][2] * d4.z);
return (n1+n2+n3+n4)*32;
}
#include <Nazara/Core/DebugOff.hpp>

29
include/Nazara/Noise/Simplex4D.hpp
View File

@@ -9,37 +9,32 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
#include <Nazara/Noise/Abstract4DNoise.hpp>
#include <Nazara/Math/Vector4.hpp>
template <typename T> class NAZARA_API NzSimplex4D : public NzNoiseBase
class NAZARA_API NzSimplex4D : public NzAbstract4DNoise
{
public:
NzSimplex4D();
T GetValue(T x, T y, T z, T w, T res);
NzSimplex4D(unsigned int seed);
float GetValue(float x, float y, float z, float w, float resolution);
~NzSimplex4D() = default;
protected:
private:
int ii,jj,kk,ll;
int gi0,gi1,gi2,gi3,gi4;
NzVector4i skewedCubeOrigin,off1,off2,off3;
T n1,n2,n3,n4,n5;
T c1,c2,c3,c4,c5,c6;
T gradient4[32][4];
int lookupTable4D[64][4];
int c;
T UnskewCoeff4D;
T SkewCoeff4D;
T sum;
NzVector4<T> unskewedCubeOrigin, unskewedDistToOrigin;
NzVector4<T> d1,d2,d3,d4,d5;
float n1,n2,n3,n4,n5;
float c1,c2,c3,c4,c5,c6;
float gradient4[32][4];
float UnskewCoeff4D;
float SkewCoeff4D;
float sum;
NzVector4<float> unskewedCubeOrigin, unskewedDistToOrigin;
NzVector4<float> d1,d2,d3,d4,d5;
};
typedef NzSimplex4D<float> NzSimplex4Df;
typedef NzSimplex4D<double> NzSimplex4Dd;
#include <Nazara/Noise/Simplex4D.inl>
#endif // SIMPLEX4D_H

163
include/Nazara/Noise/Simplex4D.inl
View File

@@ -1,163 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine - Noise module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
NzSimplex4D<T>::NzSimplex4D()
{
SkewCoeff4D = (sqrt(5.) - 1.)/4.;
UnskewCoeff4D = (5. - sqrt(5.))/20.;
int lookupTemp4D[][4] =
{
{0,1,2,3},{0,1,3,2},{0,0,0,0},{0,2,3,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,2,3,0},
{0,2,1,3},{0,0,0,0},{0,3,1,2},{0,3,2,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,3,2,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{1,2,0,3},{0,0,0,0},{1,3,0,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,3,0,1},{2,3,1,0},
{1,0,2,3},{1,0,3,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,0,3,1},{0,0,0,0},{2,1,3,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,1,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,0,1,2},{3,0,2,1},{0,0,0,0},{3,1,2,0},
{2,1,0,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,1,0,2},{0,0,0,0},{3,2,0,1},{3,2,1,0}
};
for(int i(0) ; i < 64 ; ++i)
for(int j(0) ; j < 4 ; ++j)
lookupTable4D[i][j] = lookupTemp4D[i][j];
int grad4Temp[][4] =
{
{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
{0,-1,1,1},{0,-1,1,-1},{0,-1,-1,1},{0,-1,-1,-1},
{1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
{-1,0,1,1},{-1,0,1,-1},{-1,0,-1,1},{-1,0,-1,-1},
{1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
{-1,1,0,1},{-1,1,0,-1},{-1,-1,0,1},{-1,-1,0,-1},
{1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
{-1,1,1,0},{-1,1,-1,0},{-1,-1,1,0},{-1,-1,-1,0}
};
for(int i(0) ; i < 32 ; ++i)
for(int j(0) ; j < 4 ; ++j)
gradient4[i][j] = grad4Temp[i][j];
}
template <typename T>
T NzSimplex4D<T>::GetValue(T x, T y, T z, T w, T res)
{
x /= res;
y /= res;
z /= res;
w /= res;
sum = (x + y + z + w) * SkewCoeff4D;
skewedCubeOrigin.x = fastfloor(x + sum);
skewedCubeOrigin.y = fastfloor(y + sum);
skewedCubeOrigin.z = fastfloor(z + sum);
skewedCubeOrigin.w = fastfloor(w + sum);
sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z + skewedCubeOrigin.w) * UnskewCoeff4D;
unskewedCubeOrigin.x = skewedCubeOrigin.x - sum;
unskewedCubeOrigin.y = skewedCubeOrigin.y - sum;
unskewedCubeOrigin.z = skewedCubeOrigin.z - sum;
unskewedCubeOrigin.w = skewedCubeOrigin.w - sum;
unskewedDistToOrigin.x = x - unskewedCubeOrigin.x;
unskewedDistToOrigin.y = y - unskewedCubeOrigin.y;
unskewedDistToOrigin.z = z - unskewedCubeOrigin.z;
unskewedDistToOrigin.w = w - unskewedCubeOrigin.w;
c1 = (unskewedDistToOrigin.x > unskewedDistToOrigin.y) ? 32 : 0;
c2 = (unskewedDistToOrigin.x > unskewedDistToOrigin.z) ? 16 : 0;
c3 = (unskewedDistToOrigin.y > unskewedDistToOrigin.z) ? 8 : 0;
c4 = (unskewedDistToOrigin.x > unskewedDistToOrigin.w) ? 4 : 0;
c5 = (unskewedDistToOrigin.y > unskewedDistToOrigin.w) ? 2 : 0;
c6 = (unskewedDistToOrigin.z > unskewedDistToOrigin.w) ? 1 : 0;
c = c1 + c2 + c3 + c4 + c5 + c6;
off1.x = lookupTable4D[c][0] >= 3 ? 1 : 0;
off1.y = lookupTable4D[c][1] >= 3 ? 1 : 0;
off1.z = lookupTable4D[c][2] >= 3 ? 1 : 0;
off1.w = lookupTable4D[c][3] >= 3 ? 1 : 0;
off2.x = lookupTable4D[c][0] >= 2 ? 1 : 0;
off2.y = lookupTable4D[c][1] >= 2 ? 1 : 0;
off2.z = lookupTable4D[c][2] >= 2 ? 1 : 0;
off2.w = lookupTable4D[c][3] >= 2 ? 1 : 0;
off3.x = lookupTable4D[c][0] >= 1 ? 1 : 0;
off3.y = lookupTable4D[c][1] >= 1 ? 1 : 0;
off3.z = lookupTable4D[c][2] >= 1 ? 1 : 0;
off3.w = lookupTable4D[c][3] >= 1 ? 1 : 0;
d1 = unskewedDistToOrigin;
d2.x = d1.x - off1.x + UnskewCoeff4D;
d2.y = d1.y - off1.y + UnskewCoeff4D;
d2.z = d1.z - off1.z + UnskewCoeff4D;
d2.w = d1.w - off1.w + UnskewCoeff4D;
d3.x = d1.x - off2.x + 2*UnskewCoeff4D;
d3.y = d1.y - off2.y + 2*UnskewCoeff4D;
d3.z = d1.z - off2.z + 2*UnskewCoeff4D;
d3.w = d1.w - off2.w + 2*UnskewCoeff4D;
d4.x = d1.x - off3.x + 3*UnskewCoeff4D;
d4.y = d1.y - off3.y + 3*UnskewCoeff4D;
d4.z = d1.z - off3.z + 3*UnskewCoeff4D;
d4.w = d1.w - off3.w + 3*UnskewCoeff4D;
d5.x = d1.x - 1.0 + 4*UnskewCoeff4D;
d5.y = d1.y - 1.0 + 4*UnskewCoeff4D;
d5.z = d1.z - 1.0 + 4*UnskewCoeff4D;
d5.w = d1.w - 1.0 + 4*UnskewCoeff4D;
ii = skewedCubeOrigin.x & 255;
jj = skewedCubeOrigin.y & 255;
kk = skewedCubeOrigin.z & 255;
ll = skewedCubeOrigin.w & 255;
gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] & 31;
gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z + perm[ll + off1.w]]]] & 31;
gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z + perm[ll + off2.w]]]] & 31;
gi3 = perm[ii + off3.x + perm[jj + off3.y + perm[kk + off3.z + perm[ll + off3.w]]]] & 31;
gi4 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32;
c1 = 0.6 - d1.x*d1.x - d1.y*d1.y - d1.z*d1.z - d1.w*d1.w;
c2 = 0.6 - d2.x*d2.x - d2.y*d2.y - d2.z*d2.z - d2.w*d2.w;
c3 = 0.6 - d3.x*d3.x - d3.y*d3.y - d3.z*d3.z - d3.w*d3.w;
c4 = 0.6 - d4.x*d4.x - d4.y*d4.y - d4.z*d4.z - d4.w*d4.w;
c5 = 0.6 - d5.x*d5.x - d5.y*d5.y - d5.z*d5.z - d5.w*d5.w;
if(c1 < 0)
n1 = 0;
else
n1 = c1*c1*c1*c1*(gradient4[gi0][0]*d1.x + gradient4[gi0][1]*d1.y + gradient4[gi0][2]*d1.z + gradient4[gi0][3]*d1.w);
if(c2 < 0)
n2 = 0;
else
n2 = c2*c2*c2*c2*(gradient4[gi1][0]*d2.x + gradient4[gi1][1]*d2.y + gradient4[gi1][2]*d2.z + gradient4[gi1][3]*d2.w);
if(c3 < 0)
n3 = 0;
else
n3 = c3*c3*c3*c3*(gradient4[gi2][0]*d3.x + gradient4[gi2][1]*d3.y + gradient4[gi2][2]*d3.z + gradient4[gi2][3]*d3.w);
if(c4 < 0)
n4 = 0;
else
n4 = c4*c4*c4*c4*(gradient4[gi3][0]*d4.x + gradient4[gi3][1]*d4.y + gradient4[gi3][2]*d4.z + gradient4[gi3][3]*d4.w);
if(c5 < 0)
n5 = 0;
else
n5 = c5*c5*c5*c5*(gradient4[gi4][0]*d5.x + gradient4[gi4][1]*d5.y + gradient4[gi4][2]*d5.z + gradient4[gi4][3]*d5.w);
return (n1+n2+n3+n4+n5)*27.0;
}
#include <Nazara/Core/DebugOff.hpp>

2
include/Nazara/Renderer.hpp
View File

@@ -34,6 +34,7 @@
#include <Nazara/Renderer/ContextParameters.hpp>
#include <Nazara/Renderer/DebugDrawer.hpp>
#include <Nazara/Renderer/Enums.hpp>
#include <Nazara/Renderer/Material.hpp>
#include <Nazara/Renderer/OcclusionQuery.hpp>
#include <Nazara/Renderer/OpenGL.hpp>
#include <Nazara/Renderer/Renderer.hpp>
@@ -42,6 +43,7 @@
#include <Nazara/Renderer/RenderTexture.hpp>
#include <Nazara/Renderer/RenderWindow.hpp>
#include <Nazara/Renderer/Shader.hpp>
#include <Nazara/Renderer/ShaderBuilder.hpp>
#include <Nazara/Renderer/Texture.hpp>
#endif // NAZARA_GLOBAL_RENDERER_HPP

4
include/Nazara/Renderer/Enums.hpp
View File

@@ -158,7 +158,9 @@ enum nzTextureFilter
nzTextureFilter_Nearest,
nzTextureFilter_Trilinear,
nzTextureFilter_Max = nzTextureFilter_Trilinear
nzTextureFilter_Default,
nzTextureFilter_Max = nzTextureFilter_Default
};
enum nzTextureWrap

5
include/Nazara/Renderer/Material.hpp
View File

@@ -47,6 +47,7 @@ class NAZARA_API NzMaterial : public NzResource
NzColor GetSpecularColor() const;
const NzTexture* GetSpecularMap() const;
nzBlendFunc GetSrcBlend() const;
nzTextureFilter GetTextureFilter() const;
nzRendererComparison GetZTestCompare() const;
bool IsAlphaBlendingEnabled() const;
@@ -69,6 +70,8 @@ class NAZARA_API NzMaterial : public NzResource
void SetSpecularColor(const NzColor& specular);
void SetSpecularMap(const NzTexture* map);
void SetSrcBlend(nzBlendFunc func);
void SetTextureFilter(nzTextureFilter filter);
void SetTextureWrap(nzTextureWrap wrapMode);
void SetZTestCompare(nzRendererComparison compareFunc);
static const NzMaterial* GetDefault();
@@ -79,6 +82,8 @@ class NAZARA_API NzMaterial : public NzResource
nzFaceCulling m_faceCulling;
nzFaceFilling m_faceFilling;
nzRendererComparison m_zTestCompareFunc;
nzTextureFilter m_textureFilter;
nzTextureWrap m_textureWrap;
NzColor m_ambientColor;
NzColor m_diffuseColor;
NzColor m_specularColor;

2
include/Nazara/Renderer/Texture.hpp
View File

@@ -43,6 +43,8 @@ class NAZARA_API NzTexture : public NzResource, NzNonCopyable
unsigned int GetWidth() const;
nzTextureWrap GetWrapMode() const;
bool HasMipmaps() const;
bool IsCompressed() const;
bool IsCubemap() const;
bool IsTarget() const;