First draft of generics

include/core/Generic.h

@@ -0,0 +1,142 @@
+#ifndef CORE_GENERIC_H
+#define CORE_GENERIC_H
+
+#ifdef IMPORT_CORE
+#define addSet(a, b)                                                           \
+    _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)                                                           \
+    _Generic((a),                                                              \
+        Vector2 *: subV2,                                                      \
+        Vector3 *: subV3,                                                      \
+        Vector4 *: subV4,                                                      \
+        IntVector2 *: subIV2,                                                  \
+        IntVector3 *: subIV3,                                                  \
+        IntVector4 *: subIV4)(a, b, c)
+
+#define mulSet(a, b)                                                           \
+    _Generic((a),                                                              \
+        Vector2 *: _Generic((b), Vector2 *: mulSetV2, default: mulSetV2F),     \
+        Vector3 *: _Generic((b), Vector3 *: mulSetV3, default: mulSetV3F),     \
+        Vector4 *: _Generic((b), Vector4 *: mulSetV4, default: mulSetV4F),     \
+        IntVector2 *: _Generic((b),                                            \
+                    IntVector2 *: mulSetIV2,                                   \
+                    default: mulSetIV2F),                                      \
+        IntVector3 *: _Generic((b),                                            \
+                    IntVector3 *: mulSetIV3,                                   \
+                    default: mulSetIV3F),                                      \
+        IntVector4 *: _Generic((b),                                            \
+                    IntVector4 *: mulSetIV4,                                   \
+                    default: mulSetIV4F))(a, b)
+
+#define mul(a, b, c)                                                           \
+    _Generic((a),                                                              \
+        Vector2 *: _Generic((c), Vector2 *: mulV2, default: mulV2F),           \
+        Vector3 *: _Generic((c), Vector3 *: mulV3, default: mulV3F),           \
+        Vector4 *: _Generic((c), Vector4 *: mulV4, default: mulV4F),           \
+        IntVector2 *: _Generic((c), IntVector2 *: mulIV2, default: mulIV2F),   \
+        IntVector3 *: _Generic((c), IntVector3 *: mulIV3, default: mulIV3F),   \
+        IntVector4 *: _Generic((c), IntVector4 *: mulIV4, default: mulIV4F))(  \
+        a, b, c)
+
+#define divSet(a, b)                                                           \
+    _Generic((a),                                                              \
+        Vector2 *: _Generic((b), Vector2 *: divSetV2, default: divSetV2F),     \
+        Vector3 *: _Generic((b), Vector3 *: divSetV3, default: divSetV3F),     \
+        Vector4 *: _Generic((b), Vector4 *: divSetV4, default: divSetV4F),     \
+        IntVector2 *: _Generic((b),                                            \
+                    IntVector2 *: divSetIV2,                                   \
+                    default: divSetIV2F),                                      \
+        IntVector3 *: _Generic((b),                                            \
+                    IntVector3 *: divSetIV3,                                   \
+                    default: divSetIV3F),                                      \
+        IntVector4 *: _Generic((b),                                            \
+                    IntVector4 *: divSetIV4,                                   \
+                    default: divSetIV4F))(a, b)
+
+#define div(a, b, c)                                                           \
+    _Generic((a),                                                              \
+        Vector2 *: _Generic((c), Vector2 *: divV2, default: divV2F),           \
+        Vector3 *: _Generic((c), Vector3 *: divV3, default: divV3F),           \
+        Vector4 *: _Generic((c), Vector4 *: divV4, default: divV4F),           \
+        IntVector2 *: _Generic((c), IntVector2 *: divIV2, default: divIV2F),   \
+        IntVector3 *: _Generic((c), IntVector3 *: divIV3, default: divIV3F),   \
+        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, Vector3 *: dotV3, 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 convert(a, b)                                                          \
+    _Generic((a),                                                              \
+        Vector2 *: convertIV2,                                                 \
+        Vector3 *: convertIV3,                                                 \
+        Vector4 *: convertIV4,                                                 \
+        IntVector2 *: convertV2,                                               \
+        IntVector3 *: convertV3,                                               \
+        IntVector4 *: convertV4)(a, b)
+
+// #define toStringV2 coreToStringV2
+#endif
+
+#endif

include/core/Vector.h

@@ -1,6 +1,7 @@
 #ifndef CORE_VECTOR_H
 #define CORE_VECTOR_H
 
+#include "core/Generic.h"
 #include "core/Types.h"
 
 #define CORE_VECTOR_OP2(name) name *r, const name *a

test/modules/VectorTests.c

@@ -82,9 +82,9 @@ static void testSetAdd() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(0, 0, 0, 0);                                               \
-        addSet##T(&v, C##T(1, 2, 3, 4));                                       \
+        addSet(&v, C##T(1, 2, 3, 4));                                          \
         TEST_##T(C##T(1, 2, 3, 4), &v);                                        \
-        addSet##T(&v, C##T(2, 3, 4, 5));                                       \
+        addSet(&v, C##T(2, 3, 4, 5));                                          \
         TEST_##T(C##T(3, 5, 7, 9), &v);                                        \
     }
     TESTS
@@ -92,17 +92,17 @@ static void testSetAdd() {
 }
 
 static void testAdd() {
-    TEST_V3(FV3(1, 2, 3), addV3(CV30, CV30, FV3(1, 2, 3)));
-    TEST_V3(FV3(3, 5, 7), addV3(CV30, FV3(1, 2, 3), FV3(2, 3, 4)));
+    TEST_V3(FV3(1, 2, 3), add(CV30, CV30, FV3(1, 2, 3)));
+    TEST_V3(FV3(3, 5, 7), add(CV30, FV3(1, 2, 3), FV3(2, 3, 4)));
 }
 
 static void testSetSub() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(0, 0, 0, 0);                                               \
-        subSet##T(&v, C##T(1, 2, 3, 4));                                       \
+        subSet(&v, C##T(1, 2, 3, 4));                                          \
         TEST_##T(C##T(-1, -2, -3, -4), &v);                                    \
-        subSet##T(&v, C##T(2, 3, 4, 5));                                       \
+        subSet(&v, C##T(2, 3, 4, 5));                                          \
         TEST_##T(C##T(-3, -5, -7, -9), &v);                                    \
     }
     TESTS
@@ -110,17 +110,17 @@ static void testSetSub() {
 }
 
 static void testSub() {
-    TEST_V3(FV3(1, 2, 3), subV3(CV30, CV30, FV3(-1, -2, -3)));
-    TEST_V3(FV3(-1, -1, -1), subV3(CV30, FV3(1, 2, 3), FV3(2, 3, 4)));
+    TEST_V3(FV3(1, 2, 3), sub(CV30, CV30, FV3(-1, -2, -3)));
+    TEST_V3(FV3(-1, -1, -1), sub(CV30, FV3(1, 2, 3), FV3(2, 3, 4)));
 }
 
 static void testSetMul() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(1, 2, 3, 4);                                               \
-        mulSet##T##F(&v, 3);                                                   \
+        mulSet(&v, 3);                                                         \
         TEST_##T(C##T(3, 6, 9, 12), &v);                                       \
-        mulSet##T##F(&v, -2);                                                  \
+        mulSet(&v, -2);                                                        \
         TEST_##T(C##T(-6, -12, -18, -24), &v);                                 \
     }
     TESTS
@@ -128,16 +128,16 @@ static void testSetMul() {
 }
 
 static void testMul() {
-    TEST_V3(FV3(3, 6, 9), mulV3F(CV30, FV3(1, 2, 3), 3));
+    TEST_V3(FV3(3, 6, 9), mul(CV30, FV3(1, 2, 3), 3));
 }
 
 static void testSetMulVector() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(1, 2, 3, 4);                                               \
-        mulSet##T(&v, C##T(2, 1, 3, 4));                                       \
+        mulSet(&v, C##T(2, 1, 3, 4));                                          \
         TEST_##T(C##T(2, 2, 9, 16), &v);                                       \
-        mulSet##T(&v, C##T(-3, 4, -2, -2));                                    \
+        mulSet(&v, C##T(-3, 4, -2, -2));                                       \
         TEST_##T(C##T(-6, 8, -18, -32), &v);                                   \
     }
     TESTS
@@ -145,17 +145,17 @@ static void testSetMulVector() {
 }
 
 static void testMulVector() {
-    TEST_V3(FV3(-2, -2, -9), mulV3(CV30, FV3(2, 1, 3), FV3(-1, -2, -3)));
-    TEST_V3(FV3(2, 2, 9), mulV3(CV30, FV3(1, 2, 3), FV3(2, 1, 3)));
+    TEST_V3(FV3(-2, -2, -9), mul(CV30, FV3(2, 1, 3), FV3(-1, -2, -3)));
+    TEST_V3(FV3(2, 2, 9), mul(CV30, FV3(1, 2, 3), FV3(2, 1, 3)));
 }
 
 static void testSetDiv() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(18, 36, 9, 27);                                            \
-        divSet##T##F(&v, 3);                                                   \
+        divSet(&v, 3);                                                         \
         TEST_##T(C##T(6, 12, 3, 9), &v);                                       \
-        divSet##T##F(&v, -3);                                                  \
+        divSet(&v, -3);                                                        \
         TEST_##T(C##T(-2, -4, -1, -3), &v);                                    \
     }
     TESTS
@@ -163,16 +163,16 @@ static void testSetDiv() {
 }
 
 static void testDiv() {
-    TEST_V3(FV3(-1, -2, -3), divV3F(CV30, FV3(-3, -6, -9), 3));
+    TEST_V3(FV3(-1, -2, -3), div(CV30, FV3(-3, -6, -9), 3));
 }
 
 static void testSetDivVector() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(12, 4, 6, 8);                                              \
-        divSet##T(&v, C##T(2, 1, 3, 4));                                       \
+        divSet(&v, C##T(2, 1, 3, 4));                                          \
         TEST_##T(C##T(6, 4, 2, 2), &v);                                        \
-        divSet##T(&v, C##T(-3, 4, -2, -1));                                    \
+        divSet(&v, C##T(-3, 4, -2, -1));                                       \
         TEST_##T(C##T(-2, 1, -1, -2), &v);                                     \
     }
     TESTS
@@ -180,93 +180,93 @@ static void testSetDivVector() {
 }
 
 static void testDivVector() {
-    TEST_V3(FV3(-2, -0.5f, -1), divV3(CV30, FV3(2, 1, 3), FV3(-1, -2, -3)));
-    TEST_V3(FV3(0.5f, 2, 1), divV3(CV30, FV3(1, 2, 3), FV3(2, 1, 3)));
+    TEST_V3(FV3(-2, -0.5f, -1), div(CV30, FV3(2, 1, 3), FV3(-1, -2, -3)));
+    TEST_V3(FV3(0.5f, 2, 1), div(CV30, FV3(1, 2, 3), FV3(2, 1, 3)));
 }
 
 static void testSetInvert() {
-    TEST_V2(FV2(-1, 2), invertSetV2(FV2(1, -2)));
-    TEST_V3(FV3(-1, 2, 3), invertSetV3(FV3(1, -2, -3)));
-    TEST_V4(CV4(-1, 2, 3, 4), invertSetV4(CV4(1, -2, -3, -4)));
-    TEST_IV2(FIV2(-1, 2), invertSetIV2(FIV2(1, -2)));
-    TEST_IV3(FIV3(-1, 2, 3), invertSetIV3(FIV3(1, -2, -3)));
-    TEST_IV4(CIV4(-1, 2, 3, 4), invertSetIV4(CIV4(1, -2, -3, -4)));
+    TEST_V2(FV2(-1, 2), invertSet(FV2(1, -2)));
+    TEST_V3(FV3(-1, 2, 3), invertSet(FV3(1, -2, -3)));
+    TEST_V4(CV4(-1, 2, 3, 4), invertSet(CV4(1, -2, -3, -4)));
+    TEST_IV2(FIV2(-1, 2), invertSet(FIV2(1, -2)));
+    TEST_IV3(FIV3(-1, 2, 3), invertSet(FIV3(1, -2, -3)));
+    TEST_IV4(CIV4(-1, 2, 3, 4), invertSet(CIV4(1, -2, -3, -4)));
 }
 
 static void testInvert() {
-    TEST_V3(FV3(-1, 2, 3), invertV3(CV30, FV3(1, -2, -3)));
+    TEST_V3(FV3(-1, 2, 3), invert(CV30, FV3(1, -2, -3)));
 }
 
 static void testDot() {
-    TEST_FLOAT(0, dotV2(FV2(-4, 2), FV2(-1, -2)), eps);
-    TEST_FLOAT(9, dotV3(FV3(-4, 2, -3), FV3(-1, -2, -3)), eps);
-    TEST_FLOAT(16, dotV4(CV4(-4, 2, -3, 1), CV4(-1, -2, -3, 7)), eps);
+    TEST_FLOAT(0, dot(FV2(-4, 2), FV2(-1, -2)), eps);
+    TEST_FLOAT(9, dot(FV3(-4, 2, -3), FV3(-1, -2, -3)), eps);
+    TEST_FLOAT(16, dot(CV4(-4, 2, -3, 1), CV4(-1, -2, -3, 7)), eps);
 }
 
 static void testSquareLength() {
-    TEST_FLOAT(20, squareLengthV2(FV2(-4, 2)), eps);
-    TEST_FLOAT(29, squareLengthV3(FV3(-4, 2, -3)), eps);
-    TEST_FLOAT(54, squareLengthV4(CV4(-4, 2, -3, 5)), eps);
+    TEST_FLOAT(20, squareLength(FV2(-4, 2)), eps);
+    TEST_FLOAT(29, squareLength(FV3(-4, 2, -3)), eps);
+    TEST_FLOAT(54, squareLength(CV4(-4, 2, -3, 5)), eps);
 }
 
 static void testLength() {
-    TEST_FLOAT(5, lengthV2(FV2(-3, 4)), eps);
-    TEST_FLOAT(13, lengthV2(FV2(5, 12)), eps);
-    TEST_FLOAT(3, lengthV3(FV3(-2, 2, -1)), eps);
-    TEST_FLOAT(7, lengthV3(FV3(6, 2, -3)), eps);
-    TEST_FLOAT(3, lengthV4(CV4(-2, 2, 0, -1)), eps);
-    TEST_FLOAT(9, lengthV4(CV4(6, 0, -6, 3)), eps);
+    TEST_FLOAT(5, length(FV2(-3, 4)), eps);
+    TEST_FLOAT(13, length(FV2(5, 12)), eps);
+    TEST_FLOAT(3, length(FV3(-2, 2, -1)), eps);
+    TEST_FLOAT(7, length(FV3(6, 2, -3)), eps);
+    TEST_FLOAT(3, length(CV4(-2, 2, 0, -1)), eps);
+    TEST_FLOAT(9, length(CV4(6, 0, -6, 3)), eps);
 }
 
 static void testNormalize() {
     {
         V2 v1 = {{-15, 20}};
         V2 v2;
-        mulV2F(&v2, &v1, 1.0f / 25.0f);
-        normalizeV2(&v1);
+        mul(&v2, &v1, 1.0f / 25.0f);
+        normalize(&v1);
         TEST_V2(&v2, &v1);
 
         V2 v3 = {{15, 36}};
         V2 v4;
-        mulV2F(&v4, &v3, 1.0f / 39.0f);
-        normalizeV2(&v3);
+        mul(&v4, &v3, 1.0f / 39.0f);
+        normalize(&v3);
         TEST_V2(&v4, &v3);
     }
     {
         V3 v1 = {{-2, 2, -1}};
         V3 v2;
-        mulV3F(&v2, &v1, 1.0f / 3.0f);
-        normalizeV3(&v1);
+        mul(&v2, &v1, 1.0f / 3.0f);
+        normalize(&v1);
         TEST_V3(&v2, &v1);
 
         V3 v3 = {{6, 2, -3}};
         V3 v4;
-        mulV3F(&v4, &v3, 1.0f / 7.0f);
-        normalizeV3(&v3);
+        mul(&v4, &v3, 1.0f / 7.0f);
+        normalize(&v3);
         TEST_V3(&v4, &v3);
     }
     {
         V4 v1 = {{-2, 2, 0, -1}};
         V4 v2;
-        mulV4F(&v2, &v1, 1.0f / 3.0f);
-        normalizeV4(&v1);
+        mul(&v2, &v1, 1.0f / 3.0f);
+        normalize(&v1);
         TEST_V4(&v2, &v1);
 
         V4 v3 = {{6, 0, -6, 3}};
         V4 v4;
-        mulV4F(&v4, &v3, 1.0f / 9.0f);
-        normalizeV4(&v3);
+        mul(&v4, &v3, 1.0f / 9.0f);
+        normalize(&v3);
         TEST_V4(&v4, &v3);
     }
 }
 
 static void testCast() {
-    TEST_V2(FV2(-2.0f, 2.0f), convertIV2(CV20, FIV2(-2, 2)));
-    TEST_IV2(FIV2(-2, 2), convertV2(CIV20, FV2(-2.5f, 2.6f)));
-    TEST_V3(FV3(-2.0f, 2.0f, 9.0f), convertIV3(CV30, FIV3(-2, 2, 9)));
-    TEST_IV3(FIV3(-2, 2, 9), convertV3(CIV30, FV3(-2.5f, 2.6f, 9.0f)));
-    TEST_V4(CV4(-2.0f, 2.0f, 9.0f, 6.0f), convertIV4(CV40, CIV4(-2, 2, 9, 6)));
-    TEST_IV4(CIV4(-2, 2, 9, 3), convertV4(CIV40, CV4(-2.5f, 2.6f, 9.0f, 3.2f)));
+    TEST_V2(FV2(-2.0f, 2.0f), convert(CV20, FIV2(-2, 2)));
+    TEST_IV2(FIV2(-2, 2), convert(CIV20, FV2(-2.5f, 2.6f)));
+    TEST_V3(FV3(-2.0f, 2.0f, 9.0f), convert(CV30, FIV3(-2, 2, 9)));
+    TEST_IV3(FIV3(-2, 2, 9), convert(CIV30, FV3(-2.5f, 2.6f, 9.0f)));
+    TEST_V4(CV4(-2.0f, 2.0f, 9.0f, 6.0f), convert(CV40, CIV4(-2, 2, 9, 6)));
+    TEST_IV4(CIV4(-2, 2, 9, 3), convert(CIV40, CV4(-2.5f, 2.6f, 9.0f, 3.2f)));
 }
 
 static void testToString() {