Merge pull request #24 from orange-cpp/u/orange-cpp/improved-triangle-class

U/orange cpp/improved triangle class

.idea/vcs.xml

@@ -2,7 +2,6 @@
 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/extlibs/glm" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/extlibs/googletest" vcs="Git" />
   </component>
 </project>

CMakeLists.txt

@@ -1,8 +1,8 @@
 cmake_minimum_required(VERSION 3.26)
 
-project(omath VERSION 1.0.0)
-
+project(omath VERSION 1.0.1)
 
+include(CMakePackageConfigHelpers)
 
 set(CMAKE_CXX_STANDARD 26)
 
@@ -16,13 +16,18 @@ option(OMATH_BUILD_AS_SHARED_LIBRARY "Build Omath as .so or .dll" OFF)
 if (OMATH_BUILD_AS_SHARED_LIBRARY)
     add_library(omath SHARED source/Vector3.cpp)
 else()
-    add_library(omath STATIC source/Vector3.cpp)
+    add_library(omath STATIC source/Vector3.cpp
+            include/omath/engines/OpenGL/Constants.hpp
+            include/omath/engines/OpenGL/Formulas.hpp
+            include/omath/engines/OpenGL/Camera.hpp)
 endif()
 
+target_compile_definitions(omath PUBLIC OMATH_EXPORT)
+
 add_subdirectory(source)
-add_subdirectory(extlibs)
 
 if(OMATH_BUILD_TESTS)
+    add_subdirectory(extlibs)
     add_subdirectory(tests)
 endif()
 
@@ -79,4 +84,4 @@ install(FILES
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfigVersion.cmake"
         DESTINATION lib/cmake/omath
-)
+)

README.md

@@ -11,7 +11,7 @@
 
 Oranges's Math Library (omath) is a comprehensive, open-source library aimed at providing efficient, reliable, and versatile mathematical functions and algorithms. Developed primarily in C++, this library is designed to cater to a wide range of mathematical operations essential in scientific computing, engineering, and academic research.
 
-## Features
+## 👁‍🗨 Features
 - **Efficiency**: Optimized for performance, ensuring quick computations.
 - **Versatility**: Includes a wide array of mathematical functions and algorithms.
 - **Ease of Use**: Simplified interface for convenient integration into various projects.
@@ -20,12 +20,26 @@ Oranges's Math Library (omath) is a comprehensive, open-source library aimed at
 - **Collision Detection**: Production ready code to handle collision detection by using simple interfaces.
 - **No Additional Dependencies**: No additional dependencies need to use OMath except unit test execution
 
-## Getting Started
+## ⏬ Getting Started
 ### Prerequisites
 - C++ Compiler
 - CMake (for building the project)
 
 ### Installation
+### vcpkg
+**Note**: Support vcpkg for package management
+1. Install vcpkg (https://github.com/microsoft/vcpkg)
+2. Run the following command to install the orange-math package:
+```
+vcpkg install orange-math
+```
+CMakeLists.txt
+```cmake
+find_package(omath CONFIG REQUIRED)
+target_link_libraries(main PRIVATE omath::omath)
+```
+For detailed commands on installing different versions and more information, please refer to Microsoft's official instructions (https://learn.microsoft.com/en-us/vcpkg/get_started/overview)
+### Build from source
 1. Clone the repository:
    ```
    git clone https://github.com/orange-cpp/omath.git
@@ -40,7 +54,7 @@ Oranges's Math Library (omath) is a comprehensive, open-source library aimed at
    cmake --build cmake-build/build/windows-release --target server -j 6
    ```
    Use **\<platform\>-\<build configuration\>** preset to build siutable version for yourself. Like **windows-release** or **linux-release**.
-## Usage
+## ❔ Usage
 Simple world to screen function
 ```c++
 TEST(UnitTestProjection, IsPointOnScreen)
@@ -62,11 +76,11 @@ With `omath/projection` module you can achieve simple ESP hack for powered by So
 
 </details>
 
-## Contributing
+## 🫵🏻 Contributing
 Contributions to `omath` are welcome! Please read `CONTRIBUTING.md` for details on our code of conduct and the process for submitting pull requests.
 
-## License
+## 📜 License
 This project is licensed under the MIT - see the `LICENSE` file for details.
 
-## Acknowledgments
-- Orange | [Telegram](https://t.me/orange_cpp)
+## 💘 Acknowledgments
+-  [All contributors](https://github.com/orange-cpp/omath/graphs/contributors)

cmake/omathConfig.cmake.in

@@ -4,3 +4,4 @@ include(CMakeFindDependencyMacro)
 
 # Load the targets for the omath library
 include("${CMAKE_CURRENT_LIST_DIR}/omathTargets.cmake")
+check_required_components(omath)

include/omath/Angle.hpp

@@ -4,10 +4,8 @@
 
 #pragma once
 #include "omath/Angles.hpp"
-
 #include <algorithm>
 
-
 namespace omath
 {
     enum class AngleFlags

include/omath/Angles.hpp

@@ -6,7 +6,6 @@
 #include <numbers>
 #include <cmath>
 
-
 namespace omath::angles
 {
     template<class Type>

include/omath/Color.hpp

@@ -8,7 +8,6 @@
 #include <cstdint>
 #include "omath/Vector4.hpp"
 
-
 namespace omath
 {
     struct HSV

include/omath/Mat.hpp

@@ -9,7 +9,6 @@
 #include <utility>
 #include "Vector3.hpp"
 
-
 namespace omath
 {
     struct MatSize
@@ -66,6 +65,11 @@ namespace omath
             m_data = other.m_data;
         }
 
+        constexpr Type& operator[](const size_t row, const size_t col)
+        {
+            return At(row, col);
+        }
+
         constexpr Mat(Mat&& other) noexcept
         {
             m_data = std::move(other.m_data);

include/omath/Matrix.hpp

@@ -36,6 +36,10 @@ namespace omath
         [[nodiscard]]
         size_t RowCount() const noexcept;
 
+
+        [[nodiscard]]
+        float& operator[](size_t row, size_t column);
+
         [[nodiscard]]
         size_t ColumnsCount() const noexcept;
 

include/omath/Triangle.hpp

@@ -0,0 +1,74 @@
+//
+// Created by Orange on 11/13/2024.
+//
+#pragma once
+#include "omath/Vector3.hpp"
+
+namespace omath
+{
+    template<class Vector>
+    class Triangle final
+    {
+    public:
+        constexpr Triangle() = default;
+        constexpr Triangle(const Vector& vertex1, const Vector& vertex2, const Vector& vertex3)
+            : m_vertex1(vertex1), m_vertex2(vertex2), m_vertex3(vertex3)
+        {
+        }
+
+        Vector3 m_vertex1;
+        Vector3 m_vertex2;
+        Vector3 m_vertex3;
+
+        [[nodiscard]]
+        constexpr Vector3 CalculateNormal() const
+        {
+            const auto b = SideBVector();
+            const auto a = SideAVector();
+            return b.Cross(a).Normalized();
+        }
+
+        [[nodiscard]]
+        float SideALength() const
+        {
+            return m_vertex1.DistTo(m_vertex2);
+        }
+
+        [[nodiscard]]
+        float SideBLength() const
+        {
+            return m_vertex3.DistTo(m_vertex2);
+        }
+
+        [[nodiscard]]
+        constexpr Vector3 SideAVector() const
+        {
+            return m_vertex1 - m_vertex2;
+        }
+
+        [[nodiscard]]
+        constexpr float Hypot() const
+        {
+            return m_vertex1.DistTo(m_vertex3);
+        }
+        [[nodiscard]]
+        constexpr bool IsRectangular() const
+        {
+            const auto sideA = SideALength();
+            const auto sideB = SideBLength();
+            const auto hypot = Hypot();
+
+            return std::abs(sideA*sideA + sideB*sideB - hypot*hypot) <= 0.0001f;
+        }
+        [[nodiscard]]
+        constexpr Vector3 SideBVector() const
+        {
+            return m_vertex3 - m_vertex2;
+        }
+        [[nodiscard]]
+        constexpr Vector3 MidPoint() const
+        {
+            return (m_vertex1 + m_vertex2 + m_vertex3) / 3;
+        }
+    };
+} // namespace omath

include/omath/Triangle3d.hpp

@@ -1,33 +0,0 @@
-//
-// Created by Orange on 11/13/2024.
-//
-#pragma once
-#include "omath/Vector3.hpp"
-
-namespace omath
-{
-    class Triangle3d final
-    {
-    public:
-        Triangle3d(const Vector3& vertex1, const Vector3& vertex2, const Vector3& vertex3);
-
-        Vector3 m_vertex1;
-        Vector3 m_vertex2;
-        Vector3 m_vertex3;
-
-        [[nodiscard]]
-        Vector3 CalculateNormal() const;
-
-        [[nodiscard]]
-        float SideALength() const;
-
-        [[nodiscard]]
-        float SideBLength() const;
-
-        [[nodiscard]]
-        Vector3 SideAVector() const;
-
-        [[nodiscard]]
-        Vector3 SideBVector() const;
-    };
-}

include/omath/Vector2.hpp

@@ -6,7 +6,6 @@
 #include <tuple>
 #include <cmath>
 
-
 namespace omath
 {
     class Vector2

include/omath/Vector3.hpp

@@ -7,10 +7,18 @@
 #include <cstdint>
 #include <functional>
 #include "omath/Vector2.hpp"
+#include "omath/Angle.hpp"
+#include <expected>
 
 
 namespace omath
 {
+
+    enum class Vector3Error
+    {
+        IMPOSSIBLE_BETWEEN_ANGLE,
+    };
+
     class Vector3 : public Vector2
     {
     public:
@@ -209,6 +217,17 @@ namespace omath
             return Sum2D() + z;
         }
 
+        [[nodiscard]] std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
+        AngleBetween(const Vector3& other) const
+        {
+            const auto bottom = Length() * other.Length();
+
+            if (bottom == 0.f)
+                return std::unexpected(Vector3Error::IMPOSSIBLE_BETWEEN_ANGLE);
+
+            return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::FromRadians(std::acos(Dot(other) / bottom));
+        }
+
         [[nodiscard]] constexpr float Sum2D() const
         {
             return Vector2::Sum();

include/omath/Vector4.hpp

@@ -6,7 +6,6 @@
 #include <omath/Vector3.hpp>
 #include <algorithm>
 
-
 namespace omath
 {
     class Vector4 : public Vector3

include/omath/collision/LineTracer.hpp

@@ -4,8 +4,7 @@
 #pragma once
 
 #include "omath/Vector3.hpp"
-#include "omath/Triangle3d.hpp"
-
+#include "omath/Triangle.hpp"
 
 namespace omath::collision
 {
@@ -28,12 +27,12 @@ namespace omath::collision
 
 
         [[nodiscard]]
-        static bool CanTraceLine(const Ray& ray, const Triangle3d& triangle);
+        static bool CanTraceLine(const Ray& ray, const Triangle<Vector3>& triangle);
 
 
         // Realization of Möller–Trumbore intersection algorithm
         // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
         [[nodiscard]]
-        static Vector3 GetRayHitPoint(const Ray& ray, const Triangle3d& triangle);
+        static Vector3 GetRayHitPoint(const Ray& ray, const Triangle<Vector3>& triangle);
     };
 }

include/omath/engines/OpenGL/Camera.hpp

@@ -0,0 +1,19 @@
+//
+// Created by Orange on 12/23/2024.
+//
+#pragma once
+#include "Constants.hpp"
+#include "omath/projection/Camera.hpp"
+
+namespace omath::opengl
+{
+    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    {
+    public:
+        Camera(const Vector3& 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& target) override;
+        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
+        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
+    };
+}

include/omath/engines/OpenGL/Constants.hpp

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

include/omath/engines/OpenGL/Formulas.hpp

@@ -0,0 +1,54 @@
+//
+// Created by Orange on 12/23/2024.
+//
+#pragma once
+#include "Constants.hpp"
+
+
+namespace omath::opengl
+{
+    [[nodiscard]]
+    inline Vector3 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 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 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& cam_origin)
+    {
+        return MatCameraView<float, MatStoreType::COLUMN_MAJOR>(-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},
+
+            };
+    }
+}

include/omath/engines/Source/Camera.hpp

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

include/omath/engines/Source/Formulas.hpp

@@ -2,7 +2,7 @@
 // Created by Orange on 12/4/2024.
 //
 #pragma once
-#include "Constants.h"
+#include "Constants.hpp"
 
 namespace omath::source
 {

include/omath/pathfinding/Astar.hpp

@@ -7,7 +7,6 @@
 #include "NavigationMesh.hpp"
 #include "omath/Vector3.hpp"
 
-
 namespace omath::pathfinding
 {
     class Astar final

include/omath/pathfinding/NavigationMesh.hpp

@@ -9,7 +9,6 @@
 #include <vector>
 #include <string>
 
-
 namespace omath::pathfinding
 {
 

include/omath/prediction/Engine.hpp

@@ -9,7 +9,6 @@
 #include "omath/prediction/Projectile.hpp"
 #include "omath/prediction/Target.hpp"
 
-
 namespace omath::prediction
 {
     class Engine final

include/omath/prediction/Projectile.hpp

@@ -5,7 +5,6 @@
 #pragma once
 #include "omath/Vector3.hpp"
 
-
 namespace omath::prediction
 {
     class Projectile final

include/omath/prediction/Target.hpp

@@ -5,7 +5,6 @@
 #pragma once
 #include "omath/Vector3.hpp"
 
-
 namespace omath::prediction
 {
     class Target final

include/omath/projection/Camera.hpp

@@ -11,7 +11,6 @@
 #include <omath/Angle.hpp>
 #include <type_traits>
 
-
 namespace omath::projection
 {
     class ViewPort final
@@ -30,7 +29,6 @@ namespace omath::projection
     template<class Mat4x4Type, class ViewAnglesType>
     class Camera
     {
-
     public:
         virtual ~Camera() = default;
         Camera(const Vector3& position, const ViewAnglesType& viewAngles, const ViewPort& viewPort,
@@ -43,18 +41,82 @@ namespace omath::projection
 
         virtual void LookAt(const Vector3& target) = 0;
 
-        [[nodiscard]] virtual Mat4x4Type GetViewMatrix() const = 0;
+        [[nodiscard]] virtual Mat4x4Type CalcViewMatrix() const = 0;
 
-        [[nodiscard]] virtual Mat4x4Type GetProjectionMatrix() const = 0;
+        [[nodiscard]] virtual Mat4x4Type CalcProjectionMatrix() const = 0;
 
-        [[nodiscard]] Mat4x4Type GetViewProjectionMatrix()
+        [[nodiscard]] Mat4x4Type CalcViewProjectionMatrix() const
         {
-            return GetProjectionMatrix() * GetViewMatrix();
+            return CalcProjectionMatrix() * CalcViewMatrix();
         }
 
-        [[nodiscard]] std::expected<Vector3, Error> WorldToScreen(const Mat4x4Type& viewProj, const Vector3& worldPosition) const
+        void SetFieldOfView(const FieldOfView& fov)
         {
-            auto projected = viewProj * MatColumnFromVector<float, Mat4x4Type::GetStoreOrdering()>(worldPosition);
+            m_fieldOfView = fov;
+            m_viewProjectionMatrix = CalcViewProjectionMatrix();
+        }
+
+        void SetNearPlane(const float near)
+        {
+            m_nearPlaneDistance = near;
+            m_viewProjectionMatrix = CalcViewProjectionMatrix();
+        }
+
+        void SetFarPlane(const float far)
+        {
+            m_farPlaneDistance = far;
+            m_viewProjectionMatrix = CalcViewProjectionMatrix();
+        }
+
+        void SetViewAngles(const ViewAnglesType& viewAngles)
+        {
+            m_viewAngles = viewAngles;
+            m_viewProjectionMatrix = CalcViewProjectionMatrix();
+        }
+
+        void SetOrigin(const Vector3& origin)
+        {
+            m_origin = origin;
+            m_viewProjectionMatrix = CalcViewProjectionMatrix();
+        }
+
+        void SetViewPort(const ViewPort& viewPort)
+        {
+            m_viewPort = viewPort;
+            m_viewProjectionMatrix = CalcViewProjectionMatrix();
+        }
+
+        [[nodiscard]] const FieldOfView& GetFieldOfView() const
+        {
+            return m_fieldOfView;
+        }
+
+        [[nodiscard]] const float& GetNearPlane() const
+        {
+            return m_nearPlaneDistance;
+        }
+
+        [[nodiscard]] const float& GetFarPlane() const
+        {
+            return m_farPlaneDistance;
+        }
+
+        [[nodiscard]] const ViewAnglesType& GetViewAngles() const
+        {
+            return m_viewAngles;
+        }
+
+        [[nodiscard]] const Vector3& GetOrigin() const
+        {
+            return m_origin;
+        }
+
+        [[nodiscard]] std::expected<Vector3, Error> WorldToScreen(const Vector3& worldPosition) const
+        {
+            if (!m_viewProjectionMatrix.has_value())
+                m_viewProjectionMatrix = CalcViewProjectionMatrix();
+
+            auto projected = m_viewProjectionMatrix.value() * MatColumnFromVector<float, Mat4x4Type::GetStoreOrdering()>(worldPosition);
 
             if (projected.At(3, 0) == 0.0f)
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
@@ -64,13 +126,18 @@ namespace omath::projection
             if (IsNdcOutOfBounds(projected))
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
-            return Vector3{(projected.At(0,0)+1) / 2 * m_viewPort.m_width , (-projected.At(1,0)+1) / 2 * m_viewPort.m_height, projected.At(2,0)};
+            const auto screenPositionX = (projected.At(0,0)+1.f) / 2.f * m_viewPort.m_width;
+            const auto screenPositionY = (-projected.At(1,0)+1) / 2.f * m_viewPort.m_height;
+
+            return Vector3{screenPositionX, screenPositionY, projected.At(2,0)};
         }
 
     protected:
         ViewPort m_viewPort{};
         Angle<float, 0.f, 180.f, AngleFlags::Clamped> m_fieldOfView;
 
+        mutable std::optional<Mat4x4Type> m_viewProjectionMatrix;
+
         float m_farPlaneDistance;
         float m_nearPlaneDistance;
 

source/CMakeLists.txt

@@ -4,7 +4,6 @@ target_sources(omath PRIVATE
         color.cpp
         Vector4.cpp
         Vector2.cpp
-        Triangle3d.cpp
 )
 
 add_subdirectory(prediction)

source/Matrix.cpp

@@ -74,6 +74,11 @@ namespace omath
     {
         return m_rows;
     }
+    
+    float& Matrix::operator[](const size_t row, const size_t column)
+    {
+        return At(row, column);
+    }
 
     Matrix::Matrix(Matrix&& other) noexcept
     {

source/Triangle3d.cpp

@@ -1,36 +0,0 @@
-#include "omath/Triangle3d.hpp"
-
-
-namespace omath
-{
-    Triangle3d::Triangle3d(const Vector3 &vertex1, const Vector3 &vertex2, const Vector3 &vertex3)
-        : m_vertex1(vertex1), m_vertex2(vertex2), m_vertex3(vertex3)
-    {
-
-    }
-
-    Vector3 Triangle3d::CalculateNormal() const
-    {
-        return (m_vertex1 - m_vertex2).Cross(m_vertex3 - m_vertex1).Normalized();
-    }
-
-    float Triangle3d::SideALength() const
-    {
-        return m_vertex1.DistTo(m_vertex2);
-    }
-
-    float Triangle3d::SideBLength() const
-    {
-        return m_vertex3.DistTo(m_vertex2);
-    }
-
-    Vector3 Triangle3d::SideAVector() const
-    {
-        return m_vertex1 - m_vertex2;
-    }
-
-    Vector3 Triangle3d::SideBVector() const
-    {
-        return m_vertex3 - m_vertex2;
-    }
-}

source/collision/LineTracer.cpp

@@ -5,7 +5,7 @@
 
 namespace omath::collision
 {
-    bool LineTracer::CanTraceLine(const Ray &ray, const Triangle3d &triangle)
+    bool LineTracer::CanTraceLine(const Ray& ray, const Triangle<Vector3>& triangle)
     {
         return GetRayHitPoint(ray, triangle) == ray.end;
     }
@@ -19,7 +19,7 @@ namespace omath::collision
         return DirectionVector().Normalized();
     }
 
-    Vector3 LineTracer::GetRayHitPoint(const Ray &ray, const Triangle3d &triangle)
+    Vector3 LineTracer::GetRayHitPoint(const Ray& ray, const Triangle<Vector3>& triangle)
     {
         constexpr float kEpsilon = std::numeric_limits<float>::epsilon();
 
@@ -41,7 +41,7 @@ namespace omath::collision
         const auto u = t.Dot(p) * invDet;
 
 
-        if ((u < 0 && std::abs(u) > kEpsilon) || (u > 1 && std::abs(u-1) > kEpsilon))
+        if ((u < 0 && std::abs(u) > kEpsilon) || (u > 1 && std::abs(u - 1) > kEpsilon))
             return ray.end;
 
         const auto q = t.Cross(sideA);
@@ -59,4 +59,4 @@ namespace omath::collision
 
         return ray.start + rayDir * tHit;
     }
-}
+} // namespace omath::collision

source/engines/CMakeLists.txt

@@ -1 +1,2 @@
-add_subdirectory(Source)
+add_subdirectory(Source)
+add_subdirectory(OpenGL)

source/engines/OpenGL/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(omath PRIVATE Camera.cpp)

source/engines/OpenGL/Camera.cpp

@@ -0,0 +1,35 @@
+//
+// Created by Orange on 12/23/2024.
+//
+#include "omath/engines/OpenGL/Camera.hpp"
+#include "omath/engines/OpenGL/Formulas.hpp"
+
+
+namespace omath::opengl
+{
+
+    Camera::Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+                   const Angle<float, 0, 180, AngleFlags::Clamped>& fov, const float near, const float far) :
+        projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
+    {
+    }
+    void Camera::LookAt([[maybe_unused]] const Vector3& target)
+    {
+        const float distance = m_origin.DistTo(target);
+        const auto delta = target - m_origin;
+
+
+        m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
+        m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
+        m_viewAngles.roll = RollAngle::FromRadians(0.f);
+    }
+    Mat4x4 Camera::CalcViewMatrix() const
+    {
+        return opengl::CalcViewMatrix(m_viewAngles, m_origin);
+    }
+    Mat4x4 Camera::CalcProjectionMatrix() const
+    {
+        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
+                                               m_farPlaneDistance);
+    }
+} // namespace omath::opengl

source/engines/Source/Camera.cpp

@@ -24,13 +24,14 @@ namespace omath::source
         m_viewAngles.roll = RollAngle::FromRadians(0.f);
     }
 
-    Mat4x4 Camera::GetViewMatrix() const
+    Mat4x4 Camera::CalcViewMatrix() const
     {
-        return CalcViewMatrix(m_viewAngles, m_origin);
+        return source::CalcViewMatrix(m_viewAngles, m_origin);
     }
 
-    Mat4x4 Camera::GetProjectionMatrix() const
+    Mat4x4 Camera::CalcProjectionMatrix() const
     {
-        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance, m_farPlaneDistance);
+        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
+                                               m_farPlaneDistance);
     }
 } // namespace omath::source

tests/CMakeLists.txt

@@ -18,6 +18,7 @@ add_executable(unit-tests
         general/UnitTestAngles.cpp
         general/UnitTestViewAngles.cpp
         general/UnitTestAngle.cpp
+        general/UnitTestTriangle.cpp
 
         engines/UnitTestOpenGL.cpp
         engines/UnitTestUnityEngine.cpp

tests/engines/UnitTestOpenGL.cpp

@@ -1,37 +1,69 @@
 //
 // Created by Orange on 11/23/2024.
 //
-#include <complex>
 #include <gtest/gtest.h>
-#include <omath/Matrix.hpp>
-#include <print>
-
-// #include <glm/glm.hpp>
-
-// #include "glm/ext/matrix_clip_space.hpp"
-// #include "glm/ext/matrix_transform.hpp"
+#include <omath/engines/OpenGL/Camera.hpp>
+#include <omath/engines/OpenGL/Constants.hpp>
+#include <omath/engines/OpenGL/Formulas.hpp>
 
 
-TEST(UnitTestOpenGL, Projection)
+TEST(UnitTestOpenGL, ForwardVector)
 {
+    const auto forward = omath::opengl::ForwardVector({});
 
-    /*const auto proj_glm = glm::perspective(glm::radians(90.f), 16.f / 9.f, 0.1f, 1000.f);
-    // const auto proj_glm2 = glm::perspectiveLH_NO(glm::radians(90.f), 16.f / 9.f, 0.1f, 1000.f);
-    // const auto proj_omath = omath::Mat<4, 4, float, omath::MatStoreType::COLUMN_MAJOR>((const float*)&proj_glm);
-    // EXPECT_EQ(omath::opengl::PerspectiveProjectionMatrix(90, 16.f / 9.f, 0.1f, 1000.f), proj_omath);
+    EXPECT_EQ(forward, omath::opengl::kAbsForward);
+}
+
+TEST(UnitTestOpenGL, RightVector)
+{
+    const auto right = omath::opengl::RightVector({});
+
+    EXPECT_EQ(right, omath::opengl::kAbsRight);
+}
+
+TEST(UnitTestOpenGL, UpVector)
+{
+    const auto up = omath::opengl::UpVector({});
+    EXPECT_EQ(up, omath::opengl::kAbsUp);
+}
+
+TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
+{
+    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    auto cam = omath::opengl::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
 
-    glm::vec4 ndc_glm2 = proj_glm * glm::vec4(300.f, 0.f, -1000.f, 1.f);
-    ndc_glm2 /= ndc_glm2.w;
-    const omath::Mat<4, 1, float, omath::MatStoreType::COLUMN_MAJOR> cords_omath =
+    for (float distance = -10.f; distance > -1000.f; distance -= 0.01f)
     {
-        {0},
-        {0},
-        {-0.2f},
-        {1}
-    };
+        const auto projected = cam.WorldToScreen({0, 0, distance});
 
-    //auto ndc_omath = proj_omath * cords_omath;
-   // ndc_omath /= ndc_omath.At(3, 0);
-    */
+        EXPECT_TRUE(projected.has_value());
+
+        if (!projected.has_value())
+            continue;
+
+        EXPECT_NEAR(projected->x, 960, 0.00001f);
+        EXPECT_NEAR(projected->y, 540, 0.00001f);
+    }
+}
+
+TEST(UnitTestOpenGL, CameraSetAndGetFov)
+{
+    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    auto cam = omath::opengl::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
+    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+}
+
+TEST(UnitTestOpenGL, CameraSetAndGetOrigin)
+{
+    auto cam = omath::opengl::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.GetOrigin(), omath::Vector3{});
+    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
 }

tests/engines/UnitTestSourceEngine.cpp

@@ -3,7 +3,7 @@
 //
 #include <gtest/gtest.h>
 #include <omath/engines/Source/Camera.hpp>
-#include <omath/engines/Source/Constants.h>
+#include <omath/engines/Source/Constants.hpp>
 #include <omath/engines/Source/Formulas.hpp>
 
 
@@ -27,17 +27,15 @@ TEST(UnitTestSourceEngine, UpVector)
     EXPECT_EQ(up, omath::source::kAbsUp);
 }
 
-TEST(UnitTestSourceEngine, PerpectiveProjectionAtCenter)
+TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
     auto cam = omath::source::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
 
-    const auto viewProjMatrix = cam.GetViewProjectionMatrix();
-
     for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
     {
-        const auto projected = cam.WorldToScreen(viewProjMatrix, {distance, 0, 0});
+        const auto projected = cam.WorldToScreen({distance, 0, 0});
 
         EXPECT_TRUE(projected.has_value());
 
@@ -47,4 +45,25 @@ TEST(UnitTestSourceEngine, PerpectiveProjectionAtCenter)
         EXPECT_NEAR(projected->x, 960, 0.00001f);
         EXPECT_NEAR(projected->y, 540, 0.00001f);
     }
+}
+
+TEST(UnitTestSourceEngine, CameraSetAndGetFov)
+{
+    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    auto cam = omath::source::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
+    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+}
+
+TEST(UnitTestSourceEngine, CameraSetAndGetOrigin)
+{
+    auto cam = omath::source::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.GetOrigin(), omath::Vector3{});
+    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
 }

tests/general/UnitTestLineTrace.cpp

@@ -1,6 +1,6 @@
 #include "gtest/gtest.h"
 #include "omath/collision/LineTracer.hpp"
-#include "omath/Triangle3d.hpp"
+#include "omath/Triangle.hpp"
 #include "omath/Vector3.hpp"
 
 using namespace omath;
@@ -13,7 +13,7 @@ protected:
     Vector3 vertex1{0.0f, 0.0f, 0.0f};
     Vector3 vertex2{1.0f, 0.0f, 0.0f};
     Vector3 vertex3{0.0f, 1.0f, 0.0f};
-    Triangle3d triangle{vertex1, vertex2, vertex3};
+    Triangle<Vector3> triangle{vertex1, vertex2, vertex3};
 };
 
 // Test that a ray intersecting the triangle returns false for CanTraceLine
@@ -71,7 +71,7 @@ TEST_F(LineTracerTest, TriangleFarBeyondRayEndPoint)
     constexpr Ray ray{{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}};
 
     // Define a triangle far beyond the ray's endpoint
-    const Triangle3d distantTriangle{
+    constexpr Triangle<Vector3> distantTriangle{
         {1000.0f, 1000.0f, 1000.0f}, {1001.0f, 1000.0f, 1000.0f}, {1000.0f, 1001.0f, 1000.0f}
     };
 

tests/general/UnitTestMat.cpp

@@ -40,6 +40,14 @@ TEST_F(UnitTestMat, Constructor_InitializerList)
     EXPECT_FLOAT_EQ(m.At(1, 1), 4.0f);
 }
 
+TEST_F(UnitTestMat, Operator_SquareBrackets)
+{
+    EXPECT_EQ((m2[0, 0]), 1.0f);
+    EXPECT_EQ((m2[0, 1]), 2.0f);
+    EXPECT_EQ((m2[1, 0]), 3.0f);
+    EXPECT_EQ((m2[1, 1]), 4.0f);
+}
+
 TEST_F(UnitTestMat, Constructor_Copy)
 {
     Mat<2, 2> m3 = m2;

tests/general/UnitTestMatrix.cpp

@@ -29,6 +29,15 @@ TEST_F(UnitTestMatrix, Constructor_Size)
     EXPECT_EQ(m.ColumnsCount(), 3);
 }
 
+TEST_F(UnitTestMatrix, Operator_SquareBrackets)
+{
+    EXPECT_EQ((m2[0, 0]), 1.0f);
+    EXPECT_EQ((m2[0, 1]), 2.0f);
+    EXPECT_EQ((m2[1, 0]), 3.0f);
+    EXPECT_EQ((m2[1, 1]), 4.0f);
+}
+
+
 TEST_F(UnitTestMatrix, Constructor_InitializerList)
 {
     Matrix m{{1.0f, 2.0f}, {3.0f, 4.0f}};

tests/general/UnitTestProjection.cpp

@@ -10,9 +10,9 @@
 
 TEST(UnitTestProjection, Projection)
 {
-    auto x = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::FromDegrees(90.f);
+    const auto x = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::FromDegrees(90.f);
     auto cam = omath::source::Camera({0, 0, 0}, omath::source::ViewAngles{}, {1920.f, 1080.f}, x, 0.01f, 1000.f);
 
-    const auto projected = cam.WorldToScreen(cam.GetViewProjectionMatrix(), {1000, 0, 50});
+    const auto projected = cam.WorldToScreen({1000, 0, 50});
     std::print("{} {} {}", projected->x, projected->y, projected->z);
 }

tests/general/UnitTestTriangle.cpp

@@ -0,0 +1,132 @@
+//
+// Created by Orange on 1/6/2025.
+//
+#include "omath/Triangle.hpp"
+#include <gtest/gtest.h>
+#include <omath/Vector3.hpp>
+#include <cmath>  // For std::sqrt, std::isinf, std::isnan
+
+
+using namespace omath;
+
+class UnitTestTriangle : public ::testing::Test
+{
+protected:
+    // Define some Triangles to use in tests
+    Triangle<Vector3> t1;
+    Triangle<Vector3> t2;
+    Triangle<Vector3> t3;
+
+    constexpr void SetUp() override
+    {
+        // Triangle with vertices (0, 0, 0), (1, 0, 0), (0, 1, 0)
+        t1 = Triangle<Vector3>(
+            Vector3(0.0f, 0.0f, 0.0f),
+            Vector3(1.0f, 0.0f, 0.0f),
+            Vector3(0.0f, 1.0f, 0.0f)
+        );
+
+        // Triangle with vertices (1, 2, 3), (4, 5, 6), (7, 8, 9)
+        t2 = Triangle<Vector3>(
+            Vector3(1.0f, 2.0f, 3.0f),
+            Vector3(4.0f, 5.0f, 6.0f),
+            Vector3(7.0f, 8.0f, 9.0f)
+        );
+
+        // An isosceles right triangle
+        t3 = Triangle<Vector3>(
+            Vector3(0.0f, 0.0f, 0.0f),
+            Vector3(2.0f, 0.0f, 0.0f),
+            Vector3(0.0f, 2.0f, 0.0f)
+        );
+    }
+};
+
+// Test constructor and vertices
+TEST_F(UnitTestTriangle, Constructor)
+{
+    constexpr Triangle<Vector3> t(
+        Vector3(1.0f, 2.0f, 3.0f),
+        Vector3(4.0f, 5.0f, 6.0f),
+        Vector3(7.0f, 8.0f, 9.0f)
+    );
+
+    EXPECT_FLOAT_EQ(t.m_vertex1.x, 1.0f);
+    EXPECT_FLOAT_EQ(t.m_vertex1.y, 2.0f);
+    EXPECT_FLOAT_EQ(t.m_vertex1.z, 3.0f);
+
+    EXPECT_FLOAT_EQ(t.m_vertex2.x, 4.0f);
+    EXPECT_FLOAT_EQ(t.m_vertex2.y, 5.0f);
+    EXPECT_FLOAT_EQ(t.m_vertex2.z, 6.0f);
+
+    EXPECT_FLOAT_EQ(t.m_vertex3.x, 7.0f);
+    EXPECT_FLOAT_EQ(t.m_vertex3.y, 8.0f);
+    EXPECT_FLOAT_EQ(t.m_vertex3.z, 9.0f);
+}
+
+// Test CalculateNormal
+TEST_F(UnitTestTriangle, CalculateNormal)
+{
+    // For t1, the normal should point in the +Z direction (0, 0, 1) or (0, 0, -1)
+    const Vector3 normal_t1 = t1.CalculateNormal();
+    // Check if it's normalized and pointed along Z (sign can differ, so use absolute check)
+    EXPECT_NEAR(std::fabs(normal_t1.z), 1.0f, 1e-5f);
+    EXPECT_NEAR(normal_t1.Length(), 1.0f, 1e-5f);
+
+
+    // For t3, we expect the normal to be along +Z as well
+    const Vector3 normal_t3 = t3.CalculateNormal();
+    EXPECT_NEAR(std::fabs(normal_t3.z), 1.0f, 1e-5f);
+}
+
+// Test side lengths
+TEST_F(UnitTestTriangle, SideLengths)
+{
+    // For t1 side lengths
+    EXPECT_FLOAT_EQ(t1.SideALength(), std::sqrt(1.0f)); // distance between (0,0,0) and (1,0,0)
+    EXPECT_FLOAT_EQ(t1.SideBLength(), std::sqrt(1.0f + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate:
+    // Actually, for t1: vertex2=(1,0,0), vertex3=(0,1,0)
+    // Dist between (0,1,0) and (1,0,0) = sqrt((1-0)^2 + (0-1)^2) = sqrt(1 + 1) = sqrt(2)
+    EXPECT_FLOAT_EQ(t1.SideBLength(), std::sqrt(2.0f));
+
+    // For t3, side a = distance between vertex1=(0,0,0) and vertex2=(2,0,0), which is 2
+    // side b = distance between vertex3=(0,2,0) and vertex2=(2,0,0), which is sqrt(2^2 + (-2)^2)= sqrt(8)= 2.828...
+    // We'll just check side a first:
+    EXPECT_FLOAT_EQ(t3.SideALength(), 2.0f);
+    // Then side b:
+    EXPECT_FLOAT_EQ(t3.SideBLength(), std::sqrt(8.0f));
+}
+
+// Test side vectors
+TEST_F(UnitTestTriangle, SideVectors)
+{
+    const Vector3 sideA_t1 = t1.SideAVector(); // m_vertex1 - m_vertex2
+    EXPECT_FLOAT_EQ(sideA_t1.x, 0.0f - 1.0f);
+    EXPECT_FLOAT_EQ(sideA_t1.y, 0.0f - 0.0f);
+    EXPECT_FLOAT_EQ(sideA_t1.z, 0.0f - 0.0f);
+
+    const Vector3 sideB_t1 = t1.SideBVector(); // m_vertex3 - m_vertex2
+    EXPECT_FLOAT_EQ(sideB_t1.x, 0.0f - 1.0f);
+    EXPECT_FLOAT_EQ(sideB_t1.y, 1.0f - 0.0f);
+    EXPECT_FLOAT_EQ(sideB_t1.z, 0.0f - 0.0f);
+}
+
+TEST_F(UnitTestTriangle, IsRectangular)
+{
+    EXPECT_TRUE(Triangle<Vector3>({2,0,0}, {}, {0,2,0}).IsRectangular());
+}
+// Test midpoint
+TEST_F(UnitTestTriangle, MidPoint)
+{
+    // For t1, midpoint of (0,0,0), (1,0,0), (0,1,0)
+    const Vector3 mid1 = t1.MidPoint();
+    EXPECT_FLOAT_EQ(mid1.x, (0.0f + 1.0f + 0.0f) / 3.0f);
+    EXPECT_FLOAT_EQ(mid1.y, (0.0f + 0.0f + 1.0f) / 3.0f);
+    EXPECT_FLOAT_EQ(mid1.z, 0.0f);
+
+    // For t2, midpoint of (1,2,3), (4,5,6), (7,8,9)
+    const Vector3 mid2 = t2.MidPoint();
+    EXPECT_FLOAT_EQ(mid2.x, (1.0f + 4.0f + 7.0f) / 3.0f);
+    EXPECT_FLOAT_EQ(mid2.y, (2.0f + 5.0f + 8.0f) / 3.0f);
+    EXPECT_FLOAT_EQ(mid2.z, (3.0f + 6.0f + 9.0f) / 3.0f);
+}

tests/general/UnitTestVector3.cpp

@@ -387,6 +387,15 @@ TEST_F(UnitTestVector3, AsTuple)
     EXPECT_FLOAT_EQ(std::get<2>(tuple), v1.z);
 }
 
+// Test AsTuple method
+TEST_F(UnitTestVector3, AngleBeatween)
+{
+    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).AngleBetween({1, 0 ,0}).value().AsDegrees(), 90.0f);
+    EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).AngleBetween({0.0f, 0.0f, 1.0f}).value().AsDegrees(), 0.0f);
+    EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).AngleBetween({0.0f, 0.0f, 1.0f}).has_value());
+}
+
+
 // Static assertions (compile-time checks)
 static_assert(Vector3(1.0f, 2.0f, 3.0f).LengthSqr() == 14.0f, "LengthSqr should be 14");
 static_assert(Vector3(1.0f, 2.0f, 3.0f).Dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32");