Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adding interface for renderpass layout transitions

Browse Source
This commit is contained in:
Dynamitos
2024-01-31 09:49:53 +01:00
parent 1bf08f696b
commit 5678021c9e
34 changed files with 616 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+5
View File
@@ -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 -8
View File
@@ -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
+14 -12
View File
@@ -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
{
@@ -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;
src/Engine/Graphics/Graphics.h
+2 -2
View File
@@ -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
+29 -8
View File
@@ -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<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
+15 -4
View File
@@ -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);
src/Engine/Graphics/RenderPass/DepthPrepass.cpp
+15 -4
View File
@@ -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
+23 -2
View File
@@ -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
-1
View File
@@ -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
+7 -7
View File
@@ -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;
src/Engine/Graphics/RenderPass/TextPass.cpp
+2 -2
View File
@@ -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
+8 -4
View File
@@ -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
+5 -1
View File
@@ -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
+35 -11
View File
@@ -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
+12 -10
View File
@@ -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
+20
View File
@@ -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
+4
View File
@@ -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
+1
View File
@@ -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
+4
View File
@@ -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
+241
View File
@@ -1553,3 +1553,244 @@ Gfx::SeSamplerMipmapMode Seele::Vulkan::cast(const VkSamplerMipmapMode &filter)
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
+4
View File
@@ -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
+8 -8
View File
@@ -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
+2 -2
View File
@@ -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
+5 -4
View File
@@ -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,
.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,
};
src/Engine/Graphics/Vulkan/Graphics.h
+1 -1
View File
@@ -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
+6 -8
View File
@@ -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(colorAttachments.size());
for(uint32 i = 0; i < colorAttachments.size(); ++i)
Array<VkPipelineColorBlendAttachmentState> 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<VkPipelineColorBlendAttachmentState> blendAttachments(colorAttachments.size());
for (uint32 i = 0; i < colorAttachments.size(); ++i)
Array<VkPipelineColorBlendAttachmentState> 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,
src/Engine/Graphics/Vulkan/Queue.cpp
+3 -1
View File
@@ -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
+65 -43
View File
@@ -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<Gfx::SubPassDependency> _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<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,
.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<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()),
.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<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()),
.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 = {
Array<VkSubpassDependency2> dep;
for(const auto& d : dependencies) {
dep.add() = {
.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,
.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<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
+2 -1
View File
@@ -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
+40 -20
View File
@@ -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,
.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, &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
+16 -4
View File
@@ -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
+7 -6
View File
@@ -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]);
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 = {
src/Engine/Window/GameView.cpp
+3 -3
View File
@@ -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();
src/Engine/Window/GameView.h
+3 -3
View File
@@ -35,9 +35,9 @@ protected:
RenderGraph<
DepthPrepass,
LightCullingPass,
BasePass,
DebugPass,
SkyboxRenderPass
BasePass
//DebugPass,
//SkyboxRenderPass
> renderGraph;
PSystemGraph systemGraph;