///////////////////////////////////////////////////////////////////////////////
+PcgRandom::PcgRandom(u64 state, u64 seq)
+{
+ seed(state, seq);
+}
+
+void PcgRandom::seed(u64 state, u64 seq)
+{
+ m_state = 0U;
+ m_inc = (seq << 1u) | 1u;
+ next();
+ m_state += state;
+ next();
+}
+
+
+u32 PcgRandom::next()
+{
+ u64 oldstate = m_state;
+ m_state = oldstate * 6364136223846793005ULL + m_inc;
+
+ u32 xorshifted = ((oldstate >> 18u) ^ oldstate) >> 27u;
+ u32 rot = oldstate >> 59u;
+ return (xorshifted >> rot) | (xorshifted << ((-rot) & 31));
+}
+
+
+u32 PcgRandom::range(u32 bound)
+{
+ /*
+ If the bound is not a multiple of the RNG's range, it may cause bias,
+ e.g. a RNG has a range from 0 to 3 and we take want a number 0 to 2.
+ Using rand() % 3, the number 0 would be twice as likely to appear.
+ With a very large RNG range, the effect becomes less prevalent but
+ still present. This can be solved by modifying the range of the RNG
+ to become a multiple of bound by dropping values above the a threshhold.
+ In our example, threshhold == 4 - 3 = 1 % 3 == 1, so reject 0, thus
+ making the range 3 with no bias.
+
+ This loop looks dangerous, but will always terminate due to the
+ RNG's property of uniformity.
+ */
+ u32 threshhold = -bound % bound;
+ u32 r;
+
+ while ((r = next()) < threshhold)
+ ;
+
+ return r % bound;
+}
+
+
+s32 PcgRandom::range(s32 min, s32 max)
+{
+ if (max < min)
+ throw PrngException("Invalid range (max < min)");
+
+ u32 bound = max - min + 1;
+ return range(bound) + min;
+}
+
+
+void PcgRandom::bytes(void *out, size_t len)
+{
+ u8 *outb = (u8 *)out;
+ int bytes_left = 0;
+ u32 r;
+
+ while (len--) {
+ if (bytes_left == 0) {
+ bytes_left = sizeof(u32);
+ r = next();
+ }
+
+ *outb = r & 0xFF;
+ outb++;
+ bytes_left--;
+ r >>= 8;
+ }
+}
+
+
+s32 PcgRandom::randNormalDist(s32 min, s32 max, int num_trials)
+{
+ s32 accum = 0;
+ for (int i = 0; i != num_trials; i++)
+ accum += range(min, max);
+ return myround((float)accum / num_trials);
+}
+
+///////////////////////////////////////////////////////////////////////////////
float noise2d(int x, int y, int seed)
{
}
-///////////////////////// [ New perlin stuff ] ////////////////////////////
+///////////////////////// [ New noise ] ////////////////////////////
+
+
+float NoisePerlin2D(NoiseParams *np, float x, float y, int seed)
+{
+ float a = 0;
+ float f = 1.0;
+ float g = 1.0;
+
+ x /= np->spread.X;
+ y /= np->spread.Y;
+ seed += np->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));
+
+ if (np->flags & NOISE_FLAG_ABSVALUE)
+ noiseval = fabs(noiseval);
+
+ a += g * noiseval;
+ f *= np->lacunarity;
+ g *= np->persist;
+ }
+
+ return np->offset + a * np->scale;
+}
+
+
+float NoisePerlin3D(NoiseParams *np, float x, float y, float z, int seed)
+{
+ float a = 0;
+ float f = 1.0;
+ float g = 1.0;
+
+ x /= np->spread.X;
+ y /= np->spread.Y;
+ z /= np->spread.Z;
+ seed += np->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);
+
+ if (np->flags & NOISE_FLAG_ABSVALUE)
+ noiseval = fabs(noiseval);
+
+ a += g * noiseval;
+ f *= np->lacunarity;
+ g *= np->persist;
+ }
+
+ return np->offset + a * np->scale;
+}
Noise::Noise(NoiseParams *np_, int seed, int sx, int sy, int sz)
this->gradient_buf = NULL;
this->result = NULL;
- if (np.flags & NOISE_FLAG_DEFAULTS) {
- // By default, only 2d noise is eased.
- if (sz <= 1)
- np.flags |= NOISE_FLAG_EASED;
- }
-
allocBuffers();
}
void Noise::allocBuffers()
{
+ if (sx < 1)
+ sx = 1;
+ if (sy < 1)
+ sy = 1;
+ if (sz < 1)
+ sz = 1;
+
this->noise_buf = NULL;
resizeNoiseBuf(sz > 1);
void Noise::resizeNoiseBuf(bool is3d)
{
- int nlx, nly, nlz;
- float ofactor;
-
//maximum possible spread value factor
- ofactor = pow(np.lacunarity, np.octaves - 1);
+ 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
+ float num_noise_points_x = sx * ofactor / np.spread.X;
+ float num_noise_points_y = sy * ofactor / np.spread.Y;
+ 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 ||
+ num_noise_points_z > 1000000000.f)
+ throw InvalidNoiseParamsException();
- //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)ceil(sx * ofactor / np.spread.X) + 3;
- nly = (int)ceil(sy * ofactor / np.spread.Y) + 3;
- nlz = is3d ? (int)ceil(sz * ofactor / np.spread.Z) + 3 : 1;
+ size_t nlx = (size_t)ceil(num_noise_points_x) + 3;
+ size_t nly = (size_t)ceil(num_noise_points_y) + 3;
+ size_t nlz = is3d ? (size_t)ceil(num_noise_points_z) + 3 : 1;
delete[] noise_buf;
try {
int index, i, j, x0, y0, noisex, noisey;
int nlx, nly;
- Interp2dFxn interpolate = (np.flags & NOISE_FLAG_EASED) ?
+ bool eased = np.flags & (NOISE_FLAG_DEFAULTS | NOISE_FLAG_EASED);
+ Interp2dFxn interpolate = eased ?
biLinearInterpolation : biLinearInterpolationNoEase;
x0 = floor(x);
projects / dragonfireclient.git / blobdiff