+void Noise::init(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) {
+ setSize(sx, sy, 1);
+}
+
+
+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++;
+ }