PipelineShaderConstantsManager.hpp

#pragma once
 
// Standard.
#include <stdexcept>
#include <format>
#include <vector>
 
// Custom.
#include "misc/Error.h"
#include "io/Logger.h"
 
namespace ne {
    class PipelineShaderConstantsManager {
    public:
        using variable_type = unsigned int;
 
        PipelineShaderConstantsManager() = delete;
        PipelineShaderConstantsManager(const PipelineShaderConstantsManager&) = delete;
        PipelineShaderConstantsManager& operator=(const PipelineShaderConstantsManager&) = delete;
 
        struct SpecialConstantsNames {
            static constexpr auto pShadowPassLightInfoIndex = "iShadowPassLightInfoIndex";
        };
 
        static constexpr size_t getMaxConstantsSizeInBytes() { return iMaxShaderConstantsSizeInBytes; }
 
        PipelineShaderConstantsManager(size_t iVariableCount) {
            // Make sure we won't exceed maximum allowed size limit.
            const size_t iSizeInBytes = iVariableCount * sizeof(variable_type);
            if (iSizeInBytes > iMaxShaderConstantsSizeInBytes) [[unlikely]] {
                Error error(std::format(
                    "failed to create shader constants manager with size {} bytes because the maximum "
                    "allowed size is {} bytes",
                    iSizeInBytes,
                    iMaxShaderConstantsSizeInBytes));
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
 
            // Make sure the specified size is not zero.
            if (iVariableCount == 0) [[unlikely]] {
                Error error("failed to create shader constants manager because the specified size is zero");
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
 
            // Prepare data.
            vConstantsData.resize(iVariableCount, 0);
        }
 
        inline void copyValueToShaderConstant(size_t iShaderConstantIndex, unsigned int iValueToCopy) {
            // Make sure we don't access out of bounds.
            if (iShaderConstantIndex >= vConstantsData.size()) [[unlikely]] {
                Logger::get().error(std::format(
                    "the specified push/root constant index {} is out of bounds (max: {})",
                    iShaderConstantIndex,
                    vConstantsData.size() - 1));
                return;
            }
 
            // Set value.
            vConstantsData[iShaderConstantIndex] = iValueToCopy;
        }
 
        inline unsigned int getTotalSizeInBytes() const {
            // We can safely cast to `uint` here since push/root constants are very small in size.
            return static_cast<unsigned int>(vConstantsData.size() * sizeof(variable_type));
        }
 
        inline unsigned int getVariableCount() const {
            return static_cast<unsigned int>(vConstantsData.size());
        }
 
        inline void* getData() { return vConstantsData.data(); }
 
    private:
        std::vector<variable_type> vConstantsData;
 
        static constexpr size_t iMaxShaderConstantsSizeInBytes =
            128; // NOLINT: guaranteed minimum supported size from Vulkan specs, we should stick with it to
                 // support as much GPUs as possible
    };
} // namespace ne