materialinstance.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
 
// External includes
#include <nap/resourceptr.h>
#include <utility/dllexport.h>
#include <nap/resource.h>
#include <nap/signalslot.h>
#include <rtti/typeinfo.h>
 
// Local includes
#include "uniformcontainer.h"
#include "descriptorsetcache.h"
#include "material.h"
 
namespace nap
{
    class Material;
    class RenderService;
    struct DescriptorSet;
    class DescriptorSetCache;
 
    namespace material
    {
        namespace instance
        {
            // RTTI get or create material function
            constexpr const char* getOrCreateMaterial = "getOrCreateMaterial";
        }
    }
 
    class NAPAPI BaseMaterialInstanceResource
    {
        RTTI_ENABLE()
    public:
        std::vector<ResourcePtr<UniformStruct>>     mUniforms;                                      
        std::vector<ResourcePtr<Sampler>>           mSamplers;                                      
        std::vector<ResourcePtr<BufferBinding>>     mBuffers;                                       
        std::vector<ResourcePtr<ShaderConstant>>    mConstants;                                     
 
        rttr::property getMaterialProperty() const;
 
        const std::string& getMaterialPropertyName() const;
 
    protected:
        BaseMaterialInstanceResource(std::string&& materialPropertyName);
 
    protected:
        std::string mMaterialPropertyName;
    };
 
    class NAPAPI MaterialInstanceResource : public BaseMaterialInstanceResource
    {
        RTTI_ENABLE(BaseMaterialInstanceResource)
    public:
        static constexpr const char* matProperty = "Material";
 
        MaterialInstanceResource() :
            BaseMaterialInstanceResource(matProperty)   {}
 
        ResourcePtr<Material>                       mMaterial;                                          
        EBlendMode                                  mBlendMode = EBlendMode::NotSet;                    
        EDepthMode                                  mDepthMode = EDepthMode::NotSet;                    
    };
 
    class NAPAPI ComputeMaterialInstanceResource : public BaseMaterialInstanceResource
    {
        RTTI_ENABLE(BaseMaterialInstanceResource)
    public:
        static constexpr const char* matProperty = "ComputeMaterial";
 
        ComputeMaterialInstanceResource() :
            BaseMaterialInstanceResource(matProperty)   {}
 
        ResourcePtr<ComputeMaterial>                mComputeMaterial;                                   
    };
 
    class NAPAPI BaseMaterialInstance : public UniformContainer
    {
        RTTI_ENABLE(UniformContainer)
        friend class RenderService;
    public:
        virtual UniformStructInstance* getOrCreateUniform(const std::string& name);
 
        template<class T>
        T* getOrCreateBuffer(const std::string& name);
 
        BufferBindingInstance* getOrCreateBuffer(const std::string& name) { return getOrCreateBufferInternal(name); }
 
        template<class T>
        T* getOrCreateSampler(const std::string& name);
 
        SamplerInstance* getOrCreateSampler(const std::string& name)        { return getOrCreateSamplerInternal(name, nullptr); }
 
        template<class T>
        T* getOrCreateSampler(const Sampler& resource);
 
        SamplerInstance* getOrCreateSampler(const Sampler& resource)        { return getOrCreateSamplerInternal(resource.mName, &resource); }
 
        BaseMaterial* getMaterial()                                         { assert(mMaterial != nullptr); return mMaterial; }
 
        const BaseMaterial* getMaterial() const                             { assert(mMaterial != nullptr); return mMaterial; }
 
        virtual const DescriptorSet& update();
        
    protected:
        friend class RenderableMesh;    // For responding to pipeline state events
 
        bool initInternal(RenderService& renderService, BaseMaterial& material, BaseMaterialInstanceResource& instanceResource, utility::ErrorState& errorState);
        void rebuildUBO(UniformBufferObject& ubo, UniformStructInstance* overrideStruct);
 
        void onUniformCreated();
        void onSamplerChanged(int imageStartIndex, SamplerInstance& samplerInstance, int imageArrayIndex);
        void onBufferChanged(int storageBufferIndex, BufferBindingInstance& bindingInstance);
 
        void updateBuffers(const DescriptorSet& descriptorSet);
        bool initBuffers(BaseMaterialInstanceResource& resource, utility::ErrorState& errorState);
 
        void updateSamplers(const DescriptorSet& descriptorSet);
        bool initSamplers(BaseMaterialInstanceResource& resource, utility::ErrorState& errorState);
        void addImageInfo(const Texture& texture, VkSampler sampler);
 
        bool initConstants(BaseMaterialInstanceResource& resource, utility::ErrorState& errorState);
 
        BufferBindingInstance* getOrCreateBufferInternal(const std::string& name);
        SamplerInstance* getOrCreateSamplerInternal(const std::string& name, const Sampler* sampler);
 
        const ShaderStageConstantMap& getShaderStageConstantMap() const     { return mShaderStageConstantMap; }
 
        ShaderConstantHash getConstantHash() const                          { return mConstantHash; }
 
    protected:
        VkDevice                                mDevice = nullptr;                      // Vulkan device
        RenderService*                          mRenderService = nullptr;               // RenderService
        BaseMaterial*                           mMaterial = nullptr;                    // Material
        BaseMaterialInstanceResource*           mResource = nullptr;                    // Material Instance Resource
 
        DescriptorSetCache*                     mDescriptorSetCache;                    // Cache used to acquire Vulkan DescriptorSets on each update
        std::vector<UniformBufferObject>        mUniformBufferObjects;                  // List of all UBO instances
 
        std::vector<VkWriteDescriptorSet>       mStorageWriteDescriptorSets;            // List of storage storage descriptors, used to update Descriptor Sets
        std::vector<VkDescriptorBufferInfo>     mStorageDescriptors;                    // List of storage buffers, used to update Descriptor Sets.
 
        std::vector<VkWriteDescriptorSet>       mSamplerWriteDescriptorSets;            // List of sampler descriptors, used to update Descriptor Sets
        std::vector<VkDescriptorImageInfo>      mSamplerDescriptors;                    // List of sampler images, used to update Descriptor Sets.
 
        ShaderStageConstantMap                  mShaderStageConstantMap;                // Reference of all shader constants per shader stage, generated on materialinstance init
        ShaderConstantHash                      mConstantHash;                          // Shader constant hash used to create a pipeline key
 
        bool                                    mUniformsCreated = false;               // Set when a uniform instance is created in between draws
    };
 
    class NAPAPI MaterialInstance : public BaseMaterialInstance
    {
        RTTI_ENABLE(BaseMaterialInstance)
    public:
 
        bool init(RenderService& renderService, MaterialInstanceResource& resource, utility::ErrorState& errorState);
 
        Material& getMaterial()                                                             { return static_cast<Material&>(*BaseMaterialInstance::getMaterial()); }
 
        const Material& getMaterial() const                                                 { return static_cast<const Material&>(*BaseMaterialInstance::getMaterial()); }
 
        EBlendMode getBlendMode() const;
 
        void setBlendMode(EBlendMode blendMode);
 
        void setDepthMode(EDepthMode depthMode);
 
        EDepthMode getDepthMode() const;
 
    private:
        MaterialInstanceResource*               mResource;                              // Resource this instance is associated with
    };
 
    class NAPAPI ComputeMaterialInstance : public BaseMaterialInstance
    {
        RTTI_ENABLE(BaseMaterialInstance)
    public:
 
        bool init(RenderService& renderService, ComputeMaterialInstanceResource& resource, utility::ErrorState& errorState);
 
        ComputeMaterial& getMaterial()                                                  { return static_cast<ComputeMaterial&>(*BaseMaterialInstance::getMaterial()); }
 
        const ComputeMaterial& getMaterial() const                                      { return static_cast<const ComputeMaterial&>(*BaseMaterialInstance::getMaterial()); }
 
        glm::uvec3 getWorkGroupSize() const;
 
    private:
        ComputeMaterialInstanceResource*        mResource;                              // Resource this instance is associated with
    };
 
 
    // Template definitions
 
    template<class T>
    T* BaseMaterialInstance::getOrCreateBuffer(const std::string& name)
    {
        return rtti_cast<T>(getOrCreateBufferInternal(name));
    }
    
    template<class T>
    T* BaseMaterialInstance::getOrCreateSampler(const std::string& name)
    {
        return rtti_cast<T>(getOrCreateSamplerInternal(name, nullptr));
    }
 
    template<class T>
    T* BaseMaterialInstance::getOrCreateSampler(const Sampler& resource)
    {
        return rtti_cast<T>(getOrCreateSamplerInternal(resource.mName, &resource));
    }
}