shader.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 "rendertarget.h"
#include "vertexattributedeclaration.h"
#include "samplerdeclaration.h"
#include "shadervariabledeclarations.h"
#include "shaderconstant.h"
#include "shaderconstantdeclaration.h"
#include "uniform.h"
 
// External Includes
#include <utility/dllexport.h>
#include <nap/resource.h>
#include <rtti/factory.h>
 
namespace nap
{
    // Forward Declares
    class RenderService;
    class Core;
 
    class NAPAPI BaseShader : public Resource
    {
        RTTI_ENABLE(Resource)
    public:
        BaseShader(Core& core);
        virtual ~BaseShader();
 
        const SamplerDeclarations& getSamplerDeclarations() const                   { return mSamplerDeclarations; }
 
        const std::vector<BufferObjectDeclaration>& getUBODeclarations() const      { return mUBODeclarations; }
 
        const std::vector<BufferObjectDeclaration>& getSSBODeclarations() const     { return mSSBODeclarations; }
 
        const ShaderConstantDeclarations& getConstantDeclarations() const           { return mConstantDeclarations; }
 
        const std::string& getDisplayName() const                                   { return mDisplayName; }
 
        VkDescriptorSetLayout getDescriptorSetLayout() const                        { return mDescriptorSetLayout; }
 
        void clear();
 
    protected:
        RenderService*                                  mRenderService = nullptr;               
        std::string                                     mDisplayName;                           
        BufferObjectDeclarationList                     mUBODeclarations;                       
        BufferObjectDeclarationList                     mSSBODeclarations;                      
        SamplerDeclarations                             mSamplerDeclarations;                   
        ShaderConstantDeclarations                      mConstantDeclarations;                  
        VkDescriptorSetLayout                           mDescriptorSetLayout = VK_NULL_HANDLE;  
 
        bool initLayout(VkDevice device, nap::utility::ErrorState& errorState);
 
        bool verifyShaderVariableDeclarations(utility::ErrorState& errorState);
    };
 
 
    class NAPAPI Shader : public BaseShader
    {
        RTTI_ENABLE(BaseShader)
    public:
        enum EShaderType : uint
        {
            Vertex      = 0x01,
            Fragment    = 0x02
        };
        using ShaderTypeFlags = uint;
 
        Shader(Core& core);
        ~Shader();
 
        const VertexAttributeDeclarations& getAttributes() const                    { return mShaderAttributes; }
 
        VkShaderModule getVertexModule() const                                      { return mVertexModule; }
 
        VkShaderModule getFragmentModule() const                                    { return mFragmentModule; }
 
    protected:
         bool load(const std::string& displayName, const std::vector<std::string>& searchPaths, const char* vertShader, int vertSize, const char* fragShader, int fragSize, utility::ErrorState& errorState);
         
         bool loadDefault(const std::string& displayName, utility::ErrorState& errorState);
 
    private:
        VertexAttributeDeclarations                     mShaderAttributes;                      
        VkShaderModule                                  mVertexModule = VK_NULL_HANDLE;         
        VkShaderModule                                  mFragmentModule = VK_NULL_HANDLE;       
    };
 
 
    class NAPAPI ComputeShader : public BaseShader
    {
        RTTI_ENABLE(BaseShader)
    public:
        ComputeShader(Core& core);
        ~ComputeShader();
 
        VkShaderModule getComputeModule() const                                         { return mComputeModule; }
 
        const glm::uvec3& getWorkGroupSize() const                                      { return mWorkGroupSize; }
 
        const std::unordered_map<uint, std::string>& getWorkGroupSizeOverrides() const  { return mWorkGroupSizeOverrides; }
 
        bool mEnableMaxGroupSizeDefault = false; 
 
    protected:
        virtual bool load(const std::string& displayName, const std::vector<std::string>& searchPaths, const char* compShader, int compSize, utility::ErrorState& errorState);
 
    private:
        glm::uvec3                                          mWorkGroupSize;                         
        std::unordered_map<uint, std::string>               mWorkGroupSizeOverrides;                
        VkShaderModule                                      mComputeModule = VK_NULL_HANDLE;        
    };
 
 
    class NAPAPI ShaderFromFile : public Shader
    {
        RTTI_ENABLE(Shader)
    public:
        ShaderFromFile(Core& core);
 
        virtual bool init(utility::ErrorState& error) override;
 
        std::string mVertPath;                          
        std::string mFragPath;                          
        bool mRestrictModuleIncludes = false;           
    };
 
 
    class NAPAPI ComputeShaderFromFile : public ComputeShader
    {
        RTTI_ENABLE(ComputeShader)
    public:
        ComputeShaderFromFile(Core& core);
 
        virtual bool init(utility::ErrorState& error) override;
 
        std::string mComputePath;                       
        bool mRestrictModuleIncludes = false;           
    };
}