MRViewer.h

Go to the documentation of this file.

#pragma once
 
#include "MRViewerInstance.h"
#include "MRMouse.h"
#include <MRMesh/MRVector2.h>
#include <MRMesh/MRViewportId.h>
#include "MRMesh/MRRenderModelParameters.h"
#include <cstdint>
#include <filesystem>
 
struct GLFWwindow;
 
#define ENQUEUE_VIEWER_METHOD( NAME, METHOD ) MR::getViewerInstance().emplaceEvent( NAME, [] { \
    MR::getViewerInstance() . METHOD (); \
} )
#define ENQUEUE_VIEWER_METHOD_ARGS( NAME, METHOD, ... ) MR::getViewerInstance().emplaceEvent( NAME, [__VA_ARGS__] { \
    MR::getViewerInstance() . METHOD ( __VA_ARGS__ ); \
} )
#define ENQUEUE_VIEWER_METHOD_ARGS_SKIPABLE( NAME, METHOD, ... ) MR::getViewerInstance().emplaceEvent( NAME, [__VA_ARGS__] { \
    MR::getViewerInstance() . METHOD ( __VA_ARGS__ ); \
}, true )
 
namespace MR
{
 
 
class FramebufferData;
 
struct LaunchParams
{
    bool fullscreen{ false }; 
    int width{ 0 };
    int height{ 0 };
    enum WindowMode
    {
        Show, 
        HideInit, 
        Hide, 
        TryHidden, 
        NoWindow 
    } windowMode{ HideInit };
    bool enableTransparentBackground{ false };
    bool preferOpenGL3{ false };
    bool render3dSceneInTexture{ true }; 
    bool developerFeatures{ false }; 
    bool multiViewport{ true }; 
    std::string name{ "MRViewer" }; 
    bool resetConfig{ false }; 
    bool startEventLoop{ true }; 
    bool close{ true }; 
    bool console{ false }; 
    int argc{ 0 }; 
    char** argv{ nullptr }; 
 
    bool showMRVersionInTitle{ false }; 
    bool isAnimating{ false }; 
    int animationMaxFps{ 30 }; 
    bool unloadPluginsAtEnd{ false }; 
 
    std::shared_ptr<SplashWindow> splashWindow; 
};
 
class MRVIEWER_CLASS Viewer
{
public:
    using MouseButton = MR::MouseButton;
    using MouseMode = MR::MouseMode;
 
    using LaunchParams = MR::LaunchParams;
 
    MRVIEWER_API static void parseLaunchParams( LaunchParams& params );
 
    MRVIEWER_API int launch( const LaunchParams& params );
    MRVIEWER_API void launchEventLoop();
    MRVIEWER_API void launchShut();
 
    bool isLaunched() const { return isLaunched_; }
 
    const LaunchParams& getLaunchParams() const { return launchParams_; }
 
    static Viewer* instance() { return &getViewerInstance(); }
    static Viewer& instanceRef() { return getViewerInstance(); }
    static const Viewer* constInstance() { return &getViewerInstance(); }
    static const Viewer& constInstanceRef() { return getViewerInstance(); }
 
    template<typename PluginType>
    PluginType* getPluginInstance()
    {
        for ( auto& plugin : plugins )
        {
            auto p = dynamic_cast< PluginType* >( plugin );
            if ( p )
            {
                return p;
            }
        }
        return nullptr;
    }
 
    MRVIEWER_API bool isSupportedFormat( const std::filesystem::path& file_name );
 
    MRVIEWER_API bool loadFiles( const std::vector< std::filesystem::path>& filesList, const FileLoadOptions & options );
    MRVIEWER_API bool loadFiles( const std::vector< std::filesystem::path>& filesList );
 
    MRVIEWER_API bool saveToFile( const std::filesystem::path & mesh_file_name );
 
    MRVIEWER_API bool keyPressed( unsigned int unicode_key, int modifier );
    MRVIEWER_API bool keyDown( int key, int modifier );
    MRVIEWER_API bool keyUp( int key, int modifier );
    MRVIEWER_API bool keyRepeat( int key, int modifier );
    MRVIEWER_API bool mouseDown( MouseButton button, int modifier );
    MRVIEWER_API bool mouseUp( MouseButton button, int modifier );
    MRVIEWER_API bool mouseMove( int mouse_x, int mouse_y );
    MRVIEWER_API bool mouseScroll( float delta_y );
    MRVIEWER_API bool mouseClick( MouseButton button, int modifier );
    MRVIEWER_API bool dragStart( MouseButton button, int modifier );
    MRVIEWER_API bool dragEnd( MouseButton button, int modifier );
    MRVIEWER_API bool drag( int mouse_x, int mouse_y );
    MRVIEWER_API bool spaceMouseMove( const Vector3f& translate, const Vector3f& rotate );
    MRVIEWER_API bool spaceMouseDown( int key );
    MRVIEWER_API bool spaceMouseUp( int key );
    MRVIEWER_API bool spaceMouseRepeat( int key );
    MRVIEWER_API bool dragDrop( const std::vector<std::filesystem::path>& paths  );
    MRVIEWER_API bool touchStart( int id, int x, int y );
    MRVIEWER_API bool touchMove( int id, int x, int y );
    MRVIEWER_API bool touchEnd( int id, int x, int y );
    MRVIEWER_API bool touchpadRotateGestureBegin();
    MRVIEWER_API bool touchpadRotateGestureUpdate( float angle );
    MRVIEWER_API bool touchpadRotateGestureEnd();
    MRVIEWER_API bool touchpadSwipeGestureBegin();
    MRVIEWER_API bool touchpadSwipeGestureUpdate( float dx, float dy, bool kinetic );
    MRVIEWER_API bool touchpadSwipeGestureEnd();
    MRVIEWER_API bool touchpadZoomGestureBegin();
    MRVIEWER_API bool touchpadZoomGestureUpdate( float scale, bool kinetic );
    MRVIEWER_API bool touchpadZoomGestureEnd();
    MRVIEWER_API bool interruptWindowClose();
 
    MRVIEWER_API void draw( bool force = false );
    MRVIEWER_API void drawFull( bool dirtyScene );
    MRVIEWER_API void drawScene( FramebufferData* framebuffer );
    void setSceneDirty() { dirtyScene_ = true; }
    MRVIEWER_API void setupScene();
    MRVIEWER_API void clearFramebuffers();
    MRVIEWER_API void resize( int w, int h ); 
    MRVIEWER_API void postResize( int w, int h ); 
    MRVIEWER_API void postSetPosition( int xPos, int yPos ); 
    MRVIEWER_API void postSetMaximized( bool maximized ); 
    MRVIEWER_API void postSetIconified( bool iconified ); 
    MRVIEWER_API void postFocus( bool focused ); 
    MRVIEWER_API void postRescale( float x, float y ); 
    MRVIEWER_API void postClose(); 
 
 
    MRVIEWER_API void set_root( SceneRootObject& newRoot );
 
    MRVIEWER_API void clearScene();
 
 
    MRVIEWER_API Viewport& viewport( ViewportId viewportId = {} );
    MRVIEWER_API const Viewport& viewport( ViewportId viewportId = {} ) const;
 
    MRVIEWER_API ViewportId append_viewport( const ViewportRectangle & viewportRect, bool append_empty = false );
 
    MRVIEWER_API Box2f getViewportsBounds() const;
 
    MRVIEWER_API bool erase_viewport( const size_t index );
    MRVIEWER_API bool erase_viewport( ViewportId viewport_id );
 
    MRVIEWER_API int viewport_index( ViewportId viewport_id ) const;
 
    MRVIEWER_API ViewportId getHoveredViewportId() const;
 
    MRVIEWER_API ViewportId getHoveredViewportIdOrInvalid() const;
 
    MRVIEWER_API void select_hovered_viewport();
 
    MRVIEWER_API void fitDataViewport( MR::ViewportMask vpList = MR::ViewportMask::all(), float fill = 0.6f, bool snapView = true );
 
    MRVIEWER_API void fitBoxViewport( const Box3f& box, MR::ViewportMask vpList = MR::ViewportMask::all(), float fill = 0.6f, bool snapView = true );
 
    MRVIEWER_API void preciseFitDataViewport( MR::ViewportMask vpList = MR::ViewportMask::all() );
    MRVIEWER_API void preciseFitDataViewport( MR::ViewportMask vpList, const FitDataParams& param );
 
    MRVIEWER_API size_t getTotalFrames() const;
    MRVIEWER_API size_t getSwappedFrames() const;
    MRVIEWER_API size_t getFPS() const;
    MRVIEWER_API double getPrevFrameDrawTimeMillisec() const;
 
    MRVIEWER_API size_t getStaticGLBufferSize() const;
 
    bool swapOnLastPostEventsRedraw{ true };
    int forceRedrawMinimumIncrementAfterEvents{ 4 };
 
    MRVIEWER_API void incrementForceRedrawFrames( int i = 1, bool swapOnLastOnly = false );
 
    MRVIEWER_API void forceSwapOnFrame( int i = 0 );
 
    MRVIEWER_API bool isCurrentFrameSwapping() const;
 
    enum class EventType
    {
        MouseDown,
        MouseUp,
        MouseMove,
        MouseScroll,
        KeyDown,
        KeyUp,
        KeyRepeat,
        CharPressed,
        Count
    };
    MRVIEWER_API size_t getEventsCount( EventType type )const;
 
    enum class GLPrimitivesType
    {
        PointArraySize,
        LineArraySize,
        TriangleArraySize,
        PointElementsNum,
        LineElementsNum,
        TriangleElementsNum,
        Count
    };
    MRVIEWER_API size_t getLastFrameGLPrimitivesCount( GLPrimitivesType type ) const;
    MRVIEWER_API void incrementThisFrameGLPrimitivesCount( GLPrimitivesType type, size_t num );
 
 
    ViewportMask getPresentViewports() const { return presentViewportsMask_; }
 
    MRVIEWER_API void resetAllCounters();
 
    MRVIEWER_API Image captureSceneScreenShot( const Vector2i& resolution = Vector2i(), bool transparentBg = false );
 
    MRVIEWER_API void captureUIScreenShot( std::function<void( const Image& )> callback,
                                           const Vector2i& pos = Vector2i(), const Vector2i& size = Vector2i() );
 
    MRVIEWER_API bool isAlphaSortAvailable() const;
    MRVIEWER_API bool enableAlphaSort( bool on );
    bool isAlphaSortEnabled() const { return alphaSortEnabled_; }
 
    MRVIEWER_API int getDepthPeelNumPasses() const;
    MRVIEWER_API void setDepthPeelNumPasses( int numPasses );
    MRVIEWER_API bool isDepthPeelingEnabled() const;
 
    MRVIEWER_API bool isSceneTextureBound()  const;
    MRVIEWER_API void bindSceneTexture( bool bind );
    MRVIEWER_API bool isSceneTextureEnabled() const;
 
    MRVIEWER_API int getMSAA() const;
    MRVIEWER_API void requestChangeMSAA( int newMSAA );
    MRVIEWER_API int getRequestedMSAA() const;
 
    MRVIEWER_API void setViewportSettingsManager( std::unique_ptr<IViewerSettingsManager> mng );
    MRVIEWER_API const std::unique_ptr<IViewerSettingsManager>& getViewerSettingsManager() const { return settingsMng_; }
 
    using PointInAllSpaces = MR::PointInAllSpaces;
    MRVIEWER_API PointInAllSpaces getPixelPointInfo( const Vector3f& screenPoint ) const;
    MRVIEWER_API PointInAllSpaces getMousePointInfo() const;
 
    MRVIEWER_API Vector3f screenToViewport( const Vector3f& screenPoint, ViewportId id ) const;
    MRVIEWER_API Vector3f viewportToScreen( const Vector3f& viewportPoint, ViewportId id ) const;
 
    MRVIEWER_API std::vector<std::reference_wrapper<Viewport>> getViewports( ViewportMask mask = ViewportMask::any() );
 
    MRVIEWER_API void enableGlobalHistory( bool on );
    bool isGlobalHistoryEnabled() const { return bool( globalHistoryStore_ ); };
    MRVIEWER_API void appendHistoryAction( const std::shared_ptr<HistoryAction>& action );
    MRVIEWER_API bool globalHistoryUndo();
    MRVIEWER_API bool globalHistoryRedo();
 
    MRVIEWER_API HistoryStore* getGlobalHistoryStore() const { return globalHistoryStore_.get(); }
    
    const std::shared_ptr<SpaceMouse::Handler>& getSpaceMouseHandler() const { return spaceMouseHandler_; }
 
    MRVIEWER_API void onSceneSaved( const std::filesystem::path& savePath, bool storeInRecent = true );
 
    MRVIEWER_API const std::shared_ptr<ImGuiMenu>& getMenuPlugin() const;
    MRVIEWER_API void setMenuPlugin( std::shared_ptr<ImGuiMenu> menu );
 
    MRVIEWER_API std::shared_ptr<RibbonMenu> getRibbonMenu() const;
 
    template <typename T>
    std::shared_ptr<T> getMenuPluginAs() const { return std::dynamic_pointer_cast<T>( getMenuPlugin() ); }
 
    MRVIEWER_API void stopEventLoop();
    bool getStopEventLoopFlag() const { return stopEventLoop_; }
 
    bool windowShouldClose();
 
    bool isGLInitialized() const { return glInitialized_; }
 
    MRVIEWER_API void makeTitleFromSceneRootPath();
 
    bool hasScaledFramebuffer() const { return hasScaledFramebuffer_; }
 
public:
    GLFWwindow* window;
 
    std::function<void( Viewer* viewer )> resetSettingsFunction;
 
    std::vector<Viewport> viewport_list;
    size_t selected_viewport_index;
 
    std::vector<ViewerPlugin*> plugins;
 
    float pixelRatio{ 1.0f };
    Vector2i framebufferSize;
    Vector2i windowSavePos; 
    Vector2i windowSaveSize; 
    Vector2i windowOldPos;
    bool windowMaximized{ false };
 
    bool isAnimating{ false };
    int animationMaxFps{ 30 };
    float scrollForce{ }; 
    uint16_t glPickRadius{ }; 
    bool experimentalFeatures{ };
    std::vector<std::string> commandArgs;
 
    std::shared_ptr<ObjectMesh> basisAxes;
    std::unique_ptr<CornerControllerObject> basisViewController;
    std::unique_ptr<ViewportGlobalBasis> globalBasis;
    std::shared_ptr<ObjectMesh> rotationSphere;
    std::shared_ptr<ObjectMesh> clippingPlaneObject;
 
    std::shared_ptr<ViewerTitle> windowTitle;
 
    ViewerSignals & signals() { return *signals_; }
 
    MRVIEWER_API void emplaceEvent( std::string name, ViewerEventCallback cb, bool skipable = false );
    MRVIEWER_API void popEventByName( const std::string& name );
 
    MRVIEWER_API void postEmptyEvent();
 
    [[nodiscard]] const TouchpadController &touchpadController() const { return *touchpadController_; }
    [[nodiscard]] TouchpadController& touchpadController() { return *touchpadController_; }
 
    [[nodiscard]] const SpaceMouse::Controller &spaceMouseController() const { return *spaceMouseController_; }
    [[nodiscard]] SpaceMouse::Controller& spaceMouseController() { return *spaceMouseController_; }
 
    [[nodiscard]] const MouseController &mouseController() const { return *mouseController_; }
    [[nodiscard]] MouseController &mouseController() { return *mouseController_; }
 
    [[nodiscard]] const RecentFilesStore &recentFilesStore() const { return *recentFilesStore_; }
    [[nodiscard]] RecentFilesStore &recentFilesStore() { return *recentFilesStore_; }
 
    [[nodiscard]] bool getSortDroppedFiles() const { return sortDroppedFiles_; }
 
    void setSortDroppedFiles( bool value ) { sortDroppedFiles_ = value; }
 
    MRVIEWER_API void drawUiRenderObjects();
 
    MRVIEWER_API bool isMultiViewportAvailable();
private:
    Viewer();
    ~Viewer();
 
    int launchInit_( const LaunchParams& params );
 
    bool setupWindow_( const LaunchParams& params );
 
    bool checkOpenGL_(const LaunchParams& params );
 
    void init_();
 
    void initPlugins_();
 
    void shutdownPlugins_();
 
#ifdef __EMSCRIPTEN__
    void mainLoopFunc_();
    static void emsMainInfiniteLoop();
#endif
    bool draw_( bool force );
 
    int forceRedrawFrames_{ 0 };
    int forceRedrawFramesWithoutSwap_{ 0 };
 
    std::unique_ptr<ViewerEventQueue> eventQueue_;
 
    std::shared_ptr<ImGuiMenu> menuPlugin_;
 
    std::unique_ptr<TouchpadController> touchpadController_;
    std::unique_ptr<SpaceMouse::Controller> spaceMouseController_;
    std::unique_ptr<TouchesController> touchesController_;
    std::unique_ptr<MouseController> mouseController_;
    std::unique_ptr<IDragDropHandler> dragDropAdvancedHandler_;
 
    std::unique_ptr<RecentFilesStore> recentFilesStore_;
    std::unique_ptr<FrameCounter> frameCounter_;
 
    mutable struct EventsCounter
    {
        std::array<size_t, size_t( EventType::Count )> counter{};
        void reset();
    } eventsCounter_;
 
    mutable struct GLPrimitivesCounter
    {
        std::array<size_t, size_t( GLPrimitivesType::Count )> counter{};
        void reset();
    } glPrimitivesCounter_;
 
 
    bool tryCreateWindow_( bool fullscreen, int& width, int& height, const std::string& name, int major, int minor );
 
    bool needRedraw_() const;
    void resetRedraw_();
 
    void initGlobalBasisAxesObject_();
    void initBasisAxesObject_();
    void initBasisViewControllerObject_();
    void initClippingPlaneObject_();
    void initRotationCenterObject_();
 
    void initSpaceMouseHandler_();
 
    void updatePixelRatio_();
 
    int getRequiredMSAA_( bool sceneTextureOn, bool forSceneTexture ) const;
 
    bool stopEventLoop_{ false };
 
    bool isLaunched_{ false };
    bool focusRedrawReady_{ false };
 
    std::unique_ptr<SceneTextureGL> sceneTexture_;
    std::unique_ptr<AlphaSortGL> alphaSorter_;
    std::unique_ptr<DepthPeelingGL> depthPeeler_;
 
    bool alphaSortEnabled_{ false };
 
    bool glInitialized_{ false };
 
    bool isInDraw_{ false };
    bool dirtyScene_{ false };
 
    bool hasScaledFramebuffer_{ false };
 
    bool sortDroppedFiles_{ true };
 
    LaunchParams launchParams_;
 
    ViewportId getFirstAvailableViewportId_() const;
    ViewportMask presentViewportsMask_;
 
    std::unique_ptr<IViewerSettingsManager> settingsMng_;
 
    std::unique_ptr<HistoryStore> globalHistoryStore_;
 
    std::shared_ptr<SpaceMouse::Handler> spaceMouseHandler_;
 
    struct Connections;
    std::unique_ptr<Connections> connections_;
    std::unique_ptr<ViewerSignals> signals_;
 
    friend MRVIEWER_API Viewer& getViewerInstance();
};
 
MRVIEWER_API int launchDefaultViewer( const Viewer::LaunchParams& params, const ViewerSetup& setup );
 
}