From 00e7c564fd5c72d44a6db887c2faa3e00e2ba8e3 Mon Sep 17 00:00:00 2001 From: Orange Date: Thu, 11 Jun 2026 16:18:42 +0300 Subject: [PATCH 01/20] added gcem --- CMakeLists.txt | 10 +++++++++ CMakePresets.json | 2 +- .../internal/optional_constexpr_math.hpp | 12 ++++++++++ include/omath/trigonometry/angle.hpp | 22 ++++++++++++++++--- vcpkg.json | 7 ++++++ 5 files changed, 49 insertions(+), 4 deletions(-) create mode 100644 include/omath/internal/optional_constexpr_math.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index fd24fcd..8da5a63 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,6 +33,7 @@ option(OMATH_ENABLE_FORCE_INLINE option(OMATH_ENABLE_LUA "omath bindings for lua" OFF) option(OMATH_ENABLE_HOOKING "omath will HooksManager that can hook DirectX/OpenGL automatically" OFF) +option(OMATH_USE_GCEM "omath will use gcem library to make more functions/methods constexpr" OFF) if(VCPKG_MANIFEST_FEATURES) foreach(omath_feature IN LISTS VCPKG_MANIFEST_FEATURES) @@ -50,6 +51,8 @@ if(VCPKG_MANIFEST_FEATURES) set(OMATH_ENABLE_LUA ON) elseif(omath_feature STREQUAL "hooking") set(OMATH_ENABLE_HOOKING ON) + elseif (omath_feature STREQUAL "gcem") + set(OMATH_USE_GCEM ON) endif() endforeach() @@ -80,6 +83,7 @@ if(${PROJECT_IS_TOP_LEVEL}) message(STATUS "[${PROJECT_NAME}]: Coverage feature status ${OMATH_ENABLE_COVERAGE}") message(STATUS "[${PROJECT_NAME}]: Valgrind feature status ${OMATH_ENABLE_VALGRIND}") message(STATUS "[${PROJECT_NAME}]: Lua feature status ${OMATH_ENABLE_LUA}") + message(STATUS "[${PROJECT_NAME}]: Gcem feature status ${OMATH_USE_GCEM}") endif() if(OMATH_STATIC_MSVC_RUNTIME_LIBRARY) @@ -120,6 +124,12 @@ if (OMATH_ENABLE_HOOKING) endif () endif () + +if (OMATH_USE_GCEM) + target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_USE_GCEM) + find_package(gcem CONFIG REQUIRED) + target_link_libraries(${PROJECT_NAME} PUBLIC gcem) +endif () add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME}) target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}") diff --git a/CMakePresets.json b/CMakePresets.json index 2ed29f2..f067ed3 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -57,7 +57,7 @@ "inherits": ["windows-base", "vcpkg-base"], "cacheVariables": { "VCPKG_TARGET_TRIPLET": "x64-windows-static", - "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;hooking", + "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;hooking;gcem", "OMATH_STATIC_MSVC_RUNTIME_LIBRARY": "ON" } }, diff --git a/include/omath/internal/optional_constexpr_math.hpp b/include/omath/internal/optional_constexpr_math.hpp new file mode 100644 index 0000000..ecc49dd --- /dev/null +++ b/include/omath/internal/optional_constexpr_math.hpp @@ -0,0 +1,12 @@ +// +// Created by orange on 6/11/2026. +// +#pragma once + + +#ifdef OMATH_USE_GCEM +#include +#define OMATH_CONSTEXPR constexpr +#else +#define OMATH_CONSTEXPR +#endif \ No newline at end of file diff --git a/include/omath/trigonometry/angle.hpp b/include/omath/trigonometry/angle.hpp index 4506e0c..7b687ee 100644 --- a/include/omath/trigonometry/angle.hpp +++ b/include/omath/trigonometry/angle.hpp @@ -7,6 +7,7 @@ #include #include #include +#include "omath/internal/optional_constexpr_math.hpp" namespace omath { @@ -70,21 +71,36 @@ namespace omath } [[nodiscard]] - Type sin() const noexcept + OMATH_CONSTEXPR Type sin() const noexcept { +#ifdef OMATH_USE_GCEM + return gcem::sin(as_radians()); +#else return std::sin(as_radians()); + +#endif } [[nodiscard]] - Type cos() const noexcept + OMATH_CONSTEXPR Type cos() const noexcept { +#ifdef OMATH_USE_GCEM + return gcem::cos(as_radians()); +#else return std::cos(as_radians()); + +#endif } [[nodiscard]] - Type tan() const noexcept + OMATH_CONSTEXPR Type tan() const noexcept { +#ifdef OMATH_USE_GCEM + return gcem::tan(as_radians()); +#else return std::tan(as_radians()); + +#endif } [[nodiscard]] diff --git a/vcpkg.json b/vcpkg.json index 27e3bef..5b68917 100644 --- a/vcpkg.json +++ b/vcpkg.json @@ -82,6 +82,13 @@ "lua", "sol2" ] + }, + "gcem": + { + "description": "Improve constexpr compatibility using gcem", + "dependencies": [ + "gcem" + ] } } } From a2be99be50ed9a5223ef3610a49b5858f2dcce03 Mon Sep 17 00:00:00 2001 From: Orange Date: Thu, 11 Jun 2026 23:20:18 +0300 Subject: [PATCH 02/20] added more gcem to angle vec2,3 --- CMakePresets.json | 2 +- include/omath/linear_algebra/vector2.hpp | 27 ++++++++++---- include/omath/linear_algebra/vector3.hpp | 46 +++++++++++++++--------- include/omath/trigonometry/angle.hpp | 11 ++++-- tests/general/unit_test_vector2.cpp | 9 +++-- tests/general/unit_test_vector3.cpp | 43 +++++++++++++--------- 6 files changed, 92 insertions(+), 46 deletions(-) diff --git a/CMakePresets.json b/CMakePresets.json index f067ed3..8780fa2 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -239,7 +239,7 @@ "hidden": true, "inherits": ["darwin-base", "vcpkg-base"], "cacheVariables": { - "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;lua" + "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;lua;gcem" } }, { diff --git a/include/omath/linear_algebra/vector2.hpp b/include/omath/linear_algebra/vector2.hpp index e283d51..74ef70b 100644 --- a/include/omath/linear_algebra/vector2.hpp +++ b/include/omath/linear_algebra/vector2.hpp @@ -3,6 +3,7 @@ // #pragma once +#include "omath/internal/optional_constexpr_math.hpp" #include #include #include @@ -116,9 +117,13 @@ namespace omath // Basic vector operations [[nodiscard("You must use distance")]] - Type distance_to(const Vector2& other) const noexcept + OMATH_CONSTEXPR Type distance_to(const Vector2& other) const noexcept { +#ifdef OMATH_USE_GCEM + return gcem::sqrt(distance_to_sqr(other)); +#else return std::sqrt(distance_to_sqr(other)); +#endif } [[nodiscard("You must use squared distance")]] @@ -136,7 +141,11 @@ namespace omath #ifndef _MSC_VER [[nodiscard("You must use length")]] constexpr Type length() const noexcept { +#ifdef OMATH_USE_GCEM + return gcem::hypot(this->x, this->y); +#else return std::hypot(this->x, this->y); +#endif } [[nodiscard("You must use normalized vector")]] constexpr Vector2 normalized() const noexcept @@ -146,13 +155,17 @@ namespace omath } #else [[nodiscard("You must use length")]] - Type length() const noexcept + OMATH_CONSTEXPR Type length() const noexcept { +#ifdef OMATH_USE_GCEM + return gcem::hypot(x, y); +#else return std::hypot(x, y); +#endif } [[nodiscard("You must use normalized vector")]] - Vector2 normalized() const noexcept + OMATH_CONSTEXPR Vector2 normalized() const noexcept { const Type len = length(); return len > static_cast(0) ? *this / len : *this; @@ -216,24 +229,24 @@ namespace omath } [[nodiscard("You must use comparison result")]] - bool operator<(const Vector2& other) const noexcept + OMATH_CONSTEXPR bool operator<(const Vector2& other) const noexcept { return length() < other.length(); } [[nodiscard("You must use comparison result")]] - bool operator>(const Vector2& other) const noexcept + OMATH_CONSTEXPR bool operator>(const Vector2& other) const noexcept { return length() > other.length(); } [[nodiscard("You must use comparison result")]] - bool operator<=(const Vector2& other) const noexcept + OMATH_CONSTEXPR bool operator<=(const Vector2& other) const noexcept { return length() <= other.length(); } [[nodiscard("You must use comparison result")]] - bool operator>=(const Vector2& other) const noexcept + OMATH_CONSTEXPR bool operator>=(const Vector2& other) const noexcept { return length() >= other.length(); } diff --git a/include/omath/linear_algebra/vector3.hpp b/include/omath/linear_algebra/vector3.hpp index 6dac417..405c8f3 100644 --- a/include/omath/linear_algebra/vector3.hpp +++ b/include/omath/linear_algebra/vector3.hpp @@ -140,20 +140,24 @@ namespace omath } #ifndef _MSC_VER - [[nodiscard("You must use length")]] constexpr Type length() const + [[nodiscard("You must use length")]] constexpr Type length() const noexcept { +#ifdef OMATH_USE_GCEM + return gcem::sqrt(this->x * this->x + this->y * this->y + z * z); +#else return std::hypot(this->x, this->y, z); +#endif } - [[nodiscard("You must use 2D length")]] constexpr Type length_2d() const + [[nodiscard("You must use 2D length")]] constexpr Type length_2d() const noexcept { return Vector2::length(); } - [[nodiscard("You must use distance")]] Type distance_to(const Vector3& other) const + [[nodiscard("You must use distance")]] OMATH_CONSTEXPR Type distance_to(const Vector3& other) const noexcept { return (*this - other).length(); } - [[nodiscard("You must use normalized vector")]] constexpr Vector3 normalized() const + [[nodiscard("You must use normalized vector")]] constexpr Vector3 normalized() const noexcept { const Type length_value = this->length(); @@ -161,13 +165,17 @@ namespace omath } #else [[nodiscard("You must use length")]] - Type length() const noexcept + OMATH_CONSTEXPR Type length() const noexcept { +#ifdef OMATH_USE_GCEM + return gcem::sqrt(this->x * this->x + this->y * this->y + this->z * this->z); +#else return std::hypot(this->x, this->y, z); +#endif } [[nodiscard("You must use normalized vector")]] - Vector3 normalized() const noexcept + OMATH_CONSTEXPR Vector3 normalized() const noexcept { const Type len = this->length(); @@ -175,13 +183,13 @@ namespace omath } [[nodiscard("You must use 2D length")]] - Type length_2d() const noexcept + OMATH_CONSTEXPR Type length_2d() const noexcept { return Vector2::length(); } [[nodiscard("You must use distance")]] - Type distance_to(const Vector3& v_other) const noexcept + OMATH_CONSTEXPR Type distance_to(const Vector3& v_other) const noexcept { return (*this - v_other).length(); } @@ -249,24 +257,28 @@ namespace omath } [[nodiscard("You must use direction check result")]] - bool point_to_same_direction(const Vector3& other) const + OMATH_CONSTEXPR bool point_to_same_direction(const Vector3& other) const { return dot(other) > static_cast(0); } [[nodiscard("You must use angle between vectors")]] - std::expected, Vector3Error> + OMATH_CONSTEXPR std::expected, Vector3Error> angle_between(const Vector3& other) const noexcept { const auto bottom = length() * other.length(); if (bottom == static_cast(0)) return std::unexpected(Vector3Error::IMPOSSIBLE_BETWEEN_ANGLE); - +#ifdef OMATH_USE_GCEM + return Angle::from_radians(gcem::acos(dot(other) / bottom)); +#else return Angle::from_radians(std::acos(dot(other) / bottom)); +#endif } [[nodiscard("You must use perpendicularity check result")]] - bool is_perpendicular(const Vector3& other, Type epsilon = static_cast(0.0001)) const noexcept + OMATH_CONSTEXPR bool is_perpendicular(const Vector3& other, + Type epsilon = static_cast(0.0001)) const noexcept { if (const auto angle = angle_between(other)) return std::abs(angle->as_degrees() - static_cast(90)) <= epsilon; @@ -287,25 +299,25 @@ namespace omath } [[nodiscard("You must use comparison result")]] - bool operator<(const Vector3& other) const noexcept + OMATH_CONSTEXPR bool operator<(const Vector3& other) const noexcept { return length() < other.length(); } [[nodiscard("You must use comparison result")]] - bool operator>(const Vector3& other) const noexcept + OMATH_CONSTEXPR bool operator>(const Vector3& other) const noexcept { return length() > other.length(); } [[nodiscard("You must use comparison result")]] - bool operator<=(const Vector3& other) const noexcept + OMATH_CONSTEXPR bool operator<=(const Vector3& other) const noexcept { return length() <= other.length(); } [[nodiscard("You must use comparison result")]] - bool operator>=(const Vector3& other) const noexcept + OMATH_CONSTEXPR bool operator>=(const Vector3& other) const noexcept { return length() >= other.length(); } @@ -321,7 +333,7 @@ namespace omath template<> struct std::hash> { [[nodiscard("You must use hash value")]] - std::size_t operator()(const omath::Vector3& vec) const noexcept + constexpr std::size_t operator()(const omath::Vector3& vec) const noexcept { std::size_t hash = 0; constexpr std::hash hasher; diff --git a/include/omath/trigonometry/angle.hpp b/include/omath/trigonometry/angle.hpp index 7b687ee..146a309 100644 --- a/include/omath/trigonometry/angle.hpp +++ b/include/omath/trigonometry/angle.hpp @@ -3,11 +3,11 @@ // #pragma once +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/trigonometry/angles.hpp" #include #include #include -#include "omath/internal/optional_constexpr_math.hpp" namespace omath { @@ -104,13 +104,18 @@ namespace omath } [[nodiscard]] - Type atan() const noexcept + OMATH_CONSTEXPR Type atan() const noexcept { +#ifdef OMATH_USE_GCEM + return gcem::atan(as_radians()); +#else return std::atan(as_radians()); + +#endif } [[nodiscard]] - Type cot() const noexcept + OMATH_CONSTEXPR Type cot() const noexcept { return cos() / sin(); } diff --git a/tests/general/unit_test_vector2.cpp b/tests/general/unit_test_vector2.cpp index 91d9e61..52f606c 100644 --- a/tests/general/unit_test_vector2.cpp +++ b/tests/general/unit_test_vector2.cpp @@ -2,10 +2,10 @@ // Created by Vlad on 02.09.2024. // -#include #include // For FLT_MAX and FLT_MIN #include // For std::isinf and std::isnan #include +#include using namespace omath; @@ -399,7 +399,6 @@ TEST_F(UnitTestVector2, GreaterEqualOperator) EXPECT_TRUE(omath::Vector2(1.f, 1.f) >= omath::Vector2{}); } - // ── Cast operator tests ────────────────────────────────────────────────────── TEST(Vector2Cast, FloatToDouble) @@ -463,3 +462,9 @@ static_assert(Vector2(1.0f, 2.0f).length_sqr() == 5.0f, "LengthSqr should be 5") static_assert(Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot product should be 14"); static_assert(Vector2(4.0f, 5.0f).distance_to_sqr(Vector2(1.0f, 2.0f)) == 18.0f, "DistToSqr should be 18"); static_assert(Vector2(-1.0f, -2.0f).abs() == Vector2(1.0f, 2.0f), "Abs should convert negative values to positive"); + +#ifdef OMATH_USE_GCEM +static_assert(Vector2(3.0f, 4.0f).length() == 5.0f, "Length should be constexpr with gcem"); +static_assert(Vector2(0.0f, 0.0f).distance_to(Vector2(3.0f, 4.0f)) == 5.0f, "Distance should be constexpr with gcem"); +static_assert(Vector2(1.0f, 1.0f) < Vector2(3.0f, 4.0f), "Comparison should be constexpr with gcem"); +#endif diff --git a/tests/general/unit_test_vector3.cpp b/tests/general/unit_test_vector3.cpp index 158f1c0..e9c2b75 100644 --- a/tests/general/unit_test_vector3.cpp +++ b/tests/general/unit_test_vector3.cpp @@ -2,11 +2,11 @@ // Created by Vlad on 01.09.2024. // -#include #include // For FLT_MAX, FLT_MIN #include #include #include // For std::numeric_limits +#include using namespace omath; @@ -31,35 +31,33 @@ TEST(Vector3More, ArithmeticAndDotCross) constexpr Vector3 a{1.f, 0.f, 0.f}; constexpr Vector3 b{0.f, 1.f, 0.f}; const auto c = a + b; - constexpr Vector3 expect_c{1.f,1.f,0.f}; + constexpr Vector3 expect_c{1.f, 1.f, 0.f}; EXPECT_EQ(c, expect_c); const auto d = a - b; - constexpr Vector3 expect_d{1.f,-1.f,0.f}; + constexpr Vector3 expect_d{1.f, -1.f, 0.f}; EXPECT_EQ(d, expect_d); const auto e = a * 2.f; - constexpr Vector3 expect_e{2.f,0.f,0.f}; + constexpr Vector3 expect_e{2.f, 0.f, 0.f}; EXPECT_EQ(e, expect_e); EXPECT_FLOAT_EQ(a.dot(b), 0.f); // manual cross product check - const auto cr = Vector3{ a.y * b.z - a.z * b.y, - a.z * b.x - a.x * b.z, - a.x * b.y - a.y * b.x }; - constexpr Vector3 expect_cr{0.f,0.f,1.f}; + const auto cr = Vector3{a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; + constexpr Vector3 expect_cr{0.f, 0.f, 1.f}; EXPECT_EQ(cr, expect_cr); } TEST(Vector3More, NormalizationEdgeCases) { - constexpr Vector3 z{0.0,0.0,0.0}; + constexpr Vector3 z{0.0, 0.0, 0.0}; const auto zn = z.normalized(); EXPECT_DOUBLE_EQ(zn.x, 0.0); EXPECT_DOUBLE_EQ(zn.y, 0.0); EXPECT_DOUBLE_EQ(zn.z, 0.0); - constexpr Vector3 v{3.0,4.0,0.0}; + constexpr Vector3 v{3.0, 4.0, 0.0}; const auto vn = v.normalized(); EXPECT_NEAR(vn.x, 0.6, 1e-12); EXPECT_NEAR(vn.y, 0.8, 1e-12); @@ -481,16 +479,14 @@ TEST_F(UnitTestVector3, AsTuple) // Test AsTuple method TEST_F(UnitTestVector3, AngleBeatween) { - EXPECT_NEAR(Vector3(0.0f, 0.0f, 1.0f).angle_between({1, 0, 0}).value().as_degrees(), - 90.0f, 0.001f); - EXPECT_NEAR(Vector3(0.0f, 0.0f, 1.0f).angle_between({0.0f, 0.0f, 1.0f}).value().as_degrees(), - 0.0f, 0.001f); + EXPECT_NEAR(Vector3(0.0f, 0.0f, 1.0f).angle_between({1, 0, 0}).value().as_degrees(), 90.0f, 0.001f); + EXPECT_NEAR(Vector3(0.0f, 0.0f, 1.0f).angle_between({0.0f, 0.0f, 1.0f}).value().as_degrees(), 0.0f, 0.001f); EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).angle_between({0.0f, 0.0f, 1.0f}).has_value()); } TEST_F(UnitTestVector3, IsPerpendicular) { - EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({1, 0 ,0}), true); + EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({1, 0, 0}), true); EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({0.0f, 0.0f, 1.0f}), false); EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).is_perpendicular({0.0f, 0.0f, 1.0f})); } @@ -585,4 +581,19 @@ TEST(Vector3Cast, SameTypeRoundtrip) static_assert(Vector3(1.0f, 2.0f, 3.0f).length_sqr() == 14.0f, "LengthSqr should be 14"); static_assert(Vector3(1.0f, 2.0f, 3.0f).dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32"); static_assert(Vector3(4.0f, 5.0f, 6.0f).distance_to_sqr(Vector3(1.0f, 2.0f, 3.0f)) == 27.0f, "DistToSqr should be 27"); -static_assert(Vector3(-1.0f, -2.0f, -3.0f).abs() == Vector3(1.0f, 2.0f, 3.0f), "Abs should convert negative values to positive"); +static_assert(Vector3(-1.0f, -2.0f, -3.0f).abs() == Vector3(1.0f, 2.0f, 3.0f), + "Abs should convert negative values to positive"); + +#ifdef OMATH_USE_GCEM +static_assert(Vector3(1.0f, 2.0f, 2.0f).length() == 3.0f, "Length should be constexpr with gcem"); +static_assert(Vector3(0.0f, 0.0f, 0.0f).distance_to(Vector3(1.0f, 2.0f, 2.0f)) == 3.0f, + "Distance should be constexpr with gcem"); +static_assert(Vector3(1.0f, 1.0f, 1.0f) < Vector3(3.0f, 4.0f, 5.0f), "Comparison should be constexpr with gcem"); +static_assert( + [] + { + constexpr auto angle = Vector3(1.0f, 0.0f, 0.0f).angle_between(Vector3(0.0f, 1.0f, 0.0f)); + return angle.has_value() && angle->as_degrees() > 89.999f && angle->as_degrees() < 90.001f; + }(), + "Angle between should be constexpr with gcem"); +#endif From a741fc14852e58f8a4c57a0c0df8e3bb64e65a9a Mon Sep 17 00:00:00 2001 From: Orange Date: Thu, 11 Jun 2026 23:41:07 +0300 Subject: [PATCH 03/20] now add constexpr gcem tests for triangle and mat classes --- include/omath/linear_algebra/mat.hpp | 21 +++++++++++++++++++-- include/omath/linear_algebra/triangle.hpp | 6 +++--- tests/general/unit_test_angle.cpp | 18 +++++++++++++++++- 3 files changed, 39 insertions(+), 6 deletions(-) diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index 2cbf078..a3ee0ee 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -622,10 +622,14 @@ namespace omath template [[nodiscard("You must use extracted scale")]] - Vector3 mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept + OMATH_CONSTEXPR Vector3 mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept { auto column_length = [](const Type x, const Type y, const Type z) { +#ifdef OMATH_CONSTEXPR + return static_cast(gcem::sqrt(x * x + y * y + z * z)); +#else return static_cast(std::sqrt(x * x + y * y + z * z)); +#endif }; const auto scale_x = column_length(mat.at(0, 0), mat.at(1, 0), mat.at(2, 0)); @@ -635,9 +639,16 @@ namespace omath constexpr auto epsilon = std::numeric_limits::epsilon(); return { +#ifdef OMATH_CONSTEXPR + gcem::abs(scale_x) < epsilon ? Type{1} : scale_x, + gcem::abs(scale_y) < epsilon ? Type{1} : scale_y, + gcem::abs(scale_z) < epsilon ? Type{1} : scale_z, +#else std::abs(scale_x) < epsilon ? Type{1} : scale_x, std::abs(scale_y) < epsilon ? Type{1} : scale_y, std::abs(scale_z) < epsilon ? Type{1} : scale_z, +#endif + }; } @@ -654,9 +665,15 @@ namespace omath const auto m22 = mat.at(2, 2) / scale.z; return { - angles::radians_to_degrees(std::atan2(m21, m22)), +#ifdef OMATH_CONSTEXPR + angles::radians_to_degrees(gcem::atan2(m21, m22)), + angles::radians_to_degrees(gcem::asin(std::clamp(-m20, Type{-1}, Type{1}))), + angles::radians_to_degrees(gcem::atan2(m10, m00)), +#else + angles::radians_to_degrees(gc::atan2(m21, m22)), angles::radians_to_degrees(std::asin(std::clamp(-m20, Type{-1}, Type{1}))), angles::radians_to_degrees(std::atan2(m10, m00)), +#endif }; } diff --git a/include/omath/linear_algebra/triangle.hpp b/include/omath/linear_algebra/triangle.hpp index 1d8e68c..a62f888 100644 --- a/include/omath/linear_algebra/triangle.hpp +++ b/include/omath/linear_algebra/triangle.hpp @@ -3,7 +3,7 @@ // #pragma once #include "vector3.hpp" - +#include "omath/internal/optional_constexpr_math.hpp" namespace omath { /* @@ -40,13 +40,13 @@ namespace omath } [[nodiscard]] - Vector::ContainedType side_a_length() const + OMATH_CONSTEXPR Vector::ContainedType side_a_length() const { return m_vertex1.distance_to(m_vertex2); } [[nodiscard]] - Vector::ContainedType side_b_length() const + OMATH_CONSTEXPR Vector::ContainedType side_b_length() const { return m_vertex3.distance_to(m_vertex2); } diff --git a/tests/general/unit_test_angle.cpp b/tests/general/unit_test_angle.cpp index d1fc410..ad17e65 100644 --- a/tests/general/unit_test_angle.cpp +++ b/tests/general/unit_test_angle.cpp @@ -2,10 +2,10 @@ // Created by Orange on 11/30/2024. // -#include #include #include #include +#include using namespace omath; @@ -19,6 +19,14 @@ namespace constexpr float k_eps = 1e-5f; +#ifdef OMATH_USE_GCEM + constexpr bool close_to(const float actual, const float expected, const float epsilon) + { + const float diff = actual - expected; + return (diff < 0.0f ? -diff : diff) <= epsilon; + } +#endif + } // namespace // ---------- Construction / factories ---------- @@ -190,3 +198,11 @@ TEST(UnitTestAngle, BinaryMinus_ReturnsWrappedDiff) const Deg c = a - b; // expect 340° EXPECT_FLOAT_EQ(c.as_degrees(), 340.0f); } + +#ifdef OMATH_USE_GCEM +static_assert(close_to(Pitch::from_degrees(0.0f).sin(), 0.0f, k_eps), "Sin should be constexpr with gcem"); +static_assert(close_to(Pitch::from_degrees(0.0f).cos(), 1.0f, k_eps), "Cos should be constexpr with gcem"); +static_assert(close_to(Pitch::from_degrees(45.0f).tan(), 1.0f, 1e-4f), "Tan should be constexpr with gcem"); +static_assert(close_to(Pitch::from_degrees(45.0f).cot(), 1.0f, 1e-4f), "Cot should be constexpr with gcem"); +static_assert(close_to(Pitch::from_degrees(45.0f).atan(), 0.66577375f, 1e-6f), "Atan should be constexpr with gcem"); +#endif From 854b50f317c5cb10bf62890e0a1ae4acdb6d8a06 Mon Sep 17 00:00:00 2001 From: Orange Date: Thu, 11 Jun 2026 23:49:03 +0300 Subject: [PATCH 04/20] added mat tests and triangle tests --- include/omath/linear_algebra/mat.hpp | 44 +++++++++++------ include/omath/linear_algebra/triangle.hpp | 6 ++- tests/general/unit_test_mat.cpp | 60 ++++++++++++++++++++++- tests/general/unit_test_triangle.cpp | 28 +++++++++++ 4 files changed, 122 insertions(+), 16 deletions(-) diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index a3ee0ee..d8e3cb9 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -679,7 +679,7 @@ namespace omath template [[nodiscard("You must use rotation matrix")]] - Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept + OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept { return { @@ -692,7 +692,7 @@ namespace omath template [[nodiscard("You must use rotation matrix")]] - Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept + OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept { return { @@ -705,7 +705,7 @@ namespace omath template [[nodiscard("You must use rotation matrix")]] - Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept + OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept { return { @@ -718,7 +718,7 @@ namespace omath template [[nodiscard("You must use camera view matrix")]] - static Mat<4, 4, Type, St> mat_camera_view(const Vector3& forward, const Vector3& right, + OMATH_CONSTEXPR static Mat<4, 4, Type, St> mat_camera_view(const Vector3& forward, const Vector3& right, const Vector3& up, const Vector3& camera_origin) noexcept { return Mat<4, 4, Type, St> @@ -732,12 +732,15 @@ namespace omath template - [[nodiscard("You must use perspective matrix")]] + [[nodiscard("You must use perspective matrix")]] OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_perspective_left_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near, const Type far) noexcept { - const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2}); - +#ifdef OMATH_USE_GCEM + const auto fov_half_tan = gcem::tan(angles::degrees_to_radians(field_of_view) / Type{2}); +#else + const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2}) +#endif if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, @@ -754,11 +757,15 @@ namespace omath template - [[nodiscard("You must use perspective matrix")]] + [[nodiscard("You must use perspective matrix")]] OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_perspective_right_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near, const Type far) noexcept { +#ifdef OMATH_USE_GCEM + const auto fov_half_tan = gcem::tan(angles::degrees_to_radians(field_of_view) / Type{2}); +#else const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2}); +#endif if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, @@ -779,12 +786,16 @@ namespace omath // X and Y scales derived as: X = 1 / tan(hfov/2), Y = aspect / tan(hfov/2). template - [[nodiscard("You must use perspective matrix")]] + [[nodiscard("You must use perspective matrix")]] OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near, const Type far) noexcept { +#ifdef OMATH_USE_GCEM + const auto inv_tan_half_hfov = Type{1} / gcem::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); +#else const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); +#endif const auto x_axis = inv_tan_half_hfov; const auto y_axis = inv_tan_half_hfov * aspect_ratio; @@ -804,12 +815,17 @@ namespace omath template - [[nodiscard("You must use perspective matrix")]] + [[nodiscard("You must use perspective matrix")]] OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near, const Type far) noexcept { +#ifdef OMATH_USE_GCEM + const auto inv_tan_half_hfov = Type{1} / gcem::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); +#else const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); +#endif + const auto x_axis = inv_tan_half_hfov; const auto y_axis = inv_tan_half_hfov * aspect_ratio; @@ -828,7 +844,7 @@ namespace omath } template - [[nodiscard("You must use ortho matrix")]] + [[nodiscard("You must use ortho matrix")]] OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near, const Type far) noexcept { @@ -853,7 +869,7 @@ namespace omath } template - [[nodiscard("You must use ortho matrix")]] + [[nodiscard("You must use ortho matrix")]] OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near, const Type far) noexcept { @@ -877,7 +893,7 @@ namespace omath std::unreachable(); } template - Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3& eye, const Vector3& center, const Vector3& up) + OMATH_CONSTEXPR Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3& eye, const Vector3& center, const Vector3& up) { const Vector3 f = (center - eye).normalized(); const Vector3 s = f.cross(up).normalized(); @@ -886,7 +902,7 @@ namespace omath } template - Mat<4, 4, T, St>mat_look_at_right_handed(const Vector3& eye, const Vector3& center, const Vector3& up) + OMATH_CONSTEXPR Mat<4, 4, T, St> mat_look_at_right_handed(const Vector3& eye, const Vector3& center, const Vector3& up) { const Vector3 f = (center - eye).normalized(); const Vector3 s = f.cross(up).normalized(); diff --git a/include/omath/linear_algebra/triangle.hpp b/include/omath/linear_algebra/triangle.hpp index a62f888..8e051be 100644 --- a/include/omath/linear_algebra/triangle.hpp +++ b/include/omath/linear_algebra/triangle.hpp @@ -2,8 +2,8 @@ // Created by Orange on 11/13/2024. // #pragma once -#include "vector3.hpp" #include "omath/internal/optional_constexpr_math.hpp" +#include "vector3.hpp" namespace omath { /* @@ -69,7 +69,11 @@ namespace omath const auto side_b = side_b_length(); const auto hypot_value = hypot(); +#ifdef OMATH_USE_GCEM + return gcem::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f; +#else return std::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f; +#endif } [[nodiscard]] constexpr Vector side_b_vector() const diff --git a/tests/general/unit_test_mat.cpp b/tests/general/unit_test_mat.cpp index 0cc51c3..63bfd64 100644 --- a/tests/general/unit_test_mat.cpp +++ b/tests/general/unit_test_mat.cpp @@ -1,11 +1,25 @@ // UnitTestMat.cpp #include "omath/linear_algebra/mat.hpp" #include "omath/linear_algebra/vector3.hpp" +#include "omath/trigonometry/angle.hpp" #include "omath/trigonometry/angles.hpp" #include using namespace omath; +#ifdef OMATH_USE_GCEM +namespace +{ + using Pitch = Angle(-90), static_cast(90), AngleFlags::Clamped>; + + constexpr bool close_to(const float actual, const float expected, const float epsilon) + { + const float diff = actual - expected; + return (diff < 0.0f ? -diff : diff) <= epsilon; + } +} // namespace +#endif + class UnitTestMat : public ::testing::Test { protected: @@ -522,4 +536,48 @@ TEST(UnitTestMatStandalone, MatOrthoNegativeOneToOneDefault) NDCDepthRange::NEGATIVE_ONE_TO_ONE>(-1.f, 1.f, -1.f, 1.f, 0.1f, 100.f); EXPECT_EQ(ortho_default, ortho_explicit); -} \ No newline at end of file +} + +#ifdef OMATH_USE_GCEM +static_assert( + [] + { + constexpr auto scale = mat_extract_scale(mat_scale(Vector3{2.0f, 3.0f, 4.0f})); + return close_to(scale.x, 2.0f, 1e-5f) && close_to(scale.y, 3.0f, 1e-5f) && close_to(scale.z, 4.0f, 1e-5f); + }(), + "Mat scale extraction should be constexpr with gcem"); + +static_assert( + [] + { + constexpr auto rotation = mat_rotation_axis_z(Pitch::from_degrees(90.0f)); + return close_to(rotation.at(0, 0), 0.0f, 1e-5f) && close_to(rotation.at(0, 1), -1.0f, 1e-5f) + && close_to(rotation.at(1, 0), 1.0f, 1e-5f) && close_to(rotation.at(1, 1), 0.0f, 1e-5f) + && close_to(rotation.at(2, 2), 1.0f, 1e-5f) && close_to(rotation.at(3, 3), 1.0f, 1e-5f); + }(), + "Mat rotation should be constexpr with gcem"); + +static_assert( + [] + { + constexpr auto projection = + mat_perspective_left_handed_vertical_fov(90.0f, 1.0f, 1.0f, 11.0f); + return close_to(projection.at(0, 0), 1.0f, 1e-5f) && close_to(projection.at(1, 1), 1.0f, 1e-5f) + && close_to(projection.at(2, 2), 1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) + && close_to(projection.at(3, 2), 1.0f, 1e-5f); + }(), + "Mat vertical-FOV perspective should be constexpr with gcem"); + +static_assert( + [] + { + constexpr auto projection = + mat_perspective_right_handed_horizontal_fov(90.0f, 2.0f, 1.0f, 11.0f); + return close_to(projection.at(0, 0), 1.0f, 1e-5f) && close_to(projection.at(1, 1), 2.0f, 1e-5f) + && close_to(projection.at(2, 2), -1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) + && close_to(projection.at(3, 2), -1.0f, 1e-5f); + }(), + "Mat horizontal-FOV perspective should be constexpr with gcem"); +#endif diff --git a/tests/general/unit_test_triangle.cpp b/tests/general/unit_test_triangle.cpp index f972a8a..e327689 100644 --- a/tests/general/unit_test_triangle.cpp +++ b/tests/general/unit_test_triangle.cpp @@ -8,6 +8,17 @@ using namespace omath; +#ifdef OMATH_USE_GCEM +namespace +{ + constexpr bool close_to(const float actual, const float expected, const float epsilon) + { + const float diff = actual - expected; + return (diff < 0.0f ? -diff : diff) <= epsilon; + } +} // namespace +#endif + class UnitTestTriangle : public ::testing::Test { protected: @@ -129,3 +140,20 @@ TEST_F(UnitTestTriangle, MidPoint) EXPECT_FLOAT_EQ(mid2.y, (2.0f + 5.0f + 8.0f) / 3.0f); EXPECT_FLOAT_EQ(mid2.z, (3.0f + 6.0f + 9.0f) / 3.0f); } + +#ifdef OMATH_USE_GCEM +static_assert( + [] + { + constexpr Triangle> triangle{{3.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 4.0f, 0.0f}}; + constexpr auto normal = triangle.calculate_normal(); + constexpr auto mid_point = triangle.mid_point(); + + return close_to(triangle.side_a_length(), 3.0f, 1e-5f) && close_to(triangle.side_b_length(), 4.0f, 1e-5f) + && close_to(triangle.hypot(), 5.0f, 1e-5f) && triangle.is_rectangular() + && close_to(normal.length(), 1.0f, 1e-5f) && close_to(normal.z, -1.0f, 1e-5f) + && close_to(mid_point.x, 1.0f, 1e-5f) && close_to(mid_point.y, 4.0f / 3.0f, 1e-5f) + && close_to(mid_point.z, 0.0f, 1e-5f); + }(), + "Triangle helpers should be constexpr with gcem"); +#endif From 589f440e70e99c5257c978c6d1be2f5562a9f297 Mon Sep 17 00:00:00 2001 From: Orange Date: Thu, 11 Jun 2026 23:54:53 +0300 Subject: [PATCH 05/20] added gcem to pipelines --- .github/workflows/cmake-multi-platform.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml index a989ffd..1866dd6 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/cmake-multi-platform.yml @@ -107,7 +107,7 @@ jobs: -DOMATH_BUILD_TESTS=ON \ -DOMATH_BUILD_BENCHMARK=OFF \ -DOMATH_ENABLE_COVERAGE=${{ matrix.coverage == true && 'ON' || 'OFF' }} \ - -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua" + -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua;gcem" - name: Build shell: bash From d9acf5eea82333e31f3d3bf6331f45885ea2f209 Mon Sep 17 00:00:00 2001 From: Orange Date: Fri, 12 Jun 2026 00:04:12 +0300 Subject: [PATCH 06/20] fix --- include/omath/linear_algebra/mat.hpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index d8e3cb9..7a0dece 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -625,7 +625,7 @@ namespace omath OMATH_CONSTEXPR Vector3 mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept { auto column_length = [](const Type x, const Type y, const Type z) { -#ifdef OMATH_CONSTEXPR +#ifdef OMATH_USE_GCEM return static_cast(gcem::sqrt(x * x + y * y + z * z)); #else return static_cast(std::sqrt(x * x + y * y + z * z)); @@ -639,7 +639,7 @@ namespace omath constexpr auto epsilon = std::numeric_limits::epsilon(); return { -#ifdef OMATH_CONSTEXPR +#ifdef OMATH_USE_GCEM gcem::abs(scale_x) < epsilon ? Type{1} : scale_x, gcem::abs(scale_y) < epsilon ? Type{1} : scale_y, gcem::abs(scale_z) < epsilon ? Type{1} : scale_z, @@ -665,12 +665,12 @@ namespace omath const auto m22 = mat.at(2, 2) / scale.z; return { -#ifdef OMATH_CONSTEXPR +#ifdef OMATH_USE_GCEM angles::radians_to_degrees(gcem::atan2(m21, m22)), angles::radians_to_degrees(gcem::asin(std::clamp(-m20, Type{-1}, Type{1}))), angles::radians_to_degrees(gcem::atan2(m10, m00)), #else - angles::radians_to_degrees(gc::atan2(m21, m22)), + angles::radians_to_degrees(std::atan2(m21, m22)), angles::radians_to_degrees(std::asin(std::clamp(-m20, Type{-1}, Type{1}))), angles::radians_to_degrees(std::atan2(m10, m00)), #endif @@ -739,7 +739,7 @@ namespace omath #ifdef OMATH_USE_GCEM const auto fov_half_tan = gcem::tan(angles::degrees_to_radians(field_of_view) / Type{2}); #else - const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2}) + const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2}); #endif if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, From 4a9125549f3ace32743474a3c20071aa84a6816a Mon Sep 17 00:00:00 2001 From: Orange Date: Fri, 12 Jun 2026 00:09:14 +0300 Subject: [PATCH 07/20] patch --- include/omath/linear_algebra/mat.hpp | 1 - include/omath/linear_algebra/vector3.hpp | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index 7a0dece..fce2acb 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -648,7 +648,6 @@ namespace omath std::abs(scale_y) < epsilon ? Type{1} : scale_y, std::abs(scale_z) < epsilon ? Type{1} : scale_z, #endif - }; } diff --git a/include/omath/linear_algebra/vector3.hpp b/include/omath/linear_algebra/vector3.hpp index 405c8f3..c36deb1 100644 --- a/include/omath/linear_algebra/vector3.hpp +++ b/include/omath/linear_algebra/vector3.hpp @@ -332,8 +332,9 @@ namespace omath template<> struct std::hash> { + // NOTE: Cannot be constexpr because of MSVC [[nodiscard("You must use hash value")]] - constexpr std::size_t operator()(const omath::Vector3& vec) const noexcept + std::size_t operator()(const omath::Vector3& vec) const noexcept { std::size_t hash = 0; constexpr std::hash hasher; From 5f14510e5b5d2c097ac3d705c3764fd7c03fcb53 Mon Sep 17 00:00:00 2001 From: Orange Date: Fri, 12 Jun 2026 00:52:22 +0300 Subject: [PATCH 08/20] made constexpr cryengine camera & fromulas --- include/omath/engines/cry_engine/formulas.hpp | 71 +++++++++-- .../cry_engine/traits/camera_trait.hpp | 32 ++++- include/omath/trigonometry/angles.hpp | 7 +- source/engines/cry_engine/formulas.cpp | 70 ----------- .../cry_engine/traits/camera_trait.cpp | 27 ---- tests/engines/unit_test_cry_engine.cpp | 118 +++++++++++++++--- 6 files changed, 195 insertions(+), 130 deletions(-) delete mode 100644 source/engines/cry_engine/formulas.cpp delete mode 100644 source/engines/cry_engine/traits/camera_trait.cpp diff --git a/include/omath/engines/cry_engine/formulas.hpp b/include/omath/engines/cry_engine/formulas.hpp index 4014b40..3739b67 100644 --- a/include/omath/engines/cry_engine/formulas.hpp +++ b/include/omath/engines/cry_engine/formulas.hpp @@ -8,31 +8,82 @@ namespace omath::cry_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.yaw) + * mat_rotation_axis_y(angles.roll) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept; + OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(angles.y), + }; + } + [[nodiscard]] + OMATH_CONSTEXPR Mat4X4 + calc_perspective_projection_matrix( + const float field_of_view, const float aspect_ratio, const float near, const float far, + const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept + { + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near, far); + + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near, far); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/cry_engine/traits/camera_trait.hpp b/include/omath/engines/cry_engine/traits/camera_trait.hpp index b7770af..0aee139 100644 --- a/include/omath/engines/cry_engine/traits/camera_trait.hpp +++ b/include/omath/engines/cry_engine/traits/camera_trait.hpp @@ -4,21 +4,41 @@ #pragma once #include "omath/engines/cry_engine/formulas.hpp" +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/projection/camera.hpp" - namespace omath::cry_engine { class CameraTrait final { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); +#ifdef OMATH_USE_GCEM + return {PitchAngle::from_radians(gcem::asin(direction.z)), + YawAngle::from_radians(-gcem::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; +#else + return {PitchAngle::from_radians(std::asin(direction.z)), + YawAngle::from_radians(-std::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; +#endif + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return cry_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + OMATH_CONSTEXPR static Mat4X4 + calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, + const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + { + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + ndc_depth_range); + } }; -} // namespace omath::cry_engine \ No newline at end of file +} // namespace omath::cry_engine diff --git a/include/omath/trigonometry/angles.hpp b/include/omath/trigonometry/angles.hpp index ce07dd8..10c2789 100644 --- a/include/omath/trigonometry/angles.hpp +++ b/include/omath/trigonometry/angles.hpp @@ -3,6 +3,7 @@ // #pragma once +#include "omath/internal/optional_constexpr_math.hpp" #include #include @@ -47,14 +48,18 @@ namespace omath::angles template requires std::is_arithmetic_v - [[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept + [[nodiscard]] OMATH_CONSTEXPR Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept { if (angle <= max && angle >= min) return angle; const Type range = max - min; +#ifdef OMATH_USE_GCEM + Type wrapped_angle = gcem::fmod(angle - min, range); +#else Type wrapped_angle = std::fmod(angle - min, range); +#endif if (wrapped_angle < 0) wrapped_angle += range; diff --git a/source/engines/cry_engine/formulas.cpp b/source/engines/cry_engine/formulas.cpp deleted file mode 100644 index bc7d6ce..0000000 --- a/source/engines/cry_engine/formulas.cpp +++ /dev/null @@ -1,70 +0,0 @@ -// -// Created by Vlad on 3/22/2025. -// -#include "omath/engines/cry_engine/formulas.hpp" - -namespace omath::cry_engine -{ - Vector3 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 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 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& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.yaw) - * mat_rotation_axis_y(angles.roll) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(angles.y), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - std::unreachable(); - } -} // namespace omath::cry_engine diff --git a/source/engines/cry_engine/traits/camera_trait.cpp b/source/engines/cry_engine/traits/camera_trait.cpp deleted file mode 100644 index da260f5..0000000 --- a/source/engines/cry_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/cry_engine/traits/camera_trait.hpp" - -namespace omath::cry_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(std::asin(direction.z)), - YawAngle::from_radians(-std::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return cry_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::cry_engine \ No newline at end of file diff --git a/tests/engines/unit_test_cry_engine.cpp b/tests/engines/unit_test_cry_engine.cpp index 1888c27..3392772 100644 --- a/tests/engines/unit_test_cry_engine.cpp +++ b/tests/engines/unit_test_cry_engine.cpp @@ -9,6 +9,98 @@ #include using namespace omath; + +#ifdef OMATH_USE_GCEM +namespace +{ + constexpr bool close_to(const float actual, const float expected, const float epsilon) + { + const float diff = actual - expected; + return (diff < 0.0f ? -diff : diff) <= epsilon; + } + + constexpr bool vec_close_to(const Vector3& actual, const Vector3& expected, const float epsilon) + { + return close_to(actual.x, expected.x, epsilon) && close_to(actual.y, expected.y, epsilon) + && close_to(actual.z, expected.z, epsilon); + } +} // namespace + +static_assert( + [] + { + constexpr omath::cry_engine::ViewAngles angles{}; + constexpr auto forward = omath::cry_engine::forward_vector(angles); + constexpr auto right = omath::cry_engine::right_vector(angles); + constexpr auto up = omath::cry_engine::up_vector(angles); + constexpr auto rotation = omath::cry_engine::rotation_matrix(angles); + + return vec_close_to(forward, omath::cry_engine::k_abs_forward, 1e-5f) + && vec_close_to(right, omath::cry_engine::k_abs_right, 1e-5f) + && vec_close_to(up, omath::cry_engine::k_abs_up, 1e-5f) && close_to(rotation.at(0, 0), 1.0f, 1e-5f) + && close_to(rotation.at(1, 1), 1.0f, 1e-5f) && close_to(rotation.at(2, 2), 1.0f, 1e-5f) + && close_to(rotation.at(3, 3), 1.0f, 1e-5f); + }(), + "CryEngine basis vectors should be constexpr with gcem"); + +static_assert( + [] + { + constexpr auto view = omath::cry_engine::calc_view_matrix({}, {}); + return close_to(view.at(0, 0), 1.0f, 1e-5f) && close_to(view.at(1, 2), 1.0f, 1e-5f) + && close_to(view.at(2, 1), 1.0f, 1e-5f) && close_to(view.at(3, 3), 1.0f, 1e-5f); + }(), + "CryEngine view matrix should be constexpr with gcem"); + +static_assert( + [] + { + constexpr auto transform = mat_translation({1.0f, 2.0f, 3.0f}) + * mat_scale({2.0f, 3.0f, 4.0f}); + constexpr auto origin = omath::cry_engine::extract_origin(transform); + constexpr auto scale = omath::cry_engine::extract_scale(transform); + + return vec_close_to(origin, {1.0f, 2.0f, 3.0f}, 1e-5f) && vec_close_to(scale, {2.0f, 3.0f, 4.0f}, 1e-5f); + }(), + "CryEngine transform extraction should be constexpr with gcem"); + +static_assert( + [] + { + constexpr auto projection = omath::cry_engine::calc_perspective_projection_matrix( + 90.0f, 1.0f, 1.0f, 11.0f, NDCDepthRange::ZERO_TO_ONE); + return close_to(projection.at(0, 0), 1.0f, 1e-5f) && close_to(projection.at(1, 1), 1.0f, 1e-5f) + && close_to(projection.at(2, 2), 1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) + && close_to(projection.at(3, 2), 1.0f, 1e-5f); + }(), + "CryEngine projection matrix should be constexpr with gcem"); + +static_assert( + [] + { + constexpr auto angles = + omath::cry_engine::CameraTrait::calc_look_at_angle({}, omath::cry_engine::k_abs_forward); + constexpr auto view = omath::cry_engine::CameraTrait::calc_view_matrix(angles, {}); + constexpr auto projection = omath::cry_engine::CameraTrait::calc_projection_matrix( + projection::FieldOfView::from_degrees(90.0f), {1.0f, 1.0f}, 1.0f, 11.0f, + NDCDepthRange::ZERO_TO_ONE); + + return close_to(angles.pitch.as_degrees(), 0.0f, 1e-5f) && close_to(angles.yaw.as_degrees(), 0.0f, 1e-5f) + && close_to(angles.roll.as_degrees(), 0.0f, 1e-5f) && close_to(view.at(0, 0), 1.0f, 1e-5f) + && close_to(view.at(2, 1), 1.0f, 1e-5f) && close_to(projection.at(0, 0), 1.0f, 1e-5f) + && close_to(projection.at(1, 1), 1.0f, 1e-5f) && close_to(projection.at(2, 2), 1.1f, 1e-5f) + && close_to(projection.at(2, 3), -1.1f, 1e-5f) && close_to(projection.at(3, 2), 1.0f, 1e-5f); + }(), + "CryEngine CameraTrait should be constexpr with gcem"); + +static_assert(omath::cry_engine::units_to_centimeters(100.0f) == 1.0f); +static_assert(omath::cry_engine::units_to_meters(2.0f) == 2.0f); +static_assert(omath::cry_engine::units_to_kilometers(2000.0f) == 2.0f); +static_assert(omath::cry_engine::centimeters_to_units(1.0f) == 100.0f); +static_assert(omath::cry_engine::meters_to_units(2.0f) == 2.0f); +static_assert(omath::cry_engine::kilometers_to_units(2.0f) == 2000.0f); +#endif + TEST(unit_test_cry_engine, look_at_forward) { const auto angles = cry_engine::CameraTrait::calc_look_at_angle({}, cry_engine::k_abs_forward); @@ -251,11 +343,9 @@ TEST(unit_test_cry_engine, ViewAnglesAsVector3Zero) TEST(unit_test_cry_engine, ViewAnglesAsVector3Values) { - const omath::cry_engine::ViewAngles angles{ - omath::cry_engine::PitchAngle::from_degrees(45.f), - omath::cry_engine::YawAngle::from_degrees(-90.f), - omath::cry_engine::RollAngle::from_degrees(30.f) - }; + const omath::cry_engine::ViewAngles angles{omath::cry_engine::PitchAngle::from_degrees(45.f), + omath::cry_engine::YawAngle::from_degrees(-90.f), + omath::cry_engine::RollAngle::from_degrees(30.f)}; const auto vec = angles.as_vector3(); EXPECT_FLOAT_EQ(vec.x, 45.f); @@ -266,11 +356,9 @@ TEST(unit_test_cry_engine, ViewAnglesAsVector3Values) TEST(unit_test_cry_engine, ViewAnglesAsVector3ClampedPitch) { // Pitch is clamped to [-90, 90] - const omath::cry_engine::ViewAngles angles{ - omath::cry_engine::PitchAngle::from_degrees(120.f), - omath::cry_engine::YawAngle::from_degrees(0.f), - omath::cry_engine::RollAngle::from_degrees(0.f) - }; + const omath::cry_engine::ViewAngles angles{omath::cry_engine::PitchAngle::from_degrees(120.f), + omath::cry_engine::YawAngle::from_degrees(0.f), + omath::cry_engine::RollAngle::from_degrees(0.f)}; const auto vec = angles.as_vector3(); EXPECT_FLOAT_EQ(vec.x, 90.f); @@ -279,12 +367,10 @@ TEST(unit_test_cry_engine, ViewAnglesAsVector3ClampedPitch) TEST(unit_test_cry_engine, ViewAnglesAsVector3NormalizedYaw) { // Yaw is normalized to [-180, 180], 270 wraps to -90 - const omath::cry_engine::ViewAngles angles{ - omath::cry_engine::PitchAngle::from_degrees(0.f), - omath::cry_engine::YawAngle::from_degrees(270.f), - omath::cry_engine::RollAngle::from_degrees(0.f) - }; + const omath::cry_engine::ViewAngles angles{omath::cry_engine::PitchAngle::from_degrees(0.f), + omath::cry_engine::YawAngle::from_degrees(270.f), + omath::cry_engine::RollAngle::from_degrees(0.f)}; const auto vec = angles.as_vector3(); EXPECT_NEAR(vec.y, -90.f, 0.01f); -} \ No newline at end of file +} From 2d38387da92909613b4cf0ecd63c1c8c8ea6f5b0 Mon Sep 17 00:00:00 2001 From: Orange Date: Fri, 12 Jun 2026 01:05:14 +0300 Subject: [PATCH 09/20] fix --- include/omath/linear_algebra/mat.hpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index fce2acb..f0f8bb4 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #ifdef OMATH_USE_AVX2 @@ -149,7 +150,8 @@ namespace omath } } - [[nodiscard("You must use element reference")]] constexpr Type& at(const size_t row_index, const size_t column_index) + [[nodiscard("You must use element reference")]] constexpr Type& at(const size_t row_index, + const size_t column_index) { return const_cast(std::as_const(*this).at(row_index, column_index)); } @@ -176,6 +178,13 @@ namespace omath operator*(const Mat& other) const { #ifdef OMATH_USE_AVX2 + if (std::is_constant_evaluated()) + { + if constexpr (StoreType == MatStoreType::ROW_MAJOR) + return cache_friendly_multiply_row_major(other); + else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR) + return cache_friendly_multiply_col_major(other); + } if constexpr (StoreType == MatStoreType::ROW_MAJOR) return avx_multiply_row_major(other); else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR) From 792fb1385145a43152e90cfa0511dfe185cfb0c6 Mon Sep 17 00:00:00 2001 From: Orange Date: Fri, 12 Jun 2026 01:12:13 +0300 Subject: [PATCH 10/20] patch --- include/omath/engines/cry_engine/formulas.hpp | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/include/omath/engines/cry_engine/formulas.hpp b/include/omath/engines/cry_engine/formulas.hpp index 3739b67..0338260 100644 --- a/include/omath/engines/cry_engine/formulas.hpp +++ b/include/omath/engines/cry_engine/formulas.hpp @@ -8,7 +8,7 @@ namespace omath::cry_engine { [[nodiscard]] - OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept { return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.roll) @@ -16,7 +16,7 @@ namespace omath::cry_engine } [[nodiscard]] - OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept + inline OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); @@ -24,7 +24,7 @@ namespace omath::cry_engine } [[nodiscard]] - OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); @@ -32,7 +32,7 @@ namespace omath::cry_engine } [[nodiscard]] - OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept + inline OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); @@ -40,26 +40,26 @@ namespace omath::cry_engine } [[nodiscard]] - OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); } [[nodiscard]] - OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept { return mat_extract_origin(mat); } [[nodiscard]] - OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept { return mat_extract_scale(mat); } [[nodiscard]] - OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept { const auto angles = mat_extract_rotation_zyx(mat); return { @@ -69,8 +69,7 @@ namespace omath::cry_engine }; } [[nodiscard]] - OMATH_CONSTEXPR Mat4X4 - calc_perspective_projection_matrix( + inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( const float field_of_view, const float aspect_ratio, const float near, const float far, const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept { From bb618f692fbfb476084502025c01680caea2620b Mon Sep 17 00:00:00 2001 From: Orange Date: Sun, 14 Jun 2026 22:16:39 +0300 Subject: [PATCH 11/20] added wrapers --- .../cry_engine/traits/camera_trait.hpp | 9 +- .../internal/optional_constexpr_math.hpp | 139 +++++++++++++++++- include/omath/linear_algebra/mat.hpp | 55 ++----- include/omath/linear_algebra/triangle.hpp | 6 +- include/omath/linear_algebra/vector2.hpp | 18 +-- include/omath/linear_algebra/vector3.hpp | 19 +-- include/omath/trigonometry/angle.hpp | 28 +--- include/omath/trigonometry/angles.hpp | 16 +- include/omath/trigonometry/view_angles.hpp | 2 +- 9 files changed, 172 insertions(+), 120 deletions(-) diff --git a/include/omath/engines/cry_engine/traits/camera_trait.hpp b/include/omath/engines/cry_engine/traits/camera_trait.hpp index 0aee139..58e2927 100644 --- a/include/omath/engines/cry_engine/traits/camera_trait.hpp +++ b/include/omath/engines/cry_engine/traits/camera_trait.hpp @@ -16,13 +16,8 @@ namespace omath::cry_engine const Vector3& look_at) noexcept { const auto direction = (look_at - cam_origin).normalized(); -#ifdef OMATH_USE_GCEM - return {PitchAngle::from_radians(gcem::asin(direction.z)), - YawAngle::from_radians(-gcem::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; -#else - return {PitchAngle::from_radians(std::asin(direction.z)), - YawAngle::from_radians(-std::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; -#endif + return {PitchAngle::from_radians(internal::asin(direction.z)), + YawAngle::from_radians(-internal::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; } [[nodiscard]] diff --git a/include/omath/internal/optional_constexpr_math.hpp b/include/omath/internal/optional_constexpr_math.hpp index ecc49dd..ebd3fa9 100644 --- a/include/omath/internal/optional_constexpr_math.hpp +++ b/include/omath/internal/optional_constexpr_math.hpp @@ -3,10 +3,147 @@ // #pragma once +#include +#include #ifdef OMATH_USE_GCEM #include #define OMATH_CONSTEXPR constexpr #else #define OMATH_CONSTEXPR -#endif \ No newline at end of file +#endif + +namespace omath::internal +{ + template + [[nodiscard]] + OMATH_CONSTEXPR Type sin(const Type& value) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::sin(value); +#endif + return std::sin(value); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type cos(const Type& value) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::cos(value); +#endif + return std::cos(value); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type tan(const Type& value) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::tan(value); +#endif + return std::tan(value); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type atan(const Type& value) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::atan(value); +#endif + return std::atan(value); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type atan2(const Type& y, const Type& x) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::atan2(y, x); +#endif + return std::atan2(y, x); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type asin(const Type& value) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::asin(value); +#endif + return std::asin(value); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type acos(const Type& value) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::acos(value); +#endif + return std::acos(value); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type sqrt(const Type& value) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::sqrt(value); +#endif + return std::sqrt(value); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type hypot(const Type& x, const Type& y) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::hypot(x, y); +#endif + return std::hypot(x, y); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type hypot(const Type& x, const Type& y, const Type& z) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::sqrt(x * x + y * y + z * z); +#endif + return std::hypot(x, y, z); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type abs(const Type& value) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::abs(value); +#endif + return std::abs(value); + } + + template + [[nodiscard]] + OMATH_CONSTEXPR Type fmod(const Type& dividend, const Type& divisor) noexcept + { +#ifdef OMATH_USE_GCEM + if (std::is_constant_evaluated()) + return gcem::fmod(dividend, divisor); +#endif + return std::fmod(dividend, divisor); + } +} // namespace omath::internal diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index f0f8bb4..012c3e6 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -2,6 +2,7 @@ // Created by vlad on 9/29/2024. // #pragma once +#include "omath/internal/optional_constexpr_math.hpp" #include "vector3.hpp" #include #include @@ -634,11 +635,7 @@ namespace omath OMATH_CONSTEXPR Vector3 mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept { auto column_length = [](const Type x, const Type y, const Type z) { -#ifdef OMATH_USE_GCEM - return static_cast(gcem::sqrt(x * x + y * y + z * z)); -#else - return static_cast(std::sqrt(x * x + y * y + z * z)); -#endif + return static_cast(internal::sqrt(x * x + y * y + z * z)); }; const auto scale_x = column_length(mat.at(0, 0), mat.at(1, 0), mat.at(2, 0)); @@ -648,15 +645,9 @@ namespace omath constexpr auto epsilon = std::numeric_limits::epsilon(); return { -#ifdef OMATH_USE_GCEM - gcem::abs(scale_x) < epsilon ? Type{1} : scale_x, - gcem::abs(scale_y) < epsilon ? Type{1} : scale_y, - gcem::abs(scale_z) < epsilon ? Type{1} : scale_z, -#else - std::abs(scale_x) < epsilon ? Type{1} : scale_x, - std::abs(scale_y) < epsilon ? Type{1} : scale_y, - std::abs(scale_z) < epsilon ? Type{1} : scale_z, -#endif + internal::abs(scale_x) < epsilon ? Type{1} : scale_x, + internal::abs(scale_y) < epsilon ? Type{1} : scale_y, + internal::abs(scale_z) < epsilon ? Type{1} : scale_z, }; } @@ -673,15 +664,9 @@ namespace omath const auto m22 = mat.at(2, 2) / scale.z; return { -#ifdef OMATH_USE_GCEM - angles::radians_to_degrees(gcem::atan2(m21, m22)), - angles::radians_to_degrees(gcem::asin(std::clamp(-m20, Type{-1}, Type{1}))), - angles::radians_to_degrees(gcem::atan2(m10, m00)), -#else - angles::radians_to_degrees(std::atan2(m21, m22)), - angles::radians_to_degrees(std::asin(std::clamp(-m20, Type{-1}, Type{1}))), - angles::radians_to_degrees(std::atan2(m10, m00)), -#endif + angles::radians_to_degrees(internal::atan2(m21, m22)), + angles::radians_to_degrees(internal::asin(std::clamp(-m20, Type{-1}, Type{1}))), + angles::radians_to_degrees(internal::atan2(m10, m00)), }; } @@ -744,11 +729,7 @@ namespace omath Mat<4, 4, Type, St> mat_perspective_left_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near, const Type far) noexcept { -#ifdef OMATH_USE_GCEM - const auto fov_half_tan = gcem::tan(angles::degrees_to_radians(field_of_view) / Type{2}); -#else - const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2}); -#endif + const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2}); if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, @@ -769,11 +750,7 @@ namespace omath Mat<4, 4, Type, St> mat_perspective_right_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near, const Type far) noexcept { -#ifdef OMATH_USE_GCEM - const auto fov_half_tan = gcem::tan(angles::degrees_to_radians(field_of_view) / Type{2}); -#else - const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2}); -#endif + const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2}); if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, @@ -799,11 +776,7 @@ namespace omath const Type aspect_ratio, const Type near, const Type far) noexcept { -#ifdef OMATH_USE_GCEM - const auto inv_tan_half_hfov = Type{1} / gcem::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); -#else - const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); -#endif + const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); const auto x_axis = inv_tan_half_hfov; const auto y_axis = inv_tan_half_hfov * aspect_ratio; @@ -828,11 +801,7 @@ namespace omath const Type aspect_ratio, const Type near, const Type far) noexcept { -#ifdef OMATH_USE_GCEM - const auto inv_tan_half_hfov = Type{1} / gcem::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); -#else - const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); -#endif + const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); const auto x_axis = inv_tan_half_hfov; const auto y_axis = inv_tan_half_hfov * aspect_ratio; diff --git a/include/omath/linear_algebra/triangle.hpp b/include/omath/linear_algebra/triangle.hpp index 8e051be..3111389 100644 --- a/include/omath/linear_algebra/triangle.hpp +++ b/include/omath/linear_algebra/triangle.hpp @@ -69,11 +69,7 @@ namespace omath const auto side_b = side_b_length(); const auto hypot_value = hypot(); -#ifdef OMATH_USE_GCEM - return gcem::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f; -#else - return std::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f; -#endif + return internal::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f; } [[nodiscard]] constexpr Vector side_b_vector() const diff --git a/include/omath/linear_algebra/vector2.hpp b/include/omath/linear_algebra/vector2.hpp index 74ef70b..d94924f 100644 --- a/include/omath/linear_algebra/vector2.hpp +++ b/include/omath/linear_algebra/vector2.hpp @@ -119,11 +119,7 @@ namespace omath [[nodiscard("You must use distance")]] OMATH_CONSTEXPR Type distance_to(const Vector2& other) const noexcept { -#ifdef OMATH_USE_GCEM - return gcem::sqrt(distance_to_sqr(other)); -#else - return std::sqrt(distance_to_sqr(other)); -#endif + return internal::sqrt(distance_to_sqr(other)); } [[nodiscard("You must use squared distance")]] @@ -141,11 +137,7 @@ namespace omath #ifndef _MSC_VER [[nodiscard("You must use length")]] constexpr Type length() const noexcept { -#ifdef OMATH_USE_GCEM - return gcem::hypot(this->x, this->y); -#else - return std::hypot(this->x, this->y); -#endif + return internal::hypot(this->x, this->y); } [[nodiscard("You must use normalized vector")]] constexpr Vector2 normalized() const noexcept @@ -157,11 +149,7 @@ namespace omath [[nodiscard("You must use length")]] OMATH_CONSTEXPR Type length() const noexcept { -#ifdef OMATH_USE_GCEM - return gcem::hypot(x, y); -#else - return std::hypot(x, y); -#endif + return internal::hypot(x, y); } [[nodiscard("You must use normalized vector")]] diff --git a/include/omath/linear_algebra/vector3.hpp b/include/omath/linear_algebra/vector3.hpp index c36deb1..4a178a4 100644 --- a/include/omath/linear_algebra/vector3.hpp +++ b/include/omath/linear_algebra/vector3.hpp @@ -4,6 +4,7 @@ #pragma once +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/linear_algebra/vector2.hpp" #include "omath/trigonometry/angle.hpp" #include @@ -142,11 +143,7 @@ namespace omath #ifndef _MSC_VER [[nodiscard("You must use length")]] constexpr Type length() const noexcept { -#ifdef OMATH_USE_GCEM - return gcem::sqrt(this->x * this->x + this->y * this->y + z * z); -#else - return std::hypot(this->x, this->y, z); -#endif + return internal::hypot(this->x, this->y, z); } [[nodiscard("You must use 2D length")]] constexpr Type length_2d() const noexcept @@ -167,11 +164,7 @@ namespace omath [[nodiscard("You must use length")]] OMATH_CONSTEXPR Type length() const noexcept { -#ifdef OMATH_USE_GCEM - return gcem::sqrt(this->x * this->x + this->y * this->y + this->z * this->z); -#else - return std::hypot(this->x, this->y, z); -#endif + return internal::hypot(this->x, this->y, this->z); } [[nodiscard("You must use normalized vector")]] @@ -269,11 +262,7 @@ namespace omath if (bottom == static_cast(0)) return std::unexpected(Vector3Error::IMPOSSIBLE_BETWEEN_ANGLE); -#ifdef OMATH_USE_GCEM - return Angle::from_radians(gcem::acos(dot(other) / bottom)); -#else - return Angle::from_radians(std::acos(dot(other) / bottom)); -#endif + return Angle::from_radians(internal::acos(dot(other) / bottom)); } [[nodiscard("You must use perpendicularity check result")]] diff --git a/include/omath/trigonometry/angle.hpp b/include/omath/trigonometry/angle.hpp index 146a309..37980dd 100644 --- a/include/omath/trigonometry/angle.hpp +++ b/include/omath/trigonometry/angle.hpp @@ -73,45 +73,25 @@ namespace omath [[nodiscard]] OMATH_CONSTEXPR Type sin() const noexcept { -#ifdef OMATH_USE_GCEM - return gcem::sin(as_radians()); -#else - return std::sin(as_radians()); - -#endif + return internal::sin(as_radians()); } [[nodiscard]] OMATH_CONSTEXPR Type cos() const noexcept { -#ifdef OMATH_USE_GCEM - return gcem::cos(as_radians()); -#else - return std::cos(as_radians()); - -#endif + return internal::cos(as_radians()); } [[nodiscard]] OMATH_CONSTEXPR Type tan() const noexcept { -#ifdef OMATH_USE_GCEM - return gcem::tan(as_radians()); -#else - return std::tan(as_radians()); - -#endif + return internal::tan(as_radians()); } [[nodiscard]] OMATH_CONSTEXPR Type atan() const noexcept { -#ifdef OMATH_USE_GCEM - return gcem::atan(as_radians()); -#else - return std::atan(as_radians()); - -#endif + return internal::atan(as_radians()); } [[nodiscard]] diff --git a/include/omath/trigonometry/angles.hpp b/include/omath/trigonometry/angles.hpp index 10c2789..1e08cfb 100644 --- a/include/omath/trigonometry/angles.hpp +++ b/include/omath/trigonometry/angles.hpp @@ -25,23 +25,25 @@ namespace omath::angles template requires std::is_floating_point_v - [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept + [[nodiscard]] OMATH_CONSTEXPR Type horizontal_fov_to_vertical(const Type& horizontal_fov, + const Type& aspect) noexcept { const auto fov_rad = degrees_to_radians(horizontal_fov); - const auto vert_fov = static_cast(2) * std::atan(std::tan(fov_rad / static_cast(2)) / aspect); + const auto vert_fov = static_cast(2) * internal::atan(internal::tan(fov_rad / static_cast(2)) / aspect); return radians_to_degrees(vert_fov); } template requires std::is_floating_point_v - [[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept + [[nodiscard]] OMATH_CONSTEXPR 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(2) * std::atan(std::tan(fov_as_radians / static_cast(2)) * aspect); + static_cast(2) * internal::atan(internal::tan(fov_as_radians / static_cast(2)) * aspect); return radians_to_degrees(horizontal_fov); } @@ -55,11 +57,7 @@ namespace omath::angles const Type range = max - min; -#ifdef OMATH_USE_GCEM - Type wrapped_angle = gcem::fmod(angle - min, range); -#else - Type wrapped_angle = std::fmod(angle - min, range); -#endif + Type wrapped_angle = internal::fmod(angle - min, range); if (wrapped_angle < 0) wrapped_angle += range; diff --git a/include/omath/trigonometry/view_angles.hpp b/include/omath/trigonometry/view_angles.hpp index 2a11f96..87f90ff 100644 --- a/include/omath/trigonometry/view_angles.hpp +++ b/include/omath/trigonometry/view_angles.hpp @@ -18,7 +18,7 @@ namespace omath RollType roll; [[nodiscard]] - Vector3 as_vector3() const + constexpr Vector3 as_vector3() const { return {pitch.as_degrees(), yaw.as_degrees(), roll.as_degrees()}; } From 136cd39496b763b8b1ffb06aabd8d5d9119ca249 Mon Sep 17 00:00:00 2001 From: Orange Date: Sun, 14 Jun 2026 22:30:26 +0300 Subject: [PATCH 12/20] fix --- include/omath/linear_algebra/mat.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index 012c3e6..231d215 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -398,7 +398,7 @@ namespace omath { const auto det = determinant(); - if (std::abs(det) < std::numeric_limits::epsilon()) + if (internal::abs(det) < std::numeric_limits::epsilon()) return std::nullopt; const auto transposed_mat = transposed(); From 91d9335f83ddeb405ccd23bdd2a6d1e89b4236fd Mon Sep 17 00:00:00 2001 From: Orange Date: Sun, 14 Jun 2026 22:46:24 +0300 Subject: [PATCH 13/20] added constexpr engine traits --- .../engines/frostbite_engine/formulas.hpp | 76 +++++- .../frostbite_engine/traits/camera_trait.hpp | 27 ++- include/omath/engines/iw_engine/formulas.hpp | 76 +++++- .../engines/iw_engine/traits/camera_trait.hpp | 29 ++- .../omath/engines/opengl_engine/formulas.hpp | 78 +++++- .../opengl_engine/traits/camera_trait.hpp | 30 ++- .../omath/engines/rage_engine/formulas.hpp | 75 +++++- .../rage_engine/traits/camera_trait.hpp | 25 +- .../omath/engines/source_engine/formulas.hpp | 74 +++++- .../source_engine/traits/camera_trait.hpp | 29 ++- .../omath/engines/unity_engine/formulas.hpp | 75 +++++- .../unity_engine/traits/camera_trait.hpp | 27 ++- .../omath/engines/unreal_engine/formulas.hpp | 75 +++++- .../unreal_engine/traits/camera_trait.hpp | 27 ++- .../internal/optional_constexpr_math.hpp | 60 ++++- include/omath/projection/camera.hpp | 223 +++++++++++------- source/engines/frostbite_engine/formulas.cpp | 67 ------ .../frostbite_engine/traits/camera_trait.cpp | 23 -- source/engines/iw_engine/formulas.cpp | 75 ------ .../engines/iw_engine/traits/camera_trait.cpp | 23 -- source/engines/opengl_engine/formulas.cpp | 69 ------ .../opengl_engine/traits/camera_trait.cpp | 24 -- source/engines/rage_engine/formulas.cpp | 67 ------ .../rage_engine/traits/camera_trait.cpp | 23 -- source/engines/source_engine/formulas.cpp | 75 ------ .../source_engine/traits/camera_trait.cpp | 24 -- source/engines/unity_engine/formulas.cpp | 66 ------ .../unity_engine/traits/camera_trait.cpp | 23 -- source/engines/unreal_engine/formulas.cpp | 73 ------ .../unreal_engine/traits/camera_trait.cpp | 23 -- tests/engines/unit_test_traits_engines.cpp | 47 ++++ tests/general/unit_test_projection.cpp | 30 ++- 32 files changed, 879 insertions(+), 859 deletions(-) diff --git a/include/omath/engines/frostbite_engine/formulas.hpp b/include/omath/engines/frostbite_engine/formulas.hpp index 2328cfe..7f7b115 100644 --- a/include/omath/engines/frostbite_engine/formulas.hpp +++ b/include/omath/engines/frostbite_engine/formulas.hpp @@ -8,31 +8,87 @@ namespace omath::frostbite_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.roll) + * mat_rotation_axis_y(angles.yaw) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.y), + RollAngle::from_degrees(angles.z), + }; + } + + [[nodiscard]] + inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + const float field_of_view, const float aspect_ratio, const float near, const float far, + const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept + { + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near, far); + + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near, far); + + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp index 99a46ae..9156a76 100644 --- a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp +++ b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp @@ -4,6 +4,7 @@ #pragma once #include "omath/engines/frostbite_engine/formulas.hpp" +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::frostbite_engine @@ -12,13 +13,29 @@ namespace omath::frostbite_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(-internal::asin(direction.y)), + YawAngle::from_radians(internal::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return frostbite_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + OMATH_CONSTEXPR static Mat4X4 + calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, + const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + { + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + ndc_depth_range); + } }; -} // namespace omath::unreal_engine \ No newline at end of file +} // namespace omath::unreal_engine diff --git a/include/omath/engines/iw_engine/formulas.hpp b/include/omath/engines/iw_engine/formulas.hpp index a79895e..6cb962f 100644 --- a/include/omath/engines/iw_engine/formulas.hpp +++ b/include/omath/engines/iw_engine/formulas.hpp @@ -8,31 +8,85 @@ namespace omath::iw_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR 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); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; - - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.y), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(angles.x), + }; + } + + [[nodiscard]] + inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); + } + + [[nodiscard]] + inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + const float field_of_view, const float aspect_ratio, const float near, const float far, + const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept + { + constexpr float k_source_reference_aspect = 4.f / 3.f; + const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect); + + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + vertical_fov, aspect_ratio, near, far); + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + vertical_fov, aspect_ratio, near, far); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/iw_engine/traits/camera_trait.hpp b/include/omath/engines/iw_engine/traits/camera_trait.hpp index 964b8c4..a50a87d 100644 --- a/include/omath/engines/iw_engine/traits/camera_trait.hpp +++ b/include/omath/engines/iw_engine/traits/camera_trait.hpp @@ -3,7 +3,8 @@ // #pragma once -#include "omath/engines/iw_engine/constants.hpp" +#include "omath/engines/iw_engine/formulas.hpp" +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::iw_engine @@ -12,13 +13,29 @@ namespace omath::iw_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(-internal::asin(direction.z)), + YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return iw_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + OMATH_CONSTEXPR static Mat4X4 + calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, + const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + { + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + ndc_depth_range); + } }; -} // namespace omath::iw_engine \ No newline at end of file +} // namespace omath::iw_engine diff --git a/include/omath/engines/opengl_engine/formulas.hpp b/include/omath/engines/opengl_engine/formulas.hpp index dd07f07..c74c0a4 100644 --- a/include/omath/engines/opengl_engine/formulas.hpp +++ b/include/omath/engines/opengl_engine/formulas.hpp @@ -7,31 +7,89 @@ namespace omath::opengl_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + { + const auto vec = + rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return mat_look_at_right_handed(cam_origin, cam_origin + forward_vector(angles), up_vector(angles)); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.roll) + * mat_rotation_axis_y(angles.yaw) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.y), + RollAngle::from_degrees(angles.z), + }; + } + + [[nodiscard]] + inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + const float field_of_view, const float aspect_ratio, const float near, const float far, + const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept + { + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_right_handed_vertical_fov< + float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( + field_of_view, aspect_ratio, near, far); + + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_right_handed_vertical_fov< + float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::ZERO_TO_ONE>( + field_of_view, aspect_ratio, near, far); + + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/opengl_engine/traits/camera_trait.hpp b/include/omath/engines/opengl_engine/traits/camera_trait.hpp index e7c1f4b..f16457c 100644 --- a/include/omath/engines/opengl_engine/traits/camera_trait.hpp +++ b/include/omath/engines/opengl_engine/traits/camera_trait.hpp @@ -3,7 +3,8 @@ // #pragma once -#include "omath/engines/opengl_engine/constants.hpp" +#include "omath/engines/opengl_engine/formulas.hpp" +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::opengl_engine @@ -12,13 +13,30 @@ namespace omath::opengl_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(internal::asin(direction.y)), + YawAngle::from_radians(-internal::atan2(direction.x, -direction.z)), + RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return opengl_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + OMATH_CONSTEXPR static Mat4X4 + calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, + const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + { + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + ndc_depth_range); + } }; -} // namespace omath::opengl_engine \ No newline at end of file +} // namespace omath::opengl_engine diff --git a/include/omath/engines/rage_engine/formulas.hpp b/include/omath/engines/rage_engine/formulas.hpp index 53c3066..f2bc04f 100644 --- a/include/omath/engines/rage_engine/formulas.hpp +++ b/include/omath/engines/rage_engine/formulas.hpp @@ -9,31 +9,86 @@ namespace omath::rage_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.yaw) + * mat_rotation_axis_y(angles.roll) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(angles.y), + }; + } + + [[nodiscard]] + inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + const float field_of_view, const float aspect_ratio, const float near, const float far, + const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept + { + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near, far); + + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near, far); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/rage_engine/traits/camera_trait.hpp b/include/omath/engines/rage_engine/traits/camera_trait.hpp index 5e6c420..8395af8 100644 --- a/include/omath/engines/rage_engine/traits/camera_trait.hpp +++ b/include/omath/engines/rage_engine/traits/camera_trait.hpp @@ -4,6 +4,7 @@ #pragma once #include "omath/engines/rage_engine/formulas.hpp" +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::rage_engine @@ -12,13 +13,29 @@ namespace omath::rage_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(internal::asin(direction.z)), + YawAngle::from_radians(-internal::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return rage_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + OMATH_CONSTEXPR static Mat4X4 + calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, + const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + { + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + ndc_depth_range); + } }; } // namespace omath::rage_engine diff --git a/include/omath/engines/source_engine/formulas.hpp b/include/omath/engines/source_engine/formulas.hpp index 4a8bd93..60e3d7c 100644 --- a/include/omath/engines/source_engine/formulas.hpp +++ b/include/omath/engines/source_engine/formulas.hpp @@ -7,31 +7,85 @@ namespace omath::source_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR 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); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.y), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(angles.x), + }; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } + + [[nodiscard]] + inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); + } + + [[nodiscard]] + inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + const float field_of_view, const float aspect_ratio, const float near, const float far, + const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept + { + constexpr float k_source_reference_aspect = 4.f / 3.f; + const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect); + + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + vertical_fov, aspect_ratio, near, far); + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + vertical_fov, aspect_ratio, near, far); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/source_engine/traits/camera_trait.hpp b/include/omath/engines/source_engine/traits/camera_trait.hpp index 5ecb192..09d9ed9 100644 --- a/include/omath/engines/source_engine/traits/camera_trait.hpp +++ b/include/omath/engines/source_engine/traits/camera_trait.hpp @@ -3,7 +3,8 @@ // #pragma once -#include "omath/engines/source_engine/constants.hpp" +#include "omath/engines/source_engine/formulas.hpp" +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::source_engine @@ -12,13 +13,29 @@ namespace omath::source_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(-internal::asin(direction.z)), + YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return source_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + OMATH_CONSTEXPR static Mat4X4 + calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, + const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + { + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + ndc_depth_range); + } }; -} // namespace omath::source_engine \ No newline at end of file +} // namespace omath::source_engine diff --git a/include/omath/engines/unity_engine/formulas.hpp b/include/omath/engines/unity_engine/formulas.hpp index 7d5535b..65e8356 100644 --- a/include/omath/engines/unity_engine/formulas.hpp +++ b/include/omath/engines/unity_engine/formulas.hpp @@ -8,31 +8,86 @@ namespace omath::unity_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return mat_camera_view(-forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.roll) + * mat_rotation_axis_y(angles.yaw) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.y), + RollAngle::from_degrees(angles.z), + }; + } + + [[nodiscard]] + inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + const float field_of_view, const float aspect_ratio, const float near, const float far, + const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept + { + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return omath::mat_perspective_right_handed_vertical_fov< + float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( + field_of_view, aspect_ratio, near, far); + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return omath::mat_perspective_right_handed_vertical_fov< + float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( + field_of_view, aspect_ratio, near, far); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/unity_engine/traits/camera_trait.hpp b/include/omath/engines/unity_engine/traits/camera_trait.hpp index 1f531af..c7b89ed 100644 --- a/include/omath/engines/unity_engine/traits/camera_trait.hpp +++ b/include/omath/engines/unity_engine/traits/camera_trait.hpp @@ -4,6 +4,7 @@ #pragma once #include "omath/engines/unity_engine/formulas.hpp" +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::unity_engine @@ -12,13 +13,29 @@ namespace omath::unity_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(-internal::asin(direction.y)), + YawAngle::from_radians(internal::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return unity_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + OMATH_CONSTEXPR static Mat4X4 + calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, + const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + { + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + ndc_depth_range); + } }; -} // namespace omath::unity_engine \ No newline at end of file +} // namespace omath::unity_engine diff --git a/include/omath/engines/unreal_engine/formulas.hpp b/include/omath/engines/unreal_engine/formulas.hpp index 47b6dfe..4df684d 100644 --- a/include/omath/engines/unreal_engine/formulas.hpp +++ b/include/omath/engines/unreal_engine/formulas.hpp @@ -8,31 +8,86 @@ namespace omath::unreal_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline OMATH_CONSTEXPR Vector3 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)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR 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); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(double field_of_view, double aspect_ratio, double near, double far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(-angles.y), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(-angles.x), + }; + } + + [[nodiscard]] + inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + const double field_of_view, const double aspect_ratio, const double near, const double far, + const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept + { + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_left_handed_horizontal_fov< + double, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( + field_of_view, aspect_ratio, near, far); + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_horizontal_fov< + double, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( + field_of_view, aspect_ratio, near, far); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/unreal_engine/traits/camera_trait.hpp b/include/omath/engines/unreal_engine/traits/camera_trait.hpp index 4b0fe77..826e17d 100644 --- a/include/omath/engines/unreal_engine/traits/camera_trait.hpp +++ b/include/omath/engines/unreal_engine/traits/camera_trait.hpp @@ -4,6 +4,7 @@ #pragma once #include "omath/engines/unreal_engine/formulas.hpp" +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::unreal_engine @@ -12,13 +13,29 @@ namespace omath::unreal_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(internal::asin(direction.z)), + YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, + const Vector3& cam_origin) noexcept + { + return unreal_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - double near, double far, NDCDepthRange ndc_depth_range) noexcept; + OMATH_CONSTEXPR static Mat4X4 + calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, + const double near, const double far, const NDCDepthRange ndc_depth_range) noexcept + { + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + ndc_depth_range); + } }; -} // namespace omath::unreal_engine \ No newline at end of file +} // namespace omath::unreal_engine diff --git a/include/omath/internal/optional_constexpr_math.hpp b/include/omath/internal/optional_constexpr_math.hpp index ebd3fa9..04c1266 100644 --- a/include/omath/internal/optional_constexpr_math.hpp +++ b/include/omath/internal/optional_constexpr_math.hpp @@ -16,133 +16,169 @@ namespace omath::internal { template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type sin(const Type& value) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::sin(value); + } #endif return std::sin(value); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type cos(const Type& value) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::cos(value); + } #endif return std::cos(value); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type tan(const Type& value) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::tan(value); + } #endif return std::tan(value); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type atan(const Type& value) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::atan(value); + } #endif return std::atan(value); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type atan2(const Type& y, const Type& x) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::atan2(y, x); + } #endif return std::atan2(y, x); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type asin(const Type& value) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::asin(value); + } #endif return std::asin(value); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type acos(const Type& value) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::acos(value); + } #endif return std::acos(value); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type sqrt(const Type& value) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::sqrt(value); + } #endif return std::sqrt(value); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type hypot(const Type& x, const Type& y) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::hypot(x, y); + } #endif return std::hypot(x, y); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type hypot(const Type& x, const Type& y, const Type& z) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::sqrt(x * x + y * y + z * z); + } #endif return std::hypot(x, y, z); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type abs(const Type& value) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::abs(value); + } #endif return std::abs(value); } template + requires std::is_floating_point_v [[nodiscard]] OMATH_CONSTEXPR Type fmod(const Type& dividend, const Type& divisor) noexcept { #ifdef OMATH_USE_GCEM - if (std::is_constant_evaluated()) + if consteval + { return gcem::fmod(dividend, divisor); + } #endif return std::fmod(dividend, divisor); } diff --git a/include/omath/projection/camera.hpp b/include/omath/projection/camera.hpp index 42baf73..a753341 100644 --- a/include/omath/projection/camera.hpp +++ b/include/omath/projection/camera.hpp @@ -6,6 +6,7 @@ #include "omath/3d_primitives/aabb.hpp" #include "omath/3d_primitives/obb.hpp" +#include "omath/internal/optional_constexpr_math.hpp" #include "omath/linear_algebra/mat.hpp" #include "omath/linear_algebra/triangle.hpp" #include "omath/linear_algebra/vector3.hpp" @@ -84,8 +85,9 @@ namespace omath::projection }; ~Camera() = default; - Camera(const Vector3& position, const ViewAnglesType& view_angles, const ViewPort& view_port, - const FieldOfView& fov, const NumericType near, const NumericType far) noexcept + constexpr Camera(const Vector3& position, const ViewAnglesType& view_angles, + const ViewPort& view_port, const FieldOfView& fov, const NumericType near, + const NumericType 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) { @@ -102,18 +104,18 @@ namespace omath::projection // NEGATIVE_ONE_TO_ONE) share the same m[0,0]/m[1,1] layout, so this works // regardless of the NDC depth range. [[nodiscard("You must use extracted projection params")]] - static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept + OMATH_CONSTEXPR static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept { // m[1,1] == 1 / tan(fov/2) => fov = 2 * atan(1 / m[1,1]) const auto f = proj_matrix.at(1, 1); // m[0,0] == m[1,1] / aspect_ratio => aspect = m[1,1] / m[0,0] - const auto fov_radians = NumericType{2} * std::atan(NumericType{1} / f); + const auto fov_radians = NumericType{2} * internal::atan(NumericType{1} / f); return {FieldOfView::from_radians(static_cast(fov_radians)), f / proj_matrix.at(0, 0)}; } [[nodiscard("You must use calculated view angles")]] - static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept + OMATH_CONSTEXPR static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept { Vector3 forward_vector = {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]}; if constexpr (axes.inverted_forward) @@ -122,7 +124,7 @@ namespace omath::projection } [[nodiscard("You must use calculated origin")]] - static Vector3 calc_origin_from_view_matrix(const Mat4X4Type& view_matrix) noexcept + constexpr static Vector3 calc_origin_from_view_matrix(const Mat4X4Type& view_matrix) noexcept { // The view matrix is R * T(-origin), so the last column stores t = -R * origin. // Recovering origin: origin = -R^T * t @@ -136,40 +138,58 @@ namespace omath::projection }; } - void look_at(const Vector3& target) + OMATH_CONSTEXPR void look_at(const Vector3& target) { m_view_angles = TraitClass::calc_look_at_angle(m_origin, target); m_view_projection_matrix = std::nullopt; m_view_matrix = std::nullopt; } [[nodiscard("You must use calculated look-at angles")]] - ViewAnglesType calc_look_at_angles(const Vector3& look_to) const + OMATH_CONSTEXPR ViewAnglesType calc_look_at_angles(const Vector3& look_to) const { return TraitClass::calc_look_at_angle(m_origin, look_to); } [[nodiscard("You must use forward vector")]] - Vector3 get_forward() const noexcept + OMATH_CONSTEXPR Vector3 get_forward() const noexcept { + if consteval + { + const auto view_matrix = calc_view_matrix(); + return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]}; + } + const auto& view_matrix = get_view_matrix(); return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]}; } [[nodiscard("You must use right vector")]] - Vector3 get_right() const noexcept + OMATH_CONSTEXPR Vector3 get_right() const noexcept { + if consteval + { + const auto view_matrix = calc_view_matrix(); + return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]}; + } + const auto& view_matrix = get_view_matrix(); return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]}; } [[nodiscard("You must use up vector")]] - Vector3 get_up() const noexcept + OMATH_CONSTEXPR Vector3 get_up() const noexcept { + if consteval + { + const auto view_matrix = calc_view_matrix(); + return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]}; + } + const auto& view_matrix = get_view_matrix(); return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]}; } [[nodiscard("You must use absolute forward vector")]] - Vector3 get_abs_forward() const noexcept + OMATH_CONSTEXPR Vector3 get_abs_forward() const noexcept { if constexpr (axes.inverted_forward) return -get_forward(); @@ -177,7 +197,7 @@ namespace omath::projection } [[nodiscard("You must use absolute right vector")]] - Vector3 get_abs_right() const noexcept + OMATH_CONSTEXPR Vector3 get_abs_right() const noexcept { if constexpr (axes.inverted_right) return -get_right(); @@ -185,13 +205,32 @@ namespace omath::projection } [[nodiscard("You must use absolute up vector")]] - Vector3 get_abs_up() const noexcept + OMATH_CONSTEXPR Vector3 get_abs_up() const noexcept { return get_up(); } + [[nodiscard("You must use calculated view-projection matrix")]] + OMATH_CONSTEXPR Mat4X4Type calc_view_projection_matrix() const noexcept + { + return calc_projection_matrix() * calc_view_matrix(); + } + + [[nodiscard("You must use calculated view matrix")]] + OMATH_CONSTEXPR Mat4X4Type calc_view_matrix() const noexcept + { + return TraitClass::calc_view_matrix(m_view_angles, m_origin); + } + + [[nodiscard("You must use calculated projection matrix")]] + OMATH_CONSTEXPR Mat4X4Type calc_projection_matrix() const noexcept + { + return TraitClass::calc_projection_matrix( + m_field_of_view, m_view_port, m_near_plane_distance, m_far_plane_distance, depth_range); + } + [[nodiscard("You must use view-projection matrix")]] - const Mat4X4Type& get_view_projection_matrix() const noexcept + OMATH_CONSTEXPR const Mat4X4Type& get_view_projection_matrix() const noexcept { if (!m_view_projection_matrix.has_value()) m_view_projection_matrix = get_projection_matrix() * get_view_matrix(); @@ -199,90 +238,89 @@ namespace omath::projection return m_view_projection_matrix.value(); } - [[nodiscard("You must use view matrix")]] const Mat4X4Type& get_view_matrix() const noexcept + [[nodiscard("You must use view matrix")]] OMATH_CONSTEXPR const Mat4X4Type& get_view_matrix() const noexcept { if (!m_view_matrix.has_value()) - m_view_matrix = TraitClass::calc_view_matrix(m_view_angles, m_origin); + m_view_matrix = calc_view_matrix(); return m_view_matrix.value(); } - [[nodiscard("You must use projection matrix")]] const Mat4X4Type& get_projection_matrix() const noexcept + [[nodiscard("You must use projection matrix")]] OMATH_CONSTEXPR const Mat4X4Type& get_projection_matrix() const noexcept { if (!m_projection_matrix.has_value()) - m_projection_matrix = TraitClass::calc_projection_matrix( - m_field_of_view, m_view_port, m_near_plane_distance, m_far_plane_distance, depth_range); + m_projection_matrix = calc_projection_matrix(); return m_projection_matrix.value(); } - void set_field_of_view(const FieldOfView& fov) noexcept + constexpr void set_field_of_view(const FieldOfView& fov) noexcept { m_field_of_view = fov; m_view_projection_matrix = std::nullopt; m_projection_matrix = std::nullopt; } - void set_near_plane(const NumericType near_plane) noexcept + constexpr void set_near_plane(const NumericType near_plane) noexcept { m_near_plane_distance = near_plane; m_view_projection_matrix = std::nullopt; m_projection_matrix = std::nullopt; } - void set_far_plane(const NumericType far_plane) noexcept + constexpr void set_far_plane(const NumericType far_plane) noexcept { m_far_plane_distance = far_plane; m_view_projection_matrix = std::nullopt; m_projection_matrix = std::nullopt; } - void set_view_angles(const ViewAnglesType& view_angles) noexcept + constexpr void set_view_angles(const ViewAnglesType& view_angles) noexcept { m_view_angles = view_angles; m_view_projection_matrix = std::nullopt; m_view_matrix = std::nullopt; } - void set_origin(const Vector3& origin) noexcept + constexpr void set_origin(const Vector3& origin) noexcept { m_origin = origin; m_view_projection_matrix = std::nullopt; m_view_matrix = std::nullopt; } - void set_view_port(const ViewPort& view_port) noexcept + constexpr void set_view_port(const ViewPort& view_port) noexcept { m_view_port = view_port; m_view_projection_matrix = std::nullopt; m_projection_matrix = std::nullopt; } - [[nodiscard("You must use field of view")]] const FieldOfView& get_field_of_view() const noexcept + [[nodiscard("You must use field of view")]] constexpr const FieldOfView& get_field_of_view() const noexcept { return m_field_of_view; } - [[nodiscard("You must use near plane")]] const NumericType& get_near_plane() const noexcept + [[nodiscard("You must use near plane")]] constexpr const NumericType& get_near_plane() const noexcept { return m_near_plane_distance; } - [[nodiscard("You must use far plane")]] const NumericType& get_far_plane() const noexcept + [[nodiscard("You must use far plane")]] constexpr const NumericType& get_far_plane() const noexcept { return m_far_plane_distance; } - [[nodiscard("You must use view angles")]] const ViewAnglesType& get_view_angles() const noexcept + [[nodiscard("You must use view angles")]] constexpr const ViewAnglesType& get_view_angles() const noexcept { return m_view_angles; } - [[nodiscard("You must use origin")]] const Vector3& get_origin() const noexcept + [[nodiscard("You must use origin")]] constexpr const Vector3& get_origin() const noexcept { return m_origin; } template - [[nodiscard("You must use screen position")]] std::expected, Error> + [[nodiscard("You must use screen position")]] OMATH_CONSTEXPR std::expected, Error> world_to_screen(const Vector3& world_position) const noexcept { const auto normalized_cords = world_to_view_port(world_position); @@ -298,7 +336,7 @@ namespace omath::projection std::unreachable(); } template - [[nodiscard("You must use unclipped screen position")]] std::expected, Error> + [[nodiscard("You must use unclipped screen position")]] OMATH_CONSTEXPR std::expected, Error> world_to_screen_unclipped(const Vector3& world_position) const noexcept { const auto normalized_cords = world_to_view_port(world_position, ViewPortClipping::MANUAL); @@ -314,7 +352,7 @@ namespace omath::projection std::unreachable(); } - [[nodiscard("You must use frustum culling result")]] bool + [[nodiscard("You must use frustum culling result")]] OMATH_CONSTEXPR bool is_culled_by_frustum(const Triangle>& triangle) const noexcept { // Transform to clip space (before perspective divide) @@ -382,7 +420,7 @@ namespace omath::projection return false; } - [[nodiscard("You must use AABB frustum culling result")]] bool + [[nodiscard("You must use AABB frustum culling result")]] OMATH_CONSTEXPR bool is_aabb_culled_by_frustum(const primitives::Aabb& aabb) const noexcept { // For each plane, find the AABB corner most in the direction of the plane normal @@ -400,7 +438,7 @@ namespace omath::projection return false; } - [[nodiscard("You must use OBB frustum culling result")]] bool + [[nodiscard("You must use OBB frustum culling result")]] OMATH_CONSTEXPR bool is_obb_culled_by_frustum(const primitives::Obb& obb) const noexcept { // For each plane, project the OBB extents onto the plane normal to get the @@ -410,9 +448,9 @@ namespace omath::projection const Vector3 normal{a, b, c}; const auto center_distance = normal.dot(obb.center) + d; - const auto radius = obb.half_extents.x * std::abs(normal.dot(obb.axis_x)) - + obb.half_extents.y * std::abs(normal.dot(obb.axis_y)) - + obb.half_extents.z * std::abs(normal.dot(obb.axis_z)); + const auto radius = obb.half_extents.x * internal::abs(normal.dot(obb.axis_x)) + + obb.half_extents.y * internal::abs(normal.dot(obb.axis_y)) + + obb.half_extents.z * internal::abs(normal.dot(obb.axis_z)); if (center_distance + radius < NumericType{0}) return true; @@ -421,60 +459,84 @@ namespace omath::projection return false; } - [[nodiscard("You must use view port position")]] std::expected, Error> + [[nodiscard("You must use view port position")]] OMATH_CONSTEXPR std::expected, Error> world_to_view_port(const Vector3& world_position, const ViewPortClipping& clipping = ViewPortClipping::AUTO) const noexcept { + auto project_to_view_port = [this, &clipping](auto projected) -> std::expected, Error> + { + const auto& w = projected.at(3, 0); + constexpr auto eps = std::numeric_limits::epsilon(); + if (w <= eps) + return std::unexpected(Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO); + + projected /= w; + + // ReSharper disable once CppTooWideScope + const auto clipped_automatically = + clipping == ViewPortClipping::AUTO && is_ndc_out_of_bounds(projected); + if (clipped_automatically) + return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); + + // ReSharper disable once CppTooWideScope + constexpr auto z_min = depth_range == NDCDepthRange::ZERO_TO_ONE ? NumericType{0} : -NumericType{1}; + const auto clipped_manually = + clipping == ViewPortClipping::MANUAL + && (projected.at(2, 0) < z_min - eps || projected.at(2, 0) > NumericType{1} + eps); + if (clipped_manually) + return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); + + return Vector3{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)}; + }; + + if consteval + { + auto projected = + calc_view_projection_matrix() + * mat_column_from_vector(world_position); + return project_to_view_port(projected); + } + auto projected = get_view_projection_matrix() * mat_column_from_vector(world_position); - - const auto& w = projected.at(3, 0); - constexpr auto eps = std::numeric_limits::epsilon(); - if (w <= eps) - return std::unexpected(Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO); - - projected /= w; - - // ReSharper disable once CppTooWideScope - const auto clipped_automatically = clipping == ViewPortClipping::AUTO && is_ndc_out_of_bounds(projected); - if (clipped_automatically) - return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); - - // ReSharper disable once CppTooWideScope - constexpr auto z_min = depth_range == NDCDepthRange::ZERO_TO_ONE ? NumericType{0} : -NumericType{1}; - const auto clipped_manually = - clipping == ViewPortClipping::MANUAL - && (projected.at(2, 0) < z_min - eps || projected.at(2, 0) > NumericType{1} + eps); - if (clipped_manually) - return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); - - return Vector3{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)}; + return project_to_view_port(projected); } [[nodiscard("You must use world position")]] - std::expected, Error> view_port_to_world(const Vector3& ndc) const noexcept + OMATH_CONSTEXPR std::expected, Error> + view_port_to_world(const Vector3& ndc) const noexcept { - const auto inv_view_proj = get_view_projection_matrix().inverted(); + auto view_port_to_world = [&ndc](const Mat4X4Type& view_projection) -> std::expected, Error> + { + const auto inv_view_proj = view_projection.inverted(); - if (!inv_view_proj) - return std::unexpected(Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO); + if (!inv_view_proj) + return std::unexpected(Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO); - auto inverted_projection = - inv_view_proj.value() * mat_column_from_vector(ndc); + auto inverted_projection = inv_view_proj.value() + * mat_column_from_vector(ndc); - const auto& w = inverted_projection.at(3, 0); + const auto& w = inverted_projection.at(3, 0); - if (std::abs(w) < std::numeric_limits::epsilon()) - return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); + if (internal::abs(w) < std::numeric_limits::epsilon()) + return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); - inverted_projection /= w; + inverted_projection /= w; - return Vector3{inverted_projection.at(0, 0), inverted_projection.at(1, 0), - inverted_projection.at(2, 0)}; + return Vector3{inverted_projection.at(0, 0), inverted_projection.at(1, 0), + inverted_projection.at(2, 0)}; + }; + + if consteval + { + return view_port_to_world(calc_view_projection_matrix()); + } + + return view_port_to_world(get_view_projection_matrix()); } template [[nodiscard("You must use world position")]] - std::expected, Error> + OMATH_CONSTEXPR std::expected, Error> screen_to_world(const Vector3& screen_pos) const noexcept { return view_port_to_world(screen_to_ndc(screen_pos)); @@ -482,7 +544,7 @@ namespace omath::projection template [[nodiscard("You must use world position")]] - std::expected, Error> + OMATH_CONSTEXPR std::expected, Error> screen_to_world(const Vector2& screen_pos) const noexcept { const auto& [x, y] = screen_pos; @@ -517,7 +579,8 @@ namespace omath::projection // Top = r3 - r1 // Near = r3 + r2 ([-1,1]) or r2 ([0,1]) // Far = r3 - r2 - [[nodiscard("You must use frustum planes")]] std::array extract_frustum_planes() const noexcept + [[nodiscard("You must use frustum planes")]] OMATH_CONSTEXPR std::array + extract_frustum_planes() const noexcept { const auto& m = get_view_projection_matrix(); @@ -589,7 +652,7 @@ namespace omath::projection v */ - [[nodiscard("You must use screen position")]] Vector3 + [[nodiscard("You must use screen position")]] constexpr Vector3 ndc_to_screen_position_from_top_left_corner(const Vector3& ndc) const noexcept { /* @@ -607,7 +670,7 @@ namespace omath::projection (ndc.y / -NumericType{2} + NumericType{0.5}) * m_view_port.m_height, ndc.z}; } - [[nodiscard("You must use screen position")]] Vector3 + [[nodiscard("You must use screen position")]] constexpr Vector3 ndc_to_screen_position_from_bottom_left_corner(const Vector3& ndc) const noexcept { /* @@ -626,7 +689,7 @@ namespace omath::projection } template - [[nodiscard("You must use NDC position")]] Vector3 + [[nodiscard("You must use NDC position")]] constexpr Vector3 screen_to_ndc(const Vector3& screen_pos) const noexcept { if constexpr (screen_start == ScreenStart::TOP_LEFT_CORNER) diff --git a/source/engines/frostbite_engine/formulas.cpp b/source/engines/frostbite_engine/formulas.cpp index 3c18648..f0a73c4 100644 --- a/source/engines/frostbite_engine/formulas.cpp +++ b/source/engines/frostbite_engine/formulas.cpp @@ -2,70 +2,3 @@ // Created by Vlad on 3/22/2025. // #include "omath/engines/frostbite_engine/formulas.hpp" - -namespace omath::frostbite_engine -{ - Vector3 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 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 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& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.roll) - * mat_rotation_axis_y(angles.yaw) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.y), - RollAngle::from_degrees(angles.z), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - std::unreachable(); - } -} // namespace omath::unity_engine diff --git a/source/engines/frostbite_engine/traits/camera_trait.cpp b/source/engines/frostbite_engine/traits/camera_trait.cpp index 1d4ac21..cf7a896 100644 --- a/source/engines/frostbite_engine/traits/camera_trait.cpp +++ b/source/engines/frostbite_engine/traits/camera_trait.cpp @@ -2,26 +2,3 @@ // Created by Vlad on 8/11/2025. // #include "omath/engines/frostbite_engine/traits/camera_trait.hpp" - -namespace omath::frostbite_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(-std::asin(direction.y)), - YawAngle::from_radians(std::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return frostbite_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::unity_engine \ No newline at end of file diff --git a/source/engines/iw_engine/formulas.cpp b/source/engines/iw_engine/formulas.cpp index 2437065..6b1cc8e 100644 --- a/source/engines/iw_engine/formulas.cpp +++ b/source/engines/iw_engine/formulas.cpp @@ -2,78 +2,3 @@ // Created by Vlad on 3/19/2025. // #include "omath/engines/iw_engine/formulas.hpp" - -namespace omath::iw_engine -{ - - Vector3 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 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 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) noexcept - { - return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.y), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(angles.x), - }; - } - - Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& 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 NDCDepthRange ndc_depth_range) noexcept - { - // InfinityWard Engine (inherited from Quake) stores FOV as horizontal FOV at a 4:3 - // reference aspect. Convert to true vertical FOV, then delegate to the - // standard vertical-FOV left-handed builder with the caller's actual - // aspect ratio. - // vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) ) - constexpr float k_source_reference_aspect = 4.f / 3.f; - const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect); - - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - vertical_fov, aspect_ratio, near, far); - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( - vertical_fov, aspect_ratio, near, far); - std::unreachable(); - }; -} // namespace omath::iw_engine diff --git a/source/engines/iw_engine/traits/camera_trait.cpp b/source/engines/iw_engine/traits/camera_trait.cpp index 14fbd7b..70794f1 100644 --- a/source/engines/iw_engine/traits/camera_trait.cpp +++ b/source/engines/iw_engine/traits/camera_trait.cpp @@ -2,26 +2,3 @@ // Created by Vlad on 8/11/2025. // #include "omath/engines/iw_engine/traits/camera_trait.hpp" -#include "omath/engines/iw_engine/formulas.hpp" -namespace omath::iw_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(-std::asin(direction.z)), - YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return iw_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::iw_engine \ No newline at end of file diff --git a/source/engines/opengl_engine/formulas.cpp b/source/engines/opengl_engine/formulas.cpp index 5a1a7e9..6b3c8b5 100644 --- a/source/engines/opengl_engine/formulas.cpp +++ b/source/engines/opengl_engine/formulas.cpp @@ -2,72 +2,3 @@ // Created by Vlad on 3/19/2025. // #include "omath/engines/opengl_engine/formulas.hpp" - -namespace omath::opengl_engine -{ - - Vector3 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 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 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& cam_origin) noexcept - { - return mat_look_at_right_handed(cam_origin, cam_origin + forward_vector(angles), up_vector(angles)); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.roll) - * mat_rotation_axis_y(angles.yaw) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.y), - RollAngle::from_degrees(angles.z), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_right_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_right_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - std::unreachable(); - } -} // namespace omath::opengl_engine diff --git a/source/engines/opengl_engine/traits/camera_trait.cpp b/source/engines/opengl_engine/traits/camera_trait.cpp index 6addb71..1797702 100644 --- a/source/engines/opengl_engine/traits/camera_trait.cpp +++ b/source/engines/opengl_engine/traits/camera_trait.cpp @@ -2,27 +2,3 @@ // Created by Vlad on 8/11/2025. // #include "omath/engines/opengl_engine/traits/camera_trait.hpp" -#include "omath/engines/opengl_engine/formulas.hpp" - -namespace omath::opengl_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(std::asin(direction.y)), - YawAngle::from_radians(-std::atan2(direction.x, -direction.z)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return opengl_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::opengl_engine \ No newline at end of file diff --git a/source/engines/rage_engine/formulas.cpp b/source/engines/rage_engine/formulas.cpp index 3ef1f38..99b070a 100644 --- a/source/engines/rage_engine/formulas.cpp +++ b/source/engines/rage_engine/formulas.cpp @@ -2,70 +2,3 @@ // Created by Orange on 6/3/2026. // #include "omath/engines/rage_engine/formulas.hpp" - -namespace omath::rage_engine -{ - Vector3 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 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 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& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.yaw) - * mat_rotation_axis_y(angles.roll) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(angles.y), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - std::unreachable(); - } -} // namespace omath::rage_engine diff --git a/source/engines/rage_engine/traits/camera_trait.cpp b/source/engines/rage_engine/traits/camera_trait.cpp index b9e7b28..df4f739 100644 --- a/source/engines/rage_engine/traits/camera_trait.cpp +++ b/source/engines/rage_engine/traits/camera_trait.cpp @@ -2,26 +2,3 @@ // Created by Orange on 6/3/2026. // #include "omath/engines/rage_engine/traits/camera_trait.hpp" - -namespace omath::rage_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(std::asin(direction.z)), - YawAngle::from_radians(-std::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return rage_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, const float far, - const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::rage_engine diff --git a/source/engines/source_engine/formulas.cpp b/source/engines/source_engine/formulas.cpp index c3c762b..6fcb5e1 100644 --- a/source/engines/source_engine/formulas.cpp +++ b/source/engines/source_engine/formulas.cpp @@ -2,78 +2,3 @@ // Created by Vlad on 3/19/2025. // #include - -namespace omath::source_engine -{ - Vector3 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) noexcept - { - return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.y), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(angles.x), - }; - } - - Vector3 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 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& 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 NDCDepthRange ndc_depth_range) noexcept - { - // Source (inherited from Quake) stores FOV as horizontal FOV at a 4:3 - // reference aspect. Convert to true vertical FOV, then delegate to the - // standard vertical-FOV left-handed builder with the caller's actual - // aspect ratio. - // vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) ) - constexpr float k_source_reference_aspect = 4.f / 3.f; - const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect); - - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - vertical_fov, aspect_ratio, near, far); - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( - vertical_fov, aspect_ratio, near, far); - std::unreachable(); - } -} // namespace omath::source_engine diff --git a/source/engines/source_engine/traits/camera_trait.cpp b/source/engines/source_engine/traits/camera_trait.cpp index 2663d34..d365696 100644 --- a/source/engines/source_engine/traits/camera_trait.cpp +++ b/source/engines/source_engine/traits/camera_trait.cpp @@ -2,27 +2,3 @@ // Created by Vlad on 8/11/2025. // #include "omath/engines/source_engine/traits/camera_trait.hpp" -#include "omath/engines/source_engine/formulas.hpp" -namespace omath::source_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - - return {PitchAngle::from_radians(-std::asin(direction.z)), - YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return source_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::source_engine \ No newline at end of file diff --git a/source/engines/unity_engine/formulas.cpp b/source/engines/unity_engine/formulas.cpp index 370191e..719f189 100644 --- a/source/engines/unity_engine/formulas.cpp +++ b/source/engines/unity_engine/formulas.cpp @@ -2,69 +2,3 @@ // Created by Vlad on 3/22/2025. // #include "omath/engines/unity_engine/formulas.hpp" - -namespace omath::unity_engine -{ - Vector3 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 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 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& cam_origin) noexcept - { - return mat_camera_view(-forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.roll) - * mat_rotation_axis_y(angles.yaw) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.y), - RollAngle::from_degrees(angles.z), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return omath::mat_perspective_right_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return omath::mat_perspective_right_handed_vertical_fov(field_of_view, aspect_ratio, - near, far); - std::unreachable(); - } -} // namespace omath::unity_engine diff --git a/source/engines/unity_engine/traits/camera_trait.cpp b/source/engines/unity_engine/traits/camera_trait.cpp index 1c88cb2..52fb651 100644 --- a/source/engines/unity_engine/traits/camera_trait.cpp +++ b/source/engines/unity_engine/traits/camera_trait.cpp @@ -2,26 +2,3 @@ // Created by Vlad on 8/11/2025. // #include "omath/engines/unity_engine/traits/camera_trait.hpp" - -namespace omath::unity_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(-std::asin(direction.y)), - YawAngle::from_radians(std::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return unity_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::unity_engine \ No newline at end of file diff --git a/source/engines/unreal_engine/formulas.cpp b/source/engines/unreal_engine/formulas.cpp index d972118..5820e54 100644 --- a/source/engines/unreal_engine/formulas.cpp +++ b/source/engines/unreal_engine/formulas.cpp @@ -2,76 +2,3 @@ // Created by Vlad on 3/22/2025. // #include "omath/engines/unreal_engine/formulas.hpp" -namespace omath::unreal_engine -{ - Vector3 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 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 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& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - // UE FRotator is intrinsic Z-Y-X (Yaw → Pitch → Roll applied in local - // frame), which for column-vector composition is Rz·Ry·Rx. - // Pitch and roll axes in omath spin opposite to UE's convention, so - // both carry a sign flip. - return mat_rotation_axis_z(angles.yaw) - * mat_rotation_axis_y(-angles.pitch) - * mat_rotation_axis_x(-angles.roll); - } - - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(-angles.y), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(-angles.x), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const double field_of_view, const double aspect_ratio, const double near, - const double far, const NDCDepthRange ndc_depth_range) noexcept - { - // UE stores horizontal FOV in FMinimalViewInfo — use the left-handed - // horizontal-FOV builder directly. - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_horizontal_fov< - double, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - field_of_view, aspect_ratio, near, far); - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_horizontal_fov< - double, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( - field_of_view, aspect_ratio, near, far); - std::unreachable(); - } -} // namespace omath::unreal_engine diff --git a/source/engines/unreal_engine/traits/camera_trait.cpp b/source/engines/unreal_engine/traits/camera_trait.cpp index f652d3e..24d8a38 100644 --- a/source/engines/unreal_engine/traits/camera_trait.cpp +++ b/source/engines/unreal_engine/traits/camera_trait.cpp @@ -2,26 +2,3 @@ // Created by Vlad on 8/11/2025. // #include "omath/engines/unreal_engine/traits/camera_trait.hpp" - -namespace omath::unreal_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(std::asin(direction.z)), - YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return unreal_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const double near, - const double far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::unreal_engine \ No newline at end of file diff --git a/tests/engines/unit_test_traits_engines.cpp b/tests/engines/unit_test_traits_engines.cpp index d01efc0..6d1a113 100644 --- a/tests/engines/unit_test_traits_engines.cpp +++ b/tests/engines/unit_test_traits_engines.cpp @@ -1,30 +1,40 @@ // Tests for engine trait headers to improve header coverage #include +#include #include #include #include +#include #include #include #include +#include #include #include #include +#include #include #include #include +#include #include #include #include +#include #include #include +#include #include +#include +#include + #include #include #include @@ -41,6 +51,43 @@ static void expect_matrix_near(const MatT& a, const MatT& b, float eps = 1e-5f) } // ── Launch offset tests for all engines ────────────────────────────────────── +#ifdef OMATH_USE_GCEM +template +constexpr bool matrix_has_non_zero_element(const MatType& mat) +{ + for (std::size_t r = 0; r < 4; ++r) + for (std::size_t c = 0; c < 4; ++c) + if (mat.at(r, c) != NumericType{0}) + return true; + + return false; +} + +template +constexpr bool camera_can_calculate_matrices_at_compile_time() +{ + using FieldOfView = projection::FieldOfView; + + CameraType camera{{}, {}, {1280.f, 720.f}, FieldOfView::from_degrees(90.f), NumericType{0.01}, NumericType{1000}}; + const auto view = camera.get_view_matrix(); + const auto projection = camera.get_projection_matrix(); + const auto view_projection = camera.get_view_projection_matrix(); + + return matrix_has_non_zero_element(view) + && matrix_has_non_zero_element(projection) + && matrix_has_non_zero_element(view_projection); +} + +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +#endif + #include // Helper: verify that zero offset matches default-initialized offset behavior diff --git a/tests/general/unit_test_projection.cpp b/tests/general/unit_test_projection.cpp index 8f3b79c..0c5cebd 100644 --- a/tests/general/unit_test_projection.cpp +++ b/tests/general/unit_test_projection.cpp @@ -60,15 +60,37 @@ static void verify_random_look_at_targets_project_to_screen_center(const omath:: } } +#ifdef OMATH_USE_GCEM +constexpr bool source_camera_constexpr_projection_round_trip() +{ + constexpr auto fov = omath::Angle::from_degrees(90.f); + constexpr auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, + fov, 0.01f, 1000.f); + + constexpr auto projected = cam.world_to_screen({1000.f, 0, 50.f}); + constexpr auto result = cam.screen_to_world(projected.value()); + constexpr auto result2 = cam.world_to_screen(result.value()); + + return projected.has_value() && result.has_value() && result2.has_value() + && static_cast>(projected.value()) + == static_cast>(result2.value()) + && omath::internal::abs(projected->x - 960.f) < 0.001f + && omath::internal::abs(projected->y - 504.f) < 0.001f + && omath::internal::abs(projected->z - 1.f) < 0.001f; +} + +static_assert(source_camera_constexpr_projection_round_trip()); +#endif + TEST(UnitTestProjection, Projection) { constexpr auto fov = omath::Angle::from_degrees(90.f); - const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov, + constexpr auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov, 0.01f, 1000.f); - const auto projected = cam.world_to_screen({1000.f, 0, 50.f}); - const auto result = cam.screen_to_world(projected.value()); - const auto result2 = cam.world_to_screen(result.value()); + constexpr auto projected = cam.world_to_screen({1000.f, 0, 50.f}); + constexpr auto result = cam.screen_to_world(projected.value()); + constexpr auto result2 = cam.world_to_screen(result.value()); EXPECT_EQ(static_cast>(projected.value()), static_cast>(result2.value())); From 098be538f78684f66aa4fa8d87ac5d2b9b59494d Mon Sep 17 00:00:00 2001 From: Orange Date: Sun, 14 Jun 2026 23:17:48 +0300 Subject: [PATCH 14/20] fix --- include/omath/engines/cry_engine/formulas.hpp | 6 +++--- .../omath/engines/cry_engine/traits/camera_trait.hpp | 5 +++-- include/omath/engines/frostbite_engine/formulas.hpp | 6 +++--- .../engines/frostbite_engine/traits/camera_trait.hpp | 5 +++-- include/omath/engines/iw_engine/formulas.hpp | 6 +++--- .../omath/engines/iw_engine/traits/camera_trait.hpp | 5 +++-- include/omath/engines/opengl_engine/formulas.hpp | 6 +++--- .../engines/opengl_engine/traits/camera_trait.hpp | 5 +++-- include/omath/engines/rage_engine/formulas.hpp | 6 +++--- .../engines/rage_engine/traits/camera_trait.hpp | 5 +++-- include/omath/engines/source_engine/formulas.hpp | 6 +++--- .../engines/source_engine/traits/camera_trait.hpp | 5 +++-- include/omath/engines/unity_engine/formulas.hpp | 6 +++--- .../engines/unity_engine/traits/camera_trait.hpp | 5 +++-- include/omath/engines/unreal_engine/formulas.hpp | 6 +++--- .../engines/unreal_engine/traits/camera_trait.hpp | 5 +++-- tests/general/unit_test_projection.cpp | 12 ++++++------ 17 files changed, 54 insertions(+), 46 deletions(-) diff --git a/include/omath/engines/cry_engine/formulas.hpp b/include/omath/engines/cry_engine/formulas.hpp index 0338260..18d8e9a 100644 --- a/include/omath/engines/cry_engine/formulas.hpp +++ b/include/omath/engines/cry_engine/formulas.hpp @@ -70,17 +70,17 @@ namespace omath::cry_engine } [[nodiscard]] inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const float field_of_view, const float aspect_ratio, const float near, const float far, + const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/cry_engine/traits/camera_trait.hpp b/include/omath/engines/cry_engine/traits/camera_trait.hpp index 58e2927..7137581 100644 --- a/include/omath/engines/cry_engine/traits/camera_trait.hpp +++ b/include/omath/engines/cry_engine/traits/camera_trait.hpp @@ -29,9 +29,10 @@ namespace omath::cry_engine [[nodiscard]] OMATH_CONSTEXPR static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + const float near_plane, const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); } }; diff --git a/include/omath/engines/frostbite_engine/formulas.hpp b/include/omath/engines/frostbite_engine/formulas.hpp index 7f7b115..3ea697e 100644 --- a/include/omath/engines/frostbite_engine/formulas.hpp +++ b/include/omath/engines/frostbite_engine/formulas.hpp @@ -75,17 +75,17 @@ namespace omath::frostbite_engine [[nodiscard]] inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const float field_of_view, const float aspect_ratio, const float near, const float far, + const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp index 9156a76..866f188 100644 --- a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp +++ b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp @@ -31,9 +31,10 @@ namespace omath::frostbite_engine [[nodiscard]] OMATH_CONSTEXPR static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + const float near_plane, const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); } }; diff --git a/include/omath/engines/iw_engine/formulas.hpp b/include/omath/engines/iw_engine/formulas.hpp index 6cb962f..042af08 100644 --- a/include/omath/engines/iw_engine/formulas.hpp +++ b/include/omath/engines/iw_engine/formulas.hpp @@ -72,7 +72,7 @@ namespace omath::iw_engine [[nodiscard]] inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const float field_of_view, const float aspect_ratio, const float near, const float far, + const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { constexpr float k_source_reference_aspect = 4.f / 3.f; @@ -80,11 +80,11 @@ namespace omath::iw_engine if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return mat_perspective_left_handed_vertical_fov( - vertical_fov, aspect_ratio, near, far); + vertical_fov, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) return mat_perspective_left_handed_vertical_fov( - vertical_fov, aspect_ratio, near, far); + vertical_fov, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/iw_engine/traits/camera_trait.hpp b/include/omath/engines/iw_engine/traits/camera_trait.hpp index a50a87d..10be763 100644 --- a/include/omath/engines/iw_engine/traits/camera_trait.hpp +++ b/include/omath/engines/iw_engine/traits/camera_trait.hpp @@ -31,9 +31,10 @@ namespace omath::iw_engine [[nodiscard]] OMATH_CONSTEXPR static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + const float near_plane, const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); } }; diff --git a/include/omath/engines/opengl_engine/formulas.hpp b/include/omath/engines/opengl_engine/formulas.hpp index c74c0a4..424d337 100644 --- a/include/omath/engines/opengl_engine/formulas.hpp +++ b/include/omath/engines/opengl_engine/formulas.hpp @@ -75,18 +75,18 @@ namespace omath::opengl_engine [[nodiscard]] inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const float field_of_view, const float aspect_ratio, const float near, const float far, + const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) return mat_perspective_right_handed_vertical_fov< float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return mat_perspective_right_handed_vertical_fov< float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/opengl_engine/traits/camera_trait.hpp b/include/omath/engines/opengl_engine/traits/camera_trait.hpp index f16457c..cd0e43e 100644 --- a/include/omath/engines/opengl_engine/traits/camera_trait.hpp +++ b/include/omath/engines/opengl_engine/traits/camera_trait.hpp @@ -32,9 +32,10 @@ namespace omath::opengl_engine [[nodiscard]] OMATH_CONSTEXPR static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + const float near_plane, const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); } }; diff --git a/include/omath/engines/rage_engine/formulas.hpp b/include/omath/engines/rage_engine/formulas.hpp index f2bc04f..d89493b 100644 --- a/include/omath/engines/rage_engine/formulas.hpp +++ b/include/omath/engines/rage_engine/formulas.hpp @@ -76,17 +76,17 @@ namespace omath::rage_engine [[nodiscard]] inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const float field_of_view, const float aspect_ratio, const float near, const float far, + const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/rage_engine/traits/camera_trait.hpp b/include/omath/engines/rage_engine/traits/camera_trait.hpp index 8395af8..7dc013f 100644 --- a/include/omath/engines/rage_engine/traits/camera_trait.hpp +++ b/include/omath/engines/rage_engine/traits/camera_trait.hpp @@ -31,9 +31,10 @@ namespace omath::rage_engine [[nodiscard]] OMATH_CONSTEXPR static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + const float near_plane, const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); } }; diff --git a/include/omath/engines/source_engine/formulas.hpp b/include/omath/engines/source_engine/formulas.hpp index 60e3d7c..5a7b523 100644 --- a/include/omath/engines/source_engine/formulas.hpp +++ b/include/omath/engines/source_engine/formulas.hpp @@ -71,7 +71,7 @@ namespace omath::source_engine [[nodiscard]] inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const float field_of_view, const float aspect_ratio, const float near, const float far, + const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { constexpr float k_source_reference_aspect = 4.f / 3.f; @@ -79,11 +79,11 @@ namespace omath::source_engine if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return mat_perspective_left_handed_vertical_fov( - vertical_fov, aspect_ratio, near, far); + vertical_fov, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) return mat_perspective_left_handed_vertical_fov( - vertical_fov, aspect_ratio, near, far); + vertical_fov, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/source_engine/traits/camera_trait.hpp b/include/omath/engines/source_engine/traits/camera_trait.hpp index 09d9ed9..61cc9c7 100644 --- a/include/omath/engines/source_engine/traits/camera_trait.hpp +++ b/include/omath/engines/source_engine/traits/camera_trait.hpp @@ -31,9 +31,10 @@ namespace omath::source_engine [[nodiscard]] OMATH_CONSTEXPR static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + const float near_plane, const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); } }; diff --git a/include/omath/engines/unity_engine/formulas.hpp b/include/omath/engines/unity_engine/formulas.hpp index 65e8356..350b30b 100644 --- a/include/omath/engines/unity_engine/formulas.hpp +++ b/include/omath/engines/unity_engine/formulas.hpp @@ -75,17 +75,17 @@ namespace omath::unity_engine [[nodiscard]] inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const float field_of_view, const float aspect_ratio, const float near, const float far, + const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return omath::mat_perspective_right_handed_vertical_fov< float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) return omath::mat_perspective_right_handed_vertical_fov< float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/unity_engine/traits/camera_trait.hpp b/include/omath/engines/unity_engine/traits/camera_trait.hpp index c7b89ed..08faafb 100644 --- a/include/omath/engines/unity_engine/traits/camera_trait.hpp +++ b/include/omath/engines/unity_engine/traits/camera_trait.hpp @@ -31,9 +31,10 @@ namespace omath::unity_engine [[nodiscard]] OMATH_CONSTEXPR static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near, const float far, const NDCDepthRange ndc_depth_range) noexcept + const float near_plane, const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); } }; diff --git a/include/omath/engines/unreal_engine/formulas.hpp b/include/omath/engines/unreal_engine/formulas.hpp index 4df684d..558afb7 100644 --- a/include/omath/engines/unreal_engine/formulas.hpp +++ b/include/omath/engines/unreal_engine/formulas.hpp @@ -75,17 +75,17 @@ namespace omath::unreal_engine [[nodiscard]] inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const double field_of_view, const double aspect_ratio, const double near, const double far, + const double field_of_view, const double aspect_ratio, const double near_plane, const double far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return mat_perspective_left_handed_horizontal_fov< double, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) return mat_perspective_left_handed_horizontal_fov< double, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( - field_of_view, aspect_ratio, near, far); + field_of_view, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/unreal_engine/traits/camera_trait.hpp b/include/omath/engines/unreal_engine/traits/camera_trait.hpp index 826e17d..cb04cec 100644 --- a/include/omath/engines/unreal_engine/traits/camera_trait.hpp +++ b/include/omath/engines/unreal_engine/traits/camera_trait.hpp @@ -31,9 +31,10 @@ namespace omath::unreal_engine [[nodiscard]] OMATH_CONSTEXPR static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const double near, const double far, const NDCDepthRange ndc_depth_range) noexcept + const double near_plane, const double far_plane, + const NDCDepthRange ndc_depth_range) noexcept { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, + return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); } }; diff --git a/tests/general/unit_test_projection.cpp b/tests/general/unit_test_projection.cpp index 0c5cebd..8c7f4b9 100644 --- a/tests/general/unit_test_projection.cpp +++ b/tests/general/unit_test_projection.cpp @@ -84,13 +84,13 @@ static_assert(source_camera_constexpr_projection_round_trip()); TEST(UnitTestProjection, Projection) { - constexpr auto fov = omath::Angle::from_degrees(90.f); - constexpr auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov, - 0.01f, 1000.f); + OMATH_CONSTEXPR auto fov = omath::Angle::from_degrees(90.f); + OMATH_CONSTEXPR auto cam = omath::source_engine::Camera( + {0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov, 0.01f, 1000.f); - constexpr auto projected = cam.world_to_screen({1000.f, 0, 50.f}); - constexpr auto result = cam.screen_to_world(projected.value()); - constexpr auto result2 = cam.world_to_screen(result.value()); + OMATH_CONSTEXPR auto projected = cam.world_to_screen({1000.f, 0, 50.f}); + OMATH_CONSTEXPR auto result = cam.screen_to_world(projected.value()); + OMATH_CONSTEXPR auto result2 = cam.world_to_screen(result.value()); EXPECT_EQ(static_cast>(projected.value()), static_cast>(result2.value())); From 43823c8fdca4f5c5b0684bb7df409489a34d2883 Mon Sep 17 00:00:00 2001 From: Orange Date: Sun, 14 Jun 2026 23:26:24 +0300 Subject: [PATCH 15/20] fix --- include/omath/projection/camera.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/omath/projection/camera.hpp b/include/omath/projection/camera.hpp index a753341..050be14 100644 --- a/include/omath/projection/camera.hpp +++ b/include/omath/projection/camera.hpp @@ -463,7 +463,7 @@ namespace omath::projection world_to_view_port(const Vector3& world_position, const ViewPortClipping& clipping = ViewPortClipping::AUTO) const noexcept { - auto project_to_view_port = [this, &clipping](auto projected) -> std::expected, Error> + auto project_to_view_port = [&clipping](auto projected) -> std::expected, Error> { const auto& w = projected.at(3, 0); constexpr auto eps = std::numeric_limits::epsilon(); From a2a09fa8a6d51a24a4b0e1069e914fe5439e977b Mon Sep 17 00:00:00 2001 From: Orange Date: Sun, 14 Jun 2026 23:47:25 +0300 Subject: [PATCH 16/20] removed .cpp for engines since they are no longer used --- source/engines/frostbite_engine/formulas.cpp | 4 ---- source/engines/frostbite_engine/traits/camera_trait.cpp | 4 ---- source/engines/iw_engine/formulas.cpp | 4 ---- source/engines/iw_engine/traits/camera_trait.cpp | 4 ---- source/engines/opengl_engine/formulas.cpp | 4 ---- source/engines/opengl_engine/traits/camera_trait.cpp | 4 ---- source/engines/rage_engine/formulas.cpp | 4 ---- source/engines/rage_engine/traits/camera_trait.cpp | 4 ---- source/engines/source_engine/formulas.cpp | 4 ---- source/engines/source_engine/traits/camera_trait.cpp | 4 ---- source/engines/unity_engine/formulas.cpp | 4 ---- source/engines/unity_engine/traits/camera_trait.cpp | 4 ---- source/engines/unreal_engine/formulas.cpp | 4 ---- source/engines/unreal_engine/traits/camera_trait.cpp | 4 ---- 14 files changed, 56 deletions(-) delete mode 100644 source/engines/frostbite_engine/formulas.cpp delete mode 100644 source/engines/frostbite_engine/traits/camera_trait.cpp delete mode 100644 source/engines/iw_engine/formulas.cpp delete mode 100644 source/engines/iw_engine/traits/camera_trait.cpp delete mode 100644 source/engines/opengl_engine/formulas.cpp delete mode 100644 source/engines/opengl_engine/traits/camera_trait.cpp delete mode 100644 source/engines/rage_engine/formulas.cpp delete mode 100644 source/engines/rage_engine/traits/camera_trait.cpp delete mode 100644 source/engines/source_engine/formulas.cpp delete mode 100644 source/engines/source_engine/traits/camera_trait.cpp delete mode 100644 source/engines/unity_engine/formulas.cpp delete mode 100644 source/engines/unity_engine/traits/camera_trait.cpp delete mode 100644 source/engines/unreal_engine/formulas.cpp delete mode 100644 source/engines/unreal_engine/traits/camera_trait.cpp diff --git a/source/engines/frostbite_engine/formulas.cpp b/source/engines/frostbite_engine/formulas.cpp deleted file mode 100644 index f0a73c4..0000000 --- a/source/engines/frostbite_engine/formulas.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 3/22/2025. -// -#include "omath/engines/frostbite_engine/formulas.hpp" diff --git a/source/engines/frostbite_engine/traits/camera_trait.cpp b/source/engines/frostbite_engine/traits/camera_trait.cpp deleted file mode 100644 index cf7a896..0000000 --- a/source/engines/frostbite_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/frostbite_engine/traits/camera_trait.hpp" diff --git a/source/engines/iw_engine/formulas.cpp b/source/engines/iw_engine/formulas.cpp deleted file mode 100644 index 6b1cc8e..0000000 --- a/source/engines/iw_engine/formulas.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 3/19/2025. -// -#include "omath/engines/iw_engine/formulas.hpp" diff --git a/source/engines/iw_engine/traits/camera_trait.cpp b/source/engines/iw_engine/traits/camera_trait.cpp deleted file mode 100644 index 70794f1..0000000 --- a/source/engines/iw_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/iw_engine/traits/camera_trait.hpp" diff --git a/source/engines/opengl_engine/formulas.cpp b/source/engines/opengl_engine/formulas.cpp deleted file mode 100644 index 6b3c8b5..0000000 --- a/source/engines/opengl_engine/formulas.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 3/19/2025. -// -#include "omath/engines/opengl_engine/formulas.hpp" diff --git a/source/engines/opengl_engine/traits/camera_trait.cpp b/source/engines/opengl_engine/traits/camera_trait.cpp deleted file mode 100644 index 1797702..0000000 --- a/source/engines/opengl_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/opengl_engine/traits/camera_trait.hpp" diff --git a/source/engines/rage_engine/formulas.cpp b/source/engines/rage_engine/formulas.cpp deleted file mode 100644 index 99b070a..0000000 --- a/source/engines/rage_engine/formulas.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Orange on 6/3/2026. -// -#include "omath/engines/rage_engine/formulas.hpp" diff --git a/source/engines/rage_engine/traits/camera_trait.cpp b/source/engines/rage_engine/traits/camera_trait.cpp deleted file mode 100644 index df4f739..0000000 --- a/source/engines/rage_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Orange on 6/3/2026. -// -#include "omath/engines/rage_engine/traits/camera_trait.hpp" diff --git a/source/engines/source_engine/formulas.cpp b/source/engines/source_engine/formulas.cpp deleted file mode 100644 index 6fcb5e1..0000000 --- a/source/engines/source_engine/formulas.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 3/19/2025. -// -#include diff --git a/source/engines/source_engine/traits/camera_trait.cpp b/source/engines/source_engine/traits/camera_trait.cpp deleted file mode 100644 index d365696..0000000 --- a/source/engines/source_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/source_engine/traits/camera_trait.hpp" diff --git a/source/engines/unity_engine/formulas.cpp b/source/engines/unity_engine/formulas.cpp deleted file mode 100644 index 719f189..0000000 --- a/source/engines/unity_engine/formulas.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 3/22/2025. -// -#include "omath/engines/unity_engine/formulas.hpp" diff --git a/source/engines/unity_engine/traits/camera_trait.cpp b/source/engines/unity_engine/traits/camera_trait.cpp deleted file mode 100644 index 52fb651..0000000 --- a/source/engines/unity_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/unity_engine/traits/camera_trait.hpp" diff --git a/source/engines/unreal_engine/formulas.cpp b/source/engines/unreal_engine/formulas.cpp deleted file mode 100644 index 5820e54..0000000 --- a/source/engines/unreal_engine/formulas.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 3/22/2025. -// -#include "omath/engines/unreal_engine/formulas.hpp" diff --git a/source/engines/unreal_engine/traits/camera_trait.cpp b/source/engines/unreal_engine/traits/camera_trait.cpp deleted file mode 100644 index 24d8a38..0000000 --- a/source/engines/unreal_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/unreal_engine/traits/camera_trait.hpp" From 75c3f2409d41904f86e869a08b7910cafd70cbea Mon Sep 17 00:00:00 2001 From: Orange Date: Sun, 14 Jun 2026 23:57:58 +0300 Subject: [PATCH 17/20] added modules support --- CMakeLists.txt | 21 +++++++++ include/omath/linear_algebra/mat.hpp | 6 +-- modules/omath.cppm | 64 ++++++++++++++++++++++++++++ tests/CMakeLists.txt | 5 +++ tests/modules/unit_test_module.cpp | 11 +++++ 5 files changed, 104 insertions(+), 3 deletions(-) create mode 100644 modules/omath.cppm create mode 100644 tests/modules/unit_test_module.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 8da5a63..14f03a3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,6 +34,7 @@ option(OMATH_ENABLE_LUA "omath bindings for lua" OFF) option(OMATH_ENABLE_HOOKING "omath will HooksManager that can hook DirectX/OpenGL automatically" OFF) option(OMATH_USE_GCEM "omath will use gcem library to make more functions/methods constexpr" OFF) +option(OMATH_ENABLE_MODULES "Build omath C++ module interface" OFF) if(VCPKG_MANIFEST_FEATURES) foreach(omath_feature IN LISTS VCPKG_MANIFEST_FEATURES) @@ -84,6 +85,7 @@ if(${PROJECT_IS_TOP_LEVEL}) message(STATUS "[${PROJECT_NAME}]: Valgrind feature status ${OMATH_ENABLE_VALGRIND}") message(STATUS "[${PROJECT_NAME}]: Lua feature status ${OMATH_ENABLE_LUA}") message(STATUS "[${PROJECT_NAME}]: Gcem feature status ${OMATH_USE_GCEM}") + message(STATUS "[${PROJECT_NAME}]: Modules feature status ${OMATH_ENABLE_MODULES}") endif() if(OMATH_STATIC_MSVC_RUNTIME_LIBRARY) @@ -99,6 +101,20 @@ else() add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS}) endif() +if(OMATH_ENABLE_MODULES) + if(CMAKE_VERSION VERSION_LESS 3.28) + message(FATAL_ERROR "OMATH_ENABLE_MODULES requires CMake 3.28 or newer") + endif() + set_target_properties(${PROJECT_NAME} PROPERTIES CXX_SCAN_FOR_MODULES ON) + if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") + target_compile_options(${PROJECT_NAME} PRIVATE /wd5244) + endif() + target_sources( + ${PROJECT_NAME} + PUBLIC FILE_SET omath_modules TYPE CXX_MODULES BASE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/modules" + FILES "${CMAKE_CURRENT_SOURCE_DIR}/modules/omath.cppm") +endif() + if (OMATH_ENABLE_LUA) target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LUA) @@ -239,6 +255,10 @@ target_include_directories( # Installation rules +if(OMATH_ENABLE_MODULES) + set(OMATH_MODULE_FILE_SET FILE_SET omath_modules DESTINATION modules) +endif() + # Install the library install( TARGETS ${PROJECT_NAME} @@ -247,6 +267,7 @@ install( LIBRARY DESTINATION lib COMPONENT ${PROJECT_NAME} # For shared libraries RUNTIME DESTINATION bin COMPONENT ${PROJECT_NAME} # For executables (on # Windows) + ${OMATH_MODULE_FILE_SET} ) # Install headers as part of omath_component diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index 231d215..17f501f 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -588,13 +588,13 @@ namespace omath }; template [[nodiscard("You must use row matrix")]] - constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3& vector) noexcept + constexpr Mat<1, 4, Type, St> mat_row_from_vector(const Vector3& vector) noexcept { return {{vector.x, vector.y, vector.z, 1}}; } template [[nodiscard("You must use column matrix")]] - constexpr static Mat<4, 1, Type, St> mat_column_from_vector(const Vector3& vector) noexcept + constexpr Mat<4, 1, Type, St> mat_column_from_vector(const Vector3& vector) noexcept { return {{vector.x}, {vector.y}, {vector.z}, {1}}; } @@ -711,7 +711,7 @@ namespace omath template [[nodiscard("You must use camera view matrix")]] - OMATH_CONSTEXPR static Mat<4, 4, Type, St> mat_camera_view(const Vector3& forward, const Vector3& right, + OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_camera_view(const Vector3& forward, const Vector3& right, const Vector3& up, const Vector3& camera_origin) noexcept { return Mat<4, 4, Type, St> diff --git a/modules/omath.cppm b/modules/omath.cppm new file mode 100644 index 0000000..f879c84 --- /dev/null +++ b/modules/omath.cppm @@ -0,0 +1,64 @@ +module; + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(OMATH_USE_AVX2) +#include +#endif + +#if defined(OMATH_USE_GCEM) +#include +#endif + +#if defined(OMATH_IMGUI_INTEGRATION) +#include +#endif + +#if defined(_WIN32) +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include +#elif defined(__APPLE__) +#include +#elif defined(__linux__) || defined(__unix__) +#include +#endif + +export module omath; + +export +{ +#include "omath/omath.hpp" +} diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 824b6e9..d3d00b9 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -7,6 +7,11 @@ include(GoogleTest) file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/general/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/engines/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp") add_executable(${PROJECT_NAME} ${UNIT_TESTS_SOURCES} main.cpp) +if(OMATH_ENABLE_MODULES) + set_target_properties(${PROJECT_NAME} PROPERTIES CXX_SCAN_FOR_MODULES ON) + target_sources(${PROJECT_NAME} PRIVATE modules/unit_test_module.cpp) +endif() + set_target_properties( ${PROJECT_NAME} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}" diff --git a/tests/modules/unit_test_module.cpp b/tests/modules/unit_test_module.cpp new file mode 100644 index 0000000..e174663 --- /dev/null +++ b/tests/modules/unit_test_module.cpp @@ -0,0 +1,11 @@ +#include + +import omath; + +TEST(UnitTestModule, ImportOmath) +{ + const omath::Vector2 vec{1.f, 2.f}; + + EXPECT_FLOAT_EQ(vec.x, 1.f); + EXPECT_FLOAT_EQ(vec.y, 2.f); +} From 47dcee037e2daf64d6a867931514b4df39fac71d Mon Sep 17 00:00:00 2001 From: Orange Date: Mon, 15 Jun 2026 00:37:47 +0300 Subject: [PATCH 18/20] removed gcem as dep --- CMakeLists.txt | 9 - CMakePresets.json | 4 +- CREDITS.md | 4 +- include/omath/engines/cry_engine/formulas.hpp | 23 +- .../cry_engine/traits/camera_trait.hpp | 17 +- .../engines/frostbite_engine/formulas.hpp | 21 +- .../frostbite_engine/traits/camera_trait.hpp | 19 +- include/omath/engines/iw_engine/formulas.hpp | 21 +- .../engines/iw_engine/traits/camera_trait.hpp | 17 +- .../omath/engines/opengl_engine/formulas.hpp | 31 +- .../opengl_engine/traits/camera_trait.hpp | 20 +- .../omath/engines/rage_engine/formulas.hpp | 26 +- .../rage_engine/traits/camera_trait.hpp | 17 +- .../omath/engines/source_engine/formulas.hpp | 21 +- .../source_engine/traits/camera_trait.hpp | 17 +- .../omath/engines/unity_engine/formulas.hpp | 29 +- .../unity_engine/traits/camera_trait.hpp | 17 +- .../omath/engines/unreal_engine/formulas.hpp | 33 +- .../unreal_engine/traits/camera_trait.hpp | 17 +- include/omath/internal/constexpr_math.hpp | 707 ++++++++++++++++++ .../internal/optional_constexpr_math.hpp | 185 ----- include/omath/linear_algebra/mat.hpp | 227 +++--- include/omath/linear_algebra/triangle.hpp | 6 +- include/omath/linear_algebra/vector2.hpp | 16 +- include/omath/linear_algebra/vector3.hpp | 27 +- include/omath/projection/camera.hpp | 62 +- include/omath/trigonometry/angle.hpp | 12 +- include/omath/trigonometry/angles.hpp | 13 +- modules/omath.cppm | 9 +- tests/engines/unit_test_cry_engine.cpp | 12 +- tests/engines/unit_test_traits_engines.cpp | 182 +++-- tests/general/unit_test_angle.cpp | 19 +- tests/general/unit_test_mat.cpp | 91 +-- tests/general/unit_test_projection.cpp | 281 +++---- tests/general/unit_test_triangle.cpp | 39 +- tests/general/unit_test_vector2.cpp | 9 +- tests/general/unit_test_vector3.cpp | 11 +- vcpkg.json | 7 - 38 files changed, 1351 insertions(+), 927 deletions(-) create mode 100644 include/omath/internal/constexpr_math.hpp delete mode 100644 include/omath/internal/optional_constexpr_math.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 14f03a3..14e645d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,7 +33,6 @@ option(OMATH_ENABLE_FORCE_INLINE option(OMATH_ENABLE_LUA "omath bindings for lua" OFF) option(OMATH_ENABLE_HOOKING "omath will HooksManager that can hook DirectX/OpenGL automatically" OFF) -option(OMATH_USE_GCEM "omath will use gcem library to make more functions/methods constexpr" OFF) option(OMATH_ENABLE_MODULES "Build omath C++ module interface" OFF) if(VCPKG_MANIFEST_FEATURES) @@ -52,8 +51,6 @@ if(VCPKG_MANIFEST_FEATURES) set(OMATH_ENABLE_LUA ON) elseif(omath_feature STREQUAL "hooking") set(OMATH_ENABLE_HOOKING ON) - elseif (omath_feature STREQUAL "gcem") - set(OMATH_USE_GCEM ON) endif() endforeach() @@ -84,7 +81,6 @@ if(${PROJECT_IS_TOP_LEVEL}) message(STATUS "[${PROJECT_NAME}]: Coverage feature status ${OMATH_ENABLE_COVERAGE}") message(STATUS "[${PROJECT_NAME}]: Valgrind feature status ${OMATH_ENABLE_VALGRIND}") message(STATUS "[${PROJECT_NAME}]: Lua feature status ${OMATH_ENABLE_LUA}") - message(STATUS "[${PROJECT_NAME}]: Gcem feature status ${OMATH_USE_GCEM}") message(STATUS "[${PROJECT_NAME}]: Modules feature status ${OMATH_ENABLE_MODULES}") endif() @@ -141,11 +137,6 @@ if (OMATH_ENABLE_HOOKING) endif () -if (OMATH_USE_GCEM) - target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_USE_GCEM) - find_package(gcem CONFIG REQUIRED) - target_link_libraries(${PROJECT_NAME} PUBLIC gcem) -endif () add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME}) target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}") diff --git a/CMakePresets.json b/CMakePresets.json index 8780fa2..2ed29f2 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -57,7 +57,7 @@ "inherits": ["windows-base", "vcpkg-base"], "cacheVariables": { "VCPKG_TARGET_TRIPLET": "x64-windows-static", - "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;hooking;gcem", + "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;hooking", "OMATH_STATIC_MSVC_RUNTIME_LIBRARY": "ON" } }, @@ -239,7 +239,7 @@ "hidden": true, "inherits": ["darwin-base", "vcpkg-base"], "cacheVariables": { - "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;lua;gcem" + "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;lua" } }, { diff --git a/CREDITS.md b/CREDITS.md index 4be25b1..aafc5cd 100644 --- a/CREDITS.md +++ b/CREDITS.md @@ -4,8 +4,8 @@ Thanks to everyone who made this possible, including: - Saikari aka luadebug for VCPKG port and awesome new initial logo design. - Billy O'Neal aka BillyONeal for fixing compilation issues due to C math library compatibility. -- Alex2772 for reference of AUI declarative interface design for omath::hud - +- Alex2772 for reference of AUI declarative interface design for omath::hud. +- Keith O'Hara aka kthohr for a C++ generalized constant expression-based math library that was used as reference. And a big hand to everyone else who has contributed over the past! THANKS! <3 diff --git a/include/omath/engines/cry_engine/formulas.hpp b/include/omath/engines/cry_engine/formulas.hpp index 18d8e9a..abf0665 100644 --- a/include/omath/engines/cry_engine/formulas.hpp +++ b/include/omath/engines/cry_engine/formulas.hpp @@ -8,7 +8,7 @@ namespace omath::cry_engine { [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept { return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.roll) @@ -16,7 +16,7 @@ namespace omath::cry_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 forward_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); @@ -24,7 +24,7 @@ namespace omath::cry_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); @@ -32,7 +32,7 @@ namespace omath::cry_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); @@ -40,26 +40,26 @@ namespace omath::cry_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept { return mat_extract_origin(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept { return mat_extract_scale(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept { const auto angles = mat_extract_rotation_zyx(mat); return { @@ -69,9 +69,10 @@ namespace omath::cry_engine }; } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, - const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept + inline constexpr Mat4X4 + calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near_plane, + const float far_plane, + const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return mat_perspective_left_handed_vertical_fov( diff --git a/include/omath/engines/cry_engine/traits/camera_trait.hpp b/include/omath/engines/cry_engine/traits/camera_trait.hpp index 7137581..2f9f751 100644 --- a/include/omath/engines/cry_engine/traits/camera_trait.hpp +++ b/include/omath/engines/cry_engine/traits/camera_trait.hpp @@ -4,7 +4,7 @@ #pragma once #include "omath/engines/cry_engine/formulas.hpp" -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::cry_engine { @@ -12,8 +12,8 @@ namespace omath::cry_engine { public: [[nodiscard]] - OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, - const Vector3& look_at) noexcept + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept { const auto direction = (look_at - cam_origin).normalized(); return {PitchAngle::from_radians(internal::asin(direction.z)), @@ -21,16 +21,15 @@ namespace omath::cry_engine } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return cry_engine::calc_view_matrix(angles, cam_origin); } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 - calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near_plane, const float far_plane, - const NDCDepthRange ndc_depth_range) noexcept + constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, + const projection::ViewPort& view_port, const float near_plane, + const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); diff --git a/include/omath/engines/frostbite_engine/formulas.hpp b/include/omath/engines/frostbite_engine/formulas.hpp index 3ea697e..9212c2c 100644 --- a/include/omath/engines/frostbite_engine/formulas.hpp +++ b/include/omath/engines/frostbite_engine/formulas.hpp @@ -8,10 +8,10 @@ namespace omath::frostbite_engine { [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 forward_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); @@ -19,7 +19,7 @@ namespace omath::frostbite_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); @@ -27,7 +27,7 @@ namespace omath::frostbite_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); @@ -35,15 +35,14 @@ namespace omath::frostbite_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept { return mat_rotation_axis_z(angles.roll) * mat_rotation_axis_y(angles.yaw) @@ -51,19 +50,19 @@ namespace omath::frostbite_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept { return mat_extract_origin(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept { return mat_extract_scale(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept { const auto angles = mat_extract_rotation_zyx(mat); return { @@ -74,7 +73,7 @@ namespace omath::frostbite_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + inline constexpr Mat4X4 calc_perspective_projection_matrix( const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { diff --git a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp index 866f188..2e3074d 100644 --- a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp +++ b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp @@ -4,7 +4,7 @@ #pragma once #include "omath/engines/frostbite_engine/formulas.hpp" -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::frostbite_engine @@ -13,8 +13,8 @@ namespace omath::frostbite_engine { public: [[nodiscard]] - OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, - const Vector3& look_at) noexcept + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept { const auto direction = (look_at - cam_origin).normalized(); @@ -23,20 +23,19 @@ namespace omath::frostbite_engine } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return frostbite_engine::calc_view_matrix(angles, cam_origin); } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 - calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near_plane, const float far_plane, - const NDCDepthRange ndc_depth_range) noexcept + constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, + const projection::ViewPort& view_port, const float near_plane, + const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); } }; -} // namespace omath::unreal_engine +} // namespace omath::frostbite_engine diff --git a/include/omath/engines/iw_engine/formulas.hpp b/include/omath/engines/iw_engine/formulas.hpp index 042af08..24a16b7 100644 --- a/include/omath/engines/iw_engine/formulas.hpp +++ b/include/omath/engines/iw_engine/formulas.hpp @@ -8,10 +8,10 @@ namespace omath::iw_engine { [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 forward_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); @@ -19,7 +19,7 @@ namespace omath::iw_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); @@ -27,7 +27,7 @@ namespace omath::iw_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); @@ -35,25 +35,25 @@ namespace omath::iw_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + inline constexpr 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); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept { return mat_extract_origin(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept { return mat_extract_scale(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept { const auto angles = mat_extract_rotation_zyx(mat); return { @@ -64,14 +64,13 @@ namespace omath::iw_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + inline constexpr Mat4X4 calc_perspective_projection_matrix( const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { diff --git a/include/omath/engines/iw_engine/traits/camera_trait.hpp b/include/omath/engines/iw_engine/traits/camera_trait.hpp index 10be763..0143ea2 100644 --- a/include/omath/engines/iw_engine/traits/camera_trait.hpp +++ b/include/omath/engines/iw_engine/traits/camera_trait.hpp @@ -4,7 +4,7 @@ #pragma once #include "omath/engines/iw_engine/formulas.hpp" -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::iw_engine @@ -13,8 +13,8 @@ namespace omath::iw_engine { public: [[nodiscard]] - OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, - const Vector3& look_at) noexcept + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept { const auto direction = (look_at - cam_origin).normalized(); @@ -23,16 +23,15 @@ namespace omath::iw_engine } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return iw_engine::calc_view_matrix(angles, cam_origin); } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 - calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near_plane, const float far_plane, - const NDCDepthRange ndc_depth_range) noexcept + constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, + const projection::ViewPort& view_port, const float near_plane, + const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); diff --git a/include/omath/engines/opengl_engine/formulas.hpp b/include/omath/engines/opengl_engine/formulas.hpp index 424d337..05ae176 100644 --- a/include/omath/engines/opengl_engine/formulas.hpp +++ b/include/omath/engines/opengl_engine/formulas.hpp @@ -7,10 +7,10 @@ namespace omath::opengl_engine { [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 forward_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); @@ -19,7 +19,7 @@ namespace omath::opengl_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); @@ -28,7 +28,7 @@ namespace omath::opengl_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); @@ -36,14 +36,13 @@ namespace omath::opengl_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return mat_look_at_right_handed(cam_origin, cam_origin + forward_vector(angles), up_vector(angles)); } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept { return mat_rotation_axis_z(angles.roll) * mat_rotation_axis_y(angles.yaw) @@ -51,19 +50,19 @@ namespace omath::opengl_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept { return mat_extract_origin(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept { return mat_extract_scale(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept { const auto angles = mat_extract_rotation_zyx(mat); return { @@ -74,19 +73,19 @@ namespace omath::opengl_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + inline constexpr Mat4X4 calc_perspective_projection_matrix( const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_right_handed_vertical_fov< - float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( + return mat_perspective_right_handed_vertical_fov( field_of_view, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_right_handed_vertical_fov< - float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - field_of_view, aspect_ratio, near_plane, far_plane); + return mat_perspective_right_handed_vertical_fov(field_of_view, aspect_ratio, + near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/opengl_engine/traits/camera_trait.hpp b/include/omath/engines/opengl_engine/traits/camera_trait.hpp index cd0e43e..d953297 100644 --- a/include/omath/engines/opengl_engine/traits/camera_trait.hpp +++ b/include/omath/engines/opengl_engine/traits/camera_trait.hpp @@ -4,7 +4,7 @@ #pragma once #include "omath/engines/opengl_engine/formulas.hpp" -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::opengl_engine @@ -13,27 +13,25 @@ namespace omath::opengl_engine { public: [[nodiscard]] - OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, - const Vector3& look_at) noexcept + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept { const auto direction = (look_at - cam_origin).normalized(); return {PitchAngle::from_radians(internal::asin(direction.y)), - YawAngle::from_radians(-internal::atan2(direction.x, -direction.z)), - RollAngle::from_radians(0.f)}; + YawAngle::from_radians(-internal::atan2(direction.x, -direction.z)), RollAngle::from_radians(0.f)}; } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return opengl_engine::calc_view_matrix(angles, cam_origin); } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 - calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near_plane, const float far_plane, - const NDCDepthRange ndc_depth_range) noexcept + constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, + const projection::ViewPort& view_port, const float near_plane, + const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); diff --git a/include/omath/engines/rage_engine/formulas.hpp b/include/omath/engines/rage_engine/formulas.hpp index d89493b..08b87fa 100644 --- a/include/omath/engines/rage_engine/formulas.hpp +++ b/include/omath/engines/rage_engine/formulas.hpp @@ -9,10 +9,10 @@ namespace omath::rage_engine { [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 forward_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); @@ -20,7 +20,7 @@ namespace omath::rage_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); @@ -28,7 +28,7 @@ namespace omath::rage_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); @@ -36,15 +36,14 @@ namespace omath::rage_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept { return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.roll) @@ -52,19 +51,19 @@ namespace omath::rage_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept { return mat_extract_origin(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept { return mat_extract_scale(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept { const auto angles = mat_extract_rotation_zyx(mat); return { @@ -75,9 +74,10 @@ namespace omath::rage_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( - const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, - const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept + inline constexpr Mat4X4 + calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near_plane, + const float far_plane, + const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) return mat_perspective_left_handed_vertical_fov( diff --git a/include/omath/engines/rage_engine/traits/camera_trait.hpp b/include/omath/engines/rage_engine/traits/camera_trait.hpp index 7dc013f..55643fb 100644 --- a/include/omath/engines/rage_engine/traits/camera_trait.hpp +++ b/include/omath/engines/rage_engine/traits/camera_trait.hpp @@ -4,7 +4,7 @@ #pragma once #include "omath/engines/rage_engine/formulas.hpp" -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::rage_engine @@ -13,8 +13,8 @@ namespace omath::rage_engine { public: [[nodiscard]] - OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, - const Vector3& look_at) noexcept + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept { const auto direction = (look_at - cam_origin).normalized(); @@ -23,16 +23,15 @@ namespace omath::rage_engine } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return rage_engine::calc_view_matrix(angles, cam_origin); } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 - calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near_plane, const float far_plane, - const NDCDepthRange ndc_depth_range) noexcept + constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, + const projection::ViewPort& view_port, const float near_plane, + const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); diff --git a/include/omath/engines/source_engine/formulas.hpp b/include/omath/engines/source_engine/formulas.hpp index 5a7b523..78bb344 100644 --- a/include/omath/engines/source_engine/formulas.hpp +++ b/include/omath/engines/source_engine/formulas.hpp @@ -7,10 +7,10 @@ namespace omath::source_engine { [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 forward_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); @@ -18,25 +18,25 @@ namespace omath::source_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + inline constexpr 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); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept { return mat_extract_origin(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept { return mat_extract_scale(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept { const auto angles = mat_extract_rotation_zyx(mat); return { @@ -47,7 +47,7 @@ namespace omath::source_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); @@ -55,7 +55,7 @@ namespace omath::source_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); @@ -63,14 +63,13 @@ namespace omath::source_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + inline constexpr Mat4X4 calc_perspective_projection_matrix( const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { diff --git a/include/omath/engines/source_engine/traits/camera_trait.hpp b/include/omath/engines/source_engine/traits/camera_trait.hpp index 61cc9c7..8e65621 100644 --- a/include/omath/engines/source_engine/traits/camera_trait.hpp +++ b/include/omath/engines/source_engine/traits/camera_trait.hpp @@ -4,7 +4,7 @@ #pragma once #include "omath/engines/source_engine/formulas.hpp" -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::source_engine @@ -13,8 +13,8 @@ namespace omath::source_engine { public: [[nodiscard]] - OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, - const Vector3& look_at) noexcept + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept { const auto direction = (look_at - cam_origin).normalized(); @@ -23,16 +23,15 @@ namespace omath::source_engine } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return source_engine::calc_view_matrix(angles, cam_origin); } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 - calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near_plane, const float far_plane, - const NDCDepthRange ndc_depth_range) noexcept + constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, + const projection::ViewPort& view_port, const float near_plane, + const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); diff --git a/include/omath/engines/unity_engine/formulas.hpp b/include/omath/engines/unity_engine/formulas.hpp index 350b30b..5be46d9 100644 --- a/include/omath/engines/unity_engine/formulas.hpp +++ b/include/omath/engines/unity_engine/formulas.hpp @@ -8,10 +8,10 @@ namespace omath::unity_engine { [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 forward_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); @@ -19,7 +19,7 @@ namespace omath::unity_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); @@ -27,7 +27,7 @@ namespace omath::unity_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); @@ -35,15 +35,14 @@ namespace omath::unity_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return mat_camera_view(-forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept { return mat_rotation_axis_z(angles.roll) * mat_rotation_axis_y(angles.yaw) @@ -51,19 +50,19 @@ namespace omath::unity_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept { return mat_extract_origin(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept { return mat_extract_scale(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept { const auto angles = mat_extract_rotation_zyx(mat); return { @@ -74,17 +73,17 @@ namespace omath::unity_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + inline constexpr Mat4X4 calc_perspective_projection_matrix( const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return omath::mat_perspective_right_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( + return omath::mat_perspective_right_handed_vertical_fov( field_of_view, aspect_ratio, near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return omath::mat_perspective_right_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( + return omath::mat_perspective_right_handed_vertical_fov( field_of_view, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/unity_engine/traits/camera_trait.hpp b/include/omath/engines/unity_engine/traits/camera_trait.hpp index 08faafb..bf59185 100644 --- a/include/omath/engines/unity_engine/traits/camera_trait.hpp +++ b/include/omath/engines/unity_engine/traits/camera_trait.hpp @@ -4,7 +4,7 @@ #pragma once #include "omath/engines/unity_engine/formulas.hpp" -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::unity_engine @@ -13,8 +13,8 @@ namespace omath::unity_engine { public: [[nodiscard]] - OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, - const Vector3& look_at) noexcept + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept { const auto direction = (look_at - cam_origin).normalized(); @@ -23,16 +23,15 @@ namespace omath::unity_engine } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return unity_engine::calc_view_matrix(angles, cam_origin); } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 - calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const float near_plane, const float far_plane, - const NDCDepthRange ndc_depth_range) noexcept + constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, + const projection::ViewPort& view_port, const float near_plane, + const float far_plane, + const NDCDepthRange ndc_depth_range) noexcept { return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); diff --git a/include/omath/engines/unreal_engine/formulas.hpp b/include/omath/engines/unreal_engine/formulas.hpp index 558afb7..f490b08 100644 --- a/include/omath/engines/unreal_engine/formulas.hpp +++ b/include/omath/engines/unreal_engine/formulas.hpp @@ -8,10 +8,10 @@ namespace omath::unreal_engine { [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 forward_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 forward_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); @@ -19,7 +19,7 @@ namespace omath::unreal_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 right_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); @@ -27,7 +27,7 @@ namespace omath::unreal_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 up_vector(const ViewAngles& angles) noexcept + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept { const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); @@ -35,15 +35,14 @@ namespace omath::unreal_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return mat_camera_view(forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); + up_vector(angles), cam_origin); } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept { return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(-angles.pitch) @@ -51,19 +50,19 @@ namespace omath::unreal_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_origin(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept { return mat_extract_origin(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR Vector3 extract_scale(const Mat4X4& mat) noexcept + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept { return mat_extract_scale(mat); } [[nodiscard]] - inline OMATH_CONSTEXPR ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept { const auto angles = mat_extract_rotation_zyx(mat); return { @@ -74,17 +73,17 @@ namespace omath::unreal_engine } [[nodiscard]] - inline OMATH_CONSTEXPR Mat4X4 calc_perspective_projection_matrix( + inline constexpr Mat4X4 calc_perspective_projection_matrix( const double field_of_view, const double aspect_ratio, const double near_plane, const double far_plane, const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept { if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_horizontal_fov< - double, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - field_of_view, aspect_ratio, near_plane, far_plane); + return mat_perspective_left_handed_horizontal_fov(field_of_view, aspect_ratio, + near_plane, far_plane); if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_horizontal_fov< - double, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( + return mat_perspective_left_handed_horizontal_fov( field_of_view, aspect_ratio, near_plane, far_plane); std::unreachable(); } diff --git a/include/omath/engines/unreal_engine/traits/camera_trait.hpp b/include/omath/engines/unreal_engine/traits/camera_trait.hpp index cb04cec..8498a29 100644 --- a/include/omath/engines/unreal_engine/traits/camera_trait.hpp +++ b/include/omath/engines/unreal_engine/traits/camera_trait.hpp @@ -4,7 +4,7 @@ #pragma once #include "omath/engines/unreal_engine/formulas.hpp" -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::unreal_engine @@ -13,8 +13,8 @@ namespace omath::unreal_engine { public: [[nodiscard]] - OMATH_CONSTEXPR static ViewAngles calc_look_at_angle(const Vector3& cam_origin, - const Vector3& look_at) noexcept + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept { const auto direction = (look_at - cam_origin).normalized(); @@ -23,16 +23,15 @@ namespace omath::unreal_engine } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 calc_view_matrix(const ViewAngles& angles, - const Vector3& cam_origin) noexcept + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept { return unreal_engine::calc_view_matrix(angles, cam_origin); } [[nodiscard]] - OMATH_CONSTEXPR static Mat4X4 - calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - const double near_plane, const double far_plane, - const NDCDepthRange ndc_depth_range) noexcept + constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, + const projection::ViewPort& view_port, const double near_plane, + const double far_plane, + const NDCDepthRange ndc_depth_range) noexcept { return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane, ndc_depth_range); diff --git a/include/omath/internal/constexpr_math.hpp b/include/omath/internal/constexpr_math.hpp new file mode 100644 index 0000000..062553f --- /dev/null +++ b/include/omath/internal/constexpr_math.hpp @@ -0,0 +1,707 @@ +// +// Created by orange on 6/11/2026. +// +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace omath::internal +{ + // Embedded subset of GCE-Math 1.18.0. + // + // Original project: + // GCE-Math: A C++ generalized constant expression-based math library + // Copyright 2016-2024 Keith O'Hara + // Licensed under the Apache License, Version 2.0. + namespace math_detail + { + using uint_t = unsigned int; + using llint_t = long long int; + using ullint_t = unsigned long long int; + + template + using limits = std::numeric_limits; + + template + constexpr Type pi = std::numbers::pi_v; + + template + constexpr Type half_pi = std::numbers::pi_v / static_cast(2); + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type abs(const Type value) noexcept + { + return value == Type{0} ? Type{0} : value < Type{0} ? -value : value; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr int sgn(const Type value) noexcept + { + return value > Type{0} ? 1 : value < Type{0} ? -1 : 0; + } + + [[nodiscard]] + constexpr bool is_odd(const llint_t value) noexcept + { + return (value & 1U) != 0; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool is_nan(const Type value) noexcept + { + return value != value; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool is_neginf(const Type value) noexcept + { + return value == -limits::infinity(); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool is_posinf(const Type value) noexcept + { + return value == limits::infinity(); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool is_inf(const Type value) noexcept + { + return is_neginf(value) || is_posinf(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool is_finite(const Type value) noexcept + { + return !is_nan(value) && !is_inf(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool any_nan(const Type x, const Type y) noexcept + { + return is_nan(x) || is_nan(y); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool any_inf(const Type x, const Type y) noexcept + { + return is_inf(x) || is_inf(y); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool all_finite(const Type x, const Type y) noexcept + { + return is_finite(x) && is_finite(y); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool signbit(const Type value) noexcept + { + if constexpr (std::is_same_v) + return (std::bit_cast(value) & 0x80000000U) != 0; + else if constexpr (std::is_same_v) + return (std::bit_cast(value) & 0x8000000000000000ULL) != 0; + else + return value < Type{0}; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr bool neg_zero(const Type value) noexcept + { + return value == Type{0} && signbit(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type pow_integral_compute(const Type base, const ExpType exp_term) noexcept; + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type pow_integral_compute_recur(const Type base, const Type value, const ExpType exp_term) noexcept + { + return exp_term > ExpType{1} + ? is_odd(static_cast(exp_term)) + ? pow_integral_compute_recur(base * base, value * base, exp_term / ExpType{2}) + : pow_integral_compute_recur(base * base, value, exp_term / ExpType{2}) + : exp_term == ExpType{1} ? value * base + : value; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type pow_integral_sgn_check(const Type base, const ExpType exp_term) noexcept + { + if constexpr (std::is_signed_v) + return exp_term < ExpType{0} ? Type{1} / pow_integral_compute(base, -exp_term) + : pow_integral_compute_recur(base, Type{1}, exp_term); + else + return pow_integral_compute_recur(base, Type{1}, exp_term); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type pow_integral_compute(const Type base, const ExpType exp_term) noexcept + { + return exp_term == ExpType{3} ? base * base * base + : exp_term == ExpType{2} ? base * base + : exp_term == ExpType{1} ? base + : exp_term == ExpType{0} ? Type{1} + : exp_term == limits::min() ? Type{0} + : exp_term == limits::max() ? limits::infinity() + : pow_integral_sgn_check(base, exp_term); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type pow_integral(const Type base, const ExpType exp_term) noexcept + { + return pow_integral_compute(base, exp_term); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type sqrt_recur(const Type x, const Type xn, const int count) noexcept + { + return abs(xn - x / xn) / (Type{1} + xn) < limits::min() ? xn + : count < 100 ? sqrt_recur(x, Type{0.5} * (xn + x / xn), count + 1) + : xn; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type sqrt_simplify(const Type x, const Type m_val) noexcept + { + return x > Type{1e+08} ? sqrt_simplify(x / Type{1e+08}, Type{1e+04} * m_val) + : x > Type{1e+06} ? sqrt_simplify(x / Type{1e+06}, Type{1e+03} * m_val) + : x > Type{1e+04} ? sqrt_simplify(x / Type{1e+04}, Type{1e+02} * m_val) + : x > Type{100} ? sqrt_simplify(x / Type{100}, Type{10} * m_val) + : x > Type{4} ? sqrt_simplify(x / Type{4}, Type{2} * m_val) + : m_val * sqrt_recur(x, x / Type{2}, 0); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type sqrt(const Type x) noexcept + { + return is_nan(x) ? limits::quiet_NaN() + : x < Type{0} ? limits::quiet_NaN() + : is_posinf(x) ? x + : limits::min() > abs(x) ? Type{0} + : limits::min() > abs(Type{1} - x) ? x + : sqrt_simplify(x, Type{1}); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type floor_int(const Type x, const Type x_whole) noexcept + { + return x_whole - static_cast((x < Type{0}) && (x < x_whole)); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type floor_check_internal(const Type x) noexcept + { + if constexpr (std::is_same_v) + return abs(x) >= 8388608.f ? x : floor_int(x, static_cast(static_cast(x))); + else if constexpr (std::is_same_v) + return abs(x) >= 4503599627370496. ? x : floor_int(x, static_cast(static_cast(x))); + else + return abs(x) >= 9223372036854775808.l + ? x + : static_cast(static_cast(abs(x))) * sgn(x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type floor(const Type x) noexcept + { + return is_nan(x) ? limits::quiet_NaN() + : !is_finite(x) ? x + : limits::min() > abs(x) ? x + : floor_check_internal(x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type trunc_int(const Type x) noexcept + { + return static_cast(static_cast(x)); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type trunc_check_internal(const Type x) noexcept + { + if constexpr (std::is_same_v) + return abs(x) >= 8388608.f ? x : trunc_int(x); + else if constexpr (std::is_same_v) + return abs(x) >= 4503599627370496. ? x : trunc_int(x); + else + return abs(x) >= 9223372036854775808.l + ? x + : static_cast(static_cast(abs(x))) * sgn(x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type trunc(const Type x) noexcept + { + return is_nan(x) ? limits::quiet_NaN() + : !is_finite(x) ? x + : limits::min() > abs(x) ? x + : trunc_check_internal(x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type fmod(const Type x, const Type y) noexcept + { + return any_nan(x, y) || !all_finite(x, y) || limits::min() > abs(y) ? limits::quiet_NaN() + : x - trunc(x / y) * y; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type tan_series_exp_long(const Type z) noexcept + { + return -Type{1} / z + + (z / Type{3} + + (pow_integral(z, 3) / Type{45} + + (Type{2} * pow_integral(z, 5) / Type{945} + pow_integral(z, 7) / Type{4725}))); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type tan_series_exp(const Type x) noexcept + { + return limits::min() > abs(x - half_pi) ? Type{1.633124e+16} + : tan_series_exp_long(x - half_pi); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type tan_cf_recur(const Type xx, const int max_depth) noexcept + { + Type result = static_cast(2 * max_depth - 1); + for (int depth = max_depth - 1; depth >= 1; --depth) + result = static_cast(2 * depth - 1) - xx / result; + + return result; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type tan_cf_main(const Type x) noexcept + { + return x > Type{1.55} && x < Type{1.60} ? tan_series_exp(x) + : x > Type{1.4} ? x / tan_cf_recur(x * x, 45) + : x > Type{1} ? x / tan_cf_recur(x * x, 35) + : x / tan_cf_recur(x * x, 25); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type tan_begin(const Type x, const int count = 0) noexcept + { + return x > pi ? count > 1 ? limits::quiet_NaN() + : tan_begin(x - pi * floor(x / pi), count + 1) + : tan_cf_main(x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type tan(const Type x) noexcept + { + return is_nan(x) ? limits::quiet_NaN() + : limits::min() > abs(x) ? Type{0} + : x < Type{0} ? -tan_begin(-x) + : tan_begin(x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type sin(const Type x) noexcept + { + return is_nan(x) ? limits::quiet_NaN() + : limits::min() > abs(x) ? Type{0} + : limits::min() > abs(x - half_pi) ? Type{1} + : limits::min() > abs(x + half_pi) ? -Type{1} + : limits::min() > abs(x - pi) ? Type{0} + : limits::min() > abs(x + pi) + ? -Type{0} + : (Type{2} * tan(x / Type{2})) / (Type{1} + tan(x / Type{2}) * tan(x / Type{2})); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type cos(const Type x) noexcept + { + return is_nan(x) ? limits::quiet_NaN() + : limits::min() > abs(x) ? Type{1} + : limits::min() > abs(x - half_pi) ? Type{0} + : limits::min() > abs(x + half_pi) ? Type{0} + : limits::min() > abs(x - pi) ? -Type{1} + : limits::min() > abs(x + pi) + ? -Type{1} + : (Type{1} - tan(x / Type{2}) * tan(x / Type{2})) + / (Type{1} + tan(x / Type{2}) * tan(x / Type{2})); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan_series_order_calc(const Type xx, const Type x_pow, const uint_t order) noexcept + { + return Type{1} / (static_cast((order - 1) * 4 - 1) * x_pow) + - Type{1} / (static_cast((order - 1) * 4 + 1) * x_pow * xx); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan_series_order(const Type x, const uint_t order_begin, const uint_t max_order) noexcept + { + if (max_order == 1) + return half_pi - Type{1} / x; + + const Type xx = x * x; + Type result = atan_series_order_calc(xx, pow_integral(x, 4 * max_order - 5), max_order); + auto depth = max_order - 1; + + while (depth > order_begin) + { + result += atan_series_order_calc(xx, pow_integral(x, 4 * depth - 5), depth); + --depth; + } + + return result + half_pi - Type{1} / x; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan_series_main(const Type x) noexcept + { + return x < Type{3} ? atan_series_order(x, 1U, 10U) + : x < Type{4} ? atan_series_order(x, 1U, 9U) + : x < Type{5} ? atan_series_order(x, 1U, 8U) + : x < Type{7} ? atan_series_order(x, 1U, 7U) + : x < Type{11} ? atan_series_order(x, 1U, 6U) + : x < Type{25} ? atan_series_order(x, 1U, 5U) + : x < Type{100} ? atan_series_order(x, 1U, 4U) + : x < Type{1000} ? atan_series_order(x, 1U, 3U) + : atan_series_order(x, 1U, 2U); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan_cf_recur(const Type xx, const uint_t depth_begin, const uint_t max_depth) noexcept + { + auto depth = max_depth - 1; + Type result = static_cast(2 * (depth + 1) - 1); + + while (depth > depth_begin - 1) + { + result = static_cast(2 * depth - 1) + static_cast(depth * depth) * xx / result; + --depth; + } + + return result; + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan_cf_main(const Type x) noexcept + { + return x < Type{0.5} ? x / atan_cf_recur(x * x, 1U, 15U) + : x < Type{1} ? x / atan_cf_recur(x * x, 1U, 25U) + : x < Type{1.5} ? x / atan_cf_recur(x * x, 1U, 35U) + : x < Type{2} ? x / atan_cf_recur(x * x, 1U, 45U) + : x / atan_cf_recur(x * x, 1U, 52U); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan_begin(const Type x) noexcept + { + return x > Type{2.5} ? atan_series_main(x) : atan_cf_main(x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan(const Type x) noexcept + { + return is_nan(x) ? limits::quiet_NaN() + : limits::min() > abs(x) ? Type{0} + : x < Type{0} ? -atan_begin(-x) + : atan_begin(x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan2(const Type y, const Type x) noexcept + { + return any_nan(y, x) ? limits::quiet_NaN() + : limits::min() > abs(x) ? limits::min() > abs(y) + ? neg_zero(y) ? neg_zero(x) ? -pi : -Type{0} + : neg_zero(x) ? pi + : Type{0} + : y > Type{0} ? half_pi + : -half_pi + : x < Type{0} ? y < Type{0} ? atan(y / x) - pi : atan(y / x) + pi + : atan(y / x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type asin_compute(const Type x) noexcept + { + return x > Type{1} ? limits::quiet_NaN() + : limits::min() > abs(x - Type{1}) ? half_pi + : limits::min() > abs(x) ? Type{0} + : atan(x / sqrt(Type{1} - x * x)); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type asin(const Type x) noexcept + { + return is_nan(x) ? limits::quiet_NaN() : x < Type{0} ? -asin_compute(-x) : asin_compute(x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type acos_compute(const Type x) noexcept + { + return abs(x) > Type{1} ? limits::quiet_NaN() + : limits::min() > abs(x - Type{1}) ? Type{0} + : limits::min() > abs(x) ? half_pi + : atan(sqrt(Type{1} - x * x) / x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type acos(const Type x) noexcept + { + return is_nan(x) ? limits::quiet_NaN() : x > Type{0} ? acos_compute(x) : pi - acos_compute(-x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type hypot(const Type x, const Type y) noexcept + { + return any_nan(x, y) ? limits::quiet_NaN() + : any_inf(x, y) ? limits::infinity() + : limits::min() > abs(x) ? abs(y) + : limits::min() > abs(y) ? abs(x) + : abs(x) * sqrt(Type{1} + (y / x) * (y / x)); + } + } // namespace math_detail + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type sin(const Type& value) noexcept + { + if consteval + { + return math_detail::sin(value); + } + return std::sin(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type cos(const Type& value) noexcept + { + if consteval + { + return math_detail::cos(value); + } + return std::cos(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type tan(const Type& value) noexcept + { + if consteval + { + return math_detail::tan(value); + } + return std::tan(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan(const Type& value) noexcept + { + if consteval + { + return math_detail::atan(value); + } + return std::atan(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type atan2(const Type& y, const Type& x) noexcept + { + if consteval + { + return math_detail::atan2(y, x); + } + return std::atan2(y, x); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type asin(const Type& value) noexcept + { + if consteval + { + return math_detail::asin(value); + } + return std::asin(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type acos(const Type& value) noexcept + { + if consteval + { + return math_detail::acos(value); + } + return std::acos(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type sqrt(const Type& value) noexcept + { + if consteval + { + return math_detail::sqrt(value); + } + return std::sqrt(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type hypot(const Type& x, const Type& y) noexcept + { + if consteval + { + return math_detail::hypot(x, y); + } + return std::hypot(x, y); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type hypot(const Type& x, const Type& y, const Type& z) noexcept + { + if consteval + { + return math_detail::sqrt(x * x + y * y + z * z); + } + return std::hypot(x, y, z); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type abs(const Type& value) noexcept + { + if consteval + { + return math_detail::abs(value); + } + return std::abs(value); + } + + template + requires std::is_floating_point_v + [[nodiscard]] + constexpr Type fmod(const Type& dividend, const Type& divisor) noexcept + { + if consteval + { + return math_detail::fmod(dividend, divisor); + } + return std::fmod(dividend, divisor); + } +} // namespace omath::internal diff --git a/include/omath/internal/optional_constexpr_math.hpp b/include/omath/internal/optional_constexpr_math.hpp deleted file mode 100644 index 04c1266..0000000 --- a/include/omath/internal/optional_constexpr_math.hpp +++ /dev/null @@ -1,185 +0,0 @@ -// -// Created by orange on 6/11/2026. -// -#pragma once - -#include -#include - -#ifdef OMATH_USE_GCEM -#include -#define OMATH_CONSTEXPR constexpr -#else -#define OMATH_CONSTEXPR -#endif - -namespace omath::internal -{ - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type sin(const Type& value) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::sin(value); - } -#endif - return std::sin(value); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type cos(const Type& value) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::cos(value); - } -#endif - return std::cos(value); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type tan(const Type& value) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::tan(value); - } -#endif - return std::tan(value); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type atan(const Type& value) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::atan(value); - } -#endif - return std::atan(value); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type atan2(const Type& y, const Type& x) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::atan2(y, x); - } -#endif - return std::atan2(y, x); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type asin(const Type& value) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::asin(value); - } -#endif - return std::asin(value); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type acos(const Type& value) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::acos(value); - } -#endif - return std::acos(value); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type sqrt(const Type& value) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::sqrt(value); - } -#endif - return std::sqrt(value); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type hypot(const Type& x, const Type& y) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::hypot(x, y); - } -#endif - return std::hypot(x, y); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type hypot(const Type& x, const Type& y, const Type& z) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::sqrt(x * x + y * y + z * z); - } -#endif - return std::hypot(x, y, z); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type abs(const Type& value) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::abs(value); - } -#endif - return std::abs(value); - } - - template - requires std::is_floating_point_v - [[nodiscard]] - OMATH_CONSTEXPR Type fmod(const Type& dividend, const Type& divisor) noexcept - { -#ifdef OMATH_USE_GCEM - if consteval - { - return gcem::fmod(dividend, divisor); - } -#endif - return std::fmod(dividend, divisor); - } -} // namespace omath::internal diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index 17f501f..40175f9 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -2,7 +2,7 @@ // Created by vlad on 9/29/2024. // #pragma once -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "vector3.hpp" #include #include @@ -43,12 +43,12 @@ namespace omath enum class NDCDepthRange : uint8_t { NEGATIVE_ONE_TO_ONE = 0, // OpenGL: [-1.0, 1.0] - ZERO_TO_ONE // DirectX / Vulkan: [0.0, 1.0] + ZERO_TO_ONE // DirectX / Vulkan: [0.0, 1.0] }; - template concept MatTemplateEqual - = (M1::rows == M2::rows) && (M1::columns == M2::columns) - && std::is_same_v && (M1::store_type == M2::store_type); + template concept MatTemplateEqual = + (M1::rows == M2::rows) && (M1::columns == M2::columns) + && std::is_same_v && (M1::store_type == M2::store_type); template requires std::is_arithmetic_v @@ -202,7 +202,11 @@ namespace omath constexpr Mat& operator*=(const Type& f) noexcept { - std::ranges::for_each(m_data, [&f](auto& val) { val *= f; }); + std::ranges::for_each(m_data, + [&f](auto& val) + { + val *= f; + }); return *this; } @@ -222,7 +226,11 @@ namespace omath constexpr Mat& operator/=(const Type& value) noexcept { - std::ranges::for_each(m_data, [&value](auto& val) { val /= value; }); + std::ranges::for_each(m_data, + [&value](auto& val) + { + val /= value; + }); return *this; } @@ -603,8 +611,7 @@ namespace omath [[nodiscard("You must use translation matrix")]] constexpr Mat<4, 4, Type, St> mat_translation(const Vector3& diff) noexcept { - return - { + return { {1, 0, 0, diff.x}, {0, 1, 0, diff.y}, {0, 0, 1, diff.z}, @@ -632,9 +639,10 @@ namespace omath template [[nodiscard("You must use extracted scale")]] - OMATH_CONSTEXPR Vector3 mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept + constexpr Vector3 mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept { - auto column_length = [](const Type x, const Type y, const Type z) { + auto column_length = [](const Type x, const Type y, const Type z) + { return static_cast(internal::sqrt(x * x + y * y + z * z)); }; @@ -672,96 +680,83 @@ namespace omath template [[nodiscard("You must use rotation matrix")]] - OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept + constexpr Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept { - return - { - {1, 0, 0, 0}, - {0, angle.cos(), -angle.sin(), 0}, - {0, angle.sin(), angle.cos(), 0}, - {0, 0, 0, 1} - }; + return {{1, 0, 0, 0}, {0, angle.cos(), -angle.sin(), 0}, {0, angle.sin(), angle.cos(), 0}, {0, 0, 0, 1}}; } template [[nodiscard("You must use rotation matrix")]] - OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept + constexpr Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept { - return - { - {angle.cos(), 0, angle.sin(), 0}, - {0 , 1, 0, 0}, - {-angle.sin(), 0, angle.cos(), 0}, - {0 , 0, 0, 1} - }; + return {{angle.cos(), 0, angle.sin(), 0}, {0, 1, 0, 0}, {-angle.sin(), 0, angle.cos(), 0}, {0, 0, 0, 1}}; } template [[nodiscard("You must use rotation matrix")]] - OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept + constexpr Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept { - return - { - {angle.cos(), -angle.sin(), 0, 0}, - {angle.sin(), angle.cos(), 0, 0}, - { 0, 0, 1, 0}, - { 0, 0, 0, 1}, + return { + {angle.cos(), -angle.sin(), 0, 0}, + {angle.sin(), angle.cos(), 0, 0}, + {0, 0, 1, 0}, + {0, 0, 0, 1}, }; } template [[nodiscard("You must use camera view matrix")]] - OMATH_CONSTEXPR Mat<4, 4, Type, St> mat_camera_view(const Vector3& forward, const Vector3& right, - const Vector3& up, const Vector3& camera_origin) noexcept + constexpr Mat<4, 4, Type, St> mat_camera_view(const Vector3& forward, const Vector3& right, + const Vector3& up, const Vector3& camera_origin) noexcept { - return Mat<4, 4, Type, St> - { - {right.x, right.y, right.z, 0}, - {up.x, up.y, up.z, 0}, - {forward.x, forward.y, forward.z, 0}, - {0, 0, 0, 1}, - } * mat_translation(-camera_origin); + return Mat<4, 4, Type, St>{ + {right.x, right.y, right.z, 0}, + {up.x, up.y, up.z, 0}, + {forward.x, forward.y, forward.z, 0}, + {0, 0, 0, 1}, + } + * mat_translation(-camera_origin); } template - [[nodiscard("You must use perspective matrix")]] OMATH_CONSTEXPR - Mat<4, 4, Type, St> mat_perspective_left_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, - const Type near, const Type far) noexcept + [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St> + mat_perspective_left_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near, + const Type far) noexcept { const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2}); if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) - return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, - {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, - {Type{0}, Type{0}, far / (far - near), -(near * far) / (far - near)}, - {Type{0}, Type{0}, Type{1}, Type{0}}}; + return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, + {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, + {Type{0}, Type{0}, far / (far - near), -(near * far) / (far - near)}, + {Type{0}, Type{0}, Type{1}, Type{0}}}; else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, - {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, - {Type{0}, Type{0}, (far + near) / (far - near), -(Type{2} * near * far) / (far - near)}, - {Type{0}, Type{0}, Type{1}, Type{0}}}; + return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, + {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, + {Type{0}, Type{0}, (far + near) / (far - near), -(Type{2} * near * far) / (far - near)}, + {Type{0}, Type{0}, Type{1}, Type{0}}}; else std::unreachable(); } template - [[nodiscard("You must use perspective matrix")]] OMATH_CONSTEXPR - Mat<4, 4, Type, St> mat_perspective_right_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, - const Type near, const Type far) noexcept + [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St> + mat_perspective_right_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near, + const Type far) noexcept { const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2}); if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) - return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, - {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, - {Type{0}, Type{0}, -far / (far - near), -(near * far) / (far - near)}, - {Type{0}, Type{0}, -Type{1}, Type{0}}}; + return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, + {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, + {Type{0}, Type{0}, -far / (far - near), -(near * far) / (far - near)}, + {Type{0}, Type{0}, -Type{1}, Type{0}}}; else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, - {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, - {Type{0}, Type{0}, -(far + near) / (far - near), -(Type{2} * near * far) / (far - near)}, - {Type{0}, Type{0}, -Type{1}, Type{0}}}; + return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}}, + {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}}, + {Type{0}, Type{0}, -(far + near) / (far - near), -(Type{2} * near * far) / (far - near)}, + {Type{0}, Type{0}, -Type{1}, Type{0}}}; else std::unreachable(); } @@ -771,35 +766,33 @@ namespace omath // X and Y scales derived as: X = 1 / tan(hfov/2), Y = aspect / tan(hfov/2). template - [[nodiscard("You must use perspective matrix")]] OMATH_CONSTEXPR - Mat<4, 4, Type, St> mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov, - const Type aspect_ratio, const Type near, - const Type far) noexcept + [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St> + mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near, + const Type far) noexcept { const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); const auto x_axis = inv_tan_half_hfov; const auto y_axis = inv_tan_half_hfov * aspect_ratio; if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) - return {{x_axis, Type{0}, Type{0}, Type{0}}, - {Type{0}, y_axis, Type{0}, Type{0}}, - {Type{0}, Type{0}, far / (far - near), -(near * far) / (far - near)}, - {Type{0}, Type{0}, Type{1}, Type{0}}}; + return {{x_axis, Type{0}, Type{0}, Type{0}}, + {Type{0}, y_axis, Type{0}, Type{0}}, + {Type{0}, Type{0}, far / (far - near), -(near * far) / (far - near)}, + {Type{0}, Type{0}, Type{1}, Type{0}}}; else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return {{x_axis, Type{0}, Type{0}, Type{0}}, - {Type{0}, y_axis, Type{0}, Type{0}}, + return {{x_axis, Type{0}, Type{0}, Type{0}}, + {Type{0}, y_axis, Type{0}, Type{0}}, {Type{0}, Type{0}, (far + near) / (far - near), -(Type{2} * near * far) / (far - near)}, - {Type{0}, Type{0}, Type{1}, Type{0}}}; + {Type{0}, Type{0}, Type{1}, Type{0}}}; else std::unreachable(); } template - [[nodiscard("You must use perspective matrix")]] OMATH_CONSTEXPR - Mat<4, 4, Type, St> mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov, - const Type aspect_ratio, const Type near, - const Type far) noexcept + [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St> + mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near, + const Type far) noexcept { const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); @@ -807,70 +800,59 @@ namespace omath const auto y_axis = inv_tan_half_hfov * aspect_ratio; if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) - return {{x_axis, Type{0}, Type{0}, Type{0}}, - {Type{0}, y_axis, Type{0}, Type{0}}, + return {{x_axis, Type{0}, Type{0}, Type{0}}, + {Type{0}, y_axis, Type{0}, Type{0}}, {Type{0}, Type{0}, -far / (far - near), -(near * far) / (far - near)}, - {Type{0}, Type{0}, -Type{1}, Type{0}}}; + {Type{0}, Type{0}, -Type{1}, Type{0}}}; else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return {{x_axis, Type{0}, Type{0}, Type{0}}, - {Type{0}, y_axis, Type{0}, Type{0}}, + return {{x_axis, Type{0}, Type{0}, Type{0}}, + {Type{0}, y_axis, Type{0}, Type{0}}, {Type{0}, Type{0}, -(far + near) / (far - near), -(Type{2} * near * far) / (far - near)}, - {Type{0}, Type{0}, -Type{1}, Type{0}}}; + {Type{0}, Type{0}, -Type{1}, Type{0}}}; else std::unreachable(); } template - [[nodiscard("You must use ortho matrix")]] OMATH_CONSTEXPR - Mat<4, 4, Type, St> mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top, - const Type near, const Type far) noexcept + [[nodiscard("You must use ortho matrix")]] constexpr Mat<4, 4, Type, St> + mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near, + const Type far) noexcept { if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) - return - { - { static_cast(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)}, - { 0.f, static_cast(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)}, - { 0.f, 0.f, static_cast(1) / (far - near), -near / (far - near) }, - { 0.f, 0.f, 0.f, 1.f } - }; + return {{static_cast(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)}, + {0.f, static_cast(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)}, + {0.f, 0.f, static_cast(1) / (far - near), -near / (far - near)}, + {0.f, 0.f, 0.f, 1.f}}; else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return - { - { static_cast(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)}, - { 0.f, static_cast(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)}, - { 0.f, 0.f, static_cast(2) / (far - near), -(far + near) / (far - near) }, - { 0.f, 0.f, 0.f, 1.f } - }; + return {{static_cast(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)}, + {0.f, static_cast(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)}, + {0.f, 0.f, static_cast(2) / (far - near), -(far + near) / (far - near)}, + {0.f, 0.f, 0.f, 1.f}}; else std::unreachable(); } template - [[nodiscard("You must use ortho matrix")]] OMATH_CONSTEXPR - Mat<4, 4, Type, St> mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top, - const Type near, const Type far) noexcept + [[nodiscard("You must use ortho matrix")]] constexpr Mat<4, 4, Type, St> + mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near, + const Type far) noexcept { if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE) - return - { - { static_cast(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)}, - { 0.f, static_cast(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)}, - { 0.f, 0.f, -static_cast(1) / (far - near), -near / (far - near) }, - { 0.f, 0.f, 0.f, 1.f } - }; + return {{static_cast(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)}, + {0.f, static_cast(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)}, + {0.f, 0.f, -static_cast(1) / (far - near), -near / (far - near)}, + {0.f, 0.f, 0.f, 1.f}}; else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return - { - { static_cast(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)}, - { 0.f, static_cast(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)}, - { 0.f, 0.f, -static_cast(2) / (far - near), -(far + near) / (far - near) }, - { 0.f, 0.f, 0.f, 1.f } - }; + return {{static_cast(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)}, + {0.f, static_cast(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)}, + {0.f, 0.f, -static_cast(2) / (far - near), -(far + near) / (far - near)}, + {0.f, 0.f, 0.f, 1.f}}; else std::unreachable(); } template - OMATH_CONSTEXPR Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3& eye, const Vector3& center, const Vector3& up) + constexpr Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3& eye, const Vector3& center, + const Vector3& up) { const Vector3 f = (center - eye).normalized(); const Vector3 s = f.cross(up).normalized(); @@ -879,7 +861,8 @@ namespace omath } template - OMATH_CONSTEXPR Mat<4, 4, T, St> mat_look_at_right_handed(const Vector3& eye, const Vector3& center, const Vector3& up) + constexpr Mat<4, 4, T, St> mat_look_at_right_handed(const Vector3& eye, const Vector3& center, + const Vector3& up) { const Vector3 f = (center - eye).normalized(); const Vector3 s = f.cross(up).normalized(); diff --git a/include/omath/linear_algebra/triangle.hpp b/include/omath/linear_algebra/triangle.hpp index 3111389..8f30afc 100644 --- a/include/omath/linear_algebra/triangle.hpp +++ b/include/omath/linear_algebra/triangle.hpp @@ -2,7 +2,7 @@ // Created by Orange on 11/13/2024. // #pragma once -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "vector3.hpp" namespace omath { @@ -40,13 +40,13 @@ namespace omath } [[nodiscard]] - OMATH_CONSTEXPR Vector::ContainedType side_a_length() const + constexpr Vector::ContainedType side_a_length() const { return m_vertex1.distance_to(m_vertex2); } [[nodiscard]] - OMATH_CONSTEXPR Vector::ContainedType side_b_length() const + constexpr Vector::ContainedType side_b_length() const { return m_vertex3.distance_to(m_vertex2); } diff --git a/include/omath/linear_algebra/vector2.hpp b/include/omath/linear_algebra/vector2.hpp index d94924f..a4f23de 100644 --- a/include/omath/linear_algebra/vector2.hpp +++ b/include/omath/linear_algebra/vector2.hpp @@ -3,7 +3,7 @@ // #pragma once -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include #include #include @@ -117,7 +117,7 @@ namespace omath // Basic vector operations [[nodiscard("You must use distance")]] - OMATH_CONSTEXPR Type distance_to(const Vector2& other) const noexcept + constexpr Type distance_to(const Vector2& other) const noexcept { return internal::sqrt(distance_to_sqr(other)); } @@ -147,13 +147,13 @@ namespace omath } #else [[nodiscard("You must use length")]] - OMATH_CONSTEXPR Type length() const noexcept + constexpr Type length() const noexcept { return internal::hypot(x, y); } [[nodiscard("You must use normalized vector")]] - OMATH_CONSTEXPR Vector2 normalized() const noexcept + constexpr Vector2 normalized() const noexcept { const Type len = length(); return len > static_cast(0) ? *this / len : *this; @@ -217,24 +217,24 @@ namespace omath } [[nodiscard("You must use comparison result")]] - OMATH_CONSTEXPR bool operator<(const Vector2& other) const noexcept + constexpr bool operator<(const Vector2& other) const noexcept { return length() < other.length(); } [[nodiscard("You must use comparison result")]] - OMATH_CONSTEXPR bool operator>(const Vector2& other) const noexcept + constexpr bool operator>(const Vector2& other) const noexcept { return length() > other.length(); } [[nodiscard("You must use comparison result")]] - OMATH_CONSTEXPR bool operator<=(const Vector2& other) const noexcept + constexpr bool operator<=(const Vector2& other) const noexcept { return length() <= other.length(); } [[nodiscard("You must use comparison result")]] - OMATH_CONSTEXPR bool operator>=(const Vector2& other) const noexcept + constexpr bool operator>=(const Vector2& other) const noexcept { return length() >= other.length(); } diff --git a/include/omath/linear_algebra/vector3.hpp b/include/omath/linear_algebra/vector3.hpp index 4a178a4..b607a4f 100644 --- a/include/omath/linear_algebra/vector3.hpp +++ b/include/omath/linear_algebra/vector3.hpp @@ -4,7 +4,7 @@ #pragma once -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/linear_algebra/vector2.hpp" #include "omath/trigonometry/angle.hpp" #include @@ -150,7 +150,7 @@ namespace omath { return Vector2::length(); } - [[nodiscard("You must use distance")]] OMATH_CONSTEXPR Type distance_to(const Vector3& other) const noexcept + [[nodiscard("You must use distance")]] constexpr Type distance_to(const Vector3& other) const noexcept { return (*this - other).length(); } @@ -162,13 +162,13 @@ namespace omath } #else [[nodiscard("You must use length")]] - OMATH_CONSTEXPR Type length() const noexcept + constexpr Type length() const noexcept { return internal::hypot(this->x, this->y, this->z); } [[nodiscard("You must use normalized vector")]] - OMATH_CONSTEXPR Vector3 normalized() const noexcept + constexpr Vector3 normalized() const noexcept { const Type len = this->length(); @@ -176,13 +176,13 @@ namespace omath } [[nodiscard("You must use 2D length")]] - OMATH_CONSTEXPR Type length_2d() const noexcept + constexpr Type length_2d() const noexcept { return Vector2::length(); } [[nodiscard("You must use distance")]] - OMATH_CONSTEXPR Type distance_to(const Vector3& v_other) const noexcept + constexpr Type distance_to(const Vector3& v_other) const noexcept { return (*this - v_other).length(); } @@ -250,12 +250,12 @@ namespace omath } [[nodiscard("You must use direction check result")]] - OMATH_CONSTEXPR bool point_to_same_direction(const Vector3& other) const + constexpr bool point_to_same_direction(const Vector3& other) const { return dot(other) > static_cast(0); } [[nodiscard("You must use angle between vectors")]] - OMATH_CONSTEXPR std::expected, Vector3Error> + constexpr std::expected, Vector3Error> angle_between(const Vector3& other) const noexcept { const auto bottom = length() * other.length(); @@ -266,8 +266,7 @@ namespace omath } [[nodiscard("You must use perpendicularity check result")]] - OMATH_CONSTEXPR bool is_perpendicular(const Vector3& other, - Type epsilon = static_cast(0.0001)) const noexcept + constexpr bool is_perpendicular(const Vector3& other, Type epsilon = static_cast(0.0001)) const noexcept { if (const auto angle = angle_between(other)) return std::abs(angle->as_degrees() - static_cast(90)) <= epsilon; @@ -288,25 +287,25 @@ namespace omath } [[nodiscard("You must use comparison result")]] - OMATH_CONSTEXPR bool operator<(const Vector3& other) const noexcept + constexpr bool operator<(const Vector3& other) const noexcept { return length() < other.length(); } [[nodiscard("You must use comparison result")]] - OMATH_CONSTEXPR bool operator>(const Vector3& other) const noexcept + constexpr bool operator>(const Vector3& other) const noexcept { return length() > other.length(); } [[nodiscard("You must use comparison result")]] - OMATH_CONSTEXPR bool operator<=(const Vector3& other) const noexcept + constexpr bool operator<=(const Vector3& other) const noexcept { return length() <= other.length(); } [[nodiscard("You must use comparison result")]] - OMATH_CONSTEXPR bool operator>=(const Vector3& other) const noexcept + constexpr bool operator>=(const Vector3& other) const noexcept { return length() >= other.length(); } diff --git a/include/omath/projection/camera.hpp b/include/omath/projection/camera.hpp index 050be14..3bf1569 100644 --- a/include/omath/projection/camera.hpp +++ b/include/omath/projection/camera.hpp @@ -6,7 +6,7 @@ #include "omath/3d_primitives/aabb.hpp" #include "omath/3d_primitives/obb.hpp" -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/linear_algebra/mat.hpp" #include "omath/linear_algebra/triangle.hpp" #include "omath/linear_algebra/vector3.hpp" @@ -104,7 +104,7 @@ namespace omath::projection // NEGATIVE_ONE_TO_ONE) share the same m[0,0]/m[1,1] layout, so this works // regardless of the NDC depth range. [[nodiscard("You must use extracted projection params")]] - OMATH_CONSTEXPR static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept + constexpr static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept { // m[1,1] == 1 / tan(fov/2) => fov = 2 * atan(1 / m[1,1]) const auto f = proj_matrix.at(1, 1); @@ -115,7 +115,7 @@ namespace omath::projection } [[nodiscard("You must use calculated view angles")]] - OMATH_CONSTEXPR static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept + constexpr static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept { Vector3 forward_vector = {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]}; if constexpr (axes.inverted_forward) @@ -138,20 +138,20 @@ namespace omath::projection }; } - OMATH_CONSTEXPR void look_at(const Vector3& target) + constexpr void look_at(const Vector3& target) { m_view_angles = TraitClass::calc_look_at_angle(m_origin, target); m_view_projection_matrix = std::nullopt; m_view_matrix = std::nullopt; } [[nodiscard("You must use calculated look-at angles")]] - OMATH_CONSTEXPR ViewAnglesType calc_look_at_angles(const Vector3& look_to) const + constexpr ViewAnglesType calc_look_at_angles(const Vector3& look_to) const { return TraitClass::calc_look_at_angle(m_origin, look_to); } [[nodiscard("You must use forward vector")]] - OMATH_CONSTEXPR Vector3 get_forward() const noexcept + constexpr Vector3 get_forward() const noexcept { if consteval { @@ -164,7 +164,7 @@ namespace omath::projection } [[nodiscard("You must use right vector")]] - OMATH_CONSTEXPR Vector3 get_right() const noexcept + constexpr Vector3 get_right() const noexcept { if consteval { @@ -177,7 +177,7 @@ namespace omath::projection } [[nodiscard("You must use up vector")]] - OMATH_CONSTEXPR Vector3 get_up() const noexcept + constexpr Vector3 get_up() const noexcept { if consteval { @@ -189,7 +189,7 @@ namespace omath::projection return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]}; } [[nodiscard("You must use absolute forward vector")]] - OMATH_CONSTEXPR Vector3 get_abs_forward() const noexcept + constexpr Vector3 get_abs_forward() const noexcept { if constexpr (axes.inverted_forward) return -get_forward(); @@ -197,7 +197,7 @@ namespace omath::projection } [[nodiscard("You must use absolute right vector")]] - OMATH_CONSTEXPR Vector3 get_abs_right() const noexcept + constexpr Vector3 get_abs_right() const noexcept { if constexpr (axes.inverted_right) return -get_right(); @@ -205,32 +205,32 @@ namespace omath::projection } [[nodiscard("You must use absolute up vector")]] - OMATH_CONSTEXPR Vector3 get_abs_up() const noexcept + constexpr Vector3 get_abs_up() const noexcept { return get_up(); } [[nodiscard("You must use calculated view-projection matrix")]] - OMATH_CONSTEXPR Mat4X4Type calc_view_projection_matrix() const noexcept + constexpr Mat4X4Type calc_view_projection_matrix() const noexcept { return calc_projection_matrix() * calc_view_matrix(); } [[nodiscard("You must use calculated view matrix")]] - OMATH_CONSTEXPR Mat4X4Type calc_view_matrix() const noexcept + constexpr Mat4X4Type calc_view_matrix() const noexcept { return TraitClass::calc_view_matrix(m_view_angles, m_origin); } [[nodiscard("You must use calculated projection matrix")]] - OMATH_CONSTEXPR Mat4X4Type calc_projection_matrix() const noexcept + constexpr Mat4X4Type calc_projection_matrix() const noexcept { - return TraitClass::calc_projection_matrix( - m_field_of_view, m_view_port, m_near_plane_distance, m_far_plane_distance, depth_range); + return TraitClass::calc_projection_matrix(m_field_of_view, m_view_port, m_near_plane_distance, + m_far_plane_distance, depth_range); } [[nodiscard("You must use view-projection matrix")]] - OMATH_CONSTEXPR const Mat4X4Type& get_view_projection_matrix() const noexcept + constexpr const Mat4X4Type& get_view_projection_matrix() const noexcept { if (!m_view_projection_matrix.has_value()) m_view_projection_matrix = get_projection_matrix() * get_view_matrix(); @@ -238,14 +238,15 @@ namespace omath::projection return m_view_projection_matrix.value(); } - [[nodiscard("You must use view matrix")]] OMATH_CONSTEXPR const Mat4X4Type& get_view_matrix() const noexcept + [[nodiscard("You must use view matrix")]] constexpr const Mat4X4Type& get_view_matrix() const noexcept { if (!m_view_matrix.has_value()) m_view_matrix = calc_view_matrix(); return m_view_matrix.value(); } - [[nodiscard("You must use projection matrix")]] OMATH_CONSTEXPR const Mat4X4Type& get_projection_matrix() const noexcept + [[nodiscard("You must use projection matrix")]] constexpr const Mat4X4Type& + get_projection_matrix() const noexcept { if (!m_projection_matrix.has_value()) m_projection_matrix = calc_projection_matrix(); @@ -320,7 +321,7 @@ namespace omath::projection } template - [[nodiscard("You must use screen position")]] OMATH_CONSTEXPR std::expected, Error> + [[nodiscard("You must use screen position")]] constexpr std::expected, Error> world_to_screen(const Vector3& world_position) const noexcept { const auto normalized_cords = world_to_view_port(world_position); @@ -336,7 +337,7 @@ namespace omath::projection std::unreachable(); } template - [[nodiscard("You must use unclipped screen position")]] OMATH_CONSTEXPR std::expected, Error> + [[nodiscard("You must use unclipped screen position")]] constexpr std::expected, Error> world_to_screen_unclipped(const Vector3& world_position) const noexcept { const auto normalized_cords = world_to_view_port(world_position, ViewPortClipping::MANUAL); @@ -352,7 +353,7 @@ namespace omath::projection std::unreachable(); } - [[nodiscard("You must use frustum culling result")]] OMATH_CONSTEXPR bool + [[nodiscard("You must use frustum culling result")]] constexpr bool is_culled_by_frustum(const Triangle>& triangle) const noexcept { // Transform to clip space (before perspective divide) @@ -420,7 +421,7 @@ namespace omath::projection return false; } - [[nodiscard("You must use AABB frustum culling result")]] OMATH_CONSTEXPR bool + [[nodiscard("You must use AABB frustum culling result")]] constexpr bool is_aabb_culled_by_frustum(const primitives::Aabb& aabb) const noexcept { // For each plane, find the AABB corner most in the direction of the plane normal @@ -438,7 +439,7 @@ namespace omath::projection return false; } - [[nodiscard("You must use OBB frustum culling result")]] OMATH_CONSTEXPR bool + [[nodiscard("You must use OBB frustum culling result")]] constexpr bool is_obb_culled_by_frustum(const primitives::Obb& obb) const noexcept { // For each plane, project the OBB extents onto the plane normal to get the @@ -459,7 +460,7 @@ namespace omath::projection return false; } - [[nodiscard("You must use view port position")]] OMATH_CONSTEXPR std::expected, Error> + [[nodiscard("You must use view port position")]] constexpr std::expected, Error> world_to_view_port(const Vector3& world_position, const ViewPortClipping& clipping = ViewPortClipping::AUTO) const noexcept { @@ -502,10 +503,11 @@ namespace omath::projection return project_to_view_port(projected); } [[nodiscard("You must use world position")]] - OMATH_CONSTEXPR std::expected, Error> + constexpr std::expected, Error> view_port_to_world(const Vector3& ndc) const noexcept { - auto view_port_to_world = [&ndc](const Mat4X4Type& view_projection) -> std::expected, Error> + auto view_port_to_world = + [&ndc](const Mat4X4Type& view_projection) -> std::expected, Error> { const auto inv_view_proj = view_projection.inverted(); @@ -536,7 +538,7 @@ namespace omath::projection template [[nodiscard("You must use world position")]] - OMATH_CONSTEXPR std::expected, Error> + constexpr std::expected, Error> screen_to_world(const Vector3& screen_pos) const noexcept { return view_port_to_world(screen_to_ndc(screen_pos)); @@ -544,7 +546,7 @@ namespace omath::projection template [[nodiscard("You must use world position")]] - OMATH_CONSTEXPR std::expected, Error> + constexpr std::expected, Error> screen_to_world(const Vector2& screen_pos) const noexcept { const auto& [x, y] = screen_pos; @@ -579,7 +581,7 @@ namespace omath::projection // Top = r3 - r1 // Near = r3 + r2 ([-1,1]) or r2 ([0,1]) // Far = r3 - r2 - [[nodiscard("You must use frustum planes")]] OMATH_CONSTEXPR std::array + [[nodiscard("You must use frustum planes")]] constexpr std::array extract_frustum_planes() const noexcept { const auto& m = get_view_projection_matrix(); diff --git a/include/omath/trigonometry/angle.hpp b/include/omath/trigonometry/angle.hpp index 37980dd..cd33534 100644 --- a/include/omath/trigonometry/angle.hpp +++ b/include/omath/trigonometry/angle.hpp @@ -3,7 +3,7 @@ // #pragma once -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/trigonometry/angles.hpp" #include #include @@ -71,31 +71,31 @@ namespace omath } [[nodiscard]] - OMATH_CONSTEXPR Type sin() const noexcept + constexpr Type sin() const noexcept { return internal::sin(as_radians()); } [[nodiscard]] - OMATH_CONSTEXPR Type cos() const noexcept + constexpr Type cos() const noexcept { return internal::cos(as_radians()); } [[nodiscard]] - OMATH_CONSTEXPR Type tan() const noexcept + constexpr Type tan() const noexcept { return internal::tan(as_radians()); } [[nodiscard]] - OMATH_CONSTEXPR Type atan() const noexcept + constexpr Type atan() const noexcept { return internal::atan(as_radians()); } [[nodiscard]] - OMATH_CONSTEXPR Type cot() const noexcept + constexpr Type cot() const noexcept { return cos() / sin(); } diff --git a/include/omath/trigonometry/angles.hpp b/include/omath/trigonometry/angles.hpp index 1e08cfb..c88e421 100644 --- a/include/omath/trigonometry/angles.hpp +++ b/include/omath/trigonometry/angles.hpp @@ -3,7 +3,7 @@ // #pragma once -#include "omath/internal/optional_constexpr_math.hpp" +#include "omath/internal/constexpr_math.hpp" #include #include @@ -25,20 +25,19 @@ namespace omath::angles template requires std::is_floating_point_v - [[nodiscard]] OMATH_CONSTEXPR Type horizontal_fov_to_vertical(const Type& horizontal_fov, - const Type& aspect) noexcept + [[nodiscard]] constexpr Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept { const auto fov_rad = degrees_to_radians(horizontal_fov); - const auto vert_fov = static_cast(2) * internal::atan(internal::tan(fov_rad / static_cast(2)) / aspect); + const auto vert_fov = + static_cast(2) * internal::atan(internal::tan(fov_rad / static_cast(2)) / aspect); return radians_to_degrees(vert_fov); } template requires std::is_floating_point_v - [[nodiscard]] OMATH_CONSTEXPR Type vertical_fov_to_horizontal(const Type& vertical_fov, - const Type& aspect) noexcept + [[nodiscard]] constexpr Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept { const auto fov_as_radians = degrees_to_radians(vertical_fov); @@ -50,7 +49,7 @@ namespace omath::angles template requires std::is_arithmetic_v - [[nodiscard]] OMATH_CONSTEXPR Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept + [[nodiscard]] constexpr Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept { if (angle <= max && angle >= min) return angle; diff --git a/modules/omath.cppm b/modules/omath.cppm index f879c84..39c55cd 100644 --- a/modules/omath.cppm +++ b/modules/omath.cppm @@ -10,8 +10,8 @@ module; #include #include #include -#include #include +#include #include #include #include @@ -37,10 +37,6 @@ module; #include #endif -#if defined(OMATH_USE_GCEM) -#include -#endif - #if defined(OMATH_IMGUI_INTEGRATION) #include #endif @@ -58,7 +54,6 @@ module; export module omath; -export -{ +export { #include "omath/omath.hpp" } diff --git a/tests/engines/unit_test_cry_engine.cpp b/tests/engines/unit_test_cry_engine.cpp index 3392772..0e41578 100644 --- a/tests/engines/unit_test_cry_engine.cpp +++ b/tests/engines/unit_test_cry_engine.cpp @@ -10,7 +10,6 @@ using namespace omath; -#ifdef OMATH_USE_GCEM namespace { constexpr bool close_to(const float actual, const float expected, const float epsilon) @@ -41,7 +40,7 @@ static_assert( && close_to(rotation.at(1, 1), 1.0f, 1e-5f) && close_to(rotation.at(2, 2), 1.0f, 1e-5f) && close_to(rotation.at(3, 3), 1.0f, 1e-5f); }(), - "CryEngine basis vectors should be constexpr with gcem"); + "CryEngine basis vectors should be constexpr with embedded constexpr math"); static_assert( [] @@ -50,7 +49,7 @@ static_assert( return close_to(view.at(0, 0), 1.0f, 1e-5f) && close_to(view.at(1, 2), 1.0f, 1e-5f) && close_to(view.at(2, 1), 1.0f, 1e-5f) && close_to(view.at(3, 3), 1.0f, 1e-5f); }(), - "CryEngine view matrix should be constexpr with gcem"); + "CryEngine view matrix should be constexpr with embedded constexpr math"); static_assert( [] @@ -62,7 +61,7 @@ static_assert( return vec_close_to(origin, {1.0f, 2.0f, 3.0f}, 1e-5f) && vec_close_to(scale, {2.0f, 3.0f, 4.0f}, 1e-5f); }(), - "CryEngine transform extraction should be constexpr with gcem"); + "CryEngine transform extraction should be constexpr with embedded constexpr math"); static_assert( [] @@ -73,7 +72,7 @@ static_assert( && close_to(projection.at(2, 2), 1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) && close_to(projection.at(3, 2), 1.0f, 1e-5f); }(), - "CryEngine projection matrix should be constexpr with gcem"); + "CryEngine projection matrix should be constexpr with embedded constexpr math"); static_assert( [] @@ -91,7 +90,7 @@ static_assert( && close_to(projection.at(1, 1), 1.0f, 1e-5f) && close_to(projection.at(2, 2), 1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) && close_to(projection.at(3, 2), 1.0f, 1e-5f); }(), - "CryEngine CameraTrait should be constexpr with gcem"); + "CryEngine CameraTrait should be constexpr with embedded constexpr math"); static_assert(omath::cry_engine::units_to_centimeters(100.0f) == 1.0f); static_assert(omath::cry_engine::units_to_meters(2.0f) == 2.0f); @@ -99,7 +98,6 @@ static_assert(omath::cry_engine::units_to_kilometers(2000.0f) == 2.0f); static_assert(omath::cry_engine::centimeters_to_units(1.0f) == 100.0f); static_assert(omath::cry_engine::meters_to_units(2.0f) == 2.0f); static_assert(omath::cry_engine::kilometers_to_units(2.0f) == 2000.0f); -#endif TEST(unit_test_cry_engine, look_at_forward) { diff --git a/tests/engines/unit_test_traits_engines.cpp b/tests/engines/unit_test_traits_engines.cpp index 6d1a113..8ce1837 100644 --- a/tests/engines/unit_test_traits_engines.cpp +++ b/tests/engines/unit_test_traits_engines.cpp @@ -1,40 +1,32 @@ // Tests for engine trait headers to improve header coverage #include -#include -#include -#include -#include - -#include -#include -#include -#include - -#include -#include -#include -#include - -#include -#include -#include -#include - -#include -#include -#include -#include - -#include -#include -#include - #include #include - +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include - +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include #include @@ -51,7 +43,6 @@ static void expect_matrix_near(const MatT& a, const MatT& b, float eps = 1e-5f) } // ── Launch offset tests for all engines ────────────────────────────────────── -#ifdef OMATH_USE_GCEM template constexpr bool matrix_has_non_zero_element(const MatType& mat) { @@ -86,7 +77,6 @@ static_assert(camera_can_calculate_matrices_at_compile_time()); static_assert(camera_can_calculate_matrices_at_compile_time()); static_assert(camera_can_calculate_matrices_at_compile_time()); -#endif #include @@ -121,8 +111,10 @@ static void verify_zero_offset_matches_default() p2.m_launch_speed = static_cast(50); p2.m_gravity_scale = static_cast(1); - const auto pos1 = Trait::predict_projectile_position(p, static_cast(15), static_cast(30), static_cast(1), static_cast(9.81)); - const auto pos2 = Trait::predict_projectile_position(p2, static_cast(15), static_cast(30), static_cast(1), static_cast(9.81)); + const auto pos1 = Trait::predict_projectile_position(p, static_cast(15), static_cast(30), + static_cast(1), static_cast(9.81)); + const auto pos2 = Trait::predict_projectile_position(p2, static_cast(15), static_cast(30), + static_cast(1), static_cast(9.81)); #if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || defined(_M_ARM64) constexpr double tol = 1e-6; #else @@ -205,7 +197,8 @@ TEST(LaunchOffsetTests, OffsetShiftsTrajectory) p_with_offset.m_gravity_scale = 1.f; const auto pos1 = source_engine::PredEngineTrait::predict_projectile_position(p_no_offset, 20.f, 45.f, 2.f, 9.81f); - const auto pos2 = source_engine::PredEngineTrait::predict_projectile_position(p_with_offset, 20.f, 45.f, 2.f, 9.81f); + const auto pos2 = + source_engine::PredEngineTrait::predict_projectile_position(p_with_offset, 20.f, 45.f, 2.f, 9.81f); // The difference should be exactly the launch offset EXPECT_NEAR(pos2.x - pos1.x, 10.f, 1e-4f); @@ -268,12 +261,16 @@ TEST(TraitTests, Frostbite_Pred_And_Mesh_And_Camera) // CameraTrait look at should be callable const auto angles = e::CameraTrait::calc_look_at_angle({0, 0, 0}, {0, 1, 1}); (void)angles; - const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, + 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f); expect_matrix_near(proj, expected); - const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); - const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto proj_zo = e::CameraTrait::calc_projection_matrix( + projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto expected_zo = + e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); expect_matrix_near(proj_zo, expected_zo); EXPECT_NE(proj, proj_zo); } @@ -319,12 +316,16 @@ TEST(TraitTests, IW_Pred_And_Mesh_And_Camera) e::ViewAngles va; expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va)); - const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, + 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); const auto expected = e::calc_perspective_projection_matrix(45.f, 1920.f / 1080.f, 0.1f, 1000.f); expect_matrix_near(proj, expected); - const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); - const auto expected_zo = e::calc_perspective_projection_matrix(45.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto proj_zo = e::CameraTrait::calc_projection_matrix( + projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto expected_zo = + e::calc_perspective_projection_matrix(45.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); expect_matrix_near(proj_zo, expected_zo); EXPECT_NE(proj, proj_zo); @@ -374,12 +375,16 @@ TEST(TraitTests, OpenGL_Pred_And_Mesh_And_Camera) e::ViewAngles va; expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va)); - const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, + 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f); expect_matrix_near(proj, expected); - const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); - const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto proj_zo = e::CameraTrait::calc_projection_matrix( + projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto expected_zo = + e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); expect_matrix_near(proj_zo, expected_zo); EXPECT_NE(proj, proj_zo); @@ -429,12 +434,16 @@ TEST(TraitTests, Unity_Pred_And_Mesh_And_Camera) e::ViewAngles va; expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va)); - const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, + 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f); expect_matrix_near(proj, expected); - const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); - const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto proj_zo = e::CameraTrait::calc_projection_matrix( + projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto expected_zo = + e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); expect_matrix_near(proj_zo, expected_zo); EXPECT_NE(proj, proj_zo); @@ -484,12 +493,16 @@ TEST(TraitTests, Unreal_Pred_And_Mesh_And_Camera) e::ViewAngles va; expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va)); - const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, + 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f); expect_matrix_near(proj, expected); - const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); - const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto proj_zo = e::CameraTrait::calc_projection_matrix( + projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto expected_zo = + e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); expect_matrix_near(proj_zo, expected_zo); EXPECT_NE(proj, proj_zo); @@ -505,18 +518,17 @@ TEST(NDCDepthRangeTests, Source_BothDepthRanges) { namespace e = omath::source_engine; - const auto proj_no = e::CameraTrait::calc_projection_matrix( - projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f, - NDCDepthRange::NEGATIVE_ONE_TO_ONE); - const auto expected_no = e::calc_perspective_projection_matrix( - 90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj_no = + e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, + 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto expected_no = e::calc_perspective_projection_matrix(90.f, 1920.f / 1080.f, 0.1f, 1000.f, + NDCDepthRange::NEGATIVE_ONE_TO_ONE); expect_matrix_near(proj_no, expected_no); const auto proj_zo = e::CameraTrait::calc_projection_matrix( - projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f, - NDCDepthRange::ZERO_TO_ONE); - const auto expected_zo = e::calc_perspective_projection_matrix( - 90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto expected_zo = + e::calc_perspective_projection_matrix(90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); expect_matrix_near(proj_zo, expected_zo); EXPECT_NE(proj_no, proj_zo); @@ -526,18 +538,17 @@ TEST(NDCDepthRangeTests, CryEngine_BothDepthRanges) { namespace e = omath::cry_engine; - const auto proj_no = e::CameraTrait::calc_projection_matrix( - projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f, - NDCDepthRange::NEGATIVE_ONE_TO_ONE); - const auto expected_no = e::calc_perspective_projection_matrix( - 90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj_no = + e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, + 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto expected_no = e::calc_perspective_projection_matrix(90.f, 1920.f / 1080.f, 0.1f, 1000.f, + NDCDepthRange::NEGATIVE_ONE_TO_ONE); expect_matrix_near(proj_no, expected_no); const auto proj_zo = e::CameraTrait::calc_projection_matrix( - projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f, - NDCDepthRange::ZERO_TO_ONE); - const auto expected_zo = e::calc_perspective_projection_matrix( - 90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); + const auto expected_zo = + e::calc_perspective_projection_matrix(90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); expect_matrix_near(proj_zo, expected_zo); EXPECT_NE(proj_no, proj_zo); @@ -584,7 +595,8 @@ TEST(NDCDepthRangeTests, OpenGL_ZeroToOne_ZRange) const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); // OpenGL engine uses column-major matrices, project manually - auto proj_z = [&](float z) { + auto proj_z = [&](float z) + { auto clip = proj * mat_column_from_vector({0, 0, z}); return clip.at(2, 0) / clip.at(3, 0); }; @@ -612,7 +624,8 @@ TEST(NDCDepthRangeTests, Unity_ZeroToOne_ZRange) // Unity is right-handed, row-major const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE); - auto proj_z = [&](float z) { + auto proj_z = [&](float z) + { auto clip = proj * mat_column_from_vector({0, 0, z}); return clip.at(2, 0) / clip.at(3, 0); }; @@ -650,7 +663,8 @@ TEST(NDCDepthRangeTests, CryEngine_ZeroToOne_ZRange) TEST(NDCDepthRangeTests, Source_NegativeOneToOne_ZRange) { namespace e = omath::source_engine; - const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f); EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f); @@ -659,7 +673,8 @@ TEST(NDCDepthRangeTests, Source_NegativeOneToOne_ZRange) TEST(NDCDepthRangeTests, IW_NegativeOneToOne_ZRange) { namespace e = omath::iw_engine; - const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f); EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f); @@ -668,7 +683,8 @@ TEST(NDCDepthRangeTests, IW_NegativeOneToOne_ZRange) TEST(NDCDepthRangeTests, Frostbite_NegativeOneToOne_ZRange) { namespace e = omath::frostbite_engine; - const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f); EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f); @@ -677,7 +693,8 @@ TEST(NDCDepthRangeTests, Frostbite_NegativeOneToOne_ZRange) TEST(NDCDepthRangeTests, Unreal_NegativeOneToOne_ZRange) { namespace e = omath::unreal_engine; - const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f); EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f); @@ -686,7 +703,8 @@ TEST(NDCDepthRangeTests, Unreal_NegativeOneToOne_ZRange) TEST(NDCDepthRangeTests, CryEngine_NegativeOneToOne_ZRange) { namespace e = omath::cry_engine; - const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f); EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f); @@ -695,9 +713,11 @@ TEST(NDCDepthRangeTests, CryEngine_NegativeOneToOne_ZRange) TEST(NDCDepthRangeTests, OpenGL_NegativeOneToOne_ZRange) { namespace e = omath::opengl_engine; - const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); - auto proj_z = [&](float z) { + auto proj_z = [&](float z) + { auto clip = proj * mat_column_from_vector({0, 0, z}); return clip.at(2, 0) / clip.at(3, 0); }; @@ -709,9 +729,11 @@ TEST(NDCDepthRangeTests, OpenGL_NegativeOneToOne_ZRange) TEST(NDCDepthRangeTests, Unity_NegativeOneToOne_ZRange) { namespace e = omath::unity_engine; - const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); + const auto proj = + e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE); - auto proj_z = [&](float z) { + auto proj_z = [&](float z) + { auto clip = proj * mat_column_from_vector({0, 0, z}); return clip.at(2, 0) / clip.at(3, 0); }; diff --git a/tests/general/unit_test_angle.cpp b/tests/general/unit_test_angle.cpp index ad17e65..89cc88c 100644 --- a/tests/general/unit_test_angle.cpp +++ b/tests/general/unit_test_angle.cpp @@ -19,13 +19,11 @@ namespace constexpr float k_eps = 1e-5f; -#ifdef OMATH_USE_GCEM constexpr bool close_to(const float actual, const float expected, const float epsilon) { const float diff = actual - expected; return (diff < 0.0f ? -diff : diff) <= epsilon; } -#endif } // namespace @@ -199,10 +197,13 @@ TEST(UnitTestAngle, BinaryMinus_ReturnsWrappedDiff) EXPECT_FLOAT_EQ(c.as_degrees(), 340.0f); } -#ifdef OMATH_USE_GCEM -static_assert(close_to(Pitch::from_degrees(0.0f).sin(), 0.0f, k_eps), "Sin should be constexpr with gcem"); -static_assert(close_to(Pitch::from_degrees(0.0f).cos(), 1.0f, k_eps), "Cos should be constexpr with gcem"); -static_assert(close_to(Pitch::from_degrees(45.0f).tan(), 1.0f, 1e-4f), "Tan should be constexpr with gcem"); -static_assert(close_to(Pitch::from_degrees(45.0f).cot(), 1.0f, 1e-4f), "Cot should be constexpr with gcem"); -static_assert(close_to(Pitch::from_degrees(45.0f).atan(), 0.66577375f, 1e-6f), "Atan should be constexpr with gcem"); -#endif +static_assert(close_to(Pitch::from_degrees(0.0f).sin(), 0.0f, k_eps), + "Sin should be constexpr with embedded constexpr math"); +static_assert(close_to(Pitch::from_degrees(0.0f).cos(), 1.0f, k_eps), + "Cos should be constexpr with embedded constexpr math"); +static_assert(close_to(Pitch::from_degrees(45.0f).tan(), 1.0f, 1e-4f), + "Tan should be constexpr with embedded constexpr math"); +static_assert(close_to(Pitch::from_degrees(45.0f).cot(), 1.0f, 1e-4f), + "Cot should be constexpr with embedded constexpr math"); +static_assert(close_to(Pitch::from_degrees(45.0f).atan(), 0.66577375f, 1e-6f), + "Atan should be constexpr with embedded constexpr math"); diff --git a/tests/general/unit_test_mat.cpp b/tests/general/unit_test_mat.cpp index 63bfd64..e2e3654 100644 --- a/tests/general/unit_test_mat.cpp +++ b/tests/general/unit_test_mat.cpp @@ -7,7 +7,6 @@ using namespace omath; -#ifdef OMATH_USE_GCEM namespace { using Pitch = Angle(-90), static_cast(90), AngleFlags::Clamped>; @@ -18,7 +17,6 @@ namespace return (diff < 0.0f ? -diff : diff) <= epsilon; } } // namespace -#endif class UnitTestMat : public ::testing::Test { @@ -177,7 +175,6 @@ TEST_F(UnitTestMat, StaticMethod_ToScreenMat) EXPECT_FLOAT_EQ(screen_mat.at(3, 3), 1.0f); } - // Test exception handling in At() method TEST_F(UnitTestMat, Method_At_OutOfRange) { @@ -225,7 +222,7 @@ TEST(UnitTestMatStandalone, Transpose_NonSquare) TEST(UnitTestMatStandalone, Enverse) { constexpr Mat<2, 2> m{{1.0f, 3.0f}, {2.0f, 5.0f}}; - constexpr Mat<2,2> mv{{-5.0f, 3.0f}, {2.0f, -1.0f}}; + constexpr Mat<2, 2> mv{{-5.0f, 3.0f}, {2.0f, -1.0f}}; EXPECT_EQ(mv, m.inverted()); } @@ -248,9 +245,8 @@ TEST(UnitTestMatStandalone, Equanity) } TEST(UnitTestMatStandalone, MatPerspectiveLeftHanded) { - const auto perspective_proj = mat_perspective_left_handed_vertical_fov(90.f, 16.f/9.f, 0.1f, 1000.f); - auto projected = perspective_proj - * mat_column_from_vector({0, 0, 0.1001}); + const auto perspective_proj = mat_perspective_left_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); + auto projected = perspective_proj * mat_column_from_vector({0, 0, 0.1001}); projected /= projected.at(3, 0); @@ -259,8 +255,9 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHanded) TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedZeroToOne) { - const auto proj = mat_perspective_left_handed_vertical_fov( - 90.f, 16.f / 9.f, 0.1f, 1000.f); + const auto proj = + mat_perspective_left_handed_vertical_fov( + 90.f, 16.f / 9.f, 0.1f, 1000.f); // Near plane point should map to z ~ 0 auto near_pt = proj * mat_column_from_vector({0, 0, 0.1f}); @@ -281,8 +278,9 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedZeroToOne) TEST(UnitTestMatStandalone, MatPerspectiveRightHandedZeroToOne) { - const auto proj = mat_perspective_right_handed_vertical_fov( - 90.f, 16.f / 9.f, 0.1f, 1000.f); + const auto proj = + mat_perspective_right_handed_vertical_fov( + 90.f, 16.f / 9.f, 0.1f, 1000.f); // Near plane point (negative z for right-handed) should map to z ~ 0 auto near_pt = proj * mat_column_from_vector({0, 0, -0.1f}); @@ -306,7 +304,8 @@ TEST(UnitTestMatStandalone, MatPerspectiveNegativeOneToOneRange) // Verify existing [-1, 1] behavior with explicit template arg matches default const auto proj_default = mat_perspective_left_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); const auto proj_explicit = mat_perspective_left_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); + NDCDepthRange::NEGATIVE_ONE_TO_ONE>( + 90.f, 16.f / 9.f, 0.1f, 1000.f); EXPECT_EQ(proj_default, proj_explicit); @@ -324,7 +323,8 @@ TEST(UnitTestMatStandalone, MatPerspectiveNegativeOneToOneRange) TEST(UnitTestMatStandalone, MatPerspectiveRightHandedNegOneToOne) { const auto proj = mat_perspective_right_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); + NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f, + 0.1f, 1000.f); // Near plane (negative z for RH) should map to z ~ -1 auto near_pt = proj * mat_column_from_vector({0, 0, -0.1f}); @@ -340,14 +340,15 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedNegOneToOne) auto mid_pt = proj * mat_column_from_vector({0, 0, -500.f}); mid_pt /= mid_pt.at(3, 0); EXPECT_GT(mid_pt.at(2, 0), -1.0f); - EXPECT_LT(mid_pt.at(2, 0), 1.0f); + EXPECT_LT(mid_pt.at(2, 0), 1.0f); } TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovZeroToOne) { // hfov=90 deg, aspect=16/9 => tan(hfov/2)=1, so x_axis=1 and y_axis=aspect - const auto proj = mat_perspective_left_handed_horizontal_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); + const auto proj = + mat_perspective_left_handed_horizontal_fov( + 90.f, 16.f / 9.f, 0.1f, 1000.f); // Near plane should map to z ~ 0 auto near_pt = proj * mat_column_from_vector({0, 0, 0.1f}); @@ -368,7 +369,8 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovZeroToOne) TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovNegOneToOne) { const auto proj = mat_perspective_left_handed_horizontal_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); + NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f, + 0.1f, 1000.f); auto near_pt = proj * mat_column_from_vector({0, 0, 0.1f}); near_pt /= near_pt.at(3, 0); @@ -385,8 +387,9 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovNegOneToOne) TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovZeroToOne) { - const auto proj = mat_perspective_right_handed_horizontal_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); + const auto proj = + mat_perspective_right_handed_horizontal_fov( + 90.f, 16.f / 9.f, 0.1f, 1000.f); auto near_pt = proj * mat_column_from_vector({0, 0, -0.1f}); near_pt /= near_pt.at(3, 0); @@ -404,7 +407,8 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovZeroToOne) TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovNegOneToOne) { const auto proj = mat_perspective_right_handed_horizontal_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); + NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f, + 0.1f, 1000.f); auto near_pt = proj * mat_column_from_vector({0, 0, -0.1f}); near_pt /= near_pt.at(3, 0); @@ -422,7 +426,7 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovNegOneToOne) TEST(UnitTestMatStandalone, MatPerspectiveHorizontalVsVerticalFovEquivalence) { constexpr float hfov_deg = 90.f; - constexpr float aspect = 16.f / 9.f; + constexpr float aspect = 16.f / 9.f; const float vfov_deg = angles::horizontal_fov_to_vertical(hfov_deg, aspect); const auto proj_h = mat_perspective_left_handed_horizontal_fov(hfov_deg, aspect, 0.1f, 1000.f); @@ -440,11 +444,11 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedVerticalFovHandedness) { const auto proj = mat_perspective_left_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); - const auto in_front = proj * mat_column_from_vector({0, 0, 1.f}); - const auto behind = proj * mat_column_from_vector({0, 0, -1.f}); + const auto in_front = proj * mat_column_from_vector({0, 0, 1.f}); + const auto behind = proj * mat_column_from_vector({0, 0, -1.f}); EXPECT_GT(in_front.at(3, 0), 0.0f); - EXPECT_LT(behind.at(3, 0), 0.0f); + EXPECT_LT(behind.at(3, 0), 0.0f); } TEST(UnitTestMatStandalone, MatPerspectiveRightHandedVerticalFovHandedness) @@ -452,21 +456,21 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedVerticalFovHandedness) const auto proj = mat_perspective_right_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); const auto in_front = proj * mat_column_from_vector({0, 0, -1.f}); - const auto behind = proj * mat_column_from_vector({0, 0, 1.f}); + const auto behind = proj * mat_column_from_vector({0, 0, 1.f}); EXPECT_GT(in_front.at(3, 0), 0.0f); - EXPECT_LT(behind.at(3, 0), 0.0f); + EXPECT_LT(behind.at(3, 0), 0.0f); } TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovHandedness) { const auto proj = mat_perspective_left_handed_horizontal_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); - const auto in_front = proj * mat_column_from_vector({0, 0, 1.f}); - const auto behind = proj * mat_column_from_vector({0, 0, -1.f}); + const auto in_front = proj * mat_column_from_vector({0, 0, 1.f}); + const auto behind = proj * mat_column_from_vector({0, 0, -1.f}); EXPECT_GT(in_front.at(3, 0), 0.0f); - EXPECT_LT(behind.at(3, 0), 0.0f); + EXPECT_LT(behind.at(3, 0), 0.0f); } TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovHandedness) @@ -474,10 +478,10 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovHandedness) const auto proj = mat_perspective_right_handed_horizontal_fov(90.f, 16.f / 9.f, 0.1f, 1000.f); const auto in_front = proj * mat_column_from_vector({0, 0, -1.f}); - const auto behind = proj * mat_column_from_vector({0, 0, 1.f}); + const auto behind = proj * mat_column_from_vector({0, 0, 1.f}); EXPECT_GT(in_front.at(3, 0), 0.0f); - EXPECT_LT(behind.at(3, 0), 0.0f); + EXPECT_LT(behind.at(3, 0), 0.0f); } TEST(UnitTestMatStandalone, MatPerspectiveZeroToOneEquanity) @@ -486,10 +490,12 @@ TEST(UnitTestMatStandalone, MatPerspectiveZeroToOneEquanity) constexpr omath::Vector3 left_handed = {0, 2, 10}; constexpr omath::Vector3 right_handed = {0, 2, -10}; - const auto proj_lh = mat_perspective_left_handed_vertical_fov( - 90.f, 16.f / 9.f, 0.1f, 1000.f); - const auto proj_rh = mat_perspective_right_handed_vertical_fov( - 90.f, 16.f / 9.f, 0.1f, 1000.f); + const auto proj_lh = + mat_perspective_left_handed_vertical_fov( + 90.f, 16.f / 9.f, 0.1f, 1000.f); + const auto proj_rh = + mat_perspective_right_handed_vertical_fov( + 90.f, 16.f / 9.f, 0.1f, 1000.f); auto ndc_lh = proj_lh * mat_column_from_vector(left_handed); auto ndc_rh = proj_rh * mat_column_from_vector(right_handed); @@ -532,20 +538,20 @@ TEST(UnitTestMatStandalone, MatOrthoNegativeOneToOneDefault) { // Verify explicit [-1, 1] matches default const auto ortho_default = mat_ortho_left_handed(-1.f, 1.f, -1.f, 1.f, 0.1f, 100.f); - const auto ortho_explicit = mat_ortho_left_handed(-1.f, 1.f, -1.f, 1.f, 0.1f, 100.f); + const auto ortho_explicit = + mat_ortho_left_handed(-1.f, 1.f, -1.f, + 1.f, 0.1f, 100.f); EXPECT_EQ(ortho_default, ortho_explicit); } -#ifdef OMATH_USE_GCEM static_assert( [] { constexpr auto scale = mat_extract_scale(mat_scale(Vector3{2.0f, 3.0f, 4.0f})); return close_to(scale.x, 2.0f, 1e-5f) && close_to(scale.y, 3.0f, 1e-5f) && close_to(scale.z, 4.0f, 1e-5f); }(), - "Mat scale extraction should be constexpr with gcem"); + "Mat scale extraction should be constexpr with embedded constexpr math"); static_assert( [] @@ -555,7 +561,7 @@ static_assert( && close_to(rotation.at(1, 0), 1.0f, 1e-5f) && close_to(rotation.at(1, 1), 0.0f, 1e-5f) && close_to(rotation.at(2, 2), 1.0f, 1e-5f) && close_to(rotation.at(3, 3), 1.0f, 1e-5f); }(), - "Mat rotation should be constexpr with gcem"); + "Mat rotation should be constexpr with embedded constexpr math"); static_assert( [] @@ -567,7 +573,7 @@ static_assert( && close_to(projection.at(2, 2), 1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) && close_to(projection.at(3, 2), 1.0f, 1e-5f); }(), - "Mat vertical-FOV perspective should be constexpr with gcem"); + "Mat vertical-FOV perspective should be constexpr with embedded constexpr math"); static_assert( [] @@ -579,5 +585,4 @@ static_assert( && close_to(projection.at(2, 2), -1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) && close_to(projection.at(3, 2), -1.0f, 1e-5f); }(), - "Mat horizontal-FOV perspective should be constexpr with gcem"); -#endif + "Mat horizontal-FOV perspective should be constexpr with embedded constexpr math"); diff --git a/tests/general/unit_test_projection.cpp b/tests/general/unit_test_projection.cpp index 8c7f4b9..ebcb04a 100644 --- a/tests/general/unit_test_projection.cpp +++ b/tests/general/unit_test_projection.cpp @@ -60,7 +60,6 @@ static void verify_random_look_at_targets_project_to_screen_center(const omath:: } } -#ifdef OMATH_USE_GCEM constexpr bool source_camera_constexpr_projection_round_trip() { constexpr auto fov = omath::Angle::from_degrees(90.f); @@ -74,23 +73,21 @@ constexpr bool source_camera_constexpr_projection_round_trip() return projected.has_value() && result.has_value() && result2.has_value() && static_cast>(projected.value()) == static_cast>(result2.value()) - && omath::internal::abs(projected->x - 960.f) < 0.001f - && omath::internal::abs(projected->y - 504.f) < 0.001f + && omath::internal::abs(projected->x - 960.f) < 0.001f && omath::internal::abs(projected->y - 504.f) < 0.001f && omath::internal::abs(projected->z - 1.f) < 0.001f; } static_assert(source_camera_constexpr_projection_round_trip()); -#endif TEST(UnitTestProjection, Projection) { - OMATH_CONSTEXPR auto fov = omath::Angle::from_degrees(90.f); - OMATH_CONSTEXPR auto cam = omath::source_engine::Camera( - {0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov, 0.01f, 1000.f); + constexpr auto fov = omath::Angle::from_degrees(90.f); + constexpr auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, + fov, 0.01f, 1000.f); - OMATH_CONSTEXPR auto projected = cam.world_to_screen({1000.f, 0, 50.f}); - OMATH_CONSTEXPR auto result = cam.screen_to_world(projected.value()); - OMATH_CONSTEXPR auto result2 = cam.world_to_screen(result.value()); + constexpr auto projected = cam.world_to_screen({1000.f, 0, 50.f}); + constexpr auto result = cam.screen_to_world(projected.value()); + constexpr auto result2 = cam.world_to_screen(result.value()); EXPECT_EQ(static_cast>(projected.value()), static_cast>(result2.value())); @@ -587,11 +584,9 @@ TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_LookingForward) { constexpr float k_eps = 1e-4f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f); - const omath::source_engine::ViewAngles angles{ - omath::source_engine::PitchAngle::from_degrees(0.f), - omath::source_engine::YawAngle::from_degrees(0.f), - omath::source_engine::RollAngle::from_degrees(0.f) - }; + const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(0.f), + omath::source_engine::YawAngle::from_degrees(0.f), + omath::source_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f); const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix()); @@ -604,11 +599,9 @@ TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_PositivePitchAndYaw) { constexpr float k_eps = 1e-4f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f); - const omath::source_engine::ViewAngles angles{ - omath::source_engine::PitchAngle::from_degrees(30.f), - omath::source_engine::YawAngle::from_degrees(45.f), - omath::source_engine::RollAngle::from_degrees(0.f) - }; + const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(30.f), + omath::source_engine::YawAngle::from_degrees(45.f), + omath::source_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f); const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix()); @@ -621,11 +614,9 @@ TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_NegativePitchAndYaw) { constexpr float k_eps = 1e-4f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f); - const omath::source_engine::ViewAngles angles{ - omath::source_engine::PitchAngle::from_degrees(-45.f), - omath::source_engine::YawAngle::from_degrees(-90.f), - omath::source_engine::RollAngle::from_degrees(0.f) - }; + const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(-45.f), + omath::source_engine::YawAngle::from_degrees(-90.f), + omath::source_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f); const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix()); @@ -640,11 +631,9 @@ TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_OffOriginCameraIgnored) // so the same angles should be recovered regardless of position. constexpr float k_eps = 1e-4f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f); - const omath::source_engine::ViewAngles angles{ - omath::source_engine::PitchAngle::from_degrees(20.f), - omath::source_engine::YawAngle::from_degrees(60.f), - omath::source_engine::RollAngle::from_degrees(0.f) - }; + const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(20.f), + omath::source_engine::YawAngle::from_degrees(60.f), + omath::source_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::source_engine::Camera({100.f, 200.f, -50.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f); const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix()); @@ -657,11 +646,9 @@ TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_RollAlwaysZero) { // Roll cannot be encoded in the forward vector, so it is always 0 in the result. constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f); - const omath::source_engine::ViewAngles angles{ - omath::source_engine::PitchAngle::from_degrees(10.f), - omath::source_engine::YawAngle::from_degrees(30.f), - omath::source_engine::RollAngle::from_degrees(15.f) - }; + const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(10.f), + omath::source_engine::YawAngle::from_degrees(30.f), + omath::source_engine::RollAngle::from_degrees(15.f)}; const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f); const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix()); @@ -686,11 +673,9 @@ TEST(UnitTestProjection, CalcOriginFromViewMatrix_ArbitraryPosition) { constexpr float k_eps = 1e-3f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f); - const omath::source_engine::ViewAngles angles{ - omath::source_engine::PitchAngle::from_degrees(0.f), - omath::source_engine::YawAngle::from_degrees(0.f), - omath::source_engine::RollAngle::from_degrees(0.f) - }; + const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(0.f), + omath::source_engine::YawAngle::from_degrees(0.f), + omath::source_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::source_engine::Camera({100.f, 200.f, -50.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f); const auto origin = omath::source_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix()); @@ -705,11 +690,9 @@ TEST(UnitTestProjection, CalcOriginFromViewMatrix_WithRotation) // Origin recovery must work even when the camera is rotated. constexpr float k_eps = 1e-3f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f); - const omath::source_engine::ViewAngles angles{ - omath::source_engine::PitchAngle::from_degrees(30.f), - omath::source_engine::YawAngle::from_degrees(45.f), - omath::source_engine::RollAngle::from_degrees(0.f) - }; + const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(30.f), + omath::source_engine::YawAngle::from_degrees(45.f), + omath::source_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::source_engine::Camera({300.f, -100.f, 75.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f); const auto origin = omath::source_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix()); @@ -726,16 +709,12 @@ TEST(UnitTestProjection, CalcOriginFromViewMatrix_IndependentOfAngles) constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f); constexpr omath::Vector3 expected_origin{50.f, 50.f, 50.f}; - const omath::source_engine::ViewAngles angles_a{ - omath::source_engine::PitchAngle::from_degrees(0.f), - omath::source_engine::YawAngle::from_degrees(0.f), - omath::source_engine::RollAngle::from_degrees(0.f) - }; - const omath::source_engine::ViewAngles angles_b{ - omath::source_engine::PitchAngle::from_degrees(-60.f), - omath::source_engine::YawAngle::from_degrees(135.f), - omath::source_engine::RollAngle::from_degrees(0.f) - }; + const omath::source_engine::ViewAngles angles_a{omath::source_engine::PitchAngle::from_degrees(0.f), + omath::source_engine::YawAngle::from_degrees(0.f), + omath::source_engine::RollAngle::from_degrees(0.f)}; + const omath::source_engine::ViewAngles angles_b{omath::source_engine::PitchAngle::from_degrees(-60.f), + omath::source_engine::YawAngle::from_degrees(135.f), + omath::source_engine::RollAngle::from_degrees(0.f)}; const auto cam_a = omath::source_engine::Camera(expected_origin, angles_a, {1920.f, 1080.f}, fov, 0.01f, 1000.f); const auto cam_b = omath::source_engine::Camera(expected_origin, angles_b, {1920.f, 1080.f}, fov, 0.01f, 1000.f); @@ -758,11 +737,9 @@ TEST(UnitTestProjection, Unity_CalcViewAnglesFromViewMatrix_LookingForward) { constexpr float k_eps = 1e-4f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f); - const omath::unity_engine::ViewAngles angles{ - omath::unity_engine::PitchAngle::from_degrees(0.f), - omath::unity_engine::YawAngle::from_degrees(0.f), - omath::unity_engine::RollAngle::from_degrees(0.f) - }; + const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(0.f), + omath::unity_engine::YawAngle::from_degrees(0.f), + omath::unity_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::unity_engine::Camera({0, 0, 0}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f); const auto result = omath::unity_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix()); @@ -775,11 +752,9 @@ TEST(UnitTestProjection, Unity_CalcViewAnglesFromViewMatrix_PositivePitchAndYaw) { constexpr float k_eps = 1e-4f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f); - const omath::unity_engine::ViewAngles angles{ - omath::unity_engine::PitchAngle::from_degrees(30.f), - omath::unity_engine::YawAngle::from_degrees(45.f), - omath::unity_engine::RollAngle::from_degrees(0.f) - }; + const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(30.f), + omath::unity_engine::YawAngle::from_degrees(45.f), + omath::unity_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::unity_engine::Camera({0, 0, 0}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f); const auto result = omath::unity_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix()); @@ -792,11 +767,9 @@ TEST(UnitTestProjection, Unity_CalcViewAnglesFromViewMatrix_NegativePitchAndYaw) { constexpr float k_eps = 1e-4f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f); - const omath::unity_engine::ViewAngles angles{ - omath::unity_engine::PitchAngle::from_degrees(-45.f), - omath::unity_engine::YawAngle::from_degrees(-90.f), - omath::unity_engine::RollAngle::from_degrees(0.f) - }; + const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(-45.f), + omath::unity_engine::YawAngle::from_degrees(-90.f), + omath::unity_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::unity_engine::Camera({0, 0, 0}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f); const auto result = omath::unity_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix()); @@ -822,11 +795,9 @@ TEST(UnitTestProjection, Unity_CalcOriginFromViewMatrix_ArbitraryPosition) { constexpr float k_eps = 1e-3f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f); - const omath::unity_engine::ViewAngles angles{ - omath::unity_engine::PitchAngle::from_degrees(0.f), - omath::unity_engine::YawAngle::from_degrees(0.f), - omath::unity_engine::RollAngle::from_degrees(0.f) - }; + const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(0.f), + omath::unity_engine::YawAngle::from_degrees(0.f), + omath::unity_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::unity_engine::Camera({100.f, 200.f, -50.f}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f); const auto origin = omath::unity_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix()); @@ -840,11 +811,9 @@ TEST(UnitTestProjection, Unity_CalcOriginFromViewMatrix_WithRotation) { constexpr float k_eps = 1e-3f; constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f); - const omath::unity_engine::ViewAngles angles{ - omath::unity_engine::PitchAngle::from_degrees(30.f), - omath::unity_engine::YawAngle::from_degrees(45.f), - omath::unity_engine::RollAngle::from_degrees(0.f) - }; + const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(30.f), + omath::unity_engine::YawAngle::from_degrees(45.f), + omath::unity_engine::RollAngle::from_degrees(0.f)}; const auto cam = omath::unity_engine::Camera({300.f, -100.f, 75.f}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f); const auto origin = omath::unity_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix()); @@ -860,21 +829,21 @@ TEST(UnitTestProjection, SourceEngine_ZeroAngles_BasisVectors) constexpr float k_eps = 1e-5f; const auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f}, omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f); - const auto fwd = cam.get_abs_forward(); + const auto fwd = cam.get_abs_forward(); const auto right = cam.get_abs_right(); - const auto up = cam.get_abs_up(); + const auto up = cam.get_abs_up(); - EXPECT_NEAR(fwd.x, omath::source_engine::k_abs_forward.x, k_eps); - EXPECT_NEAR(fwd.y, omath::source_engine::k_abs_forward.y, k_eps); - EXPECT_NEAR(fwd.z, omath::source_engine::k_abs_forward.z, k_eps); + EXPECT_NEAR(fwd.x, omath::source_engine::k_abs_forward.x, k_eps); + EXPECT_NEAR(fwd.y, omath::source_engine::k_abs_forward.y, k_eps); + EXPECT_NEAR(fwd.z, omath::source_engine::k_abs_forward.z, k_eps); EXPECT_NEAR(right.x, omath::source_engine::k_abs_right.x, k_eps); EXPECT_NEAR(right.y, omath::source_engine::k_abs_right.y, k_eps); EXPECT_NEAR(right.z, omath::source_engine::k_abs_right.z, k_eps); - EXPECT_NEAR(up.x, omath::source_engine::k_abs_up.x, k_eps); - EXPECT_NEAR(up.y, omath::source_engine::k_abs_up.y, k_eps); - EXPECT_NEAR(up.z, omath::source_engine::k_abs_up.z, k_eps); + EXPECT_NEAR(up.x, omath::source_engine::k_abs_up.x, k_eps); + EXPECT_NEAR(up.y, omath::source_engine::k_abs_up.y, k_eps); + EXPECT_NEAR(up.z, omath::source_engine::k_abs_up.z, k_eps); } TEST(UnitTestProjection, UnityEngine_ZeroAngles_BasisVectors) @@ -882,21 +851,21 @@ TEST(UnitTestProjection, UnityEngine_ZeroAngles_BasisVectors) constexpr float k_eps = 1e-5f; const auto cam = omath::unity_engine::Camera({}, {}, {1280.f, 720.f}, omath::projection::FieldOfView::from_degrees(60.f), 0.03f, 1000.f); - const auto fwd = cam.get_abs_forward(); + const auto fwd = cam.get_abs_forward(); const auto right = cam.get_abs_right(); - const auto up = cam.get_abs_up(); + const auto up = cam.get_abs_up(); - EXPECT_NEAR(fwd.x, omath::unity_engine::k_abs_forward.x, k_eps); - EXPECT_NEAR(fwd.y, omath::unity_engine::k_abs_forward.y, k_eps); - EXPECT_NEAR(fwd.z, omath::unity_engine::k_abs_forward.z, k_eps); + EXPECT_NEAR(fwd.x, omath::unity_engine::k_abs_forward.x, k_eps); + EXPECT_NEAR(fwd.y, omath::unity_engine::k_abs_forward.y, k_eps); + EXPECT_NEAR(fwd.z, omath::unity_engine::k_abs_forward.z, k_eps); EXPECT_NEAR(right.x, omath::unity_engine::k_abs_right.x, k_eps); EXPECT_NEAR(right.y, omath::unity_engine::k_abs_right.y, k_eps); EXPECT_NEAR(right.z, omath::unity_engine::k_abs_right.z, k_eps); - EXPECT_NEAR(up.x, omath::unity_engine::k_abs_up.x, k_eps); - EXPECT_NEAR(up.y, omath::unity_engine::k_abs_up.y, k_eps); - EXPECT_NEAR(up.z, omath::unity_engine::k_abs_up.z, k_eps); + EXPECT_NEAR(up.x, omath::unity_engine::k_abs_up.x, k_eps); + EXPECT_NEAR(up.y, omath::unity_engine::k_abs_up.y, k_eps); + EXPECT_NEAR(up.z, omath::unity_engine::k_abs_up.z, k_eps); } TEST(UnitTestProjection, OpenGLEngine_ZeroAngles_BasisVectors) @@ -904,21 +873,21 @@ TEST(UnitTestProjection, OpenGLEngine_ZeroAngles_BasisVectors) constexpr float k_eps = 1e-5f; const auto cam = omath::opengl_engine::Camera({}, {}, {1920.f, 1080.f}, omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f); - const auto fwd = cam.get_abs_forward(); + const auto fwd = cam.get_abs_forward(); const auto right = cam.get_abs_right(); - const auto up = cam.get_abs_up(); + const auto up = cam.get_abs_up(); - EXPECT_NEAR(fwd.x, omath::opengl_engine::k_abs_forward.x, k_eps); - EXPECT_NEAR(fwd.y, omath::opengl_engine::k_abs_forward.y, k_eps); - EXPECT_NEAR(fwd.z, omath::opengl_engine::k_abs_forward.z, k_eps); + EXPECT_NEAR(fwd.x, omath::opengl_engine::k_abs_forward.x, k_eps); + EXPECT_NEAR(fwd.y, omath::opengl_engine::k_abs_forward.y, k_eps); + EXPECT_NEAR(fwd.z, omath::opengl_engine::k_abs_forward.z, k_eps); EXPECT_NEAR(right.x, omath::opengl_engine::k_abs_right.x, k_eps); EXPECT_NEAR(right.y, omath::opengl_engine::k_abs_right.y, k_eps); EXPECT_NEAR(right.z, omath::opengl_engine::k_abs_right.z, k_eps); - EXPECT_NEAR(up.x, omath::opengl_engine::k_abs_up.x, k_eps); - EXPECT_NEAR(up.y, omath::opengl_engine::k_abs_up.y, k_eps); - EXPECT_NEAR(up.z, omath::opengl_engine::k_abs_up.z, k_eps); + EXPECT_NEAR(up.x, omath::opengl_engine::k_abs_up.x, k_eps); + EXPECT_NEAR(up.y, omath::opengl_engine::k_abs_up.y, k_eps); + EXPECT_NEAR(up.z, omath::opengl_engine::k_abs_up.z, k_eps); } TEST(UnitTestProjection, UnrealEngine_ZeroAngles_BasisVectors) @@ -926,21 +895,21 @@ TEST(UnitTestProjection, UnrealEngine_ZeroAngles_BasisVectors) constexpr float k_eps = 1e-5f; const auto cam = omath::unreal_engine::Camera({}, {}, {1920.f, 1080.f}, omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f); - const auto fwd = cam.get_abs_forward(); + const auto fwd = cam.get_abs_forward(); const auto right = cam.get_abs_right(); - const auto up = cam.get_abs_up(); + const auto up = cam.get_abs_up(); - EXPECT_NEAR(fwd.x, omath::unreal_engine::k_abs_forward.x, k_eps); - EXPECT_NEAR(fwd.y, omath::unreal_engine::k_abs_forward.y, k_eps); - EXPECT_NEAR(fwd.z, omath::unreal_engine::k_abs_forward.z, k_eps); + EXPECT_NEAR(fwd.x, omath::unreal_engine::k_abs_forward.x, k_eps); + EXPECT_NEAR(fwd.y, omath::unreal_engine::k_abs_forward.y, k_eps); + EXPECT_NEAR(fwd.z, omath::unreal_engine::k_abs_forward.z, k_eps); EXPECT_NEAR(right.x, omath::unreal_engine::k_abs_right.x, k_eps); EXPECT_NEAR(right.y, omath::unreal_engine::k_abs_right.y, k_eps); EXPECT_NEAR(right.z, omath::unreal_engine::k_abs_right.z, k_eps); - EXPECT_NEAR(up.x, omath::unreal_engine::k_abs_up.x, k_eps); - EXPECT_NEAR(up.y, omath::unreal_engine::k_abs_up.y, k_eps); - EXPECT_NEAR(up.z, omath::unreal_engine::k_abs_up.z, k_eps); + EXPECT_NEAR(up.x, omath::unreal_engine::k_abs_up.x, k_eps); + EXPECT_NEAR(up.y, omath::unreal_engine::k_abs_up.y, k_eps); + EXPECT_NEAR(up.z, omath::unreal_engine::k_abs_up.z, k_eps); } TEST(UnitTestProjection, FrostbiteEngine_ZeroAngles_BasisVectors) @@ -948,21 +917,21 @@ TEST(UnitTestProjection, FrostbiteEngine_ZeroAngles_BasisVectors) constexpr float k_eps = 1e-5f; const auto cam = omath::frostbite_engine::Camera({}, {}, {1920.f, 1080.f}, omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f); - const auto fwd = cam.get_abs_forward(); + const auto fwd = cam.get_abs_forward(); const auto right = cam.get_abs_right(); - const auto up = cam.get_abs_up(); + const auto up = cam.get_abs_up(); - EXPECT_NEAR(fwd.x, omath::frostbite_engine::k_abs_forward.x, k_eps); - EXPECT_NEAR(fwd.y, omath::frostbite_engine::k_abs_forward.y, k_eps); - EXPECT_NEAR(fwd.z, omath::frostbite_engine::k_abs_forward.z, k_eps); + EXPECT_NEAR(fwd.x, omath::frostbite_engine::k_abs_forward.x, k_eps); + EXPECT_NEAR(fwd.y, omath::frostbite_engine::k_abs_forward.y, k_eps); + EXPECT_NEAR(fwd.z, omath::frostbite_engine::k_abs_forward.z, k_eps); EXPECT_NEAR(right.x, omath::frostbite_engine::k_abs_right.x, k_eps); EXPECT_NEAR(right.y, omath::frostbite_engine::k_abs_right.y, k_eps); EXPECT_NEAR(right.z, omath::frostbite_engine::k_abs_right.z, k_eps); - EXPECT_NEAR(up.x, omath::frostbite_engine::k_abs_up.x, k_eps); - EXPECT_NEAR(up.y, omath::frostbite_engine::k_abs_up.y, k_eps); - EXPECT_NEAR(up.z, omath::frostbite_engine::k_abs_up.z, k_eps); + EXPECT_NEAR(up.x, omath::frostbite_engine::k_abs_up.x, k_eps); + EXPECT_NEAR(up.y, omath::frostbite_engine::k_abs_up.y, k_eps); + EXPECT_NEAR(up.z, omath::frostbite_engine::k_abs_up.z, k_eps); } TEST(UnitTestProjection, CryEngine_ZeroAngles_BasisVectors) @@ -970,21 +939,21 @@ TEST(UnitTestProjection, CryEngine_ZeroAngles_BasisVectors) constexpr float k_eps = 1e-5f; const auto cam = omath::cry_engine::Camera({}, {}, {1920.f, 1080.f}, omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f); - const auto fwd = cam.get_abs_forward(); + const auto fwd = cam.get_abs_forward(); const auto right = cam.get_abs_right(); - const auto up = cam.get_abs_up(); + const auto up = cam.get_abs_up(); - EXPECT_NEAR(fwd.x, omath::cry_engine::k_abs_forward.x, k_eps); - EXPECT_NEAR(fwd.y, omath::cry_engine::k_abs_forward.y, k_eps); - EXPECT_NEAR(fwd.z, omath::cry_engine::k_abs_forward.z, k_eps); + EXPECT_NEAR(fwd.x, omath::cry_engine::k_abs_forward.x, k_eps); + EXPECT_NEAR(fwd.y, omath::cry_engine::k_abs_forward.y, k_eps); + EXPECT_NEAR(fwd.z, omath::cry_engine::k_abs_forward.z, k_eps); EXPECT_NEAR(right.x, omath::cry_engine::k_abs_right.x, k_eps); EXPECT_NEAR(right.y, omath::cry_engine::k_abs_right.y, k_eps); EXPECT_NEAR(right.z, omath::cry_engine::k_abs_right.z, k_eps); - EXPECT_NEAR(up.x, omath::cry_engine::k_abs_up.x, k_eps); - EXPECT_NEAR(up.y, omath::cry_engine::k_abs_up.y, k_eps); - EXPECT_NEAR(up.z, omath::cry_engine::k_abs_up.z, k_eps); + EXPECT_NEAR(up.x, omath::cry_engine::k_abs_up.x, k_eps); + EXPECT_NEAR(up.y, omath::cry_engine::k_abs_up.y, k_eps); + EXPECT_NEAR(up.z, omath::cry_engine::k_abs_up.z, k_eps); } TEST(UnitTestProjection, IWEngine_ZeroAngles_BasisVectors) @@ -992,21 +961,21 @@ TEST(UnitTestProjection, IWEngine_ZeroAngles_BasisVectors) constexpr float k_eps = 1e-5f; const auto cam = omath::iw_engine::Camera({}, {}, {1920.f, 1080.f}, omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f); - const auto fwd = cam.get_abs_forward(); + const auto fwd = cam.get_abs_forward(); const auto right = cam.get_abs_right(); - const auto up = cam.get_abs_up(); + const auto up = cam.get_abs_up(); - EXPECT_NEAR(fwd.x, omath::iw_engine::k_abs_forward.x, k_eps); - EXPECT_NEAR(fwd.y, omath::iw_engine::k_abs_forward.y, k_eps); - EXPECT_NEAR(fwd.z, omath::iw_engine::k_abs_forward.z, k_eps); + EXPECT_NEAR(fwd.x, omath::iw_engine::k_abs_forward.x, k_eps); + EXPECT_NEAR(fwd.y, omath::iw_engine::k_abs_forward.y, k_eps); + EXPECT_NEAR(fwd.z, omath::iw_engine::k_abs_forward.z, k_eps); EXPECT_NEAR(right.x, omath::iw_engine::k_abs_right.x, k_eps); EXPECT_NEAR(right.y, omath::iw_engine::k_abs_right.y, k_eps); EXPECT_NEAR(right.z, omath::iw_engine::k_abs_right.z, k_eps); - EXPECT_NEAR(up.x, omath::iw_engine::k_abs_up.x, k_eps); - EXPECT_NEAR(up.y, omath::iw_engine::k_abs_up.y, k_eps); - EXPECT_NEAR(up.z, omath::iw_engine::k_abs_up.z, k_eps); + EXPECT_NEAR(up.x, omath::iw_engine::k_abs_up.x, k_eps); + EXPECT_NEAR(up.y, omath::iw_engine::k_abs_up.y, k_eps); + EXPECT_NEAR(up.z, omath::iw_engine::k_abs_up.z, k_eps); } // ---- extract_projection_params ---- @@ -1142,11 +1111,9 @@ TEST(UnitTestProjection, SetViewAngles_InvalidatesViewMatrix) auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f); const auto view_before = cam.get_view_matrix(); - const omath::source_engine::ViewAngles rotated{ - omath::source_engine::PitchAngle::from_degrees(30.f), - omath::source_engine::YawAngle::from_degrees(45.f), - omath::source_engine::RollAngle::from_degrees(0.f) - }; + const omath::source_engine::ViewAngles rotated{omath::source_engine::PitchAngle::from_degrees(30.f), + omath::source_engine::YawAngle::from_degrees(45.f), + omath::source_engine::RollAngle::from_degrees(0.f)}; cam.set_view_angles(rotated); const auto view_after = cam.get_view_matrix(); @@ -1164,7 +1131,7 @@ TEST(UnitTestProjection, CalcLookAtAngles_ForwardTarget) const auto angles = cam.calc_look_at_angles({100.f, 0.f, 0.f}); EXPECT_NEAR(angles.pitch.as_degrees(), 0.f, 1e-4f); - EXPECT_NEAR(angles.yaw.as_degrees(), 0.f, 1e-4f); + EXPECT_NEAR(angles.yaw.as_degrees(), 0.f, 1e-4f); } TEST(UnitTestProjection, LookAt_ForwardVectorPointsAtTarget) @@ -1237,11 +1204,7 @@ TEST(UnitTestProjection, TriangleInsideFrustumNotCulled) const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f); // Small triangle directly in front (Source: +X forward) - const omath::Triangle> tri{ - {100.f, 0.f, 1.f}, - {100.f, 1.f, -1.f}, - {100.f, -1.f, -1.f} - }; + const omath::Triangle> tri{{100.f, 0.f, 1.f}, {100.f, 1.f, -1.f}, {100.f, -1.f, -1.f}}; EXPECT_FALSE(cam.is_culled_by_frustum(tri)); } @@ -1251,11 +1214,7 @@ TEST(UnitTestProjection, TriangleBehindCameraCulled) const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f); // Triangle entirely behind the camera (-X) - const omath::Triangle> tri{ - {-100.f, 0.f, 1.f}, - {-100.f, 1.f, -1.f}, - {-100.f, -1.f, -1.f} - }; + const omath::Triangle> tri{{-100.f, 0.f, 1.f}, {-100.f, 1.f, -1.f}, {-100.f, -1.f, -1.f}}; EXPECT_TRUE(cam.is_culled_by_frustum(tri)); } @@ -1265,11 +1224,7 @@ TEST(UnitTestProjection, TriangleBeyondFarPlaneCulled) const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f); // Triangle beyond the 1000-unit far plane - const omath::Triangle> tri{ - {2000.f, 0.f, 1.f}, - {2000.f, 1.f, -1.f}, - {2000.f, -1.f, -1.f} - }; + const omath::Triangle> tri{{2000.f, 0.f, 1.f}, {2000.f, 1.f, -1.f}, {2000.f, -1.f, -1.f}}; EXPECT_TRUE(cam.is_culled_by_frustum(tri)); } @@ -1279,11 +1234,7 @@ TEST(UnitTestProjection, TriangleFarToSideCulled) const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f); // Triangle far outside the side frustum planes - const omath::Triangle> tri{ - {100.f, 5000.f, 0.f}, - {100.f, 5001.f, 1.f}, - {100.f, 5001.f, -1.f} - }; + const omath::Triangle> tri{{100.f, 5000.f, 0.f}, {100.f, 5001.f, 1.f}, {100.f, 5001.f, -1.f}}; EXPECT_TRUE(cam.is_culled_by_frustum(tri)); } @@ -1293,10 +1244,6 @@ TEST(UnitTestProjection, TriangleStraddlingFrustumNotCulled) const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f); // Large triangle with vertices on both sides of the frustum — should not be culled - const omath::Triangle> tri{ - { 100.f, 0.f, 0.f}, - { 100.f, 5000.f, 0.f}, - { 100.f, 0.f, 5000.f} - }; + const omath::Triangle> tri{{100.f, 0.f, 0.f}, {100.f, 5000.f, 0.f}, {100.f, 0.f, 5000.f}}; EXPECT_FALSE(cam.is_culled_by_frustum(tri)); } diff --git a/tests/general/unit_test_triangle.cpp b/tests/general/unit_test_triangle.cpp index e327689..7f26976 100644 --- a/tests/general/unit_test_triangle.cpp +++ b/tests/general/unit_test_triangle.cpp @@ -8,7 +8,6 @@ using namespace omath; -#ifdef OMATH_USE_GCEM namespace { constexpr bool close_to(const float actual, const float expected, const float epsilon) @@ -17,7 +16,6 @@ namespace return (diff < 0.0f ? -diff : diff) <= epsilon; } } // namespace -#endif class UnitTestTriangle : public ::testing::Test { @@ -30,36 +28,21 @@ protected: constexpr void SetUp() override { // Triangle with vertices (0, 0, 0), (1, 0, 0), (0, 1, 0) - t1 = Triangle>( - Vector3(0.0f, 0.0f, 0.0f), - Vector3(1.0f, 0.0f, 0.0f), - Vector3(0.0f, 1.0f, 0.0f) - ); + t1 = Triangle>(Vector3(0.0f, 0.0f, 0.0f), Vector3(1.0f, 0.0f, 0.0f), Vector3(0.0f, 1.0f, 0.0f)); // Triangle with vertices (1, 2, 3), (4, 5, 6), (7, 8, 9) - t2 = Triangle>( - Vector3(1.0f, 2.0f, 3.0f), - Vector3(4.0f, 5.0f, 6.0f), - Vector3(7.0f, 8.0f, 9.0f) - ); + t2 = Triangle>(Vector3(1.0f, 2.0f, 3.0f), Vector3(4.0f, 5.0f, 6.0f), Vector3(7.0f, 8.0f, 9.0f)); // An isosceles right triangle - t3 = Triangle>( - Vector3(0.0f, 0.0f, 0.0f), - Vector3(2.0f, 0.0f, 0.0f), - Vector3(0.0f, 2.0f, 0.0f) - ); + t3 = Triangle>(Vector3(0.0f, 0.0f, 0.0f), Vector3(2.0f, 0.0f, 0.0f), Vector3(0.0f, 2.0f, 0.0f)); } }; // Test constructor and vertices TEST_F(UnitTestTriangle, Constructor) { - constexpr Triangle> t( - Vector3(1.0f, 2.0f, 3.0f), - Vector3(4.0f, 5.0f, 6.0f), - Vector3(7.0f, 8.0f, 9.0f) - ); + constexpr Triangle> t(Vector3(1.0f, 2.0f, 3.0f), Vector3(4.0f, 5.0f, 6.0f), + Vector3(7.0f, 8.0f, 9.0f)); EXPECT_FLOAT_EQ(t.m_vertex1.x, 1.0f); EXPECT_FLOAT_EQ(t.m_vertex1.y, 2.0f); @@ -83,7 +66,6 @@ TEST_F(UnitTestTriangle, CalculateNormal) EXPECT_NEAR(std::fabs(normal_t1.z), 1.0f, 1e-5f); EXPECT_NEAR(normal_t1.length(), 1.0f, 1e-5f); - // For t3, we expect the normal to be along +Z as well const Vector3 normal_t3 = t3.calculate_normal(); EXPECT_NEAR(std::fabs(normal_t3.z), 1.0f, 1e-5f); @@ -94,7 +76,10 @@ TEST_F(UnitTestTriangle, SideLengths) { // For t1 side lengths EXPECT_FLOAT_EQ(t1.side_a_length(), std::sqrt(1.0f)); // distance between (0,0,0) and (1,0,0) - EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(1.0f + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate: + EXPECT_FLOAT_EQ( + t1.side_b_length(), + std::sqrt(1.0f + + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate: // Actually, for t1: vertex2=(1,0,0), vertex3=(0,1,0) // Dist between (0,1,0) and (1,0,0) = sqrt((1-0)^2 + (0-1)^2) = sqrt(1 + 1) = sqrt(2) EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(2.0f)); @@ -123,7 +108,7 @@ TEST_F(UnitTestTriangle, SideVectors) TEST_F(UnitTestTriangle, IsRectangular) { - EXPECT_TRUE(Triangle>({2,0,0}, {}, {0,2,0}).is_rectangular()); + EXPECT_TRUE(Triangle>({2, 0, 0}, {}, {0, 2, 0}).is_rectangular()); } // Test midpoint TEST_F(UnitTestTriangle, MidPoint) @@ -141,7 +126,6 @@ TEST_F(UnitTestTriangle, MidPoint) EXPECT_FLOAT_EQ(mid2.z, (3.0f + 6.0f + 9.0f) / 3.0f); } -#ifdef OMATH_USE_GCEM static_assert( [] { @@ -155,5 +139,4 @@ static_assert( && close_to(mid_point.x, 1.0f, 1e-5f) && close_to(mid_point.y, 4.0f / 3.0f, 1e-5f) && close_to(mid_point.z, 0.0f, 1e-5f); }(), - "Triangle helpers should be constexpr with gcem"); -#endif + "Triangle helpers should be constexpr with embedded constexpr math"); diff --git a/tests/general/unit_test_vector2.cpp b/tests/general/unit_test_vector2.cpp index 52f606c..84fee1d 100644 --- a/tests/general/unit_test_vector2.cpp +++ b/tests/general/unit_test_vector2.cpp @@ -463,8 +463,7 @@ static_assert(Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot produc static_assert(Vector2(4.0f, 5.0f).distance_to_sqr(Vector2(1.0f, 2.0f)) == 18.0f, "DistToSqr should be 18"); static_assert(Vector2(-1.0f, -2.0f).abs() == Vector2(1.0f, 2.0f), "Abs should convert negative values to positive"); -#ifdef OMATH_USE_GCEM -static_assert(Vector2(3.0f, 4.0f).length() == 5.0f, "Length should be constexpr with gcem"); -static_assert(Vector2(0.0f, 0.0f).distance_to(Vector2(3.0f, 4.0f)) == 5.0f, "Distance should be constexpr with gcem"); -static_assert(Vector2(1.0f, 1.0f) < Vector2(3.0f, 4.0f), "Comparison should be constexpr with gcem"); -#endif +static_assert(Vector2(3.0f, 4.0f).length() == 5.0f, "Length should be constexpr with embedded constexpr math"); +static_assert(Vector2(0.0f, 0.0f).distance_to(Vector2(3.0f, 4.0f)) == 5.0f, + "Distance should be constexpr with embedded constexpr math"); +static_assert(Vector2(1.0f, 1.0f) < Vector2(3.0f, 4.0f), "Comparison should be constexpr with embedded constexpr math"); diff --git a/tests/general/unit_test_vector3.cpp b/tests/general/unit_test_vector3.cpp index e9c2b75..3717ba9 100644 --- a/tests/general/unit_test_vector3.cpp +++ b/tests/general/unit_test_vector3.cpp @@ -584,16 +584,15 @@ static_assert(Vector3(4.0f, 5.0f, 6.0f).distance_to_sqr(Vector3(1.0f, 2.0f, 3.0f static_assert(Vector3(-1.0f, -2.0f, -3.0f).abs() == Vector3(1.0f, 2.0f, 3.0f), "Abs should convert negative values to positive"); -#ifdef OMATH_USE_GCEM -static_assert(Vector3(1.0f, 2.0f, 2.0f).length() == 3.0f, "Length should be constexpr with gcem"); +static_assert(Vector3(1.0f, 2.0f, 2.0f).length() == 3.0f, "Length should be constexpr with embedded constexpr math"); static_assert(Vector3(0.0f, 0.0f, 0.0f).distance_to(Vector3(1.0f, 2.0f, 2.0f)) == 3.0f, - "Distance should be constexpr with gcem"); -static_assert(Vector3(1.0f, 1.0f, 1.0f) < Vector3(3.0f, 4.0f, 5.0f), "Comparison should be constexpr with gcem"); + "Distance should be constexpr with embedded constexpr math"); +static_assert(Vector3(1.0f, 1.0f, 1.0f) < Vector3(3.0f, 4.0f, 5.0f), + "Comparison should be constexpr with embedded constexpr math"); static_assert( [] { constexpr auto angle = Vector3(1.0f, 0.0f, 0.0f).angle_between(Vector3(0.0f, 1.0f, 0.0f)); return angle.has_value() && angle->as_degrees() > 89.999f && angle->as_degrees() < 90.001f; }(), - "Angle between should be constexpr with gcem"); -#endif + "Angle between should be constexpr with embedded constexpr math"); diff --git a/vcpkg.json b/vcpkg.json index 5b68917..27e3bef 100644 --- a/vcpkg.json +++ b/vcpkg.json @@ -82,13 +82,6 @@ "lua", "sol2" ] - }, - "gcem": - { - "description": "Improve constexpr compatibility using gcem", - "dependencies": [ - "gcem" - ] } } } From 92da8bf0a656ba085934bcdabcdad8c420a52b2e Mon Sep 17 00:00:00 2001 From: Orange Date: Mon, 15 Jun 2026 00:45:16 +0300 Subject: [PATCH 19/20] fix --- include/omath/linear_algebra/mat.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/omath/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index 40175f9..a5115ef 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -662,7 +662,7 @@ namespace omath template requires std::is_floating_point_v [[nodiscard("You must use extracted rotation")]] - Vector3 mat_extract_rotation_zyx(const Mat<4, 4, Type, St>& mat) noexcept + constexpr Vector3 mat_extract_rotation_zyx(const Mat<4, 4, Type, St>& mat) noexcept { const auto scale = mat_extract_scale(mat); const auto m00 = mat.at(0, 0) / scale.x; From 10f5d866bd66e341408b3332470a9babf0713a4f Mon Sep 17 00:00:00 2001 From: Orange Date: Mon, 15 Jun 2026 00:57:03 +0300 Subject: [PATCH 20/20] removed redundant option --- .github/workflows/cmake-multi-platform.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml index 1866dd6..a989ffd 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/cmake-multi-platform.yml @@ -107,7 +107,7 @@ jobs: -DOMATH_BUILD_TESTS=ON \ -DOMATH_BUILD_BENCHMARK=OFF \ -DOMATH_ENABLE_COVERAGE=${{ matrix.coverage == true && 'ON' || 'OFF' }} \ - -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua;gcem" + -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua" - name: Build shell: bash