CouplingSystem.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>     // RA_ENGINE_API
#include <Engine/Scene/System.hpp> // System methods declaration
#include <memory>                  // std::unique_ptr
#include <type_traits>             // std::is_base_of
#include <vector>                  // std::vector
 
namespace Ra {
namespace Engine {
namespace Scene {
 
template <typename _BaseAbstractSystem>
class BaseCouplingSystem : public _BaseAbstractSystem
{
  public:
    using BaseAbstractSystem = _BaseAbstractSystem;
 
    inline BaseCouplingSystem() {
        static_assert( std::is_base_of<Ra::Engine::Scene::System, BaseAbstractSystem>::value,
                       "BaseAbstractSystem must inherit Ra::Core::System" );
    }
    ~BaseCouplingSystem() override = default;
 
    BaseCouplingSystem( const BaseCouplingSystem<BaseAbstractSystem>& ) = delete;
    BaseCouplingSystem<BaseAbstractSystem>&
    operator=( const BaseCouplingSystem<BaseAbstractSystem>& ) = delete;
 
    inline void addSystem( BaseAbstractSystem* s ) { m_systems.emplace_back( s ); }
 
    inline void generateTasks( Core::TaskQueue* taskQueue,
                               const Engine::FrameInfo& frameInfo ) override {
        dispatch( [taskQueue, &frameInfo]( const auto& s ) {
            s->generateTasks( taskQueue, frameInfo );
        } );
    }
    inline void handleAssetLoading( Entity* entity, const Core::Asset::FileData* data ) override {
        BaseAbstractSystem::handleAssetLoading( entity, data );
        dispatch( [entity, data]( const auto& s ) { s->handleAssetLoading( entity, data ); } );
    }
 
  protected:
    template <typename Functor>
    inline void dispatch( Functor f ) {
        for ( auto& s : m_systems )
            f( s );
    }
 
    template <typename Functor>
    inline void dispatch( Functor f ) const {
        for ( const auto& s : m_systems )
            f( s );
    }
 
    template <typename Functor>
    inline bool conditionnaldispatch( Functor f, bool abortWhenInvalid = true ) {
        for ( auto& s : m_systems ) {
            if ( !f( s ) && abortWhenInvalid ) return false;
        }
        return true;
    }
 
    template <typename Functor>
    inline bool conditionnaldispatch( Functor f, bool abortWhenInvalid = true ) const {
        for ( const auto& s : m_systems ) {
            if ( !f( s ) && abortWhenInvalid ) return false;
        }
        return true;
    }
 
  private:
    std::vector<std::unique_ptr<BaseAbstractSystem>> m_systems;
};
 
} // namespace Scene
} // namespace Engine
} // namespace Ra