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 "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 std::string& getDisplayName() const { return mDisplayName; }
 
        VkDescriptorSetLayout getDescriptorSetLayout() const { return mDescriptorSetLayout; }
 
    protected:
        RenderService*                                  mRenderService = nullptr;               
        std::string                                     mDisplayName;                           
        BufferObjectDeclarationList                     mUBODeclarations;                       
        BufferObjectDeclarationList                     mSSBODeclarations;                      
        SamplerDeclarations                             mSamplerDeclarations;                   
        VkDescriptorSetLayout                           mDescriptorSetLayout = VK_NULL_HANDLE;  
 
        bool initLayout(VkDevice device, nap::utility::ErrorState& errorState);
 
        bool verifyShaderVariableDeclarations(utility::ErrorState& errorState);
    };
 
 
    class NAPAPI Shader : public BaseShader
    {
    public:
        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 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(Resource)
    public:
        ComputeShader(Core& core);
        ~ComputeShader();
 
        VkShaderModule getComputeModule() const { return mComputeModule; }
 
        glm::u32vec3 getWorkGroupSize() const { return mWorkGroupSize; }
 
        const std::vector<int>& getWorkGroupSizeConstantIds() const { return mWorkGroupSizeConstantIds; }
 
    protected:
        virtual bool load(const std::string& displayName, const char* compShader, int compSize, utility::ErrorState& errorState);
 
    private:
        glm::u32vec3                                    mWorkGroupSize;
        VkShaderModule                                  mComputeModule = VK_NULL_HANDLE;        
 
        std::vector<int>                                mWorkGroupSizeConstantIds;              
    };
 
 
    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;                          
    };
 
 
    class NAPAPI ComputeShaderFromFile : public ComputeShader
    {
        RTTI_ENABLE(ComputeShader)
    public:
        ComputeShaderFromFile(Core& core);
 
        virtual bool init(utility::ErrorState& error) override;
 
        std::string mComputePath;                           
    };
}