float x, float y, float z);
float cos_lookup[16] = {
- 1.0, 0.9238, 0.7071, 0.3826, 0, -0.3826, -0.7071, -0.9238,
- 1.0, -0.9238, -0.7071, -0.3826, 0, 0.3826, 0.7071, 0.9238
+ 1.0f, 0.9238f, 0.7071f, 0.3826f, .0f, -0.3826f, -0.7071f, -0.9238f,
+ 1.0f, -0.9238f, -0.7071f, -0.3826f, .0f, 0.3826f, 0.7071f, 0.9238f
};
FlagDesc flagdesc_noiseparams[] = {
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;
if (max < min)
throw PrngException("Invalid range (max < min)");
- u32 bound = max - min + 1;
+ // We have to cast to s64 because otherwise this could overflow,
+ // and signed overflow is undefined behavior.
+ u32 bound = (s64)max - (s64)min + 1;
return range(bound) + min;
}
///////////////////////////////////////////////////////////////////////////////
-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;
}
return linearInterpolation(u, v, z);
}
-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;
this->sy = sy;
this->sz = sz;
- this->persist_buf = NULL;
- this->gradient_buf = NULL;
- this->result = NULL;
-
allocBuffers();
}
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, noisex, noisey;
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;
projects / dragonfireclient.git / blobdiff