CameraManager.hpp

#pragma once
#include <Core/Asset/Camera.hpp>
#include <Core/Utils/Index.hpp>
#include <Core/Utils/Observable.hpp>
#include <Engine/RaEngine.hpp>
#include <Engine/Scene/CameraStorage.hpp>
#include <Engine/Scene/System.hpp>
#include <memory>
 
namespace Ra {
namespace Core {
class TaskQueue;
namespace Asset {
class FileData;
} // namespace Asset
} // namespace Core
 
namespace Engine {
struct FrameInfo;
 
namespace Scene {
class CameraComponent;
class Component;
class Entity;
 
class RA_ENGINE_API CameraManager : public System
{
    // Radium-V2 : make Camera manager compatible with range for ...
  public:
    CameraManager();
 
    // Make copies impossible
    CameraManager( const CameraManager& )            = delete;
    CameraManager& operator=( const CameraManager& ) = delete;
 
    ~CameraManager() override = default;
 
    virtual const CameraComponent* getCamera( size_t i ) const = 0;
 
    virtual void addCamera( CameraComponent* cam ) = 0;
 
    virtual Core::Utils::Index getCameraIndex( const CameraComponent* cam );
 
    virtual void initialize();
 
    void activate( Core::Utils::Index index );
 
    void updateActiveCameraData();
 
    //
    // Calls for the Renderer
    //
 
    virtual size_t count() const;
 
    //
    // System methods
    //
    void generateTasks( Core::TaskQueue* taskQueue, const Engine::FrameInfo& frameInfo ) override;
 
    void handleAssetLoading( Entity* entity, const Core::Asset::FileData* data ) override;
 
    static Ra::Core::Asset::Camera defaultCamera;
 
    Ra::Core::Asset::Camera* getActiveCamera() { return &m_activeCamera; }
 
    Core::Utils::Index getActiveCameraIndex() const { return m_activeIndex; }
 
    void resetActiveCamera() {
        m_activeCamera = defaultCamera;
        m_activeIndex  = -1;
        m_activeCameraObservers.notify( m_activeIndex );
    }
    void resetActiveCamera() {…}
 
    inline Core::Utils::Observable<Core::Utils::Index>& activeCameraObservers() {
        return m_activeCameraObservers;
    }
    inline Core::Utils::Observable<Core::Utils::Index>& activeCameraObservers() {…}
 
  protected:
    void registerComponent( const Entity* entity, Component* component ) final;
 
    void unregisterComponent( const Entity* entity, Component* component ) final;
 
    void unregisterAllComponents( const Entity* entity ) final;
 
  protected:
    std::unique_ptr<CameraStorage> m_data { nullptr };
 
    Ra::Core::Asset::Camera m_activeCamera;
 
    Core::Utils::Index m_activeIndex;
 
    Core::Utils::Observable<Core::Utils::Index> m_activeCameraObservers;
};
class RA_ENGINE_API CameraManager : public System {…};
 
} // namespace Scene
} // namespace Engine
} // namespace Ra