unit tests and fixes

implemented the rest of the tests
euler single dimension angle tests now pass, missed 1.0f in z

Engine/source/math/mMatrix.h

@@ -713,7 +713,10 @@ public:
    ///< a * b -> M
    Matrix<DATA_TYPE, rows, cols>& mul(const Matrix<DATA_TYPE, rows, cols>& a, const F32 b)
    { return *this = a * b; }
-
+   Matrix<DATA_TYPE, rows, cols>& add(const Matrix<DATA_TYPE, rows, cols>& a)
+   {
+      return *this = *this += a;
+   }
 
    ///< M * p -> p (full [4x4] * [1x4])
    void mul(Point4F& p) const { p = *this * p; }
@@ -840,6 +843,33 @@ public:
       return *this;
    }
 
+   Matrix<DATA_TYPE, rows, cols> operator+(const Matrix<DATA_TYPE, rows, cols>& m2) {
+      Matrix<DATA_TYPE, rows, cols> result;
+
+      for (U32 i = 0; i < rows; ++i)
+      {
+         for (U32 j = 0; j < cols; ++j)
+         {
+            result(i, j) = 0; // Initialize result element to 0
+            result(i, j) = (*this)(i, j) + m2(i, j);
+         }
+      }
+
+      return result;
+   }
+
+   Matrix<DATA_TYPE, rows, cols> operator+=(const Matrix<DATA_TYPE, rows, cols>& m2) {
+      for (U32 i = 0; i < rows; ++i)
+      {
+         for (U32 j = 0; j < cols; ++j)
+         {
+            (*this)(i, j) += m2(i, j);
+         }
+      }
+
+      return (*this);
+   }
+
    Matrix<DATA_TYPE, rows, cols> operator * (const DATA_TYPE scalar) const {
       Matrix<DATA_TYPE, rows, cols> result;
       for (U32 i = 0; i < rows; i++)
@@ -917,7 +947,7 @@ public:
       return data[idx(col,row)];
    }
 
-   const DATA_TYPE& operator () (U32 row, U32 col) const {
+   DATA_TYPE operator () (U32 row, U32 col) const {
       if (row >= rows || col >= cols)
          AssertFatal(false, "Matrix indices out of range");
 
@@ -1302,7 +1332,7 @@ inline Matrix<DATA_TYPE, rows, cols>& Matrix<DATA_TYPE, rows, cols>::set(const E
    case AXIS_Z:
       (*this)(0, 0) = cosRoll;   (*this)(1, 0) = -sinRoll;  (*this)(2, 0) = 0.0f;
       (*this)(0, 1) = sinRoll;   (*this)(1, 1) = cosRoll;   (*this)(2, 1) = 0.0f;
-      (*this)(0, 2) = 0.0f;      (*this)(1, 2) = 0.0f;      (*this)(2, 2) = 0.0f;
+      (*this)(0, 2) = 0.0f;      (*this)(1, 2) = 0.0f;      (*this)(2, 2) = 1.0f;
       break;
    default:
       F32 r1 = cosYaw * cosRoll;

Engine/source/testing/mathMatrixTest.cpp

@@ -93,6 +93,472 @@ TEST(MatrixTest, TestEulerPointSet)
    EXPECT_NEAR(test(3, 0), 0.0f, 0.001f);      EXPECT_NEAR(test(3, 1), 0.0f, 0.001f);     EXPECT_NEAR(test(3, 2), 0.0f, 0.001f);    EXPECT_NEAR(test(3, 3), 1.0f, 0.001f);
 }
 
+TEST(MatrixTest, TestGetColumn4)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point4F column;
+
+   test.getColumn(0, &column);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 0), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 0), 0.001f);
+
+   test.getColumn(1, &column);
+
+   EXPECT_NEAR(column.x, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 1), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 1), 0.001f);
+
+   test.getColumn(2, &column);
+
+   EXPECT_NEAR(column.x, test(0, 2), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 2), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 2), 0.001f);
+
+   test.getColumn(3, &column);
+
+   EXPECT_NEAR(column.x, test(0, 3), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 3), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 3), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 3), 0.001f);
+
+}
+
+TEST(MatrixTest, TestGetRow4)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point4F column;
+
+   test.getRow(0, &column);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(0, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(0, 3), 0.001f);
+
+   test.getRow(1, &column);
+
+   EXPECT_NEAR(column.x, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(1, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(1, 3), 0.001f);
+
+   test.getRow(2, &column);
+
+   EXPECT_NEAR(column.x, test(2, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(2, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(2, 3), 0.001f);
+
+   test.getRow(3, &column);
+
+   EXPECT_NEAR(column.x, test(3, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(3, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(3, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 3), 0.001f);
+}
+
+TEST(MatrixTest, TestGetColumn3)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point3F column;
+
+   test.getColumn(0, &column);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 0), 0.001f);
+
+   test.getColumn(1, &column);
+
+   EXPECT_NEAR(column.x, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 1), 0.001f);
+
+   test.getColumn(2, &column);
+
+   EXPECT_NEAR(column.x, test(0, 2), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 2), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+
+   test.getColumn(3, &column);
+
+   EXPECT_NEAR(column.x, test(0, 3), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 3), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 3), 0.001f);
+
+}
+
+TEST(MatrixTest, TestGetRow3)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point3F column;
+
+   test.getRow(0, &column);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(0, 2), 0.001f);
+
+   test.getRow(1, &column);
+
+   EXPECT_NEAR(column.x, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(1, 2), 0.001f);
+
+   test.getRow(2, &column);
+
+   EXPECT_NEAR(column.x, test(2, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(2, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+
+   test.getRow(3, &column);
+
+   EXPECT_NEAR(column.x, test(3, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(3, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(3, 2), 0.001f);
+}
+
+TEST(MatrixTest, TestGetColumn4F)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point4F column;
+
+   column = test.getColumn4F(0);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 0), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 0), 0.001f);
+
+   column = test.getColumn4F(1);
+
+   EXPECT_NEAR(column.x, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 1), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 1), 0.001f);
+
+   column = test.getColumn4F(2);
+
+   EXPECT_NEAR(column.x, test(0, 2), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 2), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 2), 0.001f);
+
+   column = test.getColumn4F(3);
+
+   EXPECT_NEAR(column.x, test(0, 3), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 3), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 3), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 3), 0.001f);
+
+}
+
+TEST(MatrixTest, TestGetRow4F)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point4F column;
+
+   column = test.getRow4F(0);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(0, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(0, 3), 0.001f);
+
+   column = test.getRow4F(1);
+
+   EXPECT_NEAR(column.x, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(1, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(1, 3), 0.001f);
+
+   column = test.getRow4F(2);
+
+   EXPECT_NEAR(column.x, test(2, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(2, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(2, 3), 0.001f);
+
+   column = test.getRow4F(3);
+
+   EXPECT_NEAR(column.x, test(3, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(3, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(3, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 3), 0.001f);
+}
+
+TEST(MatrixTest, TestGetColumn3F)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point3F column;
+
+   column = test.getColumn3F(0);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 0), 0.001f);
+
+   column = test.getColumn3F(1);
+
+   EXPECT_NEAR(column.x, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 1), 0.001f);
+
+   column = test.getColumn3F(2);
+
+   EXPECT_NEAR(column.x, test(0, 2), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 2), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+
+   column = test.getColumn3F(3);
+
+   EXPECT_NEAR(column.x, test(0, 3), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 3), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 3), 0.001f);
+
+}
+
+TEST(MatrixTest, TestGetRow3F)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point3F column;
+
+   column = test.getRow3F(0);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(0, 2), 0.001f);
+
+   column = test.getRow3F(1);
+
+   EXPECT_NEAR(column.x, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(1, 2), 0.001f);
+
+   column = test.getRow3F(2);
+
+   EXPECT_NEAR(column.x, test(2, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(2, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+
+   column = test.getRow3F(3);
+
+   EXPECT_NEAR(column.x, test(3, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(3, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(3, 2), 0.001f);
+}
+
+TEST(MatrixTest, TestSetColumn4)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point4F column(1.0f, 1.0f, 1.0f, 1.0f);
+
+   test.setColumn(0, column);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 0), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 0), 0.001f);
+
+   test.setColumn(1, column);
+
+   EXPECT_NEAR(column.x, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 1), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 1), 0.001f);
+
+   test.setColumn(2, column);
+
+   EXPECT_NEAR(column.x, test(0, 2), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 2), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 2), 0.001f);
+
+   test.setColumn(3, column);
+
+   EXPECT_NEAR(column.x, test(0, 3), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 3), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 3), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 3), 0.001f);
+}
+
+TEST(MatrixTest, TestSetRow4)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point4F column(1.0f, 1.0f, 1.0f, 1.0f);
+
+   test.setRow(0, column);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(0, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(0, 3), 0.001f);
+
+   test.setRow(1, column);
+
+   EXPECT_NEAR(column.x, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(1, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(1, 3), 0.001f);
+
+   test.setRow(2, column);
+
+   EXPECT_NEAR(column.x, test(2, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(2, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(2, 3), 0.001f);
+
+   test.setRow(3, column);
+
+   EXPECT_NEAR(column.x, test(3, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(3, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(3, 2), 0.001f);
+   EXPECT_NEAR(column.w, test(3, 3), 0.001f);
+}
+
+TEST(MatrixTest, TestSetColumn3)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point3F column(1.0f, 1.0f, 1.0f);
+
+   test.setColumn(0, column);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 0), 0.001f);
+
+   test.setColumn(1, column);
+
+   EXPECT_NEAR(column.x, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 1), 0.001f);
+
+   test.setColumn(2, column);
+
+   EXPECT_NEAR(column.x, test(0, 2), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 2), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+
+   test.setColumn(3, column);
+
+   EXPECT_NEAR(column.x, test(0, 3), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 3), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 3), 0.001f);
+}
+
+TEST(MatrixTest, TestSetRow3)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point3F column(1.0f, 1.0f, 1.0f);
+
+   test.setRow(0, column);
+
+   EXPECT_NEAR(column.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(0, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(0, 2), 0.001f);
+
+   test.setRow(1, column);
+
+   EXPECT_NEAR(column.x, test(1, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(1, 2), 0.001f);
+
+   test.setRow(2, column);
+
+   EXPECT_NEAR(column.x, test(2, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(2, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(2, 2), 0.001f);
+
+   test.setRow(3, column);
+
+   EXPECT_NEAR(column.x, test(3, 0), 0.001f);
+   EXPECT_NEAR(column.y, test(3, 1), 0.001f);
+   EXPECT_NEAR(column.z, test(3, 2), 0.001f);
+}
+
+TEST(MatrixTest, TestDisplace)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   Point3F column(1.0f, 1.0f, 1.0f);
+
+   test.displace(column);
+
+   EXPECT_NEAR(test(0, 3), 6.0f, 0.001f);
+   EXPECT_NEAR(test(1, 3), 1.0f, 0.001f);
+   EXPECT_NEAR(test(2, 3), 2.0f, 0.001f);
+}
+
+TEST(MatrixTest, TestGetVectorFunctions)
+{
+   MatrixF test(true);
+
+   test.set(EulerF(1.0f, 0.0f, 1.0f), Point3F(5.0f, 0.0f, 1.0f));
+
+   VectorF vector;
+
+   vector = test.getRightVector();
+
+   EXPECT_NEAR(vector.x, test(0, 0), 0.001f);
+   EXPECT_NEAR(vector.y, test(1, 0), 0.001f);
+   EXPECT_NEAR(vector.z, test(2, 0), 0.001f);
+
+   vector = test.getForwardVector();
+
+   EXPECT_NEAR(vector.x, test(0, 1), 0.001f);
+   EXPECT_NEAR(vector.y, test(1, 1), 0.001f);
+   EXPECT_NEAR(vector.z, test(2, 1), 0.001f);
+
+   vector = test.getUpVector();
+
+   EXPECT_NEAR(vector.x, test(0, 2), 0.001f);
+   EXPECT_NEAR(vector.y, test(1, 2), 0.001f);
+   EXPECT_NEAR(vector.z, test(2, 2), 0.001f);
+}
+
 TEST(MatrixTest, TestSetCrossProduct)
 {
    MatrixF test(true);
@@ -175,6 +641,21 @@ TEST(MatrixTest, TestMulArgMatrixFunction)
    EXPECT_NEAR(testResult(3, 0), 0.0f, 0.001f);     EXPECT_NEAR(testResult(3, 1), 0.0f, 0.001f);     EXPECT_NEAR(testResult(3, 2), 0.0f, 0.001f);     EXPECT_NEAR(testResult(3, 3), 1.0f, 0.001f);
 }
 
+TEST(MatrixTest, TestMulArgMultipleRotationMatrix)
+{
+   MatrixF testResult(true);
+
+   MatrixF xRot(EulerF(-1.54f, 0.0f, 0.0f));
+   MatrixF zRot(EulerF(0.0f, 0.0f, -1.57f));
+
+   testResult.mul(zRot, xRot);
+
+   EXPECT_NEAR(testResult(0, 0), 0.0008f, 0.001f); EXPECT_NEAR(testResult(0, 1), -0.0308f, 0.001f);EXPECT_NEAR(testResult(0, 2), 0.9995f, 0.001f);  EXPECT_NEAR(testResult(0, 3), 0.0f, 0.001f);
+   EXPECT_NEAR(testResult(1, 0), 1.0f, 0.001f);    EXPECT_NEAR(testResult(1, 1), 0.0f, 0.001f);    EXPECT_NEAR(testResult(1, 2), -0.0008f, 0.001f); EXPECT_NEAR(testResult(1, 3), 0.0f, 0.001f);
+   EXPECT_NEAR(testResult(2, 0), 0.0f, 0.001f);    EXPECT_NEAR(testResult(2, 1), 0.9995f, 0.001f); EXPECT_NEAR(testResult(2, 2), 0.0308f, 0.001f);  EXPECT_NEAR(testResult(2, 3), 0.0f, 0.001f);
+   EXPECT_NEAR(testResult(3, 0), 0.0f, 0.001f);    EXPECT_NEAR(testResult(3, 1), 0.0f, 0.001f);    EXPECT_NEAR(testResult(3, 2), 0.0f, 0.001f);     EXPECT_NEAR(testResult(3, 3), 1.0f, 0.001f);
+}
+
 TEST(MatrixTest, TestMulScalarFunction)
 {
    MatrixF test(true);
@@ -294,6 +775,31 @@ TEST(MatrixTest, TestMulBox)
    EXPECT_NEAR(testBox.maxExtents.x, 5.5f, 0.001f); EXPECT_NEAR(testBox.maxExtents.y, 2.5f, 0.001f); EXPECT_NEAR(testBox.maxExtents.z, 1.5f, 0.001f);
 }
 
+TEST(MatrixTest, TestMatrixAdd)
+{
+   MatrixF test(true);
+   MatrixF test2(true);
+   for (U32 i = 0; i < 4; i++)
+   {
+      for (U32 j = 0; j < 4; j++)
+      {
+         test(i, j) = 1.0f;
+         test2(i, j) = 1.0f;
+      }
+   }
+
+   test.add(test2);
+
+   for (U32 i = 0; i < 4; i++)
+   {
+      for (U32 j = 0; j < 4; j++)
+      {
+         EXPECT_NEAR(test(i,j), 2.0f, 0.001f);
+      }
+   }
+
+}
+
 TEST(MatrixTest, TestReverseProjection)
 {
    MatrixF test(true);
@@ -352,6 +858,22 @@ TEST(MatrixTest, TestInvertTo)
    EXPECT_NEAR(test(3, 0), 0.0f, 0.001f);     EXPECT_NEAR(test(3, 1), 0.0f, 0.001f);     EXPECT_NEAR(test(3, 2), 0.0f, 0.001f);     EXPECT_NEAR(test(3, 3), 1.0f, 0.001f);
 }
 
+TEST(MatrixTest, TestFullInverse)
+{
+   MatrixF test(true);
+   test.setPosition(Point3F(5.0f, 2.0f, 1.0f));
+   MatrixF test2(EulerF(1.0f, 0.0f, 1.0f));
+
+   test.mulL(test2);
+
+   EXPECT_TRUE(test.fullInverse());
+
+   EXPECT_NEAR(test(0, 0), 0.5403f, 0.001f);  EXPECT_NEAR(test(0, 1), -0.4546f, 0.001f); EXPECT_NEAR(test(0, 2), 0.7081f, 0.001f);  EXPECT_NEAR(test(0, 3), -5.0f, 0.001f);
+   EXPECT_NEAR(test(1, 0), 0.8415f, 0.001f);  EXPECT_NEAR(test(1, 1), 0.2919f, 0.001f);  EXPECT_NEAR(test(1, 2), -0.4546f, 0.001f); EXPECT_NEAR(test(1, 3), -2.0f, 0.001f);
+   EXPECT_NEAR(test(2, 0), 0.0, 0.001f);      EXPECT_NEAR(test(2, 1), 0.8415f, 0.001f);  EXPECT_NEAR(test(2, 2), 0.5403f, 0.001f);  EXPECT_NEAR(test(2, 3), -1.0f, 0.001f);
+   EXPECT_NEAR(test(3, 0), 0.0f, 0.001f);     EXPECT_NEAR(test(3, 1), 0.0f, 0.001f);     EXPECT_NEAR(test(3, 2), 0.0f, 0.001f);     EXPECT_NEAR(test(3, 3), 1.0f, 0.001f);
+}
+
 TEST(MatrixTest, TestIsAffine)
 {
    MatrixF test(true);