QueueSubmitBuilder.cpp

Go to the documentation of this file.

#include "Engine/Renderer/QueueSubmitBuilder.h"
 
namespace EngineCore
{
 
QueueSubmitBuilder::QueueSubmitBuilder(const TimelineSynchronizer& sync, uint64_t frameNumber)
    : sync_(sync)
    , frameNumber_(frameNumber)
{
}
 
QueueSubmitBuilder& QueueSubmitBuilder::waitFor(
    PipelineStage stage,
    VkPipelineStageFlags2 waitStages,
    uint64_t frameNumber)
{
    uint64_t waitValue = sync_.getStageValue(frameNumber, stage);
 
    waitInfos_.push_back(VkSemaphoreSubmitInfo{
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
        .pNext = nullptr,
        .semaphore = sync_.getSemaphore(),
        .value = waitValue,
        .stageMask = waitStages,
        .deviceIndex = 0,
    });
 
    return *this;
}
 
QueueSubmitBuilder& QueueSubmitBuilder::waitForCurrent(
    PipelineStage stage,
    VkPipelineStageFlags2 waitStages)
{
    return waitFor(stage, waitStages, frameNumber_);
}
 
QueueSubmitBuilder& QueueSubmitBuilder::waitForPrevious(
    PipelineStage stage,
    VkPipelineStageFlags2 waitStages)
{
    auto waitValue = sync_.getWaitValue(frameNumber_, stage, 1);
    if (waitValue.has_value())
    {
        waitInfos_.push_back(VkSemaphoreSubmitInfo{
            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
            .pNext = nullptr,
            .semaphore = sync_.getSemaphore(),
            .value = waitValue.value(),
            .stageMask = waitStages,
            .deviceIndex = 0,
        });
    }
    return *this;
}
 
QueueSubmitBuilder& QueueSubmitBuilder::waitForResourceReuse(
    PipelineStage stage,
    VkPipelineStageFlags2 waitStages)
{
    auto waitValue = sync_.getResourceReuseWaitValue(frameNumber_, stage);
    if (waitValue.has_value())
    {
        waitInfos_.push_back(VkSemaphoreSubmitInfo{
            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
            .pNext = nullptr,
            .semaphore = sync_.getSemaphore(),
            .value = waitValue.value(),
            .stageMask = waitStages,
            .deviceIndex = 0,
        });
    }
    return *this;
}
 
QueueSubmitBuilder& QueueSubmitBuilder::waitForBinary(
    VkSemaphore semaphore,
    VkPipelineStageFlags2 waitStages)
{
    if (semaphore != VK_NULL_HANDLE)
    {
        waitInfos_.push_back(VkSemaphoreSubmitInfo{
            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
            .pNext = nullptr,
            .semaphore = semaphore,
            .value = 0,  // Binary semaphores use value 0
            .stageMask = waitStages,
            .deviceIndex = 0,
        });
    }
    return *this;
}
 
QueueSubmitBuilder& QueueSubmitBuilder::signalStage(PipelineStage stage)
{
    uint64_t signalValue = sync_.getStageValue(frameNumber_, stage);
    lastSignalValue_ = signalValue;
 
    signalInfos_.push_back(VkSemaphoreSubmitInfo{
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
        .pNext = nullptr,
        .semaphore = sync_.getSemaphore(),
        .value = signalValue,
        .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
        .deviceIndex = 0,
    });
 
    return *this;
}
 
QueueSubmitBuilder& QueueSubmitBuilder::signalBinary(VkSemaphore semaphore)
{
    if (semaphore != VK_NULL_HANDLE)
    {
        signalInfos_.push_back(VkSemaphoreSubmitInfo{
            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
            .pNext = nullptr,
            .semaphore = semaphore,
            .value = 0,  // Binary semaphores use value 0
            .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
            .deviceIndex = 0,
        });
    }
    return *this;
}
 
QueueSubmitBuilder& QueueSubmitBuilder::withCommandBuffer(VkCommandBuffer cmdBuffer)
{
    if (cmdBuffer != VK_NULL_HANDLE)
    {
        cmdBufferInfos_.push_back(VkCommandBufferSubmitInfo{
            .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
            .pNext = nullptr,
            .commandBuffer = cmdBuffer,
            .deviceMask = 0,
        });
    }
    return *this;
}
 
QueueSubmitBuilder& QueueSubmitBuilder::withCommandBuffers(const std::vector<VkCommandBuffer>& cmdBuffers)
{
    for (VkCommandBuffer cmdBuffer : cmdBuffers)
    {
        withCommandBuffer(cmdBuffer);
    }
    return *this;
}
 
VkResult QueueSubmitBuilder::submit(VkQueue queue, VkFence fence)
{
    VkSubmitInfo2 submitInfo{
        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
        .pNext = nullptr,
        .flags = 0,
        .waitSemaphoreInfoCount = static_cast<uint32_t>(waitInfos_.size()),
        .pWaitSemaphoreInfos = waitInfos_.empty() ? nullptr : waitInfos_.data(),
        .commandBufferInfoCount = static_cast<uint32_t>(cmdBufferInfos_.size()),
        .pCommandBufferInfos = cmdBufferInfos_.empty() ? nullptr : cmdBufferInfos_.data(),
        .signalSemaphoreInfoCount = static_cast<uint32_t>(signalInfos_.size()),
        .pSignalSemaphoreInfos = signalInfos_.empty() ? nullptr : signalInfos_.data(),
    };
 
    return vkQueueSubmit2(queue, 1, &submitInfo, fence);
}
 
} // namespace EngineCore