MRViewport.h

Go to the documentation of this file.

#pragma once
 
#include "MRViewportGL.h"
#include "MRFitData.h"
#include "MRMesh/MRIRenderObject.h"
#include <MRMesh/MRVector3.h>
#include <MRMesh/MRPlane3.h>
#include <MRMesh/MRPointOnObject.h>
#include <MRMesh/MRViewportId.h>
#include <MRMesh/MRQuaternion.h>
#include <MRMesh/MRMatrix4.h>
#include <MRMesh/MRColor.h>
#include <MRMesh/MRBox.h>
#include "MRImGui.h"
#include <memory>
#include <functional>
#include <unordered_map>
#include <optional>
#include <span>
 
namespace MR
{
 
 
inline ImVec2 position( const ViewportRectangle& rect )
{
    return { rect.min.x, rect.min.y };
}
 
inline ImVec2 size( const ViewportRectangle& rect )
{
    return { width( rect ), height( rect ) };
}

template<typename T>
inline Vector4<T> toVec4( const ViewportRectangle& rect )
{
    return Vector4<T>{T( rect.min.x ), T( rect.min.y ), T( MR::width( rect ) ), T( MR::height( rect ) )};
}

class Viewport
{
public:
    using ViewportRectangle = MR::ViewportRectangle;

    MRVIEWER_API static Viewport& get( ViewportId viewportId = {} );
 
    MRVIEWER_API Viewport();
    MRVIEWER_API ~Viewport();
 
private: 
    Viewport( const Viewport & ) = default;
    Viewport & operator = ( const Viewport & ) = default;
public:
    [[nodiscard]] Viewport clone() const { return Viewport( *this ); }
    Viewport( Viewport && ) noexcept = default;
    Viewport & operator = ( Viewport && ) noexcept = default;

    MRVIEWER_API void init();

    MRVIEWER_API void setAxesPos( const int pixelXoffset = -100, const int pixelYoffset = -100 );
    MRVIEWER_API void setAxesSize( const int axisPixSize = 80 );

    MRVIEWER_API const Vector2f& getAxesPosition() const;
    MRVIEWER_API float getAxesSize() const;

    [[deprecated("Use (draw/getBaseRenderParams/getModelRenderParams)OrthoFixedPos functions instead of using this value")]] 
    const Matrix4f& getAxesProjectionMatrix() const { return axesProjMat_; }

    MRVIEWER_API void shut();


    MRVIEWER_API void clearFramebuffers();

    MRVIEWER_API void recursiveDraw( const Object& obj,
        DepthFunction depthFunc = DepthFunction::Default, const AffineXf3f& rootXf = {}, RenderModelPassMask renderType = RenderModelPassMask::All,
        const TransparencyMode& transparentMode = {}, int* numDraws = nullptr ) const;

    MRVIEWER_API bool draw( const VisualObject& obj,
        DepthFunction depthFunc = DepthFunction::Default, RenderModelPassMask pass = RenderModelPassMask::All, const TransparencyMode& transparentMode = {} ) const;

    MRVIEWER_API bool draw( const VisualObject& obj, const AffineXf3f& xf,
        DepthFunction depthFunc = DepthFunction::Default, RenderModelPassMask pass = RenderModelPassMask::All, const TransparencyMode& transparentMode = {} ) const;

    MRVIEWER_API bool draw( const VisualObject& obj, const AffineXf3f& xf, const Matrix4f & projM,
        DepthFunction depthFunc = DepthFunction::Default, RenderModelPassMask pass = RenderModelPassMask::All, const TransparencyMode& transparentMode = {} ) const;

    MRVIEWER_API bool drawOrthoFixedPos( const VisualObject& obj, const AffineXf3f& xf,
        DepthFunction depthFunc = DepthFunction::Default, RenderModelPassMask pass = RenderModelPassMask::All, const TransparencyMode& transparentMode = {} ) const;

    struct LinePointImmediateRenderParams : BaseRenderParams
    {
        float width{1.0f};
        bool depthTest{ true };
    };

    MRVIEWER_API void drawLines( const std::vector<LineSegm3f>& lines, const std::vector<SegmEndColors>& colors, const LinePointImmediateRenderParams & params );
    void drawLines( const std::vector<LineSegm3f>& lines, const std::vector<SegmEndColors>& colors, float width = 1, bool depthTest = true )
        { drawLines( lines, colors, { getBaseRenderParams(), width, depthTest } ); }

    MRVIEWER_API void drawPoints( const std::vector<Vector3f>& points, const std::vector<Vector4f>& colors, const LinePointImmediateRenderParams & params );
    void drawPoints( const std::vector<Vector3f>& points, const std::vector<Vector4f>& colors, float width = 1, bool depthTest = true )
        { drawPoints( points, colors, { getBaseRenderParams(), width, depthTest } ); }
 
    struct TriCornerColors
    {
        Vector4f a, b, c;
    };

    MRVIEWER_API void drawTris( const std::vector<Triangle3f>& tris, const std::vector<TriCornerColors>& colors, const ModelRenderParams& params, bool depthTest = true );
    MRVIEWER_API void drawTris( const std::vector<Triangle3f>& tris, const std::vector<TriCornerColors>& colors, const Matrix4f& modelM = {}, bool depthTest = true );

    [[nodiscard]] BaseRenderParams getBaseRenderParams() const { return getBaseRenderParams( projM_ ); }

    [[nodiscard]] BaseRenderParams getBaseRenderParams( const Matrix4f & projM ) const
        { return { viewM_, projM, id, toVec4<int>( viewportRect_ ) }; }

    [[nodiscard]] BaseRenderParams getBaseRenderParamsOrthoFixedPos() const
        { return { axesViewMat_, axesProjMat_, id, toVec4<int>( viewportRect_ ) }; }

    [[nodiscard]] ModelRenderParams getModelRenderParams(
         const Matrix4f & modelM, 
         Matrix4f * normM, 
         DepthFunction depthFunc = DepthFunction::Default,
         RenderModelPassMask pass = RenderModelPassMask::All,
         const TransparencyMode& transparentMode = {} 
    ) const
    { return getModelRenderParams( modelM, getBaseRenderParams(projM_), normM, depthFunc, pass, transparentMode ); }

    [[nodiscard]] ModelRenderParams getModelRenderParamsOrthoFixedPos(
         const Matrix4f & modelM, 
         Matrix4f * normM, 
         DepthFunction depthFunc = DepthFunction::Default,
         RenderModelPassMask pass = RenderModelPassMask::All,
         const TransparencyMode& transparentMode = {} 
    ) const
    { return getModelRenderParams( modelM, getBaseRenderParamsOrthoFixedPos(), normM, depthFunc, pass, transparentMode ); }

    [[nodiscard]] MRVIEWER_API ModelRenderParams getModelRenderParams( const Matrix4f & modelM, const BaseRenderParams& baseParams,
         Matrix4f * normM, 
         DepthFunction depthFunc = DepthFunction::Default,
         RenderModelPassMask pass = RenderModelPassMask::All,
         const TransparencyMode& transparentMode = {} 
    ) const;

    using PickRenderObjectPredicate = std::function<bool ( const VisualObject*, ViewportMask )>;
    struct PickRenderObjectParams
    {
        std::optional<Vector2f> point;

        PickRenderObjectPredicate predicate;

        int pickRadius = -1;
        bool exactPickFirst = true;

        const BaseRenderParams* baseRenderParams{ nullptr };

        static PickRenderObjectParams defaults()
        {
            return {};
        }
    };

    MRVIEWER_API ObjAndPick pickRenderObject( const PickRenderObjectParams& params = PickRenderObjectParams::defaults() ) const;
    MRVIEWER_API ObjAndPick pickRenderObject( std::span<VisualObject* const> objects, const PickRenderObjectParams& params = PickRenderObjectParams::defaults() ) const;
    MRVIEWER_API ConstObjAndPick pickRenderObjectConst( std::span<const VisualObject* const> objects, const PickRenderObjectParams& params = PickRenderObjectParams::defaults() ) const;

    MRVIEWER_API ObjAndPick pick_render_object() const;
    [[deprecated("Use `pickRenderObject()`")]]
    MRVIEWER_API ObjAndPick pick_render_object( uint16_t pickRadius ) const;
    [[deprecated("Use `pickRenderObject( objects } )`")]] 
    MRVIEWER_API ObjAndPick pick_render_object( const std::vector<VisualObject*>& objects ) const;
    [[deprecated("Use `pickRenderObject( ... )`")]]
    MRVIEWER_API ObjAndPick pick_render_object( const std::vector<VisualObject*>& objects, uint16_t pickRadius, bool exactPickFirst = true ) const;
    [[deprecated("Use `pickRenderObject( { .exactPickFirst = ... } )`")]]
    MRVIEWER_API ObjAndPick pick_render_object( bool exactPickFirst ) const;
    [[deprecated("Use `pickRenderObject( { .point = ... } )`")]]
    MRVIEWER_API ObjAndPick pick_render_object( const Vector2f& viewportPoint ) const;
    [[deprecated("Use `multiPickObjects( objects, { .point = ... } )`")]]
    MRVIEWER_API ObjAndPick pick_render_object( const std::vector<VisualObject*>& objects, const Vector2f& viewportPoint ) const;

    MRVIEWER_API std::vector<ObjAndPick> multiPickObjects( std::span<VisualObject* const> objects, const std::vector<Vector2f>& viewportPoints, const BaseRenderParams* overrideRenderParams = nullptr ) const;

    MRVIEWER_API std::vector<std::shared_ptr<VisualObject>> findObjectsInRect( const Box2i& rect,
                                                                               int maxRenderResolutionSide = 512 ) const;

    MRVIEWER_API std::unordered_map<std::shared_ptr<ObjectMesh>, FaceBitSet> findVisibleFaces( const BitSet& includePixBs,
        int maxRenderResolutionSide = 512 ) const;

    [[nodiscard]] MRVIEWER_API FaceBitSet findCameraLookingFaces( const Mesh& mesh, const AffineXf3f& meshToWorld ) const;
 

    [[deprecated("Use `pickRenderObject()`.")]]
    MRVIEWER_API ConstObjAndPick const_pick_render_object() const;
    [[deprecated("Use `pickRenderObject( objects )`.")]]
    MRVIEWER_API ConstObjAndPick const_pick_render_object( const std::vector<const VisualObject*>& objects ) const;
    MRVIEWER_API std::vector<ConstObjAndPick> constMultiPickObjects( const std::vector<const VisualObject*>& objects, const std::vector<Vector2f>& viewportPoints ) const;

    MRVIEWER_API void transformView( const AffineXf3f & xf );
 
    bool getRedrawFlag() const { return needRedraw_; }
    void resetRedrawFlag() { needRedraw_ = false; }

    ViewportId id{ 1};
 
    struct Parameters
    {
        Color backgroundColor = Color( Vector3f{0.3f, 0.3f, 0.5f} );
        Vector3f lightPosition{0.0f, 0.3f, 0.0f};
 
        Quaternionf cameraTrackballAngle;
        Vector3f cameraTranslation;
        float cameraZoom{1.0f};
        float cameraViewAngle{45.0f};
        float cameraDnear{1.0f};
        float cameraDfar{100.0f};
 
        bool depthTest{true};
        bool orthographic{true};
 
        enum class GlobalBasisScaleMode
        {
            Auto, 
            Fixed 
        } globalBasisScaleMode{ GlobalBasisScaleMode::Auto };

        float objectScale{1.0f};
 
        Color borderColor;
 
        std::string label;
 
        Plane3f clippingPlane{Vector3f::plusX(), 0.0f};
 
        enum class RotationCenterMode
        {
            Static, 
            DynamicStatic, 
            Dynamic 
        } rotationMode{ RotationCenterMode::Dynamic };

        std::optional<Vector3f> staticRotationPivot;

        bool compensateRotation{ true };

        bool selectable{true};
 
        bool operator==( const Viewport::Parameters& other ) const = default;
    };

    MRVIEWER_API void setRotation( bool state );

    MRVIEWER_API const ViewportRectangle& getViewportRect() const;

    MRVIEWER_API float getPixelSize() const;

    MRVIEWER_API float getPixelSizeAtPoint( const Vector3f& worldPoint ) const;

    MRVIEWER_API void setViewportRect( const ViewportRectangle& rect );
 
private:
    Matrix4f viewM_;
    Matrix4f projM_;
 
public:
    [[nodiscard]] MRVIEWER_API AffineXf3f getUnscaledViewXf() const;

    [[nodiscard]] AffineXf3f getViewXf() const { return AffineXf3f( viewM_ ); }

    [[nodiscard]] Vector3f getUpDirection() const { return Vector3f( viewM_.y.x, viewM_.y.y, viewM_.y.z ).normalized(); } 

    [[nodiscard]] Vector3f getRightDirection() const { return Vector3f( viewM_.x.x, viewM_.x.y, viewM_.x.z ).normalized(); } 

    [[nodiscard]] Vector3f getBackwardDirection() const { return Vector3f( viewM_.z.x, viewM_.z.y, viewM_.z.z ).normalized(); } 

    MRVIEWER_API Line3f unprojectPixelRay( const Vector2f& viewportPoint ) const;

    MRVIEWER_API Vector3f worldToCameraSpace( const Vector3f& p ) const;
    MRVIEWER_API std::vector<Vector3f> worldToCameraSpace( const std::vector<Vector3f>& p ) const;

    MRVIEWER_API Vector3f projectToClipSpace( const Vector3f& worldPoint ) const;
    MRVIEWER_API std::vector<Vector3f> projectToClipSpace( const std::vector<Vector3f>& worldPoints ) const;
    MRVIEWER_API Vector3f unprojectFromClipSpace( const Vector3f& clipPoint ) const;
    MRVIEWER_API std::vector<Vector3f> unprojectFromClipSpace( const std::vector<Vector3f>& clipPoints ) const;

    MRVIEWER_API Vector3f projectToViewportSpace( const Vector3f& worldPoint ) const;
    MRVIEWER_API std::vector<Vector3f> projectToViewportSpace( const std::vector<Vector3f>& worldPoints ) const;
    MRVIEWER_API Vector3f unprojectFromViewportSpace( const Vector3f& viewportPoint ) const;
    MRVIEWER_API std::vector<Vector3f> unprojectFromViewportSpace( const std::vector<Vector3f>& viewportPoints ) const;

    MRVIEWER_API Vector3f clipSpaceToViewportSpace( const Vector3f& p ) const;
    MRVIEWER_API std::vector<Vector3f> clipSpaceToViewportSpace( const std::vector<Vector3f>& p ) const;
    MRVIEWER_API Vector3f viewportSpaceToClipSpace( const Vector3f& p ) const;
    MRVIEWER_API std::vector<Vector3f> viewportSpaceToClipSpace( const std::vector<Vector3f>& p ) const;

    void setupView();
    void preDraw();
    void postDraw() const;

    MRVIEWER_API void fitData( float fill = 1.0f, bool snapView = true );

    MRVIEWER_API void fitBox( const Box3f& newSceneBox, float fill = 1.0f, bool snapView = true );
 
    using FitMode = MR::FitMode;
    using BaseFitParams = MR::BaseFitParams;
    using FitDataParams = MR::FitDataParams;
    using FitBoxParams = MR::FitBoxParams;

    MRVIEWER_API void preciseFitBoxToScreenBorder( const FitBoxParams& params );
    MRVIEWER_API void preciseFitDataToScreenBorder( const FitDataParams& params = {} );

    MRVIEWER_API float getRatio() const;

    MRVIEWER_API bool allModelsInsideViewportRectangle() const;
 
    MRVIEWER_API const Box3f& getSceneBox() const;
 
    const Parameters& getParameters() const { return params_; }

    MRVIEWER_API Vector3f getCameraPoint() const;
    MRVIEWER_API void setCameraPoint( const Vector3f& cameraWorldPos );
 
    MRVIEWER_API void setCameraTrackballAngle( const Quaternionf& rot );
 
    MRVIEWER_API void setCameraTranslation( const Vector3f& translation );
 
    MRVIEWER_API void setCameraViewAngle( float newViewAngle );
 
    MRVIEWER_API void setCameraZoom( float zoom );
 
    MRVIEWER_API void setOrthographic( bool orthographic );
 
    MRVIEWER_API void setBackgroundColor( const Color& color );
 
    MRVIEWER_API void setClippingPlane( const Plane3f& plane );
 
    MRVIEWER_API void setLabel( std::string s );
 
    void setSelectable( bool on ) { params_.selectable = on; }
 
    MRVIEWER_API void showAxes( bool on );
    MRVIEWER_API void showClippingPlane( bool on );
    MRVIEWER_API void showRotationCenter( bool on );
    MRVIEWER_API void showGlobalBasis( bool on );
    MRVIEWER_API void rotationCenterMode( Parameters::RotationCenterMode mode );
 
    MRVIEWER_API void setParameters( const Viewport::Parameters& params );

    MRVIEWER_API void cameraLookAlong( const Vector3f& dir, const Vector3f& up );

    MRVIEWER_API void cameraRotateAround( const Line3f& axis, float angle );

    Vector3f getRotationPivot() const { return rotationPivot_; }

    MRVIEWER_API void resetStaticRotationPivot( const std::optional<Vector3f>& pivot = std::nullopt );
private:
    void setRotationPivot_( const Vector3f& point ) { rotationPivot_ = point; }
    void setupViewMatrix_();
    AffineXf3f getViewXf_() const;

    void setupProjMatrix_();
    void setupAxesViewProjMatrix_();

    Matrix4f getFullViewportMatrix() const { return projM_ * viewM_; }
    Matrix4f getFullViewportInversedMatrix() const;
 
    ViewportRectangle viewportRect_;
 
    ViewportGL viewportGL_;
 
    bool previewLinesDepthTest_ = false;
    bool previewPointsDepthTest_ = false;
 
    void draw_border() const;
    void draw_rotation_center() const;
    void draw_clipping_plane() const;
    void drawGlobalBasis() const;

    void initBaseAxes();
    void drawAxesAndViewController() const;

    Matrix4f axesViewMat_;
    Matrix4f axesProjMat_;
    Vector2f basisAxesPos_;
    float basisAxesSize_;

    int pixelXoffset_{ -100 };
    int pixelYoffset_{ -128 };
    int axisPixSize_{ 70 };
 
    void updateSceneBox_();
    void rotateView_();
 
    enum class Space
    {
        World,              
        CameraOrthographic, 
        CameraPerspective   
    };

    Box3f calcBox_( const std::vector<std::shared_ptr<VisualObject>>& objs, Space space, bool selectedPrimitives = false ) const;

    std::pair<float, bool> getZoomFOVtoScreen_( std::function<Box3f()> getBoxFn, Vector3f* cameraShift = nullptr ) const;
    void preciseFitToScreenBorder_( std::function<Box3f( bool zoomFOV, bool globalBasis )> getBoxFn, const BaseFitParams& params );
 
    bool rotation_{ false };
    Vector3f rotationPivot_;
    Vector3f static_point_;
    Vector2f static_viewport_point;
    float distToSceneCenter_;
 
    bool needRedraw_{false};

    Box3f sceneBox_;
 
    Parameters params_;
};
 
}