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
@@ -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);
 }