Separate Quaternion from Vector4 & Implement many Vector4 methods

clib.json

@@ -40,6 +40,7 @@
     "include/ModelAnimation.hpp",
     "include/Mouse.hpp",
     "include/Music.hpp",
+    "include/Quaternion.hpp",
     "include/physac.hpp",
     "include/Ray.hpp",
     "include/RayCollision.hpp",

include/CMakeLists.txt

@@ -23,6 +23,7 @@ set(RAYLIB_CPP_HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/ModelAnimation.hpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Mouse.hpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Music.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/Quaternion.hpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Ray.hpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RayCollision.hpp
     ${CMAKE_CURRENT_SOURCE_DIR}/RaylibException.hpp

include/Quaternion.hpp

@@ -0,0 +1,296 @@
+#ifndef RAYLIB_CPP_INCLUDE_QUATERNION_HPP_
+#define RAYLIB_CPP_INCLUDE_QUATERNION_HPP_
+
+#ifndef RAYLIB_CPP_NO_MATH
+#include <cmath>
+#include <utility>
+#endif
+
+#include <string>
+
+#include "./raylib-cpp-utils.hpp"
+#include "./raylib.hpp"
+#include "./raymath.hpp"
+
+namespace raylib {
+class Vector4 : public ::Vector4 {};
+
+/**
+ * Quaternion type
+ */
+class Quaternion : public ::Quaternion {
+public:
+    constexpr Quaternion(const ::Quaternion& quat) : ::Quaternion{quat.x, quat.y, quat.z, quat.w} {}
+    explicit constexpr Quaternion(const raylib::Vector4 vec4) : ::Quaternion{vec4.x, vec4.y, vec4.z, vec4.w} {}
+
+    explicit constexpr Quaternion(const float x = 0, const float y = 0, const float z = 0, const float w = 1) : ::Quaternion{x, y, z, w} {}
+
+    GETTERSETTER(float, X, x)
+    GETTERSETTER(float, Y, y)
+    GETTERSETTER(float, Z, z)
+    GETTERSETTER(float, W, w)
+
+    Quaternion& operator=(const ::Quaternion& quaternion) {
+        set(quaternion);
+        return *this;
+    }
+
+    /*
+     * An exact value by value equality comparison.
+     * Due to floating point inaccuracies consider using Equals instead.
+     */
+    constexpr bool operator==(const ::Quaternion& other) const {
+        return x == other.x && y == other.y && z == other.z && w == other.w;
+    }
+
+    /*
+     * An exact value by value inequality comparison.
+     * Due to floating point inaccuracies consider using Equals instead.
+     */
+    constexpr bool operator!=(const ::Quaternion& other) const { return !(*this == other); }
+
+    RLCPP_NODISCARD std::string ToString() const { return ::TextFormat("Quaternion(%f, %f, %f, %f)", x, y, z, w); }
+
+    operator std::string() const { return ToString(); }
+
+#ifndef RAYLIB_CPP_NO_MATH
+    /**
+     * Add two quaternions
+     */
+    RLCPP_NODISCARD Quaternion Add(const ::Quaternion& quaternion) const { return ::QuaternionAdd(*this, quaternion); }
+
+    /**
+     * Add two quaternions
+     */
+    Quaternion operator+(const ::Quaternion& quaternion) const { return ::QuaternionAdd(*this, quaternion); }
+
+    Quaternion& operator+=(const ::Quaternion& quaternion) {
+        set(::QuaternionAdd(*this, quaternion));
+
+        return *this;
+    }
+
+    /**
+     * Add quaternion and float value
+     */
+    RLCPP_NODISCARD Quaternion Add(const float value) const {
+        return ::QuaternionAddValue(*this, value);
+    }
+
+    /**
+     * Add quaternion and float value
+     */
+    Quaternion operator+(const float value) const {
+        return ::QuaternionAddValue(*this, value);
+    }
+
+    /**
+     * Add quaternion and float value
+     */
+    Quaternion& operator+=(const float value) {
+        set(::QuaternionAddValue(*this, value));
+
+        return *this;
+    }
+
+    /**
+     * Add quaternion and float value
+     */
+    friend Quaternion operator+(const float lhs, const Quaternion& rhs) { return rhs + lhs; }
+
+    /**
+     * Subtract two quaternions.
+     */
+    RLCPP_NODISCARD Quaternion Subtract(const ::Quaternion& quaternion) const { return ::QuaternionSubtract(*this, quaternion); }
+
+    /**
+     * Subtract two quaternions.
+     */
+    Quaternion operator-(const ::Quaternion& quaternion) const { return ::QuaternionSubtract(*this, quaternion); }
+
+    Quaternion& operator-=(const ::Quaternion& quaternion) {
+        set(::QuaternionSubtract(*this, quaternion));
+
+        return *this;
+    }
+
+    /**
+     * Subtract quaternion by float value
+     */
+    RLCPP_NODISCARD Quaternion Subtract(const float value) const {
+        return ::QuaternionSubtractValue(*this, value);
+    }
+
+    /**
+     * Get identity quaternion
+     */
+    static RLCPP_NODISCARD Quaternion Identity() {
+        return ::QuaternionIdentity();
+    }
+
+    RLCPP_NODISCARD float Length() const { return ::QuaternionLength(*this); }
+
+    RLCPP_NODISCARD Quaternion Normalize() const { return ::QuaternionNormalize(*this); }
+
+    RLCPP_NODISCARD Quaternion Invert() const { return ::QuaternionInvert(*this); }
+
+    /**
+     * Multiply quaternion by quaternion
+     */
+    RLCPP_NODISCARD Quaternion Multiply(const ::Quaternion& other) const { return ::QuaternionMultiply(*this, other); }
+
+    /**
+     * Multiply quaternion by quaternion
+     */
+    Quaternion operator*(const ::Quaternion& other) const { return ::QuaternionMultiply(*this, other); }
+
+    /**
+     * Multiply quaternion by quaternion
+     */
+    Quaternion& operator*=(const ::Quaternion& other) {
+        set(::QuaternionMultiply(*this, other));
+
+        return *this;
+    }
+
+    /**
+     * Scale quaternion components by value (multiply)
+     */
+    RLCPP_NODISCARD Quaternion Scale(const float scale) const { return ::QuaternionScale(*this, scale); }
+
+    /**
+     * Divide quaternion by quaternion
+     */
+    RLCPP_NODISCARD Quaternion Divide(const ::Quaternion& quaternion) const { return ::QuaternionDivide(*this, quaternion); }
+
+    /**
+     * Divide quaternion by quaternion
+     */
+    Quaternion operator/(const ::Quaternion& quaternion) const { return ::QuaternionDivide(*this, quaternion); }
+
+    /**
+     * Divide quaternion by quaternion
+     */
+    Quaternion& operator/=(const ::Quaternion& quaternion) {
+        set(::QuaternionDivide(*this, quaternion));
+
+        return *this;
+    }
+
+    /**
+     * Divide quaternion components by value
+     */
+    RLCPP_NODISCARD constexpr Quaternion Divide(const float div) const { return ::Quaternion{x / div, y / div, z / div, w / div}; }
+
+    RLCPP_NODISCARD Quaternion Lerp(const ::Quaternion& v2, const float amount) const
+    {
+        return ::QuaternionLerp(*this, v2, amount);
+    }
+
+    /**
+     * Calculate normalized linear interpolation between two quaternions
+     */
+    RLCPP_NODISCARD Quaternion Nlerp(const ::Quaternion& v2, const float amount) const {
+        return ::QuaternionNlerp(*this, v2, amount);
+    }
+
+    /**
+     * Calculates spherical linear interpolation between two quaternions
+     */
+    RLCPP_NODISCARD Quaternion Slerp(const ::Quaternion& v2, const float amount) const {
+        return ::QuaternionSlerp(*this, v2, amount);
+    }
+
+    /**
+     * Calculate quaternion cubic spline interpolation using Cubic Hermite Spline
+     */
+    RLCPP_NODISCARD Quaternion CubicHermiteSpline(
+        const ::Quaternion& outTangent1,
+        const ::Quaternion& q2,
+        const ::Quaternion& inTangent2,
+        const float t
+    ) const {
+        return ::QuaternionCubicHermiteSpline(*this, outTangent1, q2, inTangent2, t);
+    }
+
+    /**
+     * Calculate quaternion based on the rotation from one vector to another
+     */
+    static RLCPP_NODISCARD Quaternion FromVector3ToVector3(const ::Vector3& from, const ::Vector3& to) {
+        return ::QuaternionFromVector3ToVector3(from, to);
+    }
+
+    /**
+     * Get a quaternion for a given rotation matrix
+     */
+    static RLCPP_NODISCARD Quaternion FromMatrix(const ::Matrix& mat) {
+        return ::QuaternionFromMatrix(mat);
+    }
+
+    /**
+     * Get a matrix for this quaternion
+     */
+    RLCPP_NODISCARD ::Matrix ToMatrix() const {
+        return ::QuaternionToMatrix(*this);
+    }
+
+    /**
+     * Get rotation quaternion for an angle and axis
+     * NOTE: Angle must be provided in radians
+     */
+    static RLCPP_NODISCARD Quaternion FromAxisAngle(const ::Vector3& axis, const float angle) {
+        return ::QuaternionFromAxisAngle(axis, angle);
+    }
+
+    /**
+     * Get the rotation angle and axis for this quaternion
+     */
+    void ToAxisAngle(::Vector3* outAxis, float* outAngle) const {
+        ::QuaternionToAxisAngle(*this, outAxis, outAngle);
+    }
+
+    /**
+     * Get the quaternion equivalent to Euler angles
+     * NOTE: Rotation order is ZYX
+     */
+    static RLCPP_NODISCARD Quaternion FromEuler(const float pitch, const float yaw, const float roll) {
+        return ::QuaternionFromEuler(pitch, yaw, roll);
+    }
+
+    /**
+     * Get the Euler angles equivalent to quaternion
+     * NOTE: Angles are returned in radians
+     */
+    RLCPP_NODISCARD ::Vector3 ToEuler() const {
+        return ::QuaternionToEuler(*this);
+    }
+
+    /**
+     * Transform quaternion given transformation matrix
+     */
+    RLCPP_NODISCARD Quaternion Transform(const ::Matrix& mat) const {
+        return ::QuaternionTransform(*this, mat);
+    }
+
+    /*
+     * Check whether two given quaternions are almost equal
+     */
+    RLCPP_NODISCARD bool Equals(const ::Quaternion& other) const {
+        return static_cast<bool>(::QuaternionEquals(*this, other));
+    }
+#endif
+protected:
+    void set(const ::Quaternion& quat) {
+        x = quat.x;
+        y = quat.y;
+        z = quat.z;
+        w = quat.w;
+    }
+};
+
+} // namespace raylib
+
+using RQuaternion = raylib::Quaternion;
+
+#endif // RAYLIB_CPP_INCLUDE_QUATERNION_HPP_
+