Redesign: add Resin-like as new support type instead of tree style

Co-authored-by: ImLevath <191364547+ImLevath@users.noreply.github.com>

Author: Copilot

src/libslic3r/Print.cpp

@@ -1318,7 +1318,7 @@ StringObjectException Print::validate(StringObjectException *warning, Polygons*
     for (size_t print_object_idx = 0; print_object_idx < m_objects.size(); ++ print_object_idx)
         if (const PrintObject &print_object = *m_objects[print_object_idx];
             print_object.has_support_material() && is_tree(print_object.config().support_type.value) && (print_object.config().support_style.value == smsTreeOrganic ||
-                print_object.config().support_style.value == smsResinLike ||
+                is_resin_like(print_object.config().support_type.value) ||
                 // Orca: use organic as default
                 print_object.config().support_style.value == smsDefault) &&
             print_object.model_object()->has_custom_layering()) {
@@ -1492,7 +1492,7 @@ StringObjectException Print::validate(StringObjectException *warning, Polygons*
                 // Prusa: Fixing crashes with invalid tip diameter or branch diameter
                 // https://github.com/prusa3d/PrusaSlicer/commit/96b3ae85013ac363cd1c3e98ec6b7938aeacf46d
                 if (is_tree(object->config().support_type.value) && (object->config().support_style == smsTreeOrganic ||
-                    object->config().support_style == smsResinLike ||
+                    is_resin_like(object->config().support_type.value) ||
                     // Orca: use organic as default
                     object->config().support_style == smsDefault)) {
                     float extrusion_width = std::min(

src/libslic3r/PrintConfig.cpp

@@ -299,8 +299,7 @@ static t_config_enum_values s_keys_map_SupportMaterialStyle {
     { "organic",        smsTreeOrganic },
     { "tree_slim",      smsTreeSlim },
     { "tree_strong",    smsTreeStrong },
-    { "tree_hybrid",    smsTreeHybrid },
-    { "resin_like",     smsResinLike }
+    { "tree_hybrid",    smsTreeHybrid }
 };
 CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(SupportMaterialStyle)
 
@@ -314,10 +313,11 @@ static t_config_enum_values s_keys_map_SupportMaterialInterfacePattern {
 CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(SupportMaterialInterfacePattern)
 
 static t_config_enum_values s_keys_map_SupportType{
-    { "normal(auto)",   stNormalAuto },
-    { "tree(auto)", stTreeAuto },
-    { "normal(manual)", stNormal },
-    { "tree(manual)", stTree }
+    { "normal(auto)",       stNormalAuto },
+    { "tree(auto)",         stTreeAuto },
+    { "normal(manual)",     stNormal },
+    { "tree(manual)",       stTree },
+    { "resin_like(auto)",   stResinLikeAuto }
 };
 CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(SupportType)
 
@@ -5554,17 +5554,21 @@ void PrintConfigDef::init_fff_params()
     def = this->add("support_type", coEnum);
     def->label = L("Type");
     def->category = L("Support");
-    def->tooltip = L("Normal (auto) and Tree (auto) are used to generate support automatically. "
-                     "If Normal (manual) or Tree (manual) is selected, only support enforcers are generated.");
+    def->tooltip = L("Normal (auto) and Tree (auto) generate support automatically. "
+                     "Normal (manual) or Tree (manual) generate support only on enforcers. "
+                     "Resin-like (auto) generates thin-pillar point-contact supports inspired by SLA printers, "
+                     "for easy removal.");
     def->enum_keys_map = &ConfigOptionEnum<SupportType>::get_enum_values();
     def->enum_values.push_back("normal(auto)");
     def->enum_values.push_back("tree(auto)");
     def->enum_values.push_back("normal(manual)");
     def->enum_values.push_back("tree(manual)");
+    def->enum_values.push_back("resin_like(auto)");
     def->enum_labels.push_back(L("Normal (auto)"));
     def->enum_labels.push_back(L("Tree (auto)"));
     def->enum_labels.push_back(L("Normal (manual)"));
     def->enum_labels.push_back(L("Tree (manual)"));
+    def->enum_labels.push_back(L("Resin-like (auto)"));
     def->mode = comSimple;
     def->set_default_value(new ConfigOptionEnum<SupportType>(stNormalAuto));
 
@@ -5846,9 +5850,7 @@ void PrintConfigDef::init_fff_params()
                      "object scarring.\n"
                      "For tree support, slim and organic style will merge branches more aggressively and save "
                      "a lot of material (default organic), while hybrid style will create similar structure to normal support "
-                     "under large flat overhangs.\n"
-                     "Resin-like style uses very thin branching pillars with tiny contact tips inspired by SLA/resin printer "
-                     "supports, minimizing contact area for easy removal while reliably supporting overhangs.");
+                     "under large flat overhangs.");
     def->enum_keys_map = &ConfigOptionEnum<SupportMaterialStyle>::get_enum_values();
     def->enum_values.push_back("default");
     def->enum_values.push_back("grid");
@@ -5857,15 +5859,13 @@ void PrintConfigDef::init_fff_params()
     def->enum_values.push_back("tree_slim");
     def->enum_values.push_back("tree_strong");
     def->enum_values.push_back("tree_hybrid");
-    def->enum_values.push_back("resin_like");
     def->enum_labels.push_back(L("Default (Grid/Organic)"));
     def->enum_labels.push_back(L("Grid"));
     def->enum_labels.push_back(L("Snug"));
     def->enum_labels.push_back(L("Organic"));
     def->enum_labels.push_back(L("Tree Slim"));
     def->enum_labels.push_back(L("Tree Strong"));
     def->enum_labels.push_back(L("Tree Hybrid"));
-    def->enum_labels.push_back(L("Resin-like"));
 
     def->mode = comAdvanced;
     def->set_default_value(new ConfigOptionEnum<SupportMaterialStyle>(smsDefault));

src/libslic3r/PrintConfig.hpp

@@ -160,7 +160,7 @@ enum SupportMaterialPattern {
 };
 
 enum SupportMaterialStyle {
-    smsDefault, smsGrid, smsSnug, smsTreeOrganic, smsTreeSlim, smsTreeStrong, smsTreeHybrid, smsResinLike,
+    smsDefault, smsGrid, smsSnug, smsTreeOrganic, smsTreeSlim, smsTreeStrong, smsTreeHybrid,
 };
 
 enum LongRectrationLevel
@@ -176,19 +176,23 @@ enum SupportMaterialInterfacePattern {
 
 // BBS
 enum SupportType {
-    stNormalAuto, stTreeAuto, stNormal, stTree
+    stNormalAuto, stTreeAuto, stNormal, stTree, stResinLikeAuto
 };
 inline bool is_tree(SupportType stype)
 {
-    return std::set<SupportType>{stTreeAuto, stTree}.count(stype) != 0;
+    return std::set<SupportType>{stTreeAuto, stTree, stResinLikeAuto}.count(stype) != 0;
 };
 inline bool is_tree_slim(SupportType type, SupportMaterialStyle style)
 {
     return is_tree(type) && style==smsTreeSlim;
 };
 inline bool is_auto(SupportType stype)
 {
-    return std::set<SupportType>{stNormalAuto, stTreeAuto}.count(stype) != 0;
+    return std::set<SupportType>{stNormalAuto, stTreeAuto, stResinLikeAuto}.count(stype) != 0;
+};
+inline bool is_resin_like(SupportType stype)
+{
+    return stype == stResinLikeAuto;
 };
 
 enum SeamPosition {

src/libslic3r/Support/SupportCommon.cpp

@@ -1745,8 +1745,7 @@ void generate_support_toolpaths(
                     filler->link_max_length = coord_t(scale_(filler->spacing * link_max_length_factor / density));
                     sheath  = true;
                     no_sort = true;
-                } else if (support_params.support_style == SupportMaterialStyle::smsTreeOrganic ||
-                           support_params.support_style == SupportMaterialStyle::smsResinLike) {
+                } else if (support_params.support_style == SupportMaterialStyle::smsTreeOrganic) {
                     // if the tree supports are too tall, use double wall to make it stronger
                     SupportParameters support_params2 = support_params;
                     if (support_layer.print_z > 100.0)

src/libslic3r/Support/SupportMaterial.cpp

@@ -650,7 +650,7 @@ class SupportGridPattern
         m_support_material_closing_radius(params.support_closing_radius)
     {
         if (m_style == smsDefault) m_style = smsGrid;
-        if (std::set<SupportMaterialStyle>{smsTreeSlim, smsTreeStrong, smsTreeHybrid, smsTreeOrganic, smsResinLike}.count(m_style))
+        if (std::set<SupportMaterialStyle>{smsTreeSlim, smsTreeStrong, smsTreeHybrid, smsTreeOrganic}.count(m_style))
             m_style = smsGrid;
         switch (m_style) {
         case smsGrid:
@@ -747,7 +747,6 @@ class SupportGridPattern
         case smsTreeStrong:
         case smsTreeHybrid:
         case smsTreeOrganic:
-        case smsResinLike:
             assert(false);
             //[[fallthrough]];
             return Polygons();

src/libslic3r/Support/SupportParameters.hpp

@@ -173,11 +173,14 @@ struct SupportParameters {
         support_style = object_config.support_style;
         if (support_style != smsDefault) {
             if ((support_style == smsSnug || support_style == smsGrid) && is_tree(object_config.support_type)) support_style = smsDefault;
-            if ((support_style == smsTreeSlim || support_style == smsTreeStrong || support_style == smsTreeHybrid || support_style == smsTreeOrganic || support_style == smsResinLike) &&
+            if ((support_style == smsTreeSlim || support_style == smsTreeStrong || support_style == smsTreeHybrid || support_style == smsTreeOrganic) &&
                 !is_tree(object_config.support_type))
                 support_style = smsDefault;
         }
-        if (support_style == smsDefault) {
+        // Resin-like type always uses organic generation; ignore any user-set style.
+        if (is_resin_like(object_config.support_type.value))
+            support_style = smsTreeOrganic;
+        else if (support_style == smsDefault) {
             if (is_tree(object_config.support_type)) {
                 // Orca: use organic as default
                 support_style = smsTreeOrganic;

src/libslic3r/Support/TreeSupport.cpp

@@ -1659,7 +1659,7 @@ void TreeSupport::generate()
 {
     if (!is_tree(m_object_config->support_type.value)) return;
 
-    if (m_support_params.support_style == smsTreeOrganic || m_support_params.support_style == smsResinLike) {
+    if (m_support_params.support_style == smsTreeOrganic) {
         generate_tree_support_3D(*m_object, this, this->throw_on_cancel);
         return;
     }

src/libslic3r/Support/TreeSupportCommon.hpp

@@ -92,19 +92,19 @@ struct TreeSupportMeshGroupSettings {
     //    this->support_tree_tip_diameter = this->support_line_width;
         this->support_tree_tip_diameter = std::clamp(scaled<coord_t>(config.tree_support_tip_diameter.value), (coord_t)0, this->support_tree_branch_diameter);
 
-        // For resin-like style, use very thin contact tips and narrow branches (SLA-inspired).
-        if (config.support_style.value == smsResinLike) {
-            // Tip diameter: use support line width (the minimum printable size) for a pin-head contact point.
+        // Resin-like type: apply SLA-inspired thin-pillar, pin-head parameters automatically.
+        if (is_resin_like(config.support_type.value)) {
+            // Tip diameter: use support line width for a single-extrusion pin-head contact point.
             this->support_tree_tip_diameter    = this->support_line_width;
-            // Branch diameter: keep branches thin — at most 2× the line width or the configured value, whichever is smaller.
+            // Branch diameter: thin pillars — at most 2× line width or the configured value, whichever is smaller.
             this->support_tree_branch_diameter = std::min(this->support_tree_branch_diameter,
                                                           this->support_line_width * 2);
             // Ensure tip_diameter does not exceed branch_diameter.
             this->support_tree_tip_diameter    = std::min(this->support_tree_tip_diameter,
                                                           this->support_tree_branch_diameter);
-            // Use a high top-rate so the thin tips densely cover the overhang.
+            // High top-rate so thin tips densely cover the overhang area.
             this->support_tree_top_rate        = 30.;
-            // Reduce roof/floor interface to 1 layer — resin supports need minimal flat interface.
+            // Minimal flat interface (1 layer) — easier removal, like resin supports.
             if (this->support_roof_enable && this->support_roof_layers > 1)
                 this->support_roof_layers = 1;
             if (this->support_floor_enable && this->support_floor_layers > 1)

src/slic3r/GUI/ConfigManipulation.cpp

@@ -472,7 +472,7 @@ void ConfigManipulation::update_print_fff_config(DynamicPrintConfig* config, con
         auto   support_type = config->opt_enum<SupportType>("support_type");
         auto   support_style = config->opt_enum<SupportMaterialStyle>("support_style");
         std::set<int> enum_set_normal = { smsDefault, smsGrid, smsSnug };
-        std::set<int> enum_set_tree   = { smsDefault, smsTreeSlim, smsTreeStrong, smsTreeHybrid, smsTreeOrganic, smsResinLike };
+        std::set<int> enum_set_tree   = { smsDefault, smsTreeSlim, smsTreeStrong, smsTreeHybrid, smsTreeOrganic };
         auto &           set             = is_tree(support_type) ? enum_set_tree : enum_set_normal;
         if (set.find(support_style) == set.end()) {
             DynamicPrintConfig new_conf = *config;
@@ -743,9 +743,10 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, co
     //toggle_field("support_closing_radius", have_support_material && support_style == smsSnug);
 
     bool support_is_tree = config->opt_bool("enable_support") && is_tree(support_type);
-    bool support_is_normal_tree = support_is_tree && support_style != smsTreeOrganic &&
+    // Resin-like is always organic (auto-configured, no manual normal-tree settings needed)
+    bool support_is_normal_tree = support_is_tree && !is_resin_like(support_type) && support_style != smsTreeOrganic &&
     // Orca: use organic as default
-    support_style != smsDefault && support_style != smsResinLike;
+    support_style != smsDefault;
     bool support_is_organic = support_is_tree && !support_is_normal_tree;
     // settings shared by normal and organic trees
     for (auto el : {"tree_support_branch_angle", "tree_support_branch_distance", "tree_support_branch_diameter" })

src/slic3r/GUI/Tab.cpp

@@ -2749,7 +2749,7 @@ void TabPrint::toggle_options()
     if (auto choice = dynamic_cast<Choice*>(field)) {
         auto def = print_config_def.get("support_style");
         std::vector<int> enum_set_normal = {smsDefault, smsGrid, smsSnug };
-        std::vector<int> enum_set_tree   = { smsDefault, smsTreeSlim, smsTreeStrong, smsTreeHybrid, smsTreeOrganic, smsResinLike };
+        std::vector<int> enum_set_tree   = { smsDefault, smsTreeSlim, smsTreeStrong, smsTreeHybrid, smsTreeOrganic };
         auto &           set             = is_tree(support_type) ? enum_set_tree : enum_set_normal;
         auto &           opt             = const_cast<ConfigOptionDef &>(field->m_opt);
         auto             cb              = dynamic_cast<ComboBox *>(choice->window);
@@ -2763,6 +2763,9 @@ void TabPrint::toggle_options()
             cb->Append(_(def->enum_labels[i]));
         }
         cb->SetValue(n);
+        // Hide the style selector for resin-like: its geometry is fully determined by the type.
+        if (auto line = m_active_page->get_line("support_style"))
+            line->toggle(!is_resin_like(support_type));
     }
 
     // BBL printers do not support cone wipe tower