ENH: simplify support options and fix a tree sup bug

1. add default support base pattern (lightning for tree support,
   rectilinear for normal)
2. change default support interface pattern to "Default" (concentric for
   absoluble material, rectilinear for others)
3. delete tree_support_with_infill, replace no-infill optio with "None" infill type
4. delete HAS_LIGHTNING_INFILL macro (lightning is impossible to be
   removed now)
5. fix the issue that tree support base may grow above interface by
   adding virtual nodes (distance_to_top<0).

Change-Id: I5affa44e1f72d0dc54052927f2b315de83702870
(cherry picked from commit a2b41b1dfd9227e68ac6d971312133ec3382baa7)

resources/profiles/BBL/process/fdm_process_bbl_common.json

@@ -84,14 +84,13 @@
     "support_interface_spacing": "0.5",
 	"support_expansion":	"0",
     "support_interface_speed": "80",
-    "support_base_pattern": "rectilinear",
+    "support_base_pattern": "default",
     "support_base_pattern_spacing": "2.5",
     "support_speed": "150",
     "support_threshold_angle": "30",
     "support_object_xy_distance": "0.35",
     "tree_support_branch_angle": "30",
     "tree_support_wall_count": "0",
-    "tree_support_with_infill": "0",
     "detect_thin_wall": "0",
     "top_surface_pattern": "monotonicline",
     "top_surface_line_width": "0.42",

resources/profiles/BBL/process/fdm_process_common.json

@@ -54,12 +54,12 @@
     "support_interface_top_layers": "2",
     "support_interface_spacing": "0",
     "support_interface_speed": "80",
-    "support_base_pattern": "rectilinear",
+    "support_interface_pattern": "auto",
+    "support_base_pattern": "default",
     "support_base_pattern_spacing": "2",
     "support_speed": "40",
     "support_threshold_angle": "40",
     "support_object_xy_distance": "0.5",
-    "tree_support_with_infill": "1",
     "detect_thin_wall": "0",
     "top_surface_line_width": "0.42",
     "top_surface_speed": "30",

src/libslic3r/Fill/FillBase.cpp

@@ -54,9 +54,7 @@ Fill* Fill::new_from_type(const InfillPattern type)
     case ipAdaptiveCubic:       return new FillAdaptive::Filler();
     case ipSupportCubic:        return new FillAdaptive::Filler();
     case ipSupportBase:         return new FillSupportBase();
-#if HAS_LIGHTNING_INFILL
     case ipLightning:           return new FillLightning::Filler();
-#endif // HAS_LIGHTNING_INFILL
     // BBS: for internal solid infill only
     case ipConcentricInternal:  return new FillConcentricInternal();
     // BBS: for bottom and top surface only

src/libslic3r/Layer.hpp

@@ -248,6 +248,7 @@ public:
     ExPolygons roof_1st_layer;  // the layer just below roof. When working with PolySupport, this layer should be printed with regular material
     ExPolygons floor_areas;
     ExPolygons base_areas;
+    ExPolygons roof_gap_areas; // the areas in the gap between support roof and overhang
 
         enum AreaType {
         BaseType=0,

src/libslic3r/Preset.cpp

@@ -724,7 +724,7 @@ static std::vector<std::string> s_Preset_print_options {
     "wipe_tower_no_sparse_layers", "compatible_printers", "compatible_printers_condition", "inherits",
     "flush_into_infill", "flush_into_objects", "flush_into_support",
     // BBS
-     "tree_support_branch_angle", "tree_support_with_infill", "tree_support_wall_count", "tree_support_branch_distance",
+     "tree_support_branch_angle", "tree_support_wall_count", "tree_support_branch_distance",
      "tree_support_branch_diameter",
      "detect_narrow_internal_solid_infill",
      "gcode_add_line_number", "enable_arc_fitting", "infill_combination", /*"adaptive_layer_height",*/

src/libslic3r/PrintConfig.cpp

@@ -131,9 +131,7 @@ static t_config_enum_values s_keys_map_InfillPattern {
     { "archimedeanchords",  ipArchimedeanChords },
     { "octagramspiral",     ipOctagramSpiral },
     { "supportcubic",       ipSupportCubic },
-#if HAS_LIGHTNING_INFILL
     { "lightning",          ipLightning }
-#endif // HAS_LIGHTNING_INFILL
 };
 CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(InfillPattern)
 
@@ -172,9 +170,9 @@ static t_config_enum_values s_keys_map_SupportMaterialPattern {
     { "rectilinear",        smpRectilinear },
     { "rectilinear-grid",   smpRectilinearGrid },
     { "honeycomb",          smpHoneycomb },
-#if HAS_LIGHTNING_INFILL
     { "lightning",          smpLightning },
-#endif
+    { "default",            smpDefault},
+    { "none",               smpNone},
 };
 CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(SupportMaterialPattern)
 
@@ -1276,9 +1274,7 @@ void PrintConfigDef::init_fff_params()
     def->enum_values.push_back("archimedeanchords");
     def->enum_values.push_back("octagramspiral");
     def->enum_values.push_back("supportcubic");
-#if HAS_LIGHTNING_INFILL
     def->enum_values.push_back("lightning");
-#endif // HAS_LIGHTNING_INFILL
     def->enum_labels.push_back(L("Concentric"));
     def->enum_labels.push_back(L("Rectilinear"));
     def->enum_labels.push_back(L("Grid"));
@@ -1295,9 +1291,7 @@ void PrintConfigDef::init_fff_params()
     def->enum_labels.push_back(L("Archimedean Chords"));
     def->enum_labels.push_back(L("Octagram Spiral"));
     def->enum_labels.push_back(L("Support Cubic"));
-#if HAS_LIGHTNING_INFILL
     def->enum_labels.push_back(L("Lightning"));
-#endif // HAS_LIGHTNING_INFILL
     def->set_default_value(new ConfigOptionEnum<InfillPattern>(ipCubic));
 
     def = this->add("top_surface_acceleration", coFloat);
@@ -2553,18 +2547,18 @@ void PrintConfigDef::init_fff_params()
     def->category = L("Support");
     def->tooltip = L("Line pattern of support");
     def->enum_keys_map = &ConfigOptionEnum<SupportMaterialPattern>::get_enum_values();
+    def->enum_values.push_back("default");
     def->enum_values.push_back("rectilinear");
     def->enum_values.push_back("rectilinear-grid");
     def->enum_values.push_back("honeycomb");
-#if HAS_LIGHTNING_INFILL
     def->enum_values.push_back("lightning");
-#endif
+    def->enum_values.push_back("none");
+    def->enum_labels.push_back(L("Default"));
     def->enum_labels.push_back(L("Rectilinear"));
     def->enum_labels.push_back(L("Rectilinear grid"));
     def->enum_labels.push_back(L("Honeycomb"));
-#if HAS_LIGHTNING_INFILL
     def->enum_labels.push_back(L("Lightning"));
-#endif
+    def->enum_labels.push_back(L("None"));
     def->mode = comAdvanced;
     def->set_default_value(new ConfigOptionEnum<SupportMaterialPattern>(smpRectilinear));
 
@@ -2680,13 +2674,6 @@ void PrintConfigDef::init_fff_params()
     def->mode = comAdvanced;
     def->set_default_value(new ConfigOptionInt(1));
 
-    def = this->add("tree_support_with_infill", coBool);
-    def->label = L("Tree support with infill");
-    def->category = L("Support");
-    def->tooltip = L("This setting specifies whether to add infill inside large hollows of tree support");
-    def->mode = comAdvanced;
-    def->set_default_value(new ConfigOptionBool(false));
-
     def = this->add("nozzle_temperature", coInts);
     def->label = L("Other layers");
     def->tooltip = L("Nozzle temperature for layers after the initial one");
@@ -3748,7 +3735,7 @@ void PrintConfigDef::handle_legacy(t_config_option_key &opt_key, std::string &va
 #endif /* HAS_PRESSURE_EQUALIZER */
         // BBS
         , "support_sharp_tails","remove_small_overhangs", "support_with_sheath",
-        "tree_support_branch_diameter_angle", "tree_support_collision_resolution",
+        "tree_support_branch_diameter_angle", "tree_support_collision_resolution", "tree_support_with_infill",
         "small_perimeter_speed", "max_volumetric_speed", "max_print_speed",
         "support_closing_radius",
         "remove_freq_sweep", "remove_bed_leveling", "remove_extrusion_calibration",

src/libslic3r/PrintConfig.hpp

@@ -50,14 +50,10 @@ enum AuthorizationType {
     atKeyPassword, atUserPassword
 };
 
-#define HAS_LIGHTNING_INFILL 1
-
 enum InfillPattern : int {
     ipConcentric, ipRectilinear, ipGrid, ipLine, ipCubic, ipTriangles, ipStars, ipGyroid, ipHoneycomb, ipAdaptiveCubic, ipMonotonic, ipMonotonicLine, ipAlignedRectilinear, ip3DHoneycomb,
     ipHilbertCurve, ipArchimedeanChords, ipOctagramSpiral, ipSupportCubic, ipSupportBase, ipConcentricInternal,
-#if HAS_LIGHTNING_INFILL
     ipLightning,
-#endif // HAS_LIGHTNING_INFILL
 ipCount,
 };
 
@@ -95,10 +91,10 @@ enum class SlicingMode
 };
 
 enum SupportMaterialPattern {
+    smpDefault,
     smpRectilinear, smpRectilinearGrid, smpHoneycomb,
-#if HAS_LIGHTNING_INFILL
     smpLightning,
-#endif // HAS_LIGHTNING_INFILL
+    smpNone,
 };
 
 enum SupportMaterialStyle {
@@ -654,7 +650,6 @@ PRINT_CONFIG_CLASS_DEFINE(
     ((ConfigOptionFloat,              tree_support_branch_diameter))
     ((ConfigOptionFloat,              tree_support_branch_angle))
     ((ConfigOptionInt,                tree_support_wall_count))
-    ((ConfigOptionBool,               tree_support_with_infill))
     ((ConfigOptionBool,               detect_narrow_internal_solid_infill))
     // ((ConfigOptionBool,               adaptive_layer_height))
     ((ConfigOptionFloat,              support_bottom_interface_spacing))

src/libslic3r/PrintObject.cpp

@@ -751,7 +751,6 @@ bool PrintObject::invalidate_state_by_config_options(
             || opt_key == "tree_support_branch_distance"
             || opt_key == "tree_support_branch_diameter"
             || opt_key == "tree_support_branch_angle"
-            || opt_key == "tree_support_with_infill"
             || opt_key == "tree_support_wall_count") {
             steps.emplace_back(posSupportMaterial);
         } else if (opt_key == "bottom_shell_layers") {
@@ -786,7 +785,6 @@ bool PrintObject::invalidate_state_by_config_options(
             steps.emplace_back(posInfill);
         } else if (opt_key == "sparse_infill_pattern") {
             steps.emplace_back(posInfill);
-#if HAS_LIGHTNING_INFILL
             const auto *old_fill_pattern = old_config.option<ConfigOptionEnum<InfillPattern>>(opt_key);
             const auto *new_fill_pattern = new_config.option<ConfigOptionEnum<InfillPattern>>(opt_key);
             assert(old_fill_pattern && new_fill_pattern);
@@ -794,7 +792,6 @@ bool PrintObject::invalidate_state_by_config_options(
             // the Lightning infill to another infill or vice versa.
             if (PrintObject::infill_only_where_needed && (new_fill_pattern->value == ipLightning || old_fill_pattern->value == ipLightning))
                 steps.emplace_back(posPrepareInfill);
-#endif
         } else if (opt_key == "sparse_infill_density") {
             // One likely wants to reslice only when switching between zero infill to simulate boolean difference (subtracting volumes),
             // normal infill and 100% (solid) infill.

src/libslic3r/TreeSupport.cpp

@@ -687,12 +687,11 @@ TreeSupport::TreeSupport(PrintObject& object, const SlicingParameters &slicing_p
         
     SupportMaterialPattern support_pattern  = m_object_config->support_base_pattern;
     m_support_params.base_fill_pattern      = 
-#if HAS_LIGHTNING_INFILL
+        (support_pattern == smpDefault || support_pattern == smpLightning) ? ipLightning :
-        support_pattern == smpLightning ? ipLightning :
-#endif
         support_pattern == smpHoneycomb ? ipHoneycomb :
                                               m_support_params.support_density > 0.95 || m_support_params.with_sheath ? ipRectilinear :
                                                                                                                         ipSupportBase;
+
     m_support_params.interface_fill_pattern = (m_support_params.interface_density > 0.95 ? ipRectilinear : ipSupportBase);
     m_support_params.contact_fill_pattern   = (m_object_config->support_interface_pattern == smipAuto && m_slicing_params.soluble_interface) ||
                                                     m_object_config->support_interface_pattern == smipConcentric ?
@@ -1395,7 +1394,7 @@ void TreeSupport::generate_toolpaths()
     coordf_t nozzle_diameter = print_config.nozzle_diameter.get_at(object_config.support_filament - 1);
 
     const size_t wall_count = object_config.tree_support_wall_count.value;
-    const bool with_infill = object_config.tree_support_with_infill.value;
+    const bool with_infill = object_config.support_base_pattern != smpNone;
     const bool contact_loops = object_config.support_interface_loop_pattern.value;
     auto m_support_material_flow = support_material_flow(m_object, float(m_slicing_params.layer_height));
 
@@ -1606,7 +1605,7 @@ void TreeSupport::generate_toolpaths()
                         }
                     }
                 }
-                if (with_infill && m_support_params.base_fill_pattern == ipLightning)
+                if (m_support_params.base_fill_pattern == ipLightning)
                 {
                     double print_z = ts_layer->print_z;
                     if (printZ_to_lightninglayer.find(print_z) == printZ_to_lightninglayer.end())
@@ -1619,11 +1618,7 @@ void TreeSupport::generate_toolpaths()
                     // strengthen lightnings while it may make support harder. decide to enable it or not. if yes, proper values for params are remained to be tested
                     auto& lightning_layer = generator->getTreesForLayer(printZ_to_lightninglayer[print_z]);
 
-                    Flow       flow  = (layer_id == 0 && m_raft_layers == 0) ?
+                    Flow       flow  = (layer_id == 0 && m_raft_layers == 0) ? m_object->print()->brim_flow() :support_flow;
-                                           m_object->print()->brim_flow() :
-                                           (m_support_params.base_fill_pattern == ipRectilinear && (layer_id % num_layers_to_change_infill_direction == 0) ?
-                                                support_transition_flow(m_object) :
-                                                support_flow);
                     ExPolygons areas = offset_ex(ts_layer->base_areas, -flow.scaled_spacing());
 
                     for (auto& area : areas)
@@ -1981,7 +1976,7 @@ void TreeSupport::draw_circles(const std::vector<std::vector<Node*>>& contact_no
 {
     const PrintObjectConfig &config = m_object->config();
     bool has_brim = m_object->print()->has_brim();
-    bool has_infill = config.tree_support_with_infill.value;
+    bool has_infill = config.support_base_pattern.value != smpNone;
     int bottom_gap_layers = round(m_slicing_params.gap_object_support / m_slicing_params.layer_height);
     const coordf_t branch_radius = config.tree_support_branch_diameter.value / 2;
     const coordf_t branch_radius_scaled = scale_(branch_radius);
@@ -2022,7 +2017,7 @@ void TreeSupport::draw_circles(const std::vector<std::vector<Node*>>& contact_no
     const coordf_t line_width = config.support_line_width;
     const coordf_t line_width_scaled           = scale_(line_width);
 
-    const bool with_lightning_infill = config.tree_support_with_infill.value && config.support_base_pattern.value == smpLightning;
+    const bool with_lightning_infill = m_support_params.base_fill_pattern == ipLightning;
     coordf_t support_extrusion_width = config.support_line_width.value > 0 ? config.support_line_width : config.line_width;
     const size_t wall_count = config.tree_support_wall_count.value;
 
@@ -2059,6 +2054,7 @@ void TreeSupport::draw_circles(const std::vector<std::vector<Node*>>& contact_no
                 ExPolygons& roof_areas = ts_layer->roof_areas;
                 ExPolygons& roof_1st_layer = ts_layer->roof_1st_layer;
                 ExPolygons& floor_areas = ts_layer->floor_areas;
+                ExPolygons& roof_gap_areas = ts_layer->roof_gap_areas;
 
                 BOOST_LOG_TRIVIAL(debug) << "circles at layer " << layer_nr << " contact nodes size=" << contact_nodes[layer_nr].size();
                 //Draw the support areas and add the roofs appropriately to the support roof instead of normal areas.
@@ -2070,8 +2066,11 @@ void TreeSupport::draw_circles(const std::vector<std::vector<Node*>>& contact_no
 
                     const Node& node = *p_node;
                     ExPolygon area;
-                    // 如果是混合支撑里的普通部分，或没有启用顶部接触层，则直接从overhang多边形生成
+                    // 直接从overhang多边形生成，如果：
-                    if (node.type == ePolygon || (top_interface_layers>0 &&node.support_roof_layers_below > 0)) {
+                    // 1) 是混合支撑里的普通部分，
+                    // 2) 启用了顶部接触层，
+                    // 3) 是顶部空隙
+                    if (node.type == ePolygon || (top_interface_layers>0 &&node.support_roof_layers_below > 0) || node.distance_to_top<0) {
                         auto tmp = offset_ex({ *node.overhang }, scale_(m_ts_data->m_xy_distance));
                         if(!tmp.empty()) // 对于有缺陷的模型，overhang膨胀以后可能是空的！
                             area = tmp[0];
@@ -2080,7 +2079,7 @@ void TreeSupport::draw_circles(const std::vector<std::vector<Node*>>& contact_no
                         Polygon circle;
                         size_t layers_to_top = node.distance_to_top;
                         double  scale;
-                        if (top_interface_layers>0) { // if has infill, branch circles should be larger
+                        if (top_interface_layers>0) { // if has interface, branch circles should be larger
                             scale = static_cast<double>(layers_to_top + 1) / tip_layers;
                             scale = layers_to_top < tip_layers ? (0.5 + scale / 2) : (1 + static_cast<double>(layers_to_top - tip_layers) * diameter_angle_scale_factor);
                         } else {
@@ -2100,7 +2099,9 @@ void TreeSupport::draw_circles(const std::vector<std::vector<Node*>>& contact_no
                         area = ExPolygon(circle);
                     }
 
-                    if (node.support_roof_layers_below == 1)
+                    if (node.distance_to_top < 0)
+                        roof_gap_areas.emplace_back(area);
+                    else if (node.support_roof_layers_below == 1)
                     {
                         roof_1st_layer.emplace_back(area);
                     }
@@ -2149,6 +2150,7 @@ void TreeSupport::draw_circles(const std::vector<std::vector<Node*>>& contact_no
                 base_areas = avoid_object_remove_extra_small_parts(base_areas, avoid_region);
                 base_areas = std::move(diff_ex(base_areas, roof_areas));
                 base_areas = std::move(diff_ex(base_areas, roof_1st_layer));
+                base_areas = std::move(diff_ex(base_areas, roof_gap_areas));
 
                 if (SQUARE_SUPPORT) {
                     // simplify support contours
@@ -2433,7 +2435,7 @@ void TreeSupport::drop_nodes(std::vector<std::vector<Node*>>& contact_nodes)
         //m_object->print()->set_status(59, "Support: preparing avoidance regions ");
         // get all the possible radiis
         std::vector<std::set<coordf_t> > all_layer_radius(m_highest_overhang_layer+1);
-        std::vector<std::set<size_t> > all_layer_node_dist(m_highest_overhang_layer+1);
+        std::vector<std::set<int> > all_layer_node_dist(m_highest_overhang_layer+1);
         for (size_t layer_nr = m_highest_overhang_layer; layer_nr > 0; layer_nr--)
         {
             auto& layer_contact_nodes = contact_nodes[layer_nr];
@@ -2509,6 +2511,13 @@ void TreeSupport::drop_nodes(std::vector<std::vector<Node*>>& contact_nodes)
         {
             const Node& node = *p_node;
 
+            if (node.distance_to_top < 0) {
+                // virtual node do not merge or move
+                Node* next_node = new Node(p_node->position, p_node->distance_to_top + 1, p_node->skin_direction, p_node->support_roof_layers_below - 1, p_node->to_buildplate, p_node,
+                    m_object->get_layer(layer_nr - 1)->print_z, m_object->get_layer(layer_nr - 1)->height);
+                contact_nodes[layer_nr - 1].emplace_back(next_node);
+                continue;
+            }
             if (support_on_buildplate_only && !node.to_buildplate) //Can't rest on model and unable to reach the build plate. Then we must drop the node and leave parts unsupported.
             {
                 unsupported_branch_leaves.push_front({ layer_nr, p_node });
@@ -2960,7 +2969,7 @@ void TreeSupport::generate_contact_points(std::vector<std::vector<TreeSupport::N
     if (!m_slicing_params.soluble_interface && m_object_config->thick_bridges) {
         z_distance_top += m_object->layers()[0]->regions()[0]->region().bridging_height_avg(m_object->print()->config()) - layer_height;
     }
-    const size_t z_distance_top_layers = round_up_divide(scale_(z_distance_top), scale_(layer_height)) + 1; //Support must always be 1 layer below overhang.
+    const int z_distance_top_layers = round_up_divide(scale_(z_distance_top), scale_(layer_height)) + 1; //Support must always be 1 layer below overhang.
 
     const size_t support_roof_layers = config.support_interface_top_layers.value + 1; // BBS: add a normal support layer below interface
     coordf_t  thresh_angle           = config.support_threshold_angle.value < EPSILON ? 30.f : config.support_threshold_angle.value;
@@ -2973,11 +2982,11 @@ void TreeSupport::generate_contact_points(std::vector<std::vector<TreeSupport::N
     m_highest_overhang_layer = 0;
     int      nonempty_layers = 0;
     std::vector<Slic3r::Vec3f> all_nodes;
-    for (size_t layer_nr = 1; layer_nr < m_object->layers().size() - z_distance_top_layers; layer_nr++)
+    for (size_t layer_nr = 1; layer_nr < m_object->layers().size(); layer_nr++)
     {
         if (m_object->print()->canceled())
             break;
-        auto              ts_layer = m_object->get_tree_support_layer(layer_nr + m_raft_layers + z_distance_top_layers);
+        auto              ts_layer = m_object->get_tree_support_layer(layer_nr + m_raft_layers);
         const ExPolygons &overhang = ts_layer->overhang_areas;
         auto &          curr_nodes = contact_nodes[layer_nr];
         if (overhang.empty())
@@ -2994,7 +3003,7 @@ void TreeSupport::generate_contact_points(std::vector<std::vector<TreeSupport::N
                 Point candidate = overhang_bounds.center();
                 if (!overhang_part.contains(candidate))
                     move_inside_expoly(overhang_part, candidate);
-                Node *contact_node     = new Node(candidate, 0, (layer_nr + z_distance_top_layers) % 2, support_roof_layers, true, Node::NO_PARENT, print_z, height);
+                Node *contact_node     = new Node(candidate, -z_distance_top_layers, (layer_nr) % 2, support_roof_layers+ z_distance_top_layers, true, Node::NO_PARENT, print_z, height);
                 contact_node->type = ePolygon;
                 contact_node->overhang = &overhang_part;
                 curr_nodes.emplace_back(contact_node);
@@ -3020,9 +3029,8 @@ void TreeSupport::generate_contact_points(std::vector<std::vector<TreeSupport::N
                         // collision radius has to be 0 or the supports are too few at curved slopes
                         //if (!is_inside_ex(m_ts_data->get_collision(0, layer_nr), candidate))
                         {
-                            constexpr size_t distance_to_top = 0;
                             constexpr bool to_buildplate = true;
-                            Node* contact_node = new Node(candidate, distance_to_top, (layer_nr + z_distance_top_layers) % 2, support_roof_layers, to_buildplate, Node::NO_PARENT,print_z,height);
+                            Node* contact_node = new Node(candidate, -z_distance_top_layers, (layer_nr) % 2, support_roof_layers+ z_distance_top_layers, to_buildplate, Node::NO_PARENT,print_z,height);
                             contact_node->overhang = &overhang_part;
                             curr_nodes.emplace_back(contact_node);
                             added = true;
@@ -3043,9 +3051,8 @@ void TreeSupport::generate_contact_points(std::vector<std::vector<TreeSupport::N
                 for (Point candidate : candidates) {
                     if (!overhang_part.contains(candidate))
                         move_inside_expoly(overhang_part, candidate);
-                    constexpr size_t distance_to_top = 0;
                     constexpr bool   to_buildplate   = true;
-                    Node *           contact_node    = new Node(candidate, distance_to_top, layer_nr % 2, support_roof_layers, to_buildplate, Node::NO_PARENT, print_z, height);
+                    Node *           contact_node    = new Node(candidate, -z_distance_top_layers, layer_nr % 2, support_roof_layers+ z_distance_top_layers, to_buildplate, Node::NO_PARENT, print_z, height);
                     contact_node->overhang           = &overhang_part;
                     curr_nodes.emplace_back(contact_node);
                 }
@@ -3058,7 +3065,7 @@ void TreeSupport::generate_contact_points(std::vector<std::vector<TreeSupport::N
                     auto v1 = (pt - points[(i - 1 + points.size()) % points.size()]).normalized();
                     auto v2 = (pt - points[(i + 1) % points.size()]).normalized();
                     if (v1.dot(v2) > -0.7) {
-                        Node *contact_node = new Node(pt, 0, layer_nr % 2, support_roof_layers, true, Node::NO_PARENT, print_z, height);
+                        Node *contact_node = new Node(pt, -z_distance_top_layers, layer_nr % 2, support_roof_layers+ z_distance_top_layers, true, Node::NO_PARENT, print_z, height);
                         contact_node->overhang = &overhang_part;
                         curr_nodes.emplace_back(contact_node);
                     }

src/libslic3r/TreeSupport.hpp

@@ -223,7 +223,7 @@ public:
          , height(0.0)
         {}
 
-        Node(const Point position, const size_t distance_to_top, const bool skin_direction, const int support_roof_layers_below, const bool to_buildplate, Node* parent,
+        Node(const Point position, const int distance_to_top, const bool skin_direction, const int support_roof_layers_below, const bool to_buildplate, Node* parent,
              coordf_t     print_z_, coordf_t height_)
          : distance_to_top(distance_to_top)
          , position(position)
@@ -252,8 +252,9 @@ public:
 
         /*!
          * \brief The number of layers to go to the top of this branch.
+         * Negative value means it's a virtual node between support and overhang, which doesn't need to be extruded.
          */
-        size_t distance_to_top;
+        int distance_to_top;
 
         /*!
          * \brief The position of this node on the layer.

src/slic3r/GUI/ConfigManipulation.cpp

@@ -538,7 +538,7 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, co
     toggle_field("support_threshold_angle", have_support_material && (support_type == stNormalAuto || support_type == stTreeAuto || support_type==stHybridAuto));
     //toggle_field("support_closing_radius", have_support_material && support_style == smsSnug);
 
-    for (auto el : {"tree_support_branch_angle", "tree_support_wall_count", "tree_support_with_infill", "tree_support_branch_distance", "tree_support_branch_diameter"})
+    for (auto el : {"tree_support_branch_angle", "tree_support_wall_count", "tree_support_branch_distance", "tree_support_branch_diameter"})
         toggle_field(el, config->opt_bool("enable_support") && (support_type == stTreeAuto || support_type == stTree || support_type == stHybridAuto));
 
     // hide tree support settings when normal is selected
@@ -547,7 +547,6 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, co
     toggle_line("tree_support_branch_diameter", support_is_tree);
     toggle_line("tree_support_branch_angle", support_is_tree);
     toggle_line("tree_support_wall_count", support_is_tree);
-    toggle_line("tree_support_with_infill", support_is_tree);
     toggle_line("max_bridge_length", support_is_tree);
 
     // tree support use max_bridge_length instead of bridge_no_support

src/slic3r/GUI/GUI_Factories.cpp

@@ -78,9 +78,9 @@ std::map<std::string, std::vector<SimpleSettingData>>  SettingsFactory::OBJECT_C
                     }},
     { L("Support"), {{"brim_type", "",1},{"brim_width", "",2},{"brim_object_gap", "",3},
                     {"enable_support", "",4},{"support_type", "",5},{"support_threshold_angle", "",6},{"support_on_build_plate_only", "",7},
-                    {"support_filament", "",8},{"support_interface_filament", "",9},{"support_expansion", "",25},
+                    {"support_filament", "",8},{"support_interface_filament", "",9},{"support_expansion", "",24},
-                     {"tree_support_branch_angle", "",10}, {"tree_support_wall_count", "",11},{"tree_support_with_infill", "",12},//tree support
+                     {"tree_support_branch_angle", "",10}, {"tree_support_wall_count", "",11},//tree support
-                            {"support_top_z_distance", "",13},{"support_bottom_z_distance", "",24},{"support_base_pattern", "",14},{"support_base_pattern_spacing", "",15},
+                            {"support_top_z_distance", "",13},{"support_bottom_z_distance", "",12},{"support_base_pattern", "",14},{"support_base_pattern_spacing", "",15},
                             {"support_interface_top_layers", "",16},{"support_interface_bottom_layers", "",17},{"support_interface_spacing", "",18},{"support_bottom_interface_spacing", "",19},
                             {"support_object_xy_distance", "",20}, {"bridge_no_support", "",21},{"max_bridge_length", "",22},{"support_critical_regions_only", "",23}
                             }},
@@ -141,7 +141,7 @@ std::vector<SimpleSettingData> SettingsFactory::get_visible_options(const std::s
         //Support
         "enable_support", "support_type", "support_threshold_angle", "support_on_build_plate_only", "support_critical_regions_only", "enforce_support_layers",
         //tree support
-        "tree_support_wall_count", "tree_support_with_infill",
+        "tree_support_wall_count",
         //support
         "support_top_z_distance", "support_base_pattern", "support_base_pattern_spacing", "support_interface_top_layers", "support_interface_bottom_layers", "support_interface_spacing", "support_bottom_interface_spacing", "support_object_xy_distance",
         //adhesion

src/slic3r/GUI/Tab.cpp

@@ -1888,7 +1888,6 @@ void TabPrint::build()
         optgroup->append_single_option_line("tree_support_branch_diameter", "support#tree-support-only-options");
         optgroup->append_single_option_line("tree_support_branch_angle", "support#tree-support-only-options");
         optgroup->append_single_option_line("tree_support_wall_count");
-        optgroup->append_single_option_line("tree_support_with_infill");
         optgroup->append_single_option_line("support_top_z_distance", "support#top-z-distance");
         optgroup->append_single_option_line("support_bottom_z_distance", "support#bottom-z-distance");
         optgroup->append_single_option_line("support_base_pattern", "support#base-pattern");