raymath: Add C++ constexpr support and Matrix scalar multiplication

- Make RMAPI functions constexpr in C++ mode
- Add constexpr to all C++ math operators
- Add MatrixMultiplyValue() and scalar operators
- Add MatrixZeros and MatrixUnit constants

src/raymath.h

@@ -24,7 +24,7 @@
 *           or source files without problems. But only ONE file should hold the implementation
 *
 *       #define RAYMATH_STATIC_INLINE
-*           Define static inline functions code, so #include header suffices for use
+*           Define static inline constexpr functions code, so #include header suffices for use
 *           This may use up lots of memory
 *
 *       #define RAYMATH_DISABLE_CPP_OPERATORS
@@ -75,14 +75,22 @@
         #define RMAPI extern inline // Provide external definition
     #endif
 #elif defined(RAYMATH_STATIC_INLINE)
+#if defined(__cplusplus)
+    #define RMAPI static inline constexpr
+#else
     #define RMAPI static inline // Functions may be inlined, no external out-of-line definition
+#endif
 #else
     #if defined(__TINYC__)
         #define RMAPI static inline // plain inline not supported by tinycc (See issue #435)
+    #else
+        #if defined(__cplusplus)
+            #define RMAPI static inline constexpr
         #else
             #define RMAPI inline        // Functions may be inlined or external definition used
         #endif
     #endif
+#endif
 
 //----------------------------------------------------------------------------------
 // Defines and Macros
@@ -1765,6 +1773,15 @@ RMAPI Matrix MatrixMultiply(Matrix left, Matrix right)
     return result;
 }
 
+RMAPI Matrix MatrixMultiplyValue(Matrix left, float value)
+{
+    Matrix result = { left.m0 * value, left.m4 * value, left.m8 * value,  left.m12 * value, 
+                      left.m1 * value, left.m5 * value, left.m9 * value,  left.m13 * value, 
+                      left.m2 * value, left.m6 * value, left.m10 * value, left.m14 * value, 
+                      left.m3 * value, left.m7 * value, left.m11 * value, left.m15 * value };
+    return result;
+}
+
 // Get translation matrix
 RMAPI Matrix MatrixTranslate(float x, float y, float z)
 {
@@ -2775,89 +2792,89 @@ static constexpr Vector2 Vector2Ones = { 1, 1 };
 static constexpr Vector2 Vector2UnitX = { 1, 0 };
 static constexpr Vector2 Vector2UnitY = { 0, 1 };
 
-inline Vector2 operator + (const Vector2& lhs, const Vector2& rhs)
+inline constexpr Vector2 operator + (const Vector2& lhs, const Vector2& rhs)
 {
     return Vector2Add(lhs, rhs);
 }
 
-inline const Vector2& operator += (Vector2& lhs, const Vector2& rhs)
+inline constexpr const Vector2& operator += (Vector2& lhs, const Vector2& rhs)
 {
     lhs = Vector2Add(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator - (const Vector2& lhs, const Vector2& rhs)
+inline constexpr Vector2 operator - (const Vector2& lhs, const Vector2& rhs)
 {
     return Vector2Subtract(lhs, rhs);
 }
 
-inline const Vector2& operator -= (Vector2& lhs, const Vector2& rhs)
+inline constexpr const Vector2& operator -= (Vector2& lhs, const Vector2& rhs)
 {
     lhs = Vector2Subtract(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator * (const Vector2& lhs, const float& rhs)
+inline constexpr Vector2 operator * (const Vector2& lhs, const float& rhs)
 {
     return Vector2Scale(lhs, rhs);
 }
 
-inline const Vector2& operator *= (Vector2& lhs, const float& rhs)
+inline constexpr const Vector2& operator *= (Vector2& lhs, const float& rhs)
 {
     lhs = Vector2Scale(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator * (const Vector2& lhs, const Vector2& rhs)
+inline constexpr Vector2 operator * (const Vector2& lhs, const Vector2& rhs)
 {
     return Vector2Multiply(lhs, rhs);
 }
 
-inline const Vector2& operator *= (Vector2& lhs, const Vector2& rhs)
+inline constexpr const Vector2& operator *= (Vector2& lhs, const Vector2& rhs)
 {
     lhs = Vector2Multiply(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator * (const Vector2& lhs, const Matrix& rhs)
+inline constexpr Vector2 operator * (const Vector2& lhs, const Matrix& rhs)
 {
     return Vector2Transform(lhs, rhs);
 }
 
-inline const Vector2& operator *= (Vector2& lhs, const Matrix& rhs)
+inline constexpr const Vector2& operator *= (Vector2& lhs, const Matrix& rhs)
 {
     lhs = Vector2Transform(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator / (const Vector2& lhs, const float& rhs)
+inline constexpr Vector2 operator / (const Vector2& lhs, const float& rhs)
 {
     return Vector2Scale(lhs, 1.0f/rhs);
 }
 
-inline const Vector2& operator /= (Vector2& lhs, const float& rhs)
+inline constexpr const Vector2& operator /= (Vector2& lhs, const float& rhs)
 {
     lhs = Vector2Scale(lhs, 1.0f/rhs);
     return lhs;
 }
 
-inline Vector2 operator / (const Vector2& lhs, const Vector2& rhs)
+inline constexpr Vector2 operator / (const Vector2& lhs, const Vector2& rhs)
 {
     return Vector2Divide(lhs, rhs);
 }
 
-inline const Vector2& operator /= (Vector2& lhs, const Vector2& rhs)
+inline constexpr const Vector2& operator /= (Vector2& lhs, const Vector2& rhs)
 {
     lhs = Vector2Divide(lhs, rhs);
     return lhs;
 }
 
-inline bool operator == (const Vector2& lhs, const Vector2& rhs)
+inline constexpr bool operator == (const Vector2& lhs, const Vector2& rhs)
 {
     return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y);
 }
 
-inline bool operator != (const Vector2& lhs, const Vector2& rhs)
+inline constexpr bool operator != (const Vector2& lhs, const Vector2& rhs)
 {
     return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y);
 }
@@ -2869,89 +2886,89 @@ static constexpr Vector3 Vector3UnitX = { 1, 0, 0 };
 static constexpr Vector3 Vector3UnitY = { 0, 1, 0 };
 static constexpr Vector3 Vector3UnitZ = { 0, 0, 1 };
 
-inline Vector3 operator + (const Vector3& lhs, const Vector3& rhs)
+inline constexpr Vector3 operator + (const Vector3& lhs, const Vector3& rhs)
 {
     return Vector3Add(lhs, rhs);
 }
 
-inline const Vector3& operator += (Vector3& lhs, const Vector3& rhs)
+inline constexpr const Vector3& operator += (Vector3& lhs, const Vector3& rhs)
 {
     lhs = Vector3Add(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator - (const Vector3& lhs, const Vector3& rhs)
+inline constexpr Vector3 operator - (const Vector3& lhs, const Vector3& rhs)
 {
     return Vector3Subtract(lhs, rhs);
 }
 
-inline const Vector3& operator -= (Vector3& lhs, const Vector3& rhs)
+inline constexpr const Vector3& operator -= (Vector3& lhs, const Vector3& rhs)
 {
     lhs = Vector3Subtract(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator * (const Vector3& lhs, const float& rhs)
+inline constexpr Vector3 operator * (const Vector3& lhs, const float& rhs)
 {
     return Vector3Scale(lhs, rhs);
 }
 
-inline const Vector3& operator *= (Vector3& lhs, const float& rhs)
+inline constexpr const Vector3& operator *= (Vector3& lhs, const float& rhs)
 {
     lhs = Vector3Scale(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator * (const Vector3& lhs, const Vector3& rhs)
+inline constexpr Vector3 operator * (const Vector3& lhs, const Vector3& rhs)
 {
     return Vector3Multiply(lhs, rhs);
 }
 
-inline const Vector3& operator *= (Vector3& lhs, const Vector3& rhs)
+inline constexpr const Vector3& operator *= (Vector3& lhs, const Vector3& rhs)
 {
     lhs = Vector3Multiply(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator * (const Vector3& lhs, const Matrix& rhs)
+inline constexpr Vector3 operator * (const Vector3& lhs, const Matrix& rhs)
 {
     return Vector3Transform(lhs, rhs);
 }
 
-inline const Vector3& operator *= (Vector3& lhs, const Matrix& rhs)
+inline constexpr const Vector3& operator *= (Vector3& lhs, const Matrix& rhs)
 {
     lhs = Vector3Transform(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator / (const Vector3& lhs, const float& rhs)
+inline constexpr Vector3 operator / (const Vector3& lhs, const float& rhs)
 {
     return Vector3Scale(lhs, 1.0f/rhs);
 }
 
-inline const Vector3& operator /= (Vector3& lhs, const float& rhs)
+inline constexpr const Vector3& operator /= (Vector3& lhs, const float& rhs)
 {
     lhs = Vector3Scale(lhs, 1.0f/rhs);
     return lhs;
 }
 
-inline Vector3 operator / (const Vector3& lhs, const Vector3& rhs)
+inline constexpr Vector3 operator / (const Vector3& lhs, const Vector3& rhs)
 {
     return Vector3Divide(lhs, rhs);
 }
 
-inline const Vector3& operator /= (Vector3& lhs, const Vector3& rhs)
+inline constexpr const Vector3& operator /= (Vector3& lhs, const Vector3& rhs)
 {
     lhs = Vector3Divide(lhs, rhs);
     return lhs;
 }
 
-inline bool operator == (const Vector3& lhs, const Vector3& rhs)
+inline constexpr bool operator == (const Vector3& lhs, const Vector3& rhs)
 {
     return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) && FloatEquals(lhs.z, rhs.z);
 }
 
-inline bool operator != (const Vector3& lhs, const Vector3& rhs)
+inline constexpr bool operator != (const Vector3& lhs, const Vector3& rhs)
 {
     return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) || !FloatEquals(lhs.z, rhs.z);
 }
@@ -2964,78 +2981,78 @@ static constexpr Vector4 Vector4UnitY = { 0, 1, 0, 0 };
 static constexpr Vector4 Vector4UnitZ = { 0, 0, 1, 0 };
 static constexpr Vector4 Vector4UnitW = { 0, 0, 0, 1 };
 
-inline Vector4 operator + (const Vector4& lhs, const Vector4& rhs)
+inline constexpr Vector4 operator + (const Vector4& lhs, const Vector4& rhs)
 {
     return Vector4Add(lhs, rhs);
 }
 
-inline const Vector4& operator += (Vector4& lhs, const Vector4& rhs)
+inline constexpr const Vector4& operator += (Vector4& lhs, const Vector4& rhs)
 {
     lhs = Vector4Add(lhs, rhs);
     return lhs;
 }
 
-inline Vector4 operator - (const Vector4& lhs, const Vector4& rhs)
+inline constexpr Vector4 operator - (const Vector4& lhs, const Vector4& rhs)
 {
     return Vector4Subtract(lhs, rhs);
 }
 
-inline const Vector4& operator -= (Vector4& lhs, const Vector4& rhs)
+inline constexpr const Vector4& operator -= (Vector4& lhs, const Vector4& rhs)
 {
     lhs = Vector4Subtract(lhs, rhs);
     return lhs;
 }
 
-inline Vector4 operator * (const Vector4& lhs, const float& rhs)
+inline constexpr Vector4 operator * (const Vector4& lhs, const float& rhs)
 {
     return Vector4Scale(lhs, rhs);
 }
 
-inline const Vector4& operator *= (Vector4& lhs, const float& rhs)
+inline constexpr const Vector4& operator *= (Vector4& lhs, const float& rhs)
 {
     lhs = Vector4Scale(lhs, rhs);
     return lhs;
 }
 
-inline Vector4 operator * (const Vector4& lhs, const Vector4& rhs)
+inline constexpr Vector4 operator * (const Vector4& lhs, const Vector4& rhs)
 {
     return Vector4Multiply(lhs, rhs);
 }
 
-inline const Vector4& operator *= (Vector4& lhs, const Vector4& rhs)
+inline constexpr const Vector4& operator *= (Vector4& lhs, const Vector4& rhs)
 {
     lhs = Vector4Multiply(lhs, rhs);
     return lhs;
 }
 
-inline Vector4 operator / (const Vector4& lhs, const float& rhs)
+inline constexpr Vector4 operator / (const Vector4& lhs, const float& rhs)
 {
     return Vector4Scale(lhs, 1.0f/rhs);
 }
 
-inline const Vector4& operator /= (Vector4& lhs, const float& rhs)
+inline constexpr const Vector4& operator /= (Vector4& lhs, const float& rhs)
 {
     lhs = Vector4Scale(lhs, 1.0f/rhs);
     return lhs;
 }
 
-inline Vector4 operator / (const Vector4& lhs, const Vector4& rhs)
+inline constexpr Vector4 operator / (const Vector4& lhs, const Vector4& rhs)
 {
     return Vector4Divide(lhs, rhs);
 }
 
-inline const Vector4& operator /= (Vector4& lhs, const Vector4& rhs)
+inline constexpr const Vector4& operator /= (Vector4& lhs, const Vector4& rhs)
 {
     lhs = Vector4Divide(lhs, rhs);
     return lhs;
 }
 
-inline bool operator == (const Vector4& lhs, const Vector4& rhs)
+inline constexpr bool operator == (const Vector4& lhs, const Vector4& rhs)
 {
     return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) && FloatEquals(lhs.z, rhs.z) && FloatEquals(lhs.w, rhs.w);
 }
 
-inline bool operator != (const Vector4& lhs, const Vector4& rhs)
+inline constexpr bool operator != (const Vector4& lhs, const Vector4& rhs)
 {
     return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) || !FloatEquals(lhs.z, rhs.z) || !FloatEquals(lhs.w, rhs.w);
 }
@@ -3045,72 +3062,89 @@ static constexpr Quaternion QuaternionZeros = { 0, 0, 0, 0 };
 static constexpr Quaternion QuaternionOnes = { 1, 1, 1, 1 };
 static constexpr Quaternion QuaternionUnitX = { 0, 0, 0, 1 };
 
-inline Quaternion operator + (const Quaternion& lhs, const float& rhs)
+inline constexpr Quaternion operator + (const Quaternion& lhs, const float& rhs)
 {
     return QuaternionAddValue(lhs, rhs);
 }
 
-inline const Quaternion& operator += (Quaternion& lhs, const float& rhs)
+inline constexpr const Quaternion& operator += (Quaternion& lhs, const float& rhs)
 {
     lhs = QuaternionAddValue(lhs, rhs);
     return lhs;
 }
 
-inline Quaternion operator - (const Quaternion& lhs, const float& rhs)
+inline constexpr Quaternion operator - (const Quaternion& lhs, const float& rhs)
 {
     return QuaternionSubtractValue(lhs, rhs);
 }
 
-inline const Quaternion& operator -= (Quaternion& lhs, const float& rhs)
+inline constexpr const Quaternion& operator -= (Quaternion& lhs, const float& rhs)
 {
     lhs = QuaternionSubtractValue(lhs, rhs);
     return lhs;
 }
 
-inline Quaternion operator * (const Quaternion& lhs, const Matrix& rhs)
+inline constexpr Quaternion operator * (const Quaternion& lhs, const Matrix& rhs)
 {
     return QuaternionTransform(lhs, rhs);
 }
 
-inline const Quaternion& operator *= (Quaternion& lhs, const Matrix& rhs)
+inline constexpr const Quaternion& operator *= (Quaternion& lhs, const Matrix& rhs)
 {
     lhs = QuaternionTransform(lhs, rhs);
     return lhs;
 }
 
 // Matrix operators
-inline Matrix operator + (const Matrix& lhs, const Matrix& rhs)
+static constexpr Matrix MatrixZeros = {};
+static constexpr Matrix MatrixUnit = { 1, 0, 0, 0, 
+                                        0, 1, 0, 0, 
+                                        0, 0, 1, 0,
+                                        0, 0, 0, 1 };
+inline constexpr Matrix operator + (const Matrix& lhs, const Matrix& rhs)
 {
     return MatrixAdd(lhs, rhs);
 }
 
-inline const Matrix& operator += (Matrix& lhs, const Matrix& rhs)
+inline constexpr const Matrix& operator += (Matrix& lhs, const Matrix& rhs)
 {
     lhs = MatrixAdd(lhs, rhs);
     return lhs;
 }
 
-inline Matrix operator - (const Matrix& lhs, const Matrix& rhs)
+inline constexpr Matrix operator - (const Matrix& lhs, const Matrix& rhs)
 {
     return MatrixSubtract(lhs, rhs);
 }
 
-inline const Matrix& operator -= (Matrix& lhs, const Matrix& rhs)
+inline constexpr const Matrix& operator -= (Matrix& lhs, const Matrix& rhs)
 {
     lhs = MatrixSubtract(lhs, rhs);
     return lhs;
 }
 
-inline Matrix operator * (const Matrix& lhs, const Matrix& rhs)
+inline constexpr Matrix operator * (const Matrix& lhs, const Matrix& rhs)
 {
     return MatrixMultiply(lhs, rhs);
 }
 
-inline const Matrix& operator *= (Matrix& lhs, const Matrix& rhs)
+inline constexpr const Matrix& operator *= (Matrix& lhs, const Matrix& rhs)
 {
     lhs = MatrixMultiply(lhs, rhs);
     return lhs;
 }
+
+inline constexpr Matrix operator * (const Matrix& lhs, const float value)
+{
+    return MatrixMultiplyValue(lhs, value);
+}
+
+inline constexpr const Matrix& operator *= (Matrix& lhs, const float value)
+{
+    lhs = MatrixMultiplyValue(lhs, value);
+    return lhs;
+}
+
 //-------------------------------------------------------------------------------
 #endif // C++ operators