Test in both C and C++ (#58)

* Switch to custom unit testing that is compatible with C

* Remove Google Test framework

* Attempt to fix missing math functions

* Link against C math library

* Try forcing c99 again

* Include -lm at compile time

* Move -lm argument to the end

* Update README and gitignore

.gitignore

@@ -6,6 +6,7 @@
 *.lo
 *.o
 *.obj
+*.vs
 
 # Precompiled Headers
 *.gch
@@ -31,3 +32,4 @@
 *.out
 *.app
 hmm_test
+hmm_test*

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "externals/googletest"]
-	path = externals/googletest
-	url = https://github.com/google/googletest.git

.travis.yml

@@ -5,4 +5,6 @@ compiler:
 install:
   - cd test
   - make
-script: ./hmm_test
+script:
+  - ./hmm_test_c
+  - ./hmm_test_cpp

CONTRIBUTING.md

@@ -0,0 +1,51 @@
+# Quick style guide
+
+* Put braces on a new line
+* Float literals should have digits both before and after the decimal.
+  ```cpp
+  // Good
+  0.0f;
+  0.5f;
+  1.0f;
+  3.14159f;
+  
+  // Bad
+  1.f
+  .0f
+  ```
+* Put macros and return types on a separate line from the function definition:
+  ```cpp
+  HINLINE float
+  HMM_MyFunction()
+  {
+      // ...
+  }
+  ```
+* Explicitly initialize variables to zero:
+  ```cpp
+  HINLINE float
+  HMM_MyFunction()
+  {
+      float MyFloat = 0.0f;
+      hmm_vec3 MyVector = {0};
+  }
+  ```
+* Put parentheses around the returned value:
+  ```cpp
+  HINLINE float
+  HMM_MyFunction()
+  {
+      return (1.0f);
+  }
+  ```
+
+
+# Other notes
+
+* If a new function is defined with different names for different datatypes, also add C++ overloaded versions of the functions. For example, if you have `HMM_LengthVec2(hmm_vec2)` and `HMM_LengthVec3(hmm_vec3)`, also provide `HMM_Length(hmm_vec2)` and `HMM_Length(hmm_vec3)`.
+
+  It is fine for the overloaded versions to call the C versions.
+* Only use operator overloading for analogous operators in C. That means `+` for vector addition is fine, but no using `^` for cross product or `|` for dot product.
+* Try to define functions in the same order as the prototypes.
+* Don't forget that Handmade Math uses column-major order for matrices!
+

HandmadeMath.h

@@ -1,5 +1,5 @@
 /*
-  HandmadeMath.h v1.0
+  HandmadeMath.h v1.1.2
   
   This is a single header file with a bunch of useful functions for
   basic game math operations.
@@ -79,8 +79,11 @@
      #define HMM_TANF MyTanF
      #define HMM_EXPF MyExpF
      #define HMM_LOGF MyLogF
+     #define HMM_ACOSF MyACosF
+     #define HMM_ATANF MyATanF
+     #define HMM_ATAN2F MYATan2F
      
-  Provide your own implementations of SinF, CosF, TanF, ExpF and LogF
+  Provide your own implementations of SinF, CosF, TanF, ACosF, ATanF, ATan2F, ExpF and LogF 
   in EXACTLY one C or C++ file that includes this header, BEFORE the
   include, like this:     
   
@@ -89,6 +92,9 @@
      #define HMM_TANF MyTanF
      #define HMM_EXPF MyExpF
      #define HMM_LOGF MyLogF
+     #define HMM_ACOSF MyACosF
+     #define HMM_ATANF MyATanF
+     #define HMM_ATAN2F MyATan2F
      #define HANDMADE_MATH_IMPLEMENTATION
      #define HANDMADE_MATH_CPP_MODE
      #include "HandmadeMath.h"
@@ -147,6 +153,28 @@
           (*) Added HMM_NormalizeVec4
      1.0
           (*) Lots of testing!
+     1.1
+          (*) Quaternion support
+          (*) Added type hmm_quaternion
+          (*) Added HMM_Quaternion
+          (*) Added HMM_QuaternionV4
+          (*) Added HMM_AddQuaternion
+          (*) Added HMM_SubtractQuaternion
+          (*) Added HMM_MultiplyQuaternion
+          (*) Added HMM_MultiplyQuaternionF
+          (*) Added HMM_DivideQuaternionF
+          (*) Added HMM_InverseQuaternion
+          (*) Added HMM_DotQuaternion
+          (*) Added HMM_NormalizeQuaternion
+          (*) Added HMM_Slerp
+          (*) Added HMM_QuaternionToMat4
+          (*) Added HMM_QuaternionFromAxisAngle
+     1.1.1
+          (*) Resolved compiler warnings on gcc and g++
+     1.1.2
+          (*) Fixed invalid HMMDEF's in the function definitions
+     1.1.3
+          (*) Fixed compile error in C mode
           
   LICENSE
   
@@ -164,6 +192,7 @@
    FieryDrake (@fierydrake)
    Gingerbill (@TheGingerBill)
    Ben Visness (@bvisness) 
+   Trinton Bullard (@Peliex_Dev)
    
   Fixes:
    Jeroen van Rijn (@J_vanRijn)
@@ -171,7 +200,9 @@
    Insofaras (@insofaras)
 */
 
+#ifndef HANDMADE_NO_SSE
 #include <xmmintrin.h>
+#endif
 
 #ifndef HANDMADE_MATH_H
 #define HANDMADE_MATH_H
@@ -180,7 +211,8 @@
 #pragma warning(disable:4201)
 #endif
 
-#ifdef __GNUC__
+#ifdef __clang__
+#pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wgnu-anonymous-struct"
 #endif
 
@@ -189,7 +221,7 @@ extern "C"
 {
 #endif
 
-#ifdef HANDMADEMATH_STATIC
+#ifdef HANDMADE_MATH_STATIC
 #define HMMDEF static
 #else
 #define HMMDEF extern
@@ -204,7 +236,8 @@ extern "C"
 #endif
 
 #if !defined(HMM_SINF) || !defined(HMM_COSF) || !defined(HMM_TANF) || \
-    !defined(HMM_EXPF) || !defined(HMM_LOGF)
+    !defined(HMM_EXPF) || !defined(HMM_LOGF) || !defined(HMM_ACOSF) || \
+    !defined(HMM_ATANF)|| !defined(HMM_ATAN2F)
 #include <math.h>    
 #endif
     
@@ -228,12 +261,24 @@ extern "C"
 #define HMM_LOGF logf
 #endif
 
+#ifndef HMM_ACOSF
+#define HMM_ACOSF acosf
+#endif
+
+#ifndef HMM_ATANF
+#define HMM_ATANF atanf
+#endif
+
+#ifndef HMM_ATAN2F
+#define HMM_ATAN2F atan2f
+#endif
+
 #define HMM_PI32 3.14159265359f
 #define HMM_PI 3.14159265358979323846
 
 #define HMM_MIN(a, b) (a) > (b) ? (b) : (a)
 #define HMM_MAX(a, b) (a) < (b) ? (b) : (a)
-#define HMN_ABS(a) (a) < 0 ? -(a) : (a)
+#define HMM_ABS(a) ((a) > 0 ? (a) : -(a))
 #define HMM_MOD(a, m) ((a) % (m)) >= 0 ? ((a) % (m)) : (((a) % (m)) + (m))
 #define HMM_SQUARE(x) ((x) * (x))
 
@@ -359,6 +404,25 @@ typedef union hmm_mat4
     float Elements[4][4];
 } hmm_mat4;
 
+typedef union hmm_quaternion
+{
+    struct
+    {
+        union
+        {
+            hmm_vec3 XYZ;
+            struct
+            {
+                float X, Y, Z;
+            };
+        };
+        
+        float W;
+    };
+    
+    float Elements[4];
+} hmm_quaternion;
+
 typedef hmm_vec2 hmm_v2;
 typedef hmm_vec3 hmm_v3;
 typedef hmm_vec4 hmm_v4;
@@ -366,7 +430,10 @@ typedef hmm_mat4 hmm_m4;
 
 HMMDEF float HMM_SinF(float Angle);
 HMMDEF float HMM_TanF(float Angle);
+HMMDEF float HMM_ATanF(float Theta);
+HMMDEF float HMM_ATan2F(float Theta, float Theta2);
 HMMDEF float HMM_CosF(float Angle);
+HMMDEF float HMM_ACosF(float Theta);
 HMMDEF float HMM_ExpF(float Float);
 HMMDEF float HMM_LogF(float Float);
 
@@ -397,8 +464,8 @@ HMMDEF float HMM_DotVec4(hmm_vec4 VecOne, hmm_vec4 VecTwo);
 
 HMMDEF hmm_vec3 HMM_Cross(hmm_vec3 VecOne, hmm_vec3 VecTwo);
 
-HMMDEF hmm_vec2 HMM_Vec2i(int X, int Y);
 HMMDEF hmm_vec2 HMM_Vec2(float X, float Y);
+HMMDEF hmm_vec2 HMM_Vec2i(int X, int Y);
 HMMDEF hmm_vec3 HMM_Vec3(float X, float Y, float Z);
 HMMDEF hmm_vec3 HMM_Vec3i(int X, int Y, int Z);
 HMMDEF hmm_vec4 HMM_Vec4(float X, float Y, float Z, float W);
@@ -447,6 +514,21 @@ HMMDEF hmm_mat4 HMM_Scale(hmm_vec3 Scale);
 
 HMMDEF hmm_mat4 HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up);
 
+HMMDEF hmm_quaternion HMM_Quaternion(float X, float Y, float Z, float W);
+HMMDEF hmm_quaternion HMM_QuaternionV4(hmm_vec4 Vector);
+HMMDEF hmm_quaternion HMM_AddQuaternion(hmm_quaternion Left, hmm_quaternion Right);
+HMMDEF hmm_quaternion HMM_SubtractQuaternion(hmm_quaternion Left, hmm_quaternion Right);
+HMMDEF hmm_quaternion HMM_MultiplyQuaternion(hmm_quaternion Left, hmm_quaternion Right);
+HMMDEF hmm_quaternion HMM_MultiplyQuaternionF(hmm_quaternion Left, float Multiplicative);
+HMMDEF hmm_quaternion HMM_DivideQuaternionF(hmm_quaternion Left, float Dividend);
+HMMDEF hmm_quaternion HMM_InverseQuaternion(hmm_quaternion Left);
+HMMDEF float HMM_DotQuaternion(hmm_quaternion Left, hmm_quaternion Right);
+HMMDEF hmm_quaternion HMM_NormalizeQuaternion(hmm_quaternion Left);
+HMMDEF hmm_quaternion HMM_NLerp(hmm_quaternion Left, float Time, hmm_quaternion Right);
+HMMDEF hmm_quaternion HMM_Slerp(hmm_quaternion Left, float Time, hmm_quaternion Right);
+HMMDEF hmm_mat4 HMM_QuaternionToMat4(hmm_quaternion Left);
+HMMDEF hmm_quaternion HMM_QuaternionFromAxisAngle(hmm_vec3 Axis, float AngleOfRotation);
+
 #ifdef __cplusplus
 }
 #endif
@@ -464,20 +546,24 @@ HMMDEF float HMM_LengthSquared(hmm_vec4 A);
 HMMDEF hmm_vec2 HMM_Normalize(hmm_vec2 A);
 HMMDEF hmm_vec3 HMM_Normalize(hmm_vec3 A);
 HMMDEF hmm_vec4 HMM_Normalize(hmm_vec4 A);
+HMMDEF hmm_quaternion HMM_Normalize(hmm_quaternion A);
 
 HMMDEF float HMM_Dot(hmm_vec2 VecOne, hmm_vec2 VecTwo);
 HMMDEF float HMM_Dot(hmm_vec3 VecOne, hmm_vec3 VecTwo);
 HMMDEF float HMM_Dot(hmm_vec4 VecOne, hmm_vec4 VecTwo);
+HMMDEF float HMM_Dot(hmm_quaternion QuatOne, hmm_quaternion QuatTwo);
 
 HMMDEF hmm_vec2 HMM_Add(hmm_vec2 Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 HMM_Add(hmm_vec3 Left, hmm_vec3 Right);
 HMMDEF hmm_vec4 HMM_Add(hmm_vec4 Left, hmm_vec4 Right);
 HMMDEF hmm_mat4 HMM_Add(hmm_mat4 Left, hmm_mat4 Right);
+HMMDEF hmm_quaternion HMM_Add(hmm_quaternion Left, hmm_quaternion Right);
 
 HMMDEF hmm_vec2 HMM_Subtract(hmm_vec2 Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 HMM_Subtract(hmm_vec3 Left, hmm_vec3 Right);
 HMMDEF hmm_vec4 HMM_Subtract(hmm_vec4 Left, hmm_vec4 Right);
 HMMDEF hmm_mat4 HMM_Subtract(hmm_mat4 Left, hmm_mat4 Right);
+HMMDEF hmm_quaternion HMM_Subtract(hmm_quaternion Left, hmm_quaternion Right);
 
 HMMDEF hmm_vec2 HMM_Multiply(hmm_vec2 Left, hmm_vec2 Right);
 HMMDEF hmm_vec2 HMM_Multiply(hmm_vec2 Left, float Right);
@@ -488,6 +574,8 @@ HMMDEF hmm_vec4 HMM_Multiply(hmm_vec4 Left, float Right);
 HMMDEF hmm_mat4 HMM_Multiply(hmm_mat4 Left, hmm_mat4 Right);
 HMMDEF hmm_mat4 HMM_Multiply(hmm_mat4 Left, float Right);
 HMMDEF hmm_vec4 HMM_Multiply(hmm_mat4 Matrix, hmm_vec4 Vector);
+HMMDEF hmm_quaternion HMM_Multiply(hmm_quaternion Left, hmm_quaternion Right);
+HMMDEF hmm_quaternion HMM_Multiply(hmm_quaternion Left, float Right);
 
 HMMDEF hmm_vec2 HMM_Divide(hmm_vec2 Left, hmm_vec2 Right);
 HMMDEF hmm_vec2 HMM_Divide(hmm_vec2 Left, float Right);
@@ -496,31 +584,38 @@ HMMDEF hmm_vec3 HMM_Divide(hmm_vec3 Left, float Right);
 HMMDEF hmm_vec4 HMM_Divide(hmm_vec4 Left, hmm_vec4 Right);
 HMMDEF hmm_vec4 HMM_Divide(hmm_vec4 Left, float Right);
 HMMDEF hmm_mat4 HMM_Divide(hmm_mat4 Left, float Right);
+HMMDEF hmm_quaternion HMM_Divide(hmm_quaternion Left, hmm_quaternion Right);
+HMMDEF hmm_quaternion HMM_Divide(hmm_quaternion Left, float Right);
 
 HMMDEF hmm_vec2 operator+(hmm_vec2 Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 operator+(hmm_vec3 Left, hmm_vec3 Right);
 HMMDEF hmm_vec4 operator+(hmm_vec4 Left, hmm_vec4 Right);
 HMMDEF hmm_mat4 operator+(hmm_mat4 Left, hmm_mat4 Right);
+HMMDEF hmm_quaternion operator+(hmm_quaternion Left, hmm_quaternion Right);
 
 HMMDEF hmm_vec2 operator-(hmm_vec2 Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 operator-(hmm_vec3 Left, hmm_vec3 Right);
 HMMDEF hmm_vec4 operator-(hmm_vec4 Left, hmm_vec4 Right);
 HMMDEF hmm_mat4 operator-(hmm_mat4 Left, hmm_mat4 Right);
+HMMDEF hmm_quaternion operator-(hmm_quaternion Left, hmm_quaternion Right);
 
 HMMDEF hmm_vec2 operator*(hmm_vec2 Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 operator*(hmm_vec3 Left, hmm_vec3 Right);
 HMMDEF hmm_vec4 operator*(hmm_vec4 Left, hmm_vec4 Right);
 HMMDEF hmm_mat4 operator*(hmm_mat4 Left, hmm_mat4 Right);
+HMMDEF hmm_quaternion operator*(hmm_quaternion Left, hmm_quaternion Right);
 
 HMMDEF hmm_vec2 operator*(hmm_vec2 Left, float Right);
 HMMDEF hmm_vec3 operator*(hmm_vec3 Left, float Right);
 HMMDEF hmm_vec4 operator*(hmm_vec4 Left, float Right);
 HMMDEF hmm_mat4 operator*(hmm_mat4 Left, float Right);
+HMMDEF hmm_quaternion operator*(hmm_quaternion Left, float Right);
 
 HMMDEF hmm_vec2 operator*(float Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 operator*(float Left, hmm_vec3 Right);
 HMMDEF hmm_vec4 operator*(float Left, hmm_vec4 Right);
 HMMDEF hmm_mat4 operator*(float Left, hmm_mat4 Right);
+HMMDEF hmm_quaternion operator*(float Left, hmm_quaternion Right);
 
 HMMDEF hmm_vec4 operator*(hmm_mat4 Matrix, hmm_vec4 Vector);
 
@@ -532,16 +627,19 @@ HMMDEF hmm_vec2 operator/(hmm_vec2 Left, float Right);
 HMMDEF hmm_vec3 operator/(hmm_vec3 Left, float Right);
 HMMDEF hmm_vec4 operator/(hmm_vec4 Left, float Right);
 HMMDEF hmm_mat4 operator/(hmm_mat4 Left, float Right);
+HMMDEF hmm_quaternion operator/(hmm_quaternion Left, float Right);
 
 HMMDEF hmm_vec2 &operator+=(hmm_vec2 &Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 &operator+=(hmm_vec3 &Left, hmm_vec3 Right);
 HMMDEF hmm_vec4 &operator+=(hmm_vec4 &Left, hmm_vec4 Right);
 HMMDEF hmm_mat4 &operator+=(hmm_mat4 &Left, hmm_mat4 Right);
+HMMDEF hmm_quaternion &operator+=(hmm_quaternion &Left, hmm_quaternion Right);
 
 HMMDEF hmm_vec2 &operator-=(hmm_vec2 &Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 &operator-=(hmm_vec3 &Left, hmm_vec3 Right);
 HMMDEF hmm_vec4 &operator-=(hmm_vec4 &Left, hmm_vec4 Right);
 HMMDEF hmm_mat4 &operator-=(hmm_mat4 &Left, hmm_mat4 Right);
+HMMDEF hmm_quaternion &operator-=(hmm_quaternion &Left, hmm_quaternion Right);
 
 HMMDEF hmm_vec2 &operator*=(hmm_vec2 &Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 &operator*=(hmm_vec3 &Left, hmm_vec3 Right);
@@ -551,6 +649,7 @@ HMMDEF hmm_vec2 &operator*=(hmm_vec2 &Left, float Right);
 HMMDEF hmm_vec3 &operator*=(hmm_vec3 &Left, float Right);
 HMMDEF hmm_vec4 &operator*=(hmm_vec4 &Left, float Right);
 HMMDEF hmm_mat4 &operator*=(hmm_mat4 &Left, float Right);
+HMMDEF hmm_quaternion &operator*=(hmm_quaternion &Left, float Right);
 
 HMMDEF hmm_vec2 &operator/=(hmm_vec2 &Left, hmm_vec2 Right);
 HMMDEF hmm_vec3 &operator/=(hmm_vec3 &Left, hmm_vec3 Right);
@@ -560,9 +659,14 @@ HMMDEF hmm_vec2 &operator/=(hmm_vec2 &Left, float Right);
 HMMDEF hmm_vec3 &operator/=(hmm_vec3 &Left, float Right);
 HMMDEF hmm_vec4 &operator/=(hmm_vec4 &Left, float Right);
 HMMDEF hmm_mat4 &operator/=(hmm_mat4 &Left, float Right);
+HMMDEF hmm_quaternion &operator/=(hmm_quaternion &Left, float Right);
 
 #endif /* HANDMADE_MATH_CPP */
 
+#ifdef __clang__
+#pragma GCC diagnostic pop
+#endif
+
 #endif /* HANDMADE_MATH_H */
 
 #ifdef HANDMADE_MATH_IMPLEMENTATION
@@ -594,6 +698,33 @@ HMM_TanF(float Radians)
     return (Result);
 }
 
+HINLINE float
+HMM_ACosF(float Radians)
+{
+    float Result = 0.0f;
+
+    Result = HMM_ACOSF(Radians);
+    return (Result);
+}
+
+HINLINE float
+HMM_ATanF(float Radians)
+{
+    float Result = 0.0f;
+
+    Result = HMM_ATANF(Radians);
+    return (Result);
+}
+
+HINLINE float
+HMM_Atan2F(float Left, float Right)
+{
+    float Result = 0.0f;
+
+    Result = HMM_ATAN2F(Left, Right);
+    return (Result);
+}
+
 HINLINE float
 HMM_ExpF(float Float)
 {
@@ -1205,7 +1336,7 @@ HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right)
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right)
 {
     hmm_mat4 Result = HMM_Mat4();
@@ -1230,7 +1361,7 @@ HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right)
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar)
 {
     hmm_mat4 Result = HMM_Mat4();
@@ -1248,7 +1379,7 @@ HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar)
     return (Result);
 }
 
-hmm_vec4
+HINLINE hmm_vec4
 HMM_MultiplyMat4ByVec4(hmm_mat4 Matrix, hmm_vec4 Vector)
 {
     hmm_vec4 Result = {0};
@@ -1268,7 +1399,7 @@ HMM_MultiplyMat4ByVec4(hmm_mat4 Matrix, hmm_vec4 Vector)
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar)
 {
     hmm_mat4 Result = HMM_Mat4();
@@ -1286,7 +1417,7 @@ HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar)
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_Transpose(hmm_mat4 Matrix)
 {
     hmm_mat4 Result = HMM_Mat4();
@@ -1304,7 +1435,7 @@ HMM_Transpose(hmm_mat4 Matrix)
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far)
 {
     hmm_mat4 Result = HMM_Mat4d(1.0f);
@@ -1320,7 +1451,7 @@ HMM_Orthographic(float Left, float Right, float Bottom, float Top, float Near, f
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_Perspective(float FOV, float AspectRatio, float Near, float Far)
 {
     hmm_mat4 Result = HMM_Mat4d(1.0f);
@@ -1337,7 +1468,7 @@ HMM_Perspective(float FOV, float AspectRatio, float Near, float Far)
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_Translate(hmm_vec3 Translation)
 {
     hmm_mat4 Result = HMM_Mat4d(1.0f);
@@ -1349,7 +1480,7 @@ HMM_Translate(hmm_vec3 Translation)
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_Rotate(float Angle, hmm_vec3 Axis)
 {
     hmm_mat4 Result = HMM_Mat4d(1.0f);
@@ -1375,7 +1506,7 @@ HMM_Rotate(float Angle, hmm_vec3 Axis)
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_Scale(hmm_vec3 Scale)
 {
     hmm_mat4 Result = HMM_Mat4d(1.0f);
@@ -1387,7 +1518,7 @@ HMM_Scale(hmm_vec3 Scale)
     return (Result);
 }
 
-hmm_mat4
+HINLINE hmm_mat4
 HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up)
 {
     hmm_mat4 Result = {0};
@@ -1416,9 +1547,239 @@ HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up)
     return (Result);
 }
 
+
+HINLINE hmm_quaternion 
+HMM_Quaternion(float X, float Y, float Z, float W)
+{
+    hmm_quaternion Result = {0};
+    
+    Result.X = X;
+    Result.Y = Y;
+    Result.Z = Z;
+    Result.W = W;
+    
+    return(Result);
+}
+
+HINLINE hmm_quaternion 
+HMM_QuaternionV4(hmm_vec4 Vector)
+{
+    hmm_quaternion Result = {0};
+    
+    Result.X = Vector.X;
+    Result.Y = Vector.Y;
+    Result.Z = Vector.Z;
+    Result.W = Vector.W;
+    
+    return(Result);    
+}
+
+HINLINE hmm_quaternion
+HMM_AddQuaternion(hmm_quaternion Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result.X = Left.X + Right.X;
+    Result.Y = Left.Y + Right.Y;
+    Result.Z = Left.Z + Right.Z;
+    Result.W = Left.W + Right.W;
+
+    return(Result);
+}
+
+HINLINE hmm_quaternion
+HMM_SubtractQuaternion(hmm_quaternion Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result.X = Left.X - Right.X;
+    Result.Y = Left.Y - Right.Y;
+    Result.Z = Left.Z - Right.Z;
+    Result.W = Left.W - Right.W;
+
+    return(Result);
+}
+
+HINLINE hmm_quaternion
+HMM_MultiplyQuaternion(hmm_quaternion Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result.X = (Left.X * Right.W) + (Left.Y * Right.Z) - (Left.Z * Right.Y) + (Left.W * Right.X);
+    Result.Y = (-Left.X * Right.Z) + (Left.Y * Right.W) + (Left.Z * Right.X) + (Left.W * Right.Y);
+    Result.Z = (Left.X * Right.Y) - (Left.Y * Right.X) + (Left.Z * Right.W) + (Left.W * Right.Z);
+    Result.W = (-Left.X * Right.X) - (Left.Y * Right.Y) - (Left.Z * Right.Z) + (Left.W * Right.W);
+
+    return(Result);
+}
+
+HINLINE hmm_quaternion
+HMM_MultiplyQuaternionF(hmm_quaternion Left, float Multiplicative)
+{
+    hmm_quaternion Result = {0};
+
+    Result.X = Left.X * Multiplicative;
+    Result.Y = Left.Y * Multiplicative;
+    Result.Z = Left.Z * Multiplicative;
+    Result.W = Left.W * Multiplicative;
+
+    return(Result);
+}
+
+HINLINE hmm_quaternion
+HMM_DivideQuaternionF(hmm_quaternion Left, float Dividend)
+{
+    hmm_quaternion Result = {0};
+
+    Result.X = Left.X / Dividend;
+    Result.Y = Left.Y / Dividend;
+    Result.Z = Left.Z / Dividend;
+    Result.W = Left.W / Dividend;
+
+    return(Result);
+}
+
+HINLINE hmm_quaternion
+HMM_InverseQuaternion(hmm_quaternion Left)
+{
+    hmm_quaternion Conjugate = {0};
+    hmm_quaternion Result = {0};
+    float Norm = 0;
+    float NormSquared = 0;
+
+    Conjugate.X = -Left.X;
+    Conjugate.Y = -Left.Y;
+    Conjugate.Z = -Left.Z;
+    Conjugate.W = Left.W;
+
+    Norm = HMM_SquareRootF(HMM_DotQuaternion(Left, Left));
+    NormSquared = Norm * Norm;
+
+    Result.X = Conjugate.X / NormSquared;
+    Result.Y = Conjugate.Y / NormSquared;
+    Result.Z = Conjugate.Z / NormSquared;
+    Result.W = Conjugate.W / NormSquared;
+
+    return(Result);
+}
+
+HINLINE float
+HMM_DotQuaternion(hmm_quaternion Left, hmm_quaternion Right)
+{
+    float Result = 0.0f;
+
+    Result = (Left.X * Right.X) + (Left.Y * Right.Y) + (Left.Z * Right.Z) + (Left.W * Right.W);
+
+    return(Result);
+}
+
+HINLINE hmm_quaternion
+HMM_NormalizeQuaternion(hmm_quaternion Left)
+{
+    hmm_quaternion Result = {0};
+
+    float Length = HMM_SquareRootF(HMM_DotQuaternion(Left, Left));
+    Result = HMM_DivideQuaternionF(Left, Length);
+
+    return(Result);
+}
+
+HINLINE hmm_quaternion
+HMM_NLerp(hmm_quaternion Left, float Time, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result.X = HMM_Lerp(Left.X, Time, Right.X);
+    Result.Y = HMM_Lerp(Left.Y, Time, Right.Y);
+    Result.Z = HMM_Lerp(Left.Z, Time, Right.Z);
+    Result.W = HMM_Lerp(Left.W, Time, Right.W);
+
+    Result = HMM_NormalizeQuaternion(Result);
+
+    return(Result);
+}
+
+HINLINE hmm_quaternion
+HMM_Slerp(hmm_quaternion Left, float Time, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+    hmm_quaternion QuaternionLeft = {0};
+    hmm_quaternion QuaternionRight = {0};
+
+    float Cos_Theta = HMM_DotQuaternion(Left, Right);
+    float Angle = HMM_ACosF(Cos_Theta);
+    
+    float S1 = HMM_SinF((1.0f - Time) * Angle);
+    float S2 = HMM_SinF(Time * Angle);
+    float Is = 1.0f / HMM_SinF(Angle);
+
+    QuaternionLeft = HMM_MultiplyQuaternionF(Left, S1);
+    QuaternionRight = HMM_MultiplyQuaternionF(Right, S2);
+
+    Result = HMM_AddQuaternion(QuaternionLeft, QuaternionRight);
+    Result = HMM_MultiplyQuaternionF(Result, Is);
+
+    return(Result);
+}
+
+HINLINE hmm_mat4
+HMM_QuaternionToMat4(hmm_quaternion Left)
+{
+    hmm_mat4 Result = {0};
+    Result = HMM_Mat4d(1);
+
+    hmm_quaternion NormalizedQuaternion = HMM_NormalizeQuaternion(Left);
+    
+    float XX, YY, ZZ,
+          XY, XZ, YZ,
+          WX, WY, WZ;
+
+    XX = NormalizedQuaternion.X * NormalizedQuaternion.X;
+    YY = NormalizedQuaternion.Y * NormalizedQuaternion.Y;
+    ZZ = NormalizedQuaternion.Z * NormalizedQuaternion.Z;
+    XY = NormalizedQuaternion.X * NormalizedQuaternion.Y;
+    XZ = NormalizedQuaternion.X * NormalizedQuaternion.Z;
+    YZ = NormalizedQuaternion.Y * NormalizedQuaternion.Z;
+    WX = NormalizedQuaternion.W * NormalizedQuaternion.X;
+    WY = NormalizedQuaternion.W * NormalizedQuaternion.Y;
+    WZ = NormalizedQuaternion.W * NormalizedQuaternion.Z;
+
+    Result.Elements[0][0] = 1.0f - 2.0f * (YY + ZZ);
+    Result.Elements[0][1] = 2.0f * (XY + WZ);
+    Result.Elements[0][2] = 2.0f * (XZ - WY);
+
+    Result.Elements[1][0] = 2.0f * (XY - WZ);
+    Result.Elements[1][1] = 1.0f - 2.0f * (XX + ZZ);
+    Result.Elements[1][2] = 2.0f * (YZ + WX);
+
+    Result.Elements[2][0] = 2.0f * (XZ + WY);
+    Result.Elements[2][1] = 2.0f * (YZ - WX);
+    Result.Elements[2][2] = 1.0f - 2.0f * (XX + YY);
+
+    return(Result);
+}
+
+HINLINE hmm_quaternion
+HMM_QuaternionFromAxisAngle(hmm_vec3 Axis, float AngleOfRotation)
+{
+    hmm_quaternion Result = {0};
+    float AxisNorm = 0;
+    float SineOfRotation = 0;
+    hmm_vec3 RotatedVector = {0};
+
+    AxisNorm = HMM_SquareRootF(HMM_DotVec3(Axis, Axis));
+    SineOfRotation = HMM_SinF(AngleOfRotation / 2.0f);
+    RotatedVector = HMM_MultiplyVec3f(Axis, SineOfRotation);
+
+    Result.W = HMM_CosF(AngleOfRotation / 2.0f);
+    Result.XYZ = HMM_DivideVec3f(RotatedVector, AxisNorm);
+
+    return(Result);
+}
+
 #ifdef HANDMADE_MATH_CPP_MODE
 
-HMMDEF float 
+HINLINE float 
 HMM_Length(hmm_vec2 A)
 {
     float Result = 0.0f;
@@ -1428,7 +1789,7 @@ HMM_Length(hmm_vec2 A)
     return(Result);
 }
 
-HMMDEF float 
+HINLINE float 
 HMM_Length(hmm_vec3 A)
 {
     float Result = 0.0f;
@@ -1438,7 +1799,7 @@ HMM_Length(hmm_vec3 A)
     return(Result);
 }
 
-HMMDEF float 
+HINLINE float 
 HMM_Length(hmm_vec4 A)
 {
     float Result = 0.0f;
@@ -1508,6 +1869,16 @@ HMM_Normalize(hmm_vec4 A)
     return(Result);
 }
 
+HINLINE hmm_quaternion
+HMM_Normalize(hmm_quaternion A)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_NormalizeQuaternion(A);
+
+    return(Result);
+}
+
 HINLINE float 
 HMM_Dot(hmm_vec2 VecOne, hmm_vec2 VecTwo)
 {
@@ -1538,6 +1909,16 @@ HMM_Dot(hmm_vec4 VecOne, hmm_vec4 VecTwo)
     return(Result);
 }
 
+HINLINE float
+HMM_Dot(hmm_quaternion QuatOne, hmm_quaternion QuatTwo)
+{
+    float Result = 0;
+
+    Result = HMM_DotQuaternion(QuatOne, QuatTwo);
+
+    return(Result);
+}
+
 HINLINE hmm_vec2
 HMM_Add(hmm_vec2 Left, hmm_vec2 Right)
 {
@@ -1556,7 +1937,7 @@ HMM_Add(hmm_vec3 Left, hmm_vec3 Right)
     return (Result);
 }
 
-HMMDEF HINLINE hmm_vec4
+HINLINE hmm_vec4
 HMM_Add(hmm_vec4 Left, hmm_vec4 Right)
 {
     hmm_vec4 Result = {0};
@@ -1574,6 +1955,15 @@ HMM_Add(hmm_mat4 Left, hmm_mat4 Right)
     return (Result);
 }
 
+HINLINE hmm_quaternion
+HMM_Add(hmm_quaternion Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_AddQuaternion(Left, Right);
+    return(Result);
+}
+
 HINLINE hmm_vec2
 HMM_Subtract(hmm_vec2 Left, hmm_vec2 Right)
 {
@@ -1610,6 +2000,15 @@ HMM_Subtract(hmm_mat4 Left, hmm_mat4 Right)
     return (Result);
 }
 
+HINLINE hmm_quaternion
+HMM_Subtract(hmm_quaternion Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_SubtractQuaternion(Left, Right);
+    return (Result);
+}
+
 HINLINE hmm_vec2
 HMM_Multiply(hmm_vec2 Left, hmm_vec2 Right)
 {
@@ -1691,6 +2090,33 @@ HMM_Multiply(hmm_mat4 Matrix, hmm_vec4 Vector)
     return (Result);
 }
 
+HINLINE hmm_quaternion
+HMM_Multiply(hmm_quaternion Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_MultiplyQuaternion(Left, Right);
+    return (Result);
+}
+
+HINLINE hmm_quaternion
+HMM_Multiply(hmm_quaternion Left, float Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_MultiplyQuaternionF(Left, Right);
+    return (Result);
+}
+
+HINLINE hmm_quaternion
+HMM_Multiply(float Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_MultiplyQuaternionF(Right, Left);
+    return (Result);
+}
+
 HINLINE hmm_vec2
 HMM_Divide(hmm_vec2 Left, hmm_vec2 Right)
 {
@@ -1754,6 +2180,15 @@ HMM_Divide(hmm_mat4 Left, float Right)
     return (Result);
 }
 
+HINLINE hmm_quaternion
+HMM_Divide(hmm_quaternion Left, float Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_DivideQuaternionF(Left, Right);
+    return (Result);
+}
+
 HINLINE hmm_vec2
 operator+(hmm_vec2 Left, hmm_vec2 Right)
 {
@@ -1790,6 +2225,15 @@ operator+(hmm_mat4 Left, hmm_mat4 Right)
     return (Result);
 }
 
+HINLINE hmm_quaternion
+operator+(hmm_quaternion Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_Add(Left, Right);
+    return (Result);
+}
+
 HINLINE hmm_vec2
 operator-(hmm_vec2 Left, hmm_vec2 Right)
 {
@@ -1826,6 +2270,15 @@ operator-(hmm_mat4 Left, hmm_mat4 Right)
     return (Result);
 }
 
+HINLINE hmm_quaternion
+operator-(hmm_quaternion Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_Subtract(Left, Right);
+    return (Result);
+}
+
 HINLINE hmm_vec2
 operator*(hmm_vec2 Left, hmm_vec2 Right)
 {
@@ -1942,6 +2395,33 @@ operator*(hmm_mat4 Matrix, hmm_vec4 Vector)
     return (Result);
 }
 
+HINLINE hmm_quaternion
+operator*(hmm_quaternion Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_Multiply(Left, Right);
+    return (Result);
+}
+
+HINLINE hmm_quaternion
+operator*(hmm_quaternion Left, float Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_Multiply(Left, Right);
+    return (Result);
+}
+
+HINLINE hmm_quaternion
+operator*(float Left, hmm_quaternion Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_Multiply(Right, Left);
+    return (Result);
+}
+
 HINLINE hmm_vec2
 operator/(hmm_vec2 Left, hmm_vec2 Right)
 {
@@ -1954,7 +2434,9 @@ operator/(hmm_vec2 Left, hmm_vec2 Right)
 HINLINE hmm_vec3
 operator/(hmm_vec3 Left, hmm_vec3 Right)
 {
-    hmm_vec3 Result = HMM_Divide(Left, Right);
+    hmm_vec3 Result = {0};
+    
+    Result = HMM_Divide(Left, Right);
 
     return (Result);
 }
@@ -2004,6 +2486,15 @@ operator/(hmm_mat4 Left, float Right)
     return (Result);
 }
 
+HINLINE hmm_quaternion
+operator/(hmm_quaternion Left, float Right)
+{
+    hmm_quaternion Result = {0};
+
+    Result = HMM_Divide(Left, Right);
+    return (Result);
+}
+
 HINLINE hmm_vec2 &
 operator+=(hmm_vec2 &Left, hmm_vec2 Right)
 {    
@@ -2028,6 +2519,12 @@ operator+=(hmm_mat4 &Left, hmm_mat4 Right)
     return (Left = Left + Right);
 }
 
+HINLINE hmm_quaternion &
+operator+=(hmm_quaternion &Left, hmm_quaternion Right)
+{
+    return (Left = Left + Right);
+}
+
 HINLINE hmm_vec2 &
 operator-=(hmm_vec2 &Left, hmm_vec2 Right)
 {    
@@ -2052,6 +2549,12 @@ operator-=(hmm_mat4 &Left, hmm_mat4 Right)
     return (Left = Left - Right);
 }
 
+HINLINE hmm_quaternion &
+operator-=(hmm_quaternion &Left, hmm_quaternion Right)
+{
+    return (Left = Left - Right);
+}
+
 HINLINE hmm_vec2 &
 operator/=(hmm_vec2 &Left, hmm_vec2 Right)
 {    
@@ -2094,6 +2597,12 @@ operator/=(hmm_mat4 &Left, float Right)
     return (Left = Left / Right);
 }
 
+HINLINE hmm_quaternion &
+operator/=(hmm_quaternion &Left, float Right)
+{
+    return (Left = Left / Right);
+}
+
 HINLINE hmm_vec2 &
 operator*=(hmm_vec2 &Left, hmm_vec2 Right)
 {    
@@ -2136,6 +2645,12 @@ operator*=(hmm_mat4 &Left, float Right)
     return (Left = Left * Right);
 }
 
+HINLINE hmm_quaternion &
+operator*=(hmm_quaternion &Left, float Right)
+{
+    return (Left = Left * Right);
+}
+
 #endif /* HANDMADE_MATH_CPP_MODE */
 
-#endif /* HANDMADE_MATH_IMPLEMENTATION */
+#endif /* HANDMADE_MATH_IMPLEMENTATION */

README.md

@@ -12,6 +12,10 @@ _This library is free and will stay free, but if you would like to support devel
 
 Version         | Changes        | 
 ----------------|----------------|
+**1.1.3** | Fixed compile error in C mode
+**1.1.2** | Fixed invalid HMMDEF's in the function definitions
+**1.1.1** | Resolved compiler warnings on gcc and g++
+**1.1**   | Quaternions! |
 **1.0**   | Lots of testing |
 **0.7**   | Added HMM_Vec2, and HMM_Vec4 versions of  HMM_LengthSquared, HMM_Length, and HMM_Normalize.   |
 **0.6**   | Made HMM_Power faster, Fixed possible efficiency problem with HMM_Normalize, RENAMED HMM_LengthSquareRoot to HMM_LengthSquared, RENAMED HMM_RSqrtF to HMM_RSquareRootF, RENAMED HMM_SqrtF to HMM_SquareRootF, REMOVED Inner function (user should use Dot now), REMOVED HMM_FastInverseSquareRoot function declaration |
@@ -32,7 +36,7 @@ _This library is free and will stay free, but if you would like to support devel
 
 **What's the license?**
 
-This library is in the public domain. You can do whatever you want with them.
+This library is in the public domain. You can do whatever you want with it.
 
 **Where can I contact you to ask questions?**
 

test/HandmadeMath.c

@@ -0,0 +1,4 @@
+
+#define HANDMADE_MATH_IMPLEMENTATION
+#define HANDMADE_MATH_NO_INLINE
+#include "../HandmadeMath.h"

test/HandmadeTest.h

@@ -0,0 +1,80 @@
+#ifndef HANDMADETEST_H
+#define HANDMADETEST_H
+
+#include <float.h>
+#include <stdio.h>
+
+int hmt_count_tests = 0;
+int hmt_count_failedtests = 0;
+int hmt_count_failures = 0;
+
+#define RESET "\033[0m"
+#define RED   "\033[31m"
+#define GREEN "\033[32m"
+
+#define CATEGORY_BEGIN(name) { \
+    int count_categorytests = 0; \
+    int count_categoryfailedtests = 0; \
+    int count_categoryfailures = 0; \
+    printf("\n" #name ":\n");
+#define CATEGORY_END(name) \
+    hmt_count_tests += count_categorytests; \
+    hmt_count_failedtests += count_categoryfailedtests; \
+    hmt_count_failures += count_categoryfailures; \
+    printf("%d/%d tests passed, %d failures\n", count_categorytests - count_categoryfailedtests, count_categorytests, count_categoryfailures); \
+}
+
+#define TEST_BEGIN(name) { \
+    int count_testfailures = 0; \
+    count_categorytests++; \
+    printf("    " #name ":");
+#define TEST_END() \
+    count_categoryfailures += count_testfailures; \
+    if (count_testfailures > 0) { \
+        count_categoryfailedtests++; \
+        printf("\n"); \
+    } else { \
+        printf(GREEN " [PASS]\n" RESET); \
+    } \
+}
+
+#define CASE_FAIL() \
+    count_testfailures++; \
+    printf("\n      - " RED "[FAIL] (%d) " RESET, __LINE__)
+
+/*
+ * Asserts and expects
+ */
+#define EXPECT_FLOAT_EQ(_actual, _expected) do { \
+    float actual = (_actual); \
+    float diff = actual - (_expected); \
+    if (diff < -FLT_EPSILON || FLT_EPSILON < diff) { \
+        CASE_FAIL(); \
+        printf("Expected %f, got %f", (_expected), actual); \
+    } \
+} while (0)
+
+#define EXPECT_NEAR(_actual, _expected, _epsilon) do { \
+    float actual = (_actual); \
+    float diff = actual - (_expected); \
+    if (diff < -(_epsilon) || (_epsilon) < diff) { \
+        CASE_FAIL(); \
+        printf("Expected %f, got %f", (_expected), actual); \
+    } \
+} while (0)
+
+#define EXPECT_LT(_actual, _expected) do { \
+    if ((_actual) >= (_expected)) { \
+        CASE_FAIL(); \
+        printf("Expected %f to be less than %f", (_actual), (_expected)); \
+    } \
+} while (0)
+
+#define EXPECT_GT(_actual, _expected) do { \
+    if ((_actual) <= (_expected)) { \
+        CASE_FAIL(); \
+        printf("Expected %f to be greater than %f", (_actual), (_expected)); \
+    } \
+} while (0)
+
+#endif

test/Makefile

@@ -1,81 +1,17 @@
-# A sample Makefile for building Google Test and using it in user
+ROOT_DIR = ..
-# tests.  Please tweak it to suit your environment and project.  You
-# may want to move it to your project's root directory.
-#
-# SYNOPSIS:
-#
-#   make [all]  - makes everything.
-#   make TARGET - makes the given target.
-#   make clean  - removes all files generated by make.
 
-# Please tweak the following variable definitions as needed by your
-# project, except GTEST_HEADERS, which you can use in your own targets
-# but shouldn't modify.
-
-# Points to the root of Google Test, relative to where this file is.
-# Remember to tweak this if you move this file.
-GTEST_DIR = ../externals/googletest/googletest
-
-# Where to find user code.
-USER_DIR = ..
-
-# Flags passed to the preprocessor.
-# Set Google Test's header directory as a system directory, such that
-# the compiler doesn't generate warnings in Google Test headers.
-CPPFLAGS += -isystem $(GTEST_DIR)/include
-
-# Flags passed to the C++ compiler.
 CXXFLAGS += -g -Wall -Wextra -pthread -Wno-missing-braces -Wno-missing-field-initializers
 
-# All tests produced by this Makefile.  Remember to add new tests you
+all: c cpp
-# created to the list.
-TESTS = hmm_test
 
-# All Google Test headers.  Usually you shouldn't change this
+clean:
-# definition.
+	rm -f hmm_test_c hmm_test_cpp *.o
-GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
-                $(GTEST_DIR)/include/gtest/internal/*.h
 
-# House-keeping build targets.
+c: $(ROOT_DIR)/test/HandmadeMath.c test_impl
+	$(CC) $(CPPFLAGS) $(CXXFLAGS) -std=c99 -c $(ROOT_DIR)/test/HandmadeMath.c $(ROOT_DIR)/test/hmm_test.c -lm
+	$(CC) -ohmm_test_c HandmadeMath.o hmm_test.o -lm
 
-all : $(TESTS)
+cpp: $(ROOT_DIR)/test/HandmadeMath.cpp test_impl
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -ohmm_test_cpp $(ROOT_DIR)/test/HandmadeMath.cpp $(ROOT_DIR)/test/hmm_test.cpp
 
-clean :
+test_impl: $(ROOT_DIR)/test/hmm_test.cpp $(ROOT_DIR)/test/hmm_test.c
-	rm -f $(TESTS) gtest.a gtest_main.a *.o
-
-# Builds gtest.a and gtest_main.a.
-
-# Usually you shouldn't tweak such internal variables, indicated by a
-# trailing _.
-GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
-
-# For simplicity and to avoid depending on Google Test's
-# implementation details, the dependencies specified below are
-# conservative and not optimized.  This is fine as Google Test
-# compiles fast and for ordinary users its source rarely changes.
-gtest-all.o : $(GTEST_SRCS_)
-	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
-            $(GTEST_DIR)/src/gtest-all.cc
-
-gtest_main.o : $(GTEST_SRCS_)
-	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
-            $(GTEST_DIR)/src/gtest_main.cc
-
-gtest.a : gtest-all.o
-	$(AR) $(ARFLAGS) $@ $^
-
-gtest_main.a : gtest-all.o gtest_main.o
-	$(AR) $(ARFLAGS) $@ $^
-
-# Builds a sample test.  A test should link with either gtest.a or
-# gtest_main.a, depending on whether it defines its own main()
-# function.
-
-HandmadeMath.o : $(USER_DIR)/test/HandmadeMath.cpp $(USER_DIR)/HandmadeMath.h $(GTEST_HEADERS)
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/test/HandmadeMath.cpp
-
-hmm_test.o : $(USER_DIR)/test/hmm_test.cpp $(GTEST_HEADERS)
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/test/hmm_test.cpp
-
-hmm_test : HandmadeMath.o hmm_test.o gtest_main.a
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@