CLIViewer.hpp

#pragma once
 
#include <Core/Tasks/TaskQueue.hpp>
#include <Headless/CLIBaseApplication.hpp>
#include <Headless/OpenGLContext/OpenGLContext.hpp>
 
#include <Core/Utils/Index.hpp>
 
#include <functional>
 
#include <glbinding/Version.h>
 
namespace Ra {
namespace Core {
namespace Asset {
class FileLoaderInterface;
class Camera;
} // namespace Asset
} // namespace Core
 
namespace Engine {
class RadiumEngine;
namespace Rendering {
class Renderer;
}
} // namespace Engine
 
namespace Headless {
 
class HEADLESS_API CLIRadiumEngineApp : public CLIBaseApplication
{
  public:
    explicit CLIRadiumEngineApp( std::unique_ptr<OpenGLContext> context );
    virtual ~CLIRadiumEngineApp();
 
    const Engine::RadiumEngine* getEngine() const { return m_engine; }
 
    int init( int argc, const char* argv[] ) override;
 
    void openGlAddOns( std::function<void()> f );
 
    void bindOpenGLContext( bool on = true );
 
    //  private:
  protected: 
    std::unique_ptr<OpenGLContext> m_glContext;
 
    bool m_engineInitialized { false };
 
    Ra::Engine::RadiumEngine* m_engine;
};
 
class HEADLESS_API CLIViewer : public CLIRadiumEngineApp
{
  public:
    struct ViewerParameters {
        bool m_animationEnable { false };
        std::array<int, 2> m_size { { 512, 512 } };
        std::string m_imgPrefix { "frame" };
        std::string m_dataFile = { "" };
    };
 
  public:
    explicit CLIViewer( std::unique_ptr<OpenGLContext> context );
    virtual ~CLIViewer();
 
    int init( int argc, const char* argv[] ) override;
 
    int oneFrame( float timeStep = 1.f / 60.f );
 
    void setRenderer( Ra::Engine::Rendering::Renderer* renderer );
 
    void addDataFileLoader( Ra::Core::Asset::FileLoaderInterface* loader );
 
    void loadScene();
 
    void compileScene();
 
    Ra::Core::Utils::Index setCamera( Ra::Core::Utils::Index camIdx = 0 );
 
    void setImageNamePrefix( std::string s );
 
    const ViewerParameters& getCommandLineParameters() const;
 
    std::unique_ptr<unsigned char[]> grabFrame( size_t& w, size_t& h ) const;
 
    void showWindow( bool on                       = true,
                     OpenGLContext::EventMode mode = OpenGLContext::EventMode::POLL,
                     float delay                   = 1.f / 60.f );
 
    inline OpenGLContext& getWindow();
 
    void renderLoop( std::function<void( float )> render );
 
    inline std::string getDataFileName() const;
 
    inline void setDataFileName( std::string filename );
 
  protected:
    void resize( int width, int height );
 
  private:
    std::shared_ptr<Ra::Engine::Rendering::Renderer> m_renderer;
 
    Ra::Core::Asset::Camera* m_camera { nullptr };
 
    ViewerParameters m_parameters;
 
    bool m_exposedWindow { false };
};
 
inline std::string CLIViewer::getDataFileName() const {
    return m_parameters.m_dataFile;
}
 
inline void CLIViewer::setDataFileName( std::string filename ) {
    m_parameters.m_dataFile = std::move( filename );
}
 
inline OpenGLContext& CLIViewer::getWindow() {
    return *m_glContext;
}
 
} // namespace Headless
} // namespace Ra