TimelineSynchronizer.h

Go to the documentation of this file.

#pragma once
 
#include "PipelineStages.h"
 
#include <optional>
#include <vulkan/vulkan_core.h>
 
namespace EngineCore
{
 
class ApplicationContext;

class TimelineSynchronizer
{
public:
    explicit TimelineSynchronizer(ApplicationContext* context, uint32_t framesInFlight);
 
    ~TimelineSynchronizer();
 
    // Non-copyable
    TimelineSynchronizer(const TimelineSynchronizer&) = delete;
    TimelineSynchronizer& operator=(const TimelineSynchronizer&) = delete;
 
    // Movable
    TimelineSynchronizer(TimelineSynchronizer&& other) noexcept;
    TimelineSynchronizer& operator=(TimelineSynchronizer&& other) noexcept;

    [[nodiscard]] uint64_t getStageValue(uint64_t frameNumber, PipelineStage stage) const
    {
        // +1 offset ensures frame 0's first signal (value 1) is greater than
        // the timeline semaphore's initial value (0), as required by Vulkan
        return frameNumber * PIPELINE_STAGE_COUNT + static_cast<uint32_t>(stage) + 1;
    }

    [[nodiscard]] std::optional<uint64_t> getWaitValue(
        uint64_t currentFrame,
        PipelineStage waitForStage,
        uint32_t framesBack = 1) const
    {
        if (currentFrame < framesBack)
        {
            return std::nullopt;
        }
        return getStageValue(currentFrame - framesBack, waitForStage);
    }

    [[nodiscard]] std::optional<uint64_t> getResourceReuseWaitValue(
        uint64_t currentFrame,
        PipelineStage waitForStage) const
    {
        if (currentFrame < framesInFlight_)
        {
            return std::nullopt;
        }
        return getStageValue(currentFrame - framesInFlight_, waitForStage);
    }

    [[nodiscard]] uint64_t getCurrentValue() const;

    void waitForValue(uint64_t value, uint64_t timeout = UINT64_MAX) const;

    void waitForStage(uint64_t frameNumber, PipelineStage stage,
                      uint64_t timeout = UINT64_MAX) const
    {
        waitForValue(getStageValue(frameNumber, stage), timeout);
    }

    void signalValue(uint64_t value) const;

    [[nodiscard]] VkSemaphore getSemaphore() const { return timelineSemaphore_; }

    [[nodiscard]] uint32_t getFramesInFlight() const { return framesInFlight_; }
 
private:
    ApplicationContext* context_ = nullptr;
    VkSemaphore timelineSemaphore_ = VK_NULL_HANDLE;
    uint32_t framesInFlight_ = 0;
};
 
} // namespace EngineCore