Added an option to limit painting to triangles only highlighted by "Highlight by angle" in the support painting gizmo.

src/libslic3r/TriangleSelector.cpp

@@ -127,7 +127,8 @@ int TriangleSelector::select_unsplit_triangle(const Vec3f &hit, int facet_idx) c
 void TriangleSelector::select_patch(const Vec3f& hit, int facet_start,
                                     const Vec3f& source, float radius,
                                     CursorType cursor_type, EnforcerBlockerType new_state,
-                                    const Transform3d& trafo, bool triangle_splitting)
+                                    const Transform3d& trafo, const Transform3d& trafo_no_translate,
+                                    bool triangle_splitting, float highlight_by_angle_deg)
 {
     assert(facet_start < m_orig_size_indices);
 
@@ -143,6 +144,9 @@ void TriangleSelector::select_patch(const Vec3f& hit, int facet_start,
         m_old_cursor_radius_sqr = m_cursor.radius_sqr;
     }
 
+    const float highlight_angle_limit = cos(Geometry::deg2rad(highlight_by_angle_deg));
+    Vec3f       vec_down              = (trafo_no_translate.inverse() * -Vec3d::UnitZ()).normalized().cast<float>();
+
     // Now start with the facet the pointer points to and check all adjacent facets.
     std::vector<int> facets_to_check;
     facets_to_check.reserve(16);
@@ -154,21 +158,24 @@ void TriangleSelector::select_patch(const Vec3f& hit, int facet_start,
     int facet_idx = 0;
     while (facet_idx < int(facets_to_check.size())) {
         int          facet        = facets_to_check[facet_idx];
-        if (! visited[facet]) {
+        const Vec3f &facet_normal = m_face_normals[m_triangles[facet].source_triangle];
+        if (!visited[facet] && (highlight_by_angle_deg == 0.f || vec_down.dot(facet_normal) >= highlight_angle_limit)) {
             if (select_triangle(facet, new_state, triangle_splitting)) {
-                // add neighboring facets to list to be proccessed later
+                // add neighboring facets to list to be processed later
-                for (int neighbor_idx : m_neighbors[facet]) {
+                for (int neighbor_idx : m_neighbors[facet])
                     if (neighbor_idx >= 0 && (m_cursor.type == SPHERE || faces_camera(neighbor_idx)))
                         facets_to_check.push_back(neighbor_idx);
             }
         }
-        }
         visited[facet] = true;
         ++facet_idx;
     }
 }
 
-void TriangleSelector::seed_fill_select_triangles(const Vec3f &hit, int facet_start, float seed_fill_angle, bool force_reselection)
+void TriangleSelector::seed_fill_select_triangles(const Vec3f &hit, int facet_start,
+                                                  const Transform3d& trafo_no_translate,
+                                                  float seed_fill_angle, float highlight_by_angle_deg,
+                                                  bool force_reselection)
 {
     assert(facet_start < m_orig_size_indices);
 
@@ -183,13 +190,16 @@ void TriangleSelector::seed_fill_select_triangles(const Vec3f &hit, int facet_st
     facet_queue.push(facet_start);
 
     const double facet_angle_limit     = cos(Geometry::deg2rad(seed_fill_angle)) - EPSILON;
+    const float  highlight_angle_limit = cos(Geometry::deg2rad(highlight_by_angle_deg));
+    Vec3f        vec_down              = (trafo_no_translate.inverse() * -Vec3d::UnitZ()).normalized().cast<float>();
 
     // Depth-first traversal of neighbors of the face hit by the ray thrown from the mouse cursor.
     while (!facet_queue.empty()) {
         int current_facet = facet_queue.front();
         facet_queue.pop();
 
-        if (!visited[current_facet]) {
+        const Vec3f &facet_normal = m_face_normals[m_triangles[current_facet].source_triangle];
+        if (!visited[current_facet] && (highlight_by_angle_deg == 0.f || vec_down.dot(facet_normal) >= highlight_angle_limit)) {
             if (m_triangles[current_facet].is_split()) {
                 for (int split_triangle_idx = 0; split_triangle_idx <= m_triangles[current_facet].number_of_split_sides(); ++split_triangle_idx) {
                     assert(split_triangle_idx < int(m_triangles[current_facet].children.size()));

src/libslic3r/TriangleSelector.hpp

@@ -45,11 +45,15 @@ public:
                       CursorType          type,        // current type of cursor
                       EnforcerBlockerType new_state,   // enforcer or blocker?
                       const Transform3d  &trafo,       // matrix to get from mesh to world
-                      bool                triangle_splitting); // If triangles will be split base on the cursor or not
+                      const Transform3d  &trafo_no_translate,            // matrix to get from mesh to world without translation
+                      bool                triangle_splitting,            // If triangles will be split base on the cursor or not
+                      float               highlight_by_angle_deg = 0.f); // The maximal angle of overhang. If it is set to a non-zero value, it is possible to paint only the triangles of overhang defined by this angle in degrees.
 
     void seed_fill_select_triangles(const Vec3f       &hit,                          // point where to start
                                     int                facet_start,                  // facet of the original mesh (unsplit) that the hit point belongs to
+                                    const Transform3d &trafo_no_translate,           // matrix to get from mesh to world without translation
                                     float              seed_fill_angle,              // the maximal angle between two facets to be painted by the same color
+                                    float              highlight_by_angle_deg = 0.f, // The maximal angle of overhang. If it is set to a non-zero value, it is possible to paint only the triangles of overhang defined by this angle in degrees.
                                     bool               force_reselection = false);   // force reselection of the triangle mesh even in cases that mouse is pointing on the selected triangle
 
     void bucket_fill_select_triangles(const Vec3f &hit,             // point where to start

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp

@@ -20,7 +20,7 @@ namespace Slic3r::GUI {
 
 void GLGizmoFdmSupports::on_shutdown()
 {
-    m_angle_threshold_deg = 0.f;
+    m_highlight_by_angle_threshold_deg = 0.f;
     m_parent.use_slope(false);
     m_parent.toggle_model_objects_visibility(true);
 }
@@ -62,6 +62,9 @@ bool GLGizmoFdmSupports::on_init()
 
     m_desc["smart_fill_angle"] = _L("Smart fill angle");
 
+    m_desc["split_triangles"]   = _L("Split triangles");
+    m_desc["on_overhangs_only"] = _L("On overhangs only");
+
     return true;
 }
 
@@ -116,6 +119,9 @@ void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_l
     const float tool_type_radio_brush      = m_imgui->calc_text_size(m_desc["tool_brush"]).x + m_imgui->scaled(2.5f);
     const float tool_type_radio_smart_fill = m_imgui->calc_text_size(m_desc["tool_smart_fill"]).x + m_imgui->scaled(2.5f);
 
+    const float split_triangles_checkbox_width   = m_imgui->calc_text_size(m_desc["split_triangles"]).x + m_imgui->scaled(2.5f);
+    const float on_overhangs_only_checkbox_width = m_imgui->calc_text_size(m_desc["on_overhangs_only"]).x + m_imgui->scaled(2.5f);
+
     float caption_max    = 0.f;
     float total_text_max = 0.f;
     for (const auto &t : std::array<std::string, 3>{"enforce", "block", "remove"}) {
@@ -129,6 +135,8 @@ void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_l
     float window_width  = minimal_slider_width + sliders_width;
     window_width = std::max(window_width, total_text_max);
     window_width = std::max(window_width, button_width);
+    window_width = std::max(window_width, split_triangles_checkbox_width);
+    window_width = std::max(window_width, on_overhangs_only_checkbox_width);
     window_width = std::max(window_width, cursor_type_radio_circle + cursor_type_radio_sphere + cursor_type_radio_pointer);
     window_width = std::max(window_width, tool_type_radio_left + tool_type_radio_brush + tool_type_radio_smart_fill);
     window_width = std::max(window_width, 2.f * buttons_width + m_imgui->scaled(1.f));
@@ -152,25 +160,25 @@ void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_l
         "placed after the number with no whitespace in between.");
     ImGui::SameLine(sliders_width);
     ImGui::PushItemWidth(window_width - sliders_width);
-    if (m_imgui->slider_float("##angle_threshold_deg", &m_angle_threshold_deg, 0.f, 90.f, format_str.data())) {
+    if (m_imgui->slider_float("##angle_threshold_deg", &m_highlight_by_angle_threshold_deg, 0.f, 90.f, format_str.data())) {
-        m_parent.set_slope_normal_angle(90.f - m_angle_threshold_deg);
+        m_parent.set_slope_normal_angle(90.f - m_highlight_by_angle_threshold_deg);
         if (! m_parent.is_using_slope()) {
             m_parent.use_slope(true);
             m_parent.set_as_dirty();
         }
     }
 
-    m_imgui->disabled_begin(m_angle_threshold_deg == 0.f);
+    m_imgui->disabled_begin(m_highlight_by_angle_threshold_deg == 0.f);
     ImGui::NewLine();
     ImGui::SameLine(window_width - 2.f*buttons_width - m_imgui->scaled(0.5f));
     if (m_imgui->button(m_desc["enforce_button"], buttons_width, 0.f)) {
-        select_facets_by_angle(m_angle_threshold_deg, false);
+        select_facets_by_angle(m_highlight_by_angle_threshold_deg, false);
-        m_angle_threshold_deg = 0.f;
+        m_highlight_by_angle_threshold_deg = 0.f;
         m_parent.use_slope(false);
     }
     ImGui::SameLine(window_width - buttons_width);
     if (m_imgui->button(m_desc["cancel"], buttons_width, 0.f)) {
-        m_angle_threshold_deg = 0.f;
+        m_highlight_by_angle_threshold_deg = 0.f;
         m_parent.use_slope(false);
     }
     m_imgui->disabled_end();
@@ -209,6 +217,8 @@ void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_l
         ImGui::EndTooltip();
     }
 
+    m_imgui->checkbox(m_desc["on_overhangs_only"], m_paint_on_overhangs_only);
+
     ImGui::Separator();
 
     if (m_tool_type == ToolType::BRUSH) {
@@ -272,7 +282,7 @@ void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_l
             ImGui::EndTooltip();
         }
 
-        m_imgui->checkbox(_L("Split triangles"), m_triangle_splitting_enabled);
+        m_imgui->checkbox(m_desc["split_triangles"], m_triangle_splitting_enabled);
 
         if (ImGui::IsItemHovered()) {
             ImGui::BeginTooltip();
@@ -287,8 +297,7 @@ void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_l
         assert(m_tool_type == ToolType::SMART_FILL);
         ImGui::AlignTextToFramePadding();
         m_imgui->text(m_desc["smart_fill_angle"] + ":");
-        std::string format_str = std::string("%.f") + I18N::translate_utf8("°", "Degree sign to use in the respective slider in MMU gizmo,"
+
-                                                                                "placed after the number with no whitespace in between.");
         ImGui::SameLine(sliders_width);
         ImGui::PushItemWidth(window_width - sliders_width);
         if (m_imgui->slider_float("##smart_fill_angle", &m_smart_fill_angle, SmartFillAngleMin, SmartFillAngleMax, format_str.data()))

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp

@@ -35,7 +35,6 @@ private:
     PainterGizmoType get_painter_type() const override;
 
     void select_facets_by_angle(float threshold, bool block);
-    float m_angle_threshold_deg = 0.f;
 
     // 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.

src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp

@@ -129,6 +129,7 @@ bool GLGizmoMmuSegmentation::on_init()
     m_desc["tool_bucket_fill"]     = _L("Bucket fill");
 
     m_desc["smart_fill_angle"]     = _L("Smart fill angle");
+    m_desc["split_triangles"]      = _L("Split triangles");
 
     init_extruders_data();
 
@@ -261,6 +262,8 @@ void GLGizmoMmuSegmentation::on_render_input_window(float x, float y, float bott
     const float tool_type_radio_bucket_fill = m_imgui->calc_text_size(m_desc["tool_bucket_fill"]).x + m_imgui->scaled(2.5f);
     const float tool_type_radio_smart_fill  = m_imgui->calc_text_size(m_desc["tool_smart_fill"]).x + m_imgui->scaled(2.5f);
 
+    const float split_triangles_checkbox_width = m_imgui->calc_text_size(m_desc["split_triangles"]).x + m_imgui->scaled(2.5f);
+
     float caption_max    = 0.f;
     float total_text_max = 0.f;
     for (const auto &t : std::array<std::string, 3>{"first_color", "second_color", "remove"}) {
@@ -274,6 +277,7 @@ void GLGizmoMmuSegmentation::on_render_input_window(float x, float y, float bott
     float window_width = minimal_slider_width + sliders_width;
     window_width       = std::max(window_width, total_text_max);
     window_width       = std::max(window_width, button_width);
+    window_width       = std::max(window_width, split_triangles_checkbox_width);
     window_width       = std::max(window_width, cursor_type_radio_circle + cursor_type_radio_sphere + cursor_type_radio_pointer);
     window_width       = std::max(window_width, tool_type_radio_brush + tool_type_radio_bucket_fill + tool_type_radio_smart_fill);
     window_width       = std::max(window_width, 2.f * buttons_width + m_imgui->scaled(1.f));
@@ -438,7 +442,7 @@ void GLGizmoMmuSegmentation::on_render_input_window(float x, float y, float bott
             ImGui::EndTooltip();
         }
 
-        m_imgui->checkbox(_L("Split triangles"), m_triangle_splitting_enabled);
+        m_imgui->checkbox(m_desc["split_triangles"], m_triangle_splitting_enabled);
 
         if (ImGui::IsItemHovered()) {
             ImGui::BeginTooltip();

src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp

@@ -253,7 +253,12 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
                                                                                 : std::min(m_smart_fill_angle + SmartFillAngleStep, SmartFillAngleMax);
                 m_parent.set_as_dirty();
                 if (m_rr.mesh_id != -1) {
-                    m_triangle_selectors[m_rr.mesh_id]->seed_fill_select_triangles(m_rr.hit, int(m_rr.facet), m_smart_fill_angle, true);
+                    const Selection     &selection                 = m_parent.get_selection();
+                    const ModelObject   *mo                        = m_c->selection_info()->model_object();
+                    const ModelInstance *mi                        = mo->instances[selection.get_instance_idx()];
+                    const Transform3d   trafo_matrix_not_translate = mi->get_transformation().get_matrix(true) * mo->volumes[m_rr.mesh_id]->get_matrix(true);
+                    m_triangle_selectors[m_rr.mesh_id]->seed_fill_select_triangles(m_rr.hit, int(m_rr.facet), trafo_matrix_not_translate, m_smart_fill_angle,
+                                                                                   m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f, true);
                     m_triangle_selectors[m_rr.mesh_id]->request_update_render_data();
                     m_seed_fill_last_mesh_id = m_rr.mesh_id;
                 }
@@ -288,7 +293,8 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         const Selection     &selection                   = m_parent.get_selection();
         const ModelObject   *mo                          = m_c->selection_info()->model_object();
         const ModelInstance *mi                          = mo->instances[selection.get_instance_idx()];
-        const Transform3d   &instance_trafo = mi->get_transformation().get_matrix();
+        const Transform3d   instance_trafo               = mi->get_transformation().get_matrix();
+        const Transform3d   instance_trafo_not_translate = mi->get_transformation().get_matrix(true);
 
         // List of mouse positions that will be used as seeds for painting.
         std::vector<Vec2d> mouse_positions{mouse_position};
@@ -314,9 +320,11 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
 
         // Precalculate transformations of individual meshes.
         std::vector<Transform3d> trafo_matrices;
-        for (const ModelVolume* mv : mo->volumes) {
+        std::vector<Transform3d> trafo_matrices_not_translate;
-            if (mv->is_model_part())
+        for (const ModelVolume *mv : mo->volumes)
+            if (mv->is_model_part()) {
                 trafo_matrices.emplace_back(instance_trafo * mv->get_matrix());
+                trafo_matrices_not_translate.emplace_back(instance_trafo_not_translate * mv->get_matrix(true));
             }
 
         // Now "click" into all the prepared points and spill paint around them.
@@ -340,6 +348,7 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
             }
 
             const Transform3d &trafo_matrix               = trafo_matrices[m_rr.mesh_id];
+            const Transform3d &trafo_matrix_not_translate = trafo_matrices_not_translate[m_rr.mesh_id];
 
             // Calculate direction from camera to the hit (in mesh coords):
             Vec3f camera_pos = (trafo_matrix.inverse() * camera.get_position()).cast<float>();
@@ -348,7 +357,8 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
             if (m_tool_type == ToolType::SMART_FILL || m_tool_type == ToolType::BUCKET_FILL || (m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::POINTER)) {
                 m_triangle_selectors[m_rr.mesh_id]->seed_fill_apply_on_triangles(new_state);
                 if (m_tool_type == ToolType::SMART_FILL)
-                    m_triangle_selectors[m_rr.mesh_id]->seed_fill_select_triangles(m_rr.hit, int(m_rr.facet), m_smart_fill_angle, true);
+                    m_triangle_selectors[m_rr.mesh_id]->seed_fill_select_triangles(m_rr.hit, int(m_rr.facet), trafo_matrix_not_translate, m_smart_fill_angle,
+                                                                                   m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f, true);
                 else if (m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::POINTER)
                     m_triangle_selectors[m_rr.mesh_id]->bucket_fill_select_triangles(m_rr.hit, int(m_rr.facet), false, true);
                 else if (m_tool_type == ToolType::BUCKET_FILL)
@@ -357,7 +367,8 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
                 m_seed_fill_last_mesh_id = -1;
             } else if (m_tool_type == ToolType::BRUSH)
                 m_triangle_selectors[m_rr.mesh_id]->select_patch(m_rr.hit, int(m_rr.facet), camera_pos, m_cursor_radius, m_cursor_type,
-                                                                 new_state, trafo_matrix, m_triangle_splitting_enabled);
+                                                                 new_state, trafo_matrix, trafo_matrix_not_translate, m_triangle_splitting_enabled,
+                                                                 m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f);
 
             m_triangle_selectors[m_rr.mesh_id]->request_update_render_data();
             m_last_mouse_click = mouse_position;
@@ -374,13 +385,17 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         const Selection     &selection                    = m_parent.get_selection();
         const ModelObject   *mo                           = m_c->selection_info()->model_object();
         const ModelInstance *mi                           = mo->instances[selection.get_instance_idx()];
-        const Transform3d &  instance_trafo = mi->get_transformation().get_matrix();
+        const Transform3d    instance_trafo               = mi->get_transformation().get_matrix();
+        const Transform3d    instance_trafo_not_translate = mi->get_transformation().get_matrix(true);
 
         // Precalculate transformations of individual meshes.
         std::vector<Transform3d> trafo_matrices;
+        std::vector<Transform3d> trafo_matrices_not_translate;
         for (const ModelVolume *mv : mo->volumes)
-            if (mv->is_model_part())
+            if (mv->is_model_part()) {
                 trafo_matrices.emplace_back(instance_trafo * mv->get_matrix());
+                trafo_matrices_not_translate.emplace_back(instance_trafo_not_translate * mv->get_matrix(true));
+            }
 
         // Now "click" into all the prepared points and spill paint around them.
         update_raycast_cache(mouse_position, camera, trafo_matrices);
@@ -405,9 +420,12 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         if(m_rr.mesh_id != m_seed_fill_last_mesh_id)
             seed_fill_unselect_all();
 
+        const Transform3d &trafo_matrix_not_translate = trafo_matrices_not_translate[m_rr.mesh_id];
+
         assert(m_rr.mesh_id < int(m_triangle_selectors.size()));
         if (m_tool_type == ToolType::SMART_FILL)
-            m_triangle_selectors[m_rr.mesh_id]->seed_fill_select_triangles(m_rr.hit, int(m_rr.facet), m_smart_fill_angle);
+            m_triangle_selectors[m_rr.mesh_id]->seed_fill_select_triangles(m_rr.hit, int(m_rr.facet), trafo_matrix_not_translate, m_smart_fill_angle,
+                                                                           m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f);
         else if (m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::POINTER)
             m_triangle_selectors[m_rr.mesh_id]->bucket_fill_select_triangles(m_rr.hit, int(m_rr.facet), false);
         else if (m_tool_type == ToolType::BUCKET_FILL)

src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp

@@ -159,6 +159,9 @@ protected:
     ToolType m_tool_type                  = ToolType::BRUSH;
     float    m_smart_fill_angle           = 30.f;
 
+    bool     m_paint_on_overhangs_only          = false;
+    float    m_highlight_by_angle_threshold_deg = 0.f;
+
     static constexpr float SmartFillAngleMin  = 0.0f;
     static constexpr float SmartFillAngleMax  = 90.f;
     static constexpr float SmartFillAngleStep = 1.f;