Merge pull request #49 from orange-cpp/feature/legacy_option

Adds option to enable legacy classes

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.26)
 
-project(omath VERSION 1.0.1 LANGUAGES CXX)
+project(omath VERSION 3.0.2 LANGUAGES CXX)
 
 include(CMakePackageConfigHelpers)
 
@@ -14,26 +14,29 @@ option(OMATH_BUILD_EXAMPLES "Build example projects with you can learn & play" O
 option(OMATH_STATIC_MSVC_RUNTIME_LIBRARY "Force Omath to link static runtime" OFF)
 option(OMATH_SUPRESS_SAFETY_CHECKS "Supress some safety checks in release build to improve general performance" ON)
 option(OMATH_USE_UNITY_BUILD "Will enable unity build to speed up compilation" ON)
+option(OMATH_ENABLE_LEGACY "Will enable legacy classes that MUST be used ONLY for backward compatibility" OFF)
+
 
 file(GLOB_RECURSE OMATH_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp")
 file(GLOB_RECURSE OMATH_HEADERS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp")
 
 
 if (OMATH_BUILD_AS_SHARED_LIBRARY)
-    add_library(omath SHARED ${OMATH_SOURCES} ${OMATH_HEADERS})
+    add_library(${PROJECT_NAME} SHARED ${OMATH_SOURCES} ${OMATH_HEADERS})
 else ()
-    add_library(omath STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
+    add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
 endif ()
 
-message(STATUS "Building on ${CMAKE_HOST_SYSTEM_NAME}")
-add_library(omath::omath ALIAS omath)
+message(STATUS "[OMATH]: Building on ${CMAKE_HOST_SYSTEM_NAME}")
+
+add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
 if (OMATH_IMGUI_INTEGRATION)
-    target_compile_definitions(omath PUBLIC OMATH_IMGUI_INTEGRATION)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_IMGUI_INTEGRATION)
 
     # IMGUI is being linked as submodule
     if (TARGET imgui)
-        target_link_libraries(omath PUBLIC imgui)
+        target_link_libraries(${PROJECT_NAME} PUBLIC imgui)
         install(TARGETS imgui
                 EXPORT omathTargets
                 ARCHIVE DESTINATION lib
@@ -42,42 +45,46 @@ if (OMATH_IMGUI_INTEGRATION)
     else ()
         # Assume that IMGUI linked via VCPKG.
         find_package(imgui CONFIG REQUIRED)
-        target_link_libraries(omath PUBLIC imgui::imgui)
+        target_link_libraries(${PROJECT_NAME} PUBLIC imgui::imgui)
     endif ()
 
 endif ()
 
 if (OMATH_USE_AVX2)
-    target_compile_definitions(omath PUBLIC OMATH_USE_AVX2)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_USE_AVX2)
 endif ()
 
 if (OMATH_SUPRESS_SAFETY_CHECKS)
-    target_compile_definitions(omath PUBLIC OMATH_SUPRESS_SAFETY_CHECKS)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_SUPRESS_SAFETY_CHECKS)
 endif ()
 
-set_target_properties(omath PROPERTIES
+if (OMATH_ENABLE_LEGACY)
+    target_compile_options(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LEGACY)
+endif ()
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
         CXX_STANDARD 23
         CXX_STANDARD_REQUIRED ON)
 
 if (OMATH_USE_UNITY_BUILD)
-    set_target_properties(omath PROPERTIES
+    set_target_properties(${PROJECT_NAME} PROPERTIES
             UNITY_BUILD ON
             UNITY_BUILD_BATCH_SIZE 20)
 endif ()
 
 if (OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
-    set_target_properties(omath PROPERTIES
+    set_target_properties(${PROJECT_NAME} PROPERTIES
             MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
     )
 endif ()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    target_compile_options(omath PRIVATE -mavx2 -mfma)
+    target_compile_options(${PROJECT_NAME} PRIVATE -mavx2 -mfma)
 endif ()
 
-target_compile_features(omath PUBLIC cxx_std_23)
+target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_23)
 
 
 if (OMATH_BUILD_TESTS)
@@ -90,12 +97,12 @@ if (OMATH_BUILD_EXAMPLES)
 endif ()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND OMATH_THREAT_WARNING_AS_ERROR)
-    target_compile_options(omath PRIVATE /W4 /WX)
+    target_compile_options(${PROJECT_NAME} PRIVATE /W4 /WX)
 elseif (OMATH_THREAT_WARNING_AS_ERROR)
-    target_compile_options(omath PRIVATE -Wall -Wextra -Wpedantic -Werror)
+    target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra -Wpedantic -Werror)
 endif ()
 
-target_include_directories(omath
+target_include_directories(${PROJECT_NAME}
         PUBLIC
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>   # Use this path when building the project
         $<INSTALL_INTERFACE:include>                             # Use this path when the project is installed
@@ -105,21 +112,21 @@ target_include_directories(omath
 # Installation rules
 
 # Install the library
-install(TARGETS omath
-        EXPORT omathTargets
-        ARCHIVE DESTINATION lib COMPONENT omath   # For static libraries
-        LIBRARY DESTINATION lib COMPONENT omath   # For shared libraries
-        RUNTIME DESTINATION bin COMPONENT omath   # For executables (on Windows)
+install(TARGETS ${PROJECT_NAME}
+        EXPORT ${PROJECT_NAME}Targets
+        ARCHIVE DESTINATION lib COMPONENT ${PROJECT_NAME}   # For static libraries
+        LIBRARY DESTINATION lib COMPONENT ${PROJECT_NAME}   # For shared libraries
+        RUNTIME DESTINATION bin COMPONENT ${PROJECT_NAME}   # For executables (on Windows)
 )
 
 # Install headers as part of omath_component
-install(DIRECTORY include/ DESTINATION include COMPONENT omath)
+install(DIRECTORY include/ DESTINATION include COMPONENT ${PROJECT_NAME})
 
 # Export omath target for CMake find_package support, also under omath_component
-install(EXPORT omathTargets
-        FILE omathTargets.cmake
-        NAMESPACE omath::
-        DESTINATION lib/cmake/omath COMPONENT omath
+install(EXPORT ${PROJECT_NAME}Targets
+        FILE ${PROJECT_NAME}Targets.cmake
+        NAMESPACE ${PROJECT_NAME}::
+        DESTINATION lib/cmake/${PROJECT_NAME} COMPONENT ${PROJECT_NAME}
 )
 
 
@@ -134,12 +141,12 @@ write_basic_package_version_file(
 configure_package_config_file(
         "${CMAKE_CURRENT_SOURCE_DIR}/cmake/omathConfig.cmake.in"  # Path to the .in file
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"           # Output path for the generated file
-        INSTALL_DESTINATION lib/cmake/omath
+        INSTALL_DESTINATION lib/cmake/${PROJECT_NAME}
 )
 
 # Install the generated config files
 install(FILES
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"
         "${CMAKE_CURRENT_BINARY_DIR}/omathConfigVersion.cmake"
-        DESTINATION lib/cmake/omath
+        DESTINATION lib/cmake/${PROJECT_NAME}
 )

INSTALL.md

@@ -14,6 +14,20 @@ 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).
 
+## <img width="28px" src="https://xmake.io/assets/img/logo.svg" /> Using xrepo
+**Note**: Support xrepo for package management
+1. Install [xmake](https://xmake.io/)
+2. Run the following command to install the omath package:
+```
+xrepo install omath
+```
+xmake.lua
+```xmake
+add_requires("omath")
+target("...")
+    add_packages("omath")
+```
+
 ## <img width="28px" src="https://upload.wikimedia.org/wikipedia/commons/e/ef/CMake_logo.svg?" /> Build from source using CMake 
 1. **Preparation**
    

README.md

@@ -1,17 +1,28 @@
 <div align = center>
 
-![banner](https://i.imgur.com/SM9ccP6.png)
+![banner](https://github.com/orange-cpp/omath/blob/main/.github/images/banner.png?raw=true)
 
 ![GitHub License](https://img.shields.io/github/license/orange-cpp/omath)
 ![GitHub contributors](https://img.shields.io/github/contributors/orange-cpp/omath)
 ![GitHub top language](https://img.shields.io/github/languages/top/orange-cpp/omath)
 [![CodeFactor](https://www.codefactor.io/repository/github/orange-cpp/omath/badge)](https://www.codefactor.io/repository/github/orange-cpp/omath)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/orange-cpp/omath/cmake-multi-platform.yml)
+[![Vcpkg package](https://repology.org/badge/version-for-repo/vcpkg/orange-math.svg)](https://repology.org/project/orange-math/versions)
 ![GitHub forks](https://img.shields.io/github/forks/orange-cpp/omath)
 </div>
 
 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.
 
+<div align = center>
+ <a href="https://www.star-history.com/#orange-cpp/omath&Date">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=orange-cpp/omath&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=orange-cpp/omath&type=Date" />
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=orange-cpp/omath&type=Date" />
+  </picture>
+ </a>
+</div>
+
 ## 👁‍🗨 Features
 - **Efficiency**: Optimized for performance, ensuring quick computations using AVX2.
 - **Versatility**: Includes a wide array of mathematical functions and algorithms.
@@ -71,7 +82,7 @@ Or even advanced projectile aimbot
 Contributions to `omath` are welcome! Please read `CONTRIBUTING.md` for details on our code of conduct and the process for submitting pull requests.
 
 ## 📜 License
-This project is licensed under the MIT - see the `LICENSE` file for details.
+This project is licensed under the ZLIB - see the `LICENSE` file for details.
 
 ## 💘 Acknowledgments
 -  [All contributors](https://github.com/orange-cpp/omath/graphs/contributors)

cmake/omathConfig.cmake.in

@@ -2,6 +2,10 @@
 
 include(CMakeFindDependencyMacro)
 
+if (@OMATH_IMGUI_INTEGRATION@)
+    find_dependency(imgui CONFIG)
+endif()
+
 # Load the targets for the omath library
 include("${CMAKE_CURRENT_LIST_DIR}/omathTargets.cmake")
 check_required_components(omath)

examples/example_proj_mat_builder.cpp

@@ -15,8 +15,8 @@ int main()
     float fov = 0;
     float near = 0;
     float far = 0;
-    float viewPortWidth = 0;
-    float viewPortHeight = 0;
+    float view_port_width = 0;
+    float view_port_height = 0;
 
     std::print("Enter camera fov: ");
     std::cin >> fov;
@@ -28,13 +28,13 @@ int main()
     std::cin >> far;
 
     std::print("Enter camera screen width: ");
-    std::cin >> viewPortWidth;
+    std::cin >> view_port_width;
 
     std::print("Enter camera screen height: ");
-    std::cin >> viewPortHeight;
+    std::cin >> view_port_height;
 
     const auto mat =
-            omath::opengl_engine::CalcPerspectiveProjectionMatrix(fov, viewPortWidth / viewPortHeight, near, far);
+            omath::opengl_engine::calc_perspective_projection_matrix(fov, view_port_width / view_port_height, near, far);
 
-    std::print("{}", mat.ToString());
+    std::print("{}", mat.to_string());
 };

include/omath/color.hpp

@@ -166,5 +166,12 @@ namespace omath
         {
             return {0.f, 0.f, 1.f, 1.f};
         }
+#ifdef OMATH_IMGUI_INTEGRATION
+        [[nodiscard]]
+        ImColor to_im_color() const noexcept
+        {
+            return {to_im_vec4()};
+        }
+#endif
     };
 } // namespace omath

include/omath/engines/iw_engine/formulas.hpp

@@ -8,19 +8,19 @@
 namespace omath::iw_engine
 {
     [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles);
+    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles);
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles);
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles);
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
 
     [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
 } // namespace omath::iw_engine

include/omath/matrix.hpp

@@ -1,4 +1,7 @@
 #pragma once
+
+#ifdef OMATH_ENABLE_LEGACY
+
 #include "omath/vector3.hpp"
 #include <initializer_list>
 #include <memory>
@@ -106,3 +109,4 @@ namespace omath
         std::unique_ptr<float[]> m_data;
     };
 } // namespace omath
+#endif

include/omath/triangle.hpp

@@ -7,11 +7,12 @@
 namespace omath
 {
     /*
+    v1
     |\
     | \
   a |  \ hypot
     |   \
-    -----
+ v2 ----- v3
       b
     */
 

include/omath/vector2.hpp

@@ -30,78 +30,78 @@ namespace omath
 
         // Equality operators
         [[nodiscard]]
-        constexpr bool operator==(const Vector2& src) const noexcept
+        constexpr bool operator==(const Vector2& other) const noexcept
         {
-            return x == src.x && y == src.y;
+            return x == other.x && y == other.y;
         }
 
         [[nodiscard]]
-        constexpr bool operator!=(const Vector2& src) const noexcept
+        constexpr bool operator!=(const Vector2& other) const noexcept
         {
-            return !(*this == src);
+            return !(*this == other);
         }
 
         // Compound assignment operators
-        constexpr Vector2& operator+=(const Vector2& v) noexcept
+        constexpr Vector2& operator+=(const Vector2& other) noexcept
         {
-            x += v.x;
-            y += v.y;
+            x += other.x;
+            y += other.y;
 
             return *this;
         }
 
-        constexpr Vector2& operator-=(const Vector2& v) noexcept
+        constexpr Vector2& operator-=(const Vector2& other) noexcept
         {
-            x -= v.x;
-            y -= v.y;
+            x -= other.x;
+            y -= other.y;
 
             return *this;
         }
 
-        constexpr Vector2& operator*=(const Vector2& v) noexcept
+        constexpr Vector2& operator*=(const Vector2& other) noexcept
         {
-            x *= v.x;
-            y *= v.y;
+            x *= other.x;
+            y *= other.y;
 
             return *this;
         }
 
-        constexpr Vector2& operator/=(const Vector2& v) noexcept
+        constexpr Vector2& operator/=(const Vector2& other) noexcept
         {
-            x /= v.x;
-            y /= v.y;
+            x /= other.x;
+            y /= other.y;
 
             return *this;
         }
 
-        constexpr Vector2& operator*=(const Type& fl) noexcept
+        constexpr Vector2& operator*=(const Type& value) noexcept
         {
-            x *= fl;
-            y *= fl;
+            x *= value;
+            y *= value;
 
             return *this;
         }
 
-        constexpr Vector2& operator/=(const Type& fl) noexcept
+        constexpr Vector2& operator/=(const Type& value) noexcept
         {
-            x /= fl;
-            y /= fl;
+            x /= value;
+            y /= value;
 
             return *this;
         }
 
-        constexpr Vector2& operator+=(const Type& fl) noexcept
+        constexpr Vector2& operator+=(const Type& value) noexcept
         {
-            x += fl;
-            y += fl;
+            x += value;
+            y += value;
 
             return *this;
         }
 
-        constexpr Vector2& operator-=(const Type& fl) noexcept
+        constexpr Vector2& operator-=(const Type& value) noexcept
         {
-            x -= fl;
-            y -= fl;
+            x -= value;
+            y -= value;
 
             return *this;
         }
@@ -164,24 +164,24 @@ namespace omath
         }
 
         // Binary arithmetic operators
-        [[nodiscard]] constexpr Vector2 operator+(const Vector2& v) const noexcept
+        [[nodiscard]] constexpr Vector2 operator+(const Vector2& other) const noexcept
         {
-            return {x + v.x, y + v.y};
+            return {x + other.x, y + other.y};
         }
 
-        [[nodiscard]] constexpr Vector2 operator-(const Vector2& v) const noexcept
+        [[nodiscard]] constexpr Vector2 operator-(const Vector2& other) const noexcept
         {
-            return {x - v.x, y - v.y};
+            return {x - other.x, y - other.y};
         }
 
-        [[nodiscard]] constexpr Vector2 operator*(const float fl) const noexcept
+        [[nodiscard]] constexpr Vector2 operator*(const Type& value) const noexcept
         {
-            return {x * fl, y * fl};
+            return {x * value, y * value};
         }
 
-        [[nodiscard]] constexpr Vector2 operator/(const float fl) const noexcept
+        [[nodiscard]] constexpr Vector2 operator/(const Type& value) const noexcept
         {
-            return {x / fl, y / fl};
+            return {x / value, y / value};
         }
 
         // Sum of elements

include/omath/vector3.hpp

@@ -29,76 +29,76 @@ namespace omath
         }
         constexpr Vector3() noexcept: Vector2<Type>() {};
 
-        [[nodiscard]] constexpr bool operator==(const Vector3& src) const noexcept
+        [[nodiscard]] constexpr bool operator==(const Vector3& other) const noexcept
         {
-            return Vector2<Type>::operator==(src) && (src.z == z);
+            return Vector2<Type>::operator==(other) && (other.z == z);
         }
 
-        [[nodiscard]] constexpr bool operator!=(const Vector3& src) const noexcept
+        [[nodiscard]] constexpr bool operator!=(const Vector3& other) const noexcept
         {
-            return !(*this == src);
+            return !(*this == other);
         }
 
-        constexpr Vector3& operator+=(const Vector3& v) noexcept
+        constexpr Vector3& operator+=(const Vector3& other) noexcept
         {
-            Vector2<Type>::operator+=(v);
-            z += v.z;
+            Vector2<Type>::operator+=(other);
+            z += other.z;
 
             return *this;
         }
 
-        constexpr Vector3& operator-=(const Vector3& v) noexcept
+        constexpr Vector3& operator-=(const Vector3& other) noexcept
         {
-            Vector2<Type>::operator-=(v);
-            z -= v.z;
+            Vector2<Type>::operator-=(other);
+            z -= other.z;
 
             return *this;
         }
 
-        constexpr Vector3& operator*=(const float fl) noexcept
+        constexpr Vector3& operator*=(const Type& value) noexcept
         {
-            Vector2<Type>::operator*=(fl);
-            z *= fl;
+            Vector2<Type>::operator*=(value);
+            z *= value;
 
             return *this;
         }
 
-        constexpr Vector3& operator*=(const Vector3& v) noexcept
+        constexpr Vector3& operator*=(const Vector3& other) noexcept
         {
-            Vector2<Type>::operator*=(v);
-            z *= v.z;
+            Vector2<Type>::operator*=(other);
+            z *= other.z;
 
             return *this;
         }
 
-        constexpr Vector3& operator/=(const Vector3& v) noexcept
+        constexpr Vector3& operator/=(const Vector3& other) noexcept
         {
-            Vector2<Type>::operator/=(v);
-            z /= v.z;
+            Vector2<Type>::operator/=(other);
+            z /= other.z;
 
             return *this;
         }
 
-        constexpr Vector3& operator+=(const float fl) noexcept
+        constexpr Vector3& operator+=(const Type& value) noexcept
         {
-            Vector2<Type>::operator+=(fl);
-            z += fl;
+            Vector2<Type>::operator+=(value);
+            z += value;
 
             return *this;
         }
 
-        constexpr Vector3& operator/=(const float fl) noexcept
+        constexpr Vector3& operator/=(const Type& value) noexcept
         {
-            Vector2<Type>::operator/=(fl);
-            z /= fl;
+            Vector2<Type>::operator/=(value);
+            z /= value;
 
             return *this;
         }
 
-        constexpr Vector3& operator-=(const float fl) noexcept
+        constexpr Vector3& operator-=(const Type& value) noexcept
         {
-            Vector2<Type>::operator-=(fl);
-            z -= fl;
+            Vector2<Type>::operator-=(value);
+            z -= value;
 
             return *this;
         }
@@ -175,40 +175,42 @@ namespace omath
             return {-this->x, -this->y, -z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator+(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 operator+(const Vector3& other) const noexcept
         {
-            return {this->x + v.x, this->y + v.y, z + v.z};
+            return {this->x + other.x, this->y + other.y, z + other.z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator-(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 operator-(const Vector3& other) const noexcept
         {
-            return {this->x - v.x, this->y - v.y, z - v.z};
+            return {this->x - other.x, this->y - other.y, z - other.z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator*(const float fl) const noexcept
+        [[nodiscard]] constexpr Vector3 operator*(const Type& value) const noexcept
         {
-            return {this->x * fl, this->y * fl, z * fl};
+            return {this->x * value, this->y * value, z * value};
         }
 
-        [[nodiscard]] constexpr Vector3 operator*(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 operator*(const Vector3& other) const noexcept
         {
-            return {this->x * v.x, this->y * v.y, z * v.z};
+            return {this->x * other.x, this->y * other.y, z * other.z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator/(const float fl) const noexcept
+        [[nodiscard]] constexpr Vector3 operator/(const Type& value) const noexcept
         {
-            return {this->x / fl, this->y / fl, z / fl};
+            return {this->x / value, this->y / value, z / value};
         }
 
-        [[nodiscard]] constexpr Vector3 operator/(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 operator/(const Vector3& other) const noexcept
         {
-            return {this->x / v.x, this->y / v.y, z / v.z};
+            return {this->x / other.x, this->y / other.y, z / other.z};
         }
 
-        [[nodiscard]] constexpr Vector3 cross(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 cross(const Vector3& other) const noexcept
         {
-            return {this->y * v.z - z * v.y, z * v.x - this->x * v.z, this->x * v.y - this->y * v.x};
+            return {this->y * other.z - z * other.y, z * other.x - this->x * other.z,
+                    this->x * other.y - this->y * other.x};
         }
+
         [[nodiscard]] constexpr Type sum() const noexcept
         {
             return sum_2d() + z;
@@ -245,7 +247,7 @@ namespace omath
 
         [[nodiscard]] Vector3 view_angle_to(const Vector3& other) const noexcept
         {
-            const float distance = distance_to(other);
+            const auto distance = distance_to(other);
             const auto delta = other - *this;
 
             return {angles::radians_to_degrees(std::asin(delta.z / distance)),

include/omath/vector4.hpp

@@ -9,6 +9,7 @@
 namespace omath
 {
     template<class Type>
+    requires std::is_arithmetic_v<Type>
     class Vector4 : public Vector3<Type>
     {
     public:
@@ -20,61 +21,61 @@ namespace omath
         constexpr Vector4() noexcept : Vector3<Type>(), w(0) {};
 
         [[nodiscard]]
-        constexpr bool operator==(const Vector4& src) const noexcept
+        constexpr bool operator==(const Vector4& other) const noexcept
         {
-            return Vector3<Type>::operator==(src) && w == src.w;
+            return Vector3<Type>::operator==(other) && w == other.w;
         }
 
         [[nodiscard]]
-        constexpr bool operator!=(const Vector4& src) const noexcept
+        constexpr bool operator!=(const Vector4& other) const noexcept
         {
-            return !(*this == src);
+            return !(*this == other);
         }
 
-        constexpr Vector4& operator+=(const Vector4& v) noexcept
+        constexpr Vector4& operator+=(const Vector4& other) noexcept
         {
-            Vector3<Type>::operator+=(v);
-            w += v.w;
+            Vector3<Type>::operator+=(other);
+            w += other.w;
 
             return *this;
         }
 
-        constexpr Vector4& operator-=(const Vector4& v) noexcept
+        constexpr Vector4& operator-=(const Vector4& other) noexcept
         {
-            Vector3<Type>::operator-=(v);
-            w -= v.w;
+            Vector3<Type>::operator-=(other);
+            w -= other.w;
 
             return *this;
         }
 
-        constexpr Vector4& operator*=(const float scalar) noexcept
+        constexpr Vector4& operator*=(const Type& value) noexcept
         {
-            Vector3<Type>::operator*=(scalar);
-            w *= scalar;
+            Vector3<Type>::operator*=(value);
+            w *= value;
 
             return *this;
         }
 
-        constexpr Vector4& operator*=(const Vector4& v) noexcept
+        constexpr Vector4& operator*=(const Vector4& other) noexcept
         {
-            Vector3<Type>::operator*=(v);
-            w *= v.w;
+            Vector3<Type>::operator*=(other);
+            w *= other.w;
 
             return *this;
         }
 
-        constexpr Vector4& operator/=(const float scalar) noexcept
+        constexpr Vector4& operator/=(const Type& value) noexcept
         {
-            Vector3<Type>::operator/=(scalar);
-            w /= scalar;
+            Vector3<Type>::operator/=(value);
+            w /= value;
 
             return *this;
         }
 
-        constexpr Vector4& operator/=(const Vector4& v) noexcept
+        constexpr Vector4& operator/=(const Vector4& other) noexcept
         {
-            Vector3<Type>::operator/=(v);
-            w /= v.w;
+            Vector3<Type>::operator/=(other);
+            w /= other.w;
             return *this;
         }
 
@@ -116,39 +117,39 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Vector4 operator+(const Vector4& v) const noexcept
+        constexpr Vector4 operator+(const Vector4& other) const noexcept
         {
-            return {this->x + v.x, this->y + v.y, this->z + v.z, w + v.w};
+            return {this->x + other.x, this->y + other.y, this->z + other.z, w + other.w};
         }
 
         [[nodiscard]]
-        constexpr Vector4 operator-(const Vector4& v) const noexcept
+        constexpr Vector4 operator-(const Vector4& other) const noexcept
         {
-            return {this->x - v.x, this->y - v.y, this->z - v.z, w - v.w};
+            return {this->x - other.x, this->y - other.y, this->z - other.z, w - other.w};
         }
 
         [[nodiscard]]
-        constexpr Vector4 operator*(const Type& scalar) const noexcept
+        constexpr Vector4 operator*(const Type& value) const noexcept
         {
-            return {this->x * scalar, this->y * scalar, this->z * scalar, w * scalar};
+            return {this->x * value, this->y * value, this->z * value, w * value};
         }
 
         [[nodiscard]]
-        constexpr Vector4 operator*(const Vector4& v) const noexcept
+        constexpr Vector4 operator*(const Vector4& other) const noexcept
         {
-            return {this->x * v.x, this->y * v.y, this->z * v.z, w * v.w};
+            return {this->x * other.x, this->y * other.y, this->z * other.z, w * other.w};
         }
 
         [[nodiscard]]
-        constexpr Vector4 operator/(const Type& scalar) const noexcept
+        constexpr Vector4 operator/(const Type& value) const noexcept
         {
-            return {this->x / scalar, this->y / scalar, this->z / scalar, w / scalar};
+            return {this->x / value, this->y / value, this->z / value, w / value};
         }
 
         [[nodiscard]]
-        constexpr Vector4 operator/(const Vector4& v) const noexcept
+        constexpr Vector4 operator/(const Vector4& other) const noexcept
         {
-            return {this->x / v.x, this->y / v.y, this->z / v.z, w / v.w};
+            return {this->x / other.x, this->y / other.y, this->z / other.z, w / other.w};
         }
 
         [[nodiscard]]

source/engines/iw_engine/formulas.cpp

@@ -6,37 +6,37 @@
 namespace omath::iw_engine
 {
 
-    Vector3<float> forward_vector(const ViewAngles& angles)
+    Vector3<float> forward_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
 
-    Vector3<float> right_vector(const ViewAngles& angles)
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Vector3<float> up_vector(const ViewAngles& angles)
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Mat4X4 rotation_matrix(const ViewAngles& angles)
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
     {
         return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
     }
 
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {
         return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
     }
 
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far)
+                                              const float far) noexcept
     {
         // NOTE: Need magic number to fix fov calculation, since IW engine inherit Quake proj matrix calculation
         constexpr auto k_multiply_factor = 0.75f;

source/matrix.cpp

@@ -1,3 +1,5 @@
+#ifdef OMATH_ENABLE_LEGACY
+
 #include "omath/matrix.hpp"
 #include "omath/angles.hpp"
 #include "omath/vector3.hpp"
@@ -359,3 +361,4 @@ namespace omath
         m_data = nullptr;
     }
 } // namespace omath
+#endif

tests/CMakeLists.txt

@@ -5,7 +5,7 @@ project(unit_tests)
 include(GoogleTest)
 
 file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
-add_executable(unit_tests ${UNIT_TESTS_SOURCES})
+add_executable(${PROJECT_NAME} ${UNIT_TESTS_SOURCES})
 
 set_target_properties(unit_tests PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
@@ -17,6 +17,6 @@ set_target_properties(unit_tests PROPERTIES
         CXX_STANDARD_REQUIRED ON)
 
 
-target_link_libraries(unit_tests PRIVATE gtest gtest_main omath::omath)
+target_link_libraries(${PROJECT_NAME} PRIVATE gtest gtest_main omath::omath)
 
-gtest_discover_tests(unit_tests)
+gtest_discover_tests(${PROJECT_NAME})

tests/engines/unit_test_iw_engine.cpp

@@ -7,27 +7,27 @@
 #include <omath/engines/iw_engine/formulas.hpp>
 
 
-TEST(UnitTestIwEngine, ForwardVector)
+TEST(unit_test_iw_engine, ForwardVector)
 {
     const auto forward = omath::iw_engine::forward_vector({});
 
     EXPECT_EQ(forward, omath::iw_engine::k_abs_forward);
 }
 
-TEST(UnitTestIwEngine, RightVector)
+TEST(unit_test_iw_engine, RightVector)
 {
     const auto right = omath::iw_engine::right_vector({});
 
     EXPECT_EQ(right, omath::iw_engine::k_abs_right);
 }
 
-TEST(UnitTestIwEngine, UpVector)
+TEST(unit_test_iw_engine, UpVector)
 {
     const auto up = omath::iw_engine::up_vector({});
     EXPECT_EQ(up, omath::iw_engine::k_abs_up);
 }
 
-TEST(UnitTestIwEngine, ForwardVectorRotationYaw)
+TEST(unit_test_iw_engine, ForwardVectorRotationYaw)
 {
     omath::iw_engine::ViewAngles angles;
 
@@ -39,7 +39,7 @@ TEST(UnitTestIwEngine, ForwardVectorRotationYaw)
     EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_right.z, 0.00001f);
 }
 
-TEST(UnitTestIwEngine, ForwardVectorRotationPitch)
+TEST(unit_test_iw_engine, ForwardVectorRotationPitch)
 {
     omath::iw_engine::ViewAngles angles;
 
@@ -51,7 +51,7 @@ TEST(UnitTestIwEngine, ForwardVectorRotationPitch)
     EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_up.z, 0.01f);
 }
 
-TEST(UnitTestIwEngine, ForwardVectorRotationRoll)
+TEST(unit_test_iw_engine, ForwardVectorRotationRoll)
 {
     omath::iw_engine::ViewAngles angles;
 
@@ -63,7 +63,7 @@ TEST(UnitTestIwEngine, ForwardVectorRotationRoll)
     EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_right.z, 0.00001f);
 }
 
-TEST(UnitTestIwEngine, ProjectTargetMovedFromCamera)
+TEST(unit_test_iw_engine, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     const auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
@@ -83,7 +83,7 @@ TEST(UnitTestIwEngine, ProjectTargetMovedFromCamera)
     }
 }
 
-TEST(UnitTestIwEngine, CameraSetAndGetFov)
+TEST(unit_test_iw_engine, CameraSetAndGetFov)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
@@ -94,7 +94,7 @@ TEST(UnitTestIwEngine, CameraSetAndGetFov)
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }
 
-TEST(UnitTestIwEngine, CameraSetAndGetOrigin)
+TEST(unit_test_iw_engine, CameraSetAndGetOrigin)
 {
     auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 

tests/engines/unit_test_open_gl.cpp

@@ -7,25 +7,25 @@
 #include <omath/engines/opengl_engine/formulas.hpp>
 
 
-TEST(UnitTestOpenGL, ForwardVector)
+TEST(unit_test_opengl, ForwardVector)
 {
     const auto forward = omath::opengl_engine::forward_vector({});
     EXPECT_EQ(forward, omath::opengl_engine::k_abs_forward);
 }
 
-TEST(UnitTestOpenGL, RightVector)
+TEST(unit_test_opengl, RightVector)
 {
     const auto right = omath::opengl_engine::right_vector({});
     EXPECT_EQ(right, omath::opengl_engine::k_abs_right);
 }
 
-TEST(UnitTestOpenGL, UpVector)
+TEST(unit_test_opengl, UpVector)
 {
     const auto up = omath::opengl_engine::up_vector({});
     EXPECT_EQ(up, omath::opengl_engine::k_abs_up);
 }
 
-TEST(UnitTestOpenGL, ForwardVectorRotationYaw)
+TEST(unit_test_opengl, ForwardVectorRotationYaw)
 {
     omath::opengl_engine::ViewAngles angles;
 
@@ -39,7 +39,7 @@ TEST(UnitTestOpenGL, ForwardVectorRotationYaw)
 
 
 
-TEST(UnitTestOpenGL, ForwardVectorRotationPitch)
+TEST(unit_test_opengl, ForwardVectorRotationPitch)
 {
     omath::opengl_engine::ViewAngles angles;
 
@@ -51,7 +51,7 @@ TEST(UnitTestOpenGL, ForwardVectorRotationPitch)
     EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_up.z, 0.00001f);
 }
 
-TEST(UnitTestOpenGL, ForwardVectorRotationRoll)
+TEST(unit_test_opengl, ForwardVectorRotationRoll)
 {
     omath::opengl_engine::ViewAngles angles;
 
@@ -63,7 +63,7 @@ TEST(UnitTestOpenGL, ForwardVectorRotationRoll)
     EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_right.z, 0.00001f);
 }
 
-TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
+TEST(unit_test_opengl, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     const auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
@@ -83,7 +83,7 @@ TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
     }
 }
 
-TEST(UnitTestOpenGL, CameraSetAndGetFov)
+TEST(unit_test_opengl, CameraSetAndGetFov)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
@@ -94,7 +94,7 @@ TEST(UnitTestOpenGL, CameraSetAndGetFov)
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }
 
-TEST(UnitTestOpenGL, CameraSetAndGetOrigin)
+TEST(unit_test_opengl, CameraSetAndGetOrigin)
 {
     auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 

tests/engines/unit_test_source_engine.cpp

@@ -7,27 +7,27 @@
 #include <omath/engines/source_engine/formulas.hpp>
 
 
-TEST(UnitTestSourceEngine, ForwardVector)
+TEST(unit_test_source_engine, ForwardVector)
 {
     const auto forward = omath::source_engine::forward_vector({});
 
     EXPECT_EQ(forward, omath::source_engine::k_abs_forward);
 }
 
-TEST(UnitTestSourceEngine, RightVector)
+TEST(unit_test_source_engine, RightVector)
 {
     const auto right = omath::source_engine::right_vector({});
 
     EXPECT_EQ(right, omath::source_engine::k_abs_right);
 }
 
-TEST(UnitTestSourceEngine, UpVector)
+TEST(unit_test_source_engine, UpVector)
 {
     const auto up = omath::source_engine::up_vector({});
     EXPECT_EQ(up, omath::source_engine::k_abs_up);
 }
 
-TEST(UnitTestSourceEngine, ForwardVectorRotationYaw)
+TEST(unit_test_source_engine, ForwardVectorRotationYaw)
 {
     omath::source_engine::ViewAngles angles;
 
@@ -39,7 +39,7 @@ TEST(UnitTestSourceEngine, ForwardVectorRotationYaw)
     EXPECT_NEAR(forward.z, omath::source_engine::k_abs_right.z, 0.00001f);
 }
 
-TEST(UnitTestSourceEngine, ForwardVectorRotationPitch)
+TEST(unit_test_source_engine, ForwardVectorRotationPitch)
 {
     omath::source_engine::ViewAngles angles;
 
@@ -51,7 +51,7 @@ TEST(UnitTestSourceEngine, ForwardVectorRotationPitch)
     EXPECT_NEAR(forward.z, omath::source_engine::k_abs_up.z, 0.01f);
 }
 
-TEST(UnitTestSourceEngine, ForwardVectorRotationRoll)
+TEST(unit_test_source_engine, ForwardVectorRotationRoll)
 {
     omath::source_engine::ViewAngles angles;
 
@@ -63,7 +63,7 @@ TEST(UnitTestSourceEngine, ForwardVectorRotationRoll)
     EXPECT_NEAR(forward.z, omath::source_engine::k_abs_right.z, 0.00001f);
 }
 
-TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
+TEST(unit_test_source_engine, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
@@ -83,7 +83,7 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
     }
 }
 
-TEST(UnitTestSourceEngine, ProjectTargetMovedUp)
+TEST(unit_test_source_engine, ProjectTargetMovedUp)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
@@ -103,7 +103,7 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedUp)
     }
 }
 
-TEST(UnitTestSourceEngine, CameraSetAndGetFov)
+TEST(unit_test_source_engine, CameraSetAndGetFov)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
@@ -114,7 +114,7 @@ TEST(UnitTestSourceEngine, CameraSetAndGetFov)
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }
 
-TEST(UnitTestSourceEngine, CameraSetAndGetOrigin)
+TEST(unit_test_source_engine, CameraSetAndGetOrigin)
 {
     auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 

tests/engines/unit_test_unity_engine.cpp

@@ -7,14 +7,14 @@
 #include <omath/engines/unity_engine/formulas.hpp>
 #include <print>
 
-TEST(UnitTestUnityEngine, ForwardVector)
+TEST(unit_test_unity_engine, ForwardVector)
 {
     const auto forward = omath::unity_engine::forward_vector({});
 
     EXPECT_EQ(forward, omath::unity_engine::k_abs_forward);
 }
 
-TEST(UnitTestUnityEngine, ForwardVectorRotationYaw)
+TEST(unit_test_unity_engine, ForwardVectorRotationYaw)
 {
     omath::unity_engine::ViewAngles angles;
 
@@ -26,7 +26,7 @@ TEST(UnitTestUnityEngine, ForwardVectorRotationYaw)
     EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_right.z, 0.00001f);
 }
 
-TEST(UnitTestUnityEngine, ForwardVectorRotationPitch)
+TEST(unit_test_unity_engine, ForwardVectorRotationPitch)
 {
     omath::unity_engine::ViewAngles angles;
 
@@ -38,7 +38,7 @@ TEST(UnitTestUnityEngine, ForwardVectorRotationPitch)
     EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_up.z, 0.00001f);
 }
 
-TEST(UnitTestUnityEngine, ForwardVectorRotationRoll)
+TEST(unit_test_unity_engine, ForwardVectorRotationRoll)
 {
     omath::unity_engine::ViewAngles angles;
 
@@ -50,20 +50,20 @@ TEST(UnitTestUnityEngine, ForwardVectorRotationRoll)
     EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_right.z, 0.00001f);
 }
 
-TEST(UnitTestUnityEngine, RightVector)
+TEST(unit_test_unity_engine, RightVector)
 {
     const auto right = omath::unity_engine::right_vector({});
 
     EXPECT_EQ(right, omath::unity_engine::k_abs_right);
 }
 
-TEST(UnitTestUnityEngine, UpVector)
+TEST(unit_test_unity_engine, UpVector)
 {
     const auto up = omath::unity_engine::up_vector({});
     EXPECT_EQ(up, omath::unity_engine::k_abs_up);
 }
 
-TEST(UnitTestUnityEngine, ProjectTargetMovedFromCamera)
+TEST(unit_test_unity_engine, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
     const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.01f, 1000.f);
@@ -82,7 +82,7 @@ TEST(UnitTestUnityEngine, ProjectTargetMovedFromCamera)
         EXPECT_NEAR(projected->y, 360, 0.00001f);
     }
 }
-TEST(UnitTestUnityEngine, Project)
+TEST(unit_test_unity_engine, Project)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
 
@@ -91,7 +91,7 @@ TEST(UnitTestUnityEngine, Project)
     std::println("{} {}", proj->x, proj->y);
 }
 
-TEST(UnitTestUnityEngine, CameraSetAndGetFov)
+TEST(unit_test_unity_engine, CameraSetAndGetFov)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
@@ -102,7 +102,7 @@ TEST(UnitTestUnityEngine, CameraSetAndGetFov)
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
 }
 
-TEST(UnitTestUnityEngine, CameraSetAndGetOrigin)
+TEST(unit_test_unity_engine, CameraSetAndGetOrigin)
 {
     auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 

tests/general/unit_test_color.cpp

@@ -7,7 +7,7 @@
 
 using namespace omath;
 
-class UnitTestColor : public ::testing::Test
+class unit_test_color : public ::testing::Test
 {
 protected:
     Color color1;
@@ -21,7 +21,7 @@ protected:
 };
 
 // Test constructors
-TEST_F(UnitTestColor, Constructor_Float)
+TEST_F(unit_test_color, Constructor_Float)
 {
     constexpr Color color(0.5f, 0.5f, 0.5f, 1.0f);
     EXPECT_FLOAT_EQ(color.x, 0.5f);
@@ -30,7 +30,7 @@ TEST_F(UnitTestColor, Constructor_Float)
     EXPECT_FLOAT_EQ(color.w, 1.0f);
 }
 
-TEST_F(UnitTestColor, Constructor_Vector4)
+TEST_F(unit_test_color, Constructor_Vector4)
 {
     constexpr omath::Vector4 vec(0.2f, 0.4f, 0.6f, 0.8f);
     Color color(vec);
@@ -41,7 +41,7 @@ TEST_F(UnitTestColor, Constructor_Vector4)
 }
 
 // Test static methods for color creation
-TEST_F(UnitTestColor, FromRGBA)
+TEST_F(unit_test_color, FromRGBA)
 {
     constexpr Color color = Color::from_rgba(128, 64, 32, 255);
     EXPECT_FLOAT_EQ(color.x, 128.0f / 255.0f);
@@ -50,7 +50,7 @@ TEST_F(UnitTestColor, FromRGBA)
     EXPECT_FLOAT_EQ(color.w, 1.0f);
 }
 
-TEST_F(UnitTestColor, FromHSV)
+TEST_F(unit_test_color, FromHSV)
 {
     constexpr Color color = Color::from_hsv(0.0f, 1.0f, 1.0f); // Red in HSV
     EXPECT_FLOAT_EQ(color.x, 1.0f);
@@ -60,7 +60,7 @@ TEST_F(UnitTestColor, FromHSV)
 }
 
 // Test HSV conversion
-TEST_F(UnitTestColor, ToHSV)
+TEST_F(unit_test_color, ToHSV)
 {
     Hsv hsv = color1.to_hsv(); // Red color
     EXPECT_FLOAT_EQ(hsv.hue, 0.0f);
@@ -69,7 +69,7 @@ TEST_F(UnitTestColor, ToHSV)
 }
 
 // Test color blending
-TEST_F(UnitTestColor, Blend)
+TEST_F(unit_test_color, Blend)
 {
     Color blended = color1.blend(color2, 0.5f);
     EXPECT_FLOAT_EQ(blended.x, 0.5f);
@@ -79,7 +79,7 @@ TEST_F(UnitTestColor, Blend)
 }
 
 // Test predefined colors
-TEST_F(UnitTestColor, PredefinedColors)
+TEST_F(unit_test_color, PredefinedColors)
 {
     constexpr Color red = Color::red();
     constexpr Color green = Color::green();
@@ -102,7 +102,7 @@ TEST_F(UnitTestColor, PredefinedColors)
 }
 
 // Test non-member function: Blend for Vector3
-TEST_F(UnitTestColor, BlendVector3)
+TEST_F(unit_test_color, BlendVector3)
 {
     constexpr Color v1(1.0f, 0.0f, 0.0f, 1.f); // Red
     constexpr Color v2(0.0f, 1.0f, 0.0f, 1.f); // Green

tests/general/unit_test_line_trace.cpp

@@ -31,10 +31,10 @@ namespace
     // -----------------------------------------------------------------------------
     // Fixture with one canonical right‑angled triangle in the XY plane.
     // -----------------------------------------------------------------------------
-    class LineTracerFixture : public ::testing::Test
+    class line_tracer_fixture : public ::testing::Test
     {
     protected:
-        LineTracerFixture() :
+        line_tracer_fixture() :
             triangle({0.f, 0.f, 0.f}, {1.f, 0.f, 0.f}, {0.f, 1.f, 0.f})
         {
         }
@@ -51,7 +51,7 @@ namespace
         bool expected_clear; // true => segment does NOT hit the triangle
     };
 
-    class CanTraceLineParam : public LineTracerFixture,
+    class CanTraceLineParam : public line_tracer_fixture,
                               public ::testing::WithParamInterface<TraceCase>
     {
     };
@@ -79,7 +79,7 @@ namespace
     // -----------------------------------------------------------------------------
     // Validate that the reported hit point is correct for a genuine intersection.
     // -----------------------------------------------------------------------------
-    TEST_F(LineTracerFixture, HitPointCorrect)
+    TEST_F(line_tracer_fixture, HitPointCorrect)
     {
         constexpr Ray ray{{0.3f, 0.3f, -1.f}, {0.3f, 0.3f, 1.f}};
         constexpr Vec3 expected{0.3f, 0.3f, 0.f};
@@ -92,7 +92,7 @@ namespace
     // -----------------------------------------------------------------------------
     // Triangle far beyond the ray should not block.
     // -----------------------------------------------------------------------------
-    TEST_F(LineTracerFixture, DistantTriangleClear)
+    TEST_F(line_tracer_fixture, DistantTriangleClear)
     {
         constexpr Ray short_ray{{0.f, 0.f, 0.f}, {0.f, 0.f, 1.f}};
         constexpr Triangle<Vec3> distant{{1000.f, 1000.f, 1000.f},
@@ -102,7 +102,7 @@ namespace
         EXPECT_TRUE(LineTracer::can_trace_line(short_ray, distant));
     }
 
-    TEST(LineTracerTraceRayEdge, CantHit)
+    TEST(unit_test_unity_engine, CantHit)
     {
         constexpr omath::Triangle<Vector3<float>> triangle{{2, 0, 0}, {2, 2, 0}, {2, 2, 2}};
 
@@ -110,7 +110,7 @@ namespace
 
         EXPECT_TRUE(omath::collision::LineTracer::can_trace_line(ray, triangle));
     }
-    TEST(LineTracerTraceRayEdge, CanHit)
+    TEST(unit_test_unity_engine, CanHit)
     {
         constexpr omath::Triangle<Vector3<float>> triangle{{2, 0, 0}, {2, 2, 0}, {2, 2, 2}};
 

tests/general/unit_test_mat.cpp

@@ -5,7 +5,7 @@
 
 using namespace omath;
 
-class UnitTestMat : public ::testing::Test
+class unit_test_mat : public ::testing::Test
 {
 protected:
     Mat<2, 2> m1;
@@ -19,7 +19,7 @@ protected:
 };
 
 // Test constructors
-TEST_F(UnitTestMat, Constructor_Default)
+TEST_F(unit_test_mat, Constructor_Default)
 {
     Mat<3, 3> m;
     EXPECT_EQ(m.row_count(), 3);
@@ -29,7 +29,7 @@ TEST_F(UnitTestMat, Constructor_Default)
             EXPECT_FLOAT_EQ(m.at(i, j), 0.0f);
 }
 
-TEST_F(UnitTestMat, Constructor_InitializerList)
+TEST_F(unit_test_mat, Constructor_InitializerList)
 {
     constexpr Mat<2, 2> m{{1.0f, 2.0f}, {3.0f, 4.0f}};
     EXPECT_EQ(m.row_count(), 2);
@@ -40,7 +40,7 @@ TEST_F(UnitTestMat, Constructor_InitializerList)
     EXPECT_FLOAT_EQ(m.at(1, 1), 4.0f);
 }
 
-TEST_F(UnitTestMat, Operator_SquareBrackets)
+TEST_F(unit_test_mat, Operator_SquareBrackets)
 {
     EXPECT_EQ((m2[0, 0]), 1.0f);
     EXPECT_EQ((m2[0, 1]), 2.0f);
@@ -48,7 +48,7 @@ TEST_F(UnitTestMat, Operator_SquareBrackets)
     EXPECT_EQ((m2[1, 1]), 4.0f);
 }
 
-TEST_F(UnitTestMat, Constructor_Copy)
+TEST_F(unit_test_mat, Constructor_Copy)
 {
     Mat<2, 2> m3 = m2;
     EXPECT_EQ(m3.row_count(), m2.row_count());
@@ -57,7 +57,7 @@ TEST_F(UnitTestMat, Constructor_Copy)
     EXPECT_FLOAT_EQ(m3.at(1, 1), m2.at(1, 1));
 }
 
-TEST_F(UnitTestMat, Constructor_Move)
+TEST_F(unit_test_mat, Constructor_Move)
 {
     Mat<2, 2> m3 = std::move(m2);
     EXPECT_EQ(m3.row_count(), 2);
@@ -68,7 +68,7 @@ TEST_F(UnitTestMat, Constructor_Move)
 }
 
 // Test matrix operations
-TEST_F(UnitTestMat, Operator_Multiplication_Matrix)
+TEST_F(unit_test_mat, Operator_Multiplication_Matrix)
 {
     Mat<2, 2> m3 = m2 * m2;
     EXPECT_EQ(m3.row_count(), 2);
@@ -79,14 +79,14 @@ TEST_F(UnitTestMat, Operator_Multiplication_Matrix)
     EXPECT_FLOAT_EQ(m3.at(1, 1), 22.0f);
 }
 
-TEST_F(UnitTestMat, Operator_Multiplication_Scalar)
+TEST_F(unit_test_mat, Operator_Multiplication_Scalar)
 {
     Mat<2, 2> m3 = m2 * 2.0f;
     EXPECT_FLOAT_EQ(m3.at(0, 0), 2.0f);
     EXPECT_FLOAT_EQ(m3.at(1, 1), 8.0f);
 }
 
-TEST_F(UnitTestMat, Operator_Division_Scalar)
+TEST_F(unit_test_mat, Operator_Division_Scalar)
 {
     Mat<2, 2> m3 = m2 / 2.0f;
     EXPECT_FLOAT_EQ(m3.at(0, 0), 0.5f);
@@ -94,7 +94,7 @@ TEST_F(UnitTestMat, Operator_Division_Scalar)
 }
 
 // Test matrix functions
-TEST_F(UnitTestMat, Transpose)
+TEST_F(unit_test_mat, Transpose)
 {
     Mat<2, 2> m3 = m2.transposed();
     EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
@@ -103,19 +103,19 @@ TEST_F(UnitTestMat, Transpose)
     EXPECT_FLOAT_EQ(m3.at(1, 1), m2.at(1, 1));
 }
 
-TEST_F(UnitTestMat, Determinant)
+TEST_F(unit_test_mat, Determinant)
 {
     const float det = m2.determinant();
     EXPECT_FLOAT_EQ(det, -2.0f);
 }
 
-TEST_F(UnitTestMat, Sum)
+TEST_F(unit_test_mat, Sum)
 {
     const float sum = m2.sum();
     EXPECT_FLOAT_EQ(sum, 10.0f);
 }
 
-TEST_F(UnitTestMat, Clear)
+TEST_F(unit_test_mat, Clear)
 {
     m2.clear();
     for (size_t i = 0; i < m2.row_count(); ++i)
@@ -123,7 +123,7 @@ TEST_F(UnitTestMat, Clear)
             EXPECT_FLOAT_EQ(m2.at(i, j), 0.0f);
 }
 
-TEST_F(UnitTestMat, ToString)
+TEST_F(unit_test_mat, ToString)
 {
     const std::string str = m2.to_string();
     EXPECT_FALSE(str.empty());
@@ -131,7 +131,7 @@ TEST_F(UnitTestMat, ToString)
 }
 
 // Test assignment operators
-TEST_F(UnitTestMat, AssignmentOperator_Copy)
+TEST_F(unit_test_mat, AssignmentOperator_Copy)
 {
     Mat<2, 2> m3;
     m3 = m2;
@@ -140,7 +140,7 @@ TEST_F(UnitTestMat, AssignmentOperator_Copy)
     EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
 }
 
-TEST_F(UnitTestMat, AssignmentOperator_Move)
+TEST_F(unit_test_mat, AssignmentOperator_Move)
 {
     Mat<2, 2> m3;
     m3 = std::move(m2);
@@ -152,7 +152,7 @@ TEST_F(UnitTestMat, AssignmentOperator_Move)
 }
 
 // Test static methods
-TEST_F(UnitTestMat, StaticMethod_ToScreenMat)
+TEST_F(unit_test_mat, StaticMethod_ToScreenMat)
 {
     Mat<4, 4> screenMat = Mat<4, 4>::to_screen_mat(800.0f, 600.0f);
     EXPECT_FLOAT_EQ(screenMat.at(0, 0), 400.0f);
@@ -164,11 +164,11 @@ TEST_F(UnitTestMat, StaticMethod_ToScreenMat)
 
 
 // Test exception handling in At() method
-TEST_F(UnitTestMat, Method_At_OutOfRange)
+TEST_F(unit_test_mat, Method_At_OutOfRange)
 {
 #if !defined(NDEBUG) && defined(OMATH_SUPRESS_SAFETY_CHECKS)
-    EXPECT_THROW(std::ignore = m2.At(2, 0), std::out_of_range);
-    EXPECT_THROW(std::ignore = m2.At(0, 2), std::out_of_range);
+    EXPECT_THROW(std::ignore = m2.at(2, 0), std::out_of_range);
+    EXPECT_THROW(std::ignore = m2.at(0, 2), std::out_of_range);
 #endif
 }
 

tests/general/unit_test_matrix.cpp

@@ -1,6 +1,9 @@
 //
 // Created by vlad on 5/18/2024.
 //
+
+#ifdef OMATH_ENABLE_LEGACY
+
 #include <gtest/gtest.h>
 #include <omath/matrix.hpp>
 #include "omath/vector3.hpp"
@@ -177,4 +180,5 @@ TEST_F(UnitTestMatrix, AssignmentOperator_Move)
     EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
     EXPECT_EQ(m2.row_count(), 0);  // m2 should be empty after the move
     EXPECT_EQ(m2.columns_count(), 0);
-}
+}
+#endif

writerside/c.list

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE categories
+        SYSTEM "https://resources.jetbrains.com/writerside/1.0/categories.dtd">
+<categories>
+    <category id="wrs" name="Writerside documentation" order="1"/>
+    <category id="inf" name="Learn more" order="2"/>
+</categories>

writerside/cfg/buildprofiles.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE buildprofiles SYSTEM "https://resources.jetbrains.com/writerside/1.0/build-profiles.dtd">
+<buildprofiles xsi:noNamespaceSchemaLocation="https://resources.jetbrains.com/writerside/1.0/build-profiles.xsd"
+               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+    <variables></variables>
+    <build-profile instance="o">
+        <variables>
+            <noindex-content>true</noindex-content>
+        </variables>
+    </build-profile>
+
+</buildprofiles>

writerside/o.tree

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE instance-profile
+        SYSTEM "https://resources.jetbrains.com/writerside/1.0/product-profile.dtd">
+
+<instance-profile id="o"
+                 name="OMATH"
+                 start-page="starter-topic.md">
+
+    <toc-element topic="starter-topic.md"/>
+    <toc-element topic="Documentation.md"/>
+    <toc-element topic="Code-Of-Conduct.md"/>
+    <toc-element topic="Community.md"/>
+    <toc-element topic="License.md"/>
+</instance-profile>

writerside/redirection-rules.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE rules SYSTEM "https://resources.jetbrains.com/writerside/1.0/redirection-rules.dtd">
+<rules>
+    <!-- format is as follows
+    <rule id="<unique id>">
+        <accepts>page.html</accepts>
+    </rule>
+    -->
+    <rule id="4e037516">
+        <description><![CDATA[Created after removal of "<Empty-MD-Topic.md>" from OMATH]]></description>
+        <accepts>Empty-MD-Topic.html</accepts>
+    </rule>
+</rules>

writerside/topics/Code-Of-Conduct.md

@@ -0,0 +1,95 @@
+# Code Of Conduct
+
+## 🎯 Goal
+
+My goal is to provide a space where it is safe for everyone to contribute to,
+and get support for, open-source software in a respectful and cooperative
+manner.
+
+I value all contributions and want to make this project and its
+surrounding community a place for everyone.
+
+As members, contributors, and everyone else who may participate in the
+development, I strive to keep the entire experience civil.
+
+## 📜 Standards
+
+Our community standards exist in order to make sure everyone feels comfortable
+contributing to the project(s) together.
+
+Our standards are:
+- Do not harass, attack, or in any other way discriminate against anyone, including
+  for their protected traits, including, but not limited to, sex, religion, race,
+  appearance, gender, identity, nationality, sexuality, etc.
+- Do not go off-topic, do not post spam.
+- Treat everyone with respect.
+
+Examples of breaking each rule respectively include:
+- Harassment, bullying or inappropriate jokes about another person.
+- Posting distasteful imagery, trolling, or posting things unrelated to the topic at hand.
+- Treating someone as worse because of their lack of understanding of an issue.
+
+## ⚡ Enforcement
+
+Enforcement of this CoC is done by Orange++ and/or other core contributors.
+
+I, as the core developer, will strive my best to keep this community civil and
+following the standards outlined above.
+
+### 🚩 Reporting incidents
+
+If you believe an incident of breaking these standards has occurred, but nobody has
+taken appropriate action, you can privately contact the people responsible for dealing
+with such incidents in multiple ways:
+
+***E-Mail***
+- `orange-cpp@yandex.ru`
+
+***Discord***
+- `@orange_cpp`
+
+***Telegram***
+- `@orange_cpp`
+
+I guarantee your privacy and will not share those reports with anyone.
+
+## ⚖️ Enforcement Strategy
+
+Depending on the severity of the infraction, any action from the list below may be applied.
+Please keep in mind cases are reviewed on a per-case basis and members are the ultimate
+deciding factor in the type of punishment.
+
+If the matter benefited from an outside opinion, a member might reach for more opinions
+from people unrelated, however, the final decision regarding the action
+to be taken is still up to the member.
+
+For example, if the matter at hand regards a representative of a marginalized group or minority,
+the member might ask for a first-hand opinion from another representative of such group.
+
+### ✏️ Correction/Edit
+
+If your message is found to be misleading or poorly worded, a member might
+edit your message.
+
+### ⚠️ Warning/Deletion
+
+If your message is found inappropriate, a member might give you a public or private warning,
+and/or delete your message.
+
+### 🔇 Mute
+
+If your message is disruptive, or you have been repeatedly violating the standards,
+a member might mute (or temporarily ban) you.
+
+### ⛔ Ban
+
+If your message is hateful, very disruptive, or other, less serious infractions are repeated
+ignoring previous punishments, a member might ban you permanently.
+
+## 🔎 Scope
+
+This CoC shall apply to all projects ran under the Orange++ lead and all _official_ communities
+outside of GitHub.
+
+However, it is worth noting that official communities outside of GitHub might have their own,
+additional sets of rules.

writerside/topics/Community.md

@@ -0,0 +1,11 @@
+# Credits
+
+Thanks to everyone who made this possible, including:
+
+- Saikari aka luadebug for VCPKG port.
+
+And a big hand to everyone else who has contributed over the past!
+
+THANKS! <3
+
+    -- Orange++ <orange-cpp@yandex.ru>

writerside/topics/Documentation.md

@@ -0,0 +1,54 @@
+# 📥Installation Guide
+
+## Using 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 using CMake
+1. **Preparation**
+
+   Install needed tools: cmake, clang, git, msvc (windows only).
+
+    1. **Linux:**
+        ```bash
+        sudo pacman -Sy cmake ninja clang git
+        ```
+    2. **MacOS:**
+        ```bash
+        brew install llvm git cmake ninja
+        ```
+    3. **Windows:**
+
+       Install Visual Studio from [here](https://visualstudio.microsoft.com/downloads/) and Git from [here](https://git-scm.com/downloads).
+
+       Use x64 Native Tools shell to execute needed commands down below.
+2. **Clone the repository:**
+   ```bash
+   git clone https://github.com/orange-cpp/omath.git
+   ```
+3. **Navigate to the project directory:**
+   ```bash
+   cd omath
+   ```
+4. **Build the project using CMake:**
+   ```bash
+   cmake --preset windows-release -S .
+   cmake --build cmake-build/build/windows-release --target omath -j 6
+   ```
+   Use **\<platform\>-\<build configuration\>** preset to build siutable version for yourself. Like **windows-release** or **linux-release**.
+
+   | Platform Name | Build Config  |
+       |---------------|---------------|
+   | windows       | release/debug |
+   | linux         | release/debug |
+   | darwin        | release/debug |

writerside/topics/License.md

@@ -0,0 +1,9 @@
+# License
+
+Copyright (c) 2025 Orange++
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

writerside/topics/starter-topic.md

@@ -0,0 +1,67 @@
+# Intro
+
+![banner](https://i.imgur.com/SM9ccP6.png)
+
+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
+- **Efficiency**: Optimized for performance, ensuring quick computations using AVX2.
+- **Versatility**: Includes a wide array of mathematical functions and algorithms.
+- **Ease of Use**: Simplified interface for convenient integration into various projects.
+- **Projectile Prediction**: Projectile prediction engine with O(N) algo complexity, that can power you projectile aim-bot.
+- **3D Projection**: No need to find view-projection matrix anymore you can make your own projection pipeline.
+- **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
+- **Ready for meta-programming**: Omath use templates for common types like Vectors, Matrixes etc, to handle all types!
+
+## Supported Render Pipelines
+| ENGINE   | SUPPORT |
+|----------|---------|
+| Source   | ✅YES    |
+| Unity    | ✅YES    |
+| IWEngine | ✅YES    |
+| Unreal   | ❌NO     |
+
+## Supported Operating Systems
+
+| OS             | SUPPORT |
+|----------------|---------|
+| Windows 10/11  | ✅YES    |
+| Linux          | ✅YES    |
+| Darwin (MacOS) | ✅YES    |
+
+## ⏬ Installation
+Please read our [installation guide](https://github.com/orange-cpp/omath/blob/main/INSTALL.md). If this link doesn't work check out INSTALL.md file.
+
+## ❔ Usage
+Simple world to screen function
+```c++
+TEST(UnitTestProjection, IsPointOnScreen)
+{
+    const omath::projection::Camera camera({0.f, 0.f, 0.f}, {0, 0.f, 0.f} , {1920.f, 1080.f}, 110.f, 0.1f, 500.f);
+
+    const auto proj = camera.WorldToScreen({100, 0, 15});
+    EXPECT_TRUE(proj.has_value());
+}
+```
+## Showcase
+
+With `omath/projection` module you can achieve simple ESP hack for powered by Source/Unreal/Unity engine games, like [Apex Legends](https://store.steampowered.com/app/1172470/Apex_Legends/).
+
+![banner](https://i.imgur.com/lcJrfcZ.png)
+Or for InfinityWard Engine based games. Like Call of Duty Black Ops 2!
+![banner](https://i.imgur.com/F8dmdoo.png)
+Or create simple trigger bot with embeded traceline from omath::collision::LineTrace
+![banner](https://i.imgur.com/fxMjRKo.jpeg)
+Or even advanced projectile aimbot
+[Watch Video](https://youtu.be/lM_NJ1yCunw?si=5E87OrQMeypxSJ3E)
+
+
+## 🫵🏻 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
+This project is licensed under the MIT - see the `LICENSE` file for details.
+
+## 💘 Acknowledgments
+-  [All contributors](https://github.com/orange-cpp/omath/graphs/contributors)

writerside/v.list

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE vars SYSTEM "https://resources.jetbrains.com/writerside/1.0/vars.dtd">
+<vars>
+    <var name="product" value="Writerside"/>
+</vars>

writerside/writerside.cfg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE ihp SYSTEM "https://resources.jetbrains.com/writerside/1.0/ihp.dtd">
+
+<ihp version="2.0">
+    <topics dir="topics" web-path="topics"/>
+    <images dir="images" web-path="images"/>
+    <instance src="o.tree"/>
+</ihp>