public float noise(Vector2 p)
{
// get shared & individual constants
// get int base
int x0 = Mathf.FloorToInt(p.x);
int y0 = Mathf.FloorToInt(p.y);
// get displacements
float dx0 = p.x - x0;
float dy0 = p.y - y0;
float dx1 = dx0 - 1f;
float dy1 = dy0 - 1f;
x0 &= m;
y0 &= m;
// Step 3 & 4: first get p00, p01, p10, and p11
int x1 = x0 + 1;
int y1 = y0 + 1;
int _0 = h [x0];
int _1 = h [x1];
int _00 = h [_0 + y0]; // h(p00)
int _01 = h [_0 + y1]; // h(p01)
int _10 = h [_1 + y0]; // h(p10)
int _11 = h [_1 + y1]; // h(p11)
dx0 = M.Fade(dx0); // must be in [0, 1] range
dy0 = M.Fade(dy0);
p_00 [0] = dx0;
p_00 [1] = dy0;
p_01 [0] = dx0;
p_01 [1] = dy1;
p_10 [0] = dx1;
p_10 [1] = dy0;
p_11 [0] = dx1;
p_11 [1] = dy1;
// u = h'(p00)p dot h (p00)
// here, p is (dx0, dy0)
// and h'(p00) is h'(h(p00))
float p1 = Mathf.Lerp(M.Dot(g [h [_00] & gm], e [_00] * p_00[0], e[_00] * p_00[1]),
M.Dot(g [h [_10] & gm], e [_10] * p_10[0], e[_10] * p_10[1]), dx0);
// v = h'(p01)p * h(p01)
// Step 6&8
// u = (h'(p10)p) dot h (p10)
// v = h'(p11)p dot h (p11)
float p2 = Mathf.Lerp(M.Dot(g [h [_01] & gm], e [_01] * p_01[0], e[_01] * p_01[1]),
M.Dot(g [h [_11] & gm], e [_11] * p_11[0], e[_11] * p_11[1]), dx0);
return(Mathf.Lerp(p1, p2, dy0) * n * 0.5f);
}
private float assignRandom(float offset = 1f)
{
if (useGaussian)
{
return(M.Gaussian(offset));
}
return(Random.Range(0, offset));
}
// 2D Perlin noise
public float noise(Vector2 p)
{
// get int base
int x0 = Mathf.FloorToInt(p.x);
int y0 = Mathf.FloorToInt(p.y);
// get displacements
float dx0 = p.x - x0;
float dy0 = p.y - y0;
float dx1 = dx0 - 1f;
float dy1 = dy0 - 1f;
// do the masking
x0 &= m;
y0 &= m;
// get next ones over
int x1 = x0 + 1;
int y1 = y0 + 1;
// get first-level displacement on x
int _0 = h [x0];
int _1 = h [x1];
int _00 = h [_0 + y0];
int _01 = h [_0 + y1];
int _10 = h [_1 + y0];
int _11 = h [_1 + y1];
// smooth the displacements
dx0 = M.Fade(dx0);
dy0 = M.Fade(dy0);
// this is where it diverges from value noise: pick a gradient
int[] _x00 = g [h [_00] & gm];
int[] _x10 = g [h [_10] & gm];
float x00 = M.Dot(_x00, dx0, dy0); // u = p dot h[p_00]
float x10 = M.Dot(_x10, dx1, dy0); // v = p dot h[_10]
float p1 = Mathf.Lerp(x00, x10, dx0);
int[] _x01 = g [h [_01] & gm];
int[] _x11 = g [h [_11] & gm];
float x01 = M.Dot(_x01, dx0, dy1);
float x11 = M.Dot(_x11, dx1, dy1);
float p2 = Mathf.Lerp(x01, x11, dx0);
float t0 = Mathf.Lerp(p1, p2, dy0);
float prod = t0 * n;
return(prod * 0.5f);
}
// 2D noise
public float noise(Vector2 p)
{
// get int version
int x0 = Mathf.FloorToInt(p.x);
int y0 = Mathf.FloorToInt(p.y);
// get starting displacements
float dx = p.x - x0;
float dy = p.y - y0;
x0 &= m;
y0 &= m;
// get next ones over
int x1 = x0 + 1;
int y1 = y0 + 1;
// first level hashing on x
int _0 = h [x0];
int _1 = h [x1];
// second level hashing on y
int _00 = h [_0 + y0];
int _01 = h [_0 + y1];
int _10 = h [_1 + y0];
int _11 = h [_1 + y1];
// smooth the displacements
dx = M.Fade(dx);
dy = M.Fade(dy);
// interpolate between the relative points on a 2-d plane
float t1 = Mathf.Lerp(_00, _10, dx);
float t2 = Mathf.Lerp(_01, _11, dx);
float z = Mathf.Lerp(t1, t2, dy);
// normalize the restult
float prod = z * (1f / m);
return(prod - 0.5f);
}
// 3D noise
public float _noise(Vector3 p)
{
// get constants
int[] h = Constants.hash;
int m = Constants.hashMask;
int x0 = M.Floor(p.x);
int y0 = M.Floor(p.y);
int z0 = M.Floor(p.z);
// only take the most significant bits of this int
// maybe not necessary if the side of the square isn't too large?
// mask tem
x0 &= m;
y0 &= m;
z0 &= m;
// get the next adjacent point
int x1 = x0 + 1;
int y1 = y0 + 1;
int z1 = z0 + 1;
// first level hashing on x
int _0 = h [x0];
int _1 = h [x1];
// second level hashing with the appropriate closest coordinate
int _00 = h [_0 + y0];
int _10 = h [_1 + y0];
int _01 = h [_0 + y1];
int _11 = h [_1 + y1];
// third level three-dimensional coordinate hashing
int x000 = h [_00 + z0];
int x100 = h [_10 + z0];
int x010 = h [_01 + z0];
int x110 = h [_11 + z0];
int x001 = h [_00 + z1];
int x101 = h [_10 + z1];
int x011 = h [_01 + z1];
int x111 = h [_11 + z1];
// get the smoothed floor displacements
float dx = M.Fade(p.x - x0);
float dy = M.Fade(p.y - y0);
float dz = M.Fade(p.z - z0);
// Do the interpolation
float p1 = M.Lerp(x000, x100, dx);
float p2 = M.Lerp(x010, x110, dx);
float t0 = M.Lerp(p1, p2, dy);
float p3 = M.Lerp(x001, x101, dx);
float p4 = M.Lerp(x011, x111, dx);
float t1 = M.Lerp(p3, p4, dy);
float z = M.Lerp(t0, t1, dz);
// normalize the result
float prod = z / m;
return(prod);
}
// 3D NOISE
public float _noise(Vector3 p)
{
// get constants
int[] h = Constants.hash;
int m = Constants.hashMask;
int gm = hashMask3D;
int[][] g = gradients3D;
// get masked int version
int x0 = M.Floor(p.x);
int y0 = M.Floor(p.y);
int z0 = M.Floor(p.z);
// get the displacements
float dx0 = p.x - x0;
float dy0 = p.y - y0;
float dz0 = p.z - z0;
// now do the masking
x0 &= m;
y0 &= m;
z0 &= m;
// get next ones over
int x1 = x0 + 1;
int y1 = y0 + 1;
int z1 = z0 + 1;
;
// why is this subtracted by 1?
float dx1 = dx0 - 1f;
float dy1 = dy0 - 1f;
float dz1 = dz0 - 1f;
// first level hashing on x
int _0 = h [x0];
int _1 = h [x1];
// second level hashing on y
int _00 = h [_0 + y0];
int _01 = h [_0 + y1];
int _10 = h [_1 + y0];
int _11 = h [_1 + y1];
// third "level" hashing on z
int[] _000 = g [h [_00 + z0] & gm];
int[] _001 = g [h [_00 + z1] & gm];
int[] _010 = g [h [_01 + z0] & gm];
int[] _011 = g [h [_01 + z1] & gm];
int[] _100 = g [h [_10 + z0] & gm];
int[] _101 = g [h [_10 + z1] & gm];
int[] _110 = g [h [_11 + z0] & gm];
int[] _111 = g [h [_11 + z1] & gm];
// do the dot product with displacement vector in order to smooth
float x000 = M.Dot(_000, dx0, dy0, dz0);
float x001 = M.Dot(_001, dx0, dy0, dz1);
float x010 = M.Dot(_010, dx0, dy1, dz0);
float x011 = M.Dot(_011, dx0, dy1, dz1);
float x100 = M.Dot(_100, dx1, dy0, dz0);
float x101 = M.Dot(_101, dx1, dy0, dz1);
float x110 = M.Dot(_110, dx1, dy1, dz0);
float x111 = M.Dot(_111, dx1, dy1, dz1);
// smooth the original displacements
float dx = M.Fade(dx0);
float dy = M.Fade(dy0);
float dz = M.Fade(dz0);
// Do the interpolation
float p1 = M.Lerp(x000, x100, dx);
float p2 = M.Lerp(x010, x110, dx);
float t0 = M.Lerp(p1, p2, dy);
float p3 = M.Lerp(x001, x101, dx);
float p4 = M.Lerp(x011, x111, dx);
float t1 = M.Lerp(p3, p4, dy);
float res = M.Lerp(t0, t1, dz);
return(res);
}
