more removal of vector

JeanPhilippeKernel · JeanPhilippeKernel · commit bfcbde04863e · 2025-04-06T14:18:57.000+01:00
diff --git a/Tetragrama/EditorWindow.cpp b/Tetragrama/EditorWindow.cpp
@@ -155,10 +155,10 @@ namespace Tetragrama
 
         ZENGINE_CORE_INFO("Windows layers initialized")
 
-        // Initialize Devices (Keyboard, Mouse)
+        // Initialize Input Devices (Keyboard, Mouse)
         ZEngine::Windows::Inputs::IDevice::Initialize(arena);
 
-        ZENGINE_CORE_INFO("Device initialized")
+        ZENGINE_CORE_INFO("Input devices initialized")
 
         glfwSetWindowUserPointer(m_native_window, &m_property);
 
diff --git a/ZEngine/ZEngine/Core/Memory/Allocator.cpp b/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)
diff --git a/ZEngine/ZEngine/Hardwares/VulkanDevice.cpp b/ZEngine/ZEngine/Hardwares/VulkanDevice.cpp
@@ -448,16 +448,21 @@ namespace ZEngine::Hardwares
                 TextureHandleToUpdates.Enqueue(tex_handle);
                 return;
             }
-            const auto&                       image_info            = texture->ImageBuffer->GetDescriptorImageInfo();
-            std::vector<VkWriteDescriptorSet> write_descriptor_sets = {};
-            write_descriptor_sets.reserve(WriteBindlessDescriptorSetRequests.size());
+            const auto& image_info = texture->ImageBuffer->GetDescriptorImageInfo();
 
-            for (auto& req : WriteBindlessDescriptorSetRequests)
+            auto        scratch    = ZGetScratch(Arena);
             {
-                write_descriptor_sets.push_back(VkWriteDescriptorSet{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .pNext = nullptr, .dstSet = req.DstSet, .dstBinding = req.Binding, .dstArrayElement = (uint32_t) tex_handle.Index, .descriptorCount = 1, .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &(image_info), .pBufferInfo = nullptr, .pTexelBufferView = nullptr});
-            }
+                Array<VkWriteDescriptorSet> write_descriptor_sets = {};
+                write_descriptor_sets.init(scratch.Arena, WriteBindlessDescriptorSetRequests.size());
+
+                for (auto& req : WriteBindlessDescriptorSetRequests)
+                {
+                    write_descriptor_sets.push(VkWriteDescriptorSet{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .pNext = nullptr, .dstSet = req.DstSet, .dstBinding = req.Binding, .dstArrayElement = (uint32_t) tex_handle.Index, .descriptorCount = 1, .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &(image_info), .pBufferInfo = nullptr, .pTexelBufferView = nullptr});
+                }
 
-            vkUpdateDescriptorSets(LogicalDevice, write_descriptor_sets.size(), write_descriptor_sets.data(), 0, nullptr);
+                vkUpdateDescriptorSets(LogicalDevice, write_descriptor_sets.size(), write_descriptor_sets.data(), 0, nullptr);
+            }
+            ZReleaseScratch(scratch);
         }
 
         Textures::TextureHandle tex_to_dispose = {};
@@ -1342,6 +1347,7 @@ namespace ZEngine::Hardwares
      */
     CommandBuffer::CommandBuffer(Hardwares::VulkanDevice* device, VkCommandPool command_pool, Rendering::QueueType type, bool one_time_usage) : Device(device), QueueType(type), m_command_pool(command_pool)
     {
+        Device->Arena->CreateSubArena(ZKilo(120), &LocalArena);
         Create();
     }
 
@@ -1466,15 +1472,17 @@ namespace ZEngine::Hardwares
     {
         ZENGINE_VALIDATE_ASSERT(m_command_buffer != nullptr, "Command buffer can't be null")
 
-        const auto&               render_pass_spec = render_pass->Specification;
-        const uint32_t            width            = render_pass->GetRenderAreaWidth();
-        const uint32_t            height           = render_pass->GetRenderAreaHeight();
+        const auto&         render_pass_spec = render_pass->Specification;
+        const uint32_t      width            = render_pass->GetRenderAreaWidth();
+        const uint32_t      height           = render_pass->GetRenderAreaHeight();
 
-        std::vector<VkClearValue> clear_values     = {};
+        auto                scratch          = ZGetScratch(&LocalArena);
 
+        Array<VkClearValue> clear_values     = {};
+        clear_values.init(scratch.Arena, 5);
         if (render_pass_spec.SwapchainAsRenderTarget)
         {
-            clear_values.push_back(m_clear_value[0]);
+            clear_values.push(m_clear_value[0]);
         }
         else
         {
@@ -1484,10 +1492,10 @@ namespace ZEngine::Hardwares
                 auto texture = Device->GlobalTextures.Access(handle);
                 if (texture->IsDepthTexture)
                 {
-                    clear_values.push_back(m_clear_value[1]);
+                    clear_values.push(m_clear_value[1]);
                     continue;
                 }
-                clear_values.push_back(m_clear_value[0]);
+                clear_values.push(m_clear_value[0]);
             }
 
             for (const auto& handle : spec.ExternalOutputs)
@@ -1496,10 +1504,10 @@ namespace ZEngine::Hardwares
 
                 if (texture->IsDepthTexture)
                 {
-                    clear_values.push_back(m_clear_value[1]);
+                    clear_values.push(m_clear_value[1]);
                     continue;
                 }
-                clear_values.push_back(m_clear_value[0]);
+                clear_values.push(m_clear_value[0]);
             }
         }
 
@@ -1532,6 +1540,8 @@ namespace ZEngine::Hardwares
         vkCmdBindPipeline(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, render_pass->Pipeline->GetHandle());
 
         m_active_render_pass = render_pass;
+
+        ZReleaseScratch(scratch);
     }
 
     void CommandBuffer::EndRenderPass()
@@ -1550,18 +1560,21 @@ namespace ZEngine::Hardwares
 
         if (auto render_pass = m_active_render_pass)
         {
-            auto                         pipeline           = render_pass->Pipeline;
-            auto                         pipeline_layout    = pipeline->GetPipelineLayout();
-            auto                         shader             = pipeline->GetShader();
-            const auto&                  descriptor_set_map = shader->GetDescriptorSetMap();
+            auto                   pipeline           = render_pass->Pipeline;
+            auto                   pipeline_layout    = pipeline->GetPipelineLayout();
+            auto                   shader             = pipeline->GetShader();
+            const auto&            descriptor_set_map = shader->GetDescriptorSetMap();
 
-            std::vector<VkDescriptorSet> frame_sets         = {};
+            auto                   scratch            = ZGetScratch(&LocalArena);
+            Array<VkDescriptorSet> frame_sets         = {};
+            frame_sets.init(scratch.Arena, 5);
             for (auto& [_, sets] : descriptor_set_map)
             {
-                frame_sets.emplace_back(sets[frame_index]);
+                frame_sets.push(sets[frame_index]);
             }
 
             vkCmdBindDescriptorSets(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, frame_sets.size(), frame_sets.data(), 0, nullptr);
+            ZReleaseScratch(scratch);
         }
     }
 
diff --git a/ZEngine/ZEngine/Hardwares/VulkanDevice.h b/ZEngine/ZEngine/Hardwares/VulkanDevice.h
@@ -560,7 +560,8 @@ namespace ZEngine::Hardwares
         ~CommandBuffer();
 
         Rendering::QueueType              QueueType;
-        Hardwares::VulkanDevice*          Device = nullptr;
+        Hardwares::VulkanDevice*          Device     = nullptr;
+        Core::Memory::ArenaAllocator      LocalArena = {};
 
         void                              Create();
         void                              Free();
diff --git a/ZEngine/ZEngine/Windows/Inputs/IDevice.h b/ZEngine/ZEngine/Windows/Inputs/IDevice.h
@@ -38,15 +38,9 @@ namespace ZEngine::Windows::Inputs
             return reinterpret_cast<T*>(pair.first->second);
         }
 
-        virtual bool IsKeyPressed(ZENGINE_KEYCODE key, Windows::CoreWindow* const window) const
-        {
-            return false;
-        }
+        virtual bool        IsKeyPressed(ZENGINE_KEYCODE key, Windows::CoreWindow* const window) const  = 0;
 
-        virtual bool IsKeyReleased(ZENGINE_KEYCODE key, Windows::CoreWindow* const window) const
-        {
-            return false;
-        }
+        virtual bool        IsKeyReleased(ZENGINE_KEYCODE key, Windows::CoreWindow* const window) const = 0;
 
         virtual const char* GetName() const
         {

Original file line number	Diff line number	Diff line change
`@@ -85,8 +85,9 @@ namespace ZEngine::Core::Memory`
`85`	`85`	`void ArenaAllocator::CreateSubArena(size_t size, ArenaAllocator* out_arena)`
`86`	`86`	`{`
`87`	`87`	`out_arena->m_memory = reinterpret_cast<uint8_t*>(Allocate(size));`
`88`		`- out_arena->m_total_size = size;`
`89`		`- out_arena->m_previous_offset = out_arena->m_current_offset = m_previous_offset;`
	`88`	`+ out_arena->m_previous_offset = m_previous_offset;`
	`89`	`+ out_arena->m_current_offset = m_previous_offset;`
	`90`	`+ out_arena->m_total_size = m_previous_offset + size;`
`90`	`91`	`}`
`91`	`92`
`92`	`93`	`ArenaTemp BeginTempArena(ArenaAllocator* arena)`
Original file line number	Diff line number	Diff line change
`@@ -448,16 +448,21 @@ namespace ZEngine::Hardwares`
`448`	`448`	`TextureHandleToUpdates.Enqueue(tex_handle);`
`449`	`449`	`return;`
`450`	`450`	`}`
`451`		`- const auto& image_info = texture->ImageBuffer->GetDescriptorImageInfo();`
`452`		`- std::vector<VkWriteDescriptorSet> write_descriptor_sets = {};`
`453`		`- write_descriptor_sets.reserve(WriteBindlessDescriptorSetRequests.size());`
	`451`	`+ const auto& image_info = texture->ImageBuffer->GetDescriptorImageInfo();`
`454`	`452`
`455`		`- for (auto& req : WriteBindlessDescriptorSetRequests)`
	`453`	`+ auto scratch = ZGetScratch(Arena);`
`456`	`454`	`{`
`457`		`- write_descriptor_sets.push_back(VkWriteDescriptorSet{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .pNext = nullptr, .dstSet = req.DstSet, .dstBinding = req.Binding, .dstArrayElement = (uint32_t) tex_handle.Index, .descriptorCount = 1, .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &(image_info), .pBufferInfo = nullptr, .pTexelBufferView = nullptr});`
`458`		`- }`
	`455`	`+ Array<VkWriteDescriptorSet> write_descriptor_sets = {};`
	`456`	`+ write_descriptor_sets.init(scratch.Arena, WriteBindlessDescriptorSetRequests.size());`
	`457`	`+`
	`458`	`+ for (auto& req : WriteBindlessDescriptorSetRequests)`
	`459`	`+ {`
	`460`	`+ write_descriptor_sets.push(VkWriteDescriptorSet{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .pNext = nullptr, .dstSet = req.DstSet, .dstBinding = req.Binding, .dstArrayElement = (uint32_t) tex_handle.Index, .descriptorCount = 1, .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &(image_info), .pBufferInfo = nullptr, .pTexelBufferView = nullptr});`
	`461`	`+ }`
`459`	`462`
`460`		`- vkUpdateDescriptorSets(LogicalDevice, write_descriptor_sets.size(), write_descriptor_sets.data(), 0, nullptr);`
	`463`	`+ vkUpdateDescriptorSets(LogicalDevice, write_descriptor_sets.size(), write_descriptor_sets.data(), 0, nullptr);`
	`464`	`+ }`
	`465`	`+ ZReleaseScratch(scratch);`
`461`	`466`	`}`
`462`	`467`
`463`	`468`	`Textures::TextureHandle tex_to_dispose = {};`
`@@ -1342,6 +1347,7 @@ namespace ZEngine::Hardwares`
`1342`	`1347`	`*/`
`1343`	`1348`	`CommandBuffer::CommandBuffer(Hardwares::VulkanDevice* device, VkCommandPool command_pool, Rendering::QueueType type, bool one_time_usage) : Device(device), QueueType(type), m_command_pool(command_pool)`
`1344`	`1349`	`{`
	`1350`	`+ Device->Arena->CreateSubArena(ZKilo(120), &LocalArena);`
`1345`	`1351`	`Create();`
`1346`	`1352`	`}`
`1347`	`1353`
`@@ -1466,15 +1472,17 @@ namespace ZEngine::Hardwares`
`1466`	`1472`	`{`
`1467`	`1473`	`ZENGINE_VALIDATE_ASSERT(m_command_buffer != nullptr, "Command buffer can't be null")`
`1468`	`1474`
`1469`		`- const auto& render_pass_spec = render_pass->Specification;`
`1470`		`- const uint32_t width = render_pass->GetRenderAreaWidth();`
`1471`		`- const uint32_t height = render_pass->GetRenderAreaHeight();`
	`1475`	`+ const auto& render_pass_spec = render_pass->Specification;`
	`1476`	`+ const uint32_t width = render_pass->GetRenderAreaWidth();`
	`1477`	`+ const uint32_t height = render_pass->GetRenderAreaHeight();`
`1472`	`1478`
`1473`		`- std::vector<VkClearValue> clear_values = {};`
	`1479`	`+ auto scratch = ZGetScratch(&LocalArena);`
`1474`	`1480`
	`1481`	`+ Array<VkClearValue> clear_values = {};`
	`1482`	`+ clear_values.init(scratch.Arena, 5);`
`1475`	`1483`	`if (render_pass_spec.SwapchainAsRenderTarget)`
`1476`	`1484`	`{`
`1477`		`- clear_values.push_back(m_clear_value[0]);`
	`1485`	`+ clear_values.push(m_clear_value[0]);`
`1478`	`1486`	`}`
`1479`	`1487`	`else`
`1480`	`1488`	`{`
`@@ -1484,10 +1492,10 @@ namespace ZEngine::Hardwares`
`1484`	`1492`	`auto texture = Device->GlobalTextures.Access(handle);`
`1485`	`1493`	`if (texture->IsDepthTexture)`
`1486`	`1494`	`{`
`1487`		`- clear_values.push_back(m_clear_value[1]);`
	`1495`	`+ clear_values.push(m_clear_value[1]);`
`1488`	`1496`	`continue;`
`1489`	`1497`	`}`
`1490`		`- clear_values.push_back(m_clear_value[0]);`
	`1498`	`+ clear_values.push(m_clear_value[0]);`
`1491`	`1499`	`}`
`1492`	`1500`
`1493`	`1501`	`for (const auto& handle : spec.ExternalOutputs)`
`@@ -1496,10 +1504,10 @@ namespace ZEngine::Hardwares`
`1496`	`1504`
`1497`	`1505`	`if (texture->IsDepthTexture)`
`1498`	`1506`	`{`
`1499`		`- clear_values.push_back(m_clear_value[1]);`
	`1507`	`+ clear_values.push(m_clear_value[1]);`
`1500`	`1508`	`continue;`
`1501`	`1509`	`}`
`1502`		`- clear_values.push_back(m_clear_value[0]);`
	`1510`	`+ clear_values.push(m_clear_value[0]);`
`1503`	`1511`	`}`
`1504`	`1512`	`}`
`1505`	`1513`
`@@ -1532,6 +1540,8 @@ namespace ZEngine::Hardwares`
`1532`	`1540`	`vkCmdBindPipeline(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, render_pass->Pipeline->GetHandle());`
`1533`	`1541`
`1534`	`1542`	`m_active_render_pass = render_pass;`
	`1543`	`+`
	`1544`	`+ ZReleaseScratch(scratch);`
`1535`	`1545`	`}`
`1536`	`1546`
`1537`	`1547`	`void CommandBuffer::EndRenderPass()`
`@@ -1550,18 +1560,21 @@ namespace ZEngine::Hardwares`
`1550`	`1560`
`1551`	`1561`	`if (auto render_pass = m_active_render_pass)`
`1552`	`1562`	`{`
`1553`		`- auto pipeline = render_pass->Pipeline;`
`1554`		`- auto pipeline_layout = pipeline->GetPipelineLayout();`
`1555`		`- auto shader = pipeline->GetShader();`
`1556`		`- const auto& descriptor_set_map = shader->GetDescriptorSetMap();`
	`1563`	`+ auto pipeline = render_pass->Pipeline;`
	`1564`	`+ auto pipeline_layout = pipeline->GetPipelineLayout();`
	`1565`	`+ auto shader = pipeline->GetShader();`
	`1566`	`+ const auto& descriptor_set_map = shader->GetDescriptorSetMap();`
`1557`	`1567`
`1558`		`- std::vector<VkDescriptorSet> frame_sets = {};`
	`1568`	`+ auto scratch = ZGetScratch(&LocalArena);`
	`1569`	`+ Array<VkDescriptorSet> frame_sets = {};`
	`1570`	`+ frame_sets.init(scratch.Arena, 5);`
`1559`	`1571`	`for (auto& [_, sets] : descriptor_set_map)`
`1560`	`1572`	`{`
`1561`		`- frame_sets.emplace_back(sets[frame_index]);`
	`1573`	`+ frame_sets.push(sets[frame_index]);`
`1562`	`1574`	`}`
`1563`	`1575`
`1564`	`1576`	`vkCmdBindDescriptorSets(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, frame_sets.size(), frame_sets.data(), 0, nullptr);`
	`1577`	`+ ZReleaseScratch(scratch);`
`1565`	`1578`	`}`
`1566`	`1579`	`}`
`1567`	`1580`