Add auto-wrap/shrink and multiline surface curve following.

Extend Text Shape with wrap-to-width, optional height box with auto-shrink, and per-line surface contour sampling so multiline text follows the mesh instead of a flat stamp.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: rhys100

src/libslic3r/Emboss.cpp

@@ -1702,6 +1702,172 @@ double Emboss::get_text_shape_scale(const FontProp &fp, const FontFile &ff)
     return scale * SHAPE_SCALE;
 }
 
+namespace {
+double measure_line_width_mm(FontFileWithCache &font_with_cache, const FontProp &font_prop, const std::wstring &line)
+{
+    if (!font_with_cache.has_value() || line.empty())
+        return 0.;
+    const double  scale = get_text_shape_scale(font_prop, *font_with_cache.font_file);
+    fontinfo_opt  font_info_cache;
+    Point         cursor(0, 0);
+    for (wchar_t letter : line) {
+        if (letter == '\n' || letter == '\r')
+            continue;
+        letter2shapes(letter, cursor, font_with_cache, font_prop, font_info_cache);
+    }
+    return cursor.x() * scale;
+}
+
+double measure_text_height_mm(FontFileWithCache &font_with_cache, const FontProp &font_prop, const std::string &text)
+{
+    if (!font_with_cache.has_value())
+        return 0.;
+    const unsigned lines = std::max(1u, get_count_lines(text));
+    const double   scale = get_text_shape_scale(font_prop, *font_with_cache.font_file);
+    return get_line_height(*font_with_cache.font_file, font_prop) * scale * lines;
+}
+} // namespace
+
+std::string Emboss::apply_text_wrap(FontFileWithCache &font_with_cache, const std::string &text, const FontProp &font_prop, double wrap_width_mm)
+{
+    if (!font_with_cache.has_value() || wrap_width_mm <= 1e-3 || text.empty())
+        return text;
+
+    const std::wstring src = boost::nowide::widen(text);
+    std::wstring       out;
+    out.reserve(src.size() + 8);
+
+    size_t para_start = 0;
+    while (para_start <= src.size()) {
+        size_t para_end = src.find('\n', para_start);
+        if (para_end == std::wstring::npos)
+            para_end = src.size();
+        const std::wstring paragraph = src.substr(para_start, para_end - para_start);
+
+        std::wstring line;
+        auto         flush_line = [&]() {
+            if (line.empty())
+                return;
+            if (!out.empty())
+                out.push_back('\n');
+            out += line;
+            line.clear();
+        };
+
+        size_t i = 0;
+        while (i < paragraph.size()) {
+            size_t start = i;
+            if (paragraph[i] == ' ' || paragraph[i] == '\t') {
+                while (i < paragraph.size() && (paragraph[i] == ' ' || paragraph[i] == '\t'))
+                    ++i;
+            } else {
+                while (i < paragraph.size() && paragraph[i] != ' ' && paragraph[i] != '\t')
+                    ++i;
+            }
+            const std::wstring token = paragraph.substr(start, i - start);
+            const std::wstring trial = line + token;
+            if (line.empty() || measure_line_width_mm(font_with_cache, font_prop, trial) <= wrap_width_mm) {
+                line = trial;
+                continue;
+            }
+            flush_line();
+            if (measure_line_width_mm(font_with_cache, font_prop, token) <= wrap_width_mm) {
+                line = token;
+            } else {
+                for (wchar_t ch : token) {
+                    std::wstring next = line;
+                    next.push_back(ch);
+                    if (!line.empty() && measure_line_width_mm(font_with_cache, font_prop, next) > wrap_width_mm) {
+                        flush_line();
+                        line.assign(1, ch);
+                    } else {
+                        line.swap(next);
+                    }
+                }
+            }
+        }
+        flush_line();
+
+        // Preserve blank lines from consecutive Enter presses
+        if (para_end < src.size() && paragraph.empty()) {
+            if (!out.empty())
+                out.push_back('\n');
+        }
+
+        if (para_end >= src.size())
+            break;
+        para_start = para_end + 1;
+    }
+
+    return boost::nowide::narrow(out);
+}
+
+std::string Emboss::fit_text_to_box(FontFileWithCache &font_with_cache,
+                                   FontProp &         font_prop,
+                                   const std::string &text,
+                                   double             wrap_width_mm,
+                                   double             wrap_height_mm,
+                                   bool               do_wrap,
+                                   bool               do_shrink)
+{
+    if (!font_with_cache.has_value() || text.empty())
+        return text;
+
+    const float original_size = font_prop.size_in_mm;
+    std::string working       = text;
+    // Work on a private glyph cache so fitting does not wipe the caller's style-manager cache.
+    FontFileWithCache local_font = font_with_cache;
+    local_font.cache             = std::make_shared<Glyphs>();
+
+    auto rebuild = [&](float size) {
+        font_prop.size_in_mm = size;
+        local_font.cache     = std::make_shared<Glyphs>();
+        working = do_wrap && wrap_width_mm > 1e-3 ? apply_text_wrap(local_font, text, font_prop, wrap_width_mm) : text;
+    };
+
+    rebuild(original_size);
+
+    if (!do_shrink || wrap_width_mm <= 1e-3)
+        return working;
+
+    auto fits = [&]() {
+        // Width: every line must fit (wrap already enforces when enabled; still check for shrink-only)
+        std::wstring ws = boost::nowide::widen(working);
+        size_t       start = 0;
+        while (start <= ws.size()) {
+            size_t end = ws.find('\n', start);
+            if (end == std::wstring::npos)
+                end = ws.size();
+            if (measure_line_width_mm(local_font, font_prop, ws.substr(start, end - start)) > wrap_width_mm + 1e-3)
+                return false;
+            if (end >= ws.size())
+                break;
+            start = end + 1;
+        }
+        if (wrap_height_mm > 1e-3 && measure_text_height_mm(local_font, font_prop, working) > wrap_height_mm + 1e-3)
+            return false;
+        return true;
+    };
+
+    if (fits())
+        return working;
+
+    float lo = 1.f;
+    float hi = original_size;
+    for (int iter = 0; iter < 16; ++iter) {
+        float mid = 0.5f * (lo + hi);
+        rebuild(mid);
+        if (fits())
+            lo = mid;
+        else
+            hi = mid;
+    }
+    rebuild(lo);
+    if (font_prop.size_in_mm < 1.f)
+        font_prop.size_in_mm = 1.f;
+    return working;
+}
+
 namespace {
 
 void add_quad(uint32_t              i1,

src/libslic3r/Emboss.hpp

@@ -169,6 +169,25 @@ namespace Emboss
     /// <returns>Conversion to mm</returns>
     double get_text_shape_scale(const FontProp &fp, const FontFile &ff);
 
+    /// <summary>
+    /// Insert line breaks so each line fits wrap_width_mm. Preserves existing '\n'.
+    /// Word-wraps on spaces; breaks long words by character when needed.
+    /// </summary>
+    std::string apply_text_wrap(FontFileWithCache &font_with_cache, const std::string &text, const FontProp &font_prop, double wrap_width_mm);
+
+    /// <summary>
+    /// Optionally wrap text to width and/or shrink FontProp::size_in_mm so the layout fits a box.
+    /// When wrap_height_mm &lt;= 0, only width is enforced.
+    /// </summary>
+    /// <returns>Text used for shape generation (may include inserted '\n')</returns>
+    std::string fit_text_to_box(FontFileWithCache &font_with_cache,
+                                FontProp &         font_prop,
+                                const std::string &text,
+                                double             wrap_width_mm,
+                                double             wrap_height_mm,
+                                bool               do_wrap,
+                                bool               do_shrink);
+
     /// <summary>
     /// getter of font info by collection defined in prop
     /// </summary>

src/libslic3r/Format/bbs_3mf.cpp

@@ -249,6 +249,10 @@ static constexpr const char* THICKNESS_ATTR       = "thickness";
 static constexpr const char* EMBEDED_DEPTH_ATTR   = "embeded_depth";
 static constexpr const char* ROTATE_ANGLE_ATTR    = "rotate_angle";
 static constexpr const char* TEXT_GAP_ATTR        = "text_gap";
+static constexpr const char* WRAP_TEXT_ATTR       = "wrap_text";
+static constexpr const char* WRAP_WIDTH_ATTR      = "wrap_width";
+static constexpr const char* WRAP_HEIGHT_ATTR     = "wrap_height";
+static constexpr const char* AUTO_SHRINK_ATTR     = "auto_shrink";
 static constexpr const char* BOLD_ATTR            = "bold";
 static constexpr const char* ITALIC_ATTR          = "italic";
 static constexpr const char *SURFACE_TYPE         = "surface_type";
@@ -4990,6 +4994,14 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         text_info.m_embeded_depth = bbs_get_attribute_value_float(attributes, num_attributes, EMBEDED_DEPTH_ATTR);
         text_info.m_rotate_angle  = bbs_get_attribute_value_float(attributes, num_attributes, ROTATE_ANGLE_ATTR);
         text_info.m_text_gap      = bbs_get_attribute_value_float(attributes, num_attributes, TEXT_GAP_ATTR);
+        if (bbs_has_attribute_value_int(attributes, num_attributes, WRAP_TEXT_ATTR))
+            text_info.m_wrap_text = bbs_get_attribute_value_int(attributes, num_attributes, WRAP_TEXT_ATTR) != 0;
+        if (bbs_has_attribute_value_int(attributes, num_attributes, WRAP_WIDTH_ATTR))
+            text_info.m_wrap_width_mm = bbs_get_attribute_value_float(attributes, num_attributes, WRAP_WIDTH_ATTR);
+        if (bbs_has_attribute_value_int(attributes, num_attributes, WRAP_HEIGHT_ATTR))
+            text_info.m_wrap_height_mm = bbs_get_attribute_value_float(attributes, num_attributes, WRAP_HEIGHT_ATTR);
+        if (bbs_has_attribute_value_int(attributes, num_attributes, AUTO_SHRINK_ATTR))
+            text_info.m_auto_shrink = bbs_get_attribute_value_int(attributes, num_attributes, AUTO_SHRINK_ATTR) != 0;
 
         text_info.m_bold      = bbs_get_attribute_value_int(attributes, num_attributes, BOLD_ATTR);
         text_info.m_italic    = bbs_get_attribute_value_int(attributes, num_attributes, ITALIC_ATTR);
@@ -8038,6 +8050,10 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         stream << EMBEDED_DEPTH_ATTR << "=\"" << text_info.m_embeded_depth << "\" ";
         stream << ROTATE_ANGLE_ATTR << "=\"" << text_info.m_rotate_angle << "\" ";
         stream << TEXT_GAP_ATTR << "=\"" << text_info.m_text_gap << "\" ";
+        stream << WRAP_TEXT_ATTR << "=\"" << (text_info.m_wrap_text ? 1 : 0) << "\" ";
+        stream << WRAP_WIDTH_ATTR << "=\"" << text_info.m_wrap_width_mm << "\" ";
+        stream << WRAP_HEIGHT_ATTR << "=\"" << text_info.m_wrap_height_mm << "\" ";
+        stream << AUTO_SHRINK_ATTR << "=\"" << (text_info.m_auto_shrink ? 1 : 0) << "\" ";
 
         stream << BOLD_ATTR << "=\"" << (text_info.m_bold ? 1 : 0) << "\" ";
         stream << ITALIC_ATTR << "=\"" << (text_info.m_italic ? 1 : 0) << "\" ";

src/libslic3r/Model.hpp

@@ -854,6 +854,10 @@ struct TextInfo
     float       m_embeded_depth = 0.f;
     float       m_rotate_angle    = 0;
     float       m_text_gap        = 0.f;
+    bool        m_wrap_text       = false;
+    float       m_wrap_width_mm   = 40.f;
+    float       m_wrap_height_mm  = 0.f; // 0 = no height limit
+    bool        m_auto_shrink     = false;
     bool        m_is_surface_text = false;//for old
     bool        m_keep_horizontal = false;//for old
     enum TextType {
@@ -867,8 +871,8 @@ struct TextInfo
 
     RaycastResult m_rr;
     template<typename Archive> void serialize(Archive &ar) {
-        ar(m_font_name, m_font_version, m_font_size, m_curr_font_idx, m_bold, m_italic, m_thickness, m_embeded_depth, m_rotate_angle, m_text_gap, m_surface_type, m_text,
-           m_rr,text_configuration);
+        ar(m_font_name, m_font_version, m_font_size, m_curr_font_idx, m_bold, m_italic, m_thickness, m_embeded_depth, m_rotate_angle, m_text_gap, m_wrap_text,
+           m_wrap_width_mm, m_wrap_height_mm, m_auto_shrink, m_surface_type, m_text, m_rr, text_configuration);
     }
     TextConfiguration text_configuration;
 };

src/slic3r/GUI/Gizmos/GLGizmoText.cpp

@@ -1351,15 +1351,6 @@ std::unique_ptr<Emboss::DataBase> GLGizmoText::create_emboss_data_base(
     assert(style_manager.get_wx_font().IsOk());
     assert(style.path.compare(WxFontUtils::store_wxFont(style_manager.get_wx_font())) == 0);
 
-    // Multiline placement uses the Emboss 2D layout, so character spacing must live in FontProp.
-    // Single-line text still applies m_text_gap in GenerateTextJob::calc_position_points.
-    if (get_count_lines(text) > 1) {
-        if (std::abs(m_text_gap) > 1e-4f)
-            style.prop.char_gap = static_cast<int>(std::lround(m_text_gap));
-        else
-            style.prop.char_gap.reset();
-    }
-
     bool is_outside = (type == ModelVolumeType::MODEL_PART);
 
     // Cancel previous Job, when it is in process
@@ -1378,7 +1369,28 @@ std::unique_ptr<Emboss::DataBase> GLGizmoText::create_emboss_data_base(
     base.from_surface = style.distance;
 
     FontFileWithCache &font = style_manager.get_font_file_with_cache();
-    TextConfiguration  tc{static_cast<EmbossStyle>(style), text};
+
+    // Apply auto-wrap / shrink into the shape string; keep UI m_text as the editable source.
+    std::string shape_text = text;
+    if ((m_wrap_text || m_auto_shrink) && font.has_value()) {
+        FontProp fit_prop = style.prop;
+        fit_prop.size_in_mm = m_font_size;
+        shape_text = fit_text_to_box(font, fit_prop, text, m_wrap_width_mm, m_wrap_height_mm, m_wrap_text, m_auto_shrink);
+        style.prop.size_in_mm = fit_prop.size_in_mm;
+        m_font_size           = fit_prop.size_in_mm;
+        m_style_manager.get_font_prop().size_in_mm = fit_prop.size_in_mm;
+    }
+
+    // Multiline placement uses the Emboss 2D layout, so character spacing must live in FontProp.
+    // Single-line text still applies m_text_gap in GenerateTextJob::calc_position_points.
+    if (get_count_lines(shape_text) > 1) {
+        if (std::abs(m_text_gap) > 1e-4f)
+            style.prop.char_gap = static_cast<int>(std::lround(m_text_gap));
+        else
+            style.prop.char_gap.reset();
+    }
+
+    TextConfiguration  tc{static_cast<EmbossStyle>(style), shape_text};
     auto td_ptr = std::make_unique<TextDataBase>(std::move(base), font, std::move(tc), style.projection);
     return td_ptr;
 }
@@ -2366,6 +2378,38 @@ void GLGizmoText::on_render_input_window(float x, float y, float bottom_limit)
 
 
 
+    ImGui::AlignTextToFramePadding();
+    bool wrap_changed = ImGui::Checkbox((_L("Auto wrap")).c_str(), &m_wrap_text);
+    ImGui::SameLine();
+    bool shrink_changed = ImGui::Checkbox((_L("Auto shrink")).c_str(), &m_auto_shrink);
+    if (wrap_changed || shrink_changed)
+        m_need_update_text = true;
+    if (m_wrap_text || m_auto_shrink) {
+        ImGui::AlignTextToFramePadding();
+        m_imgui->text(_L("Wrap width"));
+        ImGui::SameLine(caption_size);
+        ImGui::PushItemWidth(temp_input_width);
+        float old_wrap_w = m_wrap_width_mm;
+        if (ImGui::InputFloat("###text_wrap_width", &m_wrap_width_mm, 0.0f, 0.0f, "%.2f")) {
+            m_wrap_width_mm = ImClamp(m_wrap_width_mm, 1.f, 1000.f);
+            if (old_wrap_w != m_wrap_width_mm)
+                m_need_update_text = true;
+        }
+        ImGui::SameLine();
+        m_imgui->text(_L("Wrap height"));
+        ImGui::SameLine();
+        ImGui::PushItemWidth(temp_input_width);
+        float old_wrap_h = m_wrap_height_mm;
+        if (ImGui::InputFloat("###text_wrap_height", &m_wrap_height_mm, 0.0f, 0.0f, "%.2f")) {
+            m_wrap_height_mm = ImClamp(m_wrap_height_mm, 0.f, 1000.f);
+            if (old_wrap_h != m_wrap_height_mm)
+                m_need_update_text = true;
+        }
+        if (ImGui::IsItemHovered())
+            m_imgui->tooltip(_u8L("Optional max height in mm. 0 means no height limit. With Auto shrink, font size is reduced to fit the box."),
+                             m_gui_cfg->max_tooltip_width);
+    }
+
     ImGui::AlignTextToFramePadding();
     m_imgui->text(_L("Text Gap"));
     ImGui::SameLine(caption_size);
@@ -3096,6 +3140,10 @@ void GLGizmoText::reset_text_info()
     m_embeded_depth = m_style_manager.get_style().projection.embeded_depth;
     m_rotate_angle    = get_angle_from_current_style();
     m_text_gap        = m_style_manager.get_style().prop.char_gap.value_or(0);
+    m_wrap_text       = false;
+    m_wrap_width_mm   = 40.f;
+    m_wrap_height_mm  = 0.f;
+    m_auto_shrink     = false;
     m_surface_type    = TextInfo::TextType::SURFACE;
     m_rr              = RaycastResult();
     m_last_text_mv = nullptr;
@@ -3399,6 +3447,11 @@ bool GLGizmoText::generate_text_volume()
     input_info.m_thickness                  = m_thickness;
     input_info.m_cut_plane_dir_in_world     = m_cut_plane_dir_in_world;
     input_info.use_surface                  = m_surface_type == TextInfo::TextType::SURFACE_CHAR ? true : false;
+    if (m_style_manager.is_active_font() && m_style_manager.get_font_file_with_cache().has_value()) {
+        input_info.font_file = m_style_manager.get_font_file_with_cache().font_file;
+        input_info.font_prop = m_style_manager.get_font_prop();
+        input_info.font_prop.size_in_mm = m_font_size;
+    }
     TextInfo text_info = get_text_info();
 
     ModelObject *model_object = selection.get_model()->objects[m_object_idx];
@@ -3445,6 +3498,10 @@ TextInfo GLGizmoText::get_text_info()
     text_info.m_rr.mesh_id    = m_rr.mesh_id;
     text_info.m_rotate_angle  = m_rotate_angle;
     text_info.m_text_gap      = m_text_gap;
+    text_info.m_wrap_text     = m_wrap_text;
+    text_info.m_wrap_width_mm = m_wrap_width_mm;
+    text_info.m_wrap_height_mm = m_wrap_height_mm;
+    text_info.m_auto_shrink   = m_auto_shrink;
     text_info.m_surface_type  = m_surface_type;
     text_info.text_configuration = m_ui_text_configuration;
     text_info.text_configuration.style.prop.line_gap = m_style_manager.get_font_prop().line_gap;
@@ -3472,6 +3529,10 @@ void GLGizmoText::load_from_text_info(const TextInfo &text_info)
     m_rotate_angle = (float) Geometry::rad2deg(limit_angle);
 
     m_text_gap      = text_info.m_text_gap;
+    m_wrap_text     = text_info.m_wrap_text;
+    m_wrap_width_mm = text_info.m_wrap_width_mm;
+    m_wrap_height_mm = text_info.m_wrap_height_mm;
+    m_auto_shrink   = text_info.m_auto_shrink;
     m_surface_type  = (TextInfo::TextType) text_info.m_surface_type;
 
     if (is_old_text_info(text_info)) { // compatible with older versions