BaseApplication.hpp

#pragma once
#include <atomic>
#include <chrono>
#include <memory>
#include <vector>
 
#include <QApplication>
 
#include <Core/Utils/Timer.hpp>
#include <Gui/TimerData/FrameTimerData.hpp>
#include <PluginBase/RadiumPluginInterface.hpp>
 
#include <glbinding/Version.h>
 
class QTimer;
class QCommandLineParser;
namespace Ra {
namespace Engine {
class RadiumEngine;
namespace Scene {
class GeometrySystem;
struct ItemEntry;
} // namespace Scene
} // namespace Engine
 
namespace Gui {
class Viewer;
class MainWindowInterface;
 
class RA_GUI_API BaseApplication : public QApplication
{
    Q_OBJECT
 
  public:
    class WindowFactory
    {
      public:
        WindowFactory()                                                = default;
        virtual ~WindowFactory()                                       = default;
        virtual Ra::Gui::MainWindowInterface* createMainWindow() const = 0;
    };
 
    BaseApplication( int& argc,
                     char** argv,
                     QString applicationName  = "RadiumEngine",
                     QString organizationName = "STORM-IRIT" );
 
    ~BaseApplication() override;
 
    void initialize( const WindowFactory& factory, const glbinding::Version& glVersion = { 4, 1 } );
 
    virtual void engineBaseInitialization();
 
    virtual void addApplicationExtension() {};
 
    void radiumFrame();
 
    bool isRunning() const { return !m_isAboutToQuit; }
 
    const Engine::RadiumEngine* getEngine() const { return m_engine; }
 
    uint getFrameCount() const { return m_frameCounter; }
 
    const std::string& getExportFolderName() const { return m_exportFoldername; }
 
    void addPluginDirectory( const std::string& pluginDir );
    void clearPluginDirectories();
 
    void editSettings();
 
    virtual std::string getHelpText() const;
 
    void addRadiumMenu();
 
  signals:
    void starting();
 
    void stopping();
 
    void sceneChanged( const Core::Aabb& );
 
    void updateFrameStats( const std::vector<FrameTimerData>& );
 
    void loadComplete();
 
    void selectedItem( const Ra::Engine::Scene::ItemEntry& entry );
 
  public slots:
 
    virtual void engineOpenGLInitialize();
 
    virtual void initializeGl();
 
    void updateRadiumFrameIfNeeded() {
        // Main loop
        if ( !m_isAboutToQuit && m_isUpdateNeeded.load() ) radiumFrame();
        if ( m_continuousUpdateRequest <= 0 ) {
            m_continuousUpdateRequest.store( 0 );
            m_isUpdateNeeded.store( false );
        }
        if ( m_isAboutToQuit ) { this->exit(); }
    }
 
    bool loadFile( QString path );
    void framesCountForStatsChanged( uint count );
    void appNeedsToQuit();
 
    void setRealFrameRate( bool on );
    void setRecordFrames( bool on );
    void setRecordTimings( bool on );
    void setRecordGraph( bool on );
 
    void recordFrame();
 
    void onSelectedItem( const Ra::Engine::Scene::ItemEntry& entry ) { emit selectedItem( entry ); }
 
    void setContinuousUpdate( bool b ) {
        b ? m_continuousUpdateRequest++ : m_continuousUpdateRequest--;
        // if continuous update is requested, then we need an update, if not,
        // let update needed stay in the same state.
        if ( m_continuousUpdateRequest > 0 ) m_isUpdateNeeded.store( true );
    }
    void askForUpdate() { m_isUpdateNeeded.store( true ); }
 
  protected:
    void createConnections();
 
    bool loadPlugins( const std::string& pluginsPath,
                      const QStringList& loadList,
                      const QStringList& ignoreList );
 
    void setupScene();
 
    bool isUpdateNeeded() { return m_isUpdateNeeded.load(); }
 
    void setIsUpdateNeeded( bool b ) { m_isUpdateNeeded.store( b ); }
 
    // Public variables, accessible through the mainApp singleton.
  public:
    std::unique_ptr<Gui::MainWindowInterface> m_mainWindow;
 
    Engine::RadiumEngine* m_engine;
 
    std::unique_ptr<Core::TaskQueue> m_taskQueue;
 
    uint m_targetFPS;
 
  protected:
    std::vector<Ra::Plugins::RadiumPluginInterface*> m_openGLPlugins;
 
    Gui::Viewer* m_viewer;
 
    QTimer* m_frameTimer;
 
    Core::Utils::TimePoint m_lastFrameStart;
 
    uint m_frameCounter;
    uint m_frameCountBeforeUpdate;
    uint m_numFrames;
    uint m_maxThreads;
    std::vector<FrameTimerData> m_timerData;
    std::string m_pluginPath;
 
    bool m_realFrameRate;
 
    // Options to control monitoring and outputs
    std::string m_exportFoldername;
 
    bool m_recordFrames;
    bool m_recordTimings;
    bool m_recordGraph;
 
    bool m_isAboutToQuit;
 
    std::atomic_bool m_isUpdateNeeded { true };
 
    std::atomic<int> m_continuousUpdateRequest { 1 };
 
    Plugins::Context m_pluginContext;
    QCommandLineParser* m_parser;
 
    std::map<std::string, std::string> m_loadedPlugins;
};
} // namespace Gui
} // namespace Ra