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

Convert spaces to tabs

Browse Source 
Former-commit-id: b459cfe0c83f651cc660d42f7d3014c3b146f345
This commit is contained in:
Lynix
2015-09-24 00:55:57 +02:00
parent ce3bbf6c78
commit dea3fb4e39
87 changed files with 1206 additions and 1205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/Nazara/Noise/Abstract2DNoise.hpp
View File

@@ -12,12 +12,12 @@
class NAZARA_NOISE_API NzAbstract2DNoise : public NzMappedNoiseBase
{
public:
virtual ~NzAbstract2DNoise();
public:
virtual ~NzAbstract2DNoise();
float GetBasicValue(float x, float y);
float GetMappedValue(float x, float y);
virtual float GetValue(float x, float y, float resolution) = 0;
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

10
include/Nazara/Noise/Abstract3DNoise.hpp
View File

@@ -12,12 +12,12 @@
class NAZARA_NOISE_API NzAbstract3DNoise : public NzMappedNoiseBase
{
public:
virtual ~NzAbstract3DNoise();
public:
virtual ~NzAbstract3DNoise();
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;
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

10
include/Nazara/Noise/Abstract4DNoise.hpp
View File

@@ -12,12 +12,12 @@
class NAZARA_NOISE_API NzAbstract4DNoise : public NzMappedNoiseBase
{
public:
virtual ~NzAbstract4DNoise();
public:
virtual ~NzAbstract4DNoise();
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;
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

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

@@ -12,26 +12,27 @@
class NAZARA_NOISE_API NzComplexNoiseBase
{
public:
NzComplexNoiseBase();
~NzComplexNoiseBase() = default;
public:
NzComplexNoiseBase();
~NzComplexNoiseBase() = default;
float GetHurstParameter() const;
float GetLacunarity() const;
float GetOctaveNumber() const;
void SetHurstParameter(float h);
void SetLacunarity(float lacunarity);
void SetOctavesNumber(float octaves);
void RecomputeExponentArray();
float GetHurstParameter() const;
float GetLacunarity() const;
float GetOctaveNumber() const;
void SetHurstParameter(float h);
void SetLacunarity(float lacunarity);
void SetOctavesNumber(float octaves);
void RecomputeExponentArray();
protected:
float m_lacunarity;
float m_hurst;
float m_octaves;
std::array<float, 30> m_exponent_array;
float m_sum;
private:
bool m_parametersModified;
protected:
float m_lacunarity;
float m_hurst;
float m_octaves;
std::array<float, 30> m_exponent_array;
float m_sum;
private:
bool m_parametersModified;
};
#endif // COMPLEXNOISEBASE_HPP

20
include/Nazara/Noise/FBM2D.hpp
View File

@@ -13,16 +13,16 @@
class NAZARA_NOISE_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;
public:
NzFBM2D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float resolution);
~NzFBM2D();
private:
NzAbstract2DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
#endif // FBM2D_HPP

20
include/Nazara/Noise/FBM3D.hpp
View File

@@ -13,16 +13,16 @@
class NAZARA_NOISE_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;
public:
NzFBM3D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float z, float resolution);
~NzFBM3D();
private:
NzAbstract3DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
#endif // FBM3D_HPP

20
include/Nazara/Noise/FBM4D.hpp
View File

@@ -13,16 +13,16 @@
class NAZARA_NOISE_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;
public:
NzFBM4D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float z, float w, float resolution);
~NzFBM4D();
private:
NzAbstract4DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
#endif // FBM4D_HPP

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

@@ -13,19 +13,19 @@
class NAZARA_NOISE_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;
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

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

@@ -13,19 +13,19 @@
class NAZARA_NOISE_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;
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

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

@@ -13,19 +13,19 @@
class NAZARA_NOISE_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;
public:
NzHybridMultiFractal2D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float resolution);
~NzHybridMultiFractal2D();
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

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

@@ -12,20 +12,20 @@
class NAZARA_NOISE_API NzMappedNoiseBase : public NzNoiseBase
{
public:
NzMappedNoiseBase();
~NzMappedNoiseBase() = default;
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;
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

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

@@ -12,31 +12,31 @@
enum nzNoises
{
PERLIN,
SIMPLEX,
CELL
PERLIN,
SIMPLEX,
CELL
};
class NAZARA_NOISE_API NzNoiseBase
{
public:
NzNoiseBase(unsigned int seed = 0);
~NzNoiseBase() = default;
public:
NzNoiseBase(unsigned int seed = 0);
~NzNoiseBase() = default;
void SetNewSeed(unsigned int seed);
void SetNewSeed(unsigned int seed);
void ShufflePermutationTable();
void ShufflePermutationTable();
unsigned int GetUniformRandomValue();
unsigned int GetUniformRandomValue();
int fastfloor(float n);
int JenkinsHash(int a, int b, int c);
protected:
unsigned int perm[512];
private:
unsigned int Ua, Uc, Um;
unsigned int UcurrentSeed;
unsigned int Uprevious, Ulast;
int fastfloor(float n);
int JenkinsHash(int a, int b, int c);
protected:
unsigned int perm[512];
private:
unsigned int Ua, Uc, Um;
unsigned int UcurrentSeed;
unsigned int Uprevious, Ulast;
};

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

@@ -14,21 +14,21 @@
class NAZARA_NOISE_API NzPerlin2D : public NzAbstract2DNoise
{
public:
NzPerlin2D();
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;
float gradient2[8][2];
float s,t,u,v;
float Cx,Cy;
float Li1, Li2;
NzVector2<float> temp;
public:
NzPerlin2D();
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;
float gradient2[8][2];
float s,t,u,v;
float Cx,Cy;
float Li1, Li2;
NzVector2<float> temp;
};
#endif // PERLIN2D_HPP

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

@@ -14,23 +14,23 @@
class NAZARA_NOISE_API NzPerlin3D : public NzAbstract3DNoise
{
public:
NzPerlin3D();
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;
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;
public:
NzPerlin3D();
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;
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;
};
#endif // PERLIN3D_HPP

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

@@ -14,22 +14,22 @@
class NAZARA_NOISE_API NzPerlin4D : public NzAbstract4DNoise
{
public:
NzPerlin4D();
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;
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;
public:
NzPerlin4D();
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;
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;
};
#endif // PERLIN4D_HPP

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

@@ -14,24 +14,24 @@
class NAZARA_NOISE_API NzSimplex2D : public NzAbstract2DNoise
{
public:
NzSimplex2D();
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;
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;
public:
NzSimplex2D();
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;
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;
};
#endif // SIMPLEX2D_HPP

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

@@ -14,24 +14,24 @@
class NAZARA_NOISE_API NzSimplex3D : public NzAbstract3DNoise
{
public:
NzSimplex3D();
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;
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;
public:
NzSimplex3D();
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;
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;
};
#endif // SIMPLEX3D_HPP

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

@@ -14,26 +14,26 @@
class NAZARA_NOISE_API NzSimplex4D : public NzAbstract4DNoise
{
public:
NzSimplex4D();
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;
int lookupTable4D[64][4];
int c;
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;
public:
NzSimplex4D();
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;
int lookupTable4D[64][4];
int c;
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;
};
#endif // SIMPLEX4D_H