PipelineConfiguration.h

#pragma once
 
// Standard.
#include <set>
#include <optional>
 
// Custom.
#include "render/general/pipeline/PipelineType.hpp"
#include "shader/general/ShaderMacro.h"
 
namespace ne {
    enum class PipelineShadowMappingUsage : unsigned char {
        DIRECTIONAL_AND_SPOT_LIGHTS,
        POINT_LIGHTS,
    };
 
    class PipelineConfiguration {
    public:
        PipelineConfiguration() = delete;
        virtual ~PipelineConfiguration() = default;
 
        std::set<ShaderMacro> getRequiredVertexShaderMacros() const { return requiredVertexShaderMacros; }
 
        virtual std::set<ShaderMacro> getRequiredFragmentShaderMacros() const { return {}; }
 
        std::string_view getVertexShaderName() const { return sVertexShaderName; }
 
        virtual std::optional<GraphicsPipelineType> getGraphicsType() const = 0;
 
        virtual std::string_view getFragmentShaderName() const { return ""; }
 
        virtual std::string_view getComputeShaderName() const { return ""; }
 
        virtual bool isPixelBlendingEnabled() const { return false; }
 
        virtual bool isDepthBiasEnabled() const { return false; }
 
        virtual std::optional<PipelineShadowMappingUsage> getShadowMappingUsage() const { return {}; }
 
    protected:
        PipelineConfiguration(
            const std::string& sVertexShaderName, const std::set<ShaderMacro>& requiredVertexShaderMacros);
 
        std::set<ShaderMacro> requiredVertexShaderMacros;
 
        const std::string sVertexShaderName;
    };
 
    class ColorPipelineConfiguration : public PipelineConfiguration {
    public:
        ColorPipelineConfiguration() = delete;
        virtual ~ColorPipelineConfiguration() override = default;
 
        ColorPipelineConfiguration(
            const std::string& sVertexShaderName,
            const std::set<ShaderMacro>& requiredVertexShaderMacros,
            const std::string& sFragmentShaderName,
            const std::set<ShaderMacro>& requiredFragmentShaderMacros,
            bool bUsePixelBlending);
 
        virtual std::optional<GraphicsPipelineType> getGraphicsType() const override;
 
        virtual std::set<ShaderMacro> getRequiredFragmentShaderMacros() const override;
 
        virtual std::string_view getFragmentShaderName() const override;
 
        virtual bool isPixelBlendingEnabled() const override;
 
    protected:
        std::set<ShaderMacro> requiredFragmentShaderMacros;
 
        const std::string sFragmentShaderName;
 
        const bool bUsePixelBlending;
    };
 
    class DepthPipelineConfiguration : public PipelineConfiguration {
    public:
        DepthPipelineConfiguration() = delete;
        virtual ~DepthPipelineConfiguration() override = default;
 
        DepthPipelineConfiguration(
            const std::string& sVertexShaderName,
            const std::set<ShaderMacro>& additionalVertexShaderMacros,
            std::optional<PipelineShadowMappingUsage> shadowMappingUsage);
 
        virtual std::optional<GraphicsPipelineType> getGraphicsType() const override;
 
        virtual bool isDepthBiasEnabled() const override;
 
        virtual std::string_view getFragmentShaderName() const override;
 
        virtual std::optional<PipelineShadowMappingUsage> getShadowMappingUsage() const override;
 
    protected:
        const std::optional<PipelineShadowMappingUsage> shadowMappingUsage;
    };
 
    class ComputePipelineConfiguration : public PipelineConfiguration {
    public:
        ComputePipelineConfiguration() = delete;
        virtual ~ComputePipelineConfiguration() override = default;
 
        ComputePipelineConfiguration(const std::string& sComputeShaderName);
 
        virtual std::optional<GraphicsPipelineType> getGraphicsType() const override;
 
        virtual std::string_view getComputeShaderName() const override;
 
    private:
        const std::string sComputeShaderName;
    };
}