uniforminstance.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 "uniform.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()>;
 
    class NAPAPI UniformInstance
    {
        RTTI_ENABLE()
 
    public:
        // Default Destructor
        virtual ~UniformInstance() = default;
 
        virtual const ShaderVariableDeclaration& getDeclaration() const = 0;
    };
 
 
    // UniformStructInstance
 
    class NAPAPI UniformStructInstance : public UniformInstance
    {
        RTTI_ENABLE(UniformInstance)
 
    public:
        // Constructor
        UniformStructInstance(const ShaderVariableStructDeclaration& declaration, const UniformCreatedCallback& uniformCreatedCallback) :
            mUniformCreatedCallback(uniformCreatedCallback),
            mDeclaration(declaration)
        { }
 
        // Delete copy assignment operator and copy constructor
        UniformStructInstance(const UniformStructInstance&) = delete;
        UniformStructInstance& operator=(const UniformStructInstance&) = delete;
 
        const std::vector<std::unique_ptr<UniformInstance>>& getUniforms() const        { return mUniforms; }
 
        UniformInstance* findUniform(const std::string& name);
 
        template<typename T>
        T* findUniform(const std::string& name);
 
        template<typename T>
        T* getOrCreateUniform(const std::string& name);
 
        virtual const ShaderVariableDeclaration& getDeclaration() const override        { return mDeclaration; }
 
    private:
        friend class BaseMaterial;
        friend class ComputeMaterial;
        friend class Material;
        friend class BaseMaterialInstance;
        friend class MaterialInstance;
 
        bool addUniformRecursive(const ShaderVariableStructDeclaration& structDeclaration, const UniformStruct* structResource, const UniformCreatedCallback& uniformCreatedCallback, bool createDefaults, utility::ErrorState& errorState);
 
        static std::unique_ptr<UniformInstance> createUniformFromDeclaration(const ShaderVariableDeclaration& declaration, const UniformCreatedCallback& uniformCreatedCallback);
 
        UniformCreatedCallback                                  mUniformCreatedCallback;
        const ShaderVariableStructDeclaration&                  mDeclaration;
        std::vector<std::unique_ptr<UniformInstance>>           mUniforms;
    };
 
 
    // UniformStructArrayInstance
 
    class NAPAPI UniformStructArrayInstance : public UniformInstance
    {
        friend class UniformStructInstance;
        RTTI_ENABLE(UniformInstance)
    public:
        // Constructor
        UniformStructArrayInstance(const ShaderVariableStructArrayDeclaration& declaration) :
            mDeclaration(declaration)
        { }
 
        // Copy construction and copy assignment not allowed
        UniformStructArrayInstance(const UniformStructArrayInstance&) = delete;
        UniformStructArrayInstance& operator=(const UniformStructArrayInstance&) = delete;
 
        const std::vector<std::unique_ptr<UniformStructInstance>>& getElements() const  { return mElements; }
 
        int getNumElements() const                                                      { return static_cast<int>(mElements.size()); }
 
        int getMaxNumElements() const                                                   { return mDeclaration.mElements.size(); }
 
        UniformStructInstance& getElement(int index)                                    { assert(index < mElements.size()); return *mElements[index]; }
 
        UniformStructInstance* findElement(int index);
 
        UniformStructInstance& operator[](size_t index)                                 { return getElement(index); }
 
        virtual const ShaderVariableDeclaration& getDeclaration() const override        { return mDeclaration; }
 
    private:
        const ShaderVariableStructArrayDeclaration&             mDeclaration;
        std::vector<std::unique_ptr<UniformStructInstance>>     mElements;
 
        void addElement(std::unique_ptr<UniformStructInstance> element);
    };
 
 
    // UniformLeafInstance
 
    class NAPAPI UniformLeafInstance : public UniformInstance
    {
        RTTI_ENABLE(UniformInstance)
    public:
        virtual void push(uint8* uniformBuffer) const = 0;
    };
 
 
    // Uniform Values
 
    class NAPAPI UniformValueInstance : public UniformLeafInstance
    {
        RTTI_ENABLE(UniformLeafInstance)
    public:
 
        // Constructor
        UniformValueInstance(const ShaderVariableValueDeclaration& declaration) :
            mDeclaration(&declaration) { }
 
        virtual const ShaderVariableDeclaration& getDeclaration() const override        { return *mDeclaration; }
 
    protected:
        const ShaderVariableValueDeclaration*   mDeclaration = nullptr;
    };
 
 
    template<class T>
    class TypedUniformValueInstance : public UniformValueInstance
    {
        RTTI_ENABLE(UniformValueInstance)
 
    public:
        TypedUniformValueInstance(const ShaderVariableValueDeclaration& declaration) :
            UniformValueInstance(declaration) { }
 
        void setValue(const T& value)                                                   { mValue = value; }
 
        const T& getValue() const                                                       { return mValue; }
            
        void set(const TypedUniformValue<T>& resource)                                  { mValue = resource.mValue; }
 
        virtual void push(uint8_t* uniformBuffer) const override;
 
    private:
        T mValue = T();
    };
 
 
    // Uniform Value Array
 
    class NAPAPI UniformValueArrayInstance : public UniformLeafInstance
    {
        RTTI_ENABLE(UniformLeafInstance)
 
    public:
        UniformValueArrayInstance(const ShaderVariableValueArrayDeclaration& declaration) :
            mDeclaration(&declaration) { }
 
        virtual const ShaderVariableDeclaration& getDeclaration() const override    { return *mDeclaration; }
 
        int getMaxNumElements() const                                               { return mDeclaration->mNumElements; }
 
        virtual void setDefault() = 0;
 
    protected:
        const ShaderVariableValueArrayDeclaration* mDeclaration;
    };
 
 
    template<typename T>
    class TypedUniformValueArrayInstance : public UniformValueArrayInstance
    {
        RTTI_ENABLE(UniformValueArrayInstance)
 
    public:
        TypedUniformValueArrayInstance(const ShaderVariableValueArrayDeclaration& declaration) :
            UniformValueArrayInstance(declaration) { }
 
        void set(const TypedUniformValueArray<T>& resource)                         { mValues = resource.mValues; }
 
        void setValues(const std::vector<T>& values)                                { assert(values.size() <= mDeclaration->mNumElements); mValues = values; }
 
        void setValue(T value, int index)                                           { assert(index < mValues.size()); mValues[index] = value; }
 
        virtual void setDefault() override                                          { mValues.resize(mDeclaration->mNumElements, T()); }
 
        int getNumElements() const                                                  { return static_cast<int>(mValues.size()); }
 
        std::vector<T>& getValues()                                                 { return mValues; }
 
        virtual void push(uint8* uniformBuffer) const override;
 
        T& operator[](size_t index) { assert(index < mValues.size()); return mValues[index]; }
 
 
    private:
        std::vector<T> mValues;
    };
 
 
    // Type definitions for all supported uniform instance value types
 
    using UniformUIntInstance   = TypedUniformValueInstance<uint>;
    using UniformIntInstance    = TypedUniformValueInstance<int>;
    using UniformFloatInstance  = TypedUniformValueInstance<float>;
    using UniformVec2Instance   = TypedUniformValueInstance<glm::vec2>;
    using UniformVec3Instance   = TypedUniformValueInstance<glm::vec3>;
    using UniformVec4Instance   = TypedUniformValueInstance<glm::vec4>;
    using UniformIVec4Instance  = TypedUniformValueInstance<glm::ivec4>;
    using UniformUVec4Instance  = TypedUniformValueInstance<glm::uvec4>;
    using UniformMat4Instance   = TypedUniformValueInstance<glm::mat4>;
 
 
    // Type definitions for all supported uniform instance array value types
 
    using UniformUIntArrayInstance  = TypedUniformValueArrayInstance<uint>;
    using UniformIntArrayInstance   = TypedUniformValueArrayInstance<int>;
    using UniformFloatArrayInstance = TypedUniformValueArrayInstance<float>;
    using UniformVec2ArrayInstance  = TypedUniformValueArrayInstance<glm::vec2>;
    using UniformVec3ArrayInstance  = TypedUniformValueArrayInstance<glm::vec3>;
    using UniformVec4ArrayInstance  = TypedUniformValueArrayInstance<glm::vec4>;
    using UniformIVec4ArrayInstance = TypedUniformValueArrayInstance<glm::ivec4>;
    using UniformUVec4ArrayInstance = TypedUniformValueArrayInstance<glm::uvec4>;
    using UniformMat4ArrayInstance  = TypedUniformValueArrayInstance<glm::mat4>;
 
 
    // Template definitions
 
    template<typename T>
    T* nap::UniformStructInstance::findUniform(const std::string& name)
    {
        UniformInstance* instance = findUniform(name);
        if (instance != nullptr)
            return rtti_cast<T>(instance);
        return nullptr;
    }
 
    template<typename T>
    T* nap::UniformStructInstance::getOrCreateUniform(const std::string& name)
    {
        // First try to find it, if found cast and return
        UniformInstance* instance = findUniform(name);
        if (instance != nullptr)
        {
            assert(instance->get_type().is_derived_from<T>());
            return rtti_cast<T>(instance);
        }
 
        // Otherwise fetch the declaration and use it to create the new instance
        const ShaderVariableDeclaration* declaration = mDeclaration.findMember(name);
        if (declaration == nullptr)
            return nullptr;
 
        std::unique_ptr<UniformInstance> new_instance = createUniformFromDeclaration(*declaration, mUniformCreatedCallback);
        T* result = rtti_cast<T>(new_instance.get());
        assert(result != nullptr);
        mUniforms.emplace_back(std::move(new_instance));
 
        // Notify listeners
        if (mUniformCreatedCallback)
            mUniformCreatedCallback();
        return result;
    }
 
    template<class T>
    void nap::TypedUniformValueInstance<T>::push(uint8* uniformBuffer) const
    {
        assert(sizeof(mValue) == mDeclaration->mSize);
        memcpy(uniformBuffer + mDeclaration->mOffset, &mValue, sizeof(mValue));
    }
 
    template<typename T>
    void nap::TypedUniformValueArrayInstance<T>::push(uint8* uniformBuffer) const
    {
        if (sizeof(T) == mDeclaration->mStride)
        {
            size_t size = mValues.size() * sizeof(T);
            memcpy(uniformBuffer + mDeclaration->mOffset, mValues.data(), size);
        }
        else
        {
            uint8_t* dest = uniformBuffer + mDeclaration->mOffset;
            for (const T& value : mValues)
            {
                memcpy(dest, &value, sizeof(value));
                dest += mDeclaration->mStride;
            }
        }
    }
}