#include "lib/float.qh"
+ERASEABLE
void mean_accumulate(entity e, .float a, .float c, float mean, float value, float weight)
{
if (weight == 0) return;
e.(c) += weight;
}
+ERASEABLE
float mean_evaluate(entity e, .float a, .float c, float mean)
{
if (e.(c) == 0) return 0;
*/
+ERASEABLE
float angc(float a1, float a2)
{
while (a1 > 180)
return a;
}
+ERASEABLE
float fsnap(float val, float fsize)
{
return rint(val / fsize) * fsize;
}
+ERASEABLE
vector vsnap(vector point, float fsize)
{
vector vret;
return vret;
}
+ERASEABLE
+float lerpratio(float f0, float f1, float ratio)
+{
+ return f0 * (1 - ratio) + f1 * ratio;
+}
+
+ERASEABLE
+float lerp(float t0, float f0, float t1, float f1, float t)
+{
+ return lerpratio(f0, f1, (t - t0) / (t1 - t0));
+}
+
+ERASEABLE
+float lerp3ratio(float f0, float f1, float f2, float ratio)
+{
+ float mid = 0.5;
+ return ratio < mid ? lerpratio(f0, f1, ratio / mid) : ratio > mid ? lerpratio(f1, f2, (ratio - mid) / mid) : f1;
+}
+
+
+ERASEABLE
+vector lerpvratio(vector f0, vector f1, float ratio)
+{
+ return f0 * (1 - ratio) + f1 * ratio;
+}
+
+ERASEABLE
+vector lerpv3ratio(vector f0, vector f1, vector f2, float ratio)
+{
+ float mid = 0.5;
+ return ratio < mid ? lerpvratio(f0, f1, ratio / mid) : ratio > mid ? lerpvratio(f1, f2, (ratio - mid) / mid) : f1;
+}
+
+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)
+ 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
) * spd;
}
+ERASEABLE
bool cubic_speedfunc_is_sane(float startspeedfactor, float endspeedfactor)
{
if (startspeedfactor < 0 || endspeedfactor < 0) return false;
}
/** 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;
return b == median(a - eps, b, c + eps);
}
+ERASEABLE
float ExponentialFalloff(float mindist, float maxdist, float halflifedist, float d)
{
if (halflifedist > 0) return (0.5 ** ((bound(mindist, d, maxdist) - mindist) / halflifedist));
else return 1;
}
-float power2of(float e)
-{
- return (2 ** e);
-}
+#define power2of(e) (2 ** e)
+ERASEABLE
float log2of(float e)
{
// NOTE: generated code
}
/** ax^2 + bx + c = 0 */
+ERASEABLE
vector solve_quadratic(float a, float b, float c)
{
vector v;
}
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);
+}