RenderTechnique.hpp

#pragma once
 
#include <Core/Utils/Index.hpp>
#include <Engine/RaEngine.hpp>
 
#include <Engine/Data/ShaderConfiguration.hpp>
 
#include <functional>
#include <map>
#include <memory>
 
namespace Ra {
namespace Engine {
namespace Data {
class Material;
class ShaderProgram;
class ShaderParameterProvider;
} // namespace Data
 
namespace Rendering {
 
enum DefaultRenderingPasses : int {
    DEFAULT_PASS = 0,
    LIGHTING_OPAQUE = DEFAULT_PASS,
    Z_PREPASS,
    LIGHTING_TRANSPARENT,
    LIGHTING_VOLUMETRIC
 
}; // enum DefaultRenderingPasses
 
class RA_ENGINE_API RenderTechnique final
{
  public:
    RenderTechnique();
 
    RenderTechnique( const RenderTechnique& );
    ~RenderTechnique();
 
    void setConfiguration( const Data::ShaderConfiguration& newConfig,
                           Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE );
 
    inline bool
    hasConfiguration( Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE ) const;
 
    inline void
    setConfiguration( Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE );
 
    inline void
    clearConfiguration( Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE );
 
    inline const Data::ShaderConfiguration&
    getConfiguration( Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE ) const;
 
    const Data::ShaderProgram*
    getShader( Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE ) const;
 
    void setParametersProvider( std::shared_ptr<Data::ShaderParameterProvider> provider,
                                Core::Utils::Index pass = Core::Utils::Index( -1 ) );
 
    const Data::ShaderParameterProvider* getParametersProvider(
        Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE ) const;
 
    void updateGL();
 
    inline bool isDirty( Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE ) const;
 
    inline void setDirty( Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE );
 
    inline void clearDirty( Core::Utils::Index pass = DefaultRenderingPasses::LIGHTING_OPAQUE );
 
    void addPassProperties( const std::list<std::string>& props,
                            Core::Utils::Index pass = Core::Utils::Index {} );
    static RenderTechnique createDefaultRenderTechnique();
 
  private:
    static constexpr int s_maxNbPasses { 32 };
 
    using PassConfiguration = std::pair<Data::ShaderConfiguration, const Data::ShaderProgram*>;
    using ConfigurationSet = std::array<PassConfiguration, s_maxNbPasses>;
    using PassesParameters =
        std::array<std::shared_ptr<Data::ShaderParameterProvider>, s_maxNbPasses>;
 
    ConfigurationSet m_activePasses;
    PassesParameters m_passesParameters;
 
    Core::Utils::Index m_numActivePass;
 
    // Change this if there is more than 32 configurations
    unsigned int m_dirtyBits { 0xFFFFFFFF };
    unsigned int m_setPasses { 0x00000000 };
};
 
namespace EngineRenderTechniques {
 
using DefaultTechniqueBuilder = std::function<void( RenderTechnique& rt, bool isTransparent )>;
 
RA_ENGINE_API bool registerDefaultTechnique( const std::string& name,
                                             DefaultTechniqueBuilder builder );
 
RA_ENGINE_API bool removeDefaultTechnique( const std::string& name );
 
RA_ENGINE_API std::pair<bool, DefaultTechniqueBuilder>
getDefaultTechnique( const std::string& name );
 
RA_ENGINE_API bool cleanup();
} // namespace EngineRenderTechniques
 
inline bool RenderTechnique::isDirty( Core::Utils::Index pass ) const {
    return m_dirtyBits & ( 1 << pass );
}
 
inline void RenderTechnique::setDirty( Core::Utils::Index pass ) {
    m_dirtyBits |= ( 1 << pass );
}
 
inline void RenderTechnique::clearDirty( Core::Utils::Index pass ) {
    m_dirtyBits &= ~( 1 << pass );
}
 
inline bool RenderTechnique::hasConfiguration( Core::Utils::Index pass ) const {
    return m_setPasses & ( 1 << pass );
}
 
inline void RenderTechnique::setConfiguration( Core::Utils::Index pass ) {
    m_setPasses |= ( 1 << pass );
}
 
inline void RenderTechnique::clearConfiguration( Core::Utils::Index pass ) {
    m_setPasses &= ~( 1 << pass );
}
 
inline const Data::ShaderConfiguration&
RenderTechnique::getConfiguration( Core::Utils::Index pass ) const {
    return m_activePasses[pass].first;
}
 
} // namespace Rendering
} // namespace Engine
} // namespace Ra