/** 3D float Perlin periodic noise.
*/
float pnoise3( float x, float y, float z, int px, int py, int pz )
{
int ix0, iy0, ix1, iy1, iz0, iz1;
float fx0, fy0, fz0, fx1, fy1, fz1;
float s, t, r;
float nxy0, nxy1, nx0, nx1, n0, n1;
ix0 = FASTFLOOR( x ); // Integer part of x
iy0 = FASTFLOOR( y ); // Integer part of y
iz0 = FASTFLOOR( z ); // Integer part of z
fx0 = x - ix0; // Fractional part of x
fy0 = y - iy0; // Fractional part of y
fz0 = z - iz0; // Fractional part of z
fx1 = fx0 - 1.0f;
fy1 = fy0 - 1.0f;
fz1 = fz0 - 1.0f;
ix1 = (( ix0 + 1 ) % px ) & 0xff; // Wrap to 0..px-1 and wrap to 0..255
iy1 = (( iy0 + 1 ) % py ) & 0xff; // Wrap to 0..py-1 and wrap to 0..255
iz1 = (( iz0 + 1 ) % pz ) & 0xff; // Wrap to 0..pz-1 and wrap to 0..255
ix0 = ( ix0 % px ) & 0xff;
iy0 = ( iy0 % py ) & 0xff;
iz0 = ( iz0 % pz ) & 0xff;
r = FADE( fz0 );
t = FADE( fy0 );
s = FADE( fx0 );
nxy0 = grad3(perm[ix0 + perm[iy0 + perm[iz0]]], fx0, fy0, fz0);
nxy1 = grad3(perm[ix0 + perm[iy0 + perm[iz1]]], fx0, fy0, fz1);
nx0 = LERP( r, nxy0, nxy1 );
nxy0 = grad3(perm[ix0 + perm[iy1 + perm[iz0]]], fx0, fy1, fz0);
nxy1 = grad3(perm[ix0 + perm[iy1 + perm[iz1]]], fx0, fy1, fz1);
nx1 = LERP( r, nxy0, nxy1 );
n0 = LERP( t, nx0, nx1 );
nxy0 = grad3(perm[ix1 + perm[iy0 + perm[iz0]]], fx1, fy0, fz0);
nxy1 = grad3(perm[ix1 + perm[iy0 + perm[iz1]]], fx1, fy0, fz1);
nx0 = LERP( r, nxy0, nxy1 );
nxy0 = grad3(perm[ix1 + perm[iy1 + perm[iz0]]], fx1, fy1, fz0);
nxy1 = grad3(perm[ix1 + perm[iy1 + perm[iz1]]], fx1, fy1, fz1);
nx1 = LERP( r, nxy0, nxy1 );
n1 = LERP( t, nx0, nx1 );
return 0.936f * ( LERP( s, n0, n1 ) );
}
float Perlin::noise (float x, float y, float z)
{
float fx, fy, fz;
int A, AA, AB, B, BA, BB;
// find nearest whole number to each input coordinate
int i = (int)floorf(x);
int j = (int)floorf(y);
int k = (int)floorf(z);
int ii = i + 1;
int jj = j + 1;
int kk = k + 1;
// ensure all inputs to permutation functions are between 0 and 255
i &= 0xff;
ii &= 0xff;
j &= 0xff;
jj &= 0xff;
k &= 0xff;
kk &= 0xff;
// convert each input to a number between 0 and 1
x -= floorf(x); y -= floorf(y); z -= floorf(z);
// apply easing function
fx = x*x*x * (x * (x * 6 - 15) + 10);
fy = y*y*y * (y * (y * 6 - 15) + 10);
fz = z*z*z * (z * (z * 6 - 15) + 10);
// apply permutation function
A = PERM[i];
AA = PERM[A + j];
AB = PERM[A + jj];
B = PERM[ii];
BA = PERM[B + j];
BB = PERM[B + jj];
// six linear interpolations
return lerp(fz, lerp(fy, lerp(fx, grad3(PERM[AA + k], x, y, z),
grad3(PERM[BA + k], x - 1, y, z)),
lerp(fx, grad3(PERM[AB + k], x, y - 1, z),
grad3(PERM[BB + k], x - 1, y - 1, z))),
lerp(fy, lerp(fx, grad3(PERM[AA + kk], x, y, z - 1),
grad3(PERM[BA + kk], x - 1, y, z - 1)),
lerp(fx, grad3(PERM[AB + kk], x, y - 1, z - 1),
grad3(PERM[BB + kk], x - 1, y - 1, z - 1))));
}
float
noise3(float x, float y, float z, const int repeatx, const int repeaty, const int repeatz,
const int base)
{
float fx, fy, fz;
int A, AA, AB, B, BA, BB;
int i = (int)floorf(fmodf(x, repeatx));
int j = (int)floorf(fmodf(y, repeaty));
int k = (int)floorf(fmodf(z, repeatz));
int ii = (int)fmodf(i + 1, repeatx);
int jj = (int)fmodf(j + 1, repeaty);
int kk = (int)fmodf(k + 1, repeatz);
i = (i & 255) + base;
j = (j & 255) + base;
k = (k & 255) + base;
ii = (ii & 255) + base;
jj = (jj & 255) + base;
kk = (kk & 255) + base;
x -= floorf(x); y -= floorf(y); z -= floorf(z);
fx = x*x*x * (x * (x * 6 - 15) + 10);
fy = y*y*y * (y * (y * 6 - 15) + 10);
fz = z*z*z * (z * (z * 6 - 15) + 10);
A = PERM[i];
AA = PERM[A + j];
AB = PERM[A + jj];
B = PERM[ii];
BA = PERM[B + j];
BB = PERM[B + jj];
return lerp(fz, lerp(fy, lerp(fx, grad3(PERM[AA + k], x, y, z),
grad3(PERM[BA + k], x - 1, y, z)),
lerp(fx, grad3(PERM[AB + k], x, y - 1, z),
grad3(PERM[BB + k], x - 1, y - 1, z))),
lerp(fy, lerp(fx, grad3(PERM[AA + kk], x, y, z - 1),
grad3(PERM[BA + kk], x - 1, y, z - 1)),
lerp(fx, grad3(PERM[AB + kk], x, y - 1, z - 1),
grad3(PERM[BB + kk], x - 1, y - 1, z - 1))));
}
/* 3D simplex noise */
GLfloat _slang_library_noise3 (GLfloat x, GLfloat y, GLfloat z)
{
/* Simple skewing factors for the 3D case */
#define F3 0.333333333f
#define G3 0.166666667f
float n0, n1, n2, n3; /* Noise contributions from the four corners */
/* 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 = FASTFLOOR(xs);
int j = FASTFLOOR(ys);
int k = FASTFLOOR(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;
float x1, y1, z1, x2, y2, z2, x3, y3, z3;
int ii, jj, kk;
float t0, t1, t2, t3;
/* 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 */
/* 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. */
x1 = x0 - i1 + G3; /* Offsets for second corner in (x,y,z) coords */
y1 = y0 - j1 + G3;
z1 = z0 - k1 + G3;
x2 = x0 - i2 + 2.0f*G3; /* Offsets for third corner in (x,y,z) coords */
y2 = y0 - j2 + 2.0f*G3;
z2 = z0 - k2 + 2.0f*G3;
x3 = x0 - 1.0f + 3.0f*G3; /* Offsets for last corner in (x,y,z) coords */
y3 = y0 - 1.0f + 3.0f*G3;
z3 = z0 - 1.0f + 3.0f*G3;
/* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
ii = i % 256;
jj = j % 256;
kk = k % 256;
/* Calculate the contribution from the four corners */
t0 = 0.6f - x0*x0 - y0*y0 - z0*z0;
if(t0 < 0.0f) n0 = 0.0f;
else {
t0 *= t0;
n0 = t0 * t0 * grad3(perm[ii+perm[jj+perm[kk]]], x0, y0, z0);
}
t1 = 0.6f - x1*x1 - y1*y1 - z1*z1;
if(t1 < 0.0f) n1 = 0.0f;
else {
t1 *= t1;
n1 = t1 * t1 * grad3(perm[ii+i1+perm[jj+j1+perm[kk+k1]]], x1, y1, z1);
}
t2 = 0.6f - x2*x2 - y2*y2 - z2*z2;
if(t2 < 0.0f) n2 = 0.0f;
else {
t2 *= t2;
n2 = t2 * t2 * grad3(perm[ii+i2+perm[jj+j2+perm[kk+k2]]], x2, y2, z2);
}
t3 = 0.6f - x3*x3 - y3*y3 - z3*z3;
if(t3<0.0f) n3 = 0.0f;
else {
t3 *= t3;
n3 = t3 * t3 * grad3(perm[ii+1+perm[jj+1+perm[kk+1]]], x3, y3, z3);
}
/* Add contributions from each corner to get the final noise value. */
/* The result is scaled to stay just inside [-1,1] */
return 32.0f * (n0 + n1 + n2 + n3); /* TODO: The scale factor is preliminary! */
}
void AbstractWheelWidget::paintEvent(QPaintEvent* event)
{
Q_UNUSED( event );
// -- first calculate size and position.
int w = width();
int h = height();
QPainter painter(this);
QPalette palette = QApplication::palette();
QPalette::ColorGroup colorGroup = isEnabled() ? QPalette::Active : QPalette::Disabled;
// linear gradient brush
QLinearGradient grad(0.5, 0, 0.5, 1.0);
grad.setColorAt(0, palette.color(colorGroup, QPalette::ButtonText));
grad.setColorAt(0.2, palette.color(colorGroup, QPalette::Button));
grad.setColorAt(0.8, palette.color(colorGroup, QPalette::Button));
grad.setColorAt(1.0, palette.color(colorGroup, QPalette::ButtonText));
grad.setCoordinateMode( QGradient::ObjectBoundingMode );
QBrush gBrush( grad );
// paint a border and background
painter.setPen(palette.color(colorGroup, QPalette::ButtonText));
painter.setBrush(gBrush);
// painter.setBrushOrigin( QPointF( 0.0, 0.0 ) );
painter.drawRect( 0, 0, w-1, h-1 );
// paint inner border
painter.setPen(palette.color(colorGroup, QPalette::Button));
painter.setBrush(Qt::NoBrush);
painter.drawRect( 1, 1, w-3, h-3 );
// paint the items
painter.setClipRect( QRect( 3, 3, w-6, h-6 ) );
painter.setPen(palette.color(colorGroup, QPalette::ButtonText));
int iH = itemHeight();
int iC = itemCount();
if (iC > 0) {
m_itemOffset = m_itemOffset % iH;
for (int i=-h/2/iH; i<=h/2/iH+1; i++) {
int itemNum = m_currentItem + i;
while (itemNum < 0)
itemNum += iC;
while (itemNum >= iC)
itemNum -= iC;
paintItem(&painter, itemNum, QRect(6, h/2 +i*iH - m_itemOffset - iH/2, w-6, iH ));
}
}
// draw a transparent bar over the center
QColor highlight = palette.color(colorGroup, QPalette::Highlight);
highlight.setAlpha(150);
QLinearGradient grad2(0.5, 0, 0.5, 1.0);
grad2.setColorAt(0, highlight);
grad2.setColorAt(1.0, highlight.lighter());
grad2.setCoordinateMode( QGradient::ObjectBoundingMode );
QBrush gBrush2( grad2 );
QLinearGradient grad3(0.5, 0, 0.5, 1.0);
grad3.setColorAt(0, highlight);
grad3.setColorAt(1.0, highlight.darker());
grad3.setCoordinateMode( QGradient::ObjectBoundingMode );
QBrush gBrush3( grad3 );
painter.fillRect( QRect( 0, h/2 - iH/2, w, iH/2 ), gBrush2 );
painter.fillRect( QRect( 0, h/2, w, iH/2 ), gBrush3 );
}
/** 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.
*/
float sdnoise3( float x, float y, float z,
float *dnoise_dx, float *dnoise_dy, float *dnoise_dz )
{
float n0, n1, n2, n3; /* Noise contributions from the four simplex corners */
float noise; /* Return value */
float gx0, gy0, gz0, gx1, gy1, gz1; /* Gradients at simplex corners */
float gx2, gy2, gz2, gx3, gy3, gz3;
/* 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 = FASTFLOOR(xs);
int j = FASTFLOOR(ys);
int k = FASTFLOOR(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 % 256;
int jj = j % 256;
int kk = k % 256;
/* 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 = gy0 = gz0 = 0.0f;
else {
grad3( perm[ii + perm[jj + perm[kk]]], &gx0, &gy0, &gz0 );
t20 = t0 * t0;
t40 = t20 * t20;
n0 = t40 * ( gx0 * x0 + gy0 * y0 + gz0 * z0 );
}
float t1 = 0.6f - x1*x1 - y1*y1 - z1*z1;
float t21, t41;
if(t1 < 0.0f) n1 = t1 = t21 = t41 = gx1 = gy1 = gz1 = 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 * x1 + gy1 * y1 + gz1 * z1 );
}
float t2 = 0.6f - x2*x2 - y2*y2 - z2*z2;
float t22, t42;
if(t2 < 0.0f) n2 = t2 = t22 = t42 = gx2 = gy2 = gz2 = 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 * x2 + gy2 * y2 + gz2 * z2 );
}
float t3 = 0.6f - x3*x3 - y3*y3 - z3*z3;
float t23, t43;
if(t3 < 0.0f) n3 = t3 = t23 = t43 = gx3 = gy3 = gz3 = 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 * x3 + gy3 * y3 + gz3 * 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( ( dnoise_dx != 0 ) && ( dnoise_dy != 0 ) && ( dnoise_dz != 0 ))
{
/* 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 * x0 + gy0 * y0 + gz0 * z0 );
*dnoise_dx = temp0 * x0;
*dnoise_dy = temp0 * y0;
*dnoise_dz = temp0 * z0;
float temp1 = t21 * t1 * ( gx1 * x1 + gy1 * y1 + gz1 * z1 );
*dnoise_dx += temp1 * x1;
*dnoise_dy += temp1 * y1;
*dnoise_dz += temp1 * z1;
float temp2 = t22 * t2 * ( gx2 * x2 + gy2 * y2 + gz2 * z2 );
*dnoise_dx += temp2 * x2;
*dnoise_dy += temp2 * y2;
*dnoise_dz += temp2 * z2;
float temp3 = t23 * t3 * ( gx3 * x3 + gy3 * y3 + gz3 * z3 );
*dnoise_dx += temp3 * x3;
*dnoise_dy += temp3 * y3;
*dnoise_dz += temp3 * z3;
*dnoise_dx *= -8.0f;
*dnoise_dy *= -8.0f;
*dnoise_dz *= -8.0f;
*dnoise_dx += t40 * gx0 + t41 * gx1 + t42 * gx2 + t43 * gx3;
*dnoise_dy += t40 * gy0 + t41 * gy1 + t42 * gy2 + t43 * gy3;
*dnoise_dz += t40 * gz0 + t41 * gz1 + t42 * gz2 + t43 * gz3;
*dnoise_dx *= 28.0f; /* Scale derivative to match the noise scaling */
*dnoise_dy *= 28.0f;
*dnoise_dz *= 28.0f;
}
return noise;
}
// 3D simplex noise
float snoise3(float x, float y, float z) {
// Simple skewing factors for the 3D case
#define F3 0.333333333
#define G3 0.166666667
float n0, n1, n2, n3; // Noise contributions from the four corners
// 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 = FASTFLOOR(xs);
int j = FASTFLOOR(ys);
int k = FASTFLOOR(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
/* 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;
if(t0 < 0.0f) n0 = 0.0f;
else {
t0 *= t0;
n0 = t0 * t0 * grad3(perm[ii+perm[jj+perm[kk]]], x0, y0, z0);
}
float t1 = 0.6f - x1*x1 - y1*y1 - z1*z1;
if(t1 < 0.0f) n1 = 0.0f;
else {
t1 *= t1;
n1 = t1 * t1 * grad3(perm[ii+i1+perm[jj+j1+perm[kk+k1]]], x1, y1, z1);
}
float t2 = 0.6f - x2*x2 - y2*y2 - z2*z2;
if(t2 < 0.0f) n2 = 0.0f;
else {
t2 *= t2;
n2 = t2 * t2 * grad3(perm[ii+i2+perm[jj+j2+perm[kk+k2]]], x2, y2, z2);
}
float t3 = 0.6f - x3*x3 - y3*y3 - z3*z3;
if(t3<0.0f) n3 = 0.0f;
else {
t3 *= t3;
n3 = t3 * t3 * grad3(perm[ii+1+perm[jj+1+perm[kk+1]]], x3, y3, z3);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to stay just inside [-1,1]
return 32.0f * (n0 + n1 + n2 + n3); // TODO: The scale factor is preliminary!
}
