uniform.h

#pragma once
 
// Local Includes
#include "shadervariabledeclarations.h"
#include "gpubuffer.h"
 
// External Includes
#include <rtti/objectptr.h>
#include <glm/glm.hpp>
#include <utility/dllexport.h>
#include <nap/resource.h>
 
namespace nap
{
    // Forward Declares
    class UniformInstance;
    using UniformCreatedCallback = std::function<void()>;
 
    // Common uniform property names
    namespace uniform
    {
        constexpr const char* uniforms  = "Uniforms";
        constexpr const char* value     = "Value";
        constexpr const char* values    = "Values";
        constexpr const char* structs   = "Structs";
    }
 
    class NAPAPI Uniform : public Resource
    {
        RTTI_ENABLE(Resource)
    public:
        std::string mName;      
    };
 
 
    class NAPAPI UniformStruct : public Uniform
    {
        RTTI_ENABLE(Uniform)
    public:
 
        void addUniform(Uniform& uniform);
 
        Uniform* findUniform(const std::string& name);
 
        const Uniform* findUniform(const std::string& name) const;
 
    public:
        std::vector<rtti::ObjectPtr<Uniform>> mUniforms;
    };
    
 
    class NAPAPI UniformStructArray : public Uniform
    {
        RTTI_ENABLE(Uniform)
    public:
        void insertStruct(int index, UniformStruct& uniformStruct);
 
    public:
        std::vector<rtti::ObjectPtr<UniformStruct>> mStructs;
    };
 
 
    class NAPAPI UniformValue : public Uniform
    {
        RTTI_ENABLE(Uniform)
    };
 
 
    template<typename T>
    class TypedUniformValue : public UniformValue
    {
        RTTI_ENABLE(UniformValue)
    public:
        T mValue = T();
    };
 
 
    class NAPAPI UniformValueArray : public UniformValue
    {
        RTTI_ENABLE(UniformValue)
 
    public:
        virtual int getCount() const = 0;
    };
 
 
    template<typename T>
    class TypedUniformValueArray : public UniformValueArray
    {
        RTTI_ENABLE(UniformValueArray)
    public:
        virtual int getCount() const override { return mValues.size(); }
        std::vector<T> mValues;
    };
 
 
    template<class T>
    const Uniform* findUniformStructMember(const std::vector<T>& members, const ShaderVariableDeclaration& declaration)
    {
        for (auto& member : members)
            if (member->mName == declaration.mName)
                return member.get();
        return nullptr;
    }
 
 
    // Uniform value type definitions
    
    using UniformUInt                       = TypedUniformValue<uint>;
    using UniformInt                        = TypedUniformValue<int>;
    using UniformFloat                      = TypedUniformValue<float>;
    using UniformVec2                       = TypedUniformValue<glm::vec2>;
    using UniformVec3                       = TypedUniformValue<glm::vec3>;
    using UniformVec4                       = TypedUniformValue<glm::vec4>;
    using UniformIVec4                      = TypedUniformValue<glm::ivec4>;
    using UniformUVec4                      = TypedUniformValue<glm::uvec4>;
    using UniformMat4                       = TypedUniformValue<glm::mat4>;
 
 
    // Uniform value array type definitions
 
    using UniformUIntArray                  = TypedUniformValueArray<uint>;
    using UniformIntArray                   = TypedUniformValueArray<int>;
    using UniformFloatArray                 = TypedUniformValueArray<float>;
    using UniformVec2Array                  = TypedUniformValueArray<glm::vec2>;
    using UniformVec3Array                  = TypedUniformValueArray<glm::vec3>;
    using UniformVec4Array                  = TypedUniformValueArray<glm::vec4>;
    using UniformIVec4Array                 = TypedUniformValueArray<glm::ivec4>;
    using UniformUVec4Array                 = TypedUniformValueArray<glm::uvec4>;
    using UniformMat4Array                  = TypedUniformValueArray<glm::mat4>;
}