+
+float noise3d_perlin(float x, float y, float z, int seed,
+ int octaves, float persistence, bool eased)
+{
+ float a = 0;
+ float f = 1.0;
+ float g = 1.0;
+ for (int i = 0; i < octaves; i++)
+ {
+ a += g * noise3d_gradient(x * f, y * f, z * f, seed + i, eased);
+ f *= 2.0;
+ g *= persistence;
+ }
+ return a;
+}
+
+
+float noise3d_perlin_abs(float x, float y, float z, int seed,
+ int octaves, float persistence, bool eased)
+{
+ float a = 0;
+ float f = 1.0;
+ float g = 1.0;
+ for (int i = 0; i < octaves; i++)
+ {
+ a += g * fabs(noise3d_gradient(x * f, y * f, z * f, seed + i, eased));
+ f *= 2.0;
+ g *= persistence;
+ }
+ return a;
+}
+
+
+float contour(float v)
+{
+ v = fabs(v);
+ if(v >= 1.0)
+ return 0.0;
+ return (1.0 - v);
+}
+
+
+///////////////////////// [ New perlin stuff ] ////////////////////////////
+
+
+Noise::Noise(NoiseParams *np, int seed, int sx, int sy, int sz)
+{
+ this->np = np;
+ this->seed = seed;
+ this->sx = sx;
+ this->sy = sy;
+ this->sz = sz;
+
+ this->noisebuf = NULL;
+ resizeNoiseBuf(sz > 1);
+
+ this->buf = new float[sx * sy * sz];
+ this->result = new float[sx * sy * sz];
+}
+
+
+Noise::~Noise()
+{
+ delete[] buf;
+ delete[] result;
+ delete[] noisebuf;
+}
+
+
+void Noise::setSize(int sx, int sy, int sz)
+{
+ this->sx = sx;
+ this->sy = sy;
+ this->sz = sz;
+
+ this->noisebuf = NULL;
+ resizeNoiseBuf(sz > 1);
+
+ delete[] buf;
+ delete[] result;
+ this->buf = new float[sx * sy * sz];
+ this->result = new float[sx * sy * sz];
+}
+
+
+void Noise::setSpreadFactor(v3f spread)
+{
+ this->np->spread = spread;
+
+ resizeNoiseBuf(sz > 1);
+}
+
+
+void Noise::setOctaves(int octaves)
+{
+ this->np->octaves = octaves;
+
+ resizeNoiseBuf(sz > 1);
+}
+
+
+void Noise::resizeNoiseBuf(bool is3d)
+{
+ int nlx, nly, nlz;
+ float ofactor;
+
+ //maximum possible spread value factor
+ ofactor = (float)(1 << (np->octaves - 1));
+
+ //noise lattice point count
+ //(int)(sz * spread * ofactor) is # of lattice points crossed due to length
+ // + 2 for the two initial endpoints
+ // + 1 for potentially crossing a boundary due to offset
+ nlx = (int)(sx * ofactor / np->spread.X) + 3;
+ nly = (int)(sy * ofactor / np->spread.Y) + 3;
+ nlz = is3d ? (int)(sz * ofactor / np->spread.Z) + 3 : 1;
+
+ if (noisebuf)
+ delete[] noisebuf;
+ noisebuf = new float[nlx * nly * nlz];
+}
+
+
+/*
+ * NB: This algorithm is not optimal in terms of space complexity. The entire
+ * integer lattice of noise points could be done as 2 lines instead, and for 3D,
+ * 2 lines + 2 planes.
+ * However, this would require the noise calls to be interposed with the
+ * interpolation loops, which may trash the icache, leading to lower overall
+ * performance.
+ * Another optimization that could save half as many noise calls is to carry over
+ * values from the previous noise lattice as midpoints in the new lattice for the
+ * next octave.
+ */
+#define idx(x, y) ((y) * nlx + (x))
+void Noise::gradientMap2D(
+ float x, float y,
+ float step_x, float step_y,
+ int seed)
+{
+ float v00, v01, v10, v11, u, v, orig_u;
+ int index, i, j, x0, y0, noisex, noisey;
+ int nlx, nly;
+
+ x0 = floor(x);
+ y0 = floor(y);
+ u = x - (float)x0;
+ v = y - (float)y0;
+ orig_u = u;
+
+ //calculate noise point lattice
+ nlx = (int)(u + sx * step_x) + 2;
+ nly = (int)(v + sy * step_y) + 2;
+ index = 0;
+ for (j = 0; j != nly; j++)
+ for (i = 0; i != nlx; i++)
+ noisebuf[index++] = noise2d(x0 + i, y0 + j, seed);
+
+ //calculate interpolations
+ index = 0;
+ noisey = 0;
+ for (j = 0; j != sy; j++) {
+ v00 = noisebuf[idx(0, noisey)];
+ v10 = noisebuf[idx(1, noisey)];
+ v01 = noisebuf[idx(0, noisey + 1)];
+ v11 = noisebuf[idx(1, noisey + 1)];
+
+ u = orig_u;
+ noisex = 0;
+ for (i = 0; i != sx; i++) {
+ buf[index++] = biLinearInterpolation(v00, v10, v01, v11, u, v);
+ u += step_x;
+ if (u >= 1.0) {
+ u -= 1.0;
+ noisex++;
+ v00 = v10;
+ v01 = v11;
+ v10 = noisebuf[idx(noisex + 1, noisey)];
+ v11 = noisebuf[idx(noisex + 1, noisey + 1)];
+ }
+ }
+
+ v += step_y;
+ if (v >= 1.0) {
+ v -= 1.0;
+ noisey++;
+ }
+ }
+}
+#undef idx
+
+
+#define idx(x, y, z) ((z) * nly * nlx + (y) * nlx + (x))
+void Noise::gradientMap3D(
+ float x, float y, float z,
+ float step_x, float step_y, float step_z,
+ int seed, bool eased)
+{
+ float v000, v010, v100, v110;
+ float v001, v011, v101, v111;
+ float u, v, w, orig_u, orig_v;
+ int index, i, j, k, x0, y0, z0, noisex, noisey, noisez;
+ int nlx, nly, nlz;
+
+ Interp3dFxn interpolate = eased ?
+ triLinearInterpolation : triLinearInterpolationNoEase;
+
+ x0 = floor(x);
+ y0 = floor(y);
+ z0 = floor(z);
+ u = x - (float)x0;
+ v = y - (float)y0;
+ w = z - (float)z0;
+ orig_u = u;
+ orig_v = v;
+
+ //calculate noise point lattice
+ nlx = (int)(u + sx * step_x) + 2;
+ nly = (int)(v + sy * step_y) + 2;
+ nlz = (int)(w + sz * step_z) + 2;
+ index = 0;
+ for (k = 0; k != nlz; k++)
+ for (j = 0; j != nly; j++)
+ for (i = 0; i != nlx; i++)
+ noisebuf[index++] = noise3d(x0 + i, y0 + j, z0 + k, seed);
+
+ //calculate interpolations
+ index = 0;
+ noisey = 0;
+ noisez = 0;
+ for (k = 0; k != sz; k++) {
+ v = orig_v;
+ noisey = 0;
+ for (j = 0; j != sy; j++) {
+ v000 = noisebuf[idx(0, noisey, noisez)];
+ v100 = noisebuf[idx(1, noisey, noisez)];
+ v010 = noisebuf[idx(0, noisey + 1, noisez)];
+ v110 = noisebuf[idx(1, noisey + 1, noisez)];
+ v001 = noisebuf[idx(0, noisey, noisez + 1)];
+ v101 = noisebuf[idx(1, noisey, noisez + 1)];
+ v011 = noisebuf[idx(0, noisey + 1, noisez + 1)];
+ v111 = noisebuf[idx(1, noisey + 1, noisez + 1)];
+
+ u = orig_u;
+ noisex = 0;
+ for (i = 0; i != sx; i++) {
+ buf[index++] = interpolate(
+ v000, v100, v010, v110,
+ v001, v101, v011, v111,
+ u, v, w);
+
+ u += step_x;
+ if (u >= 1.0) {
+ u -= 1.0;
+ noisex++;
+ v000 = v100;
+ v010 = v110;
+ v100 = noisebuf[idx(noisex + 1, noisey, noisez)];
+ v110 = noisebuf[idx(noisex + 1, noisey + 1, noisez)];
+ v001 = v101;
+ v011 = v111;
+ v101 = noisebuf[idx(noisex + 1, noisey, noisez + 1)];
+ v111 = noisebuf[idx(noisex + 1, noisey + 1, noisez + 1)];
+ }
+ }
+
+ v += step_y;
+ if (v >= 1.0) {
+ v -= 1.0;
+ noisey++;
+ }
+ }
+
+ w += step_z;
+ if (w >= 1.0) {
+ w -= 1.0;
+ noisez++;
+ }
+ }
+}
+#undef idx
+
+
+float *Noise::perlinMap2D(float x, float y)
+{
+ float f = 1.0, g = 1.0;
+ size_t bufsize = sx * sy;
+
+ x /= np->spread.X;
+ y /= np->spread.Y;
+
+ memset(result, 0, sizeof(float) * bufsize);
+
+ for (int oct = 0; oct < np->octaves; oct++) {
+ gradientMap2D(x * f, y * f,
+ f / np->spread.X, f / np->spread.Y,
+ seed + np->seed + oct);
+
+ for (size_t i = 0; i != bufsize; i++)
+ result[i] += g * buf[i];
+
+ f *= 2.0;
+ g *= np->persist;
+ }
+
+ return result;
+}
+
+
+float *Noise::perlinMap2DModulated(float x, float y, float *persist_map)
+{
+ float f = 1.0;
+ size_t bufsize = sx * sy;
+
+ x /= np->spread.X;
+ y /= np->spread.Y;
+
+ memset(result, 0, sizeof(float) * bufsize);
+
+ float *g = new float[bufsize];
+ for (size_t i = 0; i != bufsize; i++)
+ g[i] = 1.0;
+
+ for (int oct = 0; oct < np->octaves; oct++) {
+ gradientMap2D(x * f, y * f,
+ f / np->spread.X, f / np->spread.Y,
+ seed + np->seed + oct);
+
+ for (size_t i = 0; i != bufsize; i++) {
+ result[i] += g[i] * buf[i];
+ g[i] *= persist_map[i];
+ }
+
+ f *= 2.0;
+ }
+
+ delete[] g;
+ return result;
+}
+
+
+float *Noise::perlinMap3D(float x, float y, float z, bool eased)
+{
+ float f = 1.0, g = 1.0;
+ size_t bufsize = sx * sy * sz;
+
+ x /= np->spread.X;
+ y /= np->spread.Y;
+ z /= np->spread.Z;
+
+ memset(result, 0, sizeof(float) * bufsize);
+
+ for (int oct = 0; oct < np->octaves; oct++) {
+ gradientMap3D(x * f, y * f, z * f,
+ f / np->spread.X, f / np->spread.Y, f / np->spread.Z,
+ seed + np->seed + oct, eased);
+
+ for (size_t i = 0; i != bufsize; i++)
+ result[i] += g * buf[i];
+
+ f *= 2.0;
+ g *= np->persist;
+ }
+
+ return result;
+}
+
+
+void Noise::transformNoiseMap()
+{
+ size_t i = 0;
+
+ for (int z = 0; z != sz; z++)
+ for (int y = 0; y != sy; y++)
+ for (int x = 0; x != sx; x++) {
+ result[i] = result[i] * np->scale + np->offset;
+ i++;
+ }
+}
+