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

Replaced templates by float

Browse Source 
*Since only valid template parameters were float and double, the whole
template aspect has been removed.
Double precision would only be used in extremely rare occasions
(applications needing high precision and slow performances), it is not
relevant to template the whole module for it.


Former-commit-id: fc6dd028189c608a6a7b4c312b3e5e3f53a01fd7
This commit is contained in:
Remi Beges
2012-10-27 18:59:39 +02:00
parent 745b9dbbd1
commit 9fef43951b
25 changed files with 239 additions and 346 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -10,14 +10,12 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/MappedNoiseBase.hpp>
template <typename T> class NzAbstract2DNoise : public NzMappedNoiseBase<T>
class NAZARA_API NzAbstract2DNoise : public NzMappedNoiseBase
{
public:
T GetBasicValue(T x, T y);
T GetMappedValue(T x, T y);
virtual T GetValue(T x, T y, T resolution) = 0;
float GetBasicValue(float x, float y);
float GetMappedValue(float x, float y);
virtual float GetValue(float x, float y, float resolution) = 0;
};
#include <Nazara/Noise/Abstract2DNoise.inl>
#endif // NAZARA_ABSTRACT2DNOISE_HPP

23
include/Nazara/Noise/Abstract2DNoise.inl
View File

@@ -1,23 +0,0 @@
// 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
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Math/Basic.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
T NzAbstract2DNoise<T>::GetBasicValue(T x, T y)
{
return this->GetValue(x,y,this->m_resolution);
}
template <typename T>
T NzAbstract2DNoise<T>::GetMappedValue(T x, T y)
{
return (this->GetValue(x,y,this->m_resolution) + this->m_offset) * this->m_gain;
}
#include <Nazara/Core/DebugOff.hpp>

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

@@ -10,14 +10,12 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/MappedNoiseBase.hpp>
template<typename T> class NzAbstract3DNoise : public NzMappedNoiseBase<T>
class NAZARA_API NzAbstract3DNoise : public NzMappedNoiseBase
{
public:
T GetBasicValue(T x, T y, T z);
T GetMappedValue(T x, T y, T z);
virtual T GetValue(T x, T y, T z, T 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;
};
#include <Nazara/Noise/Abstract3DNoise.inl>
#endif // NAZARA_ABSTRACT3DNOISE_HPP

23
include/Nazara/Noise/Abstract3DNoise.inl
View File

@@ -1,23 +0,0 @@
// 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
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Math/Basic.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
T NzAbstract3DNoise<T>::GetBasicValue(T x, T y, T z)
{
return this->GetValue(x,y,z,this->m_resolution);
}
template <typename T>
T NzAbstract3DNoise<T>::GetMappedValue(T x, T y, T z)
{
return (this->GetValue(x,y,z,this->m_resolution) + this->m_offset) * this->m_gain ;
}
#include <Nazara/Core/DebugOff.hpp>

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

@@ -10,14 +10,12 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/MappedNoiseBase.hpp>
template <typename T> class NzAbstract4DNoise : public NzMappedNoiseBase<T>
class NAZARA_API NzAbstract4DNoise : public NzMappedNoiseBase
{
public:
T GetBasicValue(T x, T y, T z, T w);
T GetMappedValue(T x, T y, T z, T w);
virtual T GetValue(T x, T y, T z, T w, T 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;
};
#include <Nazara/Noise/Abstract4DNoise.inl>
#endif // NAZARA_ABSTRACT4DNOISE_HPP

23
include/Nazara/Noise/Abstract4DNoise.inl
View File

@@ -1,23 +0,0 @@
// 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
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Math/Basic.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
T NzAbstract4DNoise<T>::GetBasicValue(T x, T y, T z, T w)
{
return this->GetValue(x,y,z,w,this->m_resolution);
}
template <typename T>
T NzAbstract4DNoise<T>::GetMappedValue(T x, T y, T z, T w)
{
return (this->GetValue(x,y,z,w,this->m_resolution) + this->m_offset) * this->m_gain ;
}
#include <Nazara/Core/DebugOff.hpp>

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

@@ -8,33 +8,31 @@
#define COMPLEXNOISEBASE_HPP
#include <Nazara/Prerequesites.hpp>
#include <array>
template <typename T>
class NzComplexNoiseBase
class NAZARA_API NzComplexNoiseBase
{
public:
NzComplexNoiseBase();
~NzComplexNoiseBase() = default;
T GetOctaveNumber() const;
T GetLacunarity() const;
T GetHurstParameter() const;
void SetLacunarity(T lacunarity);
void SetHurstParameter(T h);
void SetOctavesNumber(T octaves);
const std::array<float, 30>& GetExponentArray() const; //For debug purpose
float GetHurstParameter() const;
float GetLacunarity() const;
float GetOctaveNumber() const;
void SetHurstParameter(float h);
void SetLacunarity(float lacunarity);
void SetOctavesNumber(float octaves);
void RecomputeExponentArray();
protected:
T m_lacunarity;
T m_hurst;
T m_octaves;
T exponent_array[30];
T m_sum;
float m_lacunarity;
float m_hurst;
float m_octaves;
std::array<float, 30> exponent_array;
float m_sum;
private:
bool m_parametersModified;
};
#include<Nazara/Noise/ComplexNoiseBase.inl>
#endif // COMPLEXNOISEBASE_HPP

102
include/Nazara/Noise/ComplexNoiseBase.inl
View File

@@ -1,102 +0,0 @@
// 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
#include <cmath>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
#include <iostream>
using namespace std;
template <typename T>
NzComplexNoiseBase<T>::NzComplexNoiseBase()
{
m_parametersModified = true;
m_lacunarity = 5.0f;
m_hurst = 1.2f;
m_octaves = 3.0f;
for (int i(0) ; i < m_octaves; ++i)
{
exponent_array[i] = 0;
}
}
template <typename T>
T NzComplexNoiseBase<T>::GetLacunarity() const
{
return m_lacunarity;
}
template <typename T>
T NzComplexNoiseBase<T>::GetHurstParameter() const
{
return m_hurst;
}
template <typename T>
T NzComplexNoiseBase<T>::GetOctaveNumber() const
{
return m_octaves;
}
template <typename T>
void NzComplexNoiseBase<T>::SetLacunarity(T lacunarity)
{
// if(lacunarity != m_lacunarity)
//{
m_lacunarity = lacunarity;
m_parametersModified = true;
//}
}
template <typename T>
void NzComplexNoiseBase<T>::SetHurstParameter(T h)
{
//if(h != m_hurst)
//{
m_hurst = h;
m_parametersModified = true;
//}
}
template <typename T>
void NzComplexNoiseBase<T>::SetOctavesNumber(T octaves)
{
if(octaves <= 30.0f)
m_octaves = octaves;
else
m_octaves = 30.0f;
m_parametersModified = true;
}
template <typename T>
void NzComplexNoiseBase<T>::RecomputeExponentArray()
{
if(m_parametersModified)
{
cout<<"Recomputing exponent array"<<endl;
float frequency = 1.0;
m_sum = 0.f;
for (int i(0) ; i < static_cast<int>(m_octaves) ; ++i)
{
exponent_array[i] = std::pow( frequency, -m_hurst );
cout<<"expo["<<i<<"] : "<<exponent_array[i]<<endl;
frequency *= m_lacunarity;
//m_sum += 1.0f/exponent_array[i];//A tester
m_sum += exponent_array[i];
}
cout<<"sum = "<<m_sum<<endl;
m_parametersModified = false;
}
}
#include <Nazara/Core/DebugOff.hpp>

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

@@ -11,23 +11,18 @@
#include <Nazara/Noise/ComplexNoiseBase.hpp>
#include <Nazara/Noise/Abstract2DNoise.hpp>
template <typename T> class NzFBM2D : public NzAbstract2DNoise<T>, public NzComplexNoiseBase<T>
class NAZARA_API NzFBM2D : public NzAbstract2DNoise, public NzComplexNoiseBase
{
public:
NzFBM2D(nzNoises source, int seed);
T GetValue(T x, T y, T resolution);
float GetValue(float x, float y, float resolution);
~NzFBM2D();
protected:
private:
NzAbstract2DNoise<T>* m_source;
T m_value;
T m_remainder;
NzAbstract2DNoise* m_source;
float m_value;
float m_remainder;
nzNoises m_noiseType;
};
typedef NzFBM2D<float> NzFBM2Df;
typedef NzFBM2D<double> NzFBM2Dd;
#include <Nazara/Noise/FBM2D.inl>
#endif // FBM2DNOISE_HPP

70
include/Nazara/Noise/FBM2D.inl
View File

@@ -1,70 +0,0 @@
// 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
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <Nazara/Noise/Debug.hpp>
#include <Nazara/Noise/Perlin2D.hpp>
#include <Nazara/Noise/Simplex2D.hpp>
#include <iostream>
using namespace std;
template <typename T>
NzFBM2D<T>::NzFBM2D(nzNoises source, int seed) : NzComplexNoiseBase<T>()
{
switch(source)
{
case PERLIN:
m_source = new NzPerlin2D<T>;
break;
default:
m_source = new NzSimplex2D<T>;
break;
}
m_source->SetNewSeed(seed);
m_source->ShufflePermutationTable();
m_noiseType = source;
}
template <typename T>
T NzFBM2D<T>::GetValue(T x, T y, T resolution)
{
this->RecomputeExponentArray();
m_value = 0.0;
for (int i(0); i < this->m_octaves; ++i)
{
m_value += m_source->GetValue(x,y,resolution) * this->exponent_array[i];
resolution *= this->m_lacunarity;
}
//cout<<m_value<<endl;//"|"<<this->m_sum<<endl;
//m_remainder = this->m_octaves - static_cast<int>(this->m_octaves);
//if(!NzNumberEquals(remainder, static_cast<T>(0.0)))
// m_value += remainder * Get2DSimplexNoiseValue(x,y,resolution) * exponent_array[(int)m_octaves-1];
//0.65 is an experimental value to make the noise stick closer to [-1 , 1]
return m_value / (this->m_sum * 0.65);
}
template <typename T>
NzFBM2D<T>::~NzFBM2D()
{
switch(m_noiseType)
{
case PERLIN:
delete dynamic_cast<NzPerlin2D<T>*>(m_source);
break;
default:
delete dynamic_cast<NzSimplex2D<T>*>(m_source);
break;
}
}
#include <Nazara/Core/DebugOff.hpp>

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

@@ -10,24 +10,22 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Noise/NoiseBase.hpp>
template <typename T> class NzMappedNoiseBase : public NzNoiseBase
class NAZARA_API NzMappedNoiseBase : public NzNoiseBase
{
public:
NzMappedNoiseBase();
~NzMappedNoiseBase() = default;
T GetGain() const;
T GetOffset() const;
T GetResolution() const;
void SetGain(T gain);
void SetOffset(T offset);
void SetResolution(T resolution);
float GetGain() const;
float GetOffset() const;
float GetResolution() const;
void SetGain(float gain);
void SetOffset(float offset);
void SetResolution(float resolution);
protected:
T m_gain;
T m_offset;
T m_resolution;
float m_gain;
float m_offset;
float m_resolution;
};
#include <Nazara/Noise/MappedNoiseBase.inl>
#endif // NAZARA_MAPPEDNOISEBASE_HPP

62
include/Nazara/Noise/MappedNoiseBase.inl
View File

@@ -1,62 +0,0 @@
// 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
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Math/Basic.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Noise/Config.hpp>
#include <stdexcept>
#include <Nazara/Noise/Debug.hpp>
template <typename T>
NzMappedNoiseBase<T>::NzMappedNoiseBase() : m_gain(1), m_offset(0), m_resolution(30)
{
}
template <typename T>
T NzMappedNoiseBase<T>::GetGain() const
{
return m_gain;
}
template <typename T>
T NzMappedNoiseBase<T>::GetOffset() const
{
return m_offset;
}
template <typename T>
T NzMappedNoiseBase<T>::GetResolution() const
{
return m_resolution;
}
template <typename T>
void NzMappedNoiseBase<T>::SetGain(T gain)
{
m_gain = gain;
}
template <typename T>
void NzMappedNoiseBase<T>::SetOffset(T offset)
{
m_offset = offset;
}
template <typename T>
void NzMappedNoiseBase<T>::SetResolution(T resolution)
{
if (NzNumberEquals(resolution, static_cast<T>(0.0)))
{
NzStringStream ss;
ss << __FILE__ << ':' << __LINE__ << " : resolution cannot be 0.0f";
throw std::domain_error(ss.ToString());
}
m_resolution = resolution;
}
#include <Nazara/Core/DebugOff.hpp>

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

@@ -12,28 +12,23 @@
#include <Nazara/Noise/Abstract2DNoise.hpp>
#include <Nazara/Math/Vector2.hpp>
template <typename T> class NzPerlin2D : public NzAbstract2DNoise<T>
class NAZARA_API NzPerlin2D : public NzAbstract2DNoise
{
public:
NzPerlin2D();
T GetValue(T x, T y, T resolution);
virtual ~NzPerlin2D() = default;
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 resolution)
{
x *= resolution;
y *= resolution;
x0 = this->fastfloor(x);
y0 = this->fastfloor(y);
ii = x0 & 255;
jj = y0 & 255;
gi0 = this->perm[ii + this->perm[jj]] & 7;
gi1 = this->perm[ii + 1 + this->perm[jj]] & 7;
gi2 = this->perm[ii + this->perm[jj + 1]] & 7;
gi3 = this->perm[ii + 1 + this->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>

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

@@ -12,30 +12,24 @@
#include <Nazara/Noise/Abstract3DNoise.hpp>
#include <Nazara/Math/Vector3.hpp>
template <typename T> class NzPerlin3D : public NzAbstract3DNoise<T>
class NAZARA_API NzPerlin3D : public NzAbstract3DNoise
{
public:
NzPerlin3D();
T GetValue(T x, T y, T z, T resolution);
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 resolution)
{
x /= resolution;
y /= resolution;
z /= resolution;
x0 = this->fastfloor(x);
y0 = this->fastfloor(y);
z0 = this->fastfloor(z);
ii = x0 & 255;
jj = y0 & 255;
kk = z0 & 255;
gi0 = this->perm[ii + this->perm[jj + this->perm[kk]]] & 15;
gi1 = this->perm[ii + 1 + this->perm[jj + this->perm[kk]]] & 15;
gi2 = this->perm[ii + this->perm[jj + 1 + this->perm[kk]]] & 15;
gi3 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk]]] & 15;
gi4 = this->perm[ii + this->perm[jj + this->perm[kk + 1]]] & 15;
gi5 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + 1]]] & 15;
gi6 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + 1]]] & 15;
gi7 = this->perm[ii + 1 + this->perm[jj + 1 + this->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>

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

@@ -12,29 +12,23 @@
#include <Nazara/Noise/Abstract4DNoise.hpp>
#include <Nazara/Math/Vector4.hpp>
template <typename T> class NzPerlin4D : public NzAbstract4DNoise<T>
class NAZARA_API NzPerlin4D : public NzAbstract4DNoise
{
public:
NzPerlin4D();
T GetValue(T x, T y, T z, T w, T resolution);
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 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 resolution)
{
x *= resolution;
y *= resolution;
z *= resolution;
w *= resolution;
x0 = this->fastfloor(x);
y0 = this->fastfloor(y);
z0 = this->fastfloor(z);
w0 = this->fastfloor(w);
ii = x0 & 255;
jj = y0 & 255;
kk = z0 & 255;
ll = w0 & 255;
gi0 = this->perm[ii + this->perm[jj + this->perm[kk + this->perm[ll]]]] & 31;
gi1 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + this->perm[ll]]]] & 31;
gi2 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + this->perm[ll]]]] & 31;
gi3 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + this->perm[ll]]]] & 31;
gi4 = this->perm[ii + this->perm[jj + + this->perm[kk + 1 + this->perm[ll]]]] & 31;
gi5 = this->perm[ii + 1 + this->perm[jj + + this->perm[kk + 1 + this->perm[ll]]]] & 31;
gi6 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll]]]] & 31;
gi7 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll]]]] & 31;
gi8 = this->perm[ii + this->perm[jj + this->perm[kk + this->perm[ll + 1]]]] & 31;
gi9 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + this->perm[ll + 1]]]] & 31;
gi10 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + this->perm[ll + 1]]]] & 31;
gi11 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + this->perm[ll + 1]]]] & 31;
gi12 = this->perm[ii + this->perm[jj + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31;
gi13 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31;
gi14 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31;
gi15 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31;
temp.x = x-x0;
temp.y = y-y0;
temp.z = z-z0;
temp.w = w-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 = x-(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 = y-(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 = x-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 = y-y0;
temp.z = z-(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 = x-(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 = y-(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 = x-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 = y-y0;
temp.z = z-z0;
temp.w = w-(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 = x-(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 = y-(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 = x-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 = y-y0;
temp.z = z-(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 = x-(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 = y-(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 = x-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>

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

@@ -12,33 +12,26 @@
#include <Nazara/Noise/Abstract2DNoise.hpp>
#include <Nazara/Math/Vector2.hpp>
template <typename T> class NzSimplex2D : public NzAbstract2DNoise<T>
class NAZARA_API NzSimplex2D : public NzAbstract2DNoise
{
public:
NzSimplex2D();
T GetValue(T x, T y, T resolution);
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 resolution)
{
x *= resolution;
y *= resolution;
sum = (x + y) * SkewCoeff2D;
skewedCubeOrigin.x = this->fastfloor(x + sum);
skewedCubeOrigin.y = this->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 = this->perm[ii + this->perm[jj ]] & 7;
gi1 = this->perm[ii + off1.x + this->perm[jj + off1.y]] & 7;
gi2 = this->perm[ii + 1 + this->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>

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

@@ -12,33 +12,26 @@
#include <Nazara/Noise/Abstract3DNoise.hpp>
#include <Nazara/Math/Vector3.hpp>
template <typename T> class NzSimplex3D : public NzAbstract3DNoise<T>
class NAZARA_API NzSimplex3D : public NzAbstract3DNoise
{
public:
NzSimplex3D();
T GetValue(T x, T y, T z, T resolution);
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 resolution)
{
x *= resolution;
y *= resolution;
z *= resolution;
sum = (x + y + z) * SkewCoeff3D;
skewedCubeOrigin.x = this->fastfloor(x + sum);
skewedCubeOrigin.y = this->fastfloor(y + sum);
skewedCubeOrigin.z = this->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 = this->perm[ii + this->perm[jj + this->perm[kk ]]] % 12;
gi1 = this->perm[ii + off1.x + this->perm[jj + off1.y + this->perm[kk + off1.z]]] % 12;
gi2 = this->perm[ii + off2.x + this->perm[jj + off2.y + this->perm[kk + off2.z]]] % 12;
gi3 = this->perm[ii + 1 + this->perm[jj + 1 + this->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>

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

@@ -12,35 +12,28 @@
#include <Nazara/Noise/Abstract4DNoise.hpp>
#include <Nazara/Math/Vector4.hpp>
template <typename T> class NzSimplex4D : public NzAbstract4DNoise<T>
class NAZARA_API NzSimplex4D : public NzAbstract4DNoise
{
public:
NzSimplex4D();
T GetValue(T x, T y, T z, T w, T resolution);
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 resolution)
{
x *= resolution;
y *= resolution;
z *= resolution;
w *= resolution;
sum = (x + y + z + w) * SkewCoeff4D;
skewedCubeOrigin.x = this->fastfloor(x + sum);
skewedCubeOrigin.y = this->fastfloor(y + sum);
skewedCubeOrigin.z = this->fastfloor(z + sum);
skewedCubeOrigin.w = this->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 = this->perm[ii + this->perm[jj + this->perm[kk + this->perm[ll]]]] & 31;
gi1 = this->perm[ii + off1.x + this->perm[jj + off1.y + this->perm[kk + off1.z + this->perm[ll + off1.w]]]] & 31;
gi2 = this->perm[ii + off2.x + this->perm[jj + off2.y + this->perm[kk + off2.z + this->perm[ll + off2.w]]]] & 31;
gi3 = this->perm[ii + off3.x + this->perm[jj + off3.y + this->perm[kk + off3.z + this->perm[ll + off3.w]]]] & 31;
gi4 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 + this->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>