vulkan2d fixes

implementations/Crafter.Graphics-Rendertarget.cpp

@@ -30,24 +30,6 @@ import :RenderingElement2DVulkan;
 import std;
 using namespace Crafter;
 
-RendertargetVulkan::RendertargetVulkan(std::uint16_t sizeX, std::uint16_t sizeY, std::vector<RenderingElement2DVulkanBase*>&& elementss) : RendertargetBase(sizeX, sizeY), elements(std::move(elementss)) {
-    for(Transform2D* child : transform.children) {
-        SetOrderResursive(child);
-    }
-    for(std::uint8_t frame = 0; frame < Window::numFrames; frame++) {
-        transformBuffer[frame].Resize(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, elements.size()+1);
-        RenderingElement2DVulkanTransformInfo* val =  reinterpret_cast<RenderingElement2DVulkanTransformInfo*>(reinterpret_cast<char*>(transformBuffer[frame].value) + sizeof(RenderingElement2DVulkanTransformInfo));
-        std::uint16_t* sizePtr =  reinterpret_cast<std::uint16_t*>(transformBuffer[frame].value);
-        *sizePtr = static_cast<std::uint16_t>(elements.size());
-        for(std::uint16_t i = 0; i < elements.size(); i++) {
-            elements[i]->ScaleElement(transform);
-            val[i].scaled = elements[i]->scaled;
-            val[i].bufferX = elements[i]->bufferX;
-            val[i].bufferY = elements[i]->bufferY;
-        }
-        transformBuffer[frame].FlushDevice();
-    }
-}
 
 RendertargetVulkan::RendertargetVulkan(std::uint16_t sizeX, std::uint16_t sizeY) : RendertargetBase(sizeX, sizeY) {
 
@@ -59,18 +41,14 @@ void RendertargetVulkan::UpdateElements() {
     for(Transform2D* child : transform.children) {
         SetOrderResursive(child);
     }
-    for(std::uint16_t i = 0; i < elements.size(); i++) {
-        elements[i]->ScaleElement(transform);
-    }
 }
 
-void RendertargetVulkan::UpdateBuffer(std::uint8_t frame) {
+void RendertargetVulkan::CreateBuffer(std::uint8_t frame) {
     transformBuffer[frame].Resize(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, elements.size()+1);
     RenderingElement2DVulkanTransformInfo* val =  reinterpret_cast<RenderingElement2DVulkanTransformInfo*>(reinterpret_cast<char*>(transformBuffer[frame].value) + sizeof(RenderingElement2DVulkanTransformInfo));
     std::uint16_t* sizePtr =  reinterpret_cast<std::uint16_t*>(transformBuffer[frame].value);
     *sizePtr = static_cast<std::uint16_t>(elements.size());
     for(std::uint16_t i = 0; i < elements.size(); i++) {
-        val[i].scaled = elements[i]->scaled;
         val[i].bufferX = elements[i]->bufferX;
         val[i].bufferY = elements[i]->bufferY;
     }
@@ -84,6 +62,7 @@ void RendertargetVulkan::ReorderBuffer(std::uint8_t frame) {
         val[i].bufferX = elements[i]->bufferX;
         val[i].bufferY = elements[i]->bufferY;
     }
+    transformBuffer[frame].FlushDevice();
 }
 
 void RendertargetVulkan::WriteDescriptors(std::span<VkResourceDescriptorInfoEXT> infos, std::span<VkHostAddressRangeEXT> ranges, std::uint16_t start, std::uint32_t bufferOffset, DescriptorHeapVulkan& descriptorHeap) {

interfaces/Crafter.Graphics-RenderingElement2DVulkan.cppm

@@ -50,13 +50,16 @@ export namespace Crafter {
         }
     };
 
-    template<bool Owning, bool Mapped>
+    template<bool Owning, bool Mapped, bool Single = false>
     struct RenderingElement2DVulkan : RenderingElement2DVulkanBase {
-        RenderingElement2DVulkan(Anchor2D anchor, RendertargetBase& target, Transform2D& parent, bool single = false) requires(Owning) : RenderingElement2DVulkanBase(anchor) {
+        RenderingElement2DVulkan(Anchor2D anchor) : RenderingElement2DVulkanBase(anchor) {
+
+        }
+        RenderingElement2DVulkan(Anchor2D anchor, RendertargetBase& target, Transform2D& parent) requires(Owning) : RenderingElement2DVulkanBase(anchor) {
             GetScale(target, parent);
             this->bufferX = this->scaled.size.x;
             this->bufferY = this->scaled.size.y;
-            if(single) {
+            if(Single) {
                 buffers[0] = new VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>(); 
                 static_cast<VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>*>(buffers[0])->Create(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, bufferX * bufferY);
                 for(std::uint8_t i = 1; i < Window::numFrames; i++) {
@@ -70,8 +73,8 @@ export namespace Crafter {
             }
         }
 
-        RenderingElement2DVulkan(Anchor2D anchor, std::uint16_t bufferX, std::uint16_t bufferY, bool single = false) requires(Owning) : RenderingElement2DVulkanBase(anchor, bufferX, bufferY) {
+        RenderingElement2DVulkan(Anchor2D anchor, std::uint16_t bufferX, std::uint16_t bufferY) requires(Owning) : RenderingElement2DVulkanBase(anchor, bufferX, bufferY) {
-            if(single) {
+            if constexpr(Single) {
                 buffers[0] = new VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>(); 
                 static_cast<VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>*>(buffers[0])->Create(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, bufferX * bufferY);
                 for(std::uint8_t i = 1; i < Window::numFrames; i++) {
@@ -89,11 +92,11 @@ export namespace Crafter {
 
         }
 
-        RenderingElement2DVulkan(Anchor2D anchor, const std::filesystem::path& assetPath, bool single = false) requires(Owning && Mapped) : RenderingElement2DVulkanBase(anchor) {
+        RenderingElement2DVulkan(Anchor2D anchor, const std::filesystem::path& assetPath) requires(Owning && Mapped) : RenderingElement2DVulkanBase(anchor) {
             TextureAssetInfo info = TextureAsset<_Float16>::LoadInfo(assetPath);
             this->bufferX = info.sizeX;
             this->bufferY = info.sizeY;
-            if(single) {
+            if constexpr(Single) {
                 buffers[0] = new VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>(); 
                 static_cast<VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>*>(buffers[0])->Create(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, bufferX * bufferY);
                 for(std::uint8_t i = 1; i < Window::numFrames; i++) {
@@ -114,15 +117,107 @@ export namespace Crafter {
 
         ~RenderingElement2DVulkan() {
             if constexpr(Owning) {
+                if constexpr(Single) {
+                    delete static_cast<VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>*>(buffers[0]);
+                } else {
                     for(VulkanBufferBase* buffer : buffers) {
                         delete static_cast<VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>*>(buffer);
                     }
                 }
             }
+        }
     
         RenderingElement2DVulkan(RenderingElement2DVulkan&) = delete;
         RenderingElement2DVulkan& operator=(RenderingElement2DVulkan&) = delete;
 
+        void CreateBuffer(std::uint16_t bufferX, std::uint16_t bufferY) requires(Owning) {
+            this->bufferX = this->scaled.size.x;
+            this->bufferY = this->scaled.size.y;
+            if constexpr(Single) {
+                buffers[0] = new VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>(); 
+                static_cast<VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>*>(buffers[0])->Create(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, bufferX * bufferY);
+                for(std::uint8_t i = 1; i < Window::numFrames; i++) {
+                    buffers[i] = buffers[0]; 
+                }
+            } else {
+                for(std::uint8_t i = 0; i < Window::numFrames; i++) {
+                    buffers[i] = new VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>(); 
+                    static_cast<VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>*>(buffers[i])->Create(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, bufferX * bufferY);
+                }
+            }
+        }
+
+        void ResizeBuffer(RendertargetVulkan& window, DescriptorHeapVulkan& descriptorHeap, std::uint16_t bufferOffset, std::uint16_t bufferX, std::uint16_t bufferY) requires(Owning) {
+            if constexpr(Single) {
+                static_cast<VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>*>(buffers[0])->Resize(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, bufferX * bufferY);
+            } else {
+                for(VulkanBufferBase* buffer : buffers) {
+                    delete static_cast<VulkanBuffer<Vector<_Float16, 4, 4>, Mapped>*>(buffer)->Resize(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, bufferX * bufferY);
+                }
+            }
+            this->bufferX = bufferX;
+            this->bufferY = bufferY;
+            for(std::uint8_t frame = 0; frame < Window::numFrames; frame++) {
+                RenderingElement2DVulkanTransformInfo* val = reinterpret_cast<RenderingElement2DVulkanTransformInfo*>(reinterpret_cast<char*>(window.transformBuffer[frame].value) + sizeof(RenderingElement2DVulkanTransformInfo));
+                val[index].bufferX = this->bufferX;
+                val[index].bufferY = this->bufferY;
+                window.transformBuffer[frame].FlushDevice();
+            }
+
+            VkHostAddressRangeEXT ranges[3] = {
+                {
+                    .address = descriptorHeap.resourceHeap[0].value + bufferOffset + Device::descriptorHeapProperties.bufferDescriptorSize * index,
+                    .size = Device::descriptorHeapProperties.bufferDescriptorSize
+                },
+                {
+                    .address = descriptorHeap.resourceHeap[1].value + bufferOffset + Device::descriptorHeapProperties.bufferDescriptorSize * index,
+                    .size = Device::descriptorHeapProperties.bufferDescriptorSize
+                },
+                {
+                    .address = descriptorHeap.resourceHeap[2].value + bufferOffset + Device::descriptorHeapProperties.bufferDescriptorSize * index,
+                    .size = Device::descriptorHeapProperties.bufferDescriptorSize
+                },
+            };
+
+            VkDeviceAddressRangeKHR bufferRanges[3] {
+                {
+                    .address = buffers[0]->address,
+                    .size = buffers[0]->size
+                },
+                {
+                    .address = buffers[1]->address,
+                    .size = buffers[1]->size
+                },
+                {
+                    .address = buffers[2]->address,
+                    .size = buffers[2]->size
+                },
+            };
+
+            VkResourceDescriptorInfoEXT infos[3] = {
+                {
+                    .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
+                    .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+                    .data = { .pAddressRange = &bufferRanges[0]}
+                },
+                {
+                    .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
+                    .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+                    .data = { .pAddressRange = &bufferRanges[1]}
+                },
+                {
+                    .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
+                    .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+                    .data = { .pAddressRange = &bufferRanges[2]}
+                },
+            };
+
+            Device::vkWriteResourceDescriptorsEXT(Device::device, 3, infos, ranges);
+            for(std::uint8_t i = 0; i < Window::numFrames; i++) {
+                descriptorHeap.resourceHeap[i].FlushDevice();
+            }
+        }
+
         void UpdatePosition(RendertargetBase& window2, Transform2D& parent) override {
             RendertargetVulkan& window = static_cast<RendertargetVulkan&>(window2);
             this->ScaleElement(parent);

interfaces/Crafter.Graphics-Rendertarget.cppm

@@ -69,10 +69,9 @@ export namespace Crafter {
         VulkanBuffer<RenderingElement2DVulkanTransformInfo, true> transformBuffer[3];
 
         RendertargetVulkan() = default;
-        RendertargetVulkan(std::uint16_t sizeX, std::uint16_t sizeY, std::vector<RenderingElement2DVulkanBase*>&& elements);
         RendertargetVulkan(std::uint16_t sizeX, std::uint16_t sizeY);
         void UpdateElements();
-        void UpdateBuffer(std::uint8_t frame);
+        void CreateBuffer(std::uint8_t frame);
         void ReorderBuffer(std::uint8_t frame);
         void WriteDescriptors(std::span<VkResourceDescriptorInfoEXT> infos, std::span<VkHostAddressRangeEXT> ranges, std::uint16_t start, std::uint32_t bufferOffset, DescriptorHeapVulkan& descriptorHeap);
         void SetOrderResursive(Transform2D* elementTransform);