ShaderProgramManager.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include <Core/Utils/Singleton.hpp>
#include <Core/Utils/StdOptional.hpp>
 
namespace globjects {
class File;
class NamedString;
} // namespace globjects
 
namespace Ra {
namespace Engine {
namespace Data {
 
class ShaderProgram;
class ShaderConfiguration;
 
class RA_ENGINE_API ShaderProgramManager final
{
 
  public:
    ShaderProgramManager();
    ~ShaderProgramManager();
    ShaderProgramManager( const ShaderProgramManager& )            = delete;
    ShaderProgramManager& operator=( const ShaderProgramManager& ) = delete;
 
    Core::Utils::optional<const Data::ShaderProgram*>
    addShaderProgram( const Data::ShaderConfiguration& config );
 
    const Data::ShaderProgram* getShaderProgram( const std::string& id );
 
    const Data::ShaderProgram* getShaderProgram( const Data::ShaderConfiguration& config );
 
    void reloadAllShaderPrograms();
    void reloadNotCompiledShaderPrograms();
 
    bool addNamedString( const std::string& includepath, const std::string& realfile );
 
    void reloadNamedString();
 
  private:
    void insertShader( const Data::ShaderConfiguration& config,
                       const std::shared_ptr<Data::ShaderProgram>& shader );
 
  private:
    std::map<std::string, Data::ShaderConfiguration> m_shaderProgramIds;
    std::map<Data::ShaderConfiguration, std::shared_ptr<Data::ShaderProgram>> m_shaderPrograms;
    std::vector<Data::ShaderConfiguration> m_shaderFailedConfs;
 
    std::map<std::string,
             std::pair<std::unique_ptr<globjects::File>, std::unique_ptr<globjects::NamedString>>>
        m_namedStrings;
};
class RA_ENGINE_API ShaderProgramManager final {…};
 
} // namespace Data
} // namespace Engine
} // namespace Ra