ccore/test/modules/MatrixTests.c

#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)

static void testInit() {
    Matrix m = CORE_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);
    }
}

static void testTranspose() {
    Matrix m;
    float* data = (float*)&m;
    for(int i = 0; i < 16; i++) {
        data[i] = (float)(i + 1);
    }
    Matrix t = m;
    coreTransposeMatrix(&t);
    Matrix m2 = t;
    coreTransposeMatrix(&m2);

    const float* mp = (float*)&m;
    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);
        }
    }
    const float* mp2 = (float*)&m2;
    for(int i = 0; i < 16; i++) {
        CORE_TEST_FLOAT(mp[i], mp2[i], 0.0f);
    }
}

static void testScale() {
    Matrix m = CORE_UNIT_MATRIX;
    coreScaleMatrix(&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)));
}

static void testUniformScale() {
    Matrix m = CORE_UNIT_MATRIX;
    coreScaleMatrixF(&m, 2.0f);
    CORE_TEST_V3(CV3(-8.0f, 12.0f, 14.0f),
                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
}

static void testTranslateX() {
    Matrix m = CORE_UNIT_MATRIX;
    coreTranslateMatrixX(&m, 5.0f);
    CORE_TEST_V3(CV3(1.0f, 6.0f, 7.0f),
                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
}

static void testTranslateY() {
    Matrix m = CORE_UNIT_MATRIX;
    coreTranslateMatrixY(&m, 6.0f);
    CORE_TEST_V3(CV3(-4.0f, 12.0f, 7.0f),
                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
}

static void testTranslateZ() {
    Matrix m = CORE_UNIT_MATRIX;
    coreTranslateMatrixZ(&m, 7.0f);
    CORE_TEST_V3(CV3(-4.0f, 6.0f, 14.0f),
                 coreMulMatrixV3(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));
    CORE_TEST_V3(CV3(-3.0f, 8.0f, 10.0f),
                 coreMulMatrixV3(CV30, &m, CV3(-4.0f, 6.0f, 7.0f)));
}

static void testTranslateTo() {
    char buffer[1024];
    Matrix m;
    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));
    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);
}

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);
    CORE_TEST_V3(CV3(-1.0f, 9.0f, 16.0f),
                 coreMulMatrixV3(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));

    Matrix b = CORE_UNIT_MATRIX;
    coreScaleMatrixF(&b, 3.0f);
    coreTranslateMatrix(&b, CV3(1.0f, 1.0f, 1.0f));

    Matrix c = CORE_UNIT_MATRIX;
    coreTranslateMatrix(&c, CV3(-1.0f, -2.0f, -3.0f));

    coreMulSetMatrix(&c, coreMulMatrix(&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)));
}

static void testRotateX() {
    Matrix m = CORE_UNIT_MATRIX;
    coreRotateMatrixX(&m, 90.0f);
    CORE_TEST_V3(CV3(1.0f, 0.0f, 0.0f),
                 coreMulMatrixV3(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)));
    CORE_TEST_V3(CV3(0.0f, -1.0f, 0.0f),
                 coreMulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
}

static void testRotateY() {
    Matrix m = CORE_UNIT_MATRIX;
    coreRotateMatrixY(&m, 90.0f);
    CORE_TEST_V3(CV3(0.0f, 0.0f, -1.0f),
                 coreMulMatrixV3(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)));
    CORE_TEST_V3(CV3(1.0f, 0.0f, 0.0f),
                 coreMulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
}

static void testRotateZ() {
    Matrix m = CORE_UNIT_MATRIX;
    coreRotateMatrixZ(&m, 90.0f);
    CORE_TEST_V3(CV3(0.0f, 1.0f, 0.0f),
                 coreMulMatrixV3(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)));
    CORE_TEST_V3(CV3(0.0f, 0.0f, 1.0f),
                 coreMulMatrixV3(CV30, &m, CV3(0.0f, 0.0f, 1.0f)));
}

static void testToString() {
    Matrix m;
    for(int i = 0; i < 16; i++) {
        ((float*)&m)[i] = (float)i + 1.0f;
    }
    char buffer[1024];
    size_t n = coreToStringMatrix(&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);
    CORE_TEST_SIZE(127, n);
    CORE_TEST_STRING("[[1.000, 2.000, 3.0", buffer);
}

/*static void testQuaternionMatrix() {
    Core::Quaternion q1(V3(1.0f, 0.0f, 0.0f), 48.0f);
    Core::Quaternion q2(V3(0.0f, 1.0f, 0.0f), 52.0f);
    Core::Quaternion q3(V3(0.0f, 0.0f, 1.0f), 60.0f);

    Core::Matrix m;
    m.translate(V3(1.0f, 2.0f, 3.0f));
    m.rotate(q1).rotate(q2).rotate(q3);
    m.translate(V3(1.0f, 2.0f, 3.0f));

    Core::Matrix check;
    check.translate(V3(1.0f, 2.0f, 3.0f));
    check.rotateX(48.0f).rotateY(52.0f).rotateZ(60.0f);
    check.translate(V3(1.0f, 2.0f, 3.0f));

    for(int i = 0; i < 16; i++) {
        CORE_TEST_FLOAT(check.getValues()[i], m.getValues()[i], 0.0001f);
    }
}*/

void coreTestMatrix() {
    testInit();
    testTranspose();
    testScale();
    testUniformScale();
    testTranslateX();
    testTranslateY();
    testTranslateZ();
    testTranslate();
    testTranslateTo();
    testCombination();
    testMatrixCombination();
    testRotateX();
    testRotateY();
    testRotateZ();
    testToString();
    // testQuaternionMatrix();
}