Adding interface for renderpass layout transitions

CMakeLists.txt

@@ -121,6 +121,11 @@ if(WIN32)
         COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_RUNTIME_DLLS:Engine> $<TARGET_FILE_DIR:Editor>
         COMMAND_EXPAND_LISTS
         DEPENDS Editor)
+elseif(APPLE)
+    add_custom_target(dll_copy ALL
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}/libslang.dylib $<TARGET_FILE_DIR:Editor>
+        COMMAND_EXPAND_LISTS
+        DEPENDS Editor)
 else()
     add_custom_target(dll_copy ALL
         COMMAND ${CMAKE_COMMAND} -E true)

src/Engine/Graphics/Buffer.h

@@ -5,19 +5,12 @@ namespace Seele
 {
 namespace Gfx
 {
-
-// IMPORTANT!! 
-// WHEN DERIVING FROM ANY Gfx:: BASE CLASSES WITH MULTIPLE INHERITANCE
-// ALWAYS PUT THE Gfx:: BASE CLASS FIRST
-// This is because the refcounting object is unique per allocation, so
-// the base address of both the Gfx:: and the implementation class
-// need to match for it to work
 class Buffer : public QueueOwnedResource
 {
 public:
     Buffer(QueueFamilyMapping mapping, QueueType startQueueType);
     virtual ~Buffer();
-
+    virtual void beginFrame() = 0;
 protected:
     // Inherited via QueueOwnedResource
     virtual void executeOwnershipBarrier(QueueType newOwner) = 0;
@@ -40,6 +33,7 @@ public:
 
     virtual void updateRegion(DataSource update) = 0;
     virtual void download(Array<uint8>& buffer) = 0;
+    virtual void beginFrame() = 0;
 protected:
     // Inherited via QueueOwnedResource
     virtual void executeOwnershipBarrier(QueueType newOwner) = 0;
@@ -65,6 +59,7 @@ public:
     }
 
     virtual void download(Array<uint8>& buffer) = 0;
+    virtual void beginFrame() = 0;
 protected:
     // Inherited via QueueOwnedResource
     virtual void executeOwnershipBarrier(QueueType newOwner) = 0;
@@ -99,6 +94,7 @@ public:
         }
         return true;
     }
+    virtual void beginFrame() = 0;
 protected:
     Array<uint8> contents;
     // Inherited via QueueOwnedResource
@@ -133,6 +129,7 @@ public:
     {
         return numElements;
     }
+    virtual void beginFrame() = 0;
 protected:
     // Inherited via QueueOwnedResource
     virtual void executeOwnershipBarrier(QueueType newOwner) = 0;

src/Engine/Graphics/Enums.h

@@ -165,7 +165,6 @@ typedef uint32 KeyModifierFlags;
 namespace Gfx
 {
 static constexpr bool useAsyncCompute = true;
-static constexpr bool waitIdleOnSubmit = false;
 static constexpr bool useMeshShading = true;
 static constexpr uint32 numFramesBuffered = 3;
 
@@ -173,6 +172,7 @@ static constexpr uint32 numFramesBuffered = 3;
 static constexpr uint32 numVerticesPerMeshlet = 64;
 static constexpr uint32 numPrimitivesPerMeshlet = 126;
 double getCurrentFrameDelta();
+uint32 getCurrentFrameIndex();
 
 enum class QueueType
 {
@@ -1670,7 +1670,7 @@ typedef enum SeDeviceQueueCreateFlagBits
 typedef SeFlags SeDeviceQueueCreateFlags;
 
 typedef enum SePipelineStageFlagBits
-{
+{ 
     SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
     SE_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
     SE_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
@@ -1688,15 +1688,16 @@ typedef enum SePipelineStageFlagBits
     SE_PIPELINE_STAGE_HOST_BIT = 0x00004000,
     SE_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
     SE_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
+    SE_PIPELINE_STAGE_NONE = 0,
     SE_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,
     SE_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
-    SE_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
+    SE_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000,
-    SE_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000,
+    SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000,
-    SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = 0x00200000,
-    SE_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000,
-    SE_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000,
-    SE_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,
     SE_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,
+    SE_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000,
+    SE_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000,
+    SE_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0x00080000,
+    SE_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0x00100000,
     SE_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } SePipelineStageFlagBits;
 typedef SeFlags SePipelineStageFlags;
@@ -1969,17 +1970,18 @@ typedef enum SeAccessFlagBits
     SE_ACCESS_HOST_WRITE_BIT = 0x00004000,
     SE_ACCESS_MEMORY_READ_BIT = 0x00008000,
     SE_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
+    SE_ACCESS_NONE = 0,
     SE_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,
     SE_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,
     SE_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,
     SE_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
-    SE_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
-    SE_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
     SE_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
-    SE_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000,
+    SE_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000,
-    SE_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000,
+    SE_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000,
-    SE_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000,
     SE_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000,
+    SE_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000,
+    SE_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000,
+    SE_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000,
     SE_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } SeAccessFlagBits;
 typedef SeFlags SeAccessFlags;

src/Engine/Graphics/Graphics.h

@@ -2,6 +2,7 @@
 #include "MinimalEngine.h"
 #include "Initializer.h"
 #include "Resources.h"
+#include "RenderTarget.h"
 #include "Containers/Array.h"
 
 namespace Seele
@@ -10,7 +11,6 @@ namespace Gfx
 {
 DECLARE_REF(Window)
 DECLARE_REF(Viewport)
-DECLARE_REF(RenderTargetLayout)
 DECLARE_REF(ShaderCompiler)
 DECLARE_REF(Texture)
 DECLARE_REF(Texture2D)
@@ -51,7 +51,7 @@ public:
     virtual OWindow createWindow(const WindowCreateInfo &createInfo) = 0;
     virtual OViewport createViewport(PWindow owner, const ViewportCreateInfo &createInfo) = 0;
 
-    virtual ORenderPass createRenderPass(ORenderTargetLayout layout, PViewport renderArea) = 0;
+    virtual ORenderPass createRenderPass(RenderTargetLayout layout, Array<SubPassDependency> dependencies, PViewport renderArea) = 0;
     virtual void beginRenderPass(PRenderPass renderPass) = 0;
     virtual void endRenderPass() = 0;
 

src/Engine/Graphics/RenderPass/BasePass.cpp

@@ -72,10 +72,8 @@ void BasePass::render()
         Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
         Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
     depthAttachment->getTexture()->pipelineBarrier(
-        Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+        Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-        Gfx::SE_ACCESS_MEMORY_READ_BIT, Gfx::SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT);
+        Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT);
-    depthAttachment->getTexture()->transferOwnership(Gfx::QueueType::GRAPHICS);
-    depthAttachment->getTexture()->changeLayout(Gfx::SE_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
 
     descriptorSets[INDEX_VIEW_PARAMS] = viewParamsSet;
     descriptorSets[INDEX_LIGHT_ENV] = scene->getLightEnvironment()->getDescriptorSet();
@@ -137,6 +135,7 @@ void BasePass::render()
                 pipelineInfo.renderPass = renderPass;
                 pipelineInfo.depthStencilState.depthCompareOp = Gfx::SE_COMPARE_OP_LESS_OR_EQUAL;
                 pipelineInfo.multisampleState.samples = viewport->getSamples();
+                pipelineInfo.colorBlend.attachmentCount = 1;
                 Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
                 command->bindPipeline(pipeline);
             }
@@ -149,6 +148,7 @@ void BasePass::render()
                 pipelineInfo.renderPass = renderPass;
                 pipelineInfo.depthStencilState.depthCompareOp = Gfx::SE_COMPARE_OP_LESS_OR_EQUAL;
                 pipelineInfo.multisampleState.samples = viewport->getSamples();
+                pipelineInfo.colorBlend.attachmentCount = 1;
                 Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
                 command->bindPipeline(pipeline);
             }
@@ -190,19 +190,40 @@ void BasePass::endFrame()
 
 void BasePass::publishOutputs() 
 {
-    colorAttachment = new Gfx::SwapchainAttachment(viewport, Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
+    colorAttachment = new Gfx::SwapchainAttachment(viewport,
+        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);
 }
 
 void BasePass::createRenderPass() 
 {
     depthAttachment = resources->requestRenderTarget("DEPTHPREPASS_DEPTH");
-    depthAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
+    depthAttachment->setLoadOp(Gfx::SE_ATTACHMENT_LOAD_OP_LOAD);
-    Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{
+    depthAttachment->setInitialLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL);
+    Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
         .colorAttachments = { colorAttachment }, 
         .depthAttachment = depthAttachment,
     };
-    renderPass = graphics->createRenderPass(std::move(layout), viewport);
+    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_NONE,
+            .dstAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+        }
+    };
+    renderPass = graphics->createRenderPass(std::move(layout), {dependency}, viewport);
     oLightIndexList = resources->requestBuffer("LIGHTCULLING_OLIGHTLIST");
     tLightIndexList = resources->requestBuffer("LIGHTCULLING_TLIGHTLIST");
     oLightGrid = resources->requestTexture("LIGHTCULLING_OLIGHTGRID");

src/Engine/Graphics/RenderPass/DebugPass.cpp

@@ -70,14 +70,25 @@ void DebugPass::publishOutputs()
 void DebugPass::createRenderPass()
 {
     Gfx::PRenderTargetAttachment baseColorAttachment = resources->requestRenderTarget("BASEPASS_COLOR");
-    baseColorAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
+    baseColorAttachment->setLoadOp(Gfx::SE_ATTACHMENT_LOAD_OP_LOAD);
+    baseColorAttachment->setInitialLayout(Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
     Gfx::PRenderTargetAttachment depthAttachment = resources->requestRenderTarget("DEPTHPREPASS_DEPTH");
-    depthAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
+    depthAttachment->setLoadOp(Gfx::SE_ATTACHMENT_LOAD_OP_LOAD);
-    Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{
+    depthAttachment->setInitialLayout(Gfx::SE_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
+    Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
         .colorAttachments = {baseColorAttachment}, 
         .depthAttachment = depthAttachment,
     };
-    renderPass = graphics->createRenderPass(std::move(layout), viewport);
+
+    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,
+    };
+    renderPass = graphics->createRenderPass(std::move(layout), {dependency}, viewport);
     
     Gfx::OPipelineLayout pipelineLayout = graphics->createPipelineLayout();
     pipelineLayout->addDescriptorLayout(0, viewParamsLayout);

src/Engine/Graphics/RenderPass/DepthPrepass.cpp

@@ -86,7 +86,7 @@ void DepthPrepass::render()
                 pipelineInfo.fragmentShader = collection->fragmentShader;
                 pipelineInfo.pipelineLayout = std::move(layout);
                 pipelineInfo.renderPass = renderPass;
-                pipelineInfo.depthStencilState.depthCompareOp = Gfx::SE_COMPARE_OP_LESS_OR_EQUAL;
+                pipelineInfo.depthStencilState.depthCompareOp = Gfx::SE_COMPARE_OP_LESS;
                 pipelineInfo.multisampleState.samples = viewport->getSamples();
                 Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
                 command->bindPipeline(pipeline);
@@ -98,6 +98,7 @@ void DepthPrepass::render()
                 pipelineInfo.fragmentShader = collection->fragmentShader;
                 pipelineInfo.pipelineLayout = std::move(layout);
                 pipelineInfo.renderPass = renderPass;
+                //pipelineInfo.depthStencilState.depthWriteEnable = false;
                 pipelineInfo.depthStencilState.depthCompareOp = Gfx::SE_COMPARE_OP_LESS_OR_EQUAL;
                 pipelineInfo.multisampleState.samples = viewport->getSamples();
                 Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
@@ -151,17 +152,27 @@ void DepthPrepass::publishOutputs()
     };
     depthBuffer = graphics->createTexture2D(depthBufferInfo);
     depthAttachment = 
-        new Gfx::RenderTargetAttachment(depthBuffer, Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
+        new 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);
     depthAttachment->clear.depthStencil.depth = 1.0f;
     resources->registerRenderPassOutput("DEPTHPREPASS_DEPTH", depthAttachment);
 }
 
 void DepthPrepass::createRenderPass() 
 {
-    Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{
+    Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
         .depthAttachment = depthAttachment,
     };
-    renderPass = graphics->createRenderPass(std::move(layout), viewport);
+    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,
+    };
+    renderPass = graphics->createRenderPass(std::move(layout), {dependency}, viewport);
 }
 
 void DepthPrepass::modifyRenderPassMacros(Map<const char*, const char*>&) 

src/Engine/Graphics/RenderPass/LightCullingPass.cpp

@@ -22,6 +22,14 @@ void LightCullingPass::beginFrame(const Component::Camera& cam)
 {
     RenderPass::beginFrame(cam);
 
+    oLightIndexCounter->pipelineBarrier(
+        Gfx::SE_ACCESS_MEMORY_WRITE_BIT | Gfx::SE_ACCESS_MEMORY_READ_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+        Gfx::SE_ACCESS_MEMORY_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT
+    );
+    tLightIndexCounter->pipelineBarrier(
+        Gfx::SE_ACCESS_MEMORY_WRITE_BIT | Gfx::SE_ACCESS_MEMORY_READ_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+        Gfx::SE_ACCESS_MEMORY_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT
+    );
     uint32 reset = 0;
     DataSource counterReset = {
         .size = sizeof(uint32),
@@ -45,23 +53,36 @@ void LightCullingPass::beginFrame(const Component::Camera& cam)
 
 void LightCullingPass::render() 
 {
+    oLightIndexCounter->pipelineBarrier(
+        Gfx::SE_ACCESS_MEMORY_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
+        Gfx::SE_ACCESS_MEMORY_WRITE_BIT | Gfx::SE_ACCESS_MEMORY_READ_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT
+    );
     oLightIndexList->pipelineBarrier( 
         Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
         Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
     oLightGrid->pipelineBarrier( 
         Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
         Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    tLightIndexCounter->pipelineBarrier(
+        Gfx::SE_ACCESS_MEMORY_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
+        Gfx::SE_ACCESS_MEMORY_WRITE_BIT | Gfx::SE_ACCESS_MEMORY_READ_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT
+    );
+    tLightIndexList->pipelineBarrier( 
+        Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    tLightGrid->pipelineBarrier( 
+        Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
     depthAttachment->pipelineBarrier(
         Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
         Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    depthAttachment->changeLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL);
     depthAttachment->transferOwnership(Gfx::QueueType::COMPUTE);
     cullingDescriptorSet->updateTexture(0, depthAttachment);
     cullingDescriptorSet->writeChanges();
     Gfx::PComputeCommand computeCommand = graphics->createComputeCommand("CullingCommand");
     computeCommand->bindPipeline(cullingPipeline);
     computeCommand->bindDescriptor({ viewParamsSet, dispatchParamsSet, cullingDescriptorSet, lightEnv->getDescriptorSet() });
-    //computeCommand->dispatch(dispatchParams.numThreadGroups.x, dispatchParams.numThreadGroups.y, dispatchParams.numThreadGroups.z);
+    computeCommand->dispatch(dispatchParams.numThreadGroups.x, dispatchParams.numThreadGroups.y, dispatchParams.numThreadGroups.z);
     Array<Gfx::PComputeCommand> commands = {computeCommand};
     graphics->executeCommands(commands);
     //std::cout << "LightCulling render()" << std::endl;

src/Engine/Graphics/RenderPass/LightCullingPass.h

@@ -52,7 +52,6 @@ private:
     
     PLightEnvironment lightEnv;
     Gfx::PTexture2D depthAttachment;
-    Gfx::OShaderBuffer frustums;
     Gfx::OShaderBuffer oLightIndexCounter;
     Gfx::OShaderBuffer tLightIndexCounter;
     Gfx::OShaderBuffer oLightIndexList;

src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp

@@ -87,14 +87,14 @@ void SkyboxRenderPass::publishOutputs()
 void SkyboxRenderPass::createRenderPass()
 {
     colorAttachment = resources->requestRenderTarget("BASEPASS_COLOR");
-    colorAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
+    //colorAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
     depthAttachment = resources->requestRenderTarget("DEPTHPREPASS_DEPTH");
-    depthAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
+    //depthAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
-    Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{
+    //Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{
-        .colorAttachments = { colorAttachment },
+    //    .colorAttachments = { colorAttachment },
-        .depthAttachment = depthAttachment
+    //    .depthAttachment = depthAttachment
-    };
+    //};
-    renderPass = graphics->createRenderPass(std::move(layout), viewport);
+    //renderPass = graphics->createRenderPass(std::move(layout), viewport);
 
     skyboxData.transformMatrix = Matrix4(1);
     skyboxData.fogColor = skybox.fogColor;

src/Engine/Graphics/RenderPass/TextPass.cpp

@@ -158,11 +158,11 @@ void TextPass::createRenderPass()
         .size = sizeof(TextData)});
     pipelineLayout->create();
 
-    Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{
+    Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
         .colorAttachments = {renderTarget},
         .depthAttachment = depthAttachment
     };
-    renderPass = graphics->createRenderPass(std::move(layout), viewport);
+    renderPass = graphics->createRenderPass(std::move(layout), {}, viewport);
     
     Gfx::LegacyPipelineCreateInfo pipelineInfo;
     pipelineInfo.vertexShader = vertexShader;

src/Engine/Graphics/RenderPass/UIPass.cpp

@@ -70,7 +70,9 @@ void UIPass::publishOutputs()
 
     depthBuffer = graphics->createTexture2D(depthBufferInfo);
     depthAttachment = 
-        new Gfx::RenderTargetAttachment(depthBuffer, Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
+        new 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);
     depthAttachment->clear.depthStencil.depth = 1.0f;
     resources->registerRenderPassOutput("UIPASS_DEPTH", depthAttachment);
 
@@ -82,7 +84,9 @@ void UIPass::publishOutputs()
     };
     colorBuffer = graphics->createTexture2D(colorBufferInfo);
     renderTarget =
-        new Gfx::RenderTargetAttachment(colorBuffer, Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
+        new Gfx::RenderTargetAttachment(colorBuffer, 
+            Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            Gfx::SE_ATTACHMENT_LOAD_OP_CLEAR, Gfx::SE_ATTACHMENT_STORE_OP_STORE);
     renderTarget->clear.color = { {0.0f, 0.0f, 0.0f, 1.0f} };
     resources->registerRenderPassOutput("UIPASS_COLOR", renderTarget);
 }
@@ -136,11 +140,11 @@ void UIPass::createRenderPass()
     pipelineLayout->addDescriptorLayout(0, descriptorLayout);
     pipelineLayout->create();
 
-    Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{
+    Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{
         .colorAttachments = { renderTarget }, 
         .depthAttachment = depthAttachment
     };
-    renderPass = graphics->createRenderPass(std::move(layout), viewport);
+    renderPass = graphics->createRenderPass(std::move(layout), {}, viewport);
     
     Gfx::LegacyPipelineCreateInfo pipelineInfo;
     pipelineInfo.vertexShader = vertexShader;

src/Engine/Graphics/RenderTarget.cpp

@@ -4,17 +4,21 @@ using namespace Seele;
 using namespace Seele::Gfx;
 
 RenderTargetAttachment::RenderTargetAttachment(PTexture2D texture,
+	SeImageLayout initialLayout,
+	SeImageLayout finalLayout,
 	SeAttachmentLoadOp loadOp,
 	SeAttachmentStoreOp storeOp,
 	SeAttachmentLoadOp stencilLoadOp,
 	SeAttachmentStoreOp stencilStoreOp)
 	: clear()
 	, componentFlags(0)
+	, texture(texture)
+	, initialLayout(initialLayout)
+	, finalLayout(finalLayout)
 	, loadOp(loadOp)
 	, storeOp(storeOp)
 	, stencilLoadOp(stencilLoadOp)
 	, stencilStoreOp(stencilStoreOp)
-	, texture(texture)
 {
 }
 

src/Engine/Graphics/RenderTarget.h

@@ -11,6 +11,8 @@ class RenderTargetAttachment
 {
 public:
     RenderTargetAttachment(PTexture2D texture,
+        SeImageLayout initialLayout,
+        SeImageLayout finalLayout,
         SeAttachmentLoadOp loadOp = SE_ATTACHMENT_LOAD_OP_LOAD,
         SeAttachmentStoreOp storeOp = SE_ATTACHMENT_STORE_OP_STORE,
         SeAttachmentLoadOp stencilLoadOp = SE_ATTACHMENT_LOAD_OP_DONT_CARE,
@@ -40,14 +42,24 @@ public:
     constexpr SeAttachmentStoreOp getStoreOp() const { return storeOp; }
     constexpr SeAttachmentLoadOp getStencilLoadOp() const { return stencilLoadOp; }
     constexpr SeAttachmentStoreOp getStencilStoreOp() const { return stencilStoreOp; }
+    constexpr SeImageLayout getInitialLayout() const { return initialLayout; }
+    constexpr SeImageLayout getFinalLayout() const { return finalLayout; }
+    constexpr void setLoadOp(SeAttachmentLoadOp val) { loadOp = val; }
+    constexpr void setStoreOp(SeAttachmentStoreOp val) { storeOp = val; }
+    constexpr void setStencilLoadOp(SeAttachmentLoadOp val) { stencilLoadOp = val; }
+    constexpr void setStencilStoreOp(SeAttachmentStoreOp val) { stencilStoreOp = val; }
+    constexpr void setInitialLayout(SeImageLayout val) { initialLayout = val; }
+    constexpr void setFinalLayout(SeImageLayout val) { finalLayout = val; }
     SeClearValue clear;
     SeColorComponentFlags componentFlags;
+protected:
+    PTexture2D texture;
+    SeImageLayout initialLayout;
+    SeImageLayout finalLayout;
     SeAttachmentLoadOp loadOp;
     SeAttachmentStoreOp storeOp;
     SeAttachmentLoadOp stencilLoadOp;
     SeAttachmentStoreOp stencilStoreOp;
-protected:
-    PTexture2D texture;
 };
 DEFINE_REF(RenderTargetAttachment)
 
@@ -55,11 +67,13 @@ class SwapchainAttachment : public RenderTargetAttachment
 {
 public:
     SwapchainAttachment(PViewport viewport,
+        SeImageLayout initialLayout,
+        SeImageLayout finalLayout,
         SeAttachmentLoadOp loadOp = SE_ATTACHMENT_LOAD_OP_LOAD,
         SeAttachmentStoreOp storeOp = SE_ATTACHMENT_STORE_OP_STORE,
         SeAttachmentLoadOp stencilLoadOp = SE_ATTACHMENT_LOAD_OP_DONT_CARE,
         SeAttachmentStoreOp stencilStoreOp = SE_ATTACHMENT_STORE_OP_DONT_CARE)
-        : RenderTargetAttachment(nullptr, loadOp, storeOp, stencilLoadOp, stencilStoreOp)
+        : RenderTargetAttachment(nullptr, initialLayout, finalLayout, loadOp, storeOp, stencilLoadOp, stencilStoreOp)
         , viewport(viewport)
     {}
     virtual ~SwapchainAttachment()
@@ -89,30 +103,40 @@ private:
     PViewport viewport;
 };
 
-class RenderTargetLayout
+struct RenderTargetLayout
 {
-public:
     Array<PRenderTargetAttachment> inputAttachments;
     Array<PRenderTargetAttachment> colorAttachments;
     Array<PRenderTargetAttachment> resolveAttachments;
     PRenderTargetAttachment depthAttachment;
     PRenderTargetAttachment depthResolveAttachment;
-    uint32 width;
-    uint32 height;
 };
-DEFINE_REF(RenderTargetLayout)
+
+struct SubPassDependency
+{
+    uint32 srcSubpass;
+    uint32 dstSubpass;
+    SePipelineStageFlags srcStage;
+    SePipelineStageFlags dstStage;
+    SeAccessFlags srcAccess;
+    SeAccessFlags dstAccess;
+};
 
 class RenderPass
 {
 public:
-    RenderPass(ORenderTargetLayout layout) : layout(std::move(layout)) {}
+    RenderPass(RenderTargetLayout layout, Array<SubPassDependency> dependencies) 
+        : layout(std::move(layout))
+        , dependencies(std::move(dependencies))
+    {}
     virtual ~RenderPass() {}
     RenderPass(RenderPass&&) = default;
     RenderPass& operator=(RenderPass&&) = default;
-    PRenderTargetLayout getLayout() const { return layout; }
+    const RenderTargetLayout& getLayout() const { return layout; }
 
 protected:
-    ORenderTargetLayout layout;
+    RenderTargetLayout layout;
+    Array<SubPassDependency> dependencies;
 };
 DEFINE_REF(RenderPass)
 }

src/Engine/Graphics/Texture.h

@@ -5,12 +5,6 @@ namespace Seele
 {
 namespace Gfx
 {
-// IMPORTANT!! 
-// WHEN DERIVING FROM ANY Gfx:: BASE CLASSES WITH MULTIPLE INHERITANCE
-// ALWAYS PUT THE Gfx:: BASE CLASS FIRST
-// This is because the refcounting object is unique per allocation, so
-// the base address of both the Gfx:: and the implementation class
-// need to match for it to work
 class Texture : public QueueOwnedResource
 {
 public:
@@ -24,7 +18,9 @@ public:
     virtual uint32 getNumFaces() const { return 1; }
     virtual SeSampleCountFlags getNumSamples() const = 0;
     virtual uint32 getMipLevels() const = 0;
-    virtual void changeLayout(SeImageLayout newLayout) = 0;
+    virtual void changeLayout(SeImageLayout newLayout, 
+        SeAccessFlags srcAccess, SePipelineStageFlags srcStage,
+        SeAccessFlags dstAccess, SePipelineStageFlags dstStage) = 0;
     virtual void download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Array<uint8>& buffer) = 0;
 protected:
     // Inherited via QueueOwnedResource
@@ -46,7 +42,9 @@ public:
     virtual uint32 getDepth() const = 0;
     virtual SeSampleCountFlags getNumSamples() const = 0;
     virtual uint32 getMipLevels() const = 0;
-    virtual void changeLayout(SeImageLayout newLayout) = 0;
+    virtual void changeLayout(SeImageLayout newLayout, 
+        SeAccessFlags srcAccess, SePipelineStageFlags srcStage,
+        SeAccessFlags dstAccess, SePipelineStageFlags dstStage) = 0;
 protected:
     //Inherited via QueueOwnedResource
     virtual void executeOwnershipBarrier(QueueType newOwner) = 0;
@@ -67,7 +65,9 @@ public:
     virtual uint32 getDepth() const = 0;
     virtual SeSampleCountFlags getNumSamples() const = 0;
     virtual uint32 getMipLevels() const = 0;
-    virtual void changeLayout(SeImageLayout newLayout) = 0;
+    virtual void changeLayout(SeImageLayout newLayout, 
+        SeAccessFlags srcAccess, SePipelineStageFlags srcStage,
+        SeAccessFlags dstAccess, SePipelineStageFlags dstStage) = 0;
 protected:
     //Inherited via QueueOwnedResource
     virtual void executeOwnershipBarrier(QueueType newOwner) = 0;
@@ -89,7 +89,9 @@ public:
     virtual uint32 getNumFaces() const { return 6; }
     virtual SeSampleCountFlags getNumSamples() const = 0;
     virtual uint32 getMipLevels() const = 0;
-    virtual void changeLayout(SeImageLayout newLayout) = 0;
+    virtual void changeLayout(SeImageLayout newLayout, 
+        SeAccessFlags srcAccess, SePipelineStageFlags srcStage,
+        SeAccessFlags dstAccess, SePipelineStageFlags dstStage) = 0;
 protected:
     //Inherited via QueueOwnedResource
     virtual void executeOwnershipBarrier(QueueType newOwner) = 0;

src/Engine/Graphics/Vulkan/Buffer.cpp

@@ -278,6 +278,11 @@ bool UniformBuffer::updateContents(const DataSource &sourceData)
     return true;
 }
 
+void UniformBuffer::beginFrame()
+{
+    Vulkan::Buffer::advanceBuffer();
+}
+
 void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
     Gfx::QueueOwnedResource::transferOwnership(newOwner);
@@ -330,6 +335,11 @@ bool ShaderBuffer::updateContents(const DataSource &sourceData)
     return true;
 }
 
+void ShaderBuffer::beginFrame()
+{
+    Vulkan::Buffer::advanceBuffer();
+}
+
 void ShaderBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
     Gfx::QueueOwnedResource::transferOwnership(newOwner);
@@ -386,6 +396,11 @@ void VertexBuffer::download(Array<uint8> &buffer)
     unmap();
 }
 
+void VertexBuffer::beginFrame()
+{
+    Vulkan::Buffer::advanceBuffer();
+}
+
 void VertexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
     Gfx::QueueOwnedResource::transferOwnership(newOwner);
@@ -435,6 +450,11 @@ void IndexBuffer::download(Array<uint8> &buffer)
     unmap();
 }
 
+void IndexBuffer::beginFrame()
+{
+    Vulkan::Buffer::advanceBuffer();
+}
+
 void IndexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
     Gfx::QueueOwnedResource::transferOwnership(newOwner);

src/Engine/Graphics/Vulkan/Buffer.h

@@ -60,6 +60,7 @@ public:
     virtual ~UniformBuffer();
     virtual bool updateContents(const DataSource &sourceData) override;
     
+    virtual void beginFrame() override;
 protected:
     // Inherited via Vulkan::Buffer
     virtual VkAccessFlags getSourceAccessMask() override;
@@ -80,6 +81,7 @@ public:
     ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo &sourceData);
     virtual ~ShaderBuffer();
     virtual bool updateContents(const DataSource &sourceData) override;
+    virtual void beginFrame() override;
 
 protected:
     // Inherited via Vulkan::Buffer
@@ -102,6 +104,7 @@ public:
 
     virtual void updateRegion(DataSource update) override;
     virtual void download(Array<uint8>& buffer) override;
+    virtual void beginFrame() override;
 protected:
     // Inherited via Vulkan::Buffer
     virtual VkAccessFlags getSourceAccessMask() override;
@@ -121,6 +124,7 @@ public:
     virtual ~IndexBuffer();
 
     virtual void download(Array<uint8>& buffer) override;
+    virtual void beginFrame() override;
 protected:
     // Inherited via Vulkan::Buffer
     virtual VkAccessFlags getSourceAccessMask() override;

src/Engine/Graphics/Vulkan/Command.cpp

@@ -76,6 +76,7 @@ void Command::beginRenderPass(PRenderPass renderPass, PFramebuffer framebuffer)
 
 void Command::endRenderPass()
 {
+    boundRenderPass->endRenderPass();
     boundRenderPass = nullptr;
     boundFramebuffer = nullptr;
     vkCmdEndRenderPass(handle);

src/Engine/Graphics/Vulkan/Debug.cpp

@@ -10,6 +10,10 @@ VkBool32 Seele::Vulkan::debugCallback(
     void*                                            pUserData)
 {
 	std::cerr << pCallbackData->pMessage << std::endl;
+	if(messageSeverity == VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
+	{
+		return VK_FALSE;
+	}
 	return VK_FALSE;
 }
 

src/Engine/Graphics/Vulkan/Enums.cpp

@@ -1552,4 +1552,245 @@ Gfx::SeSamplerMipmapMode Seele::Vulkan::cast(const VkSamplerMipmapMode &filter)
     default:
         return SE_SAMPLER_MIPMAP_MODE_MAX_ENUM;
     }
+}
+VkAccessFlagBits Seele::Vulkan::cast(const Gfx::SeAccessFlagBits &flags)
+{
+    switch(flags)
+    {
+    case SE_ACCESS_INDIRECT_COMMAND_READ_BIT:
+        return VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
+    case SE_ACCESS_INDEX_READ_BIT:
+        return VK_ACCESS_INDEX_READ_BIT;
+    case SE_ACCESS_VERTEX_ATTRIBUTE_READ_BIT:
+        return VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
+    case SE_ACCESS_UNIFORM_READ_BIT:
+        return VK_ACCESS_UNIFORM_READ_BIT;
+    case SE_ACCESS_INPUT_ATTACHMENT_READ_BIT:
+        return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
+    case SE_ACCESS_SHADER_READ_BIT:
+        return VK_ACCESS_SHADER_READ_BIT;
+    case SE_ACCESS_SHADER_WRITE_BIT:
+        return VK_ACCESS_SHADER_WRITE_BIT;
+    case SE_ACCESS_COLOR_ATTACHMENT_READ_BIT:
+        return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
+    case SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT:
+        return VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+    case SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
+        return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+    case SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
+        return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+    case SE_ACCESS_TRANSFER_READ_BIT:
+        return VK_ACCESS_TRANSFER_READ_BIT;
+    case SE_ACCESS_TRANSFER_WRITE_BIT:
+        return VK_ACCESS_TRANSFER_WRITE_BIT;
+    case SE_ACCESS_HOST_READ_BIT:
+        return VK_ACCESS_HOST_READ_BIT;
+    case SE_ACCESS_HOST_WRITE_BIT:
+        return VK_ACCESS_HOST_WRITE_BIT;
+    case SE_ACCESS_MEMORY_READ_BIT:
+        return VK_ACCESS_MEMORY_READ_BIT;
+    case SE_ACCESS_MEMORY_WRITE_BIT:
+        return VK_ACCESS_MEMORY_WRITE_BIT;
+    case SE_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
+        return VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
+    case SE_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
+        return VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT;
+    case SE_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
+        return VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT;
+    case SE_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT:
+        return VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT;
+    case SE_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
+        return VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT;
+    case SE_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
+        return VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT;
+    case SE_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV:
+        return VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV;
+    case SE_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV:
+        return VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV;
+    default:
+        return VK_ACCESS_FLAG_BITS_MAX_ENUM;
+    }
+}
+
+Gfx::SeAccessFlagBits Seele::Vulkan::cast(const VkAccessFlagBits &flags)
+{
+    switch(flags)
+    {
+    case VK_ACCESS_INDIRECT_COMMAND_READ_BIT:
+        return SE_ACCESS_INDIRECT_COMMAND_READ_BIT;
+    case VK_ACCESS_INDEX_READ_BIT:
+        return SE_ACCESS_INDEX_READ_BIT;
+    case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT:
+        return SE_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
+    case VK_ACCESS_UNIFORM_READ_BIT:
+        return SE_ACCESS_UNIFORM_READ_BIT;
+    case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT:
+        return SE_ACCESS_INPUT_ATTACHMENT_READ_BIT;
+    case VK_ACCESS_SHADER_READ_BIT:
+        return SE_ACCESS_SHADER_READ_BIT;
+    case VK_ACCESS_SHADER_WRITE_BIT:
+        return SE_ACCESS_SHADER_WRITE_BIT;
+    case VK_ACCESS_COLOR_ATTACHMENT_READ_BIT:
+        return SE_ACCESS_COLOR_ATTACHMENT_READ_BIT;
+    case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT:
+        return SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+    case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
+        return SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+    case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
+        return SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+    case VK_ACCESS_TRANSFER_READ_BIT:
+        return SE_ACCESS_TRANSFER_READ_BIT;
+    case VK_ACCESS_TRANSFER_WRITE_BIT:
+        return SE_ACCESS_TRANSFER_WRITE_BIT;
+    case VK_ACCESS_HOST_READ_BIT:
+        return SE_ACCESS_HOST_READ_BIT;
+    case VK_ACCESS_HOST_WRITE_BIT:
+        return SE_ACCESS_HOST_WRITE_BIT;
+    case VK_ACCESS_MEMORY_READ_BIT:
+        return SE_ACCESS_MEMORY_READ_BIT;
+    case VK_ACCESS_MEMORY_WRITE_BIT:
+        return SE_ACCESS_MEMORY_WRITE_BIT;
+    case VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
+        return SE_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
+    case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
+        return SE_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT;
+    case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
+        return SE_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT;
+    case VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT:
+        return SE_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT;
+    case VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
+        return SE_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT;
+    case VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
+        return SE_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT;
+    case VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV:
+        return SE_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV;
+    case VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV:
+        return SE_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV;
+    default:
+        return SE_ACCESS_FLAG_BITS_MAX_ENUM;
+    }
+}
+VkPipelineStageFlagBits Seele::Vulkan::cast(const Gfx::SePipelineStageFlagBits &flags)
+{
+    switch(flags)
+    {
+    case SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT:
+        return VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    case SE_PIPELINE_STAGE_DRAW_INDIRECT_BIT:
+        return VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
+    case SE_PIPELINE_STAGE_VERTEX_INPUT_BIT:
+        return VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
+    case SE_PIPELINE_STAGE_VERTEX_SHADER_BIT:
+        return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+    case SE_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT:
+        return VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
+    case SE_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT:
+        return VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
+    case SE_PIPELINE_STAGE_GEOMETRY_SHADER_BIT:
+        return VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+    case SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT:
+        return VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+    case SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT:
+        return VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+    case SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT:
+        return VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+    case SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT:
+        return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    case SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT:
+        return VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+    case SE_PIPELINE_STAGE_TRANSFER_BIT:
+        return VK_PIPELINE_STAGE_TRANSFER_BIT;
+    case SE_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT:
+        return VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+    case SE_PIPELINE_STAGE_HOST_BIT:
+        return VK_PIPELINE_STAGE_HOST_BIT;
+    case SE_PIPELINE_STAGE_ALL_GRAPHICS_BIT:
+        return VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+    case SE_PIPELINE_STAGE_ALL_COMMANDS_BIT:
+        return VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+    case SE_PIPELINE_STAGE_NONE:
+        return VK_PIPELINE_STAGE_NONE;
+    case SE_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT:
+        return VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
+    case SE_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT:
+        return VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT;
+    case SE_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR:
+        return VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
+    case SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR:
+        return VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
+    case SE_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT:
+        return VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT;
+    case SE_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
+        return VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
+    case SE_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV:
+        return VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV;
+    case SE_PIPELINE_STAGE_TASK_SHADER_BIT_EXT:
+        return VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT;
+    case SE_PIPELINE_STAGE_MESH_SHADER_BIT_EXT:
+        return VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT;
+    default:
+        return VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM;
+    }
+}
+Gfx::SePipelineStageFlagBits Seele::Vulkan::cast(const VkPipelineStageFlagBits &flags)
+{
+    switch(flags)
+    {
+    case VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT:
+        return SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    case VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT:
+        return SE_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
+    case VK_PIPELINE_STAGE_VERTEX_INPUT_BIT:
+        return SE_PIPELINE_STAGE_VERTEX_INPUT_BIT;
+    case VK_PIPELINE_STAGE_VERTEX_SHADER_BIT:
+        return SE_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+    case VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT:
+        return SE_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
+    case VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT:
+        return SE_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
+    case VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT:
+        return SE_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+    case VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT:
+        return SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+    case VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT:
+        return SE_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+    case VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT:
+        return SE_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+    case VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT:
+        return SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    case VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT:
+        return SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+    case VK_PIPELINE_STAGE_TRANSFER_BIT:
+        return SE_PIPELINE_STAGE_TRANSFER_BIT;
+    case VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT:
+        return SE_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+    case VK_PIPELINE_STAGE_HOST_BIT:
+        return SE_PIPELINE_STAGE_HOST_BIT;
+    case VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT:
+        return SE_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+    case VK_PIPELINE_STAGE_ALL_COMMANDS_BIT:
+        return SE_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+    case VK_PIPELINE_STAGE_NONE:
+        return SE_PIPELINE_STAGE_NONE;
+    case VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT:
+        return SE_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
+    case VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT:
+        return SE_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT;
+    case VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR:
+        return SE_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
+    case VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR:
+        return SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
+    case VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT:
+        return SE_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT;
+    case VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
+        return SE_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
+    case VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV:
+        return SE_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV;
+    case VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT:
+        return SE_PIPELINE_STAGE_TASK_SHADER_BIT_EXT;
+    case VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT:
+        return SE_PIPELINE_STAGE_MESH_SHADER_BIT_EXT;
+    default:
+        return SE_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM;
+    }
 }

src/Engine/Graphics/Vulkan/Enums.h

@@ -62,5 +62,9 @@ VkFilter cast(const Gfx::SeFilter &filter);
 Gfx::SeFilter cast(const VkFilter &filter);
 VkSamplerMipmapMode cast(const Gfx::SeSamplerMipmapMode &filter);
 Gfx::SeSamplerMipmapMode cast(const VkSamplerMipmapMode &filter);
+VkAccessFlagBits cast(const Gfx::SeAccessFlagBits &flags);
+Gfx::SeAccessFlagBits cast(const VkAccessFlagBits &flags);
+VkPipelineStageFlagBits cast(const Gfx::SePipelineStageFlagBits &flags);
+Gfx::SePipelineStageFlagBits cast(const VkPipelineStageFlagBits &flags);
 } // namespace Vulkan
 } // namespace Seele

src/Engine/Graphics/Vulkan/Framebuffer.cpp

@@ -7,7 +7,7 @@
 using namespace Seele;
 using namespace Seele::Vulkan;
 
-Framebuffer::Framebuffer(PGraphics graphics, PRenderPass renderPass, Gfx::PRenderTargetLayout renderTargetLayout)
+Framebuffer::Framebuffer(PGraphics graphics, PRenderPass renderPass, Gfx::RenderTargetLayout renderTargetLayout)
     : graphics(graphics)
     , layout(renderTargetLayout)
     , renderPass(renderPass)
@@ -17,7 +17,7 @@ Framebuffer::Framebuffer(PGraphics graphics, PRenderPass renderPass, Gfx::PRende
     Array<VkImageView> attachments;
     uint32 width = 0;
     uint32 height = 0;
-    for (auto inputAttachment : layout->inputAttachments)
+    for (auto inputAttachment : layout.inputAttachments)
     {
         PTexture2D vkInputAttachment = inputAttachment->getTexture().cast<Texture2D>();
         attachments.add(vkInputAttachment->getView());
@@ -25,7 +25,7 @@ Framebuffer::Framebuffer(PGraphics graphics, PRenderPass renderPass, Gfx::PRende
         width = std::max(width, vkInputAttachment->getWidth());
         height = std::max(height, vkInputAttachment->getHeight());
     }
-    for (auto colorAttachment : layout->colorAttachments)
+    for (auto colorAttachment : layout.colorAttachments)
     {
         PTexture2D vkColorAttachment = colorAttachment->getTexture().cast<Texture2D>();
         attachments.add(vkColorAttachment->getView());
@@ -33,7 +33,7 @@ Framebuffer::Framebuffer(PGraphics graphics, PRenderPass renderPass, Gfx::PRende
         width = std::max(width, vkColorAttachment->getWidth());
         height = std::max(height, vkColorAttachment->getHeight());
     }
-    for (auto resolveAttachment : layout->resolveAttachments)
+    for (auto resolveAttachment : layout.resolveAttachments)
     {
         PTexture2D vkResolveAttachment = resolveAttachment->getTexture().cast<Texture2D>();
         attachments.add(vkResolveAttachment->getView());
@@ -41,17 +41,17 @@ Framebuffer::Framebuffer(PGraphics graphics, PRenderPass renderPass, Gfx::PRende
         width = std::max(width, vkResolveAttachment->getWidth());
         height = std::max(height, vkResolveAttachment->getHeight());
     }
-    if (layout->depthAttachment != nullptr)
+    if (layout.depthAttachment != nullptr)
     {
-        PTexture2D vkDepthAttachment = layout->depthAttachment->getTexture().cast<Texture2D>();
+        PTexture2D vkDepthAttachment = layout.depthAttachment->getTexture().cast<Texture2D>();
         attachments.add(vkDepthAttachment->getView());
         description.depthAttachment = vkDepthAttachment->getView();
         width = std::max(width, vkDepthAttachment->getWidth());
         height = std::max(height, vkDepthAttachment->getHeight());
     }
-    if (layout->depthResolveAttachment != nullptr)
+    if (layout.depthResolveAttachment != nullptr)
     {
-        PTexture2D vkDepthAttachment = layout->depthResolveAttachment->getTexture().cast<Texture2D>();
+        PTexture2D vkDepthAttachment = layout.depthResolveAttachment->getTexture().cast<Texture2D>();
         attachments.add(vkDepthAttachment->getView());
         description.depthResolveAttachment = vkDepthAttachment->getView();
         width = std::max(width, vkDepthAttachment->getWidth());

src/Engine/Graphics/Vulkan/Framebuffer.h

@@ -22,7 +22,7 @@ struct FramebufferDescription
 class Framebuffer
 {
 public:
-    Framebuffer(PGraphics graphics, PRenderPass renderpass, Gfx::PRenderTargetLayout renderTargetLayout);
+    Framebuffer(PGraphics graphics, PRenderPass renderpass, Gfx::RenderTargetLayout renderTargetLayout);
     virtual ~Framebuffer();
     constexpr VkFramebuffer getHandle() const
     {
@@ -37,7 +37,7 @@ private:
     uint32 hash;
     PGraphics graphics;
     VkFramebuffer handle;
-    Gfx::PRenderTargetLayout layout;
+    Gfx::RenderTargetLayout layout;
     PRenderPass renderPass;
 };
 DEFINE_REF(Framebuffer)

src/Engine/Graphics/Vulkan/Graphics.cpp

@@ -80,9 +80,10 @@ Gfx::OViewport Graphics::createViewport(Gfx::PWindow owner, const ViewportCreate
 {
     return new Viewport(this, owner, viewportInfo);
 }
-Gfx::ORenderPass Graphics::createRenderPass(Gfx::ORenderTargetLayout layout, Gfx::PViewport renderArea)
+
+Gfx::ORenderPass Graphics::createRenderPass(Gfx::RenderTargetLayout layout, Array<Gfx::SubPassDependency> dependencies, Gfx::PViewport renderArea)
 {
-    return new RenderPass(this, std::move(layout), renderArea);
+    return new RenderPass(this, std::move(layout), std::move(dependencies), renderArea);
 }
 void Graphics::beginRenderPass(Gfx::PRenderPass renderPass)
 {
@@ -415,8 +416,8 @@ void Graphics::setupDebugCallback()
         .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
         .pNext = nullptr,
         .flags = 0,
-        .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT,
+        .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
-        .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
+        .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
         .pfnUserCallback = &debugCallback,
         .pUserData = nullptr,
     };

src/Engine/Graphics/Vulkan/Graphics.h

@@ -35,7 +35,7 @@ public:
     virtual Gfx::OWindow createWindow(const WindowCreateInfo &createInfo) override;
     virtual Gfx::OViewport createViewport(Gfx::PWindow owner, const ViewportCreateInfo &createInfo) override;
 
-    virtual Gfx::ORenderPass createRenderPass(Gfx::ORenderTargetLayout layout, Gfx::PViewport renderArea) override;
+    virtual Gfx::ORenderPass createRenderPass(Gfx::RenderTargetLayout layout, Array<Gfx::SubPassDependency> dependencies, Gfx::PViewport renderArea) override;
     virtual void beginRenderPass(Gfx::PRenderPass renderPass) override;
     virtual void endRenderPass() override;
 

src/Engine/Graphics/Vulkan/PipelineCache.cpp

@@ -171,12 +171,11 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::LegacyPipelineCreateInfo gf
     };
     hash = CRC::Calculate(&depthStencilState, sizeof(depthStencilState), CRC::CRC_32(), hash);
 
-    const auto& colorAttachments = gfxInfo.renderPass->getLayout()->colorAttachments;
+    Array<VkPipelineColorBlendAttachmentState> blendAttachments;
-    Array<VkPipelineColorBlendAttachmentState> blendAttachments(colorAttachments.size());
+    for(uint32 i = 0; i < gfxInfo.colorBlend.attachmentCount; ++i)
-    for(uint32 i = 0; i < colorAttachments.size(); ++i)
     {
         const Gfx::ColorBlendState::BlendAttachment& attachment = gfxInfo.colorBlend.blendAttachments[i];
-        blendAttachments[i] = {
+        blendAttachments.add() = {
             .blendEnable = attachment.blendEnable,
             .srcColorBlendFactor = (VkBlendFactor)attachment.srcColorBlendFactor,
             .dstColorBlendFactor = (VkBlendFactor)attachment.dstColorBlendFactor,
@@ -343,12 +342,11 @@ PGraphicsPipeline PipelineCache::createPipeline(Gfx::MeshPipelineCreateInfo gfxI
     };
     hash = CRC::Calculate(&depthStencilState, sizeof(depthStencilState), CRC::CRC_32(), hash);
 
-    const auto& colorAttachments = gfxInfo.renderPass->getLayout()->colorAttachments;
+    Array<VkPipelineColorBlendAttachmentState> blendAttachments;
-    Array<VkPipelineColorBlendAttachmentState> blendAttachments(colorAttachments.size());
+    for (uint32 i = 0; i < gfxInfo.colorBlend.attachmentCount; ++i)
-    for (uint32 i = 0; i < colorAttachments.size(); ++i)
     {
         const Gfx::ColorBlendState::BlendAttachment& attachment = gfxInfo.colorBlend.blendAttachments[i];
-        blendAttachments[i] = {
+        blendAttachments.add() = {
             .blendEnable = attachment.blendEnable,
             .srcColorBlendFactor = (VkBlendFactor)attachment.srcColorBlendFactor,
             .dstColorBlendFactor = (VkBlendFactor)attachment.dstColorBlendFactor,

src/Engine/Graphics/Vulkan/Queue.cpp

@@ -6,6 +6,8 @@
 using namespace Seele;
 using namespace Seele::Vulkan;
 
+static constexpr bool waitIdleOnSubmit = false;
+
 Queue::Queue(PGraphics graphics, uint32 familyIndex, uint32 queueIndex)
     : graphics(graphics)
     , familyIndex(familyIndex)
@@ -49,7 +51,7 @@ void Queue::submitCommandBuffer(PCommand command, const Array<VkSemaphore>& sign
     command->waitFlags.clear();
     command->waitSemaphores.clear();
 
-    if (Gfx::waitIdleOnSubmit)
+    if (waitIdleOnSubmit)
     {
         command->fence->wait(1000 * 1000ull);
     }

src/Engine/Graphics/Vulkan/RenderPass.cpp

@@ -8,8 +8,8 @@
 using namespace Seele;
 using namespace Seele::Vulkan;
 
-RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx::PViewport viewport)
+RenderPass::RenderPass(PGraphics graphics, Gfx::RenderTargetLayout _layout, Array<Gfx::SubPassDependency> _dependencies, Gfx::PViewport viewport)
-    : Gfx::RenderPass(std::move(_layout))
+    : Gfx::RenderPass(std::move(_layout), std::move(_dependencies))
     , graphics(graphics)
 {
     renderArea.extent.width = viewport->getWidth();
@@ -25,7 +25,7 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
     VkAttachmentReference2 depthResolveRef;
 
     uint32 attachmentCounter = 0;
-    for (auto& inputAttachment : layout->inputAttachments)
+    for (auto& inputAttachment : layout.inputAttachments)
     {
         PTexture2D image = inputAttachment->getTexture().cast<Texture2D>();
         VkAttachmentDescription2& desc = attachments.add() = {
@@ -37,8 +37,8 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
             .storeOp = cast(inputAttachment->getStoreOp()),
             .stencilLoadOp = cast(inputAttachment->getStencilLoadOp()),
             .stencilStoreOp = cast(inputAttachment->getStencilStoreOp()),
-            .initialLayout = image->isDepthStencil() ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            .initialLayout = cast(inputAttachment->getInitialLayout()),
-            .finalLayout = image->isDepthStencil() ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            .finalLayout = cast(inputAttachment->getFinalLayout()),
         };
         
         inputRefs.add() = {
@@ -46,7 +46,7 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
             .layout = desc.initialLayout,
         };
     }
-    for (auto& colorAttachment : layout->colorAttachments)
+    for (auto& colorAttachment : layout.colorAttachments)
     {
         attachments.add() = {
             .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
@@ -58,8 +58,8 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
             .storeOp = cast(colorAttachment->getStoreOp()),
             .stencilLoadOp = cast(colorAttachment->getStencilLoadOp()),
             .stencilStoreOp = cast(colorAttachment->getStencilStoreOp()),
-            .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            .initialLayout = cast(colorAttachment->getInitialLayout()),
-            .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            .finalLayout = cast(colorAttachment->getFinalLayout()),
         };
         
         VkClearValue& clearValue = clearValues.add();
@@ -75,7 +75,7 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
             .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
         };
     }
-    for (auto& resolveAttachment : layout->resolveAttachments)
+    for (auto& resolveAttachment : layout.resolveAttachments)
     {
         attachments.add() = {
             .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
@@ -87,8 +87,8 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
             .storeOp = cast(resolveAttachment->getStoreOp()),
             .stencilLoadOp = cast(resolveAttachment->getStencilLoadOp()),
             .stencilStoreOp = cast(resolveAttachment->getStencilStoreOp()),
-            .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            .initialLayout = cast(resolveAttachment->getInitialLayout()),
-            .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            .finalLayout = cast(resolveAttachment->getFinalLayout()),
         };
 
         VkClearValue& clearValue = clearValues.add();
@@ -104,27 +104,27 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
             .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
         };
     }
-    if (layout->depthAttachment != nullptr)
+    if (layout.depthAttachment != nullptr)
     {
-        PTexture2D image = layout->depthAttachment->getTexture().cast<Texture2D>();
+        PTexture2D image = layout.depthAttachment->getTexture().cast<Texture2D>();
         attachments.add() = {
             .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
             .pNext = nullptr,
             .flags = 0,
             .format = cast(image->getFormat()),
             .samples = (VkSampleCountFlagBits)image->getNumSamples(),
-            .loadOp = cast(layout->depthAttachment->getLoadOp()),
+            .loadOp = cast(layout.depthAttachment->getLoadOp()),
-            .storeOp = cast(layout->depthAttachment->getStoreOp()),
+            .storeOp = cast(layout.depthAttachment->getStoreOp()),
-            .stencilLoadOp = cast(layout->depthAttachment->getStencilLoadOp()),
+            .stencilLoadOp = cast(layout.depthAttachment->getStencilLoadOp()),
-            .stencilStoreOp = cast(layout->depthAttachment->getStencilStoreOp()),
+            .stencilStoreOp = cast(layout.depthAttachment->getStencilStoreOp()),
-            .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+            .initialLayout = cast(layout.depthAttachment->getInitialLayout()),
-            .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+            .finalLayout = cast(layout.depthAttachment->getFinalLayout()),
         };
 
         VkClearValue& clearValue = clearValues.add();
         if (attachments.back().loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR)
         {
-            clearValue = cast(layout->depthAttachment->clear);
+            clearValue = cast(layout.depthAttachment->clear);
         }
 
         depthRef = {
@@ -134,21 +134,21 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
             .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
         };
     }
-    if (layout->depthResolveAttachment != nullptr)
+    if (layout.depthResolveAttachment != nullptr)
     {
-        PTexture2D image = layout->depthResolveAttachment->getTexture().cast<Texture2D>();
+        PTexture2D image = layout.depthResolveAttachment->getTexture().cast<Texture2D>();
         attachments.add() = {
             .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
             .pNext = nullptr,
             .flags = 0,
             .format = cast(image->getFormat()),
             .samples = (VkSampleCountFlagBits)image->getNumSamples(),
-            .loadOp = cast(layout->depthResolveAttachment->getLoadOp()),
+            .loadOp = cast(layout.depthResolveAttachment->getLoadOp()),
-            .storeOp = cast(layout->depthResolveAttachment->getStoreOp()),
+            .storeOp = cast(layout.depthResolveAttachment->getStoreOp()),
-            .stencilLoadOp = cast(layout->depthResolveAttachment->getStencilLoadOp()),
+            .stencilLoadOp = cast(layout.depthResolveAttachment->getStencilLoadOp()),
-            .stencilStoreOp = cast(layout->depthResolveAttachment->getStencilStoreOp()),
+            .stencilStoreOp = cast(layout.depthResolveAttachment->getStencilStoreOp()),
-            .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+            .initialLayout = cast(layout.depthResolveAttachment->getInitialLayout()),
-            .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+            .finalLayout = cast(layout.depthResolveAttachment->getFinalLayout()),
         };
         depthResolveRef = {
             .sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,
@@ -167,7 +167,7 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
     };
     VkSubpassDescription2 subPassDesc = {
         .sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,
-        .pNext = layout->depthResolveAttachment != nullptr ? &depthResolve : nullptr,
+        .pNext = layout.depthResolveAttachment != nullptr ? &depthResolve : nullptr,
         .flags = 0,
         .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
         .inputAttachmentCount = (uint32)inputRefs.size(),
@@ -177,17 +177,20 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
         .pResolveAttachments = resolveRefs.size() > 0 ? resolveRefs.data() : nullptr,
         .pDepthStencilAttachment = &depthRef,
     };
-    VkSubpassDependency2 dependency = {
+    Array<VkSubpassDependency2> dep;
-        .sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,
+    for(const auto& d : dependencies) {
-        .pNext = nullptr,
+        dep.add() = {
-        .srcSubpass = VK_SUBPASS_EXTERNAL,
+            .sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,
-        .dstSubpass = 0,
+            .pNext = nullptr,
-        .srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+            .srcSubpass = d.srcSubpass,
-        .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+            .dstSubpass = d.dstSubpass,
-        .srcAccessMask = VK_ACCESS_MEMORY_READ_BIT,
+            .srcStageMask = d.srcStage,
-        .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+            .dstStageMask = d.dstStage,
-    };
+            .srcAccessMask = d.srcAccess,
-    
+            .dstAccessMask = d.dstAccess,
+            .dependencyFlags = 0,
+        };
+    }
     VkRenderPassCreateInfo2 info = {
         .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,
         .pNext = nullptr,
@@ -195,8 +198,8 @@ RenderPass::RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout _layout, Gfx
         .pAttachments = attachments.data(),
         .subpassCount = 1,
         .pSubpasses = &subPassDesc,
-        .dependencyCount = 1,
+        .dependencyCount = (uint32)dep.size(),
-        .pDependencies = &dependency,
+        .pDependencies = dep.data(),
     };
 
     VK_CHECK(vkCreateRenderPass2(graphics->getDevice(), &info, nullptr, &renderPass));
@@ -211,20 +214,39 @@ uint32 RenderPass::getFramebufferHash()
 {
     FramebufferDescription description;
     std::memset(&description, 0, sizeof(FramebufferDescription));
-    for (auto& inputAttachment : layout->inputAttachments)
+    for (auto& inputAttachment : layout.inputAttachments)
     {
         PTexture2D tex = inputAttachment->getTexture().cast<Texture2D>();
         description.inputAttachments[description.numInputAttachments++] = tex->getView();
     }
-    for (auto& colorAttachment : layout->colorAttachments)
+    for (auto& colorAttachment : layout.colorAttachments)
     {
         PTexture2D tex = colorAttachment->getTexture().cast<Texture2D>();
         description.colorAttachments[description.numColorAttachments++] = tex->getView();
     }
-    if (layout->depthAttachment != nullptr)
+    if (layout.depthAttachment != nullptr)
     {
-        PTexture2D tex = layout->depthAttachment->getTexture().cast<Texture2D>();
+        PTexture2D tex = layout.depthAttachment->getTexture().cast<Texture2D>();
         description.depthAttachment = tex->getView();
     }
     return CRC::Calculate(&description, sizeof(FramebufferDescription), CRC::CRC_32());
 }
+
+void Vulkan::RenderPass::endRenderPass()
+{
+    for (auto& inputAttachment : layout.inputAttachments)
+    {
+        PTexture2D tex = inputAttachment->getTexture().cast<Texture2D>();
+        tex->setLayout(inputAttachment->getFinalLayout());
+    }
+    for (auto& colorAttachment : layout.colorAttachments)
+    {
+        PTexture2D tex = colorAttachment->getTexture().cast<Texture2D>();
+        tex->setLayout(colorAttachment->getFinalLayout());
+    }
+    if (layout.depthAttachment != nullptr)
+    {
+        PTexture2D tex = layout.depthAttachment->getTexture().cast<Texture2D>();
+        tex->setLayout(layout.depthAttachment->getFinalLayout());
+    }
+}

src/Engine/Graphics/Vulkan/RenderPass.h

@@ -9,9 +9,10 @@ namespace Vulkan
 class RenderPass : public Gfx::RenderPass
 {
 public:
-    RenderPass(PGraphics graphics, Gfx::ORenderTargetLayout layout, Gfx::PViewport viewport);
+    RenderPass(PGraphics graphics, Gfx::RenderTargetLayout layout, Array<Gfx::SubPassDependency> dependencies, Gfx::PViewport viewport);
     virtual ~RenderPass();
     uint32 getFramebufferHash();
+    void endRenderPass();
     constexpr VkRenderPass getHandle() const
     {
         return renderPass;

src/Engine/Graphics/Vulkan/Texture.cpp

@@ -104,7 +104,9 @@ TextureBase::TextureBase(PGraphics graphics, VkImageViewType viewType,
         const DataSource& sourceData = createInfo.sourceData;
         if(sourceData.size > 0)
         {
-            changeLayout(Gfx::SE_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+            changeLayout(Gfx::SE_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                VK_ACCESS_NONE, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                VK_ACCESS_MEMORY_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
             void* data;
             VkMemoryPropertyFlags memProps;
             VkBuffer stagingBuffer = VK_NULL_HANDLE;
@@ -161,7 +163,9 @@ TextureBase::TextureBase(PGraphics graphics, VkImageViewType viewType,
                 stagingBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
             
             // When loading a texture from a file, we will almost always use it as a texture map for fragment shaders
-            changeLayout(Gfx::SE_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+            changeLayout(Gfx::SE_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
             if(stagingBuffer != VK_NULL_HANDLE)
             {
                 vmaUnmapMemory(graphics->getAllocator(), stagingAlloc);
@@ -169,20 +173,24 @@ TextureBase::TextureBase(PGraphics graphics, VkImageViewType viewType,
             }
         }
     }
-
     if(usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
     {
-        changeLayout(Gfx::SE_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
+        changeLayout(Gfx::SE_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+            VK_ACCESS_NONE, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT);
     }
     else if (usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
     {
-        changeLayout(Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+        changeLayout(Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            VK_ACCESS_NONE, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
     }
     else
     {
-        changeLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL);
+        changeLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL,
+            VK_ACCESS_NONE, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+            VK_ACCESS_MEMORY_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
     }
-
     VkImageViewCreateInfo viewInfo = {
         .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
         .pNext = nullptr,
@@ -210,13 +218,15 @@ TextureBase::~TextureBase()
 }
 
 
-void TextureBase::changeLayout(Gfx::SeImageLayout newLayout)
+void TextureBase::changeLayout(Gfx::SeImageLayout newLayout, 
+        VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
+        VkAccessFlags dstAccess, VkPipelineStageFlags dstStage)
 {
     VkImageMemoryBarrier barrier = {
         .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
         .pNext = nullptr,
-        .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
+        .srcAccessMask = srcAccess,
-        .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT,
+        .dstAccessMask = dstAccess,
         .oldLayout = cast(layout),
         .newLayout = cast(newLayout),
         .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
@@ -225,14 +235,14 @@ void TextureBase::changeLayout(Gfx::SeImageLayout newLayout)
         .subresourceRange = {
             .aspectMask = aspect,
             .baseMipLevel = 0,
-            .levelCount = 1,
+            .levelCount = mipLevels,
             .baseArrayLayer = 0,
             .layerCount = layerCount,
         },
     };
     PCommandPool commandPool = graphics->getQueueCommands(currentOwner);
     vkCmdPipelineBarrier(commandPool->getCommands()->getHandle(),
-                            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                            srcStage, dstStage,
                             0, 0, nullptr, 0, nullptr, 1, &barrier);
     commandPool->submitCommands();
     layout = newLayout;
@@ -243,7 +253,9 @@ void TextureBase::download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Arra
     uint64 imageSize = width * height * depth * Gfx::getFormatInfo(format).blockSize;
 
     auto prevLayout = layout;
-    changeLayout(Gfx::SE_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+    changeLayout(Gfx::SE_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+        VK_ACCESS_MEMORY_WRITE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+        VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
     void* data;
     VkBuffer stagingBuffer = VK_NULL_HANDLE;
     VmaAllocation stagingAlloc;
@@ -286,7 +298,9 @@ void TextureBase::download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Arra
         },
     };
     vkCmdCopyImageToBuffer(cmdBuffer->getHandle(), image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, stagingBuffer, 1, &region);
-    changeLayout(prevLayout);
+    changeLayout(prevLayout,
+        VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+        VK_ACCESS_MEMORY_READ_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
     VK_CHECK(vmaMapMemory(graphics->getAllocator(), stagingAlloc, &data));
     buffer.resize(imageSize);
     std::memcpy(buffer.data(), data, buffer.size());
@@ -397,9 +411,11 @@ Texture2D::~Texture2D()
 {
 }
 
-void Texture2D::changeLayout(Gfx::SeImageLayout newLayout) 
+void Texture2D::changeLayout(Gfx::SeImageLayout newLayout, 
+        Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
+        Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) 
 {
-    TextureBase::changeLayout(newLayout);
+    TextureBase::changeLayout(newLayout, srcAccess, srcStage, dstAccess, dstStage);
 }
 
 void Texture2D::download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Array<uint8>& buffer)
@@ -429,9 +445,11 @@ Texture3D::~Texture3D()
 {
 }
 
-void Texture3D::changeLayout(Gfx::SeImageLayout newLayout) 
+void Texture3D::changeLayout(Gfx::SeImageLayout newLayout, 
+        Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
+        Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) 
 {
-    TextureBase::changeLayout(newLayout);
+    TextureBase::changeLayout(newLayout, srcAccess, srcStage, dstAccess, dstStage);
 }
 
 void Texture3D::download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Array<uint8>& buffer)
@@ -460,9 +478,11 @@ TextureCube::~TextureCube()
 {
 }
 
-void TextureCube::changeLayout(Gfx::SeImageLayout newLayout) 
+void TextureCube::changeLayout(Gfx::SeImageLayout newLayout, 
+        Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
+        Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) 
 {
-    TextureBase::changeLayout(newLayout);
+    TextureBase::changeLayout(newLayout, srcAccess, srcStage, dstAccess, dstStage);
 }
 
 void TextureCube::download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Array<uint8>& buffer)

src/Engine/Graphics/Vulkan/Texture.h

@@ -36,6 +36,10 @@ public:
     {
         return layout;
     }
+    void setLayout(Gfx::SeImageLayout val)
+    {
+        layout = val;
+    }
     constexpr VkImageAspectFlags getAspect() const
     {
         return aspect;
@@ -63,7 +67,9 @@ public:
     void executeOwnershipBarrier(Gfx::QueueType newOwner);
     void executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
         VkAccessFlags dstAccess, VkPipelineStageFlags dstStage);
-    void changeLayout(Gfx::SeImageLayout newLayout);
+    void changeLayout(Gfx::SeImageLayout newLayout, 
+        VkAccessFlags srcAccess, VkPipelineStageFlags srcStage,
+        VkAccessFlags dstAccess, VkPipelineStageFlags dstStage);
     void download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Array<uint8>& buffer);
 
 protected:
@@ -118,7 +124,9 @@ public:
     {
         return mipLevels;
     }
-    virtual void changeLayout(Gfx::SeImageLayout newLayout) override;
+    virtual void changeLayout(Gfx::SeImageLayout newLayout, 
+        Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
+        Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) override;
     virtual void download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Array<uint8>& buffer) override;
 
 protected:
@@ -159,7 +167,9 @@ public:
     {
         return mipLevels;
     }
-    virtual void changeLayout(Gfx::SeImageLayout newLayout) override;
+    virtual void changeLayout(Gfx::SeImageLayout newLayout, 
+        Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
+        Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) override;
     virtual void download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Array<uint8>& buffer) override;
 
 protected:
@@ -200,7 +210,9 @@ public:
     {
         return mipLevels;
     }
-    virtual void changeLayout(Gfx::SeImageLayout newLayout) override;
+    virtual void changeLayout(Gfx::SeImageLayout newLayout, 
+        Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
+        Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) override;
     virtual void download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Array<uint8>& buffer) override;
 protected:
     // Inherited via QueueOwnedResource

src/Engine/Graphics/Vulkan/Window.cpp

@@ -66,12 +66,12 @@ Window::Window(PGraphics graphics, const WindowCreateInfo &createInfo)
     , instance(graphics->getInstance())
     , swapchain(VK_NULL_HANDLE)
 {
+    float xscale, yscale;
+    glfwGetMonitorContentScale(glfwGetPrimaryMonitor(), &xscale, &yscale);
     glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
-    GLFWwindow *handle = glfwCreateWindow(createInfo.width, createInfo.height, createInfo.title, nullptr, nullptr);
+    GLFWwindow *handle = glfwCreateWindow(createInfo.width / xscale, createInfo.height / yscale, createInfo.title, nullptr, nullptr);
     windowHandle = handle;
     glfwSetWindowUserPointer(handle, this);
-    int w, h;
-    glfwGetWindowSize(handle, &w, &h);
 
     glfwSetKeyCallback(handle, &glfwKeyCallback);
     glfwSetCursorPosCallback(handle, &glfwMouseMoveCallback);
@@ -111,13 +111,14 @@ void Window::beginFrame()
     imageAvailableFences[currentSemaphoreIndex]->wait(100000);
     imageAvailableFences[currentSemaphoreIndex]->reset();
     vkAcquireNextImageKHR(graphics->getDevice(), swapchain, std::numeric_limits<uint64>::max(), imageAvailableSemaphores[currentSemaphoreIndex]->getHandle(), imageAvailableFences[currentSemaphoreIndex]->getHandle(), &currentImageIndex);
-    graphics->getGraphicsCommands()->getCommands()->waitForSemaphore(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, imageAvailableSemaphores[currentSemaphoreIndex]);
+    graphics->getGraphicsCommands()->getCommands()->waitForSemaphore(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, imageAvailableSemaphores[currentSemaphoreIndex]);
-    swapChainTextures[currentImageIndex]->changeLayout(Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
 }
 
 void Window::endFrame()
 {
-    swapChainTextures[currentImageIndex]->changeLayout(Gfx::SE_IMAGE_LAYOUT_PRESENT_SRC_KHR);
+    swapChainTextures[currentImageIndex]->changeLayout(Gfx::SE_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+        Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        Gfx::SE_ACCESS_MEMORY_READ_BIT, Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
     graphics->getGraphicsCommands()->submitCommands(renderingDoneSemaphores[currentSemaphoreIndex]);
     VkSemaphore renderDoneHandle = renderingDoneSemaphores[currentSemaphoreIndex]->getHandle();
     VkPresentInfoKHR presentInfo = {

src/Engine/Window/GameView.cpp

@@ -19,9 +19,9 @@ GameView::GameView(Gfx::PGraphics graphics, PWindow window, const ViewportCreate
     , renderGraph(RenderGraphBuilder::build(
         DepthPrepass(graphics, scene),
         LightCullingPass(graphics, scene),
-        BasePass(graphics, scene),
+        BasePass(graphics, scene)
-        DebugPass(graphics, scene),
+        //DebugPass(graphics, scene),
-        SkyboxRenderPass(graphics, scene)
+        //SkyboxRenderPass(graphics, scene)
     ))
 {
     reloadGame();

src/Engine/Window/GameView.h

@@ -35,9 +35,9 @@ protected:
     RenderGraph<
         DepthPrepass,
 		LightCullingPass,
-        BasePass,
+        BasePass
-		DebugPass,
+		//DebugPass,
-		SkyboxRenderPass
+		//SkyboxRenderPass
 		> renderGraph;
 
 	PSystemGraph systemGraph;