refactored camera

include/omath/engines/Source/Camera.hpp

@@ -0,0 +1,22 @@
+//
+// Created by Orange on 12/4/2024.
+//
+#pragma once
+#include "Constants.h"
+#include "omath/projection/Camera.hpp"
+
+namespace omath::source
+{
+    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    {
+    public:
+        Camera(const Vector3& position, const ViewAngles& viewAngles,
+               const projection::ViewPort& viewPort, const Angle<float, 0, 180, AngleFlags::Clamped>& fov, float near, const float far) :
+            projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
+        {
+        }
+        void LookAt(const Vector3& target) override;
+        [[nodiscard]] Mat4x4 GetViewMatrix() const override;
+        [[nodiscard]] Mat4x4 GetProjectionMatrix() const override;
+    };
+}

include/omath/engines/Source/Constants.h

@@ -0,0 +1,24 @@
+//
+// Created by Orange on 12/4/2024.
+//
+#pragma once
+
+#include <omath/Vector3.hpp>
+#include <omath/Mat.hpp>
+#include <omath/Angle.hpp>
+#include <omath/ViewAngles.hpp>
+namespace omath::source
+{
+    constexpr Vector3 kAbsUp = {0, 0, 1};
+    constexpr Vector3 kAbsRight = {0, -1, 0};
+    constexpr Vector3 kAbsForward = {1, 0, 0};
+
+    using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+
+    using PitchAngle = Angle<float, -89.f, 89.f, AngleFlags::Clamped>;
+    using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+    using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+
+    using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
+} // namespace omath::source

include/omath/engines/Source/Formulas.hpp

@@ -0,0 +1,98 @@
+//
+// Created by Orange on 12/4/2024.
+//
+#pragma once
+#include "Constants.h"
+
+
+namespace omath::source
+{
+    [[nodiscard]]
+    inline Vector3 ForwardVector(const ViewAngles& angles)
+    {
+        const auto cosPitch = angles.pitch.Cos();
+        const auto sinPitch = angles.pitch.Sin();
+
+        const auto cosYaw = angles.yaw.Cos();
+        const auto sinYaw = angles.yaw.Sin();
+
+
+        return {cosPitch * cosYaw, cosPitch * sinYaw, -sinPitch};
+    }
+
+    [[nodiscard]]
+    inline Vector3 RightVector(const ViewAngles& angles)
+    {
+        const auto cosPitch = angles.pitch.Cos();
+        const auto sinPitch = angles.pitch.Sin();
+
+        const auto cosYaw = angles.yaw.Cos();
+        const auto sinYaw = angles.yaw.Sin();
+
+        const auto cosRoll = angles.roll.Cos();
+        const auto sinRoll = angles.roll.Sin();
+
+
+        return
+        {
+            -1 * sinRoll * sinPitch * cosYaw + -1 * cosRoll * -sinYaw,
+            -1 * sinRoll * sinPitch * sinYaw + -1 * cosRoll * cosYaw,
+            -1 * sinRoll * cosPitch
+        };
+    }
+
+    [[nodiscard]]
+    inline Vector3 UpVector(const ViewAngles& angles)
+    {
+        const auto cosPitch = angles.pitch.Cos();
+        const auto sinPitch = angles.pitch.Sin();
+
+        const auto cosYaw = angles.yaw.Cos();
+        const auto sinYaw = angles.yaw.Sin();
+
+        const auto cosRoll = angles.roll.Cos();
+        const auto sinRoll = angles.roll.Sin();
+
+
+        return
+        {
+            cosRoll * sinPitch * cosYaw + - sinRoll * -sinYaw,
+            cosRoll * sinPitch * sinYaw + - sinRoll * cosYaw,
+            cosRoll * cosPitch,
+        };
+    }
+
+    [[nodiscard]]
+    constexpr Mat4x4 ViewMatrixFromVecs(const Vector3& forward, const Vector3& right, const Vector3& up,
+                                        const Vector3& camera_pos)
+    {
+        return Mat4x4{
+                           {right.x, right.y, right.z, 0},
+                           {up.x, up.y, up.z, 0},
+                           {forward.x, forward.y, forward.z, 0},
+                           {0, 0, 0, 1},
+                   } *
+                   MatTranslation<float, MatStoreType::ROW_MAJOR>(-camera_pos);
+    }
+
+    [[nodiscard]] inline Mat4x4 ViewMatrix(const ViewAngles& angles, const Vector3& cam_origin)
+    {
+        return ViewMatrixFromVecs(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
+    }
+
+
+    [[nodiscard]]
+    inline Mat4x4 PerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near, const float far)
+    {
+        constexpr auto kMultiplyFactor = 0.75f;
+
+        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f) * kMultiplyFactor;
+
+        return {
+                        {-1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
+                        {0, -1.f / (fovHalfTan), 0, 0},
+                        {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                        {0, 0, 1, 0},
+                };
+    }
+} // namespace omath::source