aboutsummaryrefslogtreecommitdiff
path: root/src/noise.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/noise.cpp')
-rw-r--r--src/noise.cpp277
1 files changed, 166 insertions, 111 deletions
diff --git a/src/noise.cpp b/src/noise.cpp
index 04739423b..5a1d989cb 100644
--- a/src/noise.cpp
+++ b/src/noise.cpp
@@ -9,18 +9,18 @@
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
- * of conditions and the following disclaimer in the documentation and/or other
- * materials provided with the distribution.
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
*
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <cmath>
@@ -32,21 +32,28 @@
#include "util/string.h"
#include "exceptions.h"
-#define NOISE_MAGIC_X 1619
-#define NOISE_MAGIC_Y 31337
-#define NOISE_MAGIC_Z 52591
+#define NOISE_MAGIC_X 1619
+#define NOISE_MAGIC_Y 31337
+#define NOISE_MAGIC_Z 52591
#define NOISE_MAGIC_SEED 1013
typedef float (*Interp2dFxn)(
- float v00, float v10, float v01, float v11, float x, float y);
-
-typedef float (*Interp3dFxn)(float v000, float v100, float v010, float v110, float v001,
- float v101, float v011, float v111, float x, float y, float z);
-
-FlagDesc flagdesc_noiseparams[] = {{"defaults", NOISE_FLAG_DEFAULTS},
- {"eased", NOISE_FLAG_EASED}, {"absvalue", NOISE_FLAG_ABSVALUE},
- {"pointbuffer", NOISE_FLAG_POINTBUFFER}, {"simplex", NOISE_FLAG_SIMPLEX},
- {NULL, 0}};
+ float v00, float v10, float v01, float v11,
+ float x, float y);
+
+typedef float (*Interp3dFxn)(
+ float v000, float v100, float v010, float v110,
+ float v001, float v101, float v011, float v111,
+ float x, float y, float z);
+
+FlagDesc flagdesc_noiseparams[] = {
+ {"defaults", NOISE_FLAG_DEFAULTS},
+ {"eased", NOISE_FLAG_EASED},
+ {"absvalue", NOISE_FLAG_ABSVALUE},
+ {"pointbuffer", NOISE_FLAG_POINTBUFFER},
+ {"simplex", NOISE_FLAG_SIMPLEX},
+ {NULL, 0}
+};
///////////////////////////////////////////////////////////////////////////////
@@ -64,6 +71,7 @@ void PcgRandom::seed(u64 state, u64 seq)
next();
}
+
u32 PcgRandom::next()
{
u64 oldstate = m_state;
@@ -74,6 +82,7 @@ u32 PcgRandom::next()
return (xorshifted >> rot) | (xorshifted << ((-rot) & 31));
}
+
u32 PcgRandom::range(u32 bound)
{
// If the bound is 0, we cover the whole RNG's range
@@ -110,6 +119,7 @@ u32 PcgRandom::range(u32 bound)
return r % bound;
}
+
s32 PcgRandom::range(s32 min, s32 max)
{
if (max < min)
@@ -121,6 +131,7 @@ s32 PcgRandom::range(s32 min, s32 max)
return range(bound) + min;
}
+
void PcgRandom::bytes(void *out, size_t len)
{
u8 *outb = (u8 *)out;
@@ -140,6 +151,7 @@ void PcgRandom::bytes(void *out, size_t len)
}
}
+
s32 PcgRandom::randNormalDist(s32 min, s32 max, int num_trials)
{
s32 accum = 0;
@@ -152,36 +164,40 @@ s32 PcgRandom::randNormalDist(s32 min, s32 max, int num_trials)
float noise2d(int x, int y, s32 seed)
{
- unsigned int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y +
- NOISE_MAGIC_SEED * seed) &
- 0x7fffffff;
+ unsigned int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y
+ + NOISE_MAGIC_SEED * seed) & 0x7fffffff;
n = (n >> 13) ^ n;
n = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
return 1.f - (float)(int)n / 0x40000000;
}
+
float noise3d(int x, int y, int z, s32 seed)
{
- unsigned int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y + NOISE_MAGIC_Z * z +
- NOISE_MAGIC_SEED * seed) &
- 0x7fffffff;
+ unsigned int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y + NOISE_MAGIC_Z * z
+ + NOISE_MAGIC_SEED * seed) & 0x7fffffff;
n = (n >> 13) ^ n;
n = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
return 1.f - (float)(int)n / 0x40000000;
}
+
inline float dotProduct(float vx, float vy, float wx, float wy)
{
return vx * wx + vy * wy;
}
+
inline float linearInterpolation(float v0, float v1, float t)
{
return v0 + (v1 - v0) * t;
}
+
inline float biLinearInterpolation(
- float v00, float v10, float v01, float v11, float x, float y)
+ float v00, float v10,
+ float v01, float v11,
+ float x, float y)
{
float tx = easeCurve(x);
float ty = easeCurve(y);
@@ -190,16 +206,22 @@ inline float biLinearInterpolation(
return linearInterpolation(u, v, ty);
}
+
inline float biLinearInterpolationNoEase(
- float v00, float v10, float v01, float v11, float x, float y)
+ float v00, float v10,
+ float v01, float v11,
+ float x, float y)
{
float u = linearInterpolation(v00, v10, x);
float v = linearInterpolation(v01, v11, x);
return linearInterpolation(u, v, y);
}
-float triLinearInterpolation(float v000, float v100, float v010, float v110, float v001,
- float v101, float v011, float v111, float x, float y, float z)
+
+float triLinearInterpolation(
+ float v000, float v100, float v010, float v110,
+ float v001, float v101, float v011, float v111,
+ float x, float y, float z)
{
float tx = easeCurve(x);
float ty = easeCurve(y);
@@ -209,8 +231,10 @@ float triLinearInterpolation(float v000, float v100, float v010, float v110, flo
return linearInterpolation(u, v, tz);
}
-float triLinearInterpolationNoEase(float v000, float v100, float v010, float v110,
- float v001, float v101, float v011, float v111, float x, float y, float z)
+float triLinearInterpolationNoEase(
+ float v000, float v100, float v010, float v110,
+ float v001, float v101, float v011, float v111,
+ float x, float y, float z)
{
float u = biLinearInterpolationNoEase(v000, v100, v010, v110, x, y);
float v = biLinearInterpolationNoEase(v001, v101, v011, v111, x, y);
@@ -227,9 +251,9 @@ float noise2d_gradient(float x, float y, s32 seed, bool eased)
float yl = y - (float)y0;
// Get values for corners of square
float v00 = noise2d(x0, y0, seed);
- float v10 = noise2d(x0 + 1, y0, seed);
- float v01 = noise2d(x0, y0 + 1, seed);
- float v11 = noise2d(x0 + 1, y0 + 1, seed);
+ float v10 = noise2d(x0+1, y0, seed);
+ float v01 = noise2d(x0, y0+1, seed);
+ float v11 = noise2d(x0+1, y0+1, seed);
// Interpolate
if (eased)
return biLinearInterpolation(v00, v10, v01, v11, xl, yl);
@@ -237,6 +261,7 @@ float noise2d_gradient(float x, float y, s32 seed, bool eased)
return biLinearInterpolationNoEase(v00, v10, v01, v11, xl, yl);
}
+
float noise3d_gradient(float x, float y, float z, s32 seed, bool eased)
{
// Calculate the integer coordinates
@@ -248,31 +273,37 @@ float noise3d_gradient(float x, float y, float z, s32 seed, bool eased)
float yl = y - (float)y0;
float zl = z - (float)z0;
// Get values for corners of cube
- float v000 = noise3d(x0, y0, z0, seed);
- float v100 = noise3d(x0 + 1, y0, z0, seed);
- float v010 = noise3d(x0, y0 + 1, z0, seed);
- float v110 = noise3d(x0 + 1, y0 + 1, z0, seed);
- float v001 = noise3d(x0, y0, z0 + 1, seed);
- float v101 = noise3d(x0 + 1, y0, z0 + 1, seed);
- float v011 = noise3d(x0, y0 + 1, z0 + 1, seed);
+ float v000 = noise3d(x0, y0, z0, seed);
+ float v100 = noise3d(x0 + 1, y0, z0, seed);
+ float v010 = noise3d(x0, y0 + 1, z0, seed);
+ float v110 = noise3d(x0 + 1, y0 + 1, z0, seed);
+ float v001 = noise3d(x0, y0, z0 + 1, seed);
+ float v101 = noise3d(x0 + 1, y0, z0 + 1, seed);
+ float v011 = noise3d(x0, y0 + 1, z0 + 1, seed);
float v111 = noise3d(x0 + 1, y0 + 1, z0 + 1, seed);
// Interpolate
if (eased) {
- return triLinearInterpolation(v000, v100, v010, v110, v001, v101, v011,
- v111, xl, yl, zl);
+ return triLinearInterpolation(
+ v000, v100, v010, v110,
+ v001, v101, v011, v111,
+ xl, yl, zl);
}
return triLinearInterpolationNoEase(
- v000, v100, v010, v110, v001, v101, v011, v111, xl, yl, zl);
+ v000, v100, v010, v110,
+ v001, v101, v011, v111,
+ xl, yl, zl);
}
-float noise2d_perlin(
- float x, float y, s32 seed, int octaves, float persistence, bool eased)
+
+float noise2d_perlin(float x, float y, s32 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++) {
+ for (int i = 0; i < octaves; i++)
+ {
a += g * noise2d_gradient(x * f, y * f, seed + i, eased);
f *= 2.0;
g *= persistence;
@@ -280,8 +311,9 @@ float noise2d_perlin(
return a;
}
-float noise2d_perlin_abs(
- float x, float y, s32 seed, int octaves, float persistence, bool eased)
+
+float noise2d_perlin_abs(float x, float y, s32 seed,
+ int octaves, float persistence, bool eased)
{
float a = 0;
float f = 1.0;
@@ -294,8 +326,9 @@ float noise2d_perlin_abs(
return a;
}
-float noise3d_perlin(float x, float y, float z, s32 seed, int octaves, float persistence,
- bool eased)
+
+float noise3d_perlin(float x, float y, float z, s32 seed,
+ int octaves, float persistence, bool eased)
{
float a = 0;
float f = 1.0;
@@ -308,21 +341,22 @@ float noise3d_perlin(float x, float y, float z, s32 seed, int octaves, float per
return a;
}
-float noise3d_perlin_abs(float x, float y, float z, s32 seed, int octaves,
- float persistence, bool eased)
+
+float noise3d_perlin_abs(float x, float y, float z, s32 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 *
- std::fabs(noise3d_gradient(x * f, y * f, z * f, seed + i, eased));
+ a += g * std::fabs(noise3d_gradient(x * f, y * f, z * f, seed + i, eased));
f *= 2.0;
g *= persistence;
}
return a;
}
+
float contour(float v)
{
v = std::fabs(v);
@@ -331,8 +365,10 @@ float contour(float v)
return (1.0 - v);
}
+
///////////////////////// [ New noise ] ////////////////////////////
+
float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed)
{
float a = 0;
@@ -345,7 +381,7 @@ float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed)
for (size_t i = 0; i < np->octaves; i++) {
float noiseval = noise2d_gradient(x * f, y * f, seed + i,
- np->flags & (NOISE_FLAG_DEFAULTS | NOISE_FLAG_EASED));
+ np->flags & (NOISE_FLAG_DEFAULTS | NOISE_FLAG_EASED));
if (np->flags & NOISE_FLAG_ABSVALUE)
noiseval = std::fabs(noiseval);
@@ -358,6 +394,7 @@ float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed)
return np->offset + a * np->scale;
}
+
float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed)
{
float a = 0;
@@ -371,7 +408,7 @@ float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed)
for (size_t i = 0; i < np->octaves; i++) {
float noiseval = noise3d_gradient(x * f, y * f, z * f, seed + i,
- np->flags & NOISE_FLAG_EASED);
+ np->flags & NOISE_FLAG_EASED);
if (np->flags & NOISE_FLAG_ABSVALUE)
noiseval = std::fabs(noiseval);
@@ -384,17 +421,19 @@ float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed)
return np->offset + a * np->scale;
}
+
Noise::Noise(NoiseParams *np_, s32 seed, u32 sx, u32 sy, u32 sz)
{
memcpy(&np, np_, sizeof(np));
this->seed = seed;
- this->sx = sx;
- this->sy = sy;
- this->sz = sz;
+ this->sx = sx;
+ this->sy = sy;
+ this->sz = sz;
allocBuffers();
}
+
Noise::~Noise()
{
delete[] gradient_buf;
@@ -403,6 +442,7 @@ Noise::~Noise()
delete[] result;
}
+
void Noise::allocBuffers()
{
if (sx < 1)
@@ -421,14 +461,15 @@ void Noise::allocBuffers()
try {
size_t bufsize = sx * sy * sz;
- this->persist_buf = NULL;
+ this->persist_buf = NULL;
this->gradient_buf = new float[bufsize];
- this->result = new float[bufsize];
+ this->result = new float[bufsize];
} catch (std::bad_alloc &e) {
throw InvalidNoiseParamsException();
}
}
+
void Noise::setSize(u32 sx, u32 sy, u32 sz)
{
this->sx = sx;
@@ -438,6 +479,7 @@ void Noise::setSize(u32 sx, u32 sy, u32 sz)
allocBuffers();
}
+
void Noise::setSpreadFactor(v3f spread)
{
this->np.spread = spread;
@@ -445,6 +487,7 @@ void Noise::setSpreadFactor(v3f spread)
resizeNoiseBuf(sz > 1);
}
+
void Noise::setOctaves(int octaves)
{
this->np.octaves = octaves;
@@ -452,11 +495,13 @@ void Noise::setOctaves(int octaves)
resizeNoiseBuf(sz > 1);
}
+
void Noise::resizeNoiseBuf(bool is3d)
{
// Maximum possible spread value factor
- float ofactor = (np.lacunarity > 1.0) ? pow(np.lacunarity, np.octaves - 1)
- : np.lacunarity;
+ float ofactor = (np.lacunarity > 1.0) ?
+ pow(np.lacunarity, np.octaves - 1) :
+ np.lacunarity;
// Noise lattice point count
// (int)(sz * spread * ofactor) is # of lattice points crossed due to length
@@ -465,17 +510,18 @@ void Noise::resizeNoiseBuf(bool is3d)
float num_noise_points_z = sz * ofactor / np.spread.Z;
// Protect against obviously invalid parameters
- if (num_noise_points_x > 1000000000.f || num_noise_points_y > 1000000000.f ||
+ if (num_noise_points_x > 1000000000.f ||
+ num_noise_points_y > 1000000000.f ||
num_noise_points_z > 1000000000.f)
throw InvalidNoiseParamsException();
// Protect against an octave having a spread < 1, causing broken noise values
- if (np.spread.X / ofactor < 1.0f || np.spread.Y / ofactor < 1.0f ||
+ if (np.spread.X / ofactor < 1.0f ||
+ np.spread.Y / ofactor < 1.0f ||
np.spread.Z / ofactor < 1.0f) {
- errorstream << "A noise parameter has too many octaves: " << np.octaves
- << " octaves" << std::endl;
- throw InvalidNoiseParamsException(
- "A noise parameter has too many octaves");
+ errorstream << "A noise parameter has too many octaves: "
+ << np.octaves << " octaves" << std::endl;
+ throw InvalidNoiseParamsException("A noise parameter has too many octaves");
}
// + 2 for the two initial endpoints
@@ -492,6 +538,7 @@ void Noise::resizeNoiseBuf(bool is3d)
}
}
+
/*
* 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,
@@ -503,8 +550,11 @@ void Noise::resizeNoiseBuf(bool is3d)
* 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, s32 seed)
+#define idx(x, y) ((y) * nlx + (x))
+void Noise::gradientMap2D(
+ float x, float y,
+ float step_x, float step_y,
+ s32 seed)
{
float v00, v01, v10, v11, u, v, orig_u;
u32 index, i, j, noisex, noisey;
@@ -512,8 +562,8 @@ void Noise::gradientMap2D(float x, float y, float step_x, float step_y, s32 seed
s32 x0, y0;
bool eased = np.flags & (NOISE_FLAG_DEFAULTS | NOISE_FLAG_EASED);
- Interp2dFxn interpolate =
- eased ? biLinearInterpolation : biLinearInterpolationNoEase;
+ Interp2dFxn interpolate = eased ?
+ biLinearInterpolation : biLinearInterpolationNoEase;
x0 = std::floor(x);
y0 = std::floor(y);
@@ -521,7 +571,7 @@ void Noise::gradientMap2D(float x, float y, float step_x, float step_y, s32 seed
v = y - (float)y0;
orig_u = u;
- // calculate noise point lattice
+ //calculate noise point lattice
nlx = (u32)(u + sx * step_x) + 2;
nly = (u32)(v + sy * step_y) + 2;
index = 0;
@@ -529,8 +579,8 @@ void Noise::gradientMap2D(float x, float y, float step_x, float step_y, s32 seed
for (i = 0; i != nlx; i++)
noise_buf[index++] = noise2d(x0 + i, y0 + j, seed);
- // calculate interpolations
- index = 0;
+ //calculate interpolations
+ index = 0;
noisey = 0;
for (j = 0; j != sy; j++) {
v00 = noise_buf[idx(0, noisey)];
@@ -563,9 +613,12 @@ void Noise::gradientMap2D(float x, float y, float step_x, float step_y, s32 seed
}
#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, s32 seed)
+
+#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,
+ s32 seed)
{
float v000, v010, v100, v110;
float v001, v011, v101, v111;
@@ -574,9 +627,8 @@ void Noise::gradientMap3D(float x, float y, float z, float step_x, float step_y,
u32 nlx, nly, nlz;
s32 x0, y0, z0;
- Interp3dFxn interpolate = (np.flags & NOISE_FLAG_EASED)
- ? triLinearInterpolation
- : triLinearInterpolationNoEase;
+ Interp3dFxn interpolate = (np.flags & NOISE_FLAG_EASED) ?
+ triLinearInterpolation : triLinearInterpolationNoEase;
x0 = std::floor(x);
y0 = std::floor(y);
@@ -587,7 +639,7 @@ void Noise::gradientMap3D(float x, float y, float z, float step_x, float step_y,
orig_u = u;
orig_v = v;
- // calculate noise point lattice
+ //calculate noise point lattice
nlx = (u32)(u + sx * step_x) + 2;
nly = (u32)(v + sy * step_y) + 2;
nlz = (u32)(w + sz * step_z) + 2;
@@ -595,31 +647,32 @@ void Noise::gradientMap3D(float x, float y, float z, float step_x, float step_y,
for (k = 0; k != nlz; k++)
for (j = 0; j != nly; j++)
for (i = 0; i != nlx; i++)
- noise_buf[index++] =
- noise3d(x0 + i, y0 + j, z0 + k, seed);
+ noise_buf[index++] = noise3d(x0 + i, y0 + j, z0 + k, seed);
- // calculate interpolations
- index = 0;
+ //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 = noise_buf[idx(0, noisey, noisez)];
- v100 = noise_buf[idx(1, noisey, noisez)];
+ v000 = noise_buf[idx(0, noisey, noisez)];
+ v100 = noise_buf[idx(1, noisey, noisez)];
v010 = noise_buf[idx(0, noisey + 1, noisez)];
v110 = noise_buf[idx(1, noisey + 1, noisez)];
- v001 = noise_buf[idx(0, noisey, noisez + 1)];
- v101 = noise_buf[idx(1, noisey, noisez + 1)];
+ v001 = noise_buf[idx(0, noisey, noisez + 1)];
+ v101 = noise_buf[idx(1, noisey, noisez + 1)];
v011 = noise_buf[idx(0, noisey + 1, noisez + 1)];
v111 = noise_buf[idx(1, noisey + 1, noisez + 1)];
u = orig_u;
noisex = 0;
for (i = 0; i != sx; i++) {
- gradient_buf[index++] = interpolate(v000, v100, v010,
- v110, v001, v101, v011, v111, u, v, w);
+ gradient_buf[index++] = interpolate(
+ v000, v100, v010, v110,
+ v001, v101, v011, v111,
+ u, v, w);
u += step_x;
if (u >= 1.0) {
@@ -627,15 +680,12 @@ void Noise::gradientMap3D(float x, float y, float z, float step_x, float step_y,
noisex++;
v000 = v100;
v010 = v110;
- v100 = noise_buf[idx(noisex + 1, noisey, noisez)];
- v110 = noise_buf[idx(
- noisex + 1, noisey + 1, noisez)];
+ v100 = noise_buf[idx(noisex + 1, noisey, noisez)];
+ v110 = noise_buf[idx(noisex + 1, noisey + 1, noisez)];
v001 = v101;
v011 = v111;
- v101 = noise_buf[idx(
- noisex + 1, noisey, noisez + 1)];
- v111 = noise_buf[idx(noisex + 1, noisey + 1,
- noisez + 1)];
+ v101 = noise_buf[idx(noisex + 1, noisey, noisez + 1)];
+ v111 = noise_buf[idx(noisex + 1, noisey + 1, noisez + 1)];
}
}
@@ -655,6 +705,7 @@ void Noise::gradientMap3D(float x, float y, float z, float step_x, float step_y,
}
#undef idx
+
float *Noise::perlinMap2D(float x, float y, float *persistence_map)
{
float f = 1.0, g = 1.0;
@@ -673,8 +724,9 @@ float *Noise::perlinMap2D(float x, float y, float *persistence_map)
}
for (size_t oct = 0; oct < np.octaves; oct++) {
- gradientMap2D(x * f, y * f, f / np.spread.X, f / np.spread.Y,
- seed + np.seed + oct);
+ gradientMap2D(x * f, y * f,
+ f / np.spread.X, f / np.spread.Y,
+ seed + np.seed + oct);
updateResults(g, persist_buf, persistence_map, bufsize);
@@ -690,6 +742,7 @@ float *Noise::perlinMap2D(float x, float y, float *persistence_map)
return result;
}
+
float *Noise::perlinMap3D(float x, float y, float z, float *persistence_map)
{
float f = 1.0, g = 1.0;
@@ -709,8 +762,9 @@ float *Noise::perlinMap3D(float x, float y, float z, float *persistence_map)
}
for (size_t 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);
+ gradientMap3D(x * f, y * f, z * f,
+ f / np.spread.X, f / np.spread.Y, f / np.spread.Z,
+ seed + np.seed + oct);
updateResults(g, persist_buf, persistence_map, bufsize);
@@ -726,8 +780,9 @@ float *Noise::perlinMap3D(float x, float y, float z, float *persistence_map)
return result;
}
-void Noise::updateResults(
- float g, float *gmap, const float *persistence_map, size_t bufsize)
+
+void Noise::updateResults(float g, float *gmap,
+ const float *persistence_map, size_t bufsize)
{
// This looks very ugly, but it is 50-70% faster than having
// conditional statements inside the loop
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-20 21:00:54 +0000