FrameResourceManager.h

#pragma once
 
// Standard.
#include <array>
#include <memory>
#include <mutex>
#include <variant>
 
// Custom.
#include "misc/Error.h"
#include "math/GLMath.hpp"
#include "shader/VulkanAlignmentConstants.hpp"
#include "render/general/resource/frame/FrameResource.h"
 
namespace ne {
    class UploadBuffer;
    class Renderer;
 
    struct FrameConstants {
        alignas(iVkMat4Alignment) glm::mat4x4 viewMatrix = glm::identity<glm::mat4x4>();
 
        alignas(iVkMat4Alignment) glm::mat4x4 viewProjectionMatrix = glm::identity<glm::mat4x4>();
 
        alignas(iVkVec4Alignment) glm::vec4 cameraPosition = glm::vec4(0.0F, 0.0F, 0.0F, 0.0F);
 
        alignas(iVkScalarAlignment) float timeSincePrevFrameInSec = 0.0F;
 
        alignas(iVkScalarAlignment) float totalTimeInSec = 0.0F;
 
        // don't forget to add padding to 4 floats (if needed) for HLSL packing rules
    };
 
    class FrameResourceManager {
        // Only renderer is allowed to switch to the next frame resource.
        friend class Renderer;
 
        // Vulkan renderer need to cycle frame resources in a very specific case.
        friend class VulkanRenderer;
 
    public:
        struct CurrentFrameResource {
            CurrentFrameResource() = default;
 
            size_t iIndex = 0;
 
            FrameResource* pResource = nullptr;
        };
 
        FrameResourceManager() = delete;
        FrameResourceManager(const FrameResourceManager&) = delete;
        FrameResourceManager& operator=(const FrameResourceManager&) = delete;
 
        static constexpr unsigned int getFrameResourceCount() { return iFrameResourceCount; }
 
        static std::variant<std::unique_ptr<FrameResourceManager>, Error> create(Renderer* pRenderer);
 
        std::pair<std::recursive_mutex, CurrentFrameResource>* getCurrentFrameResource();
 
        std::pair<std::recursive_mutex*, std::vector<FrameResource*>> getAllFrameResources();
 
    private:
        static constexpr unsigned int iFrameResourceCount = 2; // small to avoid input latency
 
        static std::array<std::unique_ptr<FrameResource>, iFrameResourceCount>
        createRenderDependentFrameResources(Renderer* pRenderer);
 
        FrameResourceManager(Renderer* pRenderer);
 
        void switchToNextFrameResource();
 
        Renderer* pRenderer = nullptr;
 
        std::pair<std::recursive_mutex, CurrentFrameResource> mtxCurrentFrameResource;
 
        std::array<std::unique_ptr<FrameResource>, iFrameResourceCount> vFrameResources;
    };
} // namespace ne