#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

# 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>

#ifndef HANDMADE_MATH_H

#define HANDMADE_MATH_H

#ifdef _MSC_VER

#pragma warning(disable:4201)

#ifdef __clang__

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wgnu-anonymous-struct"

#ifdef __cplusplus

extern "C"

{

#define HMM_INLINE static inline

#define HMM_EXTERN extern

#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>

#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

#ifndef HMM_LOGF

#define HMM_LOGF logf

#ifndef HMM_ACOSF

#define HMM_ACOSF acosf

#ifndef HMM_ATANF

#define HMM_ATANF atanf

#ifndef HMM_ATAN2F

#define HMM_ATAN2F atan2f

#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 U, V;

};

struct

{

float Left, Right;

};

struct

{

float Width, Height;

};

float Elements[2];

#ifdef __cplusplus

inline float &operator[](int Index)

{

return Elements[Index];

}

} hmm_vec2;

typedef union hmm_vec3

{

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];

#ifdef __cplusplus

inline float &operator[](int Index)

{

return Elements[Index];

}

} hmm_vec3;

typedef union hmm_vec4

{

struct

{

union

{

hmm_vec3 XYZ;

struct

{

float X, Y, Z;

};

};

float W;

};

struct

{

union

{

hmm_vec3 RGB;

struct

{

float R, G, B;

};

};

float A;

};

struct

{

hmm_vec2 XY;

float Ignored0_;

float Ignored1_;

};

struct

{

float Ignored2_;

hmm_vec2 YZ;

float Ignored3_;

};

struct

{

float Ignored4_;

float Ignored5_;

hmm_vec2 ZW;

};

float Elements[4];

#ifdef HANDMADE_MATH__USE_SSE

__m128 InternalElementsSSE;

#ifdef __cplusplus

inline float &operator[](int Index)

{

return Elements[Index];

}

} hmm_vec4;

typedef union hmm_mat4

{

float Elements[4][4];

#ifdef HANDMADE_MATH__USE_SSE

__m128 Columns[4];

// DEPRECATED. Our matrices are column-major, so this was named

// incorrectly. Use Columns instead.

__m128 Rows[4];

#ifdef __cplusplus

inline hmm_vec4 operator[](const int Index)

{

float* col = Elements[Index];

hmm_vec4 result;

result.Elements[0] = col[0];

result.Elements[1] = col[1];

result.Elements[2] = col[2];

result.Elements[3] = col[3];

return result;

}

} hmm_mat4;

typedef union hmm_quaternion

{

struct

{

union

{

hmm_vec3 XYZ;

struct

{

float X, Y, Z;

};

};

float W;

};

float Elements[4];

} hmm_quaternion;

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;

HMM_INLINE float HMM_SinF(float Radians)

{

float Result = HMM_SINF(Radians);

return (Result);

}

HMM_INLINE float HMM_CosF(float Radians)

{

float Result = HMM_COSF(Radians);

return (Result);

}

HMM_INLINE float HMM_TanF(float Radians)

{

float Result = HMM_TANF(Radians);

return (Result);

}

HMM_INLINE float HMM_ACosF(float Radians)

{

float Result = HMM_ACOSF(Radians);

return (Result);

}

HMM_INLINE float HMM_ATanF(float Radians)

{

float Result = HMM_ATANF(Radians);

return (Result);

}

HMM_INLINE float HMM_ATan2F(float Left, float Right)

{

float Result = HMM_ATAN2F(Left, Right);

return (Result);

}

HMM_INLINE float HMM_ExpF(float Float)

{

float Result = HMM_EXPF(Float);

return (Result);

}

HMM_INLINE float HMM_LogF(float Float)

{

float Result = HMM_LOGF(Float);

return (Result);

}

HMM_INLINE float HMM_SquareRootF(float Float)

{

float Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 In = _mm_set_ss(Float);

__m128 Out = _mm_sqrt_ss(In);

Result = _mm_cvtss_f32(Out);

Result = HMM_SQRTF(Float);

#endif

return(Result);

}

HMM_INLINE float HMM_RSquareRootF(float Float)

{

float Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 In = _mm_set_ss(Float);

__m128 Out = _mm_rsqrt_ss(In);

Result = _mm_cvtss_f32(Out);

Result = 1.0f/HMM_SquareRootF(Float);

return(Result);

}

HMM_EXTERN float HMM_Power(float Base, int Exponent);

HMM_INLINE float HMM_PowerF(float Base, float Exponent)

{

float Result = HMM_EXPF(Exponent * HMM_LOGF(Base));

return (Result);

}

HMM_INLINE float HMM_ToRadians(float Degrees)

{

float Result = Degrees * (HMM_PI32 / 180.0f);

return (Result);

}

HMM_INLINE float HMM_Lerp(float A, float Time, float B)

{

float Result = (1.0f - Time) * A + Time * B;

return (Result);

}

HMM_INLINE 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);

}

HMM_INLINE hmm_vec2 HMM_Vec2(float X, float Y)

{

hmm_vec2 Result;

Result.X = X;

Result.Y = Y;

return (Result);

}

HMM_INLINE hmm_vec2 HMM_Vec2i(int X, int Y)

{

hmm_vec2 Result;

Result.X = (float)X;

Result.Y = (float)Y;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_Vec3(float X, float Y, float Z)

{

hmm_vec3 Result;

Result.X = X;

Result.Y = Y;

Result.Z = Z;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_Vec3i(int X, int Y, int Z)

{

hmm_vec3 Result;

Result.X = (float)X;

Result.Y = (float)Y;

Result.Z = (float)Z;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_Vec4(float X, float Y, float Z, float W)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_setr_ps(X, Y, Z, W);

Result.X = X;

Result.Y = Y;

Result.Z = Z;

Result.W = W;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_Vec4i(int X, int Y, int Z, int W)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_setr_ps((float)X, (float)Y, (float)Z, (float)W);

Result.X = (float)X;

Result.Y = (float)Y;

Result.Z = (float)Z;

Result.W = (float)W;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_Vec4v(hmm_vec3 Vector, float W)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_setr_ps(Vector.X, Vector.Y, Vector.Z, W);

Result.XYZ = Vector;

Result.W = W;

return (Result);

}

HMM_INLINE hmm_vec2 HMM_AddVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_vec2 Result;

Result.X = Left.X + Right.X;

Result.Y = Left.Y + Right.Y;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_AddVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_vec3 Result;

Result.X = Left.X + Right.X;

Result.Y = Left.Y + Right.Y;

Result.Z = Left.Z + Right.Z;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_AddVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_add_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);

#else

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);

}

HMM_INLINE hmm_vec2 HMM_SubtractVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_vec2 Result;

Result.X = Left.X - Right.X;

Result.Y = Left.Y - Right.Y;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_SubtractVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_vec3 Result;

Result.X = Left.X - Right.X;

Result.Y = Left.Y - Right.Y;

Result.Z = Left.Z - Right.Z;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_SubtractVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_sub_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);

#else

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);

}

HMM_INLINE hmm_vec2 HMM_MultiplyVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_vec2 Result;

Result.X = Left.X * Right.X;

Result.Y = Left.Y * Right.Y;

return (Result);

}

HMM_INLINE hmm_vec2 HMM_MultiplyVec2f(hmm_vec2 Left, float Right)

{

hmm_vec2 Result;

Result.X = Left.X * Right;

Result.Y = Left.Y * Right;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_MultiplyVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_vec3 Result;

Result.X = Left.X * Right.X;

Result.Y = Left.Y * Right.Y;

Result.Z = Left.Z * Right.Z;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_MultiplyVec3f(hmm_vec3 Left, float Right)

{

hmm_vec3 Result;

Result.X = Left.X * Right;

Result.Y = Left.Y * Right;

Result.Z = Left.Z * Right;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_MultiplyVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_mul_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);

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);

}

HMM_INLINE hmm_vec4 HMM_MultiplyVec4f(hmm_vec4 Left, float Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 Scalar = _mm_set1_ps(Right);

Result.InternalElementsSSE = _mm_mul_ps(Left.InternalElementsSSE, Scalar);

#else

Result.X = Left.X * Right;

Result.Y = Left.Y * Right;

Result.Z = Left.Z * Right;

Result.W = Left.W * Right;

return (Result);

}

HMM_INLINE hmm_vec2 HMM_DivideVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_vec2 Result;

Result.X = Left.X / Right.X;

Result.Y = Left.Y / Right.Y;

return (Result);

}

HMM_INLINE hmm_vec2 HMM_DivideVec2f(hmm_vec2 Left, float Right)

{

hmm_vec2 Result;

Result.X = Left.X / Right;

Result.Y = Left.Y / Right;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_DivideVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_vec3 Result;

Result.X = Left.X / Right.X;

Result.Y = Left.Y / Right.Y;

Result.Z = Left.Z / Right.Z;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_DivideVec3f(hmm_vec3 Left, float Right)

{

hmm_vec3 Result;

Result.X = Left.X / Right;

Result.Y = Left.Y / Right;

Result.Z = Left.Z / Right;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_DivideVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_div_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);

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);

}

HMM_INLINE hmm_vec4 HMM_DivideVec4f(hmm_vec4 Left, float Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 Scalar = _mm_set1_ps(Right);

Result.InternalElementsSSE = _mm_div_ps(Left.InternalElementsSSE, Scalar);

#else

Result.X = Left.X / Right;

Result.Y = Left.Y / Right;

Result.Z = Left.Z / Right;

Result.W = Left.W / Right;

return (Result);

}

HMM_INLINE hmm_bool HMM_EqualsVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y);

return (Result);

}

HMM_INLINE hmm_bool HMM_EqualsVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z);

return (Result);

}

HMM_INLINE hmm_bool HMM_EqualsVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z && Left.W == Right.W);

return (Result);

}

HMM_INLINE float HMM_DotVec2(hmm_vec2 VecOne, hmm_vec2 VecTwo)

{

float Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y);

return (Result);

}

HMM_INLINE float HMM_DotVec3(hmm_vec3 VecOne, hmm_vec3 VecTwo)

{

float Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z);

return (Result);

}

HMM_INLINE float HMM_DotVec4(hmm_vec4 VecOne, hmm_vec4 VecTwo)

{

float Result;

// NOTE(zak): IN the future if we wanna check what version SSE is support

// we can use _mm_dp_ps (4.3) but for now we will use the old way.

// Or a r = _mm_mul_ps(v1, v2), r = _mm_hadd_ps(r, r), r = _mm_hadd_ps(r, r) for SSE3