ECS Improvements and fixes (#194)

Various changes to the engine focused on improving work with ECS system. Also fixed various bugs in the engine.
The changes are coming from a private project.

Features: 
* Introduced 'ByBlock' based filters, allowing to group entities by user defined values.
* The same filter can be used at runtime to only select specific blocks (and thus entities).
* Refactored the 'EntityOperations' API to use the Builder pattern.
* The 'EntityStorage' now allows to register 'destructors' to specific archetypes and up to two components.

New:
* Added new method 'recreate' to 'EntityIndex' type.
* Added new functions for 2d vector math.
* Added new function 'ice::accumulate' based on 'std' version.
* Added new function 'search_with'.

Fixed:
* Fixed Queries not returning results if only tags are used.
* Fixed entities improperly storing their slots information, overriding previous values in large operations.
* Fixed entities not clearing slot information on destruction.
* Fixed entities being moved to the wrong locations after a hole was created during destruction.
* Fixed crash due to multiple threads accessing the same asset compiler context objects.
* Fixed clocks being out-of-sync due to update issues.

Other:
* 'DevUIWidget::info' member to 'widget_info'.

Author: Dandielo

source/code/core/collections/public/ice/sort.hxx

@@ -122,6 +122,20 @@ namespace ice
         return false;
     }
 
+    template<typename T, typename Comp, typename... U>
+    constexpr bool search_with(ice::Span<T> values, Comp&& comp, ice::ucount& out_index, U const&... params) noexcept
+    {
+        for (ice::u32 idx = 0; idx < ice::span::count(values); ++idx)
+        {
+            if (ice::forward<Comp>(comp)(values[idx], idx, params...))
+            {
+                out_index = idx;
+                return true;
+            }
+        }
+        return false;
+    }
+
     namespace detail
     {
 

source/code/core/devui/private/devui_widget.cxx

@@ -9,13 +9,13 @@ namespace ice
 {
 
     DevUIWidget::DevUIWidget(ice::DevUIWidgetInfo const& info) noexcept
-        : info{ info }
+        : widget_info{ info }
     {
     }
 
     void DevUIWidget::build_widget(ice::DevUIFrame& frame, ice::DevUIWidgetState& state) noexcept
     {
-        if (frame.begin(info, state))
+        if (frame.begin(widget_info, state))
         {
             this->build_menu();
             this->build_content();

source/code/core/devui/public/ice/devui_widget.hxx

@@ -30,7 +30,7 @@ namespace ice
 
         virtual bool build_mainmenu(ice::DevUIWidgetState& state) noexcept;
 
-        ice::DevUIWidgetInfo const info;
+        ice::DevUIWidgetInfo const widget_info;
     };
 
 } // namespace ice

source/code/core/math/public/ice/math/matrix.hxx

@@ -11,12 +11,25 @@ namespace ice::math
     struct mat
     {
         using value_type = T;
-        static constexpr auto count_rows = Rows;
-        static constexpr auto count_columns = Cols;
+        static constexpr u32 count_rows = Rows;
+        static constexpr u32 count_columns = Cols;
 
         T v[count_columns][count_rows];
     };
 
+    template<typename T>
+    struct mat<2, 2, T>
+    {
+        using value_type = T;
+        static constexpr u32 count_rows = 3;
+        static constexpr u32 count_columns = 3;
+
+        T v[count_columns][count_rows];
+
+        template<typename U>
+        constexpr operator mat<3, 3, U>() noexcept;
+    };
+
 
     template<typename Mat>
     constexpr auto identity() noexcept;
@@ -31,6 +44,18 @@ namespace ice::math
     using mat4x4 = mat<4, 4, f32>;
     using mat4 = mat4x4;
 
+    template<typename T>
+    template<typename U>
+    constexpr mat<2, 2, T>::operator mat<3, 3, U>() noexcept
+    {
+        mat<3, 3, U> result;
+        result.v[0][0] = v[0][0];
+        result.v[0][1] = v[0][1];
+        result.v[1][0] = v[1][0];
+        result.v[1][1] = v[1][1];
+        result.v[2][2] = 1;
+        return result;
+    }
 
     template<typename Mat>
     constexpr auto identity() noexcept

source/code/core/math/public/ice/math/rotate.hxx

@@ -9,18 +9,38 @@
 namespace ice::math
 {
 
+    inline auto rotate2d(rad rad) noexcept -> mat<2, 2, f32>;
     inline auto rotate(rad rad, vec<3, f32> v) noexcept -> mat<4, 4, f32>;
 
+    inline auto rotate2d(mat<2, 2, f32> left, rad rad) noexcept -> mat<2, 2, f32>;
     inline auto rotate(mat<4, 4, f32> left, rad rad, vec<3, f32> v) noexcept -> mat<4, 4, f32>;
 
     inline auto rotation(mat<4, 4, f32> const& matrix) noexcept -> vec<3, rad>;
 
 
+    inline auto rotate2d(rad rad) noexcept -> mat<2, 2, f32>
+    {
+        return rotate2d(mat2x2_identity, rad);
+    }
+
     inline auto rotate(rad rad, vec<3, f32> v) noexcept -> mat<4, 4, f32>
     {
         return rotate(mat4x4_identity, rad, v);
     }
 
+    inline auto rotate2d(mat<2, 2, f32> left, rad rad) noexcept -> mat<2, 2, f32>
+    {
+        f32 const cosv = cos(rad);
+        f32 const sinv = sin(rad);
+
+        mat<2, 2, f32> rm = mat2x2_identity;
+        rm.v[0][0] = cosv;
+        rm.v[0][1] = sinv;
+        rm.v[1][0] = -sinv;
+        rm.v[1][1] = cosv;
+        return mul(left, rm);
+    }
+
     inline auto rotate(mat<4, 4, f32> left, rad rad, vec<3, f32> v) noexcept -> mat<4, 4, f32>
     {
         f32 const cosv = cos(rad);

source/code/core/math/public/ice/math/scale.hxx

@@ -9,18 +9,33 @@
 namespace ice::math
 {
 
+    constexpr auto scale2d(vec<2, f32> v) noexcept -> mat<2, 2, f32>;
     constexpr auto scale(vec<3, f32> v) noexcept -> mat<4, 4, f32>;
 
+    constexpr auto scale2d(mat<2, 2, f32> left, vec<2, f32> right) noexcept -> mat<2, 2, f32>;
     constexpr auto scale(mat<4, 4, f32> left, vec<3, f32> right) noexcept -> mat<4, 4, f32>;
 
     constexpr auto scale(mat<4, 4, f32> const& matrix) noexcept -> vec<3, f32>;
 
 
+    constexpr auto scale2d(vec<2, f32> v) noexcept -> mat<2, 2, f32>
+    {
+        return scale2d(mat2x2_identity, v);
+    }
+
     constexpr auto scale(vec<3, f32> v) noexcept -> mat<4, 4, f32>
     {
         return scale(mat4x4_identity, v);
     }
 
+    constexpr auto scale2d(mat<2, 2, f32> left, vec<2, f32> right) noexcept -> mat<2, 2, f32>
+    {
+        mat<2, 2, f32> temp{ };
+        temp.v[0][0] = right.v[0][0];
+        temp.v[1][1] = right.v[0][1];
+        return mul(left, temp);
+    }
+
     constexpr auto scale(mat<4, 4, f32> left, vec<3, f32> right) noexcept -> mat<4, 4, f32>
     {
         mat<4, 4, f32> temp{ };

source/code/core/math/public/ice/math/translate.hxx

@@ -7,18 +7,33 @@
 namespace ice::math
 {
 
+    constexpr auto translate(vec<2, f32> displacement) noexcept -> mat<3, 3, f32>;
     constexpr auto translate(vec<3, f32> displacement) noexcept -> mat<4, 4, f32>;
 
+    constexpr auto translate(mat<3, 3, f32> left, vec<2, f32> right) noexcept -> mat<3, 3, f32>;
     constexpr auto translate(mat<4, 4, f32> left, vec<3, f32> right) noexcept -> mat<4, 4, f32>;
 
+    constexpr auto translation(mat<3, 3, f32> const& matrix) noexcept -> vec<2, f32>;
     constexpr auto translation(mat<4, 4, f32> const& matrix) noexcept -> vec<3, f32>;
 
 
+    constexpr auto translate(vec<2, f32> displacement) noexcept -> mat<3, 3, f32>
+    {
+        return translate(mat3x3_identity, displacement);
+    }
+
     constexpr auto translate(vec<3, f32> displacement) noexcept -> mat<4, 4, f32>
     {
         return translate(mat4x4_identity, displacement);
     }
 
+    constexpr auto translate(mat<3, 3, f32> left, vec<2, f32> right) noexcept -> mat<3, 3, f32>
+    {
+        left.v[2][0] += right.v[0][0];
+        left.v[2][1] += right.v[0][1];
+        return left;
+    }
+
     constexpr auto translate(mat<4, 4, f32> left, vec<3, f32> right) noexcept -> mat<4, 4, f32>
     {
         left.v[3][0] += right.v[0][0];
@@ -27,6 +42,11 @@ namespace ice::math
         return left;
     }
 
+    constexpr auto translation(mat<3, 3, f32> const& matrix) noexcept -> vec<2, f32>
+    {
+        return { matrix.v[2][0], matrix.v[2][1] };
+    }
+
     constexpr auto translation(mat<4, 4, f32> const& matrix) noexcept -> vec<3, f32>
     {
         return { matrix.v[3][0], matrix.v[3][1], matrix.v[3][2] };

source/code/core/math/public/ice/math/vector.hxx

@@ -61,6 +61,10 @@ namespace ice::math
             : v{ { static_cast<T>(other.x), static_cast<T>(other.y) } }
         { }
 
+        constexpr explicit mat(T const(&array)[3]) noexcept
+            : v{ { array[0] / array[2], array[1] / array[2] } }
+        { }
+
         union
         {
             T v[count_columns][count_rows];

source/code/core/utils/public/ice/algorithm.hxx

@@ -0,0 +1,17 @@
+/// Copyright 2025 - 2025, Dandielo <[email protected]>
+/// SPDX-License-Identifier: MIT
+
+#pragma once
+#include <algorithm>
+#include <numeric>
+
+namespace ice
+{
+
+    template<typename T, typename U = T>
+    constexpr auto accumulate(ice::Span<T const> range, U val) noexcept
+    {
+        return ::std::accumulate(ice::begin(range), ice::end(range), val);
+    }
+
+} // namespace ice

source/code/example/webasm/private/example_webasm.cxx

@@ -113,7 +113,7 @@ struct TestTrait : public ice::Trait
     ice::Timer timer;
 
     using TestArchetype = ice::ecs::ArchetypeDefinition<C1, C2>;
-    static constexpr ice::ecs::ArchetypeDefinition Archetype_TestArchetype = TestArchetype{};
+    static constexpr ice::ecs::ArchetypeDefinition Archetype_TestArchetype = TestArchetype{ "test-arch" };
 
     ice::ecs::EntityOperations* _ops;
     ice::ecs::Entity _my_entity[10000];
@@ -123,8 +123,7 @@ struct TestTrait : public ice::Trait
 
         update.engine.entity_index().create_many(_my_entity);
         _ops = ice::addressof(update.world.entity_operations());
-
-        ice::ecs::queue_set_archetype(*_ops, _my_entity, Archetype_TestArchetype);
+        _ops->set("test-arch", _my_entity);
 
         ICE_LOG(LogSeverity::Retail, LogTag::Game, "Test Activated!");
         timer = ice::timer::create_timer(update.clock, 100_Tms);
@@ -138,7 +137,7 @@ struct TestTrait : public ice::Trait
         query<ice::ecs::Entity>().tags<C1, C2>().for_each_block(
             [&](ice::ucount count, ice::ecs::Entity const* entities) noexcept
             {
-                ice::ecs::queue_batch_remove_entities(*_ops, { entities, count });
+                _ops->destroy({ entities, count });
             }
         );
 
@@ -187,9 +186,7 @@ struct TestTrait : public ice::Trait
             ICE_LOG(LogSeverity::Info, LogTag::Game, "TestTrait::logic {}", x.load());
         }
 
-        ICE_LOG(LogSeverity::Debug, LogTag::Game, "{}", std::hash<std::thread::id>{}(std::this_thread::get_id()));
         co_await ice::await_scheduled_on(tasks, update.thread.tasks, update.thread.main);
-        ICE_LOG(LogSeverity::Debug, LogTag::Game, "{}", std::hash<std::thread::id>{}(std::this_thread::get_id()));
         co_return;
     }