Update README for 1.1.5

1.1.5 (#64 )
* Added Width, and Height to hmm_vec2, and fixed SqrtF when compiling without the CRT * Syntax error * Test all the vector access methods
2025-12-28 23:54:32 +00:00 · 2017-06-21 09:31:20 -05:00 · 2017-06-14 20:49:44 -07:00 · 2017-06-13 11:39:42 -05:00 · 2017-06-13 11:26:46 -05:00 · 2017-06-13 11:21:55 -05:00
7 changed files with 247 additions and 23 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,4 +7,6 @@ install:
  - make
 script:
  - ./hmm_test_c
+  - ./hmm_test_c_no_sse
  - ./hmm_test_cpp
+  - ./hmm_test_cpp_no_sse
--- a/HandmadeMath.h
+++ b/HandmadeMath.h
@@ -1,5 +1,5 @@
 /*
-  HandmadeMath.h v1.1.2
+  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
@@ -175,6 +177,12 @@
          (*) Fixed invalid HMMDEF's in the function definitions
     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
  
@@ -198,9 +206,30 @@
   Jeroen van Rijn (@J_vanRijn)
   Kiljacken (@Kiljacken)
   Insofaras (@insofaras)
+   Daniel Gibson (@DanielGibson)
 */

-#ifndef HANDMADE_NO_SSE
+
+/* let's figure out if SSE is really available (unless disabled anyway)
+   (it isn't on non-x86/x86_64 platforms or even x86 without explicit SSE support)
+   => only use "#ifdef HANDMADE_MATH__USE_SSE" to check for SSE support below this block! */
+#ifndef HANDMADE_MATH_NO_SSE
+
+# ifdef _MSC_VER
+   /* MSVC supports SSE in amd64 mode or _M_IX86_FP >= 1 (2 means SSE2) */
+#  if defined(_M_AMD64) || ( defined(_M_IX86_FP) && _M_IX86_FP >= 1 )
+#   define HANDMADE_MATH__USE_SSE 1
+#  endif
+# else /* not MSVC, probably GCC, clang, icc or something that doesn't support SSE anyway */
+#  ifdef __SSE__ /* they #define __SSE__ if it's supported */
+#   define HANDMADE_MATH__USE_SSE 1
+#  endif /*  __SSE__ */
+# endif /* not _MSC_VER */
+
+#endif /* #ifndef HANDMADE_MATH_NO_SSE */
+
+
+#ifdef HANDMADE_MATH__USE_SSE
 #include <xmmintrin.h>
 #endif

@@ -236,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_ATANF)|| !defined(HMM_ATAN2F)
+    !defined(HMM_SQRTF) || !defined(HMM_EXPF) || !defined(HMM_LOGF) || \
+    !defined(HMM_ACOSF) || !defined(HMM_ATANF)|| !defined(HMM_ATAN2F)
 #include <math.h>    
 #endif
    
@@ -252,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
@@ -298,6 +331,11 @@ typedef union hmm_vec2
    {
        float Left, Right;
    };
+    
+    struct
+    {
+        float Width, Height;
+    };

    float Elements[2];
 } hmm_vec2;
@@ -757,12 +795,12 @@ HMM_SquareRootF(float Value)
 {
    float Result = 0.0f;

-#ifdef HANDMADE_MATH_NO_SSE
-    Result = sqrtf(Value);
-#else        
+#ifdef HANDMADE_MATH__USE_SSE
    __m128 In = _mm_set_ss(Value);
    __m128 Out = _mm_sqrt_ss(In);
    Result = _mm_cvtss_f32(Out);
+#else
+    Result = HMM_SQRTF(Value);
 #endif 

    return(Result);
@@ -773,12 +811,12 @@ HMM_RSquareRootF(float Value)
 {
    float Result = 0.0f;

-#ifdef HANDMADE_MATH_NO_SSE
-    Result = 1.0f/HMM_SqrtF(Value);    
-#else        
+#ifdef HANDMADE_MATH__USE_SSE
    __m128 In = _mm_set_ss(Value);
    __m128 Out = _mm_rsqrt_ss(In);
    Result = _mm_cvtss_f32(Out);
+#else
+    Result = 1.0f/HMM_SquareRootF(Value);
 #endif

    return(Result);
@@ -903,8 +941,12 @@ HMM_NormalizeVec2(hmm_vec2 A)

    float VectorLength = HMM_LengthVec2(A);
    
-    Result.X = A.X * (1.0f / VectorLength);
-    Result.Y = A.Y * (1.0f / VectorLength);
+    /* NOTE(kiljacken): We need a zero check to not divide-by-zero */
+    if (VectorLength != 0.0f)
+    {
+        Result.X = A.X * (1.0f / VectorLength);
+        Result.Y = A.Y * (1.0f / VectorLength);
+    }
    
    return (Result);
 }
@@ -916,9 +958,13 @@ HMM_NormalizeVec3(hmm_vec3 A)

    float VectorLength = HMM_LengthVec3(A);
    
-    Result.X = A.X * (1.0f / VectorLength);
-    Result.Y = A.Y * (1.0f / VectorLength);
-    Result.Z = A.Z * (1.0f / VectorLength);
+    /* NOTE(kiljacken): We need a zero check to not divide-by-zero */
+    if (VectorLength != 0.0f)
+    {
+        Result.X = A.X * (1.0f / VectorLength);
+        Result.Y = A.Y * (1.0f / VectorLength);
+        Result.Z = A.Z * (1.0f / VectorLength);
+    }
    
    return (Result);
 }
@@ -930,10 +976,14 @@ HMM_NormalizeVec4(hmm_vec4 A)

    float VectorLength = HMM_LengthVec4(A);
    
-    Result.X = A.X * (1.0f / VectorLength);
-    Result.Y = A.Y * (1.0f / VectorLength);
-    Result.Z = A.Z * (1.0f / VectorLength);
-    Result.W = A.W * (1.0f / VectorLength);
+    /* NOTE(kiljacken): We need a zero check to not divide-by-zero */
+    if (VectorLength != 0.0f)
+    {
+        Result.X = A.X * (1.0f / VectorLength);
+        Result.Y = A.Y * (1.0f / VectorLength);
+        Result.Z = A.Z * (1.0f / VectorLength);
+        Result.W = A.W * (1.0f / VectorLength);
+    }
    
    return (Result);
 }
--- a/README.md
+++ b/README.md
@@ -12,6 +12,8 @@ _This library is free and will stay free, but if you would like to support devel

 Version         | Changes        | 
 ----------------|----------------|
+**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++
--- a/test/HandmadeMath_NoSSE.c
+++ b/test/HandmadeMath_NoSSE.c
@@ -0,0 +1,5 @@
+
+#define HANDMADE_MATH_IMPLEMENTATION
+#define HANDMADE_MATH_NO_SSE
+#define HANDMADE_MATH_NO_INLINE
+#include "../HandmadeMath.h"
--- a/test/HandmadeMath_NoSSE.cpp
+++ b/test/HandmadeMath_NoSSE.cpp
@@ -0,0 +1,6 @@
+
+#define HANDMADE_MATH_IMPLEMENTATION
+#define HANDMADE_MATH_CPP_MODE
+#define HANDMADE_MATH_NO_SSE
+#define HANDMADE_MATH_NO_INLINE
+#include "../HandmadeMath.h"
--- a/test/Makefile
+++ b/test/Makefile
@@ -2,16 +2,23 @@ ROOT_DIR = ..

 CXXFLAGS += -g -Wall -Wextra -pthread -Wno-missing-braces -Wno-missing-field-initializers

-all: c cpp
+all: c c_no_sse cpp cpp_no_sse

 clean:
-	rm -f hmm_test_c hmm_test_cpp *.o
+	rm -f hmm_test_c hmm_test_cpp hmm_test_c_no_sse hmm_test_cpp_no_sse *.o

 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

+c_no_sse: $(ROOT_DIR)/test/HandmadeMath_NoSSE.c test_impl
+	$(CC) $(CPPFLAGS) $(CXXFLAGS) -std=c99 -c $(ROOT_DIR)/test/HandmadeMath_NoSSE.c $(ROOT_DIR)/test/hmm_test.c -lm
+	$(CC) -ohmm_test_c_no_sse HandmadeMath_NoSSE.o hmm_test.o -lm
+
 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

+cpp_no_sse: $(ROOT_DIR)/test/HandmadeMath_NoSSE.cpp test_impl
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -ohmm_test_cpp_no_sse $(ROOT_DIR)/test/HandmadeMath_NoSSE.cpp $(ROOT_DIR)/test/hmm_test.cpp
+
 test_impl: $(ROOT_DIR)/test/hmm_test.cpp $(ROOT_DIR)/test/hmm_test.c
--- a/test/hmm_test.c
+++ b/test/hmm_test.c
@@ -70,7 +70,7 @@ int run_tests()

        TEST_BEGIN(RSquareRootF)
        {
-            EXPECT_FLOAT_EQ(HMM_RSquareRootF(10.0f), 0.31616211f);
+            EXPECT_NEAR(HMM_RSquareRootF(10.0f), 0.31616211f, 0.0001f);
        }
        TEST_END()

@@ -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()

@@ -310,6 +414,54 @@ int run_tests()
        }
        TEST_END()

+        TEST_BEGIN(NormalizeZero)
+        {
+            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_NormalizeVec2(v2);
+                EXPECT_FLOAT_EQ(result.X, 0.0f);
+                EXPECT_FLOAT_EQ(result.Y, 0.0f);
+            }
+            {
+                hmm_vec3 result = HMM_NormalizeVec3(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);
+                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 HANDMADE_MATH_CPP_MODE
+            {
+                hmm_vec2 result = HMM_Normalize(v2);
+                EXPECT_FLOAT_EQ(result.X, 0.0f);
+                EXPECT_FLOAT_EQ(result.Y, 0.0f);
+            }
+            {
+                hmm_vec3 result = HMM_Normalize(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);
+                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_END()
+
        TEST_BEGIN(Cross)
        {
            hmm_vec3 v1 = HMM_Vec3(1.0f, 2.0f, 3.0f);
Author	SHA1	Message	Date
Ben Visness	c8ada18370	Update README for 1.1.5	2017-06-21 09:31:20 -05:00
Zak Strange	70ac2b7e5b	1.1.5 (#64 ) * Added Width, and Height to hmm_vec2, and fixed SqrtF when compiling without the CRT * Syntax error * Test all the vector access methods	2017-06-14 20:49:44 -07:00
Ben Visness	924ee43923	Update history to include @DanielGibson's SSE fixes	2017-06-13 11:39:42 -05:00
Ben Visness	440b885d59	Update version to 1.1.4	2017-06-13 11:26:46 -05:00
Emil Lauridsen	98f535aeec	Handle zero-vector normalization. (#63 ) * Handle zero-vector normalization. When normalizing a vectors, we have to check whether vector length is not zero, to avoid dividing by zero when normalizing zero-vectors. * Test for normalization of zero vectors	2017-06-13 11:21:55 -05:00
Ben Visness	09524f72ed	Merge branch 'sse-testing' # Conflicts: # HandmadeMath.h	2017-06-11 18:54:06 -05:00
Emil Lauridsen	be30046a5a	C89 style comments (#62 )	2017-06-11 10:32:46 -07:00
Daniel Gibson	ff4513ff33	Make it usable on non-SSE platforms (#60 ) * at one place HANDMADE_NO_SSE instead of HANDMADE_MATH_NO_SSE was used * introduce HANDMADE_MATH__USE_SSE for the SSE #ifdefs throughout code - use #ifdef HANDMADE_MATH_NO_SSE at only one place * only use SSE (#define HANDMADE_MATH__USE_SSE) if the targetplatform actually supports it => users don't have to #define HANDMADE_MATH_NO_SSE on ARM etc * at one place HMM_SqrtF instead of HMM_SquareRootF was used	2017-06-09 17:14:24 -07:00
Ben Visness	364569abe9	Fix wrong name for square root function	2017-06-09 10:43:11 -05:00
Ben Visness	a9972e71da	Test both with and without SSE	2017-06-09 10:37:38 -05:00