ShaderLightArray.h

#pragma once
 
// Standard.
#include <memory>
#include <functional>
#include <variant>
#include <optional>
#include <array>
#include <unordered_set>
#include <mutex>
 
// Custom.
#include "misc/Error.h"
#include "render/general/resource/UploadBuffer.h"
#include "render/general/resource/frame/FrameResourceManager.h"
#include "shader/general/resource/ShaderLightsInFrustumSingleType.hpp"
 
namespace ne {
    class Renderer;
    class Pipeline;
    class ShaderLightArray;
 
    class ShaderLightArraySlot {
        // Only arrays can create slots.
        friend class ShaderLightArray;
 
    public:
        ShaderLightArraySlot() = delete;
 
        ShaderLightArraySlot(const ShaderLightArraySlot&) = delete;
        ShaderLightArraySlot& operator=(const ShaderLightArraySlot&) = delete;
 
        ~ShaderLightArraySlot();
 
        void markAsNeedsUpdate();
 
        inline size_t getCurrentIndexIntoArray() const { return iIndexIntoArray; }
 
    private:
        ShaderLightArraySlot(
            ShaderLightArray* pArray,
            Node* pSpawnedOwnerLightNode,
            size_t iIndexIntoArray,
            const std::function<void*()>& startUpdateCallback,
            const std::function<void()>& finishUpdateCallback);
 
        ShaderLightArray* pArray = nullptr;
 
        Node* const pSpawnedOwnerLightNode = nullptr;
 
        const std::function<void*()> startUpdateCallback;
 
        const std::function<void()> finishUpdateCallback;
 
        size_t iIndexIntoArray = 0;
    };
 
    class ShaderLightArray {
        // Frees the slot in its destructor.
        friend class ShaderLightArraySlot;
 
        // Manager notifies when pipeline updates happen and when we can copy new data of slots that
        // need update.
        friend class LightingShaderResourceManager;
 
        // Modifies lights in frustum.
        friend class Renderer;
 
    public:
        struct Resources {
            std::array<std::unique_ptr<UploadBuffer>, FrameResourceManager::getFrameResourceCount()>
                vGpuArrayLightDataResources;
 
            ShaderLightsInFrustumSingleType lightsInFrustum;
 
            std::array<
                std::unordered_set<ShaderLightArraySlot*>,
                FrameResourceManager::getFrameResourceCount()>
                vSlotsToBeUpdated;
 
            std::unordered_set<ShaderLightArraySlot*> activeSlots;
        };
 
        ShaderLightArray() = delete;
 
        ~ShaderLightArray();
 
        static std::unique_ptr<ShaderLightArray> create(
            Renderer* pRenderer,
            const std::string& sShaderLightResourceName,
            const std::function<void(size_t)>& onSizeChanged,
            const std::optional<std::pair<std::function<void(size_t)>, std::string>>&
                optionalOnLightsInCameraFrustumCulled);
 
        std::variant<std::unique_ptr<ShaderLightArraySlot>, Error> reserveNewSlot(
            Node* pSpawnedOwnerLightNode,
            size_t iDataSizeInBytes,
            const std::function<void*()>& startUpdateCallback,
            const std::function<void()>& finishUpdateCallback);
 
        std::pair<std::recursive_mutex, Resources>* getInternalResources();
 
        std::string getShaderResourceName() const;
 
    private:
        ShaderLightArray(
            Renderer* pRenderer,
            const std::string& sShaderLightResourceName,
            const std::function<void(size_t)>& onSizeChanged,
            const std::optional<std::function<void(size_t)>>& optionalCallbackOnLightsInCameraFrustumCulled,
            const std::string& sIndicesLightsInFrustumShaderResourceName = "");
 
        void onLightsInCameraFrustumCulled(size_t iCurrentFrameResourceIndex);
 
        [[nodiscard]] std::optional<Error> recreateArray(bool bIsInitialization = false);
 
        void updateSlotsMarkedAsNeedsUpdate(size_t iCurrentFrameResourceIndex);
 
        [[nodiscard]] std::optional<Error> updateBindingsInAllPipelines();
 
        [[nodiscard]] std::optional<Error> updatePipelineBinding(Pipeline* pPipeline);
 
        void freeSlot(ShaderLightArraySlot* pSlot);
 
        void markSlotAsNeedsUpdate(ShaderLightArraySlot* pSlot);
 
        std::pair<std::recursive_mutex, Resources> mtxResources;
 
        Renderer* pRenderer = nullptr;
 
        size_t iElementSizeInBytes = 0;
 
        const std::optional<std::function<void(size_t)>> optionalCallbackOnLightsInCameraFrustumCulled;
 
        const std::function<void(size_t)> onSizeChanged;
 
        const std::string sShaderLightResourceName;
    };
}