u32 PcgRandom::range(u32 bound)
{
+ // If the bound is 0, we cover the whole RNG's range
+ if (bound == 0)
+ return next();
+
/*
- 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.
+ This is an optimization of the expression:
+ 0x100000000ull % bound
+ since 64-bit modulo operations typically much slower than 32.
*/
- u32 threshhold = -bound % bound;
+ u32 threshold = -bound % bound;
u32 r;
- while ((r = next()) < threshhold)
+ /*
+ 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 threshold.
+
+ In our example, threshold == 4 % 3 == 1, so reject values < 1
+ (that is, 0), thus making the range == 3 with no bias.
+
+ This loop may look dangerous, but will always terminate due to the
+ RNG's property of uniformity.
+ */
+ while ((r = next()) < threshold)
;
return r % bound;
*outb = r & 0xFF;
outb++;
bytes_left--;
- r >>= 8;
+ r >>= CHAR_BIT;
}
}
///////////////////////////////////////////////////////////////////////////////
-float noise2d(int x, int y, int seed)
+float noise2d(int x, int y, s32 seed)
{
- int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y
+ 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)n / 0x40000000;
+ return 1.f - (float)(int)n / 0x40000000;
}
-float noise3d(int x, int y, int z, int seed)
+float noise3d(int x, int y, int z, s32 seed)
{
- int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y + NOISE_MAGIC_Z * z
+ 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)n / 0x40000000;
+ return 1.f - (float)(int)n / 0x40000000;
}
{
float tx = easeCurve(x);
float ty = easeCurve(y);
-#if 0
- return (
- v00 * (1 - tx) * (1 - ty) +
- v10 * tx * (1 - ty) +
- v01 * (1 - tx) * ty +
- v11 * tx * ty
- );
-#endif
float u = linearInterpolation(v00, v10, tx);
float v = linearInterpolation(v01, v11, tx);
return linearInterpolation(u, v, ty);
float tx = easeCurve(x);
float ty = easeCurve(y);
float tz = easeCurve(z);
-#if 0
- return (
- v000 * (1 - tx) * (1 - ty) * (1 - tz) +
- v100 * tx * (1 - ty) * (1 - tz) +
- v010 * (1 - tx) * ty * (1 - tz) +
- v110 * tx * ty * (1 - tz) +
- v001 * (1 - tx) * (1 - ty) * tz +
- v101 * tx * (1 - ty) * tz +
- v011 * (1 - tx) * ty * tz +
- v111 * tx * ty * tz
- );
-#endif
float u = biLinearInterpolationNoEase(v000, v100, v010, v110, tx, ty);
float v = biLinearInterpolationNoEase(v001, v101, v011, v111, tx, ty);
return linearInterpolation(u, v, tz);
return linearInterpolation(u, v, z);
}
-
-#if 0
-float noise2d_gradient(float x, float y, int seed)
-{
- // Calculate the integer coordinates
- int x0 = (x > 0.0 ? (int)x : (int)x - 1);
- int y0 = (y > 0.0 ? (int)y : (int)y - 1);
- // Calculate the remaining part of the coordinates
- float xl = x - (float)x0;
- float yl = y - (float)y0;
- // Calculate random cosine lookup table indices for the integer corners.
- // They are looked up as unit vector gradients from the lookup table.
- int n00 = (int)((noise2d(x0, y0, seed)+1)*8);
- int n10 = (int)((noise2d(x0+1, y0, seed)+1)*8);
- int n01 = (int)((noise2d(x0, y0+1, seed)+1)*8);
- int n11 = (int)((noise2d(x0+1, y0+1, seed)+1)*8);
- // Make a dot product for the gradients and the positions, to get the values
- float s = dotProduct(cos_lookup[n00], cos_lookup[(n00+12)%16], xl, yl);
- float u = dotProduct(-cos_lookup[n10], cos_lookup[(n10+12)%16], 1.-xl, yl);
- float v = dotProduct(cos_lookup[n01], -cos_lookup[(n01+12)%16], xl, 1.-yl);
- float w = dotProduct(-cos_lookup[n11], -cos_lookup[(n11+12)%16], 1.-xl, 1.-yl);
- // Interpolate between the values
- return biLinearInterpolation(s,u,v,w,xl,yl);
-}
-#endif
-
-
-float noise2d_gradient(float x, float y, int seed, bool eased)
+float noise2d_gradient(float x, float y, s32 seed, bool eased)
{
// Calculate the integer coordinates
int x0 = myfloor(x);
}
-float noise3d_gradient(float x, float y, float z, int seed, bool eased)
+float noise3d_gradient(float x, float y, float z, s32 seed, bool eased)
{
// Calculate the integer coordinates
int x0 = myfloor(x);
}
-float noise2d_perlin(float x, float y, int seed,
+float noise2d_perlin(float x, float y, s32 seed,
int octaves, float persistence, bool eased)
{
float a = 0;
}
-float noise2d_perlin_abs(float x, float y, int seed,
+float noise2d_perlin_abs(float x, float y, s32 seed,
int octaves, float persistence, bool eased)
{
float a = 0;
}
-float noise3d_perlin(float x, float y, float z, int seed,
+float noise3d_perlin(float x, float y, float z, s32 seed,
int octaves, float persistence, bool eased)
{
float a = 0;
}
-float noise3d_perlin_abs(float x, float y, float z, int seed,
+float noise3d_perlin_abs(float x, float y, float z, s32 seed,
int octaves, float persistence, bool eased)
{
float a = 0;
///////////////////////// [ New noise ] ////////////////////////////
-float NoisePerlin2D(NoiseParams *np, float x, float y, int seed)
+float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed)
{
float a = 0;
float f = 1.0;
}
-float NoisePerlin3D(NoiseParams *np, float x, float y, float z, int seed)
+float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed)
{
float a = 0;
float f = 1.0;
}
-Noise::Noise(NoiseParams *np_, int seed, u32 sx, u32 sy, u32 sz)
+Noise::Noise(NoiseParams *np_, s32 seed, u32 sx, u32 sy, u32 sz)
{
memcpy(&np, np_, sizeof(np));
this->seed = seed;
void Noise::gradientMap2D(
float x, float y,
float step_x, float step_y,
- int seed)
+ s32 seed)
{
float v00, v01, v10, v11, u, v, orig_u;
- u32 index, i, j, x0, y0, noisex, noisey;
+ u32 index, i, j, noisex, noisey;
u32 nlx, nly;
+ s32 x0, y0;
bool eased = np.flags & (NOISE_FLAG_DEFAULTS | NOISE_FLAG_EASED);
Interp2dFxn interpolate = eased ?
void Noise::gradientMap3D(
float x, float y, float z,
float step_x, float step_y, float step_z,
- int seed)
+ s32 seed)
{
float v000, v010, v100, v110;
float v001, v011, v101, v111;
float u, v, w, orig_u, orig_v;
- u32 index, i, j, k, x0, y0, z0, noisex, noisey, noisez;
+ u32 index, i, j, k, noisex, noisey, noisez;
u32 nlx, nly, nlz;
+ s32 x0, y0, z0;
Interp3dFxn interpolate = (np.flags & NOISE_FLAG_EASED) ?
triLinearInterpolation : triLinearInterpolationNoEase;
projects / minetest.git / blobdiff