X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;ds=sidebyside;f=src%2Fnoise.cpp;h=e6ca8a4951cf669c8312275f2b859fc34d2f1297;hb=d382483fa76028c2d34f75067bff45306c6da34e;hp=614234aa4c52bbf9370fe86f85ecf4f63be3eff1;hpb=415167b228dea8b4108d7fe164c7fec8c061dcf5;p=dragonfireclient.git

diff --git a/src/noise.cpp b/src/noise.cpp
index 614234aa4..e6ca8a495 100644
--- a/src/noise.cpp
+++ b/src/noise.cpp
@@ -47,8 +47,8 @@ typedef float (*Interp3dFxn)(
 		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[] = {
@@ -90,23 +90,35 @@ u32 PcgRandom::next()
 
 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;
@@ -118,7 +130,9 @@ s32 PcgRandom::range(s32 min, s32 max)
 	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;
 }
 
@@ -138,7 +152,7 @@ void PcgRandom::bytes(void *out, size_t len)
 		*outb = r & 0xFF;
 		outb++;
 		bytes_left--;
-		r >>= 8;
+		r >>= CHAR_BIT;
 	}
 }
 
@@ -148,28 +162,28 @@ 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 round((float)accum / num_trials);
+	return myround((float)accum / num_trials);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-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;
 }
 
 
@@ -192,14 +206,6 @@ inline float biLinearInterpolation(
 {
 	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);
@@ -225,18 +231,6 @@ float triLinearInterpolation(
 	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);
@@ -252,34 +246,7 @@ float triLinearInterpolationNoEase(
 	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);
@@ -300,7 +267,7 @@ float noise2d_gradient(float x, float y, int seed, bool eased)
 }
 
 
-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);
@@ -334,7 +301,7 @@ float noise3d_gradient(float x, float y, float z, int seed, bool eased)
 }
 
 
-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;
@@ -350,7 +317,7 @@ float noise2d_perlin(float x, float y, int seed,
 }
 
 
-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;
@@ -365,7 +332,7 @@ float noise2d_perlin_abs(float x, float y, int seed,
 }
 
 
-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;
@@ -380,7 +347,7 @@ float noise3d_perlin(float x, float y, float z, int seed,
 }
 
 
-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;
@@ -407,7 +374,7 @@ float contour(float v)
 ///////////////////////// [ 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;
@@ -433,7 +400,7 @@ float NoisePerlin2D(NoiseParams *np, float x, float y, int seed)
 }
 
 
-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;
@@ -460,7 +427,7 @@ float NoisePerlin3D(NoiseParams *np, float x, float y, float z, int seed)
 }
 
 
-Noise::Noise(NoiseParams *np_, int seed, int sx, int sy, int sz)
+Noise::Noise(NoiseParams *np_, s32 seed, u32 sx, u32 sy, u32 sz)
 {
 	memcpy(&np, np_, sizeof(np));
 	this->seed = seed;
@@ -468,10 +435,6 @@ Noise::Noise(NoiseParams *np_, int seed, int sx, int sy, int sz)
 	this->sy   = sy;
 	this->sz   = sz;
 
-	this->persist_buf  = NULL;
-	this->gradient_buf = NULL;
-	this->result       = NULL;
-
 	allocBuffers();
 }
 
@@ -512,7 +475,7 @@ void Noise::allocBuffers()
 }
 
 
-void Noise::setSize(int sx, int sy, int sz)
+void Noise::setSize(u32 sx, u32 sy, u32 sz)
 {
 	this->sx = sx;
 	this->sy = sy;
@@ -587,11 +550,12 @@ void Noise::resizeNoiseBuf(bool is3d)
 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;
-	int index, i, j, x0, y0, noisex, noisey;
-	int nlx, nly;
+	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 ?
@@ -604,8 +568,8 @@ void Noise::gradientMap2D(
 	orig_u = u;
 
 	//calculate noise point lattice
-	nlx = (int)(u + sx * step_x) + 2;
-	nly = (int)(v + sy * step_y) + 2;
+	nlx = (u32)(u + sx * step_x) + 2;
+	nly = (u32)(v + sy * step_y) + 2;
 	index = 0;
 	for (j = 0; j != nly; j++)
 		for (i = 0; i != nlx; i++)
@@ -650,13 +614,14 @@ void Noise::gradientMap2D(
 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;
-	int index, i, j, k, x0, y0, z0, noisex, noisey, noisez;
-	int nlx, nly, nlz;
+	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;
@@ -671,9 +636,9 @@ void Noise::gradientMap3D(
 	orig_v = v;
 
 	//calculate noise point lattice
-	nlx = (int)(u + sx * step_x) + 2;
-	nly = (int)(v + sy * step_y) + 2;
-	nlz = (int)(w + sz * step_z) + 2;
+	nlx = (u32)(u + sx * step_x) + 2;
+	nly = (u32)(v + sy * step_y) + 2;
+	nlz = (u32)(w + sz * step_z) + 2;
 	index = 0;
 	for (k = 0; k != nlz; k++)
 		for (j = 0; j != nly; j++)