Tech ENABLE_RAYCAST_PICKING - Raytraced picking of gizmos - Move Gizmo

(cherry picked from commit prusa3d/PrusaSlicer@df47ba7122)

src/slic3r/GUI/GLCanvas3D.cpp

@@ -2192,6 +2192,10 @@ void GLCanvas3D::reload_scene(bool refresh_immediately, bool force_full_scene_re
 
     m_hover_volume_idxs.clear();
 
+    GLGizmoBase* curr_gizmo = m_gizmos.get_current();
+    if (curr_gizmo != nullptr)
+        curr_gizmo->unregister_raycasters_for_picking();
+
     struct ModelVolumeState {
         ModelVolumeState(const GLVolume* volume) :
             model_volume(nullptr), geometry_id(volume->geometry_id), volume_idx(-1) {}
@@ -2711,6 +2715,11 @@ void GLCanvas3D::reload_scene(bool refresh_immediately, bool force_full_scene_re
         add_raycaster_for_picking(SceneRaycaster::EType::Volume, i, *m_volumes.volumes[i]->mesh_raycaster, m_volumes.volumes[i]->world_matrix());
     }
 
+    // refresh gizmo elements raycasters for picking
+    m_scene_raycaster.remove_raycasters(SceneRaycaster::EType::Gizmo);
+    if (curr_gizmo != nullptr && !m_selection.is_empty())
+        curr_gizmo->register_raycasters_for_picking();
+
     // and force this canvas to be redrawn.
     m_dirty = true;
 }

src/slic3r/GUI/GLCanvas3D.hpp

@@ -739,6 +739,10 @@ public:
         m_scene_raycaster.remove_raycasters(type);
     }
 
+    void set_raycaster_gizmos_on_top(bool value) {
+        m_scene_raycaster.set_gizmos_on_top(value);
+    }
+
     void reset_explosion_ratio() { m_explosion_ratio = 1.0; }
     void on_change_color_mode(bool is_dark, bool reinit = true);
     const bool get_dark_mode_status() { return m_is_dark; }

src/slic3r/GUI/Gizmos/GLGizmoAdvancedCut.cpp

@@ -485,7 +485,7 @@ void GLGizmoAdvancedCut::on_render()
 
     render_cut_line();
 }
-
+/*
 void GLGizmoAdvancedCut::on_render_for_picking()
 {
     GLGizmoRotate3D::on_render_for_picking();
@@ -545,7 +545,7 @@ void GLGizmoAdvancedCut::on_render_for_picking()
         render_connector_model(m_shapes[connectors[i].attribs], color, model_matrix, true);
     }
 }
-
+*/
 void GLGizmoAdvancedCut::on_render_input_window(float x, float y, float bottom_limit)
 {
     GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 0.0f, 0.0f);
@@ -949,7 +949,7 @@ void GLGizmoAdvancedCut::render_cut_plane_and_grabbers()
         else
             render_color = GrabberColor;
 
-        GLModel &cube = m_move_grabber.get_cube();
+        PickingModel &cube = m_move_grabber.get_cube();
         // BBS set to fixed size grabber
         // float fullsize = 2 * (dragging ? get_dragging_half_size(size) : get_half_size(size));
         float fullsize = 8.0f;
@@ -957,7 +957,7 @@ void GLGizmoAdvancedCut::render_cut_plane_and_grabbers()
             fullsize = m_move_grabber.FixedGrabberSize * GLGizmoBase::INV_ZOOM;
         }
 
-        cube.set_color(render_color);
+        cube.model.set_color(render_color);
 
         const Transform3d trafo_matrix = Geometry::assemble_transform(m_move_grabber.center) * m_rotate_matrix *
                                          Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), fullsize * Vec3d::Ones());
@@ -967,7 +967,7 @@ void GLGizmoAdvancedCut::render_cut_plane_and_grabbers()
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
         const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
         shader->set_uniform("view_normal_matrix", view_normal_matrix);
-        cube.render();
+        cube.model.render();
         shader->stop_using();
     }
 

src/slic3r/GUI/Gizmos/GLGizmoAdvancedCut.hpp

@@ -150,7 +150,6 @@ protected:
     virtual void on_stop_dragging() override;
     virtual void on_update(const UpdateData& data);
     virtual void on_render();
-    virtual void on_render_for_picking();
     virtual void on_render_input_window(float x, float y, float bottom_limit);
 
     void show_tooltip_information(float x, float y);

src/slic3r/GUI/Gizmos/GLGizmoBase.cpp

@@ -69,16 +69,16 @@ void GLGizmoBase::load_render_colors()
     RenderColor::colors[RenderCol_Flatten_Plane_Hover] = ImGuiWrapper::to_ImVec4(GLGizmoBase::FLATTEN_HOVER_COLOR);
 }
 
-GLModel GLGizmoBase::Grabber::s_cube;
+PickingModel GLGizmoBase::Grabber::s_cube;
-GLModel GLGizmoBase::Grabber::s_cone;
+PickingModel GLGizmoBase::Grabber::s_cone;
 
 GLGizmoBase::Grabber::~Grabber()
 {
-    if (s_cube.is_initialized())
+    if (s_cube.model.is_initialized())
-        s_cube.reset();
+        s_cube.model.reset();
 
-    if (s_cone.is_initialized())
+    if (s_cone.model.is_initialized())
-        s_cone.reset();
+        s_cone.model.reset();
 }
 
 float GLGizmoBase::Grabber::get_half_size(float size) const
@@ -91,51 +91,75 @@ float GLGizmoBase::Grabber::get_dragging_half_size(float size) const
     return get_half_size(size) * DraggingScaleFactor;
 }
 
-GLModel& GLGizmoBase::Grabber::get_cube()
+PickingModel &GLGizmoBase::Grabber::get_cube()
 {
-    if (!s_cube.is_initialized()) {
+    if (!s_cube.model.is_initialized()) {
         // This cannot be done in constructor, OpenGL is not yet
         // initialized at that point (on Linux at least).
         indexed_triangle_set its = its_make_cube(1.0, 1.0, 1.0);
         its_translate(its, -0.5f * Vec3f::Ones());
-        s_cube.init_from(its);
+        s_cube.model.init_from(its);
+        s_cube.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
     }
     return s_cube;
 }
 
+void GLGizmoBase::Grabber::register_raycasters_for_picking(int id)
+{
+    picking_id = id;
+    assert(elements_registered_for_picking == false);
+}
+
+void GLGizmoBase::Grabber::unregister_raycasters_for_picking()
+{
+    wxGetApp().plater()->canvas3D()->remove_raycasters_for_picking(SceneRaycaster::EType::Gizmo, picking_id);
+    picking_id = -1;
+    elements_registered_for_picking = false;
+}
+
 void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, bool picking)
 {
     GLShaderProgram* shader = wxGetApp().get_current_shader();
     if (shader == nullptr)
         return;
 
-    if (!s_cube.is_initialized()) {
+    if (!s_cube.model.is_initialized()) {
         // This cannot be done in constructor, OpenGL is not yet
         // initialized at that point (on Linux at least).
         indexed_triangle_set its = its_make_cube(1.0, 1.0, 1.0);
         its_translate(its, -0.5f * Vec3f::Ones());
-        s_cube.init_from(its);
+        s_cube.model.init_from(its);
+        s_cube.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
     }
 
-    if (!s_cone.is_initialized())
+    if (!s_cone.model.is_initialized()) {
-        s_cone.init_from(its_make_cone(1.0, 1.0, double(PI) / 18.0));
+        indexed_triangle_set its = its_make_cone(1.0, 1.0, double(PI) / 18.0);
+        s_cone.model.init_from(its);
+        s_cone.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
+    }
 
     //BBS set to fixed size grabber
     const float  grabber_size   = FixedGrabberSize * INV_ZOOM;
     const double extension_size = 0.75 * FixedGrabberSize * INV_ZOOM;
 
-    s_cube.set_color(render_color);
+    s_cube.model.set_color(render_color);
-    s_cone.set_color(render_color);
+    s_cone.model.set_color(render_color);
 
     const Camera& camera = wxGetApp().plater()->get_camera();
-    const Transform3d& view_matrix = camera.get_view_matrix();
     shader->set_uniform("projection_matrix", camera.get_projection_matrix());
+    const Transform3d& view_matrix = camera.get_view_matrix();
+    const Matrix3d view_matrix_no_offset = view_matrix.matrix().block(0, 0, 3, 3);
 
-    auto render_extension = [&view_matrix, shader](GLModel &model, const Transform3d &model_matrix) {
+    auto render_extension = [&view_matrix, &view_matrix_no_offset, shader, register_for_picking = !elements_registered_for_picking, picking_id = picking_id](PickingModel &model, const Transform3d &model_matrix) {
         shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
-        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        const Matrix3d view_normal_matrix = view_matrix_no_offset * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
         shader->set_uniform("view_normal_matrix", view_normal_matrix);
-        model.render();
+        model.model.render();
+
+        if (register_for_picking) {
+            GLCanvas3D &canvas = *wxGetApp().plater()->canvas3D();
+            canvas.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, picking_id, *model.mesh_raycaster, model_matrix);
+        }
     };
 
     if (extensions == EGrabberExtension::PosZ) {
@@ -166,20 +190,15 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo
             render_extension(s_cone, extension_model_matrix_base * Geometry::assemble_transform(-2.0 * extension_size * Vec3d::UnitZ(), Vec3d(double(PI), 0.0, 0.0), extension_scale));
         }
     }
+
+    elements_registered_for_picking = true;
 }
 
 GLGizmoBase::GLGizmoBase(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
     : m_parent(parent)
-    , m_group_id(-1)
-    , m_state(Off)
-    , m_shortcut_key(0)
     , m_icon_filename(icon_filename)
     , m_sprite_id(sprite_id)
-    , m_hover_id(-1)
-    , m_dragging(false)
     , m_imgui(wxGetApp().imgui())
-    , m_first_input_window_render(true)
-    , m_dirty(false)
 {
     m_base_color = DEFAULT_BASE_COLOR;
     m_drag_color = DEFAULT_DRAG_COLOR;
@@ -280,6 +299,20 @@ void GLGizmoBase::GizmoImguiSetNextWIndowPos(float &x, float y, int flag, float
     m_imgui->set_next_window_pos(x, y, flag, pivot_x, pivot_y);
 }
 
+void GLGizmoBase::register_grabbers_for_picking()
+{
+    for (size_t i = 0; i < m_grabbers.size(); ++i) {
+        m_grabbers[i].register_raycasters_for_picking(i);
+    }
+}
+
+void GLGizmoBase::unregister_grabbers_for_picking()
+{
+    for (size_t i = 0; i < m_grabbers.size(); ++i) {
+        m_grabbers[i].unregister_raycasters_for_picking();
+    }
+}
+
 ColorRGBA GLGizmoBase::picking_color_component(unsigned int id) const
 {
     id = BASE_ID - id;
@@ -312,28 +345,6 @@ void GLGizmoBase::render_grabbers(float size) const
     shader->stop_using();
 }
 
-void GLGizmoBase::render_grabbers_for_picking(const BoundingBoxf3& box) const
-{
-    GLShaderProgram* shader = wxGetApp().get_shader("flat");
-    if (shader != nullptr) {
-        shader->start_using();
-
-#if ENABLE_FIXED_GRABBER
-        const float mean_size = (float)(GLGizmoBase::Grabber::FixedGrabberSize);
-#else
-        const float mean_size = (float)((box.size().x() + box.size().y() + box.size().z()) / 3.0);
-#endif
-
-        for (unsigned int i = 0; i < (unsigned int)m_grabbers.size(); ++i) {
-            if (m_grabbers[i].enabled) {
-                m_grabbers[i].color = picking_color_component(i);
-                m_grabbers[i].render_for_picking(mean_size);
-            }
-        }
-        shader->stop_using();
-    }
-}
-
 std::string GLGizmoBase::format(float value, unsigned int decimals) const
 {
     return Slic3r::string_printf("%.*f", decimals, value);

src/slic3r/GUI/Gizmos/GLGizmoBase.hpp

@@ -6,6 +6,7 @@
 
 #include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/GLModel.hpp"
+#include "slic3r/GUI/MeshUtils.hpp"
 
 #include <cereal/archives/binary.hpp>
 
@@ -83,22 +84,27 @@ protected:
         ColorRGBA color{GRABBER_NORMAL_COL};
         ColorRGBA hover_color{GRABBER_HOVER_COL};
         EGrabberExtension extensions{ EGrabberExtension::None };
+        // the picking id shared by all the elements
+        int picking_id{ -1 };
+        bool elements_registered_for_picking{ false };
 
         Grabber() = default;
         ~Grabber();
 
         void render(bool hover, float size) { render(size, hover ? hover_color : color, false); }
-        void render_for_picking(float size) { render(size, color, true); }
 
         float get_half_size(float size) const;
         float get_dragging_half_size(float size) const;
-        GLModel& get_cube();
+        PickingModel &get_cube();
+
+        void register_raycasters_for_picking(int id);
+        void unregister_raycasters_for_picking();
 
     private:
         void render(float size, const ColorRGBA& render_color, bool picking);
 
-        static GLModel s_cube;
+        static PickingModel s_cube;
-        static GLModel s_cone;
+        static PickingModel s_cone;
     };
 
 public:
@@ -121,21 +127,22 @@ public:
 
 protected:
     GLCanvas3D& m_parent;
-    int m_group_id;
+
-    EState m_state;
+    int m_group_id{ -1 }; // TODO: remove only for rotate
-    int m_shortcut_key;
+    EState m_state{ Off };
+    int m_shortcut_key{ 0 };
     std::string m_icon_filename;
     unsigned int m_sprite_id;
-    int m_hover_id;
+    int m_hover_id{ -1 };
-    bool m_dragging;
+    bool m_dragging{ false };
     ColorRGBA m_base_color;
     ColorRGBA m_drag_color;
     ColorRGBA m_highlight_color;
     mutable std::vector<Grabber> m_grabbers;
     ImGuiWrapper* m_imgui;
-    bool m_first_input_window_render;
+    bool m_first_input_window_render{ true };
     mutable std::string m_tooltip;
-    CommonGizmosDataPool* m_c;
+    CommonGizmosDataPool* m_c{ nullptr };
 
     bool m_is_dark_mode = false;
 
@@ -196,7 +203,6 @@ public:
     bool update_items_state();
 
     void render() { m_tooltip.clear(); on_render(); }
-    void render_for_picking() { on_render_for_picking(); }
     void render_input_window(float x, float y, float bottom_limit);
     virtual void on_change_color_mode(bool is_dark) {  m_is_dark_mode = is_dark; }
 
@@ -205,6 +211,9 @@ public:
     int get_count() { return ++count; }
     std::string get_gizmo_name() { return on_get_name(); }
 
+    void register_raycasters_for_picking()   { register_grabbers_for_picking(); on_register_raycasters_for_picking(); }
+    void unregister_raycasters_for_picking() { unregister_grabbers_for_picking(); on_unregister_raycasters_for_picking(); }
+
 protected:
     float last_input_window_width = 0;
     virtual bool on_init() = 0;
@@ -222,18 +231,22 @@ protected:
     virtual void on_stop_dragging() {}
     virtual void on_update(const UpdateData& data) {}
     virtual void on_render() = 0;
-    virtual void on_render_for_picking() = 0;
     virtual void on_render_input_window(float x, float y, float bottom_limit) {}
 
     bool GizmoImguiBegin(const std::string& name, int flags);
     void GizmoImguiEnd();
     void GizmoImguiSetNextWIndowPos(float &x, float y, int flag, float pivot_x = 0.0f, float pivot_y = 0.0f);
+
+    void register_grabbers_for_picking();
+    void unregister_grabbers_for_picking();
+    virtual void on_register_raycasters_for_picking() {}
+    virtual void on_unregister_raycasters_for_picking() {}
+
     // Returns the picking color for the given id, based on the BASE_ID constant
     // No check is made for clashing with other picking color (i.e. GLVolumes)
     ColorRGBA picking_color_component(unsigned int id) const;
     void render_grabbers(const BoundingBoxf3& box) const;
     void render_grabbers(float size) const;
-    void render_grabbers_for_picking(const BoundingBoxf3& box) const;
 
     std::string format(float value, unsigned int decimals) const;
 
@@ -242,7 +255,7 @@ protected:
 private:
     // Flag for dirty visible state of Gizmo
     // When True then need new rendering
-    bool m_dirty;
+    bool m_dirty{ false };
     int count = 0;
 };
 

src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp

@@ -95,6 +95,7 @@ void GLGizmoFlatten::on_render()
     shader->stop_using();
 }
 
+/*
 void GLGizmoFlatten::on_render_for_picking()
 {
     const Selection& selection = m_parent.get_selection();
@@ -126,6 +127,7 @@ void GLGizmoFlatten::on_render_for_picking()
     glsafe(::glEnable(GL_CULL_FACE));
     shader->stop_using();
 }
+*/
 
 void GLGizmoFlatten::set_flattening_data(const ModelObject* model_object)
 {

src/slic3r/GUI/Gizmos/GLGizmoFlatten.hpp

@@ -54,7 +54,6 @@ protected:
     virtual bool on_is_activable() const override;
     virtual void on_start_dragging() override;
     virtual void on_render() override;
-    virtual void on_render_for_picking() override;
     virtual void on_set_state() override;
     virtual CommonGizmosDataID on_get_requirements() const override;
 };

src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp

@@ -89,18 +89,6 @@ void GLGizmoHollow::on_render()
     glsafe(::glDisable(GL_BLEND));
 }
 
-
-void GLGizmoHollow::on_render_for_picking()
-{
-    const Selection& selection = m_parent.get_selection();
-//#if ENABLE_RENDER_PICKING_PASS
-//    m_z_shift = selection.get_volume(*selection.get_volume_idxs().begin())->get_sla_shift_z();
-//#endif
-
-    glsafe(::glEnable(GL_DEPTH_TEST));
-    render_points(selection, true);
-}
-
 void GLGizmoHollow::render_points(const Selection& selection, bool picking)
 {
     GLShaderProgram* shader = picking ? wxGetApp().get_shader("flat") : wxGetApp().get_shader("gouraud_light");

src/slic3r/GUI/Gizmos/GLGizmoHollow.hpp

@@ -40,7 +40,6 @@ private:
     bool on_init() override;
     void on_update(const UpdateData& data) override;
     void on_render() override;
-    void on_render_for_picking() override;
 
     void render_points(const Selection& selection, bool picking = false);
     void hollow_mesh(bool postpone_error_messages = false);

src/slic3r/GUI/Gizmos/GLGizmoMeshBoolean.hpp

@@ -62,7 +62,6 @@ protected:
     virtual std::string on_get_name() const override;
     virtual bool on_is_activable() const override;
     virtual void on_render() override;
-    virtual void on_render_for_picking() override {}
     virtual void on_set_state() override;
     virtual CommonGizmosDataID on_get_requirements() const override;
     virtual void on_render_input_window(float x, float y, float bottom_limit);

src/slic3r/GUI/Gizmos/GLGizmoMove.cpp

@@ -182,12 +182,15 @@ void GLGizmoMove3D::on_render()
     render_grabbers(box);
 }
 
-void GLGizmoMove3D::on_render_for_picking()
+void GLGizmoMove3D::on_register_raycasters_for_picking()
 {
-    glsafe(::glDisable(GL_DEPTH_TEST));
+    // this gizmo is rendered on top of the scene, so the raytraced picker should take it into account
+    m_parent.set_raycaster_gizmos_on_top(true);
+}
 
-    const BoundingBoxf3& box = m_parent.get_selection().get_bounding_box();
+void GLGizmoMove3D::on_unregister_raycasters_for_picking()
-    render_grabbers_for_picking(box);
+{
+    m_parent.set_raycaster_gizmos_on_top(false);
 }
 
 //BBS: add input window for move

src/slic3r/GUI/Gizmos/GLGizmoMove.hpp

@@ -52,7 +52,8 @@ protected:
     virtual void on_stop_dragging() override;
     virtual void on_update(const UpdateData& data) override;
     virtual void on_render() override;
-    virtual void on_render_for_picking() override;
+    virtual void on_register_raycasters_for_picking() override;
+    virtual void on_unregister_raycasters_for_picking() override;
     //BBS: GUI refactor: add object manipulation
     virtual void on_render_input_window(float x, float y, float bottom_limit);
 

src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp

@@ -185,7 +185,6 @@ private:
     ObjectID m_old_mo_id;
     size_t m_old_volumes_size = 0;
     void on_render() override {}
-    void on_render_for_picking() override {}
 public:
     GLGizmoPainterBase(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
     virtual ~GLGizmoPainterBase() override;

src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp

@@ -161,18 +161,6 @@ void GLGizmoRotate::on_render()
     render_grabber(box);
 }
 
-void GLGizmoRotate::on_render_for_picking()
-{
-    const Selection& selection = m_parent.get_selection();
-
-    glsafe(::glDisable(GL_DEPTH_TEST));
-
-    m_grabbers.front().matrix = local_transform(selection);
-
-    const BoundingBoxf3& box = selection.get_bounding_box();
-    render_grabbers_for_picking(box);
-}
-
 //BBS: add input window for move
 void GLGizmoRotate3D::on_render_input_window(float x, float y, float bottom_limit)
 {

src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp

@@ -72,7 +72,6 @@ protected:
     void on_start_dragging() override;
     void on_update(const UpdateData& data) override;
     void on_render() override;
-    void on_render_for_picking() override;
 
 private:
     void render_circle(const ColorRGBA& color, bool radius_changed);
@@ -150,11 +149,6 @@ protected:
         }
     }
     void on_render() override;
-    void on_render_for_picking() override {
-        for (GLGizmoRotate& g : m_gizmos) {
-            g.render_for_picking();
-        }
-    }
 
     void on_render_input_window(float x, float y, float bottom_limit) override;
 

src/slic3r/GUI/Gizmos/GLGizmoScale.cpp

@@ -255,12 +255,6 @@ void GLGizmoScale3D::on_render()
     render_grabbers(grabber_mean_size);
 }
 
-void GLGizmoScale3D::on_render_for_picking()
-{
-    glsafe(::glDisable(GL_DEPTH_TEST));
-    render_grabbers_for_picking(m_parent.get_selection().get_bounding_box());
-}
-
 void GLGizmoScale3D::render_grabbers_connection(unsigned int id_1, unsigned int id_2, const ColorRGBA& color)
 {
     auto grabber_connection = [this](unsigned int id_1, unsigned int id_2) {

src/slic3r/GUI/Gizmos/GLGizmoScale.hpp

@@ -72,7 +72,6 @@ protected:
     virtual void on_start_dragging() override;
     virtual void on_update(const UpdateData& data) override;
     virtual void on_render() override;
-    virtual void on_render_for_picking() override;
     //BBS: GUI refactor: add object manipulation
     virtual void on_render_input_window(float x, float y, float bottom_limit);
 

src/slic3r/GUI/Gizmos/GLGizmoSimplify.hpp

@@ -37,7 +37,6 @@ protected:
     // must implement
     virtual bool on_init() override { return true;};
     virtual void on_render() override;
-    virtual void on_render_for_picking() override{};    
 
     CommonGizmosDataID on_get_requirements() const override;
 

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp

@@ -108,14 +108,6 @@ void GLGizmoSlaSupports::on_render()
     glsafe(::glDisable(GL_BLEND));
 }
 
-
-void GLGizmoSlaSupports::on_render_for_picking()
-{
-    const Selection& selection = m_parent.get_selection();
-    //glsafe(::glEnable(GL_DEPTH_TEST));
-    render_points(selection, true);
-}
-
 void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
 {
     const size_t cache_size = m_editing_mode ? m_editing_cache.size() : m_normal_cache.size();

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp

@@ -75,7 +75,6 @@ private:
     bool on_init() override;
     void on_update(const UpdateData& data) override;
     void on_render() override;
-    void on_render_for_picking() override;
 
     void render_points(const Selection& selection, bool picking = false);
     bool unsaved_changes() const;

src/slic3r/GUI/Gizmos/GLGizmoText.cpp

@@ -451,7 +451,7 @@ void GLGizmoText::on_render()
         GLShaderProgram *shader    = wxGetApp().get_shader("gouraud_light");
         if (shader != nullptr) {
             shader->start_using();
-            m_grabbers[0].render_for_picking(mean_size);
+            //m_grabbers[0].render_for_picking(mean_size);
 
             shader->stop_using();
         }
@@ -466,6 +466,7 @@ void GLGizmoText::on_render()
     plater->update();
 }
 
+/*
 void GLGizmoText::on_render_for_picking()
 {
     glsafe(::glDisable(GL_DEPTH_TEST));
@@ -510,6 +511,7 @@ void GLGizmoText::on_render_for_picking()
         }
     }
 }
+*/
 
 void GLGizmoText::on_update(const UpdateData &data)
 {

src/slic3r/GUI/Gizmos/GLGizmoText.hpp

@@ -91,7 +91,6 @@ protected:
     virtual std::string on_get_name() const override;
     virtual bool on_is_activable() const override;
     virtual void on_render() override;
-    virtual void on_render_for_picking() override;
     virtual void on_update(const UpdateData &data) override;
     void push_combo_style(const float scale);
     void pop_combo_style();

src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp

@@ -80,7 +80,7 @@ enum class CommonGizmosDataID {
 // by GLGizmoManager, the gizmos keep a pointer to it.
 class CommonGizmosDataPool {
 public:
-    CommonGizmosDataPool(GLCanvas3D* canvas);
+    explicit CommonGizmosDataPool(GLCanvas3D* canvas);
 
     // Update all resources and release what is not used.
     // Accepts a bitmask of currently required resources.

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -713,15 +713,6 @@ void GLGizmosManager::render_painter_assemble_view() const
         m_assemble_view_data->model_objects_clipper()->render_cut();
 }
 
-void GLGizmosManager::render_current_gizmo_for_picking_pass() const
-{
-    if (! m_enabled || m_current == Undefined)
-
-        return;
-
-    m_gizmos[m_current]->render_for_picking();
-}
-
 void GLGizmosManager::render_overlay()
 {
     if (!m_enabled)
@@ -1594,7 +1585,6 @@ bool GLGizmosManager::activate_gizmo(EType type)
         return true;
 
     GLGizmoBase* old_gizmo = m_current == Undefined ? nullptr : m_gizmos[m_current].get();
-    GLGizmoBase* new_gizmo = type == Undefined ? nullptr : m_gizmos[type].get();
 
     if (old_gizmo) {
         //if (m_current == Text) {
@@ -1604,6 +1594,8 @@ bool GLGizmosManager::activate_gizmo(EType type)
         if (old_gizmo->get_state() != GLGizmoBase::Off)
             return false; // gizmo refused to be turned off, do nothing.
 
+        old_gizmo->unregister_raycasters_for_picking();
+
         if (! m_parent.get_gizmos_manager().is_serializing()
          && old_gizmo->wants_enter_leave_snapshots())
             Plater::TakeSnapshot snapshot(wxGetApp().plater(),
@@ -1611,7 +1603,16 @@ bool GLGizmosManager::activate_gizmo(EType type)
                 UndoRedo::SnapshotType::LeavingGizmoWithAction);
     }
 
-    if (new_gizmo && ! m_parent.get_gizmos_manager().is_serializing()
+    if (type == Undefined) { 
+        // it is deactivation of gizmo
+        m_current = Undefined;
+        return true;
+    }
+
+    // set up new gizmo
+    GLGizmoBase* new_gizmo = type == Undefined ? nullptr : m_gizmos[type].get();
+
+	if (new_gizmo && ! m_parent.get_gizmos_manager().is_serializing()
      && new_gizmo->wants_enter_leave_snapshots())
         Plater::TakeSnapshot snapshot(wxGetApp().plater(),
             new_gizmo->get_gizmo_entering_text(),
@@ -1619,12 +1620,14 @@ bool GLGizmosManager::activate_gizmo(EType type)
 
     m_current = type;
 
-    if (new_gizmo) {
+    //if (m_current == Text) {
-        //if (m_current == Text) {
+    //    wxGetApp().imgui()->load_fonts_texture();
-        //    wxGetApp().imgui()->load_fonts_texture();
+    //}
-        //}
+    new_gizmo->set_state(GLGizmoBase::On);
-        new_gizmo->set_state(GLGizmoBase::On);
+
-    }
+    new_gizmo->register_raycasters_for_picking();
+
+    // sucessful activation of gizmo
     return true;
 }
 

src/slic3r/GUI/Gizmos/GLGizmosManager.hpp

@@ -294,7 +294,6 @@ public:
 
     void on_change_color_mode(bool is_dark);
     void render_current_gizmo() const;
-    void render_current_gizmo_for_picking_pass() const;
     void render_painter_gizmo();
     void render_painter_assemble_view() const;