package Roguelike.DungeonGeneration.RoomGenerators;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector3;
/* sdnoise123, Simplex noise with true analytic
* derivative in 1D to 3D.
*
* Copyright 2003-2011, Stefan Gustavson
*
* Contact: stefan.gustavson@gmail.com
*
* This library is public domain software, released by the author
* into the public domain in February 2011. You may do anything
* you like with it. You may even remove all attributions,
* but of course I'd appreciate it if you kept my name somewhere.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* Ported from C to Java by Philip Collin
*/
/*
* This is an implementation of Perlin "simplex noise" over one
* dimension (x), two dimensions (x,y), three dimensions (x,y,z). The analytic derivative is
* returned, to make it possible to do lots of fun stuff like
* flow animations, curl noise, analytic antialiasing and such.
*
*/
public class FastSimplexNoise
{
/* Static data ---------------------- */
/*
* Permutation table. This is just a random jumble of all numbers 0-255,
* repeated twice to avoid wrapping the index at 255 for each lookup.
*/
private static final char[] perm = {151,160,137,91,90,15,
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,
151,160,137,91,90,15,
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
};
/*
* Gradient tables. These could be programmed the Ken Perlin way with
* some clever bit-twiddling, but this is more clear, and not really slower.
*/
private static final float[][] grad2lut = {
{ -1.0f, -1.0f }, { 1.0f, 0.0f } , { -1.0f, 0.0f } , { 1.0f, 1.0f } ,
{ -1.0f, 1.0f } , { 0.0f, -1.0f } , { 0.0f, 1.0f } , { 1.0f, -1.0f }
};
/*
* Gradient directions for 3D.
* These vectors are based on the midpoints of the 12 edges of a cube.
* A larger array of random unit length vectors would also do the job,
* but these 12 (including 4 repeats to make the array length a power
* of two) work better. They are not random, they are carefully chosen
* to represent a small, isotropic set of directions.
*/
private static final float[][] grad3lut = {
{ 1.0f, 0.0f, 1.0f }, { 0.0f, 1.0f, 1.0f }, // 12 cube edges
{ -1.0f, 0.0f, 1.0f }, { 0.0f, -1.0f, 1.0f },
{ 1.0f, 0.0f, -1.0f }, { 0.0f, 1.0f, -1.0f },
{ -1.0f, 0.0f, -1.0f }, { 0.0f, -1.0f, -1.0f },
{ 1.0f, -1.0f, 0.0f }, { 1.0f, 1.0f, 0.0f },
{ -1.0f, 1.0f, 0.0f }, { -1.0f, -1.0f, 0.0f },
{ 1.0f, 0.0f, 1.0f }, { -1.0f, 0.0f, 1.0f }, // 4 repeats to make 16
{ 0.0f, 1.0f, -1.0f }, { 0.0f, -1.0f, -1.0f }
};
private static final float[][] grad4lut = {
{ 0.0f, 1.0f, 1.0f, 1.0f }, { 0.0f, 1.0f, 1.0f, -1.0f }, { 0.0f, 1.0f, -1.0f, 1.0f }, { 0.0f, 1.0f, -1.0f, -1.0f }, // 32 tesseract edges
{ 0.0f, -1.0f, 1.0f, 1.0f }, { 0.0f, -1.0f, 1.0f, -1.0f }, { 0.0f, -1.0f, -1.0f, 1.0f }, { 0.0f, -1.0f, -1.0f, -1.0f },
{ 1.0f, 0.0f, 1.0f, 1.0f }, { 1.0f, 0.0f, 1.0f, -1.0f }, { 1.0f, 0.0f, -1.0f, 1.0f }, { 1.0f, 0.0f, -1.0f, -1.0f },
{ -1.0f, 0.0f, 1.0f, 1.0f }, { -1.0f, 0.0f, 1.0f, -1.0f }, { -1.0f, 0.0f, -1.0f, 1.0f }, { -1.0f, 0.0f, -1.0f, -1.0f },
{ 1.0f, 1.0f, 0.0f, 1.0f }, { 1.0f, 1.0f, 0.0f, -1.0f }, { 1.0f, -1.0f, 0.0f, 1.0f }, { 1.0f, -1.0f, 0.0f, -1.0f },
{ -1.0f, 1.0f, 0.0f, 1.0f }, { -1.0f, 1.0f, 0.0f, -1.0f }, { -1.0f, -1.0f, 0.0f, 1.0f }, { -1.0f, -1.0f, 0.0f, -1.0f },
{ 1.0f, 1.0f, 1.0f, 0.0f }, { 1.0f, 1.0f, -1.0f, 0.0f }, { 1.0f, -1.0f, 1.0f, 0.0f }, { 1.0f, -1.0f, -1.0f, 0.0f },
{ -1.0f, 1.0f, 1.0f, 0.0f }, { -1.0f, 1.0f, -1.0f, 0.0f }, { -1.0f, -1.0f, 1.0f, 0.0f }, { -1.0f, -1.0f, -1.0f, 0.0f }
};
/* --------------------------------------------------------------------- */
/*
* Helper functions to compute gradients in 1D to 4D
* and gradients-dot-residualvectors in 2D to 4D.
*/
public static void grad1( int hash, float[] gx ) {
int h = hash & 15;
gx[0] = 1.0f + (h & 7); // Gradient value is one of 1.0, 2.0, ..., 8.0
if ((h&8) != 0) gx[0] = -gx[0]; // Make half of the gradients negative
}
public static void grad2( int hash, float[] gx, float[] gy )
{
int h = hash & 7;
gx[0] = grad2lut[h][0];
gy[0] = grad2lut[h][1];
}
public static void grad3( int hash, float[] gx, float[] gy, float[] gz ) {
int h = hash & 15;
gx[0] = grad3lut[h][0];
gy[0] = grad3lut[h][1];
gz[0] = grad3lut[h][2];
}
public static void grad4( int hash, float[] gx, float[] gy, float[] gz, float[] gw) {
int h = hash & 31;
gx[0] = grad4lut[h][0];
gy[0] = grad4lut[h][1];
gz[0] = grad4lut[h][2];
gw[0] = grad4lut[h][3];
}
/** 1D simplex noise with derivative.
* If the last argument is not null, the analytic derivative
* is also calculated.
*/
public static float sdnoise1( float x, float[] dnoise_dx)
{
int i0 = MathUtils.floor(x);
int i1 = i0 + 1;
float x0 = x - i0;
float x1 = x0 - 1.0f;
float[] gx0 = {0}, gx1 = {0};
float n0, n1;
float t20, t40, t21, t41;
float x20 = x0*x0;
float t0 = 1.0f - x20;
// if(t0 < 0.0f) t0 = 0.0f; // Never happens for 1D: x0<=1 always
t20 = t0 * t0;
t40 = t20 * t20;
grad1(perm[i0 & 0xff], gx0);
n0 = t40 * gx0[0] * x0;
float x21 = x1*x1;
float t1 = 1.0f - x21;
// if(t1 < 0.0f) t1 = 0.0f; // Never happens for 1D: |x1|<=1 always
t21 = t1 * t1;
t41 = t21 * t21;
grad1(perm[i1 & 0xff], gx1);
n1 = t41 * gx1[0] * x1;
/* Compute derivative according to:
* *dnoise_dx = -8.0f * t20 * t0 * x0 * (gx0 * x0) + t40 * gx0;
* *dnoise_dx += -8.0f * t21 * t1 * x1 * (gx1 * x1) + t41 * gx1;
*/
dnoise_dx[0] = t20 * t0 * gx0[0] * x20;
dnoise_dx[0] += t21 * t1 * gx1[0] * x21;
dnoise_dx[0] *= -8.0f;
dnoise_dx[0] += t40 * gx0[0] + t41 * gx1[0];
dnoise_dx[0] *= 0.25f; /* Scale derivative to match the noise scaling */
// The maximum value of this noise is 8*(3/4)^4 = 2.53125
// A factor of 0.395 would scale to fit exactly within [-1,1], but
// to better match classic Perlin noise, we scale it down some more.
return 0.25f * (n0 + n1);
}
/* Skewing factors for 2D simplex grid:
* F2 = 0.5*(sqrt(3.0)-1.0)
* G2 = (3.0-Math.sqrt(3.0))/6.0
*/
private static final float F2 = 0.366025403f;
private static final float G2 = 0.211324865f;
/** 2D simplex noise with derivatives.
* If the last two arguments are not null, the analytic derivative
* (the 2D gradient of the scalar noise field) is also calculated.
*/
public static float sdnoise2( float x, float y, float[] dnoise_dx, float[] dnoise_dy )
{
float n0, n1, n2; /* Noise contributions from the three simplex corners */
float[] gx0 = {0}, gy0 = {0}, gx1 = {0}, gy1 = {0}, gx2 = {0}, gy2 = {0}; /* Gradients at simplex corners */
/* Skew the input space to determine which simplex cell we're in */
float s = ( x + y ) * F2; /* Hairy factor for 2D */
float xs = x + s;
float ys = y + s;
int i = MathUtils.floor( xs );
int j = MathUtils.floor( ys );
float t = ( float ) ( i + j ) * G2;
float X0 = i - t; /* Unskew the cell origin back to (x,y) space */
float Y0 = j - t;
float x0 = x - X0; /* The x,y distances from the cell origin */
float y0 = y - Y0;
/* For the 2D case, the simplex shape is an equilateral triangle.
* Determine which simplex we are in. */
int i1, j1; /* Offsets for second (middle) corner of simplex in (i,j) coords */
if( x0 > y0 ) { i1 = 1; j1 = 0; } /* lower triangle, XY order: (0,0)->(1,0)->(1,1) */
else { i1 = 0; j1 = 1; } /* upper triangle, YX order: (0,0)->(0,1)->(1,1) */
/* A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
* a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
* c = (3-sqrt(3))/6 */
float x1 = x0 - i1 + G2; /* Offsets for middle corner in (x,y) unskewed coords */
float y1 = y0 - j1 + G2;
float x2 = x0 - 1.0f + 2.0f * G2; /* Offsets for last corner in (x,y) unskewed coords */
float y2 = y0 - 1.0f + 2.0f * G2;
/* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
int ii = i & 0xff;
int jj = j & 0xff;
/* Calculate the contribution from the three corners */
float t0 = 0.5f - x0 * x0 - y0 * y0;
float t20, t40;
if( t0 < 0.0f ) t40 = t20 = t0 = n0 = gx0[0] = gy0[0] = 0.0f; /* No influence */
else {
grad2( perm[ii + perm[jj]], gx0, gy0 );
t20 = t0 * t0;
t40 = t20 * t20;
n0 = t40 * ( gx0[0] * x0 + gy0[0] * y0 );
}
float t1 = 0.5f - x1 * x1 - y1 * y1;
float t21, t41;
if( t1 < 0.0f ) t21 = t41 = t1 = n1 = gx1[0] = gy1[0] = 0.0f; /* No influence */
else {
grad2( perm[ii + i1 + perm[jj + j1]], gx1, gy1 );
t21 = t1 * t1;
t41 = t21 * t21;
n1 = t41 * ( gx1[0] * x1 + gy1[0] * y1 );
}
float t2 = 0.5f - x2 * x2 - y2 * y2;
float t22, t42;
if( t2 < 0.0f ) t42 = t22 = t2 = n2 = gx2[0] = gy2[0] = 0.0f; /* No influence */
else {
grad2( perm[ii + 1 + perm[jj + 1]], gx2, gy2 );
t22 = t2 * t2;
t42 = t22 * t22;
n2 = t42 * ( gx2[0] * x2 + gy2[0] * y2 );
}
/* Add contributions from each corner to get the final noise value.
* The result is scaled to return values in the interval [-1,1]. */
float noise = 40.0f * ( n0 + n1 + n2 );
/* Compute derivative, if requested by supplying non-null pointers
* for the last two arguments */
if( ( dnoise_dx != null ) && ( dnoise_dy != null ) )
{
/* A straight, unoptimised calculation would be like:
* *dnoise_dx = -8.0f * t20 * t0 * x0 * ( gx0 * x0 + gy0 * y0 ) + t40 * gx0;
* *dnoise_dy = -8.0f * t20 * t0 * y0 * ( gx0 * x0 + gy0 * y0 ) + t40 * gy0;
* *dnoise_dx += -8.0f * t21 * t1 * x1 * ( gx1 * x1 + gy1 * y1 ) + t41 * gx1;
* *dnoise_dy += -8.0f * t21 * t1 * y1 * ( gx1 * x1 + gy1 * y1 ) + t41 * gy1;
* *dnoise_dx += -8.0f * t22 * t2 * x2 * ( gx2 * x2 + gy2 * y2 ) + t42 * gx2;
* *dnoise_dy += -8.0f * t22 * t2 * y2 * ( gx2 * x2 + gy2 * y2 ) + t42 * gy2;
*/
float temp0 = t20 * t0 * ( gx0[0] * x0 + gy0[0] * y0 );
dnoise_dx[0] = temp0 * x0;
dnoise_dy[0] = temp0 * y0;
float temp1 = t21 * t1 * ( gx1[0] * x1 + gy1[0] * y1 );
dnoise_dx[0] += temp1 * x1;
dnoise_dy[0] += temp1 * y1;
float temp2 = t22 * t2 * ( gx2[0] * x2 + gy2[0] * y2 );
dnoise_dx[0] += temp2 * x2;
dnoise_dy[0] += temp2 * y2;
dnoise_dx[0] *= -8.0f;
dnoise_dy[0] *= -8.0f;
dnoise_dx[0] += t40 * gx0[0] + t41 * gx1[0] + t42 * gx2[0];
dnoise_dy[0] += t40 * gy0[0] + t41 * gy1[0] + t42 * gy2[0];
dnoise_dx[0] *= 40.0f; /* Scale derivative to match the noise scaling */
dnoise_dy[0] *= 40.0f;
}
return noise;
}
/* Skewing factors for 3D simplex grid:
* F3 = 1/3
* G3 = 1/6 */
public static final float F3 = 0.333333333f;
public static final float G3 = 0.166666667f;
/** 3D simplex noise with derivatives.
* If the last tthree arguments are not null, the analytic derivative
* (the 3D gradient of the scalar noise field) is also calculated.
*/
public static float sdnoise3( float x, float y, float z,
float[] noiseGradient )
{
float n0, n1, n2, n3; /* Noise contributions from the four simplex corners */
float noise; /* Return value */
float[] gx0 = {0}, gy0 = {0}, gz0 = {0}, gx1 = {0}, gy1 = {0}, gz1 = {0}; /* Gradients at simplex corners */
float[] gx2 = {0}, gy2 = {0}, gz2 = {0}, gx3 = {0}, gy3 = {0}, gz3 = {0};
/* Skew the input space to determine which simplex cell we're in */
float s = (x+y+z)*F3; /* Very nice and simple skew factor for 3D */
float xs = x+s;
float ys = y+s;
float zs = z+s;
int i = MathUtils.floor(xs);
int j = MathUtils.floor(ys);
int k = MathUtils.floor(zs);
float t = (float)(i+j+k)*G3;
float X0 = i-t; /* Unskew the cell origin back to (x,y,z) space */
float Y0 = j-t;
float Z0 = k-t;
float x0 = x-X0; /* The x,y,z distances from the cell origin */
float y0 = y-Y0;
float z0 = z-Z0;
/* For the 3D case, the simplex shape is a slightly irregular tetrahedron.
* Determine which simplex we are in. */
int i1, j1, k1; /* Offsets for second corner of simplex in (i,j,k) coords */
int i2, j2, k2; /* Offsets for third corner of simplex in (i,j,k) coords */
/* TODO: This code would benefit from a backport from the GLSL version! */
if(x0>=y0) {
if(y0>=z0)
{ i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; } /* X Y Z order */
else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; } /* X Z Y order */
else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; } /* Z X Y order */
}
else { // x0<y0
if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; } /* Z Y X order */
else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; } /* Y Z X order */
else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; } /* Y X Z order */
}
/* 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. */
float x1 = x0 - i1 + G3; /* Offsets for second corner in (x,y,z) coords */
float y1 = y0 - j1 + G3;
float z1 = z0 - k1 + G3;
float x2 = x0 - i2 + 2.0f * G3; /* Offsets for third corner in (x,y,z) coords */
float y2 = y0 - j2 + 2.0f * G3;
float z2 = z0 - k2 + 2.0f * G3;
float x3 = x0 - 1.0f + 3.0f * G3; /* Offsets for last corner in (x,y,z) coords */
float y3 = y0 - 1.0f + 3.0f * G3;
float z3 = z0 - 1.0f + 3.0f * G3;
/* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
int ii = i & 0xff;
int jj = j & 0xff;
int kk = k & 0xff;
/* Calculate the contribution from the four corners */
float t0 = 0.6f - x0*x0 - y0*y0 - z0*z0;
float t20, t40;
if(t0 < 0.0f) n0 = t0 = t20 = t40 = gx0[0] = gy0[0] = gz0[0] = 0.0f;
else {
grad3( perm[ii + perm[jj + perm[kk]]], gx0, gy0, gz0 );
t20 = t0 * t0;
t40 = t20 * t20;
n0 = t40 * ( gx0[0] * x0 + gy0[0] * y0 + gz0[0] * z0 );
}
float t1 = 0.6f - x1*x1 - y1*y1 - z1*z1;
float t21, t41;
if(t1 < 0.0f) n1 = t1 = t21 = t41 = gx1[0] = gy1[0] = gz1[0] = 0.0f;
else {
grad3( perm[ii + i1 + perm[jj + j1 + perm[kk + k1]]], gx1, gy1, gz1 );
t21 = t1 * t1;
t41 = t21 * t21;
n1 = t41 * ( gx1[0] * x1 + gy1[0] * y1 + gz1[0] * z1 );
}
float t2 = 0.6f - x2*x2 - y2*y2 - z2*z2;
float t22, t42;
if(t2 < 0.0f) n2 = t2 = t22 = t42 = gx2[0] = gy2[0] = gz2[0] = 0.0f;
else {
grad3( perm[ii + i2 + perm[jj + j2 + perm[kk + k2]]], gx2, gy2, gz2 );
t22 = t2 * t2;
t42 = t22 * t22;
n2 = t42 * ( gx2[0] * x2 + gy2[0] * y2 + gz2[0] * z2 );
}
float t3 = 0.6f - x3*x3 - y3*y3 - z3*z3;
float t23, t43;
if(t3 < 0.0f) n3 = t3 = t23 = t43 = gx3[0] = gy3[0] = gz3[0] = 0.0f;
else {
grad3( perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]], gx3, gy3, gz3 );
t23 = t3 * t3;
t43 = t23 * t23;
n3 = t43 * ( gx3[0] * x3 + gy3[0] * y3 + gz3[0] * z3 );
}
/* Add contributions from each corner to get the final noise value.
* The result is scaled to return values in the range [-1,1] */
noise = 28.0f * (n0 + n1 + n2 + n3);
/* Compute derivative, if requested by supplying non-null pointers
* for the last three arguments */
if ( noiseGradient != null)
{
/* A straight, unoptimised calculation would be like:
* *dnoise_dx = -8.0f * t20 * t0 * x0 * dot(gx0, gy0, gz0, x0, y0, z0) + t40 * gx0;
* *dnoise_dy = -8.0f * t20 * t0 * y0 * dot(gx0, gy0, gz0, x0, y0, z0) + t40 * gy0;
* *dnoise_dz = -8.0f * t20 * t0 * z0 * dot(gx0, gy0, gz0, x0, y0, z0) + t40 * gz0;
* *dnoise_dx += -8.0f * t21 * t1 * x1 * dot(gx1, gy1, gz1, x1, y1, z1) + t41 * gx1;
* *dnoise_dy += -8.0f * t21 * t1 * y1 * dot(gx1, gy1, gz1, x1, y1, z1) + t41 * gy1;
* *dnoise_dz += -8.0f * t21 * t1 * z1 * dot(gx1, gy1, gz1, x1, y1, z1) + t41 * gz1;
* *dnoise_dx += -8.0f * t22 * t2 * x2 * dot(gx2, gy2, gz2, x2, y2, z2) + t42 * gx2;
* *dnoise_dy += -8.0f * t22 * t2 * y2 * dot(gx2, gy2, gz2, x2, y2, z2) + t42 * gy2;
* *dnoise_dz += -8.0f * t22 * t2 * z2 * dot(gx2, gy2, gz2, x2, y2, z2) + t42 * gz2;
* *dnoise_dx += -8.0f * t23 * t3 * x3 * dot(gx3, gy3, gz3, x3, y3, z3) + t43 * gx3;
* *dnoise_dy += -8.0f * t23 * t3 * y3 * dot(gx3, gy3, gz3, x3, y3, z3) + t43 * gy3;
* *dnoise_dz += -8.0f * t23 * t3 * z3 * dot(gx3, gy3, gz3, x3, y3, z3) + t43 * gz3;
*/
float temp0 = t20 * t0 * ( gx0[0] * x0 + gy0[0] * y0 + gz0[0] * z0 );
noiseGradient[0] = temp0 * x0;
noiseGradient[1] = temp0 * y0;
noiseGradient[2] = temp0 * z0;
float temp1 = t21 * t1 * ( gx1[0] * x1 + gy1[0] * y1 + gz1[0] * z1 );
noiseGradient[0] += temp1 * x1;
noiseGradient[1] += temp1 * y1;
noiseGradient[2] += temp1 * z1;
float temp2 = t22 * t2 * ( gx2[0] * x2 + gy2[0] * y2 + gz2[0] * z2 );
noiseGradient[0] += temp2 * x2;
noiseGradient[1] += temp2 * y2;
noiseGradient[2] += temp2 * z2;
float temp3 = t23 * t3 * ( gx3[0] * x3 + gy3[0] * y3 + gz3[0] * z3 );
noiseGradient[0] += temp3 * x3;
noiseGradient[1] += temp3 * y3;
noiseGradient[2] += temp3 * z3;
noiseGradient[0] *= -8.0f;
noiseGradient[1] *= -8.0f;
noiseGradient[2] *= -8.0f;
noiseGradient[0] += t40 * gx0[0] + t41 * gx1[0] + t42 * gx2[0] + t43 * gx3[0];
noiseGradient[1] += t40 * gy0[0] + t41 * gy1[0] + t42 * gy2[0] + t43 * gy3[0];
noiseGradient[2] += t40 * gz0[0] + t41 * gz1[0] + t42 * gz2[0] + t43 * gz3[0];
noiseGradient[0] *= 28.0f; /* Scale derivative to match the noise scaling */
noiseGradient[1] *= 28.0f;
noiseGradient[2] *= 28.0f;
}
return noise;
}
public static float noise3d (float x, float y, float z, float lacunarity, int octaves, float[] gradient)
{
float[] exponentArray = new float[octaves];
float frequency = 1.0f;
float H = 0.25f;
float offset = 0.7f;
float weight = 1.0f;
float max = 0.0f;
float result = 0.0f;
for (int i = 0; i < octaves; i++) {
exponentArray[i] = (float) Math.pow(frequency, -H);
frequency *= lacunarity;
}
for (int i = 0; i < octaves; i++) {
float _signal = (sdnoise3(x, y, z, gradient) + offset) * exponentArray[i];
if (weight > 1.0) {
weight = 1.0f;
}
result += (weight * _signal);
max += exponentArray[i];
weight *= _signal;
x *= lacunarity;
z *= lacunarity;
}
return result / max;
}
public static float noise(float x, float y, float z, float frequency, float amplitude, int octaves, float scale, boolean normalized, float[] gradient) {
float result = 0;
float amp = 1;
float freq = 1;
float max = 0;
float[] tempGradient = null;
if (gradient != null) tempGradient = new float[3];
x *= scale;
y *= scale;
z *= scale;
for (int i = 0; i < octaves; i++) {
result += sdnoise3(x * freq, y * freq, z * freq, tempGradient) * amp;
if (gradient != null)
{
gradient[0] += tempGradient[0] * amp;
gradient[1] += tempGradient[1] * amp;
gradient[2] += tempGradient[2] * amp;
}
max += amp;
freq *= frequency;
amp *= amplitude;
}
if (normalized) {
result /= max;
}
if (gradient != null)
{
float len = Vector3.len(gradient[0], gradient[1], gradient[2]);
gradient[0] /= len;
gradient[1] /= len;
gradient[2] /= len;
}
return result;
}
}