/*
  HandmadeMath.h v1.2.0
  
  This is a single header file with a bunch of useful functions for
  basic game math operations.
  
  =============================================================================
  
  You MUST
  
     #define HANDMADE_MATH_IMPLEMENTATION
     
  in EXACTLY one C or C++ file that includes this header, BEFORE the
  include, like this:
  
     #define HANDMADE_MATH_IMPLEMENTATION
     #include "HandmadeMath.h"
     
  All other files should just #include "HandmadeMath.h" without the #define.
  
  =============================================================================
  
  For overloaded and operator overloaded versions of the base C functions,
  you MUST
  
     #define HANDMADE_MATH_CPP_MODE
     
  in EXACTLY one C or C++ file that includes this header, BEFORE the
  include, like this:
  
     #define HANDMADE_MATH_IMPLEMENTATION
     #define HANDMADE_MATH_CPP_MODE
     #include "HandmadeMath.h"
     
  All other files should just #include "HandmadeMath.h" without the #define.
  
  =============================================================================
  
  To disable SSE intrinsics, you MUST
  
  #define HANDMADE_MATH_NO_SSE
  
  in EXACTLY one C or C++ file that includes this header, BEFORE the
  include, like this:
  
     #define HANDMADE_MATH_IMPLEMENTATION
     #define HANDMADE_MATH_CPP_MODE
     #define HANDMADE_MATH_NO_SSE
     #include "HandmadeMath.h"
     
     or
     
     #define HANDMADE_MATH_IMPLEMENTATION
     #define HANDMADE_MATH_NO_SSE
     #include "HandmadeMath.h"
     
  =============================================================================
  
  To disable inlining functions, you MUST
  
  #define HANDMADE_MATH_NO_INLINE
  
  in EXACTLY one C or C++ file that includes this header, BEFORE the
  include, like this:
  
     #define HANDMADE_MATH_IMPLEMENTATION
     #define HANDMADE_MATH_CPP_MODE
     #define HANDMADE_MATH_NO_INLINE
     #include "HandmadeMath.h"
     
  All other files should just #include "HandmadeMath.h" without the #define.
  
  =============================================================================
  
  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
     #define HMM_ATANF MyATanF
     #define HMM_ATAN2F MYATan2F
     
  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:     
  
     #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
     #define HMM_ATANF MyATanF
     #define HMM_ATAN2F MyATan2F
     #define HANDMADE_MATH_IMPLEMENTATION
     #define HANDMADE_MATH_CPP_MODE
     #include "HandmadeMath.h"
     
  If you do not define all five of these, HandmadeMath.h will use the
  versions of these functions that are provided by the CRT.
  
  =============================================================================
  
  Version History:
      0.2 (*) Updated documentation
          (*) Better C compliance
          (*) Prefix all handmade math functions 
          (*) Better operator overloading
      0.2a
          (*) Prefixed Macros
      0.2b
          (*) Disabled warning 4201 on MSVC as it is legal is C11
          (*) Removed the f at the end of HMM_PI to get 64bit precision
      0.3
          (*) Added +=, -=, *=, /= for hmm_vec2, hmm_vec3, hmm_vec4
      0.4
          (*) SSE Optimized HMM_SqrtF
          (*) SSE Optimized HMM_RSqrtF
          (*) Removed CRT
      0.5
          (*) Added scalar multiplication and division for vectors
              and matrices
          (*) Added matrix subtraction and += for hmm_mat4
          (*) Reconciled all headers and implementations
          (*) Tidied up, and filled in a few missing operators
      0.5.1
          (*) Ensured column-major order for matrices throughout
          (*) Fixed HMM_Translate producing row-major matrices
      0.5.2
          (*) Fixed SSE code in HMM_SqrtF
          (*) Fixed SSE code in HMM_RSqrtF
      0.6
          (*) Added Unit testing
          (*) 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
      0.7 
          (*) REMOVED HMM_LengthSquared in HANDMADE_MATH_IMPLEMENTATION (should
              use HMM_LengthSquaredVec3, or HANDMADE_MATH_CPP_MODE for function
              overloaded version)
          (*) REMOVED HMM_Length in HANDMADE_MATH_IMPLEMENTATION (should use
              HMM_LengthVec3, HANDMADE_MATH_CPP_MODE for function
              overloaded version)
          (*) REMOVED HMM_Normalize in HANDMADE_MATH_IMPLEMENTATION (should use
              HMM_NormalizeVec3, or HANDMADE_MATH_CPP_MODE for function
              overloaded version)
          (*) Added HMM_LengthSquaredVec2
          (*) Added HMM_LengthSquaredVec4
          (*) Addd HMM_LengthVec2
          (*) Added HMM_LengthVec4
          (*) Added HMM_NormalizeVec2
          (*) 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
     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 
     1.2.0
          (*) Added equality functions for HMM_Vec2, HMM_Vec3, and HMM_Vec4.
              (*) Added HMM_EqualsVec2, HMM_EqualsVec3, and HMM_EqualsVec4
              (*) Added C++ overloaded HMM_Equals for all three
              (*) Added C++ == and != operators for all three
          (*) SSE'd HMM_MultiplyMat4 (this is _WAY_ faster)
          (*) SSE'd HMM_Transpose
          
  LICENSE
  
  This software is in the public domain. Where that dedication is not
  recognized, you are granted a perpetual, irrevocable license to copy,
  distribute, and modify this file as you see fit.
  
  CREDITS
  
  Written by Zakary Strange (zak@handmade.network && @strangezak)
  
  Functionality:
   Matt Mascarenhas (@miblo_)
   Aleph
   FieryDrake (@fierydrake)
   Gingerbill (@TheGingerBill)
   Ben Visness (@bvisness) 
   Trinton Bullard (@Peliex_Dev)
   
  Fixes:
   Jeroen van Rijn (@J_vanRijn)
   Kiljacken (@Kiljacken)
   Insofaras (@insofaras)
   Daniel Gibson (@DanielGibson)
*/


/* 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 */

#include <stdint.h> // This is for types

#ifdef HANDMADE_MATH__USE_SSE
#include <xmmintrin.h>
#endif

#ifndef HANDMADE_MATH_H
#define HANDMADE_MATH_H

#ifdef _MSC_VER
#pragma warning(disable:4201)
#endif

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
#endif

#ifdef __cplusplus
extern "C"
{
#endif
  
#ifdef HANDMADE_MATH_STATIC
#define HMMDEF static
#else
#define HMMDEF extern
#endif
  
#ifdef HANDMADE_MATH_NO_INLINE
#define HINLINE
#elif _MSC_VER && !__INTEL_COMPILER
#define HINLINE __inline
#else
#define HINLINE inline
#endif
  
#if !defined(HMM_SINF) || !defined(HMM_COSF) || !defined(HMM_TANF) || \
!defined(HMM_SQRTF) || !defined(HMM_EXPF) || !defined(HMM_LOGF) || \
!defined(HMM_ACOSF) || !defined(HMM_ATANF)|| !defined(HMM_ATAN2F)
#include <math.h>    
#endif
  
#ifndef HMM_SINF
#define HMM_SINF sinf
#endif    
  
#ifndef HMM_COSF
#define HMM_COSF cosf
#endif    
  
#ifndef HMM_TANF
#define HMM_TANF tanf
#endif        
  
#ifndef HMM_SQRTF
#define HMM_SQRTF sqrtf
#endif    
  
#ifndef HMM_EXPF
#define HMM_EXPF expf
#endif
  
#ifndef HMM_LOGF
#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 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))
  
  typedef union hmm_vec2
  {
    struct
    {
      float X, Y;
    };
    struct
    {
      float x, y;
    }; 
    struct
    {
      float U, V;
    };
    
    struct
    {
      float Left, Right;
    };
    
    struct
    {
      float Width, Height;
    };
    
    float Elements[2];
  } hmm_vec2;
  
  typedef union hmm_vec3
  {
    struct
    {
      float X, Y, Z;
    };
    
    struct
    {
      float x, y, z;
    };
    
    struct
    {
      float U, V, W;
    };
    
    struct
    {
      float R, G, B;
    };
    
    struct
    {
      hmm_vec2 XY;
      float Ignored0_;
    };
    
    struct
    {
      float Ignored1_;
      hmm_vec2 YZ;
    };
    
    struct
    {
      hmm_vec2 UV;
      float Ignored2_;
    };
    
    struct
    {
      float Ignored3_;
      hmm_vec2 VW;
    };
    
    float Elements[3];
  } hmm_vec3;
  
  typedef union hmm_vec4
  {
    struct
    {
      union
      {
        hmm_vec3 XYZ;
        struct
        {
          float X, Y, Z;
        };
      };
      
      float W;
    };
    struct
    {
      union
      {
        hmm_vec3 xyz;
        struct
        {
          float x, y, z;
        };
      };
      
      float w;
    };
    struct
    {
      union
      {
        hmm_vec3 RGB;
        struct
        {
          float R, G, B;
        };
        struct
        {
          float r, g, b;
        };
      };
      
      union
      {
        float A;
        float a;
      };
    };
    
    struct
    {
      hmm_vec2 XY;
      float Ignored0_;
      float Ignored1_;
    };
    struct
    {
      hmm_vec2 xy;
      float Ignored0b_;
      float Ignored1b_;
    };
    
    struct
    {
      float Ignored2_;
      hmm_vec2 YZ;
      float Ignored3_;
    };
    struct
    {
      float Ignored2b_;
      hmm_vec2 yz;
      float Ignored3b_;
    };
    
    struct
    {
      float Ignored4_;
      float Ignored5_;
      hmm_vec2 ZW;
    };
    
    struct
    {
      float Ignored4b_;
      float Ignored5b_;
      hmm_vec2 zw;
    };
    
    float Elements[4];
  } hmm_vec4;
  
  typedef union hmm_mat4
  {
    float Elements[4][4];
    
    
#ifdef HANDMADE_MATH__USE_SSE
    __m128 Rows[4];
#endif
  } hmm_mat4;
  
  typedef union hmm_quaternion
  {
    struct
    {
      union
      {
        hmm_vec3 XYZ;
        struct
        {
          float X, Y, Z;
        };
      };
      
      float W;
    };
    
    float Elements[4];
  } hmm_quaternion;
  
  typedef struct
  {
    hmm_vec2 ValueMin;
    hmm_vec2 ValueMax;
  } hmm_vec2r;
  
  typedef struct
  {
    hmm_vec3 ValueMin;
    hmm_vec3 ValueMax;
  } hmm_vec3r;
  
  typedef struct
  {
    hmm_vec4 ValueMin;
    hmm_vec4 ValueMax;
  } hmm_vec4r;
  
  typedef int32_t hmm_bool;
  
  typedef hmm_vec2 hmm_v2;
  typedef hmm_vec3 hmm_v3;
  typedef hmm_vec4 hmm_v4;
  typedef hmm_mat4 hmm_m4;    
  typedef hmm_vec2r hmm_v2r;
  typedef hmm_vec3r hmm_v3r;
  typedef hmm_vec4r hmm_v4r;
  
  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);
  
  HMMDEF float HMM_ToRadians(float Degrees);
  HMMDEF float HMM_SquareRootF(float Float);
  HMMDEF float HMM_RSquareRootF(float Float);
  
  HMMDEF float HMM_LengthSquaredVec2(hmm_vec2 A);
  HMMDEF float HMM_LengthSquaredVec3(hmm_vec3 A);
  HMMDEF float HMM_LengthSquaredVec4(hmm_vec4 A);
  
  HMMDEF float HMM_LengthVec2(hmm_vec2 A);    
  HMMDEF float HMM_LengthVec3(hmm_vec3 A);    
  HMMDEF float HMM_LengthVec4(hmm_vec4 A);    
  
  HMMDEF float HMM_Power(float Base, int Exponent);
  HMMDEF float HMM_PowerF(float Base, float Exponent);
  HMMDEF float HMM_Lerp(float A, float Time, float B);
  HMMDEF float HMM_Clamp(float Min, float Value, float Max);
  
  HMMDEF hmm_vec2 HMM_NormalizeVec2(hmm_vec2 A);
  HMMDEF hmm_vec3 HMM_NormalizeVec3(hmm_vec3 A);
  HMMDEF hmm_vec4 HMM_NormalizeVec4(hmm_vec4 A);
  
  HMMDEF float HMM_DotVec2(hmm_vec2 VecOne, hmm_vec2 VecTwo);
  HMMDEF float HMM_DotVec3(hmm_vec3 VecOne, hmm_vec3 VecTwo);
  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_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);
  HMMDEF hmm_vec4 HMM_Vec4i(int X, int Y, int Z, int W);
  HMMDEF hmm_vec4 HMM_Vec4v(hmm_vec3 Vector, float W);
  
  HMMDEF hmm_vec2 HMM_AddVec2(hmm_vec2 Left, hmm_vec2 Right);
  HMMDEF hmm_vec3 HMM_AddVec3(hmm_vec3 Left, hmm_vec3 Right);
  HMMDEF hmm_vec4 HMM_AddVec4(hmm_vec4 Left, hmm_vec4 Right);
  
  HMMDEF hmm_vec2 HMM_SubtractVec2(hmm_vec2 Left, hmm_vec2 Right);
  HMMDEF hmm_vec3 HMM_SubtractVec3(hmm_vec3 Left, hmm_vec3 Right);
  HMMDEF hmm_vec4 HMM_SubtractVec4(hmm_vec4 Left, hmm_vec4 Right);
  
  HMMDEF hmm_vec2 HMM_MultiplyVec2(hmm_vec2 Left, hmm_vec2 Right);
  HMMDEF hmm_vec2 HMM_MultiplyVec2f(hmm_vec2 Left, float Right);
  HMMDEF hmm_vec3 HMM_MultiplyVec3(hmm_vec3 Left, hmm_vec3 Right);
  HMMDEF hmm_vec3 HMM_MultiplyVec3f(hmm_vec3 Left, float Right);
  HMMDEF hmm_vec4 HMM_MultiplyVec4(hmm_vec4 Left, hmm_vec4 Right);
  HMMDEF hmm_vec4 HMM_MultiplyVec4f(hmm_vec4 Left, float Right);
  
  HMMDEF hmm_vec2 HMM_DivideVec2(hmm_vec2 Left, hmm_vec2 Right);
  HMMDEF hmm_vec2 HMM_DivideVec2f(hmm_vec2 Left, float Right);
  HMMDEF hmm_vec3 HMM_DivideVec3(hmm_vec3 Left, hmm_vec3 Right);
  HMMDEF hmm_vec3 HMM_DivideVec3f(hmm_vec3 Left, float Right);
  HMMDEF hmm_vec4 HMM_DivideVec4(hmm_vec4 Left, hmm_vec4 Right);
  HMMDEF hmm_vec4 HMM_DivideVec4f(hmm_vec4 Left, float Right);
  
  HMMDEF hmm_bool HMM_EqualsVec2(hmm_vec2 Left, hmm_vec2 Right);
  HMMDEF hmm_bool HMM_EqualsVec3(hmm_vec3 Left, hmm_vec3 Right);
  HMMDEF hmm_bool HMM_EqualsVec4(hmm_vec4 Left, hmm_vec4 Right);
  
  HMMDEF hmm_mat4 HMM_Mat4(void);
  HMMDEF hmm_mat4 HMM_Mat4d(float Diagonal);
  HMMDEF hmm_mat4 HMM_AddMat4(hmm_mat4 Left, hmm_mat4 Right);
  HMMDEF hmm_mat4 HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right);
  
#ifdef HANDMADE_MATH__USE_SSE
  HMMDEF __m128 HMM_LinearCombineSSE(__m128 Left, hmm_mat4 Right);
#endif 
  
  HMMDEF hmm_mat4 HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right);
  HMMDEF hmm_mat4 HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar);
  HMMDEF hmm_vec4 HMM_MultiplyMat4ByVec4(hmm_mat4 Matrix, hmm_vec4 Vector);
  HMMDEF hmm_mat4 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar);
  
  HMMDEF hmm_mat4 HMM_Transpose(hmm_mat4 Matrix);
  
  HMMDEF hmm_mat4 HMM_Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far);
  HMMDEF hmm_mat4 HMM_Perspective(float FOV, float AspectRatio, float Near, float Far);
  
  HMMDEF hmm_mat4 HMM_Translate(hmm_vec3 Translation);
  HMMDEF hmm_mat4 HMM_Rotate(float Angle, hmm_vec3 Axis);
  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

#ifdef HANDMADE_MATH_CPP_MODE

HMMDEF float HMM_Length(hmm_vec2 A);
HMMDEF float HMM_Length(hmm_vec3 A);
HMMDEF float HMM_Length(hmm_vec4 A);

HMMDEF float HMM_LengthSquared(hmm_vec2 A);
HMMDEF float HMM_LengthSquared(hmm_vec3 A);
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);
HMMDEF hmm_vec3 HMM_Multiply(hmm_vec3 Left, hmm_vec3 Right);
HMMDEF hmm_vec3 HMM_Multiply(hmm_vec3 Left, float Right);
HMMDEF hmm_vec4 HMM_Multiply(hmm_vec4 Left, hmm_vec4 Right);
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);
HMMDEF hmm_vec3 HMM_Divide(hmm_vec3 Left, hmm_vec3 Right);
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_bool HMM_Equals(hmm_vec2 Left, hmm_vec2 Right);
HMMDEF hmm_bool HMM_Equals(hmm_vec3 Left, hmm_vec3 Right);
HMMDEF hmm_bool HMM_Equals(hmm_vec4 Left, hmm_vec4 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);

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_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);
HMMDEF hmm_vec4 &operator*=(hmm_vec4 &Left, hmm_vec4 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/=(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_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_bool operator==(hmm_vec2 Left, hmm_vec2 Right);
HMMDEF hmm_bool operator==(hmm_vec3 Left, hmm_vec3 Right);
HMMDEF hmm_bool operator==(hmm_vec4 Left, hmm_vec4 Right);

HMMDEF hmm_bool operator!=(hmm_vec2 Left, hmm_vec2 Right);
HMMDEF hmm_bool operator!=(hmm_vec3 Left, hmm_vec3 Right);
HMMDEF hmm_bool operator!=(hmm_vec4 Left, hmm_vec4 Right);

HMMDEF hmm_mat4 HMM_Mat4Identity();
HMMDEF hmm_vec2 HMM_LerpV2(hmm_vec2 A, float T, hmm_vec2 B);
HMMDEF hmm_vec3 HMM_LerpV3(hmm_vec3 A, float T, hmm_vec3 B);
HMMDEF hmm_vec4 HMM_LerpV4(hmm_vec4 A, float T, hmm_vec4 B);
HMMDEF hmm_vec4 HMM_AverageVec3(hmm_vec4* Arr, unsigned int Len);
HMMDEF hmm_vec4 HMM_AverageVec4(hmm_vec4* Arr, unsigned int Len);
HMMDEF bool HMM_SameSide(hmm_vec3 P1, hmm_vec3 P2, hmm_vec3 A, hmm_vec3 B);
HMMDEF bool HMM_PointInTriangle(hmm_vec3 P, hmm_vec3 T0, hmm_vec3 T1, hmm_vec3 T2);

#endif /* HANDMADE_MATH_CPP */

#ifdef __clang__
#pragma clang diagnostic pop
#endif

#endif /* HANDMADE_MATH_H */

#ifdef HANDMADE_MATH_IMPLEMENTATION

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
#pragma clang diagnostic ignored "-Wmissing-braces"
#endif

HINLINE float
HMM_SinF(float Angle)
{
  float Result = 0.0f;
  
  Result = HMM_SINF(Angle);
  return (Result);
}

HINLINE float
HMM_CosF(float Angle)
{
  float Result = 0.0f;
  
  Result = HMM_COSF(Angle);
  return (Result);
}

HINLINE float
HMM_TanF(float Radians)
{
  float Result = 0.0f;
  
  Result = HMM_TANF(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)
{
  float Result = 0.0f;
  
  Result = HMM_EXPF(Float);
  return (Result);
}

HINLINE float
HMM_LogF(float Float)
{
  float Result = 0.0f;
  
  Result = HMM_LOGF(Float);
  return (Result);
}

HINLINE float
HMM_ToRadians(float Degrees)
{
  float Result = 0.0f;
  
  Result = Degrees * (HMM_PI32 / 180.0f);
  return (Result);
}

HINLINE float
HMM_SquareRootF(float Value)
{
  float Result = 0.0f;
  
#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);
}

HINLINE float
HMM_RSquareRootF(float Value)
{
  float Result = 0.0f;
  
#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);
}

HINLINE float
HMM_LengthSquaredVec2(hmm_vec2 A)
{
  float Result = 0.0f;
  
  Result = HMM_DotVec2(A, A);
  
  return(Result);
}

HINLINE float
HMM_LengthSquaredVec3(hmm_vec3 A)
{
  float Result = 0.0f;
  
  Result = HMM_DotVec3(A, A);
  
  return (Result);
}

HINLINE float 
HMM_LengthSquaredVec4(hmm_vec4 A)
{
  float Result = 0.0f;
  
  Result = HMM_DotVec4(A, A);
  
  return(Result);
}

HINLINE float
HMM_LengthVec2(hmm_vec2 A)
{
  float Result = 0.0f;
  
  Result = HMM_SquareRootF(HMM_LengthSquaredVec2(A));
  
  return(Result);
}

HINLINE float
HMM_LengthVec3(hmm_vec3 A)
{
  float Result = 0.0f;
  
  Result = HMM_SquareRootF(HMM_LengthSquaredVec3(A));
  
  return (Result);
}

HINLINE float 
HMM_LengthVec4(hmm_vec4 A)
{
  float Result = 0.0f;
  
  Result = HMM_SquareRootF(HMM_LengthSquaredVec4(A));
  
  return(Result);
}

HINLINE float
HMM_Power(float Base, int Exponent)
{
  float Result = 1.0f;
  float Mul = Exponent < 0 ? 1.f / Base : Base;
  int X = Exponent < 0 ? -Exponent : Exponent;
  while (X)
  {
    if (X & 1)
    {
      Result *= Mul;
    }
    
    Mul *= Mul;
    X >>= 1;
  }
  
  return (Result);
}

HINLINE float
HMM_PowerF(float Base, float Exponent)
{
  return HMM_EXPF(Exponent * HMM_LOGF(Base));
}

HINLINE float
HMM_Lerp(float A, float Time, float B)
{
  float Result = 0;
  
  Result = (1.0f - Time) * A + Time * B;
  return (Result);
}

HINLINE float
HMM_Clamp(float Min, float Value, float Max)
{
  float Result = Value;
  
  if(Result < Min)
  {
    Result = Min;
  }
  else if(Result > Max)
  {
    Result = Max;
  }
  
  return (Result);
}

HINLINE hmm_vec2
HMM_NormalizeVec2(hmm_vec2 A)
{
  hmm_vec2 Result = {0};
  
  float VectorLength = HMM_LengthVec2(A);
  
  /* 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);
}

HINLINE hmm_vec3
HMM_NormalizeVec3(hmm_vec3 A)
{
  hmm_vec3 Result = {0};
  
  float VectorLength = HMM_LengthVec3(A);
  
  /* 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);
}

HINLINE hmm_vec4
HMM_NormalizeVec4(hmm_vec4 A)
{
  hmm_vec4 Result = {0};
  
  float VectorLength = HMM_LengthVec4(A);
  
  /* 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);
}

HINLINE float
HMM_DotVec2(hmm_vec2 VecOne, hmm_vec2 VecTwo)
{
  float Result = 0.0f;
  
  Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y);
  
  return (Result);
}

HINLINE float
HMM_DotVec3(hmm_vec3 VecOne, hmm_vec3 VecTwo)
{
  float Result = 0.0f;
  
  Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z);
  
  return (Result);
}

HINLINE float
HMM_DotVec4(hmm_vec4 VecOne, hmm_vec4 VecTwo)
{
  float Result = 0.0f;
  
  Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z) + (VecOne.W * VecTwo.W);
  
  return (Result);
}

HINLINE hmm_vec3
HMM_Cross(hmm_vec3 VecOne, hmm_vec3 VecTwo)
{
  hmm_vec3 Result = {0};
  
  Result.X = (VecOne.Y * VecTwo.Z) - (VecOne.Z * VecTwo.Y);
  Result.Y = (VecOne.Z * VecTwo.X) - (VecOne.X * VecTwo.Z);
  Result.Z = (VecOne.X * VecTwo.Y) - (VecOne.Y * VecTwo.X);
  
  return (Result);
}

HINLINE hmm_vec2
HMM_Vec2(float X, float Y)
{
  hmm_vec2 Result = {0};
  
  Result.X = X;
  Result.Y = Y;
  
  return (Result);
}

HINLINE hmm_vec2
HMM_Vec2i(int X, int Y)
{
  hmm_vec2 Result = {0};
  
  Result.X = (float)X;
  Result.Y = (float)Y;
  
  return (Result);
}

HINLINE hmm_vec3
HMM_Vec3(float X, float Y, float Z)
{
  hmm_vec3 Result = {0};
  
  Result.X = X;
  Result.Y = Y;
  Result.Z = Z;
  
  return (Result);
}

HINLINE hmm_vec3
HMM_Vec3i(int X, int Y, int Z)
{
  hmm_vec3 Result = {0};
  
  Result.X = (float)X;
  Result.Y = (float)Y;
  Result.Z = (float)Z;
  
  return (Result);
}

HINLINE hmm_vec4
HMM_Vec4(float X, float Y, float Z, float W)
{
  hmm_vec4 Result = {0};
  
  Result.X = X;
  Result.Y = Y;
  Result.Z = Z;
  Result.W = W;
  
  return (Result);
}

HINLINE hmm_vec4
HMM_Vec4i(int X, int Y, int Z, int W)
{
  hmm_vec4 Result = {0};
  
  Result.X = (float)X;
  Result.Y = (float)Y;
  Result.Z = (float)Z;
  Result.W = (float)W;
  
  return (Result);
}

HINLINE hmm_vec4
HMM_Vec4v(hmm_vec3 Vector, float W)
{
  hmm_vec4 Result = {0};
  
  Result.XYZ = Vector;
  Result.W = W;
  
  return (Result);
}

HINLINE hmm_vec2
HMM_AddVec2(hmm_vec2 Left, hmm_vec2 Right)
{
  hmm_vec2 Result = {0};
  
  Result.X = Left.X + Right.X;
  Result.Y = Left.Y + Right.Y;
  
  return (Result);
}

HINLINE hmm_vec3
HMM_AddVec3(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result.X = Left.X + Right.X;
  Result.Y = Left.Y + Right.Y;
  Result.Z = Left.Z + Right.Z;
  
  return (Result);
}

HINLINE hmm_vec4
HMM_AddVec4(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 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_vec2
HMM_SubtractVec2(hmm_vec2 Left, hmm_vec2 Right)
{
  hmm_vec2 Result = {0};
  
  Result.X = Left.X - Right.X;
  Result.Y = Left.Y - Right.Y;
  
  return (Result);
}

HINLINE hmm_vec3
HMM_SubtractVec3(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result.X = Left.X - Right.X;
  Result.Y = Left.Y - Right.Y;
  Result.Z = Left.Z - Right.Z;
  
  return (Result);
}

HINLINE hmm_vec4
HMM_SubtractVec4(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 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_vec2
HMM_MultiplyVec2(hmm_vec2 Left, hmm_vec2 Right)
{
  hmm_vec2 Result = {0};
  
  Result.X = Left.X * Right.X;
  Result.Y = Left.Y * Right.Y;
  
  return (Result);
}

HINLINE hmm_vec2
HMM_MultiplyVec2f(hmm_vec2 Left, float Right)
{
  hmm_vec2 Result = {0};
  
  Result.X = Left.X * Right;
  Result.Y = Left.Y * Right;
  
  return (Result);
}

HINLINE hmm_vec3
HMM_MultiplyVec3(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result.X = Left.X * Right.X;
  Result.Y = Left.Y * Right.Y;
  Result.Z = Left.Z * Right.Z;
  
  return (Result);
}

HINLINE hmm_vec3
HMM_MultiplyVec3f(hmm_vec3 Left, float Right)
{
  hmm_vec3 Result = {0};
  
  Result.X = Left.X * Right;
  Result.Y = Left.Y * Right;
  Result.Z = Left.Z * Right;
  
  return (Result);
}

HINLINE hmm_vec4
HMM_MultiplyVec4(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 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_vec4
HMM_MultiplyVec4f(hmm_vec4 Left, float Right)
{
  hmm_vec4 Result = {0};
  
  Result.X = Left.X * Right;
  Result.Y = Left.Y * Right;
  Result.Z = Left.Z * Right;
  Result.W = Left.W * Right;
  
  return (Result);
}

HINLINE hmm_vec2
HMM_DivideVec2(hmm_vec2 Left, hmm_vec2 Right)
{
  hmm_vec2 Result = {0};
  
  Result.X = Left.X / Right.X;
  Result.Y = Left.Y / Right.Y;
  
  return (Result);
}

HINLINE hmm_vec2
HMM_DivideVec2f(hmm_vec2 Left, float Right)
{
  hmm_vec2 Result = {0};
  
  Result.X = Left.X / Right;
  Result.Y = Left.Y / Right;
  
  return (Result);
}

HINLINE hmm_vec3
HMM_DivideVec3(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result.X = Left.X / Right.X;
  Result.Y = Left.Y / Right.Y;
  Result.Z = Left.Z / Right.Z;
  
  return (Result);
}

HINLINE hmm_vec3
HMM_DivideVec3f(hmm_vec3 Left, float Right)
{
  hmm_vec3 Result = {0};
  
  Result.X = Left.X / Right;
  Result.Y = Left.Y / Right;
  Result.Z = Left.Z / Right;
  
  return (Result);
}

HINLINE hmm_vec4
HMM_DivideVec4(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 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_vec4
HMM_DivideVec4f(hmm_vec4 Left, float Right)
{
  hmm_vec4 Result = {0};
  
  Result.X = Left.X / Right;
  Result.Y = Left.Y / Right;
  Result.Z = Left.Z / Right;
  Result.W = Left.W / Right;
  
  return (Result);
}

HINLINE hmm_bool
HMM_EqualsVec2(hmm_vec2 Left, hmm_vec2 Right)
{
  hmm_bool Result = 0;
  
  Result = (Left.X == Right.X && Left.Y == Right.Y);
  
  return (Result);
}

HINLINE hmm_bool
HMM_EqualsVec3(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_bool Result = 0;
  
  Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z);
  
  return (Result);
}

HINLINE hmm_bool
HMM_EqualsVec4(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_bool Result = 0;
  
  Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z && Left.W == Right.W);
  
  return (Result);
}

HINLINE hmm_mat4
HMM_Mat4(void)
{
  hmm_mat4 Result = {0};
  
  return (Result);
}

HINLINE hmm_mat4
HMM_Mat4d(float Diagonal)
{
  hmm_mat4 Result = HMM_Mat4();
  
  Result.Elements[0][0] = Diagonal;
  Result.Elements[1][1] = Diagonal;
  Result.Elements[2][2] = Diagonal;
  Result.Elements[3][3] = Diagonal;
  
  return (Result);
}

HINLINE hmm_mat4
HMM_AddMat4(hmm_mat4 Left, hmm_mat4 Right)
{
  hmm_mat4 Result = HMM_Mat4();
  
  int Columns;
  for(Columns = 0; Columns < 4; ++Columns)
  {
    int Rows;
    for(Rows = 0; Rows < 4; ++Rows)
    {
      Result.Elements[Columns][Rows] = Left.Elements[Columns][Rows] + Right.Elements[Columns][Rows];
    }
  }
  
  return (Result);
}

HINLINE hmm_mat4
HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right)
{
  hmm_mat4 Result = HMM_Mat4();
  
  int Columns;
  for(Columns = 0; Columns < 4; ++Columns)
  {
    int Rows;
    for(Rows = 0; Rows < 4; ++Rows)
    {
      Result.Elements[Columns][Rows] = Left.Elements[Columns][Rows] - Right.Elements[Columns][Rows];
    }
  }
  
  return (Result);
}

#ifdef HANDMADE_MATH__USE_SSE
HINLINE __m128
HMM_LinearCombineSSE(__m128 Left, hmm_mat4 Right)
{
  __m128 Result = {};
  Result = _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x00), Right.Rows[0]);
  Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x55), Right.Rows[1]));
  Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xaa), Right.Rows[2]));
  Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xff), Right.Rows[3]));
  
  return(Result);
}
#endif

HINLINE hmm_mat4
HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right)
{
  hmm_mat4 Result = HMM_Mat4();
  
#ifdef HANDMADE_MATH__USE_SSE
  
  hmm_mat4 TransposedLeft = HMM_Transpose(Left);
  hmm_mat4 TransposedRight = HMM_Transpose(Right);
  
  Result.Rows[0] = HMM_LinearCombineSSE(TransposedLeft.Rows[0], TransposedRight);
  Result.Rows[1] = HMM_LinearCombineSSE(TransposedLeft.Rows[1], TransposedRight);
  Result.Rows[2] = HMM_LinearCombineSSE(TransposedLeft.Rows[2], TransposedRight);
  Result.Rows[3] = HMM_LinearCombineSSE(TransposedLeft.Rows[3], TransposedRight);       
  
  Result = HMM_Transpose(Result);
  
#else
  int Columns;
  for(Columns = 0; Columns < 4; ++Columns)
  {
    int Rows;
    for(Rows = 0; Rows < 4; ++Rows)
    {
      float Sum = 0;
      int CurrentMatrice;
      for(CurrentMatrice = 0; CurrentMatrice < 4; ++CurrentMatrice)
      {
        Sum += Left.Elements[CurrentMatrice][Rows] * Right.Elements[Columns][CurrentMatrice];
      }
      
      Result.Elements[Columns][Rows] = Sum;
    }
  }
#endif 
  return (Result);
}

HINLINE hmm_mat4
HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar)
{
  hmm_mat4 Result = HMM_Mat4();
  
  int Columns;
  for(Columns = 0; Columns < 4; ++Columns)
  {
    int Rows;
    for(Rows = 0; Rows < 4; ++Rows)
    {
      Result.Elements[Columns][Rows] = Matrix.Elements[Columns][Rows] * Scalar;
    }
  }
  
  return (Result);
}

HINLINE hmm_vec4
HMM_MultiplyMat4ByVec4(hmm_mat4 Matrix, hmm_vec4 Vector)
{
  hmm_vec4 Result = {0};
  
  int Columns, Rows;
  for(Rows = 0; Rows < 4; ++Rows)
  {
    float Sum = 0;
    for(Columns = 0; Columns < 4; ++Columns)
    {
      Sum += Matrix.Elements[Columns][Rows] * Vector.Elements[Columns];
    }
    
    Result.Elements[Rows] = Sum;
  }
  
  return (Result);
}

HINLINE hmm_mat4
HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar)
{
  hmm_mat4 Result = HMM_Mat4();
  
  int Columns;
  for(Columns = 0; Columns < 4; ++Columns)
  {
    int Rows;
    for(Rows = 0; Rows < 4; ++Rows)
    {
      Result.Elements[Columns][Rows] = Matrix.Elements[Columns][Rows] / Scalar;
    }
  }
  
  return (Result);
}

HINLINE hmm_mat4
HMM_Transpose(hmm_mat4 Matrix)
{
  hmm_mat4 Result = HMM_Mat4();
  
#ifdef HANDMADE_MATH__USE_SSE
  Result = Matrix;
  
  _MM_TRANSPOSE4_PS(Result.Rows[0], Result.Rows[1], Result.Rows[2], Result.Rows[3]);    
#else 
  int Columns;
  for(Columns = 0; Columns < 4; ++Columns)
  {
    int Rows;
    for(Rows = 0; Rows < 4; ++Rows)
    {
      Result.Elements[Rows][Columns] = Matrix.Elements[Columns][Rows];
    }
  }
#endif 
  
  return (Result);
}

HINLINE hmm_mat4
HMM_Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far)
{
  hmm_mat4 Result = HMM_Mat4d(1.0f);
  
  Result.Elements[0][0] = 2.0f / (Right - Left);
  Result.Elements[1][1] = 2.0f / (Top - Bottom);
  Result.Elements[2][2] = 2.0f / (Near - Far);
  
  Result.Elements[3][0] = (Left + Right) / (Left - Right);
  Result.Elements[3][1] = (Bottom + Top) / (Bottom - Top);
  Result.Elements[3][2] = (Far + Near) / (Near - Far);
  
  return (Result);
}

HINLINE hmm_mat4
HMM_Perspective(float FOV, float AspectRatio, float Near, float Far)
{
  hmm_mat4 Result = HMM_Mat4d(1.0f);
  
  float TanThetaOver2 = HMM_TanF(FOV * (HMM_PI32 / 360.0f));
  
  Result.Elements[0][0] = 1.0f / TanThetaOver2;
  Result.Elements[1][1] = AspectRatio / TanThetaOver2;
  Result.Elements[2][3] = -1.0f;
  Result.Elements[2][2] = (Near + Far) / (Near - Far);
  Result.Elements[3][2] = (2.0f * Near * Far) / (Near - Far);
  Result.Elements[3][3] = 0.0f;
  
  return (Result);
}

HINLINE hmm_mat4
HMM_Translate(hmm_vec3 Translation)
{
  hmm_mat4 Result = HMM_Mat4d(1.0f);
  
  Result.Elements[3][0] = Translation.X;
  Result.Elements[3][1] = Translation.Y;
  Result.Elements[3][2] = Translation.Z;
  
  return (Result);
}

HINLINE hmm_mat4
HMM_Rotate(float Angle, hmm_vec3 Axis)
{
  hmm_mat4 Result = HMM_Mat4d(1.0f);
  
  Axis = HMM_NormalizeVec3(Axis);
  
  float SinTheta = HMM_SinF(HMM_ToRadians(Angle));
  float CosTheta = HMM_CosF(HMM_ToRadians(Angle));
  float CosValue = 1.0f - CosTheta;
  
  Result.Elements[0][0] = (Axis.X * Axis.X * CosValue) + CosTheta;
  Result.Elements[0][1] = (Axis.X * Axis.Y * CosValue) + (Axis.Z * SinTheta);
  Result.Elements[0][2] = (Axis.X * Axis.Z * CosValue) - (Axis.Y * SinTheta);
  
  Result.Elements[1][0] = (Axis.Y * Axis.X * CosValue) - (Axis.Z * SinTheta);
  Result.Elements[1][1] = (Axis.Y * Axis.Y * CosValue) + CosTheta;
  Result.Elements[1][2] = (Axis.Y * Axis.Z * CosValue) + (Axis.X * SinTheta);
  
  Result.Elements[2][0] = (Axis.Z * Axis.X * CosValue) + (Axis.Y * SinTheta);
  Result.Elements[2][1] = (Axis.Z * Axis.Y * CosValue) - (Axis.X * SinTheta);
  Result.Elements[2][2] = (Axis.Z * Axis.Z * CosValue) + CosTheta;
  
  return (Result);
}

HINLINE hmm_mat4
HMM_Scale(hmm_vec3 Scale)
{
  hmm_mat4 Result = HMM_Mat4d(1.0f);
  
  Result.Elements[0][0] = Scale.X;
  Result.Elements[1][1] = Scale.Y;
  Result.Elements[2][2] = Scale.Z;
  
  return (Result);
}

HINLINE hmm_mat4
HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up)
{
  hmm_mat4 Result = {0};
  
  hmm_vec3 F = HMM_NormalizeVec3(HMM_SubtractVec3(Center, Eye));
  hmm_vec3 S = HMM_NormalizeVec3(HMM_Cross(F, Up));
  hmm_vec3 U = HMM_Cross(S, F);
  
  Result.Elements[0][0] = S.X;
  Result.Elements[0][1] = U.X;
  Result.Elements[0][2] = -F.X;
  
  Result.Elements[1][0] = S.Y;
  Result.Elements[1][1] = U.Y;
  Result.Elements[1][2] = -F.Y;
  
  Result.Elements[2][0] = S.Z;
  Result.Elements[2][1] = U.Z;
  Result.Elements[2][2] = -F.Z;
  
  Result.Elements[3][0] = -HMM_DotVec3(S, Eye);
  Result.Elements[3][1] = -HMM_DotVec3(U, Eye);
  Result.Elements[3][2] = HMM_DotVec3(F, Eye);
  Result.Elements[3][3] = 1.0f;
  
  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;
  
  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;
  hmm_quaternion QuaternionLeft;
  hmm_quaternion QuaternionRight;
  
  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;
  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;
  
  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);
}

// Extensions

HINLINE hmm_mat4
HMM_Mat4Identity()
{
  hmm_mat4 Result = {};
  
  Result.Elements[0][0] = 1;
  Result.Elements[0][1] = 0;
  Result.Elements[0][2] = 0;
  Result.Elements[0][3] = 0;
  
  Result.Elements[1][0] = 0;
  Result.Elements[1][1] = 1;
  Result.Elements[1][2] = 0;
  Result.Elements[1][3] = 0;
  
  Result.Elements[2][0] = 0;
  Result.Elements[2][1] = 0;
  Result.Elements[2][2] = 1;
  Result.Elements[2][3] = 0;
  
  Result.Elements[3][0] = 0;
  Result.Elements[3][1] = 0;
  Result.Elements[3][2] = 0;
  Result.Elements[3][3] = 1;
  
  return Result;
}

#define HMMToV2(v) (v2){ (v).X, (v).Y }
#define HMMToV3(v) (v3){ (v).X, (v).Y, (v).Z }
#define HMMToV4(v) (v4){ (v).X, (v).Y, (v).Z, (v).W }

#define ToHMMV2(v) (hmm_vec2){ (v).x, (v).y }
#define ToHMMV3(v) (hmm_vec3){ (v).x, (v).y, (v).z }
#define ToHMMV4(v) (hmm_vec4){ (v).x, (v).y, (v).z, (v).w }

HINLINE hmm_vec2
HMM_LerpV2(hmm_vec2 A, float T, hmm_vec2 B)
{
  hmm_vec2 Result = {};
  Result.X = HMM_Lerp(A.X, T, B.X);
  Result.Y = HMM_Lerp(A.Y, T, B.Y);
  return Result;
}
HINLINE hmm_vec3
HMM_LerpV3(hmm_vec3 A, float T, hmm_vec3 B)
{
  hmm_vec3 Result = {};
  Result.X = HMM_Lerp(A.X, T, B.X);
  Result.Y = HMM_Lerp(A.Y, T, B.Y);
  Result.Z = HMM_Lerp(A.Z, T, B.Z);
  return Result;
}
HINLINE hmm_vec4
HMM_LerpV4(hmm_vec4 A, float T, hmm_vec4 B)
{
  hmm_vec4 Result = {};
  Result.X = HMM_Lerp(A.X, T, B.X);
  Result.Y = HMM_Lerp(A.Y, T, B.Y);
  Result.Z = HMM_Lerp(A.Z, T, B.Z);
  Result.W = HMM_Lerp(A.W, T, B.W);
  return Result;
}

// Range

static bool
HMM_V2RContains(hmm_v2r Range, hmm_v2 P)
{
  return (Range.ValueMin.x <= P.x &&
          Range.ValueMin.y <= P.y &&
          Range.ValueMax.x >= P.x &&
          Range.ValueMax.y >= P.y);
}

static hmm_v2
HMM_V2RSize(hmm_v2r Range)
{
  hmm_v2 Result = {};
  Result.x = Range.ValueMax.x - Range.ValueMin.x;
  Result.y = Range.ValueMax.y - Range.ValueMin.y;
  return Result;
}

#define HMM_V2RWidth(r) HMM_V2RSize(r).x
#define HMM_V2RHeight(r) HMM_V2RSize(r).y

static hmm_v2r
HMM_V2ROffset(hmm_v2r Range, hmm_v2 Offset)
{
  hmm_v2r Result = {};
  Result.ValueMin = HMM_AddVec2(Range.ValueMin, Offset);
  Result.ValueMax = HMM_AddVec2(Range.ValueMax, Offset);
  return Result;
}

// Geometry

static hmm_vec3
HMM_AverageVec3(hmm_vec3* Arr, int Len)
{
  hmm_vec3 Total = {};
  for (int i = 0; i < Len; i++) 
  {
    Total = HMM_AddVec3(Total, Arr[i]);
  }
  
  hmm_vec3 Result = {};
  Result.x = Total.x / Len;
  Result.y = Total.y / Len;
  Result.z = Total.z / Len;
  
  return Result;
}

static hmm_vec4
HMM_AverageVec4(hmm_vec4* Arr, int Len)
{
  hmm_vec4 Total = {};
  for (int i = 0; i < Len; i++) 
  {
    Total = HMM_AddVec4(Total, Arr[i]);
  }
  
  hmm_vec4 Result = {};
  Result.x = Total.x / Len;
  Result.y = Total.y / Len;
  Result.z = Total.z / Len;
  Result.w = Total.w / Len;
  return Result;
}

// Point In Triangle From: https://blackpawn.com/texts/pointinpoly/default.html
static bool
HMM_SameSide(hmm_vec3 P1, hmm_vec3 P2, hmm_vec3 A, hmm_vec3 B)
{
  hmm_vec3 BA = HMM_SubtractVec3(B, A);
  hmm_vec3 P1A = HMM_SubtractVec3(P1, A);
  hmm_vec3 P2A = HMM_SubtractVec3(P2, A);
  hmm_vec3 CP1 = HMM_Cross(BA, P1A);
  hmm_vec3 CP2 = HMM_Cross(BA, P2A);
  return (HMM_DotVec3(CP1, CP2) >= 0);
}

static bool
HMM_PointInTriangle(hmm_vec3 P, hmm_vec3 T0, hmm_vec3 T1, hmm_vec3 T2)
{
  return (HMM_SameSide(P, T0, T1, T2) &&
          HMM_SameSide(P, T1, T0, T2) &&
          HMM_SameSide(P, T2, T0, T1));
}

#ifdef HANDMADE_MATH_CPP_MODE

HINLINE float 
HMM_Length(hmm_vec2 A)
{
  float Result = 0.0f;
  
  Result = HMM_LengthVec2(A);
  
  return(Result);
}

HINLINE float 
HMM_Length(hmm_vec3 A)
{
  float Result = 0.0f;
  
  Result = HMM_LengthVec3(A);
  
  return(Result);
}

HINLINE float 
HMM_Length(hmm_vec4 A)
{
  float Result = 0.0f;
  
  Result = HMM_LengthVec4(A);
  
  return(Result);
}

HINLINE float 
HMM_LengthSquared(hmm_vec2 A)
{
  float Result = 0.0f;
  
  Result = HMM_LengthSquaredVec2(A);
  
  return(Result);
}

HINLINE float 
HMM_LengthSquared(hmm_vec3 A)
{
  float Result = 0.0f;
  
  Result = HMM_LengthSquaredVec3(A);
  
  return(Result);
}

HINLINE float 
HMM_LengthSquared(hmm_vec4 A)
{
  float Result = 0.0f;
  
  Result = HMM_LengthSquaredVec4(A);
  
  return(Result);
}

HINLINE hmm_vec2 
HMM_Normalize(hmm_vec2 A)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_NormalizeVec2(A);    
  
  return(Result);
}

HINLINE hmm_vec3 
HMM_Normalize(hmm_vec3 A)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_NormalizeVec3(A);
  
  return(Result);
}

HINLINE hmm_vec4 
HMM_Normalize(hmm_vec4 A)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_NormalizeVec4(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)
{
  float Result = 0;
  
  Result = HMM_DotVec2(VecOne, VecTwo);
  
  return(Result);
}

HINLINE float 
HMM_Dot(hmm_vec3 VecOne, hmm_vec3 VecTwo)
{
  float Result = 0;
  
  Result = HMM_DotVec3(VecOne, VecTwo);
  
  return(Result);
}

HINLINE float 
HMM_Dot(hmm_vec4 VecOne, hmm_vec4 VecTwo)
{
  float Result = 0;
  
  Result = HMM_DotVec4(VecOne, 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)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_AddVec2(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
HMM_Add(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_AddVec3(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
HMM_Add(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_AddVec4(Left, Right);
  return (Result);
}

HINLINE hmm_mat4
HMM_Add(hmm_mat4 Left, hmm_mat4 Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_AddMat4(Left, 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)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_SubtractVec2(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
HMM_Subtract(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_SubtractVec3(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
HMM_Subtract(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_SubtractVec4(Left, Right);
  return (Result);
}

HINLINE hmm_mat4
HMM_Subtract(hmm_mat4 Left, hmm_mat4 Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_SubtractMat4(Left, 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)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_MultiplyVec2(Left, Right);
  return (Result);
}

HINLINE hmm_vec2
HMM_Multiply(hmm_vec2 Left, float Right)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_MultiplyVec2f(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
HMM_Multiply(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_MultiplyVec3(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
HMM_Multiply(hmm_vec3 Left, float Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_MultiplyVec3f(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
HMM_Multiply(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_MultiplyVec4(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
HMM_Multiply(hmm_vec4 Left, float Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_MultiplyVec4f(Left, Right);
  return (Result);
}

HINLINE hmm_mat4
HMM_Multiply(hmm_mat4 Left, hmm_mat4 Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_MultiplyMat4(Left, Right);
  return (Result);
}

HINLINE hmm_mat4
HMM_Multiply(hmm_mat4 Left, float Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_MultiplyMat4f(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
HMM_Multiply(hmm_mat4 Matrix, hmm_vec4 Vector)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_MultiplyMat4ByVec4(Matrix, 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)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_DivideVec2(Left, Right);
  return (Result);
}

HINLINE hmm_vec2
HMM_Divide(hmm_vec2 Left, float Right)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_DivideVec2f(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
HMM_Divide(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_DivideVec3(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
HMM_Divide(hmm_vec3 Left, float Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_DivideVec3f(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
HMM_Divide(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_DivideVec4(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
HMM_Divide(hmm_vec4 Left, float Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_DivideVec4f(Left, Right);
  return (Result);
}

HINLINE hmm_mat4
HMM_Divide(hmm_mat4 Left, float Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_DivideMat4f(Left, 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_bool
HMM_Equals(hmm_vec2 Left, hmm_vec2 Right)
{
  hmm_bool Result = 0;
  
  Result = HMM_EqualsVec2(Left, Right);
  return (Result);
}

HINLINE hmm_bool
HMM_Equals(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_bool Result = 0;
  
  Result = HMM_EqualsVec3(Left, Right);
  return (Result);
}

HINLINE hmm_bool
HMM_Equals(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_bool Result = 0;
  
  Result = HMM_EqualsVec4(Left, Right);
  return (Result);
}

HINLINE hmm_vec2
operator+(hmm_vec2 Left, hmm_vec2 Right)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_Add(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
operator+(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_Add(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
operator+(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_Add(Left, Right);
  return (Result);
}

HINLINE hmm_mat4
operator+(hmm_mat4 Left, hmm_mat4 Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_Add(Left, 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)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_Subtract(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
operator-(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_Subtract(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
operator-(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_Subtract(Left, Right);
  return (Result);
}

HINLINE hmm_mat4
operator-(hmm_mat4 Left, hmm_mat4 Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_Subtract(Left, 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)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_Multiply(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
operator*(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_Multiply(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
operator*(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 Result = HMM_Multiply(Left, Right);
  
  return (Result);
}

HINLINE hmm_vec2
operator*(hmm_vec2 Left, float Right)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_Multiply(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
operator*(hmm_vec3 Left, float Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_Multiply(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
operator*(hmm_vec4 Left, float Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_Multiply(Left, Right);
  return (Result);
}

HINLINE hmm_mat4
operator*(hmm_mat4 Left, float Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_Multiply(Left, Right);
  return (Result);
}

HINLINE hmm_vec2
operator*(float Left, hmm_vec2 Right)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_Multiply(Right, Left);
  return (Result);
}

HINLINE hmm_vec3
operator*(float Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_Multiply(Right, Left);
  return (Result);
}

HINLINE hmm_vec4
operator*(float Left, hmm_vec4 Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_Multiply(Right, Left);
  return (Result);
}

HINLINE hmm_mat4
operator*(float Left, hmm_mat4 Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_Multiply(Right, Left);
  return (Result);
}

HINLINE hmm_mat4
operator*(hmm_mat4 Left, hmm_mat4 Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_Multiply(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
operator*(hmm_mat4 Matrix, hmm_vec4 Vector)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_Multiply(Matrix, 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)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_Divide(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
operator/(hmm_vec3 Left, hmm_vec3 Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_Divide(Left, Right);
  
  return (Result);
}

HINLINE hmm_vec4
operator/(hmm_vec4 Left, hmm_vec4 Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_Divide(Left, Right);
  return (Result);
}

HINLINE hmm_vec2
operator/(hmm_vec2 Left, float Right)
{
  hmm_vec2 Result = {0};
  
  Result = HMM_Divide(Left, Right);
  return (Result);
}

HINLINE hmm_vec3
operator/(hmm_vec3 Left, float Right)
{
  hmm_vec3 Result = {0};
  
  Result = HMM_Divide(Left, Right);
  return (Result);
}

HINLINE hmm_vec4
operator/(hmm_vec4 Left, float Right)
{
  hmm_vec4 Result = {0};
  
  Result = HMM_Divide(Left, Right);
  return (Result);
}

HINLINE hmm_mat4
operator/(hmm_mat4 Left, float Right)
{
  hmm_mat4 Result = {0};
  
  Result = HMM_Divide(Left, 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)
{    
  return (Left = Left + Right);
}

HINLINE hmm_vec3 &
operator+=(hmm_vec3 &Left, hmm_vec3 Right)
{    
  return (Left = Left + Right);
}

HINLINE hmm_vec4 &
operator+=(hmm_vec4 &Left, hmm_vec4 Right)
{    
  return (Left = Left + Right);
}

HINLINE hmm_mat4 &
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)
{    
  return (Left = Left - Right);
}

HINLINE hmm_vec3 &
operator-=(hmm_vec3 &Left, hmm_vec3 Right)
{    
  return (Left = Left - Right);
}

HINLINE hmm_vec4 &
operator-=(hmm_vec4 &Left, hmm_vec4 Right)
{    
  return (Left = Left - Right);
}

HINLINE hmm_mat4 &
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)
{    
  return (Left = Left / Right);
}

HINLINE hmm_vec3 &
operator/=(hmm_vec3 &Left, hmm_vec3 Right)
{    
  return (Left = Left / Right);
}

HINLINE hmm_vec4 &
operator/=(hmm_vec4 &Left, hmm_vec4 Right)
{    
  return (Left = Left / Right);
}

HINLINE hmm_vec2 &
operator/=(hmm_vec2 &Left, float Right)
{
  return (Left = Left / Right);
}

HINLINE hmm_vec3 &
operator/=(hmm_vec3 &Left, float Right)
{
  return (Left = Left / Right);
}

HINLINE hmm_vec4 &
operator/=(hmm_vec4 &Left, float Right)
{
  return (Left = Left / Right);
}

HINLINE hmm_mat4 &
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)
{    
  return (Left = Left * Right);
}

HINLINE hmm_vec3 &
operator*=(hmm_vec3 &Left, hmm_vec3 Right)
{    
  return (Left = Left * Right);
}

HINLINE hmm_vec4 &
operator*=(hmm_vec4 &Left, hmm_vec4 Right)
{    
  return (Left = Left * Right);
}

HINLINE hmm_vec2 &
operator*=(hmm_vec2 &Left, float Right)
{
  return (Left = Left * Right);
}

HINLINE hmm_vec3 &
operator*=(hmm_vec3 &Left, float Right)
{
  return (Left = Left * Right);
}

HINLINE hmm_vec4 &
operator*=(hmm_vec4 &Left, float Right)
{
  return (Left = Left * Right);
}

HINLINE hmm_mat4 &
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_bool
operator==(hmm_vec2 Left, hmm_vec2 Right)
{
  return HMM_EqualsVec2(Left, Right);    
}

HINLINE hmm_bool
operator==(hmm_vec3 Left, hmm_vec3 Right)
{
  return HMM_EqualsVec3(Left, Right);    
}

HINLINE hmm_bool
operator==(hmm_vec4 Left, hmm_vec4 Right)
{
  return HMM_EqualsVec4(Left, Right);    
}


HINLINE hmm_bool 
operator!=(hmm_vec2 Left, hmm_vec2 Right)
{
  return !HMM_EqualsVec2(Left, Right);    
}

HINLINE hmm_bool 
operator!=(hmm_vec3 Left, hmm_vec3 Right)
{
  return !HMM_EqualsVec3(Left, Right);    
}

HINLINE hmm_bool 
operator!=(hmm_vec4 Left, hmm_vec4 Right)
{
  return !HMM_EqualsVec4(Left, Right);    
}

#endif /* HANDMADE_MATH_CPP_MODE */

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif /* HANDMADE_MATH_IMPLEMENTATION */