Merge branch 'sev/lumaIcons' into 'master'

[xonotic/xonotic-data.pk3dir.git] / qcsrc / lib / math.qh

diff --git a/qcsrc/lib/math.qh b/qcsrc/lib/math.qh
index 92d45bf142573663919fcfe5b6f93f09dc2a8f16..d8f19906a3eb26b1d9003e74f4493450f4b018d8 100644 (file)
--- a/qcsrc/lib/math.qh
+++ b/qcsrc/lib/math.qh
@@ -1,18 +1,22 @@
 #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(s, prefix, v, w) mean_accumulate(s, prefix##_accumulator, prefix##_count, prefix##_mean, v, w)
@@ -30,6 +34,7 @@ Angc used for animations
 */
 
 
+ERASEABLE
 float angc(float a1, float a2)
 {
        while (a1 > 180)
@@ -48,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;
@@ -64,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)
@@ -76,12 +85,14 @@ 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;
 }
 
+ERASEABLE
 float cubic_speedfunc(float startspeedfactor, float endspeedfactor, float spd)
 {
        return (((startspeedfactor + endspeedfactor - 2
@@ -90,6 +101,7 @@ float cubic_speedfunc(float startspeedfactor, float endspeedfactor, float spd)
               ) * spd;
 }
 
+ERASEABLE
 bool cubic_speedfunc_is_sane(float startspeedfactor, float endspeedfactor)
 {
        if (startspeedfactor < 0 || endspeedfactor < 0) return false;
@@ -154,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;
@@ -183,18 +207,17 @@ float almost_in_bounds(float a, float b, float c)
        return b == median(a - eps, b, c + eps);
 }
 
+ERASEABLE
 float ExponentialFalloff(float mindist, float maxdist, float halflifedist, float d)
 {
-       if (halflifedist > 0) return pow(0.5, (bound(mindist, d, maxdist) - mindist) / halflifedist);
-       else if (halflifedist < 0) return pow(0.5, (bound(mindist, d, maxdist) - maxdist) / halflifedist);
+       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 power2of(float e)
-{
-       return pow(2, e);
-}
+#define power2of(e) (2 ** e)
 
+ERASEABLE
 float log2of(float e)
 {
        // NOTE: generated code
@@ -247,6 +270,7 @@ float log2of(float e)
 }
 
 /** ax^2 + bx + c = 0 */
+ERASEABLE
 vector solve_quadratic(float a, float b, float c)
 {
        vector v;
@@ -298,3 +322,25 @@ vector solve_quadratic(float a, float b, float c)
        }
        return v;
 }
+
+/// 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);
+}