+disgrace and rework of ungrateful.h

1 files changed, 304 insertions, 202 deletions

diff --git a/src/un_vecd.c b/src/un_vecd.c
index 0d138a4..6e738fc 100644
--- a/src/un_vecd.c
+++ b/src/un_vecd.c
@@ -1,307 +1,409 @@
-void un_m_add2d(f64 *v, f64 *a, f64 *b) {
-    v[0] = a[0] + b[0];
-    v[1] = a[1] + b[1];
+inline double2 un_m_add2d(double2 a, double2 b) {
+    double2 result;
+    result.x = a.x + b.x;
+    result.y = a.y + b.y;
+    return result;
 }
 
-void un_m_add3d(f64 *v, f64 *a, f64 *b) {
-    v[0] = a[0] + b[0];
-    v[1] = a[1] + b[1];
-    v[2] = a[2] + b[2];
+inline double3 un_m_add3d(double3 a, double3 b) {
+    double3 result;
+    result.x = a.x + b.x;
+    result.y = a.y + b.y;
+    result.z = a.z + b.z;
+    return result;
 }
 
-void un_m_add4d(f64 *v, f64 *a, f64 *b) {
-    v[0] = a[0] + b[0];
-    v[1] = a[1] + b[1];
-    v[2] = a[2] + b[2];
-    v[3] = a[3] + b[3];
+inline double4 un_m_add4d(double4 a, double4 b) {
+    double4 result;
+    result.x = a.x + b.x;
+    result.y = a.y + b.y;
+    result.z = a.z + b.z;
+    result.w = a.w + b.w;
+    return result;
 }
 
-void un_m_sub2d(f64 *v, f64 *a, f64 *b) {
-    v[0] = a[0] - b[0];
-    v[1] = a[1] - b[1];
+inline double2 un_m_sub2d(double2 a, double2 b) {
+    double2 result;
+    result.x = a.x - b.x;
+    result.y = a.y - b.y;
+    return result;
 }
 
-void un_m_sub3d(f64 *v, f64 *a, f64 *b) {
-    v[0] = a[0] - b[0];
-    v[1] = a[1] - b[1];
-    v[2] = a[2] - b[2];
+inline double3 un_m_sub3d(double3 a, double3 b) {
+    double3 result;
+    result.x = a.x - b.x;
+    result.y = a.y - b.y;
+    result.z = a.z - b.z;
+    return result;
 }
 
-void un_m_sub4d(f64 *v, f64 *a, f64 *b) {
-    v[0] = a[0] - b[0];
-    v[1] = a[1] - b[1];
-    v[2] = a[2] - b[2];
-    v[3] = a[3] - b[3];
+inline double4 un_m_sub4d(double4 a, double4 b) {
+    double4 result;
+    result.x = a.x - b.x;
+    result.y = a.y - b.y;
+    result.z = a.z - b.z;
+    result.w = a.w - b.w;
+    return result;
 }
 
-void un_m_add_scalar2d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] + scalar;
-    v[1] = a[1] + scalar;
+inline double2 un_m_add_scalar2d(double2 a, double scalar) {
+    double2 result;
+    result.x = a.x + scalar;
+    result.y = a.y + scalar;
+    return result;
 }
 
-void un_m_add_scalar3d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] + scalar;
-    v[1] = a[1] + scalar;
-    v[2] = a[2] + scalar;
+inline double3 un_m_add_scalar3d(double3 a, double scalar) {
+    double3 result;
+    result.x = a.x + scalar;
+    result.y = a.y + scalar;
+    result.z = a.z + scalar;
+    return result;
 }
 
-void un_m_add_scalar4d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] + scalar;
-    v[1] = a[1] + scalar;
-    v[2] = a[2] + scalar;
-    v[3] = a[3] + scalar;
+inline double4 un_m_add_scalar4d(double4 a, double scalar) {
+    double4 result;
+    result.x = a.x + scalar;
+    result.y = a.y + scalar;
+    result.z = a.z + scalar;
+    result.w = a.w + scalar;
+    return result;
 }
 
-void un_m_sub_scalar2d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] - scalar;
-    v[1] = a[1] - scalar;
+inline double2 un_m_sub_scalar2d(double2 a, double scalar) {
+    double2 result;
+    result.x = a.x - scalar;
+    result.y = a.y - scalar;
+    return result;
 }
 
-void un_m_sub_scalar3d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] - scalar;
-    v[1] = a[1] - scalar;
-    v[2] = a[2] - scalar;
+inline double3 un_m_sub_scalar3d(double3 a, double scalar) {
+    double3 result;
+    result.x = a.x - scalar;
+    result.y = a.y - scalar;
+    result.z = a.z - scalar;
+    return result;
 }
 
-void un_m_sub_scalar4d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] - scalar;
-    v[1] = a[1] - scalar;
-    v[2] = a[2] - scalar;
-    v[3] = a[3] - scalar;
+inline double4 un_m_sub_scalar4d(double4 a, double scalar) {
+    double4 result;
+    result.x = a.x - scalar;
+    result.y = a.y - scalar;
+    result.z = a.z - scalar;
+    result.w = a.w - scalar;
+    return result;
 }
 
-void un_m_mul_scalar2d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] * scalar;
-    v[1] = a[1] * scalar;
+inline double2 un_m_mul_scalar2d(double2 a, double scalar) {
+    double2 result;
+    result.x = a.x * scalar;
+    result.y = a.y * scalar;
+    return result;
 }
 
-void un_m_mul_scalar3d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] * scalar;
-    v[1] = a[1] * scalar;
-    v[2] = a[2] * scalar;
+inline double3 un_m_mul_scalar3d(double3 a, double scalar) {
+    double3 result;
+    result.x = a.x * scalar;
+    result.y = a.y * scalar;
+    result.z = a.z * scalar;
+    return result;
 }
 
-void un_m_mul_scalar4d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] * scalar;
-    v[1] = a[1] * scalar;
-    v[2] = a[2] * scalar;
-    v[3] = a[3] * scalar;
+inline double4 un_m_mul_scalar4d(double4 a, double scalar) {
+    double4 result;
+    result.x = a.x * scalar;
+    result.y = a.y * scalar;
+    result.z = a.z * scalar;
+    result.w = a.w * scalar;
+    return result;
 }
 
-void un_m_div_scalar2d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] / scalar;
-    v[1] = a[1] / scalar;
+inline double2 un_m_div_scalar2d(double2 a, double scalar) {
+    double2 result;
+    result.x = a.x / scalar;
+    result.y = a.y / scalar;
+    return result;
 }
 
-void un_m_div_scalar3d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] / scalar;
-    v[1] = a[1] / scalar;
-    v[2] = a[2] / scalar;
+inline double3 un_m_div_scalar3d(double3 a, double scalar) {
+    double3 result;
+    result.x = a.x / scalar;
+    result.y = a.y / scalar;
+    result.z = a.z / scalar;
+    return result;
 }
 
-void un_m_div_scalar4d(f64 *v, f64 *a, f64 scalar) {
-    v[0] = a[0] / scalar;
-    v[1] = a[1] / scalar;
-    v[2] = a[2] / scalar;
-    v[3] = a[3] / scalar;
+inline double4 un_m_div_scalar4d(double4 a, double scalar) {
+    double4 result;
+    result.x = a.x / scalar;
+    result.y = a.y / scalar;
+    result.z = a.z / scalar;
+    result.w = a.w / scalar;
+    return result;
 }
 
-void un_m_dot2d(f64 *v, f64 *a, f64 *b) {
-    *v = a[0] * b[0] + a[1] * b[1];
+inline double un_m_dot2d(double2 a, double2 b) {
+    return a.x * b.x + a.y * b.y;
 }
 
-void un_m_dot3d(f64 *v, f64 *a, f64 *b) {
-    *v = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+inline double un_m_dot3d(double3 a, double3 b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
 }
 
-void un_m_dot4d(f64 *v, f64 *a, f64 *b) {
-    *v = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+inline double un_m_dot4d(double4 a, double4 b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
 }
 
-void un_m_hadamard2d(f64 *v, f64 *a, f64 *b) {
-    v[0] = a[0] * b[0];
-    v[1] = a[1] * b[1];
+inline double2 un_m_hadamard2d(double2 a, double2 b) {
+    double2 result;
+    result.x = a.x * b.x;
+    result.y = a.y * b.y;
+    return result;
 }
 
-void un_m_hadamard3d(f64 *v, f64 *a, f64 *b) {
-    v[0] = a[0] * b[0];
-    v[1] = a[1] * b[1];
-    v[2] = a[2] * b[2];
+inline double3 un_m_hadamard3d(double3 a, double3 b) {
+    double3 result;
+    result.x = a.x * b.x;
+    result.y = a.y * b.y;
+    result.z = a.z * b.z;
+    return result;
 }
 
-void un_m_hadamard4d(f64 *v, f64 *a, f64 *b) {
-    v[0] = a[0] * b[0];
-    v[1] = a[1] * b[1];
-    v[2] = a[2] * b[2];
-    v[3] = a[3] * b[3];
+inline double4 un_m_hadamard4d(double4 a, double4 b) {
+    double4 result;
+    result.x = a.x * b.x;
+    result.y = a.y * b.y;
+    result.z = a.z * b.z;
+    result.w = a.w * b.w;
+    return result;
 }
 
-void un_m_cross2d(f64 *v, f64 *a) {
-    v[0] = a[1];
-    v[1] =-a[0];
+inline double2 un_m_cross2d(double2 a) {
+    double2 result;
+    result.x = a.y;
+    result.y =-a.x;
+    return result;
 }
 
-void un_m_cross3d(f64 *v, f64 *a, f64 *b) {
-	v[0] = a[1] * b[2] - a[2] * b[1];
-	v[1] = a[2] * b[0] - a[0] * b[2];
-	v[2] = a[0] * b[1] - a[1] * b[0];
+inline double3 un_m_cross3d(double3 a, double3 b) {
+    double3 result;
+	result.x = a.y * b.z - a.z * b.y;
+	result.y = a.z * b.x - a.x * b.z;
+	result.z = a.x * b.y - a.y * b.x;
+    return result;
 }
 
-void un_m_magnitude2d(f64 *v, f64 *a) {
-    *v = sqrt(a[0] * a[0] + a[1] * a[1]);
+inline double un_m_magnitude2d(double2 a) {
+    return sqrt(a.x * a.x + a.y * a.y);
 }
 
-void un_m_magnitude3d(f64 *v, f64 *a) {
-    *v = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
+inline double un_m_magnitude3d(double3 a) {
+    return sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
 }
 
-void un_m_magnitude4d(f64 *v, f64 *a) {
-    *v = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3]);
+inline double un_m_magnitude4d(double4 a) {
+    return sqrt(a.x * a.x + a.y * a.y + a.z * a.z + a.w * a.w);
 }
 
-void un_m_magnitude_sqr2d(f64 *v, f64 *a) {
-    *v = a[0] * a[0] + a[1] * a[1];
+inline double un_m_magnitude_sqr2d(double2 a) {
+    return a.x * a.x + a.y * a.y;
 }
 
-void un_m_magnitude_sqr3d(f64 *v, f64 *a) {
-    *v = a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
+inline double un_m_magnitude_sqr3d(double3 a) {
+    return a.x * a.x + a.y * a.y + a.z * a.z;
 }
 
-void un_m_magnitude_sqr4d(f64 *v, f64 *a) {
-    *v = a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
+inline double un_m_magnitude_sqr4d(double4 a) {
+    return a.x * a.x + a.y * a.y + a.z * a.z + a.w * a.w;
 }
 
-void un_m_distance2d(f64 *v, f64 *a, f64 *b) {
-    f64 f[2];
-    un_m_sub2d(f, b, a);
-    *v = sqrt(f[0] * f[0] + f[1] * f[1]);
+inline double un_m_distance2d(double2 a, double2 b) {
+    double2 result;
+
+    result.x = b.x - a.x;
+    result.y = b.y - a.y;
+
+    return sqrt(result.x * result.x + result.y * result.y);
 }
 
-void un_m_distance3d(f64 *v, f64 *a, f64 *b) {
-    f64 f[3];
-    un_m_sub3d(f, b, a);
-    *v = sqrt(f[0] * f[0] + f[1] * f[1] + f[2] * f[2]);
+inline double un_m_distance3d(double3 a, double3 b) {
+    double3 result;
+
+    result.x = b.x - a.x;
+    result.y = b.y - a.y;
+    result.z = b.z - a.z;
+
+    return sqrt(result.x * result.x + result.y * result.y + result.z * result.z);
 }
 
-void un_m_distance4d(f64 *v, f64 *a, f64 *b) {
-    f64 f[4];
-    un_m_sub4d(f, b, a);
-    *v = sqrt(f[0] * f[0] + f[1] * f[1] + f[2] * f[2] + f[3] * f[3]);
+inline double un_m_distance4d(double4 a, double4 b) {
+    double4 result;
+
+    result.x = b.x - a.x;
+    result.y = b.y - a.y;
+    result.z = b.z - a.z;
+    result.w = b.w - a.w;
+
+    return sqrt(result.x * result.x + result.y * result.y + result.z * result.z + result.w * result.w);
 }
 
-void un_m_distance_sqr2d(f64 *v, f64 *a, f64 *b) {
-    f64 f[2];
-    un_m_sub2d(f, b, a);
-    *v = f[0] * f[0] + f[1] * f[1];
+inline double un_m_distance_sqr2d(double2 a, double2 b) {
+    double2 result;
+
+    result.x = b.x - a.x;
+    result.y = b.y - a.y;
+
+    return result.x * result.x + result.y * result.y;
 }
 
-void un_m_distance_sqr3d(f64 *v, f64 *a, f64 *b) {
-    f64 f[3];
-    un_m_sub3d(f, b, a);
-    *v = f[0] * f[0] + f[1] * f[1] + f[2] * f[2];
+inline double un_m_distance_sqr3d(double3 a, double3 b) {
+    double3 result;
+
+    result.x = b.x - a.x;
+    result.y = b.y - a.y;
+    result.z = b.z - a.z;
+
+    return result.x * result.x + result.y * result.y + result.z * result.z;
 }
 
-void un_m_distance_sqr4d(f64 *v, f64 *a, f64 *b) {
-    f64 f[4];
-    un_m_sub4d(f, b, a);
-    *v = f[0] * f[0] + f[1] * f[1] + f[2] * f[2] + f[3] * f[3];
+inline double un_m_distance_sqr4d(double4 a, double4 b) {
+    double4 result;
+
+    result.x = b.x - a.x;
+    result.y = b.y - a.y;
+    result.z = b.z - a.z;
+    result.w = b.w - a.w;
+
+    return result.x * result.x + result.y * result.y + result.z * result.z + result.w * result.w;
 }
 
-void un_m_normalize2d(f64 *v, f64 *a) {
-    f64 f;
-    un_m_magnitude2d(&f, a);
-    v[0] = a[0] / f;
-    v[1] = a[1] / f;
+inline double2 un_m_normalize2d(double2 a) {
+    double2 result;
+    double mag;
+
+    mag = sqrt(a.x * a.x + a.y * a.y);
+
+    result.x = a.x / mag;
+    result.y = a.y / mag;
+
+    return result;
 }
 
-void un_m_normalize3d(f64 *v, f64 *a) {
-    f64 f;
-    un_m_magnitude3d(&f, a);
-    v[0] = a[0] / f;
-    v[1] = a[1] / f;
-    v[2] = a[2] / f;
+inline double3 un_m_normalize3d(double3 a) {
+    double3 result;
+    double mag;
+
+    mag = sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
+
+    result.x = a.x / mag;
+    result.y = a.y / mag;
+    result.z = a.z / mag;
+
+    return result;
 }
 
-void un_m_normalize4d(f64 *v, f64 *a) {
-    f64 f;
-    un_m_magnitude4d(&f, a);
-    v[0] = a[0] / f;
-    v[1] = a[1] / f;
-    v[2] = a[2] / f;
-    v[3] = a[3] / f;
+inline double4 un_m_normalize4d(double4 a) {
+    double4 result;
+    double mag;
+
+    mag = sqrt(a.x * a.x + a.y * a.y + a.z * a.z + a.w * a.w);
+
+    result.x = a.x / mag;
+    result.y = a.y / mag;
+    result.z = a.z / mag;
+    result.w = a.w / mag;
+
+    return result;
 }
 
-void un_m_project2d(f64 *v, f64 *a, f64 *onto) {
-    f64 dot, magn, scale;
+inline double2 un_m_project2d(double2 a, double2 onto) {
+    double d;
+    double2 result;
 
-    un_m_dot2d(&dot, a, onto);
-    un_m_magnitude_sqr2d(&magn, onto);
+    d  = a.x * onto.x + a.y * onto.y;
+    d /= onto.x * onto.x + onto.y * onto.y;
 
-    if (magn < EPSILON) {
-        un_memory_set((void*)v, 0, sizeof(*v) * 2);
-        return;
-    }
+    result.x = onto.x * d;
+    result.y = onto.y * d;
 
-    scale = dot / magn;
-    v[0] = onto[0] * scale;
-    v[1] = onto[1] * scale;
+    return result;
 }
 
-void un_m_project3d(f64 *v, f64 *a, f64 *onto) {
-    f64 dot, magn, scale;
+inline double3 un_m_project3d(double3 a, double3 onto) {
+    double d;
+    double3 result;
 
-    un_m_dot3d(&dot, a, onto);
-    un_m_magnitude_sqr3d(&magn, onto);
+    d  = a.x    * onto.x + a.y    * onto.y + a.z    * onto.z;
+    d /= onto.x * onto.x + onto.y * onto.y + onto.z * onto.z;
 
-    if (magn < EPSILON_D) {
-        un_memory_set((void*)v, 0, sizeof(*v) * 3);
-        return;
-    }
+    result.x = onto.x * d;
+    result.y = onto.y * d;
+    result.z = onto.z * d;
 
-    scale = dot / magn;
-    v[0] = onto[0] * scale;
-    v[1] = onto[1] * scale;
-    v[2] = onto[2] * scale;
+    return result;
 }
 
-void un_m_project4d(f64 *v, f64 *a, f64 *onto) {
-    f64 dot, magn, scale;
+inline double4 un_m_project4d(double4 a, double4 onto) {
+    double d;
+    double4 result;
 
-    un_m_dot4d(&dot, a, onto);
-    un_m_magnitude_sqr4d(&magn, onto);
+    d  = a.x * onto.x + a.y * onto.y + a.z * onto.z + a.w * onto.w;
+    d /= onto.x * onto.x + onto.y * onto.y + onto.z * onto.z + onto.w * onto.w;
 
-    if (magn < EPSILON_D) {
-        un_memory_set((void*)v, 0, sizeof(*v) * 4.0);
-        return;
-    }
+    result.x = onto.x * d;
+    result.y = onto.y * d;
+    result.z = onto.z * d;
+    result.w = onto.w * d;
 
-    scale = dot / magn;
-    v[0] = onto[0] * scale;
-    v[1] = onto[1] * scale;
-    v[2] = onto[2] * scale;
-    v[3] = onto[3] * scale;
+    return result;
 }
 
-void un_m_reflect2d(f64 *v, f64 *a, f64 *normal) {
-    f64 dot;
+inline double2 un_m_reflect2d(double2 a, double2 normal) {
+    double d;
+    double2 result;
+
+    d        = a.x * normal.x + a.y * normal.y;
+    result.x = normal.x * d * 2.0;
+    result.y = normal.y * d * 2.0;
 
-    un_m_dot2d(&dot, a, normal);
-    un_m_mul_scalar2d(v, normal, 2.0 * dot);
-    un_m_sub2d(v, v, a);
+    result.x -= a.x;
+    result.y -= a.y;
+
+    return result;
 }
 
-void un_m_reflect3d(f64 *v, f64 *a, f64 *normal) {
-    f64 dot;
+inline double3 un_m_reflect3d(double3 a, double3 normal) {
+    double d;
+    double3 result;
+
+    d        = a.x * normal.x + a.y * normal.y + a.z * normal.z;
+
+    result.x = normal.x * d * 2.0;
+    result.y = normal.y * d * 2.0;
+    result.z = normal.z * d * 2.0;
+
+    result.x -= a.x;
+    result.y -= a.y;
+    result.z -= a.z;
 
-    un_m_dot3d(&dot, a, normal);
-    un_m_mul_scalar3d(v, normal, 2.0 * dot);
-    un_m_sub3d(v, v, a);
+    return result;
 }
 
-void un_m_reflect4d(f64 *v, f64 *a, f64 *normal) {
-    f64 dot;
+inline double4 un_m_reflect4d(double4 a, double4 normal) {
+    double d;
+    double4 result;
+
+    d        = a.x * normal.x + a.y * normal.y + a.z * normal.z + a.w * normal.w;
+
+    result.x = normal.x * d * 2.0;
+    result.y = normal.y * d * 2.0;
+    result.z = normal.z * d * 2.0;
+    result.w = normal.w * d * 2.0;
+
+    result.x -= a.x;
+    result.y -= a.y;
+    result.z -= a.z;
+    result.w -= a.w;
 
-    un_m_dot4d(&dot, a, normal);
-    un_m_mul_scalar4d(v, normal, 2.0 * dot);
-    un_m_sub4d(v, v, a);
+    return result;
 }