From cd701a429be5ba14a95fe6cb35aea1a2e30cf991 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Sun, 27 May 2012 21:15:12 +0200 Subject: [PATCH] =?UTF-8?q?'q'=20n'est=20pas=20reconnu=20en=20tant=20que?= =?UTF-8?q?=20commande=20interne=20ou=20externe,=20un=20programme=20ex?= =?UTF-8?q?=C2=82cutable=20ou=20un=20fichier=20de=20commandes.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- include/Nazara/Noise/NoiseMachine.h | 121 ---- src/Nazara/Noise/NoiseMachine.cpp | 885 +++++++++++++--------------- 2 files changed, 395 insertions(+), 611 deletions(-) delete mode 100644 include/Nazara/Noise/NoiseMachine.h diff --git a/include/Nazara/Noise/NoiseMachine.h b/include/Nazara/Noise/NoiseMachine.h deleted file mode 100644 index fb09d5de5..000000000 --- a/include/Nazara/Noise/NoiseMachine.h +++ /dev/null @@ -1,121 +0,0 @@ -// Copyright (C) 2012 Rémi "Overdrivr" Bèges (remi{dot}beges{at}gmail{dot}com) -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef NOISEMACHINE_HPP -#define NOISEMACHINE_HPP - -#include - -class NzVector2f; -class NzVector3f; -class NzVector4f; - -class NzNoiseMachine -{ - public: - NzNoiseMachine(int seed = 0); - ~NzNoiseMachine(); - - void SetNewSeed(int seed); - void ShufflePermutationTable(); - - float Get1DPerlinNoiseValue(float x, float res); - 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); - - void SetLacunarity(float lacunarity); - void SetHurstParameter(float h); - void SetOctavesNumber(float octaves); - void RecomputeExponentArray(); - - float Get1DFBMNoiseValue(float x, 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: - - //Pour tronquer les nombres - int fastfloor(float n); - - float pi; - int perm[512]; - int PermutationTemp[256]; - float gradient2[8][2]; - int gradient3[16][3]; - int gradient4[32][4]; - int lookupTable4D[64][4]; - - //multiplicative congruential generator - int UcurrentSeed; - int Ua,Uc,Um; - int Uprevious; - int Ulast; - - //----------------------- Simplex variables -------------------------------------- - - float n1, n2, n3, n4, n5; - NzVector4f A; - NzVector4i Origin; - NzVector4f d1,d2,d3,d4,d5; - NzVector4i off1, off2,off3; - NzVector4f IsoOriginDist; - NzVector4f H[5]; - - int ii,jj,kk,ll; - int gi0,gi1,gi2,gi3,gi4,gi5,gi6,gi7,gi8,gi9,gi10,gi11,gi12,gi13,gi14,gi15; - float lenght; - float c1,c2,c3,c4,c5,c6; - int c; - - float SkewCoeff2D; - float UnskewCoeff2D; - - float SkewCoeff3D; - float UnskewCoeff3D; - - float SkewCoeff4D; - float UnskewCoeff4D; - - //----------------------- 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 nx,ny,nz,nw; - float tmp; - - //---------------------- Complex Noise Variables -------------------------------- - - float m_lacunarity; - float m_hurst; - float m_octaves; - bool m_parametersModified; - float exponent_array[30]; - bool first; - float value; - float remainder; - - float smax; - float smin; - -}; - -#endif // NOISEMACHINE_H diff --git a/src/Nazara/Noise/NoiseMachine.cpp b/src/Nazara/Noise/NoiseMachine.cpp index cbc306420..28e7fa82a 100644 --- a/src/Nazara/Noise/NoiseMachine.cpp +++ b/src/Nazara/Noise/NoiseMachine.cpp @@ -1,19 +1,15 @@ -// Copyright (C) 2012 Rémi "Overdrivr" Bèges (remi{dot}beges{at}gmail{dot}com) +// 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 -#include -#include -#include - #include #include #include #include -NzNoiseMachine::NzNoiseMachine(float seed) +NzNoiseMachine::NzNoiseMachine(int seed) { pi = 3.14159265; @@ -26,7 +22,6 @@ NzNoiseMachine::NzNoiseMachine(float seed) SkewCoeff4D = (sqrt(5) - 1)/4; UnskewCoeff4D = (5 - sqrt(5))/20; - //Uniform pseudo random number generator coefficients Ua = 16807; Uc = 0; Um = 2147483647; @@ -35,11 +30,10 @@ NzNoiseMachine::NzNoiseMachine(float seed) SetNewSeed(seed); - for(float i(0) ; i < 256 ; i++) + for(int i(0) ; i < 256 ; i++) PermutationTemp[i] = i; - //4D only - to find the offset with Simplex in 4D - float lookupTemp4D[][4] = + 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}, @@ -51,31 +45,30 @@ NzNoiseMachine::NzNoiseMachine(float seed) {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(float i(0) ; i < 64 ; ++i) - for(float j(0) ; j < 4 ; ++j) + for(int i(0) ; i < 64 ; ++i) + for(int j(0) ; j < 4 ; ++j) lookupTable4D[i][j] = lookupTemp4D[i][j]; float unit = 1.0/sqrt(2); float grad2Temp[][2] = {{unit,unit},{-unit,unit},{unit,-unit},{-unit,-unit}, {1,0},{-1,0},{0,1},{0,-1}}; - for(float i(0) ; i < 8 ; ++i) - for(float j(0) ; j < 2 ; ++j) + for(int i(0) ; i < 8 ; ++i) + for(int j(0) ; j < 2 ; ++j) gradient2[i][j] = grad2Temp[i][j]; - //On remplit les tables de gradients - float grad3Temp[][3] = { + 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(float i(0) ; i < 16 ; ++i) - for(float j(0) ; j < 3 ; ++j) + for(int i(0) ; i < 16 ; ++i) + for(int j(0) ; j < 3 ; ++j) gradient3[i][j] = grad3Temp[i][j]; - float grad4Temp[][4] = + 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}, @@ -87,11 +80,10 @@ NzNoiseMachine::NzNoiseMachine(float seed) {-1,1,1,0},{-1,1,-1,0},{-1,-1,1,0},{-1,-1,-1,0} }; - for(float i(0) ; i < 32 ; ++i) - for(float j(0) ; j < 4 ; ++j) + for(int i(0) ; i < 32 ; ++i) + for(int j(0) ; j < 4 ; ++j) gradient4[i][j] = grad4Temp[i][j]; - m_lacunarity = 2.5f; m_octaves = 3.0f; m_hurst = 1.1f; @@ -100,28 +92,28 @@ NzNoiseMachine::NzNoiseMachine(float seed) NzNoiseMachine::~NzNoiseMachine() { - } -void NzNoiseMachine::SetNewSeed(float seed) +void NzNoiseMachine::SetNewSeed(int seed) { Uprevious = seed; UcurrentSeed = seed; } -float NzNoiseMachine::GetUniformRandomValue() +int NzNoiseMachine::GetUniformRandomValue() { Ulast = Ua*Uprevious + Uc%Um; Uprevious = Ulast; return Ulast; } -void NzNoiseMachine::MixPermutationTable() +void NzNoiseMachine::ShufflePermutationTable() { - float xchanger; - unsigned float ncase; - for(float j(0) ; j < 10 ; ++j) - for (float i(0); i < 256 ; ++i) + int xchanger; + unsigned int ncase; + + for(int j(0) ; j < 10 ; ++j) + for (int i(0); i < 256 ; ++i) { ncase = this->GetUniformRandomValue() & 255; xchanger = PermutationTemp[i]; @@ -129,7 +121,7 @@ void NzNoiseMachine::MixPermutationTable() PermutationTemp[ncase] = xchanger; } - for(float i(0) ; i < 512; ++i) + for(int i(0) ; i < 512; ++i) perm[i]=PermutationTemp[i & 255]; } @@ -138,22 +130,21 @@ void NzNoiseMachine::MixPermutationTable() float NzNoiseMachine::Get1DPerlinNoiseValue(float x, float res) { nx = x/res; - x0 = (float)(nx); + x0 = (int)(nx); ii = x0 & 255; gi0 = perm[ii] % 16; gi1 = perm[ii + 1] % 16; - temp.X = nx-x0; - temp.Y = ny-y0; + temp.x = nx-x0; + temp.y = ny-y0; - s[0] = gradient3[gi0][0]*temp.X; + s[0] = gradient3[gi0][0]*temp.x; - temp.X = nx-(x0+1); + temp.x = nx-(x0+1); - t[0] = gradient3[gi1][0]*temp.X; + t[0] = gradient3[gi1][0]*temp.x; - //Lissage tmp = nx-x0; Cx = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10); @@ -165,9 +156,8 @@ float NzNoiseMachine::Get2DPerlinNoiseValue(float x, float y, float res) nx = x/res; ny = y/res; - //On récupère les positions de la grille associée à (x,y) - x0 = (float)(nx); - y0 = (float)(ny); + x0 = (int)(nx); + y0 = (int)(ny); ii = x0 & 255; jj = y0 & 255; @@ -177,25 +167,22 @@ float NzNoiseMachine::Get2DPerlinNoiseValue(float x, float y, float res) gi2 = perm[ii + perm[jj + 1]] & 7; gi3 = perm[ii + 1 + perm[jj + 1]] & 7; - //on calcule les valeurs du plan supérieur - temp.X = nx-x0; - temp.Y = ny-y0; - s[0] = gradient2[gi0][0]*temp.X + gradient2[gi0][1]*temp.Y; + temp.x = nx-x0; + temp.y = ny-y0; + s[0] = gradient2[gi0][0]*temp.x + gradient2[gi0][1]*temp.y; - temp.X = nx-(x0+1); - temp.Y = ny-y0; - t[0] = gradient2[gi1][0]*temp.X + gradient2[gi1][1]*temp.Y; + temp.x = nx-(x0+1); + temp.y = ny-y0; + t[0] = gradient2[gi1][0]*temp.x + gradient2[gi1][1]*temp.y; - temp.X = nx-x0; - temp.Y = ny-(y0+1); - u[0] = gradient2[gi2][0]*temp.X + gradient2[gi2][1]*temp.Y; + temp.x = nx-x0; + temp.y = ny-(y0+1); + u[0] = gradient2[gi2][0]*temp.x + gradient2[gi2][1]*temp.y; - temp.X = nx-(x0+1); - temp.Y = ny-(y0+1); - v[0] = gradient2[gi3][0]*temp.X + gradient2[gi3][1]*temp.Y; + temp.x = nx-(x0+1); + temp.y = ny-(y0+1); + v[0] = gradient2[gi3][0]*temp.x + gradient2[gi3][1]*temp.y; - - //Lissage tmp = nx-x0; Cx = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10); @@ -213,10 +200,9 @@ float NzNoiseMachine::Get3DPerlinNoiseValue(float x, float y, float z, float res ny = y/res; nz = z/res; - //On récupère les positions de la grille associée à (x,y) - x0 = (float)(nx); - y0 = (float)(ny); - z0 = (float)(nz); + x0 = (int)(nx); + y0 = (int)(ny); + z0 = (int)(nz); ii = x0 & 255; jj = y0 & 255; @@ -232,43 +218,40 @@ float NzNoiseMachine::Get3DPerlinNoiseValue(float x, float y, float z, float res gi6 = perm[ii + perm[jj + 1 + perm[kk + 1]]] % 16; gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] % 16; - //on calcule les valeurs du plan inférieur - temp.X = nx-x0; - temp.Y = ny-y0; - temp.Z = nz-z0; - s[0] = gradient3[gi0][0]*temp.X + gradient3[gi0][1]*temp.Y + gradient3[gi0][2]*temp.Z; + temp.x = nx-x0; + temp.y = ny-y0; + temp.z = nz-z0; + s[0] = gradient3[gi0][0]*temp.x + gradient3[gi0][1]*temp.y + gradient3[gi0][2]*temp.z; - temp.X = nx-(x0+1); - temp.Y = ny-y0; - t[0] = gradient3[gi1][0]*temp.X + gradient3[gi1][1]*temp.Y + gradient3[gi1][2]*temp.Z; + temp.x = nx-(x0+1); + temp.y = ny-y0; + t[0] = gradient3[gi1][0]*temp.x + gradient3[gi1][1]*temp.y + gradient3[gi1][2]*temp.z; - temp.X = nx-x0; - temp.Y = ny-(y0+1); - u[0] = gradient3[gi2][0]*temp.X + gradient3[gi2][1]*temp.Y + gradient3[gi2][2]*temp.Z; + temp.x = nx-x0; + temp.y = ny-(y0+1); + u[0] = gradient3[gi2][0]*temp.x + gradient3[gi2][1]*temp.y + gradient3[gi2][2]*temp.z; - temp.X = nx-(x0+1); - temp.Y = ny-(y0+1); - v[0] = gradient3[gi3][0]*temp.X + gradient3[gi3][1]*temp.Y + gradient3[gi3][2]*temp.Z; + temp.x = nx-(x0+1); + temp.y = ny-(y0+1); + v[0] = gradient3[gi3][0]*temp.x + gradient3[gi3][1]*temp.y + gradient3[gi3][2]*temp.z; - //Les valeurs du plan supérieur - temp.X = nx-x0; - temp.Y = ny-y0; - temp.Z = nz-(z0+1); - s[1] = gradient3[gi4][0]*temp.X + gradient3[gi4][1]*temp.Y + gradient3[gi4][2]*temp.Z; + temp.x = nx-x0; + temp.y = ny-y0; + temp.z = nz-(z0+1); + s[1] = gradient3[gi4][0]*temp.x + gradient3[gi4][1]*temp.y + gradient3[gi4][2]*temp.z; - temp.X = nx-(x0+1); - temp.Y = ny-y0; - t[1] = gradient3[gi5][0]*temp.X + gradient3[gi5][1]*temp.Y + gradient3[gi5][2]*temp.Z; + temp.x = nx-(x0+1); + temp.y = ny-y0; + t[1] = gradient3[gi5][0]*temp.x + gradient3[gi5][1]*temp.y + gradient3[gi5][2]*temp.z; - temp.X = nx-x0; - temp.Y = ny-(y0+1); - u[1] = gradient3[gi6][0]*temp.X + gradient3[gi6][1]*temp.Y + gradient3[gi6][2]*temp.Z; + temp.x = nx-x0; + temp.y = ny-(y0+1); + u[1] = gradient3[gi6][0]*temp.x + gradient3[gi6][1]*temp.y + gradient3[gi6][2]*temp.z; - temp.X = nx-(x0+1); - temp.Y = ny-(y0+1); - v[1] = gradient3[gi7][0]*temp.X + gradient3[gi7][1]*temp.Y + gradient3[gi7][2]*temp.Z; + temp.x = nx-(x0+1); + temp.y = ny-(y0+1); + v[1] = gradient3[gi7][0]*temp.x + gradient3[gi7][1]*temp.y + gradient3[gi7][2]*temp.z; - //On procède à un lissage, et on affecte le pofloat à la matrice de pixels tmp = nx-x0; Cx = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10); @@ -296,11 +279,10 @@ float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w, nz = z/res; nw = w/res; - //On récupère les positions de la grille associée à (x,y) - x0 = (float)(nx); - y0 = (float)(ny); - z0 = (float)(nz); - w0 = (float)(nw); + x0 = (int)(nx); + y0 = (int)(ny); + z0 = (int)(nz); + w0 = (int)(nw); ii = x0 & 255; jj = y0 & 255; @@ -327,81 +309,76 @@ float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w, gi14 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32; gi15 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32; - //Z inférieur, W inférieur - temp.X = nx-x0; - temp.Y = ny-y0; - temp.Z = nz-z0; - temp.W = nw-w0; - 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; + temp.y = ny-y0; + temp.z = nz-z0; + temp.w = nw-w0; + 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); - temp.Y = ny-y0; - t[0] = gradient4[gi1][0]*temp.X + gradient4[gi1][1]*temp.Y + gradient4[gi1][2]*temp.Z + gradient4[gi1][3]*temp.W; + temp.x = nx-(x0+1); + temp.y = ny-y0; + t[0] = gradient4[gi1][0]*temp.x + gradient4[gi1][1]*temp.y + gradient4[gi1][2]*temp.z + gradient4[gi1][3]*temp.w; - temp.X = nx-x0; - temp.Y = ny-(y0+1); - u[0] = gradient4[gi2][0]*temp.X + gradient4[gi2][1]*temp.Y + gradient4[gi2][2]*temp.Z + gradient4[gi2][3]*temp.W; + temp.x = nx-x0; + temp.y = ny-(y0+1); + u[0] = gradient4[gi2][0]*temp.x + gradient4[gi2][1]*temp.y + gradient4[gi2][2]*temp.z + gradient4[gi2][3]*temp.w; - temp.X = nx-(x0+1); - 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+1); + 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; - //Z supérieur, W inférieur - temp.X = nx-x0; - 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; + 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); - temp.Y = ny-y0; - t[1] = gradient4[gi5][0]*temp.X + gradient4[gi5][1]*temp.Y + gradient4[gi5][2]*temp.Z + gradient4[gi5][3]*temp.W; + temp.x = nx-(x0+1); + temp.y = ny-y0; + t[1] = gradient4[gi5][0]*temp.x + gradient4[gi5][1]*temp.y + gradient4[gi5][2]*temp.z + gradient4[gi5][3]*temp.w; - temp.X = nx-x0; - temp.Y = ny-(y0+1); - u[1] = gradient4[gi6][0]*temp.X + gradient4[gi6][1]*temp.Y + gradient4[gi6][2]*temp.Z + gradient4[gi6][3]*temp.W; + temp.x = nx-x0; + temp.y = ny-(y0+1); + u[1] = gradient4[gi6][0]*temp.x + gradient4[gi6][1]*temp.y + gradient4[gi6][2]*temp.z + gradient4[gi6][3]*temp.w; - temp.X = nx-(x0+1); - 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+1); + 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; - //Z inférieur, W superieur - temp.X = nx-x0; - 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; + 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); - temp.Y = ny-y0; - t[2] = gradient4[gi9][0]*temp.X + gradient4[gi9][1]*temp.Y + gradient4[gi9][2]*temp.Z + gradient4[gi9][3]*temp.W; + temp.x = nx-(x0+1); + temp.y = ny-y0; + t[2] = gradient4[gi9][0]*temp.x + gradient4[gi9][1]*temp.y + gradient4[gi9][2]*temp.z + gradient4[gi9][3]*temp.w; - temp.X = nx-x0; - temp.Y = ny-(y0+1); - u[2] = gradient4[gi10][0]*temp.X + gradient4[gi10][1]*temp.Y + gradient4[gi10][2]*temp.Z + gradient4[gi10][3]*temp.W; + temp.x = nx-x0; + temp.y = ny-(y0+1); + u[2] = gradient4[gi10][0]*temp.x + gradient4[gi10][1]*temp.y + gradient4[gi10][2]*temp.z + gradient4[gi10][3]*temp.w; - temp.X = nx-(x0+1); - 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+1); + 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; - //Z supérieur, W superieur - temp.X = nx-x0; - 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; + 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); - temp.Y = ny-y0; - t[3] = gradient4[gi13][0]*temp.X + gradient4[gi13][1]*temp.Y + gradient4[gi13][2]*temp.Z + gradient4[gi13][3]*temp.W; + temp.x = nx-(x0+1); + temp.y = ny-y0; + t[3] = gradient4[gi13][0]*temp.x + gradient4[gi13][1]*temp.y + gradient4[gi13][2]*temp.z + gradient4[gi13][3]*temp.w; - temp.X = nx-x0; - temp.Y = ny-(y0+1); - u[3] = gradient4[gi14][0]*temp.X + gradient4[gi14][1]*temp.Y + gradient4[gi14][2]*temp.Z + gradient4[gi14][3]*temp.W; + temp.x = nx-x0; + temp.y = ny-(y0+1); + u[3] = gradient4[gi14][0]*temp.x + gradient4[gi14][1]*temp.y + gradient4[gi14][2]*temp.z + gradient4[gi14][3]*temp.w; - temp.X = nx-(x0+1); - 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+1); + 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; - //Li1 à Li8 : Lissage sur x tmp = nx-x0; Cx = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10); @@ -414,7 +391,6 @@ float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w, Li7 = s[3] + Cx*(t[3]-s[3]); Li8 = u[3] + Cx*(v[3]-u[3]); - //Li9 à Li12 : Lissage sur y tmp = ny-y0; Cy = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10); @@ -423,7 +399,6 @@ float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w, Li11 = Li5 + Cy*(Li6-Li5); Li12 = Li7 + Cy*(Li8-Li7); - //Li13,Li14 : Lissage sur z tmp = nz-z0; Cz = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10); @@ -444,72 +419,65 @@ float NzNoiseMachine::Get2DSimplexNoiseValue(float x, float y, float resolution) y /= resolution; - Origin.X = fastfloor(x + (x+y)*SkewCoeff2D); - Origin.Y = fastfloor(y + (x+y)*SkewCoeff2D); + Origin.x = fastfloor(x + (x + y) * SkewCoeff2D); + Origin.y = fastfloor(y + (x + y) * SkewCoeff2D); - A.X = Origin.X - (Origin.X+Origin.Y)*UnskewCoeff2D; - A.Y = Origin.Y - (Origin.X+Origin.Y)*UnskewCoeff2D; + A.x = Origin.x - (Origin.x + Origin.y) * UnskewCoeff2D; + A.y = Origin.y - (Origin.x + Origin.y) * UnskewCoeff2D; - IsoOriginDist.X = x - A.X; - IsoOriginDist.Y = y - A.Y; + IsoOriginDist.x = x - A.x; + IsoOriginDist.y = y - A.y; - if(IsoOriginDist.X > IsoOriginDist.Y) + if(IsoOriginDist.x > IsoOriginDist.y) { - off1.X = 1; - off1.Y = 0; + off1.x = 1; + off1.y = 0; } else { - off1.X = 0; - off1.Y = 1; + off1.x = 0; + off1.y = 1; } - //On calcule les distances - d1.X = A.X - x; - d1.Y = A.Y - y; - //?? Ordre des + et - - d2.X = d1.X + off1.X - UnskewCoeff2D; - d2.Y = d1.Y + off1.Y - UnskewCoeff2D; + d1.x = A.x - x; + d1.y = A.y - y; - d3.X = d1.X + 1.0 - 2*UnskewCoeff2D; - d3.Y = d1.Y + 1.0 - 2*UnskewCoeff2D; + d2.x = d1.x + off1.x - UnskewCoeff2D; + d2.y = d1.y + off1.y - UnskewCoeff2D; - //On récupère la valeur des gradients des trois sommets - ii = Origin.X & 255; - jj = Origin.Y & 255; + d3.x = d1.x + 1.0 - 2 * UnskewCoeff2D; + d3.y = d1.y + 1.0 - 2 * UnskewCoeff2D; + + ii = Origin.x & 255; + jj = Origin.y & 255; gi0 = perm[ii + perm[jj]] % 12; - gi1 = perm[ii + off1.X + perm[jj + off1.Y]] % 12; + gi1 = perm[ii + off1.x + perm[jj + off1.y]] % 12; gi2 = perm[ii + 1 + perm[jj + 1]] % 12; - H[0].X = gradient3[gi0][0]; - H[0].Y = gradient3[gi0][1]; + H[0].x = gradient3[gi0][0]; + H[0].y = gradient3[gi0][1]; - H[1].X = gradient3[gi1][0]; - H[1].Y = gradient3[gi1][1]; + H[1].x = gradient3[gi1][0]; + H[1].y = gradient3[gi1][1]; - H[2].X = gradient3[gi2][0]; - H[2].Y = gradient3[gi2][1]; + H[2].x = gradient3[gi2][0]; + H[2].y = gradient3[gi2][1]; - //On ajoute les valeurs ensemble - - - n1 = H[0].X*d1.X + H[0].Y*d1.Y; - n2 = H[1].X*d2.X + H[1].Y*d2.Y; - n3 = H[2].X*d3.X + H[2].Y*d3.Y; + n1 = H[0].x * d1.x + H[0].y * d1.y; + n2 = H[1].x * d2.x + H[1].y * d2.y; + n3 = H[2].x * d3.x + H[2].y * d3.y; lenght = 0.5; - c1 = lenght - d1.X*d1.X - d1.Y*d1.Y; - c2 = lenght - d2.X*d2.X - d2.Y*d2.Y; - c3 = lenght - d3.X*d3.X - d3.Y*d3.Y; + c1 = lenght - d1.x * d1.x - d1.y * d1.y; + c2 = lenght - d2.x * d2.x - d2.y * d2.y; + c3 = lenght - d3.x * d3.x - d3.y * d3.y; if(c1 < 0) c1 = 0; - if(c2 < 0) c2 = 0; - if(c3 < 0) c3 = 0; @@ -526,134 +494,122 @@ float NzNoiseMachine::Get3DSimplexNoiseValue(float x, float y, float z, float re y /= resolution; z /= resolution; + Origin.x = fastfloor(x + (x + y + z) * SkewCoeff3D); + Origin.y = fastfloor(y + (x + y + z) * SkewCoeff3D); + Origin.z = fastfloor(z + (x + y + z) * SkewCoeff3D); - Origin.X = fastfloor(x + (x+y+z)*SkewCoeff3D); - Origin.Y = fastfloor(y + (x+y+z)*SkewCoeff3D); - Origin.Z = fastfloor(z + (x+y+z)*SkewCoeff3D); + A.x = Origin.x - (Origin.x + Origin.y + Origin.z) * UnskewCoeff3D; + A.y = Origin.y - (Origin.x + Origin.y + Origin.z) * UnskewCoeff3D; + A.z = Origin.z - (Origin.x + Origin.y + Origin.z) * UnskewCoeff3D; - A.X = Origin.X - (Origin.X+Origin.Y+Origin.Z)*UnskewCoeff3D; - A.Y = Origin.Y - (Origin.X+Origin.Y+Origin.Z)*UnskewCoeff3D; - A.Z = Origin.Z - (Origin.X+Origin.Y+Origin.Z)*UnskewCoeff3D; + IsoOriginDist.x = x - A.x; + IsoOriginDist.y = y - A.y; + IsoOriginDist.z = z - A.z; - IsoOriginDist.X = x - A.X; - IsoOriginDist.Y = y - A.Y; - IsoOriginDist.Z = z - A.Z; - - // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z), - // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and - // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where - // c = 1/6. - - if(IsoOriginDist.X >= IsoOriginDist.Y) + if(IsoOriginDist.x >= IsoOriginDist.y) { - if(IsoOriginDist.Y >= IsoOriginDist.Z) + if(IsoOriginDist.y >= IsoOriginDist.z) { - off1.X=1; - off1.Y=0; - off1.Z=0; - off2.X=1; - off2.Y=1; - off2.Z=0; - } // X Y Z order - else if(IsoOriginDist.X >= IsoOriginDist.Z) + off1.x = 1; + off1.y = 0; + off1.z = 0; + off2.x = 1; + off2.y = 1; + off2.z = 0; + } + else if(IsoOriginDist.x >= IsoOriginDist.z) { - off1.X=1; // X Z Y order - off1.Y=0; - off1.Z=0; - off2.X=1; - off2.Y=0; - off2.Z=1; + off1.x = 1; + off1.y = 0; + off1.z = 0; + off2.x = 1; + off2.y = 0; + off2.z = 1; } else { - off1.X=0; // Z X Y order - off1.Y=0; - off1.Z=1; - off2.X=1; - off2.Y=0; - off2.Z=1; + off1.x = 0; + off1.y = 0; + off1.z = 1; + off2.x = 1; + off2.y = 0; + off2.z = 1; } } - else // x0 IsoOriginDist.Y) ? 32 : 0; - c2 = (IsoOriginDist.X > IsoOriginDist.Z) ? 16 : 0; - c3 = (IsoOriginDist.Y > IsoOriginDist.Z) ? 8 : 0; - c4 = (IsoOriginDist.X > IsoOriginDist.W) ? 4 : 0; - c5 = (IsoOriginDist.Y > IsoOriginDist.W) ? 2 : 0; - c6 = (IsoOriginDist.Z > IsoOriginDist.W) ? 1 : 0; + c1 = (IsoOriginDist.x > IsoOriginDist.y) ? 32 : 0; + c2 = (IsoOriginDist.x > IsoOriginDist.z) ? 16 : 0; + c3 = (IsoOriginDist.y > IsoOriginDist.z) ? 8 : 0; + c4 = (IsoOriginDist.x > IsoOriginDist.w) ? 4 : 0; + c5 = (IsoOriginDist.y > IsoOriginDist.w) ? 2 : 0; + c6 = (IsoOriginDist.z > IsoOriginDist.w) ? 1 : 0; c = c1 + c2 + c3 + c4 + c5 + c6; - // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order. - // Many values of c will never occur, since e.g. x>y>z>w makes x=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; - // The number 2 in the "simplex" array is at the second largest coordinate. - 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; - // The number 1 in the "simplex" array is at the second smallest coordinate. - 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; - // The fifth corner has all coordinate offsets = 1, so no need to look that up. - //On calcule les distances - d1.X = A.X - x; - d1.Y = A.Y - y; - d1.Z = A.Z - z; - d1.W = A.W - w; + 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; - 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; + 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; - 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; + 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; - 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; + d1.x = A.x - x; + d1.y = A.y - y; + d1.z = A.z - z; + d1.w = A.w - w; - 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; + 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; - //On récupère la valeur des gradients des trois sommets - ii = Origin.X & 255; - jj = Origin.Y & 255; - kk = Origin.Z & 255; - ll = Origin.W & 255; + 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; - gi0 = perm[ii + perm[jj + perm[kk+perm[ll]]]] % 32; - gi1 = perm[ii + off1.X + perm[jj + off1.Y + perm[kk + off1.Z + perm[ll + off1.W]]]] % 32; - gi2 = perm[ii + off2.X + perm[jj + off2.Y + perm[kk + off2.Z + perm[ll + off2.W]]]] % 32; - gi3 = perm[ii + off3.X + perm[jj + off3.Y + perm[kk + off3.Z + perm[ll + off3.W]]]] % 32; + 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 = Origin.x & 255; + jj = Origin.y & 255; + kk = Origin.z & 255; + ll = Origin.w & 255; + + gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] % 32; + gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z + perm[ll + off1.w]]]] % 32; + gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z + perm[ll + off2.w]]]] % 32; + gi3 = perm[ii + off3.x + perm[jj + off3.y + perm[kk + off3.z + perm[ll + off3.w]]]] % 32; gi4 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32; - //On ajoute les valeurs ensemble - - n1 = gradient4[gi0][0]*d1.X + gradient4[gi0][1]*d1.Y + gradient4[gi0][2]*d1.Z + gradient4[gi0][3]*d1.W; - n2 = gradient4[gi1][0]*d2.X + gradient4[gi1][1]*d2.Y + gradient4[gi1][2]*d2.Z + gradient4[gi1][3]*d2.W; - n3 = gradient4[gi2][0]*d3.X + gradient4[gi2][1]*d3.Y + gradient4[gi2][2]*d3.Z + gradient4[gi2][3]*d3.W; - n4 = gradient4[gi3][0]*d4.X + gradient4[gi3][1]*d4.Y + gradient4[gi3][2]*d4.Z + gradient4[gi3][3]*d4.W; - n5 = gradient4[gi4][0]*d5.X + gradient4[gi4][1]*d5.Y + gradient4[gi4][2]*d5.Z + gradient4[gi4][3]*d5.W; + n1 = gradient4[gi0][0]*d1.x + gradient4[gi0][1]*d1.y + gradient4[gi0][2]*d1.z + gradient4[gi0][3]*d1.w; + n2 = gradient4[gi1][0]*d2.x + gradient4[gi1][1]*d2.y + gradient4[gi1][2]*d2.z + gradient4[gi1][3]*d2.w; + n3 = gradient4[gi2][0]*d3.x + gradient4[gi2][1]*d3.y + gradient4[gi2][2]*d3.z + gradient4[gi2][3]*d3.w; + n4 = gradient4[gi3][0]*d4.x + gradient4[gi3][1]*d4.y + gradient4[gi3][2]*d4.z + gradient4[gi3][3]*d4.w; + n5 = gradient4[gi4][0]*d5.x + gradient4[gi4][1]*d5.y + gradient4[gi4][2]*d5.z + gradient4[gi4][3]*d5.w; lenght = 0.6; - c1 = lenght - d1.X*d1.X - d1.Y*d1.Y - d1.Z*d1.Z - d1.W*d1.W; - c2 = lenght - d2.X*d2.X - d2.Y*d2.Y - d2.Z*d2.Z - d2.W*d2.W; - c3 = lenght - d3.X*d3.X - d3.Y*d3.Y - d3.Z*d3.Z - d3.W*d3.W; - c4 = lenght - d4.X*d4.X - d4.Y*d4.Y - d4.Z*d4.Z - d4.W*d4.W; - c5 = lenght - d5.X*d5.X - d5.Y*d5.Y - d5.Z*d5.Z - d5.W*d5.W; + c1 = lenght - d1.x*d1.x - d1.y*d1.y - d1.z*d1.z - d1.w*d1.w; + c2 = lenght - d2.x*d2.x - d2.y*d2.y - d2.z*d2.z - d2.w*d2.w; + c3 = lenght - d3.x*d3.x - d3.y*d3.y - d3.z*d3.z - d3.w*d3.w; + c4 = lenght - d4.x*d4.x - d4.y*d4.y - d4.z*d4.z - d4.w*d4.w; + c5 = lenght - d5.x*d5.x - d5.y*d5.y - d5.z*d5.z - d5.w*d5.w; if(c1 < 0) c1 = 0; - if(c2 < 0) c2 = 0; - if(c3 < 0) c3 = 0; - if(c4 < 0) c4 = 0; - if(c5 < 0) c5 = 0; @@ -798,7 +733,6 @@ float NzNoiseMachine::Get4DSimplexNoiseValue(float x, float y, float z, float w, n4 = c4*c4*c4*n4; n5 = c5*c5*c5*n5; - //return n3*30; return (n1+n2+n3+n4+n5)*17.6995; } @@ -806,7 +740,7 @@ float NzNoiseMachine::Get4DSimplexNoiseValue(float x, float y, float z, float w, float NzNoiseMachine::Get2DCellNoiseValue(float x, float y, float res) { - + return 0; } float NzNoiseMachine::Get3DCellNoiseValue(float x, float y, float z, float res) @@ -815,12 +749,11 @@ float NzNoiseMachine::Get3DCellNoiseValue(float x, float y, float z, float res) y /= res; z /= res; - //On récupère les positions de la grille associée à (x,y) - x0 = (float)(x); - y0 = (float)(y); - z0 = (float)(z); + x0 = (int)(x); + y0 = (int)(y); + z0 = (int)(z); - return 0;//(float)((float)(this->Random3D(x0,y0,z0,SEED_A)) % 1000)/1000; + return 0; } float NzNoiseMachine::Get4DCellNoiseValue(float x, float y, float z, float w, float res) { @@ -829,13 +762,12 @@ float NzNoiseMachine::Get4DCellNoiseValue(float x, float y, float z, float w, fl z /= res; w /= res; - //On récupère les positions de la grille associée à (x,y) - x0 = (float)(x) & 255; - y0 = (float)(y) & 255; - z0 = (float)(z) & 255; - w0 = (float)(w) & 255; + x0 = (int)(x) & 255; + y0 = (int)(y) & 255; + z0 = (int)(z) & 255; + w0 = (int)(w) & 255; - return perm[x0 + perm[y0 + perm[z0 + perm[w0]]]] / 128.f - 1; + return 0; } void NzNoiseMachine::SetLacunarity(float lacunarity) @@ -860,23 +792,27 @@ void NzNoiseMachine::SetOctavesNumber(float octaves) { if(octaves != m_octaves && octaves < 30) { - m_octaves = h; + m_octaves = octaves; m_parametersModified = true; } } void NzNoiseMachine::RecomputeExponentArray() { - // precompute and store spectral weights - float frequency = 1.0; - for (float i(0) ; i < m_octaves; ++i) + if(m_parametersModified) { - //compute weight for each frequency - exponent_array[i] = pow( frequency, -m_hurst ); - frequency *= m_lacunarity; + float frequency = 1.0; + m_sum = 0.f; + for (int i(0) ; i < m_octaves; ++i) + { + exponent_array[i] = pow( frequency, -m_hurst ); + frequency *= m_lacunarity; + m_sum += exponent_array[i]; + + } + m_parametersModified = false; } - m_parametersModified = false; } //------------------------------ FBM ------------------------------ @@ -884,119 +820,94 @@ void NzNoiseMachine::RecomputeExponentArray() float NzNoiseMachine::Get1DFBMNoiseValue(float x, float res) { value = 0.0; + RecomputeExponentArray(); - if(parametersModified) + for (int i(0); i < m_octaves; ++i) { - RecomputeExponentArray(); + value += Get1DPerlinNoiseValue(x,res) * exponent_array[i]; + x *= m_lacunarity; } + remainder = m_octaves - (float)m_octaves; - // inner loop of spectral construction - for (float i(0); i < octaves; ++i) - { - value += Get1DPerlinNoiseValue(x,resolution) * exponent_array[i]; - x *= lacunarity; - } - remainder = octaves - (float)octaves; - - //Doesn't seem to work if(remainder != 0) - value += remainder * Get1DPerlinNoiseValue(x,resolution) * exponent_array[(float)octaves-1]; + value += remainder * Get1DPerlinNoiseValue(x,res) * exponent_array[(int)m_octaves-1]; - return value*sum; + return value * m_sum; } float NzNoiseMachine::Get2DFBMNoiseValue(float x, float y, float res) { value = 0.0; + RecomputeExponentArray(); - if(parametersModified) + for (int i(0); i < m_octaves; ++i) { - RecomputeExponentArray(); + value += Get2DPerlinNoiseValue(x,y,res) * exponent_array[i]; + x *= m_lacunarity; + y *= m_lacunarity; } + remainder = m_octaves - (int)m_octaves; - // inner loop of spectral construction - for (float i(0); i < octaves; ++i) - { - value += Get2DdPerlinNoiseValue(x,y,resolution) * exponent_array[i]; - x *= lacunarity; - y *= lacunarity; - } - remainder = octaves - (float)octaves; - - //Doesn't seem to work if(remainder != 0) - value += remainder * Get2DSimplexNoiseValue(x,y,resolution) * exponent_array[(float)octaves-1]; - - return value*sum; + value += remainder * Get2DSimplexNoiseValue(x,y,res) * exponent_array[(int)m_octaves-1]; + return value * m_sum; } + float NzNoiseMachine::Get3DFBMNoiseValue(float x, float y, float z, float res) { value = 0.0; + RecomputeExponentArray(); - if(parametersModified) + for(int i(0); i < m_octaves; ++i) { - RecomputeExponentArray(); + value += Get3DSimplexNoiseValue(x,y,z,res) * exponent_array[i]; + x *= m_lacunarity; + y *= m_lacunarity; + z *= m_lacunarity; } + remainder = m_octaves - (int)m_octaves; - // inner loop of spectral construction - for (float i(0); i < octaves; ++i) - { - value += Get3DSimplexNoiseValue(x,y,z,resolution) * exponent_array[i]; - x *= lacunarity; - y *= lacunarity; - z *= lacunarity; - } - remainder = octaves - (float)octaves; - - //Doesn't seem to work if(remainder != 0) - value += remainder * Get3DSimplexNoiseValue(x,y,z,resolution) * exponent_array[(float)octaves-1]; + value += remainder * Get3DSimplexNoiseValue(x,y,z,res) * exponent_array[(int)m_octaves-1]; - return value*sum; + return value * m_sum; } //------------------------------ HYBRID MULTIFRACTAL ------------------------------ float NzNoiseMachine::Get2DHybridMultiFractalNoiseValue(float x, float y, float res) { - float frequency, result, signal, weight, remainder; + float result, signal, weight, remainder; float offset = 1; - if(parametersModified) - { - RecomputeExponentArray(); - } + RecomputeExponentArray(); - // get first octave - result = (Get2DSimplexNoiseValue(x,y,resolution) + offset) * exponent_array[0]; + result = (Get2DSimplexNoiseValue(x,y,res) + offset) * exponent_array[0]; weight = result; - // increase frequency - x *= lacunarity; - y *= lacunarity; - // spectral construction inner loop - for (float i(1) ; i < octaves; ++i) + x *= m_lacunarity; + y *= m_lacunarity; + + for(int i(1) ; i < m_octaves; ++i) { - // prevent divergence - if ( weight > 1.0 ) + if(weight > 1.0) weight = 1.0; - signal = ( Get2DSimplexNoiseValue(x,y,resolution) + offset ) * exponent_array[i]; + signal = (Get2DSimplexNoiseValue(x,y,res) + offset) * exponent_array[i]; result += weight * signal; - // update the (monotonically decreasing) weighting value - // (this is why H must specify a high fractal dimension) + weight *= signal; - x *= lacunarity; - y *= lacunarity; + x *= m_lacunarity; + y *= m_lacunarity; } - // take care of remainder - remainder = octaves - (float)octaves; + + remainder = m_octaves - (int)m_octaves; if(remainder != 0) - result += remainder * Get2DSimplexNoiseValue(x,y,resolution) * exponent_array[(float)octaves-1]; + result += remainder * Get2DSimplexNoiseValue(x,y,res) * exponent_array[(int)m_octaves-1]; return result; @@ -1004,51 +915,45 @@ float NzNoiseMachine::Get2DHybridMultiFractalNoiseValue(float x, float y, float float NzNoiseMachine::Get3DHybridMultiFractalNoiseValue(float x, float y, float z, float res) { - float frequency, result, signal, weight, remainder; + float result, signal, weight, remainder; float offset = 1; - if(parametersModified) - { - RecomputeExponentArray(); - } - // get first octave of function - result = (Get3DSimplexNoiseValue(x,y,z,resolution) + offset) * exponent_array[0]; - weight = result; - // increase frequency - x *= lacunarity; - y *= lacunarity; + RecomputeExponentArray(); - // spectral construction inner loop - for (float i(1) ; i < octaves; ++i) + result = (Get3DSimplexNoiseValue(x,y,z,res) + offset) * exponent_array[0]; + weight = result; + + x *= m_lacunarity; + y *= m_lacunarity; + + for(int i(1) ; i < m_octaves; ++i) { - // prevent divergence - if ( weight > 1.0 ) + + if(weight > 1.0) weight = 1.0; - signal = ( Get3DSimplexNoiseValue(x,y,z,resolution) + offset ) * exponent_array[i]; + signal = ( Get3DSimplexNoiseValue(x,y,z,res) + offset ) * exponent_array[i]; result += weight * signal; - // update the (monotonically decreasing) weighting value - // (this is why H must specify a high fractal dimension) + weight *= signal; - x *= lacunarity; - y *= lacunarity; + x *= m_lacunarity; + y *= m_lacunarity; } - // take care of remainder - remainder = octaves - (float)octaves; + + remainder = m_octaves - (int)m_octaves; if(remainder != 0) - result += remainder * Get3DSimplexNoiseValue(x,y,z,resolution) * exponent_array[(float)octaves-1]; + result += remainder * Get3DSimplexNoiseValue(x,y,z,res) * exponent_array[(int)m_octaves-1]; return result; } - -float NzNoiseMachine::fastfloor(float n) +int NzNoiseMachine::fastfloor(float n) { if(n >= 0) - return float(n); + return int(n); else - return float(n-1); + return int(n-1); }