ShaderConfiguration.hpp

#pragma once
 
#include <Core/CoreMacros.hpp>
#include <Engine/RaEngine.hpp>
#include <array>
#include <iosfwd>
#include <list>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
namespace glbinding {
class Version;
} // namespace glbinding
 
namespace Ra {
namespace Engine {
namespace Data {
 
enum ShaderType : uint {
    ShaderType_VERTEX = 0,
    ShaderType_FRAGMENT,
    ShaderType_GEOMETRY,
    ShaderType_TESS_CONTROL,
    ShaderType_TESS_EVALUATION,
    ShaderType_COMPUTE,
    ShaderType_COUNT
};
enum ShaderType : uint {…};
 
class RA_ENGINE_API ShaderConfiguration final
{
    friend class ShaderProgram;
 
  public:
    ShaderConfiguration() = default;
    explicit ShaderConfiguration( const std::string& name );
 
    ShaderConfiguration( const std::string& name,
                         const std::string& vertexShader,
                         const std::string& fragmentShader );
 
    void addShader( ShaderType type, const std::string& name );
 
    void addShaderSource( ShaderType type, const std::string& source );
 
    void addProperty( const std::string& prop );
    void addProperties( const std::list<std::string>& props );
    void removeProperty( const std::string& prop );
 
    void addInclude( const std::string& incl, ShaderType type = ShaderType_FRAGMENT );
    void addIncludes( const std::list<std::string>& incls, ShaderType type = ShaderType_FRAGMENT );
    void removeInclude( const std::string& incl, ShaderType type = ShaderType_FRAGMENT );
 
    void addNamedString( const std::string& includepath, const std::string& realfile );
 
    bool isComplete() const;
 
    bool operator<( const ShaderConfiguration& other ) const;
 
    std::set<std::string> getProperties() const;
 
    const std::vector<std::pair<std::string, ShaderType>>& getIncludes() const;
 
    const std::vector<std::pair<std::string, std::string>>& getNamedStrings() const;
 
    // get default shader configuration
    static ShaderConfiguration getDefaultShaderConfig() { return m_defaultShaderConfig; }
 
    void setVersion( const std::string& version ) { m_version = version; }
    void setName( const std::string& name ) { m_name = name; }
 
    const std::string& getName() const { return m_name; }
    const std::string& getVersion() const { return m_version; }
    friend std::ostream& operator<<( std::ostream& stream, const ShaderConfiguration& config );
 
  private:
    std::string m_name {};
    std::string m_version {};
 
    std::array<std::pair<std::string, bool>, ShaderType_COUNT> m_shaders;
 
    std::set<std::string> m_properties;
 
    std::vector<std::pair<std::string, ShaderType>> m_includes;
 
    std::vector<std::pair<std::string, std::string>> m_named_strings;
 
    static ShaderConfiguration m_defaultShaderConfig;
 
    static std::string s_glslVersion;
 
  public:
    static void setOpenGLVersion( const glbinding::Version& version );
 
    static std::string getGLSLVersion();
};
class RA_ENGINE_API ShaderConfiguration final {…};
 
} // namespace Data
} // namespace Engine
} // namespace Ra