GPUResourceSet.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "GPUBuffer.hpp"
#include "GPUImage.hpp"
#include "GPUResource.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/StringID.hpp"
#include "CeresEngine/Foundation/Generator.hpp"
#include "CeresEngine/Foundation/Container/IndexedMultimap.hpp"
#include "CeresEngine/Foundation/Container/SmallFlatMap.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
#include "CeresEngine/Foundation/Container/Variant.hpp"
#include "CeresEngine/Foundation/Container/Pair.hpp"
#include "CeresEngine/Foundation/Container/InitializerList.hpp"
 
#include <initializer_list>
 
namespace CeresEngine {
 
    struct GPUShaderReflectionDescriptor;
    class GPUBufferObject;
 
    enum class GPUResourceBindingType {
        Undefined = 0,
 
        UniformBuffer,
 
        DynamicUniformBuffer,
 
        StorageBuffer,
 
        Image,
 
        Sampler,
 
        CombinedSampler,
 
        StorageImage
    };
 
    // ---------------------------------------------------------------------------------------------
 
    struct GPUBufferResourceBinding {
        GPUBufferPtr buffer = nullptr;
 
        GPUBufferViewDescriptor bufferView;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(buffer);
            CE_REFL_DATA(bufferView);
        }
    };
 
    struct GPUImageResourceBinding {
        GPUImagePtr image = nullptr;
 
        GPUSamplerPtr sampler = nullptr;
 
        GPUImageViewDescriptor imageView{
            .type = GPUImageType::None,
            .subresource{
                .numArrayLayers = 0,
                .numMipLevels = 0,
            },
        };
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(image);
            CE_REFL_DATA(sampler);
            CE_REFL_DATA(imageView);
        }
    };
 
    struct GPUSamplerResourceBinding {
        GPUSamplerPtr sampler = nullptr;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(sampler);
        }
    };
 
    class GPUResourceBinding : public Variant<std::nullptr_t, GPUBufferResourceBinding, GPUImageResourceBinding, GPUSamplerResourceBinding> {
        using super = Variant<std::nullptr_t, GPUBufferResourceBinding, GPUImageResourceBinding, GPUSamplerResourceBinding>;
        template<typename> friend struct std::hash;
 
    public:
        using super::super;
 
        CE_EXPLICIT(false) inline GPUResourceBinding(GPUBufferPtr buffer, const GPUBufferViewDescriptor& bufferView = {})
                : super(GPUBufferResourceBinding{.buffer = std::move(buffer), .bufferView = bufferView}) {}
        CE_EXPLICIT(false) inline GPUResourceBinding(GPUBuffer& buffer, const GPUBufferViewDescriptor& bufferView = {}) : GPUResourceBinding(&buffer, bufferView) {}
 
        CE_EXPLICIT(false) GPUResourceBinding(const GPUBufferObject& buffer);
 
        CE_EXPLICIT(false) inline GPUResourceBinding(GPUImagePtr image, GPUSamplerPtr sampler = nullptr)
                : super(GPUImageResourceBinding{.image = std::move(image), .sampler = std::move(sampler)}) {}
        CE_EXPLICIT(false) inline GPUResourceBinding(GPUImage& image, GPUSamplerPtr sampler = nullptr) : GPUResourceBinding(&image, std::move(sampler)) {}
 
        CE_EXPLICIT(false) inline GPUResourceBinding(GPUImagePtr image, GPUSampler& sampler) : GPUResourceBinding(std::move(image), &sampler) {}
        CE_EXPLICIT(false) inline GPUResourceBinding(GPUImage& image, GPUSampler& sampler) : GPUResourceBinding(&image, &sampler) {}
        
        CE_EXPLICIT(false) inline GPUResourceBinding(GPUSamplerPtr sampler)
                : super(GPUSamplerResourceBinding{.sampler = std::move(sampler)}) {}
        CE_EXPLICIT(false) inline GPUResourceBinding(GPUSampler& sampler) : GPUResourceBinding(&sampler) {}
 
    public:
        [[nodiscard]] bool isEmpty() const noexcept { return super::is<std::nullptr_t>(); }
 
        explicit operator bool() const noexcept { return isEmpty(); }
 
        [[nodiscard]] bool isBufferBinding() const noexcept { return super::is<GPUBufferResourceBinding>(); }
 
        [[nodiscard]] const GPUBufferResourceBinding& asBufferBinding() const {
            CE_ASSERT(super::is<GPUBufferResourceBinding>());
            return as<GPUBufferResourceBinding>();
        }
 
        [[nodiscard]] GPUBufferResourceBinding& asBufferBinding() {
            CE_ASSERT(super::is<GPUBufferResourceBinding>());
            return as<GPUBufferResourceBinding>();
        }
 
        [[nodiscard]] bool isImageBinding() const noexcept { return super::is<GPUImageResourceBinding>(); }
 
        [[nodiscard]] const GPUImageResourceBinding& asImageBinding() const {
            CE_ASSERT(super::is<GPUImageResourceBinding>());
            return as<GPUImageResourceBinding>();
        }
 
        [[nodiscard]] GPUImageResourceBinding& asImageBinding() {
            CE_ASSERT(super::is<GPUImageResourceBinding>());
            return as<GPUImageResourceBinding>();
        }
 
        [[nodiscard]] bool isSamplerBinding() const noexcept { return super::is<GPUSamplerResourceBinding>(); }
 
        [[nodiscard]] const GPUSamplerResourceBinding& asSamplerBinding() const {
            CE_ASSERT(super::is<GPUSamplerResourceBinding>());
            return as<GPUSamplerResourceBinding>();
        }
 
        [[nodiscard]] GPUSamplerResourceBinding& asSamplerBinding() {
            CE_ASSERT(super::is<GPUSamplerResourceBinding>());
            return as<GPUSamplerResourceBinding>();
        }
 
    public: // Comparison
        [[nodiscard]] friend bool operator==(const GPUResourceBinding& lhs, std::nullptr_t) noexcept { return lhs.isEmpty(); }
        [[nodiscard]] friend bool operator!=(const GPUResourceBinding& lhs, const std::nullptr_t rhs) noexcept { return !(lhs == rhs); }
 
        //        [[nodiscard]] friend bool operator==(const GPUResourceBinding& lhs, const GPUBufferResourceBinding& rhs) noexcept {
        //            return lhs.isBufferBinding() && lhs.asBufferBinding() == rhs;
        //        }
        //        [[nodiscard]] friend bool operator!=(const GPUResourceBinding& lhs, const GPUBufferResourceBinding& rhs) noexcept { return !(lhs == rhs); }
        //
        //        [[nodiscard]] friend bool operator==(const GPUResourceBinding& lhs, const GPUImageResourceBinding& rhs) noexcept {
        //            return lhs.isImageBinding() && lhs.asImageBinding() == rhs;
        //        }
        //        [[nodiscard]] friend bool operator!=(const GPUResourceBinding& lhs, const GPUImageResourceBinding& rhs) noexcept { return !(lhs == rhs); }
        //
        //        [[nodiscard]] friend bool operator==(const GPUResourceBinding& lhs, const GPUSamplerResourceBinding& rhs) noexcept {
        //            return lhs.isSamplerBinding() && lhs.asSamplerBinding() == rhs;
        //        }
        //        [[nodiscard]] friend bool operator!=(const GPUResourceBinding& lhs, const GPUSamplerResourceBinding& rhs) noexcept { return !(lhs == rhs); }
    };
 
    class GPUResourceSetBindings;
 
    template<bool Const> class TGPUResourceSetBindingSlot final {
        using GPUResourceSetBindingsType = std::conditional_t<Const, const GPUResourceSetBindings, GPUResourceSetBindings>;
        friend class GPUResourceSetBindings;
 
    public:
        GPUResourceSetBindingsType& bindings;
 
        UInt32 slot;
 
    private:
        // `GPUResourceSetBindings` and `slot` index.
        TGPUResourceSetBindingSlot(GPUResourceSetBindingsType& bindings, const UInt32 slot) : bindings(bindings), slot(slot) {}
 
    public:
        [[nodiscard]] const GPUResourceBinding* get(UInt32 index = 0) const { return bindings.get(slot, index); }
 
        [[nodiscard]] GPUResourceBinding* get(UInt32 index = 0) requires(!Const) { return bindings.get(slot, index); }
 
        GPUResourceBinding& set(UInt32 index, GPUResourceBinding binding) requires(!Const) { return bindings.set(slot, index, std::move(binding)); }
 
        GPUResourceBinding& set(GPUResourceBinding binding) requires(!Const) { return bindings.set(slot, std::move(binding)); }
 
        [[nodiscard]] const GPUResourceBinding& operator[](const UInt32 index) const {
            GPUResourceBinding* const binding = get(index);
            CE_ASSERT(binding != nullptr);
            return *binding;
        }
 
        [[nodiscard]] GPUResourceBinding& operator[](const UInt32 index) requires(!Const) {
            if(GPUResourceBinding* const binding = get(index)) {
                return *binding;
            }
 
            return set(index, GPUResourceBinding(nullptr));
        }
 
        TGPUResourceSetBindingSlot& operator=(GPUResourceBinding&& binding) requires(!Const)
        {
            set(binding);
            return *this;
        }
 
        UInt32 add(GPUResourceBinding binding) requires(!Const)
        {
            return bindings.add(slot, std::move(binding));
        }
 
        UInt32 operator+=(GPUResourceBinding binding) requires(!Const)
        {
            return add(std::move(binding));
        }
 
        void remove(UInt32 index) { bindings.remove(slot, index); }
 
        void remove() { bindings.remove(slot); }
 
        [[nodiscard]] UInt32 size() const { return bindings.size(slot); }
 
        explicit operator bool() const noexcept { return slot != ~0u; }
    };
 
    using GPUResourceSetBindingSlot = TGPUResourceSetBindingSlot<false>;
 
    using GPUResourceSetConstBindingSlot = TGPUResourceSetBindingSlot<true>;
 
    static constexpr UInt32 kGPUResourceSetBindingsSmallSize = 20u;
 
    class GPUResourceSetBindings : private SmallFlatIndexedMultimap<UInt32, GPUResourceBinding, kGPUResourceSetBindingsSmallSize> {
        using super = SmallFlatIndexedMultimap<UInt32, GPUResourceBinding, kGPUResourceSetBindingsSmallSize>;
        template<typename> friend struct std::hash;
 
    public:
        GPUResourceSetBindings() = default;
 
        CE_EXPLICIT(false) GPUResourceSetBindings(InitializerList<Pair<UInt32, Variant<GPUResourceBinding, InitializerList<GPUResourceBinding>>>> initializer);
 
    public:
        using super::reserve;
        using super::resize;
        using super::clear;
 
        [[nodiscard]] const GPUResourceBinding* get(const UInt32 slot, const UInt32 index = 0) const {
            if(!super::contains(slot, index)) {
                return nullptr;
            }
            return &super::at(slot, index);
        }
 
        [[nodiscard]] GPUResourceBinding* get(const UInt32 slot, const UInt32 index = 0) { return const_cast<GPUResourceBinding*>(std::as_const(*this).get(slot, index)); }
 
        GPUResourceBinding& set(const UInt32 slot, const UInt32 index, GPUResourceBinding binding) { return (*this)(slot, index) = std::move(binding); }
 
        GPUResourceBinding& set(UInt32 slot, GPUResourceBinding binding) {
            super::erase(slot);
            return super::emplace_back(slot, std::move(binding));
        }
 
        UInt32 add(const UInt32 slot, GPUResourceBinding binding) {
            super::emplace_back(slot, std::move(binding));
            return (UInt32)(super::size(slot) - 1);
        }
 
        void remove(const UInt32 slot, const UInt32 index) {
            if(super::contains(slot, index)) {
                super::erase(super::lower_bound(slot) + index);
            }
        }
 
        void remove(UInt32 slot) { super::erase(slot); }
 
        [[nodiscard]] UInt32 size(const UInt32 slot) const { return UInt32(super::size(slot)); }
 
        [[nodiscard]] UInt32 size() const { return UInt32(super::size()); }
 
        [[nodiscard]] GPUResourceSetBindingSlot operator[](UInt32 slot) { return {*this, slot}; }
 
        [[nodiscard]] GPUResourceSetConstBindingSlot operator[](UInt32 slot) const { return {*this, slot}; }
 
    public:
        using super::begin;
        using super::end;
 
        [[nodiscard]] Generator<Pair<Pair<UInt32, UInt32>, GPUResourceBinding&>> forEach();
 
        [[nodiscard]] Generator<Pair<Pair<UInt32, UInt32>, const GPUResourceBinding&>> forEach() const;
 
    public: // Interop
        [[nodiscard]] GPUResourceSetDescriptor createDescriptor() const&;
        [[nodiscard]] GPUResourceSetDescriptor createDescriptor() &&;
    };
 
    class GPUShaderResourceSetBindings : public GPUResourceSetBindings {
        using super = GPUResourceSetBindings;
        template<typename> friend struct std::hash;
 
    private:
        const GPUShaderReflectionDescriptor& mReflectionDescriptor;
 
        UInt32 mSetIndex = 0;
 
    public:
        explicit GPUShaderResourceSetBindings(const GPUShader& shader, UInt32 setIndex = 0);
 
        explicit GPUShaderResourceSetBindings(const GPUShaderPtr& shader, const UInt32 setIndex = 0) : GPUShaderResourceSetBindings(*shader, setIndex) {}
 
        explicit GPUShaderResourceSetBindings(const GPUShaderProgram& shaderProgram, UInt32 setIndex = 0);
 
        explicit GPUShaderResourceSetBindings(const GPUShaderProgramPtr& shaderProgram, const UInt32 setIndex = 0)
                : GPUShaderResourceSetBindings(*shaderProgram, setIndex) {}
 
        explicit GPUShaderResourceSetBindings(const GPUGraphicsPipeline& pipeline, UInt32 setIndex = 0);
 
        explicit GPUShaderResourceSetBindings(const GPUGraphicsPipelinePtr& pipeline, const UInt32 setIndex = 0)
                : GPUShaderResourceSetBindings(*pipeline, setIndex) {}
 
        explicit GPUShaderResourceSetBindings(const GPUComputePipeline& pipeline, UInt32 setIndex = 0);
 
        explicit GPUShaderResourceSetBindings(const GPUComputePipelinePtr& pipeline, const UInt32 setIndex = 0) : GPUShaderResourceSetBindings(*pipeline, setIndex) {}
 
        explicit GPUShaderResourceSetBindings(const GPUPipelineLayout& pipeline, UInt32 setIndex = 0);
 
        explicit GPUShaderResourceSetBindings(const GPUPipelineLayoutPtr& pipelineLayout, const UInt32 setIndex = 0)
                : GPUShaderResourceSetBindings(*pipelineLayout, setIndex) {}
 
 
        explicit GPUShaderResourceSetBindings(const GPUResourceSetBindings& existingBindings, const GPUShader& shader, UInt32 setIndex = 0);
 
        explicit GPUShaderResourceSetBindings(const GPUResourceSetBindings& existingBindings, const GPUShaderPtr& shader, const UInt32 setIndex = 0)
                : GPUShaderResourceSetBindings(*shader, setIndex) {}
 
        explicit GPUShaderResourceSetBindings(const GPUResourceSetBindings& existingBindings, const GPUShaderProgram& shaderProgram, UInt32 setIndex = 0);
 
        explicit GPUShaderResourceSetBindings(const GPUResourceSetBindings& existingBindings, const GPUShaderProgramPtr& shaderProgram, const UInt32 setIndex = 0)
                : GPUShaderResourceSetBindings(existingBindings, *shaderProgram, setIndex) {}
 
        explicit GPUShaderResourceSetBindings(const GPUResourceSetBindings& existingBindings, const GPUGraphicsPipeline& pipeline, UInt32 setIndex = 0);
 
        explicit GPUShaderResourceSetBindings(const GPUResourceSetBindings& existingBindings, const GPUGraphicsPipelinePtr& pipeline, const UInt32 setIndex = 0)
                : GPUShaderResourceSetBindings(existingBindings, *pipeline, setIndex) {}
 
        explicit GPUShaderResourceSetBindings(const GPUResourceSetBindings& existingBindings, const GPUComputePipeline& pipeline, UInt32 setIndex = 0);
 
        explicit GPUShaderResourceSetBindings(const GPUResourceSetBindings& existingBindings, const GPUComputePipelinePtr& pipeline, const UInt32 setIndex = 0)
                : GPUShaderResourceSetBindings(existingBindings, *pipeline, setIndex) {}
 
    public:
        using super::get;
        using super::set;
        using super::add;
        using super::remove;
        using super::size;
        using super::resize;
        using super::clear;
        using super::operator[];
 
        [[nodiscard]] bool has(const StringView name) const { return findSlotIndex(name) != ~0u; }
 
        [[nodiscard]] bool has(UInt32 slot) const;
 
        [[nodiscard]] const GPUResourceBinding* get(const StringView name, const UInt32 index = 0) const {
            const UInt32 slot = findSlotIndex(name);
            return super::get(slot, index);
        }
 
        [[nodiscard]] GPUResourceBinding* get(const StringView name, const UInt32 index = 0) {
            const UInt32 slot = findSlotIndex(name);
            return super::get(slot, index);
        }
 
        void set(const StringView name, const UInt32 index, GPUResourceBinding binding) {
            const UInt32 slot = findSlotIndex(name);
            super::set(slot, index, std::move(binding));
        }
 
        void set(const StringView name, GPUResourceBinding binding) {
            const UInt32 slot = findSlotIndex(name);
            super::set(slot, std::move(binding));
        }
 
        UInt32 add(const StringView name, GPUResourceBinding binding) {
            const UInt32 slot = findSlotIndex(name);
            return super::add(slot, std::move(binding));
        }
 
        void remove(const StringView name, const UInt32 index) {
            const UInt32 slot = findSlotIndex(name);
            return super::remove(slot, index);
        }
 
        void remove(const StringView name) {
            const UInt32 slot = findSlotIndex(name);
            return super::remove(slot);
        }
 
        [[nodiscard]] UInt32 size(const StringView name) const {
            const UInt32 slot = findSlotIndex(name);
            return super::size(slot);
        }
 
        void resize(const StringView name, const UInt32 newSize, const GPUResourceBinding& defaultValue = {}) {
            const UInt32 slot = findSlotIndex(name);
            super::resize(slot, newSize, defaultValue);
        }
 
        void clear(const StringView name) {
            const UInt32 slot = findSlotIndex(name);
            super::clear(slot);
        }
 
        [[nodiscard]] auto operator[](const StringView name) {
            const UInt32 slot = findSlotIndex(name);
            return super::operator[](slot);
        }
 
        [[nodiscard]] auto operator[](const StringView name) const {
            const UInt32 slot = findSlotIndex(name);
            return super::operator[](slot);
        }
 
    private:
        [[nodiscard]] UInt32 findSlotIndex(StringView name) const;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    struct GPUResourceSetDescriptor final {
        GPUResourceSetBindings bindings;
 
        String name;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(bindings);
            CE_REFL_DATA(name);
        }
    };
 
    class GPUResourceSet : public TDeviceObject<GPUResourceSetDescriptor> {
    public:
        GPUPipelineLayout& pipelineLayout;
 
    public:
        explicit GPUResourceSet(GPUPipelineLayout& pipelineLayout, const GPUResourceSetDescriptor& descriptor);
 
        ~GPUResourceSet() override;
 
        GPUResourceSet(const GPUResourceSet&) = delete;
        GPUResourceSet& operator=(const GPUResourceSet&) = delete;
 
        GPUResourceSet(GPUResourceSet&&) = delete;
        GPUResourceSet& operator=(GPUResourceSet&&) = delete;
    };
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUBufferResourceBinding);
 
CE_REFLECT_HASH(CeresEngine::GPUImageResourceBinding);
 
CE_REFLECT_HASH(CeresEngine::GPUSamplerResourceBinding);
 
template<> struct std::hash<CeresEngine::GPUResourceBinding> : public std::hash<CeresEngine::GPUResourceBinding::super> {};
 
template<> struct std::hash<CeresEngine::GPUResourceSetBindings> {
    [[nodiscard]] size_t operator()(const CeresEngine::GPUResourceSetBindings& object) {
        return CeresEngine::hash<CeresEngine::GPUResourceSetBindings::super>(object);
    }
};
 
template<> struct std::hash<CeresEngine::GPUShaderResourceSetBindings> : public std::hash<CeresEngine::GPUShaderResourceSetBindings::super> {};
 
CE_REFLECT_HASH(CeresEngine::GPUResourceSetDescriptor);