Measure: Initial porting of Measure Gizmo

src/slic3r/GUI/Gizmos/GLGizmoMeasure.hpp

@@ -0,0 +1,190 @@
+///|/ Copyright (c) Prusa Research 2019 - 2023 Oleksandra Iushchenko @YuSanka, Lukáš Matěna @lukasmatena, Enrico Turri @enricoturri1966, Vojtěch Bubník @bubnikv, Filip Sykala @Jony01
+///|/
+///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
+///|/
+#ifndef slic3r_GLGizmoMeasure_hpp_
+#define slic3r_GLGizmoMeasure_hpp_
+
+#include "GLGizmoBase.hpp"
+#include "slic3r/GUI/GLModel.hpp"
+#include "slic3r/GUI/GUI_Utils.hpp"
+#include "slic3r/GUI/MeshUtils.hpp"
+#include "slic3r/GUI/I18N.hpp"
+#include "libslic3r/Measure.hpp"
+#include "libslic3r/Model.hpp"
+
+namespace Slic3r {
+
+enum class ModelVolumeType : int;
+
+namespace Measure { class Measuring; }
+
+
+namespace GUI {
+
+enum class SLAGizmoEventType : unsigned char;
+
+class GLGizmoMeasure : public GLGizmoBase
+{
+    enum class EMode : unsigned char
+    {
+        FeatureSelection,
+        PointSelection
+    };
+
+    struct SelectedFeatures
+    {
+        struct Item
+        {
+            bool is_center{ false };
+            std::optional<Measure::SurfaceFeature> source;
+            std::optional<Measure::SurfaceFeature> feature;
+
+            bool operator == (const Item& other) const {
+                return this->is_center == other.is_center && this->source == other.source && this->feature == other.feature;
+            }
+
+            bool operator != (const Item& other) const {
+                return !operator == (other);
+            }
+
+            void reset() {
+                is_center = false;
+                source.reset();
+                feature.reset();
+            }
+        };
+
+        Item first;
+        Item second;
+
+        void reset() {
+            first.reset();
+            second.reset();
+        }
+
+        bool operator == (const SelectedFeatures & other) const {
+            if (this->first != other.first) return false;
+            return this->second == other.second;
+        }
+
+        bool operator != (const SelectedFeatures & other) const {
+            return !operator == (other);
+        }
+    };
+
+    struct VolumeCacheItem
+    {
+        const ModelObject* object{ nullptr };
+        const ModelInstance* instance{ nullptr };
+        const ModelVolume* volume{ nullptr };
+        Transform3d world_trafo;
+
+        bool operator == (const VolumeCacheItem& other) const {
+            return this->object == other.object && this->instance == other.instance && this->volume == other.volume &&
+                this->world_trafo.isApprox(other.world_trafo);
+        }
+    };
+
+    std::vector<VolumeCacheItem> m_volumes_cache;
+
+    EMode m_mode{ EMode::FeatureSelection };
+    Measure::MeasurementResult m_measurement_result;
+
+    std::unique_ptr<Measure::Measuring> m_measuring; // PIMPL
+
+    PickingModel m_sphere;
+    PickingModel m_cylinder;
+    PickingModel m_circle;
+    PickingModel m_plane;
+    struct Dimensioning
+    {
+        GLModel line;
+        GLModel triangle;
+        GLModel arc;
+    };
+    Dimensioning m_dimensioning;
+
+    // Uses a standalone raycaster and not the shared one because of the
+    // difference in how the mesh is updated
+    std::unique_ptr<MeshRaycaster> m_raycaster;
+
+    std::vector<GLModel> m_plane_models_cache;
+    std::map<int, std::shared_ptr<SceneRaycasterItem>> m_raycasters;
+    // used to keep the raycasters for point/center spheres
+    std::vector<std::shared_ptr<SceneRaycasterItem>> m_selected_sphere_raycasters;
+    std::optional<Measure::SurfaceFeature> m_curr_feature;
+    std::optional<Vec3d> m_curr_point_on_feature_position;
+    struct SceneRaycasterState
+    {
+        std::shared_ptr<SceneRaycasterItem> raycaster{ nullptr };
+        bool state{true};
+
+    };
+    std::vector<SceneRaycasterState> m_scene_raycasters;
+
+    // These hold information to decide whether recalculation is necessary:
+    float m_last_inv_zoom{ 0.0f };
+    std::optional<Measure::SurfaceFeature> m_last_circle;
+    int m_last_plane_idx{ -1 };
+
+    bool m_mouse_left_down{ false }; // for detection left_up of this gizmo
+
+    Vec2d m_mouse_pos{ Vec2d::Zero() };
+
+    KeyAutoRepeatFilter m_shift_kar_filter;
+
+    SelectedFeatures m_selected_features;
+    bool m_pending_scale{ false };
+    bool m_editing_distance{ false };
+    bool m_is_editing_distance_first_frame{ true };
+
+    void update_if_needed();
+
+    void disable_scene_raycasters();
+    void restore_scene_raycasters_state();
+
+    void render_dimensioning();
+
+#if ENABLE_MEASURE_GIZMO_DEBUG
+    void render_debug_dialog();
+#endif // ENABLE_MEASURE_GIZMO_DEBUG
+
+public:
+    GLGizmoMeasure(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
+
+    /// <summary>
+    /// Apply rotation on select plane
+    /// </summary>
+    /// <param name="mouse_event">Keep information about mouse click</param>
+    /// <returns>Return True when use the information otherwise False.</returns>
+    bool on_mouse(const wxMouseEvent &mouse_event) override;
+
+    void data_changed(bool is_serializing) override;
+
+    bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
+
+    bool wants_enter_leave_snapshots() const override { return true; }
+    std::string get_gizmo_entering_text() const override { return _u8L("Entering Measure gizmo"); }
+    std::string get_gizmo_leaving_text() const override { return _u8L("Leaving Measure gizmo"); }
+    std::string get_action_snapshot_name() const override { return _u8L("Measure gizmo editing"); }
+
+protected:
+    bool on_init() override;
+    std::string on_get_name() const override;
+    bool on_is_activable() const override;
+    void on_render() override;
+    void on_set_state() override;
+
+    virtual void on_render_input_window(float x, float y, float bottom_limit) override;
+    virtual void on_register_raycasters_for_picking() override;
+    virtual void on_unregister_raycasters_for_picking() override;
+
+    void remove_selected_sphere_raycaster(int id);
+    void update_measurement_result();
+};
+
+} // namespace GUI
+} // namespace Slic3r
+
+#endif // slic3r_GLGizmoMeasure_hpp_

src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp

@@ -30,8 +30,12 @@ enum class SLAGizmoEventType : unsigned char {
     Dragging,
     Delete,
     SelectAll,
+    CtrlDown,
+    CtrlUp,
+    ShiftDown,
     ShiftUp,
     AltUp,
+    Escape,
     ApplyChanges,
     DiscardChanges,
     AutomaticGeneration,

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -27,6 +27,7 @@
 #include "slic3r/GUI/Gizmos/GLGizmoSeam.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoSimplify.hpp"
+#include "slic3r/GUI/Gizmos/GLGizmoMeasure.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoText.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoMeshBoolean.hpp"
 
@@ -195,6 +196,7 @@ bool GLGizmosManager::init()
     m_gizmos.emplace_back(new GLGizmoSeam(m_parent, m_is_dark ? "toolbar_seam_dark.svg" : "toolbar_seam.svg", EType::Seam));
     m_gizmos.emplace_back(new GLGizmoText(m_parent, m_is_dark ? "toolbar_text_dark.svg" : "toolbar_text.svg", EType::Text));
     m_gizmos.emplace_back(new GLGizmoMmuSegmentation(m_parent, m_is_dark ? "mmu_segmentation_dark.svg" : "mmu_segmentation.svg", EType::MmuSegmentation));
+    m_gizmos.emplace_back(new GLGizmoMeasure(m_parent, "measure.svg", EType::Measure));
     m_gizmos.emplace_back(new GLGizmoSimplify(m_parent, "reduce_triangles.svg", EType::Simplify));
     //m_gizmos.emplace_back(new GLGizmoSlaSupports(m_parent, "sla_supports.svg", sprite_id++));
     //m_gizmos.emplace_back(new GLGizmoFaceDetector(m_parent, "face recognition.svg", sprite_id++));
@@ -438,6 +440,8 @@ bool GLGizmosManager::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_p
         return dynamic_cast<GLGizmoMmuSegmentation*>(m_gizmos[MmuSegmentation].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
     else if (m_current == Text)
         return dynamic_cast<GLGizmoText*>(m_gizmos[Text].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
+    else if (m_current == Measure)
+        return dynamic_cast<GLGizmoMeasure*>(m_gizmos[Measure].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
     else if (m_current == Cut)
         return dynamic_cast<GLGizmoAdvancedCut *>(m_gizmos[Cut].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
     else if (m_current == MeshBoolean)
@@ -689,8 +693,10 @@ bool GLGizmosManager::on_char(wxKeyEvent& evt)
         // key ESC
         case WXK_ESCAPE:
         {
-            if (m_current != Undefined)
-            {
+            if (m_current != Undefined) {
+                if (m_current == Measure && gizmo_event(SLAGizmoEventType::Escape)) {
+                    // do nothing
+                } else
                 //if ((m_current != SlaSupports) || !gizmo_event(SLAGizmoEventType::DiscardChanges))
                     reset_all_states();
 
@@ -698,7 +704,14 @@ bool GLGizmosManager::on_char(wxKeyEvent& evt)
             }
             break;
         }
-        //skip some keys when gizmo
+        case WXK_BACK:
+        case WXK_DELETE:
+        {
+            if ((m_current == Cut || m_current == Measure) && gizmo_event(SLAGizmoEventType::Delete))
+                processed = true;
+
+            break;
+        }
         case 'A':
         case 'a':
         {
@@ -827,6 +840,12 @@ bool GLGizmosManager::on_key(wxKeyEvent& evt)
                 processed = true;
             }
         }*/
+		if (m_current == Measure) { 
+            if (keyCode == WXK_CONTROL)
+                gizmo_event(SLAGizmoEventType::CtrlUp, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
+            else if (keyCode == WXK_SHIFT)
+                gizmo_event(SLAGizmoEventType::ShiftUp, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
+        }
 
 //        if (processed)
 //            m_parent.set_cursor(GLCanvas3D::Standard);
@@ -897,6 +916,12 @@ bool GLGizmosManager::on_key(wxKeyEvent& evt)
                 wxGetApp().imgui()->set_requires_extra_frame();
             }
         }
+        else if (m_current == Measure) {
+            if (keyCode == WXK_CONTROL)
+                gizmo_event(SLAGizmoEventType::CtrlDown, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
+            else if (keyCode == WXK_SHIFT)
+                gizmo_event(SLAGizmoEventType::ShiftDown, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
+        }
     }
 
     if (processed)

src/slic3r/GUI/Gizmos/GLGizmosManager.hpp

@@ -88,6 +88,7 @@ public:
         // BBS
         Text,
         MmuSegmentation,
+        Measure,
         Simplify,
         //SlaSupports,
         // BBS