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

Switch from Nz prefix to namespace Nz

Browse Source 
What a huge commit


Former-commit-id: 38ac5eebf70adc1180f571f6006192d28fb99897
This commit is contained in:
Lynix
2015-09-25 19:20:05 +02:00
parent c214251ecf
commit df8da275c4
609 changed files with 68265 additions and 66534 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -10,14 +10,17 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/MappedNoiseBase.hpp>
class NAZARA_NOISE_API NzAbstract2DNoise : public NzMappedNoiseBase
namespace Nz
{
public:
virtual ~NzAbstract2DNoise();
class NAZARA_NOISE_API Abstract2DNoise : public MappedNoiseBase
{
public:
virtual ~Abstract2DNoise();
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

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

@@ -10,14 +10,17 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/MappedNoiseBase.hpp>
class NAZARA_NOISE_API NzAbstract3DNoise : public NzMappedNoiseBase
namespace Nz
{
public:
virtual ~NzAbstract3DNoise();
class NAZARA_NOISE_API Abstract3DNoise : public MappedNoiseBase
{
public:
virtual ~Abstract3DNoise();
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

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

@@ -10,14 +10,17 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/MappedNoiseBase.hpp>
class NAZARA_NOISE_API NzAbstract4DNoise : public NzMappedNoiseBase
namespace Nz
{
public:
virtual ~NzAbstract4DNoise();
class NAZARA_NOISE_API Abstract4DNoise : public MappedNoiseBase
{
public:
virtual ~Abstract4DNoise();
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

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

@@ -10,29 +10,32 @@
#include <Nazara/Prerequesites.hpp>
#include <array>
class NAZARA_NOISE_API NzComplexNoiseBase
namespace Nz
{
public:
NzComplexNoiseBase();
~NzComplexNoiseBase() = default;
class NAZARA_NOISE_API ComplexNoiseBase
{
public:
ComplexNoiseBase();
~ComplexNoiseBase() = 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;
protected:
float m_lacunarity;
float m_hurst;
float m_octaves;
std::array<float, 30> m_exponent_array;
float m_sum;
private:
bool m_parametersModified;
};
private:
bool m_parametersModified;
};
}
#endif // COMPLEXNOISEBASE_HPP

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

@@ -11,18 +11,21 @@
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract2DNoise.hpp>
class NAZARA_NOISE_API NzFBM2D : public NzAbstract2DNoise, public NzComplexNoiseBase
namespace Nz
{
public:
NzFBM2D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float resolution);
~NzFBM2D();
class NAZARA_NOISE_API FBM2D : public Abstract2DNoise, public ComplexNoiseBase
{
public:
FBM2D(NoiseType source, unsigned int seed);
float GetValue(float x, float y, float resolution);
~FBM2D();
private:
NzAbstract2DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
private:
Abstract2DNoise* m_source;
float m_value;
float m_remainder;
NoiseType m_noiseType;
};
}
#endif // FBM2D_HPP

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

@@ -11,19 +11,22 @@
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract3DNoise.hpp>
class NAZARA_NOISE_API NzFBM3D : public NzAbstract3DNoise, public NzComplexNoiseBase
namespace Nz
{
public:
NzFBM3D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float z, float resolution);
~NzFBM3D();
class NAZARA_NOISE_API FBM3D : public Abstract3DNoise, public ComplexNoiseBase
{
public:
FBM3D(NoiseType source, unsigned int seed);
float GetValue(float x, float y, float z, float resolution);
~FBM3D();
private:
NzAbstract3DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
private:
Abstract3DNoise* m_source;
float m_value;
float m_remainder;
NoiseType m_noiseType;
};
}
#endif // FBM3D_HPP

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

@@ -11,19 +11,22 @@
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract4DNoise.hpp>
class NAZARA_NOISE_API NzFBM4D : public NzAbstract4DNoise, public NzComplexNoiseBase
namespace Nz
{
public:
NzFBM4D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float z, float w, float resolution);
~NzFBM4D();
class NAZARA_NOISE_API FBM4D : public Abstract4DNoise, public ComplexNoiseBase
{
public:
FBM4D(NoiseType source, unsigned int seed);
float GetValue(float x, float y, float z, float w, float resolution);
~FBM4D();
private:
NzAbstract4DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
private:
Abstract4DNoise* m_source;
float m_value;
float m_remainder;
NoiseType m_noiseType;
};
}
#endif // FBM4D_HPP

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

@@ -11,22 +11,26 @@
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract3DNoise.hpp>
class NAZARA_NOISE_API NzHybridMultiFractal3D : public NzAbstract3DNoise, public NzComplexNoiseBase
namespace Nz
{
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;
};
class NAZARA_NOISE_API HybridMultiFractal3D : public Abstract3DNoise, public ComplexNoiseBase
{
public:
HybridMultiFractal3D(NoiseType source, unsigned int seed);
~HybridMultiFractal3D();
float GetValue(float x, float y, float z, float resolution);
private:
Abstract3DNoise* m_source;
float m_value;
float m_remainder;
float m_offset;
float m_weight;
float m_signal;
NoiseType m_noiseType;
};
}
#endif // HYBRIDMULTIFRACTAL3D_HPP

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

@@ -11,22 +11,26 @@
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract4DNoise.hpp>
class NAZARA_NOISE_API NzHybridMultiFractal4D : public NzAbstract4DNoise, public NzComplexNoiseBase
namespace Nz
{
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;
};
class NAZARA_NOISE_API HybridMultiFractal4D : public Abstract4DNoise, public ComplexNoiseBase
{
public:
HybridMultiFractal4D(NoiseType source, unsigned int seed);
~HybridMultiFractal4D();
float GetValue(float x, float y, float z, float w, float resolution);
private:
Abstract4DNoise* m_source;
float m_value;
float m_remainder;
float m_offset;
float m_weight;
float m_signal;
NoiseType m_noiseType;
};
}
#endif // HYBRIDMULTIFRACTAL4D_HPP

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

@@ -11,22 +11,26 @@
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract2DNoise.hpp>
class NAZARA_NOISE_API NzHybridMultiFractal2D : public NzAbstract2DNoise, public NzComplexNoiseBase
namespace Nz
{
public:
NzHybridMultiFractal2D(nzNoises source, unsigned int seed);
float GetValue(float x, float y, float resolution);
~NzHybridMultiFractal2D();
class NAZARA_NOISE_API HybridMultiFractal2D : public Abstract2DNoise, public ComplexNoiseBase
{
public:
HybridMultiFractal2D(NoiseType source, unsigned int seed);
~HybridMultiFractal2D();
private:
NzAbstract2DNoise* m_source;
float m_value;
float m_remainder;
float m_offset;
float m_weight;
float m_signal;
nzNoises m_noiseType;
};
float GetValue(float x, float y, float resolution);
private:
Abstract2DNoise* m_source;
float m_value;
float m_remainder;
float m_offset;
float m_weight;
float m_signal;
NoiseType m_noiseType;
};
}
#endif // HYBRIDMULTIFRACTAL2D_HPP

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

@@ -10,22 +10,26 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
class NAZARA_NOISE_API NzMappedNoiseBase : public NzNoiseBase
namespace Nz
{
public:
NzMappedNoiseBase();
~NzMappedNoiseBase() = default;
class NAZARA_NOISE_API MappedNoiseBase : public NoiseBase
{
public:
MappedNoiseBase();
~MappedNoiseBase() = 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

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

@@ -11,20 +11,23 @@
#include <Nazara/Core/Initializer.hpp>
#include <Nazara/Noise/Config.hpp>
class NAZARA_NOISE_API NzNoise
namespace Nz
{
public:
NzNoise() = delete;
~NzNoise() = delete;
class NAZARA_NOISE_API Noise
{
public:
Noise() = delete;
~Noise() = delete;
static bool Initialize();
static bool Initialize();
static bool IsInitialized();
static bool IsInitialized();
static void Uninitialize();
static void Uninitialize();
private:
static unsigned int s_moduleReferenceCounter;
};
private:
static unsigned int s_moduleReferenceCounter;
};
}
#endif // NAZARA_NOISE_HPP

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

@@ -10,34 +10,39 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/Config.hpp>
enum nzNoises
namespace Nz
{
PERLIN,
SIMPLEX,
CELL
};
enum NoiseType
{
PERLIN,
SIMPLEX,
CELL
};
class NAZARA_NOISE_API NzNoiseBase
{
public:
NzNoiseBase(unsigned int seed = 0);
~NzNoiseBase() = default;
class NAZARA_NOISE_API NoiseBase
{
public:
NoiseBase(unsigned int seed = 0);
~NoiseBase() = 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;
};
}
#endif // NOISEBASE_HPP

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

@@ -12,24 +12,28 @@
#include <Nazara/Noise/Abstract2DNoise.hpp>
#include <Nazara/Math/Vector2.hpp>
class NAZARA_NOISE_API NzPerlin2D : public NzAbstract2DNoise
namespace Nz
{
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;
};
class NAZARA_NOISE_API Perlin2D : public Abstract2DNoise
{
public:
Perlin2D();
Perlin2D(unsigned int seed);
~Perlin2D() = default;
float GetValue(float x, float y, float resolution);
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;
Vector2<float> temp;
};
}
#endif // PERLIN2D_HPP

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

@@ -12,25 +12,29 @@
#include <Nazara/Noise/Abstract3DNoise.hpp>
#include <Nazara/Math/Vector3.hpp>
class NAZARA_NOISE_API NzPerlin3D : public NzAbstract3DNoise
namespace Nz
{
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;
};
class NAZARA_NOISE_API Perlin3D : public Abstract3DNoise
{
public:
Perlin3D();
Perlin3D(unsigned int seed);
~Perlin3D() = default;
float GetValue(float x, float y, float z, float resolution);
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;
Vector3<float> temp;
};
}
#endif // PERLIN3D_HPP

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

@@ -12,24 +12,28 @@
#include <Nazara/Noise/Abstract4DNoise.hpp>
#include <Nazara/Math/Vector4.hpp>
class NAZARA_NOISE_API NzPerlin4D : public NzAbstract4DNoise
namespace Nz
{
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;
};
class NAZARA_NOISE_API Perlin4D : public Abstract4DNoise
{
public:
Perlin4D();
Perlin4D(unsigned int seed);
~Perlin4D() = default;
float GetValue(float x, float y, float z, float w, float resolution);
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;
Vector4<float> temp;
};
}
#endif // PERLIN4D_HPP

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

@@ -12,27 +12,31 @@
#include <Nazara/Noise/Abstract2DNoise.hpp>
#include <Nazara/Math/Vector2.hpp>
class NAZARA_NOISE_API NzSimplex2D : public NzAbstract2DNoise
namespace Nz
{
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;
};
class NAZARA_NOISE_API Simplex2D : public Abstract2DNoise
{
public:
Simplex2D();
Simplex2D(unsigned int seed);
virtual ~Simplex2D() = default;
float GetValue(float x, float y, float resolution);
private:
int ii,jj;
int gi0,gi1,gi2;
Vector2i skewedCubeOrigin,off1;
float n1,n2,n3;
float c1,c2,c3;
float gradient2[8][2];
float UnskewCoeff2D;
float SkewCoeff2D;
float sum;
Vector2<float> unskewedCubeOrigin, unskewedDistToOrigin;
Vector2<float> d1,d2,d3;
};
}
#endif // SIMPLEX2D_HPP

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

@@ -12,27 +12,31 @@
#include <Nazara/Noise/Abstract3DNoise.hpp>
#include <Nazara/Math/Vector3.hpp>
class NAZARA_NOISE_API NzSimplex3D : public NzAbstract3DNoise
namespace Nz
{
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;
};
class NAZARA_NOISE_API Simplex3D : public Abstract3DNoise
{
public:
Simplex3D();
Simplex3D(unsigned int seed);
~Simplex3D() = default;
float GetValue(float x, float y, float z, float resolution);
private:
int ii,jj,kk;
int gi0,gi1,gi2,gi3;
Vector3i skewedCubeOrigin,off1,off2;
float n1,n2,n3,n4;
float c1,c2,c3,c4;
float gradient3[12][3];
float UnskewCoeff3D;
float SkewCoeff3D;
float sum;
Vector3<float> unskewedCubeOrigin, unskewedDistToOrigin;
Vector3<float> d1,d2,d3,d4;
};
}
#endif // SIMPLEX3D_HPP

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

@@ -12,29 +12,33 @@
#include <Nazara/Noise/Abstract4DNoise.hpp>
#include <Nazara/Math/Vector4.hpp>
class NAZARA_NOISE_API NzSimplex4D : public NzAbstract4DNoise
namespace Nz
{
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;
};
class NAZARA_NOISE_API Simplex4D : public Abstract4DNoise
{
public:
Simplex4D();
Simplex4D(unsigned int seed);
~Simplex4D() = default;
float GetValue(float x, float y, float z, float w, float resolution);
private:
int ii,jj,kk,ll;
int gi0,gi1,gi2,gi3,gi4;
Vector4i 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;
Vector4<float> unskewedCubeOrigin, unskewedDistToOrigin;
Vector4<float> d1,d2,d3,d4,d5;
};
}
#endif // SIMPLEX4D_H