diff --git a/CMakeLists.txt b/CMakeLists.txt index 0017716..8694e93 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -121,6 +121,11 @@ if(WIN32) COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ COMMAND_EXPAND_LISTS DEPENDS Editor) +elseif(APPLE) + add_custom_target(dll_copy ALL + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}/libslang.dylib $ + COMMAND_EXPAND_LISTS + DEPENDS Editor) else() add_custom_target(dll_copy ALL COMMAND ${CMAKE_COMMAND} -E true) diff --git a/src/Engine/Graphics/Buffer.h b/src/Engine/Graphics/Buffer.h index 4bed3bb..f4e732e 100644 --- a/src/Engine/Graphics/Buffer.h +++ b/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& 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& 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 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; diff --git a/src/Engine/Graphics/Enums.h b/src/Engine/Graphics/Enums.h index 1e5f25b..f412762 100644 --- a/src/Engine/Graphics/Enums.h +++ b/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_SHADING_RATE_IMAGE_BIT_NV = 0x00400000, - 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_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, + SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, 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_NV = 0x00200000, - SE_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000, + SE_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000, + SE_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 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; diff --git a/src/Engine/Graphics/Graphics.h b/src/Engine/Graphics/Graphics.h index 3292e43..8831d44 100644 --- a/src/Engine/Graphics/Graphics.h +++ b/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 dependencies, PViewport renderArea) = 0; virtual void beginRenderPass(PRenderPass renderPass) = 0; virtual void endRenderPass() = 0; diff --git a/src/Engine/Graphics/RenderPass/BasePass.cpp b/src/Engine/Graphics/RenderPass/BasePass.cpp index 514ae9e..d50060d 100644 --- a/src/Engine/Graphics/RenderPass/BasePass.cpp +++ b/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_MEMORY_READ_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); + Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_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); 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; - Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{ + depthAttachment->setLoadOp(Gfx::SE_ATTACHMENT_LOAD_OP_LOAD); + depthAttachment->setInitialLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL); + Gfx::RenderTargetLayout layout = Gfx::RenderTargetLayout{ .colorAttachments = { colorAttachment }, .depthAttachment = depthAttachment, }; - renderPass = graphics->createRenderPass(std::move(layout), viewport); + Array 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"); diff --git a/src/Engine/Graphics/RenderPass/DebugPass.cpp b/src/Engine/Graphics/RenderPass/DebugPass.cpp index b01b602..56796b8 100644 --- a/src/Engine/Graphics/RenderPass/DebugPass.cpp +++ b/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; - Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{ + depthAttachment->setLoadOp(Gfx::SE_ATTACHMENT_LOAD_OP_LOAD); + 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); diff --git a/src/Engine/Graphics/RenderPass/DepthPrepass.cpp b/src/Engine/Graphics/RenderPass/DepthPrepass.cpp index cd10cbd..aef3e1a 100644 --- a/src/Engine/Graphics/RenderPass/DepthPrepass.cpp +++ b/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&) diff --git a/src/Engine/Graphics/RenderPass/LightCullingPass.cpp b/src/Engine/Graphics/RenderPass/LightCullingPass.cpp index cc41ffc..cb92b38 100644 --- a/src/Engine/Graphics/RenderPass/LightCullingPass.cpp +++ b/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 commands = {computeCommand}; graphics->executeCommands(commands); //std::cout << "LightCulling render()" << std::endl; diff --git a/src/Engine/Graphics/RenderPass/LightCullingPass.h b/src/Engine/Graphics/RenderPass/LightCullingPass.h index 87cb551..3415c3c 100644 --- a/src/Engine/Graphics/RenderPass/LightCullingPass.h +++ b/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; diff --git a/src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp b/src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp index 08d4008..6b1b3c0 100644 --- a/src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp +++ b/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; - Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{ - .colorAttachments = { colorAttachment }, - .depthAttachment = depthAttachment - }; - renderPass = graphics->createRenderPass(std::move(layout), viewport); + //depthAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD; + //Gfx::ORenderTargetLayout layout = new Gfx::RenderTargetLayout{ + // .colorAttachments = { colorAttachment }, + // .depthAttachment = depthAttachment + //}; + //renderPass = graphics->createRenderPass(std::move(layout), viewport); skyboxData.transformMatrix = Matrix4(1); skyboxData.fogColor = skybox.fogColor; diff --git a/src/Engine/Graphics/RenderPass/TextPass.cpp b/src/Engine/Graphics/RenderPass/TextPass.cpp index 7049f43..055c338 100644 --- a/src/Engine/Graphics/RenderPass/TextPass.cpp +++ b/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; diff --git a/src/Engine/Graphics/RenderPass/UIPass.cpp b/src/Engine/Graphics/RenderPass/UIPass.cpp index e938f85..3e61aaa 100644 --- a/src/Engine/Graphics/RenderPass/UIPass.cpp +++ b/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; diff --git a/src/Engine/Graphics/RenderTarget.cpp b/src/Engine/Graphics/RenderTarget.cpp index a86f300..b4fceaa 100644 --- a/src/Engine/Graphics/RenderTarget.cpp +++ b/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) { } diff --git a/src/Engine/Graphics/RenderTarget.h b/src/Engine/Graphics/RenderTarget.h index 20707fa..fcc611a 100644 --- a/src/Engine/Graphics/RenderTarget.h +++ b/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 inputAttachments; Array colorAttachments; Array 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 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 dependencies; }; DEFINE_REF(RenderPass) } diff --git a/src/Engine/Graphics/Texture.h b/src/Engine/Graphics/Texture.h index 5b1f187..d03766f 100644 --- a/src/Engine/Graphics/Texture.h +++ b/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& 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; diff --git a/src/Engine/Graphics/Vulkan/Buffer.cpp b/src/Engine/Graphics/Vulkan/Buffer.cpp index 592fb40..24e4a87 100644 --- a/src/Engine/Graphics/Vulkan/Buffer.cpp +++ b/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 &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 &buffer) unmap(); } +void IndexBuffer::beginFrame() +{ + Vulkan::Buffer::advanceBuffer(); +} + void IndexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner) { Gfx::QueueOwnedResource::transferOwnership(newOwner); diff --git a/src/Engine/Graphics/Vulkan/Buffer.h b/src/Engine/Graphics/Vulkan/Buffer.h index c8e0b68..73fdf23 100644 --- a/src/Engine/Graphics/Vulkan/Buffer.h +++ b/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& 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& buffer) override; + virtual void beginFrame() override; protected: // Inherited via Vulkan::Buffer virtual VkAccessFlags getSourceAccessMask() override; diff --git a/src/Engine/Graphics/Vulkan/Command.cpp b/src/Engine/Graphics/Vulkan/Command.cpp index 29a173c..6f25e4a 100644 --- a/src/Engine/Graphics/Vulkan/Command.cpp +++ b/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); diff --git a/src/Engine/Graphics/Vulkan/Debug.cpp b/src/Engine/Graphics/Vulkan/Debug.cpp index ace4b8b..df313fc 100644 --- a/src/Engine/Graphics/Vulkan/Debug.cpp +++ b/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; } diff --git a/src/Engine/Graphics/Vulkan/Enums.cpp b/src/Engine/Graphics/Vulkan/Enums.cpp index bc6b258..e7b3d4b 100644 --- a/src/Engine/Graphics/Vulkan/Enums.cpp +++ b/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; + } } \ No newline at end of file diff --git a/src/Engine/Graphics/Vulkan/Enums.h b/src/Engine/Graphics/Vulkan/Enums.h index 3517445..f6fab12 100644 --- a/src/Engine/Graphics/Vulkan/Enums.h +++ b/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 diff --git a/src/Engine/Graphics/Vulkan/Framebuffer.cpp b/src/Engine/Graphics/Vulkan/Framebuffer.cpp index 0c720a4..f881324 100644 --- a/src/Engine/Graphics/Vulkan/Framebuffer.cpp +++ b/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 attachments; uint32 width = 0; uint32 height = 0; - for (auto inputAttachment : layout->inputAttachments) + for (auto inputAttachment : layout.inputAttachments) { PTexture2D vkInputAttachment = inputAttachment->getTexture().cast(); 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(); 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(); 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(); + PTexture2D vkDepthAttachment = layout.depthAttachment->getTexture().cast(); 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(); + PTexture2D vkDepthAttachment = layout.depthResolveAttachment->getTexture().cast(); attachments.add(vkDepthAttachment->getView()); description.depthResolveAttachment = vkDepthAttachment->getView(); width = std::max(width, vkDepthAttachment->getWidth()); diff --git a/src/Engine/Graphics/Vulkan/Framebuffer.h b/src/Engine/Graphics/Vulkan/Framebuffer.h index 2621c8c..38ed4e3 100644 --- a/src/Engine/Graphics/Vulkan/Framebuffer.h +++ b/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) diff --git a/src/Engine/Graphics/Vulkan/Graphics.cpp b/src/Engine/Graphics/Vulkan/Graphics.cpp index 3887530..d0045f6 100644 --- a/src/Engine/Graphics/Vulkan/Graphics.cpp +++ b/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 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, - .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_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 | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT, .pfnUserCallback = &debugCallback, .pUserData = nullptr, }; diff --git a/src/Engine/Graphics/Vulkan/Graphics.h b/src/Engine/Graphics/Vulkan/Graphics.h index 4498d68..0299859 100644 --- a/src/Engine/Graphics/Vulkan/Graphics.h +++ b/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 dependencies, Gfx::PViewport renderArea) override; virtual void beginRenderPass(Gfx::PRenderPass renderPass) override; virtual void endRenderPass() override; diff --git a/src/Engine/Graphics/Vulkan/PipelineCache.cpp b/src/Engine/Graphics/Vulkan/PipelineCache.cpp index 6e9bf2a..a252bf2 100644 --- a/src/Engine/Graphics/Vulkan/PipelineCache.cpp +++ b/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 blendAttachments(colorAttachments.size()); - for(uint32 i = 0; i < colorAttachments.size(); ++i) + Array blendAttachments; + for(uint32 i = 0; i < gfxInfo.colorBlend.attachmentCount; ++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 blendAttachments(colorAttachments.size()); - for (uint32 i = 0; i < colorAttachments.size(); ++i) + Array blendAttachments; + for (uint32 i = 0; i < gfxInfo.colorBlend.attachmentCount; ++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, diff --git a/src/Engine/Graphics/Vulkan/Queue.cpp b/src/Engine/Graphics/Vulkan/Queue.cpp index f293016..a3cd316 100644 --- a/src/Engine/Graphics/Vulkan/Queue.cpp +++ b/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& sign command->waitFlags.clear(); command->waitSemaphores.clear(); - if (Gfx::waitIdleOnSubmit) + if (waitIdleOnSubmit) { command->fence->wait(1000 * 1000ull); } diff --git a/src/Engine/Graphics/Vulkan/RenderPass.cpp b/src/Engine/Graphics/Vulkan/RenderPass.cpp index 672b1d0..5f4766f 100644 --- a/src/Engine/Graphics/Vulkan/RenderPass.cpp +++ b/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) - : Gfx::RenderPass(std::move(_layout)) +RenderPass::RenderPass(PGraphics graphics, Gfx::RenderTargetLayout _layout, Array _dependencies, Gfx::PViewport viewport) + : 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(); 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, - .finalLayout = image->isDepthStencil() ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + .initialLayout = cast(inputAttachment->getInitialLayout()), + .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, - .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + .initialLayout = cast(colorAttachment->getInitialLayout()), + .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, - .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + .initialLayout = cast(resolveAttachment->getInitialLayout()), + .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(); + PTexture2D image = layout.depthAttachment->getTexture().cast(); 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()), - .storeOp = cast(layout->depthAttachment->getStoreOp()), - .stencilLoadOp = cast(layout->depthAttachment->getStencilLoadOp()), - .stencilStoreOp = cast(layout->depthAttachment->getStencilStoreOp()), - .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + .loadOp = cast(layout.depthAttachment->getLoadOp()), + .storeOp = cast(layout.depthAttachment->getStoreOp()), + .stencilLoadOp = cast(layout.depthAttachment->getStencilLoadOp()), + .stencilStoreOp = cast(layout.depthAttachment->getStencilStoreOp()), + .initialLayout = cast(layout.depthAttachment->getInitialLayout()), + .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(); + PTexture2D image = layout.depthResolveAttachment->getTexture().cast(); 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()), - .storeOp = cast(layout->depthResolveAttachment->getStoreOp()), - .stencilLoadOp = cast(layout->depthResolveAttachment->getStencilLoadOp()), - .stencilStoreOp = cast(layout->depthResolveAttachment->getStencilStoreOp()), - .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + .loadOp = cast(layout.depthResolveAttachment->getLoadOp()), + .storeOp = cast(layout.depthResolveAttachment->getStoreOp()), + .stencilLoadOp = cast(layout.depthResolveAttachment->getStencilLoadOp()), + .stencilStoreOp = cast(layout.depthResolveAttachment->getStencilStoreOp()), + .initialLayout = cast(layout.depthResolveAttachment->getInitialLayout()), + .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 = { - .sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, - .pNext = nullptr, - .srcSubpass = VK_SUBPASS_EXTERNAL, - .dstSubpass = 0, - .srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - .srcAccessMask = VK_ACCESS_MEMORY_READ_BIT, - .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - }; - + Array dep; + for(const auto& d : dependencies) { + dep.add() = { + .sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, + .pNext = nullptr, + .srcSubpass = d.srcSubpass, + .dstSubpass = d.dstSubpass, + .srcStageMask = d.srcStage, + .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, - .pDependencies = &dependency, + .dependencyCount = (uint32)dep.size(), + .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(); description.inputAttachments[description.numInputAttachments++] = tex->getView(); } - for (auto& colorAttachment : layout->colorAttachments) + for (auto& colorAttachment : layout.colorAttachments) { PTexture2D tex = colorAttachment->getTexture().cast(); description.colorAttachments[description.numColorAttachments++] = tex->getView(); } - if (layout->depthAttachment != nullptr) + if (layout.depthAttachment != nullptr) { - PTexture2D tex = layout->depthAttachment->getTexture().cast(); + PTexture2D tex = layout.depthAttachment->getTexture().cast(); 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(); + tex->setLayout(inputAttachment->getFinalLayout()); + } + for (auto& colorAttachment : layout.colorAttachments) + { + PTexture2D tex = colorAttachment->getTexture().cast(); + tex->setLayout(colorAttachment->getFinalLayout()); + } + if (layout.depthAttachment != nullptr) + { + PTexture2D tex = layout.depthAttachment->getTexture().cast(); + tex->setLayout(layout.depthAttachment->getFinalLayout()); + } +} diff --git a/src/Engine/Graphics/Vulkan/RenderPass.h b/src/Engine/Graphics/Vulkan/RenderPass.h index ffc11d6..0377a18 100644 --- a/src/Engine/Graphics/Vulkan/RenderPass.h +++ b/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 dependencies, Gfx::PViewport viewport); virtual ~RenderPass(); uint32 getFramebufferHash(); + void endRenderPass(); constexpr VkRenderPass getHandle() const { return renderPass; diff --git a/src/Engine/Graphics/Vulkan/Texture.cpp b/src/Engine/Graphics/Vulkan/Texture.cpp index 0a06dc1..9a83d14 100644 --- a/src/Engine/Graphics/Vulkan/Texture.cpp +++ b/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, ®ion); // 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, - .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT, + .srcAccessMask = srcAccess, + .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, ®ion); - 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& 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& 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& buffer) diff --git a/src/Engine/Graphics/Vulkan/Texture.h b/src/Engine/Graphics/Vulkan/Texture.h index 08a3c5d..67adc64 100644 --- a/src/Engine/Graphics/Vulkan/Texture.h +++ b/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& 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& 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& 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& buffer) override; protected: // Inherited via QueueOwnedResource diff --git a/src/Engine/Graphics/Vulkan/Window.cpp b/src/Engine/Graphics/Vulkan/Window.cpp index 0520aab..bc700ea 100644 --- a/src/Engine/Graphics/Vulkan/Window.cpp +++ b/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::max(), imageAvailableSemaphores[currentSemaphoreIndex]->getHandle(), imageAvailableFences[currentSemaphoreIndex]->getHandle(), ¤tImageIndex); - graphics->getGraphicsCommands()->getCommands()->waitForSemaphore(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, imageAvailableSemaphores[currentSemaphoreIndex]); - swapChainTextures[currentImageIndex]->changeLayout(Gfx::SE_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + graphics->getGraphicsCommands()->getCommands()->waitForSemaphore(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, imageAvailableSemaphores[currentSemaphoreIndex]); } 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 = { diff --git a/src/Engine/Window/GameView.cpp b/src/Engine/Window/GameView.cpp index af2ea85..1b638db 100644 --- a/src/Engine/Window/GameView.cpp +++ b/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), - DebugPass(graphics, scene), - SkyboxRenderPass(graphics, scene) + BasePass(graphics, scene) + //DebugPass(graphics, scene), + //SkyboxRenderPass(graphics, scene) )) { reloadGame(); diff --git a/src/Engine/Window/GameView.h b/src/Engine/Window/GameView.h index 6717d40..332c6f3 100644 --- a/src/Engine/Window/GameView.h +++ b/src/Engine/Window/GameView.h @@ -35,9 +35,9 @@ protected: RenderGraph< DepthPrepass, LightCullingPass, - BasePass, - DebugPass, - SkyboxRenderPass + BasePass + //DebugPass, + //SkyboxRenderPass > renderGraph; PSystemGraph systemGraph;