add rotation behavior logic (not working correctly for multiple axes)

dCommon/NiQuaternion.cpp

@@ -14,13 +14,14 @@ Vector3 NiQuaternion::GetEulerAngles() const {
 	angles.x = std::atan2(sinr_cosp, cosr_cosp);
 
 	// pitch (y-axis rotation)
-	const float sinp = 2 * (w * y - z * x);
+	const float t2 = 2 * (w * y - z * x);
+	angles.y = std::asin(std::clamp(t2, -1.0f, 1.0f)); // clamp to avoid NaN
 
-	if (std::abs(sinp) >= 1) {
-		angles.y = std::copysign(3.14 / 2, sinp); // use 90 degrees if out of range
-	} else {
-		angles.y = std::asin(sinp);
-	}
+	// if (std::abs(p) >= 1) {
+	// 	angles.y = std::copysign(3.14 / 2, p); // use 90 degrees if out of range
+	// } else {
+	// 	angles.y = std::asin(p);
+	// }
 
 	// yaw (z-axis rotation)
 	const float siny_cosp = 2 * (w * z + x * y);
@@ -30,6 +31,65 @@ Vector3 NiQuaternion::GetEulerAngles() const {
 	return angles;
 }
 
+NiQuaternion NiQuaternion::operator*(const float scalar) const noexcept {
+	return NiQuaternion(this->w * scalar, this->x * scalar, this->y * scalar, this->z * scalar);
+}
+
+NiQuaternion& NiQuaternion::operator*=(const NiQuaternion& q) {
+	auto& [ow, ox, oy, oz] = q;
+	auto [cw, cx, cy, cz] = *this; // Current rotation copied because otherwise it screws up the math
+	this->w = cw * ow - cx * ox - cy * oy - cz * oz;
+	this->x = cw * ox + cx * ow + cy * oz - cz * oy;
+	this->y = cw * oy + cy * ow + cz * ox - cx * oz;
+	this->z = cw * oz + cz * ow + cx * oy - cy * ox;
+	return *this;
+}
+
+NiQuaternion NiQuaternion::operator* (const NiQuaternion& q) const {
+	auto& [ow, ox, oy, oz] = q;
+	return NiQuaternion
+	(
+		/* w */w * ow - x * ox - y * oy - z * oz,
+		/* x */w * ox + x * ow + y * oz - z * oy,
+		/* y */w * oy + y * ow + z * ox - x * oz,
+		/* z */w * oz + z * ow + x * oy - y * ox
+	);
+}
+
+NiQuaternion NiQuaternion::operator/(const float& q) const noexcept {
+	return NiQuaternion(this->w / q, this->x / q, this->y / q, this->z / q);
+}
+
+void NiQuaternion::Normalize() {
+	float length = Dot(*this);
+	float invLength = 1.0f / std::sqrt(length);
+	*this = *this * invLength;
+}
+
+float NiQuaternion::Dot(const NiQuaternion& q) const noexcept {
+	return (this->w * q.w) + (this->x * q.x) + (this->y * q.y) + (this->z * q.z);
+}
+
+void NiQuaternion::Inverse() noexcept {
+	NiQuaternion copy = *this;
+	copy.Conjugate();
+
+	const float inv = 1.0f / Dot(*this);
+	*this = copy / inv;
+}
+
+void NiQuaternion::Conjugate() noexcept {
+	x = -x;
+	y = -y;
+	z = -z;
+}
+
+NiQuaternion NiQuaternion::Diff(const NiQuaternion& q) const noexcept {
+	NiQuaternion inv = *this;
+	inv.Inverse();
+	return inv * q;
+}
+
 // MARK: Helper Functions
 
 //! Look from a specific point in space to another point in space (Y-locked)

dCommon/NiQuaternion.h

@@ -110,6 +110,18 @@ public:
 
 	[[nodiscard]] Vector3 GetEulerAngles() const;
 
+	NiQuaternion operator*(const float scalar) const noexcept;
+
+	NiQuaternion operator*(const NiQuaternion& q) const noexcept;
+	NiQuaternion operator/(const float& q) const noexcept;
+	NiQuaternion& operator*=(const NiQuaternion& q) noexcept;
+	float Dot(const NiQuaternion& q) const noexcept;
+	void Inverse() noexcept;
+	void Conjugate() noexcept;
+	NiQuaternion Diff(const NiQuaternion& q) const noexcept;
+
+	void Normalize();
+
 	// MARK: Operators
 
 	//! Operator to check for equality

dCommon/dEnums/dCommonVars.h

@@ -59,7 +59,7 @@ constexpr LWOINSTANCEID LWOINSTANCEID_INVALID = -1; //!< Invalid LWOINSTANCEID
 constexpr LWOMAPID LWOMAPID_INVALID = -1;       	//!< Invalid LWOMAPID
 constexpr uint64_t LWOZONEID_INVALID = 0;       	//!< Invalid LWOZONEID
 
-constexpr float PI = 3.14159f;
+constexpr float PI = 3.14159265358979323846264338327950288f;
 
 //============ STRUCTS ==============
 

dCommon/dMath.h

@@ -0,0 +1,23 @@
+// Darkflame Universe
+// Copyright 2025
+
+#ifndef DMATH_H
+#define DMATH_H
+
+#include <cmath>
+
+namespace Math {
+	constexpr float	PI = 3.14159265358979323846264338327950288f;
+	constexpr float RATIO_DEG_TO_RAD = PI / 180.0f;
+	constexpr float RATIO_RAD_TO_DEG = 180.0f / PI;
+
+	inline float DegToRad(float degrees) {
+		return degrees * RATIO_DEG_TO_RAD;
+	}
+
+	inline float RadToDeg(float radians) {
+		return radians * RATIO_RAD_TO_DEG;
+	}
+};
+
+#endif //!DMATH_H