WIP: Duplicated the SLA gizmo for the FDM, removed what was not needed

Clipping plane and the m_model_object pointer keeping was duplicated

src/slic3r/CMakeLists.txt

@@ -43,6 +43,8 @@ set(SLIC3R_GUI_SOURCES
     GUI/Gizmos/GLGizmoScale.hpp
     GUI/Gizmos/GLGizmoSlaSupports.cpp
     GUI/Gizmos/GLGizmoSlaSupports.hpp
+    GUI/Gizmos/GLGizmoFdmSupports.cpp
+    GUI/Gizmos/GLGizmoFdmSupports.hpp
     GUI/Gizmos/GLGizmoFlatten.cpp
     GUI/Gizmos/GLGizmoFlatten.hpp
     GUI/Gizmos/GLGizmoCut.cpp

src/slic3r/GUI/GLCanvas3D.cpp

@@ -1596,10 +1596,15 @@ void GLCanvas3D::toggle_sla_auxiliaries_visibility(bool visible, const ModelObje
 void GLCanvas3D::toggle_model_objects_visibility(bool visible, const ModelObject* mo, int instance_idx)
 {
     for (GLVolume* vol : m_volumes.volumes) {
-        if ((mo == nullptr || m_model->objects[vol->composite_id.object_id] == mo)
-        && (instance_idx == -1 || vol->composite_id.instance_id == instance_idx)) {
-            vol->is_active = visible;
-            vol->force_native_color = (instance_idx != -1);
+        if (vol->composite_id.object_id == 1000) { // wipe tower
+                vol->is_active = (visible && mo == nullptr);
+        }
+        else {
+            if ((mo == nullptr || m_model->objects[vol->composite_id.object_id] == mo)
+            && (instance_idx == -1 || vol->composite_id.instance_id == instance_idx)) {
+                vol->is_active = visible;
+                vol->force_native_color = (instance_idx != -1);
+            }
         }
     }
     if (visible && !mo)
@@ -4794,7 +4799,7 @@ void GLCanvas3D::_picking_pass() const
 
         glsafe(::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
 
-        m_camera_clipping_plane = m_gizmos.get_sla_clipping_plane();
+        m_camera_clipping_plane = m_gizmos.get_clipping_plane();
         if (m_camera_clipping_plane.is_active()) {
             ::glClipPlane(GL_CLIP_PLANE0, (GLdouble*)m_camera_clipping_plane.get_data());
             ::glEnable(GL_CLIP_PLANE0);
@@ -4962,7 +4967,7 @@ void GLCanvas3D::_render_objects() const
 #endif // !ENABLE_THUMBNAIL_GENERATOR
     glsafe(::glEnable(GL_DEPTH_TEST));
 
-    m_camera_clipping_plane = m_gizmos.get_sla_clipping_plane();
+    m_camera_clipping_plane = m_gizmos.get_clipping_plane();
 
     if (m_picking_enabled)
     {

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp

@@ -0,0 +1,422 @@
+// Include GLGizmoBase.hpp before I18N.hpp as it includes some libigl code, which overrides our localization "L" macro.
+#include "GLGizmoFdmSupports.hpp"
+#include "slic3r/GUI/GLCanvas3D.hpp"
+#include "slic3r/GUI/Gizmos/GLGizmos.hpp"
+
+#include <GL/glew.h>
+
+#include "slic3r/GUI/GUI_App.hpp"
+#include "slic3r/GUI/MeshUtils.hpp"
+#include "slic3r/GUI/PresetBundle.hpp"
+
+
+
+namespace Slic3r {
+namespace GUI {
+
+GLGizmoFdmSupports::GLGizmoFdmSupports(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
+    : GLGizmoBase(parent, icon_filename, sprite_id)
+    , m_quadric(nullptr)
+    , m_its(nullptr)
+{
+    m_clipping_plane.reset(new ClippingPlane(Vec3d::Zero(), 0.));
+    m_quadric = ::gluNewQuadric();
+    if (m_quadric != nullptr)
+        // using GLU_FILL does not work when the instance's transformation
+        // contains mirroring (normals are reverted)
+        ::gluQuadricDrawStyle(m_quadric, GLU_FILL);
+}
+
+GLGizmoFdmSupports::~GLGizmoFdmSupports()
+{
+    if (m_quadric != nullptr)
+        ::gluDeleteQuadric(m_quadric);
+}
+
+bool GLGizmoFdmSupports::on_init()
+{
+    m_shortcut_key = WXK_CONTROL_L;
+
+    m_desc["head_diameter"]    = _(L("Head diameter")) + ": ";
+    m_desc["lock_supports"]    = _(L("Lock supports under new islands"));
+    m_desc["remove_selected"]  = _(L("Remove selected points"));
+    m_desc["remove_all"]       = _(L("Remove all points"));
+    m_desc["apply_changes"]    = _(L("Apply changes"));
+    m_desc["discard_changes"]  = _(L("Discard changes"));
+    m_desc["minimal_distance"] = _(L("Minimal points distance")) + ": ";
+    m_desc["points_density"]   = _(L("Support points density")) + ": ";
+    m_desc["auto_generate"]    = _(L("Auto-generate points"));
+    m_desc["manual_editing"]   = _(L("Manual editing"));
+    m_desc["clipping_of_view"] = _(L("Clipping of view"))+ ": ";
+    m_desc["reset_direction"]  = _(L("Reset direction"));
+
+    return true;
+}
+
+void GLGizmoFdmSupports::set_fdm_support_data(ModelObject* model_object, const Selection& selection)
+{
+    if (! model_object || selection.is_empty()) {
+        m_model_object = nullptr;
+        return;
+    }
+
+    if (m_model_object != model_object || m_model_object_id != model_object->id())
+        m_model_object = model_object;
+
+    m_active_instance = selection.get_instance_idx();
+
+    if (model_object && selection.is_from_single_instance())
+    {
+        // Cache the bb - it's needed for dealing with the clipping plane quite often
+        // It could be done inside update_mesh but one has to account for scaling of the instance.
+        //FIXME calling ModelObject::instance_bounding_box() is expensive!
+        m_active_instance_bb_radius = m_model_object->instance_bounding_box(m_active_instance).radius();
+
+        if (is_mesh_update_necessary())
+            update_mesh();
+
+        if (m_state == On) {
+            m_parent.toggle_model_objects_visibility(false);
+            m_parent.toggle_model_objects_visibility(true, m_model_object, m_active_instance);
+        }
+        else
+            m_parent.toggle_model_objects_visibility(true, nullptr, -1);
+    }
+}
+
+
+
+void GLGizmoFdmSupports::on_render() const
+{
+    const Selection& selection = m_parent.get_selection();
+
+    // If current m_model_object does not match selection, ask GLCanvas3D to turn us off
+    if (m_state == On
+     && (m_model_object != selection.get_model()->objects[selection.get_object_idx()]
+      || m_active_instance != selection.get_instance_idx()
+      || m_model_object_id != m_model_object->id())) {
+        m_parent.post_event(SimpleEvent(EVT_GLCANVAS_RESETGIZMOS));
+        return;
+    }
+
+    if (! m_its || ! m_mesh)
+        const_cast<GLGizmoFdmSupports*>(this)->update_mesh();
+
+    glsafe(::glEnable(GL_BLEND));
+    glsafe(::glEnable(GL_DEPTH_TEST));
+
+
+    render_clipping_plane(selection);
+
+    glsafe(::glDisable(GL_BLEND));
+}
+
+
+
+void GLGizmoFdmSupports::render_clipping_plane(const Selection& selection) const
+{
+    if (m_clipping_plane_distance == 0.f)
+        return;
+
+    // Get transformation of the instance
+    const GLVolume* vol = selection.get_volume(*selection.get_volume_idxs().begin());
+    Geometry::Transformation trafo = vol->get_instance_transformation();
+
+
+    // Now initialize the TMS for the object, perform the cut and save the result.
+    if (! m_object_clipper) {
+        m_object_clipper.reset(new MeshClipper);
+        m_object_clipper->set_mesh(*m_mesh);
+    }
+    m_object_clipper->set_plane(*m_clipping_plane);
+    m_object_clipper->set_transformation(trafo);
+
+    // At this point we have the triangulated cuts for both the object and supports - let's render.
+    if (! m_object_clipper->get_triangles().empty()) {
+		::glPushMatrix();
+        ::glColor3f(1.0f, 0.37f, 0.0f);
+        ::glBegin(GL_TRIANGLES);
+        for (const Vec3f& point : m_object_clipper->get_triangles())
+            ::glVertex3f(point(0), point(1), point(2));
+        ::glEnd();
+		::glPopMatrix();
+	}
+}
+
+
+void GLGizmoFdmSupports::on_render_for_picking() const
+{
+
+}
+
+
+
+
+bool GLGizmoFdmSupports::is_point_clipped(const Vec3d& point) const
+{
+    if (m_clipping_plane_distance == 0.f)
+        return false;
+
+    Vec3d transformed_point = m_model_object->instances.front()->get_transformation().get_matrix() * point;
+    return m_clipping_plane->distance(transformed_point) < 0.;
+}
+
+
+
+bool GLGizmoFdmSupports::is_mesh_update_necessary() const
+{
+    return ((m_state == On) && (m_model_object != nullptr) && !m_model_object->instances.empty())
+        && ((m_model_object->id() != m_model_object_id) || m_its == nullptr);
+}
+
+
+
+void GLGizmoFdmSupports::update_mesh()
+{
+    if (! m_model_object)
+        return;
+
+    wxBusyCursor wait;
+    // this way we can use that mesh directly.
+    // This mesh does not account for the possible Z up SLA offset.
+    m_mesh = &m_model_object->volumes.front()->mesh();
+    m_its = &m_mesh->its;
+
+    // If this is different mesh than last time or if the AABB tree is uninitialized, recalculate it.
+    if (m_model_object_id != m_model_object->id() || ! m_mesh_raycaster)
+        m_mesh_raycaster.reset(new MeshRaycaster(*m_mesh));
+
+    m_model_object_id = m_model_object->id();
+}
+
+
+
+// Unprojects the mouse position on the mesh and saves hit point and normal of the facet into pos_and_normal
+// Return false if no intersection was found, true otherwise.
+bool GLGizmoFdmSupports::unproject_on_mesh(const Vec2d& mouse_pos, std::pair<Vec3f, Vec3f>& pos_and_normal)
+{
+    // if the gizmo doesn't have the V, F structures for igl, calculate them first:
+    if (! m_mesh_raycaster)
+        update_mesh();
+
+    const Camera& camera = m_parent.get_camera();
+    const Selection& selection = m_parent.get_selection();
+    const GLVolume* volume = selection.get_volume(*selection.get_volume_idxs().begin());
+    Geometry::Transformation trafo = volume->get_instance_transformation();
+    trafo.set_offset(trafo.get_offset());
+
+    // The raycaster query
+    Vec3f hit;
+    Vec3f normal;
+    if (m_mesh_raycaster->unproject_on_mesh(mouse_pos, trafo.get_matrix(), camera, hit, normal, m_clipping_plane.get())) {
+        // Return both the point and the facet normal.
+        pos_and_normal = std::make_pair(hit, normal);
+        return true;
+    }
+    else
+        return false;
+}
+
+// Following function is called from GLCanvas3D to inform the gizmo about a mouse/keyboard event.
+// The gizmo has an opportunity to react - if it does, it should return true so that the Canvas3D is
+// aware that the event was reacted to and stops trying to make different sense of it. If the gizmo
+// concludes that the event was not intended for it, it should return false.
+bool GLGizmoFdmSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down)
+{
+    if (action == SLAGizmoEventType::MouseWheelUp && control_down) {
+        m_clipping_plane_distance = std::min(1.f, m_clipping_plane_distance + 0.01f);
+        update_clipping_plane(true);
+        return true;
+    }
+
+    if (action == SLAGizmoEventType::MouseWheelDown && control_down) {
+        m_clipping_plane_distance = std::max(0.f, m_clipping_plane_distance - 0.01f);
+        update_clipping_plane(true);
+        return true;
+    }
+
+    if (action == SLAGizmoEventType::ResetClippingPlane) {
+        update_clipping_plane();
+        return true;
+    }
+
+    return false;
+}
+
+
+
+
+ClippingPlane GLGizmoFdmSupports::get_fdm_clipping_plane() const
+{
+    if (!m_model_object || m_state == Off || m_clipping_plane_distance == 0.f)
+        return ClippingPlane::ClipsNothing();
+    else
+        return ClippingPlane(-m_clipping_plane->get_normal(), m_clipping_plane->get_data()[3]);
+}
+
+
+
+void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_limit)
+{
+    if (!m_model_object)
+        return;
+
+    const float approx_height = m_imgui->scaled(18.0f);
+    y = std::min(y, bottom_limit - approx_height);
+    m_imgui->set_next_window_pos(x, y, ImGuiCond_Always);
+    m_imgui->set_next_window_bg_alpha(0.5f);
+    m_imgui->begin(on_get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse);
+
+    // First calculate width of all the texts that are could possibly be shown. We will decide set the dialog width based on that:
+
+    const float settings_sliders_left = std::max(m_imgui->calc_text_size(m_desc.at("minimal_distance")).x, m_imgui->calc_text_size(m_desc.at("points_density")).x) + m_imgui->scaled(1.f);
+    const float clipping_slider_left = std::max(m_imgui->calc_text_size(m_desc.at("clipping_of_view")).x, m_imgui->calc_text_size(m_desc.at("reset_direction")).x) + m_imgui->scaled(1.5f);
+    const float diameter_slider_left = m_imgui->calc_text_size(m_desc.at("head_diameter")).x + m_imgui->scaled(1.f);
+    const float minimal_slider_width = m_imgui->scaled(4.f);
+    const float buttons_width_approx = m_imgui->calc_text_size(m_desc.at("apply_changes")).x + m_imgui->calc_text_size(m_desc.at("discard_changes")).x + m_imgui->scaled(1.5f);
+    const float lock_supports_width_approx = m_imgui->calc_text_size(m_desc.at("lock_supports")).x + m_imgui->scaled(2.f);
+
+    float window_width = minimal_slider_width + std::max(std::max(settings_sliders_left, clipping_slider_left), diameter_slider_left);
+    window_width = std::max(std::max(window_width, buttons_width_approx), lock_supports_width_approx);
+
+
+    // Following is rendered in both editing and non-editing mode:
+    m_imgui->text("");
+    if (m_clipping_plane_distance == 0.f)
+        m_imgui->text(m_desc.at("clipping_of_view"));
+    else {
+        if (m_imgui->button(m_desc.at("reset_direction"))) {
+            wxGetApp().CallAfter([this](){
+                    update_clipping_plane();
+                });
+        }
+    }
+
+    ImGui::SameLine(clipping_slider_left);
+    ImGui::PushItemWidth(window_width - clipping_slider_left);
+    if (ImGui::SliderFloat("  ", &m_clipping_plane_distance, 0.f, 1.f, "%.2f"))
+        update_clipping_plane(true);
+
+
+    m_imgui->end();
+}
+
+bool GLGizmoFdmSupports::on_is_activable() const
+{
+    const Selection& selection = m_parent.get_selection();
+
+    if (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptFFF
+        || !selection.is_from_single_instance())
+        return false;
+
+    // Check that none of the selected volumes is outside. Only SLA auxiliaries (supports) are allowed outside.
+    const Selection::IndicesList& list = selection.get_volume_idxs();
+    for (const auto& idx : list)
+        if (selection.get_volume(idx)->is_outside)
+            return false;
+
+    return true;
+}
+
+bool GLGizmoFdmSupports::on_is_selectable() const
+{
+    return (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptFFF );
+}
+
+std::string GLGizmoFdmSupports::on_get_name() const
+{
+    return (_(L("FDM Support Editing")) + " [L]").ToUTF8().data();
+}
+
+
+
+void GLGizmoFdmSupports::on_set_state()
+{
+    if (m_state == On)
+        std::cout << "zapinam se..." << std::endl;
+    else
+        std::cout << "vypinam se..." << std::endl;
+    return;
+    // m_model_object pointer can be invalid (for instance because of undo/redo action),
+    // we should recover it from the object id
+    m_model_object = nullptr;
+    for (const auto mo : wxGetApp().model().objects) {
+        if (mo->id() == m_model_object_id) {
+            m_model_object = mo;
+            break;
+        }
+    }
+
+    if (m_state == m_old_state)
+        return;
+
+    if (m_state == On && m_old_state != On) { // the gizmo was just turned on
+        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _(L("SLA gizmo turned on")));
+        if (is_mesh_update_necessary())
+            update_mesh();
+
+        // we'll now reload support points:
+        if (m_model_object)
+            ;// !!!! reload_cache();
+
+        m_parent.toggle_model_objects_visibility(false);
+        if (m_model_object)
+            m_parent.toggle_model_objects_visibility(true, m_model_object, m_active_instance);
+    }
+    if (m_state == Off && m_old_state != Off) { // the gizmo was just turned Off
+        // we are actually shutting down
+        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _(L("FDM gizmo turned off")));
+        m_parent.toggle_model_objects_visibility(true);
+        m_clipping_plane_distance = 0.f;
+        // Release clippers and the AABB raycaster.
+        m_its = nullptr;
+        m_object_clipper.reset();
+        m_mesh_raycaster.reset();
+    }
+    m_old_state = m_state;
+}
+
+
+
+void GLGizmoFdmSupports::on_start_dragging()
+{
+
+}
+
+
+void GLGizmoFdmSupports::on_stop_dragging()
+{
+
+}
+
+
+
+void GLGizmoFdmSupports::on_load(cereal::BinaryInputArchive& ar)
+{
+
+}
+
+
+
+void GLGizmoFdmSupports::on_save(cereal::BinaryOutputArchive& ar) const
+{
+
+}
+
+
+void GLGizmoFdmSupports::update_clipping_plane(bool keep_normal) const
+{
+    Vec3d normal = (keep_normal && m_clipping_plane->get_normal() != Vec3d::Zero() ?
+                        m_clipping_plane->get_normal() : -m_parent.get_camera().get_dir_forward());
+
+    const Vec3d& center = m_model_object->instances[m_active_instance]->get_offset();
+    float dist = normal.dot(center);
+    *m_clipping_plane = ClippingPlane(normal, (dist - (-m_active_instance_bb_radius) - m_clipping_plane_distance * 2*m_active_instance_bb_radius));
+    m_parent.set_as_dirty();
+}
+
+
+
+
+} // namespace GUI
+} // namespace Slic3r

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp

@@ -0,0 +1,87 @@
+#ifndef slic3r_GLGizmoFdmSupports_hpp_
+#define slic3r_GLGizmoFdmSupports_hpp_
+
+#include "GLGizmoBase.hpp"
+
+//#include "libslic3r/SLA/SLACommon.hpp"
+//#include <wx/dialog.h>
+
+#include <cereal/types/vector.hpp>
+
+
+namespace Slic3r {
+namespace GUI {
+
+class ClippingPlane;
+class MeshClipper;
+class MeshRaycaster;
+enum class SLAGizmoEventType : unsigned char;
+
+class GLGizmoFdmSupports : public GLGizmoBase
+{
+private:
+    ModelObject* m_model_object = nullptr;
+    ObjectID m_model_object_id = 0;
+    int m_active_instance = -1;
+    float m_active_instance_bb_radius; // to cache the bb
+    bool unproject_on_mesh(const Vec2d& mouse_pos, std::pair<Vec3f, Vec3f>& pos_and_normal);
+
+
+    GLUquadricObj* m_quadric;
+
+    std::unique_ptr<MeshRaycaster> m_mesh_raycaster;
+    const TriangleMesh* m_mesh;
+    const indexed_triangle_set* m_its;
+    mutable std::vector<Vec2f> m_triangles;
+
+
+public:
+    GLGizmoFdmSupports(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
+    ~GLGizmoFdmSupports() override;
+    void set_fdm_support_data(ModelObject* model_object, const Selection& selection);
+    bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
+    ClippingPlane get_fdm_clipping_plane() const;
+
+
+private:
+    bool on_init() override;
+    void on_render() const override;
+    void on_render_for_picking() const override;
+
+    void render_clipping_plane(const Selection& selection) const;
+    bool is_mesh_update_necessary() const;
+    void update_mesh();
+
+    float m_clipping_plane_distance = 0.f;
+    std::unique_ptr<ClippingPlane> m_clipping_plane;
+
+    // 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.
+    std::map<std::string, wxString> m_desc;
+
+    bool m_wait_for_up_event = false;
+    EState m_old_state = Off; // to be able to see that the gizmo has just been closed (see on_set_state)
+
+    mutable std::unique_ptr<MeshClipper> m_object_clipper;
+
+
+    bool is_point_clipped(const Vec3d& point) const;
+    void update_clipping_plane(bool keep_normal = false) const;
+
+protected:
+    void on_set_state() override;
+    void on_start_dragging() override;
+    void on_stop_dragging() override;
+    void on_render_input_window(float x, float y, float bottom_limit) override;
+    std::string on_get_name() const override;
+    bool on_is_activable() const override;
+    bool on_is_selectable() const override;
+    void on_load(cereal::BinaryInputArchive& ar) override;
+    void on_save(cereal::BinaryOutputArchive& ar) const override;
+};
+
+
+} // namespace GUI
+} // namespace Slic3r
+
+#endif // slic3r_GLGizmoFdmSupports_hpp_

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp

@@ -32,8 +32,6 @@ private:
     const float RenderPointScale = 1.f;
 
     GLUquadricObj* m_quadric;
-    typedef Eigen::Map<const Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor | Eigen::DontAlign>> MapMatrixXfUnaligned;
-    typedef Eigen::Map<const Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor | Eigen::DontAlign>> MapMatrixXiUnaligned;
 
     //std::unique_ptr<MeshRaycaster> m_mesh_raycaster;
     //const TriangleMesh* m_mesh;
@@ -142,7 +140,6 @@ private:
     void auto_generate();
     void switch_to_editing_mode();
     void disable_editing_mode();
-    void reset_clipping_plane_normal() const;
 
 protected:
     void on_set_state() override;

src/slic3r/GUI/Gizmos/GLGizmos.hpp

@@ -31,6 +31,7 @@ enum class SLAGizmoEventType : unsigned char {
 #include "slic3r/GUI/Gizmos/GLGizmoRotate.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoFlatten.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp"
+#include "slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoCut.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoHollow.hpp"
 

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -94,11 +94,13 @@ bool GLGizmosManager::init()
     m_gizmos.emplace_back(new GLGizmoCut(m_parent, "cut.svg", 4));
     m_gizmos.emplace_back(new GLGizmoHollow(m_parent, "hollow.svg", 5));
     m_gizmos.emplace_back(new GLGizmoSlaSupports(m_parent, "sla_supports.svg", 6));
+    m_gizmos.emplace_back(new GLGizmoFdmSupports(m_parent, "sla_supports.svg", 7));
 
     m_common_gizmos_data.reset(new CommonGizmosData());
     dynamic_cast<GLGizmoHollow*>(m_gizmos[Hollow].get())->set_common_data_ptr(m_common_gizmos_data.get());
     dynamic_cast<GLGizmoSlaSupports*>(m_gizmos[SlaSupports].get())->set_common_data_ptr(m_common_gizmos_data.get());
 
+
     for (auto& gizmo : m_gizmos) {
         if (! gizmo->init()) {
             m_gizmos.clear();
@@ -204,6 +206,7 @@ void GLGizmosManager::update_data()
         ModelObject* model_object = selection.get_model()->objects[selection.get_object_idx()];
         set_flattening_data(model_object);
         set_sla_support_data(model_object);
+        set_fdm_support_data(model_object);
     }
     else if (selection.is_single_volume() || selection.is_single_modifier())
     {
@@ -212,6 +215,7 @@ void GLGizmosManager::update_data()
         set_rotation(Vec3d::Zero());
         set_flattening_data(nullptr);
         set_sla_support_data(nullptr);
+        set_fdm_support_data(nullptr);
     }
     else if (is_wipe_tower)
     {
@@ -220,6 +224,7 @@ void GLGizmosManager::update_data()
         set_rotation(Vec3d(0., 0., (M_PI/180.) * dynamic_cast<const ConfigOptionFloat*>(config.option("wipe_tower_rotation_angle"))->value));
         set_flattening_data(nullptr);
         set_sla_support_data(nullptr);
+        set_fdm_support_data(nullptr);
     }
     else
     {
@@ -227,6 +232,7 @@ void GLGizmosManager::update_data()
         set_rotation(Vec3d::Zero());
         set_flattening_data(selection.is_from_single_object() ? selection.get_model()->objects[selection.get_object_idx()] : nullptr);
         set_sla_support_data(nullptr);
+        set_fdm_support_data(nullptr);
     }
 }
 
@@ -366,6 +372,14 @@ void GLGizmosManager::set_sla_support_data(ModelObject* model_object)
     gizmo_hollow->set_sla_support_data(model_object, m_parent.get_selection());
 }
 
+void GLGizmosManager::set_fdm_support_data(ModelObject* model_object)
+{
+    if (!m_enabled || m_gizmos.empty())
+        return;
+
+    dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->set_fdm_support_data(model_object, m_parent.get_selection());
+}
+
 // Returns true if the gizmo used the event to do something, false otherwise.
 bool GLGizmosManager::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down)
 {
@@ -379,15 +393,17 @@ bool GLGizmosManager::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_p
     return false;
 }
 
-ClippingPlane GLGizmosManager::get_sla_clipping_plane() const
+ClippingPlane GLGizmosManager::get_clipping_plane() const
 {
-    if (!m_enabled || (m_current != SlaSupports && m_current != Hollow) || m_gizmos.empty())
+    if (!m_enabled || (m_current != SlaSupports && m_current != Hollow && m_current != FdmSupports) || m_gizmos.empty())
         return ClippingPlane::ClipsNothing();
 
     if (m_current == SlaSupports)
         return dynamic_cast<GLGizmoSlaSupports*>(m_gizmos[SlaSupports].get())->get_sla_clipping_plane();
-    else
+    else if (m_current == Hollow)
         return dynamic_cast<GLGizmoHollow*>(m_gizmos[Hollow].get())->get_sla_clipping_plane();
+    else
+        return dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->get_fdm_clipping_plane();
 }
 
 bool GLGizmosManager::wants_reslice_supports_on_undo() const
@@ -407,6 +423,7 @@ void GLGizmosManager::render_current_gizmo() const
 void GLGizmosManager::render_current_gizmo_for_picking_pass() const
 {
     if (! m_enabled || m_current == Undefined)
+
         return;
 
     m_gizmos[m_current]->render_for_picking();

src/slic3r/GUI/Gizmos/GLGizmosManager.hpp

@@ -64,6 +64,7 @@ public:
         Cut,
         Hollow,
         SlaSupports,
+        FdmSupports,
         Undefined
     };
 
@@ -197,8 +198,11 @@ public:
     void set_flattening_data(const ModelObject* model_object);
 
     void set_sla_support_data(ModelObject* model_object);
+
+    void set_fdm_support_data(ModelObject* model_object);
+
     bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position = Vec2d::Zero(), bool shift_down = false, bool alt_down = false, bool control_down = false);
-    ClippingPlane get_sla_clipping_plane() const;
+    ClippingPlane get_clipping_plane() const;
     bool wants_reslice_supports_on_undo() const;
 
     void render_current_gizmo() const;