DynamicCpuWriteShaderResourceArray.h

#pragma once
 
// Standard.
#include <string>
#include <stdexcept>
#include <format>
#include <queue>
#include <unordered_set>
#include <mutex>
#include <variant>
#include <memory>
#include <optional>
 
// Custom.
#include "render/general/resource/UploadBuffer.h"
#include "misc/Error.h"
 
namespace ne {
    class GpuResourceManager;
    class ShaderCpuWriteResourceBinding;
    class VulkanRenderer;
    class VulkanPipeline;
 
    class DynamicCpuWriteShaderResourceArraySlot {
        // Only arrays are allowed to create and modify the internal index of this slot.
        friend class DynamicCpuWriteShaderResourceArray;
 
    public:
        DynamicCpuWriteShaderResourceArraySlot() = delete;
 
        DynamicCpuWriteShaderResourceArraySlot(const DynamicCpuWriteShaderResourceArraySlot&) = delete;
        DynamicCpuWriteShaderResourceArraySlot&
        operator=(const DynamicCpuWriteShaderResourceArraySlot&) = delete;
 
        ~DynamicCpuWriteShaderResourceArraySlot();
 
        void updateData(void* pData);
 
        inline unsigned int getIndexIntoArray() const { return iIndexInArray; }
 
    private:
        DynamicCpuWriteShaderResourceArraySlot(
            DynamicCpuWriteShaderResourceArray* pArray,
            size_t iIndexInArray,
            ShaderCpuWriteResourceBinding* pShaderResource);
 
        inline void updateIndex(size_t iNewIndex) {
            // Self check:
            static_assert(
                std::is_same_v<decltype(this->iIndexInArray), unsigned int>,
                "update cast and type limit check below");
 
            // Check before converting to unsigned int, see slot index docs for more info.
            if (iNewIndex > UINT_MAX) [[unlikely]] {
                Error error(std::format("received slot index {} exceeds type limit", iNewIndex));
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
 
            iIndexInArray = static_cast<unsigned int>(iNewIndex);
        }
 
        DynamicCpuWriteShaderResourceArray* const pArray = nullptr;
 
        ShaderCpuWriteResourceBinding* const pShaderResource = nullptr;
 
        unsigned int iIndexInArray = 0;
    };
 
    class DynamicCpuWriteShaderResourceArray {
        // Slots notify the array in their destructor.
        friend class DynamicCpuWriteShaderResourceArraySlot;
 
        // Only manager should create the arrays and insert new slots.
        friend class DynamicCpuWriteShaderResourceArrayManager;
 
    public:
        struct InternalResources {
            InternalResources() = default;
 
            std::unique_ptr<UploadBuffer> pUploadBuffer = nullptr;
 
            size_t iCapacity = 0;
 
            size_t iNextFreeArrayIndex = 0;
 
            std::queue<size_t> noLongerUsedArrayIndices;
 
            std::unordered_set<DynamicCpuWriteShaderResourceArraySlot*> activeSlots;
        };
 
        DynamicCpuWriteShaderResourceArray() = delete;
        DynamicCpuWriteShaderResourceArray(const DynamicCpuWriteShaderResourceArray&) = delete;
        DynamicCpuWriteShaderResourceArray& operator=(const DynamicCpuWriteShaderResourceArray&) = delete;
 
        size_t getSize();
 
        size_t getCapacity();
 
        size_t getSizeInBytes();
 
        size_t getElementSize() const;
 
        size_t getCapacityStepSize() const;
 
        std::string_view getHandledShaderResourceName() const;
 
        std::pair<std::recursive_mutex, InternalResources>* getInternalResources();
 
    private:
        static std::variant<std::unique_ptr<DynamicCpuWriteShaderResourceArray>, Error> create(
            GpuResourceManager* pResourceManager,
            const std::string& sHandledShaderResourceName,
            size_t iElementSizeInBytes);
 
        static std::string formatBytesToKilobytes(size_t iSizeInBytes);
 
        static std::variant<size_t, Error> calculateCapacityStepSize(size_t iElementSizeInBytes);
 
        DynamicCpuWriteShaderResourceArray(
            GpuResourceManager* pResourceManager,
            const std::string& sHandledShaderResourceName,
            size_t iElementSizeInBytes,
            size_t iCapacityStepSize);
 
        std::variant<std::unique_ptr<DynamicCpuWriteShaderResourceArraySlot>, Error>
        insert(ShaderCpuWriteResourceBinding* pShaderResource);
 
        void markSlotAsNoLongerBeingUsed(DynamicCpuWriteShaderResourceArraySlot* pSlot);
 
        void updateSlotData(DynamicCpuWriteShaderResourceArraySlot* pSlot, void* pData);
 
        [[nodiscard]] std::optional<Error> createArray(size_t iCapacity);
 
        [[nodiscard]] std::optional<Error> expandArray();
 
        [[nodiscard]] std::optional<Error> shrinkArray();
 
        std::pair<std::recursive_mutex, InternalResources> mtxInternalResources;
 
        GpuResourceManager* const pResourceManager = nullptr;
 
        const size_t iCapacityStepSize = 0;
 
        const std::string sHandledShaderResourceName;
 
        const size_t iElementSizeInBytes = 0;
    };
}