DynamicSet.h

Go to the documentation of this file.

#ifndef VULKAN_DYNAMICSET
#define VULKAN_DYNAMICSET
 
#include <glm/glm.hpp>
#include <tuple>
#include <concepts>
#include <type_traits>
 
#include "UniformBuffer.h"
#include "LogicalDevice.h"
#include "PhysicalDevice.h"
#include "Set.h"
 
 
namespace Vulkan {
 
    class DynamicSet : public Set {
    public:
 
        struct DynamicSetBindingInfo : public Set::BindingInfo {
            DynamicSetBindingInfo(int size, const Buffers::UniformBuffer& buffer, int offset, int dynamicDistance = 0) : size{ size }, buffer{ buffer }, offset{ offset }, dynamicDistance{ dynamicDistance }{}
 
            DescriptorSetBindingCreationInfo generateDescriptorSetBindingInfo(const VkDescriptorSet& descriptorSet) const override {
                return DescriptorSetBindingCreationInfo{ binding, descriptorSet, size, buffer, offset, dynamicDistance };
            }
 
            int size;
            const Buffers::UniformBuffer& buffer; 
            int offset; 
            int dynamicDistance;
        };
 
 
        template<typename... Structs, template<typename, typename>class... Bindings> requires (std::same_as<Bindings<VkShaderStageFlagBits, Structs>, std::pair<VkShaderStageFlagBits, Structs>> && ...)
        DynamicSet(const PhysicalDevice& realGpu, const LogicalDevice& virtualGpu, const Buffers::UniformBuffer& buffer, Bindings<VkShaderStageFlagBits, Structs>... bindings) : Set{ virtualGpu } {
            //get minimum alignment for the GPU memory, used for padding
            int alignment = realGpu.getProperties().limits.minUniformBufferOffsetAlignment;
            int currentOffset = 0;
 
            //for each binding
            ([this, &currentOffset, &buffer, alignment](std::pair<VkShaderStageFlagBits, Structs> binding) {
                //allocate the binding info on the heap (we need a pointer for polymorphism)
                auto tmp = std::make_unique<DynamicSetBindingInfo>(sizeof(binding.second), buffer, currentOffset);
                bindingsPerBuffer[&buffer].push_back(tmp.get()); //add a pointer to this info struct in the right array (see comment next to the definition of this variable)
                this->bindingsInfo.push_back(std::move(tmp)); //put the binding info in the binding info vector
 
                currentOffset += sizeof(binding.second); //increase the offset in the buffer by the size of the last binding
                int paddingAmount = (alignment - (currentOffset % alignment)) % alignment; //number of padding bytes
                currentOffset += paddingAmount; //add the padding bytes to the offset. e.g. offset = 253, padding bytes = 3 ( (253+3) % 16 = 0, 16 is often the required alignment)
                }(bindings), ...);
 
            //the dynamic distance for bindings allocated in this way is always the same and equal to the total size of the bindings
            for (int i = 0; i < bindingsInfo.size(); ++i) {
                static_cast<DynamicSetBindingInfo*>(bindingsInfo[i].get())->dynamicDistance = currentOffset;
                bindingsInfo[i].get()->binding = i; //also set the binding index
            }
 
            //create the Vulkan layout struct used during pipeline creation
            createDescriptorSetLayout(std::pair{ bindings.first, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC }...);
        }
 
 
 
        template<typename... Structs, typename... T> requires 
            (std::same_as<T, std::tuple<VkShaderStageFlagBits, Structs, Buffers::UniformBuffer*, int, int>> && ...)
            DynamicSet(const LogicalDevice& virtualGpu, T... bindingsInfo) : Set{ virtualGpu } {
            //for each binding...
            ([this](T bindingInfo) {
                //allocate the binding info on the heap (we need a pointer for polymorphism)
                auto tmp = std::make_unique<DynamicSetBindingInfo>(sizeof(std::get<1>(bindingsInfo)), *std::get<2>(bindingsInfo), std::get<3>(bindingsInfo), std::get<4>(bindingsInfo));
                bindingsPerBuffer[&(tmp->buffer)].push_back(tmp.get()); //add a pointer to this info struct in the right array (see comment next to the definition of this variable)
                tmp->binding = bindingsInfo.size(); //set the index of this binding
                this->bindingsInfo.push_back(std::move(tmp)); //add the pointer to the vector of binding info
                }(bindingsInfo), ...);
        
            //create the Vulkan layout struct used during pipeline creation
            createDescriptorSetLayout(std::pair{ std::get<0>(bindingsInfo), VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC }...);
        }
 
 
 
        std::vector<uint32_t> getDynamicDistances(int i = 0) const {
            std::vector<uint32_t> res;
 
            for (const auto& binding : bindingsInfo) {
                res.push_back(static_cast<DynamicSetBindingInfo*>(binding.get())->dynamicDistance * i);
            }
 
            return res;
        }
 
 
        template<typename... Bindings, template<typename...>class... T> requires (std::same_as<std::tuple<Bindings...>, T<Bindings...>> && ...)
        void fillBuffer(Buffers::UniformBuffer& buffer, const T<Bindings...>&... tuplesOfData) const {
            fillBufferHelper(buffer, std::make_integer_sequence<int, sizeof...(Bindings)>{}, tuplesOfData...);
        }
 
 
 
    private:
 
        //This function is used to perform a sort of constexpr for each loop on the tuple
        template<int... TI, typename... T>
        void fillBufferHelper(Buffers::UniformBuffer& buffer, std::integer_sequence<int, TI...>, const T&... tuplesOfData) const {
            std::vector<DynamicSetBindingInfo*> bindingsInfo;
            try {
                bindingsInfo = bindingsPerBuffer.at(&buffer); //get the info of the bindings of the buffer
            }
            catch (const std::out_of_range&) {
                throw VulkanException{ "Failed to fill the uniform buffer", "The buffer to be filled isn't used in this set" };
            }
            int counter = 0; //how many tuple we've already traversed
 
            //Basically the n - th element of the m - th tuple will be inserted in position : offset[n] + dynamicDistance[n] * m
            ([&bindingsInfo, &counter, &buffer](const T& tuple) {
                (buffer.fillBuffer(std::get<TI>(tuple), bindingsInfo[TI]->offset + bindingsInfo[TI]->dynamicDistance * counter), ...);
                counter++;
            }(tuplesOfData), ...);
        }
 
 
        std::map<const Buffers::UniformBuffer*, std::vector<DynamicSetBindingInfo*>> bindingsPerBuffer; //this map holds the bindings relative to each buffer used in the Set
 
    };
 
}
 
 
 
#endif