fix: alot of stuff changed. Mostly bugfixxes / architechture changes

destrum/src/Graphics/Pipelines/SkinningPipeline.cpp

@@ -3,6 +3,7 @@
 #include "destrum/FS/AssetFS.h"
 #include "../../../include/destrum/Graphics/Caches/MeshCache.h"
 #include "destrum/Graphics/MeshDrawCommand.h"
+#include "destrum/Graphics/Util.h"
 
 #include <array>
 #include <cassert>
@@ -10,7 +11,10 @@
 #include <cstdint>
 #include <stdexcept>
 
+#include "volk.h"
+
 void SkinningPipeline::init(GfxDevice& gfxDevice) {
+    try {
     const auto& device = gfxDevice.getDevice();
 
     const auto pushConstant = VkPushConstantRange{
@@ -26,7 +30,7 @@ void SkinningPipeline::init(GfxDevice& gfxDevice) {
     pipelineLayoutInfo.pushConstantRangeCount = 1;
     pipelineLayoutInfo.pPushConstantRanges = pushConstants.data();
 
-    if (vkCreatePipelineLayout(device.device, &pipelineLayoutInfo, nullptr, &m_pipelineLayout) != VK_SUCCESS) {
+    if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &m_pipelineLayout) != VK_SUCCESS) {
         throw std::runtime_error("Could not make pipeline layout");
     }
 
@@ -42,21 +46,31 @@ void SkinningPipeline::init(GfxDevice& gfxDevice) {
         pipelineConfig
     );
 
-    for (std::size_t i = 0; i < FRAMES_IN_FLIGHT; ++i) {
+        for (std::size_t i = 0; i < FRAMES_IN_FLIGHT; ++i) {
         auto& jointMatricesBuffer = framesData[i].jointMatricesBuffer;
         jointMatricesBuffer.capacity = MAX_JOINT_MATRICES;
         jointMatricesBuffer.buffer = gfxDevice.createBuffer(
             MAX_JOINT_MATRICES * sizeof(glm::mat4),
-            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT);
+            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+            VMA_MEMORY_USAGE_CPU_TO_GPU);
+        }
+    } catch (...) {
+        cleanup(gfxDevice);
+        throw;
     }
 }
 
 void SkinningPipeline::cleanup(GfxDevice& gfxDevice) {
     for (auto& frame : framesData) {
         gfxDevice.destroyBuffer(frame.jointMatricesBuffer.buffer);
+        frame.jointMatricesBuffer.buffer = {};
+        frame.jointMatricesBuffer.size = 0;
     }
 
-    vkDestroyPipelineLayout(gfxDevice.getDevice().device, m_pipelineLayout, nullptr);
+    if (m_pipelineLayout != VK_NULL_HANDLE && gfxDevice.getDevice() != VK_NULL_HANDLE) {
+        vkDestroyPipelineLayout(gfxDevice.getDevice(), m_pipelineLayout, nullptr);
+    }
+    m_pipelineLayout = VK_NULL_HANDLE;
     skinningPipeline.reset();
 }
 
@@ -94,31 +108,45 @@ void SkinningPipeline::doSkinning(VkCommandBuffer cmd,
 
     vkCmdDispatch(cmd, groupSizeX, 1, 1);
 
-    // Required before the graphics pass reads skinnedVertexBuffer as a vertex buffer.
-    // Without this, the draw can see stale/partial data from before the compute dispatch.
-    VkBufferMemoryBarrier skinnedVertexBarrier{};
-    skinnedVertexBarrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
-    skinnedVertexBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
-    skinnedVertexBarrier.dstAccessMask = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
-    skinnedVertexBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-    skinnedVertexBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-    skinnedVertexBarrier.buffer = dc.skinnedMesh->skinnedVertexBuffer.buffer;
-    skinnedVertexBarrier.offset = 0;
-    skinnedVertexBarrier.size = VK_WHOLE_SIZE;
+    const VkBufferMemoryBarrier2 skinnedVertexBarrier{
+        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
+        .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
+        .srcAccessMask = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
+        .dstStageMask = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT,
+        .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .buffer = dc.skinnedMesh->skinnedVertexBuffer.buffer,
+        .offset = 0,
+        .size = VK_WHOLE_SIZE,
+    };
 
-    vkCmdPipelineBarrier(cmd,
-                         VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                         VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
-                         0,
-                         0, nullptr,
-                         1, &skinnedVertexBarrier,
-                         0, nullptr);
+    const VkDependencyInfo dependencyInfo{
+        .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
+        .bufferMemoryBarrierCount = 1,
+        .pBufferMemoryBarriers = &skinnedVertexBarrier,
+    };
+    vkCmdPipelineBarrier2(cmd, &dependencyInfo);
 }
 
 void SkinningPipeline::beginDrawing(std::size_t frameIndex) {
     getCurrentFrameData(frameIndex).jointMatricesBuffer.clear();
 }
 
+void SkinningPipeline::flushCurrentFrame(
+    VkCommandBuffer cmd,
+    GfxDevice& gfxDevice,
+    std::size_t frameIndex)
+{
+    auto& buffer = getCurrentFrameData(frameIndex).jointMatricesBuffer.buffer;
+    gfxDevice.getMemoryManager().flushAllocation(buffer, 0, VK_WHOLE_SIZE);
+    vkutil::bufferHostWriteToShaderReadBarrier(
+        cmd,
+        buffer.buffer,
+        0,
+        static_cast<VkDeviceSize>(MAX_JOINT_MATRICES * sizeof(glm::mat4)));
+}
+
 std::size_t SkinningPipeline::appendJointMatrices(std::span<const glm::mat4> jointMatrices,
                                                   std::size_t frameIndex) {
     auto& jointMatricesBuffer = getCurrentFrameData(frameIndex).jointMatricesBuffer;