xiaoqi
/
SHADE_Y3
1
0
Fork 0
Code Issues 12 Pull Requests Packages Projects Releases 9 Wiki Activity

Render graph fixes with attachment layouts #52

Merged
Xenosas1337 merged 11 commits from SP3-1-Rendering into main 2022-09-26 00:53:08 +08:00
Conversation 0 Commits 11 Files Changed 19 +446 -157
19 changed files with 446 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
SHADE_Application/src/Scenes/SBTestScene.cpp
View File

@ -36,12 +36,12 @@ namespace Sandbox
graphicsSystem->BuildMeshBuffers(); graphicsSystem->BuildMeshBuffers();
// Create Materials // Create Materials
auto matInst = graphicsSystem->AddMaterialInstance(); auto matInst = graphicsSystem->AddOrGetBaseMaterialInstance();
// Create Stress Test Objects // Create Stress Test Objects
static const SHVec3 TEST_OBJ_SCALE = { 0.2f, 0.2f, 0.2f }; static const SHVec3 TEST_OBJ_SCALE = { 0.2f, 0.2f, 0.2f };
constexpr int NUM_ROWS = 200; constexpr int NUM_ROWS = 1;
constexpr int NUM_COLS = 100; constexpr int NUM_COLS = 1;
static const SHVec3 TEST_OBJ_SPACING = { 1.0f, 1.0f, 1.0f }; static const SHVec3 TEST_OBJ_SPACING = { 1.0f, 1.0f, 1.0f };
static const SHVec3 TEST_OBJ_START_POS = { - (NUM_COLS / 2 * TEST_OBJ_SPACING.x ), 0.0f, 0.0f }; static const SHVec3 TEST_OBJ_START_POS = { - (NUM_COLS / 2 * TEST_OBJ_SPACING.x ), 0.0f, 0.0f };
for (int z = 0; z < NUM_ROWS; ++z) for (int z = 0; z < NUM_ROWS; ++z)

234
SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp
View File

@ -16,7 +16,7 @@ namespace SHADE
{ {
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Frees the command buffer. Frees the command buffer.
@ -30,13 +30,13 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Only the command buffer is allocated using Only the command buffer is allocated using
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT bit, is resetting VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT bit, is resetting
individually permitted. Otherwise, throw exception. IMPORTANT NOTE: individually permitted. Otherwise, throw exception. IMPORTANT NOTE:
the command buffer cannot be in the pending state!!! the command buffer cannot be in the pending state!!!
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::Reset(void) void SHVkCommandBuffer::Reset(void)
@ -67,10 +67,10 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Begins the command buffer. Begins the command buffer.
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::BeginRecording(void) noexcept void SHVkCommandBuffer::BeginRecording(void) noexcept
@ -108,10 +108,10 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
End the recording of a command buffer. End the recording of a command buffer.
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::EndRecording(void) noexcept void SHVkCommandBuffer::EndRecording(void) noexcept
@ -121,21 +121,21 @@ namespace SHADE
SHLOG_ERROR("Command Buffer not in recording state, cannot end recording. "); SHLOG_ERROR("Command Buffer not in recording state, cannot end recording. ");
return; return;
} }
vkCommandBuffer.end(); vkCommandBuffer.end();
cmdBufferState = SH_CMD_BUFFER_STATE::EXECUTABLE; cmdBufferState = SH_CMD_BUFFER_STATE::EXECUTABLE;
} }
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Begins a renderpass in the command buffer. 2 important things to note Begins a renderpass in the command buffer. 2 important things to note
here, the command buffer used MUST be a primary command buffer and here, the command buffer used MUST be a primary command buffer and
command buffer MUST be in a recording state. command buffer MUST be in a recording state.
\param renderpassHdl \param renderpassHdl
Renderpass for obvious reasons. Renderpass for obvious reasons.
\param framebufferHdl \param framebufferHdl
Framebuffer required in the begin info. Framebuffer required in the begin info.
@ -145,7 +145,7 @@ namespace SHADE
\param extent \param extent
Extent of the render area in the framebuffer. Extent of the render area in the framebuffer.
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::BeginRenderpass(Handle<SHVkRenderpass> const& renderpassHdl, Handle<SHVkFramebuffer> const& framebufferHdl, vk::Offset2D offset, vk::Extent2D extent) noexcept void SHVkCommandBuffer::BeginRenderpass(Handle<SHVkRenderpass> const& renderpassHdl, Handle<SHVkFramebuffer> const& framebufferHdl, vk::Offset2D offset, vk::Extent2D extent) noexcept
@ -170,7 +170,7 @@ namespace SHADE
vk::RenderPassBeginInfo renderPassInfo{}; vk::RenderPassBeginInfo renderPassInfo{};
renderPassInfo.renderPass = renderpassHdl->GetVkRenderpass(); renderPassInfo.renderPass = renderpassHdl->GetVkRenderpass();
renderPassInfo.framebuffer = framebufferHdl->GetVkFramebuffer(); renderPassInfo.framebuffer = framebufferHdl->GetVkFramebuffer();
// If the extent passed in is 0, use the framebuffer dimensions instead. // If the extent passed in is 0, use the framebuffer dimensions instead.
if (extent.width == 0 && extent.height == 0) if (extent.width == 0 && extent.height == 0)
renderPassInfo.renderArea.extent = framebufferExtent; renderPassInfo.renderArea.extent = framebufferExtent;
@ -192,16 +192,16 @@ namespace SHADE
} }
// Begin the render pass // Begin the render pass
vkCommandBuffer.beginRenderPass (&renderPassInfo, vk::SubpassContents::eInline); vkCommandBuffer.beginRenderPass(&renderPassInfo, vk::SubpassContents::eInline);
} }
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Ends a renderpass. Ends a renderpass.
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::EndRenderpass(void) noexcept void SHVkCommandBuffer::EndRenderpass(void) noexcept
@ -216,14 +216,14 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Sets the viewport dynamically for the command buffer. #NoteToSelf: Sets the viewport dynamically for the command buffer. #NoteToSelf:
Dynamic state will not affect pipelines that don't use dynamic state Dynamic state will not affect pipelines that don't use dynamic state
so there isn't a need to do any checks. Also, setting dynamic state like so there isn't a need to do any checks. Also, setting dynamic state like
this only needs to happen ONCE per command buffer UNLESS a different this only needs to happen ONCE per command buffer UNLESS a different
viewport is to be used for different drawing commands. viewport is to be used for different drawing commands.
\param vpWidth \param vpWidth
viewport width viewport width
@ -254,7 +254,7 @@ namespace SHADE
\param vpMaxDepth \param vpMaxDepth
viewport maximum depth value viewport maximum depth value
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::SetViewportScissor(float vpWidth, float vpHeight, uint32_t sWidth, uint32_t sHeight, float vpX /*= 0.0f*/, float vpY /*= 0.0f*/, int32_t sX /*= 0.0f*/, int32_t sY /*= 0.0f*/, float vpMinDepth /*= 0.0f*/, float vpMaxDepth /*= 1.0f*/) noexcept void SHVkCommandBuffer::SetViewportScissor(float vpWidth, float vpHeight, uint32_t sWidth, uint32_t sHeight, float vpX /*= 0.0f*/, float vpY /*= 0.0f*/, int32_t sX /*= 0.0f*/, int32_t sY /*= 0.0f*/, float vpMinDepth /*= 0.0f*/, float vpMaxDepth /*= 1.0f*/) noexcept
@ -283,13 +283,13 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Binds a pipeline object to the command buffer. Binds a pipeline object to the command buffer.
\param pipelineHdl \param pipelineHdl
The pipeline to bind. The pipeline to bind.
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::BindPipeline(Handle<SHVkPipeline> const& pipelineHdl) noexcept void SHVkCommandBuffer::BindPipeline(Handle<SHVkPipeline> const& pipelineHdl) noexcept
@ -307,7 +307,7 @@ namespace SHADE
/*! /*!
\brief \brief
Binds a buffer to the vertex buffer binding point specified in Binds a buffer to the vertex buffer binding point specified in
bindingPoint. bindingPoint.
\param bindingPoint \param bindingPoint
@ -321,29 +321,32 @@ namespace SHADE
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::BindVertexBuffer (uint32_t bindingPoint, Handle<SHVkBuffer> const& buffer, vk::DeviceSize offset) noexcept void SHVkCommandBuffer::BindVertexBuffer(uint32_t bindingPoint, Handle<SHVkBuffer> const& buffer, vk::DeviceSize offset) noexcept
{ {
if (cmdBufferState == SH_CMD_BUFFER_STATE::RECORDING) if (cmdBufferState == SH_CMD_BUFFER_STATE::RECORDING)
{ {
auto bufferHandle = buffer->GetVkBuffer(); if (buffer)
vkCommandBuffer.bindVertexBuffers (bindingPoint, 1, &bufferHandle, &offset); {
auto bufferHandle = buffer->GetVkBuffer();
vkCommandBuffer.bindVertexBuffers(bindingPoint, 1, &bufferHandle, &offset);
}
} }
} }
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Binds an index buffer to the pipeline. Binds an index buffer to the pipeline.
\param buffer \param buffer
The buffer to bind. The buffer to bind.
\param startingIndex \param startingIndex
The starting index in the index buffer. For example, 0 would mean The starting index in the index buffer. For example, 0 would mean
starting at the beginning. 5 would mean starting at byte offset starting at the beginning. 5 would mean starting at byte offset
size(uint32_t) * 5. size(uint32_t) * 5.
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::BindIndexBuffer(Handle<SHVkBuffer> const& buffer, uint32_t startingIndex) const noexcept void SHVkCommandBuffer::BindIndexBuffer(Handle<SHVkBuffer> const& buffer, uint32_t startingIndex) const noexcept
@ -351,33 +354,33 @@ namespace SHADE
if (cmdBufferState == SH_CMD_BUFFER_STATE::RECORDING) if (cmdBufferState == SH_CMD_BUFFER_STATE::RECORDING)
{ {
auto bufferHandle = buffer->GetVkBuffer(); auto bufferHandle = buffer->GetVkBuffer();
vkCommandBuffer.bindIndexBuffer (bufferHandle, sizeof (uint32_t) * startingIndex, vk::IndexType::eUint32); vkCommandBuffer.bindIndexBuffer(bufferHandle, sizeof(uint32_t) * startingIndex, vk::IndexType::eUint32);
} }
} }
void SHVkCommandBuffer::BindDescriptorSet(Handle<SHVkDescriptorSetGroup> descSetGroup, vk::PipelineBindPoint bindPoint, uint32_t firstSet, std::span<uint32_t> dynamicOffsets) void SHVkCommandBuffer::BindDescriptorSet(Handle<SHVkDescriptorSetGroup> descSetGroup, vk::PipelineBindPoint bindPoint, uint32_t firstSet, std::span<uint32_t> dynamicOffsets)
{ {
vkCommandBuffer.bindDescriptorSets (bindPoint, boundPipelineLayoutHdl->GetVkPipelineLayout(), firstSet, descSetGroup->GetVkHandle(), dynamicOffsets); vkCommandBuffer.bindDescriptorSets(bindPoint, boundPipelineLayoutHdl->GetVkPipelineLayout(), firstSet, descSetGroup->GetVkHandle(), dynamicOffsets);
} }
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Calls vkCmdDraw. Calls vkCmdDraw.
\param vertexCount \param vertexCount
How many vertices to draw How many vertices to draw
\param instanceCount \param instanceCount
Number of instances to draw Number of instances to draw
\param firstVertex \param firstVertex
First vertex in the buffer of vertices to start from First vertex in the buffer of vertices to start from
\param firstInstance \param firstInstance
First instance to start from. First instance to start from.
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::DrawArrays(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const noexcept void SHVkCommandBuffer::DrawArrays(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const noexcept
@ -387,30 +390,30 @@ namespace SHADE
SHLOG_ERROR("Command buffer must have started recording before a pipeline can be bound. "); SHLOG_ERROR("Command buffer must have started recording before a pipeline can be bound. ");
return; return;
} }
vkCommandBuffer.draw (vertexCount, instanceCount, firstVertex, firstInstance); vkCommandBuffer.draw(vertexCount, instanceCount, firstVertex, firstInstance);
} }
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Issues a non-instanced indexed draw call. Issues a non-instanced indexed draw call.
\param indexCount \param indexCount
Number of indices to draw. Number of indices to draw.
\param firstIndex \param firstIndex
Starting index. if the array was 0, 2, 5, 4, and we indicated this to be Starting index. if the array was 0, 2, 5, 4, and we indicated this to be
1. The draw call would start from index 2. 1. The draw call would start from index 2.
\param vertexOffset \param vertexOffset
Starting vertex offset. This would indicate that vertex pulling should Starting vertex offset. This would indicate that vertex pulling should
start from a certain vertex. So a vertex offset of 3 (for example) would start from a certain vertex. So a vertex offset of 3 (for example) would
mean an index of 0 would mean the 3rd vertex. mean an index of 0 would mean the 3rd vertex.
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::DrawIndexed (uint32_t indexCount, uint32_t firstIndex, uint32_t vertexOffset) const noexcept void SHVkCommandBuffer::DrawIndexed(uint32_t indexCount, uint32_t firstIndex, uint32_t vertexOffset) const noexcept
{ {
if (cmdBufferState != SH_CMD_BUFFER_STATE::RECORDING) if (cmdBufferState != SH_CMD_BUFFER_STATE::RECORDING)
{ {
@ -422,7 +425,7 @@ namespace SHADE
vkCommandBuffer.drawIndexed(indexCount, 1, firstIndex, vertexOffset, 0); vkCommandBuffer.drawIndexed(indexCount, 1, firstIndex, vertexOffset, 0);
} }
/***************************************************************************/ /***************************************************************************/
/*! /*!
@ -445,35 +448,36 @@ namespace SHADE
return; return;
} }
vkCommandBuffer.drawIndexedIndirect(indirectDrawData->GetVkBuffer(), 0, drawCount, sizeof(vk::DrawIndexedIndirectCommand)); if (indirectDrawData)
vkCommandBuffer.drawIndexedIndirect(indirectDrawData->GetVkBuffer(), 0, drawCount, sizeof(vk::DrawIndexedIndirectCommand));
} }
void SHVkCommandBuffer::CopyBufferToImage(const vk::Buffer& src, const vk::Image& dst, const std::vector<vk::BufferImageCopy>& copyInfo) void SHVkCommandBuffer::CopyBufferToImage(const vk::Buffer& src, const vk::Image& dst, const std::vector<vk::BufferImageCopy>& copyInfo)
{ {
vkCommandBuffer.copyBufferToImage vkCommandBuffer.copyBufferToImage
( (
src, dst, vk::ImageLayout::eTransferDstOptimal, src, dst, vk::ImageLayout::eTransferDstOptimal,
static_cast<uint32_t>(copyInfo.size()), copyInfo.data() static_cast<uint32_t>(copyInfo.size()), copyInfo.data()
); );
} }
void SHVkCommandBuffer::PipelineBarrier( void SHVkCommandBuffer::PipelineBarrier(
vk::PipelineStageFlags srcStage, vk::PipelineStageFlags srcStage,
vk::PipelineStageFlags dstStage, vk::PipelineStageFlags dstStage,
vk::DependencyFlags deps, vk::DependencyFlags deps,
std::vector<vk::MemoryBarrier> const& memoryBarriers, std::vector<vk::MemoryBarrier> const& memoryBarriers,
std::vector<vk::BufferMemoryBarrier> const& bufferMemoryBarriers, std::vector<vk::BufferMemoryBarrier> const& bufferMemoryBarriers,
std::vector<vk::ImageMemoryBarrier> const& imageMemoryBarriers std::vector<vk::ImageMemoryBarrier> const& imageMemoryBarriers
) const noexcept ) const noexcept
{ {
vkCommandBuffer.pipelineBarrier ( vkCommandBuffer.pipelineBarrier(
srcStage, srcStage,
dstStage, dstStage,
deps, deps,
memoryBarriers, memoryBarriers,
bufferMemoryBarriers, bufferMemoryBarriers,
imageMemoryBarriers imageMemoryBarriers
); );
} }
bool SHVkCommandBuffer::IsReadyToSubmit(void) const noexcept bool SHVkCommandBuffer::IsReadyToSubmit(void) const noexcept
@ -498,10 +502,10 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Calls vkCmdPushConstants and submits data stored in command buffer. Calls vkCmdPushConstants and submits data stored in command buffer.
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::SubmitPushConstants(void) const noexcept void SHVkCommandBuffer::SubmitPushConstants(void) const noexcept
@ -514,13 +518,13 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Simply returns the command buffer handle. Simply returns the command buffer handle.
\return \return
The command buffer handle. The command buffer handle.
*/ */
/***************************************************************************/ /***************************************************************************/
vk::CommandBuffer const& SHVkCommandBuffer::GetVkCommandBuffer(void) const noexcept vk::CommandBuffer const& SHVkCommandBuffer::GetVkCommandBuffer(void) const noexcept
@ -530,11 +534,11 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
See https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkGetRenderAreaGranularity.html See https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkGetRenderAreaGranularity.html
or look up vkGetRenderAreaGranularity. or look up vkGetRenderAreaGranularity.
\param renderpassHdl \param renderpassHdl
Renderpass to get info from. Renderpass to get info from.
@ -544,9 +548,9 @@ namespace SHADE
\param renderArea \param renderArea
For the comparison. Again, look it up on the webpage. For the comparison. Again, look it up on the webpage.
\return \return
If optimal, true. otherwise false. If optimal, true. otherwise false.
*/ */
/***************************************************************************/ /***************************************************************************/
bool SHVkCommandBuffer::IsRenderAreaOptimal(Handle<SHVkRenderpass> const& renderpassHdl, vk::Extent2D const& framebufferExtent, vk::Rect2D const& renderArea) const noexcept bool SHVkCommandBuffer::IsRenderAreaOptimal(Handle<SHVkRenderpass> const& renderpassHdl, vk::Extent2D const& framebufferExtent, vk::Rect2D const& renderArea) const noexcept
@ -558,14 +562,14 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Setter for the state of the command buffer. Setter for the state of the command buffer.
\param state \param state
\return \return
*/ */
/***************************************************************************/ /***************************************************************************/
void SHVkCommandBuffer::SetState(SH_CMD_BUFFER_STATE state) noexcept void SHVkCommandBuffer::SetState(SH_CMD_BUFFER_STATE state) noexcept
@ -575,12 +579,12 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Returns the state of the command buffer. Returns the state of the command buffer.
\return \return
*/ */
/***************************************************************************/ /***************************************************************************/
SH_CMD_BUFFER_STATE SHVkCommandBuffer::GetState(void) const noexcept SH_CMD_BUFFER_STATE SHVkCommandBuffer::GetState(void) const noexcept
@ -590,14 +594,14 @@ namespace SHADE
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Creates a command buffer. Cmd buffer can be primary or secondary. If Creates a command buffer. Cmd buffer can be primary or secondary. If
secondary, flags will automatically have renderpass continue bit. Command secondary, flags will automatically have renderpass continue bit. Command
pool used to create this command buffer will determine whether or not pool used to create this command buffer will determine whether or not
this buffer will be allocated with this buffer will be allocated with
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT using the reset mode. VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT using the reset mode.
\param logicalDevice \param logicalDevice
Need a logical device to create a buffer. Need a logical device to create a buffer.
@ -606,7 +610,7 @@ namespace SHADE
\param type \param type
Type of the command buffer; primary or secondary. Type of the command buffer; primary or secondary.
*/ */
/***************************************************************************/ /***************************************************************************/
SHVkCommandBuffer::SHVkCommandBuffer(Handle<SHVkCommandPool> const& commandPool, SH_CMD_BUFFER_TYPE type) noexcept SHVkCommandBuffer::SHVkCommandBuffer(Handle<SHVkCommandPool> const& commandPool, SH_CMD_BUFFER_TYPE type) noexcept
@ -616,7 +620,7 @@ namespace SHADE
, parentPoolResetMode{ SH_CMD_POOL_RESET::POOL_BASED } , parentPoolResetMode{ SH_CMD_POOL_RESET::POOL_BASED }
, usageFlags{} , usageFlags{}
, commandBufferCount{ 0 } , commandBufferCount{ 0 }
, parentPool{commandPool} , parentPool{ commandPool }
, pushConstantData{} , pushConstantData{}
{ {
@ -657,54 +661,54 @@ namespace SHADE
commandBufferType = type; commandBufferType = type;
commandBufferCount = allocateInfo.commandBufferCount; commandBufferCount = allocateInfo.commandBufferCount;
if (parentPool->GetIsTransient ()) if (parentPool->GetIsTransient())
usageFlags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit; usageFlags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit;
if (commandBufferType == SH_CMD_BUFFER_TYPE::SECONDARY) if (commandBufferType == SH_CMD_BUFFER_TYPE::SECONDARY)
usageFlags |= vk::CommandBufferUsageFlagBits::eRenderPassContinue; usageFlags |= vk::CommandBufferUsageFlagBits::eRenderPassContinue;
// Reset all the push constant data to 0 // Reset all the push constant data to 0
memset (pushConstantData, 0, PUSH_CONSTANT_SIZE); memset(pushConstantData, 0, PUSH_CONSTANT_SIZE);
} }
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Move ctor. Invalidates Vulkan handles. Move ctor. Invalidates Vulkan handles.
\param rhs \param rhs
the other command buffer. the other command buffer.
*/ */
/***************************************************************************/ /***************************************************************************/
SHVkCommandBuffer::SHVkCommandBuffer(SHVkCommandBuffer&& rhs) noexcept SHVkCommandBuffer::SHVkCommandBuffer(SHVkCommandBuffer&& rhs) noexcept
: vkCommandBuffer {std::move (rhs.vkCommandBuffer)} : vkCommandBuffer{ std::move(rhs.vkCommandBuffer) }
, cmdBufferState {rhs.cmdBufferState} , cmdBufferState{ rhs.cmdBufferState }
, commandBufferType {rhs.commandBufferType} , commandBufferType{ rhs.commandBufferType }
, parentPoolResetMode {rhs.parentPoolResetMode} , parentPoolResetMode{ rhs.parentPoolResetMode }
, usageFlags {rhs.usageFlags} , usageFlags{ rhs.usageFlags }
, commandBufferCount {rhs.commandBufferCount} , commandBufferCount{ rhs.commandBufferCount }
, parentPool {rhs.parentPool} , parentPool{ rhs.parentPool }
, boundPipelineLayoutHdl{rhs.boundPipelineLayoutHdl } , boundPipelineLayoutHdl{ rhs.boundPipelineLayoutHdl }
{ {
memcpy (pushConstantData, rhs.pushConstantData, PUSH_CONSTANT_SIZE); memcpy(pushConstantData, rhs.pushConstantData, PUSH_CONSTANT_SIZE);
rhs.vkCommandBuffer = VK_NULL_HANDLE; rhs.vkCommandBuffer = VK_NULL_HANDLE;
} }
/***************************************************************************/ /***************************************************************************/
/*! /*!
\brief \brief
Move assignment operator. Invalidates Vulkan handles. Move assignment operator. Invalidates Vulkan handles.
\param rhs \param rhs
The other Vulkan Handle. The other Vulkan Handle.
\return \return
a reference itself. a reference itself.
*/ */
/***************************************************************************/ /***************************************************************************/
SHVkCommandBuffer& SHVkCommandBuffer::operator=(SHVkCommandBuffer&& rhs) noexcept SHVkCommandBuffer& SHVkCommandBuffer::operator=(SHVkCommandBuffer&& rhs) noexcept

3
SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorPool.h
View File

@ -39,7 +39,8 @@ namespace SHADE
std::vector<vk::DescriptorPoolSize> Limits = std::vector<vk::DescriptorPoolSize> Limits =
{ {
{ vk::DescriptorType::eCombinedImageSampler, 100 }, { vk::DescriptorType::eCombinedImageSampler, 100 },
{ vk::DescriptorType::eUniformBuffer, 100 } { vk::DescriptorType::eUniformBuffer, 100 },
{ vk::DescriptorType::eUniformBufferDynamic, 100 }
}; };
/// <summary> /// <summary>
/// Maximum number of descriptor sets allowed /// Maximum number of descriptor sets allowed

94
SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.cpp
View File

@ -58,6 +58,9 @@ namespace SHADE
// Add renderable in // Add renderable in
subBatch->Renderables.insert(renderable); subBatch->Renderables.insert(renderable);
// Also add material instance in
referencedMatInstances.insert(renderable->GetMaterial());
// Mark all as dirty // Mark all as dirty
setAllDirtyFlags(); setAllDirtyFlags();
} }
@ -67,8 +70,8 @@ namespace SHADE
// Check if we have a SubBatch with the same mesh yet // Check if we have a SubBatch with the same mesh yet
auto subBatch = std::find_if(subBatches.begin(), subBatches.end(), [&](const SHSubBatch& batch) auto subBatch = std::find_if(subBatches.begin(), subBatches.end(), [&](const SHSubBatch& batch)
{ {
return batch.Mesh == renderable->Mesh; return batch.Mesh == renderable->Mesh;
}); });
// Attempt to remove if it exists // Attempt to remove if it exists
if (subBatch == subBatches.end()) if (subBatch == subBatches.end())
@ -76,6 +79,22 @@ namespace SHADE
subBatch->Renderables.erase(renderable); subBatch->Renderables.erase(renderable);
// Check if other renderables in subBatches contain the same material instance
bool matUnused = true;
for (const auto& sb : subBatches)
for (const auto& rend : sb.Renderables)
{
if (rend->GetMaterial() == renderable->GetMaterial())
{
matUnused = false;
break;
}
}
// Material is no longer in this library, so we remove it
if (matUnused)
referencedMatInstances.erase(renderable->GetMaterial());
// Mark all as dirty // Mark all as dirty
for (bool& dirt : isDirty) for (bool& dirt : isDirty)
dirt = true; dirt = true;
@ -101,7 +120,61 @@ namespace SHADE
} }
} }
void SHBatch::UpdateTransformBuffer(uint32_t frameIndex) void SHBatch::UpdateMaterialBuffer(uint32_t frameIndex)
{
if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS)
{
SHLOG_WARNING("[SHBatch] Attempted to update transform buffers with an invalid frame index.");
return;
}
// Check if there are even material properties to update
if (!matPropsData)
return;
// Check if any materials have changed
bool hasChanged = false;
for (const auto& material : referencedMatInstances)
{
if (material->HasChanged())
{
hasChanged = true;
break;
}
}
// We need to update all the material buffers if the materials have changed
if (hasChanged)
{
for (auto& dirt : matBufferDirty)
dirt = true;
}
// Check if this frame's buffer is dirty
if (!matBufferDirty[frameIndex])
return;
// Build CPI Buffer
char* propsCurrPtr = matPropsData.get();
for (auto& subBatch : subBatches)
for (const SHRenderable* renderable : subBatch.Renderables)
{
renderable->GetMaterial()->ExportProperties(propsCurrPtr);
propsCurrPtr += singleMatPropSize;
}
// Transfer to GPU
SHVkUtil::EnsureBufferAndCopyHostVisibleData
(
device, matPropsBuffer[frameIndex], matPropsData.get(), static_cast<uint32_t>(matPropsDataSize),
vk::BufferUsageFlagBits::eStorageBuffer
);
// This frame is updated
matBufferDirty[frameIndex] = false;
}
void SHBatch::UpdateTransformBuffer(uint32_t frameIndex)
{ {
if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS) if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS)
{ {
@ -130,10 +203,11 @@ namespace SHADE
} }
// Transfer to GPU // Transfer to GPU
transformDataBuffer[frameIndex]->WriteToMemory(transformData.data(), transformData.size() * sizeof(SHMatrix), 0, 0); if (transformDataBuffer[frameIndex])
transformDataBuffer[frameIndex]->WriteToMemory(transformData.data(), static_cast<uint32_t>(transformData.size() * sizeof(SHMatrix)), 0, 0);
} }
void SHBatch::Build(Handle<SHVkLogicalDevice> device, uint32_t frameIndex) void SHBatch::Build(Handle<SHVkLogicalDevice> _device, uint32_t frameIndex)
{ {
if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS) if (frameIndex >= SHGraphicsConstants::NUM_FRAME_BUFFERS)
{ {
@ -169,7 +243,6 @@ namespace SHADE
vk::ShaderStageFlagBits::eFragment vk::ShaderStageFlagBits::eFragment
); );
const bool EMPTY_MAT_PROPS = !SHADER_INFO; const bool EMPTY_MAT_PROPS = !SHADER_INFO;
Byte singleMatPropSize = 0;
Byte matPropTotalBytes = 0; Byte matPropTotalBytes = 0;
if (!EMPTY_MAT_PROPS) if (!EMPTY_MAT_PROPS)
{ {
@ -231,14 +304,14 @@ namespace SHADE
const uint32_t DRAW_DATA_BYTES = static_cast<uint32_t>(drawData.size() * sizeof(vk::DrawIndexedIndirectCommand)); const uint32_t DRAW_DATA_BYTES = static_cast<uint32_t>(drawData.size() * sizeof(vk::DrawIndexedIndirectCommand));
SHVkUtil::EnsureBufferAndCopyHostVisibleData SHVkUtil::EnsureBufferAndCopyHostVisibleData
( (
device, drawDataBuffer[frameIndex], drawData.data(), DRAW_DATA_BYTES, _device, drawDataBuffer[frameIndex], drawData.data(), DRAW_DATA_BYTES,
BuffUsage::eIndirectBuffer BuffUsage::eIndirectBuffer
); );
// - Transform Buffer // - Transform Buffer
const uint32_t TF_DATA_BYTES = static_cast<uint32_t>(transformData.size() * sizeof(SHMatrix)); const uint32_t TF_DATA_BYTES = static_cast<uint32_t>(transformData.size() * sizeof(SHMatrix));
SHVkUtil::EnsureBufferAndCopyHostVisibleData SHVkUtil::EnsureBufferAndCopyHostVisibleData
( (
device, transformDataBuffer[frameIndex], transformData.data(), TF_DATA_BYTES, _device, transformDataBuffer[frameIndex], transformData.data(), TF_DATA_BYTES,
BuffUsage::eVertexBuffer BuffUsage::eVertexBuffer
); );
// - Material Properties Buffer // - Material Properties Buffer
@ -246,12 +319,15 @@ namespace SHADE
{ {
SHVkUtil::EnsureBufferAndCopyHostVisibleData SHVkUtil::EnsureBufferAndCopyHostVisibleData
( (
device, matPropsBuffer[frameIndex], matPropsData.get(), static_cast<uint32_t>(matPropsDataSize), _device, matPropsBuffer[frameIndex], matPropsData.get(), static_cast<uint32_t>(matPropsDataSize),
BuffUsage::eStorageBuffer BuffUsage::eStorageBuffer
); );
} }
isDirty[frameIndex] = false; isDirty[frameIndex] = false;
// Save logical device
this->device = _device;
} }
/*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/

7
SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.h
View File

@ -34,6 +34,7 @@ namespace SHADE
class SHMesh; class SHMesh;
class SHRenderable; class SHRenderable;
class SHVkLogicalDevice; class SHVkLogicalDevice;
class SHMaterialInstance;
/*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/
/* Type Definitions */ /* Type Definitions */
@ -73,6 +74,7 @@ namespace SHADE
void Add(const SHRenderable* renderable); void Add(const SHRenderable* renderable);
void Remove(const SHRenderable* renderable); void Remove(const SHRenderable* renderable);
void Clear(); void Clear();
void UpdateMaterialBuffer(uint32_t frameIndex);
void UpdateTransformBuffer(uint32_t frameIndex); void UpdateTransformBuffer(uint32_t frameIndex);
void Build(Handle<SHVkLogicalDevice> device, uint32_t frameIndex); void Build(Handle<SHVkLogicalDevice> device, uint32_t frameIndex);
void Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex); void Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex);
@ -86,8 +88,12 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/ /*-----------------------------------------------------------------------------*/
/* Data Members */ /* Data Members */
/*-----------------------------------------------------------------------------*/ /*-----------------------------------------------------------------------------*/
// Resources
Handle<SHVkLogicalDevice> device;
// Batch Properties // Batch Properties
Handle<SHVkPipeline> pipeline; Handle<SHVkPipeline> pipeline;
std::unordered_set<Handle<SHMaterialInstance>> referencedMatInstances;
std::array<bool, SHGraphicsConstants::NUM_FRAME_BUFFERS> matBufferDirty;
// Batch Tree // Batch Tree
std::vector<SHSubBatch> subBatches; std::vector<SHSubBatch> subBatches;
std::array<bool, SHGraphicsConstants::NUM_FRAME_BUFFERS> isDirty; std::array<bool, SHGraphicsConstants::NUM_FRAME_BUFFERS> isDirty;
@ -96,6 +102,7 @@ namespace SHADE
std::vector<SHMatrix> transformData; std::vector<SHMatrix> transformData;
std::unique_ptr<char> matPropsData; std::unique_ptr<char> matPropsData;
Byte matPropsDataSize = 0; Byte matPropsDataSize = 0;
Byte singleMatPropSize = 0;
bool isCPUBuffersDirty = true; bool isCPUBuffersDirty = true;
// GPU Buffers // GPU Buffers
std::array<Handle<SHVkBuffer>, SHGraphicsConstants::NUM_FRAME_BUFFERS> drawDataBuffer; std::array<Handle<SHVkBuffer>, SHGraphicsConstants::NUM_FRAME_BUFFERS> drawDataBuffer;

6
SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.cpp
View File

@ -109,11 +109,11 @@ namespace SHADE
superBatches.clear(); superBatches.clear();
} }
void SHBatcher::UpdateTransformBuffer(uint32_t frameIndex) void SHBatcher::UpdateBuffers(uint32_t frameIndex)
{ {
for (auto& batch : superBatches) for (auto& batch : superBatches)
{ {
batch->UpdateTransformBuffer(frameIndex); batch->UpdateBuffers(frameIndex);
} }
} }

2
SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.h
View File

@ -53,7 +53,7 @@ namespace SHADE
void RemoveFromBatch(SHRenderable const* renderable); void RemoveFromBatch(SHRenderable const* renderable);
void FinaliseBatches(Handle<SHVkLogicalDevice> device, uint32_t frameIndex); void FinaliseBatches(Handle<SHVkLogicalDevice> device, uint32_t frameIndex);
void ClearBatches(); void ClearBatches();
void UpdateTransformBuffer(uint32_t frameIndex); void UpdateBuffers(uint32_t frameIndex);
void RegisterSuperBatch(Handle<SHSuperBatch> superBatch); void RegisterSuperBatch(Handle<SHSuperBatch> superBatch);
void DeregisterSuperBatch(Handle<SHSuperBatch> superBatch); void DeregisterSuperBatch(Handle<SHSuperBatch> superBatch);

3
SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.cpp
View File

@ -78,10 +78,11 @@ namespace SHADE
batches.clear(); batches.clear();
} }
void SHSuperBatch::UpdateTransformBuffer(uint32_t frameIndex) void SHSuperBatch::UpdateBuffers(uint32_t frameIndex)
{ {
for (auto& batch : batches) for (auto& batch : batches)
{ {
batch.UpdateMaterialBuffer(frameIndex);
batch.UpdateTransformBuffer(frameIndex); batch.UpdateTransformBuffer(frameIndex);
} }
} }

4
SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.h
View File

@ -54,8 +54,8 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/ /*-----------------------------------------------------------------------------*/
void Add(const SHRenderable* renderable) noexcept; void Add(const SHRenderable* renderable) noexcept;
void Remove(const SHRenderable* renderable) noexcept; void Remove(const SHRenderable* renderable) noexcept;
void Clear() noexcept; void Clear() noexcept;
void UpdateTransformBuffer(uint32_t frameIndex); void UpdateBuffers(uint32_t frameIndex);
void Build(Handle<SHVkLogicalDevice> device, uint32_t frameIndex) noexcept; void Build(Handle<SHVkLogicalDevice> device, uint32_t frameIndex) noexcept;
void Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept; void Draw(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept;

19
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp
View File

@ -150,9 +150,9 @@ namespace SHADE
//compositeSubpass->AddInput("Position"); //compositeSubpass->AddInput("Position");
// TODO: Use macro to add this node when SH_EDITOR is enabled // TODO: Use macro to add this node when SH_EDITOR is enabled
//auto imguiNode = worldRenderGraph->AddNode("ImGui Node", { "Present" }, {}); auto imguiNode = worldRenderGraph->AddNode("ImGui Node", { "Present" }, {"G-Buffer"});
//auto imguiSubpass = imguiNode->AddSubpass("ImGui Draw"); auto imguiSubpass = imguiNode->AddSubpass("ImGui Draw");
//imguiSubpass->AddColorOutput("Present"); imguiSubpass->AddColorOutput("Present");
worldRenderGraph->Generate(); worldRenderGraph->Generate();
@ -415,14 +415,19 @@ namespace SHADE
resourceManager.Free(material); resourceManager.Free(material);
} }
Handle<SHMaterialInstance> SHGraphicsSystem::AddMaterialInstance(Handle<SHMaterial> material) Handle<SHMaterialInstance> SHGraphicsSystem::AddOrGetBaseMaterialInstance(Handle<SHMaterial> material)
{ {
return resourceManager.Create<SHMaterialInstance>(material); return materialInstanceCache.CreateOrGet(resourceManager, material);
} }
SHADE::Handle<SHADE::SHMaterialInstance> SHGraphicsSystem::AddMaterialInstance() SHADE::Handle<SHADE::SHMaterialInstance> SHGraphicsSystem::AddOrGetBaseMaterialInstance()
{ {
return AddMaterialInstance(defaultMaterial); return AddOrGetBaseMaterialInstance(defaultMaterial);
}
SHADE::Handle<SHADE::SHMaterialInstance> SHGraphicsSystem::AddMaterialInstanceCopy(Handle<SHMaterialInstance> materialInst)
{
return resourceManager.Create<SHMaterialInstance>(materialInst->GetBaseMaterial());
} }
void SHGraphicsSystem::RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance) void SHGraphicsSystem::RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance)

11
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h
View File

@ -28,6 +28,7 @@ of DigiPen Institute of Technology is prohibited.
#include "Graphics/MiddleEnd/Shaders/SHShaderSourceLibrary.h" #include "Graphics/MiddleEnd/Shaders/SHShaderSourceLibrary.h"
#include "Graphics/MiddleEnd/Shaders/SHShaderModuleLibrary.h" #include "Graphics/MiddleEnd/Shaders/SHShaderModuleLibrary.h"
#include "SHMeshLibrary.h" #include "SHMeshLibrary.h"
#include "Graphics/MiddleEnd/Materials/SHMaterialInstanceCache.h"
namespace SHADE namespace SHADE
{ {
@ -119,9 +120,10 @@ namespace SHADE
/* Material Creation Functions */ /* Material Creation Functions */
/*-----------------------------------------------------------------------------*/ /*-----------------------------------------------------------------------------*/
Handle<SHMaterial> AddMaterial(Handle<SHVkShaderModule> vertShader, Handle<SHVkShaderModule> fragShader, Handle<SHSubpass> subpass); Handle<SHMaterial> AddMaterial(Handle<SHVkShaderModule> vertShader, Handle<SHVkShaderModule> fragShader, Handle<SHSubpass> subpass);
void RemoveMaterial(Handle<SHMaterial> material);; void RemoveMaterial(Handle<SHMaterial> material);
Handle<SHMaterialInstance> AddMaterialInstance(); Handle<SHMaterialInstance> AddOrGetBaseMaterialInstance();
Handle<SHMaterialInstance> AddMaterialInstance(Handle<SHMaterial> material); Handle<SHMaterialInstance> AddOrGetBaseMaterialInstance(Handle<SHMaterial> material);
Handle<SHMaterialInstance> AddMaterialInstanceCopy(Handle<SHMaterialInstance> materialInst);
void RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance); void RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance);
/*-----------------------------------------------------------------------------*/ /*-----------------------------------------------------------------------------*/
@ -228,8 +230,9 @@ namespace SHADE
Handle<SHGraphicsGlobalData> globalData; Handle<SHGraphicsGlobalData> globalData;
// Middle End Resources // Middle End Resources
ResourceManager resourceManager; ResourceManager resourceManager;
SHMeshLibrary meshLibrary; SHMeshLibrary meshLibrary;
SHMaterialInstanceCache materialInstanceCache;
// Viewports // Viewports
Handle<SHViewport> defaultViewport; // Whole screen Handle<SHViewport> defaultViewport; // Whole screen
std::vector<Handle<SHViewport>> viewports; // Additional viewports std::vector<Handle<SHViewport>> viewports; // Additional viewports

5
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.cpp
View File

@ -38,7 +38,7 @@ namespace SHADE
dataStore.reset(); dataStore.reset();
} }
void SHMaterialInstance::ExportProperties(void* dest) const void SHMaterialInstance::ExportProperties(void* dest)
{ {
assert(dataStore != nullptr); assert(dataStore != nullptr);
@ -62,6 +62,9 @@ namespace SHADE
const auto DATA_OFFSET = variable->offset; const auto DATA_OFFSET = variable->offset;
memcpy(static_cast<char*>(dest) + DATA_OFFSET, dataStore.get() + data.StoredDataOffset, data.DataSize); memcpy(static_cast<char*>(dest) + DATA_OFFSET, dataStore.get() + data.StoredDataOffset, data.DataSize);
} }
// Data was exported so unflag
dataWasChanged = false;
} }
/*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/

6
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.h
View File

@ -62,12 +62,13 @@ namespace SHADE
template<typename T> template<typename T>
const T& GetProperty(const std::string& key) const; const T& GetProperty(const std::string& key) const;
void ResetProperties() noexcept; void ResetProperties() noexcept;
void ExportProperties(void* dest) const; void ExportProperties(void* dest);
/*-----------------------------------------------------------------------------*/ /*-----------------------------------------------------------------------------*/
/* Getter Functions */ /* Getter Functions */
/*-----------------------------------------------------------------------------*/ /*-----------------------------------------------------------------------------*/
Handle<SHMaterial> GetBaseMaterial() const { return baseMaterial; } Handle<SHMaterial> GetBaseMaterial() const noexcept { return baseMaterial; }
bool HasChanged() const noexcept { return dataWasChanged; }
private: private:
/*-----------------------------------------------------------------------------*/ /*-----------------------------------------------------------------------------*/
@ -77,6 +78,7 @@ namespace SHADE
std::vector<OverrideData> overrideData; std::vector<OverrideData> overrideData;
std::unique_ptr<char> dataStore; std::unique_ptr<char> dataStore;
size_t dataStoreSize = 0; size_t dataStoreSize = 0;
bool dataWasChanged = false;
/*-----------------------------------------------------------------------------*/ /*-----------------------------------------------------------------------------*/
/* Helper Functions */ /* Helper Functions */

3
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.hpp
View File

@ -53,6 +53,9 @@ namespace SHADE
// Save the override data information // Save the override data information
overrideData.emplace_back(std::move(od)); overrideData.emplace_back(std::move(od));
// Flag
dataWasChanged = true;
} }
template<typename T> template<typename T>
T& SHMaterialInstance::GetProperty(const std::string& key) T& SHMaterialInstance::GetProperty(const std::string& key)

2
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.cpp
View File

@ -81,7 +81,7 @@ namespace SHADE
if (!material) if (!material)
{ {
SHGraphicsSystem* gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>(); SHGraphicsSystem* gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
material = gfxSystem->AddMaterialInstance(sharedMaterial->GetBaseMaterial()); material = gfxSystem->AddOrGetBaseMaterialInstance(sharedMaterial->GetBaseMaterial());
} }
return material; return material;

47
SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialInstanceCache.cpp Normal file
View File

@ -0,0 +1,47 @@
/************************************************************************************//*!
\file SHMaterialInstanceCache.cpp
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Sep 25, 2022
\brief Contains the definition of SHMaterialInstanceCache's functions.
Copyright (C) 2022 DigiPen Institute of Technology.
Reproduction or disclosure of this file or its contents without the prior written consent
of DigiPen Institute of Technology is prohibited.
*//*************************************************************************************/
#include "SHpch.h"
#include "SHMaterialInstanceCache.h"
#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
#include "Resource/ResourceLibrary.h"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Usage Functions */
/*---------------------------------------------------------------------------------*/
SHADE::Handle<SHADE::SHMaterialInstance> SHMaterialInstanceCache::CreateOrGet(ResourceManager& manager, Handle<SHMaterial> material)
{
// Check if there is already an existing instance
auto matInst = cache.find(material);
if (matInst == cache.end())
{
// Create and return
return cache.emplace(material, manager.Create<SHMaterialInstance>(material)).first->second;
}
return matInst->second;
}
void SHMaterialInstanceCache::Remove(Handle<SHMaterial> material)
{
cache.erase(material);
}
void SHMaterialInstanceCache::Clear()
{
cache.clear();
}
}

93
SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialInstanceCache.h Normal file
View File

@ -0,0 +1,93 @@
/************************************************************************************//*!
\file SHMaterialInstanceCache.h
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Sep 25, 2022
\brief Contains the definition of SHMaterialInstanceCache.
Copyright (C) 2022 DigiPen Institute of Technology.
Reproduction or disclosure of this file or its contents without the prior written consent
of DigiPen Institute of Technology is prohibited.
*//*************************************************************************************/
#pragma once
// STL Includes
#include <unordered_map>
// Project Includes
#include "Resource/Handle.h"
namespace SHADE
{
/*-----------------------------------------------------------------------------------*/
/* Forward Declarations */
/*-----------------------------------------------------------------------------------*/
class SHMaterial;
class SHMaterialInstance;
class ResourceManager;
/*-----------------------------------------------------------------------------------*/
/* Type Definitions */
/*-----------------------------------------------------------------------------------*/
/*************************************************************************************/
/*!
\brief
Creates and caches base SHMaterialInstances. Note that base SHMaterialInstances
refer to SHMaterialInstances with no overrides.
*/
/*************************************************************************************/
class SHMaterialInstanceCache
{
public:
/*---------------------------------------------------------------------------------*/
/* Usage Functions */
/*---------------------------------------------------------------------------------*/
/***********************************************************************************/
/*!
\brief
\param material
Material to get the SHMaterialInstance for.
\return
Handle to the base SHMaterialInstance that is mapped to SHMaterial.
*/
/***********************************************************************************/
Handle<SHMaterialInstance> CreateOrGet(ResourceManager& manager, Handle<SHMaterial> material);
/***********************************************************************************/
/*!
\brief
Removes a SHMaterialInstance from the cache with a matching material.
\param material
Handle to a SHMaterial that is used to check for removal.
*/
/***********************************************************************************/
void Remove(Handle<SHMaterial> material);
/***********************************************************************************/
/*!
\brief
Removes all SHMaterialInstances in the cache.
*/
/***********************************************************************************/
void Clear();
private:
/*---------------------------------------------------------------------------------*/
/* Type Definitions */
/*---------------------------------------------------------------------------------*/
using MaterialMap = std::unordered_map<Handle<SHMaterial>, Handle<SHMaterialInstance>>;
/*---------------------------------------------------------------------------------*/
/* Data Members */
/*---------------------------------------------------------------------------------*/
MaterialMap cache;
};
}

54
SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp
View File

@ -220,7 +220,6 @@ namespace SHADE
, depthReferences{} , depthReferences{}
, inputReferences{} , inputReferences{}
{ {
superBatch = rm.Create<SHSuperBatch>(GetHandle());
} }
/***************************************************************************/ /***************************************************************************/
@ -349,7 +348,7 @@ namespace SHADE
void SHSubpass::Execute(Handle<SHVkCommandBuffer>& commandBuffer, uint32_t frameIndex) noexcept void SHSubpass::Execute(Handle<SHVkCommandBuffer>& commandBuffer, uint32_t frameIndex) noexcept
{ {
// Ensure correct transforms are provided // Ensure correct transforms are provided
superBatch->UpdateTransformBuffer(frameIndex); superBatch->UpdateBuffers(frameIndex);
// Draw all the batches // Draw all the batches
superBatch->Draw(commandBuffer, frameIndex); superBatch->Draw(commandBuffer, frameIndex);
@ -366,6 +365,12 @@ namespace SHADE
exteriorDrawCalls.push_back(newDrawCall); exteriorDrawCalls.push_back(newDrawCall);
} }
void SHSubpass::Init(ResourceManager& resourceManager) noexcept
{
superBatch = resourceManager.Create<SHSuperBatch>(GetHandle());
}
/***************************************************************************/ /***************************************************************************/
/*! /*!
@ -524,6 +529,9 @@ namespace SHADE
, configured{ rhs.configured } , configured{ rhs.configured }
, executed{ rhs.executed } , executed{ rhs.executed }
, ptrToResources{ rhs.ptrToResources } , ptrToResources{ rhs.ptrToResources }
, pipelineLibrary{ std::move(rhs.pipelineLibrary) }
, batcher { std::move(rhs.batcher) }
{ {
rhs.renderpass = {}; rhs.renderpass = {};
} }
@ -544,6 +552,8 @@ namespace SHADE
resourceAttachmentMapping = std::move(rhs.resourceAttachmentMapping); resourceAttachmentMapping = std::move(rhs.resourceAttachmentMapping);
subpassIndexing = std::move(rhs.subpassIndexing); subpassIndexing = std::move(rhs.subpassIndexing);
ptrToResources = std::move(rhs.ptrToResources); ptrToResources = std::move(rhs.ptrToResources);
pipelineLibrary = std::move(rhs.pipelineLibrary);
batcher = std::move(rhs.batcher);
rhs.renderpass = {}; rhs.renderpass = {};
@ -577,6 +587,7 @@ namespace SHADE
subpasses.emplace_back(resourceManager.Create<SHSubpass>(resourceManager, GetHandle(), subpasses.size(), &resourceAttachmentMapping, ptrToResources)); subpasses.emplace_back(resourceManager.Create<SHSubpass>(resourceManager, GetHandle(), subpasses.size(), &resourceAttachmentMapping, ptrToResources));
subpassIndexing.try_emplace(subpassName, static_cast<uint32_t>(subpasses.size()) - 1u); subpassIndexing.try_emplace(subpassName, static_cast<uint32_t>(subpasses.size()) - 1u);
Handle<SHSubpass> subpass = subpasses.back(); Handle<SHSubpass> subpass = subpasses.back();
subpass->Init(resourceManager);
// Register the SuperBatch // Register the SuperBatch
batcher.RegisterSuperBatch(subpass->GetSuperBatch()); batcher.RegisterSuperBatch(subpass->GetSuperBatch());
@ -625,7 +636,7 @@ namespace SHADE
} }
void SHRenderGraphNode::FinaliseBatch(uint32_t frameIndex) void SHRenderGraphNode::FinaliseBatch(uint32_t frameIndex)
{ {
batcher.FinaliseBatches(logicalDeviceHdl, frameIndex); batcher.FinaliseBatches(logicalDeviceHdl, frameIndex);
} }
@ -705,7 +716,7 @@ namespace SHADE
// First we want to take all the attachment descriptions and initialize the // First we want to take all the attachment descriptions and initialize the
// finalLayout to whatever layout is specified in the last subpass that references the attachment. // finalLayout to whatever layout is specified in the last subpass that references the attachment.
for (auto& node : nodes) for (uint32_t i = 0; auto& node : nodes)
{ {
// key is handle ID, value is pair (first is initial layout, second is final layout). // key is handle ID, value is pair (first is initial layout, second is final layout).
std::unordered_map<uint32_t, vk::ImageLayout> resourceAttLayouts; std::unordered_map<uint32_t, vk::ImageLayout> resourceAttLayouts;
@ -719,7 +730,7 @@ namespace SHADE
{ {
for (auto& color : subpass->colorReferences) for (auto& color : subpass->colorReferences)
{ {
if (node->attResources[color.attachment]->resourceType == SH_ATT_DESC_TYPE::COLOR_PRESENT) if (i == nodes.size() - 1 && node->attResources[color.attachment]->resourceType == SH_ATT_DESC_TYPE::COLOR_PRESENT)
resourceAttLayouts[color.attachment] = vk::ImageLayout::ePresentSrcKHR; resourceAttLayouts[color.attachment] = vk::ImageLayout::ePresentSrcKHR;
else else
resourceAttLayouts[color.attachment] = color.layout; resourceAttLayouts[color.attachment] = color.layout;
@ -738,6 +749,7 @@ namespace SHADE
att.initialLayout = vk::ImageLayout::eUndefined; att.initialLayout = vk::ImageLayout::eUndefined;
att.finalLayout = resourceAttLayouts[i]; att.finalLayout = resourceAttLayouts[i];
} }
++i;
} }
// at this point all attachment descs will have their final layouts initialized as if they were standalone and did // at this point all attachment descs will have their final layouts initialized as if they were standalone and did
@ -846,7 +858,7 @@ namespace SHADE
for (auto& inputAtt : subpass->inputReferences) for (auto& inputAtt : subpass->inputReferences)
{ {
auto resource = node->attResources[inputAtt.attachment]; auto resource = node->attResources[inputAtt.attachment];
if (resource->resourceType == SH_ATT_DESC_TYPE::COLOR) if (resource->resourceType == SH_ATT_DESC_TYPE::COLOR || resource->resourceType == SH_ATT_DESC_TYPE::COLOR_PRESENT)
colorRead |= (1 << i); colorRead |= (1 << i);
else if (resource->resourceType == SH_ATT_DESC_TYPE::DEPTH_STENCIL) else if (resource->resourceType == SH_ATT_DESC_TYPE::DEPTH_STENCIL)
depthRead |= (1 << i); depthRead |= (1 << i);
@ -993,6 +1005,34 @@ namespace SHADE
} }
SHRenderGraph::SHRenderGraph(SHRenderGraph&& rhs) noexcept
: logicalDeviceHdl{ rhs.logicalDeviceHdl }
, swapchainHdl{ rhs.swapchainHdl }
, nodeIndexing{ std::move(rhs.nodeIndexing) }
, nodes{ std::move(rhs.nodes) }
, graphResources{ std::move(rhs.graphResources) }
, resourceManager{ std::move(rhs.resourceManager) }
, globalData{ rhs.globalData }
{
}
SHRenderGraph& SHRenderGraph::operator=(SHRenderGraph&& rhs) noexcept
{
if (&rhs == this)
return *this;
logicalDeviceHdl = rhs.logicalDeviceHdl;
swapchainHdl = rhs.swapchainHdl;
nodeIndexing = std::move(rhs.nodeIndexing);
nodes = std::move(rhs.nodes);
graphResources = std::move(rhs.graphResources);
resourceManager = std::move(rhs.resourceManager);
globalData = rhs.globalData;
return *this;
}
/***************************************************************************/ /***************************************************************************/
/*! /*!
@ -1084,7 +1124,7 @@ namespace SHADE
} }
void SHRenderGraph::FinaliseBatch(uint32_t frameIndex) void SHRenderGraph::FinaliseBatch(uint32_t frameIndex)
{ {
for (auto& node : nodes) for (auto& node : nodes)
{ {
node->FinaliseBatch(frameIndex); node->FinaliseBatch(frameIndex);

4
SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.h
View File

@ -140,6 +140,8 @@ namespace SHADE
void Execute(Handle<SHVkCommandBuffer>& commandBuffer, uint32_t frameIndex) noexcept; void Execute(Handle<SHVkCommandBuffer>& commandBuffer, uint32_t frameIndex) noexcept;
void AddExteriorDrawCalls(std::function<void(Handle<SHVkCommandBuffer>&)> const& newDrawCall) noexcept; void AddExteriorDrawCalls(std::function<void(Handle<SHVkCommandBuffer>&)> const& newDrawCall) noexcept;
void Init (ResourceManager& resourceManager) noexcept;
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
/* GETTERS AND SETTERS */ /* GETTERS AND SETTERS */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
@ -279,6 +281,8 @@ namespace SHADE
/* CTORS AND DTORS */ /* CTORS AND DTORS */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
SHRenderGraph (void) noexcept; SHRenderGraph (void) noexcept;
SHRenderGraph(SHRenderGraph&& rhs) noexcept;
SHRenderGraph& operator=(SHRenderGraph&& rhs) noexcept;
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
/* PUBLIC MEMBER FUNCTIONS */ /* PUBLIC MEMBER FUNCTIONS */