JeanPhilippeKernel · JeanPhilippeKernel · Apr 6, 2025 · Mar 25, 2025 · Mar 25, 2025 · Mar 25, 2025
diff --git a/.gitmodules b/.gitmodules
@@ -64,3 +64,6 @@
 [submodule "__externals/CLI11"]
 	path = __externals/CLI11
 	url = https://github.com/CLIUtils/CLI11
+[submodule "__externals/rapidhash/src"]
+	path = __externals/rapidhash/src
+	url = https://github.com/Nicoshev/rapidhash
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -58,6 +58,7 @@ if (NOT LAUNCHER_ONLY)
 	add_subdirectory (${EXTERNAL_DIR}/gtest)
 	add_subdirectory (${EXTERNAL_DIR}/VulkanMemoryAllocator)
 	add_subdirectory (${EXTERNAL_DIR}/tlsf)
+	add_subdirectory (${EXTERNAL_DIR}/rapidhash)
 	add_subdirectory (${EXTERNAL_DIR}/CLI11)
 
 	set (CMAKE_PREFIX_PATH

diff --git a/Tetragrama/Components/UIComponent.h b/Tetragrama/Components/UIComponent.h
@@ -1,6 +1,6 @@
 #pragma once
 #include <ImguiLayer.h>
-#include <ZEngine/Core/Container/Array.h>
+#include <ZEngine/Core/Containers/Array.h>
 #include <ZEngine/Core/IRenderable.h>
 #include <ZEngine/Core/IUpdatable.h>
 
@@ -24,11 +24,11 @@ namespace Tetragrama::Components
             CanBeClosed = closed;
         }
 
-        bool                                                  IsVisible     = true;
-        bool                                                  CanBeClosed   = false;
-        const char*                                           Name          = "";
-        uint32_t                                              ChildrenCount = 0;
-        Tetragrama::Layers::ImguiLayer*                       ParentLayer   = nullptr;
-        ZEngine::Core::Container::Array<ZRawPtr(UIComponent)> Children      = {};
+        bool                                                   IsVisible     = true;
+        bool                                                   CanBeClosed   = false;
+        const char*                                            Name          = "";
+        uint32_t                                               ChildrenCount = 0;
+        Tetragrama::Layers::ImguiLayer*                        ParentLayer   = nullptr;
+        ZEngine::Core::Containers::Array<ZRawPtr(UIComponent)> Children      = {};
     };
 } // namespace Tetragrama::Components
diff --git a/Tetragrama/Editor.cpp b/Tetragrama/Editor.cpp
@@ -6,7 +6,7 @@
 #include <nlohmann/json.hpp>
 
 using namespace ZEngine;
-using namespace ZEngine::Core::Container;
+using namespace ZEngine::Core::Containers;
 using namespace ZEngine::Core::Memory;
 using namespace ZEngine::Helpers;
 using namespace Tetragrama::Layers;
@@ -49,8 +49,8 @@ namespace Tetragrama
         std::string                  title       = fmt::format("{0} - Active Scene : {1}", Context->ConfigurationPtr->ProjectName, Context->CurrentScenePtr->Name);
         Windows::WindowConfiguration window_conf = {.EnableVsync = true};
         window_conf.Title.init(&(Context->Arena), title.c_str());
-        window_conf.RenderingLayerCollection.init(&(Context->Arena), 1, 0);
-        window_conf.OverlayLayerCollection.init(&(Context->Arena), 1, 0);
+        window_conf.RenderingLayerCollection.init(&(Context->Arena), 1);
+        window_conf.OverlayLayerCollection.init(&(Context->Arena), 1);
 
         window_conf.RenderingLayerCollection.push(CanvasLayer);
         window_conf.OverlayLayerCollection.push(UILayer);
@@ -74,10 +74,10 @@ namespace Tetragrama
         RenderScene                  = ZPushStructCtor(arena, ZEngine::Rendering::Scenes::GraphicScene);
         RenderScene->IsDrawDataDirty = true;
 
-        MeshFiles.init(arena, 1, 0);
-        ModelFiles.init(arena, 1, 0);
-        MaterialFiles.init(arena, 1, 0);
-        Hashes.init(arena, 1, 0);
+        MeshFiles.init(arena, 1);
+        ModelFiles.init(arena, 1);
+        MaterialFiles.init(arena, 1);
+        Hashes.init(arena, 1);
     }
 
     void EditorScene::Push(ZEngine::Core::Memory::ArenaAllocator* arena, const char* mesh, const char* model, const char* material)

diff --git a/Tetragrama/Editor.h b/Tetragrama/Editor.h
@@ -2,8 +2,8 @@
 #include <EditorCameraController.h>
 #include <Layers/ImguiLayer.h>
 #include <Layers/RenderLayer.h>
-#include <ZEngine/Core/Container/Array.h>
-#include <ZEngine/Core/Container/Strings.h>
+#include <ZEngine/Core/Containers/Array.h>
+#include <ZEngine/Core/Containers/Strings.h>
 #include <ZEngine/Core/Memory/Allocator.h>
 #include <ZEngine/Engine.h>
 #include <ZEngine/Helpers/IntrusivePtr.h>
@@ -23,19 +23,19 @@ namespace Tetragrama
 
         EditorScene() = default;
 
-        void                                                              Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, const char* scene_name = "");
-        void                                                              Push(ZEngine::Core::Memory::ArenaAllocator* arena, const char* mesh, const char* model, const char* material);
-        bool                                                              HasPendingChange() const;
+        void                                                                Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, const char* scene_name = "");
+        void                                                                Push(ZEngine::Core::Memory::ArenaAllocator* arena, const char* mesh, const char* model, const char* material);
+        bool                                                                HasPendingChange() const;
 
-        const char*                                                       Name          = "";
-        ZEngine::Core::Container::Array<ZEngine::Core::Container::String> MeshFiles     = {};
-        ZEngine::Core::Container::Array<ZEngine::Core::Container::String> ModelFiles    = {};
-        ZEngine::Core::Container::Array<ZEngine::Core::Container::String> MaterialFiles = {};
+        const char*                                                         Name          = "";
+        ZEngine::Core::Containers::Array<ZEngine::Core::Containers::String> MeshFiles     = {};
+        ZEngine::Core::Containers::Array<ZEngine::Core::Containers::String> ModelFiles    = {};
+        ZEngine::Core::Containers::Array<ZEngine::Core::Containers::String> MaterialFiles = {};
 
-        ZEngine::Core::Container::Array<ZEngine::Core::Container::String> Hashes        = {};
-        std::map<const char*, Model>                                      Data          = {};
+        ZEngine::Core::Containers::Array<ZEngine::Core::Containers::String> Hashes        = {};
+        std::map<const char*, Model>                                        Data          = {};
 
-        ZRawPtr(ZEngine::Rendering::Scenes::GraphicScene) RenderScene                   = nullptr;
+        ZRawPtr(ZEngine::Rendering::Scenes::GraphicScene) RenderScene                     = nullptr;
 
     private:
         std::atomic_bool m_has_pending_change;

diff --git a/Tetragrama/EditorWindow.cpp b/Tetragrama/EditorWindow.cpp
@@ -38,7 +38,7 @@ namespace Tetragrama
         return m_property.Width;
     }
 
-    ZEngine::Core::Container::StringView EditorWindow::GetTitle() const
+    ZEngine::Core::Containers::StringView EditorWindow::GetTitle() const
     {
         return m_property.Title;
     }
@@ -48,7 +48,7 @@ namespace Tetragrama
         return m_property.IsMinimized;
     }
 
-    void EditorWindow::SetTitle(ZEngine::Core::Container::StringView title)
+    void EditorWindow::SetTitle(ZEngine::Core::Containers::StringView title)
     {
         m_property.Title = title.data();
         glfwSetWindowTitle(m_native_window, m_property.Title);

diff --git a/Tetragrama/EditorWindow.h b/Tetragrama/EditorWindow.h
@@ -17,9 +17,9 @@ namespace Tetragrama
 
         uint32_t                                        GetHeight() const override;
         uint32_t                                        GetWidth() const override;
-        ZEngine::Core::Container::StringView            GetTitle() const override;
+        ZEngine::Core::Containers::StringView           GetTitle() const override;
         bool                                            IsMinimized() const override;
-        void                                            SetTitle(ZEngine::Core::Container::StringView title) override;
+        void                                            SetTitle(ZEngine::Core::Containers::StringView title) override;
         bool                                            IsVSyncEnable() const override;
         void                                            SetVSync(bool value) override;
         void                                            SetCallbackFunction(const EventCallbackFn& callback) override;

diff --git a/Tetragrama/Helpers/SerializerCommonHelper.cpp b/Tetragrama/Helpers/SerializerCommonHelper.cpp
@@ -2,18 +2,18 @@
 #include <SerializerCommonHelper.h>
 #include <ZEngine/Helpers/MemoryOperations.h>
 
-using namespace ZEngine::Core::Container;
+using namespace ZEngine::Core::Containers;
 
 namespace Tetragrama::Helpers
 {
-    void SerializeStringData(std::ostream& os, ZEngine::Core::Container::StringView str)
+    void SerializeStringData(std::ostream& os, ZEngine::Core::Containers::StringView str)
     {
         size_t f_count = str.size();
         os.write(reinterpret_cast<const char*>(&f_count), sizeof(size_t));
         os.write(str.data(), f_count + 1);
     }
 
-    void DeserializeStringData(ZEngine::Core::Memory::ArenaAllocator* Arena, std::istream& in, ZEngine::Core::Container::String& d)
+    void DeserializeStringData(ZEngine::Core::Memory::ArenaAllocator* Arena, std::istream& in, ZEngine::Core::Containers::String& d)
     {
         size_t v_count;
         in.read(reinterpret_cast<char*>(&v_count), sizeof(size_t));
@@ -22,7 +22,7 @@ namespace Tetragrama::Helpers
         in.read(d.data(), v_count + 1);
     }
 
-    void SerializeStringArrayData(std::ostream& os, ZEngine::Core::Container::ArrayView<ZEngine::Core::Container::String> str_view)
+    void SerializeStringArrayData(std::ostream& os, ZEngine::Core::Containers::ArrayView<ZEngine::Core::Containers::String> str_view)
     {
         size_t count = str_view.size();
         os.write(reinterpret_cast<const char*>(&count), sizeof(size_t));
@@ -49,7 +49,7 @@ namespace Tetragrama::Helpers
         os.write(reinterpret_cast<const char*>(flat_data.data()), sizeof(uint32_t) * flat_data.size());
     }
 
-    void DeserializeStringArrayData(ZEngine::Core::Memory::ArenaAllocator* Arena, std::istream& in, ZEngine::Core::Container::Array<ZEngine::Core::Container::String>& data)
+    void DeserializeStringArrayData(ZEngine::Core::Memory::ArenaAllocator* Arena, std::istream& in, ZEngine::Core::Containers::Array<ZEngine::Core::Containers::String>& data)
     {
         size_t data_count;
         in.read(reinterpret_cast<char*>(&data_count), sizeof(size_t));

diff --git a/Tetragrama/Helpers/SerializerCommonHelper.h b/Tetragrama/Helpers/SerializerCommonHelper.h
@@ -1,17 +1,17 @@
 #pragma once
-#include <ZEngine/Core/Container/Array.h>
-#include <ZEngine/Core/Container/Strings.h>
+#include <ZEngine/Core/Containers/Array.h>
+#include <ZEngine/Core/Containers/Strings.h>
 #include <ZEngine/Core/Memory/Allocator.h>
 #include <iostream>
 #include <unordered_map>
 
 namespace Tetragrama::Helpers
 {
-    void SerializeStringData(std::ostream&, ZEngine::Core::Container::StringView);
-    void SerializeStringArrayData(std::ostream&, ZEngine::Core::Container::ArrayView<ZEngine::Core::Container::String>);
+    void SerializeStringData(std::ostream&, ZEngine::Core::Containers::StringView);
+    void SerializeStringArrayData(std::ostream&, ZEngine::Core::Containers::ArrayView<ZEngine::Core::Containers::String>);
     void SerializeMapData(std::ostream&, const std::unordered_map<uint32_t, uint32_t>&);
 
-    void DeserializeStringData(ZEngine::Core::Memory::ArenaAllocator*, std::istream& in, ZEngine::Core::Container::String& data);
-    void DeserializeStringArrayData(ZEngine::Core::Memory::ArenaAllocator*, std::istream&, ZEngine::Core::Container::Array<ZEngine::Core::Container::String>&);
+    void DeserializeStringData(ZEngine::Core::Memory::ArenaAllocator*, std::istream& in, ZEngine::Core::Containers::String& data);
+    void DeserializeStringArrayData(ZEngine::Core::Memory::ArenaAllocator*, std::istream&, ZEngine::Core::Containers::Array<ZEngine::Core::Containers::String>&);
     void DeserializeMapData(ZEngine::Core::Memory::ArenaAllocator*, std::istream&, std::unordered_map<uint32_t, uint32_t>&);
 } // namespace Tetragrama::Helpers
diff --git a/Tetragrama/Importers/AssimpImporter.cpp b/Tetragrama/Importers/AssimpImporter.cpp
@@ -11,7 +11,7 @@ using namespace ZEngine::Helpers;
 using namespace Tetragrama::Helpers;
 using namespace ZEngine::Rendering::Meshes;
 using namespace ZEngine::Rendering::Scenes;
-using namespace ZEngine::Core::Container;
+using namespace ZEngine::Core::Containers;
 
 namespace fs = std::filesystem;
 

diff --git a/Tetragrama/Importers/IAssetImporter.h b/Tetragrama/Importers/IAssetImporter.h
@@ -2,8 +2,8 @@
 #include <Helpers/IntrusivePtr.h>
 #include <Rendering/Meshes/Mesh.h>
 #include <Rendering/Scenes/GraphicScene.h>
-#include <ZEngine/Core/Container/Array.h>
-#include <ZEngine/Core/Container/Strings.h>
+#include <ZEngine/Core/Containers/Array.h>
+#include <ZEngine/Core/Containers/Strings.h>
 #include <ZEngine/Core/Memory/Allocator.h>
 #include <atomic>
 #include <future>
@@ -25,20 +25,20 @@ namespace Tetragrama::Importers
         uint32_t                                 VertexOffset            = 0;
         uint32_t                                 IndexOffset             = 0;
         ZEngine::Rendering::Scenes::SceneRawData Scene                   = {};
-        ZEngine::Core::Container::String         Name                    = {};
-        ZEngine::Core::Container::String         SerializedMeshesPath    = {};
-        ZEngine::Core::Container::String         SerializedMaterialsPath = {};
-        ZEngine::Core::Container::String         SerializedModelPath     = {};
+        ZEngine::Core::Containers::String        Name                    = {};
+        ZEngine::Core::Containers::String        SerializedMeshesPath    = {};
+        ZEngine::Core::Containers::String        SerializedMaterialsPath = {};
+        ZEngine::Core::Containers::String        SerializedModelPath     = {};
     };
 
     struct ImportConfiguration
     {
-        ZEngine::Core::Container::String AssetFilename;
-        ZEngine::Core::Container::String InputBaseAssetFilePath;
-        ZEngine::Core::Container::String OutputModelFilePath;
-        ZEngine::Core::Container::String OutputMeshFilePath;
-        ZEngine::Core::Container::String OutputTextureFilesPath;
-        ZEngine::Core::Container::String OutputMaterialsPath;
+        ZEngine::Core::Containers::String AssetFilename;
+        ZEngine::Core::Containers::String InputBaseAssetFilePath;
+        ZEngine::Core::Containers::String OutputModelFilePath;
+        ZEngine::Core::Containers::String OutputMeshFilePath;
+        ZEngine::Core::Containers::String OutputTextureFilesPath;
+        ZEngine::Core::Containers::String OutputMaterialsPath;
     };
 
     struct IAssetImporter

diff --git a/Tetragrama/Layers/ImguiLayer.cpp b/Tetragrama/Layers/ImguiLayer.cpp
@@ -17,7 +17,7 @@
 using namespace ZEngine;
 using namespace ZEngine::Rendering::Renderers;
 using namespace ZEngine::Windows::Events;
-using namespace ZEngine::Core::Container;
+using namespace ZEngine::Core::Containers;
 using namespace ZEngine::Helpers;
 using namespace Tetragrama::Messengers;
 
@@ -29,7 +29,7 @@ namespace Tetragrama::Layers
     {
         arena->CreateSubArena(ZMega(5), &LayerArena);
 
-        NodeHierarchies.init(&LayerArena, 10, 0);
+        NodeHierarchies.init(&LayerArena, 10);
 
         auto dockspace_cmp      = ZPushStructCtor(&LayerArena, Components::DockspaceUIComponent);
         auto scene_cmp          = ZPushStructCtor(&LayerArena, Components::SceneViewportUIComponent);
@@ -48,7 +48,7 @@ namespace Tetragrama::Layers
         hierarchy_view_cmp->Initialize(this);
         demo_cmp->Initialize(this);
 
-        dockspace_cmp->Children.init(&LayerArena, 8, 7);
+        dockspace_cmp->Children.init(&LayerArena, 8);
         dockspace_cmp->Children.push(scene_cmp);
         dockspace_cmp->Children.push(editor_log_cmp);
         dockspace_cmp->Children.push(demo_cmp);
@@ -121,9 +121,9 @@ namespace Tetragrama::Layers
         Array<int> children   = {};
         Array<int> siblings   = {};
 
-        roots.init(temp_arena.Arena, 1, 0);
-        children.init(temp_arena.Arena, 1, 0);
-        siblings.init(temp_arena.Arena, 1, 0);
+        roots.init(temp_arena.Arena, 1);
+        children.init(temp_arena.Arena, 1);
+        siblings.init(temp_arena.Arena, 1);
 
         uint32_t i = 0;
         for (auto& node : NodeHierarchies)

diff --git a/Tetragrama/Layers/ImguiLayer.h b/Tetragrama/Layers/ImguiLayer.h
@@ -1,7 +1,7 @@
 #pragma once
 #include <UIComponent.h>
-#include <ZEngine/Core/Container/Array.h>
-#include <ZEngine/Core/Container/Strings.h>
+#include <ZEngine/Core/Containers/Array.h>
+#include <ZEngine/Core/Containers/Strings.h>
 #include <ZEngine/Core/Memory/Allocator.h>
 #include <ZEngine/Windows/Inputs/IInputEventCallback.h>
 #include <ZEngine/Windows/Layers/Layer.h>
@@ -28,8 +28,8 @@ namespace Tetragrama::Layers
         ImguiLayer(const char* name = "ImGUI Layer") : Layer(name) {}
         virtual ~ImguiLayer();
 
-        ZEngine::Core::Container::Array<NodeHierarchy>       NodeHierarchies  = {};
-        ZEngine::Core::Container::Array<uint32_t>            NodeToRender     = {};
+        ZEngine::Core::Containers::Array<NodeHierarchy>      NodeHierarchies  = {};
+        ZEngine::Core::Containers::Array<uint32_t>           NodeToRender     = {};
         std::map<uint32_t, ZRawPtr(Components::UIComponent)> NodeUIComponents = {};
 
         virtual void                                         Initialize(ZEngine::Core::Memory::ArenaAllocator* arena) override;

diff --git a/Tetragrama/Serializers/EditorSceneSerializer.cpp b/Tetragrama/Serializers/EditorSceneSerializer.cpp
@@ -3,11 +3,11 @@
 #include <Helpers/ThreadPool.h>
 #include <Importers/IAssetImporter.h>
 #include <Serializers/EditorSceneSerializer.h>
-#include <ZEngine/Core/Container/Array.h>
+#include <ZEngine/Core/Containers/Array.h>
 #include <fmt/format.h>
 
 using namespace ZEngine::Helpers;
-using namespace ZEngine::Core::Container;
+using namespace ZEngine::Core::Containers;
 using namespace Tetragrama::Helpers;
 using namespace Tetragrama::Importers;
 

diff --git a/ZEngine/ZEngine/CMakeLists.txt b/ZEngine/ZEngine/CMakeLists.txt
@@ -23,7 +23,7 @@ target_include_directories (zEngineLib
 		.
 		./Core
 		./Core/Memory
-		./Core/Container
+		./Core/Containers
 		./Hardwares
 		./Helpers
 		./Layers

diff --git a/ZEngine/ZEngine/Core/Container/Array.h → ZEngine/ZEngine/Core/Containers/Array.h b/ZEngine/ZEngine/Core/Container/Array.h → ZEngine/ZEngine/Core/Containers/Array.h
@@ -1,12 +1,11 @@
 #pragma once
 #include <Allocator.h>
+#include <InitializerList.h>
 #include <type_traits>
 
-// using span ?
-
 using namespace ZEngine::Core::Memory;
 
-namespace ZEngine::Core::Container
+namespace ZEngine::Core::Containers
 {
 
     template <typename T>
@@ -21,15 +20,24 @@ namespace ZEngine::Core::Container
         using iterator        = T*;
         using const_iterator  = const T*;
 
-        void init(Memory::ArenaAllocator* allocator, size_type initial_capacity, size_type initial_size = 0U)
+        void init(Memory::ArenaAllocator* allocator, size_type initial_capacity)
         {
             m_allocator = allocator;
-            m_size      = initial_size;
+            m_size      = 0;
             m_capacity  = 0;
             m_data      = nullptr;
             reserve(initial_capacity);
         }
 
+        void init(Memory::ArenaAllocator* allocator, size_type initial_capacity, const InitializerList<T>& list)
+        {
+            init(allocator, std::max(initial_capacity, list.size()));
+            for (const auto& item : list)
+            {
+                push(item);
+            }
+        }
+
         const_reference operator[](size_type index) const
         {
             ZENGINE_VALIDATE_ASSERT(index < m_size, "Index out of range")
@@ -219,4 +227,4 @@ namespace ZEngine::Core::Container
         T*     m_data;
         size_t m_size;
     };
-} // namespace ZEngine::Core::Container
+} // namespace ZEngine::Core::Containers