Improve grammar/spelling

* Removed copy in operator[]

* Updated version info

HandmadeMath.h

@@ -1,5 +1,5 @@
 /*
-  HandmadeMath.h v1.6.0
+  HandmadeMath.h v1.7.1
   
   This is a single header file with a bunch of useful functions for game and
   graphics math operations.
@@ -172,7 +172,12 @@
           (*) Added array subscript operators for vector and matrix types in
               C++. This is provided as a convenience, but be aware that it may
               incur an extra function call in unoptimized builds.
-
+     1.7.0
+          (*) Renamed the 'Rows' member of hmm_mat4 to 'Columns'. Since our
+              matrices are column-major, this should have been named 'Columns'
+              from the start. 'Rows' is still present, but has been deprecated.
+     1.7.1
+          (*) Changed operator[] to take a const ref int instead of an int. 
 
   LICENSE
   
@@ -320,7 +325,7 @@ typedef union hmm_vec2
     float Elements[2];
 
 #ifdef __cplusplus
-    inline float &operator[](int Index)
+    inline float &operator[](const int &Index)
     {
         return Elements[Index];
     }
@@ -371,7 +376,7 @@ typedef union hmm_vec3
     float Elements[3];
 
 #ifdef __cplusplus
-    inline float &operator[](int Index)
+    inline float &operator[](const int &Index)
     {
         return Elements[Index];
     }
@@ -435,7 +440,7 @@ typedef union hmm_vec4
 #endif
 
 #ifdef __cplusplus
-    inline float &operator[](int Index)
+    inline float &operator[](const int &Index)
     {
         return Elements[Index];
     }
@@ -447,11 +452,15 @@ typedef union hmm_mat4
     float Elements[4][4];
         
 #ifdef HANDMADE_MATH__USE_SSE
+    __m128 Columns[4];
+
+    // DEPRECATED. Our matrices are column-major, so this was named
+    // incorrectly. Use Columns instead.
     __m128 Rows[4];
 #endif
 
 #ifdef __cplusplus
-    inline hmm_vec4 operator[](const int Index)
+    inline hmm_vec4 operator[](const int &Index)
     {
         float* col = Elements[Index];
 
@@ -1129,10 +1138,10 @@ HMM_INLINE hmm_vec4 HMM_NormalizeVec4(hmm_vec4 A)
 HMM_INLINE __m128 HMM_LinearCombineSSE(__m128 Left, hmm_mat4 Right)
 {
     __m128 Result;
-    Result = _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x00), Right.Rows[0]);
-    Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x55), Right.Rows[1]));
-    Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xaa), Right.Rows[2]));
-    Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xff), Right.Rows[3]));
+    Result = _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x00), Right.Columns[0]);
+    Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x55), Right.Columns[1]));
+    Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xaa), Right.Columns[2]));
+    Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xff), Right.Columns[3]));
     
     return (Result);
 }
@@ -1167,7 +1176,7 @@ HMM_INLINE hmm_mat4 HMM_Transpose(hmm_mat4 Matrix)
 {
     hmm_mat4 Result = Matrix;
     
-    _MM_TRANSPOSE4_PS(Result.Rows[0], Result.Rows[1], Result.Rows[2], Result.Rows[3]);
+    _MM_TRANSPOSE4_PS(Result.Columns[0], Result.Columns[1], Result.Columns[2], Result.Columns[3]);
 
     return (Result);
 }
@@ -1180,10 +1189,10 @@ HMM_INLINE hmm_mat4 HMM_AddMat4(hmm_mat4 Left, hmm_mat4 Right)
 {
     hmm_mat4 Result;
 
-    Result.Rows[0] = _mm_add_ps(Left.Rows[0], Right.Rows[0]);
-    Result.Rows[1] = _mm_add_ps(Left.Rows[1], Right.Rows[1]);
-    Result.Rows[2] = _mm_add_ps(Left.Rows[2], Right.Rows[2]);
-    Result.Rows[3] = _mm_add_ps(Left.Rows[3], Right.Rows[3]);    
+    Result.Columns[0] = _mm_add_ps(Left.Columns[0], Right.Columns[0]);
+    Result.Columns[1] = _mm_add_ps(Left.Columns[1], Right.Columns[1]);
+    Result.Columns[2] = _mm_add_ps(Left.Columns[2], Right.Columns[2]);
+    Result.Columns[3] = _mm_add_ps(Left.Columns[3], Right.Columns[3]);    
 
     return (Result);
 }
@@ -1196,10 +1205,10 @@ HMM_INLINE hmm_mat4 HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right)
 {
     hmm_mat4 Result;
 
-    Result.Rows[0] = _mm_sub_ps(Left.Rows[0], Right.Rows[0]);
-    Result.Rows[1] = _mm_sub_ps(Left.Rows[1], Right.Rows[1]);
-    Result.Rows[2] = _mm_sub_ps(Left.Rows[2], Right.Rows[2]);
-    Result.Rows[3] = _mm_sub_ps(Left.Rows[3], Right.Rows[3]);
+    Result.Columns[0] = _mm_sub_ps(Left.Columns[0], Right.Columns[0]);
+    Result.Columns[1] = _mm_sub_ps(Left.Columns[1], Right.Columns[1]);
+    Result.Columns[2] = _mm_sub_ps(Left.Columns[2], Right.Columns[2]);
+    Result.Columns[3] = _mm_sub_ps(Left.Columns[3], Right.Columns[3]);
 
     return (Result);
 }
@@ -1215,10 +1224,10 @@ HMM_INLINE hmm_mat4 HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar)
     hmm_mat4 Result;
 
     __m128 SSEScalar = _mm_set1_ps(Scalar);
-    Result.Rows[0] = _mm_mul_ps(Matrix.Rows[0], SSEScalar);
-    Result.Rows[1] = _mm_mul_ps(Matrix.Rows[1], SSEScalar);
-    Result.Rows[2] = _mm_mul_ps(Matrix.Rows[2], SSEScalar);
-    Result.Rows[3] = _mm_mul_ps(Matrix.Rows[3], SSEScalar);
+    Result.Columns[0] = _mm_mul_ps(Matrix.Columns[0], SSEScalar);
+    Result.Columns[1] = _mm_mul_ps(Matrix.Columns[1], SSEScalar);
+    Result.Columns[2] = _mm_mul_ps(Matrix.Columns[2], SSEScalar);
+    Result.Columns[3] = _mm_mul_ps(Matrix.Columns[3], SSEScalar);
 
     return (Result);
 }
@@ -1234,10 +1243,10 @@ HMM_INLINE hmm_mat4 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar)
     hmm_mat4 Result;
     
     __m128 SSEScalar = _mm_set1_ps(Scalar);
-    Result.Rows[0] = _mm_div_ps(Matrix.Rows[0], SSEScalar);
-    Result.Rows[1] = _mm_div_ps(Matrix.Rows[1], SSEScalar);
-    Result.Rows[2] = _mm_div_ps(Matrix.Rows[2], SSEScalar);
-    Result.Rows[3] = _mm_div_ps(Matrix.Rows[3], SSEScalar);    
+    Result.Columns[0] = _mm_div_ps(Matrix.Columns[0], SSEScalar);
+    Result.Columns[1] = _mm_div_ps(Matrix.Columns[1], SSEScalar);
+    Result.Columns[2] = _mm_div_ps(Matrix.Columns[2], SSEScalar);
+    Result.Columns[3] = _mm_div_ps(Matrix.Columns[3], SSEScalar);    
 
     return (Result);
 }
@@ -1245,8 +1254,6 @@ HMM_INLINE hmm_mat4 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar)
 HMM_EXTERN hmm_mat4 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar);
 #endif
 
-HMM_EXTERN hmm_quaternion HMM_Mat4ToQuaternion(hmm_mat4 Matrix);
-
 
 /*
  * Common graphics transformations
@@ -2254,10 +2261,10 @@ hmm_mat4 HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right)
 
 #ifdef HANDMADE_MATH__USE_SSE
 
-    Result.Rows[0] = HMM_LinearCombineSSE(Right.Rows[0], Left);
-    Result.Rows[1] = HMM_LinearCombineSSE(Right.Rows[1], Left);
-    Result.Rows[2] = HMM_LinearCombineSSE(Right.Rows[2], Left);
-    Result.Rows[3] = HMM_LinearCombineSSE(Right.Rows[3], Left);     
+    Result.Columns[0] = HMM_LinearCombineSSE(Right.Columns[0], Left);
+    Result.Columns[1] = HMM_LinearCombineSSE(Right.Columns[1], Left);
+    Result.Columns[2] = HMM_LinearCombineSSE(Right.Columns[2], Left);
+    Result.Columns[3] = HMM_LinearCombineSSE(Right.Columns[3], Left);     
     
 #else
     int Columns;
@@ -2342,42 +2349,6 @@ hmm_mat4 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar)
 }
 #endif
 
-hmm_quaternion HMM_Mat4ToQuaternion(hmm_mat4 m)
-{
-    hmm_quaternion q;
-
-    float trace = m.Elements[0][0] + m.Elements[1][1] + m.Elements[2][2];
-    if (trace > 0) {
-        float s = 0.5f / HMM_SquareRootF(trace + 1.0f);
-        q.X = (m.Elements[1][2] - m.Elements[2][1] ) * s;
-        q.Y = (m.Elements[2][0] - m.Elements[0][2] ) * s;
-        q.Z = (m.Elements[0][1] - m.Elements[1][0] ) * s;
-        q.W = 0.25f / s;
-    } else {
-        if (m.Elements[0][0] > m.Elements[1][1] && m.Elements[0][0] > m.Elements[2][2]) {
-            float s = 2.0f * HMM_SquareRootF(1.0f + m.Elements[0][0] - m.Elements[1][1] - m.Elements[2][2]);
-            q.X = 0.25f * s;
-            q.Y = (m.Elements[1][0] + m.Elements[0][1]) / s;
-            q.Z = (m.Elements[2][0] + m.Elements[0][2]) / s;
-            q.W = (m.Elements[1][2] - m.Elements[2][1]) / s;
-        } else if (m.Elements[1][1] > m.Elements[2][2]) {
-            float s = 2.0f * HMM_SquareRootF(1.0f + m.Elements[1][1] - m.Elements[0][0] - m.Elements[2][2]);
-            q.X = (m.Elements[1][0] + m.Elements[0][1]) / s;
-            q.Y = 0.25f * s;
-            q.Z = (m.Elements[2][1] + m.Elements[1][2]) / s;
-            q.W = (m.Elements[2][0] - m.Elements[0][2]) / s;
-        } else {
-            float s = 2.0f * HMM_SquareRootF(1.0f + m.Elements[2][2] - m.Elements[0][0] - m.Elements[1][1]);
-            q.X = (m.Elements[2][0] + m.Elements[0][2]) / s;
-            q.Y = (m.Elements[2][1] + m.Elements[1][2]) / s;
-            q.Z = 0.25f * s;
-            q.W = (m.Elements[0][1] - m.Elements[1][0]) / s;
-        }
-    }
-
-    return q;
-}
-
 hmm_mat4 HMM_Rotate(float Angle, hmm_vec3 Axis)
 {
     hmm_mat4 Result = HMM_Mat4d(1.0f);

README.md

@@ -10,6 +10,8 @@ To get started, go download [the latest release](https://github.com/HandmadeMath
 
 Version         | Changes        |
 ----------------|----------------|
+**1.7.1** | Changed operator[] to take a const ref int instead of an int.
+**1.7.0** | Renamed the 'Rows' member of hmm_mat4 to 'Columns'. Since our matrices are column-major, this should have been named 'Columns' from the start. 'Rows' is still present, but has been deprecated.
 **1.6.0** | Added array subscript operators for vector and matrix types in C++. This is provided as a convenience, but be aware that it may incur an extra function call in unoptimized builds.
 **1.5.1** | Fixed a bug with uninitialized elements in HMM_LookAt.
 **1.5.0** | Changed internal structure for better performance and inlining. As a result, `HANDMADE_MATH_NO_INLINE` has been removed and no longer has any effect.

test/categories/MatrixOps.h

@@ -1,154 +0,0 @@
-#include "../HandmadeTest.h"
-
-void printQuat(hmm_quaternion quat) {
-    printf("\n%f %f %f %f", quat.X, quat.Y, quat.Z, quat.W);
-}
-
-TEST(MatrixOps, Transpose)
-{
-    hmm_mat4 m4 = HMM_Mat4(); // will have 1 - 16
-
-    // Fill the matrix
-    int Counter = 1;
-    for (int Column = 0; Column < 4; ++Column)
-    {
-        for (int Row = 0; Row < 4; ++Row)
-        {
-            m4.Elements[Column][Row] = Counter;
-            ++Counter;
-        }
-    }
-
-    // Test the matrix
-    hmm_mat4 result = HMM_Transpose(m4);
-    EXPECT_FLOAT_EQ(result.Elements[0][0], 1.0f);
-    EXPECT_FLOAT_EQ(result.Elements[0][1], 5.0f);
-    EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
-    EXPECT_FLOAT_EQ(result.Elements[0][3], 13.0f);
-    EXPECT_FLOAT_EQ(result.Elements[1][0], 2.0f);
-    EXPECT_FLOAT_EQ(result.Elements[1][1], 6.0f);
-    EXPECT_FLOAT_EQ(result.Elements[1][2], 10.0f);
-    EXPECT_FLOAT_EQ(result.Elements[1][3], 14.0f);
-    EXPECT_FLOAT_EQ(result.Elements[2][0], 3.0f);
-    EXPECT_FLOAT_EQ(result.Elements[2][1], 7.0f);
-    EXPECT_FLOAT_EQ(result.Elements[2][2], 11.0f);
-    EXPECT_FLOAT_EQ(result.Elements[2][3], 15.0f);
-    EXPECT_FLOAT_EQ(result.Elements[3][0], 4.0f);
-    EXPECT_FLOAT_EQ(result.Elements[3][1], 8.0f);
-    EXPECT_FLOAT_EQ(result.Elements[3][2], 12.0f);
-    EXPECT_FLOAT_EQ(result.Elements[3][3], 16.0f);
-}
-
-TEST(MatrixOps, ToQuaternion)
-{
-    { // Test 90 degree rotation about X axis
-        hmm_mat4 rot = {
-            1.0f, 0.0f, 0.0f, 0.0f, // first column (X)
-            0.0f, 0.0f, 1.0f, 0.0f, // second column (Y)
-            0.0f, -1.0f, 0.0f, 0.0f, // third column (Z)
-            0.0f, 0.0f, 0.0f, 0.0f
-        };
-
-        hmm_quaternion expected = HMM_QuaternionFromAxisAngle(HMM_Vec3(1.0f, 0.0f, 0.0f), HMM_ToRadians(90.0f));
-        hmm_quaternion actualResult = HMM_Mat4ToQuaternion(rot);
-
-        EXPECT_FLOAT_EQ(actualResult.X, expected.X);
-        EXPECT_FLOAT_EQ(actualResult.Y, expected.Y);
-        EXPECT_FLOAT_EQ(actualResult.Z, expected.Z);
-        EXPECT_FLOAT_EQ(actualResult.W, expected.W);
-    }
-
-    { // Test 90 degree rotation about Y axis
-        hmm_mat4 rot = {
-            0.0f, 0.0f, -1.0f, 0.0f, // first column (X)
-            0.0f, 1.0f, 0.0f, 0.0f, // second column (Y)
-            1.0f, 0.0f, 0.0f, 0.0f, // third column (Z)
-            0.0f, 0.0f, 0.0f, 0.0f
-        };
-
-        hmm_quaternion expected = HMM_QuaternionFromAxisAngle(HMM_Vec3(0.0f, 1.0f, 0.0f), HMM_ToRadians(90.0f));
-        hmm_quaternion actualResult = HMM_Mat4ToQuaternion(rot);
-
-        EXPECT_FLOAT_EQ(actualResult.X, expected.X);
-        EXPECT_FLOAT_EQ(actualResult.Y, expected.Y);
-        EXPECT_FLOAT_EQ(actualResult.Z, expected.Z);
-        EXPECT_FLOAT_EQ(actualResult.W, expected.W);
-    }
-
-    { // Test 90 degree rotation about Z axis
-        hmm_mat4 rot = {
-            0.0f, 1.0f, 0.0f, 0.0f, // first column (X)
-            -1.0f, 0.0f, 0.0f, 0.0f, // second column (Y)
-            0.0f, 0.0f, 1.0f, 0.0f, // third column (Z)
-            0.0f, 0.0f, 0.0f, 0.0f
-        };
-
-        hmm_quaternion expected = HMM_QuaternionFromAxisAngle(HMM_Vec3(0.0f, 0.0f, 1.0f), HMM_ToRadians(90.0f));
-        hmm_quaternion actualResult = HMM_Mat4ToQuaternion(rot);
-
-        EXPECT_FLOAT_EQ(actualResult.X, expected.X);
-        EXPECT_FLOAT_EQ(actualResult.Y, expected.Y);
-        EXPECT_FLOAT_EQ(actualResult.Z, expected.Z);
-        EXPECT_FLOAT_EQ(actualResult.W, expected.W);
-    }
-
-    { // Test 180 degree rotation about X axis
-        hmm_mat4 rot = {
-            1.0f, 0.0f, 0.0f, 0.0f, // first column (X)
-            0.0f, -1.0f, 1.0f, 0.0f, // second column (Y)
-            0.0f, 0.0f, -1.0f, 0.0f, // third column (Z)
-            0.0f, 0.0f, 0.0f, 0.0f
-        };
-
-        hmm_quaternion expected = HMM_QuaternionFromAxisAngle(HMM_Vec3(1.0f, 0.0f, 0.0f), HMM_ToRadians(180.0f));
-        hmm_quaternion actualResult = HMM_Mat4ToQuaternion(rot);
-
-        printQuat(expected);
-        printQuat(actualResult);
-
-        EXPECT_FLOAT_EQ(actualResult.X, expected.X);
-        EXPECT_FLOAT_EQ(actualResult.Y, expected.Y);
-        EXPECT_FLOAT_EQ(actualResult.Z, expected.Z);
-        EXPECT_FLOAT_EQ(actualResult.W, expected.W);
-    }
-
-    { // Test 180 degree rotation about Y axis
-        hmm_mat4 rot = {
-            -1.0f, 0.0f, 0.0f, 0.0f, // first column (X)
-            0.0f, 1.0f, 1.0f, 0.0f, // second column (Y)
-            0.0f, 0.0f, -1.0f, 0.0f, // third column (Z)
-            0.0f, 0.0f, 0.0f, 0.0f
-        };
-
-        hmm_quaternion expected = HMM_QuaternionFromAxisAngle(HMM_Vec3(0.0f, 1.0f, 0.0f), HMM_ToRadians(180.0f));
-        hmm_quaternion actualResult = HMM_Mat4ToQuaternion(rot);
-
-        printQuat(expected);
-        printQuat(actualResult);
-
-        EXPECT_FLOAT_EQ(actualResult.X, expected.X);
-        EXPECT_FLOAT_EQ(actualResult.Y, expected.Y);
-        EXPECT_FLOAT_EQ(actualResult.Z, expected.Z);
-        EXPECT_FLOAT_EQ(actualResult.W, expected.W);
-    }
-
-    { // Test 180 degree rotation about Z axis
-        hmm_mat4 rot = {
-            -1.0f, 0.0f, 0.0f, 0.0f, // first column (X)
-            0.0f, -1.0f, 1.0f, 0.0f, // second column (Y)
-            0.0f, 0.0f, 1.0f, 0.0f, // third column (Z)
-            0.0f, 0.0f, 0.0f, 0.0f
-        };
-
-        hmm_quaternion expected = HMM_QuaternionFromAxisAngle(HMM_Vec3(0.0f, 0.0f, 1.0f), HMM_ToRadians(180.0f));
-        hmm_quaternion actualResult = HMM_Mat4ToQuaternion(rot);
-
-        printQuat(expected);
-        printQuat(actualResult);
-
-        EXPECT_FLOAT_EQ(actualResult.X, expected.X);
-        EXPECT_FLOAT_EQ(actualResult.Y, expected.Y);
-        EXPECT_FLOAT_EQ(actualResult.Z, expected.Z);
-        EXPECT_FLOAT_EQ(actualResult.W, expected.W);
-    }
-}

test/categories/SSE.h

@@ -8,10 +8,10 @@ TEST(SSE, LinearCombine)
     hmm_mat4 MatrixTwo = HMM_Mat4d(4.0f);
     hmm_mat4 Result;
     
-    Result.Rows[0] = HMM_LinearCombineSSE(MatrixOne.Rows[0], MatrixTwo);
-    Result.Rows[1] = HMM_LinearCombineSSE(MatrixOne.Rows[1], MatrixTwo);
-    Result.Rows[2] = HMM_LinearCombineSSE(MatrixOne.Rows[2], MatrixTwo);
-    Result.Rows[3] = HMM_LinearCombineSSE(MatrixOne.Rows[3], MatrixTwo);
+    Result.Columns[0] = HMM_LinearCombineSSE(MatrixOne.Columns[0], MatrixTwo);
+    Result.Columns[1] = HMM_LinearCombineSSE(MatrixOne.Columns[1], MatrixTwo);
+    Result.Columns[2] = HMM_LinearCombineSSE(MatrixOne.Columns[2], MatrixTwo);
+    Result.Columns[3] = HMM_LinearCombineSSE(MatrixOne.Columns[3], MatrixTwo);
     
     {
         EXPECT_FLOAT_EQ(Result.Elements[0][0], 8.0f);
@@ -23,14 +23,12 @@ TEST(SSE, LinearCombine)
         EXPECT_FLOAT_EQ(Result.Elements[1][1], 8.0f);                
         EXPECT_FLOAT_EQ(Result.Elements[1][2], 0.0f);
         EXPECT_FLOAT_EQ(Result.Elements[1][3], 0.0f);
-
                         
         EXPECT_FLOAT_EQ(Result.Elements[2][0], 0.0f);
         EXPECT_FLOAT_EQ(Result.Elements[2][1], 0.0f);                
         EXPECT_FLOAT_EQ(Result.Elements[2][2], 8.0f);
         EXPECT_FLOAT_EQ(Result.Elements[2][3], 0.0f);
 
-        
         EXPECT_FLOAT_EQ(Result.Elements[3][0], 0.0f);
         EXPECT_FLOAT_EQ(Result.Elements[3][1], 0.0f);                
         EXPECT_FLOAT_EQ(Result.Elements[3][2], 0.0f);

test/categories/VectorOps.h

@@ -178,3 +178,43 @@ TEST(VectorOps, DotVec4)
     EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 70.0f);
 #endif
 }
+
+
+/*
+ * MatrixOps tests
+ */
+
+TEST(MatrixOps, Transpose)
+{
+    hmm_mat4 m4 = HMM_Mat4(); // will have 1 - 16
+
+    // Fill the matrix
+    int Counter = 1;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+
+    // Test the matrix
+    hmm_mat4 result = HMM_Transpose(m4);
+    EXPECT_FLOAT_EQ(result.Elements[0][0], 1.0f);
+    EXPECT_FLOAT_EQ(result.Elements[0][1], 5.0f);
+    EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
+    EXPECT_FLOAT_EQ(result.Elements[0][3], 13.0f);
+    EXPECT_FLOAT_EQ(result.Elements[1][0], 2.0f);
+    EXPECT_FLOAT_EQ(result.Elements[1][1], 6.0f);
+    EXPECT_FLOAT_EQ(result.Elements[1][2], 10.0f);
+    EXPECT_FLOAT_EQ(result.Elements[1][3], 14.0f);
+    EXPECT_FLOAT_EQ(result.Elements[2][0], 3.0f);
+    EXPECT_FLOAT_EQ(result.Elements[2][1], 7.0f);
+    EXPECT_FLOAT_EQ(result.Elements[2][2], 11.0f);
+    EXPECT_FLOAT_EQ(result.Elements[2][3], 15.0f);
+    EXPECT_FLOAT_EQ(result.Elements[3][0], 4.0f);
+    EXPECT_FLOAT_EQ(result.Elements[3][1], 8.0f);
+    EXPECT_FLOAT_EQ(result.Elements[3][2], 12.0f);
+    EXPECT_FLOAT_EQ(result.Elements[3][3], 16.0f);
+}

test/hmm_test.h

@@ -3,16 +3,15 @@
 #include "HandmadeTest.h"
 #include "../HandmadeMath.h"
 
+#include "categories/ScalarMath.h"
+#include "categories/Initialization.h"
+#include "categories/VectorOps.h"
+#include "categories/QuaternionOps.h"
 #include "categories/Addition.h"
+#include "categories/Subtraction.h"
+#include "categories/Multiplication.h"
 #include "categories/Division.h"
 #include "categories/Equality.h"
-#include "categories/Initialization.h"
-#include "categories/MatrixOps.h"
-#include "categories/Multiplication.h"
 #include "categories/Projection.h"
-#include "categories/QuaternionOps.h"
-#include "categories/ScalarMath.h"
-#include "categories/SSE.h"
-#include "categories/Subtraction.h"
 #include "categories/Transformation.h"
-#include "categories/VectorOps.h"
+#include "categories/SSE.h"