Tracking allocator

engine/native/core/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_modules_library(definitions PIC)
 add_modules_library(math)
 add_modules_library(memory)
-target_link_libraries(math PUBLIC definitions)
+target_link_libraries(math PUBLIC definitions)
+target_link_libraries(memory PUBLIC definitions)

engine/native/core/definitions/definitions.cppm

@@ -4,11 +4,11 @@ module;
 
 export module core.defs;
 export import core.version;
+export import core.stdtypes;
 
 static_assert(__cplusplus >=  202207L, "Minimum of C++23 required. Consider upgrading your compiler.");
 
 export namespace draco {
-
     template<typename T>
     concept arithmetic = std::is_arithmetic_v<T>;
 
@@ -26,4 +26,4 @@ export namespace draco {
 
     template <typename T>
     concept zero_constructible = is_zero_constructible_v<T>;
-}
+}

engine/native/core/definitions/stdtypes.cppm

@@ -0,0 +1,33 @@
+module;
+
+#include <cstddef>
+#include <cstdint>
+
+export module core.stdtypes;
+
+export namespace draco {
+using i8 = int8_t;
+using i16 = int16_t;
+using i32 = int32_t;
+using i64 = int64_t;
+
+using uint = unsigned int;
+using u8 = uint8_t;
+using u16 = uint16_t;
+using u32 = uint32_t;
+using u64 = uint64_t;
+
+using f32 = float;
+using f64 = double;
+
+using isize = int64_t;
+using usize = std::size_t;
+
+using rawptr = void *;
+using uintptr = uintptr_t;
+using ptrdiff = ptrdiff_t;
+
+// UTF-32 type
+using rune = u32;
+
+} // namespace draco

engine/native/core/definitions/version.cppm

@@ -1,29 +1,29 @@
 module;
 
-#include <cstdint>
 #include <format>
 
 export module core.version;
+import core.stdtypes;
 
 export namespace draco {
 
-    struct Version {
-        std::uint16_t major;
-        std::uint16_t minor;
-        std::uint16_t patch;
-    };
+struct Version {
+  u16 major;
+  u16 minor;
+  u16 patch;
+};
 
-    constexpr Version VERSION { .major = 2026, .minor = 0, .patch = 0 };
-}
+constexpr Version VERSION{.major = 2026, .minor = 0, .patch = 0};
+} // namespace draco
 
 export namespace std {
-    template<> struct formatter<draco::Version> {
-        constexpr auto parse(std::format_parse_context& ctx) {
-            return ctx.begin(); // Accept any format spec (or parse custom ones)
-        }
+template <> struct formatter<draco::Version> {
+  constexpr auto parse(std::format_parse_context &ctx) {
+    return ctx.begin(); // Accept any format spec (or parse custom ones)
+  }
 
-        auto format(const draco::Version& v, std::format_context& ctx) const {
-            return std::format_to(ctx.out(), "{}.{}.{}", v.major, v.minor, v.patch);
-        }
-    };
-}
+  auto format(const draco::Version &v, std::format_context &ctx) const {
+    return std::format_to(ctx.out(), "{}.{}.{}", v.major, v.minor, v.patch);
+  }
+};
+} // namespace std

engine/native/core/math/constants.cppm

@@ -5,6 +5,7 @@ module;
 
 export module core.math.constants;
 import core.defs;
+import core.stdtypes;
 
 export namespace draco::math {
     // Limit the depth of recursive algorithms
@@ -24,13 +25,13 @@ export namespace draco::math {
     constexpr float NaN = std::numeric_limits<float>::quiet_NaN();
     constexpr float DB_CONVERSION_GAIN = 8.6858896380650365530225783783321;
     constexpr float GAIN_CONVERSION_DB = 0.11512925464970228420089957273422;
-    constexpr float UINT32_MAX_F = 1.f / std::numeric_limits<uint32_t>::max();
+    constexpr float UINT32_MAX_F = 1.f / std::numeric_limits<u32>::max();
     constexpr float DECIMAL_LIMIT_F = 8388608.0f;
 
-    constexpr float CMP_EPSILON = 0.000001f;
-    constexpr float CMP_EPSILON2 = CMP_EPSILON * CMP_EPSILON;
+    constexpr f32 CMP_EPSILON = 0.000001f;
+    constexpr f32 CMP_EPSILON2 = CMP_EPSILON * CMP_EPSILON;
 
-    constexpr float CMP_NORMALIZE_TOLERANCE = 0.000001f;
-    constexpr float CMP_NORMALIZE_TOLERANCE2 = CMP_NORMALIZE_TOLERANCE * CMP_NORMALIZE_TOLERANCE;
-    constexpr float CMP_POINT_IN_PLANE_EPSILON = 0.00001f;
+    constexpr f32 CMP_NORMALIZE_TOLERANCE = 0.000001f;
+    constexpr f32 CMP_NORMALIZE_TOLERANCE2 = CMP_NORMALIZE_TOLERANCE * CMP_NORMALIZE_TOLERANCE;
+    constexpr f32 CMP_POINT_IN_PLANE_EPSILON = 0.00001f;
 }

engine/native/core/math/functions.cppm

@@ -8,6 +8,7 @@ module;
 export module core.math.functions;
 import core.math.constants;
 import core.defs;
+import core.stdtypes;
 
 export namespace draco::math {
     template <arithmetic T>
@@ -32,7 +33,7 @@ export namespace draco::math {
     template <arithmetic T>
     constexpr T abs(T value) noexcept {
         // Manually compute abs for signed types.
-        // Also avoids potential int8_t -> int issues.
+        // Also avoids potential i8 -> i32 issues.
         if constexpr (std::floating_point<T>) {
             return value < T{0} ? -value : value;
         } else if constexpr (std::signed_integral<T>) {
@@ -65,27 +66,27 @@ export namespace draco::math {
         }
 	}
 
-	constexpr float floor(float value) noexcept {
+	constexpr f32 floor(f32 value) noexcept {
 		if (value != value || abs(value) >= DECIMAL_LIMIT_F) {
 			return value;
 		}
-		const float truncated = static_cast<int>(value);
+		const f32 truncated = static_cast<i32>(value);
 		return truncated - (value < truncated);
 	}
 
-	constexpr float ceil(float value) noexcept {
+	constexpr f32 ceil(f32 value) noexcept {
 		return -floor(-value);
 	}
 
-	constexpr float trunc(float value) noexcept {
+	constexpr f32 trunc(f32 value) noexcept {
 		if (value != value || abs(value) >= DECIMAL_LIMIT_F) {
 			return value;
 		}
-		return static_cast<int>(value);
+		return static_cast<i32>(value);
 	}
 
-	constexpr float round(float value) noexcept {
-		const float s = sign(value);
+	constexpr f32 round(f32 value) noexcept {
+		const f32 s = sign(value);
 		return s * floor(s * value + 0.5f);
 	}
 

engine/native/core/math/math.cppm

@@ -4,3 +4,4 @@ export import core.math.constants;
 export import core.math.functions;
 export import core.math.types;
 export import core.defs;
+export import core.stdtypes;

engine/native/core/math/math.test.cpp

@@ -31,10 +31,12 @@
 
 import core.math;
 
+using namespace draco;
+
 TEST_SUITE("math") {
     TEST_CASE("pow") {
-        float result = draco::math::pow(2.0f, 0.5f);
-        constexpr float expected = draco::math::SQRT2;
+        f32 result = draco::math::pow(2.0f, 0.5f);
+        constexpr f32 expected = draco::math::SQRT2;
         CHECK_EQ(result, expected);
     }
 
@@ -308,8 +310,8 @@ TEST_SUITE("vector2") {
         );
 
         SUBCASE("float") {
-            static constexpr float smaller_length = 1.0f;
-            static constexpr float larger_length = 10.0f;
+            static constexpr f32 smaller_length = 1.0f;
+            static constexpr f32 larger_length = 10.0f;
 
             const Vector2 result_smaller = min_length(a, smaller_length);
             const Vector2 result_swapped = min_length(smaller_length, a);
@@ -357,8 +359,8 @@ TEST_SUITE("vector2") {
         );
 
         SUBCASE("float") {
-            static constexpr float smaller_length = 1.0f;
-            static constexpr float larger_length = 10.0f;
+            static constexpr f32 smaller_length = 1.0f;
+            static constexpr f32 larger_length = 10.0f;
 
             const Vector2 result_smaller = max_length(a, smaller_length);
             const Vector2 result_swapped = max_length(larger_length, a);
@@ -763,8 +765,8 @@ TEST_SUITE("vector3") {
         );
 
         SUBCASE("float") {
-            static constexpr float smaller_length = 1.0f;
-            static constexpr float larger_length = 10.0f;
+            static constexpr f32 smaller_length = 1.0f;
+            static constexpr f32 larger_length = 10.0f;
 
             const Vector3 result_smaller = min_length(a, smaller_length);
             const Vector3 result_swapped = min_length(smaller_length, a);
@@ -812,8 +814,8 @@ TEST_SUITE("vector3") {
         );
 
         SUBCASE("float") {
-            static constexpr float smaller_length = 1.0f;
-            static constexpr float larger_length = 10.0f;
+            static constexpr f32 smaller_length = 1.0f;
+            static constexpr f32 larger_length = 10.0f;
 
             const Vector3 result_smaller = max_length(a, smaller_length);
             const Vector3 result_swapped = max_length(larger_length, a);
@@ -1254,8 +1256,8 @@ TEST_SUITE("vector4") {
         );
 
         SUBCASE("float") {
-            static constexpr float smaller_length = 1.0f;
-            static constexpr float larger_length = 10.0f;
+            static constexpr f32 smaller_length = 1.0f;
+            static constexpr f32 larger_length = 10.0f;
 
             const Vector4 result_smaller = min_length(a, smaller_length);
             const Vector4 result_swapped = min_length(smaller_length, a);
@@ -1303,8 +1305,8 @@ TEST_SUITE("vector4") {
         );
 
         SUBCASE("float") {
-            static constexpr float smaller_length = 1.0f;
-            static constexpr float larger_length = 10.0f;
+            static constexpr f32 smaller_length = 1.0f;
+            static constexpr f32 larger_length = 10.0f;
 
             const Vector4 result_smaller = max_length(a, smaller_length);
             const Vector4 result_swapped = max_length(larger_length, a);