Tech ENABLE_RAYCAST_PICKING - Raytraced picking of Gizmo SLA Supports

src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp

@@ -111,10 +111,10 @@ void GLGizmoHollow::on_render()
 void GLGizmoHollow::on_register_raycasters_for_picking()
 {
     assert(m_raycasters.empty());
-
     set_sla_auxiliary_volumes_picking_state(false);
+
     const CommonGizmosDataObjects::SelectionInfo* info = m_c->selection_info();
-    if (info != nullptr && info->model_object()->sla_drain_holes.size() > 0) {
+    if (info != nullptr && !info->model_object()->sla_drain_holes.empty()) {
         const sla::DrainHoles& drain_holes = info->model_object()->sla_drain_holes;
         for (int i = 0; i < (int)drain_holes.size(); ++i) {
             m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, i, *m_cylinder.mesh_raycaster, Transform3d::Identity()));
@@ -167,7 +167,7 @@ void GLGizmoHollow::render_points(const Selection& selection, bool picking)
 #endif // ENABLE_LEGACY_OPENGL_REMOVAL
 
     const GLVolume* vol = selection.get_first_volume();
-    Geometry::Transformation trafo =  vol->get_instance_transformation() * vol->get_volume_transformation();
+    const Transform3d trafo = vol->world_matrix();
 
 #if ENABLE_LEGACY_OPENGL_REMOVAL
 #if ENABLE_WORLD_COORDINATE
@@ -175,13 +175,9 @@ void GLGizmoHollow::render_points(const Selection& selection, bool picking)
 #else
     const Transform3d instance_scaling_matrix_inverse = vol->get_instance_transformation().get_matrix(true, true, false, true).inverse();
 #endif // ENABLE_WORLD_COORDINATE
-    const Transform3d instance_matrix = Geometry::translation_transform(m_c->selection_info()->get_sla_shift() * Vec3d::UnitZ()) * trafo.get_matrix();
-
     const Camera& camera = wxGetApp().plater()->get_camera();
     const Transform3d& view_matrix = camera.get_view_matrix();
-    const Transform3d& projection_matrix = camera.get_projection_matrix();
+    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-
-    shader->set_uniform("projection_matrix", projection_matrix);
 #else
     const Transform3d& instance_scaling_matrix_inverse = trafo.get_matrix(true, true, false, true).inverse();
     const Transform3d& instance_matrix = trafo.get_matrix();
@@ -235,7 +231,7 @@ void GLGizmoHollow::render_points(const Selection& selection, bool picking)
         m_cylinder.set_color(render_color);
 #endif // ENABLE_RAYCAST_PICKING
         // Inverse matrix of the instance scaling is applied so that the mark does not scale with the object.
-        const Transform3d hole_matrix = Geometry::assemble_transform(drain_hole.pos.cast<double>()) * instance_scaling_matrix_inverse;
+        const Transform3d hole_matrix = Geometry::translation_transform(drain_hole.pos.cast<double>()) * instance_scaling_matrix_inverse;
 #else
         const_cast<GLModel*>(&m_cylinder)->set_color(-1, render_color);
         // Inverse matrix of the instance scaling is applied so that the mark does not scale with the object.
@@ -252,8 +248,8 @@ void GLGizmoHollow::render_points(const Selection& selection, bool picking)
         q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * (-drain_hole.normal).cast<double>());
         const Eigen::AngleAxisd aa(q);
 #if ENABLE_LEGACY_OPENGL_REMOVAL
-        const Transform3d model_matrix = instance_matrix * hole_matrix * Transform3d(aa.toRotationMatrix()) *
+        const Transform3d model_matrix = trafo * hole_matrix * Transform3d(aa.toRotationMatrix()) *
-            Geometry::assemble_transform(-drain_hole.height * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(drain_hole.radius, drain_hole.radius, drain_hole.height + sla::HoleStickOutLength));
+            Geometry::translation_transform(-drain_hole.height * Vec3d::UnitZ()) * Geometry::scale_transform(Vec3d(drain_hole.radius, drain_hole.radius, drain_hole.height + sla::HoleStickOutLength));
         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();
         shader->set_uniform("view_normal_matrix", view_normal_matrix);
@@ -385,7 +381,7 @@ bool GLGizmoHollow::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_pos
         if (m_selection_empty) {
             std::pair<Vec3f, Vec3f> pos_and_normal;
             if (unproject_on_mesh(mouse_position, pos_and_normal)) { // we got an intersection
-                Plater::TakeSnapshot snapshot(wxGetApp().plater(), _(L("Add drainage hole")));
+                Plater::TakeSnapshot snapshot(wxGetApp().plater(), _L("Add drainage hole"));
 
                 mo->sla_drain_holes.emplace_back(pos_and_normal.first,
                                                 -pos_and_normal.second, m_new_hole_radius, m_new_hole_height);
@@ -618,6 +614,8 @@ void GLGizmoHollow::update_raycasters_for_picking_transform()
     if (info != nullptr) {
         const sla::DrainHoles& drain_holes = info->model_object()->sla_drain_holes;
         if (!drain_holes.empty()) {
+            assert(!m_raycasters.empty());
+
             const GLVolume* vol = m_parent.get_selection().get_first_volume();
             const Transform3d instance_scaling_matrix_inverse = vol->get_instance_transformation().get_scaling_factor_matrix().inverse();
 

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp

@@ -22,6 +22,10 @@
 #include "libslic3r/PresetBundle.hpp"
 #include "libslic3r/SLAPrint.hpp"
 
+#if ENABLE_RAYCAST_PICKING
+static const double CONE_RADIUS = 0.25;
+static const double CONE_HEIGHT = 0.75;
+#endif // ENABLE_RAYCAST_PICKING
 
 namespace Slic3r {
 namespace GUI {
@@ -47,9 +51,11 @@ bool GLGizmoSlaSupports::on_init()
     m_desc["clipping_of_view"] = _L("Clipping of view")+ ": ";
     m_desc["reset_direction"]  = _L("Reset direction");
         
+#if !ENABLE_RAYCAST_PICKING
     m_cone.init_from(its_make_cone(1., 1., 2 * PI / 24));
     m_cylinder.init_from(its_make_cylinder(1., 1., 2 * PI / 24.));
     m_sphere.init_from(its_make_sphere(1., (2 * M_PI) / 24.));
+#endif // !ENABLE_RAYCAST_PICKING
 
     return true;
 }
@@ -73,16 +79,36 @@ void GLGizmoSlaSupports::data_changed()
         if (mo->sla_points_status == sla::PointsStatus::Generating)
             get_data_from_backend();
     }
+
+#if ENABLE_RAYCAST_PICKING
+    if (m_raycasters.empty())
+        on_register_raycasters_for_picking();
+    else
+        update_raycasters_for_picking_transform();
+#endif // ENABLE_RAYCAST_PICKING
 }
 
 
 
 void GLGizmoSlaSupports::on_render()
 {
+#if ENABLE_RAYCAST_PICKING
+    if (!m_sphere.model.is_initialized()) {
+        indexed_triangle_set its = its_make_sphere(1.0, double(PI) / 12.0);
+        m_sphere.model.init_from(its);
+        m_sphere.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
+    }
+    if (!m_cone.model.is_initialized()) {
+        indexed_triangle_set its = its_make_cone(1.0, 1.0, double(PI) / 12.0);
+        m_cone.model.init_from(its);
+        m_cone.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
+    }
+#else
     if (!m_cone.is_initialized())
         m_cone.init_from(its_make_cone(1.0, 1.0, double(PI) / 12.0));
     if (!m_sphere.is_initialized())
         m_sphere.init_from(its_make_sphere(1.0, double(PI) / 12.0));
+#endif // ENABLE_RAYCAST_PICKING
     if (!m_cylinder.is_initialized())
         m_cylinder.init_from(its_make_cylinder(1.0, 1.0, double(PI) / 12.0));
 
@@ -101,7 +127,11 @@ void GLGizmoSlaSupports::on_render()
     glsafe(::glEnable(GL_DEPTH_TEST));
 
     if (selection.is_from_single_instance())
+#if ENABLE_RAYCAST_PICKING
+        render_points(selection);
+#else
         render_points(selection, false);
+#endif // ENABLE_RAYCAST_PICKING
 
     m_selection_rectangle.render(m_parent);
     m_c->object_clipper()->render_cut();
@@ -110,17 +140,41 @@ void GLGizmoSlaSupports::on_render()
     glsafe(::glDisable(GL_BLEND));
 }
 
+#if ENABLE_RAYCAST_PICKING
+void GLGizmoSlaSupports::on_register_raycasters_for_picking()
+{
+    assert(m_raycasters.empty());
+    set_sla_auxiliary_volumes_picking_state(false);
 
-#if !ENABLE_RAYCAST_PICKING
+    if (m_editing_mode && !m_editing_cache.empty()) {
+        for (size_t i = 0; i < m_editing_cache.size(); ++i) {
+            m_raycasters.emplace_back(m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, i, *m_sphere.mesh_raycaster, Transform3d::Identity()),
+                m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, i, *m_cone.mesh_raycaster, Transform3d::Identity()));
+        }
+        update_raycasters_for_picking_transform();
+    }
+}
+
+void GLGizmoSlaSupports::on_unregister_raycasters_for_picking()
+{
+    m_parent.remove_raycasters_for_picking(SceneRaycaster::EType::Gizmo);
+    m_raycasters.clear();
+    set_sla_auxiliary_volumes_picking_state(true);
+}
+#else
 void GLGizmoSlaSupports::on_render_for_picking()
 {
     const Selection& selection = m_parent.get_selection();
     //glsafe(::glEnable(GL_DEPTH_TEST));
     render_points(selection, true);
 }
-#endif // !ENABLE_RAYCAST_PICKING
+#endif // ENABLE_RAYCAST_PICKING
 
+#if ENABLE_RAYCAST_PICKING
+void GLGizmoSlaSupports::render_points(const Selection& selection)
+#else
 void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
+#endif // ENABLE_RAYCAST_PICKING
 {
     const size_t cache_size = m_editing_mode ? m_editing_cache.size() : m_normal_cache.size();
 
@@ -132,7 +186,11 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
         return;
 
 #if ENABLE_LEGACY_OPENGL_REMOVAL
+#if ENABLE_RAYCAST_PICKING
+    GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
+#else
     GLShaderProgram* shader = wxGetApp().get_shader(picking ? "flat" : "gouraud_light");
+#endif // ENABLE_RAYCAST_PICKING
     if (shader == nullptr)
         return;
 
@@ -149,19 +207,16 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
 #endif // ENABLE_LEGACY_OPENGL_REMOVAL
 
     const GLVolume* vol = selection.get_first_volume();
-    Geometry::Transformation transformation(vol->get_instance_transformation().get_matrix() * vol->get_volume_transformation().get_matrix());
+    const Geometry::Transformation transformation(vol->world_matrix());
 #if ENABLE_WORLD_COORDINATE
     const Transform3d instance_scaling_matrix_inverse = transformation.get_scaling_factor_matrix().inverse();
 #else
     const Transform3d& instance_scaling_matrix_inverse = transformation.get_matrix(true, true, false, true).inverse();
 #endif // ENABLE_WORLD_COORDINATE
 #if ENABLE_LEGACY_OPENGL_REMOVAL
-    const Transform3d instance_matrix = Geometry::assemble_transform(m_c->selection_info()->get_sla_shift() * Vec3d::UnitZ()) * transformation.get_matrix();
     const Camera& camera = wxGetApp().plater()->get_camera();
     const Transform3d& view_matrix = camera.get_view_matrix();
-    const Transform3d& projection_matrix = camera.get_projection_matrix();
+    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-
-    shader->set_uniform("projection_matrix", projection_matrix);
 #else
     const Transform3d& instance_matrix = transformation.get_matrix();
     const float z_shift = m_c->selection_info()->get_sla_shift();
@@ -175,13 +230,25 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
         const sla::SupportPoint& support_point = m_editing_mode ? m_editing_cache[i].support_point : m_normal_cache[i];
         const bool point_selected = m_editing_mode ? m_editing_cache[i].selected : false;
 
+#if ENABLE_RAYCAST_PICKING
+        const bool clipped = is_mesh_point_clipped(support_point.pos.cast<double>());
+        if (!m_raycasters.empty()) {
+            m_raycasters[i].first->set_active(!clipped);
+            m_raycasters[i].second->set_active(!clipped);
+        }
+        if (clipped)
+            continue;
+#else
         if (is_mesh_point_clipped(support_point.pos.cast<double>()))
             continue;
+#endif // ENABLE_RAYCAST_PICKING
 
         // First decide about the color of the point.
+#if !ENABLE_RAYCAST_PICKING
         if (picking)
             render_color = picking_color_component(i);
         else {
+#endif // !ENABLE_RAYCAST_PICKING
             if (size_t(m_hover_id) == i && m_editing_mode) // ignore hover state unless editing mode is active
                 render_color = { 0.f, 1.f, 1.f, 1.f };
             else { // neigher hover nor picking
@@ -198,12 +265,21 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
                 else
                     render_color = { 0.5f, 0.5f, 0.5f, 1.f };
             }
+#if !ENABLE_RAYCAST_PICKING
         }
+#endif // !ENABLE_RAYCAST_PICKING
 
 #if ENABLE_LEGACY_OPENGL_REMOVAL
+#if ENABLE_RAYCAST_PICKING
+        m_cone.model.set_color(render_color);
+        m_sphere.model.set_color(render_color);
+#else
         m_cone.set_color(render_color);
         m_sphere.set_color(render_color);
+#endif // ENABLE_RAYCAST_PICKING
+#if !ENABLE_RAYCAST_PICKING
         if (!picking)
+#endif // !ENABLE_RAYCAST_PICKING
 #else
         m_cone.set_color(-1, render_color);
         m_sphere.set_color(-1, render_color);
@@ -213,7 +289,7 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
 
         // Inverse matrix of the instance scaling is applied so that the mark does not scale with the object.
 #if ENABLE_LEGACY_OPENGL_REMOVAL
-        const Transform3d support_matrix = Geometry::assemble_transform(support_point.pos.cast<double>()) * instance_scaling_matrix_inverse;
+        const Transform3d support_matrix = Geometry::translation_transform(support_point.pos.cast<double>()) * instance_scaling_matrix_inverse;
 #else
         glsafe(::glPushMatrix());
         glsafe(::glTranslatef(support_point.pos.x(), support_point.pos.y(), support_point.pos.z()));
@@ -233,12 +309,19 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
             Eigen::Quaterniond q;
             q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * m_editing_cache[i].normal.cast<double>());
             const Eigen::AngleAxisd aa(q);
+#if !ENABLE_RAYCAST_PICKING
             const double cone_radius = 0.25; // mm
             const double cone_height = 0.75;
+#endif // !ENABLE_RAYCAST_PICKING
 #if ENABLE_LEGACY_OPENGL_REMOVAL
-            const Transform3d model_matrix = instance_matrix * support_matrix * Transform3d(aa.toRotationMatrix()) *
+            const Transform3d model_matrix = vol->world_matrix() * support_matrix * Transform3d(aa.toRotationMatrix()) *
+#if ENABLE_RAYCAST_PICKING
+                Geometry::assemble_transform((CONE_HEIGHT + support_point.head_front_radius * RenderPointScale) * Vec3d::UnitZ(),
+                    Vec3d(PI, 0.0, 0.0), Vec3d(CONE_RADIUS, CONE_RADIUS, CONE_HEIGHT));
+#else
                 Geometry::assemble_transform((cone_height + support_point.head_front_radius * RenderPointScale) * Vec3d::UnitZ(),
                     Vec3d(PI, 0.0, 0.0), Vec3d(cone_radius, cone_radius, cone_height));
+#endif // ENABLE_RAYCAST_PICKING
 
             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();
@@ -250,7 +333,11 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
             glsafe(::glRotated(180., 1., 0., 0.));
             glsafe(::glScaled(cone_radius, cone_radius, cone_height));
 #endif // ENABLE_LEGACY_OPENGL_REMOVAL
+#if ENABLE_RAYCAST_PICKING
+            m_cone.model.render();
+#else
             m_cone.render();
+#endif // ENABLE_RAYCAST_PICKING
 #if !ENABLE_LEGACY_OPENGL_REMOVAL
             glsafe(::glPopMatrix());
 #endif // !ENABLE_LEGACY_OPENGL_REMOVAL
@@ -258,9 +345,7 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
 
         const double radius = (double)support_point.head_front_radius * RenderPointScale;
 #if ENABLE_LEGACY_OPENGL_REMOVAL
-        const Transform3d model_matrix = instance_matrix * support_matrix *
+        const Transform3d model_matrix = vol->world_matrix() * support_matrix * Geometry::scale_transform(radius);
-            Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), radius * Vec3d::Ones());
-
         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();
         shader->set_uniform("view_normal_matrix", view_normal_matrix);
@@ -268,7 +353,11 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
         glsafe(::glPushMatrix());
         glsafe(::glScaled(radius, radius, radius));
 #endif // ENABLE_LEGACY_OPENGL_REMOVAL
+#if ENABLE_RAYCAST_PICKING
+        m_sphere.model.render();
+#else
         m_sphere.render();
+#endif // ENABLE_RAYCAST_PICKING
 #if !ENABLE_LEGACY_OPENGL_REMOVAL
         glsafe(::glPopMatrix());
 #endif // !ENABLE_LEGACY_OPENGL_REMOVAL
@@ -282,7 +371,11 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
     }
 
     // Now render the drain holes:
+#if ENABLE_RAYCAST_PICKING
+    if (has_holes) {
+#else
     if (has_holes && ! picking) {
+#endif // ENABLE_RAYCAST_PICKING
         render_color = { 0.7f, 0.7f, 0.7f, 0.7f };
 #if ENABLE_LEGACY_OPENGL_REMOVAL
         m_cylinder.set_color(render_color);
@@ -296,7 +389,7 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
                 continue;
 
 #if ENABLE_LEGACY_OPENGL_REMOVAL
-            const Transform3d hole_matrix = Geometry::assemble_transform(drain_hole.pos.cast<double>()) * instance_scaling_matrix_inverse;
+            const Transform3d hole_matrix = Geometry::translation_transform(drain_hole.pos.cast<double>()) * instance_scaling_matrix_inverse;
 #else
             // Inverse matrix of the instance scaling is applied so that the mark does not scale with the object.
             glsafe(::glPushMatrix());
@@ -312,9 +405,8 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
             q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * (-drain_hole.normal).cast<double>());
             const Eigen::AngleAxisd aa(q);
 #if ENABLE_LEGACY_OPENGL_REMOVAL
-            const Transform3d model_matrix = instance_matrix * hole_matrix * Transform3d(aa.toRotationMatrix()) *
+            const Transform3d model_matrix = vol->world_matrix() * hole_matrix * Transform3d(aa.toRotationMatrix()) *
-                Geometry::assemble_transform(-drain_hole.height * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(drain_hole.radius, drain_hole.radius, drain_hole.height + sla::HoleStickOutLength));
+                Geometry::translation_transform(-drain_hole.height * Vec3d::UnitZ()) * Geometry::scale_transform(Vec3d(drain_hole.radius, drain_hole.radius, drain_hole.height + sla::HoleStickOutLength));
-
             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();
             shader->set_uniform("view_normal_matrix", view_normal_matrix);
@@ -452,6 +544,10 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
                     m_editing_cache.emplace_back(sla::SupportPoint(pos_and_normal.first, m_new_point_head_diameter/2.f, false), false, pos_and_normal.second);
                     m_parent.set_as_dirty();
                     m_wait_for_up_event = true;
+#if ENABLE_RAYCAST_PICKING
+                    on_unregister_raycasters_for_picking();
+                    on_register_raycasters_for_picking();
+#endif // ENABLE_RAYCAST_PICKING
                 }
                 else
                     return false;
@@ -606,6 +702,11 @@ void GLGizmoSlaSupports::delete_selected_points(bool force)
         }
     }
 
+#if ENABLE_RAYCAST_PICKING
+    on_unregister_raycasters_for_picking();
+    on_register_raycasters_for_picking();
+#endif // ENABLE_RAYCAST_PICKING
+
     select_point(NoPoints);
 }
 
@@ -1283,6 +1384,9 @@ void GLGizmoSlaSupports::switch_to_editing_mode()
     for (const sla::SupportPoint& sp : m_normal_cache)
         m_editing_cache.emplace_back(sp);
     select_point(NoPoints);
+#if ENABLE_RAYCAST_PICKING
+    on_register_raycasters_for_picking();
+#endif // ENABLE_RAYCAST_PICKING
 
     m_c->instances_hider()->show_supports(false);
     m_parent.set_as_dirty();
@@ -1296,6 +1400,9 @@ void GLGizmoSlaSupports::disable_editing_mode()
         wxGetApp().plater()->leave_gizmos_stack();
         m_c->instances_hider()->show_supports(true);
         m_parent.set_as_dirty();
+#if ENABLE_RAYCAST_PICKING
+        on_unregister_raycasters_for_picking();
+#endif // ENABLE_RAYCAST_PICKING
     }
     wxGetApp().plater()->get_notification_manager()->close_notification_of_type(NotificationType::QuitSLAManualMode);
 }
@@ -1314,6 +1421,54 @@ bool GLGizmoSlaSupports::unsaved_changes() const
     return false;
 }
 
+#if ENABLE_RAYCAST_PICKING
+void GLGizmoSlaSupports::set_sla_auxiliary_volumes_picking_state(bool state)
+{
+    std::vector<std::shared_ptr<SceneRaycasterItem>>* raycasters = m_parent.get_raycasters_for_picking(SceneRaycaster::EType::Volume);
+    if (raycasters != nullptr) {
+        const Selection& selection = m_parent.get_selection();
+        const Selection::IndicesList ids = selection.get_volume_idxs();
+        for (unsigned int id : ids) {
+            const GLVolume* v = selection.get_volume(id);
+            if (v->is_sla_pad() || v->is_sla_support()) {
+                auto it = std::find_if(raycasters->begin(), raycasters->end(), [v](std::shared_ptr<SceneRaycasterItem> item) { return item->get_raycaster() == v->mesh_raycaster.get(); });
+                if (it != raycasters->end())
+                    (*it)->set_active(state);
+            }
+        }
+    }
+}
+
+void GLGizmoSlaSupports::update_raycasters_for_picking_transform()
+{
+    if (!m_editing_cache.empty()) {
+        assert(!m_raycasters.empty());
+
+        const GLVolume* vol = m_parent.get_selection().get_first_volume();
+        const Geometry::Transformation transformation(vol->world_matrix());
+        const Transform3d instance_scaling_matrix_inverse = transformation.get_scaling_factor_matrix().inverse();
+        for (size_t i = 0; i < m_editing_cache.size(); ++i) {
+            const Transform3d support_matrix = Geometry::translation_transform(m_editing_cache[i].support_point.pos.cast<double>()) * instance_scaling_matrix_inverse;
+
+            if (m_editing_cache[i].normal == Vec3f::Zero())
+                m_c->raycaster()->raycaster()->get_closest_point(m_editing_cache[i].support_point.pos, &m_editing_cache[i].normal);
+
+            Eigen::Quaterniond q;
+            q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * m_editing_cache[i].normal.cast<double>());
+            const Eigen::AngleAxisd aa(q);
+            const Transform3d cone_matrix = vol->world_matrix() * support_matrix * Transform3d(aa.toRotationMatrix()) *
+                Geometry::assemble_transform((CONE_HEIGHT + m_editing_cache[i].support_point.head_front_radius * RenderPointScale) * Vec3d::UnitZ(),
+                    Vec3d(PI, 0.0, 0.0), Vec3d(CONE_RADIUS, CONE_RADIUS, CONE_HEIGHT));
+                m_raycasters[i].second->set_transform(cone_matrix);
+
+            const double radius = (double)m_editing_cache[i].support_point.head_front_radius * RenderPointScale;
+            const Transform3d sphere_matrix = vol->world_matrix() * support_matrix * Geometry::scale_transform(radius);
+            m_raycasters[i].first->set_transform(sphere_matrix);
+        }
+    }
+}
+#endif // ENABLE_RAYCAST_PICKING
+
 SlaGizmoHelpDialog::SlaGizmoHelpDialog()
 : wxDialog(nullptr, wxID_ANY, _L("SLA gizmo keyboard shortcuts"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER)
 {

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp

@@ -77,15 +77,27 @@ public:
     /// <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;
+
 private:
     bool on_init() override;
     void on_render() override;
-#if !ENABLE_RAYCAST_PICKING
+#if ENABLE_RAYCAST_PICKING
+    virtual void on_register_raycasters_for_picking() override;
+    virtual void on_unregister_raycasters_for_picking() override;
+#else
     void on_render_for_picking() override;
-#endif // !ENABLE_RAYCAST_PICKING
+#endif // ENABLE_RAYCAST_PICKING
 
+#if ENABLE_RAYCAST_PICKING
+    void render_points(const Selection& selection);
+#else
     void render_points(const Selection& selection, bool picking = false);
+#endif // ENABLE_RAYCAST_PICKING
     bool unsaved_changes() const;
+#if ENABLE_RAYCAST_PICKING
+    void set_sla_auxiliary_volumes_picking_state(bool state);
+    void update_raycasters_for_picking_transform();
+#endif // ENABLE_RAYCAST_PICKING
 
     bool m_lock_unique_islands = false;
     bool m_editing_mode = false;            // Is editing mode active?
@@ -98,9 +110,15 @@ private:
     std::vector<sla::SupportPoint> m_normal_cache; // to restore after discarding changes or undo/redo
     ObjectID m_old_mo_id;
 
+#if ENABLE_RAYCAST_PICKING
+    PickingModel m_sphere;
+    PickingModel m_cone;
+    std::vector<std::pair<std::shared_ptr<SceneRaycasterItem>, std::shared_ptr<SceneRaycasterItem>>> m_raycasters;
+#else
     GLModel m_cone;
-    GLModel m_cylinder;
     GLModel m_sphere;
+#endif // ENABLE_RAYCAST_PICKING
+    GLModel m_cylinder;
 
     // This map holds all translated description texts, so they can be easily referenced during layout calculations
     // etc. When language changes, GUI is recreated and this class constructed again, so the change takes effect.