mirror of
https://github.com/HandmadeMath/HandmadeMath.git
synced 2025-09-06 18:28:16 +00:00
887 lines
16 KiB
C
887 lines
16 KiB
C
/*
|
|
HandmadeMath.h v0.1
|
|
|
|
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 "HandmadeMade.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 "HandmadeMade.h"
|
|
|
|
All other files should just #include "HandmadeMath.h" without the #define.
|
|
==========================================================================
|
|
|
|
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@strangedev.net)
|
|
|
|
Functionality:
|
|
Matt Mascarenhas (@miblo_)
|
|
|
|
|
|
Fixes:
|
|
Jeroen van Rijn (@J_vanRijn)
|
|
*/
|
|
|
|
#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>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#ifdef HANDMADEMATH_STATIC
|
|
#define HMMDEF static
|
|
#else
|
|
#define HMMDEF extern
|
|
#endif
|
|
|
|
#if _MSC_VER && !__INTEL_COMPILER
|
|
#define HINLINE __inline
|
|
#else
|
|
#define HINLINE inline
|
|
#endif
|
|
|
|
#define Pi32 3.14159265359f
|
|
|
|
typedef union vec2
|
|
{
|
|
struct
|
|
{
|
|
float X, Y;
|
|
};
|
|
|
|
struct
|
|
{
|
|
float U, V;
|
|
};
|
|
|
|
struct
|
|
{
|
|
float Left, Right;
|
|
};
|
|
|
|
float Elements[2];
|
|
} vec2;
|
|
|
|
typedef union vec3
|
|
{
|
|
struct
|
|
{
|
|
float X, Y, Z;
|
|
};
|
|
|
|
struct
|
|
{
|
|
float U, V, W;
|
|
};
|
|
|
|
struct
|
|
{
|
|
float R, G, B;
|
|
};
|
|
|
|
struct
|
|
{
|
|
vec2 XY;
|
|
float Ignored0_;
|
|
};
|
|
|
|
struct
|
|
{
|
|
float Ignored1_;
|
|
vec2 YZ;
|
|
};
|
|
|
|
struct
|
|
{
|
|
vec2 UV;
|
|
float Ignored2_;
|
|
};
|
|
|
|
struct
|
|
{
|
|
float Ignored3_;
|
|
vec2 VW;
|
|
};
|
|
|
|
float Elements[3];
|
|
} vec3;
|
|
|
|
typedef union vec4
|
|
{
|
|
struct
|
|
{
|
|
union
|
|
{
|
|
vec3 XYZ;
|
|
struct
|
|
{
|
|
float X, Y, Z;
|
|
};
|
|
};
|
|
|
|
float W;
|
|
};
|
|
struct
|
|
{
|
|
union
|
|
{
|
|
vec3 RGB;
|
|
struct
|
|
{
|
|
float R, G, B;
|
|
};
|
|
};
|
|
|
|
float A;
|
|
};
|
|
|
|
struct
|
|
{
|
|
vec2 XY;
|
|
float Ignored0_;
|
|
float Ignored1_;
|
|
};
|
|
|
|
struct
|
|
{
|
|
float Ignored2_;
|
|
vec2 YZ;
|
|
float Ignored3_;
|
|
};
|
|
|
|
struct
|
|
{
|
|
float Ignored4_;
|
|
float Ignored5_;
|
|
vec2 ZW;
|
|
};
|
|
|
|
float Elements[4];
|
|
} vec4;
|
|
|
|
typedef union mat4
|
|
{
|
|
float Elements[4][4];
|
|
} mat4;
|
|
|
|
HMMDEF HINLINE float Power(float Base, int Exponent);
|
|
|
|
HMMDEF HINLINE vec2 V2i(int X, int Y);
|
|
HMMDEF HINLINE vec2 V2(float X, float Y);
|
|
HMMDEF HINLINE vec3 V3(float X, float Y, float Z);
|
|
HMMDEF HINLINE vec3 V3i(int X, int Y, int Z);
|
|
HMMDEF HINLINE vec4 V4(float X, float Y, float Z, float W);
|
|
HMMDEF HINLINE vec4 V4i(int X, int Y, int Z, int W);
|
|
|
|
HMMDEF HINLINE vec2 AddV2(vec2 Left, vec2 Right);
|
|
HMMDEF HINLINE vec3 AddV3(vec3 Left, vec3 Right);
|
|
HMMDEF HINLINE vec4 AddV4(vec4 Left, vec4 Right);
|
|
|
|
HMMDEF HINLINE vec2 SubtractV2(vec2 Left, vec2 Right);
|
|
HMMDEF HINLINE vec3 SubtractV3(vec3 Left, vec3 Right);
|
|
HMMDEF HINLINE vec4 SubtractV4(vec4 Left, vec4 Right);
|
|
|
|
HMMDEF HINLINE vec2 MultiplyV2(vec2 Left, vec2 Right);
|
|
HMMDEF HINLINE vec3 MultiplyV3(vec3 Left, vec3 Right);
|
|
HMMDEF HINLINE vec4 MultiplyV4(vec4 Left, vec4 Right);
|
|
|
|
HMMDEF HINLINE vec2 DivideV2(vec2 Left, vec2 Right);
|
|
HMMDEF HINLINE vec3 DivideV3(vec3 Left, vec3 Right);
|
|
HMMDEF HINLINE vec4 DivideV4(vec4 Left, vec4 Right);
|
|
|
|
HMMDEF mat4 Mat4(void);
|
|
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 Pespective(float FOV, float AspectRatio, float Near, float Far);
|
|
HMMDEF mat4 Translate(vec3 Translation);
|
|
HMMDEF mat4 Rotate(float Angle, vec3 Axis);
|
|
HMMDEF mat4 Scale(vec3 Scale);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#ifdef HANDMADE_MATH_CPP_MODE
|
|
|
|
HMMDEF HINLINE vec2 Add(int X, int Y);
|
|
HMMDEF HINLINE vec3 Add(int X, int Y, int Z);
|
|
HMMDEF HINLINE vec4 Add(int X, int Y, int Z, int W);
|
|
|
|
HMMDEF HINLINE vec2 Subtract(int X, int Y);
|
|
HMMDEF HINLINE vec3 Subtract(int X, int Y, int Z);
|
|
HMMDEF HINLINE vec4 Subtract(int X, int Y, int Z, int W);
|
|
|
|
HMMDEF HINLINE vec2 Multiply(int X, int Y);
|
|
HMMDEF HINLINE vec3 Multiply(int X, int Y, int Z);
|
|
HMMDEF HINLINE vec4 Multiply(int X, int Y, int Z, int W);
|
|
HMMDEF HINLINE mat4 Multiply(mat4 Left, mat4 Right);
|
|
|
|
HMMDEF HINLINE vec2 Divide(int X, int Y);
|
|
HMMDEF HINLINE vec3 Divide(int X, int Y, int Z);
|
|
HMMDEF HINLINE vec4 Divide(int X, int Y, int Z, int W);
|
|
|
|
HMMDEF vec2 operator+(vec2 Left, vec2 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 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 vec2 operator/(vec2 Left, vec2 Right);
|
|
HMMDEF vec3 operator/(vec3 Left, vec3 Right);
|
|
HMMDEF vec4 operator/(vec4 Left, vec4 Right);
|
|
|
|
#endif /* HANDMADE_MATH_CPP */
|
|
|
|
#endif /* HANDMADE_MATH_H */
|
|
|
|
#ifdef HANDMADE_MATH_IMPLEMENTATION
|
|
|
|
HMMDEF HINLINE float
|
|
ToRadians(float Degrees)
|
|
{
|
|
float Result = Degrees * (Pi32 / 180.0f);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE float
|
|
Power(float Base, int Exponent)
|
|
{
|
|
float Result = 1;
|
|
if (Exponent > 0)
|
|
{
|
|
for (int i = 0; i < Exponent; ++i)
|
|
{
|
|
Result *= Base;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i > Exponent; --i)
|
|
{
|
|
Result /= Base;
|
|
}
|
|
}
|
|
return (Result);
|
|
}
|
|
|
|
HMMDEF HINLINE float
|
|
Lerp(real32 A, real32 B, float Time)
|
|
{
|
|
real32 Result = (1.0f - Time) * A + Time * B;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec2
|
|
V2(float X, float Y)
|
|
{
|
|
vec2 Result;
|
|
|
|
Result.X = X;
|
|
Result.Y = Y;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
|
|
HMMDEF HINLINE vec2
|
|
V2i(int X, int Y)
|
|
{
|
|
vec2 Result;
|
|
|
|
Result.X = (float)X;
|
|
Result.Y = (float)Y;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
V3(float X, float Y, float Z)
|
|
{
|
|
vec3 Result;
|
|
|
|
Result.X = X;
|
|
Result.Y = Y;
|
|
Result.Z = Z;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
V3i(int X, int Y, int Z)
|
|
{
|
|
vec3 Result;
|
|
|
|
Result.X = (float)X;
|
|
Result.Y = (float)Y;
|
|
Result.Z = (float)Z;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
V4(float X, float Y, float Z, float W)
|
|
{
|
|
vec4 Result;
|
|
|
|
Result.X = X;
|
|
Result.Y = Y;
|
|
Result.Z = Z;
|
|
Result.W = W;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
V4i(int X, int Y, int Z, int W)
|
|
{
|
|
vec4 Result;
|
|
|
|
Result.X = (float)X;
|
|
Result.Y = (float)Y;
|
|
Result.Z = (float)Z;
|
|
Result.W = (float)W;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec2
|
|
AddV2(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result;
|
|
|
|
Result.X = Left.X + Right.X;
|
|
Result.Y = Left.Y + Right.Y;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
AddV3(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result;
|
|
|
|
Result.X = Left.X + Right.X;
|
|
Result.Y = Left.Y + Right.Y;
|
|
Result.Z = Left.Z + Right.Z;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
AddV4(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result;
|
|
|
|
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);
|
|
}
|
|
|
|
HMMDEF HINLINE vec2
|
|
SubtractV2(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result;
|
|
|
|
Result.X = Left.X - Right.X;
|
|
Result.Y = Left.Y - Right.Y;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
SubtractV3(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result;
|
|
|
|
Result.X = Left.X - Right.X;
|
|
Result.Y = Left.Y - Right.Y;
|
|
Result.Z = Left.Z - Right.Z;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
SubtractV4(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result;
|
|
|
|
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);
|
|
}
|
|
|
|
HMMDEF HINLINE vec2
|
|
MultiplyV2(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result;
|
|
|
|
Result.X = Left.X * Right.X;
|
|
Result.Y = Left.Y * Right.Y;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
MultiplyV3(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result;
|
|
|
|
Result.X = Left.Z * Right.X;
|
|
Result.Y = Left.Y * Right.Y;
|
|
Result.Z = Left.Z * Right.Z;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
MultiplyV4(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result;
|
|
|
|
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);
|
|
}
|
|
|
|
HMMDEF HINLINE vec2
|
|
DivideV2(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result;
|
|
|
|
Result.X = Left.X / Right.X;
|
|
Result.Y = Left.Y / Right.Y;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
DivideV3(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result;
|
|
|
|
Result.X = Left.X / Right.X;
|
|
Result.Y = Left.Y / Right.Y;
|
|
Result.Z = Left.Z / Right.Z;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
DivideV4(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result;
|
|
|
|
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);
|
|
}
|
|
\
|
|
HMMDEF mat4 Mat4()
|
|
{
|
|
mat4 Result;
|
|
|
|
for(int Rows = 0;
|
|
Rows < 4;
|
|
++Rows)
|
|
{
|
|
for(int Columns = 0;
|
|
Columns < 4;
|
|
++Columns)
|
|
{
|
|
Result.Elements[Rows][Columns] = 0.0f;
|
|
}
|
|
}
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF mat4
|
|
Mat4d(float Diagonal)
|
|
{
|
|
mat4 Result;
|
|
|
|
for(int Rows = 0;
|
|
Rows < 4;
|
|
++Rows)
|
|
{
|
|
for(int Columns = 0;
|
|
Columns < 4;
|
|
++Columns)
|
|
{
|
|
Result.Elements[Rows][Columns] = 0.0f;
|
|
}
|
|
}
|
|
|
|
Result.Elements[0][0] = Diagonal;
|
|
Result.Elements[1][1] = Diagonal;
|
|
Result.Elements[2][2] = Diagonal;
|
|
Result.Elements[3][3] = Diagonal;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF mat4
|
|
MultiplyMat4(mat4 Left, mat4 Right)
|
|
{
|
|
mat4 Result = Mat4();
|
|
|
|
for(int Rows = 0;
|
|
Rows < 4;
|
|
++Rows)
|
|
{
|
|
for(int Columns = 0;
|
|
Columns < 4;
|
|
++Columns)
|
|
{
|
|
Result.Elements[Rows][Columns] = Left.Elements[Rows][Columns] * Right.Elements[Rows][Columns];
|
|
}
|
|
}
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF mat4
|
|
Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far)
|
|
{
|
|
mat4 Result = 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[0][3] = (Left + Right) / (Left - Right);
|
|
Result.Elements[1][3] = (Bottom + Top) / (Bottom - Top);
|
|
Result.Elements[2][3] = (Far + Near) / (Far - Near);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF mat4
|
|
Pespective(float FOV, float AspectRatio, float Near, float Far)
|
|
{
|
|
mat4 Result = Mat4d(1.0f);
|
|
|
|
Result.Elements[0][0] = 1.0f / tan(ToRadians(0.5f * FOV));
|
|
Result.Elements[1][1] = (1.0f / tan(ToRadians(0.5f * FOV))) / AspectRatio;
|
|
Result.Elements[2][2] = (Near + Far) / (Near - Far);
|
|
Result.Elements[3][2] = -1.0f;
|
|
Result.Elements[2][3] = (2.0f * Near * Far) / (Near - Far);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF mat4
|
|
Translate(vec3 Translation)
|
|
{
|
|
mat4 Result = Mat4d(1.0f);
|
|
|
|
Result.Elements[0][3] = Translation.X;
|
|
Result.Elements[1][3] = Translation.Y;
|
|
Result.Elements[2][3] = Translation.Z;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF mat4
|
|
Rotate(float Angle, vec3 Axis)
|
|
{
|
|
mat4 Result = Mat4d(1.0f);
|
|
|
|
Result.Elements[0][0] = Axis.Z * (1.0f - cos(ToRadians(Angle))) + cos(ToRadians(Angle));
|
|
Result.Elements[1][0] = Axis.Y * Axis.X * (1.0f - cos(ToRadians(Angle))) + Axis.Z * (sin(ToRadians(Angle)));
|
|
Result.Elements[2][0] = Axis.X * Axis.Z * (1.0f - cos(ToRadians(Angle))) - Axis.Y * (sin(ToRadians(Angle)));
|
|
|
|
Result.Elements[0][1] = Axis.X * Axis.Y * (1.0f - cos(ToRadians(Angle))) - Axis.Z * (sin(ToRadians(Angle)));
|
|
Result.Elements[1][1] = Axis.Y * (1.0f - cos(ToRadians(Angle))) + (cos(ToRadians(Angle)));
|
|
Result.Elements[2][1] = Axis.Y * Axis.Z * (1.0f - cos(ToRadians(Angle))) + Axis.X * (sin(ToRadians(Angle)));
|
|
|
|
Result.Elements[0][2] = Axis.X * Axis.Z * (1.0f - cos(ToRadians(Angle))) + Axis.Y * (sin(ToRadians(Angle)));
|
|
Result.Elements[1][2] = Axis.Y * Axis.Z * (1.0f - cos(ToRadians(Angle))) - Axis.X * (sin(ToRadians(Angle)));
|
|
Result.Elements[2][2] = Axis.Z * (1.0f - cos(ToRadians(Angle))) * (cos(ToRadians(Angle)));
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF mat4
|
|
Scale(vec3 Scale)
|
|
{
|
|
mat4 Result = Mat4d(1.0f);
|
|
|
|
Result.Elements[0][0] = Scale.X;
|
|
Result.Elements[1][1] = Scale.Y;
|
|
Result.Elements[2][2] = Scale.Z;
|
|
|
|
return(Result);
|
|
}
|
|
|
|
#ifdef HANDMADE_MATH_CPP_MODE
|
|
|
|
HMMDEF HINLINE vec2
|
|
Add(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result = AddV2(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
Add(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result = AddV3(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
Add(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result = AddV4(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec2
|
|
Subtract(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result = SubtractV2(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
Subtract(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result = SubtractV3(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
Subtract(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result = SubtractV4(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec2
|
|
Multiply(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result = MultiplyV2(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
Multiply(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result = MultiplyV3(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
Multiply(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result = MultiplyV4(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE mat4
|
|
Multiply(mat4 Left, mat4 Right)
|
|
{
|
|
mat4 Result = MultiplyMat4(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec2
|
|
Divide(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result = DivideV2(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec3
|
|
Divide(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result = DivideV3(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF HINLINE vec4
|
|
Divide(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result = DivideV4(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec2
|
|
operator+(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result = Add(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec3
|
|
operator+(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result = Add(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec4
|
|
operator+(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result = Add(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec2
|
|
operator-(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result = Subtract(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec3
|
|
operator-(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result = Subtract(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec4
|
|
operator-(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result = Subtract(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec2
|
|
operator*(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result = Multiply(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec3
|
|
operator*(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result = Multiply(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec4
|
|
operator*(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result = Multiply(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF mat4
|
|
operator*(mat4 Left, mat4 Right)
|
|
{
|
|
mat4 Result = Multiply(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec2
|
|
operator/(vec2 Left, vec2 Right)
|
|
{
|
|
vec2 Result = Divide(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec3
|
|
operator/(vec3 Left, vec3 Right)
|
|
{
|
|
vec3 Result = Divide(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
HMMDEF vec4
|
|
operator/(vec4 Left, vec4 Right)
|
|
{
|
|
vec4 Result = Divide(Left, Right);
|
|
|
|
return(Result);
|
|
}
|
|
|
|
#endif /* HANDMADE_MATH_CPP_MODE */
|
|
|
|
#endif /* HANDMADE_MATH_IMPLEMENTATION */
|
|
|
|
|