fixed style

orange-cpp · orange-cpp · commit b5e788385d67 · 2025-05-03T20:38:58.000+03:00
diff --git a/include/omath/angles.hpp b/include/omath/angles.hpp
@@ -12,23 +12,23 @@ namespace omath::angles
     requires std::is_floating_point_v<Type>
     [[nodiscard]] constexpr Type radians_to_degrees(const Type& radians)
     {
-        return radians * (Type(180) / std::numbers::pi_v<Type>);
+        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)
     {
-        return degrees * (std::numbers::pi_v<Type> / Type(180));
+        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)
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect)
     {
         const auto fov_rad = degrees_to_radians(horizontal_fov);
 
-        const auto vert_fov = type(2) * std::atan(std::tan(fov_rad / type(2)) / aspect);
+        const auto vert_fov = static_cast<Type>(2) * std::atan(std::tan(fov_rad / static_cast<Type>(2)) / aspect);
 
         return radians_to_degrees(vert_fov);
     }
@@ -39,7 +39,8 @@ namespace omath::angles
     {
         const auto fov_as_radians = degrees_to_radians(vertical_fov);
 
-        const auto horizontal_fov = Type(2) * std::atan(std::tan(fov_as_radians / 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);
     }
@@ -53,11 +54,11 @@ namespace omath::angles
 
         const Type range = max - min;
 
-        Type wrappedAngle = std::fmod(angle - min, range);
+        Type wrapped_angle = std::fmod(angle - min, range);
 
-        if (wrappedAngle < 0)
-            wrappedAngle += range;
+        if (wrapped_angle < 0)
+            wrapped_angle += range;
 
-        return wrappedAngle + min;
+        return wrapped_angle + min;
     }
 } // namespace omath::angles
diff --git a/include/omath/mat.hpp b/include/omath/mat.hpp
@@ -226,7 +226,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept
+        constexpr Mat<Columns, Rows, Type, StoreType> transposed() const noexcept
         {
             Mat<Columns, Rows, Type, StoreType> transposed;
             for (size_t i = 0; i < Rows; ++i)
@@ -237,7 +237,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Type Determinant() const
+        constexpr Type determinant() const
         {
             static_assert(Rows == Columns, "Determinant is only defined for square matrices.");
 
@@ -284,7 +284,7 @@ namespace omath
         [[nodiscard]]
         constexpr Type minor(const size_t row, const size_t column) const
         {
-            return strip(row, column).Determinant();
+            return strip(row, column).determinant();
         }
 
         [[nodiscard]]
@@ -355,17 +355,17 @@ namespace omath
         [[nodiscard]]
         constexpr std::optional<Mat> inverted() const
         {
-            const auto det = Determinant();
+            const auto det = determinant();
 
             if (det == 0)
                 return std::nullopt;
 
-            const auto transposed = Transposed();
+            const auto transposed_mat = transposed();
             Mat result;
 
             for (std::size_t row = 0; row < Rows; row++)
                 for (std::size_t column = 0; column < Rows; column++)
-                    result.at(row, column) = transposed.alg_complement(row, column);
+                    result.at(row, column) = transposed_mat.alg_complement(row, column);
 
             result /= det;
 
diff --git a/include/omath/pathfinding/a_star.hpp b/include/omath/pathfinding/a_star.hpp
@@ -25,6 +25,6 @@ namespace omath::pathfinding
 
         [[nodiscard]]
         static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
-                                     const Vector3<float>& endVertex);
+                                     const Vector3<float>& end_vertex);
     };
 } // namespace omath::pathfinding
diff --git a/include/omath/projection/camera.hpp b/include/omath/projection/camera.hpp
@@ -19,7 +19,7 @@ namespace omath::projection
         float m_width;
         float m_height;
 
-        [[nodiscard]] constexpr float AspectRatio() const
+        [[nodiscard]] constexpr float aspect_ratio() const
         {
             return m_width / m_height;
         }
diff --git a/source/collision/line_tracer.cpp b/source/collision/line_tracer.cpp
@@ -42,6 +42,7 @@ namespace omath::collision
             return ray.end;
 
         const auto q = t.cross(side_a);
+        // ReSharper disable once CppTooWideScopeInitStatement
         const auto v = ray_dir.dot(q) * inv_det;
 
         if ((v < 0 && std::abs(v) > k_epsilon) || (u + v > 1 && std::abs(u + v - 1) > k_epsilon))
diff --git a/source/engines/iw_engine/camera.cpp b/source/engines/iw_engine/camera.cpp
@@ -27,7 +27,7 @@ namespace omath::iw_engine
     }
     Mat4X4 Camera::calc_projection_matrix() const
     {
-        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.AspectRatio(),
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
                                                   m_near_plane_distance, m_far_plane_distance);
     }
 } // namespace omath::iw_engine
diff --git a/source/engines/opengl_engine/camera.cpp b/source/engines/opengl_engine/camera.cpp
@@ -27,7 +27,7 @@ namespace omath::opengl_engine
     }
     Mat4X4 Camera::calc_projection_matrix() const
     {
-        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.AspectRatio(),
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
                                                   m_near_plane_distance, m_far_plane_distance);
     }
 } // namespace omath::opengl_engine
diff --git a/source/engines/source_engine/camera.cpp b/source/engines/source_engine/camera.cpp
@@ -29,7 +29,7 @@ namespace omath::source_engine
 
     Mat4X4 Camera::calc_projection_matrix() const
     {
-        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.AspectRatio(),
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
                                                   m_near_plane_distance, m_far_plane_distance);
     }
 } // namespace omath::source_engine
diff --git a/source/engines/unity_engine/camera.cpp b/source/engines/unity_engine/camera.cpp
@@ -21,7 +21,7 @@ namespace omath::unity_engine
     }
     Mat4X4 Camera::calc_projection_matrix() const
     {
-        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.AspectRatio(),
+        return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
                                                   m_near_plane_distance, m_far_plane_distance);
     }
 } // namespace omath::unity_engine
diff --git a/source/pathfinding/a_star.cpp b/source/pathfinding/a_star.cpp
@@ -38,13 +38,13 @@ namespace omath::pathfinding
         return path;
     }
     auto Astar::get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
-                                 const Vector3<float>& endVertex)
+                                 const Vector3<float>& end_vertex)
     {
         return std::ranges::min_element(open_list,
-                                        [&endVertex](const auto& a, const auto& b)
+                                        [&end_vertex](const auto& a, const auto& b)
                                         {
-                                            const float fa = a.second.g_cost + a.first.distance_to(endVertex);
-                                            const float fb = b.second.g_cost + b.first.distance_to(endVertex);
+                                            const float fa = a.second.g_cost + a.first.distance_to(end_vertex);
+                                            const float fb = b.second.g_cost + b.first.distance_to(end_vertex);
                                             return fa < fb;
                                         });
     }
@@ -86,6 +86,7 @@ namespace omath::pathfinding
 
                 const float tentative_g_cost = current_node.g_cost + neighbor.distance_to(current);
 
+                // ReSharper disable once CppTooWideScopeInitStatement
                 const auto open_it = open_list.find(neighbor);
 
                 if (open_it == open_list.end() || tentative_g_cost < open_it->second.g_cost)
diff --git a/tests/general/unit_test_mat.cpp b/tests/general/unit_test_mat.cpp
@@ -96,7 +96,7 @@ TEST_F(UnitTestMat, Operator_Division_Scalar)
 // Test matrix functions
 TEST_F(UnitTestMat, Transpose)
 {
-    Mat<2, 2> m3 = m2.Transposed();
+    Mat<2, 2> m3 = m2.transposed();
     EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
     EXPECT_FLOAT_EQ(m3.at(0, 1), m2.at(1, 0));
     EXPECT_FLOAT_EQ(m3.at(1, 0), m2.at(0, 1));
@@ -105,7 +105,7 @@ TEST_F(UnitTestMat, Transpose)
 
 TEST_F(UnitTestMat, Determinant)
 {
-    const float det = m2.Determinant();
+    const float det = m2.determinant();
     EXPECT_FLOAT_EQ(det, -2.0f);
 }
 
@@ -175,7 +175,7 @@ TEST_F(UnitTestMat, Method_At_OutOfRange)
 // Test Determinant for 3x3 matrix
 TEST(UnitTestMatStandalone, Determinant_3x3)
 {
-    constexpr auto det = Mat<3, 3>{{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}.Determinant();
+    constexpr auto det = Mat<3, 3>{{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}.determinant();
     EXPECT_FLOAT_EQ(det, -306.0f);
 }
 
@@ -196,7 +196,7 @@ TEST(UnitTestMatStandalone, Strip_3x3)
 TEST(UnitTestMatStandalone, Transpose_NonSquare)
 {
     constexpr Mat<2, 3> m{{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f, 6.0f}};
-    auto transposed = m.Transposed();
+    auto transposed = m.transposed();
     EXPECT_EQ(transposed.row_count(), 3);
     EXPECT_EQ(transposed.columns_count(), 2);
     EXPECT_FLOAT_EQ(transposed.at(0, 0), 1.0f);

Original file line number	Diff line number	Diff line change
`@@ -12,23 +12,23 @@ namespace omath::angles`
`12`	`12`	`requires std::is_floating_point_v<Type>`
`13`	`13`	`[[nodiscard]] constexpr Type radians_to_degrees(const Type& radians)`
`14`	`14`	`{`
`15`		`- return radians * (Type(180) / std::numbers::pi_v<Type>);`
	`15`	`+ return radians * (static_cast<Type>(180) / std::numbers::pi_v<Type>);`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`template<class Type>`
`19`	`19`	`requires std::is_floating_point_v<Type>`
`20`	`20`	`[[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees)`
`21`	`21`	`{`
`22`		`- return degrees * (std::numbers::pi_v<Type> / Type(180));`
	`22`	`+ return degrees * (std::numbers::pi_v<Type> / static_cast<Type>(180));`
`23`	`23`	`}`
`24`	`24`
`25`		`- template<class type>`
`26`		`- requires std::is_floating_point_v<type>`
`27`		`- [[nodiscard]] type horizontal_fov_to_vertical(const type& horizontal_fov, const type& aspect)`
	`25`	`+ template<class Type>`
	`26`	`+ requires std::is_floating_point_v<Type>`
	`27`	`+ [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect)`
`28`	`28`	`{`
`29`	`29`	`const auto fov_rad = degrees_to_radians(horizontal_fov);`
`30`	`30`
`31`		`- const auto vert_fov = type(2) * std::atan(std::tan(fov_rad / type(2)) / aspect);`
	`31`	`+ const auto vert_fov = static_cast<Type>(2) * std::atan(std::tan(fov_rad / static_cast<Type>(2)) / aspect);`
`32`	`32`
`33`	`33`	`return radians_to_degrees(vert_fov);`
`34`	`34`	`}`
`@@ -39,7 +39,8 @@ namespace omath::angles`
`39`	`39`	`{`
`40`	`40`	`const auto fov_as_radians = degrees_to_radians(vertical_fov);`
`41`	`41`
`42`		`- const auto horizontal_fov = Type(2) * std::atan(std::tan(fov_as_radians / Type(2)) * aspect);`
	`42`	`+ const auto horizontal_fov`
	`43`	`+ = static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);`
`43`	`44`
`44`	`45`	`return radians_to_degrees(horizontal_fov);`
`45`	`46`	`}`
`@@ -53,11 +54,11 @@ namespace omath::angles`
`53`	`54`
`54`	`55`	`const Type range = max - min;`
`55`	`56`
`56`		`- Type wrappedAngle = std::fmod(angle - min, range);`
	`57`	`+ Type wrapped_angle = std::fmod(angle - min, range);`
`57`	`58`
`58`		`- if (wrappedAngle < 0)`
`59`		`- wrappedAngle += range;`
	`59`	`+ if (wrapped_angle < 0)`
	`60`	`+ wrapped_angle += range;`
`60`	`61`
`61`		`- return wrappedAngle + min;`
	`62`	`+ return wrapped_angle + min;`
`62`	`63`	`}`
`63`	`64`	`} // namespace omath::angles`
Original file line number	Diff line number	Diff line change
`@@ -226,7 +226,7 @@ namespace omath`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`[[nodiscard]]`
`229`		`- constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept`
	`229`	`+ constexpr Mat<Columns, Rows, Type, StoreType> transposed() const noexcept`
`230`	`230`	`{`
`231`	`231`	`Mat<Columns, Rows, Type, StoreType> transposed;`
`232`	`232`	`for (size_t i = 0; i < Rows; ++i)`
`@@ -237,7 +237,7 @@ namespace omath`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`[[nodiscard]]`
`240`		`- constexpr Type Determinant() const`
	`240`	`+ constexpr Type determinant() const`
`241`	`241`	`{`
`242`	`242`	`static_assert(Rows == Columns, "Determinant is only defined for square matrices.");`
`243`	`243`
`@@ -284,7 +284,7 @@ namespace omath`
`284`	`284`	`[[nodiscard]]`
`285`	`285`	`constexpr Type minor(const size_t row, const size_t column) const`
`286`	`286`	`{`
`287`		`- return strip(row, column).Determinant();`
	`287`	`+ return strip(row, column).determinant();`
`288`	`288`	`}`
`289`	`289`
`290`	`290`	`[[nodiscard]]`
`@@ -355,17 +355,17 @@ namespace omath`
`355`	`355`	`[[nodiscard]]`
`356`	`356`	`constexpr std::optional<Mat> inverted() const`
`357`	`357`	`{`
`358`		`- const auto det = Determinant();`
	`358`	`+ const auto det = determinant();`
`359`	`359`
`360`	`360`	`if (det == 0)`
`361`	`361`	`return std::nullopt;`
`362`	`362`
`363`		`- const auto transposed = Transposed();`
	`363`	`+ const auto transposed_mat = transposed();`
`364`	`364`	`Mat result;`
`365`	`365`
`366`	`366`	`for (std::size_t row = 0; row < Rows; row++)`
`367`	`367`	`for (std::size_t column = 0; column < Rows; column++)`
`368`		`- result.at(row, column) = transposed.alg_complement(row, column);`
	`368`	`+ result.at(row, column) = transposed_mat.alg_complement(row, column);`
`369`	`369`
`370`	`370`	`result /= det;`
`371`	`371`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ namespace omath::projection`
`19`	`19`	`float m_width;`
`20`	`20`	`float m_height;`
`21`	`21`
`22`		`- [[nodiscard]] constexpr float AspectRatio() const`
	`22`	`+ [[nodiscard]] constexpr float aspect_ratio() const`
`23`	`23`	`{`
`24`	`24`	`return m_width / m_height;`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ namespace omath::iw_engine`
`27`	`27`	`}`
`28`	`28`	`Mat4X4 Camera::calc_projection_matrix() const`
`29`	`29`	`{`
`30`		`- return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.AspectRatio(),`
	`30`	`+ return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),`
`31`	`31`	`m_near_plane_distance, m_far_plane_distance);`
`32`	`32`	`}`
`33`	`33`	`} // namespace omath::iw_engine`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ namespace omath::opengl_engine`
`27`	`27`	`}`
`28`	`28`	`Mat4X4 Camera::calc_projection_matrix() const`
`29`	`29`	`{`
`30`		`- return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.AspectRatio(),`
	`30`	`+ return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),`
`31`	`31`	`m_near_plane_distance, m_far_plane_distance);`
`32`	`32`	`}`
`33`	`33`	`} // namespace omath::opengl_engine`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ namespace omath::source_engine`
`29`	`29`
`30`	`30`	`Mat4X4 Camera::calc_projection_matrix() const`
`31`	`31`	`{`
`32`		`- return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.AspectRatio(),`
	`32`	`+ return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),`
`33`	`33`	`m_near_plane_distance, m_far_plane_distance);`
`34`	`34`	`}`
`35`	`35`	`} // namespace omath::source_engine`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ namespace omath::unity_engine`
`21`	`21`	`}`
`22`	`22`	`Mat4X4 Camera::calc_projection_matrix() const`
`23`	`23`	`{`
`24`		`- return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.AspectRatio(),`
	`24`	`+ return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),`
`25`	`25`	`m_near_plane_distance, m_far_plane_distance);`
`26`	`26`	`}`
`27`	`27`	`} // namespace omath::unity_engine`
Original file line number	Diff line number	Diff line change
`@@ -38,13 +38,13 @@ namespace omath::pathfinding`
`38`	`38`	`return path;`
`39`	`39`	`}`
`40`	`40`	`auto Astar::get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,`
`41`		`- const Vector3<float>& endVertex)`
	`41`	`+ const Vector3<float>& end_vertex)`
`42`	`42`	`{`
`43`	`43`	`return std::ranges::min_element(open_list,`
`44`		`- [&endVertex](const auto& a, const auto& b)`
	`44`	`+ [&end_vertex](const auto& a, const auto& b)`
`45`	`45`	`{`
`46`		`- const float fa = a.second.g_cost + a.first.distance_to(endVertex);`
`47`		`- const float fb = b.second.g_cost + b.first.distance_to(endVertex);`
	`46`	`+ const float fa = a.second.g_cost + a.first.distance_to(end_vertex);`
	`47`	`+ const float fb = b.second.g_cost + b.first.distance_to(end_vertex);`
`48`	`48`	`return fa < fb;`
`49`	`49`	`});`
`50`	`50`	`}`
`@@ -86,6 +86,7 @@ namespace omath::pathfinding`
`86`	`86`
`87`	`87`	`const float tentative_g_cost = current_node.g_cost + neighbor.distance_to(current);`
`88`	`88`
	`89`	`+ // ReSharper disable once CppTooWideScopeInitStatement`
`89`	`90`	`const auto open_it = open_list.find(neighbor);`
`90`	`91`
`91`	`92`	`if (open_it == open_list.end() \|\| tentative_g_cost < open_it->second.g_cost)`