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" - ] } } }