Add Matrix4 and Quaternion to Core; rebuild Transform on native math

Engine/cpp/Runtime/Core/CMakeLists.txt

@@ -1,12 +1,13 @@
-add_modules_library(Definitions)
-add_modules_library(Math)
-add_modules_library(IO)
-add_modules_library(Memory)
-add_modules_library(Logging)
-add_modules_library(Containers)
+# PIC: these are linked into the shared Runtime library (via Core), so their objects
+# must be position-independent - a non-PIC static (e.g. Quaternion::identity) otherwise
+# fails to relocate when making the shared object.
+add_modules_library(Definitions PIC)
+add_modules_library(Math PIC)
+add_modules_library(IO PIC)
+add_modules_library(Memory PIC)
+add_modules_library(Logging PIC)
 
-target_link_libraries(Math PUBLIC Definitions bx)
+target_link_libraries(Math PUBLIC Definitions)
 target_link_libraries(IO PUBLIC Definitions stb_image)
 target_link_libraries(Memory PUBLIC Definitions Math)
 target_link_libraries(Logging PUBLIC Definitions)
-target_link_libraries(Containers PUBLIC Definitions Memory Math)

Engine/cpp/Runtime/Core/Math/Functions.cppm

@@ -1,5 +1,6 @@
 module;
 
+#include <numbers>
 #include <cmath>
 #include <concepts>
 #include <limits>
@@ -114,6 +115,21 @@ export namespace draco::math {
         return static_cast<T>(std::pow(x, y));
     }
 
+    // Trigonometry (radians) and square root.
+    [[nodiscard]] inline f32 sin(f32 x) noexcept { return std::sin(x); }
+    [[nodiscard]] inline f32 cos(f32 x) noexcept { return std::cos(x); }
+    [[nodiscard]] inline f32 tan(f32 x) noexcept { return std::tan(x); }
+    [[nodiscard]] inline f32 acos(f32 x) noexcept { return std::acos(x); }
+    [[nodiscard]] inline f32 sqrt(f32 x) noexcept { return std::sqrt(x); }
+
+    // Approximate comparisons against an epsilon (defaults to CMP_EPSILON).
+    [[nodiscard]] constexpr bool nearlyEqual(f32 a, f32 b, f32 epsilon = CMP_EPSILON) noexcept {
+        return abs(a - b) <= epsilon;
+    }
+    [[nodiscard]] constexpr bool nearlyZero(f32 v, f32 epsilon = CMP_EPSILON) noexcept {
+        return abs(v) <= epsilon;
+    }
+
     template <std::floating_point T>
     constexpr T lerp(T from, T to, T weight) noexcept {
         return std::lerp(from, to, weight);
@@ -202,4 +218,4 @@ export namespace draco::math {
         T d = (control_1 - start) * T{3.} * omt2 + (control_2 - control_1) * T{6.} * omt * t + (end - control_2) * T{3.} * t2;
         return d;
     }
-}
+}

Engine/cpp/Runtime/Core/Math/Math.cppm

@@ -4,4 +4,6 @@ export import core.defs;
 export import core.math.constants;
 export import core.math.functions;
 export import core.math.types;
+export import core.math.matrix4;
+export import core.math.quaternion;
 export import core.math.transform;