Add namespace import to Quaternion and Vector

include/core/Quaternion.h

@@ -21,4 +21,15 @@ CoreVector3* coreMulQV3(CoreVector3* r, const CoreQuaternion* q,
                         const CoreVector3* v);
 size_t coreToStringQ(const CoreQuaternion* q, char* buffer, size_t n);
 
+#ifdef IMPORT_CORE
+#define Quaternion CoreQuaternion
+#define UNIT_QUATERNION CORE_UNIT_QUATERNION
+#define axisAngleQ coreAxisAngleQ
+#define lerpQ coreLerpQ
+#define mulSetQ coreMulSetQ
+#define mulQ coreMulQ
+#define mulQV3 coreMulQV3
+#define toStringQ coreToStringQ
+#endif
+
 #endif

include/core/Vector.h

@@ -60,4 +60,140 @@ CORE_DEFINE_VECTOR_CONVERSION(CoreVector4, V4, CoreIntVector4, IV4);
 #define CORE_INT_VECTOR3 ((CoreIntVector3){0})
 #define CORE_INT_VECTOR4 ((CoreIntVector4){0})
 
+#ifdef IMPORT_CORE
+#define Vector2 CoreVector2
+#define addSetV2 coreAddSetV2
+#define addV2 coreAddV2
+#define subSetV2 coreSubSetV2
+#define subV2 coreSubV2
+#define mulSetV2 coreMulSetV2
+#define mulV2 coreMulV2
+#define divSetV2 coreDivSetV2
+#define divV2 coreDivV2
+#define mulSetV2F coreMulSetV2F
+#define mulV2F coreMulV2F
+#define divSetV2F coreDivSetV2F
+#define divV2F coreDivV2F
+#define invertSetV2 coreInvertSetV2
+#define invertV2 coreInvertV2
+#define toStringV2 coreToStringV2
+
+#define Vector3 CoreVector3
+#define addSetV3 coreAddSetV3
+#define addV3 coreAddV3
+#define subSetV3 coreSubSetV3
+#define subV3 coreSubV3
+#define mulSetV3 coreMulSetV3
+#define mulV3 coreMulV3
+#define divSetV3 coreDivSetV3
+#define divV3 coreDivV3
+#define mulSetV3F coreMulSetV3F
+#define mulV3F coreMulV3F
+#define divSetV3F coreDivSetV3F
+#define divV3F coreDivV3F
+#define invertSetV3 coreInvertSetV3
+#define invertV3 coreInvertV3
+#define toStringV3 coreToStringV3
+
+#define Vector4 CoreVector4
+#define addSetV4 coreAddSetV4
+#define addV4 coreAddV4
+#define subSetV4 coreSubSetV4
+#define subV4 coreSubV4
+#define mulSetV4 coreMulSetV4
+#define mulV4 coreMulV4
+#define divSetV4 coreDivSetV4
+#define divV4 coreDivV4
+#define mulSetV4F coreMulSetV4F
+#define mulV4F coreMulV4F
+#define divSetV4F coreDivSetV4F
+#define divV4F coreDivV4F
+#define invertSetV4 coreInvertSetV4
+#define invertV4 coreInvertV4
+#define toStringV4 coreToStringV4
+
+#define IntVector2 CoreIntVector2
+#define addSetIV2 coreAddSetIV2
+#define addIV2 coreAddIV2
+#define subSetIV2 coreSubSetIV2
+#define subIV2 coreSubIV2
+#define mulSetIV2 coreMulSetIV2
+#define mulIV2 coreMulIV2
+#define divSetIV2 coreDivSetIV2
+#define divIV2 coreDivIV2
+#define mulSetIV2F coreMulSetIV2F
+#define mulIV2F coreMulIV2F
+#define divSetIV2F coreDivSetIV2F
+#define divIV2F coreDivIV2F
+#define invertSetIV2 coreInvertSetIV2
+#define invertIV2 coreInvertIV2
+#define toStringIV2 coreToStringIV2
+
+#define IntVector3 CoreIntVector3
+#define addSetIV3 coreAddSetIV3
+#define addIV3 coreAddIV3
+#define subSetIV3 coreSubSetIV3
+#define subIV3 coreSubIV3
+#define mulSetIV3 coreMulSetIV3
+#define mulIV3 coreMulIV3
+#define divSetIV3 coreDivSetIV3
+#define divIV3 coreDivIV3
+#define mulSetIV3F coreMulSetIV3F
+#define mulIV3F coreMulIV3F
+#define divSetIV3F coreDivSetIV3F
+#define divIV3F coreDivIV3F
+#define invertSetIV3 coreInvertSetIV3
+#define invertIV3 coreInvertIV3
+#define toStringIV3 coreToStringIV3
+
+#define IntVector4 CoreIntVector4
+#define addSetIV4 coreAddSetIV4
+#define addIV4 coreAddIV4
+#define subSetIV4 coreSubSetIV4
+#define subIV4 coreSubIV4
+#define mulSetIV4 coreMulSetIV4
+#define mulIV4 coreMulIV4
+#define divSetIV4 coreDivSetIV4
+#define divIV4 coreDivIV4
+#define mulSetIV4F coreMulSetIV4F
+#define mulIV4F coreMulIV4F
+#define divSetIV4F coreDivSetIV4F
+#define divIV4F coreDivIV4F
+#define invertSetIV4 coreInvertSetIV4
+#define invertIV4 coreInvertIV4
+#define toStringIV4 coreToStringIV4
+
+#define dotV2 coreDotV2
+#define squareLengthV2 coreSquareLengthV2
+#define lengthV2 coreLengthV2
+#define normalizeV2 coreNormalizeV2
+
+#define dotV3 coreDotV3
+#define squareLengthV3 coreSquareLengthV3
+#define lengthV3 coreLengthV3
+#define normalizeV3 coreNormalizeV3
+
+#define dotV4 coreDotV4
+#define squareLengthV4 coreSquareLengthV4
+#define lengthV4 coreLengthV4
+#define normalizeV4 coreNormalizeV4
+
+#define angles coreAngles
+#define cross coreCross
+
+#define convertV2 coreConvertV2
+#define convertIV2 coreConvertIV2
+#define convertV3 coreConvertV3
+#define convertIV3 coreConvertIV3
+#define convertV4 coreConvertV4
+#define convertIV4 coreConvertIV4
+
+#define VECTOR2 CORE_VECTOR2
+#define VECTOR3 CORE_VECTOR3
+#define VECTOR4 CORE_VECTOR4
+#define INT_VECTOR2 CORE_INT_VECTOR2
+#define INT_VECTOR3 CORE_INT_VECTOR3
+#define INT_VECTOR4 CORE_INT_VECTOR4
+#endif
+
 #endif

src/Matrix.c

@@ -146,4 +146,4 @@ size_t toStringMatrix(const Matrix* m, char* buffer, size_t n) {
     coreStringAdd(&w, &buffer, &n, coreToStringV4(m->data + 3, buffer, n));
     coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "]"));
     return w;
-} // 150
+}

src/Quaternion.c

@@ -4,58 +4,54 @@
 
 #include "core/Utility.h"
 
-#define CV30 (&CORE_VECTOR3)
+#define mulC(a, b) mulV3F(&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))
 
-CoreQuaternion* coreAxisAngleQ(CoreQuaternion* q, const CoreVector3* axis,
-                               float angle) {
+Quaternion* axisAngleQ(Quaternion* q, const Vector3* axis, float angle) {
     q->xyz = *axis;
-    coreNormalizeV3(&q->xyz);
-    angle = coreDegreeToRadian(angle) * 0.5f;
+    normalizeV3(&q->xyz);
+    angle = degreeToRadian(angle) * 0.5f;
     q->w = cosf(angle);
-    coreMulSetV3F(&q->xyz, sinf(angle));
+    mulSetV3F(&q->xyz, sinf(angle));
     return q;
 }
 
-CoreQuaternion* coreLerpQ(CoreQuaternion* q, const CoreQuaternion* a, float f,
-                          const CoreQuaternion* b) {
-    coreAddV3(&q->xyz, coreMulV3F(CV30, &a->xyz, 1.0f - f),
-              coreMulV3F(CV30, &b->xyz, f));
+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));
     q->w = a->w * (1.0f - f) + b->w * f;
-    float iLength = 1.0f / sqrtf(coreSquareLengthV3(&q->xyz) + q->w * q->w);
-    coreMulSetV3F(&q->xyz, iLength);
+    float iLength = 1.0f / sqrtf(squareLengthV3(&q->xyz) + q->w * q->w);
+    mulSetV3F(&q->xyz, iLength);
     q->w *= iLength;
     return q;
 }
 
-CoreQuaternion* coreMulSetQ(CoreQuaternion* q, const CoreQuaternion* other) {
-    float dot = coreDotV3(&q->xyz, &other->xyz);
-    coreAddV3(&q->xyz, coreMulV3F(CV30, &other->xyz, q->w),
-              coreAddV3(CV30, coreMulV3F(CV30, &q->xyz, other->w),
-                        coreCross(CV30, &q->xyz, &other->xyz)));
-    q->w = q->w * other->w - dot;
+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)));
+    q->w = q->w * o->w - dot;
     return q;
 }
 
-CoreQuaternion* coreMulQ(CoreQuaternion* q, const CoreQuaternion* a,
-                         const CoreQuaternion* b) {
+Quaternion* mulQ(Quaternion* q, const Quaternion* a, const Quaternion* b) {
     *q = *a;
-    coreMulSetQ(q, b);
+    mulSetQ(q, b);
     return q;
 }
 
-CoreVector3* coreMulQV3(CoreVector3* r, const CoreQuaternion* q,
-                        const CoreVector3* v) {
-    CoreVector3 qv;
-    coreAddV3(&qv, coreMulV3F(CV30, v, q->w), coreCross(CV30, &q->xyz, v));
-
-    coreAddV3(r, coreMulV3F(CV30, &q->xyz, coreDotV3(&q->xyz, v)),
-              coreSubV3(CV30, coreMulV3F(CV30, &qv, q->w),
-                        coreCross(CV30, &qv, &q->xyz)));
+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)));
     return r;
 }
 
-size_t coreToStringQ(const CoreQuaternion* q, char* buffer, size_t n) {
-    return coreToString(buffer, n, "(%.3f i + %.3f j + %.3f k + %.3f)",
-                        (double)q->xyz.data[0], (double)q->xyz.data[1],
-                        (double)q->xyz.data[2], (double)q->w);
+size_t toStringQ(const Quaternion* q, char* buffer, size_t n) {
+    return toString(buffer, n, "(%.3f i + %.3f j + %.3f k + %.3f)",
+                    (double)q->xyz.data[0], (double)q->xyz.data[1],
+                    (double)q->xyz.data[2], (double)q->w);
 }

src/Vector.c

@@ -5,16 +5,16 @@
 
 #include "core/Utility.h"
 
-typedef CoreVector2 V2;
-typedef CoreVector3 V3;
-typedef CoreVector4 V4;
-typedef CoreIntVector2 IV2;
-typedef CoreIntVector3 IV3;
-typedef CoreIntVector4 IV4;
+typedef Vector2 V2;
+typedef Vector3 V3;
+typedef Vector4 V4;
+typedef IntVector2 IV2;
+typedef IntVector3 IV3;
+typedef IntVector4 IV4;
 
-V3* coreAngles(V3* r, float lengthAngle, float widthAngle) {
-    lengthAngle = coreDegreeToRadian(lengthAngle);
-    widthAngle = coreDegreeToRadian(widthAngle);
+V3* angles(V3* r, float lengthAngle, float widthAngle) {
+    lengthAngle = degreeToRadian(lengthAngle);
+    widthAngle = degreeToRadian(widthAngle);
 
     float sWidth = sinf(widthAngle);
     float cWidth = cosf(widthAngle);
@@ -27,7 +27,7 @@ V3* coreAngles(V3* r, float lengthAngle, float widthAngle) {
     return r;
 }
 
-V3* coreCross(V3* r, const V3* a, const V3* b) {
+V3* cross(V3* r, const V3* a, const V3* b) {
     r->data[0] = a->data[1] * b->data[2] - a->data[2] * b->data[1];
     r->data[1] = a->data[2] * b->data[0] - a->data[0] * b->data[2];
     r->data[2] = a->data[0] * b->data[1] - a->data[1] * b->data[0];
@@ -35,77 +35,77 @@ V3* coreCross(V3* r, const V3* a, const V3* b) {
 }
 
 #define VECTOR_IMPL(T, N, FT)                                                  \
-    T* coreAddSet##T(T* r, const T* a) {                                       \
-        return coreAdd##T(r, r, a);                                            \
+    T* addSet##T(T* r, const T* a) {                                           \
+        return add##T(r, r, a);                                                \
     }                                                                          \
                                                                                \
-    T* coreAdd##T(T* r, const T* a, const T* b) {                              \
+    T* add##T(T* r, const T* a, const T* b) {                                  \
         for(int i = 0; i < N; i++) {                                           \
             r->data[i] = a->data[i] + b->data[i];                              \
         }                                                                      \
         return r;                                                              \
     }                                                                          \
                                                                                \
-    T* coreSubSet##T(T* r, const T* a) {                                       \
-        return coreSub##T(r, r, a);                                            \
+    T* subSet##T(T* r, const T* a) {                                           \
+        return sub##T(r, r, a);                                                \
     }                                                                          \
                                                                                \
-    T* coreSub##T(T* r, const T* a, const T* b) {                              \
+    T* sub##T(T* r, const T* a, const T* b) {                                  \
         for(int i = 0; i < N; i++) {                                           \
             r->data[i] = a->data[i] - b->data[i];                              \
         }                                                                      \
         return r;                                                              \
     }                                                                          \
                                                                                \
-    T* coreMulSet##T(T* r, const T* a) {                                       \
-        return coreMul##T(r, r, a);                                            \
+    T* mulSet##T(T* r, const T* a) {                                           \
+        return mul##T(r, r, a);                                                \
     }                                                                          \
                                                                                \
-    T* coreMul##T(T* r, const T* a, const T* b) {                              \
+    T* mul##T(T* r, const T* a, const T* b) {                                  \
         for(int i = 0; i < N; i++) {                                           \
             r->data[i] = a->data[i] * b->data[i];                              \
         }                                                                      \
         return r;                                                              \
     }                                                                          \
                                                                                \
-    T* coreDivSet##T(T* r, const T* a) {                                       \
-        return coreDiv##T(r, r, a);                                            \
+    T* divSet##T(T* r, const T* a) {                                           \
+        return div##T(r, r, a);                                                \
     }                                                                          \
                                                                                \
-    T* coreDiv##T(T* r, const T* a, const T* b) {                              \
+    T* div##T(T* r, const T* a, const T* b) {                                  \
         for(int i = 0; i < N; i++) {                                           \
             r->data[i] = a->data[i] / b->data[i];                              \
         }                                                                      \
         return r;                                                              \
     }                                                                          \
                                                                                \
-    T* coreMulSet##T##F(T* r, FT f) {                                          \
-        return coreMul##T##F(r, r, f);                                         \
+    T* mulSet##T##F(T* r, FT f) {                                              \
+        return mul##T##F(r, r, f);                                             \
     }                                                                          \
                                                                                \
-    T* coreMul##T##F(T* r, const T* a, FT f) {                                 \
+    T* mul##T##F(T* r, const T* a, FT f) {                                     \
         for(int i = 0; i < N; i++) {                                           \
             r->data[i] = a->data[i] * f;                                       \
         }                                                                      \
         return r;                                                              \
     }                                                                          \
                                                                                \
-    T* coreDivSet##T##F(T* r, FT f) {                                          \
-        return coreDiv##T##F(r, r, f);                                         \
+    T* divSet##T##F(T* r, FT f) {                                              \
+        return div##T##F(r, r, f);                                             \
     }                                                                          \
                                                                                \
-    T* coreDiv##T##F(T* r, const T* a, FT f) {                                 \
+    T* div##T##F(T* r, const T* a, FT f) {                                     \
         for(int i = 0; i < N; i++) {                                           \
             r->data[i] = a->data[i] / f;                                       \
         }                                                                      \
         return r;                                                              \
     }                                                                          \
                                                                                \
-    T* coreInvertSet##T(T* r) {                                                \
-        return coreInvert##T(r, r);                                            \
+    T* invertSet##T(T* r) {                                                    \
+        return invert##T(r, r);                                                \
     }                                                                          \
                                                                                \
-    T* coreInvert##T(T* r, const T* a) {                                       \
+    T* invert##T(T* r, const T* a) {                                           \
         for(int i = 0; i < N; i++) {                                           \
             r->data[i] = -a->data[i];                                          \
         }                                                                      \
@@ -113,7 +113,7 @@ V3* coreCross(V3* r, const V3* a, const V3* b) {
     }
 
 #define VECTOR_IMPL_FLOAT(T, N, CN)                                            \
-    float coreDot##T(const T* a, const T* b) {                                 \
+    float dot##T(const T* a, const T* b) {                                     \
         float length = 0;                                                      \
         for(int i = 0; i < N; i++) {                                           \
             length += a->data[i] * b->data[i];                                 \
@@ -121,26 +121,26 @@ V3* coreCross(V3* r, const V3* a, const V3* b) {
         return length;                                                         \
     }                                                                          \
                                                                                \
-    float coreSquareLength##T(const T* a) {                                    \
-        return coreDot##T(a, a);                                               \
+    float squareLength##T(const T* a) {                                        \
+        return dot##T(a, a);                                                   \
     }                                                                          \
                                                                                \
-    float coreLength##T(const T* a) {                                          \
-        return sqrtf(coreSquareLength##T(a));                                  \
+    float length##T(const T* a) {                                              \
+        return sqrtf(squareLength##T(a));                                      \
     }                                                                          \
                                                                                \
-    T* coreNormalize##T(T* r) {                                                \
-        return coreMulSet##T##F(r, 1.0f / coreLength##T(r));                   \
+    T* normalize##T(T* r) {                                                    \
+        return mulSet##T##F(r, 1.0f / length##T(r));                           \
     }                                                                          \
                                                                                \
-    T* coreConvertI##T(T* r, const CN* a) {                                    \
+    T* convertI##T(T* r, const CN* a) {                                        \
         for(int i = 0; i < N; i++) {                                           \
             r->data[i] = (float)a->data[i];                                    \
         }                                                                      \
         return r;                                                              \
     }                                                                          \
                                                                                \
-    CN* coreConvert##T(CN* r, const T* a) {                                    \
+    CN* convert##T(CN* r, const T* a) {                                        \
         for(int i = 0; i < N; i++) {                                           \
             r->data[i] = (int)a->data[i];                                      \
         }                                                                      \
@@ -157,37 +157,31 @@ VECTOR_IMPL_FLOAT(V2, 2, IV2)
 VECTOR_IMPL_FLOAT(V3, 3, IV3)
 VECTOR_IMPL_FLOAT(V4, 4, IV4)
 
-static size_t safeCast(int s) {
-    return s < 0 ? 0 : (size_t)s;
+size_t toStringV2(const V2* a, char* buffer, size_t n) {
+    return toString(buffer, n, "[%.3f, %.3f]", (double)a->data[0],
+                    (double)a->data[1]);
 }
 
-size_t coreToStringV2(const V2* a, char* buffer, size_t n) {
-    return safeCast(snprintf(buffer, n, "[%.3f, %.3f]", (double)a->data[0],
-                             (double)a->data[1]));
+size_t toStringV3(const V3* a, char* buffer, size_t n) {
+    return toString(buffer, n, "[%.3f, %.3f, %.3f]", (double)a->data[0],
+                    (double)a->data[1], (double)a->data[2]);
 }
 
-size_t coreToStringV3(const V3* a, char* buffer, size_t n) {
-    return safeCast(snprintf(buffer, n, "[%.3f, %.3f, %.3f]",
-                             (double)a->data[0], (double)a->data[1],
-                             (double)a->data[2]));
+size_t toStringV4(const V4* a, char* buffer, size_t n) {
+    return toString(buffer, n, "[%.3f, %.3f, %.3f, %.3f]", (double)a->data[0],
+                    (double)a->data[1], (double)a->data[2], (double)a->data[3]);
 }
 
-size_t coreToStringV4(const V4* a, char* buffer, size_t n) {
-    return safeCast(snprintf(buffer, n, "[%.3f, %.3f, %.3f, %.3f]",
-                             (double)a->data[0], (double)a->data[1],
-                             (double)a->data[2], (double)a->data[3]));
+size_t toStringIV2(const IV2* a, char* buffer, size_t n) {
+    return toString(buffer, n, "[%d, %d]", a->data[0], a->data[1]);
 }
 
-size_t coreToStringIV2(const IV2* a, char* buffer, size_t n) {
-    return safeCast(snprintf(buffer, n, "[%d, %d]", a->data[0], a->data[1]));
+size_t toStringIV3(const IV3* a, char* buffer, size_t n) {
+    return toString(buffer, n, "[%d, %d, %d]", a->data[0], a->data[1],
+                    a->data[2]);
 }
 
-size_t coreToStringIV3(const IV3* a, char* buffer, size_t n) {
-    return safeCast(snprintf(buffer, n, "[%d, %d, %d]", a->data[0], a->data[1],
-                             a->data[2]));
-}
-
-size_t coreToStringIV4(const IV4* a, char* buffer, size_t n) {
-    return safeCast(snprintf(buffer, n, "[%d, %d, %d, %d]", a->data[0],
-                             a->data[1], a->data[2], a->data[3]));
+size_t toStringIV4(const IV4* a, char* buffer, size_t n) {
+    return toString(buffer, n, "[%d, %d, %d, %d]", a->data[0], a->data[1],
+                    a->data[2], a->data[3]);
 }

test/modules/BitArrayTests.c

@@ -8,10 +8,10 @@ static void testSetRead() {
     setBitsBitArray(&bits, 1, 2);
     setBitsBitArray(&bits, 2, 3);
     setBitsBitArray(&bits, 3, 4);
-    CORE_TEST_U64(1, getBitsBitArray(&bits, 0));
-    CORE_TEST_U64(2, getBitsBitArray(&bits, 1));
-    CORE_TEST_U64(3, getBitsBitArray(&bits, 2));
-    CORE_TEST_U64(4, getBitsBitArray(&bits, 3));
+    TEST_U64(1, getBitsBitArray(&bits, 0));
+    TEST_U64(2, getBitsBitArray(&bits, 1));
+    TEST_U64(3, getBitsBitArray(&bits, 2));
+    TEST_U64(4, getBitsBitArray(&bits, 3));
     destroyBitArray(&bits);
 }
 
@@ -22,7 +22,7 @@ static void testBigSetRead() {
         setBitsBitArray(&bits, i, i);
     }
     for(size_t i = 0; i < bits.length; i++) {
-        CORE_TEST_U64(i, getBitsBitArray(&bits, i));
+        TEST_U64(i, getBitsBitArray(&bits, i));
     }
     destroyBitArray(&bits);
 }
@@ -40,13 +40,13 @@ static void testRandomSetReadResize() {
         }
     }
     for(size_t i = 0; i < bits.length; i++) {
-        CORE_TEST_U64(data[i], getBitsBitArray(&bits, i));
+        TEST_U64(data[i], getBitsBitArray(&bits, i));
     }
     resizeBitArray(&bits, bits.length, bits.bits + 1u);
-    CORE_TEST_U64(14, bits.bits);
-    CORE_TEST_U64(100, bits.length);
+    TEST_U64(14, bits.bits);
+    TEST_U64(100, bits.length);
     for(size_t i = 0; i < bits.length; i++) {
-        CORE_TEST_U64(data[i], getBitsBitArray(&bits, i));
+        TEST_U64(data[i], getBitsBitArray(&bits, i));
     }
     destroyBitArray(&bits);
 }
@@ -61,10 +61,10 @@ static void testCopy() {
     BitArray copy = BIT_ARRAY;
     copyBitArray(&copy, &bits);
     copyBitArray(&copy, &copy);
-    CORE_TEST_U64(1, getBitsBitArray(&copy, 0));
-    CORE_TEST_U64(2, getBitsBitArray(&copy, 1));
-    CORE_TEST_U64(3, getBitsBitArray(&copy, 2));
-    CORE_TEST_U64(4, getBitsBitArray(&copy, 3));
+    TEST_U64(1, getBitsBitArray(&copy, 0));
+    TEST_U64(2, getBitsBitArray(&copy, 1));
+    TEST_U64(3, getBitsBitArray(&copy, 2));
+    TEST_U64(4, getBitsBitArray(&copy, 3));
     destroyBitArray(&copy);
     destroyBitArray(&bits);
 }
@@ -80,15 +80,15 @@ static void testSelect() {
     setBitsBitArray(&bits, 32, 1);
     setBitsBitArray(&bits, 33, 1);
     setBitsBitArray(&bits, 60, 1);
-    CORE_TEST_I64(-1, selectBitsBitArray(&bits, 0));
-    CORE_TEST_I64(0, selectBitsBitArray(&bits, 1));
-    CORE_TEST_I64(5, selectBitsBitArray(&bits, 2));
-    CORE_TEST_I64(20, selectBitsBitArray(&bits, 3));
-    CORE_TEST_I64(31, selectBitsBitArray(&bits, 4));
-    CORE_TEST_I64(32, selectBitsBitArray(&bits, 5));
-    CORE_TEST_I64(33, selectBitsBitArray(&bits, 6));
-    CORE_TEST_I64(60, selectBitsBitArray(&bits, 7));
-    CORE_TEST_I64(-1, selectBitsBitArray(&bits, 8));
+    TEST_I64(-1, selectBitsBitArray(&bits, 0));
+    TEST_I64(0, selectBitsBitArray(&bits, 1));
+    TEST_I64(5, selectBitsBitArray(&bits, 2));
+    TEST_I64(20, selectBitsBitArray(&bits, 3));
+    TEST_I64(31, selectBitsBitArray(&bits, 4));
+    TEST_I64(32, selectBitsBitArray(&bits, 5));
+    TEST_I64(33, selectBitsBitArray(&bits, 6));
+    TEST_I64(60, selectBitsBitArray(&bits, 7));
+    TEST_I64(-1, selectBitsBitArray(&bits, 8));
     destroyBitArray(&bits);
 }
 
@@ -101,8 +101,8 @@ static void testToString1() {
     setBitsBitArray(&bits, 3, 4);
     char buffer[128];
     size_t n = toStringBitArray(&bits, buffer, sizeof(buffer));
-    CORE_TEST_SIZE(12, n);
-    CORE_TEST_STRING("[1, 2, 3, 4]", buffer);
+    TEST_SIZE(12, n);
+    TEST_STRING("[1, 2, 3, 4]", buffer);
     destroyBitArray(&bits);
 }
 
@@ -112,8 +112,8 @@ static void testToString2() {
     setBitsBitArray(&bits, 0, 1);
     char buffer[128];
     size_t n = toStringBitArray(&bits, buffer, sizeof(buffer));
-    CORE_TEST_SIZE(3, n);
-    CORE_TEST_STRING("[1]", buffer);
+    TEST_SIZE(3, n);
+    TEST_STRING("[1]", buffer);
     destroyBitArray(&bits);
 }
 
@@ -121,14 +121,14 @@ static void testToString3() {
     BitArray bits = BIT_ARRAY;
     char buffer[128];
     size_t n = toStringBitArray(&bits, buffer, sizeof(buffer));
-    CORE_TEST_SIZE(2, n);
-    CORE_TEST_STRING("[]", buffer);
+    TEST_SIZE(2, n);
+    TEST_STRING("[]", buffer);
     destroyBitArray(&bits);
 }
 
 static void testResizeExact() {
     BitArray bits = BIT_ARRAY;
-    CORE_TEST_U64(0, getBytesBitArray(&bits));
+    TEST_U64(0, getBytesBitArray(&bits));
     // the size in bytes matches the internal storage type
     size_t elements = sizeof(u64);
     resizeBitArray(&bits, elements, 8);
@@ -136,9 +136,9 @@ static void testResizeExact() {
         setBitsBitArray(&bits, i, i);
     }
     for(size_t i = 0; i < elements; i++) {
-        CORE_TEST_U64(i, getBitsBitArray(&bits, i));
+        TEST_U64(i, getBitsBitArray(&bits, i));
     }
-    CORE_TEST_U64(sizeof(u64), getBytesBitArray(&bits));
+    TEST_U64(sizeof(u64), getBytesBitArray(&bits));
     destroyBitArray(&bits);
 }
 
@@ -151,9 +151,9 @@ static void testMove() {
     BitArray m = BIT_ARRAY;
     moveBitArray(&m, &bits);
     moveBitArray(&m, &m);
-    CORE_TEST_U64(8, m.length);
+    TEST_U64(8, m.length);
     for(size_t i = 0; i < m.length; i++) {
-        CORE_TEST_U64(i, getBitsBitArray(&m, i));
+        TEST_U64(i, getBitsBitArray(&m, i));
     }
     destroyBitArray(&m);
     destroyBitArray(&bits);
@@ -162,20 +162,20 @@ static void testMove() {
 static void testInvalidArgument() {
     BitArray bits = BIT_ARRAY;
     resizeBitArray(&bits, 0, 5);
-    CORE_TEST_SIZE(0, bits.length);
-    CORE_TEST_SIZE(0, bits.bits);
+    TEST_SIZE(0, bits.length);
+    TEST_SIZE(0, bits.bits);
     resizeBitArray(&bits, 5, 0);
-    CORE_TEST_SIZE(0, bits.length);
-    CORE_TEST_SIZE(0, bits.bits);
+    TEST_SIZE(0, bits.length);
+    TEST_SIZE(0, bits.bits);
     resizeBitArray(&bits, 0, 0);
-    CORE_TEST_SIZE(0, bits.length);
-    CORE_TEST_SIZE(0, bits.bits);
+    TEST_SIZE(0, bits.length);
+    TEST_SIZE(0, bits.bits);
     resizeBitArray(&bits, 1, 65);
-    CORE_TEST_SIZE(1, bits.length);
-    CORE_TEST_SIZE(64, bits.bits);
+    TEST_SIZE(1, bits.length);
+    TEST_SIZE(64, bits.bits);
     resizeBitArray(&bits, 5, 68);
-    CORE_TEST_SIZE(5, bits.length);
-    CORE_TEST_SIZE(64, bits.bits);
+    TEST_SIZE(5, bits.length);
+    TEST_SIZE(64, bits.bits);
     destroyBitArray(&bits);
 }
 

test/modules/MatrixTests.c

@@ -6,12 +6,12 @@ typedef CoreVector3 V3;
 #define CV30 CV3(0.0f, 0.0f, 0.0f)
 
 static void testInit() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     const float* data = (float*)&m;
     for(int i = 0; i < 16; i++) {
         int x = i % 4;
         int y = i / 4;
-        CORE_TEST_FLOAT(x == y, data[i], 0.0f);
+        TEST_FLOAT(x == y, data[i], 0.0f);
     }
 }
 
@@ -30,55 +30,55 @@ static void testTranspose() {
     const float* tp = (float*)&t;
     for(int x = 0; x < 4; x++) {
         for(int y = 0; y < 4; y++) {
-            CORE_TEST_FLOAT(mp[y * 4 + x], tp[x * 4 + y], 0.0f);
+            TEST_FLOAT(mp[y * 4 + x], tp[x * 4 + y], 0.0f);
         }
     }
     const float* mp2 = (float*)&m2;
     for(int i = 0; i < 16; i++) {
-        CORE_TEST_FLOAT(mp[i], mp2[i], 0.0f);
+        TEST_FLOAT(mp[i], mp2[i], 0.0f);
     }
 }
 
 static void testScale() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     scaleMatrix(&m, CV3(2.0f, 3.0f, 4.0f));
-    CORE_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),
+            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testUniformScale() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     scaleMatrixF(&m, 2.0f);
-    CORE_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),
+            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateX() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     translateMatrixX(&m, 5.0f);
-    CORE_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),
+            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateY() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     translateMatrixY(&m, 6.0f);
-    CORE_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),
+            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateZ() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     translateMatrixZ(&m, 7.0f);
-    CORE_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),
+            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslate() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     translateMatrix(&m, CV3(1.0f, 2.0f, 3.0f));
-    CORE_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),
+            mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateTo() {
@@ -89,14 +89,13 @@ static void testTranslateTo() {
     }
     translateMatrixTo(&m, CV3(6.0f, 8.0f, 9.0f));
     toStringMatrix(&m, buffer, sizeof(buffer));
-    CORE_TEST_STRING(
-        "[[1.000, 0.000, 0.000, 6.000], [0.000, 1.000, 0.000, 8.000], "
-        "[0.000, 0.000, 1.000, 9.000], [0.000, 0.000, 0.000, 1.000]]",
-        buffer);
+    TEST_STRING("[[1.000, 0.000, 0.000, 6.000], [0.000, 1.000, 0.000, 8.000], "
+                "[0.000, 0.000, 1.000, 9.000], [0.000, 0.000, 0.000, 1.000]]",
+                buffer);
 }
 
 static void testCombination() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     scaleMatrixF(&m, 2.0f);
     translateMatrixX(&m, 1.0f);
     translateMatrixY(&m, 2.0f);
@@ -104,77 +103,77 @@ 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);
-    CORE_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),
+            mulMatrixV3(CV30, &m, CV3(1.0f, 1.0f, 1.0f)));
 }
 
 static void testMatrixCombination() {
-    Matrix a = CORE_UNIT_MATRIX;
+    Matrix a = UNIT_MATRIX;
     scaleMatrixF(&a, 2.0f);
     translateMatrix(&a, CV3(1.0f, 2.0f, 3.0f));
 
-    Matrix b = CORE_UNIT_MATRIX;
+    Matrix b = UNIT_MATRIX;
     scaleMatrixF(&b, 3.0f);
     translateMatrix(&b, CV3(1.0f, 1.0f, 1.0f));
 
-    Matrix c = CORE_UNIT_MATRIX;
+    Matrix c = UNIT_MATRIX;
     translateMatrix(&c, CV3(-1.0f, -2.0f, -3.0f));
 
-    mulSetMatrix(&c, mulMatrix(&CORE_ZERO_MATRIX, &b, &a));
+    mulSetMatrix(&c, mulMatrix(&ZERO_MATRIX, &b, &a));
 
-    CORE_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),
+            mulMatrixV3(CV30, &c, CV3(1.0f, 1.0f, 1.0f)));
 }
 
 static void testRotateX() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     rotateMatrixX(&m, 90.0f);
-    CORE_TEST_V3(CV3(1.0f, 0.0f, 0.0f),
-                 mulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
-    CORE_TEST_V3(CV3(0.0f, 0.0f, 1.0f),
-                 mulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
-    CORE_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),
+            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)));
 }
 
 static void testRotateY() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     rotateMatrixY(&m, 90.0f);
-    CORE_TEST_V3(CV3(0.0f, 0.0f, -1.0f),
-                 mulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
-    CORE_TEST_V3(CV3(0.0f, 1.0f, 0.0f),
-                 mulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
-    CORE_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),
+            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)));
 }
 
 static void testRotateZ() {
-    Matrix m = CORE_UNIT_MATRIX;
+    Matrix m = UNIT_MATRIX;
     rotateMatrixZ(&m, 90.0f);
-    CORE_TEST_V3(CV3(0.0f, 1.0f, 0.0f),
-                 mulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
-    CORE_TEST_V3(CV3(-1.0f, 0.0f, 0.0f),
-                 mulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
-    CORE_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),
+            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)));
 }
 
 static void testQuaternionMatrix() {
-    CoreQuaternion q1 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q1, CV3(1.0f, 0.0f, 0.0f), 48.0f);
-    CoreQuaternion q2 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q2, CV3(0.0f, 1.0f, 0.0f), 52.0f);
-    CoreQuaternion q3 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q3, CV3(0.0f, 0.0f, 1.0f), 60.0f);
-
-    Matrix m = CORE_UNIT_MATRIX;
+    Quaternion q1 = UNIT_QUATERNION;
+    axisAngleQ(&q1, CV3(1.0f, 0.0f, 0.0f), 48.0f);
+    Quaternion q2 = UNIT_QUATERNION;
+    axisAngleQ(&q2, CV3(0.0f, 1.0f, 0.0f), 52.0f);
+    Quaternion q3 = UNIT_QUATERNION;
+    axisAngleQ(&q3, CV3(0.0f, 0.0f, 1.0f), 60.0f);
+
+    Matrix m = UNIT_MATRIX;
     translateMatrix(&m, CV3(1.0f, 2.0f, 3.0f));
     rotateMatrix(&m, &q1);
     rotateMatrix(&m, &q2);
     rotateMatrix(&m, &q3);
     translateMatrix(&m, CV3(1.0f, 2.0f, 3.0f));
 
-    Matrix check = CORE_UNIT_MATRIX;
+    Matrix check = UNIT_MATRIX;
     translateMatrix(&check, CV3(1.0f, 2.0f, 3.0f));
     rotateMatrixX(&check, 48.0f);
     rotateMatrixY(&check, 52.0f);
@@ -182,7 +181,7 @@ static void testQuaternionMatrix() {
     translateMatrix(&check, CV3(1.0f, 2.0f, 3.0f));
 
     for(int i = 0; i < 16; i++) {
-        CORE_TEST_FLOAT(((float*)&check)[i], ((float*)&m)[i], 0.0001f);
+        TEST_FLOAT(((float*)&check)[i], ((float*)&m)[i], 0.0001f);
     }
 }
 
@@ -193,15 +192,15 @@ static void testToString() {
     }
     char buffer[1024];
     size_t n = toStringMatrix(&m, buffer, sizeof(buffer));
-    CORE_TEST_SIZE(127, n);
-    CORE_TEST_STRING(
+    TEST_SIZE(127, n);
+    TEST_STRING(
         "[[1.000, 2.000, 3.000, 4.000], [5.000, 6.000, 7.000, 8.000], "
         "[9.000, 10.000, 11.000, 12.000], [13.000, 14.000, 15.000, 16.000]]",
         buffer);
 
     n = toStringMatrix(&m, buffer, 20);
-    CORE_TEST_SIZE(127, n);
-    CORE_TEST_STRING("[[1.000, 2.000, 3.0", buffer);
+    TEST_SIZE(127, n);
+    TEST_STRING("[[1.000, 2.000, 3.0", buffer);
 }
 
 void testMatrix() {

test/modules/QuaternionTests.c

@@ -1,101 +1,100 @@
 #include "../Tests.h"
 #include "core/Quaternion.h"
 
-typedef CoreQuaternion Q;
-#define CV3(a, b, c) (&(CoreVector3){{a, b, c}})
+#define CV3(a, b, c) (&(Vector3){{a, b, c}})
 #define CV30 CV3(0.0f, 0.0f, 0.0f)
 
 static void testInit() {
-    Q q = CORE_UNIT_QUATERNION;
+    Quaternion q = UNIT_QUATERNION;
     char buffer[128];
-    coreToStringQ(&q, buffer, sizeof(buffer));
-    CORE_TEST_STRING("(0.000 i + 0.000 j + 0.000 k + 1.000)", buffer);
+    toStringQ(&q, buffer, sizeof(buffer));
+    TEST_STRING("(0.000 i + 0.000 j + 0.000 k + 1.000)", buffer);
 }
 
 static void testAxisAndDegreesInit() {
-    Q q = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q, CV3(1.0f, 2.0f, 3.0f), 142.0f);
+    Quaternion q = UNIT_QUATERNION;
+    axisAngleQ(&q, CV3(1.0f, 2.0f, 3.0f), 142.0f);
     char buffer[128];
-    coreToStringQ(&q, buffer, sizeof(buffer));
-    CORE_TEST_STRING("(0.253 i + 0.505 j + 0.758 k + 0.326)", buffer);
+    toStringQ(&q, buffer, sizeof(buffer));
+    TEST_STRING("(0.253 i + 0.505 j + 0.758 k + 0.326)", buffer);
 }
 
 static void testLerp() {
-    Q q1 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q1, CV3(2.0f, 5.0f, 7.0f), 130.0f);
-    Q q2 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q2, CV3(1.0f, 2.0f, 4.0f), 260.0f);
-    Q q3;
-    coreLerpQ(&q3, &q1, 0.3f, &q2);
+    Quaternion q1 = UNIT_QUATERNION;
+    axisAngleQ(&q1, CV3(2.0f, 5.0f, 7.0f), 130.0f);
+    Quaternion q2 = UNIT_QUATERNION;
+    axisAngleQ(&q2, CV3(1.0f, 2.0f, 4.0f), 260.0f);
+    Quaternion q3;
+    lerpQ(&q3, &q1, 0.3f, &q2);
 
     char buffer[128];
-    coreToStringQ(&q3, buffer, sizeof(buffer));
-    CORE_TEST_STRING("(0.223 i + 0.529 j + 0.810 k + 0.119)", buffer);
+    toStringQ(&q3, buffer, sizeof(buffer));
+    TEST_STRING("(0.223 i + 0.529 j + 0.810 k + 0.119)", buffer);
 }
 
 static void testMulSet() {
-    Q q1 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q1, CV3(2.0f, 5.0f, 7.0f), 50.0f);
-    Q q2 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q2, CV3(2.0f, 5.0f, 7.0f), 60.0f);
-    Q q3 = CORE_UNIT_QUATERNION;
-    coreMulSetQ(&q3, &q1);
+    Quaternion q1 = UNIT_QUATERNION;
+    axisAngleQ(&q1, CV3(2.0f, 5.0f, 7.0f), 50.0f);
+    Quaternion q2 = UNIT_QUATERNION;
+    axisAngleQ(&q2, CV3(2.0f, 5.0f, 7.0f), 60.0f);
+    Quaternion q3 = UNIT_QUATERNION;
+    mulSetQ(&q3, &q1);
 
     char bufferQ1[128];
-    coreToStringQ(&q1, bufferQ1, sizeof(bufferQ1));
+    toStringQ(&q1, bufferQ1, sizeof(bufferQ1));
     char bufferQ3[128];
-    coreToStringQ(&q3, bufferQ3, sizeof(bufferQ3));
-    CORE_TEST_STRING(bufferQ1, bufferQ3);
+    toStringQ(&q3, bufferQ3, sizeof(bufferQ3));
+    TEST_STRING(bufferQ1, bufferQ3);
 
-    coreMulSetQ(&q3, &q2);
-    coreToStringQ(&q3, bufferQ3, sizeof(bufferQ3));
+    mulSetQ(&q3, &q2);
+    toStringQ(&q3, bufferQ3, sizeof(bufferQ3));
 
-    coreAxisAngleQ(&q1, CV3(2.0f, 5.0f, 7.0f), 110.0f);
-    coreToStringQ(&q1, bufferQ1, sizeof(bufferQ1));
+    axisAngleQ(&q1, CV3(2.0f, 5.0f, 7.0f), 110.0f);
+    toStringQ(&q1, bufferQ1, sizeof(bufferQ1));
 
-    CORE_TEST_STRING(bufferQ1, bufferQ3);
+    TEST_STRING(bufferQ1, bufferQ3);
 }
 
 static void testMul() {
-    Q q1 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q1, CV3(2.0f, 5.0f, 7.0f), 50.0f);
-    Q q2 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q2, CV3(2.0f, 5.0f, 7.0f), 60.0f);
-    Q q3 = CORE_UNIT_QUATERNION;
-    coreMulQ(&q3, &q1, &q2);
+    Quaternion q1 = UNIT_QUATERNION;
+    axisAngleQ(&q1, CV3(2.0f, 5.0f, 7.0f), 50.0f);
+    Quaternion q2 = UNIT_QUATERNION;
+    axisAngleQ(&q2, CV3(2.0f, 5.0f, 7.0f), 60.0f);
+    Quaternion q3 = UNIT_QUATERNION;
+    mulQ(&q3, &q1, &q2);
 
     char bufferQ3[128];
-    coreToStringQ(&q3, bufferQ3, sizeof(bufferQ3));
+    toStringQ(&q3, bufferQ3, sizeof(bufferQ3));
 
-    Q q = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q, CV3(2.0f, 5.0f, 7.0f), 110.0f);
+    Quaternion q = UNIT_QUATERNION;
+    axisAngleQ(&q, CV3(2.0f, 5.0f, 7.0f), 110.0f);
     char bufferQ[128];
-    coreToStringQ(&q, bufferQ, sizeof(bufferQ));
+    toStringQ(&q, bufferQ, sizeof(bufferQ));
 
-    CORE_TEST_STRING(bufferQ, bufferQ3);
+    TEST_STRING(bufferQ, bufferQ3);
 }
 
 static void testMulVector() {
-    Q q1 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q1, CV3(1.0f, 0.0f, 0.0f), 90.0f);
-    Q q2 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q2, CV3(0.0f, 1.0f, 0.0f), 90.0f);
-    Q q3 = CORE_UNIT_QUATERNION;
-    coreAxisAngleQ(&q3, CV3(0.0f, 0.0f, 1.0f), 90.0f);
-
-    CoreVector3 v1 = {{1.0f, 0.0f, 0.0f}};
-    CoreVector3 v2 = {{0.0f, 1.0f, 0.0f}};
-    CoreVector3 v3 = {{0.0f, 0.0f, 1.0f}};
-
-    CORE_TEST_V3(CV3(1.0f, 0.0f, 0.0f), coreMulQV3(CV30, &q1, &v1));
-    CORE_TEST_V3(CV3(0.0f, 0.0f, 1.0f), coreMulQV3(CV30, &q1, &v2));
-    CORE_TEST_V3(CV3(0.0f, -1.0f, 0.0f), coreMulQV3(CV30, &q1, &v3));
-    CORE_TEST_V3(CV3(0.0f, 0.0f, -1.0f), coreMulQV3(CV30, &q2, &v1));
-    CORE_TEST_V3(CV3(0.0f, 1.0f, 0.0f), coreMulQV3(CV30, &q2, &v2));
-    CORE_TEST_V3(CV3(1.0f, 0.0f, 0.0f), coreMulQV3(CV30, &q2, &v3));
-    CORE_TEST_V3(CV3(0.0f, 1.0f, 0.0f), coreMulQV3(CV30, &q3, &v1));
-    CORE_TEST_V3(CV3(-1.0f, 0.0f, 0.0f), coreMulQV3(CV30, &q3, &v2));
-    CORE_TEST_V3(CV3(0.0f, 0.0f, 1.0f), coreMulQV3(CV30, &q3, &v3));
+    Quaternion q1 = UNIT_QUATERNION;
+    axisAngleQ(&q1, CV3(1.0f, 0.0f, 0.0f), 90.0f);
+    Quaternion q2 = UNIT_QUATERNION;
+    axisAngleQ(&q2, CV3(0.0f, 1.0f, 0.0f), 90.0f);
+    Quaternion q3 = UNIT_QUATERNION;
+    axisAngleQ(&q3, CV3(0.0f, 0.0f, 1.0f), 90.0f);
+
+    Vector3 v1 = {{1.0f, 0.0f, 0.0f}};
+    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));
 }
 
 void testQuaternion() {

test/modules/VectorTests.c

@@ -5,31 +5,31 @@
 
 static const float eps = 0.0001f;
 
-#define V2 CoreVector2
+#define V2 Vector2
 #define CV2(a, b, c, d) (&(V2){{a, b}})
 #define FV2(a, b) CV2(a, b, 0, 0)
 #define CV20 CV2(0, 0, 0, 0)
 
-#define V3 CoreVector3
+#define V3 Vector3
 #define CV3(a, b, c, d) (&(V3){{a, b, c}})
 #define FV3(a, b, c) CV3(a, b, c, 0)
 #define CV30 CV3(0, 0, 0, 0)
 
-#define V4 CoreVector4
+#define V4 Vector4
 #define CV4(a, b, c, d) (&(V4){{a, b, c, d}})
 #define CV40 CV4(0, 0, 0, 0)
 
-#define IV2 CoreIntVector2
+#define IV2 IntVector2
 #define CIV2(a, b, c, d) (&(IV2){{a, b}})
 #define FIV2(a, b) CIV2(a, b, 0, 0)
 #define CIV20 CIV2(0, 0, 0, 0)
 
-#define IV3 CoreIntVector3
+#define IV3 IntVector3
 #define CIV3(a, b, c, d) (&(IV3){{a, b, c}})
 #define FIV3(a, b, c) CIV3(a, b, c, 0)
 #define CIV30 CIV3(0, 0, 0, 0)
 
-#define IV4 CoreIntVector4
+#define IV4 IntVector4
 #define CIV4(a, b, c, d) (&(IV4){{a, b, c, d}})
 #define CIV40 CIV4(0, 0, 0, 0)
 
@@ -37,256 +37,252 @@ static const float eps = 0.0001f;
 
 static void testSetAngles() {
     float root = sqrtf(2) * 0.5f;
-    CORE_TEST_V3(FV3(1, 0, 0), coreAngles(CV30, 0, 0));
-    CORE_TEST_V3(FV3(root, 0, -root), coreAngles(CV30, 45, 0));
-    CORE_TEST_V3(FV3(0, 0, -1), coreAngles(CV30, 90, 0));
-    CORE_TEST_V3(FV3(-root, 0, -root), coreAngles(CV30, 135, 0));
-    CORE_TEST_V3(FV3(-1, 0, 0), coreAngles(CV30, 180, 0));
-    CORE_TEST_V3(FV3(-root, 0, root), coreAngles(CV30, 225, 0));
-    CORE_TEST_V3(FV3(0, 0, 1), coreAngles(CV30, 270, 0));
-    CORE_TEST_V3(FV3(root, 0, root), coreAngles(CV30, 315, 0));
-
-    CORE_TEST_V3(FV3(0, 1, 0), coreAngles(CV30, 0, 90));
-    CORE_TEST_V3(FV3(0, 1, 0), coreAngles(CV30, 90, 90));
-    CORE_TEST_V3(FV3(0, 1, 0), coreAngles(CV30, 180, 90));
-    CORE_TEST_V3(FV3(0, 1, 0), coreAngles(CV30, 270, 90));
-
-    CORE_TEST_V3(FV3(0, -1, 0), coreAngles(CV30, 0, -90));
-    CORE_TEST_V3(FV3(0, -1, 0), coreAngles(CV30, 90, -90));
-    CORE_TEST_V3(FV3(0, -1, 0), coreAngles(CV30, 180, -90));
-    CORE_TEST_V3(FV3(0, -1, 0), coreAngles(CV30, 270, -90));
-
-    CORE_TEST_V3(FV3(root, root, 0), coreAngles(CV30, 0, 45));
-    CORE_TEST_V3(FV3(0, root, -root), coreAngles(CV30, 90, 45));
-    CORE_TEST_V3(FV3(-root, root, 0), coreAngles(CV30, 180, 45));
-    CORE_TEST_V3(FV3(0, root, root), coreAngles(CV30, 270, 45));
-
-    CORE_TEST_V3(FV3(root, -root, 0), coreAngles(CV30, 0, -45));
-    CORE_TEST_V3(FV3(0, -root, -root), coreAngles(CV30, 90, -45));
-    CORE_TEST_V3(FV3(-root, -root, 0), coreAngles(CV30, 180, -45));
-    CORE_TEST_V3(FV3(0, -root, root), coreAngles(CV30, 270, -45));
-
-    CORE_TEST_V3(FV3(0.5f, root, -0.5f), coreAngles(CV30, 45, 45));
+    TEST_V3(FV3(1, 0, 0), angles(CV30, 0, 0));
+    TEST_V3(FV3(root, 0, -root), angles(CV30, 45, 0));
+    TEST_V3(FV3(0, 0, -1), angles(CV30, 90, 0));
+    TEST_V3(FV3(-root, 0, -root), angles(CV30, 135, 0));
+    TEST_V3(FV3(-1, 0, 0), angles(CV30, 180, 0));
+    TEST_V3(FV3(-root, 0, root), angles(CV30, 225, 0));
+    TEST_V3(FV3(0, 0, 1), angles(CV30, 270, 0));
+    TEST_V3(FV3(root, 0, root), angles(CV30, 315, 0));
+
+    TEST_V3(FV3(0, 1, 0), angles(CV30, 0, 90));
+    TEST_V3(FV3(0, 1, 0), angles(CV30, 90, 90));
+    TEST_V3(FV3(0, 1, 0), angles(CV30, 180, 90));
+    TEST_V3(FV3(0, 1, 0), angles(CV30, 270, 90));
+
+    TEST_V3(FV3(0, -1, 0), angles(CV30, 0, -90));
+    TEST_V3(FV3(0, -1, 0), angles(CV30, 90, -90));
+    TEST_V3(FV3(0, -1, 0), angles(CV30, 180, -90));
+    TEST_V3(FV3(0, -1, 0), angles(CV30, 270, -90));
+
+    TEST_V3(FV3(root, root, 0), angles(CV30, 0, 45));
+    TEST_V3(FV3(0, root, -root), angles(CV30, 90, 45));
+    TEST_V3(FV3(-root, root, 0), angles(CV30, 180, 45));
+    TEST_V3(FV3(0, root, root), angles(CV30, 270, 45));
+
+    TEST_V3(FV3(root, -root, 0), angles(CV30, 0, -45));
+    TEST_V3(FV3(0, -root, -root), angles(CV30, 90, -45));
+    TEST_V3(FV3(-root, -root, 0), angles(CV30, 180, -45));
+    TEST_V3(FV3(0, -root, root), angles(CV30, 270, -45));
+
+    TEST_V3(FV3(0.5f, root, -0.5f), angles(CV30, 45, 45));
 }
 
 static void testCross() {
-    CORE_TEST_V3(FV3(0, 0, 1), coreCross(CV30, FV3(1, 0, 0), FV3(0, 1, 0)));
-    CORE_TEST_V3(FV3(0, -1, 0), coreCross(CV30, FV3(1, 0, 0), FV3(0, 0, 1)));
-    CORE_TEST_V3(FV3(0, 0, -1), coreCross(CV30, FV3(0, 1, 0), FV3(1, 0, 0)));
-    CORE_TEST_V3(FV3(1, 0, 0), coreCross(CV30, FV3(0, 1, 0), FV3(0, 0, 1)));
-    CORE_TEST_V3(FV3(0, 1, 0), coreCross(CV30, FV3(0, 0, 1), FV3(1, 0, 0)));
-    CORE_TEST_V3(FV3(-1, 0, 0), coreCross(CV30, FV3(0, 0, 1), FV3(0, 1, 0)));
+    TEST_V3(FV3(0, 0, 1), cross(CV30, FV3(1, 0, 0), FV3(0, 1, 0)));
+    TEST_V3(FV3(0, -1, 0), cross(CV30, FV3(1, 0, 0), FV3(0, 0, 1)));
+    TEST_V3(FV3(0, 0, -1), cross(CV30, FV3(0, 1, 0), FV3(1, 0, 0)));
+    TEST_V3(FV3(1, 0, 0), cross(CV30, FV3(0, 1, 0), FV3(0, 0, 1)));
+    TEST_V3(FV3(0, 1, 0), cross(CV30, FV3(0, 0, 1), FV3(1, 0, 0)));
+    TEST_V3(FV3(-1, 0, 0), cross(CV30, FV3(0, 0, 1), FV3(0, 1, 0)));
 }
 
 static void testSetAdd() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(0, 0, 0, 0);                                               \
-        coreAddSet##T(&v, C##T(1, 2, 3, 4));                                   \
-        CORE_TEST_##T(C##T(1, 2, 3, 4), &v);                                   \
-        coreAddSet##T(&v, C##T(2, 3, 4, 5));                                   \
-        CORE_TEST_##T(C##T(3, 5, 7, 9), &v);                                   \
+        addSet##T(&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));                                       \
+        TEST_##T(C##T(3, 5, 7, 9), &v);                                        \
     }
     TESTS
 #undef X
 }
 
 static void testAdd() {
-    CORE_TEST_V3(FV3(1, 2, 3), coreAddV3(CV30, CV30, FV3(1, 2, 3)));
-    CORE_TEST_V3(FV3(3, 5, 7), coreAddV3(CV30, FV3(1, 2, 3), FV3(2, 3, 4)));
+    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)));
 }
 
 static void testSetSub() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(0, 0, 0, 0);                                               \
-        coreSubSet##T(&v, C##T(1, 2, 3, 4));                                   \
-        CORE_TEST_##T(C##T(-1, -2, -3, -4), &v);                               \
-        coreSubSet##T(&v, C##T(2, 3, 4, 5));                                   \
-        CORE_TEST_##T(C##T(-3, -5, -7, -9), &v);                               \
+        subSet##T(&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));                                       \
+        TEST_##T(C##T(-3, -5, -7, -9), &v);                                    \
     }
     TESTS
 #undef X
 }
 
 static void testSub() {
-    CORE_TEST_V3(FV3(1, 2, 3), coreSubV3(CV30, CV30, FV3(-1, -2, -3)));
-    CORE_TEST_V3(FV3(-1, -1, -1), coreSubV3(CV30, FV3(1, 2, 3), FV3(2, 3, 4)));
+    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)));
 }
 
 static void testSetMul() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(1, 2, 3, 4);                                               \
-        coreMulSet##T##F(&v, 3);                                               \
-        CORE_TEST_##T(C##T(3, 6, 9, 12), &v);                                  \
-        coreMulSet##T##F(&v, -2);                                              \
-        CORE_TEST_##T(C##T(-6, -12, -18, -24), &v);                            \
+        mulSet##T##F(&v, 3);                                                   \
+        TEST_##T(C##T(3, 6, 9, 12), &v);                                       \
+        mulSet##T##F(&v, -2);                                                  \
+        TEST_##T(C##T(-6, -12, -18, -24), &v);                                 \
     }
     TESTS
 #undef X
 }
 
 static void testMul() {
-    CORE_TEST_V3(FV3(3, 6, 9), coreMulV3F(CV30, FV3(1, 2, 3), 3));
+    TEST_V3(FV3(3, 6, 9), mulV3F(CV30, FV3(1, 2, 3), 3));
 }
 
 static void testSetMulVector() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(1, 2, 3, 4);                                               \
-        coreMulSet##T(&v, C##T(2, 1, 3, 4));                                   \
-        CORE_TEST_##T(C##T(2, 2, 9, 16), &v);                                  \
-        coreMulSet##T(&v, C##T(-3, 4, -2, -2));                                \
-        CORE_TEST_##T(C##T(-6, 8, -18, -32), &v);                              \
+        mulSet##T(&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));                                    \
+        TEST_##T(C##T(-6, 8, -18, -32), &v);                                   \
     }
     TESTS
 #undef X
 }
 
 static void testMulVector() {
-    CORE_TEST_V3(FV3(-2, -2, -9),
-                 coreMulV3(CV30, FV3(2, 1, 3), FV3(-1, -2, -3)));
-    CORE_TEST_V3(FV3(2, 2, 9), coreMulV3(CV30, FV3(1, 2, 3), FV3(2, 1, 3)));
+    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)));
 }
 
 static void testSetDiv() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(18, 36, 9, 27);                                            \
-        coreDivSet##T##F(&v, 3);                                               \
-        CORE_TEST_##T(C##T(6, 12, 3, 9), &v);                                  \
-        coreDivSet##T##F(&v, -3);                                              \
-        CORE_TEST_##T(C##T(-2, -4, -1, -3), &v);                               \
+        divSet##T##F(&v, 3);                                                   \
+        TEST_##T(C##T(6, 12, 3, 9), &v);                                       \
+        divSet##T##F(&v, -3);                                                  \
+        TEST_##T(C##T(-2, -4, -1, -3), &v);                                    \
     }
     TESTS
 #undef X
 }
 
 static void testDiv() {
-    CORE_TEST_V3(FV3(-1, -2, -3), coreDivV3F(CV30, FV3(-3, -6, -9), 3));
+    TEST_V3(FV3(-1, -2, -3), divV3F(CV30, FV3(-3, -6, -9), 3));
 }
 
 static void testSetDivVector() {
 #define X(T)                                                                   \
     {                                                                          \
         T v = *C##T(12, 4, 6, 8);                                              \
-        coreDivSet##T(&v, C##T(2, 1, 3, 4));                                   \
-        CORE_TEST_##T(C##T(6, 4, 2, 2), &v);                                   \
-        coreDivSet##T(&v, C##T(-3, 4, -2, -1));                                \
-        CORE_TEST_##T(C##T(-2, 1, -1, -2), &v);                                \
+        divSet##T(&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));                                    \
+        TEST_##T(C##T(-2, 1, -1, -2), &v);                                     \
     }
     TESTS
 #undef X
 }
 
 static void testDivVector() {
-    CORE_TEST_V3(FV3(-2, -0.5f, -1),
-                 coreDivV3(CV30, FV3(2, 1, 3), FV3(-1, -2, -3)));
-    CORE_TEST_V3(FV3(0.5f, 2, 1), coreDivV3(CV30, FV3(1, 2, 3), FV3(2, 1, 3)));
+    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)));
 }
 
 static void testSetInvert() {
-    CORE_TEST_V2(FV2(-1, 2), coreInvertSetV2(FV2(1, -2)));
-    CORE_TEST_V3(FV3(-1, 2, 3), coreInvertSetV3(FV3(1, -2, -3)));
-    CORE_TEST_V4(CV4(-1, 2, 3, 4), coreInvertSetV4(CV4(1, -2, -3, -4)));
-    CORE_TEST_IV2(FIV2(-1, 2), coreInvertSetIV2(FIV2(1, -2)));
-    CORE_TEST_IV3(FIV3(-1, 2, 3), coreInvertSetIV3(FIV3(1, -2, -3)));
-    CORE_TEST_IV4(CIV4(-1, 2, 3, 4), coreInvertSetIV4(CIV4(1, -2, -3, -4)));
+    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)));
 }
 
 static void testInvert() {
-    CORE_TEST_V3(FV3(-1, 2, 3), coreInvertV3(CV30, FV3(1, -2, -3)));
+    TEST_V3(FV3(-1, 2, 3), invertV3(CV30, FV3(1, -2, -3)));
 }
 
 static void testDot() {
-    CORE_TEST_FLOAT(0, coreDotV2(FV2(-4, 2), FV2(-1, -2)), eps);
-    CORE_TEST_FLOAT(9, coreDotV3(FV3(-4, 2, -3), FV3(-1, -2, -3)), eps);
-    CORE_TEST_FLOAT(16, coreDotV4(CV4(-4, 2, -3, 1), CV4(-1, -2, -3, 7)), eps);
+    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);
 }
 
 static void testSquareLength() {
-    CORE_TEST_FLOAT(20, coreSquareLengthV2(FV2(-4, 2)), eps);
-    CORE_TEST_FLOAT(29, coreSquareLengthV3(FV3(-4, 2, -3)), eps);
-    CORE_TEST_FLOAT(54, coreSquareLengthV4(CV4(-4, 2, -3, 5)), eps);
+    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);
 }
 
 static void testLength() {
-    CORE_TEST_FLOAT(5, coreLengthV2(FV2(-3, 4)), eps);
-    CORE_TEST_FLOAT(13, coreLengthV2(FV2(5, 12)), eps);
-    CORE_TEST_FLOAT(3, coreLengthV3(FV3(-2, 2, -1)), eps);
-    CORE_TEST_FLOAT(7, coreLengthV3(FV3(6, 2, -3)), eps);
-    CORE_TEST_FLOAT(3, coreLengthV4(CV4(-2, 2, 0, -1)), eps);
-    CORE_TEST_FLOAT(9, coreLengthV4(CV4(6, 0, -6, 3)), eps);
+    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);
 }
 
 static void testNormalize() {
     {
         V2 v1 = {{-15, 20}};
         V2 v2;
-        coreMulV2F(&v2, &v1, 1.0f / 25.0f);
-        coreNormalizeV2(&v1);
-        CORE_TEST_V2(&v2, &v1);
+        mulV2F(&v2, &v1, 1.0f / 25.0f);
+        normalizeV2(&v1);
+        TEST_V2(&v2, &v1);
 
         V2 v3 = {{15, 36}};
         V2 v4;
-        coreMulV2F(&v4, &v3, 1.0f / 39.0f);
-        coreNormalizeV2(&v3);
-        CORE_TEST_V2(&v4, &v3);
+        mulV2F(&v4, &v3, 1.0f / 39.0f);
+        normalizeV2(&v3);
+        TEST_V2(&v4, &v3);
     }
     {
         V3 v1 = {{-2, 2, -1}};
         V3 v2;
-        coreMulV3F(&v2, &v1, 1.0f / 3.0f);
-        coreNormalizeV3(&v1);
-        CORE_TEST_V3(&v2, &v1);
+        mulV3F(&v2, &v1, 1.0f / 3.0f);
+        normalizeV3(&v1);
+        TEST_V3(&v2, &v1);
 
         V3 v3 = {{6, 2, -3}};
         V3 v4;
-        coreMulV3F(&v4, &v3, 1.0f / 7.0f);
-        coreNormalizeV3(&v3);
-        CORE_TEST_V3(&v4, &v3);
+        mulV3F(&v4, &v3, 1.0f / 7.0f);
+        normalizeV3(&v3);
+        TEST_V3(&v4, &v3);
     }
     {
         V4 v1 = {{-2, 2, 0, -1}};
         V4 v2;
-        coreMulV4F(&v2, &v1, 1.0f / 3.0f);
-        coreNormalizeV4(&v1);
-        CORE_TEST_V4(&v2, &v1);
+        mulV4F(&v2, &v1, 1.0f / 3.0f);
+        normalizeV4(&v1);
+        TEST_V4(&v2, &v1);
 
         V4 v3 = {{6, 0, -6, 3}};
         V4 v4;
-        coreMulV4F(&v4, &v3, 1.0f / 9.0f);
-        coreNormalizeV4(&v3);
-        CORE_TEST_V4(&v4, &v3);
+        mulV4F(&v4, &v3, 1.0f / 9.0f);
+        normalizeV4(&v3);
+        TEST_V4(&v4, &v3);
     }
 }
 
 static void testCast() {
-    CORE_TEST_V2(FV2(-2.0f, 2.0f), coreConvertIV2(CV20, FIV2(-2, 2)));
-    CORE_TEST_IV2(FIV2(-2, 2), coreConvertV2(CIV20, FV2(-2.5f, 2.6f)));
-    CORE_TEST_V3(FV3(-2.0f, 2.0f, 9.0f), coreConvertIV3(CV30, FIV3(-2, 2, 9)));
-    CORE_TEST_IV3(FIV3(-2, 2, 9), coreConvertV3(CIV30, FV3(-2.5f, 2.6f, 9.0f)));
-    CORE_TEST_V4(CV4(-2.0f, 2.0f, 9.0f, 6.0f),
-                 coreConvertIV4(CV40, CIV4(-2, 2, 9, 6)));
-    CORE_TEST_IV4(CIV4(-2, 2, 9, 3),
-                  coreConvertV4(CIV40, CV4(-2.5f, 2.6f, 9.0f, 3.2f)));
+    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)));
 }
 
 static void testToString() {
     char buffer[64];
-    coreToStringV2(FV2(4, 5), buffer, sizeof(buffer));
-    CORE_TEST_STRING("[4.000, 5.000]", buffer);
-    coreToStringV3(FV3(4, 5, 6), buffer, sizeof(buffer));
-    CORE_TEST_STRING("[4.000, 5.000, 6.000]", buffer);
-    coreToStringV4(CV4(4, 5, 6, 7), buffer, sizeof(buffer));
-    CORE_TEST_STRING("[4.000, 5.000, 6.000, 7.000]", buffer);
-    coreToStringIV2(FIV2(4, 5), buffer, sizeof(buffer));
-    CORE_TEST_STRING("[4, 5]", buffer);
-    coreToStringIV3(FIV3(4, 5, 6), buffer, sizeof(buffer));
-    CORE_TEST_STRING("[4, 5, 6]", buffer);
-    coreToStringIV4(CIV4(4, 5, 6, 7), buffer, sizeof(buffer));
-    CORE_TEST_STRING("[4, 5, 6, 7]", buffer);
+    toStringV2(FV2(4, 5), buffer, sizeof(buffer));
+    TEST_STRING("[4.000, 5.000]", buffer);
+    toStringV3(FV3(4, 5, 6), buffer, sizeof(buffer));
+    TEST_STRING("[4.000, 5.000, 6.000]", buffer);
+    toStringV4(CV4(4, 5, 6, 7), buffer, sizeof(buffer));
+    TEST_STRING("[4.000, 5.000, 6.000, 7.000]", buffer);
+    toStringIV2(FIV2(4, 5), buffer, sizeof(buffer));
+    TEST_STRING("[4, 5]", buffer);
+    toStringIV3(FIV3(4, 5, 6), buffer, sizeof(buffer));
+    TEST_STRING("[4, 5, 6]", buffer);
+    toStringIV4(CIV4(4, 5, 6, 7), buffer, sizeof(buffer));
+    TEST_STRING("[4, 5, 6, 7]", buffer);
 }
 
 void testVector() {