Add HMM_STATIC option to statically link instead of extern

HandmadeMath.h

@@ -84,7 +84,7 @@
 
   CREDITS
 
-  Written by Zakary Strange (zak@strangedev.net && @strangezak)
+  Written by Zakary Strange (strangezak@gmail.com && @strangezak)
 
   Functionality:
    Matt Mascarenhas (@miblo_)
@@ -165,7 +165,12 @@ extern "C"
 #endif
 
 #define HMM_INLINE static inline
-#define HMM_EXTERN extern
+
+#ifdef HMM_STATIC
+#define HMM_DEF static
+#else
+#define HMM_DEF extern
+#endif
 
 #if !defined(HMM_SINF) || !defined(HMM_COSF) || !defined(HMM_TANF) || \
     !defined(HMM_SQRTF) || !defined(HMM_EXPF) || !defined(HMM_LOGF) || \
@@ -547,7 +552,7 @@ HMM_INLINE float HMM_PREFIX(RSquareRootF)(float Float)
     return(Result);
 }
 
-HMM_EXTERN float HMM_PREFIX(Power)(float Base, int Exponent);
+HMM_DEF float HMM_PREFIX(Power)(float Base, int Exponent);
 
 COVERAGE(HMM_PowerF, 1)
 HMM_INLINE float HMM_PREFIX(PowerF)(float Base, float Exponent)
@@ -595,7 +600,8 @@ HMM_INLINE float HMM_PREFIX(Clamp)(float Min, float Value, float Max)
     {
         Result = Min;
     }
-    else if(Result > Max)
+
+    if(Result > Max)
     {
         Result = Max;
     }
@@ -1314,7 +1320,7 @@ HMM_INLINE hmm_mat4 HMM_PREFIX(Transpose)(hmm_mat4 Matrix)
     return (Result);
 }
 #else
-HMM_EXTERN hmm_mat4 HMM_PREFIX(Transpose)(hmm_mat4 Matrix);
+HMM_DEF hmm_mat4 HMM_PREFIX(Transpose)(hmm_mat4 Matrix);
 #endif
 
 #ifdef HANDMADE_MATH__USE_SSE
@@ -1333,7 +1339,7 @@ HMM_INLINE hmm_mat4 HMM_PREFIX(AddMat4)(hmm_mat4 Left, hmm_mat4 Right)
     return (Result);
 }
 #else
-HMM_EXTERN hmm_mat4 HMM_PREFIX(AddMat4)(hmm_mat4 Left, hmm_mat4 Right);
+HMM_DEF hmm_mat4 HMM_PREFIX(AddMat4)(hmm_mat4 Left, hmm_mat4 Right);
 #endif
 
 #ifdef HANDMADE_MATH__USE_SSE
@@ -1352,10 +1358,10 @@ HMM_INLINE hmm_mat4 HMM_PREFIX(SubtractMat4)(hmm_mat4 Left, hmm_mat4 Right)
     return (Result);
 }
 #else
-HMM_EXTERN hmm_mat4 HMM_PREFIX(SubtractMat4)(hmm_mat4 Left, hmm_mat4 Right);
+HMM_DEF hmm_mat4 HMM_PREFIX(SubtractMat4)(hmm_mat4 Left, hmm_mat4 Right);
 #endif
 
-HMM_EXTERN hmm_mat4 HMM_PREFIX(MultiplyMat4)(hmm_mat4 Left, hmm_mat4 Right);
+HMM_DEF hmm_mat4 HMM_PREFIX(MultiplyMat4)(hmm_mat4 Left, hmm_mat4 Right);
 
 #ifdef HANDMADE_MATH__USE_SSE
 COVERAGE(HMM_MultiplyMat4f, 1)
@@ -1374,10 +1380,10 @@ HMM_INLINE hmm_mat4 HMM_PREFIX(MultiplyMat4f)(hmm_mat4 Matrix, float Scalar)
     return (Result);
 }
 #else
-HMM_EXTERN hmm_mat4 HMM_PREFIX(MultiplyMat4f)(hmm_mat4 Matrix, float Scalar);
+HMM_DEF hmm_mat4 HMM_PREFIX(MultiplyMat4f)(hmm_mat4 Matrix, float Scalar);
 #endif
 
-HMM_EXTERN hmm_vec4 HMM_PREFIX(MultiplyMat4ByVec4)(hmm_mat4 Matrix, hmm_vec4 Vector);
+HMM_DEF hmm_vec4 HMM_PREFIX(MultiplyMat4ByVec4)(hmm_mat4 Matrix, hmm_vec4 Vector);
 
 #ifdef HANDMADE_MATH__USE_SSE
 COVERAGE(HMM_DivideMat4f, 1)
@@ -1396,7 +1402,7 @@ HMM_INLINE hmm_mat4 HMM_PREFIX(DivideMat4f)(hmm_mat4 Matrix, float Scalar)
     return (Result);
 }
 #else
-HMM_EXTERN hmm_mat4 HMM_PREFIX(DivideMat4f)(hmm_mat4 Matrix, float Scalar);
+HMM_DEF hmm_mat4 HMM_PREFIX(DivideMat4f)(hmm_mat4 Matrix, float Scalar);
 #endif
 
 
@@ -1458,7 +1464,7 @@ HMM_INLINE hmm_mat4 HMM_PREFIX(Translate)(hmm_vec3 Translation)
     return (Result);
 }
 
-HMM_EXTERN hmm_mat4 HMM_PREFIX(Rotate)(float Angle, hmm_vec3 Axis);
+HMM_DEF hmm_mat4 HMM_PREFIX(Rotate)(float Angle, hmm_vec3 Axis);
 
 COVERAGE(HMM_Scale, 1)
 HMM_INLINE hmm_mat4 HMM_PREFIX(Scale)(hmm_vec3 Scale)
@@ -1474,7 +1480,7 @@ HMM_INLINE hmm_mat4 HMM_PREFIX(Scale)(hmm_vec3 Scale)
     return (Result);
 }
 
-HMM_EXTERN hmm_mat4 HMM_PREFIX(LookAt)(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up);
+HMM_DEF hmm_mat4 HMM_PREFIX(LookAt)(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up);
 
 
 /*
@@ -1632,7 +1638,7 @@ HMM_INLINE hmm_quaternion HMM_PREFIX(DivideQuaternionF)(hmm_quaternion Left, flo
     return (Result);
 }
 
-HMM_EXTERN hmm_quaternion HMM_PREFIX(InverseQuaternion)(hmm_quaternion Left);
+HMM_DEF hmm_quaternion HMM_PREFIX(InverseQuaternion)(hmm_quaternion Left);
 
 COVERAGE(HMM_DotQuaternion, 1)
 HMM_INLINE float HMM_PREFIX(DotQuaternion)(hmm_quaternion Left, hmm_quaternion Right)
@@ -1692,10 +1698,10 @@ HMM_INLINE hmm_quaternion HMM_PREFIX(NLerp)(hmm_quaternion Left, float Time, hmm
     return (Result);
 }
 
-HMM_EXTERN hmm_quaternion HMM_PREFIX(Slerp)(hmm_quaternion Left, float Time, hmm_quaternion Right);
+HMM_DEF hmm_quaternion HMM_PREFIX(Slerp)(hmm_quaternion Left, float Time, hmm_quaternion Right);
-HMM_EXTERN hmm_mat4 HMM_PREFIX(QuaternionToMat4)(hmm_quaternion Left);
+HMM_DEF hmm_mat4 HMM_PREFIX(QuaternionToMat4)(hmm_quaternion Left);
-HMM_EXTERN hmm_quaternion HMM_PREFIX(Mat4ToQuaternion)(hmm_mat4 Left);
+HMM_DEF hmm_quaternion HMM_PREFIX(Mat4ToQuaternion)(hmm_mat4 Left);
-HMM_EXTERN hmm_quaternion HMM_PREFIX(QuaternionFromAxisAngle)(hmm_vec3 Axis, float AngleOfRotation);
+HMM_DEF hmm_quaternion HMM_PREFIX(QuaternionFromAxisAngle)(hmm_vec3 Axis, float AngleOfRotation);
 
 #ifdef __cplusplus
 }
@@ -2800,7 +2806,7 @@ HMM_INLINE hmm_bool operator!=(hmm_vec4 Left, hmm_vec4 Right)
 #ifdef HANDMADE_MATH_IMPLEMENTATION
 
 COVERAGE(HMM_Power, 2)
-float HMM_Power(float Base, int Exponent)
+float HMM_PREFIX(Power)(float Base, int Exponent)
 {
     ASSERT_COVERED(HMM_Power);
 
@@ -2825,7 +2831,7 @@ float HMM_Power(float Base, int Exponent)
 
 #ifndef HANDMADE_MATH__USE_SSE
 COVERAGE(HMM_Transpose, 1)
-hmm_mat4 HMM_Transpose(hmm_mat4 Matrix)
+hmm_mat4 HMM_PREFIX(Transpose)(hmm_mat4 Matrix)
 {
     ASSERT_COVERED(HMM_Transpose);
 
@@ -2847,7 +2853,7 @@ hmm_mat4 HMM_Transpose(hmm_mat4 Matrix)
 
 #ifndef HANDMADE_MATH__USE_SSE
 COVERAGE(HMM_AddMat4, 1)
-hmm_mat4 HMM_AddMat4(hmm_mat4 Left, hmm_mat4 Right)
+hmm_mat4 HMM_PREFIX(AddMat4)(hmm_mat4 Left, hmm_mat4 Right)
 {
     ASSERT_COVERED(HMM_AddMat4);
 
@@ -2869,7 +2875,7 @@ hmm_mat4 HMM_AddMat4(hmm_mat4 Left, hmm_mat4 Right)
 
 #ifndef HANDMADE_MATH__USE_SSE
 COVERAGE(HMM_SubtractMat4, 1)
-hmm_mat4 HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right)
+hmm_mat4 HMM_PREFIX(SubtractMat4)(hmm_mat4 Left, hmm_mat4 Right)
 {
     ASSERT_COVERED(HMM_SubtractMat4);
 
@@ -2890,7 +2896,7 @@ hmm_mat4 HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right)
 #endif
 
 COVERAGE(HMM_MultiplyMat4, 1)
-hmm_mat4 HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right)
+hmm_mat4 HMM_PREFIX(MultiplyMat4)(hmm_mat4 Left, hmm_mat4 Right)
 {
     ASSERT_COVERED(HMM_MultiplyMat4);
 
@@ -2925,7 +2931,7 @@ hmm_mat4 HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right)
 
 #ifndef HANDMADE_MATH__USE_SSE
 COVERAGE(HMM_MultiplyMat4f, 1)
-hmm_mat4 HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar)
+hmm_mat4 HMM_PREFIX(MultiplyMat4f)(hmm_mat4 Matrix, float Scalar)
 {
     ASSERT_COVERED(HMM_MultiplyMat4f);
 
@@ -2946,7 +2952,7 @@ hmm_mat4 HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar)
 #endif
 
 COVERAGE(HMM_MultiplyMat4ByVec4, 1)
-hmm_vec4 HMM_MultiplyMat4ByVec4(hmm_mat4 Matrix, hmm_vec4 Vector)
+hmm_vec4 HMM_PREFIX(MultiplyMat4ByVec4)(hmm_mat4 Matrix, hmm_vec4 Vector)
 {
     ASSERT_COVERED(HMM_MultiplyMat4ByVec4);
 
@@ -2973,7 +2979,7 @@ hmm_vec4 HMM_MultiplyMat4ByVec4(hmm_mat4 Matrix, hmm_vec4 Vector)
 
 #ifndef HANDMADE_MATH__USE_SSE
 COVERAGE(HMM_DivideMat4f, 1);
-hmm_mat4 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar)
+hmm_mat4 HMM_PREFIX(DivideMat4f)(hmm_mat4 Matrix, float Scalar)
 {
     ASSERT_COVERED(HMM_DivideMat4f);
 
@@ -2994,7 +3000,7 @@ hmm_mat4 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar)
 #endif
 
 COVERAGE(HMM_Rotate, 1)
-hmm_mat4 HMM_Rotate(float Angle, hmm_vec3 Axis)
+hmm_mat4 HMM_PREFIX(Rotate)(float Angle, hmm_vec3 Axis)
 {
     ASSERT_COVERED(HMM_Rotate);
 
@@ -3022,7 +3028,7 @@ hmm_mat4 HMM_Rotate(float Angle, hmm_vec3 Axis)
 }
 
 COVERAGE(HMM_LookAt, 1)
-hmm_mat4 HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up)
+hmm_mat4 HMM_PREFIX(LookAt)(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up)
 {
     ASSERT_COVERED(HMM_LookAt);
 
@@ -3056,7 +3062,7 @@ hmm_mat4 HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up)
 }
 
 COVERAGE(HMM_InverseQuaternion, 1)
-hmm_quaternion HMM_InverseQuaternion(hmm_quaternion Left)
+hmm_quaternion HMM_PREFIX(InverseQuaternion)(hmm_quaternion Left)
 {
     ASSERT_COVERED(HMM_InverseQuaternion);
 
@@ -3079,7 +3085,7 @@ hmm_quaternion HMM_InverseQuaternion(hmm_quaternion Left)
 }
 
 COVERAGE(HMM_Slerp, 1)
-hmm_quaternion HMM_Slerp(hmm_quaternion Left, float Time, hmm_quaternion Right)
+hmm_quaternion HMM_PREFIX(Slerp)(hmm_quaternion Left, float Time, hmm_quaternion Right)
 {
     ASSERT_COVERED(HMM_Slerp);
 
@@ -3104,7 +3110,7 @@ hmm_quaternion HMM_Slerp(hmm_quaternion Left, float Time, hmm_quaternion Right)
 }
 
 COVERAGE(HMM_QuaternionToMat4, 1)
-hmm_mat4 HMM_QuaternionToMat4(hmm_quaternion Left)
+hmm_mat4 HMM_PREFIX(QuaternionToMat4)(hmm_quaternion Left)
 {
     ASSERT_COVERED(HMM_QuaternionToMat4);
 
@@ -3164,7 +3170,7 @@ hmm_mat4 HMM_QuaternionToMat4(hmm_quaternion Left)
 // Don't be confused! Or if you must be confused, at least trust this
 // comment. :)
 COVERAGE(HMM_Mat4ToQuaternion, 4)
-hmm_quaternion HMM_Mat4ToQuaternion(hmm_mat4 M)
+hmm_quaternion HMM_PREFIX(Mat4ToQuaternion)(hmm_mat4 M)
 {
     float T;
     hmm_quaternion Q;
@@ -3221,7 +3227,7 @@ hmm_quaternion HMM_Mat4ToQuaternion(hmm_mat4 M)
 }
 
 COVERAGE(HMM_QuaternionFromAxisAngle, 1)
-hmm_quaternion HMM_QuaternionFromAxisAngle(hmm_vec3 Axis, float AngleOfRotation)
+hmm_quaternion HMM_PREFIX(QuaternionFromAxisAngle)(hmm_vec3 Axis, float AngleOfRotation)
 {
     ASSERT_COVERED(HMM_QuaternionFromAxisAngle);
 

README.md

@@ -10,6 +10,7 @@ To get started, go download [the latest release](https://github.com/HandmadeMath
 
 Version         | Changes        |
 ----------------|----------------|
+**1.11.1** | Added HMM_PREFIX macro to a few functions that were missing it. |
 **1.11.0** | Added ability to customize or remove the default `HMM_` prefix on function names by defining a macro called `HMM_PREFIX(name)`. |
 **1.10.1** | Removed stdint.h, this doesn't exist on some really old compilers and we didn't really use it anyways. |
 **1.10.0** | Made HMM_Perspective use vertical FOV instead of horizontal FOV for consistency with other graphics APIs. |