material.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>
 
// Local includes
#include "uniformcontainer.h"
#include "materialcommon.h"
#include "shader.h"
 
namespace nap
{
    // Forward Declares
    struct DescriptorSet;
    class DescriptorSetCache;
    class Core;
 
    class BaseMaterial : public Resource, public UniformContainer
    {
        RTTI_ENABLE(Resource)
    public:
        BaseMaterial(Core& core);
        virtual ~BaseMaterial() = default;
 
        const BaseShader& getShader()                   { assert(mShader != nullptr); return *mShader; }
 
        std::vector<ResourcePtr<UniformStruct>>         mUniforms;                                              
        std::vector<ResourcePtr<BufferBinding>>         mBuffers;                                               
        std::vector<ResourcePtr<Sampler>>               mSamplers;                                              
 
    protected:
        bool rebuild(const BaseShader& shader, utility::ErrorState& errorState);
 
    private:
        using UniformStructMap = std::unordered_map<std::string, std::unique_ptr<UniformStruct>>;
        using UniformStructArrayMap = std::unordered_map<std::string, std::unique_ptr<UniformStructArray>>;
        RenderService* mRenderService = nullptr;
        const BaseShader* mShader = nullptr;
    };
 
 
    // Material
 
    class NAPAPI Material : public BaseMaterial
    {
        RTTI_ENABLE(BaseMaterial)
    public:
        Material(Core& core);
 
        struct VertexAttributeBinding
        {
            VertexAttributeBinding(const std::string& meshAttributeID, const std::string& shaderAttributeID);
 
            // Default constructor
            VertexAttributeBinding() = default;
 
            std::string mMeshAttributeID;               
            std::string mShaderAttributeID;             
        };
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        const Shader& getShader() const                             { assert(Material::mShader != nullptr); return *Material::mShader; }
 
        EBlendMode getBlendMode() const                             { assert(mBlendMode != EBlendMode::NotSet); return mBlendMode; }
 
        void setBlendMode(EBlendMode blendMode)                     { mBlendMode = blendMode; }
 
        EDepthMode getDepthMode() const                             { assert(mDepthMode != EDepthMode::NotSet); return mDepthMode; }
 
        void setDepthMode(EDepthMode depthMode)                     { mDepthMode = depthMode; }
 
        const VertexAttributeBinding* findVertexAttributeBinding(const std::string& shaderAttributeID) const;
 
        static const std::vector<VertexAttributeBinding>& sGetDefaultVertexAttributeBindings();
 
        std::vector<VertexAttributeBinding>         mVertexAttributeBindings;                           
        ResourcePtr<Shader>                         mShader = nullptr;                                  
        EBlendMode                                  mBlendMode = EBlendMode::Opaque;                    
        EDepthMode                                  mDepthMode = EDepthMode::InheritFromBlendMode;      
    };
 
 
    // Compute Material
 
    class NAPAPI ComputeMaterial : public BaseMaterial
    {
        RTTI_ENABLE(BaseMaterial)
    public:
        ComputeMaterial(Core& core);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        const ComputeShader& getShader() const                      { assert(ComputeMaterial::mShader != nullptr); return *ComputeMaterial::mShader; }
 
        ResourcePtr<ComputeShader> mShader = nullptr;               
    };
}