first iteration - engine runs on Arena

Tetragrama/Components/DockspaceUIComponent.cpp

@@ -144,7 +144,7 @@ namespace Tetragrama::Components
         auto ctx = reinterpret_cast<EditorContext*>(ParentLayer->ParentContext);
         if (ctx->CurrentScenePtr && ctx->CurrentScenePtr->RenderScene->IsDrawDataDirty)
         {
-            ctx->CurrentScenePtr->RenderScene->InitOrResetDrawBuffer(renderer->Device, renderer->RenderGraph.get(), renderer->AsyncLoader.get());
+            ctx->CurrentScenePtr->RenderScene->InitOrResetDrawBuffer(renderer->Device, renderer->RenderGraph, renderer->AsyncLoader);
         }
     }
 

Tetragrama/Editor.cpp

@@ -15,16 +15,11 @@ using namespace Tetragrama::Controllers;
 
 namespace Tetragrama
 {
-    Editor::~Editor()
-    {
-        // ZEngine::Engine::Dispose();
-    }
-
     void Editor::Initialize(ArenaAllocator* arena, const char* file)
     {
         Context = ZPushStruct(arena, EditorContext);
 
-        arena->CreateSubArena(ZMega(10), &(Context->Arena));
+        arena->CreateSubArena(ZMega(50), &(Context->Arena));
 
         Context->ConfigurationPtr    = ZPushStructCtor(&(Context->Arena), EditorConfiguration);
         Context->CameraControllerPtr = ZPushStructCtor(&(Context->Arena), EditorCameraController);
@@ -59,12 +54,17 @@ namespace Tetragrama
 
         Context->CameraControllerPtr->Initialize(&(Context->Arena), Window, 150.0, 0.f, 45.f);
 
-        // ZEngine::Engine::Initialize(arena, {}, Window);
+        ZEngine::Engine::Initialize(arena, Window);
+    }
+
+    void Editor::Dispose()
+    {
+        ZEngine::Engine::Dispose();
     }
 
     void Editor::Run()
     {
-        // ZEngine::Engine::Run();
+        ZEngine::Engine::Run();
     }
 
     void EditorScene::Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, const char* name)

Tetragrama/Editor.h

@@ -72,14 +72,15 @@ namespace Tetragrama
 
     struct Editor
     {
-        ~Editor();
+        ~Editor() {}
 
         ZRawPtr(EditorContext) Context               = nullptr;
         ZRawPtr(Layers::ImguiLayer) UILayer          = nullptr;
         ZRawPtr(Layers::RenderLayer) CanvasLayer     = nullptr;
         ZRawPtr(ZEngine::Windows::CoreWindow) Window = nullptr;
 
         void Initialize(ZEngine::Core::Memory::ArenaAllocator*, const char*);
+        void Dispose();
         void Run();
     };
 

Tetragrama/EditorWindow.cpp

@@ -4,6 +4,7 @@
 #include <ZEngine/Engine.h>
 #include <ZEngine/Event/EngineClosedEvent.h>
 #include <ZEngine/Logging/LoggerDefinition.h>
+#include <ZEngine/Windows/Inputs/IDevice.h>
 #include <ZEngine/Windows/Inputs/KeyCode.h>
 
 #ifdef _WIN32
@@ -154,6 +155,11 @@ namespace Tetragrama
 
         ZENGINE_CORE_INFO("Windows layers initialized")
 
+        // Initialize Input Devices (Keyboard, Mouse)
+        ZEngine::Windows::Inputs::IDevice::Initialize(arena);
+
+        ZENGINE_CORE_INFO("Input devices initialized")
+
         glfwSetWindowUserPointer(m_native_window, &m_property);
 
         glfwSetFramebufferSizeCallback(m_native_window, EditorWindow::__OnGlfwFrameBufferSizeChanged);

Tetragrama/EntryPoint.cpp

@@ -1,31 +1,41 @@
 #include <pch.h>
 #include <CLI/CLI.hpp>
 #include <ZEngine/Core/Memory/MemoryManager.h>
+#include <ZEngine/EngineConfiguration.h>
+#include <ZEngine/Logging/Logger.h>
 #include "Editor.h"
 
 #ifdef ZENGINE_PLATFORM
 
+using namespace ZEngine;
+using namespace ZEngine::Logging;
 using namespace ZEngine::Core::Memory;
 
 int applicationEntryPoint(int argc, char* argv[])
 {
     CLI::App app{"ZEngine Editor"};
     argv = app.ensure_utf8(argv);
 
-    std::string json_config_file{""};
-    app.add_option("--projectConfigFile", json_config_file, "The project config file");
+    std::string editor_cfg_file{""};
+    app.add_option("--projectConfigFile", editor_cfg_file, "The project config file");
 
     CLI11_PARSE(app, argc, argv);
 
-    MemoryConfiguration config = {.DefaultSize = ZMega(15)};
-    MemoryManager       manager;
+    MemoryManager       manager = {};
+    MemoryConfiguration config  = {.DefaultSize = ZGiga(1)};
     manager.Initialize(config);
-    auto arena  = &(manager.ArenaAllocator);
+    auto                arena      = &(manager.ArenaAllocator);
+
+    LoggerConfiguration logger_cfg = {};
+    Logger::Initialize(arena, logger_cfg);
 
     auto editor = ZPushStruct(arena, Tetragrama::Editor);
-    editor->Initialize(arena, json_config_file.c_str());
+    editor->Initialize(arena, editor_cfg_file.c_str());
     editor->Run();
 
+    editor->Dispose();
+    Logger::Dispose();
+
     manager.Shutdowm();
 
     return 0;

Tetragrama/Inputs/Keyboard.h

@@ -11,13 +11,13 @@ namespace Tetragrama::Inputs
         Keyboard(const char* name = "keyboard_device") : ZEngine::Windows::Inputs::IDevice(name) {}
         ~Keyboard() = default;
 
-        virtual bool IsKeyPressed(ZENGINE_KEYCODE key, const ZEngine::Helpers::Ref<ZEngine::Windows::CoreWindow>& window) const override
+        virtual bool IsKeyPressed(ZENGINE_KEYCODE key, ZEngine::Windows::CoreWindow* const window) const override
         {
             auto state = glfwGetKey(reinterpret_cast<GLFWwindow*>(window->GetNativeWindow()), (int) key);
             return state == GLFW_PRESS;
         }
 
-        virtual bool IsKeyReleased(ZENGINE_KEYCODE key, const ZEngine::Helpers::Ref<ZEngine::Windows::CoreWindow>& window) const override
+        virtual bool IsKeyReleased(ZENGINE_KEYCODE key, ZEngine::Windows::CoreWindow* const window) const override
         {
             auto state = glfwGetKey(reinterpret_cast<GLFWwindow*>(window->GetNativeWindow()), (int) key);
             return state == GLFW_RELEASE;

Tetragrama/Inputs/Mouse.h

@@ -11,19 +11,19 @@ namespace Tetragrama::Inputs
     public:
         Mouse(const char* name = "mouse_device") : ZEngine::Windows::Inputs::IDevice(name) {}
 
-        virtual bool IsKeyPressed(ZENGINE_KEYCODE key, const ZEngine::Helpers::Ref<ZEngine::Windows::CoreWindow>& window) const override
+        virtual bool IsKeyPressed(ZENGINE_KEYCODE key, ZEngine::Windows::CoreWindow* const window) const override
         {
 
             auto state = glfwGetMouseButton(reinterpret_cast<GLFWwindow*>(window->GetNativeWindow()), (int) key);
             return state == GLFW_PRESS;
         }
 
-        virtual bool IsKeyReleased(ZENGINE_KEYCODE key, const ZEngine::Helpers::Ref<ZEngine::Windows::CoreWindow>& window) const override
+        virtual bool IsKeyReleased(ZENGINE_KEYCODE key, ZEngine::Windows::CoreWindow* const window) const override
         {
             return !IsKeyPressed(key, window);
         }
 
-        std::array<double, 2> GetMousePosition(const ZEngine::Helpers::Ref<ZEngine::Windows::CoreWindow>& window) const
+        std::array<double, 2> GetMousePosition(ZEngine::Windows::CoreWindow* const window) const
         {
             double x, y;
             glfwGetCursorPos(reinterpret_cast<GLFWwindow*>(window->GetNativeWindow()), &x, &y);

Tetragrama/Layers/ImguiLayer.cpp

@@ -27,9 +27,10 @@ namespace Tetragrama::Layers
 
     void ImguiLayer::Initialize(ZEngine::Core::Memory::ArenaAllocator* arena)
     {
-        arena->CreateSubArena(ZMega(5), &LayerArena);
+        arena->CreateSubArena(ZMega(10), &LayerArena);
 
-        NodeHierarchies.init(&LayerArena, 10);
+        NodeHierarchies.init(&LayerArena, 10, 0);
+        NodeToRender.init(&LayerArena, 10);
 
         auto dockspace_cmp      = ZPushStructCtor(&LayerArena, Components::DockspaceUIComponent);
         auto scene_cmp          = ZPushStructCtor(&LayerArena, Components::SceneViewportUIComponent);
@@ -158,7 +159,6 @@ namespace Tetragrama::Layers
         int size = roots.size() + children.size() + siblings.size();
         if (NodeToRender.capacity() < size)
         {
-            NodeToRender.reserve(size);
         }
 
         for (auto r : roots)

ZEngine/ZEngine/Core/Containers/Array.h

@@ -20,6 +20,15 @@ namespace ZEngine::Core::Containers
         using iterator        = T*;
         using const_iterator  = const T*;
 
+        void init(Memory::ArenaAllocator* allocator, size_type initial_capacity, size_type initial_size)
+        {
+            m_allocator = allocator;
+            m_size      = initial_size;
+            m_capacity  = 0;
+            m_data      = nullptr;
+            reserve(std::max(initial_capacity, initial_size));
+        }
+
         void init(Memory::ArenaAllocator* allocator, size_type initial_capacity)
         {
             m_allocator = allocator;

ZEngine/ZEngine/Core/Memory/Allocator.cpp

@@ -85,8 +85,9 @@ namespace ZEngine::Core::Memory
     void ArenaAllocator::CreateSubArena(size_t size, ArenaAllocator* out_arena)
     {
         out_arena->m_memory          = reinterpret_cast<uint8_t*>(Allocate(size));
-        out_arena->m_total_size      = size;
-        out_arena->m_previous_offset = out_arena->m_current_offset = m_previous_offset;
+        out_arena->m_previous_offset = m_previous_offset;
+        out_arena->m_current_offset  = m_previous_offset;
+        out_arena->m_total_size      = m_previous_offset + size;
     }
 
     ArenaTemp BeginTempArena(ArenaAllocator* arena)

ZEngine/ZEngine/Engine.cpp

@@ -6,21 +6,24 @@
 
 namespace ZEngine
 {
-    static bool              s_request_terminate                                = false;
-    static std::shared_mutex g_mutex                                            = {};
-    static ZRawPtr(Windows::CoreWindow) g_current_window                        = nullptr;
-    static Helpers::Scope<Rendering::Renderers::GraphicRenderer> g_renderer     = Helpers::CreateScope<Rendering::Renderers::GraphicRenderer>();
-    static Helpers::Scope<Hardwares::VulkanDevice>               g_device       = Helpers::CreateScope<Hardwares::VulkanDevice>();
-    static ZEngine::Core::Memory::ArenaAllocator                 g_engine_arena = {};
-
-    void                                                         Engine::Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, const EngineConfiguration& engine_configuration, ZRawPtr(ZEngine::Windows::CoreWindow) const window)
+    static bool              s_request_terminate                     = false;
+    static std::shared_mutex g_mutex                                 = {};
+    static ZRawPtr(Windows::CoreWindow) g_current_window             = nullptr;
+    static ZRawPtr(Rendering::Renderers::GraphicRenderer) g_renderer = nullptr;
+    static ZRawPtr(Hardwares::VulkanDevice) g_device                 = nullptr;
+    static ZEngine::Core::Memory::ArenaAllocator g_engine_arena      = {};
+
+    void                                         Engine::Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, ZRawPtr(ZEngine::Windows::CoreWindow) const window)
     {
-        arena->CreateSubArena(ZMega(2), &g_engine_arena);
-
         g_current_window = window;
-        Logging::Logger::Initialize(engine_configuration.LoggerConfiguration);
-        g_device->Initialize(g_current_window);
-        g_renderer->Initialize(g_device.get());
+
+        arena->CreateSubArena(ZMega(800), &g_engine_arena);
+
+        g_device   = ZPushStructCtor(&g_engine_arena, Hardwares::VulkanDevice);
+        g_renderer = ZPushStructCtor(&g_engine_arena, Rendering::Renderers::GraphicRenderer);
+
+        g_device->Initialize(&g_engine_arena, window);
+        g_renderer->Initialize(g_device);
 
         ZENGINE_CORE_INFO("Engine initialized")
     }
@@ -33,18 +36,15 @@ namespace ZEngine
             g_current_window->Deinitialize();
         }
         g_renderer->Deinitialize();
-        g_renderer.reset();
 
         g_device->Deinitialize();
     }
 
     void Engine::Dispose()
     {
         s_request_terminate = false;
-
-        Logging::Logger::Dispose();
         g_device->Dispose();
-        g_device.reset();
+
         ZENGINE_CORE_INFO("Engine destroyed")
     }
 
@@ -93,7 +93,7 @@ namespace ZEngine
             auto buffer = g_device->GetCommandBuffer();
             {
 
-                g_current_window->Render(g_renderer.get(), buffer);
+                g_current_window->Render(g_renderer, buffer);
 
                 g_renderer->ImguiRenderer->DrawFrame(g_device->CurrentFrameIndex, buffer);
             }
@@ -107,7 +107,7 @@ namespace ZEngine
         }
     }
 
-    Helpers::Ref<Windows::CoreWindow> Engine::GetWindow()
+    Windows::CoreWindow* Engine::GetWindow()
     {
         std::shared_lock l(g_mutex);
         return g_current_window;

ZEngine/ZEngine/Engine.h

@@ -8,12 +8,12 @@ namespace ZEngine
 {
     struct Engine
     {
-        static void                              Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, const EngineConfiguration&, ZRawPtr(ZEngine::Windows::CoreWindow) const);
-        static void                              Run();
-        static Helpers::Ref<Windows::CoreWindow> GetWindow();
-        static void                              Deinitialize();
-        static void                              Dispose();
-        static bool                              OnEngineClosed(Event::EngineClosedEvent&);
+        static void                 Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, ZRawPtr(ZEngine::Windows::CoreWindow) const);
+        static void                 Run();
+        static Windows::CoreWindow* GetWindow();
+        static void                 Deinitialize();
+        static void                 Dispose();
+        static bool                 OnEngineClosed(Event::EngineClosedEvent&);
 
     private:
         Engine()              = delete;