added iw engine files

include/omath/engines/iw_engine/Camera.hpp

@@ -0,0 +1,21 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include "Constants.hpp"
+#include "omath/projection/Camera.hpp"
+
+namespace omath::iw_engine
+{
+    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    {
+    public:
+        Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+               const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
+        void LookAt(const Vector3<float>& target) override;
+    protected:
+        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
+        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
+    };
+}

include/omath/engines/iw_engine/Constants.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include <omath/Vector3.hpp>
+#include <omath/Mat.hpp>
+#include <omath/Angle.hpp>
+#include <omath/ViewAngles.hpp>
+
+namespace omath::iw_engine
+{
+    constexpr Vector3<float> kAbsUp = {0, 0, 1};
+    constexpr Vector3<float> kAbsRight = {0, -1, 0};
+    constexpr Vector3<float> kAbsForward = {1, 0, 0};
+
+    using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat1x3 = Mat<1, 3, 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>;
+}

include/omath/engines/iw_engine/Formulas.hpp

@@ -0,0 +1,54 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include "Constants.hpp"
+
+namespace omath::iw_engine
+{
+    [[nodiscard]]
+    inline Vector3<float> ForwardVector(const ViewAngles& angles)
+    {
+        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
+
+        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
+    }
+
+    [[nodiscard]]
+    inline Vector3<float> RightVector(const ViewAngles& angles)
+    {
+        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
+
+        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
+    }
+
+    [[nodiscard]]
+    inline Vector3<float> UpVector(const ViewAngles& angles)
+    {
+        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
+
+        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
+    }
+
+    [[nodiscard]] inline Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    {
+        return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
+    }
+
+
+    [[nodiscard]]
+    inline Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
+                                                  const float far)
+    {
+        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
+
+        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