MrMonopoly/raylib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixes formatting

Browse Source
This commit is contained in:
Lam Wei Lun 2026-03-02 00:48:29 +08:00
parent be1f2a36cb
commit 1309881850
1 changed files with 233 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

195
src/raymath_cpp_addon.h
View File

@ -26,8 +26,8 @@
* *
**********************************************************************************************/ **********************************************************************************************/
#ifndef RAYMATH_ADDON_H #ifndef RAYMATH_CPP_ADDON_H
#define RAYMATH_ADDON_H #define RAYMATH_CPP_ADDON_H
#if defined(__cplusplus) && !defined(RAYMATH_DISABLE_CPP_OPERATORS) #if defined(__cplusplus) && !defined(RAYMATH_DISABLE_CPP_OPERATORS)
@ -42,74 +42,90 @@ RMAPI Vector2 Vector2Ones = {1, 1};
RMAPI Vector2 Vector2UnitX = { 1, 0 }; RMAPI Vector2 Vector2UnitX = { 1, 0 };
RMAPI Vector2 Vector2UnitY = { 0, 1 }; RMAPI Vector2 Vector2UnitY = { 0, 1 };
RMAPI Vector2 operator+(const Vector2 &lhs, const Vector2 &rhs) { RMAPI Vector2 operator+(const Vector2 &lhs, const Vector2 &rhs)
{
return Vector2Add(lhs, rhs); return Vector2Add(lhs, rhs);
} }
RMAPI const Vector2 &operator+=(Vector2 &lhs, const Vector2 &rhs) { RMAPI const Vector2 &operator+=(Vector2 &lhs, const Vector2 &rhs)
{
lhs = Vector2Add(lhs, rhs); lhs = Vector2Add(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector2 operator-(const Vector2 &lhs, const Vector2 &rhs) { RMAPI Vector2 operator-(const Vector2 &lhs, const Vector2 &rhs)
{
return Vector2Subtract(lhs, rhs); return Vector2Subtract(lhs, rhs);
} }
RMAPI const Vector2 &operator-=(Vector2 &lhs, const Vector2 &rhs) { RMAPI const Vector2 &operator-=(Vector2 &lhs, const Vector2 &rhs)
{
lhs = Vector2Subtract(lhs, rhs); lhs = Vector2Subtract(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector2 operator*(const Vector2 &lhs, const float &rhs) { RMAPI Vector2 operator*(const Vector2 &lhs, const float &rhs)
{
return Vector2Scale(lhs, rhs); return Vector2Scale(lhs, rhs);
} }
RMAPI const Vector2 &operator*=(Vector2 &lhs, const float &rhs) { RMAPI const Vector2 &operator*=(Vector2 &lhs, const float &rhs)
{
lhs = Vector2Scale(lhs, rhs); lhs = Vector2Scale(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector2 operator*(const Vector2 &lhs, const Vector2 &rhs) { RMAPI Vector2 operator*(const Vector2 &lhs, const Vector2 &rhs)
{
return Vector2Multiply(lhs, rhs); return Vector2Multiply(lhs, rhs);
} }
RMAPI const Vector2 &operator*=(Vector2 &lhs, const Vector2 &rhs) { RMAPI const Vector2 &operator*=(Vector2 &lhs, const Vector2 &rhs)
{
lhs = Vector2Multiply(lhs, rhs); lhs = Vector2Multiply(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector2 operator*(const Vector2 &lhs, const Matrix &rhs) { RMAPI Vector2 operator*(const Vector2 &lhs, const Matrix &rhs)
{
return Vector2Transform(lhs, rhs); return Vector2Transform(lhs, rhs);
} }
RMAPI const Vector2 &operator*=(Vector2 &lhs, const Matrix &rhs) { RMAPI const Vector2 &operator*=(Vector2 &lhs, const Matrix &rhs)
{
lhs = Vector2Transform(lhs, rhs); lhs = Vector2Transform(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector2 operator/(const Vector2 &lhs, const float &rhs) { RMAPI Vector2 operator/(const Vector2 &lhs, const float &rhs)
{
return Vector2Scale(lhs, 1.0f / rhs); return Vector2Scale(lhs, 1.0f / rhs);
} }
RMAPI const Vector2 &operator/=(Vector2 &lhs, const float &rhs) { RMAPI const Vector2 &operator/=(Vector2 &lhs, const float &rhs)
{
lhs = Vector2Scale(lhs, 1.0f / rhs); lhs = Vector2Scale(lhs, 1.0f / rhs);
return lhs; return lhs;
} }
RMAPI Vector2 operator/(const Vector2 &lhs, const Vector2 &rhs) { RMAPI Vector2 operator/(const Vector2 &lhs, const Vector2 &rhs)
{
return Vector2Divide(lhs, rhs); return Vector2Divide(lhs, rhs);
} }
RMAPI const Vector2 &operator/=(Vector2 &lhs, const Vector2 &rhs) { RMAPI const Vector2 &operator/=(Vector2 &lhs, const Vector2 &rhs)
{
lhs = Vector2Divide(lhs, rhs); lhs = Vector2Divide(lhs, rhs);
return lhs; return lhs;
} }
RMAPI bool operator==(const Vector2 &lhs, const Vector2 &rhs) { RMAPI bool operator==(const Vector2 &lhs, const Vector2 &rhs)
{
return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y); return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y);
} }
RMAPI bool operator!=(const Vector2 &lhs, const Vector2 &rhs) { RMAPI bool operator!=(const Vector2 &lhs, const Vector2 &rhs)
{
return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y); return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y);
} }
@ -120,75 +136,91 @@ RMAPI Vector3 Vector3UnitX = {1, 0, 0};
RMAPI Vector3 Vector3UnitY = {0, 1, 0}; RMAPI Vector3 Vector3UnitY = {0, 1, 0};
RMAPI Vector3 Vector3UnitZ = {0, 0, 1}; RMAPI Vector3 Vector3UnitZ = {0, 0, 1};
RMAPI Vector3 operator+(const Vector3 &lhs, const Vector3 &rhs) { RMAPI Vector3 operator+(const Vector3 &lhs, const Vector3 &rhs)
{
return Vector3Add(lhs, rhs); return Vector3Add(lhs, rhs);
} }
RMAPI const Vector3 &operator+=(Vector3 &lhs, const Vector3 &rhs) { RMAPI const Vector3 &operator+=(Vector3 &lhs, const Vector3 &rhs)
{
lhs = Vector3Add(lhs, rhs); lhs = Vector3Add(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector3 operator-(const Vector3 &lhs, const Vector3 &rhs) { RMAPI Vector3 operator-(const Vector3 &lhs, const Vector3 &rhs)
{
return Vector3Subtract(lhs, rhs); return Vector3Subtract(lhs, rhs);
} }
RMAPI const Vector3 &operator-=(Vector3 &lhs, const Vector3 &rhs) { RMAPI const Vector3 &operator-=(Vector3 &lhs, const Vector3 &rhs)
{
lhs = Vector3Subtract(lhs, rhs); lhs = Vector3Subtract(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector3 operator*(const Vector3 &lhs, const float &rhs) { RMAPI Vector3 operator*(const Vector3 &lhs, const float &rhs)
{
return Vector3Scale(lhs, rhs); return Vector3Scale(lhs, rhs);
} }
RMAPI const Vector3 &operator*=(Vector3 &lhs, const float &rhs) { RMAPI const Vector3 &operator*=(Vector3 &lhs, const float &rhs)
{
lhs = Vector3Scale(lhs, rhs); lhs = Vector3Scale(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector3 operator*(const Vector3 &lhs, const Vector3 &rhs) { RMAPI Vector3 operator*(const Vector3 &lhs, const Vector3 &rhs)
{
return Vector3Multiply(lhs, rhs); return Vector3Multiply(lhs, rhs);
} }
RMAPI const Vector3 &operator*=(Vector3 &lhs, const Vector3 &rhs) { RMAPI const Vector3 &operator*=(Vector3 &lhs, const Vector3 &rhs)
{
lhs = Vector3Multiply(lhs, rhs); lhs = Vector3Multiply(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector3 operator*(const Vector3 &lhs, const Matrix &rhs) { RMAPI Vector3 operator*(const Vector3 &lhs, const Matrix &rhs)
{
return Vector3Transform(lhs, rhs); return Vector3Transform(lhs, rhs);
} }
RMAPI const Vector3 &operator*=(Vector3 &lhs, const Matrix &rhs) { RMAPI const Vector3 &operator*=(Vector3 &lhs, const Matrix &rhs)
{
lhs = Vector3Transform(lhs, rhs); lhs = Vector3Transform(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector3 operator/(const Vector3 &lhs, const float &rhs) { RMAPI Vector3 operator/(const Vector3 &lhs, const float &rhs)
{
return Vector3Scale(lhs, 1.0f / rhs); return Vector3Scale(lhs, 1.0f / rhs);
} }
RMAPI const Vector3 &operator/=(Vector3 &lhs, const float &rhs) { RMAPI const Vector3 &operator/=(Vector3 &lhs, const float &rhs)
{
lhs = Vector3Scale(lhs, 1.0f / rhs); lhs = Vector3Scale(lhs, 1.0f / rhs);
return lhs; return lhs;
} }
RMAPI Vector3 operator/(const Vector3 &lhs, const Vector3 &rhs) { RMAPI Vector3 operator/(const Vector3 &lhs, const Vector3 &rhs)
{
return Vector3Divide(lhs, rhs); return Vector3Divide(lhs, rhs);
} }
RMAPI const Vector3 &operator/=(Vector3 &lhs, const Vector3 &rhs) { RMAPI const Vector3 &operator/=(Vector3 &lhs, const Vector3 &rhs)
{
lhs = Vector3Divide(lhs, rhs); lhs = Vector3Divide(lhs, rhs);
return lhs; return lhs;
} }
RMAPI bool operator==(const Vector3 &lhs, const Vector3 &rhs) { RMAPI bool operator==(const Vector3 &lhs, const Vector3 &rhs)
{
return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) && return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) &&
FloatEquals(lhs.z, rhs.z); FloatEquals(lhs.z, rhs.z);
} }
RMAPI bool operator!=(const Vector3 &lhs, const Vector3 &rhs) { RMAPI bool operator!=(const Vector3 &lhs, const Vector3 &rhs)
{
return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) || return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) ||
!FloatEquals(lhs.z, rhs.z); !FloatEquals(lhs.z, rhs.z);
} }
@ -201,66 +233,80 @@ RMAPI Vector4 Vector4UnitY = {0, 1, 0, 0};
RMAPI Vector4 Vector4UnitZ = { 0, 0, 1, 0 }; RMAPI Vector4 Vector4UnitZ = { 0, 0, 1, 0 };
RMAPI Vector4 Vector4UnitW = { 0, 0, 0, 1 }; RMAPI Vector4 Vector4UnitW = { 0, 0, 0, 1 };
RMAPI Vector4 operator+(const Vector4 &lhs, const Vector4 &rhs) { RMAPI Vector4 operator+(const Vector4 &lhs, const Vector4 &rhs)
{
return Vector4Add(lhs, rhs); return Vector4Add(lhs, rhs);
} }
RMAPI const Vector4 &operator+=(Vector4 &lhs, const Vector4 &rhs) { RMAPI const Vector4 &operator+=(Vector4 &lhs, const Vector4 &rhs)
{
lhs = Vector4Add(lhs, rhs); lhs = Vector4Add(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector4 operator-(const Vector4 &lhs, const Vector4 &rhs) { RMAPI Vector4 operator-(const Vector4 &lhs, const Vector4 &rhs)
{
return Vector4Subtract(lhs, rhs); return Vector4Subtract(lhs, rhs);
} }
RMAPI const Vector4 &operator-=(Vector4 &lhs, const Vector4 &rhs) { RMAPI const Vector4 &operator-=(Vector4 &lhs, const Vector4 &rhs)
{
lhs = Vector4Subtract(lhs, rhs); lhs = Vector4Subtract(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector4 operator*(const Vector4 &lhs, const float &rhs) { RMAPI Vector4 operator*(const Vector4 &lhs, const float &rhs)
{
return Vector4Scale(lhs, rhs); return Vector4Scale(lhs, rhs);
} }
RMAPI const Vector4 &operator*=(Vector4 &lhs, const float &rhs) { RMAPI const Vector4 &operator*=(Vector4 &lhs, const float &rhs)
{
lhs = Vector4Scale(lhs, rhs); lhs = Vector4Scale(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector4 operator*(const Vector4 &lhs, const Vector4 &rhs) { RMAPI Vector4 operator*(const Vector4 &lhs, const Vector4 &rhs)
{
return Vector4Multiply(lhs, rhs); return Vector4Multiply(lhs, rhs);
} }
RMAPI const Vector4 &operator*=(Vector4 &lhs, const Vector4 &rhs) { RMAPI const Vector4 &operator*=(Vector4 &lhs, const Vector4 &rhs)
{
lhs = Vector4Multiply(lhs, rhs); lhs = Vector4Multiply(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Vector4 operator/(const Vector4 &lhs, const float &rhs) { RMAPI Vector4 operator/(const Vector4 &lhs, const float &rhs)
{
return Vector4Scale(lhs, 1.0f / rhs); return Vector4Scale(lhs, 1.0f / rhs);
} }
RMAPI const Vector4 &operator/=(Vector4 &lhs, const float &rhs) { RMAPI const Vector4 &operator/=(Vector4 &lhs, const float &rhs)
{
lhs = Vector4Scale(lhs, 1.0f / rhs); lhs = Vector4Scale(lhs, 1.0f / rhs);
return lhs; return lhs;
} }
RMAPI Vector4 operator/(const Vector4 &lhs, const Vector4 &rhs) { RMAPI Vector4 operator/(const Vector4 &lhs, const Vector4 &rhs)
{
return Vector4Divide(lhs, rhs); return Vector4Divide(lhs, rhs);
} }
RMAPI const Vector4 &operator/=(Vector4 &lhs, const Vector4 &rhs) { RMAPI const Vector4 &operator/=(Vector4 &lhs, const Vector4 &rhs)
{
lhs = Vector4Divide(lhs, rhs); lhs = Vector4Divide(lhs, rhs);
return lhs; return lhs;
} }
RMAPI bool operator==(const Vector4 &lhs, const Vector4 &rhs) { RMAPI bool operator==(const Vector4 &lhs, const Vector4 &rhs)
{
return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) && return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) &&
FloatEquals(lhs.z, rhs.z) && FloatEquals(lhs.w, rhs.w); FloatEquals(lhs.z, rhs.z) && FloatEquals(lhs.w, rhs.w);
} }
RMAPI bool operator!=(const Vector4 &lhs, const Vector4 &rhs) { RMAPI bool operator!=(const Vector4 &lhs, const Vector4 &rhs)
{
return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) || return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) ||
!FloatEquals(lhs.z, rhs.z) || !FloatEquals(lhs.w, rhs.w); !FloatEquals(lhs.z, rhs.z) || !FloatEquals(lhs.w, rhs.w);
} }
@ -270,80 +316,89 @@ RMAPI Quaternion QuaternionZeros = {0, 0, 0, 0};
RMAPI Quaternion QuaternionOnes = { 1, 1, 1, 1 }; RMAPI Quaternion QuaternionOnes = { 1, 1, 1, 1 };
RMAPI Quaternion QuaternionUnitX = { 0, 0, 0, 1 }; RMAPI Quaternion QuaternionUnitX = { 0, 0, 0, 1 };
RMAPI Quaternion operator+(const Quaternion &lhs, const float &rhs) { RMAPI Quaternion operator+(const Quaternion &lhs, const float &rhs)
{
return QuaternionAddValue(lhs, rhs); return QuaternionAddValue(lhs, rhs);
} }
RMAPI const Quaternion &operator+=(Quaternion &lhs, RMAPI const Quaternion &operator+=(Quaternion &lhs, const float &rhs)
const float &rhs) { {
lhs = QuaternionAddValue(lhs, rhs); lhs = QuaternionAddValue(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Quaternion operator-(const Quaternion &lhs, const float &rhs) { RMAPI Quaternion operator-(const Quaternion &lhs, const float &rhs)
{
return QuaternionSubtractValue(lhs, rhs); return QuaternionSubtractValue(lhs, rhs);
} }
RMAPI const Quaternion &operator-=(Quaternion &lhs, RMAPI const Quaternion &operator-=(Quaternion &lhs, const float &rhs)
const float &rhs) { {
lhs = QuaternionSubtractValue(lhs, rhs); lhs = QuaternionSubtractValue(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Quaternion operator*(const Quaternion &lhs, RMAPI Quaternion operator*(const Quaternion &lhs, const Matrix &rhs)
const Matrix &rhs) { {
return QuaternionTransform(lhs, rhs); return QuaternionTransform(lhs, rhs);
} }
RMAPI const Quaternion &operator*=(Quaternion &lhs, RMAPI const Quaternion &operator*=(Quaternion &lhs, const Matrix &rhs)
const Matrix &rhs) { {
lhs = QuaternionTransform(lhs, rhs); lhs = QuaternionTransform(lhs, rhs);
return lhs; return lhs;
} }
// Matrix operators // Matrix operators
RMAPI Matrix MatrixZeros = {}; RMAPI Matrix MatrixZeros = { 0 };
RMAPI Matrix MatrixUnit = { 1, 0, 0, 0, RMAPI Matrix MatrixUnit = { 1, 0, 0, 0,
0, 1, 0, 0, 0, 1, 0, 0,
0, 0, 1, 0, 0, 0, 1, 0,
0, 0, 0, 1 }; 0, 0, 0, 1 };
RMAPI Matrix operator+(const Matrix &lhs, const Matrix &rhs) { RMAPI Matrix operator+(const Matrix &lhs, const Matrix &rhs)
{
return MatrixAdd(lhs, rhs); return MatrixAdd(lhs, rhs);
} }
RMAPI const Matrix &operator+=(Matrix &lhs, const Matrix &rhs) { RMAPI const Matrix &operator+=(Matrix &lhs, const Matrix &rhs)
{
lhs = MatrixAdd(lhs, rhs); lhs = MatrixAdd(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Matrix operator-(const Matrix &lhs, const Matrix &rhs) { RMAPI Matrix operator-(const Matrix &lhs, const Matrix &rhs)
{
return MatrixSubtract(lhs, rhs); return MatrixSubtract(lhs, rhs);
} }
RMAPI const Matrix &operator-=(Matrix &lhs, const Matrix &rhs) { RMAPI const Matrix &operator-=(Matrix &lhs, const Matrix &rhs)
{
lhs = MatrixSubtract(lhs, rhs); lhs = MatrixSubtract(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Matrix operator*(const Matrix &lhs, const Matrix &rhs) { RMAPI Matrix operator*(const Matrix &lhs, const Matrix &rhs)
{
return MatrixMultiply(lhs, rhs); return MatrixMultiply(lhs, rhs);
} }
RMAPI const Matrix &operator*=(Matrix &lhs, const Matrix &rhs) { RMAPI const Matrix &operator*=(Matrix &lhs, const Matrix &rhs)
{
lhs = MatrixMultiply(lhs, rhs); lhs = MatrixMultiply(lhs, rhs);
return lhs; return lhs;
} }
RMAPI Matrix operator*(const Matrix &lhs, const float value) { RMAPI Matrix operator*(const Matrix &lhs, const float value)
{
return MatrixMultiplyValue(lhs, value); return MatrixMultiplyValue(lhs, value);
} }
RMAPI const Matrix &operator*=(Matrix &lhs, const float value) { RMAPI const Matrix &operator*=(Matrix &lhs, const float value)
{
lhs = MatrixMultiplyValue(lhs, value); lhs = MatrixMultiplyValue(lhs, value);
return lhs; return lhs;
} }
//------------------------------------------------------------------------------- #endif
#endif // C++ operators
#endif // RAYMATH_ADDON_H #endif // RAYMATH_CPP_ADDON_H