fixed version

Feature/noexcept

.clang-format

@@ -33,7 +33,7 @@ BraceWrapping:
   BeforeWhile: true
   SplitEmptyRecord: true
   SplitEmptyNamespace: true
-BreakBeforeBinaryOperators: All
+BreakBeforeBinaryOperators: NonAssignment
 BreakBeforeConceptDeclarations: false
 ColumnLimit: 120
 IncludeBlocks: Merge

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)
 

LICENSE

@@ -1,9 +1,17 @@
-The MIT License (MIT)
+Copyright (C) 2024-2025 Orange++ <orange-cpp@yandex.ru>
 
-Copyright (c) 2024 Orange++
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
 
-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:
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
 
-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.
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

README.md

@@ -6,6 +6,7 @@
 ![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)
 ![GitHub forks](https://img.shields.io/github/forks/orange-cpp/omath)
 </div>
 

include/omath/3d_primitives/box.hpp

@@ -13,5 +13,5 @@ namespace omath::primitives
     [[nodiscard]]
     std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
                                              const Vector3<float>& dir_forward, const Vector3<float>& dir_right,
-                                             float ratio = 4.f);
+                                             float ratio = 4.f) noexcept;
 }

include/omath/angle.hpp

@@ -20,7 +20,7 @@ namespace omath
     class Angle
     {
         Type m_angle;
-        constexpr explicit Angle(const Type& degrees)
+        constexpr explicit Angle(const Type& degrees) noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
                 m_angle = angles::wrap_angle(degrees, min, max);
@@ -36,68 +36,68 @@ namespace omath
 
     public:
         [[nodiscard]]
-        constexpr static Angle from_degrees(const Type& degrees)
+        constexpr static Angle from_degrees(const Type& degrees) noexcept
         {
             return Angle{degrees};
         }
-        constexpr Angle(): m_angle(0)
+        constexpr Angle() noexcept: m_angle(0)
         {
         }
         [[nodiscard]]
-        constexpr static Angle from_radians(const Type& degrees)
+        constexpr static Angle from_radians(const Type& degrees) noexcept
         {
             return Angle{angles::radians_to_degrees<Type>(degrees)};
         }
 
         [[nodiscard]]
-        constexpr const Type& operator*() const
+        constexpr const Type& operator*() const noexcept
         {
             return m_angle;
         }
 
         [[nodiscard]]
-        constexpr Type as_degrees() const
+        constexpr Type as_degrees() const noexcept
         {
             return m_angle;
         }
 
         [[nodiscard]]
-        constexpr Type as_radians() const
+        constexpr Type as_radians() const noexcept
         {
             return angles::degrees_to_radians(m_angle);
         }
 
         [[nodiscard]]
-        Type sin() const
+        Type sin() const noexcept
         {
             return std::sin(as_radians());
         }
 
         [[nodiscard]]
-        Type cos() const
+        Type cos() const noexcept
         {
             return std::cos(as_radians());
         }
 
         [[nodiscard]]
-        Type tan() const
+        Type tan() const noexcept
         {
             return std::tan(as_radians());
         }
 
         [[nodiscard]]
-        Type atan() const
+        Type atan() const noexcept
         {
             return std::atan(as_radians());
         }
 
         [[nodiscard]]
-        Type cot() const
+        Type cot() const noexcept
         {
             return cos() / sin();
         }
 
-        constexpr Angle& operator+=(const Angle& other)
+        constexpr Angle& operator+=(const Angle& other) noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
                 m_angle = angles::wrap_angle(m_angle + other.m_angle, min, max);
@@ -114,16 +114,15 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr std::partial_ordering operator<=>(const Angle& other) const
-                = default;
+        constexpr std::partial_ordering operator<=>(const Angle& other) const noexcept = default;
 
-        constexpr Angle& operator-=(const Angle& other)
+        constexpr Angle& operator-=(const Angle& other) noexcept
         {
             return operator+=(-other);
         }
 
         [[nodiscard]]
-        constexpr Angle& operator+(const Angle& other)
+        constexpr Angle& operator+(const Angle& other) noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
                 return {angles::wrap_angle(m_angle + other.m_angle, min, max)};
@@ -138,13 +137,13 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Angle& operator-(const Angle& other)
+        constexpr Angle& operator-(const Angle& other) noexcept
         {
             return operator+(-other);
         }
 
         [[nodiscard]]
-        constexpr Angle operator-() const
+        constexpr Angle operator-() const noexcept
         {
             return Angle{-m_angle};
         }

include/omath/angles.hpp

@@ -10,21 +10,21 @@ namespace omath::angles
 {
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] constexpr Type radians_to_degrees(const Type& radians)
+    [[nodiscard]] constexpr Type radians_to_degrees(const Type& radians) noexcept
     {
         return radians * (static_cast<Type>(180) / std::numbers::pi_v<Type>);
     }
 
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees)
+    [[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees) noexcept
     {
         return degrees * (std::numbers::pi_v<Type> / static_cast<Type>(180));
     }
 
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect)
+    [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept
     {
         const auto fov_rad = degrees_to_radians(horizontal_fov);
 
@@ -35,19 +35,19 @@ namespace omath::angles
 
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect)
+    [[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept
     {
         const auto fov_as_radians = degrees_to_radians(vertical_fov);
 
-        const auto horizontal_fov
-                = static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
+        const auto horizontal_fov =
+                static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
 
         return radians_to_degrees(horizontal_fov);
     }
 
     template<class Type>
     requires std::is_arithmetic_v<Type>
-    [[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max)
+    [[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept
     {
         if (angle <= max && angle >= min)
             return angle;

include/omath/collision/line_tracer.hpp

@@ -16,10 +16,10 @@ namespace omath::collision
         bool infinite_length = false;
 
         [[nodiscard]]
-        Vector3<float> direction_vector() const;
+        Vector3<float> direction_vector() const noexcept;
 
         [[nodiscard]]
-        Vector3<float> direction_vector_normalized() const;
+        Vector3<float> direction_vector_normalized() const noexcept;
     };
     class LineTracer
     {
@@ -27,11 +27,11 @@ namespace omath::collision
         LineTracer() = delete;
 
         [[nodiscard]]
-        static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle);
+        static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
 
         // Realization of Möller–Trumbore intersection algorithm
         // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
         [[nodiscard]]
-        static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle);
+        static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
     };
 } // namespace omath::collision

include/omath/color.hpp

@@ -28,20 +28,20 @@ namespace omath
     class Color final : public Vector4<float>
     {
     public:
-        constexpr Color(const float r, const float g, const float b, const float a): Vector4(r, g, b, a)
+        constexpr Color(const float r, const float g, const float b, const float a) noexcept: Vector4(r, g, b, a)
         {
             clamp(0.f, 1.f);
         }
 
-        constexpr explicit Color() = default;
+        constexpr explicit Color() noexcept = default;
         [[nodiscard]]
-        constexpr static Color from_rgba(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a)
+        constexpr static Color from_rgba(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a) noexcept
         {
             return Color{Vector4(r, g, b, a) / 255.f};
         }
 
         [[nodiscard]]
-        constexpr static Color from_hsv(float hue, const float saturation, const float value)
+        constexpr static Color from_hsv(float hue, const float saturation, const float value) noexcept
         {
             float r{}, g{}, b{};
 
@@ -82,13 +82,13 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr static Color from_hsv(const Hsv& hsv)
+        constexpr static Color from_hsv(const Hsv& hsv) noexcept
         {
             return from_hsv(hsv.hue, hsv.saturation, hsv.value);
         }
 
         [[nodiscard]]
-        constexpr Hsv to_hsv() const
+        constexpr Hsv to_hsv() const noexcept
         {
             Hsv hsv_data;
 
@@ -120,11 +120,11 @@ namespace omath
             return hsv_data;
         }
 
-        constexpr explicit Color(const Vector4& vec): Vector4(vec)
+        constexpr explicit Color(const Vector4& vec) noexcept: Vector4(vec)
         {
             clamp(0.f, 1.f);
         }
-        constexpr void set_hue(const float hue)
+        constexpr void set_hue(const float hue) noexcept
         {
             auto hsv = to_hsv();
             hsv.hue = hue;
@@ -132,7 +132,7 @@ namespace omath
             *this = from_hsv(hsv);
         }
 
-        constexpr void set_saturation(const float saturation)
+        constexpr void set_saturation(const float saturation) noexcept
         {
             auto hsv = to_hsv();
             hsv.saturation = saturation;
@@ -140,7 +140,7 @@ namespace omath
             *this = from_hsv(hsv);
         }
 
-        constexpr void set_value(const float value)
+        constexpr void set_value(const float value) noexcept
         {
             auto hsv = to_hsv();
             hsv.value = value;
@@ -148,7 +148,7 @@ namespace omath
             *this = from_hsv(hsv);
         }
         [[nodiscard]]
-        constexpr Color blend(const Color& other, float ratio) const
+        constexpr Color blend(const Color& other, float ratio) const noexcept
         {
             ratio = std::clamp(ratio, 0.f, 1.f);
             return Color(*this * (1.f - ratio) + other * ratio);

include/omath/engines/iw_engine/camera.hpp

@@ -16,7 +16,7 @@ namespace omath::iw_engine
         void look_at(const Vector3<float>& target) override;
 
     protected:
-        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
-        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_view_matrix() const noexcept override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const noexcept override;
     };
 } // namespace omath::iw_engine

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/engines/opengl_engine/camera.hpp

@@ -13,7 +13,7 @@ namespace omath::opengl_engine
         Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
                const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
         void look_at(const Vector3<float>& target) override;
-        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
-        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_view_matrix() const noexcept override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const noexcept override;
     };
 } // namespace omath::opengl_engine

include/omath/engines/opengl_engine/formulas.hpp

@@ -8,19 +8,19 @@
 namespace omath::opengl_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 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 rotation_matrix(const ViewAngles& angles);
+    Mat4X4 rotation_matrix(const ViewAngles& angles) 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::opengl_engine

include/omath/engines/source_engine/camera.hpp

@@ -15,7 +15,7 @@ namespace omath::source_engine
         void look_at(const Vector3<float>& target) override;
 
     protected:
-        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
-        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_view_matrix() const noexcept override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const noexcept override;
     };
 } // namespace omath::source_engine

include/omath/engines/source_engine/formulas.hpp

@@ -7,19 +7,19 @@
 namespace omath::source_engine
 {
     [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles);
+    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles);
+    Mat4X4 rotation_matrix(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 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::source_engine

include/omath/engines/unity_engine/camera.hpp

@@ -16,7 +16,7 @@ namespace omath::unity_engine
         void look_at(const Vector3<float>& target) override;
 
     protected:
-        [[nodiscard]] Mat4X4 calc_view_matrix() const override;
-        [[nodiscard]] Mat4X4 calc_projection_matrix() const override;
+        [[nodiscard]] Mat4X4 calc_view_matrix() const noexcept override;
+        [[nodiscard]] Mat4X4 calc_projection_matrix() const noexcept override;
     };
 } // namespace omath::unity_engine

include/omath/engines/unity_engine/formulas.hpp

@@ -8,19 +8,19 @@
 namespace omath::unity_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 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 rotation_matrix(const ViewAngles& angles);
+    Mat4X4 rotation_matrix(const ViewAngles& angles) 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::unity_engine

include/omath/mat.hpp

@@ -451,7 +451,6 @@ namespace omath
             {up.x,      up.y,      up.z,      0},
             {forward.x, forward.y, forward.z, 0},
             {0,         0,         0,         1},
-
         } * mat_translation<Type, St>(-camera_origin);
     }
 

include/omath/pathfinding/a_star.hpp

@@ -15,16 +15,16 @@ namespace omath::pathfinding
     public:
         [[nodiscard]]
         static std::vector<Vector3<float>> find_path(const Vector3<float>& start, const Vector3<float>& end,
-                                                     const NavigationMesh& nav_mesh);
+                                                     const NavigationMesh& nav_mesh) noexcept;
 
     private:
         [[nodiscard]]
         static std::vector<Vector3<float>>
         reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
-                               const Vector3<float>& current);
+                               const Vector3<float>& current) noexcept;
 
         [[nodiscard]]
         static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
-                                     const Vector3<float>& end_vertex);
+                                     const Vector3<float>& end_vertex) noexcept;
     };
 } // namespace omath::pathfinding

include/omath/pathfinding/navigation_mesh.hpp

@@ -14,24 +14,23 @@ namespace omath::pathfinding
 
     enum Error
     {
-
     };
 
     class NavigationMesh final
     {
     public:
         [[nodiscard]]
-        std::expected<Vector3<float>, std::string> get_closest_vertex(const Vector3<float>& point) const;
+        std::expected<Vector3<float>, std::string> get_closest_vertex(const Vector3<float>& point) const noexcept;
 
         [[nodiscard]]
-        const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const;
+        const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const noexcept;
 
         [[nodiscard]]
         bool empty() const;
 
-        [[nodiscard]] std::vector<uint8_t> serialize() const;
+        [[nodiscard]] std::vector<uint8_t> serialize() const noexcept;
 
-        void deserialize(const std::vector<uint8_t>& raw);
+        void deserialize(const std::vector<uint8_t>& raw) noexcept;
 
         std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
     };

include/omath/projectile_prediction/proj_pred_engine_avx2.hpp

@@ -9,8 +9,8 @@ namespace omath::projectile_prediction
     class ProjPredEngineAvx2 final : public ProjPredEngine
     {
     public:
-        [[nodiscard]] std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
-                                                                              const Target& target) const override;
+        [[nodiscard]] std::optional<Vector3<float>>
+        maybe_calculate_aim_point(const Projectile& projectile, const Target& target) const override;
 
         ProjPredEngineAvx2(float gravity_constant, float simulation_time_step, float maximum_simulation_time);
         ~ProjPredEngineAvx2() override = default;
@@ -18,7 +18,7 @@ namespace omath::projectile_prediction
     private:
         [[nodiscard]] static std::optional<float> calculate_pitch(const Vector3<float>& proj_origin,
                                                                   const Vector3<float>& target_pos,
-                                                                  float bullet_gravity, float v0, float time);
+                                                                  float bullet_gravity, float v0, float time) ;
 
         // We use [[maybe_unused]] here since AVX2 is not available for ARM and ARM64 CPU
         [[maybe_unused]] const float m_gravity_constant;

include/omath/projectile_prediction/proj_pred_engine_legacy.hpp

@@ -29,11 +29,12 @@ namespace omath::projectile_prediction
         const float m_distance_tolerance;
 
         [[nodiscard]]
-        std::optional<float> maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
-                                                                           const Vector3<float>& target_position) const;
+        std::optional<float>
+        maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
+                                                      const Vector3<float>& target_position) const noexcept;
 
         [[nodiscard]]
         bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
-                                          float pitch, float time) const;
+                                          float pitch, float time) const noexcept;
     };
 } // namespace omath::projectile_prediction

include/omath/projectile_prediction/projectile.hpp

@@ -11,7 +11,7 @@ namespace omath::projectile_prediction
     {
     public:
         [[nodiscard]]
-        Vector3<float> predict_position(float pitch, float yaw, float time, float gravity) const;
+        Vector3<float> predict_position(float pitch, float yaw, float time, float gravity) const noexcept;
 
         Vector3<float> m_origin;
         float m_launch_speed{};

include/omath/projectile_prediction/target.hpp

@@ -11,12 +11,12 @@ namespace omath::projectile_prediction
     {
     public:
         [[nodiscard]]
-        constexpr Vector3<float> predict_position(const float time, const float gravity) const
+        constexpr Vector3<float> predict_position(const float time, const float gravity) const noexcept
         {
             auto predicted = m_origin + m_velocity * time;
 
             if (m_is_airborne)
-                predicted.z -= gravity * std::pow(time, 2.f) * 0.5f;
+                predicted.z -= gravity * (time*time) * 0.5f;
 
             return predicted;
         }

include/omath/projection/camera.hpp

@@ -32,7 +32,7 @@ namespace omath::projection
     public:
         virtual ~Camera() = default;
         Camera(const Vector3<float>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
-               const FieldOfView& fov, const float near, const float far)
+               const FieldOfView& fov, const float near, const float far) noexcept
             : m_view_port(view_port), m_field_of_view(fov), m_far_plane_distance(far), m_near_plane_distance(near),
               m_view_angles(view_angles), m_origin(position)
         {
@@ -41,17 +41,17 @@ namespace omath::projection
     protected:
         virtual void look_at(const Vector3<float>& target) = 0;
 
-        [[nodiscard]] virtual Mat4X4Type calc_view_matrix() const = 0;
+        [[nodiscard]] virtual Mat4X4Type calc_view_matrix() const noexcept = 0;
 
-        [[nodiscard]] virtual Mat4X4Type calc_projection_matrix() const = 0;
+        [[nodiscard]] virtual Mat4X4Type calc_projection_matrix() const noexcept = 0;
 
-        [[nodiscard]] Mat4X4Type calc_view_projection_matrix() const
+        [[nodiscard]] Mat4X4Type calc_view_projection_matrix() const noexcept
         {
             return calc_projection_matrix() * calc_view_matrix();
         }
 
     public:
-        [[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const
+        [[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const noexcept
         {
             if (!m_view_projection_matrix.has_value())
                 m_view_projection_matrix = calc_view_projection_matrix();
@@ -59,68 +59,69 @@ namespace omath::projection
             return m_view_projection_matrix.value();
         }
 
-        void set_field_of_view(const FieldOfView& fov)
+        void set_field_of_view(const FieldOfView& fov) noexcept
         {
             m_field_of_view = fov;
             m_view_projection_matrix = std::nullopt;
         }
 
-        void set_near_plane(const float near)
+        void set_near_plane(const float near) noexcept
         {
             m_near_plane_distance = near;
             m_view_projection_matrix = std::nullopt;
         }
 
-        void set_far_plane(const float far)
+        void set_far_plane(const float far) noexcept
         {
             m_far_plane_distance = far;
             m_view_projection_matrix = std::nullopt;
         }
 
-        void set_view_angles(const ViewAnglesType& view_angles)
+        void set_view_angles(const ViewAnglesType& view_angles) noexcept
         {
             m_view_angles = view_angles;
             m_view_projection_matrix = std::nullopt;
         }
 
-        void set_origin(const Vector3<float>& origin)
+        void set_origin(const Vector3<float>& origin) noexcept
         {
             m_origin = origin;
             m_view_projection_matrix = std::nullopt;
         }
 
-        void set_view_port(const ViewPort& view_port)
+        void set_view_port(const ViewPort& view_port) noexcept
         {
             m_view_port = view_port;
             m_view_projection_matrix = std::nullopt;
         }
 
-        [[nodiscard]] const FieldOfView& get_field_of_view() const
+        [[nodiscard]] const FieldOfView& get_field_of_view() const noexcept
         {
             return m_field_of_view;
         }
 
-        [[nodiscard]] const float& get_near_plane() const
+        [[nodiscard]] const float& get_near_plane() const noexcept
         {
             return m_near_plane_distance;
         }
 
-        [[nodiscard]] const float& get_far_plane() const
+        [[nodiscard]] const float& get_far_plane() const noexcept
         {
             return m_far_plane_distance;
         }
 
-        [[nodiscard]] const ViewAnglesType& get_view_angles() const
+        [[nodiscard]] const ViewAnglesType& get_view_angles() const noexcept
         {
             return m_view_angles;
         }
 
-        [[nodiscard]] const Vector3<float>& get_origin() const
+        [[nodiscard]] const Vector3<float>& get_origin() const noexcept
         {
             return m_origin;
         }
 
-        [[nodiscard]] std::expected<Vector3<float>, Error> world_to_screen(const Vector3<float>& world_position) const
+        [[nodiscard]] std::expected<Vector3<float>, Error>
+        world_to_screen(const Vector3<float>& world_position) const noexcept
         {
             auto normalized_cords = world_to_view_port(world_position);
 
@@ -131,7 +132,7 @@ namespace omath::projection
         }
 
         [[nodiscard]] std::expected<Vector3<float>, Error>
-        world_to_view_port(const Vector3<float>& world_position) const
+        world_to_view_port(const Vector3<float>& world_position) const noexcept
         {
             auto projected = get_view_projection_matrix()
                              * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(world_position);
@@ -160,13 +161,13 @@ namespace omath::projection
         Vector3<float> m_origin;
 
     private:
-        template<class Type> [[nodiscard]]
-        constexpr static bool is_ndc_out_of_bounds(const Type& ndc)
+        template<class Type>
+        [[nodiscard]] constexpr static bool is_ndc_out_of_bounds(const Type& ndc) noexcept
         {
             return std::ranges::any_of(ndc.raw_array(), [](const auto& val) { return val < -1 || val > 1; });
         }
 
-        [[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const
+        [[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const noexcept
         {
             return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (1.f - ndc.y) / 2.f * m_view_port.m_height, ndc.z};
         }

include/omath/vector2.hpp

@@ -24,133 +24,133 @@ namespace omath
         // Constructors
         constexpr Vector2() = default;
 
-        constexpr Vector2(const Type& x, const Type& y): x(x), y(y)
+        constexpr Vector2(const Type& x, const Type& y) noexcept: x(x), y(y)
         {
         }
 
         // Equality operators
         [[nodiscard]]
-        constexpr bool operator==(const Vector2& src) const
+        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
+        constexpr bool operator!=(const Vector2& other) const noexcept
         {
-            return !(*this == src);
+            return !(*this == other);
         }
 
         // Compound assignment operators
-        constexpr Vector2& operator+=(const Vector2& v)
+        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)
+        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)
+        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)
+        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)
+        constexpr Vector2& operator*=(const Type& value) noexcept
         {
-            x *= fl;
-            y *= fl;
+            x *= value;
+            y *= value;
 
             return *this;
         }
 
-        constexpr Vector2& operator/=(const Type& fl)
+        constexpr Vector2& operator/=(const Type& value) noexcept
         {
-            x /= fl;
-            y /= fl;
+            x /= value;
+            y /= value;
 
             return *this;
         }
 
-        constexpr Vector2& operator+=(const Type& fl)
+        constexpr Vector2& operator+=(const Type& value) noexcept
         {
-            x += fl;
-            y += fl;
+            x += value;
+            y += value;
 
             return *this;
         }
 
-        constexpr Vector2& operator-=(const Type& fl)
+        constexpr Vector2& operator-=(const Type& value) noexcept
         {
-            x -= fl;
-            y -= fl;
+            x -= value;
+            y -= value;
 
             return *this;
         }
 
         // Basic vector operations
-        [[nodiscard]] Type distance_to(const Vector2& other) const
+        [[nodiscard]] Type distance_to(const Vector2& other) const noexcept
         {
             return std::sqrt(distance_to_sqr(other));
         }
 
-        [[nodiscard]] constexpr Type distance_to_sqr(const Vector2& other) const
+        [[nodiscard]] constexpr Type distance_to_sqr(const Vector2& other) const noexcept
         {
             return (x - other.x) * (x - other.x) + (y - other.y) * (y - other.y);
         }
 
-        [[nodiscard]] constexpr Type dot(const Vector2& other) const
+        [[nodiscard]] constexpr Type dot(const Vector2& other) const noexcept
         {
             return x * other.x + y * other.y;
         }
 
 #ifndef _MSC_VER
-        [[nodiscard]] constexpr Type length() const
+        [[nodiscard]] constexpr Type length() const noexcept
         {
             return std::hypot(this->x, this->y);
         }
 
-        [[nodiscard]] constexpr Vector2 normalized() const
+        [[nodiscard]] constexpr Vector2 normalized() const noexcept
         {
             const Type len = length();
             return len > 0.f ? *this / len : *this;
         }
 #else
-        [[nodiscard]] Type length() const
+        [[nodiscard]] Type length() const noexcept
         {
             return std::hypot(x, y);
         }
 
-        [[nodiscard]] Vector2 normalized() const
+        [[nodiscard]] Vector2 normalized() const noexcept
         {
             const Type len = length();
             return len > 0.f ? *this / len : *this;
         }
 #endif
-        [[nodiscard]] constexpr Type length_sqr() const
+        [[nodiscard]] constexpr Type length_sqr() const noexcept
         {
             return x * x + y * y;
         }
 
-        constexpr Vector2& abs()
+        constexpr Vector2& abs() noexcept
         {
             // FIXME: Replace with std::abs, if it will become constexprable
             x = x < 0 ? -x : x;
@@ -158,47 +158,47 @@ namespace omath
             return *this;
         }
 
-        [[nodiscard]] constexpr Vector2 operator-() const
+        [[nodiscard]] constexpr Vector2 operator-() const noexcept
         {
             return {-x, -y};
         }
 
         // Binary arithmetic operators
-        [[nodiscard]] constexpr Vector2 operator+(const Vector2& v) const
+        [[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
+        [[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
+        [[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
+        [[nodiscard]] constexpr Vector2 operator/(const Type& value) const noexcept
         {
-            return {x / fl, y / fl};
+            return {x / value, y / value};
         }
 
         // Sum of elements
-        [[nodiscard]] constexpr Type sum() const
+        [[nodiscard]] constexpr Type sum() const noexcept
         {
             return x + y;
         }
 
         [[nodiscard]]
-        constexpr std::tuple<Type, Type> as_tuple() const
+        constexpr std::tuple<Type, Type> as_tuple() const noexcept
         {
             return std::make_tuple(x, y);
         }
 
 #ifdef OMATH_IMGUI_INTEGRATION
         [[nodiscard]]
-        ImVec2 to_im_vec2() const
+        ImVec2 to_im_vec2() const noexcept
         {
             return {static_cast<float>(this->x), static_cast<float>(this->y)};
         }

include/omath/vector3.hpp

@@ -24,86 +24,86 @@ namespace omath
     {
     public:
         Type z = static_cast<Type>(0);
-        constexpr Vector3(const Type& x, const Type& y, const Type& z): Vector2<Type>(x, y), z(z)
+        constexpr Vector3(const Type& x, const Type& y, const Type& z) noexcept: Vector2<Type>(x, y), z(z)
         {
         }
-        constexpr Vector3(): Vector2<Type>() {};
+        constexpr Vector3() noexcept: Vector2<Type>() {};
 
-        [[nodiscard]] constexpr bool operator==(const Vector3& src) const
+        [[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
+        [[nodiscard]] constexpr bool operator!=(const Vector3& other) const noexcept
         {
-            return !(*this == src);
+            return !(*this == other);
         }
 
-        constexpr Vector3& operator+=(const Vector3& v)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        constexpr Vector3& operator-=(const Type& value) noexcept
         {
-            Vector2<Type>::operator-=(fl);
-            z -= fl;
+            Vector2<Type>::operator-=(value);
+            z -= value;
 
             return *this;
         }
 
-        constexpr Vector3& abs()
+        constexpr Vector3& abs() noexcept
         {
             Vector2<Type>::abs();
             z = z < 0.f ? -z : z;
@@ -111,12 +111,12 @@ namespace omath
             return *this;
         }
 
-        [[nodiscard]] constexpr Type distance_to_sqr(const Vector3& other) const
+        [[nodiscard]] constexpr Type distance_to_sqr(const Vector3& other) const noexcept
         {
             return (*this - other).length_sqr();
         }
 
-        [[nodiscard]] constexpr Type dot(const Vector3& other) const
+        [[nodiscard]] constexpr Type dot(const Vector3& other) const noexcept
         {
             return Vector2<Type>::dot(other) + z * other.z;
         }
@@ -142,80 +142,82 @@ namespace omath
             return length_value != 0 ? *this / length_value : *this;
         }
 #else
-        [[nodiscard]] Type length() const
+        [[nodiscard]] Type length() const noexcept
         {
             return std::hypot(this->x, this->y, z);
         }
 
-        [[nodiscard]] Vector3 normalized() const
+        [[nodiscard]] Vector3 normalized() const noexcept
         {
             const Type len = this->length();
 
             return len != 0 ? *this / len : *this;
         }
 
-        [[nodiscard]] Type length_2d() const
+        [[nodiscard]] Type length_2d() const noexcept
         {
             return Vector2<Type>::length();
         }
 
-        [[nodiscard]] Type distance_to(const Vector3& vOther) const
+        [[nodiscard]] Type distance_to(const Vector3& vOther) const noexcept
         {
             return (*this - vOther).length();
         }
 #endif
 
-        [[nodiscard]] constexpr Type length_sqr() const
+        [[nodiscard]] constexpr Type length_sqr() const noexcept
         {
             return Vector2<Type>::length_sqr() + z * z;
         }
 
-        [[nodiscard]] constexpr Vector3 operator-() const
+        [[nodiscard]] constexpr Vector3 operator-() const noexcept
         {
             return {-this->x, -this->y, -z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator+(const Vector3& v) const
+        [[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
+        [[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
+        [[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
+        [[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
+        [[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
+        [[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
+        [[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
+
+        [[nodiscard]] constexpr Type sum() const noexcept
         {
             return sum_2d() + z;
         }
 
         [[nodiscard]] std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
-        angle_between(const Vector3& other) const
+        angle_between(const Vector3& other) const noexcept
         {
             const auto bottom = length() * other.length();
 
@@ -225,7 +227,7 @@ namespace omath
             return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::from_radians(std::acos(dot(other) / bottom));
         }
 
-        [[nodiscard]] bool is_perpendicular(const Vector3& other) const
+        [[nodiscard]] bool is_perpendicular(const Vector3& other) const noexcept
         {
             if (const auto angle = angle_between(other))
                 return angle->as_degrees() == 90.f;
@@ -233,19 +235,19 @@ namespace omath
             return false;
         }
 
-        [[nodiscard]] constexpr Type sum_2d() const
+        [[nodiscard]] constexpr Type sum_2d() const noexcept
         {
             return Vector2<Type>::sum();
         }
 
-        [[nodiscard]] constexpr std::tuple<Type, Type, Type> as_tuple() const
+        [[nodiscard]] constexpr std::tuple<Type, Type, Type> as_tuple() const noexcept
         {
             return std::make_tuple(this->x, this->y, z);
         }
 
-        [[nodiscard]] Vector3 view_angle_to(const Vector3& other) const
+        [[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:
@@ -17,90 +18,90 @@ namespace omath
         constexpr Vector4(const Type& x, const Type& y, const Type& z, const Type& w): Vector3<Type>(x, y, z), w(w)
         {
         }
-        constexpr Vector4(): Vector3<Type>(), w(0) {};
+        constexpr Vector4() noexcept : Vector3<Type>(), w(0) {};
 
         [[nodiscard]]
-        constexpr bool operator==(const Vector4& src) const
+        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
+        constexpr bool operator!=(const Vector4& other) const noexcept
         {
-            return !(*this == src);
+            return !(*this == other);
         }
 
-        constexpr Vector4& operator+=(const Vector4& v)
+        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)
+        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)
+        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)
+        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)
+        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)
+        constexpr Vector4& operator/=(const Vector4& other) noexcept
         {
-            Vector3<Type>::operator/=(v);
-            w /= v.w;
+            Vector3<Type>::operator/=(other);
+            w /= other.w;
             return *this;
         }
 
-        [[nodiscard]] constexpr Type length_sqr() const
+        [[nodiscard]] constexpr Type length_sqr() const noexcept
         {
             return Vector3<Type>::length_sqr() + w * w;
         }
 
-        [[nodiscard]] constexpr Type dot(const Vector4& other) const
+        [[nodiscard]] constexpr Type dot(const Vector4& other) const noexcept
         {
             return Vector3<Type>::dot(other) + w * other.w;
         }
 
-        [[nodiscard]] Vector3<Type> length() const
+        [[nodiscard]] Vector3<Type> length() const noexcept
         {
             return std::sqrt(length_sqr());
         }
 
-        constexpr Vector4& abs()
+        constexpr Vector4& abs() noexcept
         {
             Vector3<Type>::abs();
             w = w < 0.f ? -w : w;
 
             return *this;
         }
-        constexpr Vector4& clamp(const Type& min, const Type& max)
+        constexpr Vector4& clamp(const Type& min, const Type& max) noexcept
         {
             this->x = std::clamp(this->x, min, max);
             this->y = std::clamp(this->y, min, max);
@@ -110,56 +111,56 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Vector4 operator-() const
+        constexpr Vector4 operator-() const noexcept
         {
             return {-this->x, -this->y, -this->z, -w};
         }
 
         [[nodiscard]]
-        constexpr Vector4 operator+(const Vector4& v) const
+        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
+        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
+        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
+        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
+        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
+        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 Type sum() const
+        constexpr Type sum() const noexcept
         {
             return Vector3<Type>::sum() + w;
         }
 
 #ifdef OMATH_IMGUI_INTEGRATION
         [[nodiscard]]
-        ImVec4 to_im_vec4() const
+        ImVec4 to_im_vec4() const noexcept
         {
             return {
                     static_cast<float>(this->x),

source/3d_primitives/box.cpp

@@ -7,7 +7,7 @@ namespace omath::primitives
 {
     std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
                                                         const Vector3<float>& dir_forward,
-                                                        const Vector3<float>& dir_right, const float ratio)
+                                                        const Vector3<float>& dir_right, const float ratio) noexcept
     {
         const auto height = top.distance_to(bottom);
         const auto side_size = height / ratio;

source/collision/line_tracer.cpp

@@ -5,21 +5,21 @@
 
 namespace omath::collision
 {
-    bool LineTracer::can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle)
+    bool LineTracer::can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept
     {
         return get_ray_hit_point(ray, triangle) == ray.end;
     }
-    Vector3<float> Ray::direction_vector() const
+    Vector3<float> Ray::direction_vector() const noexcept
     {
         return end - start;
     }
 
-    Vector3<float> Ray::direction_vector_normalized() const
+    Vector3<float> Ray::direction_vector_normalized() const noexcept
     {
         return direction_vector().normalized();
     }
 
-    Vector3<float> LineTracer::get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle)
+    Vector3<float> LineTracer::get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept
     {
         constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
 

source/color.cpp

@@ -1,12 +0,0 @@
-//
-// Created by vlad on 2/4/24.
-//
-
-#include "omath/color.hpp"
-#include <algorithm>
-#include <cmath>
-
-namespace omath
-{
-
-}

source/engines/iw_engine/camera.cpp

@@ -21,11 +21,11 @@ namespace omath::iw_engine
         m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
         m_view_angles.roll = RollAngle::from_radians(0.f);
     }
-    Mat4X4 Camera::calc_view_matrix() const
+    Mat4X4 Camera::calc_view_matrix() const noexcept
     {
         return iw_engine::calc_view_matrix(m_view_angles, m_origin);
     }
-    Mat4X4 Camera::calc_projection_matrix() const
+    Mat4X4 Camera::calc_projection_matrix() const noexcept
     {
         return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
                                                   m_near_plane_distance, m_far_plane_distance);

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/engines/opengl_engine/camera.cpp

@@ -21,11 +21,11 @@ namespace omath::opengl_engine
         m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
         m_view_angles.roll = RollAngle::from_radians(0.f);
     }
-    Mat4X4 Camera::calc_view_matrix() const
+    Mat4X4 Camera::calc_view_matrix() const noexcept
     {
         return opengl_engine::calc_view_matrix(m_view_angles, m_origin);
     }
-    Mat4X4 Camera::calc_projection_matrix() const
+    Mat4X4 Camera::calc_projection_matrix() const noexcept
     {
         return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
                                                   m_near_plane_distance, m_far_plane_distance);

source/engines/opengl_engine/formulas.cpp

@@ -6,39 +6,39 @@
 namespace omath::opengl_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<float, MatStoreType::COLUMN_MAJOR>(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<float, MatStoreType::COLUMN_MAJOR>(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<float, MatStoreType::COLUMN_MAJOR>(k_abs_up);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    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<float, MatStoreType::COLUMN_MAJOR>(-forward_vector(angles), right_vector(angles),
                                                                   up_vector(angles), cam_origin);
     }
-    Mat4X4 rotation_matrix(const ViewAngles& angles)
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
     {
         return mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch)
                * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw)
                * mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
     }
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far)
+                                              const float far) noexcept
     {
         const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
 

source/engines/source_engine/camera.cpp

@@ -22,12 +22,12 @@ namespace omath::source_engine
         m_view_angles.roll = RollAngle::from_radians(0.f);
     }
 
-    Mat4X4 Camera::calc_view_matrix() const
+    Mat4X4 Camera::calc_view_matrix() const noexcept
     {
         return source_engine::calc_view_matrix(m_view_angles, m_origin);
     }
 
-    Mat4X4 Camera::calc_projection_matrix() const
+    Mat4X4 Camera::calc_projection_matrix() const noexcept
     {
         return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
                                                   m_near_plane_distance, m_far_plane_distance);

source/engines/source_engine/formulas.cpp

@@ -5,38 +5,38 @@
 
 namespace omath::source_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)};
     }
 
-    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);
     }
 
-    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 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 source inherit Quake proj matrix calculation
         constexpr auto k_multiply_factor = 0.75f;

source/engines/unity_engine/camera.cpp

@@ -15,11 +15,11 @@ namespace omath::unity_engine
     {
         throw std::runtime_error("Not implemented");
     }
-    Mat4X4 Camera::calc_view_matrix() const
+    Mat4X4 Camera::calc_view_matrix() const noexcept
     {
         return unity_engine::calc_view_matrix(m_view_angles, m_origin);
     }
-    Mat4X4 Camera::calc_projection_matrix() const
+    Mat4X4 Camera::calc_projection_matrix() const noexcept
     {
         return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
                                                   m_near_plane_distance, m_far_plane_distance);

source/engines/unity_engine/formulas.cpp

@@ -5,37 +5,37 @@
 
 namespace omath::unity_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 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<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
                                                                up_vector(angles), cam_origin);
     }
-    Mat4X4 rotation_matrix(const ViewAngles& angles)
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
     {
         return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch)
                * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
                * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll);
     }
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far)
+                                              const float far) noexcept
     {
         const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
 

source/pathfinding/a_star.cpp

@@ -17,7 +17,7 @@ namespace omath::pathfinding
 
     std::vector<Vector3<float>>
     Astar::reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
-                                  const Vector3<float>& current)
+                                  const Vector3<float>& current) noexcept
     {
         std::vector<Vector3<float>> path;
         std::optional current_opt = current;
@@ -38,7 +38,7 @@ namespace omath::pathfinding
         return path;
     }
     auto Astar::get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
-                                 const Vector3<float>& end_vertex)
+                                 const Vector3<float>& end_vertex) noexcept
     {
         return std::ranges::min_element(open_list,
                                         [&end_vertex](const auto& a, const auto& b)
@@ -50,7 +50,7 @@ namespace omath::pathfinding
     }
 
     std::vector<Vector3<float>> Astar::find_path(const Vector3<float>& start, const Vector3<float>& end,
-                                                 const NavigationMesh& nav_mesh)
+                                                 const NavigationMesh& nav_mesh) noexcept
     {
         std::unordered_map<Vector3<float>, PathNode> closed_list;
         std::unordered_map<Vector3<float>, PathNode> open_list;

source/pathfinding/navigation_mesh.cpp

@@ -6,7 +6,8 @@
 #include <stdexcept>
 namespace omath::pathfinding
 {
-    std::expected<Vector3<float>, std::string> NavigationMesh::get_closest_vertex(const Vector3<float>& point) const
+    std::expected<Vector3<float>, std::string>
+    NavigationMesh::get_closest_vertex(const Vector3<float>& point) const noexcept
     {
         const auto res = std::ranges::min_element(m_vertex_map, [&point](const auto& a, const auto& b)
                                                   { return a.first.distance_to(point) < b.first.distance_to(point); });
@@ -17,7 +18,7 @@ namespace omath::pathfinding
         return res->first;
     }
 
-    const std::vector<Vector3<float>>& NavigationMesh::get_neighbors(const Vector3<float>& vertex) const
+    const std::vector<Vector3<float>>& NavigationMesh::get_neighbors(const Vector3<float>& vertex) const noexcept
     {
         return m_vertex_map.at(vertex);
     }
@@ -27,7 +28,7 @@ namespace omath::pathfinding
         return m_vertex_map.empty();
     }
 
-    std::vector<uint8_t> NavigationMesh::serialize() const
+    std::vector<uint8_t> NavigationMesh::serialize() const noexcept
     {
         auto dump_to_vector = []<typename T>(const T& t, std::vector<uint8_t>& vec)
         {
@@ -50,7 +51,7 @@ namespace omath::pathfinding
         return raw;
     }
 
-    void NavigationMesh::deserialize(const std::vector<uint8_t>& raw)
+    void NavigationMesh::deserialize(const std::vector<uint8_t>& raw) noexcept
     {
         auto load_from_vector = [](const std::vector<uint8_t>& vec, size_t& offset, auto& value)
         {

source/projectile_prediction/proj_pred_engine.cpp

@@ -1,9 +0,0 @@
-//
-// Created by Vlad on 2/23/2025.
-//
-#include "omath/projectile_prediction/proj_pred_engine.hpp"
-
-namespace omath::projectile_prediction
-{
-
-} // namespace omath::projectile_prediction

source/projectile_prediction/proj_pred_engine_legacy.cpp

@@ -18,8 +18,8 @@ namespace omath::projectile_prediction
         {
             const auto predicted_target_position = target.predict_position(time, m_gravity_constant);
 
-            const auto projectile_pitch
-                    = maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
+            const auto projectile_pitch =
+                    maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
 
             if (!projectile_pitch.has_value()) [[unlikely]]
                 continue;
@@ -35,9 +35,8 @@ namespace omath::projectile_prediction
         return std::nullopt;
     }
 
-    std::optional<float>
-    ProjPredEngineLegacy::maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
-                                                                        const Vector3<float>& target_position) const
+    std::optional<float> ProjPredEngineLegacy::maybe_calculate_projectile_launch_pitch_angle(
+            const Projectile& projectile, const Vector3<float>& target_position) const noexcept
     {
         const auto bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
         const auto delta = target_position - projectile.m_origin;
@@ -60,7 +59,7 @@ namespace omath::projectile_prediction
 
     bool ProjPredEngineLegacy::is_projectile_reached_target(const Vector3<float>& target_position,
                                                             const Projectile& projectile, const float pitch,
-                                                            const float time) const
+                                                            const float time) const noexcept
     {
         const auto yaw = projectile.m_origin.view_angle_to(target_position).y;
         const auto projectile_position = projectile.predict_position(pitch, yaw, time, m_gravity_constant);

source/projectile_prediction/projectile.cpp

@@ -8,7 +8,7 @@
 namespace omath::projectile_prediction
 {
     Vector3<float> Projectile::predict_position(const float pitch, const float yaw, const float time,
-                                                const float gravity) const
+                                                const float gravity) const noexcept
     {
         auto current_pos = m_origin
                            + source_engine::forward_vector({source_engine::PitchAngle::from_degrees(-pitch),

source/projectile_prediction/target.cpp

@@ -1,10 +0,0 @@
-//
-// Created by Vlad on 6/9/2024.
-//
-
-#include "omath/projectile_prediction/projectile.hpp"
-
-namespace omath::prediction
-{
-
-}

source/projection/camera.cpp

@@ -1,8 +0,0 @@
-//
-// Created by Vlad on 27.08.2024.
-//
-#include "omath/projection/camera.hpp"
-
-namespace omath::projection
-{
-}