Add namespace import to Matrix

include/core/Matrix.h

@@ -32,4 +32,26 @@ CoreMatrix* coreRotateMatrixZ(CoreMatrix* m, float degrees);
 CoreMatrix* coreRotateMatrix(CoreMatrix* m, const CoreQuaternion* q);
 size_t coreToStringMatrix(const CoreMatrix* m, char* buffer, size_t n);
 
+#ifdef IMPORT_CORE
+#define Matrix CoreMatrix
+#define ZERO_MATRIX CORE_ZERO_MATRIX
+#define UNIT_MATRIX CORE_UNIT_MATRIX
+#define transposeMatrix coreTransposeMatrix
+#define mulSetMatrix coreMulSetMatrix
+#define mulMatrix coreMulMatrix
+#define mulMatrixV3 coreMulMatrixV3
+#define scaleMatrix coreScaleMatrix
+#define scaleMatrixF coreScaleMatrixF
+#define translateMatrix coreTranslateMatrix
+#define translateMatrixX coreTranslateMatrixX
+#define translateMatrixY coreTranslateMatrixY
+#define translateMatrixZ coreTranslateMatrixZ
+#define translateMatrixTo coreTranslateMatrixTo
+#define rotateMatrixX coreRotateMatrixX
+#define rotateMatrixY coreRotateMatrixY
+#define rotateMatrixZ coreRotateMatrixZ
+#define rotateMatrix coreRotateMatrix
+#define toStringMatrix coreToStringMatrix
+#endif
+
 #endif

src/Matrix.c

@@ -5,8 +5,8 @@
 
 #include "core/Utility.h"
 
-CoreMatrix* coreTransposeMatrix(CoreMatrix* m) {
-    CoreMatrix c = CORE_ZERO_MATRIX;
+Matrix* transposeMatrix(Matrix* m) {
+    Matrix c = CORE_ZERO_MATRIX;
     for(size_t x = 0; x < 4; x++) {
         for(size_t y = 0; y < 4; y++) {
             c.data[x].data[y] = m->data[y].data[x];
@@ -18,7 +18,7 @@ CoreMatrix* coreTransposeMatrix(CoreMatrix* m) {
 
 #define CV40 (&CORE_VECTOR4)
 
-CoreMatrix* coreMulSetMatrix(CoreMatrix* m, const CoreMatrix* a) {
+Matrix* mulSetMatrix(Matrix* m, const Matrix* a) {
     for(int i = 0; i < 4; i++) {
         CoreVector4 d = CORE_VECTOR4;
         coreAddSetV4(&d, coreMulV4F(CV40, a->data + 0, m->data[i].data[0]));
@@ -30,15 +30,14 @@ CoreMatrix* coreMulSetMatrix(CoreMatrix* m, const CoreMatrix* a) {
     return m;
 }
 
-CoreMatrix* coreMulMatrix(CoreMatrix* m, const CoreMatrix* a,
-                          const CoreMatrix* b) {
+Matrix* mulMatrix(Matrix* m, const Matrix* a, const Matrix* b) {
     *m = *a;
-    coreMulSetMatrix(m, b);
+    mulSetMatrix(m, b);
     return m;
 }
 
-CoreVector3* coreMulMatrixV3(CoreVector3* v, const CoreMatrix* m,
-                             const CoreVector3* a) {
+CoreVector3* mulMatrixV3(CoreVector3* v, const Matrix* m,
+                         const CoreVector3* a) {
     CoreVector4 v4 = {{a->data[0], a->data[1], a->data[2], 1.0f}};
     v->data[0] = coreDotV4(m->data + 0, &v4);
     v->data[1] = coreDotV4(m->data + 1, &v4);
@@ -47,40 +46,40 @@ CoreVector3* coreMulMatrixV3(CoreVector3* v, const CoreMatrix* m,
     return v;
 }
 
-CoreMatrix* coreScaleMatrix(CoreMatrix* m, const CoreVector3* v) {
+Matrix* scaleMatrix(Matrix* m, const CoreVector3* v) {
     coreMulSetV4F(m->data + 0, v->data[0]);
     coreMulSetV4F(m->data + 1, v->data[1]);
     coreMulSetV4F(m->data + 2, v->data[2]);
     return m;
 }
 
-CoreMatrix* coreScaleMatrixF(CoreMatrix* m, float f) {
-    return coreScaleMatrix(m, &(CoreVector3){{f, f, f}});
+Matrix* scaleMatrixF(Matrix* m, float f) {
+    return scaleMatrix(m, &(CoreVector3){{f, f, f}});
 }
 
-CoreMatrix* coreTranslateMatrix(CoreMatrix* m, const CoreVector3* v) {
-    coreTranslateMatrixX(m, v->data[0]);
-    coreTranslateMatrixY(m, v->data[1]);
-    coreTranslateMatrixZ(m, v->data[2]);
+Matrix* translateMatrix(Matrix* m, const CoreVector3* v) {
+    translateMatrixX(m, v->data[0]);
+    translateMatrixY(m, v->data[1]);
+    translateMatrixZ(m, v->data[2]);
     return m;
 }
 
-CoreMatrix* coreTranslateMatrixX(CoreMatrix* m, float tx) {
+Matrix* translateMatrixX(Matrix* m, float tx) {
     coreAddSetV4(m->data + 0, coreMulV4F(CV40, m->data + 3, tx));
     return m;
 }
 
-CoreMatrix* coreTranslateMatrixY(CoreMatrix* m, float ty) {
+Matrix* translateMatrixY(Matrix* m, float ty) {
     coreAddSetV4(m->data + 1, coreMulV4F(CV40, m->data + 3, ty));
     return m;
 }
 
-CoreMatrix* coreTranslateMatrixZ(CoreMatrix* m, float tz) {
+Matrix* translateMatrixZ(Matrix* m, float tz) {
     coreAddSetV4(m->data + 2, coreMulV4F(CV40, m->data + 3, tz));
     return m;
 }
 
-CoreMatrix* coreTranslateMatrixTo(CoreMatrix* m, const CoreVector3* v) {
+Matrix* translateMatrixTo(Matrix* m, const CoreVector3* v) {
     m->data[0] = (CoreVector4){{1.0f, 0.0f, 0.0f, v->data[0]}};
     m->data[1] = (CoreVector4){{0.0f, 1.0f, 0.0f, v->data[1]}};
     m->data[2] = (CoreVector4){{0.0f, 0.0f, 1.0f, v->data[2]}};
@@ -88,7 +87,7 @@ CoreMatrix* coreTranslateMatrixTo(CoreMatrix* m, const CoreVector3* v) {
     return m;
 }
 
-static CoreMatrix* rotate(CoreMatrix* m, float degrees, int a, int b) {
+static Matrix* rotate(Matrix* m, float degrees, int a, int b) {
     degrees = coreDegreeToRadian(degrees);
     float sin = sinf(degrees);
     float cos = cosf(degrees);
@@ -100,19 +99,19 @@ static CoreMatrix* rotate(CoreMatrix* m, float degrees, int a, int b) {
     return m;
 }
 
-CoreMatrix* coreRotateMatrixX(CoreMatrix* m, float degrees) {
+Matrix* rotateMatrixX(Matrix* m, float degrees) {
     return rotate(m, degrees, 1, 2);
 }
 
-CoreMatrix* coreRotateMatrixY(CoreMatrix* m, float degrees) {
+Matrix* rotateMatrixY(Matrix* m, float degrees) {
     return rotate(m, -degrees, 0, 2);
 }
 
-CoreMatrix* coreRotateMatrixZ(CoreMatrix* m, float degrees) {
+Matrix* rotateMatrixZ(Matrix* m, float degrees) {
     return rotate(m, degrees, 0, 1);
 }
 
-CoreMatrix* coreRotateMatrix(CoreMatrix* m, const CoreQuaternion* q) {
+Matrix* rotateMatrix(Matrix* m, const CoreQuaternion* q) {
     CoreVector3 a;
     CoreVector3 b;
     CoreVector3 c;
@@ -135,7 +134,7 @@ CoreMatrix* coreRotateMatrix(CoreMatrix* m, const CoreQuaternion* q) {
     return m;
 }
 
-size_t coreToStringMatrix(const CoreMatrix* m, char* buffer, size_t n) {
+size_t toStringMatrix(const Matrix* m, char* buffer, size_t n) {
     size_t w = 0;
     coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "["));
     coreStringAdd(&w, &buffer, &n, coreToStringV4(m->data + 0, buffer, n));
@@ -147,4 +146,4 @@ size_t coreToStringMatrix(const CoreMatrix* 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

test/modules/MatrixTests.c

@@ -1,7 +1,6 @@
 #include "../Tests.h"
 #include "core/Matrix.h"
 
-typedef CoreMatrix Matrix;
 typedef CoreVector3 V3;
 #define CV3(a, b, c) (&(V3){{a, b, c}})
 #define CV30 CV3(0.0f, 0.0f, 0.0f)
@@ -23,9 +22,9 @@ static void testTranspose() {
         data[i] = (float)(i + 1);
     }
     Matrix t = m;
-    coreTransposeMatrix(&t);
+    transposeMatrix(&t);
     Matrix m2 = t;
-    coreTransposeMatrix(&m2);
+    transposeMatrix(&m2);
 
     const float* mp = (float*)&m;
     const float* tp = (float*)&t;
@@ -42,44 +41,44 @@ static void testTranspose() {
 
 static void testScale() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreScaleMatrix(&m, CV3(2.0f, 3.0f, 4.0f));
+    scaleMatrix(&m, CV3(2.0f, 3.0f, 4.0f));
     CORE_TEST_V3(CV3(-8.0f, 18.0f, 28.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+                 mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testUniformScale() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreScaleMatrixF(&m, 2.0f);
+    scaleMatrixF(&m, 2.0f);
     CORE_TEST_V3(CV3(-8.0f, 12.0f, 14.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+                 mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateX() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreTranslateMatrixX(&m, 5.0f);
+    translateMatrixX(&m, 5.0f);
     CORE_TEST_V3(CV3(1.0f, 6.0f, 7.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+                 mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateY() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreTranslateMatrixY(&m, 6.0f);
+    translateMatrixY(&m, 6.0f);
     CORE_TEST_V3(CV3(-4.0f, 12.0f, 7.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+                 mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateZ() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreTranslateMatrixZ(&m, 7.0f);
+    translateMatrixZ(&m, 7.0f);
     CORE_TEST_V3(CV3(-4.0f, 6.0f, 14.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+                 mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslate() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreTranslateMatrix(&m, CV3(1.0f, 2.0f, 3.0f));
+    translateMatrix(&m, CV3(1.0f, 2.0f, 3.0f));
     CORE_TEST_V3(CV3(-3.0f, 8.0f, 10.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
+                 mulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
 }
 
 static void testTranslateTo() {
@@ -88,8 +87,8 @@ static void testTranslateTo() {
     for(int i = 0; i < 16; i++) {
         ((float*)&m)[i] = (float)i + 1.0f;
     }
-    coreTranslateMatrixTo(&m, CV3(6.0f, 8.0f, 9.0f));
-    coreToStringMatrix(&m, buffer, sizeof(buffer));
+    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]]",
@@ -98,66 +97,66 @@ static void testTranslateTo() {
 
 static void testCombination() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreScaleMatrixF(&m, 2.0f);
-    coreTranslateMatrixX(&m, 1.0f);
-    coreTranslateMatrixY(&m, 2.0f);
-    coreTranslateMatrixZ(&m, 3.0f);
-    coreTranslateMatrix(&m, CV3(-4.0f, 2.0f, 3.0f));
-    coreScaleMatrix(&m, CV3(2.0f, 3.0f, 4.0f));
-    coreScaleMatrixF(&m, 0.5f);
+    scaleMatrixF(&m, 2.0f);
+    translateMatrixX(&m, 1.0f);
+    translateMatrixY(&m, 2.0f);
+    translateMatrixZ(&m, 3.0f);
+    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),
-                 coreMulMatrixV3(CV30, &m, CV3(1.0f, 1.0f, 1.0f)));
+                 mulMatrixV3(CV30, &m, CV3(1.0f, 1.0f, 1.0f)));
 }
 
 static void testMatrixCombination() {
     Matrix a = CORE_UNIT_MATRIX;
-    coreScaleMatrixF(&a, 2.0f);
-    coreTranslateMatrix(&a, CV3(1.0f, 2.0f, 3.0f));
+    scaleMatrixF(&a, 2.0f);
+    translateMatrix(&a, CV3(1.0f, 2.0f, 3.0f));
 
     Matrix b = CORE_UNIT_MATRIX;
-    coreScaleMatrixF(&b, 3.0f);
-    coreTranslateMatrix(&b, CV3(1.0f, 1.0f, 1.0f));
+    scaleMatrixF(&b, 3.0f);
+    translateMatrix(&b, CV3(1.0f, 1.0f, 1.0f));
 
     Matrix c = CORE_UNIT_MATRIX;
-    coreTranslateMatrix(&c, CV3(-1.0f, -2.0f, -3.0f));
+    translateMatrix(&c, CV3(-1.0f, -2.0f, -3.0f));
 
-    coreMulSetMatrix(&c, coreMulMatrix(&CORE_ZERO_MATRIX, &b, &a));
+    mulSetMatrix(&c, mulMatrix(&CORE_ZERO_MATRIX, &b, &a));
 
     CORE_TEST_V3(CV3(9.0f, 11.0f, 13.0f),
-                 coreMulMatrixV3(CV30, &c, CV3(1.0f, 1.0f, 1.0f)));
+                 mulMatrixV3(CV30, &c, CV3(1.0f, 1.0f, 1.0f)));
 }
 
 static void testRotateX() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreRotateMatrixX(&m, 90.0f);
+    rotateMatrixX(&m, 90.0f);
     CORE_TEST_V3(CV3(1.0f, 0.0f, 0.0f),
-                 coreMulMatrixV3(CV30, &m, 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),
-                 coreMulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
+                 mulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
     CORE_TEST_V3(CV3(0.0f, -1.0f, 0.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
+                 mulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
 }
 
 static void testRotateY() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreRotateMatrixY(&m, 90.0f);
+    rotateMatrixY(&m, 90.0f);
     CORE_TEST_V3(CV3(0.0f, 0.0f, -1.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
+                 mulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
     CORE_TEST_V3(CV3(0.0f, 1.0f, 0.0f),
-                 coreMulMatrixV3(CV30, &m, 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),
-                 coreMulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
+                 mulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
 }
 
 static void testRotateZ() {
     Matrix m = CORE_UNIT_MATRIX;
-    coreRotateMatrixZ(&m, 90.0f);
+    rotateMatrixZ(&m, 90.0f);
     CORE_TEST_V3(CV3(0.0f, 1.0f, 0.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
+                 mulMatrixV3(CV30, &m, CV3(1.0f, 0.0f, 0.0f)));
     CORE_TEST_V3(CV3(-1.0f, 0.0f, 0.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
+                 mulMatrixV3(CV30, &m, CV3(0.0f, 1.0f, 0.0f)));
     CORE_TEST_V3(CV3(0.0f, 0.0f, 1.0f),
-                 coreMulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
+                 mulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
 }
 
 static void testQuaternionMatrix() {
@@ -169,18 +168,18 @@ static void testQuaternionMatrix() {
     coreAxisAngleQ(&q3, CV3(0.0f, 0.0f, 1.0f), 60.0f);
 
     Matrix m = CORE_UNIT_MATRIX;
-    coreTranslateMatrix(&m, CV3(1.0f, 2.0f, 3.0f));
-    coreRotateMatrix(&m, &q1);
-    coreRotateMatrix(&m, &q2);
-    coreRotateMatrix(&m, &q3);
-    coreTranslateMatrix(&m, CV3(1.0f, 2.0f, 3.0f));
+    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;
-    coreTranslateMatrix(&check, CV3(1.0f, 2.0f, 3.0f));
-    coreRotateMatrixX(&check, 48.0f);
-    coreRotateMatrixY(&check, 52.0f);
-    coreRotateMatrixZ(&check, 60.0f);
-    coreTranslateMatrix(&check, CV3(1.0f, 2.0f, 3.0f));
+    translateMatrix(&check, CV3(1.0f, 2.0f, 3.0f));
+    rotateMatrixX(&check, 48.0f);
+    rotateMatrixY(&check, 52.0f);
+    rotateMatrixZ(&check, 60.0f);
+    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);
@@ -193,14 +192,14 @@ static void testToString() {
         ((float*)&m)[i] = (float)i + 1.0f;
     }
     char buffer[1024];
-    size_t n = coreToStringMatrix(&m, buffer, sizeof(buffer));
+    size_t n = toStringMatrix(&m, buffer, sizeof(buffer));
     CORE_TEST_SIZE(127, n);
     CORE_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 = coreToStringMatrix(&m, buffer, 20);
+    n = toStringMatrix(&m, buffer, 20);
     CORE_TEST_SIZE(127, n);
     CORE_TEST_STRING("[[1.000, 2.000, 3.0", buffer);
 }