VertexInput.h

Go to the documentation of this file.

#ifndef VULKAN_VERTEXINPUT
#define VULKAN_VERTEXINPUT
 
#include <glm/glm.hpp>
#include <concepts>
#include <type_traits>
#include <tuple>
#include <map>
#include <array>
#include <functional>
 
#include "VulkanException.h"
 
 
namespace Vulkan::PipelineOptions {
 
    template<template<int, typename, glm::qualifier> class Vec, int n, typename Type, glm::qualifier packing>
    constexpr bool isGlmVec(Vec<n, Type, packing>) {
        return n > 0 && n <= 4 &&
            std::is_fundamental<Type>::value &&
            std::same_as <Vec<n, Type, packing>, glm::vec<n, Type, packing>>;
    }
 
    template<typename T>
    concept IsVertex = requires(T, unsigned int i) {
        {T::getDescriptors(i)} -> std::same_as<std::pair<VkVertexInputBindingDescription, std::vector<VkVertexInputAttributeDescription>>>;
    };
 
 
 
 
 
//===========================================================================================================================================================================
//===========================================================================================================================================================================
//===========================================================================================================================================================================
 
 
 
    template<int componentsAmount>
    class VertexProperties {
    private:
 
        struct ComponentProperties {
            unsigned int scalarAmount;
            size_t scalarSize;
            size_t offset;
            VkFormat format;
        };
 
        std::array<ComponentProperties, componentsAmount> componentsProperties;
        size_t stride;
        int arrayDimension = 0; //how many "complete" elements are in the array
 
 
        template<template<int, typename, glm::qualifier> class Vec, int n, typename Type, glm::qualifier packing> requires(isGlmVec(Vec<n, Type, packing>{}))
            void addComponent(Vec<n, Type, packing>, std::array<size_t, componentsAmount> tupleOffsets) {
            componentsProperties.at(arrayDimension) = ComponentProperties{ n, sizeof(Type), tupleOffsets[arrayDimension]};
            componentsProperties.at(arrayDimension).format = findRightFormat<Type, n>(); //calculate the VkFormat (no arguments are passed because it is only important the Type and coordinates amount to calculate the format)
            stride += sizeof(Vec<n, Type, packing>); //increase the stride, namely the dimension of this Vertex
            arrayDimension++;
        }
 
 
        template<typename Type, int scalarAmount>
        static VkFormat findRightFormat() {
            //build the string which match the enum value name, then lookup a map containing <string, enum>
            std::string format = "VK_FORMAT_";
            std::string length = std::to_string(sizeof(Type) * 8); //length of the underying type, in bits
 
            //add the RxxGxxBxxAxx part
            for (int i = 1; i <= scalarAmount; ++i) {
                format += RGBA(i) + length;
            }
            format += "_";
 
            std::string type = std::is_floating_point_v<Type> ? "SFLOAT" :
                std::is_unsigned_v<Type> ? "UINT" : "SINT";
            format += type;
 
            //from the string now get the enum value
            std::map<std::string, VkFormat> formats = {
                {"VK_FORMAT_R16_UINTx",                 VK_FORMAT_R16_UINT},
                {"VK_FORMAT_R16_SINT",              VK_FORMAT_R16_SINT},
                {"VK_FORMAT_R16_SFLOAT",            VK_FORMAT_R16_SFLOAT},
                {"VK_FORMAT_R16G16_UNORM",          VK_FORMAT_R16G16_UNORM},
                {"VK_FORMAT_R16G16_SNORM",          VK_FORMAT_R16G16_SNORM},
                {"VK_FORMAT_R16G16_USCALED",        VK_FORMAT_R16G16_USCALED},
                {"VK_FORMAT_R16G16_SSCALED",        VK_FORMAT_R16G16_SSCALED},
                {"VK_FORMAT_R16G16_UINT",           VK_FORMAT_R16G16_UINT},
                {"VK_FORMAT_R16G16_SINT",           VK_FORMAT_R16G16_SINT},
                {"VK_FORMAT_R16G16_SFLOAT",         VK_FORMAT_R16G16_SFLOAT},
                {"VK_FORMAT_R16G16B16_UNORM",       VK_FORMAT_R16G16B16_UNORM},
                {"VK_FORMAT_R16G16B16_SNORM",       VK_FORMAT_R16G16B16_SNORM},
                {"VK_FORMAT_R16G16B16_USCALED",     VK_FORMAT_R16G16B16_USCALED},
                {"VK_FORMAT_R16G16B16_SSCALED",     VK_FORMAT_R16G16B16_SSCALED},
                {"VK_FORMAT_R16G16B16_UINT",        VK_FORMAT_R16G16B16_UINT},
                {"VK_FORMAT_R16G16B16_SINT",        VK_FORMAT_R16G16B16_SINT},
                {"VK_FORMAT_R16G16B16_SFLOAT",      VK_FORMAT_R16G16B16_SFLOAT},
                {"VK_FORMAT_R16G16B16A16_UNORM",    VK_FORMAT_R16G16B16A16_UNORM},
                {"VK_FORMAT_R16G16B16A16_SNORM",    VK_FORMAT_R16G16B16A16_SNORM},
                {"VK_FORMAT_R16G16B16A16_USCALED",  VK_FORMAT_R16G16B16A16_USCALED},
                {"VK_FORMAT_R16G16B16A16_SSCALED",  VK_FORMAT_R16G16B16A16_SSCALED},
                {"VK_FORMAT_R16G16B16A16_UINT",     VK_FORMAT_R16G16B16A16_UINT},
                {"VK_FORMAT_R16G16B16A16_SINT",     VK_FORMAT_R16G16B16A16_SINT},
                {"VK_FORMAT_R16G16B16A16_SFLOAT",   VK_FORMAT_R16G16B16A16_SFLOAT},
                {"VK_FORMAT_R32_UINT",              VK_FORMAT_R32_UINT},
                {"VK_FORMAT_R32_SINT",              VK_FORMAT_R32_SINT},
                {"VK_FORMAT_R32_SFLOAT",            VK_FORMAT_R32_SFLOAT},
                {"VK_FORMAT_R32G32_UINT",           VK_FORMAT_R32G32_UINT},
                {"VK_FORMAT_R32G32_SINT",           VK_FORMAT_R32G32_SINT},
                {"VK_FORMAT_R32G32_SFLOAT",         VK_FORMAT_R32G32_SFLOAT},
                {"VK_FORMAT_R32G32B32_UINT",        VK_FORMAT_R32G32B32_UINT},
                {"VK_FORMAT_R32G32B32_SINT",        VK_FORMAT_R32G32B32_SINT},
                {"VK_FORMAT_R32G32B32_SFLOAT",      VK_FORMAT_R32G32B32_SFLOAT},
                {"VK_FORMAT_R32G32B32A32_UINT",     VK_FORMAT_R32G32B32A32_UINT},
                {"VK_FORMAT_R32G32B32A32_SINT",     VK_FORMAT_R32G32B32A32_SINT},
                {"VK_FORMAT_R32G32B32A32_SFLOAT",   VK_FORMAT_R32G32B32A32_SFLOAT},
                {"VK_FORMAT_R64_UINT",              VK_FORMAT_R64_UINT},
                {"VK_FORMAT_R64_SINT",              VK_FORMAT_R64_SINT},
                {"VK_FORMAT_R64_SFLOAT",            VK_FORMAT_R64_SFLOAT},
                {"VK_FORMAT_R64G64_UINT",           VK_FORMAT_R64G64_UINT},
                {"VK_FORMAT_R64G64_SINT",           VK_FORMAT_R64G64_SINT},
                {"VK_FORMAT_R64G64_SFLOAT",         VK_FORMAT_R64G64_SFLOAT},
                {"VK_FORMAT_R64G64B64_UINT",        VK_FORMAT_R64G64B64_UINT},
                {"VK_FORMAT_R64G64B64_SINT",        VK_FORMAT_R64G64B64_SINT},
                {"VK_FORMAT_R64G64B64_SFLOAT",      VK_FORMAT_R64G64B64_SFLOAT},
                {"VK_FORMAT_R64G64B64A64_UINT",     VK_FORMAT_R64G64B64A64_UINT},
                {"VK_FORMAT_R64G64B64A64_SINT",     VK_FORMAT_R64G64B64A64_SINT},
                {"VK_FORMAT_R64G64B64A64_SFLOAT", VK_FORMAT_R64G64B64A64_SFLOAT}
            };
 
            return formats[format];
        }
 
 
        static std::string RGBA(int i) {
            switch (i) {
            case 1:
                return "R";
                break;
            case 2:
                return "G";
                break;
            case 3:
                return "B";
                break;
            case 4:
                return "A";
                break;
            default:
                throw VulkanException("Error in the amount of scala amount in the component of a Vertex: 1 <= n <= 4, but n == " + i);
                break;
            }
        }
 
 
        template<int I = 0, typename... E>
        static constexpr std::array<size_t, sizeof...(E)> tupleElementsOffset(const std::tuple<E...>& tuple) {
            constexpr size_t elementsInTuple = sizeof...(E);
            std::array<size_t, elementsInTuple> result{};
            result[I] = (char*)&std::get<I>(tuple) - (char*)&tuple; //place the offset of the I-th element of the tuple (from the beginning of the tuple itself) into the I-th element of the array
 
            //if we reached the last element of the tuple you don't have to try to calculate the offsets of the next elements (because there are none)
            if constexpr (I < elementsInTuple - 1) {
                auto tmp = tupleElementsOffset<I + 1>(tuple); //calculate offsets of the elements past I
 
                //copy the calculated offsets into the return array (only elements past I)
                for (int i = I + 1; i < elementsInTuple; ++i) {
                    result[i] = tmp[i];
                }
            }
 
            return result;
        }
 
 
    public:
        template<typename... Vec> requires (isGlmVec(Vec{}) && ...)
            VertexProperties(Vec... components) : stride{ 0 }, componentsProperties{} {
            auto tupleOffsets = tupleElementsOffset(std::tuple{ components... }); //calculate the offsets of each element of the tuple
 
            (addComponent(components, tupleOffsets), ...); //for each component, extract its properties
        }
 
 
        const ComponentProperties& operator[](unsigned int i) {
            return componentsProperties.at(i);
        }
    };
 
 
 
 
 
//===========================================================================================================================================================================
//===========================================================================================================================================================================
//===========================================================================================================================================================================
 
 
 
 
    template<typename... Vec> requires (isGlmVec(Vec{}) && ...)
        class Vertex {
        public:
            Vertex(Vec... vertexComponents) : vertexComponents{ vertexComponents... } {}
 
 
            Vertex() : vertexComponents{} {}
 
 
            friend bool operator==(const Vertex& v1, const Vertex& v2) {
                return v1.vertexComponents == v2.vertexComponents;
            }
 
 
            static std::pair<VkVertexInputBindingDescription, std::vector<VkVertexInputAttributeDescription>> getDescriptors(unsigned int binding) {
                VkVertexInputBindingDescription bindingDescription{};
                bindingDescription.binding = binding;
                bindingDescription.stride = sizeof(Vertex);
                bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
 
                std::vector <VkVertexInputAttributeDescription> attributeDescriptions(sizeof...(Vec)); //the array must have as many elements as the number of components
                for (int i = 0; i < sizeof...(Vec); ++i) {
                    attributeDescriptions[i].binding = binding;
                    attributeDescriptions[i].location = i;
                    attributeDescriptions[i].format = vertexProperties[i].format;
                    attributeDescriptions[i].offset = vertexProperties[i].offset;
                }
 
                return { bindingDescription, attributeDescriptions };
            }
 
 
        private:
            std::tuple<Vec...> vertexComponents; //this MUST be the only (non-static) member of the class, if not we may have problems with the stride.
            inline static VertexProperties<sizeof...(Vec)> vertexProperties = VertexProperties<sizeof...(Vec)>{ Vec{}... };
    };
 
 
 
 
//===========================================================================================================================================================================
//===========================================================================================================================================================================
//===========================================================================================================================================================================
 
 
 
 
    class PipelineVertexArrays {
    public:
 
        template<IsVertex... V>
        PipelineVertexArrays(V...) : vertexArraysDescriptor{} {
            {
                int i = 0; //counter of how many vertex types has already been added
                auto extract = [this, &i]<IsVertex T>()->void {
                    auto [bindingDescr, attributeDescrs] = T::getDescriptors(i); //get the descriptors for this vertex type
 
                    //add them to the arrays
                    this->bindingDescriptors.push_back(bindingDescr);
                    this->attributeDescriptors.insert(this->attributeDescriptors.end(), attributeDescrs.begin(), attributeDescrs.end());
                    i++;
                };
                ((extract.operator() < V > ()), ...); //calls the lambda for each Vertex type that has been passed as argument
            }
 
            //fill the descriptor
            vertexArraysDescriptor.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
            vertexArraysDescriptor.vertexBindingDescriptionCount = bindingDescriptors.size();
            vertexArraysDescriptor.pVertexBindingDescriptions = bindingDescriptors.data();
            vertexArraysDescriptor.vertexAttributeDescriptionCount = attributeDescriptors.size();
            vertexArraysDescriptor.pVertexAttributeDescriptions = attributeDescriptors.data();
        }
 
 
        const VkPipelineVertexInputStateCreateInfo& operator+() const {
            return vertexArraysDescriptor;
        }
 
    private:
        VkPipelineVertexInputStateCreateInfo vertexArraysDescriptor;
        std::vector<VkVertexInputBindingDescription> bindingDescriptors;
        std::vector< VkVertexInputAttributeDescription> attributeDescriptors;
    };
 
}
 
#endif