MRObjectTransformWidget.h

Go to the documentation of this file.

#pragma once
 
#include "MRViewerEventsListener.h"
#include "MRMesh/MRFlagOperators.h"
#include "MRMesh/MRMeshFwd.h"
#include "MRMesh/MRVector3.h"
#include "MRMesh/MRHistoryAction.h"
#include "MRMesh/MRViewportProperty.h"
#include "MRMesh/MRAffineXf3.h"
#include "MRMesh/MRAxis.h"
#include <MRMesh/MRObject.h>
#include <MRMesh/MRColor.h>
#include "MRMesh/MRSignal.h"
#include <array>
#include <functional>
#include <string>
 
namespace MR
{
 
 
enum class ControlBit
{
    None = 0,
    RotX = 0x1,
    RotY = 0x2,
    RotZ = 0x4,
    RotMask = RotX | RotY | RotZ,
    MoveX = 0x8,
    MoveY = 0x10,
    MoveZ = 0x20,
    MoveMask = MoveX | MoveY | MoveZ,
    FullMask = RotMask | MoveMask
};
MR_MAKE_FLAG_OPERATORS( ControlBit )
 

using TransformModesValidator = std::function<ControlBit( const Vector3f& center, const AffineXf3f& xf, ViewportId )>;
 

class MRVIEWER_CLASS ITransformControls
{
public:
    virtual ~ITransformControls() = default;

    const Vector3f& getCenter() const { return center_; }
    MRVIEWER_API void setCenter( const Vector3f& center );

    virtual float getRadius() const { return 1.0f; }

    virtual void updateSizeInPixel() {};

    void setTransformModesValidator( TransformModesValidator validator ) { validator_ = validator; }

    void setPickThrough( bool on ) { pickThrough_ = on; }
    bool getPickThrough() const { return pickThrough_; }

    ControlBit getHoveredControl() const { return hoveredControl_; }

    virtual void init( std::shared_ptr<Object> parent ) = 0;
    virtual void update() = 0;
    void hover() { hoveredControl_ = hover_( pickThrough_ ); }
    void stopModify( bool rehover = true ) { stopModify_(); if ( rehover ) hover(); }

    MRVIEWER_API void updateVisualTransformMode( ControlBit showMask, ViewportMask viewportMask, const AffineXf3f& xf );

    virtual void updateTranslation( Axis ax, const Vector3f& startMove, const Vector3f& endMove, ViewportId vpId ) = 0;
    virtual void updateRotation( Axis ax, const AffineXf3f& xf, float startAngle, float endAngle, ViewportId vpId ) = 0;

    class ChangeCenterAction : public HistoryAction
    {
    public:
        ChangeCenterAction( const std::string& name, ITransformControls& controls ) :
            controls_{ controls },
            name_{ name }{ center_ = controls.getCenter(); }
 
        virtual std::string name() const override { return name_; }
 
        virtual void action( HistoryAction::Type ) override
        {
            auto center = controls_.getCenter();
            controls_.setCenter( center_ );
            center_ = center;
        }
 
        [[nodiscard]] virtual size_t heapBytes() const override { return name_.capacity(); }
 
    private:
        ITransformControls& controls_;
        Vector3f center_;
        std::string name_;
    };
protected:
    virtual ControlBit hover_( bool pickThrough ) = 0;
    virtual void stopModify_() = 0;
    virtual void updateVisualTransformMode_( ControlBit showMask, ViewportMask viewportMask ) = 0;
private:
    Vector3f center_;
 
    ControlBit hoveredControl_{ ControlBit::None };
    bool pickThrough_{ false };
    TransformModesValidator validator_;
};

class MRVIEWER_CLASS TransformControls : public ITransformControls
{
public:
 
    struct MRVIEWER_CLASS VisualParams
    {
        enum class SizeType
        {
            LengthUnit = 0,
            Pixels
        };

        MRVIEWER_API void update( const Box3f& box );
        float radius{ -1.0f };
        float width{ -1.0f };
        SizeType sizeType = SizeType::LengthUnit;
        float coneRadiusFactor{ 1.35f };
        float coneSizeFactor{ 2.2f };
        float negativeLineExtension{ 1.15f };
        float positiveLineExtension{ 1.3f };
        std::array<Color, size_t( Axis::Count )> rotationColors{ Color::red(),Color::green(),Color::blue() };
        std::array<Color, size_t( Axis::Count )> translationColors{ Color::red(),Color::green(),Color::blue() };
        Color helperLineColor{ Color::black() };
        Color activeLineColor{ Color::white() };
    };
    MRVIEWER_API void setVisualParams( const VisualParams& params );
    const VisualParams& getVisualParams() const { return params_; }
 
    MRVIEWER_API virtual ~TransformControls();
 
    MRVIEWER_API virtual void init( std::shared_ptr<Object> parent ) override;
    MRVIEWER_API virtual void update() override;
 
    virtual float getRadius() const override { return params_.radius; }
    MRVIEWER_API void setRadius( float radius );
    float getWidth() const { return params_.width; }
    MRVIEWER_API void setWidth( float width );
    MRVIEWER_API void setSizeType( VisualParams::SizeType type );
    MRVIEWER_API virtual void updateSizeInPixel() override;
 
    MRVIEWER_API virtual void updateTranslation( Axis ax, const Vector3f& startMove, const Vector3f& endMove, ViewportId vpId ) override;
    MRVIEWER_API virtual void updateRotation( Axis ax, const AffineXf3f& xf, float startAngle, float endAngle, ViewportId vpId ) override;

    MRVIEWER_API static TransformModesValidator ThresholdDotValidator( float thresholdDot );
private:
    void resetSizeInPixel_();
 
    MRVIEWER_API virtual ControlBit hover_( bool pickThrough ) override;
    MRVIEWER_API virtual void stopModify_() override;
    MRVIEWER_API virtual void updateVisualTransformMode_( ControlBit showMask, ViewportMask viewportMask ) override;
 
    VisualParams params_;

    std::array<std::shared_ptr<ObjectMesh>, size_t( Axis::Count )> translateControls_;
    std::array<std::shared_ptr<ObjectMesh>, size_t( Axis::Count )> rotateControls_;

    std::shared_ptr<ObjectLines> activeLine_;
    std::array<std::shared_ptr<ObjectLines>, size_t( Axis::Count )> translateLines_;
    std::array<std::shared_ptr<ObjectLines>, size_t( Axis::Count )> rotateLines_;
 
    std::shared_ptr<ObjectMesh> hoveredObject_;
    int findHoveredIndex_() const;
    void setActiveLineFromPoints_( const Contour3f& points );
};

class MRVIEWER_CLASS ObjectTransformWidget : public MultiListener<MouseDownListener, MouseMoveListener, MouseUpListener, PreDrawListener, PostDrawListener>
{
public:
    MRVIEWER_API void create( const Box3f& box, const AffineXf3f& xf, std::shared_ptr<ITransformControls> controls = {} );
    MRVIEWER_API void reset();

    ControlBit getTransformModeMask( ViewportId id = {} ) const { return transformModeMask_.get( id ); }
    MRVIEWER_API void setTransformMode( ControlBit mask, ViewportId id = {} );

    enum AxisTransformMode
    {
        AxisTranslation,
        AxisScaling,
        UniformScaling,
    };

    AxisTransformMode getAxisTransformMode() const { return axisTransformMode_; };
    void setAxisTransformMode( AxisTransformMode mode ) { axisTransformMode_ = mode; };

    std::shared_ptr<Object> getRootObject() const { return controlsRoot_; }

    std::shared_ptr<ITransformControls> getControls() const { return controls_; }
    template<typename T>
    std::shared_ptr<T> getControlsAs() const { return std::dynamic_pointer_cast< T >( controls_ ); }

    MRVIEWER_API void setControlsXf( const AffineXf3f& xf, ViewportId id = {} );
    MRVIEWER_API AffineXf3f getControlsXf( ViewportId id = {} ) const;

    MRVIEWER_API void followObjVisibility( const std::weak_ptr<Object>& obj );

    void setScaleTooltipCallback( std::function<void( float )> callback ) { scaleTooltipCallback_ = callback; }
    void setTranslateTooltipCallback( std::function<void( float )> callback ) { translateTooltipCallback_ = callback; }
    void setRotateTooltipCallback( std::function<void( float )> callback ) { rotateTooltipCallback_ = callback; }

    void setStopModifyCallback( std::function<void()> callback ) { stopModifyCallback_ = callback; }
    void setStartModifyCallback( std::function<void()> callback ) { startModifyCallback_ = callback; }
    void setAddXfCallback( std::function<void( const AffineXf3f& )> callback ) { addXfCallback_ = callback; }
    void setApproveXfCallback( std::function<bool( const AffineXf3f& )> callback ) { approveXfCallback_ = callback; }

    class ChangeXfAction : public HistoryAction
    {
    public:
        ChangeXfAction( const std::string& name, ObjectTransformWidget& widget ) :
            widget_{ widget },
            name_{ name }
        {
            if ( widget_.controlsRoot_ )
            {
                xf_ = widget_.controlsRoot_->xfsForAllViewports();
                scaledXf_ = widget_.scaledXf_;
            }
        }
 
        virtual std::string name() const override
        {
            return name_;
        }
 
        virtual void action( HistoryAction::Type ) override
        {
            if ( !widget_.controlsRoot_ )
                return;
            auto tmpXf = widget_.controlsRoot_->xfsForAllViewports();
            widget_.controlsRoot_->setXfsForAllViewports( xf_ );
            xf_ = tmpXf;
 
            std::swap( scaledXf_, widget_.scaledXf_ );
        }
 
        [[nodiscard]] virtual size_t heapBytes() const override
        {
            return name_.capacity();
        }
 
    private:
        ObjectTransformWidget& widget_;
        ViewportProperty<AffineXf3f> xf_;
        ViewportProperty<AffineXf3f> scaledXf_;
        std::string name_;
    };
private:
    MRVIEWER_API virtual bool onMouseDown_( MouseButton button, int modifier ) override;
    MRVIEWER_API virtual bool onMouseUp_( MouseButton button, int modifier ) override;
    MRVIEWER_API virtual bool onMouseMove_( int mouse_x, int mouse_y ) override;
    MRVIEWER_API virtual void preDraw_() override;
    MRVIEWER_API virtual void postDraw_() override;
 
    void activeMove_( bool press = false );
 
    void processScaling_( Axis ax, bool press );
    void processTranslation_( Axis ax, bool press );
    void processRotation_( Axis ax, bool press );
 
    void setControlsXf_( const AffineXf3f& xf, bool updateScaled, ViewportId id = {} );
 
    std::weak_ptr<Object> visibilityParent_;

    void addXf_( const AffineXf3f& addXf );
    void stopModify_();

    std::shared_ptr<Object> controlsRoot_;
    std::shared_ptr<ITransformControls> controls_;
 
    AxisTransformMode axisTransformMode_{ AxisTranslation };
 
    enum ActiveEditMode
    {
        TranslationMode,
        ScalingMode,
        UniformScalingMode,
        RotationMode,
    };
    ActiveEditMode activeEditMode_{ TranslationMode };
    ActiveEditMode editModeFor_( ControlBit control ) const;

    Vector3f boxDiagonal_;
    ViewportProperty<AffineXf3f> scaledXf_;
    float currentScaling_ = 1.0f;
 
    Vector3f prevScaling_;
    Vector3f startTranslation_;
    Vector3f prevTranslation_;
    float accumShift_ = 0;
 
    float startAngle_ = 0;
    float accumAngle_ = 0;
 
    ViewportProperty<ControlBit> transformModeMask_{ ControlBit::FullMask };
    bool picked_{ false };
 
    std::function<void( float )> scaleTooltipCallback_;
    std::function<void( float )> translateTooltipCallback_;
    std::function<void( float )> rotateTooltipCallback_;
 
    std::function<void()> startModifyCallback_;
    std::function<void()> stopModifyCallback_;
    std::function<void( const AffineXf3f& )> addXfCallback_;
    std::function<bool( const AffineXf3f& )> approveXfCallback_;
    bool approvedChange_ = true; 
    boost::signals2::connection xfValidatorConnection_;
};
 
}