bufferbindinginstance.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 "bufferbinding.h"
#include "gpubuffer.h"
#include "structbuffer.h"
 
// External Includes
#include <rtti/objectptr.h>
#include <glm/glm.hpp>
#include <utility/dllexport.h>
#include <nap/resource.h>
 
namespace nap
{
    // Forward Declares
    class BufferBindingInstance;
 
    // Called when the bound buffer resource changes
    using BufferBindingChangedCallback = std::function<void(BufferBindingInstance&)>;
 
    class NAPAPI BufferBindingInstance
    {
        RTTI_ENABLE()
    public:
        // Constructor
        BufferBindingInstance(const std::string& bindingName, const BufferBindingChangedCallback& bindingChangedCallback) :
            mBindingName(bindingName),
            mBindingChangedCallback(bindingChangedCallback)
        { }
 
        // Default Destructor
        virtual ~BufferBindingInstance() = default;
 
        virtual const ShaderVariableDeclaration& getDeclaration() const = 0;
 
        bool hasBuffer() const                              { return mBuffer != nullptr; }
 
        const GPUBuffer& getBuffer() const                  { assert(mBuffer != nullptr); return *mBuffer; }
 
        GPUBuffer& getBuffer()                              { assert(mBuffer != nullptr); return *mBuffer; }
 
        const std::string& getBindingName() const           { return mBindingName; }
 
    protected:
        const std::string                                   mBindingName;
        BufferBindingChangedCallback                        mBindingChangedCallback;
        GPUBuffer*                                          mBuffer = nullptr;
 
    private:
        friend class BaseMaterial;
        friend class BaseMaterialInstance;
 
        static std::unique_ptr<BufferBindingInstance> createBufferBindingInstanceFromDeclaration(const BufferObjectDeclaration& declaration, const BufferBinding* binding, BufferBindingChangedCallback bindingChangedCallback, utility::ErrorState& errorState);
 
        template<typename INSTANCE_TYPE, typename RESOURCE_TYPE, typename DECLARATION_TYPE>
        static std::unique_ptr<INSTANCE_TYPE> createBufferBindingInstance(const std::string& bindingName, const DECLARATION_TYPE& declaration, const BufferBinding* binding,  BufferBindingChangedCallback bufferChangedCallback, utility::ErrorState& errorState);
    };
 
 
    // BufferBindingStructInstance
 
    class NAPAPI BufferBindingStructInstance final : public BufferBindingInstance
    {
        RTTI_ENABLE(BufferBindingInstance)
    public:
        // Constructor
        BufferBindingStructInstance(const std::string& bindingName, const ShaderVariableStructBufferDeclaration& declaration, const BufferBindingChangedCallback& bindingChangedCallback) :
            BufferBindingInstance(bindingName, bindingChangedCallback),
            mDeclaration(&declaration)
        { }
 
        // Copy construction and copy assignment not allowed
        BufferBindingStructInstance(const BufferBindingStructInstance&) = delete;
        BufferBindingStructInstance& operator=(const BufferBindingStructInstance&) = delete;
 
        virtual const ShaderVariableDeclaration& getDeclaration() const override        { return *mDeclaration; }
 
        const ShaderVariableStructBufferDeclaration& getStructDeclaration() const       { return *mDeclaration; }
 
        const StructBuffer& getBuffer() const                                           { assert(hasBuffer()); return static_cast<const StructBuffer&>(*mBuffer); };
 
        StructBuffer& getBuffer()                                                       { assert(hasBuffer()); return static_cast<StructBuffer&>(*mBuffer); };
 
        void setBuffer(StructBuffer& buffer);
 
        void setBuffer(const BufferBindingStruct& resource);
 
    private:
        friend class BaseMaterial;
        friend class BaseMaterialInstance;
 
        void raiseChanged()                                 { if (mBindingChangedCallback) mBindingChangedCallback(*this); }
 
        // To be called when dynamic buffers are updated by upload
        // This requires the descriptor buffer info in the material instance to be updated
        nap::Slot<> mBufferChangedSlot = { [&]() -> void { raiseChanged(); } };
 
        const ShaderVariableStructBufferDeclaration*        mDeclaration;
    };
 
 
    // BufferBindingNumericInstance
 
    class NAPAPI BufferBindingNumericInstance : public BufferBindingInstance
    {
        RTTI_ENABLE(BufferBindingInstance)
    public:
        // Constructor
        BufferBindingNumericInstance(const std::string& bindingName, const ShaderVariableValueArrayDeclaration& declaration, const BufferBindingChangedCallback& bindingChangedCallback) :
            BufferBindingInstance(bindingName, bindingChangedCallback),
            mDeclaration(&declaration)
        { }
 
        virtual const ShaderVariableDeclaration& getDeclaration() const override    { return *mDeclaration; }
 
        const ShaderVariableValueArrayDeclaration& getNumericDeclaration() const    { return *mDeclaration; }
 
    protected:
        const ShaderVariableValueArrayDeclaration*          mDeclaration;
    };
 
 
    template<typename T>
    class TypedBufferBindingNumericInstance final : public BufferBindingNumericInstance
    {
        RTTI_ENABLE(BufferBindingNumericInstance)
    public:
        // Constructor
        TypedBufferBindingNumericInstance(const std::string& bindingName, const ShaderVariableValueArrayDeclaration& declaration, const BufferBindingChangedCallback& bindingChangedCallback) :
            BufferBindingNumericInstance(bindingName, declaration, bindingChangedCallback)
        { }
 
        const GPUBufferNumeric& getBuffer() const                               { assert(hasBuffer()); return static_cast<const GPUBufferNumeric&>(*mBuffer); }
 
        GPUBufferNumeric& getBuffer()                                           { assert(hasBuffer()); return static_cast<GPUBufferNumeric&>(*mBuffer); }
 
        void setBuffer(TypedGPUBufferNumeric<T>& buffer);
 
        void setBuffer(const TypedBufferBindingNumeric<T>& resource);
 
        const TypedGPUBufferNumeric<T>& getTypedBuffer() const                  { assert(mBuffer != nullptr); return static_cast<const TypedGPUBufferNumeric<T>&>(*mBuffer); }
 
        TypedGPUBufferNumeric<T>& getTypedBuffer()                              { assert(mBuffer != nullptr); return static_cast<TypedGPUBufferNumeric<T>&>(*mBuffer); }
 
    private:
        void raiseChanged()                                                     { if (mBindingChangedCallback) mBindingChangedCallback(*this); }
 
        // To be called when dynamic buffers are updated by upload
        // This requires the descriptor buffer info in the material instance to be updated
        nap::Slot<> mBufferChangedSlot = { [&]() -> void { raiseChanged(); } };
    };
 
 
    // TypedBufferBindingNumericInstance type definitions
 
    using BufferBindingUIntInstance     = TypedBufferBindingNumericInstance<uint>;
    using BufferBindingIntInstance      = TypedBufferBindingNumericInstance<int>;
    using BufferBindingFloatInstance    = TypedBufferBindingNumericInstance<float>;
    using BufferBindingVec2Instance     = TypedBufferBindingNumericInstance<glm::vec2>;
    using BufferBindingVec3Instance     = TypedBufferBindingNumericInstance<glm::vec3>;
    using BufferBindingVec4Instance     = TypedBufferBindingNumericInstance<glm::vec4>;
    using BufferBindingIVec4Instance    = TypedBufferBindingNumericInstance<glm::ivec4>;
    using BufferBindingMat4Instance     = TypedBufferBindingNumericInstance<glm::mat4>;
 
 
    // Template definitions
 
    template<class T>
    void TypedBufferBindingNumericInstance<T>::setBuffer(TypedGPUBufferNumeric<T>& buffer)
    {
        NAP_ASSERT_MSG(mDeclaration->mStride == buffer.getElementSize(), "Buffer declaration stride is not equal to buffer element size")
 
        if (mBuffer != nullptr)
            mBuffer->bufferChanged.disconnect(mBufferChangedSlot);
 
        mBuffer = &buffer;
        mBuffer->bufferChanged.connect(mBufferChangedSlot);
        raiseChanged();
    }
 
    template<class T>
    void TypedBufferBindingNumericInstance<T>::setBuffer(const TypedBufferBindingNumeric<T>& resource)
    {
        NAP_ASSERT_MSG(mDeclaration->mStride == resource.mBuffer.getElementSize(), "Buffer declaration stride is not equal to buffer element size")
 
        if (mBuffer != nullptr)
            mBuffer->bufferChanged.disconnect(mBufferChangedSlot);
 
        mBuffer = resource.mBuffer.get();
        mBuffer->bufferChanged.connect(mBufferChangedSlot);
        raiseChanged();
    }
}