SignalManager.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>
 
#include <mutex>
 
#include <Core/Utils/Observable.hpp>
 
#include <Engine/Scene/ItemEntry.hpp>
 
namespace Ra {
namespace Engine {
namespace Scene {
 
class RA_ENGINE_API SignalManager
{
 
  public:
    void fireEntityCreated( const ItemEntry& entity ) const;
    void fireEntityDestroyed( const ItemEntry& entity ) const;
 
    void fireComponentAdded( const ItemEntry& component ) const;
    void fireComponentRemoved( const ItemEntry& component ) const;
 
    void fireRenderObjectAdded( const ItemEntry& ro ) const;
    void fireRenderObjectRemoved( const ItemEntry& ro ) const;
 
    void fireFrameEnded() const;
 
    void setOn( bool on ) { m_isOn = on; }
 
    using ItemObservable = Ra::Core::Utils::Observable<const ItemEntry&>;
    using FrameObservable = Ra::Core::Utils::Observable<>;
 
    ItemObservable& getEntityCreatedNotifier();
    ItemObservable& getEntityDestroyedNotifier();
    ItemObservable& getComponentCreatedNotifier();
    ItemObservable& getComponentDestroyedNotifier();
    ItemObservable& getRenderObjectCreatedNotifier();
    ItemObservable& getRenderObjectDestroyedNotifier();
    FrameObservable& getEndFrameNotifier();
 
  private:
    mutable std::mutex m_mutex;
 
    bool m_isOn { true };
 
    ItemObservable m_entityCreatedCallbacks;
    ItemObservable m_entityDestroyedCallbacks;
    ItemObservable m_componentAddedCallbacks;
    ItemObservable m_componentRemovedCallbacks;
    ItemObservable m_roAddedCallbacks;
    ItemObservable m_roRemovedCallbacks;
 
    FrameObservable m_frameEndCallbacks;
 
    template <typename... TArgs>
    void notify( const Ra::Core::Utils::Observable<TArgs...>& o, TArgs... args ) const {
        if ( m_isOn ) {
            std::lock_guard<std::mutex> lock( m_mutex );
            o.notify( args... );
        }
    }
};
} // namespace Scene
} // namespace Engine
} // namespace Ra