RadiumEngine.hpp

#pragma once
#include <Engine/RaEngine.hpp>
 
#include <Core/Tasks/TaskQueue.hpp>
#include <Core/Types.hpp>
#include <Core/Utils/Singleton.hpp>
 
#include <glbinding/Version.h>
#include <globjects/State.h>
 
#include <map>
#include <memory>
#include <stack>
#include <string>
#include <vector>
 
namespace Ra {
namespace Core {
 
namespace Asset {
class FileLoaderInterface;
class FileData;
} // namespace Asset
} // namespace Core
 
namespace Engine {
namespace Scene {
class System;
class Entity;
class Component;
class EntityManager;
class SignalManager;
} // namespace Scene
 
namespace Data {
class ShaderProgramManager;
class Displayable;
class TextureManager;
} // namespace Data
 
namespace Rendering {
class RenderObjectManager;
}
 
class RA_ENGINE_API RadiumEngine
{
    RA_SINGLETON_INTERFACE( RadiumEngine );
 
  public:
    void initialize();
 
    void initializeGL();
 
    glbinding::Version getOpenGLVersion() const;
 
    void cleanup();
 
    void getTasks( Core::TaskQueue* taskQueue, Scalar dt );
 
    bool registerSystem( const std::string& name, Scene::System* system, int priority = 1 );
 
    Scene::System* getSystem( const std::string& system ) const;
 
    Data::Displayable* getMesh( const std::string& entityName,
                                const std::string& componentName,
                                const std::string& roName = std::string() ) const;
 
    bool loadFile( const std::string& file );
 
    const Core::Asset::FileData& getFileData() const;
 
    void releaseFile();
 
    void endFrameSync();
 
 
    Rendering::RenderObjectManager* getRenderObjectManager() const;
    Scene::EntityManager* getEntityManager() const;
 
    Scene::SignalManager* getSignalManager() const;
 
    Data::TextureManager* getTextureManager() const;
 
    Data::ShaderProgramManager* getShaderProgramManager() const;
 
    void registerFileLoader( std::shared_ptr<Core::Asset::FileLoaderInterface> fileLoader );
 
    const std::vector<std::shared_ptr<Core::Asset::FileLoaderInterface>>& getFileLoaders() const;
 
    Core::Aabb computeSceneAabb() const;
 
    void pushFboAndViewport();
 
    void popFboAndViewport();
 
 
    void setRealTime( bool realTime );
 
    bool isRealTime() const;
 
    bool isConstantTime() const;
 
    bool setConstantTimeStep( Scalar dt, bool forceConstantTime = false );
 
    void setForwardBackward( bool mode );
 
    void play( bool isPlaying );
 
    void step();
 
    void resetTime();
 
    void setTime( Scalar t );
 
    void setStartTime( Scalar t );
 
    Scalar getStartTime() const;
 
    void setEndTime( Scalar t );
 
    Scalar getEndTime() const;
 
    Scalar getTime() const;
 
    uint getFrame() const;
 
    std::string getResourcesDir() { return m_resourcesRootDir; }
 
    void runGpuTasks();
 
    Core::TaskQueue::TaskId addGpuTask( std::unique_ptr<Core::Task> );
 
    void removeGpuTask( Core::TaskQueue::TaskId taskId );
 
  private:
    RadiumEngine();
    ~RadiumEngine();
 
    glbinding::Version m_glVersion {};
    void registerDefaultPrograms();
 
    using Priority  = int;
    using SystemKey = std::pair<Priority, std::string>;
    // use transparent functors :
    // https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-transparent-functors.html
    using SystemContainer = std::map<SystemKey, std::shared_ptr<Scene::System>, std::greater<>>;
 
    SystemContainer::const_iterator findSystem( const std::string& name ) const;
    SystemContainer::iterator findSystem( const std::string& name );
 
    SystemContainer m_systems;
 
    std::vector<std::shared_ptr<Core::Asset::FileLoaderInterface>> m_fileLoaders;
 
    std::unique_ptr<Rendering::RenderObjectManager> m_renderObjectManager;
    std::unique_ptr<Scene::EntityManager> m_entityManager;
    std::unique_ptr<Scene::SignalManager> m_signalManager;
    std::unique_ptr<Data::TextureManager> m_textureManager;
    std::unique_ptr<Data::ShaderProgramManager> m_shaderProgramManager;
    std::unique_ptr<Core::Asset::FileData> m_loadedFile;
 
    bool m_loadingState { false };
 
    std::string m_resourcesRootDir;
 
    class FboAndViewport
    {
      public:
        FboAndViewport( int fbo, std::array<int, 4>&& viewport ) :
            m_fbo { fbo }, m_viewport { viewport } {}
        int m_fbo;
        std::array<int, 4> m_viewport;
    };
 
    std::stack<FboAndViewport> m_fboAndViewportStack;
 
    struct TimeData {
        void updateTime( Scalar dt );
 
        Scalar m_dt { 1_ra / 60_ra }; 
        Scalar m_startTime { 0_ra };  
        Scalar m_endTime { 1_ra };    
        Scalar m_time { 0_ra };       
        bool m_play { false };        
        bool m_singleStep { true };   
        bool m_realTime { false }; 
        bool m_forwardBackward { false }; 
        bool m_isBackward { false };      
    };
 
    TimeData m_timeData;
 
    std::unique_ptr<globjects::State> m_openglState { nullptr };
    std::unique_ptr<Core::TaskQueue> m_gpuTaskQueue { new Core::TaskQueue( 0 ) };
};
} // namespace Engine
} // namespace Ra