Updated raylib-cpp header files

includes/raylib-cpp/Vector4.hpp

@@ -8,16 +8,16 @@
 
 #include <string>
 
+#include "./raylib-cpp-utils.hpp"
 #include "./raylib.hpp"
 #include "./raymath.hpp"
-#include "./raylib-cpp-utils.hpp"
 
 namespace raylib {
 /**
  * Vector4 type
  */
 class Vector4 : public ::Vector4 {
- public:
+public:
     Vector4(const ::Vector4& vec) : ::Vector4{vec.x, vec.y, vec.z, vec.w} {}
 
     Vector4(float x, float y, float z, float w) : ::Vector4{x, y, z, w} {}
@@ -27,9 +27,7 @@ class Vector4 : public ::Vector4 {
     Vector4() : ::Vector4{0, 0, 0, 0} {}
     Vector4(::Rectangle rectangle) : ::Vector4{rectangle.x, rectangle.y, rectangle.width, rectangle.height} {}
 
-    Vector4(::Color color) {
-        set(ColorNormalize(color));
-    }
+    Vector4(::Color color) { set(ColorNormalize(color)); }
 
     GETTERSETTER(float, X, x)
     GETTERSETTER(float, Y, y)
@@ -42,126 +40,80 @@ class Vector4 : public ::Vector4 {
     }
 
     bool operator==(const ::Vector4& other) const {
-        return x == other.x
-            && y == other.y
-            && z == other.z
-            && w == other.w;
+        return x == other.x && y == other.y && z == other.z && w == other.w;
     }
 
-    bool operator!=(const ::Vector4& other) const {
-        return !(*this == other);
-    }
+    bool operator!=(const ::Vector4& other) const { return !(*this == other); }
 
-    inline ::Rectangle ToRectangle() const {
-        return {x, y, z, w};
-    }
+    [[nodiscard]] ::Rectangle ToRectangle() const { return {x, y, z, w}; }
 
-    operator ::Rectangle() const {
-        return {x, y, z, w};
-    }
+    operator ::Rectangle() const { return {x, y, z, w}; }
 
-    inline std::string ToString() const {
-        return TextFormat("Vector4(%f, %f, %f, %f)", x, y, z, w);
-    }
+    [[nodiscard]] std::string ToString() const { return TextFormat("Vector4(%f, %f, %f, %f)", x, y, z, w); }
 
-    inline operator std::string() const {
-        return ToString();
-    }
+    operator std::string() const { return ToString(); }
 
 #ifndef RAYLIB_CPP_NO_MATH
-    inline Vector4 Multiply(const ::Vector4& vector4) const {
-        return QuaternionMultiply(*this, vector4);
-    }
+    [[nodiscard]] Vector4 Multiply(const ::Vector4& vector4) const { return QuaternionMultiply(*this, vector4); }
 
-    inline Vector4 operator*(const ::Vector4& vector4) const {
-        return QuaternionMultiply(*this, vector4);
-    }
+    Vector4 operator*(const ::Vector4& vector4) const { return QuaternionMultiply(*this, vector4); }
 
-    inline Vector4 Lerp(const ::Vector4& vector4, float amount) const {
-        return QuaternionLerp(*this, vector4, amount);
-    }
+    [[nodiscard]] Vector4 Lerp(const ::Vector4& vector4, float amount) const { return QuaternionLerp(*this, vector4, amount); }
 
-    inline Vector4 Nlerp(const ::Vector4& vector4, float amount) const {
-        return QuaternionNlerp(*this, vector4, amount);
-    }
+    [[nodiscard]] Vector4 Nlerp(const ::Vector4& vector4, float amount) const { return QuaternionNlerp(*this, vector4, amount); }
 
-    inline Vector4 Slerp(const ::Vector4& vector4, float amount) const {
-        return QuaternionSlerp(*this, vector4, amount);
-    }
+    [[nodiscard]] Vector4 Slerp(const ::Vector4& vector4, float amount) const { return QuaternionSlerp(*this, vector4, amount); }
 
-    inline Matrix ToMatrix() const {
-        return QuaternionToMatrix(*this);
-    }
+    [[nodiscard]] Matrix ToMatrix() const { return QuaternionToMatrix(*this); }
 
-    inline float Length() const {
-        return QuaternionLength(*this);
-    }
+    [[nodiscard]] float Length() const { return QuaternionLength(*this); }
 
-    inline Vector4 Normalize() const {
-        return QuaternionNormalize(*this);
-    }
+    [[nodiscard]] Vector4 Normalize() const { return QuaternionNormalize(*this); }
 
-    inline Vector4 Invert() const {
-        return QuaternionInvert(*this);
-    }
+    [[nodiscard]] Vector4 Invert() const { return QuaternionInvert(*this); }
 
-    inline void ToAxisAngle(::Vector3 *outAxis, float *outAngle) const {
-        QuaternionToAxisAngle(*this, outAxis, outAngle);
-    }
+    void ToAxisAngle(::Vector3* outAxis, float* outAngle) const { QuaternionToAxisAngle(*this, outAxis, outAngle); }
 
     /**
      * Get the rotation angle and axis for a given quaternion
      */
-    std::pair<Vector3, float> ToAxisAngle() const {
+    [[nodiscard]] std::pair<Vector3, float> ToAxisAngle() const {
         Vector3 outAxis;
         float outAngle;
         QuaternionToAxisAngle(*this, &outAxis, &outAngle);
 
-        return std::pair<Vector3, float>(outAxis, outAngle);
+        return { outAxis, outAngle };
     }
 
-    inline Vector4 Transform(const ::Matrix& matrix) const {
-        return ::QuaternionTransform(*this, matrix);
+    [[nodiscard]] Vector4 Transform(const ::Matrix& matrix) const { return ::QuaternionTransform(*this, matrix); }
+
+    static Vector4 Identity() { return ::QuaternionIdentity(); }
+
+    static Vector4 FromVector3ToVector3(const ::Vector3& from, const ::Vector3& to) {
+        return ::QuaternionFromVector3ToVector3(from, to);
     }
 
-    static inline Vector4 Identity() {
-        return ::QuaternionIdentity();
-    }
+    static Vector4 FromMatrix(const ::Matrix& matrix) { return ::QuaternionFromMatrix(matrix); }
 
-    static inline Vector4 FromVector3ToVector3(const ::Vector3& from , const ::Vector3& to) {
-        return ::QuaternionFromVector3ToVector3(from , to);
-    }
-
-    static inline Vector4 FromMatrix(const ::Matrix& matrix) {
-        return ::QuaternionFromMatrix(matrix);
-    }
-
-    static inline Vector4 FromAxisAngle(const ::Vector3& axis, const float angle) {
+    static Vector4 FromAxisAngle(const ::Vector3& axis, const float angle) {
         return ::QuaternionFromAxisAngle(axis, angle);
     }
 
-    static inline Vector4 FromEuler(const float pitch, const float yaw, const float roll) {
+    static Vector4 FromEuler(const float pitch, const float yaw, const float roll) {
         return ::QuaternionFromEuler(pitch, yaw, roll);
     }
 
-    static inline Vector4 FromEuler(const ::Vector3& vector3) {
+    static Vector4 FromEuler(const ::Vector3& vector3) {
         return ::QuaternionFromEuler(vector3.x, vector3.y, vector3.z);
     }
 
-    inline Vector3 ToEuler() const {
-        return ::QuaternionToEuler(*this);
-    }
+    [[nodiscard]] Vector3 ToEuler() const { return ::QuaternionToEuler(*this); }
 #endif
 
-    inline Color ColorFromNormalized() const {
-        return ::ColorFromNormalized(*this);
-    }
+    [[nodiscard]] Color ColorFromNormalized() const { return ::ColorFromNormalized(*this); }
 
-    operator Color() const {
-        return ColorFromNormalized();
-    }
-
- protected:
+    operator Color() const { return ColorFromNormalized(); }
+protected:
     void set(const ::Vector4& vec4) {
         x = vec4.x;
         y = vec4.y;
@@ -171,10 +123,11 @@ class Vector4 : public ::Vector4 {
 };
 
 // Alias the Vector4 as Quaternion.
-typedef Vector4 Quaternion;
-}  // namespace raylib
+using Quaternion = Vector4;
+
+} // namespace raylib
 
 using RVector4 = raylib::Vector4;
 using RQuaternion = raylib::Quaternion;
 
-#endif  // RAYLIB_CPP_INCLUDE_VECTOR4_HPP_
+#endif // RAYLIB_CPP_INCLUDE_VECTOR4_HPP_