Fixed some bugs

HandmadeMath.h

@@ -44,6 +44,7 @@
 
   Functionality:
    Matt Mascarenhas (@miblo_)
+   Aleph
 
   Fixes:
    Jeroen van Rijn (@J_vanRijn)
@@ -54,8 +55,8 @@
 #ifndef HANDMADE_MATH_H
 #define HANDMADE_MATH_H
 
-// TODO(zak): Make some sort of documentation for this and a way to remove it
+
-#include <math.h>
+#include <math.h> // TODO(zak): Remove this later on
 
 #ifdef __cplusplus
 extern "C" {
@@ -76,6 +77,12 @@ extern "C" {
 #define Pi32 3.14159265359f
 #define HMM_PI 3.14159265358979323846
 
+#define MIN(a, b) (a) > (b) ? (b) : (a)
+#define MAX(a, b) (a) < (b) ? (b) : (a)
+#define ABS(a) (a) < 0 ? -(a) : (a)
+#define MOD(a, m) ((a) % (m)) >= 0 ? ((a) % (m)) : (((a) % (m)) + (m))
+#define Square(x) ((x) * (x))
+
 typedef union vec2
 {
     struct
@@ -198,46 +205,78 @@ typedef union mat4
     float Elements[4][4];
 } mat4;
 
-HMMDEF HINLINE float Power(float Base, int Exponent);
+HMMDEF float
-HMMDEF HINLINE float Clamp(float Min, float Value, float Max);
+Power(float Base, int Exponent);
-HMMDEF HINLINE vec3 Normalize(vec3 A);
+HMMDEF float
-HMMDEF HINLINE vec3 Cross(vec3 VecOne, vec3 VecTwo);
+Clamp(float Min, float Value, float Max);
-HMMDEF HINLINE float Dot(vec3 VecOne, vec3 VecTwo);
+HMMDEF vec3
+Normalize(vec3 A);
+HMMDEF vec3
+Cross(vec3 VecOne, vec3 VecTwo);
+HMMDEF float
+Dot(vec3 VecOne, vec3 VecTwo);
 
-HMMDEF HINLINE vec2 Vec2i(int X, int Y);
+HMMDEF vec2
-HMMDEF HINLINE vec2 Vec2(float X, float Y);
+Vec2i(int X, int Y);
-HMMDEF HINLINE vec3 Vec3(float X, float Y, float Z);
+HMMDEF vec2
-HMMDEF HINLINE vec3 Vec3i(int X, int Y, int Z);
+Vec2(float X, float Y);
-HMMDEF HINLINE vec4 Vec4(float X, float Y, float Z, float W);
+HMMDEF vec3
-HMMDEF HINLINE vec4 Vec4i(int X, int Y, int Z, int W);
+Vec3(float X, float Y, float Z);
+HMMDEF vec3
+Vec3i(int X, int Y, int Z);
+HMMDEF vec4
+Vec4(float X, float Y, float Z, float W);
+HMMDEF vec4
+Vec4i(int X, int Y, int Z, int W);
 
-HMMDEF HINLINE vec2 AddVec2(vec2 Left, vec2 Right);
+HMMDEF vec2
-HMMDEF HINLINE vec3 AddVec3(vec3 Left, vec3 Right);
+AddVec2(vec2 Left, vec2 Right);
-HMMDEF HINLINE vec4 AddVec4(vec4 Left, vec4 Right);
+HMMDEF vec3
+AddVec3(vec3 Left, vec3 Right);
+HMMDEF vec4
+AddVec4(vec4 Left, vec4 Right);
 
-HMMDEF HINLINE vec2 SubtractVec2(vec2 Left, vec2 Right);
+HMMDEF vec2
-HMMDEF HINLINE vec3 SubtractVec3(vec3 Left, vec3 Right);
+SubtractVec2(vec2 Left, vec2 Right);
-HMMDEF HINLINE vec4 SubtractVec4(vec4 Left, vec4 Right);
+HMMDEF vec3
+SubtractVec3(vec3 Left, vec3 Right);
+HMMDEF vec4
+SubtractVec4(vec4 Left, vec4 Right);
 
-HMMDEF HINLINE vec2 MultiplyVec2(vec2 Left, vec2 Right);
+HMMDEF vec2
-HMMDEF HINLINE vec3 MultiplyVec3(vec3 Left, vec3 Right);
+MultiplyVec2(vec2 Left, vec2 Right);
-HMMDEF HINLINE vec4 MultiplyVec4(vec4 Left, vec4 Right);
+HMMDEF vec3
+MultiplyVec3(vec3 Left, vec3 Right);
+HMMDEF vec4
+MultiplyVec4(vec4 Left, vec4 Right);
 
-HMMDEF HINLINE vec2 DivideVec2(vec2 Left, vec2 Right);
+HMMDEF vec2
-HMMDEF HINLINE vec3 DivideVec3(vec3 Left, vec3 Right);
+DivideVec2(vec2 Left, vec2 Right);
-HMMDEF HINLINE vec4 DivideVec4(vec4 Left, vec4 Right);
+HMMDEF vec3
+DivideVec3(vec3 Left, vec3 Right);
+HMMDEF vec4
+DivideVec4(vec4 Left, vec4 Right);
 
-HMMDEF mat4 Mat4(void);
+HMMDEF mat4
-HMMDEF mat4 Mat4d(float Diagonal);
+Mat4(void);
-HMMDEF mat4 MultiplyMat4(mat4 Left, mat4 Right);
+HMMDEF mat4
+Mat4d(float Diagonal);
+HMMDEF mat4
+MultiplyMat4(mat4 Left, mat4 Right);
 
-HMMDEF mat4 Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far);
+HMMDEF mat4
-HMMDEF mat4 Perspective(float FOV, float AspectRatio, float Near, float Far);
+Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far);
-HMMDEF mat4 Translate(vec3 Translation);
+HMMDEF mat4
-HMMDEF mat4 Rotate(float Angle, vec3 Axis);
+Perspective(float FOV, float AspectRatio, float Near, float Far);
-HMMDEF mat4 Scale(vec3 Scale);
+HMMDEF mat4
+Translate(vec3 Translation);
+HMMDEF mat4
+Rotate(float Angle, vec3 Axis);
+HMMDEF mat4
+Scale(vec3 Scale);
 
-HMMDEF mat4 LookAt(vec3 Eye, vec3 Center, vec3 Up);
+HMMDEF mat4
+LookAt(vec3 Eye, vec3 Center, vec3 Up);
 
 #ifdef __cplusplus
 }
@@ -245,41 +284,63 @@ HMMDEF mat4 LookAt(vec3 Eye, vec3 Center, vec3 Up);
 
 #ifdef HANDMADE_MATH_CPP_MODE
 
-HMMDEF HINLINE vec2 Add(int X, int Y);
+HMMDEF vec2
-HMMDEF HINLINE vec3 Add(int X, int Y, int Z);
+Add(int X, int Y);
-HMMDEF HINLINE vec4 Add(int X, int Y, int Z, int W);
+HMMDEF vec3
+Add(int X, int Y, int Z);
+HMMDEF vec4
+Add(int X, int Y, int Z, int W);
 
-HMMDEF HINLINE vec2 Subtract(int X, int Y);
+HMMDEF vec2
-HMMDEF HINLINE vec3 Subtract(int X, int Y, int Z);
+Subtract(int X, int Y);
-HMMDEF HINLINE vec4 Subtract(int X, int Y, int Z, int W);
+HMMDEF vec3
+Subtract(int X, int Y, int Z);
+HMMDEF vec4
+Subtract(int X, int Y, int Z, int W);
 
-HMMDEF HINLINE vec2 Multiply(int X, int Y);
+HMMDEF vec2
-HMMDEF HINLINE vec3 Multiply(int X, int Y, int Z);
+Multiply(int X, int Y);
-HMMDEF HINLINE vec4 Multiply(int X, int Y, int Z, int W);
+HMMDEF vec3
-HMMDEF HINLINE mat4 Multiply(mat4 Left, mat4 Right);
+Multiply(int X, int Y, int Z);
+HMMDEF vec4
+Multiply(int X, int Y, int Z, int W);
+HMMDEF mat4
+Multiply(mat4 Left, mat4 Right);
 
-HMMDEF HINLINE vec2 Divide(int X, int Y);
+HMMDEF vec2
-HMMDEF HINLINE vec3 Divide(int X, int Y, int Z);
+Divide(int X, int Y);
-HMMDEF HINLINE vec4 Divide(int X, int Y, int Z, int W);    
+HMMDEF vec3
+Divide(int X, int Y, int Z);
+HMMDEF vec4
+Divide(int X, int Y, int Z, int W);
 
-HMMDEF vec2 operator+(vec2 Left, vec2 Right);
+HMMDEF vec2
-HMMDEF vec3 operator+(vec3 Left, vec3 Right);
+operator+(vec2 Left, vec2 Right);
-HMMDEF vec4 operator+(vec4 Left, vec4 Right);
+HMMDEF vec3
+operator+(vec3 Left, vec3 Right);
+HMMDEF vec4
+operator+(vec4 Left, vec4 Right);
 
-HMMDEF vec2 operator-(vec2 Left, vec2 Right);
+HMMDEF vec2
-HMMDEF vec3 operator-(vec3 Left, vec3 Right);
+operator-(vec2 Left, vec2 Right);
-HMMDEF vec4 operator-(vec4 Left, vec4 Right);
+HMMDEF vec3
+operator-(vec3 Left, vec3 Right);
+HMMDEF vec4
+operator-(vec4 Left, vec4 Right);
 
 HMMDEF vec2 operator*(vec2 Left, vec2 Right);
 HMMDEF vec3 operator*(vec3 Left, vec3 Right);
 HMMDEF vec4 operator*(vec4 Left, vec4 Right);
 HMMDEF mat4 operator*(mat4 Left, mat4 Right);
 HMMDEF vec3 operator*(vec3 Left, float Right);
+HMMDEF vec2 operator*(vec2 Left, float Right);
 
-HMMDEF vec2 operator/(vec2 Left, vec2 Right);
+HMMDEF vec2
-HMMDEF vec3 operator/(vec3 Left, vec3 Right);
+operator/(vec2 Left, vec2 Right);
-HMMDEF vec4 operator/(vec4 Left, vec4 Right);
+HMMDEF vec3
-
+operator/(vec3 Left, vec3 Right);
+HMMDEF vec4
+operator/(vec4 Left, vec4 Right);
 
 #endif /* HANDMADE_MATH_CPP */
 
@@ -397,9 +458,7 @@ Dot(vec3 VecOne, vec3 VecTwo)
 {
     float Result = 0;
 
-    Result = (VecOne.X * VecTwo.X) +
+    Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z);
-             (VecOne.Y * VecTwo.Y) +
-             (VecOne.Z * VecTwo.Z);
 
     return (Result);
 }
@@ -620,17 +679,14 @@ DivideVec4(vec4 Left, vec4 Right)
     return (Result);
 }
 
-HMMDEF mat4 Mat4()
+HMMDEF mat4
+Mat4()
 {
     mat4 Result;
 
-    for(int Rows = 0;
+    for(int Rows = 0; Rows < 4; ++Rows)
-        Rows < 4;
-        ++Rows)
     {
-        for(int Columns = 0;
+        for(int Columns = 0; Columns < 4; ++Columns)
-            Columns < 4;
-            ++Columns)
         {
             Result.Elements[Rows][Columns] = 0.0f;
         }
@@ -644,13 +700,9 @@ Mat4d(float Diagonal)
 {
     mat4 Result;
 
-    for(int Rows = 0;
+    for(int Rows = 0; Rows < 4; ++Rows)
-        Rows < 4;
-        ++Rows)
     {
-        for(int Columns = 0;
+        for(int Columns = 0; Columns < 4; ++Columns)
-            Columns < 4;
-            ++Columns)
         {
             Result.Elements[Rows][Columns] = 0.0f;
         }
@@ -669,18 +721,12 @@ MultiplyMat4(mat4 Left, mat4 Right)
 {
     mat4 Result = Mat4();
 
-    for(int Rows = 0;
+    for(int Rows = 0; Rows < 4; ++Rows)
-        Rows < 4;
-        ++Rows)
     {
-        for(int Columns = 0;
+        for(int Columns = 0; Columns < 4; ++Columns)
-            Columns < 4;
-            ++Columns)
         {
             float Sum = 0;
-            for(int CurrentMatrice = 0;
+            for(int CurrentMatrice = 0; CurrentMatrice < 4; ++CurrentMatrice)
-                CurrentMatrice < 4;
-                ++CurrentMatrice)
             {
                 Sum += Right.Elements[Rows][CurrentMatrice] * Left.Elements[CurrentMatrice][Columns];
             }
@@ -713,8 +759,8 @@ Perspective(float FOV, float AspectRatio, float Near, float Far)
 {
     mat4 Result = Mat4d(1.0f);
 
-    Result.Elements[0][0] = 1.0f / (AspectRatio  * tan(FOV / 2.0f));
+    Result.Elements[0][0] = 1.0f / (AspectRatio * tanf(FOV / 2.0f));
-    Result.Elements[1][1] = 1.0f / tan(FOV / 2.0f);
+    Result.Elements[1][1] = 1.0f / tanf(FOV / 2.0f);
     Result.Elements[2][3] = -1.0f;
     Result.Elements[2][2] = -(Far + Near) / (Far - Near);
     Result.Elements[3][2] = -(2.0f * Far * Near) / (Far - Near);
@@ -740,17 +786,17 @@ Rotate(float Angle, vec3 Axis)
 {
     mat4 Result = Mat4d(1.0f);
 
-    Result.Elements[0][0] = Axis.X * Axis.X * (1.0f - cos(ToRadians(Angle))) + cos(ToRadians(Angle));
+    Result.Elements[0][0] = Axis.X * Axis.X * (1.0f - cosf(ToRadians(Angle))) + cosf(ToRadians(Angle));
-    Result.Elements[0][1] = Axis.Y * Axis.X * (1.0f - cos(ToRadians(Angle))) + Axis.Z * (sin(ToRadians(Angle)));
+    Result.Elements[0][1] = Axis.Y * Axis.X * (1.0f - cosf(ToRadians(Angle))) + Axis.Z * (sinf(ToRadians(Angle)));
-    Result.Elements[0][2] = Axis.X * Axis.Z * (1.0f - cos(ToRadians(Angle))) - Axis.Y * (sin(ToRadians(Angle)));
+    Result.Elements[0][2] = Axis.X * Axis.Z * (1.0f - cosf(ToRadians(Angle))) - Axis.Y * (sinf(ToRadians(Angle)));
 
-    Result.Elements[1][0] = Axis.X * Axis.Y * (1.0f - cos(ToRadians(Angle))) - Axis.Z * (sin(ToRadians(Angle)));
+    Result.Elements[1][0] = Axis.X * Axis.Y * (1.0f - cosf(ToRadians(Angle))) - Axis.Z * (sinf(ToRadians(Angle)));
-    Result.Elements[1][1] = Axis.Y * Axis.Y * (1.0f - cos(ToRadians(Angle))) + (cos(ToRadians(Angle)));
+    Result.Elements[1][1] = Axis.Y * Axis.Y * (1.0f - cosf(ToRadians(Angle))) + (cosf(ToRadians(Angle)));
-    Result.Elements[1][2] = Axis.Y * Axis.Z * (1.0f - cos(ToRadians(Angle))) + Axis.X * (sin(ToRadians(Angle)));
+    Result.Elements[1][2] = Axis.Y * Axis.Z * (1.0f - cosf(ToRadians(Angle))) + Axis.X * (sinf(ToRadians(Angle)));
 
-    Result.Elements[2][0] = Axis.X * Axis.Z * (1.0f - cos(ToRadians(Angle))) + Axis.Y * (sin(ToRadians(Angle)));
+    Result.Elements[2][0] = Axis.X * Axis.Z * (1.0f - cosf(ToRadians(Angle))) + Axis.Y * (sinf(ToRadians(Angle)));
-    Result.Elements[2][1] = Axis.Y * Axis.Z * (1.0f - cos(ToRadians(Angle))) - Axis.X * (sin(ToRadians(Angle)));
+    Result.Elements[2][1] = Axis.Y * Axis.Z * (1.0f - cosf(ToRadians(Angle))) - Axis.X * (sinf(ToRadians(Angle)));
-    Result.Elements[2][2] = Axis.Z * Axis.Z * (1.0f - cos(ToRadians(Angle))) * (cos(ToRadians(Angle)));
+    Result.Elements[2][2] = Axis.Z * Axis.Z * (1.0f - cosf(ToRadians(Angle))) * (cosf(ToRadians(Angle)));
 
     return (Result);
 }
@@ -950,24 +996,21 @@ operator-(vec4 Left, vec4 Right)
     return (Result);
 }
 
-HMMDEF HINLINE vec2
+HMMDEF HINLINE vec2 operator*(vec2 Left, vec2 Right)
-operator*(vec2 Left, vec2 Right)
 {
     vec2 Result = Multiply(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3
+HMMDEF HINLINE vec3 operator*(vec3 Left, vec3 Right)
-operator*(vec3 Left, vec3 Right)
 {
     vec3 Result = Multiply(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3
+HMMDEF HINLINE vec3 operator*(vec3 Left, float Right)
-operator*(vec3 Left, float Right)
 {
     vec3 Result;
 
@@ -978,16 +1021,24 @@ operator*(vec3 Left, float Right)
     return (Result);
 }
 
-HMMDEF HINLINE vec4
+HMMDEF vec2 operator*(vec2 Left, float Right)
-operator*(vec4 Left, vec4 Right)
+{
+    vec2 Result;
+
+    Result.X = Right * Left.X;
+    Result.Y = Right * Left.Y;
+
+    return (Result);
+}
+
+HMMDEF HINLINE vec4 operator*(vec4 Left, vec4 Right)
 {
     vec4 Result = Multiply(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE mat4
+HMMDEF HINLINE mat4 operator*(mat4 Left, mat4 Right)
-operator*(mat4 Left, mat4 Right)
 {
     mat4 Result = Multiply(Left, Right);
 
@@ -1021,5 +1072,3 @@ operator/(vec4 Left, vec4 Right)
 #endif /* HANDMADE_MATH_CPP_MODE */
 
 #endif /* HANDMADE_MATH_IMPLEMENTATION */
-
-