Adding basic depth prepass

src/Engine/Graphics/RenderPass/BasePass.cpp

@@ -4,6 +4,7 @@
 #include "Scene/Components/CameraComponent.h"
 #include "Scene/Actor/CameraActor.h"
 #include "Math/Vector.h"
+#include "RenderGraph.h"
 
 using namespace Seele;
 
@@ -46,10 +47,10 @@ void BasePassMeshProcessor::addMeshBatch(
     renderCommand->setViewport(target);
     for(uint32 i = 0; i < batch.elements.size(); ++i)
     {
-        pipelineLayout->addDescriptorLayout(2, material->getRenderMaterial()->getDescriptorLayout());
+        pipelineLayout->addDescriptorLayout(BasePass::INDEX_MATERIAL, material->getRenderMaterial()->getDescriptorLayout());
         pipelineLayout->create();
-        descriptorSets[2] = material->getDescriptor();
-        descriptorSets[3] = cachedPrimitiveSets[cachedPrimitiveIndex++];
+        descriptorSets[BasePass::INDEX_MATERIAL] = material->getDescriptor();
+        descriptorSets[BasePass::INDEX_SCENE_DATA] = cachedPrimitiveSets[cachedPrimitiveIndex++];
         buildMeshDrawCommand(batch, 
 //            primitiveComponent, 
             renderPass,
@@ -78,42 +79,29 @@ void BasePassMeshProcessor::clearCommands()
     cachedPrimitiveIndex = 0;
 }
 
-BasePass::BasePass(const PScene scene, Gfx::PGraphics graphics, Gfx::PViewport viewport, PCameraActor source) 
-    : processor(new BasePassMeshProcessor(scene, viewport, graphics, false))
+BasePass::BasePass(PRenderGraph renderGraph, const PScene scene, Gfx::PGraphics graphics, Gfx::PViewport viewport, PCameraActor source) 
+    : RenderPass(renderGraph)
+    , processor(new BasePassMeshProcessor(scene, viewport, graphics, false))
     , scene(scene)
     , graphics(graphics)
     , viewport(viewport)
     , descriptorSets(4)
     , source(source->getCameraComponent())
 {
-    Gfx::PRenderTargetAttachment colorAttachment = new Gfx::SwapchainAttachment(viewport->getOwner());
-    TextureCreateInfo depthBufferInfo;
-    depthBufferInfo.width = viewport->getSizeX();
-    depthBufferInfo.height = viewport->getSizeY();
-    depthBufferInfo.format = Gfx::SE_FORMAT_D32_SFLOAT;
-    depthBufferInfo.usage = Gfx::SE_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
-    depthBuffer = graphics->createTexture2D(depthBufferInfo);
-    Gfx::PRenderTargetAttachment depthAttachment = 
-        new Gfx::RenderTargetAttachment(depthBuffer, Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
-    depthAttachment->clear.depthStencil.depth = 1.0f;
-    Gfx::PRenderTargetLayout layout = new Gfx::RenderTargetLayout(colorAttachment, depthAttachment);
-    renderPass = graphics->createRenderPass(layout);
-
     UniformBufferCreateInfo uniformInitializer;
-
     basePassLayout = graphics->createPipelineLayout();
 
-    lightLayout = graphics->createDescriptorLayout();
+    lightLayout = graphics->createDescriptorLayout("LightLayout");
     lightLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
     uniformInitializer.resourceData.size = sizeof(LightEnv);
     uniformInitializer.resourceData.data = nullptr;
     uniformInitializer.bDynamic = true;
     lightUniform = graphics->createUniformBuffer(uniformInitializer);
     lightLayout->create();
-    basePassLayout->addDescriptorLayout(0, lightLayout);
-    descriptorSets[0] = lightLayout->allocatedDescriptorSet();
+    basePassLayout->addDescriptorLayout(INDEX_LIGHT_ENV, lightLayout);
+    descriptorSets[INDEX_LIGHT_ENV] = lightLayout->allocatedDescriptorSet();
 
-    viewLayout = graphics->createDescriptorLayout();
+    viewLayout = graphics->createDescriptorLayout("ViewLayout");
     viewLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
     uniformInitializer.resourceData.size = sizeof(ViewParameter);
     uniformInitializer.resourceData.data = (uint8*)&viewParams;
@@ -125,13 +113,13 @@ BasePass::BasePass(const PScene scene, Gfx::PGraphics graphics, Gfx::PViewport v
     uniformInitializer.bDynamic = true;
     screenToViewParamBuffer = graphics->createUniformBuffer(uniformInitializer);
     viewLayout->create();
-    basePassLayout->addDescriptorLayout(1, viewLayout);
-    descriptorSets[1] = viewLayout->allocatedDescriptorSet();
+    basePassLayout->addDescriptorLayout(INDEX_VIEW_PARAMS, viewLayout);
+    descriptorSets[INDEX_VIEW_PARAMS] = viewLayout->allocatedDescriptorSet();
 
-    primitiveLayout = graphics->createDescriptorLayout();
+    primitiveLayout = graphics->createDescriptorLayout("PrimitiveLayout");
     primitiveLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
     primitiveLayout->create();
-    basePassLayout->addDescriptorLayout(3, primitiveLayout);
+    basePassLayout->addDescriptorLayout(INDEX_SCENE_DATA, primitiveLayout);
 }
 
 BasePass::~BasePass()
@@ -146,8 +134,8 @@ void BasePass::beginFrame()
     uniformUpdate.size = sizeof(LightEnv);
     uniformUpdate.data = (uint8*)&scene->getLightEnvironment();
     lightUniform->updateContents(uniformUpdate);
-    descriptorSets[0]->updateBuffer(0, lightUniform);
-    descriptorSets[0]->writeChanges();
+    descriptorSets[INDEX_LIGHT_ENV]->updateBuffer(0, lightUniform);
+    descriptorSets[INDEX_LIGHT_ENV]->writeChanges();
 
     viewParams.viewMatrix = source->getViewMatrix();
     viewParams.projectionMatrix = source->getProjectionMatrix();
@@ -160,9 +148,9 @@ void BasePass::beginFrame()
     uniformUpdate.size = sizeof(ScreenToViewParameter);
     uniformUpdate.data = (uint8*)&screenToViewParams;
     screenToViewParamBuffer->updateContents(uniformUpdate);
-    descriptorSets[1]->updateBuffer(0, viewParamBuffer);
-    descriptorSets[1]->updateBuffer(1, screenToViewParamBuffer);
-    descriptorSets[1]->writeChanges();
+    descriptorSets[INDEX_VIEW_PARAMS]->updateBuffer(0, viewParamBuffer);
+    descriptorSets[INDEX_VIEW_PARAMS]->updateBuffer(1, screenToViewParamBuffer);
+    descriptorSets[INDEX_VIEW_PARAMS]->writeChanges();
     for(auto &&meshBatch : scene->getStaticMeshes())
     {
         meshBatch.material->updateDescriptorData();
@@ -183,3 +171,25 @@ void BasePass::render()
 void BasePass::endFrame() 
 {
 }
+
+void BasePass::publishOutputs() 
+{
+    colorAttachment = new Gfx::SwapchainAttachment(viewport->getOwner());
+    renderGraph->registerRenderPassOutput("BASEPASS_COLOR", colorAttachment);
+}
+
+void BasePass::createRenderPass() 
+{
+    Gfx::PRenderTargetAttachment depthAttachment = renderGraph->requestRenderTarget("DEPTHPREPASS_DEPTH");
+    depthAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
+    Gfx::PRenderTargetLayout layout = new Gfx::RenderTargetLayout(colorAttachment, depthAttachment);
+    renderPass = graphics->createRenderPass(layout);
+}
+
+void BasePass::modifyRenderPassMacros(Map<const char*, const char*>& defines)
+{
+    defines["INDEX_LIGHT_ENV"] = "0";
+    defines["INDEX_VIEW_PARAMS"] = "1";
+    defines["INDEX_MATERIAL"] = "2";
+    defines["INDEX_SCENE_DATA"] = "3";
+}

src/Engine/Graphics/RenderPass/BasePass.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "MinimalEngine.h"
 #include "MeshProcessor.h"
+#include "RenderPass.h"
 
 namespace Seele
 {
@@ -30,28 +31,19 @@ private:
 DEFINE_REF(BasePassMeshProcessor)
 DECLARE_REF(CameraActor)
 DECLARE_REF(CameraComponent)
-class BasePass
+class BasePass : public RenderPass
 {
 public:
-    BasePass(const PScene scene, Gfx::PGraphics graphics, Gfx::PViewport viewport, PCameraActor source);
-    ~BasePass();
-    void beginFrame();
-    void render();
-    void endFrame();
+    BasePass(PRenderGraph renderGraph, const PScene scene, Gfx::PGraphics graphics, Gfx::PViewport viewport, PCameraActor source);
+    virtual ~BasePass();
+    virtual void beginFrame() override;
+    virtual void render() override;
+    virtual void endFrame() override;
+    virtual void publishOutputs() override;
+    virtual void createRenderPass() override;
+    static void modifyRenderPassMacros(Map<const char*, const char*>& defines);
 private:
-    struct ViewParameter
-    {
-        Matrix4 viewMatrix;
-        Matrix4 projectionMatrix;
-        Vector4 cameraPosition;
-    } viewParams;
-    struct ScreenToViewParameter
-    {
-        Matrix4 inverseProjectionMatrix;
-        Vector2 screenDimensions;
-    } screenToViewParams;
-
-    Gfx::PRenderPass renderPass;
+    Gfx::PRenderTargetAttachment colorAttachment;
     Gfx::PTexture2D depthBuffer;
     UPBasePassMeshProcessor processor;
     const PScene scene;
@@ -61,16 +53,21 @@ private:
     PCameraComponent source;
     Gfx::PPipelineLayout basePassLayout;
     // Set 0: Light environment
+    static constexpr uint32 INDEX_LIGHT_ENV = 0;
     Gfx::PDescriptorLayout lightLayout;
     Gfx::PUniformBuffer lightUniform;
     // Set 1: viewParameter
+    static constexpr uint32 INDEX_VIEW_PARAMS = 1;
     Gfx::PDescriptorLayout viewLayout;
     Gfx::PUniformBuffer viewParamBuffer;
     Gfx::PUniformBuffer screenToViewParamBuffer;
     // Set 2: materials, generated
+    static constexpr uint32 INDEX_MATERIAL = 2;
     // Set 3: primitive scene data
+    static constexpr uint32 INDEX_SCENE_DATA = 3;
     Gfx::PDescriptorLayout primitiveLayout;
     Gfx::PUniformBuffer primitiveUniformBuffer;
+    friend class BasePassMeshProcessor;
 };
 DEFINE_REF(BasePass)
 } // namespace Seele

src/Engine/Graphics/RenderPass/CMakeLists.txt

@@ -4,5 +4,11 @@ target_sources(SeeleEngine
         BasePass.cpp
         DepthPrepass.h
         DepthPrepass.cpp
+        LightCullingPass.h
+        LightCullingPass.cpp
         MeshProcessor.h
-        MeshProcessor.cpp)
+        MeshProcessor.cpp
+        RenderGraph.h
+        RenderGraph.cpp
+        RenderPass.h
+        RenderPass.cpp)

src/Engine/Graphics/RenderPass/DepthPrepass.cpp

@@ -0,0 +1,185 @@
+#include "DepthPrepass.h"
+#include "Graphics/Graphics.h"
+#include "Window/Window.h"
+#include "Scene/Components/CameraComponent.h"
+#include "Scene/Actor/CameraActor.h"
+#include "Math/Vector.h"
+#include "RenderGraph.h"
+
+using namespace Seele;
+
+DepthPrepassMeshProcessor::DepthPrepassMeshProcessor(const PScene scene, Gfx::PViewport viewport, Gfx::PGraphics graphics) 
+    : MeshProcessor(scene, graphics)
+    , target(viewport)
+    , cachedPrimitiveIndex(0)
+{
+}
+
+DepthPrepassMeshProcessor::~DepthPrepassMeshProcessor() 
+{ 
+}
+
+void DepthPrepassMeshProcessor::addMeshBatch(
+    const MeshBatch& batch, 
+//    const PPrimitiveComponent primitiveComponent,
+    const Gfx::PRenderPass renderPass,
+    Gfx::PPipelineLayout pipelineLayout,
+    Gfx::PDescriptorLayout primitiveLayout,
+    Array<Gfx::PDescriptorSet>& descriptorSets,
+    int32 /*staticMeshId*/) 
+{
+    const PMaterialAsset material = batch.material;
+    //const Gfx::MaterialShadingModel shadingModel = material->getShadingModel();
+
+    const PVertexShaderInput vertexInput = batch.vertexInput;
+
+	const Gfx::ShaderCollection* collection = material->getRenderMaterial()->getShaders(Gfx::RenderPassType::DepthPrepass, vertexInput->getType());
+    assert(collection != nullptr);
+    for(uint32 i = 0; i < batch.elements.size(); ++i)
+    {
+        Gfx::PDescriptorSet descriptorSet = primitiveLayout->allocatedDescriptorSet();
+        descriptorSet->updateBuffer(0, batch.elements[i].uniformBuffer);
+        descriptorSet->writeChanges();
+        cachedPrimitiveSets.add(descriptorSet);
+    }
+    Gfx::PRenderCommand renderCommand = graphics->createRenderCommand();    
+    renderCommand->setViewport(target);
+    for(uint32 i = 0; i < batch.elements.size(); ++i)
+    {
+        pipelineLayout->addDescriptorLayout(DepthPrepass::INDEX_MATERIAL, material->getRenderMaterial()->getDescriptorLayout());
+        pipelineLayout->create();
+        descriptorSets[DepthPrepass::INDEX_MATERIAL] = material->getDescriptor();
+        descriptorSets[DepthPrepass::INDEX_SCENE_DATA] = cachedPrimitiveSets[cachedPrimitiveIndex++];
+        buildMeshDrawCommand(batch, 
+//            primitiveComponent, 
+            renderPass,
+            pipelineLayout,
+            renderCommand,
+            descriptorSets,
+            collection->vertexShader, 
+            collection->controlShader,
+            collection->evalutionShader,
+            collection->geometryShader,
+            collection->fragmentShader,
+            true);
+    }
+    renderCommands.add(renderCommand);
+}
+
+Array<Gfx::PRenderCommand> DepthPrepassMeshProcessor::getRenderCommands() 
+{
+    return renderCommands;
+}
+
+void DepthPrepassMeshProcessor::clearCommands()
+{
+    renderCommands.clear();
+    cachedPrimitiveSets.clear();
+    cachedPrimitiveIndex = 0;
+}
+
+DepthPrepass::DepthPrepass(PRenderGraph renderGraph, const PScene scene, Gfx::PGraphics graphics, Gfx::PViewport viewport, PCameraActor source) 
+    : RenderPass(renderGraph)
+    , processor(new DepthPrepassMeshProcessor(scene, viewport, graphics))
+    , scene(scene)
+    , graphics(graphics)
+    , viewport(viewport)
+    , descriptorSets(3)
+    , source(source->getCameraComponent())
+{
+    UniformBufferCreateInfo uniformInitializer;
+
+    depthPrepassLayout = graphics->createPipelineLayout();
+
+    viewLayout = graphics->createDescriptorLayout("ViewLayout");
+    viewLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
+    uniformInitializer.resourceData.size = sizeof(ViewParameter);
+    uniformInitializer.resourceData.data = (uint8*)&viewParams;
+    uniformInitializer.bDynamic = true;
+    viewParamBuffer = graphics->createUniformBuffer(uniformInitializer);
+    viewLayout->addDescriptorBinding(1, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
+    uniformInitializer.resourceData.size = sizeof(ScreenToViewParameter);
+    uniformInitializer.resourceData.data = (uint8*)&screenToViewParams;
+    uniformInitializer.bDynamic = true;
+    screenToViewParamBuffer = graphics->createUniformBuffer(uniformInitializer);
+    viewLayout->create();
+    depthPrepassLayout->addDescriptorLayout(INDEX_VIEW_PARAMS, viewLayout);
+    descriptorSets[INDEX_VIEW_PARAMS] = viewLayout->allocatedDescriptorSet();
+
+    primitiveLayout = graphics->createDescriptorLayout("PrimitiveLayout");
+    primitiveLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
+    primitiveLayout->create();
+    depthPrepassLayout->addDescriptorLayout(INDEX_SCENE_DATA, primitiveLayout);
+}
+
+DepthPrepass::~DepthPrepass()
+{   
+}
+
+void DepthPrepass::beginFrame() 
+{
+    processor->clearCommands();
+    primitiveLayout->reset();
+    BulkResourceData uniformUpdate;
+
+    viewParams.viewMatrix = source->getViewMatrix();
+    viewParams.projectionMatrix = source->getProjectionMatrix();
+    viewParams.cameraPosition = Vector4(source->getCameraPosition(), 0);
+    screenToViewParams.inverseProjectionMatrix = glm::inverse(viewParams.projectionMatrix);
+    screenToViewParams.screenDimensions = Vector2(static_cast<float>(viewport->getSizeX()), static_cast<float>(viewport->getSizeY()));
+    uniformUpdate.size = sizeof(ViewParameter);
+    uniformUpdate.data = (uint8*)&viewParams;
+    viewParamBuffer->updateContents(uniformUpdate);
+    uniformUpdate.size = sizeof(ScreenToViewParameter);
+    uniformUpdate.data = (uint8*)&screenToViewParams;
+    screenToViewParamBuffer->updateContents(uniformUpdate);
+    descriptorSets[INDEX_VIEW_PARAMS]->updateBuffer(0, viewParamBuffer);
+    descriptorSets[INDEX_VIEW_PARAMS]->updateBuffer(1, screenToViewParamBuffer);
+    descriptorSets[INDEX_VIEW_PARAMS]->writeChanges();
+    for(auto &&meshBatch : scene->getStaticMeshes())
+    {
+        meshBatch.material->updateDescriptorData();
+    }
+}
+
+void DepthPrepass::render() 
+{
+    graphics->beginRenderPass(renderPass);
+    for (auto &&meshBatch : scene->getStaticMeshes())
+    {
+        processor->addMeshBatch(meshBatch, renderPass, depthPrepassLayout, primitiveLayout, descriptorSets);
+    }
+    graphics->executeCommands(processor->getRenderCommands());
+    graphics->endRenderPass();
+}
+
+void DepthPrepass::endFrame() 
+{
+}
+
+void DepthPrepass::publishOutputs() 
+{
+    TextureCreateInfo depthBufferInfo;
+    depthBufferInfo.width = viewport->getSizeX();
+    depthBufferInfo.height = viewport->getSizeY();
+    depthBufferInfo.format = Gfx::SE_FORMAT_D32_SFLOAT;
+    depthBufferInfo.usage = Gfx::SE_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+    depthBuffer = graphics->createTexture2D(depthBufferInfo);
+    depthAttachment = 
+        new Gfx::RenderTargetAttachment(depthBuffer, Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
+    depthAttachment->clear.depthStencil.depth = 1.0f;
+    renderGraph->registerRenderPassOutput("DEPTHPREPASS_DEPTH", depthAttachment);
+}
+
+void DepthPrepass::createRenderPass() 
+{
+    Gfx::PRenderTargetLayout layout = new Gfx::RenderTargetLayout(depthAttachment);
+    renderPass = graphics->createRenderPass(layout);
+}
+
+void DepthPrepass::modifyRenderPassMacros(Map<const char*, const char*>& defines) 
+{
+    defines["INDEX_VIEW_PARAMS"] = "0";
+    defines["INDEX_MATERIAL"] = "1";
+    defines["INDEX_SCENE_DATA"] = "2";
+}

src/Engine/Graphics/RenderPass/DepthPrepass.h

@@ -0,0 +1,68 @@
+#pragma once
+#include "MinimalEngine.h"
+#include "MeshProcessor.h"
+#include "RenderPass.h"
+
+namespace Seele
+{
+class DepthPrepassMeshProcessor : public MeshProcessor
+{
+public:
+    DepthPrepassMeshProcessor(const PScene scene, Gfx::PViewport viewport, Gfx::PGraphics graphics);
+    virtual ~DepthPrepassMeshProcessor();
+    
+    virtual void addMeshBatch(
+        const MeshBatch& batch,
+        const Gfx::PRenderPass renderPass,
+        Gfx::PPipelineLayout pipelineLayout,
+        Gfx::PDescriptorLayout primitiveLayout,
+        Array<Gfx::PDescriptorSet>& descriptorSets,
+        int32 staticMeshId = -1) override;
+
+    Array<Gfx::PRenderCommand> getRenderCommands();
+    void clearCommands();
+private:
+    Array<Gfx::PRenderCommand> renderCommands;
+    Array<Gfx::PDescriptorSet> cachedPrimitiveSets;
+    Gfx::PViewport target;
+    uint32 cachedPrimitiveIndex;
+};
+DEFINE_REF(DepthPrepassMeshProcessor)
+DECLARE_REF(CameraActor)
+DECLARE_REF(CameraComponent)
+class DepthPrepass : public RenderPass
+{
+public:
+    DepthPrepass(PRenderGraph renderGraph, const PScene scene, Gfx::PGraphics graphics, Gfx::PViewport viewport, PCameraActor source);
+    ~DepthPrepass();
+    virtual void beginFrame() override;
+    virtual void render() override;
+    virtual void endFrame() override;
+    virtual void publishOutputs() override;
+    virtual void createRenderPass() override;
+    static void modifyRenderPassMacros(Map<const char*, const char*>& defines);
+private:
+    Gfx::PRenderTargetAttachment depthAttachment;
+    Gfx::PTexture2D depthBuffer;
+    UPDepthPrepassMeshProcessor processor;
+    const PScene scene;
+    Gfx::PGraphics graphics;
+    Gfx::PViewport viewport;
+    Array<Gfx::PDescriptorSet> descriptorSets;
+    PCameraComponent source;
+    Gfx::PPipelineLayout depthPrepassLayout;
+    // Set 0: viewParameter
+    static constexpr uint32 INDEX_VIEW_PARAMS = 0;
+    Gfx::PDescriptorLayout viewLayout;
+    Gfx::PUniformBuffer viewParamBuffer;
+    Gfx::PUniformBuffer screenToViewParamBuffer;
+    // Set 1: materials, generated
+    static constexpr uint32 INDEX_MATERIAL = 1;
+    // Set 2: primitive scene data
+    static constexpr uint32 INDEX_SCENE_DATA = 2;
+    Gfx::PDescriptorLayout primitiveLayout;
+    Gfx::PUniformBuffer primitiveUniformBuffer;
+    friend class DepthPrepassMeshProcessor;
+};
+DEFINE_REF(DepthPrepass)
+} // namespace Seele

src/Engine/Graphics/RenderPass/LightCullingPass.cpp

@@ -0,0 +1,83 @@
+#include "LightCullingPass.h"
+#include "Graphics/Graphics.h"
+#include "Scene/Actor/CameraActor.h"
+#include "Scene/Components/CameraComponent.h"
+
+using namespace Seele;
+
+LightCullingPass::LightCullingPass(PRenderGraph renderGraph, Gfx::PViewport viewport, Gfx::PGraphics graphics, PCameraActor camera) 
+    : RenderPass(renderGraph)
+    , viewport(viewport)
+    , graphics(graphics)
+    , source(camera->getCameraComponent())
+{
+}
+
+LightCullingPass::~LightCullingPass() 
+{
+    
+}
+
+void LightCullingPass::beginFrame() 
+{
+    uint32_t viewportWidth = viewport->getSizeX();
+	uint32_t viewportHeight = viewport->getSizeY();
+
+	glm::uvec3 numThreads = glm::ceil(glm::vec3(viewportWidth / (float)BLOCK_SIZE, viewportHeight / (float)BLOCK_SIZE, 1));
+	glm::uvec3 numThreadGroups = glm::ceil(glm::vec3(numThreads.x / (float)BLOCK_SIZE, numThreads.y / (float)BLOCK_SIZE, 1));
+	
+	dispatchParams.numThreads = numThreads;
+	dispatchParams.numThreadGroups = numThreadGroups;
+	ScreenToView screenToView;
+	screenToView.inverseProjection = glm::inverse(source->getProjectionMatrix());
+	screenToView.screenDimensions = glm::vec2(viewportWidth, viewportHeight);
+
+	frustumShader = renderDevice->createComputeShader(loadPlaintext("./_Game/shaders/ComputeFrustums.slang"), "computeFrustums");
+	frustumDescriptorLayout = renderDevice->createDescriptorLayout();
+	frustumDescriptorLayout->addDescriptorBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
+	frustumDescriptorLayout->addDescriptorBinding(1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
+	frustumDescriptorLayout->addDescriptorBinding(2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
+	frustumLayout = renderDevice->createPipelineLayout();
+	frustumLayout->addPushConstants(init::PushConstantRange(VK_SHADER_STAGE_COMPUTE_BIT, sizeof(DispatchParams), 0));
+	frustumLayout->addDescriptorLayout(0, frustumDescriptorLayout);
+	frustumLayout->create();
+	frustumShader->setPipelineLayout(frustumLayout);
+	RHIResourceCreateInfo frustumInfo;
+	frustumBuffer = renderDevice->createStructuredBuffer(sizeof(Frustum), sizeof(Frustum) * numThreads.x * numThreads.y * numThreads.z, BufferUsageFlags::BUF_UnorderedAccess, frustumInfo);
+	dispatchParamsBuffer = renderDevice->createUniformBuffer(&dispatchParams, sizeof(DispatchParams), UniformBuffer_MultiFrame);
+	screenToViewParams = renderDevice->createUniformBuffer(&screenToView, sizeof(ScreenToView), UniformBuffer_MultiFrame);
+	frustumDescriptorSet = frustumDescriptorLayout->allocateDescriptorSet();
+	frustumDescriptorSet->updateBuffer(0, dispatchParamsBuffer);
+	frustumDescriptorSet->updateBuffer(1, screenToViewParams);
+	frustumDescriptorSet->updateBuffer(2, frustumBuffer);
+	frustumDescriptorSet->writeChanges();
+	renderDevice->setComputeShader(frustumShader);
+	renderDevice->bindComputeDescriptors(frustumLayout, frustumDescriptorSet);
+	renderDevice->dispatchComputeShader(numThreadGroups.x, numThreadGroups.y, numThreadGroups.z);
+	renderDevice->pipelineBarrier(frustumBuffer, VK_ACCESS_SHADER_WRITE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+}
+
+void LightCullingPass::render() 
+{
+    
+}
+
+void LightCullingPass::endFrame() 
+{
+    
+}
+
+void LightCullingPass::publishOutputs() 
+{
+    
+}
+
+void LightCullingPass::createRenderPass() 
+{
+    
+}
+
+void LightCullingPass::modifyRenderPassMacros(Map<const char*, const char*>& defines) 
+{
+    
+}

src/Engine/Graphics/RenderPass/LightCullingPass.h

@@ -0,0 +1,51 @@
+#pragma once
+#include "RenderPass.h"
+
+namespace Seele
+{
+DECLARE_REF(CameraActor)
+DECLARE_REF(CameraComponent)
+DECLARE_NAME_REF(Gfx, Viewport)
+DECLARE_NAME_REF(Gfx, Graphics)
+class LightCullingPass : public RenderPass
+{
+public:
+    LightCullingPass(PRenderGraph renderGraph, Gfx::PViewport viewport, Gfx::PGraphics graphics, PCameraActor camera);
+    virtual ~LightCullingPass();
+    virtual void beginFrame() override;
+    virtual void render() override;
+    virtual void endFrame() override;
+    virtual void publishOutputs() override;
+    virtual void createRenderPass() override;
+    static void modifyRenderPassMacros(Map<const char*, const char*>& defines);
+private:
+    static constexpr uint32 BLOCK_SIZE = 8;
+    _declspec(align(16)) struct DispatchParams
+    {
+        glm::uvec3 numThreadGroups;
+        uint32_t pad0;
+        glm::uvec3 numThreads;
+        uint32_t pad1;
+    } dispatchParams;
+    __declspec(align(16)) struct Plane
+    {
+        Vector n;
+        float d;
+        Vector p0;
+        Vector p1;
+        Vector p2;
+    };
+    __declspec(align(16)) struct Frustum
+    {
+        Plane planes[4];
+    };
+    struct ScreenToView
+    {
+        Matrix4 inverseProjection;
+        Vector2 screenDimensions;
+    };
+    Gfx::PViewport viewport;
+    Gfx::PGraphics graphics;
+    PCameraComponent source;
+};
+} // namespace Seele

src/Engine/Graphics/RenderPass/RenderGraph.cpp

@@ -0,0 +1,39 @@
+#include "RenderGraph.h"
+
+using namespace Seele;
+
+
+RenderGraph::RenderGraph() 
+{
+}
+
+RenderGraph::~RenderGraph() 
+{   
+}
+
+void RenderGraph::setup() 
+{
+    for(auto pass : renderPasses)
+    {
+        pass->publishOutputs();
+    }
+    for(auto pass : renderPasses)
+    {
+        pass->createRenderPass();
+    }
+}
+
+Gfx::PRenderTargetAttachment RenderGraph::requestRenderTarget(const std::string& outputName) 
+{
+    if(registeredAttachments.find(outputName) == registeredAttachments.end())
+    {
+        std::cout << "Attachment " << outputName << " not found" << std::endl; 
+        return nullptr;
+    }
+    return registeredAttachments[outputName];
+}
+
+void RenderGraph::registerRenderPassOutput(const std::string& outputName, Gfx::PRenderTargetAttachment attachment) 
+{
+    registeredAttachments[outputName] = attachment;
+}

src/Engine/Graphics/RenderPass/RenderGraph.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "MinimalEngine.h"
+#include "Graphics/GraphicsResources.h"
+#include "RenderPass.h"
+
+namespace Seele
+{
+class RenderGraph
+{
+public:
+    RenderGraph();
+    ~RenderGraph();
+    void setup();
+    Gfx::PRenderTargetAttachment requestRenderTarget(const std::string& outputName);
+    void registerRenderPassOutput(const std::string& ouputName, Gfx::PRenderTargetAttachment attachment);
+private:
+    Map<std::string, Gfx::PRenderTargetAttachment> registeredAttachments;
+    List<PRenderPass> renderPasses;
+};
+DEFINE_REF(RenderGraph)
+} // namespace Seele

src/Engine/Graphics/RenderPass/RenderPass.cpp

@@ -0,0 +1,13 @@
+#include "RenderPass.h"
+
+using namespace Seele;
+
+RenderPass::RenderPass(PRenderGraph renderGraph) 
+    : renderGraph(renderGraph)
+{
+}
+
+RenderPass::~RenderPass() 
+{
+}
+

src/Engine/Graphics/RenderPass/RenderPass.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "MinimalEngine.h"
+#include "Math/Math.h"
+
+namespace Seele
+{
+DECLARE_NAME_REF(Gfx, RenderPass)
+DECLARE_REF(RenderGraph)
+class RenderPass
+{
+public:
+    RenderPass(PRenderGraph rendergraph);
+    virtual ~RenderPass();
+    virtual void beginFrame() = 0;
+    virtual void render() = 0;
+    virtual void endFrame() = 0;
+    virtual void publishOutputs() = 0;
+    virtual void createRenderPass() = 0;
+protected:
+    struct ViewParameter
+    {
+        Matrix4 viewMatrix;
+        Matrix4 projectionMatrix;
+        Vector4 cameraPosition;
+    } viewParams;
+    struct ScreenToViewParameter
+    {
+        Matrix4 inverseProjectionMatrix;
+        Vector2 screenDimensions;
+    } screenToViewParams;
+    Gfx::PRenderPass renderPass;
+    PRenderGraph renderGraph;
+};
+DEFINE_REF(RenderPass)
+} // namespace Seele