diff --git a/CMakeLists.txt b/CMakeLists.txt index fd24fcd..14e645d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,6 +33,7 @@ option(OMATH_ENABLE_FORCE_INLINE option(OMATH_ENABLE_LUA "omath bindings for lua" OFF) option(OMATH_ENABLE_HOOKING "omath will HooksManager that can hook DirectX/OpenGL automatically" OFF) +option(OMATH_ENABLE_MODULES "Build omath C++ module interface" OFF) if(VCPKG_MANIFEST_FEATURES) foreach(omath_feature IN LISTS VCPKG_MANIFEST_FEATURES) @@ -80,6 +81,7 @@ if(${PROJECT_IS_TOP_LEVEL}) message(STATUS "[${PROJECT_NAME}]: Coverage feature status ${OMATH_ENABLE_COVERAGE}") message(STATUS "[${PROJECT_NAME}]: Valgrind feature status ${OMATH_ENABLE_VALGRIND}") message(STATUS "[${PROJECT_NAME}]: Lua feature status ${OMATH_ENABLE_LUA}") + message(STATUS "[${PROJECT_NAME}]: Modules feature status ${OMATH_ENABLE_MODULES}") endif() if(OMATH_STATIC_MSVC_RUNTIME_LIBRARY) @@ -95,6 +97,20 @@ else() add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS}) endif() +if(OMATH_ENABLE_MODULES) + if(CMAKE_VERSION VERSION_LESS 3.28) + message(FATAL_ERROR "OMATH_ENABLE_MODULES requires CMake 3.28 or newer") + endif() + set_target_properties(${PROJECT_NAME} PROPERTIES CXX_SCAN_FOR_MODULES ON) + if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") + target_compile_options(${PROJECT_NAME} PRIVATE /wd5244) + endif() + target_sources( + ${PROJECT_NAME} + PUBLIC FILE_SET omath_modules TYPE CXX_MODULES BASE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/modules" + FILES "${CMAKE_CURRENT_SOURCE_DIR}/modules/omath.cppm") +endif() + if (OMATH_ENABLE_LUA) target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LUA) @@ -120,6 +136,7 @@ if (OMATH_ENABLE_HOOKING) endif () endif () + add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME}) target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}") @@ -229,6 +246,10 @@ target_include_directories( # Installation rules +if(OMATH_ENABLE_MODULES) + set(OMATH_MODULE_FILE_SET FILE_SET omath_modules DESTINATION modules) +endif() + # Install the library install( TARGETS ${PROJECT_NAME} @@ -237,6 +258,7 @@ install( LIBRARY DESTINATION lib COMPONENT ${PROJECT_NAME} # For shared libraries RUNTIME DESTINATION bin COMPONENT ${PROJECT_NAME} # For executables (on # Windows) + ${OMATH_MODULE_FILE_SET} ) # Install headers as part of omath_component diff --git a/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 4014b40..abf0665 100644 --- a/include/omath/engines/cry_engine/formulas.hpp +++ b/include/omath/engines/cry_engine/formulas.hpp @@ -8,31 +8,82 @@ namespace omath::cry_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.yaw) + * mat_rotation_axis_y(angles.roll) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + inline constexpr Vector3 forward_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept; + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(angles.y), + }; + } + [[nodiscard]] + inline 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( + field_of_view, aspect_ratio, near_plane, far_plane); + + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near_plane, far_plane); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/cry_engine/traits/camera_trait.hpp b/include/omath/engines/cry_engine/traits/camera_trait.hpp index b7770af..2f9f751 100644 --- a/include/omath/engines/cry_engine/traits/camera_trait.hpp +++ b/include/omath/engines/cry_engine/traits/camera_trait.hpp @@ -4,21 +4,36 @@ #pragma once #include "omath/engines/cry_engine/formulas.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" - namespace omath::cry_engine { class CameraTrait final { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + return {PitchAngle::from_radians(internal::asin(direction.z)), + YawAngle::from_radians(-internal::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return cry_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + 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::cry_engine \ No newline at end of file +} // namespace omath::cry_engine diff --git a/include/omath/engines/frostbite_engine/formulas.hpp b/include/omath/engines/frostbite_engine/formulas.hpp index 2328cfe..9212c2c 100644 --- a/include/omath/engines/frostbite_engine/formulas.hpp +++ b/include/omath/engines/frostbite_engine/formulas.hpp @@ -8,31 +8,86 @@ namespace omath::frostbite_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_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); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 up_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); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.roll) + * mat_rotation_axis_y(angles.yaw) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.y), + RollAngle::from_degrees(angles.z), + }; + } + + [[nodiscard]] + inline 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 mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near_plane, far_plane); + + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near_plane, far_plane); + + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp index 99a46ae..2e3074d 100644 --- a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp +++ b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp @@ -4,6 +4,7 @@ #pragma once #include "omath/engines/frostbite_engine/formulas.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::frostbite_engine @@ -12,13 +13,29 @@ namespace omath::frostbite_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(-internal::asin(direction.y)), + YawAngle::from_radians(internal::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return frostbite_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + 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 \ No newline at end of file +} // namespace omath::frostbite_engine diff --git a/include/omath/engines/iw_engine/formulas.hpp b/include/omath/engines/iw_engine/formulas.hpp index a79895e..24a16b7 100644 --- a/include/omath/engines/iw_engine/formulas.hpp +++ b/include/omath/engines/iw_engine/formulas.hpp @@ -8,31 +8,84 @@ namespace omath::iw_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_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); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 up_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); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(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); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) 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]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; - - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.y), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(angles.x), + }; + } + + [[nodiscard]] + inline 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 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 + { + constexpr float k_source_reference_aspect = 4.f / 3.f; + const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect); + + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + vertical_fov, aspect_ratio, near_plane, far_plane); + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + vertical_fov, aspect_ratio, near_plane, far_plane); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/iw_engine/traits/camera_trait.hpp b/include/omath/engines/iw_engine/traits/camera_trait.hpp index 964b8c4..0143ea2 100644 --- a/include/omath/engines/iw_engine/traits/camera_trait.hpp +++ b/include/omath/engines/iw_engine/traits/camera_trait.hpp @@ -3,7 +3,8 @@ // #pragma once -#include "omath/engines/iw_engine/constants.hpp" +#include "omath/engines/iw_engine/formulas.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::iw_engine @@ -12,13 +13,29 @@ namespace omath::iw_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(-internal::asin(direction.z)), + YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return iw_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + 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::iw_engine \ No newline at end of file +} // namespace omath::iw_engine diff --git a/include/omath/engines/opengl_engine/formulas.hpp b/include/omath/engines/opengl_engine/formulas.hpp index dd07f07..05ae176 100644 --- a/include/omath/engines/opengl_engine/formulas.hpp +++ b/include/omath/engines/opengl_engine/formulas.hpp @@ -7,31 +7,88 @@ namespace omath::opengl_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_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); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 up_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); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return mat_look_at_right_handed(cam_origin, cam_origin + forward_vector(angles), up_vector(angles)); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.roll) + * mat_rotation_axis_y(angles.yaw) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.y), + RollAngle::from_degrees(angles.z), + }; + } + + [[nodiscard]] + inline 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( + field_of_view, aspect_ratio, near_plane, far_plane); + + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_right_handed_vertical_fov(field_of_view, aspect_ratio, + near_plane, far_plane); + + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/opengl_engine/traits/camera_trait.hpp b/include/omath/engines/opengl_engine/traits/camera_trait.hpp index e7c1f4b..d953297 100644 --- a/include/omath/engines/opengl_engine/traits/camera_trait.hpp +++ b/include/omath/engines/opengl_engine/traits/camera_trait.hpp @@ -3,7 +3,8 @@ // #pragma once -#include "omath/engines/opengl_engine/constants.hpp" +#include "omath/engines/opengl_engine/formulas.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::opengl_engine @@ -12,13 +13,29 @@ namespace omath::opengl_engine { public: [[nodiscard]] - 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)}; + } [[nodiscard]] - 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]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, 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::opengl_engine \ No newline at end of file +} // namespace omath::opengl_engine diff --git a/include/omath/engines/rage_engine/formulas.hpp b/include/omath/engines/rage_engine/formulas.hpp index 53c3066..08b87fa 100644 --- a/include/omath/engines/rage_engine/formulas.hpp +++ b/include/omath/engines/rage_engine/formulas.hpp @@ -9,31 +9,86 @@ namespace omath::rage_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_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); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 up_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); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.yaw) + * mat_rotation_axis_y(angles.roll) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept; + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(angles.y), + }; + } + + [[nodiscard]] + inline 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( + field_of_view, aspect_ratio, near_plane, far_plane); + + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + field_of_view, aspect_ratio, near_plane, far_plane); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/rage_engine/traits/camera_trait.hpp b/include/omath/engines/rage_engine/traits/camera_trait.hpp index 5e6c420..55643fb 100644 --- a/include/omath/engines/rage_engine/traits/camera_trait.hpp +++ b/include/omath/engines/rage_engine/traits/camera_trait.hpp @@ -4,6 +4,7 @@ #pragma once #include "omath/engines/rage_engine/formulas.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::rage_engine @@ -12,13 +13,29 @@ namespace omath::rage_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(internal::asin(direction.z)), + YawAngle::from_radians(-internal::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return rage_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + 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::rage_engine diff --git a/include/omath/engines/source_engine/formulas.hpp b/include/omath/engines/source_engine/formulas.hpp index 4a8bd93..78bb344 100644 --- a/include/omath/engines/source_engine/formulas.hpp +++ b/include/omath/engines/source_engine/formulas.hpp @@ -7,31 +7,84 @@ namespace omath::source_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Mat4X4 rotation_matrix(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); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) 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]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } [[nodiscard]] - Vector3 right_vector(const ViewAngles& angles) noexcept; + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.y), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(angles.x), + }; + } [[nodiscard]] - Vector3 up_vector(const ViewAngles& angles) noexcept; + inline constexpr Vector3 right_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } + + [[nodiscard]] + inline 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 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 + { + constexpr float k_source_reference_aspect = 4.f / 3.f; + const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect); + + if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + vertical_fov, aspect_ratio, near_plane, far_plane); + if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) + return mat_perspective_left_handed_vertical_fov( + vertical_fov, aspect_ratio, near_plane, far_plane); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/source_engine/traits/camera_trait.hpp b/include/omath/engines/source_engine/traits/camera_trait.hpp index 5ecb192..8e65621 100644 --- a/include/omath/engines/source_engine/traits/camera_trait.hpp +++ b/include/omath/engines/source_engine/traits/camera_trait.hpp @@ -3,7 +3,8 @@ // #pragma once -#include "omath/engines/source_engine/constants.hpp" +#include "omath/engines/source_engine/formulas.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::source_engine @@ -12,13 +13,29 @@ namespace omath::source_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(-internal::asin(direction.z)), + YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return source_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + 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::source_engine \ No newline at end of file +} // namespace omath::source_engine diff --git a/include/omath/engines/unity_engine/formulas.hpp b/include/omath/engines/unity_engine/formulas.hpp index 7d5535b..5be46d9 100644 --- a/include/omath/engines/unity_engine/formulas.hpp +++ b/include/omath/engines/unity_engine/formulas.hpp @@ -8,31 +8,85 @@ namespace omath::unity_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_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); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 up_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); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return mat_camera_view(-forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.roll) + * mat_rotation_axis_y(angles.yaw) + * mat_rotation_axis_x(angles.pitch); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(angles.x), + YawAngle::from_degrees(angles.y), + RollAngle::from_degrees(angles.z), + }; + } + + [[nodiscard]] + inline 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( + 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( + field_of_view, aspect_ratio, near_plane, far_plane); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/unity_engine/traits/camera_trait.hpp b/include/omath/engines/unity_engine/traits/camera_trait.hpp index 1f531af..bf59185 100644 --- a/include/omath/engines/unity_engine/traits/camera_trait.hpp +++ b/include/omath/engines/unity_engine/traits/camera_trait.hpp @@ -4,6 +4,7 @@ #pragma once #include "omath/engines/unity_engine/formulas.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::unity_engine @@ -12,13 +13,29 @@ namespace omath::unity_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(-internal::asin(direction.y)), + YawAngle::from_radians(internal::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return unity_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - float near, float far, NDCDepthRange ndc_depth_range) noexcept; + 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::unity_engine \ No newline at end of file +} // namespace omath::unity_engine diff --git a/include/omath/engines/unreal_engine/formulas.hpp b/include/omath/engines/unreal_engine/formulas.hpp index 47b6dfe..f490b08 100644 --- a/include/omath/engines/unreal_engine/formulas.hpp +++ b/include/omath/engines/unreal_engine/formulas.hpp @@ -8,31 +8,85 @@ namespace omath::unreal_engine { [[nodiscard]] - Vector3 forward_vector(const ViewAngles& angles) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; [[nodiscard]] - Vector3 right_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); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 up_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); - [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept; + inline constexpr Vector3 up_vector(const ViewAngles& angles) noexcept + { + const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); + + return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; + } [[nodiscard]] - Vector3 extract_origin(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return mat_camera_view(forward_vector(angles), right_vector(angles), + up_vector(angles), cam_origin); + } [[nodiscard]] - Vector3 extract_scale(const Mat4X4& mat) noexcept; + inline constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept + { + return mat_rotation_axis_z(angles.yaw) + * mat_rotation_axis_y(-angles.pitch) + * mat_rotation_axis_x(-angles.roll); + } [[nodiscard]] - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept; + inline constexpr Vector3 extract_origin(const Mat4X4& mat) noexcept + { + return mat_extract_origin(mat); + } [[nodiscard]] - Mat4X4 calc_perspective_projection_matrix(double field_of_view, double aspect_ratio, double near, double far, - NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept; + inline constexpr Vector3 extract_scale(const Mat4X4& mat) noexcept + { + return mat_extract_scale(mat); + } + + [[nodiscard]] + inline constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept + { + const auto angles = mat_extract_rotation_zyx(mat); + return { + PitchAngle::from_degrees(-angles.y), + YawAngle::from_degrees(angles.z), + RollAngle::from_degrees(-angles.x), + }; + } + + [[nodiscard]] + inline 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(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( + field_of_view, aspect_ratio, near_plane, far_plane); + std::unreachable(); + } template requires std::is_floating_point_v diff --git a/include/omath/engines/unreal_engine/traits/camera_trait.hpp b/include/omath/engines/unreal_engine/traits/camera_trait.hpp index 4b0fe77..8498a29 100644 --- a/include/omath/engines/unreal_engine/traits/camera_trait.hpp +++ b/include/omath/engines/unreal_engine/traits/camera_trait.hpp @@ -4,6 +4,7 @@ #pragma once #include "omath/engines/unreal_engine/formulas.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/projection/camera.hpp" namespace omath::unreal_engine @@ -12,13 +13,29 @@ namespace omath::unreal_engine { public: [[nodiscard]] - static ViewAngles calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept; + constexpr static ViewAngles calc_look_at_angle(const Vector3& cam_origin, + const Vector3& look_at) noexcept + { + const auto direction = (look_at - cam_origin).normalized(); + + return {PitchAngle::from_radians(internal::asin(direction.z)), + YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; + } [[nodiscard]] - static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept; + constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept + { + return unreal_engine::calc_view_matrix(angles, cam_origin); + } [[nodiscard]] - static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port, - double near, double far, NDCDepthRange ndc_depth_range) noexcept; + 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); + } }; -} // namespace omath::unreal_engine \ No newline at end of file +} // namespace omath::unreal_engine 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/linear_algebra/mat.hpp b/include/omath/linear_algebra/mat.hpp index 2cbf078..a5115ef 100644 --- a/include/omath/linear_algebra/mat.hpp +++ b/include/omath/linear_algebra/mat.hpp @@ -2,6 +2,7 @@ // Created by vlad on 9/29/2024. // #pragma once +#include "omath/internal/constexpr_math.hpp" #include "vector3.hpp" #include #include @@ -10,6 +11,7 @@ #include #include #include +#include #include #ifdef OMATH_USE_AVX2 @@ -41,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 @@ -149,7 +151,8 @@ namespace omath } } - [[nodiscard("You must use element reference")]] constexpr Type& at(const size_t row_index, const size_t column_index) + [[nodiscard("You must use element reference")]] constexpr Type& at(const size_t row_index, + const size_t column_index) { return const_cast(std::as_const(*this).at(row_index, column_index)); } @@ -176,6 +179,13 @@ namespace omath operator*(const Mat& other) const { #ifdef OMATH_USE_AVX2 + if (std::is_constant_evaluated()) + { + if constexpr (StoreType == MatStoreType::ROW_MAJOR) + return cache_friendly_multiply_row_major(other); + else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR) + return cache_friendly_multiply_col_major(other); + } if constexpr (StoreType == MatStoreType::ROW_MAJOR) return avx_multiply_row_major(other); else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR) @@ -192,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; } @@ -212,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; } @@ -388,7 +406,7 @@ namespace omath { const auto det = determinant(); - if (std::abs(det) < std::numeric_limits::epsilon()) + if (internal::abs(det) < std::numeric_limits::epsilon()) return std::nullopt; const auto transposed_mat = transposed(); @@ -578,13 +596,13 @@ namespace omath }; template [[nodiscard("You must use row matrix")]] - constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3& vector) noexcept + constexpr Mat<1, 4, Type, St> mat_row_from_vector(const Vector3& vector) noexcept { return {{vector.x, vector.y, vector.z, 1}}; } template [[nodiscard("You must use column matrix")]] - constexpr static Mat<4, 1, Type, St> mat_column_from_vector(const Vector3& vector) noexcept + constexpr Mat<4, 1, Type, St> mat_column_from_vector(const Vector3& vector) noexcept { return {{vector.x}, {vector.y}, {vector.z}, {1}}; } @@ -593,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}, @@ -622,10 +639,11 @@ namespace omath template [[nodiscard("You must use extracted scale")]] - 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) { - return static_cast(std::sqrt(x * x + y * y + z * z)); + auto column_length = [](const Type x, const Type y, const Type z) + { + return static_cast(internal::sqrt(x * x + y * y + z * z)); }; const auto scale_x = column_length(mat.at(0, 0), mat.at(1, 0), mat.at(2, 0)); @@ -635,16 +653,16 @@ namespace omath constexpr auto epsilon = std::numeric_limits::epsilon(); return { - std::abs(scale_x) < epsilon ? Type{1} : scale_x, - std::abs(scale_y) < epsilon ? Type{1} : scale_y, - std::abs(scale_z) < epsilon ? Type{1} : scale_z, + internal::abs(scale_x) < epsilon ? Type{1} : scale_x, + internal::abs(scale_y) < epsilon ? Type{1} : scale_y, + internal::abs(scale_z) < epsilon ? Type{1} : scale_z, }; } template requires std::is_floating_point_v [[nodiscard("You must use extracted rotation")]] - Vector3 mat_extract_rotation_zyx(const Mat<4, 4, Type, St>& mat) noexcept + constexpr Vector3 mat_extract_rotation_zyx(const Mat<4, 4, Type, St>& mat) noexcept { const auto scale = mat_extract_scale(mat); const auto m00 = mat.at(0, 0) / scale.x; @@ -654,105 +672,91 @@ namespace omath const auto m22 = mat.at(2, 2) / scale.z; return { - angles::radians_to_degrees(std::atan2(m21, m22)), - angles::radians_to_degrees(std::asin(std::clamp(-m20, Type{-1}, Type{1}))), - angles::radians_to_degrees(std::atan2(m10, m00)), + angles::radians_to_degrees(internal::atan2(m21, m22)), + angles::radians_to_degrees(internal::asin(std::clamp(-m20, Type{-1}, Type{1}))), + angles::radians_to_degrees(internal::atan2(m10, m00)), }; } template [[nodiscard("You must use rotation matrix")]] - 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")]] - 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")]] - 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")]] - static 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")]] - 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 = std::tan(angles::degrees_to_radians(field_of_view) / Type{2}); - + 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")]] - 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 = std::tan(angles::degrees_to_radians(field_of_view) / Type{2}); + 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(); } @@ -762,105 +766,93 @@ 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")]] - 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} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); + 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")]] - 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} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2}); + 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}}, + 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")]] - 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")]] - 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 - 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(); @@ -869,7 +861,8 @@ namespace omath } template - 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 1d8e68c..8f30afc 100644 --- a/include/omath/linear_algebra/triangle.hpp +++ b/include/omath/linear_algebra/triangle.hpp @@ -2,8 +2,8 @@ // Created by Orange on 11/13/2024. // #pragma once +#include "omath/internal/constexpr_math.hpp" #include "vector3.hpp" - namespace omath { /* @@ -40,13 +40,13 @@ namespace omath } [[nodiscard]] - Vector::ContainedType side_a_length() const + constexpr Vector::ContainedType side_a_length() const { return m_vertex1.distance_to(m_vertex2); } [[nodiscard]] - Vector::ContainedType side_b_length() const + constexpr Vector::ContainedType side_b_length() const { return m_vertex3.distance_to(m_vertex2); } @@ -69,7 +69,7 @@ namespace omath const auto side_b = side_b_length(); const auto hypot_value = hypot(); - return std::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f; + return internal::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f; } [[nodiscard]] constexpr Vector side_b_vector() const diff --git a/include/omath/linear_algebra/vector2.hpp b/include/omath/linear_algebra/vector2.hpp index e283d51..a4f23de 100644 --- a/include/omath/linear_algebra/vector2.hpp +++ b/include/omath/linear_algebra/vector2.hpp @@ -3,6 +3,7 @@ // #pragma once +#include "omath/internal/constexpr_math.hpp" #include #include #include @@ -116,9 +117,9 @@ namespace omath // Basic vector operations [[nodiscard("You must use distance")]] - Type distance_to(const Vector2& other) const noexcept + constexpr Type distance_to(const Vector2& other) const noexcept { - return std::sqrt(distance_to_sqr(other)); + return internal::sqrt(distance_to_sqr(other)); } [[nodiscard("You must use squared distance")]] @@ -136,7 +137,7 @@ namespace omath #ifndef _MSC_VER [[nodiscard("You must use length")]] constexpr Type length() const noexcept { - return std::hypot(this->x, this->y); + return internal::hypot(this->x, this->y); } [[nodiscard("You must use normalized vector")]] constexpr Vector2 normalized() const noexcept @@ -146,13 +147,13 @@ namespace omath } #else [[nodiscard("You must use length")]] - Type length() const noexcept + constexpr Type length() const noexcept { - return std::hypot(x, y); + return internal::hypot(x, y); } [[nodiscard("You must use normalized vector")]] - Vector2 normalized() const noexcept + constexpr Vector2 normalized() const noexcept { const Type len = length(); return len > static_cast(0) ? *this / len : *this; @@ -216,24 +217,24 @@ namespace omath } [[nodiscard("You must use comparison result")]] - 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")]] - 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")]] - 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")]] - 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 6dac417..b607a4f 100644 --- a/include/omath/linear_algebra/vector3.hpp +++ b/include/omath/linear_algebra/vector3.hpp @@ -4,6 +4,7 @@ #pragma once +#include "omath/internal/constexpr_math.hpp" #include "omath/linear_algebra/vector2.hpp" #include "omath/trigonometry/angle.hpp" #include @@ -140,20 +141,20 @@ namespace omath } #ifndef _MSC_VER - [[nodiscard("You must use length")]] constexpr Type length() const + [[nodiscard("You must use length")]] constexpr Type length() const noexcept { - return std::hypot(this->x, this->y, z); + return internal::hypot(this->x, this->y, z); } - [[nodiscard("You must use 2D length")]] constexpr Type length_2d() const + [[nodiscard("You must use 2D length")]] constexpr Type length_2d() const noexcept { return Vector2::length(); } - [[nodiscard("You must use distance")]] Type distance_to(const Vector3& other) const + [[nodiscard("You must use distance")]] constexpr Type distance_to(const Vector3& other) const noexcept { return (*this - other).length(); } - [[nodiscard("You must use normalized vector")]] constexpr Vector3 normalized() const + [[nodiscard("You must use normalized vector")]] constexpr Vector3 normalized() const noexcept { const Type length_value = this->length(); @@ -161,13 +162,13 @@ namespace omath } #else [[nodiscard("You must use length")]] - Type length() const noexcept + constexpr Type length() const noexcept { - return std::hypot(this->x, this->y, z); + return internal::hypot(this->x, this->y, this->z); } [[nodiscard("You must use normalized vector")]] - Vector3 normalized() const noexcept + constexpr Vector3 normalized() const noexcept { const Type len = this->length(); @@ -175,13 +176,13 @@ namespace omath } [[nodiscard("You must use 2D length")]] - Type length_2d() const noexcept + constexpr Type length_2d() const noexcept { return Vector2::length(); } [[nodiscard("You must use distance")]] - Type distance_to(const Vector3& v_other) const noexcept + constexpr Type distance_to(const Vector3& v_other) const noexcept { return (*this - v_other).length(); } @@ -249,24 +250,23 @@ namespace omath } [[nodiscard("You must use direction check result")]] - 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")]] - std::expected, Vector3Error> + constexpr std::expected, Vector3Error> angle_between(const Vector3& other) const noexcept { const auto bottom = length() * other.length(); if (bottom == static_cast(0)) return std::unexpected(Vector3Error::IMPOSSIBLE_BETWEEN_ANGLE); - - return Angle::from_radians(std::acos(dot(other) / bottom)); + return Angle::from_radians(internal::acos(dot(other) / bottom)); } [[nodiscard("You must use perpendicularity check result")]] - 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; @@ -287,25 +287,25 @@ namespace omath } [[nodiscard("You must use comparison result")]] - 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")]] - 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")]] - 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")]] - bool operator>=(const Vector3& other) const noexcept + constexpr bool operator>=(const Vector3& other) const noexcept { return length() >= other.length(); } @@ -320,6 +320,7 @@ namespace omath template<> struct std::hash> { + // NOTE: Cannot be constexpr because of MSVC [[nodiscard("You must use hash value")]] std::size_t operator()(const omath::Vector3& vec) const noexcept { diff --git a/include/omath/projection/camera.hpp b/include/omath/projection/camera.hpp index 42baf73..3bf1569 100644 --- a/include/omath/projection/camera.hpp +++ b/include/omath/projection/camera.hpp @@ -6,6 +6,7 @@ #include "omath/3d_primitives/aabb.hpp" #include "omath/3d_primitives/obb.hpp" +#include "omath/internal/constexpr_math.hpp" #include "omath/linear_algebra/mat.hpp" #include "omath/linear_algebra/triangle.hpp" #include "omath/linear_algebra/vector3.hpp" @@ -84,8 +85,9 @@ namespace omath::projection }; ~Camera() = default; - Camera(const Vector3& position, const ViewAnglesType& view_angles, const ViewPort& view_port, - const FieldOfView& fov, const NumericType near, const NumericType far) noexcept + constexpr Camera(const Vector3& position, const ViewAnglesType& view_angles, + const ViewPort& view_port, const FieldOfView& fov, const NumericType near, + const NumericType far) noexcept : m_view_port(view_port), m_field_of_view(fov), m_far_plane_distance(far), m_near_plane_distance(near), m_view_angles(view_angles), m_origin(position) { @@ -102,18 +104,18 @@ namespace omath::projection // NEGATIVE_ONE_TO_ONE) share the same m[0,0]/m[1,1] layout, so this works // regardless of the NDC depth range. [[nodiscard("You must use extracted projection params")]] - static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept + constexpr static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept { // m[1,1] == 1 / tan(fov/2) => fov = 2 * atan(1 / m[1,1]) const auto f = proj_matrix.at(1, 1); // m[0,0] == m[1,1] / aspect_ratio => aspect = m[1,1] / m[0,0] - const auto fov_radians = NumericType{2} * std::atan(NumericType{1} / f); + const auto fov_radians = NumericType{2} * internal::atan(NumericType{1} / f); return {FieldOfView::from_radians(static_cast(fov_radians)), f / proj_matrix.at(0, 0)}; } [[nodiscard("You must use calculated view angles")]] - static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept + constexpr static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept { Vector3 forward_vector = {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]}; if constexpr (axes.inverted_forward) @@ -122,7 +124,7 @@ namespace omath::projection } [[nodiscard("You must use calculated origin")]] - static Vector3 calc_origin_from_view_matrix(const Mat4X4Type& view_matrix) noexcept + constexpr static Vector3 calc_origin_from_view_matrix(const Mat4X4Type& view_matrix) noexcept { // The view matrix is R * T(-origin), so the last column stores t = -R * origin. // Recovering origin: origin = -R^T * t @@ -136,40 +138,58 @@ namespace omath::projection }; } - void look_at(const Vector3& target) + constexpr void look_at(const Vector3& target) { m_view_angles = TraitClass::calc_look_at_angle(m_origin, target); m_view_projection_matrix = std::nullopt; m_view_matrix = std::nullopt; } [[nodiscard("You must use calculated look-at angles")]] - ViewAnglesType calc_look_at_angles(const Vector3& look_to) const + constexpr ViewAnglesType calc_look_at_angles(const Vector3& look_to) const { return TraitClass::calc_look_at_angle(m_origin, look_to); } [[nodiscard("You must use forward vector")]] - Vector3 get_forward() const noexcept + constexpr Vector3 get_forward() const noexcept { + if consteval + { + const auto view_matrix = calc_view_matrix(); + return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]}; + } + const auto& view_matrix = get_view_matrix(); return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]}; } [[nodiscard("You must use right vector")]] - Vector3 get_right() const noexcept + constexpr Vector3 get_right() const noexcept { + if consteval + { + const auto view_matrix = calc_view_matrix(); + return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]}; + } + const auto& view_matrix = get_view_matrix(); return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]}; } [[nodiscard("You must use up vector")]] - Vector3 get_up() const noexcept + constexpr Vector3 get_up() const noexcept { + if consteval + { + const auto view_matrix = calc_view_matrix(); + return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]}; + } + const auto& view_matrix = get_view_matrix(); return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]}; } [[nodiscard("You must use absolute forward vector")]] - Vector3 get_abs_forward() const noexcept + constexpr Vector3 get_abs_forward() const noexcept { if constexpr (axes.inverted_forward) return -get_forward(); @@ -177,7 +197,7 @@ namespace omath::projection } [[nodiscard("You must use absolute right vector")]] - Vector3 get_abs_right() const noexcept + constexpr Vector3 get_abs_right() const noexcept { if constexpr (axes.inverted_right) return -get_right(); @@ -185,13 +205,32 @@ namespace omath::projection } [[nodiscard("You must use absolute up vector")]] - Vector3 get_abs_up() const noexcept + constexpr Vector3 get_abs_up() const noexcept { return get_up(); } + [[nodiscard("You must use calculated view-projection matrix")]] + constexpr Mat4X4Type calc_view_projection_matrix() const noexcept + { + return calc_projection_matrix() * calc_view_matrix(); + } + + [[nodiscard("You must use calculated view matrix")]] + constexpr Mat4X4Type calc_view_matrix() const noexcept + { + return TraitClass::calc_view_matrix(m_view_angles, m_origin); + } + + [[nodiscard("You must use calculated projection matrix")]] + constexpr Mat4X4Type calc_projection_matrix() const noexcept + { + return TraitClass::calc_projection_matrix(m_field_of_view, m_view_port, m_near_plane_distance, + m_far_plane_distance, depth_range); + } + [[nodiscard("You must use view-projection matrix")]] - const Mat4X4Type& get_view_projection_matrix() const noexcept + constexpr const Mat4X4Type& get_view_projection_matrix() const noexcept { if (!m_view_projection_matrix.has_value()) m_view_projection_matrix = get_projection_matrix() * get_view_matrix(); @@ -199,90 +238,90 @@ namespace omath::projection return m_view_projection_matrix.value(); } - [[nodiscard("You must use view matrix")]] const Mat4X4Type& get_view_matrix() const noexcept + [[nodiscard("You must use view matrix")]] constexpr const Mat4X4Type& get_view_matrix() const noexcept { if (!m_view_matrix.has_value()) - m_view_matrix = TraitClass::calc_view_matrix(m_view_angles, m_origin); + m_view_matrix = calc_view_matrix(); return m_view_matrix.value(); } - [[nodiscard("You must use projection matrix")]] const Mat4X4Type& get_projection_matrix() const noexcept + [[nodiscard("You must use projection matrix")]] constexpr const Mat4X4Type& + get_projection_matrix() const noexcept { if (!m_projection_matrix.has_value()) - m_projection_matrix = TraitClass::calc_projection_matrix( - m_field_of_view, m_view_port, m_near_plane_distance, m_far_plane_distance, depth_range); + m_projection_matrix = calc_projection_matrix(); return m_projection_matrix.value(); } - void set_field_of_view(const FieldOfView& fov) noexcept + constexpr void set_field_of_view(const FieldOfView& fov) noexcept { m_field_of_view = fov; m_view_projection_matrix = std::nullopt; m_projection_matrix = std::nullopt; } - void set_near_plane(const NumericType near_plane) noexcept + constexpr void set_near_plane(const NumericType near_plane) noexcept { m_near_plane_distance = near_plane; m_view_projection_matrix = std::nullopt; m_projection_matrix = std::nullopt; } - void set_far_plane(const NumericType far_plane) noexcept + constexpr void set_far_plane(const NumericType far_plane) noexcept { m_far_plane_distance = far_plane; m_view_projection_matrix = std::nullopt; m_projection_matrix = std::nullopt; } - void set_view_angles(const ViewAnglesType& view_angles) noexcept + constexpr void set_view_angles(const ViewAnglesType& view_angles) noexcept { m_view_angles = view_angles; m_view_projection_matrix = std::nullopt; m_view_matrix = std::nullopt; } - void set_origin(const Vector3& origin) noexcept + constexpr void set_origin(const Vector3& origin) noexcept { m_origin = origin; m_view_projection_matrix = std::nullopt; m_view_matrix = std::nullopt; } - void set_view_port(const ViewPort& view_port) noexcept + constexpr void set_view_port(const ViewPort& view_port) noexcept { m_view_port = view_port; m_view_projection_matrix = std::nullopt; m_projection_matrix = std::nullopt; } - [[nodiscard("You must use field of view")]] const FieldOfView& get_field_of_view() const noexcept + [[nodiscard("You must use field of view")]] constexpr const FieldOfView& get_field_of_view() const noexcept { return m_field_of_view; } - [[nodiscard("You must use near plane")]] const NumericType& get_near_plane() const noexcept + [[nodiscard("You must use near plane")]] constexpr const NumericType& get_near_plane() const noexcept { return m_near_plane_distance; } - [[nodiscard("You must use far plane")]] const NumericType& get_far_plane() const noexcept + [[nodiscard("You must use far plane")]] constexpr const NumericType& get_far_plane() const noexcept { return m_far_plane_distance; } - [[nodiscard("You must use view angles")]] const ViewAnglesType& get_view_angles() const noexcept + [[nodiscard("You must use view angles")]] constexpr const ViewAnglesType& get_view_angles() const noexcept { return m_view_angles; } - [[nodiscard("You must use origin")]] const Vector3& get_origin() const noexcept + [[nodiscard("You must use origin")]] constexpr const Vector3& get_origin() const noexcept { return m_origin; } template - [[nodiscard("You must use screen position")]] std::expected, Error> + [[nodiscard("You must use screen position")]] constexpr std::expected, Error> world_to_screen(const Vector3& world_position) const noexcept { const auto normalized_cords = world_to_view_port(world_position); @@ -298,7 +337,7 @@ namespace omath::projection std::unreachable(); } template - [[nodiscard("You must use unclipped screen position")]] 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); @@ -314,7 +353,7 @@ namespace omath::projection std::unreachable(); } - [[nodiscard("You must use frustum culling result")]] 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) @@ -382,7 +421,7 @@ namespace omath::projection return false; } - [[nodiscard("You must use AABB frustum culling result")]] 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 @@ -400,7 +439,7 @@ namespace omath::projection return false; } - [[nodiscard("You must use OBB frustum culling result")]] 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 @@ -410,9 +449,9 @@ namespace omath::projection const Vector3 normal{a, b, c}; const auto center_distance = normal.dot(obb.center) + d; - const auto radius = obb.half_extents.x * std::abs(normal.dot(obb.axis_x)) - + obb.half_extents.y * std::abs(normal.dot(obb.axis_y)) - + obb.half_extents.z * std::abs(normal.dot(obb.axis_z)); + const auto radius = obb.half_extents.x * internal::abs(normal.dot(obb.axis_x)) + + obb.half_extents.y * internal::abs(normal.dot(obb.axis_y)) + + obb.half_extents.z * internal::abs(normal.dot(obb.axis_z)); if (center_distance + radius < NumericType{0}) return true; @@ -421,60 +460,85 @@ namespace omath::projection return false; } - [[nodiscard("You must use view port position")]] 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 { + auto project_to_view_port = [&clipping](auto projected) -> std::expected, Error> + { + const auto& w = projected.at(3, 0); + constexpr auto eps = std::numeric_limits::epsilon(); + if (w <= eps) + return std::unexpected(Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO); + + projected /= w; + + // ReSharper disable once CppTooWideScope + const auto clipped_automatically = + clipping == ViewPortClipping::AUTO && is_ndc_out_of_bounds(projected); + if (clipped_automatically) + return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); + + // ReSharper disable once CppTooWideScope + constexpr auto z_min = depth_range == NDCDepthRange::ZERO_TO_ONE ? NumericType{0} : -NumericType{1}; + const auto clipped_manually = + clipping == ViewPortClipping::MANUAL + && (projected.at(2, 0) < z_min - eps || projected.at(2, 0) > NumericType{1} + eps); + if (clipped_manually) + return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); + + return Vector3{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)}; + }; + + if consteval + { + auto projected = + calc_view_projection_matrix() + * mat_column_from_vector(world_position); + return project_to_view_port(projected); + } + auto projected = get_view_projection_matrix() * mat_column_from_vector(world_position); - - const auto& w = projected.at(3, 0); - constexpr auto eps = std::numeric_limits::epsilon(); - if (w <= eps) - return std::unexpected(Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO); - - projected /= w; - - // ReSharper disable once CppTooWideScope - const auto clipped_automatically = clipping == ViewPortClipping::AUTO && is_ndc_out_of_bounds(projected); - if (clipped_automatically) - return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); - - // ReSharper disable once CppTooWideScope - constexpr auto z_min = depth_range == NDCDepthRange::ZERO_TO_ONE ? NumericType{0} : -NumericType{1}; - const auto clipped_manually = - clipping == ViewPortClipping::MANUAL - && (projected.at(2, 0) < z_min - eps || projected.at(2, 0) > NumericType{1} + eps); - if (clipped_manually) - return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); - - return Vector3{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)}; + return project_to_view_port(projected); } [[nodiscard("You must use world position")]] - std::expected, Error> view_port_to_world(const Vector3& ndc) const noexcept + constexpr std::expected, Error> + view_port_to_world(const Vector3& ndc) const noexcept { - const auto inv_view_proj = get_view_projection_matrix().inverted(); + auto view_port_to_world = + [&ndc](const Mat4X4Type& view_projection) -> std::expected, Error> + { + const auto inv_view_proj = view_projection.inverted(); - if (!inv_view_proj) - return std::unexpected(Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO); + if (!inv_view_proj) + return std::unexpected(Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO); - auto inverted_projection = - inv_view_proj.value() * mat_column_from_vector(ndc); + auto inverted_projection = inv_view_proj.value() + * mat_column_from_vector(ndc); - const auto& w = inverted_projection.at(3, 0); + const auto& w = inverted_projection.at(3, 0); - if (std::abs(w) < std::numeric_limits::epsilon()) - return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); + if (internal::abs(w) < std::numeric_limits::epsilon()) + return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS); - inverted_projection /= w; + inverted_projection /= w; - return Vector3{inverted_projection.at(0, 0), inverted_projection.at(1, 0), - inverted_projection.at(2, 0)}; + return Vector3{inverted_projection.at(0, 0), inverted_projection.at(1, 0), + inverted_projection.at(2, 0)}; + }; + + if consteval + { + return view_port_to_world(calc_view_projection_matrix()); + } + + return view_port_to_world(get_view_projection_matrix()); } template [[nodiscard("You must use world position")]] - std::expected, Error> + constexpr std::expected, Error> screen_to_world(const Vector3& screen_pos) const noexcept { return view_port_to_world(screen_to_ndc(screen_pos)); @@ -482,7 +546,7 @@ namespace omath::projection template [[nodiscard("You must use world position")]] - std::expected, Error> + constexpr std::expected, Error> screen_to_world(const Vector2& screen_pos) const noexcept { const auto& [x, y] = screen_pos; @@ -517,7 +581,8 @@ namespace omath::projection // Top = r3 - r1 // Near = r3 + r2 ([-1,1]) or r2 ([0,1]) // Far = r3 - r2 - [[nodiscard("You must use frustum planes")]] std::array extract_frustum_planes() const noexcept + [[nodiscard("You must use frustum planes")]] constexpr std::array + extract_frustum_planes() const noexcept { const auto& m = get_view_projection_matrix(); @@ -589,7 +654,7 @@ namespace omath::projection v */ - [[nodiscard("You must use screen position")]] Vector3 + [[nodiscard("You must use screen position")]] constexpr Vector3 ndc_to_screen_position_from_top_left_corner(const Vector3& ndc) const noexcept { /* @@ -607,7 +672,7 @@ namespace omath::projection (ndc.y / -NumericType{2} + NumericType{0.5}) * m_view_port.m_height, ndc.z}; } - [[nodiscard("You must use screen position")]] Vector3 + [[nodiscard("You must use screen position")]] constexpr Vector3 ndc_to_screen_position_from_bottom_left_corner(const Vector3& ndc) const noexcept { /* @@ -626,7 +691,7 @@ namespace omath::projection } template - [[nodiscard("You must use NDC position")]] Vector3 + [[nodiscard("You must use NDC position")]] constexpr Vector3 screen_to_ndc(const Vector3& screen_pos) const noexcept { if constexpr (screen_start == ScreenStart::TOP_LEFT_CORNER) diff --git a/include/omath/trigonometry/angle.hpp b/include/omath/trigonometry/angle.hpp index 4506e0c..cd33534 100644 --- a/include/omath/trigonometry/angle.hpp +++ b/include/omath/trigonometry/angle.hpp @@ -3,6 +3,7 @@ // #pragma once +#include "omath/internal/constexpr_math.hpp" #include "omath/trigonometry/angles.hpp" #include #include @@ -70,31 +71,31 @@ namespace omath } [[nodiscard]] - Type sin() const noexcept + constexpr Type sin() const noexcept { - return std::sin(as_radians()); + return internal::sin(as_radians()); } [[nodiscard]] - Type cos() const noexcept + constexpr Type cos() const noexcept { - return std::cos(as_radians()); + return internal::cos(as_radians()); } [[nodiscard]] - Type tan() const noexcept + constexpr Type tan() const noexcept { - return std::tan(as_radians()); + return internal::tan(as_radians()); } [[nodiscard]] - Type atan() const noexcept + constexpr Type atan() const noexcept { - return std::atan(as_radians()); + return internal::atan(as_radians()); } [[nodiscard]] - 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 ce07dd8..c88e421 100644 --- a/include/omath/trigonometry/angles.hpp +++ b/include/omath/trigonometry/angles.hpp @@ -3,6 +3,7 @@ // #pragma once +#include "omath/internal/constexpr_math.hpp" #include #include @@ -24,37 +25,38 @@ namespace omath::angles template requires std::is_floating_point_v - [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept + [[nodiscard]] constexpr Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept { const auto fov_rad = degrees_to_radians(horizontal_fov); - const auto vert_fov = static_cast(2) * std::atan(std::tan(fov_rad / static_cast(2)) / aspect); + const auto vert_fov = + static_cast(2) * internal::atan(internal::tan(fov_rad / static_cast(2)) / aspect); return radians_to_degrees(vert_fov); } template requires std::is_floating_point_v - [[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept + [[nodiscard]] constexpr Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept { const auto fov_as_radians = degrees_to_radians(vertical_fov); const auto horizontal_fov = - static_cast(2) * std::atan(std::tan(fov_as_radians / static_cast(2)) * aspect); + static_cast(2) * internal::atan(internal::tan(fov_as_radians / static_cast(2)) * aspect); return radians_to_degrees(horizontal_fov); } template requires std::is_arithmetic_v - [[nodiscard]] 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; const Type range = max - min; - Type wrapped_angle = std::fmod(angle - min, range); + Type wrapped_angle = internal::fmod(angle - min, range); if (wrapped_angle < 0) wrapped_angle += range; diff --git a/include/omath/trigonometry/view_angles.hpp b/include/omath/trigonometry/view_angles.hpp index 2a11f96..87f90ff 100644 --- a/include/omath/trigonometry/view_angles.hpp +++ b/include/omath/trigonometry/view_angles.hpp @@ -18,7 +18,7 @@ namespace omath RollType roll; [[nodiscard]] - Vector3 as_vector3() const + constexpr Vector3 as_vector3() const { return {pitch.as_degrees(), yaw.as_degrees(), roll.as_degrees()}; } diff --git a/modules/omath.cppm b/modules/omath.cppm new file mode 100644 index 0000000..39c55cd --- /dev/null +++ b/modules/omath.cppm @@ -0,0 +1,59 @@ +module; + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(OMATH_USE_AVX2) +#include +#endif + +#if defined(OMATH_IMGUI_INTEGRATION) +#include +#endif + +#if defined(_WIN32) +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include +#elif defined(__APPLE__) +#include +#elif defined(__linux__) || defined(__unix__) +#include +#endif + +export module omath; + +export { +#include "omath/omath.hpp" +} diff --git a/source/engines/cry_engine/formulas.cpp b/source/engines/cry_engine/formulas.cpp deleted file mode 100644 index bc7d6ce..0000000 --- a/source/engines/cry_engine/formulas.cpp +++ /dev/null @@ -1,70 +0,0 @@ -// -// Created by Vlad on 3/22/2025. -// -#include "omath/engines/cry_engine/formulas.hpp" - -namespace omath::cry_engine -{ - Vector3 forward_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 right_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 up_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.yaw) - * mat_rotation_axis_y(angles.roll) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(angles.y), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - std::unreachable(); - } -} // namespace omath::cry_engine diff --git a/source/engines/cry_engine/traits/camera_trait.cpp b/source/engines/cry_engine/traits/camera_trait.cpp deleted file mode 100644 index da260f5..0000000 --- a/source/engines/cry_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/cry_engine/traits/camera_trait.hpp" - -namespace omath::cry_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(std::asin(direction.z)), - YawAngle::from_radians(-std::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return cry_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::cry_engine \ No newline at end of file diff --git a/source/engines/frostbite_engine/formulas.cpp b/source/engines/frostbite_engine/formulas.cpp deleted file mode 100644 index 3c18648..0000000 --- a/source/engines/frostbite_engine/formulas.cpp +++ /dev/null @@ -1,71 +0,0 @@ -// -// Created by Vlad on 3/22/2025. -// -#include "omath/engines/frostbite_engine/formulas.hpp" - -namespace omath::frostbite_engine -{ - Vector3 forward_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 right_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 up_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.roll) - * mat_rotation_axis_y(angles.yaw) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.y), - RollAngle::from_degrees(angles.z), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - std::unreachable(); - } -} // namespace omath::unity_engine diff --git a/source/engines/frostbite_engine/traits/camera_trait.cpp b/source/engines/frostbite_engine/traits/camera_trait.cpp deleted file mode 100644 index 1d4ac21..0000000 --- a/source/engines/frostbite_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/frostbite_engine/traits/camera_trait.hpp" - -namespace omath::frostbite_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(-std::asin(direction.y)), - YawAngle::from_radians(std::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return frostbite_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::unity_engine \ No newline at end of file diff --git a/source/engines/iw_engine/formulas.cpp b/source/engines/iw_engine/formulas.cpp deleted file mode 100644 index 2437065..0000000 --- a/source/engines/iw_engine/formulas.cpp +++ /dev/null @@ -1,79 +0,0 @@ -// -// Created by Vlad on 3/19/2025. -// -#include "omath/engines/iw_engine/formulas.hpp" - -namespace omath::iw_engine -{ - - Vector3 forward_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - - Vector3 right_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 up_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.y), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(angles.x), - }; - } - - Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - // InfinityWard Engine (inherited from Quake) stores FOV as horizontal FOV at a 4:3 - // reference aspect. Convert to true vertical FOV, then delegate to the - // standard vertical-FOV left-handed builder with the caller's actual - // aspect ratio. - // vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) ) - constexpr float k_source_reference_aspect = 4.f / 3.f; - const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect); - - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - vertical_fov, aspect_ratio, near, far); - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( - vertical_fov, aspect_ratio, near, far); - std::unreachable(); - }; -} // namespace omath::iw_engine diff --git a/source/engines/iw_engine/traits/camera_trait.cpp b/source/engines/iw_engine/traits/camera_trait.cpp deleted file mode 100644 index 14fbd7b..0000000 --- a/source/engines/iw_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/iw_engine/traits/camera_trait.hpp" -#include "omath/engines/iw_engine/formulas.hpp" -namespace omath::iw_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(-std::asin(direction.z)), - YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return iw_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::iw_engine \ No newline at end of file diff --git a/source/engines/opengl_engine/formulas.cpp b/source/engines/opengl_engine/formulas.cpp deleted file mode 100644 index 5a1a7e9..0000000 --- a/source/engines/opengl_engine/formulas.cpp +++ /dev/null @@ -1,73 +0,0 @@ -// -// Created by Vlad on 3/19/2025. -// -#include "omath/engines/opengl_engine/formulas.hpp" - -namespace omath::opengl_engine -{ - - Vector3 forward_vector(const ViewAngles& angles) noexcept - { - const auto vec = - rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 right_vector(const ViewAngles& angles) noexcept - { - const auto vec = - rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 up_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return mat_look_at_right_handed(cam_origin, cam_origin + forward_vector(angles), up_vector(angles)); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.roll) - * mat_rotation_axis_y(angles.yaw) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.y), - RollAngle::from_degrees(angles.z), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_right_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_right_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - std::unreachable(); - } -} // namespace omath::opengl_engine diff --git a/source/engines/opengl_engine/traits/camera_trait.cpp b/source/engines/opengl_engine/traits/camera_trait.cpp deleted file mode 100644 index 6addb71..0000000 --- a/source/engines/opengl_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/opengl_engine/traits/camera_trait.hpp" -#include "omath/engines/opengl_engine/formulas.hpp" - -namespace omath::opengl_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(std::asin(direction.y)), - YawAngle::from_radians(-std::atan2(direction.x, -direction.z)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return opengl_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::opengl_engine \ No newline at end of file diff --git a/source/engines/rage_engine/formulas.cpp b/source/engines/rage_engine/formulas.cpp deleted file mode 100644 index 3ef1f38..0000000 --- a/source/engines/rage_engine/formulas.cpp +++ /dev/null @@ -1,71 +0,0 @@ -// -// Created by Orange on 6/3/2026. -// -#include "omath/engines/rage_engine/formulas.hpp" - -namespace omath::rage_engine -{ - Vector3 forward_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 right_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 up_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.yaw) - * mat_rotation_axis_y(angles.roll) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(angles.y), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - std::unreachable(); - } -} // namespace omath::rage_engine diff --git a/source/engines/rage_engine/traits/camera_trait.cpp b/source/engines/rage_engine/traits/camera_trait.cpp deleted file mode 100644 index b9e7b28..0000000 --- a/source/engines/rage_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Created by Orange on 6/3/2026. -// -#include "omath/engines/rage_engine/traits/camera_trait.hpp" - -namespace omath::rage_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(std::asin(direction.z)), - YawAngle::from_radians(-std::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return rage_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, const float far, - const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::rage_engine diff --git a/source/engines/source_engine/formulas.cpp b/source/engines/source_engine/formulas.cpp deleted file mode 100644 index c3c762b..0000000 --- a/source/engines/source_engine/formulas.cpp +++ /dev/null @@ -1,79 +0,0 @@ -// -// Created by Vlad on 3/19/2025. -// -#include - -namespace omath::source_engine -{ - Vector3 forward_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.y), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(angles.x), - }; - } - - Vector3 right_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 up_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - - Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin); - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - // Source (inherited from Quake) stores FOV as horizontal FOV at a 4:3 - // reference aspect. Convert to true vertical FOV, then delegate to the - // standard vertical-FOV left-handed builder with the caller's actual - // aspect ratio. - // vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) ) - constexpr float k_source_reference_aspect = 4.f / 3.f; - const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect); - - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - vertical_fov, aspect_ratio, near, far); - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_vertical_fov< - float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( - vertical_fov, aspect_ratio, near, far); - std::unreachable(); - } -} // namespace omath::source_engine diff --git a/source/engines/source_engine/traits/camera_trait.cpp b/source/engines/source_engine/traits/camera_trait.cpp deleted file mode 100644 index 2663d34..0000000 --- a/source/engines/source_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/source_engine/traits/camera_trait.hpp" -#include "omath/engines/source_engine/formulas.hpp" -namespace omath::source_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - - return {PitchAngle::from_radians(-std::asin(direction.z)), - YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return source_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::source_engine \ No newline at end of file diff --git a/source/engines/unity_engine/formulas.cpp b/source/engines/unity_engine/formulas.cpp deleted file mode 100644 index 370191e..0000000 --- a/source/engines/unity_engine/formulas.cpp +++ /dev/null @@ -1,70 +0,0 @@ -// -// Created by Vlad on 3/22/2025. -// -#include "omath/engines/unity_engine/formulas.hpp" - -namespace omath::unity_engine -{ - Vector3 forward_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 right_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 up_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return mat_camera_view(-forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - return mat_rotation_axis_z(angles.roll) - * mat_rotation_axis_y(angles.yaw) - * mat_rotation_axis_x(angles.pitch); - } - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(angles.x), - YawAngle::from_degrees(angles.y), - RollAngle::from_degrees(angles.z), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return omath::mat_perspective_right_handed_vertical_fov( - field_of_view, aspect_ratio, near, far); - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return omath::mat_perspective_right_handed_vertical_fov(field_of_view, aspect_ratio, - near, far); - std::unreachable(); - } -} // namespace omath::unity_engine diff --git a/source/engines/unity_engine/traits/camera_trait.cpp b/source/engines/unity_engine/traits/camera_trait.cpp deleted file mode 100644 index 1c88cb2..0000000 --- a/source/engines/unity_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/unity_engine/traits/camera_trait.hpp" - -namespace omath::unity_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(-std::asin(direction.y)), - YawAngle::from_radians(std::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return unity_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const float near, - const float far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::unity_engine \ No newline at end of file diff --git a/source/engines/unreal_engine/formulas.cpp b/source/engines/unreal_engine/formulas.cpp deleted file mode 100644 index d972118..0000000 --- a/source/engines/unreal_engine/formulas.cpp +++ /dev/null @@ -1,77 +0,0 @@ -// -// Created by Vlad on 3/22/2025. -// -#include "omath/engines/unreal_engine/formulas.hpp" -namespace omath::unreal_engine -{ - Vector3 forward_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 right_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Vector3 up_vector(const ViewAngles& angles) noexcept - { - const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up); - - return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)}; - } - Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return mat_camera_view(forward_vector(angles), right_vector(angles), - up_vector(angles), cam_origin); - } - Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept - { - // UE FRotator is intrinsic Z-Y-X (Yaw → Pitch → Roll applied in local - // frame), which for column-vector composition is Rz·Ry·Rx. - // Pitch and roll axes in omath spin opposite to UE's convention, so - // both carry a sign flip. - return mat_rotation_axis_z(angles.yaw) - * mat_rotation_axis_y(-angles.pitch) - * mat_rotation_axis_x(-angles.roll); - } - - - Vector3 extract_origin(const Mat4X4& mat) noexcept - { - return mat_extract_origin(mat); - } - - Vector3 extract_scale(const Mat4X4& mat) noexcept - { - return mat_extract_scale(mat); - } - - ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept - { - const auto angles = mat_extract_rotation_zyx(mat); - return { - PitchAngle::from_degrees(-angles.y), - YawAngle::from_degrees(angles.z), - RollAngle::from_degrees(-angles.x), - }; - } - - Mat4X4 calc_perspective_projection_matrix(const double field_of_view, const double aspect_ratio, const double near, - const double far, const NDCDepthRange ndc_depth_range) noexcept - { - // UE stores horizontal FOV in FMinimalViewInfo — use the left-handed - // horizontal-FOV builder directly. - if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE) - return mat_perspective_left_handed_horizontal_fov< - double, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>( - field_of_view, aspect_ratio, near, far); - if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE) - return mat_perspective_left_handed_horizontal_fov< - double, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>( - field_of_view, aspect_ratio, near, far); - std::unreachable(); - } -} // namespace omath::unreal_engine diff --git a/source/engines/unreal_engine/traits/camera_trait.cpp b/source/engines/unreal_engine/traits/camera_trait.cpp deleted file mode 100644 index f652d3e..0000000 --- a/source/engines/unreal_engine/traits/camera_trait.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// -// Created by Vlad on 8/11/2025. -// -#include "omath/engines/unreal_engine/traits/camera_trait.hpp" - -namespace omath::unreal_engine -{ - - ViewAngles CameraTrait::calc_look_at_angle(const Vector3& cam_origin, const Vector3& look_at) noexcept - { - const auto direction = (look_at - cam_origin).normalized(); - - return {PitchAngle::from_radians(std::asin(direction.z)), - YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)}; - } - Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3& cam_origin) noexcept - { - return unreal_engine::calc_view_matrix(angles, cam_origin); - } - Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov, - const projection::ViewPort& view_port, const double near, - const double far, const NDCDepthRange ndc_depth_range) noexcept - { - return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far, - ndc_depth_range); - } -} // namespace omath::unreal_engine \ No newline at end of file diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 824b6e9..d3d00b9 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -7,6 +7,11 @@ include(GoogleTest) file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/general/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/engines/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp") add_executable(${PROJECT_NAME} ${UNIT_TESTS_SOURCES} main.cpp) +if(OMATH_ENABLE_MODULES) + set_target_properties(${PROJECT_NAME} PROPERTIES CXX_SCAN_FOR_MODULES ON) + target_sources(${PROJECT_NAME} PRIVATE modules/unit_test_module.cpp) +endif() + set_target_properties( ${PROJECT_NAME} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}" diff --git a/tests/engines/unit_test_cry_engine.cpp b/tests/engines/unit_test_cry_engine.cpp index 1888c27..0e41578 100644 --- a/tests/engines/unit_test_cry_engine.cpp +++ b/tests/engines/unit_test_cry_engine.cpp @@ -9,6 +9,96 @@ #include using namespace omath; + +namespace +{ + constexpr bool close_to(const float actual, const float expected, const float epsilon) + { + const float diff = actual - expected; + return (diff < 0.0f ? -diff : diff) <= epsilon; + } + + constexpr bool vec_close_to(const Vector3& actual, const Vector3& expected, const float epsilon) + { + return close_to(actual.x, expected.x, epsilon) && close_to(actual.y, expected.y, epsilon) + && close_to(actual.z, expected.z, epsilon); + } +} // namespace + +static_assert( + [] + { + constexpr omath::cry_engine::ViewAngles angles{}; + constexpr auto forward = omath::cry_engine::forward_vector(angles); + constexpr auto right = omath::cry_engine::right_vector(angles); + constexpr auto up = omath::cry_engine::up_vector(angles); + constexpr auto rotation = omath::cry_engine::rotation_matrix(angles); + + return vec_close_to(forward, omath::cry_engine::k_abs_forward, 1e-5f) + && vec_close_to(right, omath::cry_engine::k_abs_right, 1e-5f) + && vec_close_to(up, omath::cry_engine::k_abs_up, 1e-5f) && close_to(rotation.at(0, 0), 1.0f, 1e-5f) + && close_to(rotation.at(1, 1), 1.0f, 1e-5f) && close_to(rotation.at(2, 2), 1.0f, 1e-5f) + && close_to(rotation.at(3, 3), 1.0f, 1e-5f); + }(), + "CryEngine basis vectors should be constexpr with embedded constexpr math"); + +static_assert( + [] + { + constexpr auto view = omath::cry_engine::calc_view_matrix({}, {}); + return close_to(view.at(0, 0), 1.0f, 1e-5f) && close_to(view.at(1, 2), 1.0f, 1e-5f) + && close_to(view.at(2, 1), 1.0f, 1e-5f) && close_to(view.at(3, 3), 1.0f, 1e-5f); + }(), + "CryEngine view matrix should be constexpr with embedded constexpr math"); + +static_assert( + [] + { + constexpr auto transform = mat_translation({1.0f, 2.0f, 3.0f}) + * mat_scale({2.0f, 3.0f, 4.0f}); + constexpr auto origin = omath::cry_engine::extract_origin(transform); + constexpr auto scale = omath::cry_engine::extract_scale(transform); + + return vec_close_to(origin, {1.0f, 2.0f, 3.0f}, 1e-5f) && vec_close_to(scale, {2.0f, 3.0f, 4.0f}, 1e-5f); + }(), + "CryEngine transform extraction should be constexpr with embedded constexpr math"); + +static_assert( + [] + { + constexpr auto projection = omath::cry_engine::calc_perspective_projection_matrix( + 90.0f, 1.0f, 1.0f, 11.0f, NDCDepthRange::ZERO_TO_ONE); + return close_to(projection.at(0, 0), 1.0f, 1e-5f) && close_to(projection.at(1, 1), 1.0f, 1e-5f) + && close_to(projection.at(2, 2), 1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) + && close_to(projection.at(3, 2), 1.0f, 1e-5f); + }(), + "CryEngine projection matrix should be constexpr with embedded constexpr math"); + +static_assert( + [] + { + constexpr auto angles = + omath::cry_engine::CameraTrait::calc_look_at_angle({}, omath::cry_engine::k_abs_forward); + constexpr auto view = omath::cry_engine::CameraTrait::calc_view_matrix(angles, {}); + constexpr auto projection = omath::cry_engine::CameraTrait::calc_projection_matrix( + projection::FieldOfView::from_degrees(90.0f), {1.0f, 1.0f}, 1.0f, 11.0f, + NDCDepthRange::ZERO_TO_ONE); + + return close_to(angles.pitch.as_degrees(), 0.0f, 1e-5f) && close_to(angles.yaw.as_degrees(), 0.0f, 1e-5f) + && close_to(angles.roll.as_degrees(), 0.0f, 1e-5f) && close_to(view.at(0, 0), 1.0f, 1e-5f) + && close_to(view.at(2, 1), 1.0f, 1e-5f) && close_to(projection.at(0, 0), 1.0f, 1e-5f) + && close_to(projection.at(1, 1), 1.0f, 1e-5f) && close_to(projection.at(2, 2), 1.1f, 1e-5f) + && close_to(projection.at(2, 3), -1.1f, 1e-5f) && close_to(projection.at(3, 2), 1.0f, 1e-5f); + }(), + "CryEngine CameraTrait should be constexpr with 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); +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); + TEST(unit_test_cry_engine, look_at_forward) { const auto angles = cry_engine::CameraTrait::calc_look_at_angle({}, cry_engine::k_abs_forward); @@ -251,11 +341,9 @@ TEST(unit_test_cry_engine, ViewAnglesAsVector3Zero) TEST(unit_test_cry_engine, ViewAnglesAsVector3Values) { - const omath::cry_engine::ViewAngles angles{ - omath::cry_engine::PitchAngle::from_degrees(45.f), - omath::cry_engine::YawAngle::from_degrees(-90.f), - omath::cry_engine::RollAngle::from_degrees(30.f) - }; + const omath::cry_engine::ViewAngles angles{omath::cry_engine::PitchAngle::from_degrees(45.f), + omath::cry_engine::YawAngle::from_degrees(-90.f), + omath::cry_engine::RollAngle::from_degrees(30.f)}; const auto vec = angles.as_vector3(); EXPECT_FLOAT_EQ(vec.x, 45.f); @@ -266,11 +354,9 @@ TEST(unit_test_cry_engine, ViewAnglesAsVector3Values) TEST(unit_test_cry_engine, ViewAnglesAsVector3ClampedPitch) { // Pitch is clamped to [-90, 90] - const omath::cry_engine::ViewAngles angles{ - omath::cry_engine::PitchAngle::from_degrees(120.f), - omath::cry_engine::YawAngle::from_degrees(0.f), - omath::cry_engine::RollAngle::from_degrees(0.f) - }; + const omath::cry_engine::ViewAngles angles{omath::cry_engine::PitchAngle::from_degrees(120.f), + omath::cry_engine::YawAngle::from_degrees(0.f), + omath::cry_engine::RollAngle::from_degrees(0.f)}; const auto vec = angles.as_vector3(); EXPECT_FLOAT_EQ(vec.x, 90.f); @@ -279,12 +365,10 @@ TEST(unit_test_cry_engine, ViewAnglesAsVector3ClampedPitch) TEST(unit_test_cry_engine, ViewAnglesAsVector3NormalizedYaw) { // Yaw is normalized to [-180, 180], 270 wraps to -90 - const omath::cry_engine::ViewAngles angles{ - omath::cry_engine::PitchAngle::from_degrees(0.f), - omath::cry_engine::YawAngle::from_degrees(270.f), - omath::cry_engine::RollAngle::from_degrees(0.f) - }; + const omath::cry_engine::ViewAngles angles{omath::cry_engine::PitchAngle::from_degrees(0.f), + omath::cry_engine::YawAngle::from_degrees(270.f), + omath::cry_engine::RollAngle::from_degrees(0.f)}; const auto vec = angles.as_vector3(); EXPECT_NEAR(vec.y, -90.f, 0.01f); -} \ No newline at end of file +} diff --git a/tests/engines/unit_test_traits_engines.cpp b/tests/engines/unit_test_traits_engines.cpp index d01efc0..8ce1837 100644 --- a/tests/engines/unit_test_traits_engines.cpp +++ b/tests/engines/unit_test_traits_engines.cpp @@ -1,30 +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 @@ -41,6 +43,41 @@ static void expect_matrix_near(const MatT& a, const MatT& b, float eps = 1e-5f) } // ── Launch offset tests for all engines ────────────────────────────────────── +template +constexpr bool matrix_has_non_zero_element(const MatType& mat) +{ + for (std::size_t r = 0; r < 4; ++r) + for (std::size_t c = 0; c < 4; ++c) + if (mat.at(r, c) != NumericType{0}) + return true; + + return false; +} + +template +constexpr bool camera_can_calculate_matrices_at_compile_time() +{ + using FieldOfView = projection::FieldOfView; + + CameraType camera{{}, {}, {1280.f, 720.f}, FieldOfView::from_degrees(90.f), NumericType{0.01}, NumericType{1000}}; + const auto view = camera.get_view_matrix(); + const auto projection = camera.get_projection_matrix(); + const auto view_projection = camera.get_view_projection_matrix(); + + return matrix_has_non_zero_element(view) + && matrix_has_non_zero_element(projection) + && matrix_has_non_zero_element(view_projection); +} + +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); +static_assert(camera_can_calculate_matrices_at_compile_time()); + #include // Helper: verify that zero offset matches default-initialized offset behavior @@ -74,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 @@ -158,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); @@ -221,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); } @@ -272,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); @@ -327,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); @@ -382,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); @@ -437,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); @@ -458,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); @@ -479,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); @@ -537,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); }; @@ -565,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); }; @@ -603,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); @@ -612,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); @@ -621,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); @@ -630,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); @@ -639,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); @@ -648,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); }; @@ -662,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 d1fc410..89cc88c 100644 --- a/tests/general/unit_test_angle.cpp +++ b/tests/general/unit_test_angle.cpp @@ -2,10 +2,10 @@ // Created by Orange on 11/30/2024. // -#include #include #include #include +#include using namespace omath; @@ -19,6 +19,12 @@ namespace constexpr float k_eps = 1e-5f; + constexpr bool close_to(const float actual, const float expected, const float epsilon) + { + const float diff = actual - expected; + return (diff < 0.0f ? -diff : diff) <= epsilon; + } + } // namespace // ---------- Construction / factories ---------- @@ -190,3 +196,14 @@ TEST(UnitTestAngle, BinaryMinus_ReturnsWrappedDiff) const Deg c = a - b; // expect 340° EXPECT_FLOAT_EQ(c.as_degrees(), 340.0f); } + +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 0cc51c3..e2e3654 100644 --- a/tests/general/unit_test_mat.cpp +++ b/tests/general/unit_test_mat.cpp @@ -1,11 +1,23 @@ // UnitTestMat.cpp #include "omath/linear_algebra/mat.hpp" #include "omath/linear_algebra/vector3.hpp" +#include "omath/trigonometry/angle.hpp" #include "omath/trigonometry/angles.hpp" #include using namespace omath; +namespace +{ + using Pitch = Angle(-90), static_cast(90), AngleFlags::Clamped>; + + constexpr bool close_to(const float actual, const float expected, const float epsilon) + { + const float diff = actual - expected; + return (diff < 0.0f ? -diff : diff) <= epsilon; + } +} // namespace + class UnitTestMat : public ::testing::Test { protected: @@ -163,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) { @@ -211,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()); } @@ -234,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); @@ -245,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}); @@ -267,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}); @@ -292,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); @@ -310,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}); @@ -326,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}); @@ -354,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); @@ -371,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); @@ -390,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); @@ -408,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); @@ -426,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) @@ -438,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) @@ -460,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) @@ -472,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); @@ -518,8 +538,51 @@ 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); -} \ No newline at end of file +} + +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 embedded constexpr math"); + +static_assert( + [] + { + constexpr auto rotation = mat_rotation_axis_z(Pitch::from_degrees(90.0f)); + return close_to(rotation.at(0, 0), 0.0f, 1e-5f) && close_to(rotation.at(0, 1), -1.0f, 1e-5f) + && close_to(rotation.at(1, 0), 1.0f, 1e-5f) && close_to(rotation.at(1, 1), 0.0f, 1e-5f) + && close_to(rotation.at(2, 2), 1.0f, 1e-5f) && close_to(rotation.at(3, 3), 1.0f, 1e-5f); + }(), + "Mat rotation should be constexpr with embedded constexpr math"); + +static_assert( + [] + { + constexpr auto projection = + mat_perspective_left_handed_vertical_fov(90.0f, 1.0f, 1.0f, 11.0f); + return close_to(projection.at(0, 0), 1.0f, 1e-5f) && close_to(projection.at(1, 1), 1.0f, 1e-5f) + && close_to(projection.at(2, 2), 1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) + && close_to(projection.at(3, 2), 1.0f, 1e-5f); + }(), + "Mat vertical-FOV perspective should be constexpr with embedded constexpr math"); + +static_assert( + [] + { + constexpr auto projection = + mat_perspective_right_handed_horizontal_fov(90.0f, 2.0f, 1.0f, 11.0f); + return close_to(projection.at(0, 0), 1.0f, 1e-5f) && close_to(projection.at(1, 1), 2.0f, 1e-5f) + && close_to(projection.at(2, 2), -1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f) + && close_to(projection.at(3, 2), -1.0f, 1e-5f); + }(), + "Mat horizontal-FOV perspective should be constexpr with embedded constexpr math"); diff --git a/tests/general/unit_test_projection.cpp b/tests/general/unit_test_projection.cpp index 8f3b79c..ebcb04a 100644 --- a/tests/general/unit_test_projection.cpp +++ b/tests/general/unit_test_projection.cpp @@ -60,15 +60,34 @@ static void verify_random_look_at_targets_project_to_screen_center(const omath:: } } +constexpr bool source_camera_constexpr_projection_round_trip() +{ + constexpr auto fov = omath::Angle::from_degrees(90.f); + constexpr auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, + fov, 0.01f, 1000.f); + + constexpr auto projected = cam.world_to_screen({1000.f, 0, 50.f}); + constexpr auto result = cam.screen_to_world(projected.value()); + constexpr auto result2 = cam.world_to_screen(result.value()); + + return projected.has_value() && result.has_value() && result2.has_value() + && static_cast>(projected.value()) + == static_cast>(result2.value()) + && omath::internal::abs(projected->x - 960.f) < 0.001f && omath::internal::abs(projected->y - 504.f) < 0.001f + && omath::internal::abs(projected->z - 1.f) < 0.001f; +} + +static_assert(source_camera_constexpr_projection_round_trip()); + TEST(UnitTestProjection, Projection) { constexpr auto fov = omath::Angle::from_degrees(90.f); - const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov, - 0.01f, 1000.f); + constexpr auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, + fov, 0.01f, 1000.f); - const auto projected = cam.world_to_screen({1000.f, 0, 50.f}); - const auto result = cam.screen_to_world(projected.value()); - const auto result2 = cam.world_to_screen(result.value()); + constexpr auto projected = cam.world_to_screen({1000.f, 0, 50.f}); + constexpr auto result = cam.screen_to_world(projected.value()); + constexpr auto result2 = cam.world_to_screen(result.value()); EXPECT_EQ(static_cast>(projected.value()), static_cast>(result2.value())); @@ -565,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()); @@ -582,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()); @@ -599,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()); @@ -618,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()); @@ -635,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()); @@ -664,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()); @@ -683,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()); @@ -704,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); @@ -736,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()); @@ -753,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()); @@ -770,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()); @@ -800,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()); @@ -818,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()); @@ -838,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) @@ -860,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) @@ -882,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) @@ -904,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) @@ -926,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) @@ -948,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) @@ -970,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 ---- @@ -1120,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(); @@ -1142,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) @@ -1215,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)); } @@ -1229,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)); } @@ -1243,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)); } @@ -1257,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)); } @@ -1271,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 f972a8a..7f26976 100644 --- a/tests/general/unit_test_triangle.cpp +++ b/tests/general/unit_test_triangle.cpp @@ -8,6 +8,15 @@ using namespace omath; +namespace +{ + constexpr bool close_to(const float actual, const float expected, const float epsilon) + { + const float diff = actual - expected; + return (diff < 0.0f ? -diff : diff) <= epsilon; + } +} // namespace + class UnitTestTriangle : public ::testing::Test { protected: @@ -19,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); @@ -72,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); @@ -83,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)); @@ -112,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) @@ -129,3 +125,18 @@ TEST_F(UnitTestTriangle, MidPoint) EXPECT_FLOAT_EQ(mid2.y, (2.0f + 5.0f + 8.0f) / 3.0f); EXPECT_FLOAT_EQ(mid2.z, (3.0f + 6.0f + 9.0f) / 3.0f); } + +static_assert( + [] + { + constexpr Triangle> triangle{{3.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 4.0f, 0.0f}}; + constexpr auto normal = triangle.calculate_normal(); + constexpr auto mid_point = triangle.mid_point(); + + return close_to(triangle.side_a_length(), 3.0f, 1e-5f) && close_to(triangle.side_b_length(), 4.0f, 1e-5f) + && close_to(triangle.hypot(), 5.0f, 1e-5f) && triangle.is_rectangular() + && close_to(normal.length(), 1.0f, 1e-5f) && close_to(normal.z, -1.0f, 1e-5f) + && close_to(mid_point.x, 1.0f, 1e-5f) && close_to(mid_point.y, 4.0f / 3.0f, 1e-5f) + && close_to(mid_point.z, 0.0f, 1e-5f); + }(), + "Triangle helpers should be constexpr with embedded constexpr math"); diff --git a/tests/general/unit_test_vector2.cpp b/tests/general/unit_test_vector2.cpp index 91d9e61..84fee1d 100644 --- a/tests/general/unit_test_vector2.cpp +++ b/tests/general/unit_test_vector2.cpp @@ -2,10 +2,10 @@ // Created by Vlad on 02.09.2024. // -#include #include // For FLT_MAX and FLT_MIN #include // For std::isinf and std::isnan #include +#include using namespace omath; @@ -399,7 +399,6 @@ TEST_F(UnitTestVector2, GreaterEqualOperator) EXPECT_TRUE(omath::Vector2(1.f, 1.f) >= omath::Vector2{}); } - // ── Cast operator tests ────────────────────────────────────────────────────── TEST(Vector2Cast, FloatToDouble) @@ -463,3 +462,8 @@ static_assert(Vector2(1.0f, 2.0f).length_sqr() == 5.0f, "LengthSqr should be 5") static_assert(Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot product should be 14"); static_assert(Vector2(4.0f, 5.0f).distance_to_sqr(Vector2(1.0f, 2.0f)) == 18.0f, "DistToSqr should be 18"); static_assert(Vector2(-1.0f, -2.0f).abs() == Vector2(1.0f, 2.0f), "Abs should convert negative values to positive"); + +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 158f1c0..3717ba9 100644 --- a/tests/general/unit_test_vector3.cpp +++ b/tests/general/unit_test_vector3.cpp @@ -2,11 +2,11 @@ // Created by Vlad on 01.09.2024. // -#include #include // For FLT_MAX, FLT_MIN #include #include #include // For std::numeric_limits +#include using namespace omath; @@ -31,35 +31,33 @@ TEST(Vector3More, ArithmeticAndDotCross) constexpr Vector3 a{1.f, 0.f, 0.f}; constexpr Vector3 b{0.f, 1.f, 0.f}; const auto c = a + b; - constexpr Vector3 expect_c{1.f,1.f,0.f}; + constexpr Vector3 expect_c{1.f, 1.f, 0.f}; EXPECT_EQ(c, expect_c); const auto d = a - b; - constexpr Vector3 expect_d{1.f,-1.f,0.f}; + constexpr Vector3 expect_d{1.f, -1.f, 0.f}; EXPECT_EQ(d, expect_d); const auto e = a * 2.f; - constexpr Vector3 expect_e{2.f,0.f,0.f}; + constexpr Vector3 expect_e{2.f, 0.f, 0.f}; EXPECT_EQ(e, expect_e); EXPECT_FLOAT_EQ(a.dot(b), 0.f); // manual cross product check - const auto cr = Vector3{ a.y * b.z - a.z * b.y, - a.z * b.x - a.x * b.z, - a.x * b.y - a.y * b.x }; - constexpr Vector3 expect_cr{0.f,0.f,1.f}; + const auto cr = Vector3{a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; + constexpr Vector3 expect_cr{0.f, 0.f, 1.f}; EXPECT_EQ(cr, expect_cr); } TEST(Vector3More, NormalizationEdgeCases) { - constexpr Vector3 z{0.0,0.0,0.0}; + constexpr Vector3 z{0.0, 0.0, 0.0}; const auto zn = z.normalized(); EXPECT_DOUBLE_EQ(zn.x, 0.0); EXPECT_DOUBLE_EQ(zn.y, 0.0); EXPECT_DOUBLE_EQ(zn.z, 0.0); - constexpr Vector3 v{3.0,4.0,0.0}; + constexpr Vector3 v{3.0, 4.0, 0.0}; const auto vn = v.normalized(); EXPECT_NEAR(vn.x, 0.6, 1e-12); EXPECT_NEAR(vn.y, 0.8, 1e-12); @@ -481,16 +479,14 @@ TEST_F(UnitTestVector3, AsTuple) // Test AsTuple method TEST_F(UnitTestVector3, AngleBeatween) { - EXPECT_NEAR(Vector3(0.0f, 0.0f, 1.0f).angle_between({1, 0, 0}).value().as_degrees(), - 90.0f, 0.001f); - EXPECT_NEAR(Vector3(0.0f, 0.0f, 1.0f).angle_between({0.0f, 0.0f, 1.0f}).value().as_degrees(), - 0.0f, 0.001f); + EXPECT_NEAR(Vector3(0.0f, 0.0f, 1.0f).angle_between({1, 0, 0}).value().as_degrees(), 90.0f, 0.001f); + EXPECT_NEAR(Vector3(0.0f, 0.0f, 1.0f).angle_between({0.0f, 0.0f, 1.0f}).value().as_degrees(), 0.0f, 0.001f); EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).angle_between({0.0f, 0.0f, 1.0f}).has_value()); } TEST_F(UnitTestVector3, IsPerpendicular) { - EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({1, 0 ,0}), true); + EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({1, 0, 0}), true); EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({0.0f, 0.0f, 1.0f}), false); EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).is_perpendicular({0.0f, 0.0f, 1.0f})); } @@ -585,4 +581,18 @@ TEST(Vector3Cast, SameTypeRoundtrip) static_assert(Vector3(1.0f, 2.0f, 3.0f).length_sqr() == 14.0f, "LengthSqr should be 14"); static_assert(Vector3(1.0f, 2.0f, 3.0f).dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32"); static_assert(Vector3(4.0f, 5.0f, 6.0f).distance_to_sqr(Vector3(1.0f, 2.0f, 3.0f)) == 27.0f, "DistToSqr should be 27"); -static_assert(Vector3(-1.0f, -2.0f, -3.0f).abs() == Vector3(1.0f, 2.0f, 3.0f), "Abs should convert negative values to positive"); +static_assert(Vector3(-1.0f, -2.0f, -3.0f).abs() == Vector3(1.0f, 2.0f, 3.0f), + "Abs should convert negative values to positive"); + +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 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 embedded constexpr math"); diff --git a/tests/modules/unit_test_module.cpp b/tests/modules/unit_test_module.cpp new file mode 100644 index 0000000..e174663 --- /dev/null +++ b/tests/modules/unit_test_module.cpp @@ -0,0 +1,11 @@ +#include + +import omath; + +TEST(UnitTestModule, ImportOmath) +{ + const omath::Vector2 vec{1.f, 2.f}; + + EXPECT_FLOAT_EQ(vec.x, 1.f); + EXPECT_FLOAT_EQ(vec.y, 2.f); +}