From 064baeb5b960e40729ad54fdfd9a2d3699e0c4a1 Mon Sep 17 00:00:00 2001 From: Zak Strange Date: Sat, 30 Sep 2017 14:38:28 -0700 Subject: [PATCH] V1.4 - SSE upgrades and bug fixes (#70) * Fixed bug when using handmademath in C mode * SSEd vec4 operations * Fixed hmm_vec4 for non-sse builds. Added SSE option for HMM_Vec4 to load in one instruction * Whoops. We were loading in the wrong order * SSEd more things * SSEd more functions * Minor fixups * SSE'd hmm_vec4 initialization * Removed zeroing * Vector normalization should be zero'd * Removed old comments --- HandmadeMath.h | 535 ++++++++++++++++++++++++++++++++----------------- 1 file changed, 350 insertions(+), 185 deletions(-) diff --git a/HandmadeMath.h b/HandmadeMath.h index 9287389..6907c6a 100644 --- a/HandmadeMath.h +++ b/HandmadeMath.h @@ -1,5 +1,5 @@ /* - HandmadeMath.h v1.3.0 + HandmadeMath.h v1.4 This is a single header file with a bunch of useful functions for basic game math operations. @@ -182,6 +182,11 @@ (*) SSE'd HMM_Transpose 1.3.0 (*) Remove need to #define HANDMADE_MATH_CPP_MODE + 1.4.0 + (*) Fixed bug when using HandmadeMath in C mode + (*) SSEd all vec4 operations + (*) Removed all zero-ing + LICENSE @@ -435,13 +440,16 @@ typedef union hmm_vec4 }; float Elements[4]; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 InternalElementsSSE; +#endif } hmm_vec4; typedef union hmm_mat4 { float Elements[4][4]; - - + #ifdef HANDMADE_MATH__USE_SSE __m128 Rows[4]; #endif @@ -740,88 +748,97 @@ HMMDEF hmm_bool operator!=(hmm_vec4 Left, hmm_vec4 Right); HINLINE float HMM_SinF(float Angle) { - float Result = 0.0f; + float Result; Result = HMM_SINF(Angle); + return (Result); } HINLINE float HMM_CosF(float Angle) { - float Result = 0.0f; + float Result; Result = HMM_COSF(Angle); + return (Result); } HINLINE float HMM_TanF(float Radians) { - float Result = 0.0f; + float Result; Result = HMM_TANF(Radians); + return (Result); } HINLINE float HMM_ACosF(float Radians) { - float Result = 0.0f; + float Result; Result = HMM_ACOSF(Radians); + return (Result); } HINLINE float HMM_ATanF(float Radians) { - float Result = 0.0f; + float Result; Result = HMM_ATANF(Radians); + return (Result); } HINLINE float HMM_Atan2F(float Left, float Right) { - float Result = 0.0f; + float Result; Result = HMM_ATAN2F(Left, Right); + return (Result); } HINLINE float HMM_ExpF(float Float) { - float Result = 0.0f; + float Result; Result = HMM_EXPF(Float); + return (Result); } HINLINE float HMM_LogF(float Float) { - float Result = 0.0f; + float Result; Result = HMM_LOGF(Float); + return (Result); } HINLINE float HMM_ToRadians(float Degrees) { - float Result = 0.0f; + float Result; Result = Degrees * (HMM_PI32 / 180.0f); + return (Result); } HINLINE float HMM_SquareRootF(float Value) { - float Result = 0.0f; + float Result; #ifdef HANDMADE_MATH__USE_SSE __m128 In = _mm_set_ss(Value); @@ -837,7 +854,7 @@ HMM_SquareRootF(float Value) HINLINE float HMM_RSquareRootF(float Value) { - float Result = 0.0f; + float Result; #ifdef HANDMADE_MATH__USE_SSE __m128 In = _mm_set_ss(Value); @@ -853,7 +870,7 @@ HMM_RSquareRootF(float Value) HINLINE float HMM_LengthSquaredVec2(hmm_vec2 A) { - float Result = 0.0f; + float Result; Result = HMM_DotVec2(A, A); @@ -863,7 +880,7 @@ HMM_LengthSquaredVec2(hmm_vec2 A) HINLINE float HMM_LengthSquaredVec3(hmm_vec3 A) { - float Result = 0.0f; + float Result; Result = HMM_DotVec3(A, A); @@ -873,7 +890,7 @@ HMM_LengthSquaredVec3(hmm_vec3 A) HINLINE float HMM_LengthSquaredVec4(hmm_vec4 A) { - float Result = 0.0f; + float Result; Result = HMM_DotVec4(A, A); @@ -883,7 +900,7 @@ HMM_LengthSquaredVec4(hmm_vec4 A) HINLINE float HMM_LengthVec2(hmm_vec2 A) { - float Result = 0.0f; + float Result; Result = HMM_SquareRootF(HMM_LengthSquaredVec2(A)); @@ -893,7 +910,7 @@ HMM_LengthVec2(hmm_vec2 A) HINLINE float HMM_LengthVec3(hmm_vec3 A) { - float Result = 0.0f; + float Result; Result = HMM_SquareRootF(HMM_LengthSquaredVec3(A)); @@ -903,7 +920,7 @@ HMM_LengthVec3(hmm_vec3 A) HINLINE float HMM_LengthVec4(hmm_vec4 A) { - float Result = 0.0f; + float Result; Result = HMM_SquareRootF(HMM_LengthSquaredVec4(A)); @@ -1007,10 +1024,17 @@ HMM_NormalizeVec4(hmm_vec4 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); + float Multiplier = 1.0f / VectorLength; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 SSEMultiplier = _mm_set1_ps(Multiplier); + Result.InternalElementsSSE = _mm_mul_ps(A.InternalElementsSSE, SSEMultiplier); +#else + Result.X = A.X * Multiplier; + Result.Y = A.Y * Multiplier; + Result.Z = A.Z * Multiplier; + Result.W = A.W * Multiplier; +#endif } return (Result); @@ -1019,7 +1043,7 @@ HMM_NormalizeVec4(hmm_vec4 A) HINLINE float HMM_DotVec2(hmm_vec2 VecOne, hmm_vec2 VecTwo) { - float Result = 0.0f; + float Result; Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y); @@ -1029,7 +1053,7 @@ HMM_DotVec2(hmm_vec2 VecOne, hmm_vec2 VecTwo) HINLINE float HMM_DotVec3(hmm_vec3 VecOne, hmm_vec3 VecTwo) { - float Result = 0.0f; + float Result; Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z); @@ -1039,9 +1063,21 @@ HMM_DotVec3(hmm_vec3 VecOne, hmm_vec3 VecTwo) HINLINE float HMM_DotVec4(hmm_vec4 VecOne, hmm_vec4 VecTwo) { - float Result = 0.0f; + 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(VecOne.InternalElementsSSE, VecTwo.InternalElementsSSE); + __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); +#else Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z) + (VecOne.W * VecTwo.W); +#endif return (Result); } @@ -1049,7 +1085,7 @@ HMM_DotVec4(hmm_vec4 VecOne, hmm_vec4 VecTwo) HINLINE hmm_vec3 HMM_Cross(hmm_vec3 VecOne, hmm_vec3 VecTwo) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result.X = (VecOne.Y * VecTwo.Z) - (VecOne.Z * VecTwo.Y); Result.Y = (VecOne.Z * VecTwo.X) - (VecOne.X * VecTwo.Z); @@ -1061,7 +1097,7 @@ HMM_Cross(hmm_vec3 VecOne, hmm_vec3 VecTwo) HINLINE hmm_vec2 HMM_Vec2(float X, float Y) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result.X = X; Result.Y = Y; @@ -1072,7 +1108,7 @@ HMM_Vec2(float X, float Y) HINLINE hmm_vec2 HMM_Vec2i(int X, int Y) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result.X = (float)X; Result.Y = (float)Y; @@ -1083,7 +1119,7 @@ HMM_Vec2i(int X, int Y) HINLINE hmm_vec3 HMM_Vec3(float X, float Y, float Z) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result.X = X; Result.Y = Y; @@ -1095,7 +1131,7 @@ HMM_Vec3(float X, float Y, float Z) HINLINE hmm_vec3 HMM_Vec3i(int X, int Y, int Z) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result.X = (float)X; Result.Y = (float)Y; @@ -1107,44 +1143,54 @@ HMM_Vec3i(int X, int Y, int Z) HINLINE hmm_vec4 HMM_Vec4(float X, float Y, float Z, float W) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_setr_ps(X, Y, Z, W); +#else Result.X = X; Result.Y = Y; Result.Z = Z; Result.W = W; - +#endif return (Result); } HINLINE hmm_vec4 HMM_Vec4i(int X, int Y, int Z, int W) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_setr_ps((float)X, (float)Y, (float)Z, (float)W); +#else Result.X = (float)X; Result.Y = (float)Y; Result.Z = (float)Z; Result.W = (float)W; - +#endif return (Result); } HINLINE hmm_vec4 HMM_Vec4v(hmm_vec3 Vector, float W) { - hmm_vec4 Result = {0}; - + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_setr_ps(Vector.X, Vector.Y, Vector.Z, W); +#else Result.XYZ = Vector; Result.W = W; - +#endif + return (Result); } HINLINE hmm_vec2 HMM_AddVec2(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result.X = Left.X + Right.X; Result.Y = Left.Y + Right.Y; @@ -1155,7 +1201,7 @@ HMM_AddVec2(hmm_vec2 Left, hmm_vec2 Right) HINLINE hmm_vec3 HMM_AddVec3(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result.X = Left.X + Right.X; Result.Y = Left.Y + Right.Y; @@ -1167,12 +1213,16 @@ HMM_AddVec3(hmm_vec3 Left, hmm_vec3 Right) HINLINE hmm_vec4 HMM_AddVec4(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + 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; + Result.W = Left.W + Right.W; +#endif return (Result); } @@ -1180,7 +1230,7 @@ HMM_AddVec4(hmm_vec4 Left, hmm_vec4 Right) HINLINE hmm_vec2 HMM_SubtractVec2(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result.X = Left.X - Right.X; Result.Y = Left.Y - Right.Y; @@ -1191,7 +1241,7 @@ HMM_SubtractVec2(hmm_vec2 Left, hmm_vec2 Right) HINLINE hmm_vec3 HMM_SubtractVec3(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result.X = Left.X - Right.X; Result.Y = Left.Y - Right.Y; @@ -1203,12 +1253,16 @@ HMM_SubtractVec3(hmm_vec3 Left, hmm_vec3 Right) HINLINE hmm_vec4 HMM_SubtractVec4(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; - + 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; + Result.W = Left.W - Right.W; +#endif return (Result); } @@ -1216,7 +1270,7 @@ HMM_SubtractVec4(hmm_vec4 Left, hmm_vec4 Right) HINLINE hmm_vec2 HMM_MultiplyVec2(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result.X = Left.X * Right.X; Result.Y = Left.Y * Right.Y; @@ -1227,7 +1281,7 @@ HMM_MultiplyVec2(hmm_vec2 Left, hmm_vec2 Right) HINLINE hmm_vec2 HMM_MultiplyVec2f(hmm_vec2 Left, float Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result.X = Left.X * Right; Result.Y = Left.Y * Right; @@ -1238,7 +1292,7 @@ HMM_MultiplyVec2f(hmm_vec2 Left, float Right) HINLINE hmm_vec3 HMM_MultiplyVec3(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result.X = Left.X * Right.X; Result.Y = Left.Y * Right.Y; @@ -1250,7 +1304,7 @@ HMM_MultiplyVec3(hmm_vec3 Left, hmm_vec3 Right) HINLINE hmm_vec3 HMM_MultiplyVec3f(hmm_vec3 Left, float Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result.X = Left.X * Right; Result.Y = Left.Y * Right; @@ -1262,12 +1316,16 @@ HMM_MultiplyVec3f(hmm_vec3 Left, float Right) HINLINE hmm_vec4 HMM_MultiplyVec4(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_mul_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; + Result.W = Left.W * Right.W; +#endif return (Result); } @@ -1275,20 +1333,25 @@ HMM_MultiplyVec4(hmm_vec4 Left, hmm_vec4 Right) HINLINE hmm_vec4 HMM_MultiplyVec4f(hmm_vec4 Left, float Right) { - hmm_vec4 Result = {0}; + 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; - +#endif + return (Result); } HINLINE hmm_vec2 HMM_DivideVec2(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result.X = Left.X / Right.X; Result.Y = Left.Y / Right.Y; @@ -1299,7 +1362,7 @@ HMM_DivideVec2(hmm_vec2 Left, hmm_vec2 Right) HINLINE hmm_vec2 HMM_DivideVec2f(hmm_vec2 Left, float Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result.X = Left.X / Right; Result.Y = Left.Y / Right; @@ -1310,7 +1373,7 @@ HMM_DivideVec2f(hmm_vec2 Left, float Right) HINLINE hmm_vec3 HMM_DivideVec3(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result.X = Left.X / Right.X; Result.Y = Left.Y / Right.Y; @@ -1322,7 +1385,7 @@ HMM_DivideVec3(hmm_vec3 Left, hmm_vec3 Right) HINLINE hmm_vec3 HMM_DivideVec3f(hmm_vec3 Left, float Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result.X = Left.X / Right; Result.Y = Left.Y / Right; @@ -1334,33 +1397,42 @@ HMM_DivideVec3f(hmm_vec3 Left, float Right) HINLINE hmm_vec4 HMM_DivideVec4(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; - + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_div_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; - +#endif + return (Result); } HINLINE hmm_vec4 HMM_DivideVec4f(hmm_vec4 Left, float Right) { - hmm_vec4 Result = {0}; + 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; - +#endif + return (Result); } HINLINE hmm_bool HMM_EqualsVec2(hmm_vec2 Left, hmm_vec2 Right) { - hmm_bool Result = 0; + hmm_bool Result; Result = (Left.X == Right.X && Left.Y == Right.Y); @@ -1370,7 +1442,7 @@ HMM_EqualsVec2(hmm_vec2 Left, hmm_vec2 Right) HINLINE hmm_bool HMM_EqualsVec3(hmm_vec3 Left, hmm_vec3 Right) { - hmm_bool Result = 0; + hmm_bool Result; Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z); @@ -1380,7 +1452,7 @@ HMM_EqualsVec3(hmm_vec3 Left, hmm_vec3 Right) HINLINE hmm_bool HMM_EqualsVec4(hmm_vec4 Left, hmm_vec4 Right) { - hmm_bool Result = 0; + hmm_bool Result; Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z && Left.W == Right.W); @@ -1399,7 +1471,7 @@ 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; @@ -1411,8 +1483,14 @@ HMM_Mat4d(float Diagonal) HINLINE hmm_mat4 HMM_AddMat4(hmm_mat4 Left, hmm_mat4 Right) { - hmm_mat4 Result = HMM_Mat4(); + hmm_mat4 Result; +#ifdef HANDMADE_MATH__USE_SSE + Result.Rows[0] = _mm_add_ps(Left.Rows[0], Right.Rows[0]); + Result.Rows[1] = _mm_add_ps(Left.Rows[1], Right.Rows[1]); + Result.Rows[2] = _mm_add_ps(Left.Rows[2], Right.Rows[2]); + Result.Rows[3] = _mm_add_ps(Left.Rows[3], Right.Rows[3]); +#else int Columns; for(Columns = 0; Columns < 4; ++Columns) { @@ -1422,15 +1500,21 @@ HMM_AddMat4(hmm_mat4 Left, hmm_mat4 Right) Result.Elements[Columns][Rows] = Left.Elements[Columns][Rows] + Right.Elements[Columns][Rows]; } } - +#endif return (Result); } HINLINE hmm_mat4 HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right) { - hmm_mat4 Result = HMM_Mat4(); + hmm_mat4 Result; +#ifdef HANDMADE_MATH__USE_SSE + Result.Rows[0] = _mm_sub_ps(Left.Rows[0], Right.Rows[0]); + Result.Rows[1] = _mm_sub_ps(Left.Rows[1], Right.Rows[1]); + Result.Rows[2] = _mm_sub_ps(Left.Rows[2], Right.Rows[2]); + Result.Rows[3] = _mm_sub_ps(Left.Rows[3], Right.Rows[3]); +#else int Columns; for(Columns = 0; Columns < 4; ++Columns) { @@ -1440,7 +1524,7 @@ HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right) Result.Elements[Columns][Rows] = Left.Elements[Columns][Rows] - Right.Elements[Columns][Rows]; } } - +#endif return (Result); } @@ -1448,7 +1532,7 @@ HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right) HINLINE __m128 HMM_LinearCombineSSE(__m128 Left, hmm_mat4 Right) { - __m128 Result = {}; + __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])); @@ -1461,7 +1545,7 @@ HMM_LinearCombineSSE(__m128 Left, hmm_mat4 Right) HINLINE hmm_mat4 HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right) { - hmm_mat4 Result = HMM_Mat4(); + hmm_mat4 Result; #ifdef HANDMADE_MATH__USE_SSE @@ -1499,8 +1583,15 @@ HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right) HINLINE hmm_mat4 HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar) { - hmm_mat4 Result = HMM_Mat4(); - + hmm_mat4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 SSEScalar = _mm_set1_ps(Scalar); + Result.Rows[0] = _mm_mul_ps(Matrix.Rows[0], SSEScalar); + Result.Rows[1] = _mm_mul_ps(Matrix.Rows[1], SSEScalar); + Result.Rows[2] = _mm_mul_ps(Matrix.Rows[2], SSEScalar); + Result.Rows[3] = _mm_mul_ps(Matrix.Rows[3], SSEScalar); +#else int Columns; for(Columns = 0; Columns < 4; ++Columns) { @@ -1510,14 +1601,14 @@ HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar) Result.Elements[Columns][Rows] = Matrix.Elements[Columns][Rows] * Scalar; } } - +#endif return (Result); } HINLINE hmm_vec4 HMM_MultiplyMat4ByVec4(hmm_mat4 Matrix, hmm_vec4 Vector) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; int Columns, Rows; for(Rows = 0; Rows < 4; ++Rows) @@ -1537,8 +1628,15 @@ HMM_MultiplyMat4ByVec4(hmm_mat4 Matrix, hmm_vec4 Vector) HINLINE hmm_mat4 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar) { - hmm_mat4 Result = HMM_Mat4(); - + hmm_mat4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 SSEScalar = _mm_set1_ps(Scalar); + Result.Rows[0] = _mm_div_ps(Matrix.Rows[0], SSEScalar); + Result.Rows[1] = _mm_div_ps(Matrix.Rows[1], SSEScalar); + Result.Rows[2] = _mm_div_ps(Matrix.Rows[2], SSEScalar); + Result.Rows[3] = _mm_div_ps(Matrix.Rows[3], SSEScalar); +#else int Columns; for(Columns = 0; Columns < 4; ++Columns) { @@ -1548,14 +1646,14 @@ HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar) Result.Elements[Columns][Rows] = Matrix.Elements[Columns][Rows] / Scalar; } } - +#endif return (Result); } HINLINE hmm_mat4 HMM_Transpose(hmm_mat4 Matrix) { - hmm_mat4 Result = HMM_Mat4(); + hmm_mat4 Result; #ifdef HANDMADE_MATH__USE_SSE Result = Matrix; @@ -1662,7 +1760,7 @@ HMM_Scale(hmm_vec3 Scale) HINLINE hmm_mat4 HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; hmm_vec3 F = HMM_NormalizeVec3(HMM_SubtractVec3(Center, Eye)); hmm_vec3 S = HMM_NormalizeVec3(HMM_Cross(F, Up)); @@ -1692,7 +1790,7 @@ HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up) HINLINE hmm_quaternion HMM_Quaternion(float X, float Y, float Z, float W) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result.X = X; Result.Y = Y; @@ -1705,7 +1803,7 @@ HMM_Quaternion(float X, float Y, float Z, float W) HINLINE hmm_quaternion HMM_QuaternionV4(hmm_vec4 Vector) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result.X = Vector.X; Result.Y = Vector.Y; @@ -1718,7 +1816,7 @@ HMM_QuaternionV4(hmm_vec4 Vector) HINLINE hmm_quaternion HMM_AddQuaternion(hmm_quaternion Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result.X = Left.X + Right.X; Result.Y = Left.Y + Right.Y; @@ -1731,7 +1829,7 @@ HMM_AddQuaternion(hmm_quaternion Left, hmm_quaternion Right) HINLINE hmm_quaternion HMM_SubtractQuaternion(hmm_quaternion Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result.X = Left.X - Right.X; Result.Y = Left.Y - Right.Y; @@ -1744,7 +1842,7 @@ HMM_SubtractQuaternion(hmm_quaternion Left, hmm_quaternion Right) HINLINE hmm_quaternion HMM_MultiplyQuaternion(hmm_quaternion Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; 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); @@ -1757,7 +1855,7 @@ HMM_MultiplyQuaternion(hmm_quaternion Left, hmm_quaternion Right) HINLINE hmm_quaternion HMM_MultiplyQuaternionF(hmm_quaternion Left, float Multiplicative) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result.X = Left.X * Multiplicative; Result.Y = Left.Y * Multiplicative; @@ -1770,7 +1868,7 @@ HMM_MultiplyQuaternionF(hmm_quaternion Left, float Multiplicative) HINLINE hmm_quaternion HMM_DivideQuaternionF(hmm_quaternion Left, float Dividend) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result.X = Left.X / Dividend; Result.Y = Left.Y / Dividend; @@ -1783,8 +1881,8 @@ HMM_DivideQuaternionF(hmm_quaternion Left, float Dividend) HINLINE hmm_quaternion HMM_InverseQuaternion(hmm_quaternion Left) { - hmm_quaternion Conjugate = {0}; - hmm_quaternion Result = {0}; + hmm_quaternion Conjugate; + hmm_quaternion Result; float Norm = 0; float NormSquared = 0; @@ -1807,7 +1905,7 @@ HMM_InverseQuaternion(hmm_quaternion Left) HINLINE float HMM_DotQuaternion(hmm_quaternion Left, hmm_quaternion Right) { - float Result = 0.0f; + float Result; Result = (Left.X * Right.X) + (Left.Y * Right.Y) + (Left.Z * Right.Z) + (Left.W * Right.W); @@ -1817,7 +1915,7 @@ HMM_DotQuaternion(hmm_quaternion Left, hmm_quaternion Right) HINLINE hmm_quaternion HMM_NormalizeQuaternion(hmm_quaternion Left) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; float Length = HMM_SquareRootF(HMM_DotQuaternion(Left, Left)); Result = HMM_DivideQuaternionF(Left, Length); @@ -1828,7 +1926,7 @@ HMM_NormalizeQuaternion(hmm_quaternion Left) HINLINE hmm_quaternion HMM_NLerp(hmm_quaternion Left, float Time, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result.X = HMM_Lerp(Left.X, Time, Right.X); Result.Y = HMM_Lerp(Left.Y, Time, Right.Y); @@ -1843,9 +1941,9 @@ HMM_NLerp(hmm_quaternion Left, float Time, hmm_quaternion Right) HINLINE hmm_quaternion HMM_Slerp(hmm_quaternion Left, float Time, hmm_quaternion Right) { - hmm_quaternion Result = {0}; - hmm_quaternion QuaternionLeft = {0}; - hmm_quaternion QuaternionRight = {0}; + hmm_quaternion Result; + hmm_quaternion QuaternionLeft; + hmm_quaternion QuaternionRight; float Cos_Theta = HMM_DotQuaternion(Left, Right); float Angle = HMM_ACosF(Cos_Theta); @@ -1866,7 +1964,7 @@ HMM_Slerp(hmm_quaternion Left, float Time, hmm_quaternion Right) HINLINE hmm_mat4 HMM_QuaternionToMat4(hmm_quaternion Left) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_Mat4d(1); hmm_quaternion NormalizedQuaternion = HMM_NormalizeQuaternion(Left); @@ -1903,10 +2001,13 @@ HMM_QuaternionToMat4(hmm_quaternion Left) HINLINE hmm_quaternion HMM_QuaternionFromAxisAngle(hmm_vec3 Axis, float AngleOfRotation) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; + + hmm_vec3 RotatedVector; + float AxisNorm = 0; float SineOfRotation = 0; - hmm_vec3 RotatedVector = {0}; + AxisNorm = HMM_SquareRootF(HMM_DotVec3(Axis, Axis)); SineOfRotation = HMM_SinF(AngleOfRotation / 2.0f); @@ -1923,7 +2024,7 @@ HMM_QuaternionFromAxisAngle(hmm_vec3 Axis, float AngleOfRotation) HINLINE float HMM_Length(hmm_vec2 A) { - float Result = 0.0f; + float Result; Result = HMM_LengthVec2(A); @@ -1933,7 +2034,7 @@ HMM_Length(hmm_vec2 A) HINLINE float HMM_Length(hmm_vec3 A) { - float Result = 0.0f; + float Result; Result = HMM_LengthVec3(A); @@ -1943,7 +2044,7 @@ HMM_Length(hmm_vec3 A) HINLINE float HMM_Length(hmm_vec4 A) { - float Result = 0.0f; + float Result; Result = HMM_LengthVec4(A); @@ -1953,7 +2054,7 @@ HMM_Length(hmm_vec4 A) HINLINE float HMM_LengthSquared(hmm_vec2 A) { - float Result = 0.0f; + float Result; Result = HMM_LengthSquaredVec2(A); @@ -1963,7 +2064,7 @@ HMM_LengthSquared(hmm_vec2 A) HINLINE float HMM_LengthSquared(hmm_vec3 A) { - float Result = 0.0f; + float Result; Result = HMM_LengthSquaredVec3(A); @@ -1973,7 +2074,7 @@ HMM_LengthSquared(hmm_vec3 A) HINLINE float HMM_LengthSquared(hmm_vec4 A) { - float Result = 0.0f; + float Result; Result = HMM_LengthSquaredVec4(A); @@ -1983,7 +2084,7 @@ HMM_LengthSquared(hmm_vec4 A) HINLINE hmm_vec2 HMM_Normalize(hmm_vec2 A) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_NormalizeVec2(A); @@ -1993,7 +2094,7 @@ HMM_Normalize(hmm_vec2 A) HINLINE hmm_vec3 HMM_Normalize(hmm_vec3 A) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_NormalizeVec3(A); @@ -2003,7 +2104,7 @@ HMM_Normalize(hmm_vec3 A) HINLINE hmm_vec4 HMM_Normalize(hmm_vec4 A) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_NormalizeVec4(A); @@ -2013,7 +2114,7 @@ HMM_Normalize(hmm_vec4 A) HINLINE hmm_quaternion HMM_Normalize(hmm_quaternion A) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_NormalizeQuaternion(A); @@ -2023,7 +2124,7 @@ HMM_Normalize(hmm_quaternion A) HINLINE float HMM_Dot(hmm_vec2 VecOne, hmm_vec2 VecTwo) { - float Result = 0; + float Result; Result = HMM_DotVec2(VecOne, VecTwo); @@ -2033,7 +2134,7 @@ HMM_Dot(hmm_vec2 VecOne, hmm_vec2 VecTwo) HINLINE float HMM_Dot(hmm_vec3 VecOne, hmm_vec3 VecTwo) { - float Result = 0; + float Result; Result = HMM_DotVec3(VecOne, VecTwo); @@ -2043,7 +2144,7 @@ HMM_Dot(hmm_vec3 VecOne, hmm_vec3 VecTwo) HINLINE float HMM_Dot(hmm_vec4 VecOne, hmm_vec4 VecTwo) { - float Result = 0; + float Result; Result = HMM_DotVec4(VecOne, VecTwo); @@ -2053,7 +2154,7 @@ HMM_Dot(hmm_vec4 VecOne, hmm_vec4 VecTwo) HINLINE float HMM_Dot(hmm_quaternion QuatOne, hmm_quaternion QuatTwo) { - float Result = 0; + float Result; Result = HMM_DotQuaternion(QuatOne, QuatTwo); @@ -2063,412 +2164,459 @@ HMM_Dot(hmm_quaternion QuatOne, hmm_quaternion QuatTwo) HINLINE hmm_vec2 HMM_Add(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_AddVec2(Left, Right); + return (Result); } HINLINE hmm_vec3 HMM_Add(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_AddVec3(Left, Right); + return (Result); } HINLINE hmm_vec4 HMM_Add(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_AddVec4(Left, Right); + return (Result); } HINLINE hmm_mat4 HMM_Add(hmm_mat4 Left, hmm_mat4 Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_AddMat4(Left, Right); - return (Result); + + return (Result); } HINLINE hmm_quaternion HMM_Add(hmm_quaternion Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_AddQuaternion(Left, Right); + return(Result); } HINLINE hmm_vec2 HMM_Subtract(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_SubtractVec2(Left, Right); + return (Result); } HINLINE hmm_vec3 HMM_Subtract(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_SubtractVec3(Left, Right); + return (Result); } HINLINE hmm_vec4 HMM_Subtract(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_SubtractVec4(Left, Right); + return (Result); } HINLINE hmm_mat4 HMM_Subtract(hmm_mat4 Left, hmm_mat4 Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_SubtractMat4(Left, Right); + return (Result); } HINLINE hmm_quaternion HMM_Subtract(hmm_quaternion Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_SubtractQuaternion(Left, Right); + return (Result); } HINLINE hmm_vec2 HMM_Multiply(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_MultiplyVec2(Left, Right); + return (Result); } HINLINE hmm_vec2 HMM_Multiply(hmm_vec2 Left, float Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_MultiplyVec2f(Left, Right); + return (Result); } HINLINE hmm_vec3 HMM_Multiply(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_MultiplyVec3(Left, Right); + return (Result); } HINLINE hmm_vec3 HMM_Multiply(hmm_vec3 Left, float Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_MultiplyVec3f(Left, Right); + return (Result); } HINLINE hmm_vec4 HMM_Multiply(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_MultiplyVec4(Left, Right); + return (Result); } HINLINE hmm_vec4 HMM_Multiply(hmm_vec4 Left, float Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_MultiplyVec4f(Left, Right); + return (Result); } HINLINE hmm_mat4 HMM_Multiply(hmm_mat4 Left, hmm_mat4 Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_MultiplyMat4(Left, Right); + return (Result); } HINLINE hmm_mat4 HMM_Multiply(hmm_mat4 Left, float Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_MultiplyMat4f(Left, Right); - return (Result); + + return (Result); } HINLINE hmm_vec4 HMM_Multiply(hmm_mat4 Matrix, hmm_vec4 Vector) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_MultiplyMat4ByVec4(Matrix, Vector); + return (Result); } HINLINE hmm_quaternion HMM_Multiply(hmm_quaternion Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_MultiplyQuaternion(Left, Right); + return (Result); } HINLINE hmm_quaternion HMM_Multiply(hmm_quaternion Left, float Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_MultiplyQuaternionF(Left, Right); + return (Result); } HINLINE hmm_quaternion HMM_Multiply(float Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_MultiplyQuaternionF(Right, Left); + return (Result); } HINLINE hmm_vec2 HMM_Divide(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_DivideVec2(Left, Right); + return (Result); } HINLINE hmm_vec2 HMM_Divide(hmm_vec2 Left, float Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_DivideVec2f(Left, Right); + return (Result); } HINLINE hmm_vec3 HMM_Divide(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_DivideVec3(Left, Right); + return (Result); } HINLINE hmm_vec3 HMM_Divide(hmm_vec3 Left, float Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_DivideVec3f(Left, Right); + return (Result); } HINLINE hmm_vec4 HMM_Divide(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_DivideVec4(Left, Right); + return (Result); } HINLINE hmm_vec4 HMM_Divide(hmm_vec4 Left, float Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_DivideVec4f(Left, Right); + return (Result); } HINLINE hmm_mat4 HMM_Divide(hmm_mat4 Left, float Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_DivideMat4f(Left, Right); + return (Result); } HINLINE hmm_quaternion HMM_Divide(hmm_quaternion Left, float Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_DivideQuaternionF(Left, Right); + return (Result); } HINLINE hmm_bool HMM_Equals(hmm_vec2 Left, hmm_vec2 Right) { - hmm_bool Result = 0; + hmm_bool Result; Result = HMM_EqualsVec2(Left, Right); + return (Result); } HINLINE hmm_bool HMM_Equals(hmm_vec3 Left, hmm_vec3 Right) { - hmm_bool Result = 0; + hmm_bool Result; Result = HMM_EqualsVec3(Left, Right); + return (Result); } HINLINE hmm_bool HMM_Equals(hmm_vec4 Left, hmm_vec4 Right) { - hmm_bool Result = 0; + hmm_bool Result; Result = HMM_EqualsVec4(Left, Right); + return (Result); } HINLINE hmm_vec2 operator+(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_Add(Left, Right); + return (Result); } HINLINE hmm_vec3 operator+(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_Add(Left, Right); + return (Result); } HINLINE hmm_vec4 operator+(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_Add(Left, Right); + return (Result); } HINLINE hmm_mat4 operator+(hmm_mat4 Left, hmm_mat4 Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_Add(Left, Right); + return (Result); } HINLINE hmm_quaternion operator+(hmm_quaternion Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_Add(Left, Right); + return (Result); } HINLINE hmm_vec2 operator-(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_Subtract(Left, Right); + return (Result); } HINLINE hmm_vec3 operator-(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_Subtract(Left, Right); + return (Result); } HINLINE hmm_vec4 operator-(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_Subtract(Left, Right); + return (Result); } HINLINE hmm_mat4 operator-(hmm_mat4 Left, hmm_mat4 Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_Subtract(Left, Right); + return (Result); } HINLINE hmm_quaternion operator-(hmm_quaternion Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_Subtract(Left, Right); + return (Result); } HINLINE hmm_vec2 operator*(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_Multiply(Left, Right); + return (Result); } HINLINE hmm_vec3 operator*(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_Multiply(Left, Right); + return (Result); } HINLINE hmm_vec4 operator*(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = HMM_Multiply(Left, Right); + hmm_vec4 Result; + + Result = HMM_Multiply(Left, Right); return (Result); } @@ -2476,52 +2624,57 @@ operator*(hmm_vec4 Left, hmm_vec4 Right) HINLINE hmm_vec2 operator*(hmm_vec2 Left, float Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_Multiply(Left, Right); + return (Result); } HINLINE hmm_vec3 operator*(hmm_vec3 Left, float Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_Multiply(Left, Right); + return (Result); } HINLINE hmm_vec4 operator*(hmm_vec4 Left, float Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_Multiply(Left, Right); + return (Result); } HINLINE hmm_mat4 operator*(hmm_mat4 Left, float Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_Multiply(Left, Right); + return (Result); } HINLINE hmm_vec2 operator*(float Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_Multiply(Right, Left); + return (Result); } HINLINE hmm_vec3 operator*(float Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_Multiply(Right, Left); return (Result); @@ -2530,7 +2683,7 @@ operator*(float Left, hmm_vec3 Right) HINLINE hmm_vec4 operator*(float Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_Multiply(Right, Left); return (Result); @@ -2539,70 +2692,77 @@ operator*(float Left, hmm_vec4 Right) HINLINE hmm_mat4 operator*(float Left, hmm_mat4 Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_Multiply(Right, Left); + return (Result); } HINLINE hmm_mat4 operator*(hmm_mat4 Left, hmm_mat4 Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_Multiply(Left, Right); + return (Result); } HINLINE hmm_vec4 operator*(hmm_mat4 Matrix, hmm_vec4 Vector) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_Multiply(Matrix, Vector); + return (Result); } HINLINE hmm_quaternion operator*(hmm_quaternion Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_Multiply(Left, Right); + return (Result); } HINLINE hmm_quaternion operator*(hmm_quaternion Left, float Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_Multiply(Left, Right); + return (Result); } HINLINE hmm_quaternion operator*(float Left, hmm_quaternion Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_Multiply(Right, Left); + return (Result); } HINLINE hmm_vec2 operator/(hmm_vec2 Left, hmm_vec2 Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_Divide(Left, Right); + return (Result); } HINLINE hmm_vec3 operator/(hmm_vec3 Left, hmm_vec3 Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_Divide(Left, Right); @@ -2612,7 +2772,7 @@ operator/(hmm_vec3 Left, hmm_vec3 Right) HINLINE hmm_vec4 operator/(hmm_vec4 Left, hmm_vec4 Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_Divide(Left, Right); return (Result); @@ -2621,45 +2781,50 @@ operator/(hmm_vec4 Left, hmm_vec4 Right) HINLINE hmm_vec2 operator/(hmm_vec2 Left, float Right) { - hmm_vec2 Result = {0}; + hmm_vec2 Result; Result = HMM_Divide(Left, Right); + return (Result); } HINLINE hmm_vec3 operator/(hmm_vec3 Left, float Right) { - hmm_vec3 Result = {0}; + hmm_vec3 Result; Result = HMM_Divide(Left, Right); + return (Result); } HINLINE hmm_vec4 operator/(hmm_vec4 Left, float Right) { - hmm_vec4 Result = {0}; + hmm_vec4 Result; Result = HMM_Divide(Left, Right); + return (Result); } HINLINE hmm_mat4 operator/(hmm_mat4 Left, float Right) { - hmm_mat4 Result = {0}; + hmm_mat4 Result; Result = HMM_Divide(Left, Right); + return (Result); } HINLINE hmm_quaternion operator/(hmm_quaternion Left, float Right) { - hmm_quaternion Result = {0}; + hmm_quaternion Result; Result = HMM_Divide(Left, Right); + return (Result); }