RendererShader.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Container/Map.hpp"
 
#include "CeresEngine/Material/Shader.hpp"
#include "CeresEngine/RenderAPI/GPUShader.hpp"
 
namespace CeresEngine {
 
    enum class RendererShaderFlag {
    };
 
    using RendererShaderFlags = Flags<RendererShaderFlag>;
    CE_FLAGS_OPERATORS(RendererShaderFlag)
 
    
    struct RendererShaderSpecialization {
        ShaderSpecializationConstants constants;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) { CE_REFL_DATA(constants); }
    };
 
    class RendererShader : public RefCounted<RendererShader> {
    private:
        friend class RendererShaderManager;
 
        RendererShaderManager& mManager;
 
        String mName;
 
        ShaderPtr mShader = nullptr;
 
        mutable HashMap<UInt64, GPUShaderProgramPtr> mPrograms;
 
    public:
        explicit RendererShader(RendererShaderManager& manager, StringView name, const ShaderPtr& shader);
        explicit RendererShader(RendererShaderManager& manager, StringView name, const GPUShaderProgramDescriptor& baseDescriptor);
        ~RendererShader();
 
    public:
        [[nodiscard]] GPUShaderProgramPtr getProgram(const RendererShaderSpecialization& specialization) const;
 
        [[nodiscard]] GPUShaderProgramPtr getProgram() const { return getProgram(RendererShaderSpecialization{}); }
 
    public:
        [[nodiscard]] const String& getName() const noexcept { return mName; }
 
        [[nodiscard]] const ShaderPtr& getShader() const noexcept { return mShader; }
    };
 
    class RendererShaderManager {
    private:
        struct ShaderInfo {
            RendererShader* rendererShader;
        };
 
    private:
        friend class RendererShader;
 
        Renderer& mRenderer;
 
        HashMap<UInt64, ShaderInfo> mShaders;
 
    public:
        explicit RendererShaderManager(Renderer& renderer);
 
    public:
        [[nodiscard]] RendererShaderPtr get(StringView name, const GPUShaderProgramDescriptor& descriptor);
 
        [[nodiscard]] RendererShaderPtr get(const GPUShaderProgramDescriptor& descriptor) { return get(StringView(), descriptor); }
 
        [[nodiscard]] RendererShaderPtr get(StringView name, const ShaderPtr& shader);
 
        [[nodiscard]] RendererShaderPtr get(const ShaderPtr& shader) { return get(StringView(), shader); }
 
        [[nodiscard]] RendererShaderPtr get(const HShader& shader) { return get(shader.getPointer()); }
 
        [[nodiscard]] RendererShaderPtr get(const StringView name, const HShader& shader) { return get(name, shader.getPointer()); }
 
    private:
        friend class RendererShader;
 
        [[nodiscard]] RendererShaderPtr getOrCreate(StringView name, const GPUShaderProgramDescriptor& descriptor);
 
        [[nodiscard]] RendererShaderPtr getOrCreate(StringView name, const ShaderPtr& shader);
 
        void notifyDestroy(const RendererShader* shader) noexcept;
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::RendererShaderSpecialization);