Viewer.hpp

#pragma once
 
#include <Gui/RaGui.hpp>
 
#include <Core/CoreMacros.hpp>
#include <Core/Types.hpp>
#include <Engine/RadiumEngine.hpp>
#include <Engine/Rendering/Renderer.hpp>
#include <Engine/Scene/CameraComponent.hpp>
#include <Gui/Utils/KeyMappingManager.hpp>
#include <Gui/Viewer/WindowQt.hpp>
 
#include <atomic>
#include <memory>
 
#include <QThread>
#include <QWindow>
 
// Forward declarations
class QOpenGLContext;
class QSurfaceFormat;
 
namespace Ra {
namespace Gui {
class CameraManipulator;
class GizmoManager;
class PickingManager;
class RadiumHelpDialog;
} // namespace Gui
} // namespace Ra
 
namespace Ra {
namespace Gui {
 
class RA_GUI_API Viewer : public WindowQt, public KeyMappingManageable<Viewer>
{
    Q_OBJECT
    friend class KeyMappingManageable<Viewer>;
 
  public:
    explicit Viewer( QScreen* screen = nullptr );
 
    ~Viewer() override;
 
    virtual void setupKeyMappingCallbacks();
 
    virtual bool prepareDisplay();
 
    //
    // Accessors
    //
    QOpenGLContext* getContext() const { return m_context.get(); }
 
    void setCameraManipulator( CameraManipulator* ci );
 
    CameraManipulator* getCameraManipulator();
 
    void resetToDefaultCamera();
 
    GizmoManager* getGizmoManager();
 
    const Engine::Rendering::Renderer* getRenderer() const;
 
    Engine::Rendering::Renderer* getRenderer();
 
    int addRenderer( const std::shared_ptr<Engine::Rendering::Renderer>& e );
 
    PickingManager* getPickingManager();
 
    //
    //  Time dependent state management
    //
    virtual void update( const Scalar dt );
    //
    // Rendering management
    //
 
    void startRendering( const Scalar dt );
 
    void swapBuffers();
 
 
    void processPicking();
 
    void fitCameraToScene( const Core::Aabb& sceneAabb );
    void fitCamera();
    std::vector<std::string> getRenderersName() const;
 
    void grabFrame( const std::string& filename );
 
    void enableDebug();
 
    const Core::Utils::Color& getBackgroundColor() const { return m_backgroundColor; }
 
    KeyMappingManager::KeyMappingAction
    addCustomAction( const std::string& actionName,
                     const KeyMappingManager::EventBinding& binding,
                     std::function<void( QEvent* )> callback );
 
    Scalar getDepthUnderMouse() const { return m_depthUnderMouse; }
 
    Core::Vector2 toDevice( const Core::Vector2& logicCoordinates ) {
        return static_cast<Scalar>( devicePixelRatio() ) * logicCoordinates;
    }
 
  signals:
    void requestEngineOpenGLInitialization();
    bool glInitialized(); 
    void rendererReady(); 
 
    void rightClickPicking( const Ra::Engine::Rendering::Renderer::PickingResult& result );
 
    void toggleBrushPicking( bool on );
 
    void needUpdate();
 
    void onMousePress( QMouseEvent* event );
    void onMouseRelease( QMouseEvent* event );
    void onMouseMove( QMouseEvent* event );
 
  public slots:
    void reloadShaders();
 
    void displayTexture( const QString& tex );
 
    bool changeRenderer( int index );
 
    void enablePostProcess( int enabled );
 
    void enableDebugDraw( int enabled );
    void setBackgroundColor( const Core::Utils::Color& background );
 
    // Display help dialog about Viewer key-bindings
    void displayHelpDialog();
 
  private slots:
    void onAboutToCompose();
    void onAboutToResize();
    void onResized();
    void onFrameSwapped();
 
  protected:
    void createGizmoManager();
 
    void initializeRenderer( Engine::Rendering::Renderer* renderer );
 
    bool initializeGL() override;
 
    void resizeGL( QResizeEvent* event ) override;
 
    Engine::Rendering::Renderer::PickingMode
    getPickingMode( const Ra::Gui::KeyMappingManager::KeyMappingAction& action ) const;
 
    void keyPressEvent( QKeyEvent* event ) override;
    void keyReleaseEvent( QKeyEvent* event ) override;
 
    void mousePressEvent( QMouseEvent* event ) override;
    void mouseReleaseEvent( QMouseEvent* event ) override;
    void mouseMoveEvent( QMouseEvent* event ) override;
    void wheelEvent( QWheelEvent* event ) override;
 
    void showEvent( QShowEvent* ev ) override;
 
    void focusOutEvent( QFocusEvent* event ) override;
 
    virtual bool handleKeyPressEvent( QKeyEvent* event );
    virtual bool handleKeyReleaseEvent( QKeyEvent* event );
    virtual void handleMousePressEvent( QMouseEvent* event,
                                        Ra::Engine::Rendering::Renderer::PickingResult& result );
    virtual void handleMouseReleaseEvent( QMouseEvent* event );
    virtual void handleMouseMoveEvent( QMouseEvent* event,
                                       Ra::Engine::Rendering::Renderer::PickingResult& result );
    virtual void handleWheelEvent( QWheelEvent* event );
  private:
    static void configureKeyMapping_impl();
 
    Ra::Engine::Rendering::Renderer::PickingResult pickAtPosition( Core::Vector2 position );
 
    void propagateEventToParent( QEvent* event );
 
    std::tuple<KeyMappingManager::KeyMappingAction,
               KeyMappingManager::KeyMappingAction,
               KeyMappingManager::KeyMappingAction>
    getComponentActions( const Qt::MouseButtons& buttons,
                         const Qt::KeyboardModifiers& modifiers,
                         int key,
                         bool wheel );
 
    Scalar m_depthUnderMouse;
    std::unique_ptr<RadiumHelpDialog> m_helpDialog { nullptr };
 
  protected:
    std::vector<std::shared_ptr<Engine::Rendering::Renderer>> m_renderers;
    std::vector<std::shared_ptr<Engine::Rendering::Renderer>> m_pendingRenderers;
    Engine::Rendering::Renderer* m_currentRenderer;
 
    PickingManager* m_pickingManager;
 
    bool m_isBrushPickingEnabled;
    Scalar m_brushRadius;
 
    std::unique_ptr<CameraManipulator> m_camera;
 
    GizmoManager* m_gizmoManager;
 
    Core::Utils::Color m_backgroundColor { Core::Utils::Color::Grey( 0.0392_ra, 0_ra ) };
 
    enum KeyEventType { KeyPressed = 0, KeyReleased, KeyEventTypeCount };
    std::array<std::map<Core::Utils::Index, std::function<void( QKeyEvent* )>>, KeyEventTypeCount>
        m_customKeyActions;
 
    KeyMappingCallbackManager m_keyMappingCallbackManager;
 
    KeyMappingManager::Context m_activeContext {};
#define KeyMappingViewer                     \
    KMA_VALUE( VIEWER_PICKING )              \
    KMA_VALUE( VIEWER_PICKING_VERTEX )       \
    KMA_VALUE( VIEWER_PICKING_EDGE )         \
    KMA_VALUE( VIEWER_PICKING_TRIANGLE )     \
    KMA_VALUE( VIEWER_PICKING_MULTI_CIRCLE ) \
    KMA_VALUE( VIEWER_RAYCAST )              \
    KMA_VALUE( VIEWER_SCALE_BRUSH )          \
    KMA_VALUE( VIEWER_RELOAD_SHADERS )       \
    KMA_VALUE( VIEWER_TOGGLE_WIREFRAME )     \
    KMA_VALUE( VIEWER_SWITCH_CAMERA )        \
    KMA_VALUE( VIEWER_CAMERA_FIT_SCENE )     \
    KMA_VALUE( VIEWER_HELP )
 
#define KMA_VALUE( x ) static KeyMappingManager::KeyMappingAction x;
    KeyMappingViewer
#undef KMA_VALUE
};
 
} // namespace Gui
} // namespace Ra