Update version to 1.1.4

* 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

.gitignore

@@ -32,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,8 @@ compiler:
 install:
   - cd test
   - make
-script: ./hmm_test
+script:
+  - ./hmm_test_c
+  - ./hmm_test_c_no_sse
+  - ./hmm_test_cpp
+  - ./hmm_test_cpp_no_sse

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.1
+  HandmadeMath.h v1.1.4
   
   This is a single header file with a bunch of useful functions for
   basic game math operations.
@@ -171,6 +171,12 @@
           (*) 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
+     1.1.4
+          (*) Fixed divide-by-zero errors when normalizing zero vectors.
           
   LICENSE
   
@@ -196,7 +202,27 @@
    Insofaras (@insofaras)
 */
 
-#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
 
@@ -753,12 +779,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 = sqrtf(Value);
 #endif 
 
     return(Result);
@@ -769,12 +795,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);
@@ -899,8 +925,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);
 }
@@ -912,9 +942,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);
 }
@@ -926,10 +960,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);
 }
@@ -1544,7 +1582,7 @@ HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up)
 }
 
 
-HMMDEF hmm_quaternion 
+HINLINE hmm_quaternion 
 HMM_Quaternion(float X, float Y, float Z, float W)
 {
     hmm_quaternion Result = {0};
@@ -1690,7 +1728,7 @@ HMM_NLerp(hmm_quaternion Left, float Time, hmm_quaternion Right)
     Result.Z = HMM_Lerp(Left.Z, Time, Right.Z);
     Result.W = HMM_Lerp(Left.W, Time, Right.W);
 
-    Result = HMM_Normalize(Result);
+    Result = HMM_NormalizeQuaternion(Result);
 
     return(Result);
 }
@@ -1775,7 +1813,7 @@ HMM_QuaternionFromAxisAngle(hmm_vec3 Axis, float AngleOfRotation)
 
 #ifdef HANDMADE_MATH_CPP_MODE
 
-HMMDEF float 
+HINLINE float 
 HMM_Length(hmm_vec2 A)
 {
     float Result = 0.0f;
@@ -1785,7 +1823,7 @@ HMM_Length(hmm_vec2 A)
     return(Result);
 }
 
-HMMDEF float 
+HINLINE float 
 HMM_Length(hmm_vec3 A)
 {
     float Result = 0.0f;
@@ -1795,7 +1833,7 @@ HMM_Length(hmm_vec3 A)
     return(Result);
 }
 
-HMMDEF float 
+HINLINE float 
 HMM_Length(hmm_vec4 A)
 {
     float Result = 0.0f;
@@ -1933,7 +1971,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};

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.4** | 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++
 **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.   |
@@ -33,7 +37,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/HandmadeMath_NoSSE.c

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

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"

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,24 @@
-# A sample Makefile for building Google Test and using it in user
-# 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.
+ROOT_DIR = ..
 
-# 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
-# created to the list.
-TESTS = hmm_test
+all: c c_no_sse cpp cpp_no_sse
 
-# All Google Test headers.  Usually you shouldn't change this
-# definition.
-GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
-                $(GTEST_DIR)/include/gtest/internal/*.h
+clean:
+	rm -f hmm_test_c hmm_test_cpp hmm_test_c_no_sse hmm_test_cpp_no_sse *.o
 
-# 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)
+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
 
-clean :
-	rm -f $(TESTS) gtest.a gtest_main.a *.o
+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
 
-# Builds gtest.a and gtest_main.a.
+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
 
-# 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 $@
+test_impl: $(ROOT_DIR)/test/hmm_test.cpp $(ROOT_DIR)/test/hmm_test.c