Update README for 1.1.5

* Added Width, and Height to hmm_vec2, and fixed SqrtF when compiling without the CRT

* Syntax error

* Test all the vector access methods

HandmadeMath.h

@@ -1,5 +1,5 @@
 /*
-  HandmadeMath.h v1.1.4
+  HandmadeMath.h v1.1.5
   
   This is a single header file with a bunch of useful functions for
   basic game math operations.
@@ -72,11 +72,12 @@
   
   ==========================================================================
   
-  To Disable the CRT, you MUST 
+  To use HandmadeMath without the CRT, you MUST 
   
      #define HMM_SINF MySinF
      #define HMM_COSF MyCosF
      #define HMM_TANF MyTanF
+     #define HMM_SQRTF MySqrtF
      #define HMM_EXPF MyExpF
      #define HMM_LOGF MyLogF
      #define HMM_ACOSF MyACosF
@@ -90,6 +91,7 @@
      #define HMM_SINF MySinF
      #define HMM_COSF MyCosF
      #define HMM_TANF MyTanF
+     #define HMM_SQRTF MySqrtF
      #define HMM_EXPF MyExpF
      #define HMM_LOGF MyLogF
      #define HMM_ACOSF MyACosF
@@ -176,7 +178,11 @@
      1.1.3
           (*) Fixed compile error in C mode
      1.1.4
+          (*) Fixed SSE being included on platforms that don't support it
           (*) Fixed divide-by-zero errors when normalizing zero vectors.
+     1.1.5
+          (*) Add Width and Height to HMM_Vec2
+          (*) Made it so you can supply your own SqrtF 
           
   LICENSE
   
@@ -200,6 +206,7 @@
    Jeroen van Rijn (@J_vanRijn)
    Kiljacken (@Kiljacken)
    Insofaras (@insofaras)
+   Daniel Gibson (@DanielGibson)
 */
 
 
@@ -258,8 +265,8 @@ extern "C"
 #endif
 
 #if !defined(HMM_SINF) || !defined(HMM_COSF) || !defined(HMM_TANF) || \
-    !defined(HMM_EXPF) || !defined(HMM_LOGF) || !defined(HMM_ACOSF) || \
+    !defined(HMM_SQRTF) || !defined(HMM_EXPF) || !defined(HMM_LOGF) || \
-    !defined(HMM_ATANF)|| !defined(HMM_ATAN2F)
+    !defined(HMM_ACOSF) || !defined(HMM_ATANF)|| !defined(HMM_ATAN2F)
 #include <math.h>    
 #endif
     
@@ -274,6 +281,10 @@ extern "C"
 #ifndef HMM_TANF
 #define HMM_TANF tanf
 #endif        
+
+#ifndef HMM_SQRTF
+#define HMM_SQRTF sqrtf
+#endif    
     
 #ifndef HMM_EXPF
 #define HMM_EXPF expf
@@ -320,6 +331,11 @@ typedef union hmm_vec2
     {
         float Left, Right;
     };
+    
+    struct
+    {
+        float Width, Height;
+    };
 
     float Elements[2];
 } hmm_vec2;
@@ -784,7 +800,7 @@ HMM_SquareRootF(float Value)
     __m128 Out = _mm_sqrt_ss(In);
     Result = _mm_cvtss_f32(Out);
 #else
-    Result = sqrtf(Value);
+    Result = HMM_SQRTF(Value);
 #endif 
 
     return(Result);

README.md

@@ -12,7 +12,8 @@ _This library is free and will stay free, but if you would like to support devel
 
 Version         | Changes        | 
 ----------------|----------------|
-**1.1.4** | Fixed divide-by-zero errors when normalizing zero vectors.
+**1.1.5** | Added `Width` and `Height` to `HMM_Vec2`, and made it so you can supply your own `SqrtF`.
+**1.1.4** | Fixed SSE being included on platforms that don't support it, and fixed divide-by-zero errors when normalizing zero vectors.
 **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++

test/hmm_test.c

@@ -120,9 +120,25 @@ int run_tests()
 
             EXPECT_FLOAT_EQ(v2.X, 1.0f);
             EXPECT_FLOAT_EQ(v2.Y, 2.0f);
+            EXPECT_FLOAT_EQ(v2.U, 1.0f);
+            EXPECT_FLOAT_EQ(v2.V, 2.0f);
+            EXPECT_FLOAT_EQ(v2.Left, 1.0f);
+            EXPECT_FLOAT_EQ(v2.Right, 2.0f);
+            EXPECT_FLOAT_EQ(v2.Width, 1.0f);
+            EXPECT_FLOAT_EQ(v2.Height, 2.0f);
+            EXPECT_FLOAT_EQ(v2.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v2.Elements[1], 2.0f);
 
             EXPECT_FLOAT_EQ(v2i.X, 1.0f);
             EXPECT_FLOAT_EQ(v2i.Y, 2.0f);
+            EXPECT_FLOAT_EQ(v2i.U, 1.0f);
+            EXPECT_FLOAT_EQ(v2i.V, 2.0f);
+            EXPECT_FLOAT_EQ(v2i.Left, 1.0f);
+            EXPECT_FLOAT_EQ(v2i.Right, 2.0f);
+            EXPECT_FLOAT_EQ(v2i.Width, 1.0f);
+            EXPECT_FLOAT_EQ(v2i.Height, 2.0f);
+            EXPECT_FLOAT_EQ(v2i.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v2i.Elements[1], 2.0f);
 
             //
             // Test vec3
@@ -133,10 +149,44 @@ int run_tests()
             EXPECT_FLOAT_EQ(v3.X, 1.0f);
             EXPECT_FLOAT_EQ(v3.Y, 2.0f);
             EXPECT_FLOAT_EQ(v3.Z, 3.0f);
+            EXPECT_FLOAT_EQ(v3.U, 1.0f);
+            EXPECT_FLOAT_EQ(v3.V, 2.0f);
+            EXPECT_FLOAT_EQ(v3.W, 3.0f);
+            EXPECT_FLOAT_EQ(v3.R, 1.0f);
+            EXPECT_FLOAT_EQ(v3.G, 2.0f);
+            EXPECT_FLOAT_EQ(v3.B, 3.0f);
+            EXPECT_FLOAT_EQ(v3.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v3.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v3.Elements[2], 3.0f);
+            EXPECT_FLOAT_EQ(v3.XY.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v3.XY.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v3.YZ.Elements[0], 2.0f);
+            EXPECT_FLOAT_EQ(v3.YZ.Elements[1], 3.0f);
+            EXPECT_FLOAT_EQ(v3.UV.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v3.UV.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v3.VW.Elements[0], 2.0f);
+            EXPECT_FLOAT_EQ(v3.VW.Elements[1], 3.0f);
 
             EXPECT_FLOAT_EQ(v3i.X, 1.0f);
             EXPECT_FLOAT_EQ(v3i.Y, 2.0f);
             EXPECT_FLOAT_EQ(v3i.Z, 3.0f);
+            EXPECT_FLOAT_EQ(v3i.U, 1.0f);
+            EXPECT_FLOAT_EQ(v3i.V, 2.0f);
+            EXPECT_FLOAT_EQ(v3i.W, 3.0f);
+            EXPECT_FLOAT_EQ(v3i.R, 1.0f);
+            EXPECT_FLOAT_EQ(v3i.G, 2.0f);
+            EXPECT_FLOAT_EQ(v3i.B, 3.0f);
+            EXPECT_FLOAT_EQ(v3i.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v3i.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v3i.Elements[2], 3.0f);
+            EXPECT_FLOAT_EQ(v3i.XY.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v3i.XY.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v3i.YZ.Elements[0], 2.0f);
+            EXPECT_FLOAT_EQ(v3i.YZ.Elements[1], 3.0f);
+            EXPECT_FLOAT_EQ(v3i.UV.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v3i.UV.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v3i.VW.Elements[0], 2.0f);
+            EXPECT_FLOAT_EQ(v3i.VW.Elements[1], 3.0f);
 
             //
             // Test vec4
@@ -149,16 +199,70 @@ int run_tests()
             EXPECT_FLOAT_EQ(v4.Y, 2.0f);
             EXPECT_FLOAT_EQ(v4.Z, 3.0f);
             EXPECT_FLOAT_EQ(v4.W, 4.0f);
+            EXPECT_FLOAT_EQ(v4.R, 1.0f);
+            EXPECT_FLOAT_EQ(v4.G, 2.0f);
+            EXPECT_FLOAT_EQ(v4.B, 3.0f);
+            EXPECT_FLOAT_EQ(v4.A, 4.0f);
+            EXPECT_FLOAT_EQ(v4.XY.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4.XY.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4.YZ.Elements[0], 2.0f);
+            EXPECT_FLOAT_EQ(v4.YZ.Elements[1], 3.0f);
+            EXPECT_FLOAT_EQ(v4.ZW.Elements[0], 3.0f);
+            EXPECT_FLOAT_EQ(v4.ZW.Elements[1], 4.0f);
+            EXPECT_FLOAT_EQ(v4.XY.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4.XY.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4.XYZ.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4.XYZ.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4.XYZ.Elements[2], 3.0f);
+            EXPECT_FLOAT_EQ(v4.RGB.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4.RGB.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4.RGB.Elements[2], 3.0f);
 
             EXPECT_FLOAT_EQ(v4i.X, 1.0f);
             EXPECT_FLOAT_EQ(v4i.Y, 2.0f);
             EXPECT_FLOAT_EQ(v4i.Z, 3.0f);
             EXPECT_FLOAT_EQ(v4i.W, 4.0f);
+            EXPECT_FLOAT_EQ(v4i.R, 1.0f);
+            EXPECT_FLOAT_EQ(v4i.G, 2.0f);
+            EXPECT_FLOAT_EQ(v4i.B, 3.0f);
+            EXPECT_FLOAT_EQ(v4i.A, 4.0f);
+            EXPECT_FLOAT_EQ(v4i.XY.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4i.XY.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4i.YZ.Elements[0], 2.0f);
+            EXPECT_FLOAT_EQ(v4i.YZ.Elements[1], 3.0f);
+            EXPECT_FLOAT_EQ(v4i.ZW.Elements[0], 3.0f);
+            EXPECT_FLOAT_EQ(v4i.ZW.Elements[1], 4.0f);
+            EXPECT_FLOAT_EQ(v4i.XY.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4i.XY.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4i.XYZ.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4i.XYZ.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4i.XYZ.Elements[2], 3.0f);
+            EXPECT_FLOAT_EQ(v4i.RGB.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4i.RGB.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4i.RGB.Elements[2], 3.0f);
 
             EXPECT_FLOAT_EQ(v4v.X, 1.0f);
             EXPECT_FLOAT_EQ(v4v.Y, 2.0f);
             EXPECT_FLOAT_EQ(v4v.Z, 3.0f);
             EXPECT_FLOAT_EQ(v4v.W, 4.0f);
+            EXPECT_FLOAT_EQ(v4v.R, 1.0f);
+            EXPECT_FLOAT_EQ(v4v.G, 2.0f);
+            EXPECT_FLOAT_EQ(v4v.B, 3.0f);
+            EXPECT_FLOAT_EQ(v4v.A, 4.0f);
+            EXPECT_FLOAT_EQ(v4v.XY.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4v.XY.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4v.YZ.Elements[0], 2.0f);
+            EXPECT_FLOAT_EQ(v4v.YZ.Elements[1], 3.0f);
+            EXPECT_FLOAT_EQ(v4v.ZW.Elements[0], 3.0f);
+            EXPECT_FLOAT_EQ(v4v.ZW.Elements[1], 4.0f);
+            EXPECT_FLOAT_EQ(v4v.XY.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4v.XY.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4v.XYZ.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4v.XYZ.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4v.XYZ.Elements[2], 3.0f);
+            EXPECT_FLOAT_EQ(v4v.RGB.Elements[0], 1.0f);
+            EXPECT_FLOAT_EQ(v4v.RGB.Elements[1], 2.0f);
+            EXPECT_FLOAT_EQ(v4v.RGB.Elements[2], 3.0f);
         }
         TEST_END()