begin matrix; tests

UGameEngine/UGameEngine.pro

@@ -14,14 +14,15 @@ DEFINES += UGAMEENGINE_LIBRARY
 SOURCES += engine/ugameengine.cpp \
     engine/abstractrenderdevice.cpp \
     entities/ugeentity.cpp \
-    utils/vector3d.cpp \
     utils/colorvector3d.cpp \
     entities/ugeentitycube.cpp \
     entities/ugeentityaxes.cpp \
     utils/wavefrontobj.cpp \
     entities/ugeentitywavefrontobj.cpp \
     utils/texturevector3d.cpp \
-    utils/vector2d.cpp
+    utils/vector2d.cpp \
+    utils/vector3d.cpp \
+    utils/matrix3x3.cpp
 
 HEADERS += engine/ugameengine.h\
     engine/abstractrenderdevice.h \
@@ -35,7 +36,10 @@ HEADERS += engine/ugameengine.h\
     utils/texturevector3d.h \
     utils/vectorxd.h \
     utils/vectorxd.hxx \
-    utils/vector2d.h
+    utils/vector2d.h \
+    utils/matrixmxn.h \
+    utils/matrixmxn.hxx \
+    utils/matrix3x3.h
 
 
 # FLEX && BISON

UGameEngine/utils/matrix3x3.cpp

@@ -0,0 +1,5 @@
+#include "matrix3x3.h"
+
+//Matrix3x3::Matrix3x3()
+//{
+//}

UGameEngine/utils/matrix3x3.h

@@ -0,0 +1,14 @@
+#ifndef MATRIX3X3_H
+#define MATRIX3X3_H
+
+#include "utils/matrixmxn.h"
+
+typedef MatrixMxN<3, 3> Matrix3x3;
+
+//class Matrix3x3
+//{
+//public:
+//    Matrix3x3();
+//};
+
+#endif // MATRIX3X3_H

UGameEngine/utils/matrixmxn.h

@@ -0,0 +1,60 @@
+#ifndef MATRIXMXN_H
+#define MATRIXMXN_H
+
+#define uge_gm_tmpl_mnt template<unsigned M, unsigned N, class T>
+#define uge_gm_tmpl_mn template<unsigned M, unsigned N>
+#define uge_gm_tmpl_p template<unsigned P>
+#define uge_gm_tmpl_mntp template<unsigned M, unsigned N, class T, unsigned P>
+
+uge_gm_tmpl_mn class MatrixMxN;
+
+uge_gm_tmpl_mnt class GenericMatrix
+{
+public:
+    virtual ~GenericMatrix();
+
+    T& setScalar(unsigned i, unsigned j, double value);
+    double getScalar(unsigned i, unsigned j) const;
+
+    bool isNull() const;
+
+    bool equal(const T& other) const;
+
+    T& add(double k);
+    T& add(double scalars[M][N]);
+    T& add(const T& other);
+
+    T& sub(double k);
+    T& sub(double scalars[M][N]);
+    T& sub(const T& other);
+
+    T& mult(double k);
+    uge_gm_tmpl_p MatrixMxN<M, P> mult(double scalars[N][P]);
+    uge_gm_tmpl_p MatrixMxN<M, P> mult(const MatrixMxN<N, P>& other);
+
+    T& div(double k);
+    T& div(double scalars[M][N]);
+    T& div(const T& other);
+
+protected:
+    double _scalars[M][N];
+
+private:
+    T* getThis() const;
+};
+
+uge_gm_tmpl_mn class MatrixMxN: public GenericMatrix<M, N, MatrixMxN<M, N> >
+{
+public:
+    MatrixMxN();
+    MatrixMxN(double k);
+    MatrixMxN(double scalars[M][N]);
+    virtual ~MatrixMxN();
+
+protected:
+    using GenericMatrix<M, N, MatrixMxN<M, N> >::_scalars;
+};
+
+#include "matrixmxn.hxx"
+
+#endif // MATRIXMXN_H

UGameEngine/utils/matrixmxn.hxx

@@ -0,0 +1,151 @@
+#define uge_gm_tmpl_mnt template<unsigned M, unsigned N, class T>
+#define uge_gm_tmpl_mn template<unsigned M, unsigned N>
+
+uge_gm_tmpl_mn MatrixMxN<M, N>::MatrixMxN()
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] = 0;
+        }
+    }
+}
+
+uge_gm_tmpl_mn MatrixMxN<M, N>::MatrixMxN(double k)
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] = k;
+        }
+    }
+}
+
+uge_gm_tmpl_mn MatrixMxN<M, N>::MatrixMxN(double scalars[M][N])
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] = scalars[i][j];
+        }
+    }
+}
+
+uge_gm_tmpl_mn MatrixMxN<M, N>::~MatrixMxN()
+{
+}
+
+uge_gm_tmpl_mnt GenericMatrix<M, N, T>::~GenericMatrix()
+{
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::setScalar(unsigned i, unsigned j, double value)
+{
+    _scalars[i][j] = value;
+    return *getThis();
+}
+
+uge_gm_tmpl_mnt double GenericMatrix<M, N, T>::getScalar(unsigned i, unsigned j) const
+{
+    return _scalars[i][j];
+}
+
+uge_gm_tmpl_mnt T *GenericMatrix<M, N, T>::getThis() const
+{
+    return (T*)this;
+}
+
+uge_gm_tmpl_mnt bool GenericMatrix<M, N, T>::isNull() const
+{
+    return equal(T());
+}
+
+uge_gm_tmpl_mnt bool GenericMatrix<M, N, T>::equal(const T &other) const
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            if (_scalars[i][j] != other._scalars[i][j]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::add(double k)
+{
+    return add(T(k));
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::add(double scalars[M][N])
+{
+    return add(T(scalars));
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::add(const T &other)
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] += other._scalars[i][j];
+        }
+    }
+    return *getThis();
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::sub(double k)
+{
+    return sub(T(k));
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::sub(double scalars[M][N])
+{
+    return sub(T(scalars));
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::sub(const T &other)
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] -= other._scalars[i][j];
+        }
+    }
+    return *getThis();
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::mult(double k)
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] *= k;
+        }
+    }
+    return *getThis();
+}
+
+uge_gm_tmpl_mnt uge_gm_tmpl_p MatrixMxN<M, P> GenericMatrix<M, N, T>::mult(double scalars[N][P])
+{
+    return mult(MatrixMxN<N, P>(scalars));
+}
+
+uge_gm_tmpl_mnt uge_gm_tmpl_p MatrixMxN<M, P> GenericMatrix<M, N, T>::mult(const MatrixMxN<N, P>& other)
+{
+    MatrixMxN<N, P> m;
+    return m;
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::div(double k)
+{
+    return div(T(k));
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::div(double scalars[M][N])
+{
+    return div(T(scalars));
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::div(const T &other)
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] /= other._scalars[i][j];
+        }
+    }
+    return *getThis();
+}

UGameEngine/utils/vectorxd.h

@@ -27,11 +27,11 @@ public:
 
     T& mult(double k);
     T& mult(double scalars[X]);
-    T& mult(const T& k);
+    T& mult(const T& other);
 
     T& div(double k);
     T& div(double scalars[X]);
-    T& div(const T& k);
+    T& div(const T& other);
 
     double dotProduct(const T& other) const;
 

tests/main.cpp

@@ -0,0 +1,17 @@
+#include <QApplication>
+#include <QtTest/QtTest>
+
+#include "testvector3d.h"
+#include "testmatrix3x3.h"
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+    app.setAttribute(Qt::AA_Use96Dpi, true);
+    QTEST_DISABLE_KEYPAD_NAVIGATION;
+    TestVector3D tv3d;
+    int rtv3d = QTest::qExec(&tv3d, argc, argv);
+    TestMatrix3x3 tm33;
+    int rtm33 = QTest::qExec(&tm33, argc, argv);
+    return !rtv3d && !rtm33;
+}

tests/testmatrix3x3.cpp

@@ -0,0 +1,62 @@
+#include <QtTest/QtTest>
+#include "utils/matrix3x3.h"
+#include "testmatrix3x3.h"
+
+void TestMatrix3x3::gettersSetters1()
+{
+    Matrix3x3 m;
+    QCOMPARE(m.getScalar(0, 0), 0.0);
+    QCOMPARE(m.getScalar(0, 1), 0.0);
+    QCOMPARE(m.getScalar(1, 0), 0.0);
+}
+
+void TestMatrix3x3::gettersSetters2()
+{
+    double scalars[3][3] = {{0.0, 1.0, 2.0},
+                            {3.0, 4.0, 5.0},
+                            {6.0, 7.0, 8.0}};
+    Matrix3x3 m(scalars);
+    QCOMPARE(m.getScalar(0, 0), 0.0);
+    QCOMPARE(m.getScalar(0, 1), 1.0);
+    QCOMPARE(m.getScalar(1, 0), 3.0);
+    QCOMPARE(m.getScalar(1, 2), 5.0);
+}
+
+void TestMatrix3x3::gettersSetters3()
+{
+    Matrix3x3 m;
+    m.setScalar(0, 0, 42.0).setScalar(0, 1, 24.0).setScalar(1, 0, 10.0);
+    QCOMPARE(m.getScalar(0, 0), 42.0);
+    QCOMPARE(m.getScalar(0, 1), 24.0);
+    QCOMPARE(m.getScalar(1, 0), 10.0);
+}
+
+void TestMatrix3x3::isNull1()
+{
+    double scalars[3][3] = {{0.0, 1.0, 2.0},
+                            {3.0, 4.0, 5.0},
+                            {6.0, 7.0, 8.0}};
+    Matrix3x3 m(scalars);
+    QCOMPARE(m.isNull(), false);
+}
+
+void TestMatrix3x3::isNull1Op()
+{
+//    double scalars[3][3] = {{0.0, 1.0, 2.0},
+//                            {3.0, 4.0, 5.0},
+//                            {6.0, 7.0, 8.0}};
+//    Matrix3x3 m(scalars);
+//    QCOMPARE((bool)m, false);
+}
+
+void TestMatrix3x3::isNull2()
+{
+    Matrix3x3 m;
+    QCOMPARE(m.isNull(), true);
+}
+
+void TestMatrix3x3::isNull2Op()
+{
+//    Matrix3x3 m;
+//    QCOMPARE((bool)m, true);
+}

tests/testmatrix3x3.h

@@ -0,0 +1,21 @@
+#ifndef TESTMATRIX3X3_H
+#define TESTMATRIX3X3_H
+
+#include <QObject>
+
+class TestMatrix3x3 : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void gettersSetters1();
+    void gettersSetters2();
+    void gettersSetters3();
+
+    void isNull1();
+    void isNull1Op();
+    void isNull2();
+    void isNull2Op();
+};
+
+#endif // TESTMATRIX3X3_H

tests/tests.pro

@@ -13,9 +13,13 @@ TEMPLATE = app
 
 
 SOURCES += \
-    testvector3d.cpp
+    testvector3d.cpp \
+    testmatrix3x3.cpp \
+    main.cpp
 
-HEADERS  +=
+HEADERS  += \
+    testvector3d.h \
+    testmatrix3x3.h
 
 FORMS    +=
 

tests/testvector3d.cpp

@@ -1,59 +1,7 @@
 #include <QtTest/QtTest>
 #include "utils/vector3d.h"
 
-class TestVector3D : public QObject
-{
-    Q_OBJECT
-
-private slots:
-    void gettersSetters1();
-    void gettersSetters2();
-    void gettersSetters3();
-
-    void isNull1();
-    void isNull1Op();
-    void isNull2();
-    void isNull2Op();
-
-    void equal1();
-    void equal2();
-    void equal3();
-    void equal4();
-    void equal5();
-    void equal6();
-
-    void add1();
-    void add1Op();
-    void add2();
-    void add2Op();
-    void add3Op();
-
-    void sub1();
-    void sub1Op();
-    void sub2();
-    void sub2Op();
-    void sub3Op();
-
-    void mult();
-    void mult1Op();
-    void mult2Op();
-    void mult3Op();
-
-    void div();
-    void divOp();
-
-    void dotProduct1();
-    void dotProduct2();
-
-    void crossProduct1();
-    void crossProduct2();
-    void crossProduct3();
-
-    void norm1();
-    void norm2();
-
-    void getScalarOp();
-};
+#include "testvector3d.h"
 
 void TestVector3D::gettersSetters1()
 {
@@ -415,5 +363,3 @@ void TestVector3D::getScalarOp()
     QCOMPARE(v[2], z);
 }
 
-QTEST_MAIN(TestVector3D)
-#include "testvector3d.moc"

tests/testvector3d.h

@@ -0,0 +1,60 @@
+#ifndef TESTVECTOR3D_H
+#define TESTVECTOR3D_H
+
+#include <QObject>
+
+class TestVector3D : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void gettersSetters1();
+    void gettersSetters2();
+    void gettersSetters3();
+
+    void isNull1();
+    void isNull1Op();
+    void isNull2();
+    void isNull2Op();
+
+    void equal1();
+    void equal2();
+    void equal3();
+    void equal4();
+    void equal5();
+    void equal6();
+
+    void add1();
+    void add1Op();
+    void add2();
+    void add2Op();
+    void add3Op();
+
+    void sub1();
+    void sub1Op();
+    void sub2();
+    void sub2Op();
+    void sub3Op();
+
+    void mult();
+    void mult1Op();
+    void mult2Op();
+    void mult3Op();
+
+    void div();
+    void divOp();
+
+    void dotProduct1();
+    void dotProduct2();
+
+    void crossProduct1();
+    void crossProduct2();
+    void crossProduct3();
+
+    void norm1();
+    void norm2();
+
+    void getScalarOp();
+};
+
+#endif // TESTVECTOR3D_H