Use and refator generics

include/core/Generic.h

@@ -4,44 +4,39 @@
 #include "core/Matrix.h"
 
 #ifdef IMPORT_CORE
-#define addSet(a, b)                                                           \
+#define GENERIC_FLOAT_VECTOR(a, name)                                          \
     _Generic((a),                                                              \
-        Vector2 *: addSetV2,                                                   \
-        Vector3 *: addSetV3,                                                   \
-        Vector4 *: addSetV4,                                                   \
-        IntVector2 *: addSetIV2,                                               \
-        IntVector3 *: addSetIV3,                                               \
-        IntVector4 *: addSetIV4)(a, b)
-
-#define add(a, b, c)                                                           \
-    _Generic((a),                                                              \
-        Vector2 *: addV2,                                                      \
-        Vector3 *: addV3,                                                      \
-        Vector4 *: addV4,                                                      \
-        IntVector2 *: addIV2,                                                  \
-        IntVector3 *: addIV3,                                                  \
-        IntVector4 *: addIV4)(a, b, c)
-
-#define subSet(a, b)                                                           \
-    _Generic((a),                                                              \
-        Vector2 *: subSetV2,                                                   \
-        Vector3 *: subSetV3,                                                   \
-        Vector4 *: subSetV4,                                                   \
-        IntVector2 *: subSetIV2,                                               \
-        IntVector3 *: subSetIV3,                                               \
-        IntVector4 *: subSetIV4)(a, b)
-
-#define sub(a, b, c)                                                           \
+        Vector2 *: name##V2,                                                   \
+        const Vector2*: name##V2,                                              \
+        Vector3*: name##V3,                                                    \
+        const Vector3*: name##V3,                                              \
+        Vector4*: name##V4,                                                    \
+        const Vector4*: name##V4)
+
+#define GENERIC_VECTOR(a, name)                                                \
     _Generic((a),                                                              \
-        Vector2 *: subV2,                                                      \
-        Vector3 *: subV3,                                                      \
-        Vector4 *: subV4,                                                      \
-        IntVector2 *: subIV2,                                                  \
-        IntVector3 *: subIV3,                                                  \
-        IntVector4 *: subIV4)(a, b, c)
+        Vector2 *: name##V2,                                                   \
+        const Vector2*: name##V2,                                              \
+        Vector3*: name##V3,                                                    \
+        const Vector3*: name##V3,                                              \
+        Vector4*: name##V4,                                                    \
+        const Vector4*: name##V4,                                              \
+        IntVector2*: name##IV2,                                                \
+        const IntVector2*: name##IV2,                                          \
+        IntVector3*: name##IV3,                                                \
+        const IntVector3*: name##IV3,                                          \
+        IntVector4*: name##IV4,                                                \
+        const IntVector4*: name##IV4)
+
+#define addSet(a, b) GENERIC_VECTOR(a, addSet)(a, b)
+#define add(a, b, c) GENERIC_VECTOR(a, add)(a, b, c)
+#define subSet(a, b) GENERIC_VECTOR(a, subSet)(a, b)
+#define sub(a, b, c) GENERIC_VECTOR(a, sub)(a, b, c)
 
 #define mulSet(a, b)                                                           \
     _Generic((a),                                                              \
+        Matrix *: mulSetMatrix,                                                \
+        Quaternion *: mulSetQ,                                                 \
         Vector2 *: _Generic((b), Vector2 *: mulSetV2, default: mulSetV2F),     \
         Vector3 *: _Generic((b), Vector3 *: mulSetV3, default: mulSetV3F),     \
         Vector4 *: _Generic((b), Vector4 *: mulSetV4, default: mulSetV4F),     \
@@ -57,10 +52,15 @@
 
 #define mul(a, b, c)                                                           \
     _Generic((a),                                                              \
+        Matrix *: mulMatrix,                                                   \
+        Quaternion *: mulQ,                                                    \
         Vector2 *: _Generic((c), Vector2 *: mulV2, default: mulV2F),           \
         Vector3 *: _Generic((c),                                               \
                  Vector3 *: _Generic((b),                                      \
+                          Quaternion *: mulQV3,                                \
                           const Quaternion*: mulQV3,                           \
+                          const Matrix*: mulMatrixV3,                          \
+                          Matrix*: mulMatrixV3,                                \
                           default: mulV3),                                     \
                  default: mulV3F),                                             \
         Vector4 *: _Generic((c), Vector4 *: mulV4, default: mulV4F),           \
@@ -94,50 +94,12 @@
         IntVector4 *: _Generic((c), IntVector4 *: divIV4, default: divIV4F))(  \
         a, b, c)
 
-#define invertSet(a)                                                           \
-    _Generic((a),                                                              \
-        Vector2 *: invertSetV2,                                                \
-        Vector3 *: invertSetV3,                                                \
-        Vector4 *: invertSetV4,                                                \
-        IntVector2 *: invertSetIV2,                                            \
-        IntVector3 *: invertSetIV3,                                            \
-        IntVector4 *: invertSetIV4)(a)
-
-#define invert(a, b)                                                           \
-    _Generic((a),                                                              \
-        Vector2 *: invertV2,                                                   \
-        Vector3 *: invertV3,                                                   \
-        Vector4 *: invertV4,                                                   \
-        IntVector2 *: invertIV2,                                               \
-        IntVector3 *: invertIV3,                                               \
-        IntVector4 *: invertIV4)(a, b)
-
-#define dot(a, b)                                                              \
-    _Generic((a),                                                              \
-        Vector2 *: dotV2,                                                      \
-        const Vector2*: dotV2,                                                 \
-        Vector3*: dotV3,                                                       \
-        const Vector3*: dotV3,                                                 \
-        Vector4*: dotV4,                                                       \
-        const Vector4*: dotV4)(a, b)
-
-#define squareLength(a)                                                        \
-    _Generic((a),                                                              \
-        Vector2 *: squareLengthV2,                                             \
-        Vector3 *: squareLengthV3,                                             \
-        Vector4 *: squareLengthV4)(a)
-
-#define length(a)                                                              \
-    _Generic((a),                                                              \
-        Vector2 *: lengthV2,                                                   \
-        Vector3 *: lengthV3,                                                   \
-        Vector4 *: lengthV4)(a)
-
-#define normalize(a)                                                           \
-    _Generic((a),                                                              \
-        Vector2 *: normalizeV2,                                                \
-        Vector3 *: normalizeV3,                                                \
-        Vector4 *: normalizeV4)(a)
+#define invertSet(a) GENERIC_VECTOR(a, invertSet)(a)
+#define invert(a, b) GENERIC_VECTOR(a, invert)(a, b)
+#define dot(a, b) GENERIC_FLOAT_VECTOR(a, dot)(a, b)
+#define squareLength(a) GENERIC_FLOAT_VECTOR(a, squareLength)(a)
+#define length(a) GENERIC_FLOAT_VECTOR(a, length)(a)
+#define normalize(a) GENERIC_FLOAT_VECTOR(a, normalize)(a)
 
 #define convert(a, b)                                                          \
     _Generic((a),                                                              \

src/Quaternion.c

@@ -1,37 +1,36 @@
-#include "core/Quaternion.h"
-
 #include <math.h>
 
+#include "core/Generic.h"
 #include "core/Utility.h"
 
-#define mulC(a, b) mulV3F(&VECTOR3, (a), (b))
+#define mulC(a, b) mul(&VECTOR3, (a), (b))
 #define crossC(a, b) cross(&VECTOR3, (a), (b))
-#define addC(a, b) addV3(&VECTOR3, (a), (b))
-#define subC(a, b) subV3(&VECTOR3, (a), (b))
+#define addC(a, b) add(&VECTOR3, (a), (b))
+#define subC(a, b) sub(&VECTOR3, (a), (b))
 
 Quaternion* axisAngleQ(Quaternion* q, const Vector3* axis, float angle) {
     q->xyz = *axis;
-    normalizeV3(&q->xyz);
+    normalize(&q->xyz);
     angle = degreeToRadian(angle) * 0.5f;
     q->w = cosf(angle);
-    mulSetV3F(&q->xyz, sinf(angle));
+    mulSet(&q->xyz, sinf(angle));
     return q;
 }
 
 Quaternion* lerpQ(Quaternion* q, const Quaternion* a, float f,
                   const Quaternion* b) {
-    addV3(&q->xyz, mulC(&a->xyz, 1.0f - f), mulC(&b->xyz, f));
+    add(&q->xyz, mulC(&a->xyz, 1.0f - f), mulC(&b->xyz, f));
     q->w = a->w * (1.0f - f) + b->w * f;
     float iLength = 1.0f / sqrtf(squareLengthV3(&q->xyz) + q->w * q->w);
-    mulSetV3F(&q->xyz, iLength);
+    mulSet(&q->xyz, iLength);
     q->w *= iLength;
     return q;
 }
 
 Quaternion* mulSetQ(Quaternion* q, const Quaternion* o) {
     float dot = dotV3(&q->xyz, &o->xyz);
-    addV3(&q->xyz, mulC(&o->xyz, q->w),
-          addC(mulC(&q->xyz, o->w), crossC(&q->xyz, &o->xyz)));
+    add(&q->xyz, mulC(&o->xyz, q->w),
+        addC(mulC(&q->xyz, o->w), crossC(&q->xyz, &o->xyz)));
     q->w = q->w * o->w - dot;
     return q;
 }
@@ -44,9 +43,9 @@ Quaternion* mulQ(Quaternion* q, const Quaternion* a, const Quaternion* b) {
 
 Vector3* mulQV3(Vector3* r, const Quaternion* q, const Vector3* v) {
     Vector3 qv;
-    addV3(&qv, mulC(v, q->w), crossC(&q->xyz, v));
-    addV3(r, mulC(&q->xyz, dotV3(&q->xyz, v)),
-          subC(mulC(&qv, q->w), crossC(&qv, &q->xyz)));
+    add(&qv, mulC(v, q->w), crossC(&q->xyz, v));
+    add(r, mulC(&q->xyz, dotV3(&q->xyz, v)),
+        subC(mulC(&qv, q->w), crossC(&qv, &q->xyz)));
     return r;
 }
 

test/modules/MatrixTests.c

@@ -1,5 +1,5 @@
 #include "../Tests.h"
-#include "core/Matrix.h"
+#include "core/Generic.h"
 
 typedef CoreVector3 V3;
 #define CV3(a, b, c) (&(V3){{a, b, c}})
@@ -42,43 +42,37 @@ static void testTranspose() {
 static void testScale() {
     Matrix m = UNIT_MATRIX;
     scaleMatrix(&m, CV3(2.0f, 3.0f, 4.0f));
-    TEST_V3(CV3(-8.0f, 18.0f, 28.0f),
-            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+    TEST_V3(CV3(-8.0f, 18.0f, 28.0f), mul(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testUniformScale() {
     Matrix m = UNIT_MATRIX;
     scaleMatrixF(&m, 2.0f);
-    TEST_V3(CV3(-8.0f, 12.0f, 14.0f),
-            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+    TEST_V3(CV3(-8.0f, 12.0f, 14.0f), mul(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateX() {
     Matrix m = UNIT_MATRIX;
     translateMatrixX(&m, 5.0f);
-    TEST_V3(CV3(1.0f, 6.0f, 7.0f),
-            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+    TEST_V3(CV3(1.0f, 6.0f, 7.0f), mul(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateY() {
     Matrix m = UNIT_MATRIX;
     translateMatrixY(&m, 6.0f);
-    TEST_V3(CV3(-4.0f, 12.0f, 7.0f),
-            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+    TEST_V3(CV3(-4.0f, 12.0f, 7.0f), mul(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateZ() {
     Matrix m = UNIT_MATRIX;
     translateMatrixZ(&m, 7.0f);
-    TEST_V3(CV3(-4.0f, 6.0f, 14.0f),
-            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+    TEST_V3(CV3(-4.0f, 6.0f, 14.0f), mul(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslate() {
     Matrix m = UNIT_MATRIX;
     translateMatrix(&m, CV3(1.0f, 2.0f, 3.0f));
-    TEST_V3(CV3(-3.0f, 8.0f, 10.0f),
-            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+    TEST_V3(CV3(-3.0f, 8.0f, 10.0f), mul(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateTo() {
@@ -103,8 +97,7 @@ static void testCombination() {
     translateMatrix(&m, CV3(-4.0f, 2.0f, 3.0f));
     scaleMatrix(&m, CV3(2.0f, 3.0f, 4.0f));
     scaleMatrixF(&m, 0.5f);
-    TEST_V3(CV3(-1.0f, 9.0f, 16.0f),
-            mulMatrixV3(CV30, &m, CV3(1.0f, 1.0f, 1.0f)));
+    TEST_V3(CV3(-1.0f, 9.0f, 16.0f), mul(CV30, &m, CV3(1.0f, 1.0f, 1.0f)));
 }
 
 static void testMatrixCombination() {
@@ -119,43 +112,33 @@ static void testMatrixCombination() {
     Matrix c = UNIT_MATRIX;
     translateMatrix(&c, CV3(-1.0f, -2.0f, -3.0f));
 
-    mulSetMatrix(&c, mulMatrix(&ZERO_MATRIX, &b, &a));
+    mulSet(&c, mul(&ZERO_MATRIX, &b, &a));
 
-    TEST_V3(CV3(9.0f, 11.0f, 13.0f),
-            mulMatrixV3(CV30, &c, CV3(1.0f, 1.0f, 1.0f)));
+    TEST_V3(CV3(9.0f, 11.0f, 13.0f), mul(CV30, &c, CV3(1.0f, 1.0f, 1.0f)));
 }
 
 static void testRotateX() {
     Matrix m = UNIT_MATRIX;
     rotateMatrixX(&m, 90.0f);
-    TEST_V3(CV3(1.0f, 0.0f, 0.0f),
-            mulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
-    TEST_V3(CV3(0.0f, 0.0f, 1.0f),
-            mulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
-    TEST_V3(CV3(0.0f, -1.0f, 0.0f),
-            mulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
+    TEST_V3(CV3(1.0f, 0.0f, 0.0f), mul(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
+    TEST_V3(CV3(0.0f, 0.0f, 1.0f), mul(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
+    TEST_V3(CV3(0.0f, -1.0f, 0.0f), mul(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
 }
 
 static void testRotateY() {
     Matrix m = UNIT_MATRIX;
     rotateMatrixY(&m, 90.0f);
-    TEST_V3(CV3(0.0f, 0.0f, -1.0f),
-            mulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
-    TEST_V3(CV3(0.0f, 1.0f, 0.0f),
-            mulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
-    TEST_V3(CV3(1.0f, 0.0f, 0.0f),
-            mulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
+    TEST_V3(CV3(0.0f, 0.0f, -1.0f), mul(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
+    TEST_V3(CV3(0.0f, 1.0f, 0.0f), mul(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
+    TEST_V3(CV3(1.0f, 0.0f, 0.0f), mul(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
 }
 
 static void testRotateZ() {
     Matrix m = UNIT_MATRIX;
     rotateMatrixZ(&m, 90.0f);
-    TEST_V3(CV3(0.0f, 1.0f, 0.0f),
-            mulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
-    TEST_V3(CV3(-1.0f, 0.0f, 0.0f),
-            mulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
-    TEST_V3(CV3(0.0f, 0.0f, 1.0f),
-            mulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
+    TEST_V3(CV3(0.0f, 1.0f, 0.0f), mul(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
+    TEST_V3(CV3(-1.0f, 0.0f, 0.0f), mul(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
+    TEST_V3(CV3(0.0f, 0.0f, 1.0f), mul(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
 }
 
 static void testQuaternionMatrix() {

test/modules/QuaternionTests.c

@@ -1,5 +1,5 @@
 #include "../Tests.h"
-#include "core/Quaternion.h"
+#include "core/Generic.h"
 
 #define CV3(a, b, c) (&(Vector3){{a, b, c}})
 #define CV30 CV3(0.0f, 0.0f, 0.0f)
@@ -38,7 +38,7 @@ static void testMulSet() {
     Quaternion q2 = UNIT_QUATERNION;
     axisAngleQ(&q2, CV3(2.0f, 5.0f, 7.0f), 60.0f);
     Quaternion q3 = UNIT_QUATERNION;
-    mulSetQ(&q3, &q1);
+    mulSet(&q3, &q1);
 
     char bufferQ1[128];
     toStringQ(&q1, bufferQ1, sizeof(bufferQ1));
@@ -46,7 +46,7 @@ static void testMulSet() {
     toStringQ(&q3, bufferQ3, sizeof(bufferQ3));
     TEST_STRING(bufferQ1, bufferQ3);
 
-    mulSetQ(&q3, &q2);
+    mulSet(&q3, &q2);
     toStringQ(&q3, bufferQ3, sizeof(bufferQ3));
 
     axisAngleQ(&q1, CV3(2.0f, 5.0f, 7.0f), 110.0f);
@@ -61,7 +61,7 @@ static void testMul() {
     Quaternion q2 = UNIT_QUATERNION;
     axisAngleQ(&q2, CV3(2.0f, 5.0f, 7.0f), 60.0f);
     Quaternion q3 = UNIT_QUATERNION;
-    mulQ(&q3, &q1, &q2);
+    mul(&q3, &q1, &q2);
 
     char bufferQ3[128];
     toStringQ(&q3, bufferQ3, sizeof(bufferQ3));
@@ -86,15 +86,15 @@ static void testMulVector() {
     Vector3 v2 = {{0.0f, 1.0f, 0.0f}};
     Vector3 v3 = {{0.0f, 0.0f, 1.0f}};
 
-    TEST_V3(CV3(1.0f, 0.0f, 0.0f), mulQV3(CV30, &q1, &v1));
-    TEST_V3(CV3(0.0f, 0.0f, 1.0f), mulQV3(CV30, &q1, &v2));
-    TEST_V3(CV3(0.0f, -1.0f, 0.0f), mulQV3(CV30, &q1, &v3));
-    TEST_V3(CV3(0.0f, 0.0f, -1.0f), mulQV3(CV30, &q2, &v1));
-    TEST_V3(CV3(0.0f, 1.0f, 0.0f), mulQV3(CV30, &q2, &v2));
-    TEST_V3(CV3(1.0f, 0.0f, 0.0f), mulQV3(CV30, &q2, &v3));
-    TEST_V3(CV3(0.0f, 1.0f, 0.0f), mulQV3(CV30, &q3, &v1));
-    TEST_V3(CV3(-1.0f, 0.0f, 0.0f), mulQV3(CV30, &q3, &v2));
-    TEST_V3(CV3(0.0f, 0.0f, 1.0f), mulQV3(CV30, &q3, &v3));
+    TEST_V3(CV3(1.0f, 0.0f, 0.0f), mul(CV30, &q1, &v1));
+    TEST_V3(CV3(0.0f, 0.0f, 1.0f), mul(CV30, &q1, &v2));
+    TEST_V3(CV3(0.0f, -1.0f, 0.0f), mul(CV30, &q1, &v3));
+    TEST_V3(CV3(0.0f, 0.0f, -1.0f), mul(CV30, &q2, &v1));
+    TEST_V3(CV3(0.0f, 1.0f, 0.0f), mul(CV30, &q2, &v2));
+    TEST_V3(CV3(1.0f, 0.0f, 0.0f), mul(CV30, &q2, &v3));
+    TEST_V3(CV3(0.0f, 1.0f, 0.0f), mul(CV30, &q3, &v1));
+    TEST_V3(CV3(-1.0f, 0.0f, 0.0f), mul(CV30, &q3, &v2));
+    TEST_V3(CV3(0.0f, 0.0f, 1.0f), mul(CV30, &q3, &v3));
 }
 
 void testQuaternion() {