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, 111 insertions, 166 deletions
diff --git a/src/noise.cpp b/src/noise.cpp
index 5a1d989cb..04739423b 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,28 +32,21 @@
#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}};
///////////////////////////////////////////////////////////////////////////////
@@ -71,7 +64,6 @@ void PcgRandom::seed(u64 state, u64 seq)
next();
}
-
u32 PcgRandom::next()
{
u64 oldstate = m_state;
@@ -82,7 +74,6 @@ 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
@@ -119,7 +110,6 @@ u32 PcgRandom::range(u32 bound)
return r % bound;
}
-
s32 PcgRandom::range(s32 min, s32 max)
{
if (max < min)
@@ -131,7 +121,6 @@ s32 PcgRandom::range(s32 min, s32 max)
return range(bound) + min;
}
-
void PcgRandom::bytes(void *out, size_t len)
{
u8 *outb = (u8 *)out;
@@ -151,7 +140,6 @@ void PcgRandom::bytes(void *out, size_t len)
}
}
-
s32 PcgRandom::randNormalDist(s32 min, s32 max, int num_trials)
{
s32 accum = 0;
@@ -164,40 +152,36 @@ 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);
@@ -206,22 +190,16 @@ 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);
@@ -231,10 +209,8 @@ float triLinearInterpolation(
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);
@@ -251,9 +227,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);
@@ -261,7 +237,6 @@ 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
@@ -273,37 +248,31 @@ 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;
@@ -311,9 +280,8 @@ float noise2d_perlin(float x, float y, s32 seed,
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;
@@ -326,9 +294,8 @@ float noise2d_perlin_abs(float x, float y, s32 seed,
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;
@@ -341,22 +308,21 @@ float noise3d_perlin(float x, float y, float z, s32 seed,
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);
@@ -365,10 +331,8 @@ float contour(float v)
return (1.0 - v);
}
-
///////////////////////// [ New noise ] ////////////////////////////
-
float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed)
{
float a = 0;
@@ -381,7 +345,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);
@@ -394,7 +358,6 @@ 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;
@@ -408,7 +371,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);
@@ -421,19 +384,17 @@ 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;
@@ -442,7 +403,6 @@ Noise::~Noise()
delete[] result;
}
-
void Noise::allocBuffers()
{
if (sx < 1)
@@ -461,15 +421,14 @@ 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;
@@ -479,7 +438,6 @@ void Noise::setSize(u32 sx, u32 sy, u32 sz)
allocBuffers();
}
-
void Noise::setSpreadFactor(v3f spread)
{
this->np.spread = spread;
@@ -487,7 +445,6 @@ void Noise::setSpreadFactor(v3f spread)
resizeNoiseBuf(sz > 1);
}
-
void Noise::setOctaves(int octaves)
{
this->np.octaves = octaves;
@@ -495,13 +452,11 @@ 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
@@ -510,18 +465,17 @@ 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
@@ -538,7 +492,6 @@ 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,
@@ -550,11 +503,8 @@ 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;
@@ -562,8 +512,8 @@ void Noise::gradientMap2D(
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);
@@ -571,7 +521,7 @@ void Noise::gradientMap2D(
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;
@@ -579,8 +529,8 @@ void Noise::gradientMap2D(
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)];
@@ -613,12 +563,9 @@ void Noise::gradientMap2D(
}
#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;
@@ -627,8 +574,9 @@ void Noise::gradientMap3D(
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);
@@ -639,7 +587,7 @@ void Noise::gradientMap3D(
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;
@@ -647,32 +595,31 @@ void Noise::gradientMap3D(
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) {
@@ -680,12 +627,15 @@ void Noise::gradientMap3D(
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)];
}
}
@@ -705,7 +655,6 @@ void Noise::gradientMap3D(
}
#undef idx
-
float *Noise::perlinMap2D(float x, float y, float *persistence_map)
{
float f = 1.0, g = 1.0;
@@ -724,9 +673,8 @@ 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);
@@ -742,7 +690,6 @@ 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;
@@ -762,9 +709,8 @@ 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);
@@ -780,9 +726,8 @@ 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 22:10:02 +0000