Adding cached depth renderpass

2024-05-30 16:56:22 +02:00
parent 4b6022237b
commit f278afad66
20 changed files with 908 additions and 677 deletions
@@ -42,7 +42,7 @@ BasePass::BasePass(Gfx::PGraphics graphics, PScene scene)

    if (graphics->supportMeshShading())
    {
-        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "BasePass", "MeshletPass", true, true, "BasePass", true, true, "ViewCullingTask");
+        graphics->getShaderCompiler()->registerRenderPass(basePassLayout, "BasePass", "MeshletPass", true, true, "BasePass", true, true, "DrawListTask");
    }
    else
    {
@@ -91,7 +91,7 @@ void BasePass::render()
    Gfx::ShaderPermutation permutation;
    if (graphics->supportMeshShading())
    {
-        permutation.setTaskFile("ViewCullingTask");
+        permutation.setTaskFile("DrawListTask");
        permutation.setMeshFile("MeshletPass");
    }
    else
@@ -140,7 +140,7 @@ void BasePass::render()
                        .depthCompareOp = Gfx::SE_COMPARE_OP_GREATER_OR_EQUAL,
                    },
                    .colorBlend = {
-                        .attachmentCount = 2,
+                        .attachmentCount = 1,
                    },
                };
                Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
@@ -160,7 +160,7 @@ void BasePass::render()
                        .depthCompareOp = Gfx::SE_COMPARE_OP_GREATER_OR_EQUAL,
                    },
                    .colorBlend = {
-                        .attachmentCount = 2,
+                        .attachmentCount = 1,
                    },
                };
                Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
@@ -182,11 +182,10 @@ void BasePass::render()
                else
                {
                    command->bindIndexBuffer(vertexData->getIndexBuffer());
-                    uint32 inst = drawCall.offsets.instanceOffset;
                    for (const auto& meshData : drawCall.instanceMeshData)
                    {
                        // all meshlets of a mesh share the same indices offset
-                        command->drawIndexed(meshData.numIndices, 1, meshData.firstIndex, vertexData->getIndicesOffset(meshData.meshletOffset), inst++);
+                        command->drawIndexed(meshData.numIndices, 1, meshData.firstIndex, vertexData->getIndicesOffset(meshData.meshletOffset), 0);
                    }
                }
            }
@@ -208,17 +207,6 @@ void BasePass::publishOutputs()
        Gfx::SE_IMAGE_LAYOUT_UNDEFINED, Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
        Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
    resources->registerRenderPassOutput("BASEPASS_COLOR", colorAttachment);
-
-    meshletIdTexture = graphics->createTexture2D(TextureCreateInfo{
-        .format = Gfx::SE_FORMAT_R32_UINT,
-        .width = viewport->getWidth(),
-        .height = viewport->getHeight(),
-        .usage = Gfx::SE_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | Gfx::SE_IMAGE_USAGE_STORAGE_BIT,
-        });
-    meshletIdAttachment = Gfx::RenderTargetAttachment(meshletIdTexture,
-        Gfx::SE_IMAGE_LAYOUT_UNDEFINED, Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-        Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
-    resources->registerRenderPassOutput("BASEPASS_MESHLETID", meshletIdAttachment);
 }

 void BasePass::createRenderPass()
@@ -228,7 +216,7 @@ void BasePass::createRenderPass()
    depthAttachment.setInitialLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL);
    depthAttachment.setFinalLayout(Gfx::SE_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
    Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
-        .colorAttachments = { colorAttachment, meshletIdAttachment },
+        .colorAttachments = { colorAttachment },
        .depthAttachment = depthAttachment,
    };
    Array<Gfx::SubPassDependency> dependency = {
@@ -245,7 +233,7 @@ void BasePass::createRenderPass()
            .dstSubpass = 0,
            .srcStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
            .dstStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-            .srcAccess = Gfx::SE_ACCESS_NONE,
+            .srcAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
            .dstAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
        },
        {
@@ -262,7 +250,7 @@ void BasePass::createRenderPass()
            .srcStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
            .dstStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
            .srcAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-            .dstAccess = Gfx::SE_ACCESS_NONE,
+            .dstAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
        },
    };
    renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), viewport);
@@ -20,12 +20,11 @@ public:
 private:
    Gfx::RenderTargetAttachment colorAttachment;
    Gfx::RenderTargetAttachment depthAttachment;
-    Gfx::RenderTargetAttachment meshletIdAttachment;
+    Gfx::RenderTargetAttachment visibilityAttachment;
    Gfx::PShaderBuffer oLightIndexList;
    Gfx::PShaderBuffer tLightIndexList;
    Gfx::PTexture2D oLightGrid;
    Gfx::PTexture2D tLightGrid;
-    Gfx::OTexture2D meshletIdTexture;
    
    Gfx::PDescriptorSet opaqueCulling;
    Gfx::PDescriptorSet transparentCulling;
@@ -2,6 +2,8 @@ target_sources(Engine
    PRIVATE
        BasePass.h
        BasePass.cpp
+        CachedDepthPass.h
+        CachedDepthPass.cpp
        DebugPass.h
        DebugPass.cpp
        DepthPrepass.h
@@ -15,10 +17,6 @@ target_sources(Engine
        RenderPass.cpp
        SkyboxRenderPass.h
        SkyboxRenderPass.cpp
-        #StaticDepthPrepass.h
-        #StaticDepthPrepass.cpp
-        #StaticBasePass.h
-        #StaticBasePass.cpp
        TextPass.h
        TextPass.cpp
        UIPass.h
@@ -28,6 +26,7 @@ target_sources(Engine
    PUBLIC FILE_SET HEADERS
        FILES
            BasePass.h
+            CachedDepthPass.h
            DebugPass.h
            DepthPrepass.h
            LightCullingPass.h
@@ -35,7 +34,5 @@ target_sources(Engine
            RenderGraphResources.h
            RenderPass.h
            SkyboxRenderPass.h
-            #StaticDepthPrepass.h
-            #StaticBasePass.h
            TextPass.h
            UIPass.h)
@@ -0,0 +1,222 @@
+#include "CachedDepthPass.h"
+#include "Graphics/Shader.h"
+
+using namespace Seele;
+
+extern bool usePositionOnly;
+extern bool useViewCulling;
+
+CachedDepthPass::CachedDepthPass(Gfx::PGraphics graphics, PScene scene)
+    : RenderPass(graphics, scene)
+{
+  depthPrepassLayout = graphics->createPipelineLayout("CachedDepthLayout");
+  depthPrepassLayout->addDescriptorLayout(viewParamsLayout);
+  depthPrepassLayout->addPushConstants(Gfx::SePushConstantRange{
+      .stageFlags = Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT,
+      .offset = 0,
+      .size = sizeof(VertexData::DrawCallOffsets),
+  });
+  if (graphics->supportMeshShading())
+  {
+    graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "CachedDepthPass", "MeshletPass", false, false, "", true, true, "DrawListTask");
+  }
+  else
+  {
+    graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "CachedDepthPass", "LegacyPass");
+  }
+}
+
+CachedDepthPass::~CachedDepthPass()
+{
+}
+
+void CachedDepthPass::beginFrame(const Component::Camera &cam)
+{
+  RenderPass::beginFrame(cam);
+}
+
+void CachedDepthPass::render()
+{
+  graphics->beginRenderPass(renderPass);
+  Array<Gfx::ORenderCommand> commands;
+
+  Gfx::ShaderPermutation permutation;
+  permutation.setPositionOnly(usePositionOnly);
+  permutation.setViewCulling(useViewCulling);
+  if (graphics->supportMeshShading())
+  {
+    permutation.setTaskFile("DrawListTask");
+    permutation.setMeshFile("MeshletPass");
+  }
+  else
+  {
+    permutation.setVertexFile("LegacyPass");
+  }
+  for (VertexData *vertexData : VertexData::getList())
+  {
+    permutation.setVertexData(vertexData->getTypeName());
+
+    // Create Pipeline(VertexData)
+    // Descriptors:
+    // ViewData => global, static
+    // VertexData => per meshtype
+    // SceneData => per meshtype
+    Gfx::PermutationId id(permutation);
+
+    Gfx::ORenderCommand command = graphics->createRenderCommand("DepthRender");
+    command->setViewport(viewport);
+
+    const Gfx::ShaderCollection *collection = graphics->getShaderCompiler()->findShaders(id);
+    assert(collection != nullptr);
+    if (graphics->supportMeshShading())
+    {
+      Gfx::MeshPipelineCreateInfo pipelineInfo = {
+          .taskShader = collection->taskShader,
+          .meshShader = collection->meshShader,
+          .fragmentShader = collection->fragmentShader,
+          .renderPass = renderPass,
+          .pipelineLayout = collection->pipelineLayout,
+          .multisampleState = {
+              .samples = viewport->getSamples(),
+          },
+          .depthStencilState = {
+              .depthCompareOp = Gfx::SE_COMPARE_OP_GREATER,
+          },
+          .colorBlend = {
+              .attachmentCount = 1,
+          },
+      };
+      Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
+      command->bindPipeline(pipeline);
+    }
+    else
+    {
+      Gfx::LegacyPipelineCreateInfo pipelineInfo = {
+          .vertexShader = collection->vertexShader,
+          .fragmentShader = collection->fragmentShader,
+          .renderPass = renderPass,
+          .pipelineLayout = collection->pipelineLayout,
+          .multisampleState = {
+              .samples = viewport->getSamples(),
+          },
+          .depthStencilState = {
+              .depthCompareOp = Gfx::SE_COMPARE_OP_GREATER,
+          },
+          .colorBlend = {
+              .attachmentCount = 1,
+          },
+      };
+      Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
+      command->bindPipeline(pipeline);
+    }
+    command->bindDescriptor(vertexData->getVertexDataSet());
+    command->bindDescriptor(viewParamsSet);
+    command->bindDescriptor(vertexData->getInstanceDataSet());
+    uint32 offset = 0;
+    command->pushConstants(Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT, 0, sizeof(VertexData::DrawCallOffsets), &offset);
+    if (graphics->supportMeshShading())
+    {
+      command->drawMesh(vertexData->getNumInstances(), 1, 1);
+    }
+    else
+    {
+      const auto &materials = vertexData->getMaterialData();
+      for (const auto &materialData : materials)
+      {
+        // material not used for any active meshes, skip
+        if (materialData.instances.size() == 0)
+          continue;
+        for (const auto &drawCall : materialData.instances)
+        {
+          command->bindIndexBuffer(vertexData->getIndexBuffer());
+          uint32 inst = drawCall.offsets.instanceOffset;
+          for (const auto &meshData : drawCall.instanceMeshData)
+          {
+            // all meshlets of a mesh share the same indices offset
+            command->drawIndexed(meshData.numIndices, 1, meshData.firstIndex, vertexData->getIndicesOffset(meshData.meshletOffset), inst++);
+          }
+        }
+      }
+    }
+    commands.add(std::move(command));
+  }
+
+  graphics->executeCommands(std::move(commands));
+  graphics->endRenderPass();
+}
+
+void CachedDepthPass::endFrame()
+{
+}
+
+void CachedDepthPass::publishOutputs()
+{
+  // If we render to a part of an image, the depth buffer itself must
+  // still match the size of the whole image or their coordinate systems go out of sync
+  TextureCreateInfo depthBufferInfo = {
+      .format = Gfx::SE_FORMAT_D32_SFLOAT,
+      .width = viewport->getOwner()->getFramebufferWidth(),
+      .height = viewport->getOwner()->getFramebufferHeight(),
+      .usage = Gfx::SE_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+  };
+  depthBuffer = graphics->createTexture2D(depthBufferInfo);
+  depthAttachment =
+      Gfx::RenderTargetAttachment(depthBuffer,
+                                  Gfx::SE_IMAGE_LAYOUT_UNDEFINED, Gfx::SE_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+                                  Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
+  resources->registerRenderPassOutput("DEPTHPREPASS_DEPTH", depthAttachment);
+
+  TextureCreateInfo visibilityInfo = {
+      .format = Gfx::SE_FORMAT_R32G32_UINT,
+      .width = viewport->getOwner()->getFramebufferWidth(),
+      .height = viewport->getOwner()->getFramebufferHeight(),
+      .usage = Gfx::SE_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+  };
+  visibilityBuffer = graphics->createTexture2D(visibilityInfo);
+  visibilityAttachment =
+      Gfx::RenderTargetAttachment(visibilityBuffer,
+                                  Gfx::SE_IMAGE_LAYOUT_UNDEFINED, Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                                  Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
+  resources->registerRenderPassOutput("VISIBILITY", visibilityAttachment);
+}
+
+void CachedDepthPass::createRenderPass()
+{
+  Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
+      .depthAttachment = depthAttachment,
+  };
+  Array<Gfx::SubPassDependency> dependency = {
+      {
+          .srcSubpass = ~0U,
+          .dstSubpass = 0,
+          .srcStage = Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+          .dstStage = Gfx::SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+          .srcAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+          .dstAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+      },
+      {
+          .srcSubpass = 0,
+          .dstSubpass = ~0U,
+          .srcStage = Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+          .dstStage = Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+          .srcAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+          .dstAccess = Gfx::SE_ACCESS_SHADER_READ_BIT,
+      },
+      {
+          .srcSubpass = 0,
+          .dstSubpass = ~0U,
+          .srcStage = Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+          .dstStage = Gfx::SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+          .srcAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+          .dstAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+      },
+      {
+        .srcSubpass = 0,
+        .dstSubpass = ~0U,
+        .srcStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        .dstStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        .srcAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+        .dstAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+      }};
+  renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), viewport);
+}
@@ -0,0 +1,26 @@
+#pragma once
+#include "RenderPass.h"
+
+namespace Seele
+{
+class CachedDepthPass : public RenderPass
+{
+public:
+    CachedDepthPass(Gfx::PGraphics graphics, PScene scene);
+    CachedDepthPass(CachedDepthPass&&) = default;
+    CachedDepthPass& operator=(CachedDepthPass&&) = default;
+    virtual ~CachedDepthPass();
+    virtual void beginFrame(const Component::Camera& cam) override;
+    virtual void render() override;
+    virtual void endFrame() override;
+    virtual void publishOutputs() override;
+    virtual void createRenderPass() override;
+private:
+    Gfx::RenderTargetAttachment depthAttachment;
+    Gfx::RenderTargetAttachment visibilityAttachment;
+    Gfx::OTexture2D depthBuffer;
+    Gfx::OTexture2D visibilityBuffer;
+    Gfx::OPipelineLayout depthPrepassLayout;
+};
+DEFINE_REF(CachedDepthPass)
+}
@@ -1,15 +1,5 @@
 #include "DepthPrepass.h"
-#include "Graphics/Enums.h"
-#include "Graphics/Graphics.h"
 #include "Graphics/Shader.h"
-#include "Window/Window.h"
-#include "Component/Camera.h"
-#include "Component/Mesh.h"
-#include "Actor/CameraActor.h"
-#include "Math/Vector.h"
-#include "RenderGraph.h"
-#include "Graphics/Command.h"
-#include "Graphics/StaticMeshVertexData.h"

 using namespace Seele;

@@ -19,137 +9,139 @@ extern bool useViewCulling;
 DepthPrepass::DepthPrepass(Gfx::PGraphics graphics, PScene scene)
    : RenderPass(graphics, scene)
 {
-    depthPrepassLayout = graphics->createPipelineLayout("DepthPrepassLayout");
-    depthPrepassLayout->addDescriptorLayout(viewParamsLayout);
-    depthPrepassLayout->addPushConstants(Gfx::SePushConstantRange{
-        .stageFlags = Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT,
-        .offset = 0,
-        .size = sizeof(VertexData::DrawCallOffsets),
-        });
-    if (graphics->supportMeshShading())
-    {
-        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "MeshletPass", false, false, "", true, true, "ViewCullingTask");
-    }
-    else
-    {
-        graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "LegacyPass");
-    }
+  depthPrepassLayout = graphics->createPipelineLayout("DepthPrepassLayout");
+  depthPrepassLayout->addDescriptorLayout(viewParamsLayout);
+  depthPrepassLayout->addPushConstants(Gfx::SePushConstantRange{
+      .stageFlags = Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT,
+      .offset = 0,
+      .size = sizeof(VertexData::DrawCallOffsets),
+  });
+  if (graphics->supportMeshShading())
+  {
+    graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "MeshletPass", false, false, "", true, true, "ViewCullingTask");
+  }
+  else
+  {
+    graphics->getShaderCompiler()->registerRenderPass(depthPrepassLayout, "DepthPass", "LegacyPass");
+  }
 }

 DepthPrepass::~DepthPrepass()
 {
 }

-void DepthPrepass::beginFrame(const Component::Camera& cam)
+void DepthPrepass::beginFrame(const Component::Camera &cam)
 {
-    RenderPass::beginFrame(cam);
+  RenderPass::beginFrame(cam);
 }

 void DepthPrepass::render()
 {
-    graphics->beginRenderPass(renderPass);
-    Array<Gfx::ORenderCommand> commands;
+  graphics->beginRenderPass(renderPass);
+  Array<Gfx::ORenderCommand> commands;

-    Gfx::ShaderPermutation permutation;
-    permutation.setPositionOnly(usePositionOnly);
-    permutation.setViewCulling(useViewCulling);
+  Gfx::ShaderPermutation permutation;
+  permutation.setPositionOnly(usePositionOnly);
+  permutation.setViewCulling(useViewCulling);
+  if (graphics->supportMeshShading())
+  {
+    permutation.setTaskFile("ViewCullingTask");
+    permutation.setMeshFile("MeshletPass");
+  }
+  else
+  {
+    permutation.setVertexFile("LegacyPass");
+  }
+  for (VertexData *vertexData : VertexData::getList())
+  {
+    permutation.setVertexData(vertexData->getTypeName());
+    // Create Pipeline(VertexData)
+    // Descriptors:
+    // ViewData => global, static
+    // VertexData => per meshtype
+    // SceneData => per meshtype
+    Gfx::PermutationId id(permutation);
+
+    Gfx::ORenderCommand command = graphics->createRenderCommand("DepthRender");
+    command->setViewport(viewport);
+
+    const Gfx::ShaderCollection *collection = graphics->getShaderCompiler()->findShaders(id);
+    assert(collection != nullptr);
    if (graphics->supportMeshShading())
    {
-        permutation.setTaskFile("ViewCullingTask");
-        permutation.setMeshFile("MeshletPass");
+      Gfx::MeshPipelineCreateInfo pipelineInfo = {
+          .taskShader = collection->taskShader,
+          .meshShader = collection->meshShader,
+          .fragmentShader = collection->fragmentShader,
+          .renderPass = renderPass,
+          .pipelineLayout = collection->pipelineLayout,
+          .multisampleState = {
+              .samples = viewport->getSamples(),
+          },
+          .depthStencilState = {
+              .depthCompareOp = Gfx::SE_COMPARE_OP_GREATER,
+          },
+          .colorBlend = {
+              .attachmentCount = 1,
+          },
+      };
+      Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
+      command->bindPipeline(pipeline);
    }
    else
    {
-        permutation.setVertexFile("LegacyPass");
+      Gfx::LegacyPipelineCreateInfo pipelineInfo = {
+          .vertexShader = collection->vertexShader,
+          .fragmentShader = collection->fragmentShader,
+          .renderPass = renderPass,
+          .pipelineLayout = collection->pipelineLayout,
+          .multisampleState = {
+              .samples = viewport->getSamples(),
+          },
+          .depthStencilState = {
+              .depthCompareOp = Gfx::SE_COMPARE_OP_GREATER,
+          },
+          .colorBlend = {
+              .attachmentCount = 1,
+          },
+      };
+      Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
+      command->bindPipeline(pipeline);
    }
-    for (VertexData* vertexData : VertexData::getList())
+    command->bindDescriptor(vertexData->getVertexDataSet());
+    command->bindDescriptor(viewParamsSet);
+    command->bindDescriptor(vertexData->getInstanceDataSet());
+    uint32 offset = 0;
+    command->pushConstants(Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT, 0, sizeof(VertexData::DrawCallOffsets), &offset);
+    if (graphics->supportMeshShading())
    {
-        permutation.setVertexData(vertexData->getTypeName());
-        const auto& materials = vertexData->getMaterialData();
-        for (const auto& materialData : materials)
-        {
-            // material not used for any active meshes, skip
-            if (materialData.instances.size() == 0)
-                continue;
-            // Create Pipeline(VertexData)
-            // Descriptors:
-            // ViewData => global, static
-            // VertexData => per meshtype
-            // SceneData => per meshtype
-            Gfx::PermutationId id(permutation);
-
-            Gfx::ORenderCommand command = graphics->createRenderCommand("DepthRender");
-            command->setViewport(viewport);
-
-            const Gfx::ShaderCollection* collection = graphics->getShaderCompiler()->findShaders(id);
-            assert(collection != nullptr);
-            if (graphics->supportMeshShading())
-            {
-                Gfx::MeshPipelineCreateInfo pipelineInfo = {
-                    .taskShader = collection->taskShader,
-                    .meshShader = collection->meshShader,
-                    .fragmentShader = collection->fragmentShader,
-                    .renderPass = renderPass,
-                    .pipelineLayout = collection->pipelineLayout,
-                    .multisampleState = {
-                        .samples = viewport->getSamples(),},
-                    .depthStencilState = {
-                        .depthCompareOp = Gfx::SE_COMPARE_OP_GREATER,
-                    },
-                    .colorBlend = {
-                        .attachmentCount = 1,
-                    },
-                };
-                Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
-                command->bindPipeline(pipeline);
-            }
-            else
-            {
-                Gfx::LegacyPipelineCreateInfo pipelineInfo = {
-                    .vertexShader = collection->vertexShader,
-                    .fragmentShader = collection->fragmentShader,
-                    .renderPass = renderPass,
-                    .pipelineLayout = collection->pipelineLayout,
-                    .multisampleState = {
-                        .samples = viewport->getSamples(),
-                    },
-                    .depthStencilState = {
-                        .depthCompareOp = Gfx::SE_COMPARE_OP_GREATER,
-                    },
-                    .colorBlend = {
-                        .attachmentCount = 1,
-                    },
-                };
-                Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
-                command->bindPipeline(pipeline);
-            }
-            command->bindDescriptor(vertexData->getVertexDataSet());
-            command->bindDescriptor(viewParamsSet);
-            command->bindDescriptor(vertexData->getInstanceDataSet());
-            for (const auto& drawCall : materialData.instances)
-            {
-                command->pushConstants(Gfx::SE_SHADER_STAGE_TASK_BIT_EXT | Gfx::SE_SHADER_STAGE_VERTEX_BIT, 0, sizeof(VertexData::DrawCallOffsets), &drawCall.offsets);
-                if (graphics->supportMeshShading())
-                {
-                    command->drawMesh(drawCall.instanceMeshData.size(), 1, 1);
-                }
-                else
-                {
-                    command->bindIndexBuffer(vertexData->getIndexBuffer());
-                    uint32 inst = drawCall.offsets.instanceOffset;
-                    for (const auto& meshData : drawCall.instanceMeshData)
-                    {
-                        // all meshlets of a mesh share the same indices offset
-                        command->drawIndexed(meshData.numIndices, 1, meshData.firstIndex, vertexData->getIndicesOffset(meshData.meshletOffset), inst++);
-                    }
-                }
-            }
-            commands.add(std::move(command));
-        }
+      command->drawMesh(vertexData->getNumInstances(), 1, 1);
    }
+    else
+    {
+      const auto &materials = vertexData->getMaterialData();
+      for (const auto &materialData : materials)
+      {
+        for (const auto &drawCall : materialData.instances)
+        {
+          // material not used for any active meshes, skip
+          if (materialData.instances.size() == 0)
+            continue;
+          command->bindIndexBuffer(vertexData->getIndexBuffer());
+          uint32 inst = drawCall.offsets.instanceOffset;
+          for (const auto &meshData : drawCall.instanceMeshData)
+          {
+            // all meshlets of a mesh share the same indices offset
+            command->drawIndexed(meshData.numIndices, 1, meshData.firstIndex, vertexData->getIndicesOffset(meshData.meshletOffset), inst++);
+          }
+        }
+      }
+    }
+    commands.add(std::move(command));
+  }

-    graphics->executeCommands(std::move(commands));
-    graphics->endRenderPass();
+  graphics->executeCommands(std::move(commands));
+  graphics->endRenderPass();
 }

 void DepthPrepass::endFrame()
@@ -158,52 +150,63 @@ void DepthPrepass::endFrame()

 void DepthPrepass::publishOutputs()
 {
-    // If we render to a part of an image, the depth buffer itself must
-    // still match the size of the whole image or their coordinate systems go out of sync
-    TextureCreateInfo depthBufferInfo = {
-        .format = Gfx::SE_FORMAT_D32_SFLOAT,
-        .width = viewport->getOwner()->getFramebufferWidth(),
-        .height = viewport->getOwner()->getFramebufferHeight(),
-        .usage = Gfx::SE_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
-    };
-    depthBuffer = graphics->createTexture2D(depthBufferInfo);
-    depthAttachment =
-        Gfx::RenderTargetAttachment(depthBuffer,
-            Gfx::SE_IMAGE_LAYOUT_UNDEFINED, Gfx::SE_IMAGE_LAYOUT_GENERAL,
-            Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
-    resources->registerRenderPassOutput("DEPTHPREPASS_DEPTH", depthAttachment);
 }

 void DepthPrepass::createRenderPass()
 {
-    Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
-        .depthAttachment = depthAttachment,
-    };
-    Array<Gfx::SubPassDependency> dependency = {
-        {
-            .srcSubpass = ~0U,
-            .dstSubpass = 0,
-            .srcStage = Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-            .dstStage = Gfx::SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
-            .srcAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-            .dstAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-        },
-        {
-            .srcSubpass = 0,
-            .dstSubpass = ~0U,
-            .srcStage = Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-            .dstStage = Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-            .srcAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-            .dstAccess = Gfx::SE_ACCESS_SHADER_READ_BIT,
-        },
-        {
-            .srcSubpass = 0,
-            .dstSubpass = ~0U,
-            .srcStage = Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-            .dstStage = Gfx::SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
-            .srcAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-            .dstAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
-        }
-    };
-    renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), viewport);
+  auto depthAttachment = resources->requestRenderTarget("DEPTHPREPASS_DEPTH");
+  depthAttachment.setInitialLayout(Gfx::SE_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
+  depthAttachment.setFinalLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL);
+  depthAttachment.setLoadOp(Gfx::SE_ATTACHMENT_LOAD_OP_LOAD);
+  auto visibilityAttachment = resources->requestRenderTarget("VISIBILITY");
+  visibilityAttachment.setInitialLayout(Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+  visibilityAttachment.setFinalLayout(Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+  visibilityAttachment.setLoadOp(Gfx::SE_ATTACHMENT_LOAD_OP_LOAD);
+
+  Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
+      .colorAttachments = {visibilityAttachment},
+      .depthAttachment = depthAttachment,
+  };
+  Array<Gfx::SubPassDependency> dependency = {
+      {
+          .srcSubpass = ~0U,
+          .dstSubpass = 0,
+          .srcStage = Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+          .dstStage = Gfx::SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+          .srcAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+          .dstAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+      },
+      {
+          .srcSubpass = ~0U,
+          .dstSubpass = 0,
+          .srcStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+          .dstStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+          .srcAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+          .dstAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+      },
+      {
+          .srcSubpass = 0,
+          .dstSubpass = ~0U,
+          .srcStage = Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+          .dstStage = Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+          .srcAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+          .dstAccess = Gfx::SE_ACCESS_SHADER_READ_BIT,
+      },
+      {
+          .srcSubpass = 0,
+          .dstSubpass = ~0U,
+          .srcStage = Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+          .dstStage = Gfx::SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+          .srcAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+          .dstAccess = Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+      },
+      {
+          .srcSubpass = 0,
+          .dstSubpass = ~0U,
+          .srcStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+          .dstStage = Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+          .srcAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+          .dstAccess = Gfx::SE_ACCESS_SHADER_READ_BIT,
+      }};
+  renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), viewport);
 }
@@ -18,9 +18,6 @@ public:
    virtual void createRenderPass() override;
 private:
    Gfx::RenderTargetAttachment depthAttachment;
-
-    Gfx::OTexture2D depthBuffer;
-
    Gfx::OPipelineLayout depthPrepassLayout;
 };
 DEFINE_REF(DepthPrepass)