float Noise::smoothNoise3(Vec3f &vec)
{
int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
int i, j;
SETUP(vec.x(), bx0, bx1, rx0, rx1);
SETUP(vec.y(), by0, by1, ry0, ry1);
SETUP(vec.z(), bz0, bz1, rz0, rz1);
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
t = SCURVE(rx0);
sy = SCURVE(ry0);
sz = SCURVE(rz0);
#define AT3(rx, ry, rz) ((rx)*q[0] + (ry)*q[1] + (rz)*q[2])
q = g3[b00 + bz0];
u = AT3(rx0, ry0, rz0);
q = g3[b10 + bz0];
v = AT3(rx1, ry0, rz0);
a = LERP(t, u, v);
q = g3[b01 + bz0];
u = AT3(rx0, ry1, rz0);
q = g3[b11 + bz0];
v = AT3(rx1, ry1, rz0);
b = LERP(t, u, v);
c = LERP(sy, a, b);
q = g3[b00 + bz1];
u = AT3(rx0, ry0, rz1);
q = g3[b10 + bz1];
v = AT3(rx1, ry0, rz1);
a = LERP(t, u, v);
q = g3[b01 + bz1];
u = AT3(rx0, ry1, rz1);
q = g3[b11 + bz1];
v = AT3(rx1, ry1, rz1);
b = LERP(t, u, v);
d = LERP(sy, a, b);
#undef AT3
return LERP(sz, c, d);
}
float Noise::smoothNoise2(Vec2f &vec)
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
int i, j;
SETUP(vec.x(), bx0, bx1, rx0, rx1);
SETUP(vec.y(), by0, by1, ry0, ry1);
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = SCURVE(rx0);
sy = SCURVE(ry0);
#define AT2(rx, ry) ((rx)*q[0] + (ry)*q[1])
q = g2[b00];
u = AT2(rx0, ry0);
q = g2[b10];
v = AT2(rx1, ry0);
a = LERP(sx, u, v);
q = g2[b01];
u = AT2(rx0, ry1);
q = g2[b11];
v = AT2(rx1, ry1);
b = LERP(sx, u, v);
#undef AT2
return LERP(sy, a, b);
}
// Noise functions over 1, 2, and 3 dimensions
float Noise::smoothNoise1(float arg)
{
int bx0, bx1;
float rx0, rx1, sx, t, u, v, vec;
vec = arg;
SETUP(vec, bx0, bx1, rx0, rx1);
sx = SCURVE(rx0);
u = rx0 * g1[p[bx0]];
v = rx1 * g1[p[bx1]];
return LERP(sx, u, v);
}
/*************
* DESCRIPTION: Vector-valued noise function
* INPUT: v noise position
* r result vector
* OUTPUT: none
*************/
void DNoise(VECTOR *v, VECTOR *r, short *hashTable)
{
int ix, iy, iz, jx, jy, jz;
float x, y, z;
float px, py, pz, s;
float sx, sy, sz, tx, ty, tz;
short m;
float tytz,sxsy,tysz,txsy;
float *incrsum_tmp;
/* ensures the values are positive. */
x = v->x - MINX;
y = v->y - MINY;
z = v->z - MINZ;
/* its equivalent integer lattice point. */
ix = (int)floor(x);
iy = (int)floor(y);
iz = (int)floor(z);
jx = ix + 1;
jy = iy + 1;
jz = iz + 1;
sx = SCURVE(x - ix);
sy = SCURVE(y - iy);
sz = SCURVE(z - iz);
/* the complement values of sx,sy,sz */
tx = 1.f - sx;
ty = 1.f - sy;
tz = 1.f - sz;
tytz = ty*tz;
sxsy = sx*sy;
tysz = ty*sz;
txsy = tx*sy;
/*
* interpolate!
*/
m = Hash3d( ix, iy, iz ) & 0xFF;
px = x-ix; py = y-iy; pz = z-iz;
s = tx*tytz;
INCRSUM(r->x=, m, s,px,py,pz);
INCRSUM(r->y=, m+4,s,px,py,pz);
INCRSUM(r->z=, m+8,s,px,py,pz);
m = Hash3d( jx, iy, iz ) & 0xFF;
px = x-jx;
s = sx*tytz;
INCRSUM(r->x+=, m, s,px,py,pz);
INCRSUM(r->y+=, m+4,s,px,py,pz);
INCRSUM(r->z+=, m+8,s,px,py,pz);
m = Hash3d( jx, jy, iz ) & 0xFF;
py = y-jy;
s = sxsy*tz;
INCRSUM(r->x+=, m, s,px,py,pz);
INCRSUM(r->y+=, m+4,s,px,py,pz);
INCRSUM(r->z+=, m+8,s,px,py,pz);
m = Hash3d( ix, jy, iz ) & 0xFF;
px = x-ix;
s = txsy*tz;
INCRSUM(r->x+=, m, s,px,py,pz);
INCRSUM(r->y+=, m+4,s,px,py,pz);
INCRSUM(r->z+=, m+8,s,px,py,pz);
m = Hash3d( ix, jy, jz ) & 0xFF;
pz = z-jz;
s = txsy*sz;
INCRSUM(r->x+=, m, s,px,py,pz);
INCRSUM(r->y+=, m+4,s,px,py,pz);
INCRSUM(r->z+=, m+8,s,px,py,pz);
m = Hash3d( jx, jy, jz ) & 0xFF;
px = x-jx;
s = sxsy*sz;
INCRSUM(r->x+=, m, s,px,py,pz);
INCRSUM(r->y+=, m+4,s,px,py,pz);
INCRSUM(r->z+=, m+8,s,px,py,pz);
m = Hash3d( jx, iy, jz ) & 0xFF;
py = y-iy;
s = sx*tysz;
INCRSUM(r->x+=, m, s,px,py,pz);
INCRSUM(r->y+=, m+4,s,px,py,pz);
INCRSUM(r->z+=, m+8,s,px,py,pz);
m = Hash3d( ix, iy, jz ) & 0xFF;
px = x-ix;
s = tx*tysz;
INCRSUM(r->x+=, m, s,px,py,pz);
INCRSUM(r->y+=, m+4,s,px,py,pz);
INCRSUM(r->z+=, m+8,s,px,py,pz);
}
/*************
* DESCRIPTION: Noise function
* INPUT: v noise position
* OUTPUT: noise
*************/
float Noise(VECTOR *v, short *hashTable)
{
int ix, iy, iz, jx, jy, jz;
float x, y, z;
float sx, sy, sz, tx, ty, tz;
float sum,sum1,sum2, sumj,sumj1,sumj2, res;
short m;
float t,s,ts1,ts2;
float *incrsum_tmp;
/* ensures the values are positive. */
x = v->x - MINX;
y = v->y - MINY;
z = v->z - MINZ;
/* its equivalent integer lattice point. */
ix = (int)floor(x);
iy = (int)floor(y);
iz = (int)floor(z);
jx = ix + 1;
jy = iy + 1;
jz = iz + 1;
sum = x - ix;
sumj = x - jx;
sx = SCURVE(sum);
sum1 = y - iy;
sumj1 = y - jy;
sy = SCURVE(sum1);
sum2 = z - iz;
sumj2 = z - jz;
sz = SCURVE(sum2);
/* the complement values of sx,sy,sz */
tx = 1.f - sx;
ty = 1.f - sy;
tz = 1.f - sz;
t = ty*tz;
s = sx*sy;
ts1 = ty*sz;
ts2 = tx*sy;
m = Hash3d( ix, iy, iz ) & 0xFF;
INCRSUM(res= , m, (tx*t), sum, sum1, sum2);
m = Hash3d( jx, iy, iz ) & 0xFF;
INCRSUM(res+=, m, (sx*t), sumj, sum1, sum2);
m = Hash3d( ix, jy, iz ) & 0xFF;
INCRSUM(res+=, m, (ts2*tz), sum, sumj1, sum2);
m = Hash3d( jx, jy, iz ) & 0xFF;
INCRSUM(res+=, m, (s*tz), sumj, sumj1, sum2);
m = Hash3d( ix, iy, jz ) & 0xFF;
INCRSUM(res+=, m, (tx*ts1), sum, sum1, sumj2);
m = Hash3d( jx, iy, jz ) & 0xFF;
INCRSUM(res+=, m, (sx*ts1), sumj, sum1, sumj2);
m = Hash3d( ix, jy, jz ) & 0xFF;
INCRSUM(res+=, m, (ts2*sz), sum, sumj1, sumj2);
m = Hash3d( jx, jy, jz ) & 0xFF;
INCRSUM(res+=, m, (s*sz), sumj, sumj1, sumj2);
return res;
}
