shadervariabledeclarations.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local includes
#include "vulkan/vulkan_core.h"
#include "rtti/typeinfo.h"
 
// External Includes
#include <nap/numeric.h>
#include <string>
#include <vector>
 
namespace nap
{
    enum class EDescriptorType : uint
    {
        Uniform,            
        Storage             
    };
 
 
    enum class EShaderVariableValueType : uint8
    {
        Unknown = 0,        
        Float,              
        Int,                
        UInt,               
        Vec2,               
        Vec3,               
        Vec4,               
        IVec4,              
        UVec4,              
        Mat2,               
        Mat3,               
        Mat4                
    };
 
 
    class NAPAPI ShaderVariableDeclaration
    {
        RTTI_ENABLE()
    public:
        ShaderVariableDeclaration(const std::string& name, int offset, int size);
        virtual ~ShaderVariableDeclaration() {}
 
        // Move is allowed
        ShaderVariableDeclaration(ShaderVariableDeclaration&& inRHS) = default;
        ShaderVariableDeclaration& operator=(ShaderVariableDeclaration&& inRHS) = default;
 
        // Copy is not allowed
        ShaderVariableDeclaration(const ShaderVariableDeclaration&) = delete;
        ShaderVariableDeclaration& operator=(const ShaderVariableDeclaration&) = delete;
 
        std::string                 mName;                                      
        int                         mOffset;                                    
        int                         mSize;                                      
    };
    
 
    class NAPAPI ShaderVariableValueDeclaration : public ShaderVariableDeclaration
    {
        RTTI_ENABLE(ShaderVariableDeclaration)
 
    public:
        ShaderVariableValueDeclaration(const std::string& name, int offset, int size, EShaderVariableValueType type);
        EShaderVariableValueType    mType;                                      
    };
 
 
    class NAPAPI ShaderVariableStructDeclaration : public ShaderVariableDeclaration
    {
        RTTI_ENABLE(ShaderVariableDeclaration)
    public:
        ShaderVariableStructDeclaration(const std::string& name, EDescriptorType descriptorType, int offset, int size);
        virtual ~ShaderVariableStructDeclaration() override;
 
        ShaderVariableStructDeclaration(ShaderVariableStructDeclaration&& inRHS);
        ShaderVariableStructDeclaration& operator=(ShaderVariableStructDeclaration&& inRHS);
 
        const ShaderVariableDeclaration* findMember(const std::string& name) const;
        std::vector<std::unique_ptr<ShaderVariableDeclaration>> mMembers;       
        EDescriptorType             mDescriptorType;                            
    };
 
 
    class NAPAPI ShaderVariableStructArrayDeclaration : public ShaderVariableDeclaration
    {
        RTTI_ENABLE(ShaderVariableDeclaration)
    public:
        ShaderVariableStructArrayDeclaration(const std::string& name, int offset, int size);
 
        ShaderVariableStructArrayDeclaration(const ShaderVariableStructArrayDeclaration&) = delete;
        ShaderVariableStructArrayDeclaration& operator=(const ShaderVariableStructArrayDeclaration&) = delete;
 
        std::vector<std::unique_ptr<ShaderVariableStructDeclaration>> mElements; 
    };
 
 
    class NAPAPI ShaderVariableStructBufferDeclaration : public ShaderVariableDeclaration
    {
        RTTI_ENABLE(ShaderVariableDeclaration)
    public:
        ShaderVariableStructBufferDeclaration(const std::string& name, int offset, int size, int stride, int numElements);
 
        std::unique_ptr<ShaderVariableStructDeclaration> mElement;              
        int                         mNumElements;                               
        int                         mStride;                                    
    };
 
 
    class NAPAPI ShaderVariableValueArrayDeclaration : public ShaderVariableDeclaration
    {
        RTTI_ENABLE(ShaderVariableDeclaration)
    public:
        ShaderVariableValueArrayDeclaration(const std::string& name, int offset, int size, int stride, EShaderVariableValueType elementType, int numElements);
 
        EShaderVariableValueType    mElementType;                               
        int                         mNumElements;                               
        int                         mStride;                                    
    };
 
 
    class NAPAPI BufferObjectDeclaration : public ShaderVariableStructDeclaration
    {
        RTTI_ENABLE(ShaderVariableStructDeclaration)
    public:
        BufferObjectDeclaration(const std::string& name, int binding, VkShaderStageFlags inStages, EDescriptorType descriptorType, int size);
 
        BufferObjectDeclaration(BufferObjectDeclaration&& inRHS);
        BufferObjectDeclaration& operator=(BufferObjectDeclaration&& inRHS);
 
        const ShaderVariableDeclaration& getBufferDeclaration() const;
 
        int                         mBinding;                                   
        VkShaderStageFlags          mStages;                                    
    };
 
    // Type alias
    using BufferObjectDeclarationList = std::vector<nap::BufferObjectDeclaration>;
}