/*

HandmadeMath.h v2.0.0

This is a single header file with a bunch of useful types and functions for

games and graphics. Consider it a lightweight alternative to GLM that works

both C and C++.

=============================================================================

CONFIG

=============================================================================

By default, all angles in Handmade Math are specified in radians. However, it

can be configured to use degrees or turns instead. Use one of the following

defines to specify the default unit for angles:

#define HANDMADE_MATH_USE_RADIANS

#define HANDMADE_MATH_USE_DEGREES

#define HANDMADE_MATH_USE_TURNS

Regardless of the default angle, you can use the following functions to

specify an angle in a particular unit:

HMM_AngleRad(radians)

HMM_AngleDeg(degrees)

HMM_AngleTurn(turns)

The definitions of these functions change depending on the default unit.

-----------------------------------------------------------------------------

Handmade Math ships with SSE (SIMD) implementations of several common

operations. To disable the use of SSE intrinsics, you must define

HANDMADE_MATH_NO_SSE before including this file:

#define HANDMADE_MATH_NO_SSE

#include "HandmadeMath.h"

-----------------------------------------------------------------------------

To use Handmade Math without the C runtime library, you must provide your own

implementations of basic math functions. Otherwise, HandmadeMath.h will use

the runtime library implementation of these functions.

Define HANDMADE_MATH_PROVIDE_MATH_FUNCTIONS and provide your own

implementations of HMM_SINF, HMM_COSF, HMM_TANF, HMM_ACOSF, and HMM_SQRTF

before including HandmadeMath.h, like so:

#define HANDMADE_MATH_PROVIDE_MATH_FUNCTIONS

#define HMM_SINF MySinF

#define HMM_COSF MyCosF

#define HMM_TANF MyTanF

#define HMM_ACOSF MyACosF

#define HMM_SQRTF MySqrtF

#include "HandmadeMath.h"

By default, it is assumed that your math functions take radians. To use

different units, you must define HMM_ANGLE_USER_TO_INTERNAL and

HMM_ANGLE_INTERNAL_TO_USER. For example, if you want to use degrees in your

code but your math functions use turns:

#define HMM_ANGLE_USER_TO_INTERNAL(a) ((a)*HMM_DegToTurn)

#define HMM_ANGLE_INTERNAL_TO_USER(a) ((a)*HMM_TurnToDeg)

=============================================================================

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

Originally written by Zakary Strange.

Functionality:

Zakary Strange (strangezak@protonmail.com && @strangezak)

Matt Mascarenhas (@miblo_)

Aleph

FieryDrake (@fierydrake)

Gingerbill (@TheGingerBill)

Ben Visness (@bvisness)

Trinton Bullard (@Peliex_Dev)

@AntonDan

Logan Forman (@dev_dwarf)

Fixes:

Jeroen van Rijn (@J_vanRijn)

Kiljacken (@Kiljacken)

Insofaras (@insofaras)

Daniel Gibson (@DanielGibson)

*/

#ifndef HANDMADE_MATH_H

#define HANDMADE_MATH_H

// Dummy macros for when test framework is not present.

#ifndef COVERAGE

# define COVERAGE(a, b)

#endif

#ifndef ASSERT_COVERED

# define ASSERT_COVERED(a)

#endif

#ifdef HANDMADE_MATH_NO_SSE

# warning "HANDMADE_MATH_NO_SSE is deprecated, use HANDMADE_MATH_NO_SIMD instead"

# define HANDMADE_MATH_NO_SIMD

#endif

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

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

# ifdef __ARM_NEON

# define HANDMADE_MATH__USE_NEON 1

# endif /* NEON Supported */

#endif /* #ifndef HANDMADE_MATH_NO_SIMD */

#if (!defined(__cplusplus) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)

# define HANDMADE_MATH__USE_C11_GENERICS 1

#endif

#ifdef HANDMADE_MATH__USE_SSE

# include <xmmintrin.h>

#endif

#ifdef HANDMADE_MATH__USE_NEON

# include <arm_neon.h>

#endif

#ifdef _MSC_VER

#pragma warning(disable:4201)

#endif

#if defined(__GNUC__) || defined(__clang__)

# pragma GCC diagnostic push

# pragma GCC diagnostic ignored "-Wfloat-equal"

# pragma GCC diagnostic ignored "-Wmissing-braces"

# ifdef __clang__

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

# pragma GCC diagnostic ignored "-Wnested-anon-types"

# pragma GCC diagnostic ignored "-Wmissing-field-initializers"

# endif

#endif

#if defined(__GNUC__) || defined(__clang__)

# define HMM_DEPRECATED(msg) __attribute__((deprecated(msg)))

#elif defined(_MSC_VER)

# define HMM_DEPRECATED(msg) __declspec(deprecated(msg))

#else

# define HMM_DEPRECATED(msg)

#endif

#ifdef __cplusplus

extern "C"

{

#endif

#if !defined(HANDMADE_MATH_USE_DEGREES) \

&& !defined(HANDMADE_MATH_USE_TURNS) \

&& !defined(HANDMADE_MATH_USE_RADIANS)

# define HANDMADE_MATH_USE_RADIANS

#endif

#define HMM_PI 3.14159265358979323846

#define HMM_PI32 3.14159265359f

#define HMM_DEG180 180.0

#define HMM_DEG18032 180.0f

#define HMM_TURNHALF 0.5

#define HMM_TURNHALF32 0.5f

#define HMM_RadToDeg ((float)(HMM_DEG180/HMM_PI))

#define HMM_RadToTurn ((float)(HMM_TURNHALF/HMM_PI))

#define HMM_DegToRad ((float)(HMM_PI/HMM_DEG180))

#define HMM_DegToTurn ((float)(HMM_TURNHALF/HMM_DEG180))

#define HMM_TurnToRad ((float)(HMM_PI/HMM_TURNHALF))

#define HMM_TurnToDeg ((float)(HMM_DEG180/HMM_TURNHALF))

#if defined(HANDMADE_MATH_USE_RADIANS)

# define HMM_AngleRad(a) (a)

# define HMM_AngleDeg(a) ((a)*HMM_DegToRad)

# define HMM_AngleTurn(a) ((a)*HMM_TurnToRad)

#elif defined(HANDMADE_MATH_USE_DEGREES)

# define HMM_AngleRad(a) ((a)*HMM_RadToDeg)

# define HMM_AngleDeg(a) (a)

# define HMM_AngleTurn(a) ((a)*HMM_TurnToDeg)

#elif defined(HANDMADE_MATH_USE_TURNS)

# define HMM_AngleRad(a) ((a)*HMM_RadToTurn)

# define HMM_AngleDeg(a) ((a)*HMM_DegToTurn)

# define HMM_AngleTurn(a) (a)

#endif

#if !defined(HANDMADE_MATH_PROVIDE_MATH_FUNCTIONS)

# include <math.h>

# define HMM_SINF sinf

# define HMM_COSF cosf

# define HMM_TANF tanf

# define HMM_SQRTF sqrtf

# define HMM_ACOSF acosf

#endif

#if !defined(HMM_ANGLE_USER_TO_INTERNAL)

# define HMM_ANGLE_USER_TO_INTERNAL(a) (HMM_ToRad(a))

#endif

#if !defined(HMM_ANGLE_INTERNAL_TO_USER)

# if defined(HANDMADE_MATH_USE_RADIANS)

# define HMM_ANGLE_INTERNAL_TO_USER(a) (a)

# elif defined(HANDMADE_MATH_USE_DEGREES)

# define HMM_ANGLE_INTERNAL_TO_USER(a) ((a)*HMM_RadToDeg)

# elif defined(HANDMADE_MATH_USE_TURNS)

# define HMM_ANGLE_INTERNAL_TO_USER(a) ((a)*HMM_RadToTurn)

# endif

#endif

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

inline const float &operator[](int Index) const { return Elements[Index]; }

#endif

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

inline const float &operator[](int Index) const { return Elements[Index]; }

#endif

} 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 SSE;

#endif

#ifdef HANDMADE_MATH__USE_NEON

float32x4_t NEON;

#endif

#ifdef __cplusplus

inline float &operator[](int Index) { return Elements[Index]; }

inline const float &operator[](int Index) const { return Elements[Index]; }

#endif

} HMM_Vec4;

typedef union HMM_Mat2

{

float Elements[2][2];

HMM_Vec2 Columns[2];

#ifdef __cplusplus

inline HMM_Vec2 &operator[](int Index) { return Columns[Index]; }

inline const HMM_Vec2 &operator[](int Index) const { return Columns[Index]; }

#endif

} HMM_Mat2;

typedef union HMM_Mat3

{

float Elements[3][3];

HMM_Vec3 Columns[3];

#ifdef __cplusplus

inline HMM_Vec3 &operator[](int Index) { return Columns[Index]; }

inline const HMM_Vec3 &operator[](int Index) const { return Columns[Index]; }

#endif

} HMM_Mat3;

typedef union HMM_Mat4

{

float Elements[4][4];

HMM_Vec4 Columns[4];

#ifdef __cplusplus

inline HMM_Vec4 &operator[](int Index) { return Columns[Index]; }

inline const HMM_Vec4 &operator[](int Index) const { return Columns[Index]; }

#endif

} HMM_Mat4;

typedef union HMM_Quat

{

struct

{

union

{

HMM_Vec3 XYZ;

struct

{

float X, Y, Z;

};

};

float W;

};

float Elements[4];

#ifdef HANDMADE_MATH__USE_SSE

__m128 SSE;

#endif

#ifdef HANDMADE_MATH__USE_NEON

float32x4_t NEON;

#endif

} HMM_Quat;

typedef signed int HMM_Bool;

/*

* Angle unit conversion functions

*/

static inline float HMM_ToRad(float Angle)

{

#if defined(HANDMADE_MATH_USE_RADIANS)

float Result = Angle;

#elif defined(HANDMADE_MATH_USE_DEGREES)

float Result = Angle * HMM_DegToRad;

#elif defined(HANDMADE_MATH_USE_TURNS)

float Result = Angle * HMM_TurnToRad;

#endif

return Result;

}

static inline float HMM_ToDeg(float Angle)

{

#if defined(HANDMADE_MATH_USE_RADIANS)

float Result = Angle * HMM_RadToDeg;

#elif defined(HANDMADE_MATH_USE_DEGREES)

float Result = Angle;

#elif defined(HANDMADE_MATH_USE_TURNS)

float Result = Angle * HMM_TurnToDeg;

#endif

return Result;

}

static inline float HMM_ToTurn(float Angle)

{

#if defined(HANDMADE_MATH_USE_RADIANS)

float Result = Angle * HMM_RadToTurn;

#elif defined(HANDMADE_MATH_USE_DEGREES)

float Result = Angle * HMM_DegToTurn;

#elif defined(HANDMADE_MATH_USE_TURNS)

float Result = Angle;

#endif

return Result;

}

/*

* Floating-point math functions

*/

COVERAGE(HMM_SinF, 1)

static inline float HMM_SinF(float Angle)

{

ASSERT_COVERED(HMM_SinF);

return HMM_SINF(HMM_ANGLE_USER_TO_INTERNAL(Angle));

}

COVERAGE(HMM_CosF, 1)

static inline float HMM_CosF(float Angle)

{

ASSERT_COVERED(HMM_CosF);

return HMM_COSF(HMM_ANGLE_USER_TO_INTERNAL(Angle));

}

COVERAGE(HMM_TanF, 1)

static inline float HMM_TanF(float Angle)

{

ASSERT_COVERED(HMM_TanF);

return HMM_TANF(HMM_ANGLE_USER_TO_INTERNAL(Angle));

}

COVERAGE(HMM_ACosF, 1)

static inline float HMM_ACosF(float Arg)

{

ASSERT_COVERED(HMM_ACosF);

return HMM_ANGLE_INTERNAL_TO_USER(HMM_ACOSF(Arg));

}

COVERAGE(HMM_SqrtF, 1)

static inline float HMM_SqrtF(float Float)

{

ASSERT_COVERED(HMM_SqrtF);

float Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 In = _mm_set_ss(Float);

__m128 Out = _mm_sqrt_ss(In);

Result = _mm_cvtss_f32(Out);

#elif defined(HANDMADE_MATH__USE_NEON)

float32x4_t In = vdupq_n_f32(Float);

float32x4_t Out = vsqrtq_f32(In);

Result = vgetq_lane_f32(Out, 0);

#else

Result = HMM_SQRTF(Float);

#endif

return Result;

}

COVERAGE(HMM_InvSqrtF, 1)

static inline float HMM_InvSqrtF(float Float)

{

ASSERT_COVERED(HMM_InvSqrtF);

float Result;

Result = 1.0f/HMM_SqrtF(Float);

return Result;

}

/*

* Utility functions

*/

COVERAGE(HMM_Lerp, 1)

static inline float HMM_Lerp(float A, float Time, float B)

{

ASSERT_COVERED(HMM_Lerp);

return (1.0f - Time) * A + Time * B;

}

COVERAGE(HMM_Clamp, 1)

static inline float HMM_Clamp(float Min, float Value, float Max)

{

ASSERT_COVERED(HMM_Clamp);

float Result = Value;

if (Result < Min)

{

Result = Min;

}

if (Result > Max)

{

Result = Max;

}

return Result;

}

/*

* Vector initialization

*/

COVERAGE(HMM_V2, 1)

static inline HMM_Vec2 HMM_V2(float X, float Y)

{

ASSERT_COVERED(HMM_V2);

HMM_Vec2 Result;

Result.X = X;

Result.Y = Y;

return Result;

}

COVERAGE(HMM_V3, 1)

static inline HMM_Vec3 HMM_V3(float X, float Y, float Z)

{

ASSERT_COVERED(HMM_V3);

HMM_Vec3 Result;

Result.X = X;

Result.Y = Y;

Result.Z = Z;

return Result;

}

COVERAGE(HMM_V4, 1)

static inline HMM_Vec4 HMM_V4(float X, float Y, float Z, float W)

{

ASSERT_COVERED(HMM_V4);

HMM_Vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

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

#elif defined(HANDMADE_MATH__USE_NEON)

float32x4_t v = {X, Y, Z, W};

Result.NEON = v;

#else

Result.X = X;

Result.Y = Y;

Result.Z = Z;

Result.W = W;

#endif

return Result;

}

COVERAGE(HMM_V4V, 1)

static inline HMM_Vec4 HMM_V4V(HMM_Vec3 Vector, float W)

{

ASSERT_COVERED(HMM_V4V);

HMM_Vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

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

#elif defined(HANDMADE_MATH__USE_NEON)

float32x4_t v = {Vector.X, Vector.Y, Vector.Z, W};

Result.NEON = v;

#else

Result.XYZ = Vector;

Result.W = W;

#endif

return Result;

}

/*

* Binary vector operations

*/

COVERAGE(HMM_AddV2, 1)

static inline HMM_Vec2 HMM_AddV2(HMM_Vec2 Left, HMM_Vec2 Right)

{

ASSERT_COVERED(HMM_AddV2);

HMM_Vec2 Result;

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

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

return Result;

}

COVERAGE(HMM_AddV3, 1)

static inline HMM_Vec3 HMM_AddV3(HMM_Vec3 Left, HMM_Vec3 Right)

{

ASSERT_COVERED(HMM_AddV3);

HMM_Vec3 Result;

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

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

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

return Result;

}

COVERAGE(HMM_AddV4, 1)

static inline HMM_Vec4 HMM_AddV4(HMM_Vec4 Left, HMM_Vec4 Right)

{

ASSERT_COVERED(HMM_AddV4);

HMM_Vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

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

#elif defined(HANDMADE_MATH__USE_NEON)

Result.NEON = vaddq_f32(Left.NEON, Right.NEON);

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

#endif

return Result;

}

COVERAGE(HMM_SubV2, 1)

static inline HMM_Vec2 HMM_SubV2(HMM_Vec2 Left, HMM_Vec2 Right)

{

ASSERT_COVERED(HMM_SubV2);

HMM_Vec2 Result;

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

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

return Result;

}

COVERAGE(HMM_SubV3, 1)

static inline HMM_Vec3 HMM_SubV3(HMM_Vec3 Left, HMM_Vec3 Right)

{

ASSERT_COVERED(HMM_SubV3);

HMM_Vec3 Result;

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

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

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

return Result;

}

COVERAGE(HMM_SubV4, 1)

static inline HMM_Vec4 HMM_SubV4(HMM_Vec4 Left, HMM_Vec4 Right)

{

ASSERT_COVERED(HMM_SubV4);

HMM_Vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

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

#elif defined(HANDMADE_MATH__USE_NEON)

Result.NEON = vsubq_f32(Left.NEON, Right.NEON);

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

#endif

return Result;

}

COVERAGE(HMM_MulV2, 1)

static inline HMM_Vec2 HMM_MulV2(HMM_Vec2 Left, HMM_Vec2 Right)

{

ASSERT_COVERED(HMM_MulV2);

HMM_Vec2 Result;

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

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

return Result;

}

COVERAGE(HMM_MulV2F, 1)

static inline HMM_Vec2 HMM_MulV2F(HMM_Vec2 Left, float Right)

{

ASSERT_COVERED(HMM_MulV2F);

HMM_Vec2 Result;

Result.X = Left.X * Right;

Result.Y = Left.Y * Right;

return Result;

}

COVERAGE(HMM_MulV3, 1)

static inline HMM_Vec3 HMM_MulV3(HMM_Vec3 Left, HMM_Vec3 Right)

{

ASSERT_COVERED(HMM_MulV3);

HMM_Vec3 Result;

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

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

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

return Result;

}

COVERAGE(HMM_MulV3F, 1)

static inline HMM_Vec3 HMM_MulV3F(HMM_Vec3 Left, float Right)

{

ASSERT_COVERED(HMM_MulV3F);

HMM_Vec3 Result;

Result.X = Left.X * Right;

Result.Y = Left.Y * Right;

Result.Z = Left.Z * Right;

return Result;

}

COVERAGE(HMM_MulV4, 1)

static inline HMM_Vec4 HMM_MulV4(HMM_Vec4 Left, HMM_Vec4 Right)

{

ASSERT_COVERED(HMM_MulV4);

HMM_Vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

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

#elif defined(HANDMADE_MATH__USE_NEON)

Result.NEON = vmulq_f32(Left.NEON, Right.NEON);

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

#endif

return Result;

}

COVERAGE(HMM_MulV4F, 1)

static inline HMM_Vec4 HMM_MulV4F(HMM_Vec4 Left, float Right)

{

ASSERT_COVERED(HMM_MulV4F);

HMM_Vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 Scalar = _mm_set1_ps(Right);

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

#elif defined(HANDMADE_MATH__USE_NEON)

Result.NEON = vmulq_n_f32(Left.NEON, Right);

#else

Result.X = Left.X * Right;

Result.Y = Left.Y * Right;

Result.Z = Left.Z * Right;

Result.W = Left.W * Right;

#endif

return Result;

}

COVERAGE(HMM_DivV2, 1)

static inline HMM_Vec2 HMM_DivV2(HMM_Vec2 Left, HMM_Vec2 Right)

{

ASSERT_COVERED(HMM_DivV2);

HMM_Vec2 Result;

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

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

return Result;

}

COVERAGE(HMM_DivV2F, 1)

static inline HMM_Vec2 HMM_DivV2F(HMM_Vec2 Left, float Right)

{

ASSERT_COVERED(HMM_DivV2F);

HMM_Vec2 Result;

Result.X = Left.X / Right;

Result.Y = Left.Y / Right;

return Result;

}

COVERAGE(HMM_DivV3, 1)

static inline HMM_Vec3 HMM_DivV3(HMM_Vec3 Left, HMM_Vec3 Right)

{

ASSERT_COVERED(HMM_DivV3);

HMM_Vec3 Result;

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

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

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

return Result;

}

COVERAGE(HMM_DivV3F, 1)

static inline HMM_Vec3 HMM_DivV3F(HMM_Vec3 Left, float Right)

{

ASSERT_COVERED(HMM_DivV3F);

HMM_Vec3 Result;

Result.X = Left.X / Right;

Result.Y = Left.Y / Right;

Result.Z = Left.Z / Right;

return Result;

}

COVERAGE(HMM_DivV4, 1)

static inline HMM_Vec4 HMM_DivV4(HMM_Vec4 Left, HMM_Vec4 Right)

{

ASSERT_COVERED(HMM_DivV4);

HMM_Vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

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

#elif defined(HANDMADE_MATH__USE_NEON)

Result.NEON = vdivq_f32(Left.NEON, Right.NEON);

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

#endif

return Result;

}

COVERAGE(HMM_DivV4F, 1)

static inline HMM_Vec4 HMM_DivV4F(HMM_Vec4 Left, float Right)

{

ASSERT_COVERED(HMM_DivV4F);

HMM_Vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 Scalar = _mm_set1_ps(Right);

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

#elif defined(HANDMADE_MATH__USE_NEON)

float32x4_t Scalar = vdupq_n_f32(Right);

Result.NEON = vdivq_f32(Left.NEON, Scalar);

#else

Result.X = Left.X / Right;

Result.Y = Left.Y / Right;

Result.Z = Left.Z / Right;

Result.W = Left.W / Right;

#endif

return Result;

}

COVERAGE(HMM_EqV2, 1)

static inline HMM_Bool HMM_EqV2(HMM_Vec2 Left, HMM_Vec2 Right)

{

ASSERT_COVERED(HMM_EqV2);

return Left.X == Right.X && Left.Y == Right.Y;

}

COVERAGE(HMM_EqV3, 1)

static inline HMM_Bool HMM_EqV3(HMM_Vec3 Left, HMM_Vec3 Right)

{

ASSERT_COVERED(HMM_EqV3);

return Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z;

}

COVERAGE(HMM_EqV4, 1)

static inline HMM_Bool HMM_EqV4(HMM_Vec4 Left, HMM_Vec4 Right)

{

ASSERT_COVERED(HMM_EqV4);

return Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z && Left.W == Right.W;

}

COVERAGE(HMM_DotV2, 1)

static inline float HMM_DotV2(HMM_Vec2 Left, HMM_Vec2 Right)

{

ASSERT_COVERED(HMM_DotV2);

return (Left.X * Right.X) + (Left.Y * Right.Y);

}

COVERAGE(HMM_DotV3, 1)

static inline float HMM_DotV3(HMM_Vec3 Left, HMM_Vec3 Right)

{

ASSERT_COVERED(HMM_DotV3);

return (Left.X * Right.X) + (Left.Y * Right.Y) + (Left.Z * Right.Z);

}

COVERAGE(HMM_DotV4, 1)

static inline float HMM_DotV4(HMM_Vec4 Left, HMM_Vec4 Right)

{

ASSERT_COVERED(HMM_DotV4);

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

#ifdef HANDMADE_MATH__USE_SSE

__m128 SSEResultOne = _mm_mul_ps(Left.SSE, Right.SSE);

__m128 SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(2, 3, 0, 1));

SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo);

SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(0, 1, 2, 3));

SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo);

_mm_store_ss(&Result, SSEResultOne);

#elif defined(HANDMADE_MATH__USE_NEON)

float32x4_t NEONMultiplyResult = vmulq_f32(Left.NEON, Right.NEON);

float32x4_t NEONHalfAdd = vpaddq_f32(NEONMultiplyResult, NEONMultiplyResult);

float32x4_t NEONFullAdd = vpaddq_f32(NEONHalfAdd, NEONHalfAdd);

Result = vgetq_lane_f32(NEONFullAdd, 0);

#else

Result = ((Left.X * Right.X) + (Left.Z * Right.Z)) + ((Left.Y * Right.Y) + (Left.W * Right.W));

#endif

return Result;

}

COVERAGE(HMM_Cross, 1)

static inline HMM_Vec3 HMM_Cross(HMM_Vec3 Left, HMM_Vec3 Right)