HMM2.0 (#149)

These changes were all made by @dev-dwarf. Many thanks for his work on this!

* Renaming

* First Pass on 2.0UpdateTool

* Another pass on UpdateTool, changed name

* Another pass on UpdateTool, changed name

* Do Renaming

* Working on Angles Consistency

* Passing Coverage

* Remove unused arc-tangent functions

* Change macro defaults

By default if user is overriding trig functions assume their input and internal units are the same.

* wrap in AngleDeg instead of AngleRad

* Remove HMM_PREFIX configuration

* Fix for Slerp

https://discord.com/channels/239737791225790464/489148972305350656/1055167647274246265

Justified by most implementations of Slerp. EX: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/

* Handedness Changes

* More renaming. C11 _Generics

Generics enable by default when available (see lines 97-104). User can also force them by defining HANDMADE_MATH_C11_GENERICS

Also fixed some missed things w.r.t renaming. My old tool didn't catch cases like HMM_MultiplyVec3f needing to be HMM_MulV3F instead of HMM_MulV3f.

* Reuse more SSE codepaths for Quaternions

Also improved quaternion tests. More work could be done here, see discussion here about optimizing slerp: https://discord.com/channels/239737791225790464/489148972305350656/1055167647274246265

* Just saving these alternate versions of SLerp

* Reduce V4/M4 Linear Comb. codepaths

* Simple implementation of 2x2 and 3x3 basic matrix operations.

Also renamed Transpose to TransposeM4, so that we can have TransposeM2,M3

* Norm is dead! Long live Norm!

As can be seen from the tests, precision has declined quite a bit from using the FastNorm implementations for various things. We can only guarantee about 0.001f precision for anything where a norm happens now. If this is undesired we can change back easily.

* Started work on Matrix Inverses

TODO: Tests for simple 4x4 Inverses

* Matrix Inverses + Tests

* Generics for Matrices and Rename MXd/f functions

* Fixes + Better Output for UpdateTool

* I think I count as a contributor : )

* Ported UpdateTool, Inlined my library code.

* Moved tool to different repo

https://github.com/dev-dwarf/HMM2.0UpdateTool

* Remove small test change

* Found some more references to atan functions

* Standardize angle function names, use short names

* Remove other slerp comments

* woops that wasnt meant to be commited.

* Finish changing ToRadians to ToRad

* Fix [] overloads

per https://discord.com/channels/239737791225790464/600063880533770251/1051600188302692402

* Tests for 2x2, 3x3 Matrices and Other Matrix Ops

* Add an option to use Z: [0, 1] range for projection matrices.

This will make HMM more convenient to use with other graphics APIs such as Direct3d and Metal.

* Update test imports

* #if should've been #ifdef!

* Implement requested changes

test/HandmadeMath.c

@@ -2,6 +2,4 @@
 #include "HandmadeTest.h"
 #endif
 
-#define HANDMADE_MATH_IMPLEMENTATION
-#define HANDMADE_MATH_NO_INLINE
 #include "../HandmadeMath.h"

test/HandmadeMathDifferentPrefix.cpp

@@ -1,12 +0,0 @@
-#define HMM_PREFIX(name) WOW_##name
-
-#define HANDMADE_MATH_IMPLEMENTATION
-#define HANDMADE_MATH_NO_INLINE
-#include "../HandmadeMath.h"
-
-int main() {
-    hmm_vec4 a = WOW_Vec4(1, 2, 3, 4);
-    hmm_vec4 b = WOW_Vec4(5, 6, 7, 8);
-
-    WOW_Add(a, b);
-}

test/Makefile

@@ -2,7 +2,7 @@ BUILD_DIR=./build
 
 CXXFLAGS+=-g -Wall -Wextra -pthread -Wno-missing-braces -Wno-missing-field-initializers -Wfloat-equal
 
-all: c c_no_sse cpp cpp_no_sse build_c_without_coverage build_cpp_without_coverage build_cpp_different_prefix
+all: c c_no_sse cpp cpp_no_sse build_c_without_coverage build_cpp_without_coverage
 
 build_all: build_c build_c_no_sse build_cpp build_cpp_no_sse
 
@@ -76,10 +76,3 @@ build_cpp_without_coverage: HandmadeMath.cpp test_impl
 			-DHANDMADE_MATH_CPP_MODE -DWITHOUT_COVERAGE \
 			../HandmadeMath.cpp ../hmm_test.cpp
 
-build_cpp_different_prefix: HandmadeMath.cpp
-	@echo "\nCompiling C++ with different prefix"
-	mkdir -p $(BUILD_DIR)
-	cd $(BUILD_DIR) \
-		&& $(CXX) $(CPPFLAGS) $(CXXFLAGS) -ohmm_test_cpp_different_prefix \
-			-DHANDMADE_MATH_CPP_MODE -DDIFFERENT_PREFIX \
-			../HandmadeMathDifferentPrefix.cpp

test/categories/Addition.h

@@ -2,22 +2,22 @@
 
 TEST(Addition, Vec2)
 {
-    hmm_vec2 v2_1 = HMM_Vec2(1.0f, 2.0f);
+    HMM_Vec2 v2_1 = HMM_V2(1.0f, 2.0f);
-    hmm_vec2 v2_2 = HMM_Vec2(3.0f, 4.0f);
+    HMM_Vec2 v2_2 = HMM_V2(3.0f, 4.0f);
 
     {
-        hmm_vec2 result = HMM_AddVec2(v2_1, v2_2);
+        HMM_Vec2 result = HMM_AddV2(v2_1, v2_2);
         EXPECT_FLOAT_EQ(result.X, 4.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec2 result = HMM_Add(v2_1, v2_2);
+        HMM_Vec2 result = HMM_Add(v2_1, v2_2);
         EXPECT_FLOAT_EQ(result.X, 4.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
     }
     {
-        hmm_vec2 result = v2_1 + v2_2;
+        HMM_Vec2 result = v2_1 + v2_2;
         EXPECT_FLOAT_EQ(result.X, 4.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
     }
@@ -30,24 +30,24 @@ TEST(Addition, Vec2)
 
 TEST(Addition, Vec3)
 {
-    hmm_vec3 v3_1 = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v3_1 = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec3 v3_2 = HMM_Vec3(4.0f, 5.0f, 6.0f);
+    HMM_Vec3 v3_2 = HMM_V3(4.0f, 5.0f, 6.0f);
 
     {
-        hmm_vec3 result = HMM_AddVec3(v3_1, v3_2);
+        HMM_Vec3 result = HMM_AddV3(v3_1, v3_2);
         EXPECT_FLOAT_EQ(result.X, 5.0f);
         EXPECT_FLOAT_EQ(result.Y, 7.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec3 result = HMM_Add(v3_1, v3_2);
+        HMM_Vec3 result = HMM_Add(v3_1, v3_2);
         EXPECT_FLOAT_EQ(result.X, 5.0f);
         EXPECT_FLOAT_EQ(result.Y, 7.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
     }
     {
-        hmm_vec3 result = v3_1 + v3_2;
+        HMM_Vec3 result = v3_1 + v3_2;
         EXPECT_FLOAT_EQ(result.X, 5.0f);
         EXPECT_FLOAT_EQ(result.Y, 7.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
@@ -62,11 +62,11 @@ TEST(Addition, Vec3)
 
 TEST(Addition, Vec4)
 {
-    hmm_vec4 v4_1 = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4_1 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_vec4 v4_2 = HMM_Vec4(5.0f, 6.0f, 7.0f, 8.0f);
+    HMM_Vec4 v4_2 = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
 
     {
-        hmm_vec4 result = HMM_AddVec4(v4_1, v4_2);
+        HMM_Vec4 result = HMM_AddV4(v4_1, v4_2);
         EXPECT_FLOAT_EQ(result.X, 6.0f);
         EXPECT_FLOAT_EQ(result.Y, 8.0f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
@@ -74,14 +74,14 @@ TEST(Addition, Vec4)
     }
 #ifdef __cplusplus
     {
-        hmm_vec4 result = HMM_Add(v4_1, v4_2);
+        HMM_Vec4 result = HMM_Add(v4_1, v4_2);
         EXPECT_FLOAT_EQ(result.X, 6.0f);
         EXPECT_FLOAT_EQ(result.Y, 8.0f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
         EXPECT_FLOAT_EQ(result.W, 12.0f);
     }
     {
-        hmm_vec4 result = v4_1 + v4_2;
+        HMM_Vec4 result = v4_1 + v4_2;
         EXPECT_FLOAT_EQ(result.X, 6.0f);
         EXPECT_FLOAT_EQ(result.Y, 8.0f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
@@ -96,10 +96,134 @@ TEST(Addition, Vec4)
 #endif
 }
 
+TEST(Addition, Mat2)
+{
+    HMM_Mat2 a = HMM_M2();
+    HMM_Mat2 b = HMM_M2();
+
+    int Counter = 1;
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            a.Elements[Column][Row] = Counter++;
+        }
+    }
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            b.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_AddM2(a, b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 6.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 8.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 10.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 12.0f); 
+    }
+
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = HMM_Add(a, b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 6.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 8.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 10.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 12.0f); 
+    }
+    {
+        HMM_Mat2 result = a + b;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 6.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 8.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 10.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 12.0f); 
+    }
+    a += b;
+    EXPECT_FLOAT_EQ(a.Elements[0][0], 6.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[0][1], 8.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[1][0], 10.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[1][1], 12.0f); 
+#endif
+}
+
+TEST(Addition, Mat3) 
+{
+    HMM_Mat3 a = HMM_M3();
+    HMM_Mat3 b = HMM_M3();
+
+    int Counter = 1;
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            a.Elements[Column][Row] = Counter++;
+        }
+    }
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            b.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_AddM3(a, b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 11.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 13.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 15.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 17.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 19.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 23.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 25.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 27.0f);   
+    }
+
+#ifdef __cplusplus
+    {
+        HMM_Mat3 result = HMM_Add(a, b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 11.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 13.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 15.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 17.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 19.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 23.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 25.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 27.0f);   
+    }
+    {
+        HMM_Mat3 result = a + b;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 11.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 13.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 15.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 17.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 19.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 23.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 25.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 27.0f);   
+    }
+    a += b;
+    EXPECT_FLOAT_EQ(a.Elements[0][0], 11.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[0][1], 13.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[0][2], 15.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[1][0], 17.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[1][1], 19.0f);
+    EXPECT_FLOAT_EQ(a.Elements[1][2], 21.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[2][0], 23.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[2][1], 25.0f);
+    EXPECT_FLOAT_EQ(a.Elements[2][2], 27.0f);   
+#endif  
+}
+
 TEST(Addition, Mat4)
 {
-    hmm_mat4 m4_1 = HMM_Mat4(); // will have 1 - 16
+    HMM_Mat4 m4_1 = HMM_M4(); // will have 1 - 16
-    hmm_mat4 m4_2 = HMM_Mat4(); // will have 17 - 32
+    HMM_Mat4 m4_2 = HMM_M4(); // will have 17 - 32
 
     // Fill the matrices
     int Counter = 1;
@@ -122,7 +246,7 @@ TEST(Addition, Mat4)
 
     // Test the results
     {
-        hmm_mat4 result = HMM_AddMat4(m4_1, m4_2);
+        HMM_Mat4 result = HMM_AddM4(m4_1, m4_2);
         float Expected = 18.0f;
         for (int Column = 0; Column < 4; ++Column)
         {
@@ -135,7 +259,7 @@ TEST(Addition, Mat4)
     }
 #ifdef __cplusplus
     {
-        hmm_mat4 result = HMM_Add(m4_1, m4_2);
+        HMM_Mat4 result = HMM_Add(m4_1, m4_2);
         float Expected = 18.0f;
         for (int Column = 0; Column < 4; ++Column)
         {
@@ -147,7 +271,7 @@ TEST(Addition, Mat4)
         }
     }
     {
-        hmm_mat4 result = m4_1 + m4_2;
+        HMM_Mat4 result = m4_1 + m4_2;
         float Expected = 18.0f;
         for (int Column = 0; Column < 4; ++Column)
         {
@@ -174,11 +298,11 @@ TEST(Addition, Mat4)
 
 TEST(Addition, Quaternion)
 {
-    hmm_quaternion q1 = HMM_Quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_quaternion q2 = HMM_Quaternion(5.0f, 6.0f, 7.0f, 8.0f);
+    HMM_Quat q2 = HMM_Q(5.0f, 6.0f, 7.0f, 8.0f);
 
     {
-        hmm_quaternion result = HMM_AddQuaternion(q1, q2);
+        HMM_Quat result = HMM_AddQ(q1, q2);
         EXPECT_FLOAT_EQ(result.X, 6.0f);
         EXPECT_FLOAT_EQ(result.Y, 8.0f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
@@ -186,14 +310,14 @@ TEST(Addition, Quaternion)
     }
 #ifdef __cplusplus
     {
-        hmm_quaternion result = HMM_Add(q1, q2);
+        HMM_Quat result = HMM_Add(q1, q2);
         EXPECT_FLOAT_EQ(result.X, 6.0f);
         EXPECT_FLOAT_EQ(result.Y, 8.0f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
         EXPECT_FLOAT_EQ(result.W, 12.0f);
     }
     {
-        hmm_quaternion result = q1 + q2;
+        HMM_Quat result = q1 + q2;
         EXPECT_FLOAT_EQ(result.X, 6.0f);
         EXPECT_FLOAT_EQ(result.Y, 8.0f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);

test/categories/Division.h

@@ -2,22 +2,22 @@
 
 TEST(Division, Vec2Vec2)
 {
-    hmm_vec2 v2_1 = HMM_Vec2(1.0f, 3.0f);
+    HMM_Vec2 v2_1 = HMM_V2(1.0f, 3.0f);
-    hmm_vec2 v2_2 = HMM_Vec2(2.0f, 4.0f);
+    HMM_Vec2 v2_2 = HMM_V2(2.0f, 4.0f);
 
     {
-        hmm_vec2 result = HMM_DivideVec2(v2_1, v2_2);
+        HMM_Vec2 result = HMM_DivV2(v2_1, v2_2);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 0.75f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec2 result = HMM_Divide(v2_1, v2_2);
+        HMM_Vec2 result = HMM_Div(v2_1, v2_2);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 0.75f);
     }
     {
-        hmm_vec2 result = v2_1 / v2_2;
+        HMM_Vec2 result = v2_1 / v2_2;
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 0.75f);
     }
@@ -30,22 +30,22 @@ TEST(Division, Vec2Vec2)
 
 TEST(Division, Vec2Scalar)
 {
-    hmm_vec2 v2 = HMM_Vec2(1.0f, 2.0f);
+    HMM_Vec2 v2 = HMM_V2(1.0f, 2.0f);
     float s = 2;
 
     {
-        hmm_vec2 result = HMM_DivideVec2f(v2, s);
+        HMM_Vec2 result = HMM_DivV2F(v2, s);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec2 result = HMM_Divide(v2, s);
+        HMM_Vec2 result = HMM_Div(v2, s);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
     }
     {
-        hmm_vec2 result = v2 / s;
+        HMM_Vec2 result = v2 / s;
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
     }
@@ -58,24 +58,24 @@ TEST(Division, Vec2Scalar)
 
 TEST(Division, Vec3Vec3)
 {
-    hmm_vec3 v3_1 = HMM_Vec3(1.0f, 3.0f, 5.0f);
+    HMM_Vec3 v3_1 = HMM_V3(1.0f, 3.0f, 5.0f);
-    hmm_vec3 v3_2 = HMM_Vec3(2.0f, 4.0f, 0.5f);
+    HMM_Vec3 v3_2 = HMM_V3(2.0f, 4.0f, 0.5f);
 
     {
-        hmm_vec3 result = HMM_DivideVec3(v3_1, v3_2);
+        HMM_Vec3 result = HMM_DivV3(v3_1, v3_2);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 0.75f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec3 result = HMM_Divide(v3_1, v3_2);
+        HMM_Vec3 result = HMM_Div(v3_1, v3_2);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 0.75f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
     }
     {
-        hmm_vec3 result = v3_1 / v3_2;
+        HMM_Vec3 result = v3_1 / v3_2;
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 0.75f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
@@ -90,24 +90,24 @@ TEST(Division, Vec3Vec3)
 
 TEST(Division, Vec3Scalar)
 {
-    hmm_vec3 v3 = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v3 = HMM_V3(1.0f, 2.0f, 3.0f);
     float s = 2;
 
     {
-        hmm_vec3 result = HMM_DivideVec3f(v3, s);
+        HMM_Vec3 result = HMM_DivV3F(v3, s);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
         EXPECT_FLOAT_EQ(result.Z, 1.5f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec3 result = HMM_Divide(v3, s);
+        HMM_Vec3 result = HMM_Div(v3, s);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
         EXPECT_FLOAT_EQ(result.Z, 1.5f);
     }
     {
-        hmm_vec3 result = v3 / s;
+        HMM_Vec3 result = v3 / s;
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
         EXPECT_FLOAT_EQ(result.Z, 1.5f);
@@ -122,11 +122,11 @@ TEST(Division, Vec3Scalar)
 
 TEST(Division, Vec4Vec4)
 {
-    hmm_vec4 v4_1 = HMM_Vec4(1.0f, 3.0f, 5.0f, 1.0f);
+    HMM_Vec4 v4_1 = HMM_V4(1.0f, 3.0f, 5.0f, 1.0f);
-    hmm_vec4 v4_2 = HMM_Vec4(2.0f, 4.0f, 0.5f, 4.0f);
+    HMM_Vec4 v4_2 = HMM_V4(2.0f, 4.0f, 0.5f, 4.0f);
 
     {
-        hmm_vec4 result = HMM_DivideVec4(v4_1, v4_2);
+        HMM_Vec4 result = HMM_DivV4(v4_1, v4_2);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 0.75f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
@@ -134,14 +134,14 @@ TEST(Division, Vec4Vec4)
     }
 #ifdef __cplusplus
     {
-        hmm_vec4 result = HMM_Divide(v4_1, v4_2);
+        HMM_Vec4 result = HMM_Div(v4_1, v4_2);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 0.75f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
         EXPECT_FLOAT_EQ(result.W, 0.25f);
     }
     {
-        hmm_vec4 result = v4_1 / v4_2;
+        HMM_Vec4 result = v4_1 / v4_2;
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 0.75f);
         EXPECT_FLOAT_EQ(result.Z, 10.0f);
@@ -158,11 +158,11 @@ TEST(Division, Vec4Vec4)
 
 TEST(Division, Vec4Scalar)
 {
-    hmm_vec4 v4 = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
     float s = 2;
 
     {
-        hmm_vec4 result = HMM_DivideVec4f(v4, s);
+        HMM_Vec4 result = HMM_DivV4F(v4, s);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
         EXPECT_FLOAT_EQ(result.Z, 1.5f);
@@ -170,14 +170,14 @@ TEST(Division, Vec4Scalar)
     }
 #ifdef __cplusplus
     {
-        hmm_vec4 result = HMM_Divide(v4, s);
+        HMM_Vec4 result = HMM_Div(v4, s);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
         EXPECT_FLOAT_EQ(result.Z, 1.5f);
         EXPECT_FLOAT_EQ(result.W, 2.0f);
     }
     {
-        hmm_vec4 result = v4 / s;
+        HMM_Vec4 result = v4 / s;
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
         EXPECT_FLOAT_EQ(result.Z, 1.5f);
@@ -192,9 +192,103 @@ TEST(Division, Vec4Scalar)
 #endif
 }
 
+TEST(Division, Mat2Scalar) 
+{
+    HMM_Mat2 m = HMM_M2();
+    float s = 0.5f;
+
+    int Counter = 1;
+    for (int Column = 0; Column < 2; ++Column) {
+        for (int Row = 0; Row < 2; ++Row) {
+            m.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_DivM2F(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 8.0f);
+    }
+
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = HMM_Div(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 8.0f);
+    }
+
+    {
+        HMM_Mat2 result = m / s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 8.0f);
+    }
+#endif
+}
+
+
+TEST(Division, Mat3Scalar) 
+{
+    HMM_Mat3 m = HMM_M3();
+    float s = 0.5f;
+
+    int Counter = 1;
+    for (int Column = 0; Column < 3; ++Column) {
+        for (int Row = 0; Row < 3; ++Row) {
+            m.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_DivM3F(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 8.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 14.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 16.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 18.0f);
+    }
+
+#ifdef __cplusplus
+    {
+        HMM_Mat3 result = HMM_Div(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 8.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 14.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 16.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 18.0f);
+    }
+
+    {
+        HMM_Mat3 result = m / s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 8.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 14.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 16.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 18.0f);
+    }
+#endif
+}
+
 TEST(Division, Mat4Scalar)
 {
-    hmm_mat4 m4 = HMM_Mat4(); // will have 1 - 16
+    HMM_Mat4 m4 = HMM_M4(); // will have 1 - 16
     float s = 2;
 
     // Fill the matrix
@@ -210,7 +304,7 @@ TEST(Division, Mat4Scalar)
 
     // Test the results
     {
-        hmm_mat4 result = HMM_DivideMat4f(m4, s);
+        HMM_Mat4 result = HMM_DivM4F(m4, s);
         EXPECT_FLOAT_EQ(result.Elements[0][0], 0.5f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 1.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 1.5f);
@@ -230,7 +324,7 @@ TEST(Division, Mat4Scalar)
     }
 #ifdef __cplusplus
     {
-        hmm_mat4 result = HMM_Divide(m4, s);
+        HMM_Mat4 result = HMM_Div(m4, s);
         EXPECT_FLOAT_EQ(result.Elements[0][0], 0.5f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 1.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 1.5f);
@@ -249,7 +343,7 @@ TEST(Division, Mat4Scalar)
         EXPECT_FLOAT_EQ(result.Elements[3][3], 8.0f);
     }
     {
-        hmm_mat4 result = m4 / s;
+        HMM_Mat4 result = m4 / s;
         EXPECT_FLOAT_EQ(result.Elements[0][0], 0.5f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 1.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 1.5f);
@@ -290,11 +384,11 @@ TEST(Division, Mat4Scalar)
 
 TEST(Division, QuaternionScalar)
 {
-    hmm_quaternion q = HMM_Quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
     float f = 2.0f;
 
     {
-        hmm_quaternion result = HMM_DivideQuaternionF(q, f);
+        HMM_Quat result = HMM_DivQF(q, f);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
         EXPECT_FLOAT_EQ(result.Z, 1.5f);
@@ -302,14 +396,14 @@ TEST(Division, QuaternionScalar)
     }
 #ifdef __cplusplus
     {
-        hmm_quaternion result = HMM_Divide(q, f);
+        HMM_Quat result = HMM_Div(q, f);
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
         EXPECT_FLOAT_EQ(result.Z, 1.5f);
         EXPECT_FLOAT_EQ(result.W, 2.0f);
     }
     {
-        hmm_quaternion result = q / f;
+        HMM_Quat result = q / f;
         EXPECT_FLOAT_EQ(result.X, 0.5f);
         EXPECT_FLOAT_EQ(result.Y, 1.0f);
         EXPECT_FLOAT_EQ(result.Z, 1.5f);

test/categories/Equality.h

@@ -2,16 +2,16 @@
 
 TEST(Equality, Vec2)
 {
-    hmm_vec2 a = HMM_Vec2(1.0f, 2.0f);
+    HMM_Vec2 a = HMM_V2(1.0f, 2.0f);
-    hmm_vec2 b = HMM_Vec2(1.0f, 2.0f);
+    HMM_Vec2 b = HMM_V2(1.0f, 2.0f);
-    hmm_vec2 c = HMM_Vec2(3.0f, 4.0f);
+    HMM_Vec2 c = HMM_V2(3.0f, 4.0f);
 
-    EXPECT_TRUE(HMM_EqualsVec2(a, b));
+    EXPECT_TRUE(HMM_EqV2(a, b));
-    EXPECT_FALSE(HMM_EqualsVec2(a, c));
+    EXPECT_FALSE(HMM_EqV2(a, c));
 
 #ifdef __cplusplus
-    EXPECT_TRUE(HMM_Equals(a, b));
+    EXPECT_TRUE(HMM_Eq(a, b));
-    EXPECT_FALSE(HMM_Equals(a, c));
+    EXPECT_FALSE(HMM_Eq(a, c));
 
     EXPECT_TRUE(a == b);
     EXPECT_FALSE(a == c);
@@ -23,16 +23,16 @@ TEST(Equality, Vec2)
 
 TEST(Equality, Vec3)
 {
-    hmm_vec3 a = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 a = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec3 b = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 b = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec3 c = HMM_Vec3(4.0f, 5.0f, 6.0f);
+    HMM_Vec3 c = HMM_V3(4.0f, 5.0f, 6.0f);
 
-    EXPECT_TRUE(HMM_EqualsVec3(a, b));
+    EXPECT_TRUE(HMM_EqV3(a, b));
-    EXPECT_FALSE(HMM_EqualsVec3(a, c));
+    EXPECT_FALSE(HMM_EqV3(a, c));
 
 #ifdef __cplusplus
-    EXPECT_TRUE(HMM_Equals(a, b));
+    EXPECT_TRUE(HMM_Eq(a, b));
-    EXPECT_FALSE(HMM_Equals(a, c));
+    EXPECT_FALSE(HMM_Eq(a, c));
 
     EXPECT_TRUE(a == b);
     EXPECT_FALSE(a == c);
@@ -44,16 +44,16 @@ TEST(Equality, Vec3)
 
 TEST(Equality, Vec4)
 {
-    hmm_vec4 a = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 a = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_vec4 b = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 b = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_vec4 c = HMM_Vec4(5.0f, 6.0f, 7.0f, 8.0f);
+    HMM_Vec4 c = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
 
-    EXPECT_TRUE(HMM_EqualsVec4(a, b));
+    EXPECT_TRUE(HMM_EqV4(a, b));
-    EXPECT_FALSE(HMM_EqualsVec4(a, c));
+    EXPECT_FALSE(HMM_EqV4(a, c));
 
 #ifdef __cplusplus
-    EXPECT_TRUE(HMM_Equals(a, b));
+    EXPECT_TRUE(HMM_Eq(a, b));
-    EXPECT_FALSE(HMM_Equals(a, c));
+    EXPECT_FALSE(HMM_Eq(a, c));
 
     EXPECT_TRUE(a == b);
     EXPECT_FALSE(a == c);

test/categories/Initialization.h

@@ -5,8 +5,8 @@ TEST(Initialization, Vectors)
     //
     // Test vec2
     //
-    hmm_vec2 v2 = HMM_Vec2(1.0f, 2.0f);
+    HMM_Vec2 v2 = HMM_V2(1.0f, 2.0f);
-    hmm_vec2 v2i = HMM_Vec2i(1, 2);
+    HMM_Vec2 v2i = HMM_V2I(1, 2);
 
     EXPECT_FLOAT_EQ(v2.X, 1.0f);
     EXPECT_FLOAT_EQ(v2.Y, 2.0f);
@@ -41,8 +41,8 @@ TEST(Initialization, Vectors)
     //
     // Test vec3
     //
-    hmm_vec3 v3 = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v3 = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec3 v3i = HMM_Vec3i(1, 2, 3);
+    HMM_Vec3 v3i = HMM_V3I(1, 2, 3);
 
     EXPECT_FLOAT_EQ(v3.X, 1.0f);
     EXPECT_FLOAT_EQ(v3.Y, 2.0f);
@@ -99,9 +99,9 @@ TEST(Initialization, Vectors)
     //
     // Test vec4
     //
-    hmm_vec4 v4 = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_vec4 v4i = HMM_Vec4i(1, 2, 3, 4);
+    HMM_Vec4 v4i = HMM_V4I(1, 2, 3, 4);
-    hmm_vec4 v4v = HMM_Vec4v(v3, 4.0f);
+    HMM_Vec4 v4v = HMM_V4V(v3, 4.0f);
 
     EXPECT_FLOAT_EQ(v4.X, 1.0f);
     EXPECT_FLOAT_EQ(v4.Y, 2.0f);
@@ -193,7 +193,7 @@ TEST(Initialization, Vectors)
 
 TEST(Initialization, MatrixEmpty)
 {
-    hmm_mat4 m4 = HMM_Mat4();
+    HMM_Mat4 m4 = HMM_M4();
     for (int Column = 0; Column < 4; ++Column)
     {
         for (int Row = 0; Row < 4; ++Row)
@@ -208,7 +208,7 @@ TEST(Initialization, MatrixEmpty)
 
 TEST(Initialization, MatrixDiagonal)
 {
-    hmm_mat4 m4d = HMM_Mat4d(1.0f);
+    HMM_Mat4 m4d = HMM_M4D(1.0f);
     for (int Column = 0; Column < 4; ++Column)
     {
         for (int Row = 0; Row < 4; ++Row)
@@ -224,7 +224,7 @@ TEST(Initialization, MatrixDiagonal)
 
 TEST(Initialization, Quaternion)
 {
-    hmm_quaternion q = HMM_Quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
 
     EXPECT_FLOAT_EQ(q.X, 1.0f);
     EXPECT_FLOAT_EQ(q.Y, 2.0f);
@@ -236,8 +236,8 @@ TEST(Initialization, Quaternion)
     EXPECT_FLOAT_EQ(q.Elements[2], 3.0f);
     EXPECT_FLOAT_EQ(q.Elements[3], 4.0f);
 
-    hmm_vec4 v = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_quaternion qv = HMM_QuaternionV4(v);
+    HMM_Quat qv = HMM_QV4(v);
 
     EXPECT_FLOAT_EQ(qv.X, 1.0f);
     EXPECT_FLOAT_EQ(qv.Y, 2.0f);

test/categories/MatrixOps.h

@@ -0,0 +1,413 @@
+#include "../HandmadeTest.h"
+
+TEST(InvMatrix, Transpose)
+{
+    {
+        HMM_Mat2 Matrix = {
+            1.0f, 3.0f,
+            2.0f, 4.0f,
+        };
+        HMM_Mat2 Expect = {
+            1.0f, 2.0f,
+            3.0f, 4.0f,
+        };
+
+        {
+            HMM_Mat2 result = HMM_TransposeM2(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+        }
+#ifdef __cplusplus
+        {
+            HMM_Mat2 result = HMM_Transpose(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+        }
+#endif
+    }
+
+    {
+        HMM_Mat3 Matrix = {
+            1.0f, 4.0f, 7.0f,
+            2.0f, 5.0f, 8.0f,
+            3.0f, 6.0f, 9.0f,
+        };
+        HMM_Mat3 Expect = {
+            1.0f, 2.0f, 3.0f,
+            4.0f, 5.0f, 6.0f,
+            7.0f, 8.0f, 9.0f
+        };
+
+        {
+            HMM_Mat3 result = HMM_TransposeM3(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[0][2], Expect.Elements[0][2]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][2], Expect.Elements[1][2]);
+            EXPECT_FLOAT_EQ(result.Elements[2][0], Expect.Elements[2][0]);
+            EXPECT_FLOAT_EQ(result.Elements[2][1], Expect.Elements[2][1]);
+            EXPECT_FLOAT_EQ(result.Elements[2][2], Expect.Elements[2][2]);
+        }
+#ifdef __cplusplus
+        {
+            HMM_Mat3 result = HMM_Transpose(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[0][2], Expect.Elements[0][2]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][2], Expect.Elements[1][2]);
+            EXPECT_FLOAT_EQ(result.Elements[2][0], Expect.Elements[2][0]);
+            EXPECT_FLOAT_EQ(result.Elements[2][1], Expect.Elements[2][1]);
+            EXPECT_FLOAT_EQ(result.Elements[2][2], Expect.Elements[2][2]);
+        }
+#endif
+    }
+    {
+        HMM_Mat4 Matrix = {
+            1.0f, 5.0f,  9.0f, 13.0f,
+            2.0f, 6.0f, 10.0f, 14.0f, 
+            3.0f, 7.0f, 11.0f, 15.0f,
+            4.0f, 8.0f, 12.0f, 16.0f
+        };
+        HMM_Mat4 Expect = {
+            1.0f, 2.0f, 3.0f, 4.0f,
+            5.0f, 6.0f, 7.0f, 8.0f,
+            9.0f, 10.0f, 11.0f, 12.0f,
+            13.0f, 14.0f, 15.0f, 16.0f,
+        };
+        {
+            HMM_Mat4 result = HMM_TransposeM4(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[0][2], Expect.Elements[0][2]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][2], Expect.Elements[1][2]);
+            EXPECT_FLOAT_EQ(result.Elements[2][0], Expect.Elements[2][0]);
+            EXPECT_FLOAT_EQ(result.Elements[2][1], Expect.Elements[2][1]);
+            EXPECT_FLOAT_EQ(result.Elements[2][2], Expect.Elements[2][2]);
+        }
+#ifdef __cplusplus
+        {
+            HMM_Mat4 result = HMM_Transpose(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[0][2], Expect.Elements[0][2]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][2], Expect.Elements[1][2]);
+            EXPECT_FLOAT_EQ(result.Elements[2][0], Expect.Elements[2][0]);
+            EXPECT_FLOAT_EQ(result.Elements[2][1], Expect.Elements[2][1]);
+            EXPECT_FLOAT_EQ(result.Elements[2][2], Expect.Elements[2][2]);
+        }
+#endif
+    }
+
+}
+
+TEST(InvMatrix, InvGeneral)
+{
+    {
+        HMM_Mat4 Matrix = {
+            12.0f, 2.0f, 1.0f, 1.0f,
+            0.0f, 0.0f, 1.0f, 1.0f,
+            0.0f, 1.0f, 5.0f, 1.0f,
+            11.0f, 1.0f, 0.0f, 10.0f
+        };
+
+        HMM_Mat4 Expect = HMM_M4D(1.0);
+        HMM_Mat4 Inverse = HMM_InvGeneralM4(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+        
+        float Det = HMM_DeterminantM4(Matrix);
+        EXPECT_FLOAT_EQ(Det, -80.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][3], Expect.Elements[0][3]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][3], Expect.Elements[1][3]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][3], Expect.Elements[2][3]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][0], Expect.Elements[3][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][1], Expect.Elements[3][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][2], Expect.Elements[3][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][3], Expect.Elements[3][3]);
+
+#ifdef __cplusplus
+        Inverse = HMM_InvGeneral(Matrix);
+        Result = HMM_Mul(Matrix, Inverse);
+        
+        Det = HMM_Determinant(Matrix);
+        EXPECT_FLOAT_EQ(Det, -80.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][3], Expect.Elements[0][3]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][3], Expect.Elements[1][3]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][3], Expect.Elements[2][3]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][0], Expect.Elements[3][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][1], Expect.Elements[3][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][2], Expect.Elements[3][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][3], Expect.Elements[3][3]);
+#endif
+    }
+
+    {
+        HMM_Mat3 Matrix = {
+            12.0f, 2.0f, 1.0f,
+            0.0f, 0.0f, 1.0f,
+            0.0f, 1.0f, 5.0f
+        };
+
+        HMM_Mat3 Expect = HMM_M3D(1.0);
+        HMM_Mat3 Inverse = HMM_InvGeneralM3(Matrix);
+        HMM_Mat3 Result = HMM_MulM3(Matrix, Inverse);
+        
+        float Det = HMM_DeterminantM3(Matrix);
+        EXPECT_FLOAT_EQ(Det, -12.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+
+#ifdef __cplusplus
+        Inverse = HMM_InvGeneral(Matrix);
+        Result = HMM_Mul(Matrix, Inverse);
+        Det = HMM_Determinant(Matrix);
+        EXPECT_FLOAT_EQ(Det, -12.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+#endif
+    }
+
+    {
+        HMM_Mat2 Matrix = {
+            12.0f, 2.0f, 
+             1.0f, 5.0f
+        };
+
+        HMM_Mat2 Expect = HMM_M2D(1.0);
+        HMM_Mat2 Inverse = HMM_InvGeneralM2(Matrix);
+        HMM_Mat2 Result = HMM_MulM2(Matrix, Inverse);
+        
+        float Det = HMM_DeterminantM2(Matrix);
+        EXPECT_FLOAT_EQ(Det, 58.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+
+#ifdef __cplusplus
+        Inverse = HMM_InvGeneral(Matrix);
+        Result = HMM_Mul(Matrix, Inverse);
+        Det = HMM_Determinant(Matrix);
+        EXPECT_FLOAT_EQ(Det, 58.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+#endif
+    }    
+}
+
+TEST(InvMatrix, Mat4Inverses)
+{
+    {
+        HMM_Mat4 Matrix = HMM_Orthographic_RH(-160+100, 160+100, -90+200, 90+200, 10, 10000);
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvOrthographic(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+        
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][3], Expect.Elements[0][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][3], Expect.Elements[1][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][3], Expect.Elements[2][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[3][0], Expect.Elements[3][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][1], Expect.Elements[3][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][2], Expect.Elements[3][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][3], Expect.Elements[3][3]);        
+    }
+    {
+        HMM_Mat4 Matrix = HMM_Perspective_RH(HMM_AngleDeg(120), 16.0/9.0, 10, 10000);
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvPerspective(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][3], Expect.Elements[0][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][3], Expect.Elements[1][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][3], Expect.Elements[2][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[3][0], Expect.Elements[3][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][1], Expect.Elements[3][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][2], Expect.Elements[3][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][3], Expect.Elements[3][3]);        
+    }
+    {
+        HMM_Vec3 Eye = {10.0f, 10.0f, 10.0f};
+        HMM_Vec3 Center = {100.0f, 200.0f, 30.0f};
+        HMM_Vec3 Up = {0.0f, 0.0f, 1.0f};
+        HMM_Mat4 Matrix = HMM_LookAt_RH(Eye, Center, Up);
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvLookAt(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+
+        EXPECT_NEAR(Result.Elements[0][0], Expect.Elements[0][0], 0.001f);
+        EXPECT_NEAR(Result.Elements[0][1], Expect.Elements[0][1], 0.001f);
+        EXPECT_NEAR(Result.Elements[0][2], Expect.Elements[0][2], 0.001f);
+        EXPECT_NEAR(Result.Elements[0][3], Expect.Elements[0][3], 0.001f);
+
+        EXPECT_NEAR(Result.Elements[1][0], Expect.Elements[1][0], 0.001f);
+        EXPECT_NEAR(Result.Elements[1][1], Expect.Elements[1][1], 0.001f);
+        EXPECT_NEAR(Result.Elements[1][2], Expect.Elements[1][2], 0.001f);
+        EXPECT_NEAR(Result.Elements[1][3], Expect.Elements[1][3], 0.001f);
+
+        EXPECT_NEAR(Result.Elements[2][0], Expect.Elements[2][0], 0.001f);
+        EXPECT_NEAR(Result.Elements[2][1], Expect.Elements[2][1], 0.001f);
+        EXPECT_NEAR(Result.Elements[2][2], Expect.Elements[2][2], 0.001f);
+        EXPECT_NEAR(Result.Elements[2][3], Expect.Elements[2][3], 0.001f);
+
+        EXPECT_NEAR(Result.Elements[3][0], Expect.Elements[3][0], 0.001f);
+        EXPECT_NEAR(Result.Elements[3][1], Expect.Elements[3][1], 0.001f);
+        EXPECT_NEAR(Result.Elements[3][2], Expect.Elements[3][2], 0.001f);
+        EXPECT_NEAR(Result.Elements[3][3], Expect.Elements[3][3], 0.001f);        
+    }
+    {
+        HMM_Vec3 Axis = {1.0f, -1.0f, 0.5f};
+        HMM_Mat4 Matrix = HMM_Rotate_RH(HMM_AngleDeg(30), HMM_NormV3(Axis));
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvRotate(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+
+        EXPECT_NEAR(Result.Elements[0][0], Expect.Elements[0][0], 0.001f);
+        EXPECT_NEAR(Result.Elements[0][1], Expect.Elements[0][1], 0.001f);
+        EXPECT_NEAR(Result.Elements[0][2], Expect.Elements[0][2], 0.001f);
+        EXPECT_NEAR(Result.Elements[0][3], Expect.Elements[0][3], 0.001f);
+
+        EXPECT_NEAR(Result.Elements[1][0], Expect.Elements[1][0], 0.001f);
+        EXPECT_NEAR(Result.Elements[1][1], Expect.Elements[1][1], 0.001f);
+        EXPECT_NEAR(Result.Elements[1][2], Expect.Elements[1][2], 0.001f);
+        EXPECT_NEAR(Result.Elements[1][3], Expect.Elements[1][3], 0.001f);
+
+        EXPECT_NEAR(Result.Elements[2][0], Expect.Elements[2][0], 0.001f);
+        EXPECT_NEAR(Result.Elements[2][1], Expect.Elements[2][1], 0.001f);
+        EXPECT_NEAR(Result.Elements[2][2], Expect.Elements[2][2], 0.001f);
+        EXPECT_NEAR(Result.Elements[2][3], Expect.Elements[2][3], 0.001f);
+
+        EXPECT_NEAR(Result.Elements[3][0], Expect.Elements[3][0], 0.001f);
+        EXPECT_NEAR(Result.Elements[3][1], Expect.Elements[3][1], 0.001f);
+        EXPECT_NEAR(Result.Elements[3][2], Expect.Elements[3][2], 0.001f);
+        EXPECT_NEAR(Result.Elements[3][3], Expect.Elements[3][3], 0.001f);        
+    }
+    {
+        HMM_Vec3 Scale  = {1.0f, -1.0f, 0.5f};
+        HMM_Mat4 Matrix = HMM_Scale(Scale);
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvScale(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][3], Expect.Elements[0][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][3], Expect.Elements[1][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][3], Expect.Elements[2][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[3][0], Expect.Elements[3][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][1], Expect.Elements[3][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][2], Expect.Elements[3][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][3], Expect.Elements[3][3]);        
+    }
+    {
+        HMM_Vec3 Move  = {1.0f, -1.0f, 0.5f};
+        HMM_Mat4 Matrix = HMM_Translate(Move);
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvTranslate(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][3], Expect.Elements[0][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][3], Expect.Elements[1][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][3], Expect.Elements[2][3]);
+
+        EXPECT_FLOAT_EQ(Result.Elements[3][0], Expect.Elements[3][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][1], Expect.Elements[3][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][2], Expect.Elements[3][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[3][3], Expect.Elements[3][3]);        
+    }     
+}

test/categories/Multiplication.h

@@ -2,22 +2,22 @@
 
 TEST(Multiplication, Vec2Vec2)
 {
-    hmm_vec2 v2_1 = HMM_Vec2(1.0f, 2.0f);
+    HMM_Vec2 v2_1 = HMM_V2(1.0f, 2.0f);
-    hmm_vec2 v2_2 = HMM_Vec2(3.0f, 4.0f);
+    HMM_Vec2 v2_2 = HMM_V2(3.0f, 4.0f);
 
     {
-        hmm_vec2 result = HMM_MultiplyVec2(v2_1, v2_2);
+        HMM_Vec2 result = HMM_MulV2(v2_1, v2_2);
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 8.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec2 result = HMM_Multiply(v2_1, v2_2);
+        HMM_Vec2 result = HMM_Mul(v2_1, v2_2);
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 8.0f);
     }
     {
-        hmm_vec2 result = v2_1 * v2_2;
+        HMM_Vec2 result = v2_1 * v2_2;
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 8.0f);
     }
@@ -30,27 +30,27 @@ TEST(Multiplication, Vec2Vec2)
 
 TEST(Multiplication, Vec2Scalar)
 {
-    hmm_vec2 v2 = HMM_Vec2(1.0f, 2.0f);
+    HMM_Vec2 v2 = HMM_V2(1.0f, 2.0f);
     float s = 3.0f;
 
     {
-        hmm_vec2 result = HMM_MultiplyVec2f(v2, s);
+        HMM_Vec2 result = HMM_MulV2F(v2, s);
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec2 result = HMM_Multiply(v2, s);
+        HMM_Vec2 result = HMM_Mul(v2, s);
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
     }
     {
-        hmm_vec2 result = v2 * s;
+        HMM_Vec2 result = v2 * s;
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
     }
     {
-        hmm_vec2 result = s * v2;
+        HMM_Vec2 result = s * v2;
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
     }
@@ -63,24 +63,24 @@ TEST(Multiplication, Vec2Scalar)
 
 TEST(Multiplication, Vec3Vec3)
 {
-    hmm_vec3 v3_1 = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v3_1 = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec3 v3_2 = HMM_Vec3(4.0f, 5.0f, 6.0f);
+    HMM_Vec3 v3_2 = HMM_V3(4.0f, 5.0f, 6.0f);
 
     {
-        hmm_vec3 result = HMM_MultiplyVec3(v3_1, v3_2);
+        HMM_Vec3 result = HMM_MulV3(v3_1, v3_2);
         EXPECT_FLOAT_EQ(result.X, 4.0f);
         EXPECT_FLOAT_EQ(result.Y, 10.0f);
         EXPECT_FLOAT_EQ(result.Z, 18.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec3 result = HMM_Multiply(v3_1, v3_2);
+        HMM_Vec3 result = HMM_Mul(v3_1, v3_2);
         EXPECT_FLOAT_EQ(result.X, 4.0f);
         EXPECT_FLOAT_EQ(result.Y, 10.0f);
         EXPECT_FLOAT_EQ(result.Z, 18.0f);
     }
     {
-        hmm_vec3 result = v3_1 * v3_2;
+        HMM_Vec3 result = v3_1 * v3_2;
         EXPECT_FLOAT_EQ(result.X, 4.0f);
         EXPECT_FLOAT_EQ(result.Y, 10.0f);
         EXPECT_FLOAT_EQ(result.Z, 18.0f);
@@ -95,30 +95,30 @@ TEST(Multiplication, Vec3Vec3)
 
 TEST(Multiplication, Vec3Scalar)
 {
-    hmm_vec3 v3 = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v3 = HMM_V3(1.0f, 2.0f, 3.0f);
     float s = 3.0f;
 
     {
-        hmm_vec3 result = HMM_MultiplyVec3f(v3, s);
+        HMM_Vec3 result = HMM_MulV3F(v3, s);
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec3 result = HMM_Multiply(v3, s);
+        HMM_Vec3 result = HMM_Mul(v3, s);
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
     }
     {
-        hmm_vec3 result = v3 * s;
+        HMM_Vec3 result = v3 * s;
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
     }
     {
-        hmm_vec3 result = s * v3;
+        HMM_Vec3 result = s * v3;
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
@@ -133,11 +133,11 @@ TEST(Multiplication, Vec3Scalar)
 
 TEST(Multiplication, Vec4Vec4)
 {
-    hmm_vec4 v4_1 = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4_1 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_vec4 v4_2 = HMM_Vec4(5.0f, 6.0f, 7.0f, 8.0f);
+    HMM_Vec4 v4_2 = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
 
     {
-        hmm_vec4 result = HMM_MultiplyVec4(v4_1, v4_2);
+        HMM_Vec4 result = HMM_MulV4(v4_1, v4_2);
         EXPECT_FLOAT_EQ(result.X, 5.0f);
         EXPECT_FLOAT_EQ(result.Y, 12.0f);
         EXPECT_FLOAT_EQ(result.Z, 21.0f);
@@ -145,14 +145,14 @@ TEST(Multiplication, Vec4Vec4)
     }
 #ifdef __cplusplus
     {
-        hmm_vec4 result = HMM_Multiply(v4_1, v4_2);
+        HMM_Vec4 result = HMM_Mul(v4_1, v4_2);
         EXPECT_FLOAT_EQ(result.X, 5.0f);
         EXPECT_FLOAT_EQ(result.Y, 12.0f);
         EXPECT_FLOAT_EQ(result.Z, 21.0f);
         EXPECT_FLOAT_EQ(result.W, 32.0f);
     }
     {
-        hmm_vec4 result = v4_1 * v4_2;
+        HMM_Vec4 result = v4_1 * v4_2;
         EXPECT_FLOAT_EQ(result.X, 5.0f);
         EXPECT_FLOAT_EQ(result.Y, 12.0f);
         EXPECT_FLOAT_EQ(result.Z, 21.0f);
@@ -169,11 +169,11 @@ TEST(Multiplication, Vec4Vec4)
 
 TEST(Multiplication, Vec4Scalar)
 {
-    hmm_vec4 v4 = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
     float s = 3.0f;
 
     {
-        hmm_vec4 result = HMM_MultiplyVec4f(v4, s);
+        HMM_Vec4 result = HMM_MulV4F(v4, s);
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
@@ -181,21 +181,21 @@ TEST(Multiplication, Vec4Scalar)
     }
 #ifdef __cplusplus
     {
-        hmm_vec4 result = HMM_Multiply(v4, s);
+        HMM_Vec4 result = HMM_Mul(v4, s);
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
         EXPECT_FLOAT_EQ(result.W, 12.0f);
     }
     {
-        hmm_vec4 result = v4 * s;
+        HMM_Vec4 result = v4 * s;
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
         EXPECT_FLOAT_EQ(result.W, 12.0f);
     }
     {
-        hmm_vec4 result = s * v4;
+        HMM_Vec4 result = s * v4;
         EXPECT_FLOAT_EQ(result.X, 3.0f);
         EXPECT_FLOAT_EQ(result.Y, 6.0f);
         EXPECT_FLOAT_EQ(result.Z, 9.0f);
@@ -209,10 +209,309 @@ TEST(Multiplication, Vec4Scalar)
 #endif
 }
 
+TEST(Multiplication, Mat2Mat2) {
+    HMM_Mat2 a = HMM_M2();
+    HMM_Mat2 b = HMM_M2();
+
+    int counter = 1;
+    for (int Column = 0; Column < 2; Column++) {
+        for (int Row = 0; Row < 2; Row++) {
+            a.Elements[Column][Row] = counter++;
+        }
+    }
+    
+    for (int Column = 0; Column < 2; Column++) {
+        for (int Row = 0; Row < 2; Row++) {
+            b.Elements[Column][Row] = counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_MulM2(a,b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 34.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 31.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 46.0f);        
+    }
+
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = HMM_Mul(a,b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 34.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 31.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 46.0f);        
+    }
+
+    {
+        HMM_Mat2 result = a * b;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 34.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 31.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 46.0f);        
+    }
+#endif
+}
+
+TEST(Multiplication, Mat2Scalar) {
+    HMM_Mat2 m = HMM_M2();
+    float s = 10.0f;
+
+    int counter = 1;
+    for (int Column = 0; Column < 2; Column++) {
+        for (int Row = 0; Row < 2; Row++) {
+            m.Elements[Column][Row] = counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_MulM2F(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 40.0f);
+    }
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = HMM_Mul(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 40.0f);
+    }
+    {
+        HMM_Mat2 result = m * s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 40.0f);
+    }
+    {
+        HMM_Mat2 result = s * m;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 40.0f);
+    }
+    m *= s;
+    EXPECT_FLOAT_EQ(m.Elements[0][0], 10.0f);
+    EXPECT_FLOAT_EQ(m.Elements[0][1], 20.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][0], 30.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][1], 40.0f);
+#endif
+}
+
+TEST(Multiplication, Mat2Vec2) {
+    HMM_Mat2 m = HMM_M2();
+    HMM_Vec2 v = HMM_V2(0.0f, 0.0f);
+
+    int counter = 1;
+    for (int Column = 0; Column < 2; Column++) {
+        for (int Row = 0; Row < 2; Row++) {
+            m.Elements[Column][Row] = counter++;
+        }
+    }
+
+    for (int Row = 0; Row < 2; Row++) {
+        v.Elements[Row] = counter++;
+    }
+
+    {
+        HMM_Vec2 result = HMM_MulM2V2(m, v);
+        EXPECT_FLOAT_EQ(result.Elements[0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 34.0f);
+    }
+
+#ifdef __cplusplus
+    {
+        HMM_Vec2 result = HMM_Mul(m, v);
+        EXPECT_FLOAT_EQ(result.Elements[0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 34.0f);
+    }
+    
+    {
+        HMM_Vec2 result = m * v;
+        EXPECT_FLOAT_EQ(result.Elements[0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 34.0f);
+    }
+#endif
+}
+ 
+TEST(Multiplication, Mat3Mat3) 
+{
+    HMM_Mat3 a = HMM_M3();
+    HMM_Mat3 b = HMM_M3();
+
+    int counter = 1;
+    for (int Column = 0; Column < 3; Column++) {
+        for (int Row = 0; Row < 3; Row++) {
+            a.Elements[Column][Row] = counter++;
+        }
+    }
+    
+    for (int Column = 0; Column < 3; Column++) {
+        for (int Row = 0; Row < 3; Row++) {
+            b.Elements[Column][Row] = counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_MulM3(a,b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 204.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 174.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 216.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 258.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 210.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 261.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 312.0f);
+    }
+
+#ifdef __cplusplus
+    {
+        HMM_Mat3 result = HMM_Mul(a,b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 204.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 174.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 216.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 258.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 210.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 261.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 312.0f);
+    }
+
+    {
+        HMM_Mat3 result = a * b;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 204.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 174.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 216.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 258.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 210.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 261.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 312.0f);
+    }
+#endif
+}
+
+TEST(Multiplication, Mat3Scalar) {
+    HMM_Mat3 m = HMM_M3();
+    float s = 10.0f;
+
+    int counter = 1;
+    for (int Column = 0; Column < 3; Column++) {
+        for (int Row = 0; Row < 3; Row++) {
+            m.Elements[Column][Row] = counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_MulM3F(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 40.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 50.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 60.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 70.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 80.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 90.0f);
+    }
+#ifdef __cplusplus
+    {
+        HMM_Mat3 result = HMM_Mul(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 40.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 50.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 60.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 70.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 80.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 90.0f);
+    }
+    {
+        HMM_Mat3 result = m * s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 40.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 50.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 60.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 70.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 80.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 90.0f);
+    }
+    {
+        HMM_Mat3 result = s * m;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 40.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 50.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 60.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 70.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 80.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 90.0f);
+    }
+    m *= s;
+    EXPECT_FLOAT_EQ(m.Elements[0][0], 10.0f);
+    EXPECT_FLOAT_EQ(m.Elements[0][1], 20.0f);
+    EXPECT_FLOAT_EQ(m.Elements[0][2], 30.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][0], 40.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][1], 50.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][2], 60.0f);
+    EXPECT_FLOAT_EQ(m.Elements[2][0], 70.0f);
+    EXPECT_FLOAT_EQ(m.Elements[2][1], 80.0f);
+    EXPECT_FLOAT_EQ(m.Elements[2][2], 90.0f);
+#endif
+}
+
+TEST(Multiplication, Mat3Vec3) {
+    HMM_Mat3 m = HMM_M3();
+    HMM_Vec3 v = HMM_V3(0.0f, 0.0f, 0.0f);
+
+    int counter = 1;
+    for (int Column = 0; Column < 3; Column++) {
+        for (int Row = 0; Row < 3; Row++) {
+            m.Elements[Column][Row] = counter++;
+        }
+    }
+
+    for (int Row = 0; Row < 3; Row++) {
+        v.Elements[Row] = counter++;
+    }
+
+    {
+        HMM_Vec3 result = HMM_MulM3V3(m, v);
+        EXPECT_FLOAT_EQ(result.Elements[0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2], 204.0f);
+    }
+#ifdef __cplusplus
+    {
+        HMM_Vec3 result = HMM_Mul(m, v);
+        EXPECT_FLOAT_EQ(result.Elements[0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2], 204.0f);
+    }
+    
+    {
+        HMM_Vec3 result = m * v;
+        EXPECT_FLOAT_EQ(result.Elements[0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2], 204.0f);
+    }
+#endif
+}
+
 TEST(Multiplication, Mat4Mat4)
 {
-    hmm_mat4 m4_1 = HMM_Mat4(); // will have 1 - 16
+    HMM_Mat4 m4_1 = HMM_M4(); // will have 1 - 16
-    hmm_mat4 m4_2 = HMM_Mat4(); // will have 17 - 32
+    HMM_Mat4 m4_2 = HMM_M4(); // will have 17 - 32
 
     // Fill the matrices
     int Counter = 1;
@@ -235,7 +534,7 @@ TEST(Multiplication, Mat4Mat4)
 
     // Test the results
     {
-        hmm_mat4 result = HMM_MultiplyMat4(m4_1, m4_2);
+        HMM_Mat4 result = HMM_MulM4(m4_1, m4_2);
         EXPECT_FLOAT_EQ(result.Elements[0][0], 538.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 612.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 686.0f);
@@ -255,7 +554,7 @@ TEST(Multiplication, Mat4Mat4)
     }
 #ifdef __cplusplus
     {
-        hmm_mat4 result = HMM_Multiply(m4_1, m4_2);
+        HMM_Mat4 result = HMM_Mul(m4_1, m4_2);
         EXPECT_FLOAT_EQ(result.Elements[0][0], 538.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 612.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 686.0f);
@@ -274,7 +573,7 @@ TEST(Multiplication, Mat4Mat4)
         EXPECT_FLOAT_EQ(result.Elements[3][3], 1240.0f);
     }
     {
-        hmm_mat4 result = m4_1 * m4_2;
+        HMM_Mat4 result = m4_1 * m4_2;
         EXPECT_FLOAT_EQ(result.Elements[0][0], 538.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 612.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 686.0f);
@@ -301,7 +600,7 @@ TEST(Multiplication, Mat4Mat4)
 
 TEST(Multiplication, Mat4Scalar)
 {
-    hmm_mat4 m4 = HMM_Mat4(); // will have 1 - 16
+    HMM_Mat4 m4 = HMM_M4(); // will have 1 - 16
     float s = 3;
 
     // Fill the matrix
@@ -317,7 +616,7 @@ TEST(Multiplication, Mat4Scalar)
 
     // Test the results
     {
-        hmm_mat4 result = HMM_MultiplyMat4f(m4, s);
+        HMM_Mat4 result = HMM_MulM4F(m4, s);
         EXPECT_FLOAT_EQ(result.Elements[0][0], 3.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 6.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
@@ -337,7 +636,7 @@ TEST(Multiplication, Mat4Scalar)
     }
 #ifdef __cplusplus
     {
-        hmm_mat4 result = HMM_Multiply(m4, s);
+        HMM_Mat4 result = HMM_Mul(m4, s);
         EXPECT_FLOAT_EQ(result.Elements[0][0], 3.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 6.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
@@ -356,7 +655,7 @@ TEST(Multiplication, Mat4Scalar)
         EXPECT_FLOAT_EQ(result.Elements[3][3], 48.0f);
     }
     {
-        hmm_mat4 result = m4 * s;
+        HMM_Mat4 result = m4 * s;
         EXPECT_FLOAT_EQ(result.Elements[0][0], 3.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 6.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
@@ -375,7 +674,7 @@ TEST(Multiplication, Mat4Scalar)
         EXPECT_FLOAT_EQ(result.Elements[3][3], 48.0f);
     }
     {
-        hmm_mat4 result = s * m4;
+        HMM_Mat4 result = s * m4;
         EXPECT_FLOAT_EQ(result.Elements[0][0], 3.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][1], 6.0f);
         EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
@@ -416,8 +715,8 @@ TEST(Multiplication, Mat4Scalar)
 
 TEST(Multiplication, Mat4Vec4)
 {
-    hmm_mat4 m4 = HMM_Mat4(); // will have 1 - 16
+    HMM_Mat4 m4 = HMM_M4(); // will have 1 - 16
-    hmm_vec4 v4 = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
 
     // Fill the matrix
     int Counter = 1;
@@ -432,7 +731,7 @@ TEST(Multiplication, Mat4Vec4)
 
     // Test the results
     {
-        hmm_vec4 result = HMM_MultiplyMat4ByVec4(m4, v4);
+        HMM_Vec4 result = HMM_MulM4V4(m4, v4);
         EXPECT_FLOAT_EQ(result.X, 90.0f);
         EXPECT_FLOAT_EQ(result.Y, 100.0f);
         EXPECT_FLOAT_EQ(result.Z, 110.0f);
@@ -440,14 +739,14 @@ TEST(Multiplication, Mat4Vec4)
     }
 #ifdef __cplusplus
     {
-        hmm_vec4 result = HMM_Multiply(m4, v4);
+        HMM_Vec4 result = HMM_Mul(m4, v4);
         EXPECT_FLOAT_EQ(result.X, 90.0f);
         EXPECT_FLOAT_EQ(result.Y, 100.0f);
         EXPECT_FLOAT_EQ(result.Z, 110.0f);
         EXPECT_FLOAT_EQ(result.W, 120.0f);
     }
     {
-        hmm_vec4 result = m4 * v4;
+        HMM_Vec4 result = m4 * v4;
         EXPECT_FLOAT_EQ(result.X, 90.0f);
         EXPECT_FLOAT_EQ(result.Y, 100.0f);
         EXPECT_FLOAT_EQ(result.Z, 110.0f);
@@ -460,11 +759,11 @@ TEST(Multiplication, Mat4Vec4)
 
 TEST(Multiplication, QuaternionQuaternion)
 {
-    hmm_quaternion q1 = HMM_Quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_quaternion q2 = HMM_Quaternion(5.0f, 6.0f, 7.0f, 8.0f);
+    HMM_Quat q2 = HMM_Q(5.0f, 6.0f, 7.0f, 8.0f);
 
     {
-        hmm_quaternion result = HMM_MultiplyQuaternion(q1, q2);
+        HMM_Quat result = HMM_MulQ(q1, q2);
         EXPECT_FLOAT_EQ(result.X, 24.0f);
         EXPECT_FLOAT_EQ(result.Y, 48.0f);
         EXPECT_FLOAT_EQ(result.Z, 48.0f);
@@ -472,14 +771,14 @@ TEST(Multiplication, QuaternionQuaternion)
     }
 #ifdef __cplusplus
     {
-        hmm_quaternion result = HMM_Multiply(q1, q2);
+        HMM_Quat result = HMM_Mul(q1, q2);
         EXPECT_FLOAT_EQ(result.X, 24.0f);
         EXPECT_FLOAT_EQ(result.Y, 48.0f);
         EXPECT_FLOAT_EQ(result.Z, 48.0f);
         EXPECT_FLOAT_EQ(result.W, -6.0f);
     }
     {
-        hmm_quaternion result = q1 * q2;
+        HMM_Quat result = q1 * q2;
         EXPECT_FLOAT_EQ(result.X, 24.0f);
         EXPECT_FLOAT_EQ(result.Y, 48.0f);
         EXPECT_FLOAT_EQ(result.Z, 48.0f);
@@ -494,11 +793,11 @@ TEST(Multiplication, QuaternionQuaternion)
 
 TEST(Multiplication, QuaternionScalar)
 {
-    hmm_quaternion q = HMM_Quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
     float f = 2.0f;
 
     {
-        hmm_quaternion result = HMM_MultiplyQuaternionF(q, f);
+        HMM_Quat result = HMM_MulQF(q, f);
         EXPECT_FLOAT_EQ(result.X, 2.0f);
         EXPECT_FLOAT_EQ(result.Y, 4.0f);
         EXPECT_FLOAT_EQ(result.Z, 6.0f);
@@ -506,21 +805,21 @@ TEST(Multiplication, QuaternionScalar)
     }
 #ifdef __cplusplus
     {
-        hmm_quaternion result = HMM_Multiply(q, f);
+        HMM_Quat result = HMM_Mul(q, f);
         EXPECT_FLOAT_EQ(result.X, 2.0f);
         EXPECT_FLOAT_EQ(result.Y, 4.0f);
         EXPECT_FLOAT_EQ(result.Z, 6.0f);
         EXPECT_FLOAT_EQ(result.W, 8.0f);
     }
     {
-        hmm_quaternion result = q * f;
+        HMM_Quat result = q * f;
         EXPECT_FLOAT_EQ(result.X, 2.0f);
         EXPECT_FLOAT_EQ(result.Y, 4.0f);
         EXPECT_FLOAT_EQ(result.Z, 6.0f);
         EXPECT_FLOAT_EQ(result.W, 8.0f);
     }
     {
-        hmm_quaternion result = f * q;
+        HMM_Quat result = f * q;
         EXPECT_FLOAT_EQ(result.X, 2.0f);
         EXPECT_FLOAT_EQ(result.Y, 4.0f);
         EXPECT_FLOAT_EQ(result.Z, 6.0f);

test/categories/Projection.h

@@ -2,35 +2,48 @@
 
 TEST(Projection, Orthographic)
 {
-    hmm_mat4 projection = HMM_Orthographic(-10.0f, 10.0f, -5.0f, 5.0f, 0.0f, -10.0f);
+    {
+        HMM_Mat4 projection = HMM_Orthographic_RH(-10.0f, 10.0f, -5.0f, 5.0f, 0.0f, -10.0f);
 
-    hmm_vec3 original = HMM_Vec3(5.0f, 5.0f, -5.0f);
+        HMM_Vec3 original = HMM_V3(5.0f, 5.0f, -5.0f);
-    hmm_vec4 projected = HMM_MultiplyMat4ByVec4(projection, HMM_Vec4v(original, 1));
+        HMM_Vec4 projected = HMM_MulM4V4(projection, HMM_V4V(original, 1));
 
         EXPECT_FLOAT_EQ(projected.X, 0.5f);
         EXPECT_FLOAT_EQ(projected.Y, 1.0f);
         EXPECT_FLOAT_EQ(projected.Z, -2.0f);
         EXPECT_FLOAT_EQ(projected.W, 1.0f);
     }
+    {
+        HMM_Mat4 projection = HMM_Orthographic_LH(-10.0f, 10.0f, -5.0f, 5.0f, 0.0f, 10.0f);
+
+        HMM_Vec3 original = HMM_V3(5.0f, 5.0f, -5.0f);
+        HMM_Vec4 projected = HMM_MulM4V4(projection, HMM_V4V(original, 1));
+
+        EXPECT_FLOAT_EQ(projected.X, 0.5f);
+        EXPECT_FLOAT_EQ(projected.Y, 1.0f);
+        EXPECT_FLOAT_EQ(projected.Z, -2.0f);
+        EXPECT_FLOAT_EQ(projected.W, 1.0f);
+    }
+}
 
 TEST(Projection, Perspective)
 {
-    hmm_mat4 projection = HMM_Perspective(90.0f, 2.0f, 5.0f, 15.0f);
-
     {
-        hmm_vec3 original = HMM_Vec3(5.0f, 5.0f, -15.0f);
+        HMM_Mat4 projection = HMM_Perspective_RH(HMM_AngleDeg(90.0f), 2.0f, 5.0f, 15.0f);
-        hmm_vec4 projected = HMM_MultiplyMat4ByVec4(projection, HMM_Vec4v(original, 1));
+        HMM_Vec3 original = HMM_V3(5.0f, 5.0f, -15.0f);
+        HMM_Vec4 projected = HMM_MulM4V4(projection, HMM_V4V(original, 1));
         EXPECT_FLOAT_EQ(projected.X, 2.5f);
         EXPECT_FLOAT_EQ(projected.Y, 5.0f);
         EXPECT_FLOAT_EQ(projected.Z, 15.0f);
         EXPECT_FLOAT_EQ(projected.W, 15.0f);
     }
     {
-        hmm_vec3 original = HMM_Vec3(5.0f, 5.0f, -5.0f);
+        HMM_Mat4 projection = HMM_Perspective_LH(HMM_AngleDeg(90.0f), 2.0f, 5.0f, 15.0f);
-        hmm_vec4 projected = HMM_MultiplyMat4ByVec4(projection, HMM_Vec4v(original, 1));
+        HMM_Vec3 original = HMM_V3(5.0f, 5.0f, -15.0f);
+        HMM_Vec4 projected = HMM_MulM4V4(projection, HMM_V4V(original, 1));
         EXPECT_FLOAT_EQ(projected.X, 2.5f);
         EXPECT_FLOAT_EQ(projected.Y, 5.0f);
-        EXPECT_FLOAT_EQ(projected.Z, -5.0f);
+        EXPECT_FLOAT_EQ(projected.Z, 15.0f);
-        EXPECT_FLOAT_EQ(projected.W, 5.0f);
+        EXPECT_FLOAT_EQ(projected.W, -15.0f);
     }
 }

test/categories/QuaternionOps.h

@@ -2,10 +2,10 @@
 
 TEST(QuaternionOps, Inverse)
 {
-    hmm_quaternion q1 = HMM_Quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_quaternion inverse = HMM_InverseQuaternion(q1);
+    HMM_Quat inverse = HMM_InvQ(q1);
 
-    hmm_quaternion result = HMM_MultiplyQuaternion(q1, inverse);
+    HMM_Quat result = HMM_MulQ(q1, inverse);
 
     EXPECT_FLOAT_EQ(result.X, 0.0f);
     EXPECT_FLOAT_EQ(result.Y, 0.0f);
@@ -15,11 +15,11 @@ TEST(QuaternionOps, Inverse)
 
 TEST(QuaternionOps, Dot)
 {
-    hmm_quaternion q1 = HMM_Quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_quaternion q2 = HMM_Quaternion(5.0f, 6.0f, 7.0f, 8.0f);
+    HMM_Quat q2 = HMM_Q(5.0f, 6.0f, 7.0f, 8.0f);
 
     {
-        float result = HMM_DotQuaternion(q1, q2);
+        float result = HMM_DotQ(q1, q2);
         EXPECT_FLOAT_EQ(result, 70.0f);
     }
 #ifdef __cplusplus
@@ -32,57 +32,87 @@ TEST(QuaternionOps, Dot)
 
 TEST(QuaternionOps, Normalize)
 {
-    hmm_quaternion q = HMM_Quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
 
     {
-        hmm_quaternion result = HMM_NormalizeQuaternion(q);
+        HMM_Quat result = HMM_NormQ(q);
-        EXPECT_FLOAT_EQ(result.X, 0.1825741858f);
+        EXPECT_NEAR(result.X, 0.1825741858f, 0.001f);
-        EXPECT_FLOAT_EQ(result.Y, 0.3651483717f);
+        EXPECT_NEAR(result.Y, 0.3651483717f, 0.001f);
-        EXPECT_FLOAT_EQ(result.Z, 0.5477225575f);
+        EXPECT_NEAR(result.Z, 0.5477225575f, 0.001f);
-        EXPECT_FLOAT_EQ(result.W, 0.7302967433f);
+        EXPECT_NEAR(result.W, 0.7302967433f, 0.001f);
     }
 #ifdef __cplusplus
     {
-        hmm_quaternion result = HMM_Normalize(q);
+        HMM_Quat result = HMM_Norm(q);
-        EXPECT_FLOAT_EQ(result.X, 0.1825741858f);
+        EXPECT_NEAR(result.X, 0.1825741858f, 0.001f);
-        EXPECT_FLOAT_EQ(result.Y, 0.3651483717f);
+        EXPECT_NEAR(result.Y, 0.3651483717f, 0.001f);
-        EXPECT_FLOAT_EQ(result.Z, 0.5477225575f);
+        EXPECT_NEAR(result.Z, 0.5477225575f, 0.001f);
-        EXPECT_FLOAT_EQ(result.W, 0.7302967433f);
+        EXPECT_NEAR(result.W, 0.7302967433f, 0.001f);
     }
 #endif
 }
 
 TEST(QuaternionOps, NLerp)
 {
-    hmm_quaternion from = HMM_Quaternion(0.0f, 0.0f, 0.0f, 1.0f);
+    HMM_Quat from = HMM_Q(0.0f, 0.0f, 0.0f, 1.0f);
-    hmm_quaternion to = HMM_Quaternion(0.5f, 0.5f, -0.5f, 0.5f);
+    HMM_Quat to = HMM_Q(0.5f, 0.5f, -0.5f, 0.5f);
 
-    hmm_quaternion result = HMM_NLerp(from, 0.5f, to);
+    HMM_Quat result = HMM_NLerp(from, 0.5f, to);
-    EXPECT_FLOAT_EQ(result.X, 0.28867513f);
+    EXPECT_NEAR(result.X, 0.28867513f, 0.001f);
-    EXPECT_FLOAT_EQ(result.Y, 0.28867513f);
+    EXPECT_NEAR(result.Y, 0.28867513f, 0.001f);
-    EXPECT_FLOAT_EQ(result.Z, -0.28867513f);
+    EXPECT_NEAR(result.Z, -0.28867513f, 0.001f);
-    EXPECT_FLOAT_EQ(result.W, 0.86602540f);
+    EXPECT_NEAR(result.W, 0.86602540f, 0.001f);
 }
 
-TEST(QuaternionOps, Slerp)
+TEST(QuaternionOps, SLerp)
 {
-    hmm_quaternion from = HMM_Quaternion(0.0f, 0.0f, 0.0f, 1.0f);
+    HMM_Quat from = HMM_Q(0.0f, 0.0f, 0.0f, 1.0f);
-    hmm_quaternion to = HMM_Quaternion(0.5f, 0.5f, -0.5f, 0.5f);
+    HMM_Quat to = HMM_Q(0.5f, 0.5f, -0.5f, 0.5f);
 
-    hmm_quaternion result = HMM_Slerp(from, 0.5f, to);
+    {
-    EXPECT_FLOAT_EQ(result.X, 0.28867513f);
+        HMM_Quat result = HMM_SLerp(from, 0.0f, to);
-    EXPECT_FLOAT_EQ(result.Y, 0.28867513f);
+        EXPECT_NEAR(result.X, 0.0f, 0.001f);
-    EXPECT_FLOAT_EQ(result.Z, -0.28867513f);
+        EXPECT_NEAR(result.Y, 0.0f, 0.001f);
-    EXPECT_FLOAT_EQ(result.W, 0.86602540f);
+        EXPECT_NEAR(result.Z, 0.0f, 0.001f);
+        EXPECT_NEAR(result.W, 1.0, 0.001f);
+    }
+    {
+        HMM_Quat result = HMM_SLerp(from, 0.25f, to);
+        EXPECT_NEAR(result.X, 0.149429246f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.149429246f, 0.001f);
+        EXPECT_NEAR(result.Z, -0.149429246f, 0.001f);
+        EXPECT_NEAR(result.W, 0.965925812f, 0.001f);
+    }
+    {
+        HMM_Quat result = HMM_SLerp(from, 0.5f, to);
+        EXPECT_NEAR(result.X, 0.28867513f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.28867513f, 0.001f);
+        EXPECT_NEAR(result.Z, -0.28867513f, 0.001f);
+        EXPECT_NEAR(result.W, 0.86602540f, 0.001f);
+    }
+    {
+        HMM_Quat result = HMM_SLerp(from, 0.75f, to);
+        EXPECT_NEAR(result.X, 0.40824830f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.40824830f, 0.001f);
+        EXPECT_NEAR(result.Z, -0.40824830f, 0.001f);
+        EXPECT_NEAR(result.W, 0.70710676f, 0.001f);
+    }
+        {
+        HMM_Quat result = HMM_SLerp(from, 1.0f, to);
+        EXPECT_NEAR(result.X, 0.5f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.5f, 0.001f);
+        EXPECT_NEAR(result.Z, -0.5f, 0.001f);
+        EXPECT_NEAR(result.W, 0.5f, 0.001f);
+    }
 }
 
 TEST(QuaternionOps, QuatToMat4)
 {
-    const float abs_error = 0.0001f;
+    const float abs_error = 0.001f;
 
-    hmm_quaternion rot = HMM_Quaternion(0.707107f, 0.0f, 0.0f, 0.707107f);
+    HMM_Quat rot = HMM_Q(0.707107f, 0.0f, 0.0f, 0.707107f);
 
-    hmm_mat4 result = HMM_QuaternionToMat4(rot);
+    HMM_Mat4 result = HMM_QToM4(rot);
 
     EXPECT_NEAR(result.Elements[0][0], 1.0f, abs_error);
     EXPECT_NEAR(result.Elements[0][1], 0.0f, abs_error);
@@ -111,8 +141,8 @@ TEST(QuaternionOps, Mat4ToQuat)
 
     // Rotate 90 degrees on the X axis
     {
-        hmm_mat4 m = HMM_Rotate(90, HMM_Vec3(1, 0, 0));
+        HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(1, 0, 0));
-        hmm_quaternion result = HMM_Mat4ToQuaternion(m);
+        HMM_Quat result = HMM_M4ToQ_RH(m);
 
         float cosf = 0.707107f; // cos(90/2 degrees)
         float sinf = 0.707107f; // sin(90/2 degrees)
@@ -125,8 +155,8 @@ TEST(QuaternionOps, Mat4ToQuat)
 
     // Rotate 90 degrees on the Y axis (axis not normalized, just for fun)
     {
-        hmm_mat4 m = HMM_Rotate(90, HMM_Vec3(0, 2, 0));
+        HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 2, 0));
-        hmm_quaternion result = HMM_Mat4ToQuaternion(m);
+        HMM_Quat result = HMM_M4ToQ_RH(m);
 
         float cosf = 0.707107f; // cos(90/2 degrees)
         float sinf = 0.707107f; // sin(90/2 degrees)
@@ -139,8 +169,8 @@ TEST(QuaternionOps, Mat4ToQuat)
 
     // Rotate 90 degrees on the Z axis
     {
-        hmm_mat4 m = HMM_Rotate(90, HMM_Vec3(0, 0, 1));
+        HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
-        hmm_quaternion result = HMM_Mat4ToQuaternion(m);
+        HMM_Quat result = HMM_M4ToQ_RH(m);
 
         float cosf = 0.707107f; // cos(90/2 degrees)
         float sinf = 0.707107f; // sin(90/2 degrees)
@@ -153,8 +183,66 @@ TEST(QuaternionOps, Mat4ToQuat)
 
     // Rotate 45 degrees on the X axis (this hits case 4)
     {
-        hmm_mat4 m = HMM_Rotate(45, HMM_Vec3(1, 0, 0));
+        HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(45.0f), HMM_V3(1, 0, 0));
-        hmm_quaternion result = HMM_Mat4ToQuaternion(m);
+        HMM_Quat result = HMM_M4ToQ_RH(m);
+
+        float cosf = 0.9238795325f; // cos(90/2 degrees)
+        float sinf = 0.3826834324f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, sinf, abs_error);
+        EXPECT_NEAR(result.Y, 0.0f, abs_error);
+        EXPECT_NEAR(result.Z, 0.0f, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    /* NOTE(lcf): Left-handed cases. Since both Rotate and M4ToQ are LH results should be
+        the same with no changes to input. */
+    // Rotate 90 degrees on the X axis
+    {
+        HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(1, 0, 0));
+        HMM_Quat result = HMM_M4ToQ_LH(m);
+
+        float cosf = 0.707107f; // cos(90/2 degrees)
+        float sinf = 0.707107f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, sinf, abs_error);
+        EXPECT_NEAR(result.Y, 0.0f, abs_error);
+        EXPECT_NEAR(result.Z, 0.0f, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    // Rotate 90 degrees on the Y axis (axis not normalized, just for fun)
+    {
+        HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(0, 2, 0));
+        HMM_Quat result = HMM_M4ToQ_LH(m);
+
+        float cosf = 0.707107f; // cos(90/2 degrees)
+        float sinf = 0.707107f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, 0.0f, abs_error);
+        EXPECT_NEAR(result.Y, sinf, abs_error);
+        EXPECT_NEAR(result.Z, 0.0f, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    // Rotate 90 degrees on the Z axis
+    {
+        HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
+        HMM_Quat result = HMM_M4ToQ_LH(m);
+
+        float cosf = 0.707107f; // cos(90/2 degrees)
+        float sinf = 0.707107f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, 0.0f, abs_error);
+        EXPECT_NEAR(result.Y, 0.0f, abs_error);
+        EXPECT_NEAR(result.Z, sinf, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    // Rotate 45 degrees on the X axis (this hits case 4)
+    {
+        HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(45.0f), HMM_V3(1, 0, 0));
+        HMM_Quat result = HMM_M4ToQ_LH(m);
 
         float cosf = 0.9238795325f; // cos(90/2 degrees)
         float sinf = 0.3826834324f; // sin(90/2 degrees)
@@ -168,12 +256,21 @@ TEST(QuaternionOps, Mat4ToQuat)
 
 TEST(QuaternionOps, FromAxisAngle)
 {
-    hmm_vec3 axis = HMM_Vec3(1.0f, 0.0f, 0.0f);
+    HMM_Vec3 axis = HMM_V3(1.0f, 0.0f, 0.0f);
     float angle = HMM_PI32 / 2.0f;
 
-    hmm_quaternion result = HMM_QuaternionFromAxisAngle(axis, angle);
+    {
-    EXPECT_NEAR(result.X, 0.707107f, FLT_EPSILON * 2);
+        HMM_Quat result = HMM_QFromAxisAngle_RH(axis, angle);
-    EXPECT_FLOAT_EQ(result.Y, 0.0f);
+        EXPECT_NEAR(result.X, 0.707107f, 0.001f);
-    EXPECT_FLOAT_EQ(result.Z, 0.0f);
+        EXPECT_NEAR(result.Y, 0.0f, 0.001f);
-    EXPECT_NEAR(result.W, 0.707107f, FLT_EPSILON * 2);
+        EXPECT_NEAR(result.Z, 0.0f, 0.001f);
+        EXPECT_NEAR(result.W, 0.707107f, 0.001f);
+    }
+    {
+        HMM_Quat result = HMM_QFromAxisAngle_LH(axis, angle);
+        EXPECT_NEAR(result.X, -0.707107f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.0f, 0.001f);
+        EXPECT_NEAR(result.Z, 0.0f, 0.001f);
+        EXPECT_NEAR(result.W, 0.707107f, 0.001f);
+    }
 }

test/categories/SSE.h

@@ -4,14 +4,14 @@
 
 TEST(SSE, LinearCombine)
 {
-    hmm_mat4 MatrixOne = HMM_Mat4d(2.0f);
+    HMM_Mat4 MatrixOne = HMM_M4D(2.0f);
-    hmm_mat4 MatrixTwo = HMM_Mat4d(4.0f);
+    HMM_Mat4 MatrixTwo = HMM_M4D(4.0f);
-    hmm_mat4 Result;
+    HMM_Mat4 Result;
 
-    Result.Columns[0] = HMM_LinearCombineSSE(MatrixOne.Columns[0], MatrixTwo);
+    Result.Columns[0] = HMM_LinearCombineV4M4(MatrixOne.Columns[0], MatrixTwo);
-    Result.Columns[1] = HMM_LinearCombineSSE(MatrixOne.Columns[1], MatrixTwo);
+    Result.Columns[1] = HMM_LinearCombineV4M4(MatrixOne.Columns[1], MatrixTwo);
-    Result.Columns[2] = HMM_LinearCombineSSE(MatrixOne.Columns[2], MatrixTwo);
+    Result.Columns[2] = HMM_LinearCombineV4M4(MatrixOne.Columns[2], MatrixTwo);
-    Result.Columns[3] = HMM_LinearCombineSSE(MatrixOne.Columns[3], MatrixTwo);
+    Result.Columns[3] = HMM_LinearCombineV4M4(MatrixOne.Columns[3], MatrixTwo);
 
     {
         EXPECT_FLOAT_EQ(Result.Elements[0][0], 8.0f);

test/categories/ScalarMath.h

@@ -24,25 +24,10 @@ TEST(ScalarMath, Trigonometry)
     EXPECT_NEAR(HMM_TanF(HMM_PI32), 0.0f, trigAbsError);
     EXPECT_NEAR(HMM_TanF(-HMM_PI32 / 4), -1.0f, trigAbsError);
 
-    EXPECT_NEAR(HMM_ATanF(0.0f), 0.0f, trigAbsError);
-    EXPECT_NEAR(HMM_ATanF(HMM_PI32), 1.2626272557f, trigAbsError);
-    EXPECT_NEAR(HMM_ATanF(-HMM_PI32), -1.2626272557f, trigAbsError);
-
-    EXPECT_NEAR(HMM_ATan2F(0.0f, 1.0f), 0.0f, trigAbsError);
-    EXPECT_NEAR(HMM_ATan2F(1.0f, 1.0f), HMM_PI32 / 4.0f, trigAbsError);
-    EXPECT_NEAR(HMM_ATan2F(1.0f, 0.0f), HMM_PI32 / 2.0f, trigAbsError);
-
     // This isn't the most rigorous because we're really just sanity-
     // checking that things work by default.
 }
 
-TEST(ScalarMath, ToRadians)
-{
-    EXPECT_FLOAT_EQ(HMM_ToRadians(0.0f), 0.0f);
-    EXPECT_FLOAT_EQ(HMM_ToRadians(180.0f), HMM_PI32);
-    EXPECT_FLOAT_EQ(HMM_ToRadians(-180.0f), -HMM_PI32);
-}
-
 TEST(ScalarMath, ExpF)
 {
     EXPECT_NEAR(HMM_ExpF(0.0f), 1.0f, 0.0001f);
@@ -57,12 +42,12 @@ TEST(ScalarMath, LogF)
 
 TEST(ScalarMath, SquareRoot)
 {
-    EXPECT_FLOAT_EQ(HMM_SquareRootF(16.0f), 4.0f);
+    EXPECT_FLOAT_EQ(HMM_SqrtF(16.0f), 4.0f);
 }
 
 TEST(ScalarMath, RSquareRootF)
 {
-    EXPECT_NEAR(HMM_RSquareRootF(10.0f), 0.31616211f, 0.0001f);
+    EXPECT_NEAR(HMM_InvSqrtF(10.0f), 0.31616211f, 0.0001f);
 }
 
 TEST(ScalarMath, Power)

test/categories/Subtraction.h

@@ -2,22 +2,22 @@
 
 TEST(Subtraction, Vec2)
 {
-    hmm_vec2 v2_1 = HMM_Vec2(1.0f, 2.0f);
+    HMM_Vec2 v2_1 = HMM_V2(1.0f, 2.0f);
-    hmm_vec2 v2_2 = HMM_Vec2(3.0f, 4.0f);
+    HMM_Vec2 v2_2 = HMM_V2(3.0f, 4.0f);
 
     {
-        hmm_vec2 result = HMM_SubtractVec2(v2_1, v2_2);
+        HMM_Vec2 result = HMM_SubV2(v2_1, v2_2);
         EXPECT_FLOAT_EQ(result.X, -2.0f);
         EXPECT_FLOAT_EQ(result.Y, -2.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec2 result = HMM_Subtract(v2_1, v2_2);
+        HMM_Vec2 result = HMM_Sub(v2_1, v2_2);
         EXPECT_FLOAT_EQ(result.X, -2.0f);
         EXPECT_FLOAT_EQ(result.Y, -2.0f);
     }
     {
-        hmm_vec2 result = v2_1 - v2_2;
+        HMM_Vec2 result = v2_1 - v2_2;
         EXPECT_FLOAT_EQ(result.X, -2.0f);
         EXPECT_FLOAT_EQ(result.Y, -2.0f);
     }
@@ -30,24 +30,24 @@ TEST(Subtraction, Vec2)
 
 TEST(Subtraction, Vec3)
 {
-    hmm_vec3 v3_1 = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v3_1 = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec3 v3_2 = HMM_Vec3(4.0f, 5.0f, 6.0f);
+    HMM_Vec3 v3_2 = HMM_V3(4.0f, 5.0f, 6.0f);
 
     {
-        hmm_vec3 result = HMM_SubtractVec3(v3_1, v3_2);
+        HMM_Vec3 result = HMM_SubV3(v3_1, v3_2);
         EXPECT_FLOAT_EQ(result.X, -3.0f);
         EXPECT_FLOAT_EQ(result.Y, -3.0f);
         EXPECT_FLOAT_EQ(result.Z, -3.0f);
     }
 #ifdef __cplusplus
     {
-        hmm_vec3 result = HMM_Subtract(v3_1, v3_2);
+        HMM_Vec3 result = HMM_Sub(v3_1, v3_2);
         EXPECT_FLOAT_EQ(result.X, -3.0f);
         EXPECT_FLOAT_EQ(result.Y, -3.0f);
         EXPECT_FLOAT_EQ(result.Z, -3.0f);
     }
     {
-        hmm_vec3 result = v3_1 - v3_2;
+        HMM_Vec3 result = v3_1 - v3_2;
         EXPECT_FLOAT_EQ(result.X, -3.0f);
         EXPECT_FLOAT_EQ(result.Y, -3.0f);
         EXPECT_FLOAT_EQ(result.Z, -3.0f);
@@ -62,11 +62,11 @@ TEST(Subtraction, Vec3)
 
 TEST(Subtraction, Vec4)
 {
-    hmm_vec4 v4_1 = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4_1 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_vec4 v4_2 = HMM_Vec4(5.0f, 6.0f, 7.0f, 8.0f);
+    HMM_Vec4 v4_2 = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
 
     {
-        hmm_vec4 result = HMM_SubtractVec4(v4_1, v4_2);
+        HMM_Vec4 result = HMM_SubV4(v4_1, v4_2);
         EXPECT_FLOAT_EQ(result.X, -4.0f);
         EXPECT_FLOAT_EQ(result.Y, -4.0f);
         EXPECT_FLOAT_EQ(result.Z, -4.0f);
@@ -74,14 +74,14 @@ TEST(Subtraction, Vec4)
     }
 #ifdef __cplusplus
     {
-        hmm_vec4 result = HMM_Subtract(v4_1, v4_2);
+        HMM_Vec4 result = HMM_Sub(v4_1, v4_2);
         EXPECT_FLOAT_EQ(result.X, -4.0f);
         EXPECT_FLOAT_EQ(result.Y, -4.0f);
         EXPECT_FLOAT_EQ(result.Z, -4.0f);
         EXPECT_FLOAT_EQ(result.W, -4.0f);
     }
     {
-        hmm_vec4 result = v4_1 - v4_2;
+        HMM_Vec4 result = v4_1 - v4_2;
         EXPECT_FLOAT_EQ(result.X, -4.0f);
         EXPECT_FLOAT_EQ(result.Y, -4.0f);
         EXPECT_FLOAT_EQ(result.Z, -4.0f);
@@ -96,10 +96,124 @@ TEST(Subtraction, Vec4)
 #endif
 }
 
+TEST(Subtraction, Mat2)
+{
+    HMM_Mat2 a = HMM_M2();
+    HMM_Mat2 b = HMM_M2();
+    
+    int Counter = 1;
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            a.Elements[Column][Row] = Counter++;
+        }
+    }
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            b.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_SubM2(b,a);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 4.0);
+    }
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = HMM_Sub(b,a);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 4.0);
+    }
+
+    {
+        HMM_Mat2 result = b - a;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 4.0);
+    }
+
+    b -= a;
+    EXPECT_FLOAT_EQ(b.Elements[0][0], 4.0);
+    EXPECT_FLOAT_EQ(b.Elements[0][1], 4.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][0], 4.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][1], 4.0);
+#endif
+}
+
+
+TEST(Subtraction, Mat3)
+{
+    HMM_Mat3 a = HMM_M3();
+    HMM_Mat3 b = HMM_M3();
+    
+    int Counter = 1;
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            a.Elements[Column][Row] = Counter++;
+        }
+    }
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            b.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_SubM3(b,a);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 9.0);
+    }
+#ifdef __cplusplus
+    {
+        HMM_Mat3 result = HMM_Sub(b,a);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 9.0);
+    }
+
+    b -= a;
+    EXPECT_FLOAT_EQ(b.Elements[0][0], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[0][1], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[0][2], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][0], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][1], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][2], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[2][0], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[2][1], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[2][2], 9.0);
+#endif
+}
+
 TEST(Subtraction, Mat4)
 {
-    hmm_mat4 m4_1 = HMM_Mat4(); // will have 1 - 16
+    HMM_Mat4 m4_1 = HMM_M4(); // will have 1 - 16
-    hmm_mat4 m4_2 = HMM_Mat4(); // will have 17 - 32
+    HMM_Mat4 m4_2 = HMM_M4(); // will have 17 - 32
 
     // Fill the matrices
     int Counter = 1;
@@ -122,7 +236,7 @@ TEST(Subtraction, Mat4)
 
     // Test the results
     {
-        hmm_mat4 result = HMM_SubtractMat4(m4_1, m4_2);
+        HMM_Mat4 result = HMM_SubM4(m4_1, m4_2);
         for (int Column = 0; Column < 4; ++Column)
         {
             for (int Row = 0; Row < 4; ++Row)
@@ -133,7 +247,7 @@ TEST(Subtraction, Mat4)
     }
 #ifdef __cplusplus
     {
-        hmm_mat4 result = HMM_Subtract(m4_1, m4_2);
+        HMM_Mat4 result = HMM_Sub(m4_1, m4_2);
         for (int Column = 0; Column < 4; ++Column)
         {
             for (int Row = 0; Row < 4; ++Row)
@@ -143,7 +257,7 @@ TEST(Subtraction, Mat4)
         }
     }
     {
-        hmm_mat4 result = m4_1 - m4_2;
+        HMM_Mat4 result = m4_1 - m4_2;
         for (int Column = 0; Column < 4; ++Column)
         {
             for (int Row = 0; Row < 4; ++Row)
@@ -166,11 +280,11 @@ TEST(Subtraction, Mat4)
 
 TEST(Subtraction, Quaternion)
 {
-    hmm_quaternion q1 = HMM_Quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_quaternion q2 = HMM_Quaternion(5.0f, 6.0f, 7.0f, 8.0f);
+    HMM_Quat q2 = HMM_Q(5.0f, 6.0f, 7.0f, 8.0f);
 
     {
-        hmm_quaternion result = HMM_SubtractQuaternion(q1, q2);
+        HMM_Quat result = HMM_SubQ(q1, q2);
         EXPECT_FLOAT_EQ(result.X, -4.0f);
         EXPECT_FLOAT_EQ(result.Y, -4.0f);
         EXPECT_FLOAT_EQ(result.Z, -4.0f);
@@ -178,14 +292,14 @@ TEST(Subtraction, Quaternion)
     }
 #ifdef __cplusplus
     {
-        hmm_quaternion result = HMM_Subtract(q1, q2);
+        HMM_Quat result = HMM_Sub(q1, q2);
         EXPECT_FLOAT_EQ(result.X, -4.0f);
         EXPECT_FLOAT_EQ(result.Y, -4.0f);
         EXPECT_FLOAT_EQ(result.Z, -4.0f);
         EXPECT_FLOAT_EQ(result.W, -4.0f);
     }
     {
-        hmm_quaternion result = q1 - q2;
+        HMM_Quat result = q1 - q2;
         EXPECT_FLOAT_EQ(result.X, -4.0f);
         EXPECT_FLOAT_EQ(result.Y, -4.0f);
         EXPECT_FLOAT_EQ(result.Z, -4.0f);
@@ -203,16 +317,16 @@ TEST(Subtraction, Quaternion)
 #ifdef __cplusplus
 TEST(UnaryMinus, Vec2)
 {
-    hmm_vec2 VectorOne = {1.0f, 2.0f};
+    HMM_Vec2 VectorOne = {1.0f, 2.0f};
-    hmm_vec2 Result = -VectorOne;
+    HMM_Vec2 Result = -VectorOne;
     EXPECT_FLOAT_EQ(Result.X, -1.0f);
     EXPECT_FLOAT_EQ(Result.Y, -2.0f);
 }
 
 TEST(UnaryMinus, Vec3)
 {
-    hmm_vec3 VectorOne = {1.0f, 2.0f, 3.0f};
+    HMM_Vec3 VectorOne = {1.0f, 2.0f, 3.0f};
-    hmm_vec3 Result = -VectorOne;
+    HMM_Vec3 Result = -VectorOne;
     EXPECT_FLOAT_EQ(Result.X, -1.0f);
     EXPECT_FLOAT_EQ(Result.Y, -2.0f);
     EXPECT_FLOAT_EQ(Result.Z, -3.0f);
@@ -220,8 +334,8 @@ TEST(UnaryMinus, Vec3)
 
 TEST(UnaryMinus, Vec4)
 {
-    hmm_vec4 VectorOne = {1.0f, 2.0f, 3.0f, 4.0f};
+    HMM_Vec4 VectorOne = {1.0f, 2.0f, 3.0f, 4.0f};
-    hmm_vec4 Result = -VectorOne;
+    HMM_Vec4 Result = -VectorOne;
     EXPECT_FLOAT_EQ(Result.X, -1.0f);
     EXPECT_FLOAT_EQ(Result.Y, -2.0f);
     EXPECT_FLOAT_EQ(Result.Z, -3.0f);

test/categories/Transformation.h

@@ -2,76 +2,104 @@
 
 TEST(Transformations, Translate)
 {
-    hmm_mat4 translate = HMM_Translate(HMM_Vec3(1.0f, -3.0f, 6.0f));
+    HMM_Mat4 translate = HMM_Translate(HMM_V3(1.0f, -3.0f, 6.0f));
 
-    hmm_vec3 original = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 original = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec4 translated = HMM_MultiplyMat4ByVec4(translate, HMM_Vec4v(original, 1));
+    HMM_Vec4 translated = HMM_MulM4V4(translate, HMM_V4V(original, 1));
 
-    EXPECT_FLOAT_EQ(translated.X, 2.0f);
+    EXPECT_NEAR(translated.X, 2.0f, 0.001f);
-    EXPECT_FLOAT_EQ(translated.Y, -1.0f);
+    EXPECT_NEAR(translated.Y, -1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(translated.Z, 9.0f);
+    EXPECT_NEAR(translated.Z, 9.0f, 0.001f);
-    EXPECT_FLOAT_EQ(translated.W, 1.0f);
+    EXPECT_NEAR(translated.W, 1.0f, 0.001f);
 }
 
 TEST(Transformations, Rotate)
 {
-    hmm_vec3 original = HMM_Vec3(1.0f, 1.0f, 1.0f);
+    HMM_Vec3 original = HMM_V3(1.0f, 1.0f, 1.0f);
 
-    hmm_mat4 rotateX = HMM_Rotate(90, HMM_Vec3(1, 0, 0));
+    HMM_Mat4 rotateX = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(1, 0, 0));
-    hmm_vec4 rotatedX = HMM_MultiplyMat4ByVec4(rotateX, HMM_Vec4v(original, 1));
+    HMM_Vec4 rotatedX = HMM_MulM4V4(rotateX, HMM_V4V(original, 1));
-    EXPECT_FLOAT_EQ(rotatedX.X, 1.0f);
+    EXPECT_NEAR(rotatedX.X, 1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(rotatedX.Y, -1.0f);
+    EXPECT_NEAR(rotatedX.Y, -1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(rotatedX.Z, 1.0f);
+    EXPECT_NEAR(rotatedX.Z, 1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(rotatedX.W, 1.0f);
+    EXPECT_NEAR(rotatedX.W, 1.0f, 0.001f);
 
-    hmm_mat4 rotateY = HMM_Rotate(90, HMM_Vec3(0, 1, 0));
+    HMM_Mat4 rotateY = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 1, 0));
-    hmm_vec4 rotatedY = HMM_MultiplyMat4ByVec4(rotateY, HMM_Vec4v(original, 1));
+    HMM_Vec4 rotatedY = HMM_MulM4V4(rotateY, HMM_V4V(original, 1));
-    EXPECT_FLOAT_EQ(rotatedY.X, 1.0f);
+    EXPECT_NEAR(rotatedY.X, 1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(rotatedY.Y, 1.0f);
+    EXPECT_NEAR(rotatedY.Y, 1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(rotatedY.Z, -1.0f);
+    EXPECT_NEAR(rotatedY.Z, -1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(rotatedY.W, 1.0f);
+    EXPECT_NEAR(rotatedY.W, 1.0f, 0.001f);
 
-    hmm_mat4 rotateZ = HMM_Rotate(90, HMM_Vec3(0, 0, 1));
+    HMM_Mat4 rotateZ = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
-    hmm_vec4 rotatedZ = HMM_MultiplyMat4ByVec4(rotateZ, HMM_Vec4v(original, 1));
+    HMM_Vec4 rotatedZ = HMM_MulM4V4(rotateZ, HMM_V4V(original, 1));
-    EXPECT_FLOAT_EQ(rotatedZ.X, -1.0f);
+    EXPECT_NEAR(rotatedZ.X, -1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(rotatedZ.Y, 1.0f);
+    EXPECT_NEAR(rotatedZ.Y, 1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(rotatedZ.Z, 1.0f);
+    EXPECT_NEAR(rotatedZ.Z, 1.0f, 0.001f);
-    EXPECT_FLOAT_EQ(rotatedZ.W, 1.0f);
+    EXPECT_NEAR(rotatedZ.W, 1.0f, 0.001f);
+
+    HMM_Mat4 rotateZLH = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
+    HMM_Vec4 rotatedZLH = HMM_MulM4V4(rotateZLH, HMM_V4V(original, 1));
+    EXPECT_NEAR(rotatedZLH.X, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedZLH.Y, -1.0f, 0.001f);
+    EXPECT_NEAR(rotatedZLH.Z, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedZLH.W, 1.0f, 0.001f);
 }
 
 TEST(Transformations, Scale)
 {
-    hmm_mat4 scale = HMM_Scale(HMM_Vec3(2.0f, -3.0f, 0.5f));
+    HMM_Mat4 scale = HMM_Scale(HMM_V3(2.0f, -3.0f, 0.5f));
 
-    hmm_vec3 original = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 original = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec4 scaled = HMM_MultiplyMat4ByVec4(scale, HMM_Vec4v(original, 1));
+    HMM_Vec4 scaled = HMM_MulM4V4(scale, HMM_V4V(original, 1));
 
-    EXPECT_FLOAT_EQ(scaled.X, 2.0f);
+    EXPECT_NEAR(scaled.X, 2.0f, 0.001f);
-    EXPECT_FLOAT_EQ(scaled.Y, -6.0f);
+    EXPECT_NEAR(scaled.Y, -6.0f, 0.001f);
-    EXPECT_FLOAT_EQ(scaled.Z, 1.5f);
+    EXPECT_NEAR(scaled.Z, 1.5f, 0.001f);
-    EXPECT_FLOAT_EQ(scaled.W, 1.0f);
+    EXPECT_NEAR(scaled.W, 1.0f, 0.001f);
 }
 
 TEST(Transformations, LookAt)
 {
-    const float abs_error = 0.0001f;
+    const float abs_error = 0.001f;
 
-    hmm_mat4 result = HMM_LookAt(HMM_Vec3(1.0f, 0.0f, 0.0f), HMM_Vec3(0.0f, 2.0f, 1.0f), HMM_Vec3(2.0f, 1.0f, 1.0f));
+    {    HMM_Mat4 result = HMM_LookAt_RH(HMM_V3(1.0f, 0.0f, 0.0f), HMM_V3(0.0f, 2.0f, 1.0f), HMM_V3(2.0f, 1.0f, 1.0f));
 
         EXPECT_NEAR(result.Elements[0][0], 0.169031f, abs_error);
         EXPECT_NEAR(result.Elements[0][1], 0.897085f, abs_error);
         EXPECT_NEAR(result.Elements[0][2], 0.408248f, abs_error);
-    EXPECT_FLOAT_EQ(result.Elements[0][3], 0.0f);
+        EXPECT_NEAR(result.Elements[0][3], 0.0f, abs_error);
         EXPECT_NEAR(result.Elements[1][0], 0.507093f, abs_error);
         EXPECT_NEAR(result.Elements[1][1], 0.276026f, abs_error);
         EXPECT_NEAR(result.Elements[1][2], -0.816497f, abs_error);
-    EXPECT_FLOAT_EQ(result.Elements[1][3], 0.0f);
+        EXPECT_NEAR(result.Elements[1][3], 0.0f, abs_error);
         EXPECT_NEAR(result.Elements[2][0], -0.845154f, abs_error);
         EXPECT_NEAR(result.Elements[2][1], 0.345033f, abs_error);
         EXPECT_NEAR(result.Elements[2][2], -0.408248f, abs_error);
-    EXPECT_FLOAT_EQ(result.Elements[2][3], 0.0f);
+        EXPECT_NEAR(result.Elements[2][3], 0.0f, abs_error);
         EXPECT_NEAR(result.Elements[3][0], -0.169031f, abs_error);
         EXPECT_NEAR(result.Elements[3][1], -0.897085f, abs_error);
         EXPECT_NEAR(result.Elements[3][2], -0.408248f, abs_error);
-    EXPECT_FLOAT_EQ(result.Elements[3][3], 1.0f);
+        EXPECT_NEAR(result.Elements[3][3], 1.0f, abs_error);
+    }
+    {    
+        HMM_Mat4 result = HMM_LookAt_LH(HMM_V3(1.0f, 0.0f, 0.0f), HMM_V3(0.0f, 2.0f, 1.0f), HMM_V3(2.0f, 1.0f, 1.0f));
+
+        EXPECT_NEAR(result.Elements[0][0], -0.169031f, abs_error);
+        EXPECT_NEAR(result.Elements[0][1], 0.897085f, abs_error);
+        EXPECT_NEAR(result.Elements[0][2], -0.408248f, abs_error);
+        EXPECT_NEAR(result.Elements[0][3], 0.0f, abs_error);
+        EXPECT_NEAR(result.Elements[1][0], -0.507093f, abs_error);
+        EXPECT_NEAR(result.Elements[1][1], 0.276026f, abs_error);
+        EXPECT_NEAR(result.Elements[1][2], 0.816497f, abs_error);
+        EXPECT_NEAR(result.Elements[1][3], 0.0f, abs_error);
+        EXPECT_NEAR(result.Elements[2][0], 0.845154f, abs_error);
+        EXPECT_NEAR(result.Elements[2][1], 0.345033f, abs_error);
+        EXPECT_NEAR(result.Elements[2][2], 0.408248f, abs_error);
+        EXPECT_NEAR(result.Elements[2][3], 0.0f, abs_error);
+        EXPECT_NEAR(result.Elements[3][0], 0.169031f, abs_error);
+        EXPECT_NEAR(result.Elements[3][1], -0.897085f, abs_error);
+        EXPECT_NEAR(result.Elements[3][2], 0.408248f, abs_error);
+        EXPECT_NEAR(result.Elements[3][3], 1.0f, abs_error);
+    }
 }

test/categories/VectorOps.h

@@ -2,60 +2,60 @@
 
 TEST(VectorOps, LengthSquared)
 {
-    hmm_vec2 v2 = HMM_Vec2(1.0f, -2.0f);
+    HMM_Vec2 v2 = HMM_V2(1.0f, -2.0f);
-    hmm_vec3 v3 = HMM_Vec3(1.0f, -2.0f, 3.0f);
+    HMM_Vec3 v3 = HMM_V3(1.0f, -2.0f, 3.0f);
-    hmm_vec4 v4 = HMM_Vec4(1.0f, -2.0f, 3.0f, 1.0f);
+    HMM_Vec4 v4 = HMM_V4(1.0f, -2.0f, 3.0f, 1.0f);
 
-    EXPECT_FLOAT_EQ(HMM_LengthSquaredVec2(v2), 5.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqrV2(v2), 5.0f);
-    EXPECT_FLOAT_EQ(HMM_LengthSquaredVec3(v3), 14.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqrV3(v3), 14.0f);
-    EXPECT_FLOAT_EQ(HMM_LengthSquaredVec4(v4), 15.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqrV4(v4), 15.0f);
 
 #ifdef __cplusplus
-    EXPECT_FLOAT_EQ(HMM_LengthSquared(v2), 5.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqr(v2), 5.0f);
-    EXPECT_FLOAT_EQ(HMM_LengthSquared(v3), 14.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqr(v3), 14.0f);
-    EXPECT_FLOAT_EQ(HMM_LengthSquared(v4), 15.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqr(v4), 15.0f);
 #endif
 }
 
 TEST(VectorOps, Length)
 {
-    hmm_vec2 v2 = HMM_Vec2(1.0f, -9.0f);
+    HMM_Vec2 v2 = HMM_V2(1.0f, -9.0f);
-    hmm_vec3 v3 = HMM_Vec3(2.0f, -3.0f, 6.0f);
+    HMM_Vec3 v3 = HMM_V3(2.0f, -3.0f, 6.0f);
-    hmm_vec4 v4 = HMM_Vec4(2.0f, -3.0f, 6.0f, 12.0f);
+    HMM_Vec4 v4 = HMM_V4(2.0f, -3.0f, 6.0f, 12.0f);
 
-    EXPECT_FLOAT_EQ(HMM_LengthVec2(v2), 9.0553856f);
+    EXPECT_FLOAT_EQ(HMM_LenV2(v2), 9.0553856f);
-    EXPECT_FLOAT_EQ(HMM_LengthVec3(v3), 7.0f);
+    EXPECT_FLOAT_EQ(HMM_LenV3(v3), 7.0f);
-    EXPECT_FLOAT_EQ(HMM_LengthVec4(v4), 13.892444f);
+    EXPECT_FLOAT_EQ(HMM_LenV4(v4), 13.892444f);
 
 #ifdef __cplusplus
-    EXPECT_FLOAT_EQ(HMM_Length(v2), 9.0553856f);
+    EXPECT_FLOAT_EQ(HMM_Len(v2), 9.0553856f);
-    EXPECT_FLOAT_EQ(HMM_Length(v3), 7.0f);
+    EXPECT_FLOAT_EQ(HMM_Len(v3), 7.0f);
-    EXPECT_FLOAT_EQ(HMM_Length(v4), 13.892444f);
+    EXPECT_FLOAT_EQ(HMM_Len(v4), 13.892444f);
 #endif
 }
 
 TEST(VectorOps, Normalize)
 {
-    hmm_vec2 v2 = HMM_Vec2(1.0f, -2.0f);
+    HMM_Vec2 v2 = HMM_V2(1.0f, -2.0f);
-    hmm_vec3 v3 = HMM_Vec3(1.0f, -2.0f, 3.0f);
+    HMM_Vec3 v3 = HMM_V3(1.0f, -2.0f, 3.0f);
-    hmm_vec4 v4 = HMM_Vec4(1.0f, -2.0f, 3.0f, -1.0f);
+    HMM_Vec4 v4 = HMM_V4(1.0f, -2.0f, 3.0f, -1.0f);
 
     {
-        hmm_vec2 result = HMM_NormalizeVec2(v2);
+        HMM_Vec2 result = HMM_NormV2(v2);
-        EXPECT_FLOAT_EQ(HMM_LengthVec2(result), 1.0f);
+        EXPECT_NEAR(HMM_LenV2(result), 1.0f, 0.001f);
         EXPECT_GT(result.X, 0.0f);
         EXPECT_LT(result.Y, 0.0f);
     }
     {
-        hmm_vec3 result = HMM_NormalizeVec3(v3);
+        HMM_Vec3 result = HMM_NormV3(v3);
-        EXPECT_FLOAT_EQ(HMM_LengthVec3(result), 1.0f);
+        EXPECT_NEAR(HMM_LenV3(result), 1.0f, 0.001f);
         EXPECT_GT(result.X, 0.0f);
         EXPECT_LT(result.Y, 0.0f);
         EXPECT_GT(result.Z, 0.0f);
     }
     {
-        hmm_vec4 result = HMM_NormalizeVec4(v4);
+        HMM_Vec4 result = HMM_NormV4(v4);
-        EXPECT_FLOAT_EQ(HMM_LengthVec4(result), 1.0f);
+        EXPECT_NEAR(HMM_LenV4(result), 1.0f, 0.001f);
         EXPECT_GT(result.X, 0.0f);
         EXPECT_LT(result.Y, 0.0f);
         EXPECT_GT(result.Z, 0.0f);
@@ -64,21 +64,21 @@ TEST(VectorOps, Normalize)
 
 #ifdef __cplusplus
     {
-        hmm_vec2 result = HMM_Normalize(v2);
+        HMM_Vec2 result = HMM_Norm(v2);
-        EXPECT_FLOAT_EQ(HMM_LengthVec2(result), 1.0f);
+        EXPECT_NEAR(HMM_LenV2(result), 1.0f, 0.001f);
         EXPECT_GT(result.X, 0.0f);
         EXPECT_LT(result.Y, 0.0f);
     }
     {
-        hmm_vec3 result = HMM_Normalize(v3);
+        HMM_Vec3 result = HMM_Norm(v3);
-        EXPECT_FLOAT_EQ(HMM_LengthVec3(result), 1.0f);
+        EXPECT_NEAR(HMM_LenV3(result), 1.0f, 0.001f);
         EXPECT_GT(result.X, 0.0f);
         EXPECT_LT(result.Y, 0.0f);
         EXPECT_GT(result.Z, 0.0f);
     }
     {
-        hmm_vec4 result = HMM_Normalize(v4);
+        HMM_Vec4 result = HMM_Norm(v4);
-        EXPECT_FLOAT_EQ(HMM_LengthVec4(result), 1.0f);
+        EXPECT_NEAR(HMM_LenV4(result), 1.0f, 0.001f);
         EXPECT_GT(result.X, 0.0f);
         EXPECT_LT(result.Y, 0.0f);
         EXPECT_GT(result.Z, 0.0f);
@@ -89,23 +89,23 @@ TEST(VectorOps, Normalize)
 
 TEST(VectorOps, NormalizeZero)
 {
-    hmm_vec2 v2 = HMM_Vec2(0.0f, 0.0f);
+    HMM_Vec2 v2 = HMM_V2(0.0f, 0.0f);
-    hmm_vec3 v3 = HMM_Vec3(0.0f, 0.0f, 0.0f);
+    HMM_Vec3 v3 = HMM_V3(0.0f, 0.0f, 0.0f);
-    hmm_vec4 v4 = HMM_Vec4(0.0f, 0.0f, 0.0f, 0.0f);
+    HMM_Vec4 v4 = HMM_V4(0.0f, 0.0f, 0.0f, 0.0f);
 
     {
-        hmm_vec2 result = HMM_NormalizeVec2(v2);
+        HMM_Vec2 result = HMM_NormV2(v2);
         EXPECT_FLOAT_EQ(result.X, 0.0f);
         EXPECT_FLOAT_EQ(result.Y, 0.0f);
     }
     {
-        hmm_vec3 result = HMM_NormalizeVec3(v3);
+        HMM_Vec3 result = HMM_NormV3(v3);
         EXPECT_FLOAT_EQ(result.X, 0.0f);
         EXPECT_FLOAT_EQ(result.Y, 0.0f);
         EXPECT_FLOAT_EQ(result.Z, 0.0f);
     }
     {
-        hmm_vec4 result = HMM_NormalizeVec4(v4);
+        HMM_Vec4 result = HMM_NormV4(v4);
         EXPECT_FLOAT_EQ(result.X, 0.0f);
         EXPECT_FLOAT_EQ(result.Y, 0.0f);
         EXPECT_FLOAT_EQ(result.Z, 0.0f);
@@ -114,118 +114,18 @@ TEST(VectorOps, NormalizeZero)
 
 #ifdef __cplusplus
     {
-        hmm_vec2 result = HMM_Normalize(v2);
+        HMM_Vec2 result = HMM_Norm(v2);
         EXPECT_FLOAT_EQ(result.X, 0.0f);
         EXPECT_FLOAT_EQ(result.Y, 0.0f);
     }
     {
-        hmm_vec3 result = HMM_Normalize(v3);
+        HMM_Vec3 result = HMM_Norm(v3);
         EXPECT_FLOAT_EQ(result.X, 0.0f);
         EXPECT_FLOAT_EQ(result.Y, 0.0f);
         EXPECT_FLOAT_EQ(result.Z, 0.0f);
     }
     {
-        hmm_vec4 result = HMM_Normalize(v4);
+        HMM_Vec4 result = HMM_Norm(v4);
-        EXPECT_FLOAT_EQ(result.X, 0.0f);
-        EXPECT_FLOAT_EQ(result.Y, 0.0f);
-        EXPECT_FLOAT_EQ(result.Z, 0.0f);
-        EXPECT_FLOAT_EQ(result.W, 0.0f);
-    }
-#endif
-}
-
-TEST(VectorOps, FastNormalize)
-{
-    hmm_vec2 v2 = HMM_Vec2(1.0f, -2.0f);
-    hmm_vec3 v3 = HMM_Vec3(1.0f, -2.0f, 3.0f);
-    hmm_vec4 v4 = HMM_Vec4(1.0f, -2.0f, 3.0f, -1.0f);
-
-    {
-        hmm_vec2 result = HMM_FastNormalizeVec2(v2);
-        EXPECT_NEAR(HMM_LengthVec2(result), 1.0f, 0.001f);
-        EXPECT_GT(result.X, 0.0f);
-        EXPECT_LT(result.Y, 0.0f);
-    }
-    {
-        hmm_vec3 result = HMM_FastNormalizeVec3(v3);
-        EXPECT_NEAR(HMM_LengthVec3(result), 1.0f, 0.001f);
-        EXPECT_GT(result.X, 0.0f);
-        EXPECT_LT(result.Y, 0.0f);
-        EXPECT_GT(result.Z, 0.0f);
-    }
-    {
-        hmm_vec4 result = HMM_FastNormalizeVec4(v4);
-        EXPECT_NEAR(HMM_LengthVec4(result), 1.0f, 0.001f);
-        EXPECT_GT(result.X, 0.0f);
-        EXPECT_LT(result.Y, 0.0f);
-        EXPECT_GT(result.Z, 0.0f);
-        EXPECT_LT(result.W, 0.0f);
-    }
-
-#ifdef __cplusplus
-    {
-        hmm_vec2 result = HMM_FastNormalize(v2);
-        EXPECT_NEAR(HMM_LengthVec2(result), 1.0f, 0.001f);
-        EXPECT_GT(result.X, 0.0f);
-        EXPECT_LT(result.Y, 0.0f);
-    }
-    {
-        hmm_vec3 result = HMM_FastNormalize(v3);
-        EXPECT_NEAR(HMM_LengthVec3(result), 1.0f, 0.001f);
-        EXPECT_GT(result.X, 0.0f);
-        EXPECT_LT(result.Y, 0.0f);
-        EXPECT_GT(result.Z, 0.0f);
-    }
-    {
-        hmm_vec4 result = HMM_FastNormalize(v4);
-        EXPECT_NEAR(HMM_LengthVec4(result), 1.0f, 0.001f);
-        EXPECT_GT(result.X, 0.0f);
-        EXPECT_LT(result.Y, 0.0f);
-        EXPECT_GT(result.Z, 0.0f);
-        EXPECT_LT(result.W, 0.0f);
-    }
-#endif
-}
-
-TEST(VectorOps, FastNormalizeZero)
-{
-    hmm_vec2 v2 = HMM_Vec2(0.0f, 0.0f);
-    hmm_vec3 v3 = HMM_Vec3(0.0f, 0.0f, 0.0f);
-    hmm_vec4 v4 = HMM_Vec4(0.0f, 0.0f, 0.0f, 0.0f);
-
-    {
-        hmm_vec2 result = HMM_FastNormalizeVec2(v2);
-        EXPECT_FLOAT_EQ(result.X, 0.0f);
-        EXPECT_FLOAT_EQ(result.Y, 0.0f);
-    }
-    {
-        hmm_vec3 result = HMM_FastNormalizeVec3(v3);
-        EXPECT_FLOAT_EQ(result.X, 0.0f);
-        EXPECT_FLOAT_EQ(result.Y, 0.0f);
-        EXPECT_FLOAT_EQ(result.Z, 0.0f);
-    }
-    {
-        hmm_vec4 result = HMM_FastNormalizeVec4(v4);
-        EXPECT_FLOAT_EQ(result.X, 0.0f);
-        EXPECT_FLOAT_EQ(result.Y, 0.0f);
-        EXPECT_FLOAT_EQ(result.Z, 0.0f);
-        EXPECT_FLOAT_EQ(result.W, 0.0f);
-    }
-
-#ifdef __cplusplus
-    {
-        hmm_vec2 result = HMM_FastNormalize(v2);
-        EXPECT_FLOAT_EQ(result.X, 0.0f);
-        EXPECT_FLOAT_EQ(result.Y, 0.0f);
-    }
-    {
-        hmm_vec3 result = HMM_FastNormalize(v3);
-        EXPECT_FLOAT_EQ(result.X, 0.0f);
-        EXPECT_FLOAT_EQ(result.Y, 0.0f);
-        EXPECT_FLOAT_EQ(result.Z, 0.0f);
-    }
-    {
-        hmm_vec4 result = HMM_FastNormalize(v4);
         EXPECT_FLOAT_EQ(result.X, 0.0f);
         EXPECT_FLOAT_EQ(result.Y, 0.0f);
         EXPECT_FLOAT_EQ(result.Z, 0.0f);
@@ -236,10 +136,10 @@ TEST(VectorOps, FastNormalizeZero)
 
 TEST(VectorOps, Cross)
 {
-    hmm_vec3 v1 = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v1 = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec3 v2 = HMM_Vec3(4.0f, 5.0f, 6.0f);
+    HMM_Vec3 v2 = HMM_V3(4.0f, 5.0f, 6.0f);
 
-    hmm_vec3 result = HMM_Cross(v1, v2);
+    HMM_Vec3 result = HMM_Cross(v1, v2);
 
     EXPECT_FLOAT_EQ(result.X, -3.0f);
     EXPECT_FLOAT_EQ(result.Y, 6.0f);
@@ -248,10 +148,10 @@ TEST(VectorOps, Cross)
 
 TEST(VectorOps, DotVec2)
 {
-    hmm_vec2 v1 = HMM_Vec2(1.0f, 2.0f);
+    HMM_Vec2 v1 = HMM_V2(1.0f, 2.0f);
-    hmm_vec2 v2 = HMM_Vec2(3.0f, 4.0f);
+    HMM_Vec2 v2 = HMM_V2(3.0f, 4.0f);
 
-    EXPECT_FLOAT_EQ(HMM_DotVec2(v1, v2), 11.0f);
+    EXPECT_FLOAT_EQ(HMM_DotV2(v1, v2), 11.0f);
 #ifdef __cplusplus
     EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 11.0f);
 #endif
@@ -259,10 +159,10 @@ TEST(VectorOps, DotVec2)
 
 TEST(VectorOps, DotVec3)
 {
-    hmm_vec3 v1 = HMM_Vec3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v1 = HMM_V3(1.0f, 2.0f, 3.0f);
-    hmm_vec3 v2 = HMM_Vec3(4.0f, 5.0f, 6.0f);
+    HMM_Vec3 v2 = HMM_V3(4.0f, 5.0f, 6.0f);
 
-    EXPECT_FLOAT_EQ(HMM_DotVec3(v1, v2), 32.0f);
+    EXPECT_FLOAT_EQ(HMM_DotV3(v1, v2), 32.0f);
 #ifdef __cplusplus
     EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 32.0f);
 #endif
@@ -270,23 +170,85 @@ TEST(VectorOps, DotVec3)
 
 TEST(VectorOps, DotVec4)
 {
-    hmm_vec4 v1 = HMM_Vec4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v1 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
-    hmm_vec4 v2 = HMM_Vec4(5.0f, 6.0f, 7.0f, 8.0f);
+    HMM_Vec4 v2 = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
 
-    EXPECT_FLOAT_EQ(HMM_DotVec4(v1, v2), 70.0f);
+    EXPECT_FLOAT_EQ(HMM_DotV4(v1, v2), 70.0f);
 #ifdef __cplusplus
     EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 70.0f);
 #endif
 }
 
+TEST(VectorOps, LerpV2)
+{
+    HMM_Vec2 v1 = HMM_V2(1.0f, 0.0f);
+    HMM_Vec2 v2 = HMM_V2(0.0f, 1.0f);
+
+    {
+        HMM_Vec2 result = HMM_LerpV2(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.5f);
+    }
+#ifdef __cplusplus
+    {
+        HMM_Vec2 result = HMM_Lerp(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.5f);
+    }
+#endif
+}
+
+TEST(VectorOps, LerpV3)
+{
+    HMM_Vec3 v1 = HMM_V3(1.0f, 1.0f, 0.0f);
+    HMM_Vec3 v2 = HMM_V3(0.0f, 1.0f, 1.0f);
+
+    {
+        HMM_Vec3 result = HMM_LerpV3(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.5f);
+    }
+#ifdef __cplusplus
+    {
+        HMM_Vec3 result = HMM_Lerp(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.5f);
+    }
+#endif
+}
+
+TEST(VectorOps, LerpV4)
+{
+    HMM_Vec4 v1 = HMM_V4(1.0f, 1.0f, 0.0f, 1.0f);
+    HMM_Vec4 v2 = HMM_V4(0.0f, 1.0f, 1.0f, 1.0f);
+
+    {
+        HMM_Vec4 result = HMM_LerpV4(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.5f);
+        EXPECT_FLOAT_EQ(result.W, 1.0f);
+    }
+#ifdef __cplusplus
+    {
+        HMM_Vec4 result = HMM_Lerp(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.5f);
+        EXPECT_FLOAT_EQ(result.W, 1.0f);
+    }
+#endif
+}
 
 /*
  * MatrixOps tests
  */
 
-TEST(MatrixOps, Transpose)
+TEST(MatrixOps, TransposeM4)
 {
-    hmm_mat4 m4 = HMM_Mat4(); // will have 1 - 16
+    HMM_Mat4 m4 = HMM_M4(); // will have 1 - 16
 
     // Fill the matrix
     int Counter = 1;
@@ -300,7 +262,7 @@ TEST(MatrixOps, Transpose)
     }
 
     // Test the matrix
-    hmm_mat4 result = HMM_Transpose(m4);
+    HMM_Mat4 result = HMM_TransposeM4(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);

test/hmm_test.h

@@ -9,6 +9,7 @@
 #include "categories/ScalarMath.h"
 #include "categories/Initialization.h"
 #include "categories/VectorOps.h"
+#include "categories/MatrixOps.h"
 #include "categories/QuaternionOps.h"
 #include "categories/Addition.h"
 #include "categories/Subtraction.h"