X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Flib%2Fmath.qh;h=d8f19906a3eb26b1d9003e74f4493450f4b018d8;hb=7bdede86f899ea03fbf67bc1a367dd20390e113c;hp=7459a060f298413f5be3669a9cd386a6c8876f6e;hpb=349aeb508e5a3d577df60bef8a552da2db7d928d;p=xonotic%2Fxonotic-data.pk3dir.git

diff --git a/qcsrc/lib/math.qh b/qcsrc/lib/math.qh
index 7459a060f..d8f19906a 100644
--- a/qcsrc/lib/math.qh
+++ b/qcsrc/lib/math.qh
@@ -1,36 +1,30 @@
-#ifndef MATH_H
-#define MATH_H
+#pragma once
 
+#include "lib/float.qh"
+
+ERASEABLE
 void mean_accumulate(entity e, .float a, .float c, float mean, float value, float weight)
 {
 	if (weight == 0) return;
-	if (mean == 0) e.(a) *= pow(value, weight);
-	else e.(a) += pow(value, mean) * weight;
+	if (mean == 0) e.(a) *= (value ** weight);
+	else e.(a) += (value ** mean) * weight;
 	e.(c) += weight;
 }
 
+ERASEABLE
 float mean_evaluate(entity e, .float a, .float c, float mean)
 {
 	if (e.(c) == 0) return 0;
-	if (mean == 0) return pow(e.(a), 1.0 / e.(c));
-	else return pow(e.(a) / e.(c), 1.0 / mean);
+	if (mean == 0) return (e.(a) ** (1.0 / e.(c)));
+	else return ((e.(a) / e.(c)) ** (1.0 / mean));
 }
 
-#define MEAN_ACCUMULATE(prefix, v, w) mean_accumulate(self, prefix##_accumulator, prefix##_count, prefix##_mean, v, w)
-#define MEAN_EVALUATE(prefix) mean_evaluate(self, prefix##_accumulator, prefix##_count, prefix##_mean)
+#define MEAN_ACCUMULATE(s, prefix, v, w) mean_accumulate(s, prefix##_accumulator, prefix##_count, prefix##_mean, v, w)
+#define MEAN_EVALUATE(s, prefix) mean_evaluate(s, prefix##_accumulator, prefix##_count, prefix##_mean)
 #define MEAN_DECLARE(prefix, m) float prefix##_mean = m; .float prefix##_count, prefix##_accumulator
 
-/*
-==================
-crandom
-
-Returns a random number between -1.0 and 1.0
-==================
-*/
-float crandom()
-{
-	return 2 * (random() - 0.5);
-}
+/** Returns a random number between -1.0 and 1.0 */
+#define crandom() (2 * (random() - 0.5))
 
 
 /*
@@ -40,6 +34,7 @@ Angc used for animations
 */
 
 
+ERASEABLE
 float angc(float a1, float a2)
 {
 	while (a1 > 180)
@@ -58,11 +53,13 @@ float angc(float a1, float a2)
 	return a;
 }
 
+ERASEABLE
 float fsnap(float val, float fsize)
 {
 	return rint(val / fsize) * fsize;
 }
 
+ERASEABLE
 vector vsnap(vector point, float fsize)
 {
 	vector vret;
@@ -74,11 +71,13 @@ vector vsnap(vector point, float fsize)
 	return vret;
 }
 
+ERASEABLE
 vector lerpv(float t0, vector v0, float t1, vector v1, float t)
 {
 	return v0 + (v1 - v0) * ((t - t0) / (t1 - t0));
 }
 
+ERASEABLE
 vector bezier_quadratic_getpoint(vector a, vector b, vector c, float t)
 {
 	return (c - 2 * b + a) * (t * t)
@@ -86,20 +85,23 @@ vector bezier_quadratic_getpoint(vector a, vector b, vector c, float t)
 	       + a;
 }
 
+ERASEABLE
 vector bezier_quadratic_getderivative(vector a, vector b, vector c, float t)
 {
 	return (c - 2 * b + a) * (2 * t)
 	       + (b - a) * 2;
 }
 
-float cubic_speedfunc(float startspeedfactor, float endspeedfactor, float x)
+ERASEABLE
+float cubic_speedfunc(float startspeedfactor, float endspeedfactor, float spd)
 {
 	return (((startspeedfactor + endspeedfactor - 2
-	         ) * x - 2 * startspeedfactor - endspeedfactor + 3
-	        ) * x + startspeedfactor
-	       ) * x;
+	         ) * spd - 2 * startspeedfactor - endspeedfactor + 3
+	        ) * spd + startspeedfactor
+	       ) * spd;
 }
 
+ERASEABLE
 bool cubic_speedfunc_is_sane(float startspeedfactor, float endspeedfactor)
 {
 	if (startspeedfactor < 0 || endspeedfactor < 0) return false;
@@ -164,28 +166,40 @@ bool cubic_speedfunc_is_sane(float startspeedfactor, float endspeedfactor)
 }
 
 /** continuous function mapping all reals into -1..1 */
+ERASEABLE
 float float2range11(float f)
 {
 	return f / (fabs(f) + 1);
 }
 
 /** continuous function mapping all reals into 0..1 */
+ERASEABLE
 float float2range01(float f)
 {
 	return 0.5 + 0.5 * float2range11(f);
 }
 
+ERASEABLE
 float median(float a, float b, float c)
 {
 	return (a < c) ? bound(a, b, c) : bound(c, b, a);
 }
 
+ERASEABLE
 float almost_equals(float a, float b)
 {
 	float eps = (max(a, -a) + max(b, -b)) * 0.001;
 	return a - b < eps && b - a < eps;
 }
 
+ERASEABLE
+float almost_equals_eps(float a, float b, float times_eps)
+{
+	float eps = max(fabs(a), fabs(b)) * FLOAT_EPSILON * times_eps;
+	return a - b < eps && b - a < eps;
+}
+
+ERASEABLE
 float almost_in_bounds(float a, float b, float c)
 {
 	float eps = (max(a, -a) + max(c, -c)) * 0.001;
@@ -193,61 +207,140 @@ float almost_in_bounds(float a, float b, float c)
 	return b == median(a - eps, b, c + eps);
 }
 
-float power2of(float e)
+ERASEABLE
+float ExponentialFalloff(float mindist, float maxdist, float halflifedist, float d)
 {
-	return pow(2, e);
+	if (halflifedist > 0) return (0.5 ** ((bound(mindist, d, maxdist) - mindist) / halflifedist));
+	else if (halflifedist < 0) return (0.5 ** ((bound(mindist, d, maxdist) - maxdist) / halflifedist));
+	else return 1;
 }
 
-float log2of(float x)
+#define power2of(e) (2 ** e)
+
+ERASEABLE
+float log2of(float e)
 {
 	// NOTE: generated code
-	if (x > 2048)
-		if (x > 131072)
-			if (x > 1048576)
-				if (x > 4194304) return 23;
+	if (e > 2048)
+		if (e > 131072)
+			if (e > 1048576)
+				if (e > 4194304) return 23;
 				else
-					if (x > 2097152) return 22;
+					if (e > 2097152) return 22;
 					else return 21;
 			else
-				if (x > 524288) return 20;
+				if (e > 524288) return 20;
 				else
-					if (x > 262144) return 19;
+					if (e > 262144) return 19;
 					else return 18;
 		else
-			if (x > 16384)
-				if (x > 65536) return 17;
+			if (e > 16384)
+				if (e > 65536) return 17;
 				else
-					if (x > 32768) return 16;
+					if (e > 32768) return 16;
 					else return 15;
 			else
-				if (x > 8192) return 14;
+				if (e > 8192) return 14;
 				else
-					if (x > 4096) return 13;
+					if (e > 4096) return 13;
 					else return 12;
 	else
-		if (x > 32)
-			if (x > 256)
-				if (x > 1024) return 11;
+		if (e > 32)
+			if (e > 256)
+				if (e > 1024) return 11;
 				else
-					if (x > 512) return 10;
+					if (e > 512) return 10;
 					else return 9;
 			else
-				if (x > 128) return 8;
+				if (e > 128) return 8;
 				else
-					if (x > 64) return 7;
+					if (e > 64) return 7;
 					else return 6;
 		else
-			if (x > 4)
-				if (x > 16) return 5;
+			if (e > 4)
+				if (e > 16) return 5;
 				else
-					if (x > 8) return 4;
+					if (e > 8) return 4;
 					else return 3;
 			else
-				if (x > 2) return 2;
+				if (e > 2) return 2;
 				else
-					if (x > 1) return 1;
+					if (e > 1) return 1;
 					else return 0;
 }
 
+/** ax^2 + bx + c = 0 */
+ERASEABLE
+vector solve_quadratic(float a, float b, float c)
+{
+	vector v;
+	float D;
+	v = '0 0 0';
+	if (a == 0)
+	{
+		if (b != 0)
+		{
+			v.x = v.y = -c / b;
+			v.z = 1;
+		}
+		else
+		{
+			if (c == 0)
+			{
+				// actually, every number solves the equation!
+				v.z = 1;
+			}
+		}
+	}
+	else
+	{
+		D = b * b - 4 * a * c;
+		if (D >= 0)
+		{
+			D = sqrt(D);
+			if (a > 0)  // put the smaller solution first
+			{
+				v.x = ((-b) - D) / (2 * a);
+				v.y = ((-b) + D) / (2 * a);
+			}
+			else
+			{
+				v.x = (-b + D) / (2 * a);
+				v.y = (-b - D) / (2 * a);
+			}
+			v.z = 1;
+		}
+		else
+		{
+			// complex solutions!
+			D = sqrt(-D);
+			v.x = -b / (2 * a);
+			if (a > 0) v.y =  D / (2 * a);
+			else v.y = -D / (2 * a);
+			v.z = 0;
+		}
+	}
+	return v;
+}
 
-#endif
+/// Maps values between the src and dest range: src_min to dest_min, src_max to dest_max, values between them
+/// to the corresponding values between and extrapolates for values outside the range.
+///
+/// src_min and src_max must not be the same or division by zero occurs.
+///
+/// dest_max can be smaller than dest_min if you want the resulting range to be inverted, all values can be negative.
+ERASEABLE
+float map_ranges(float value, float src_min, float src_max, float dest_min, float dest_max) {
+	float src_diff = src_max - src_min;
+	float dest_diff = dest_max - dest_min;
+	float ratio = (value - src_min) / src_diff;
+	return dest_min + dest_diff * ratio;
+}
+
+/// Same as `map_ranges` except that values outside the source range are clamped to min or max.
+ERASEABLE
+float map_bound_ranges(float value, float src_min, float src_max, float dest_min, float dest_max) {
+	if (value <= src_min) return dest_min;
+	if (value >= src_max) return dest_max;
+	return map_ranges(value, src_min, src_max, dest_min, dest_max);
+}