openscad-cpp-evaluator 1.14.0__tar.gz → 1.15.0__tar.gz

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/CLAUDE.md

@@ -298,6 +298,13 @@ variable real OpenSCAD reads). Family match is case-insensitive and required; st
 dropping to Regular beats falling through to an unrelated family, which is what fontconfig does
 too.
 
+**`text()` takes `font` positionally too — and NOTHING after it.** `text(text, size, font)` is the
+positional set; `halign`/`valign`/`spacing`/`direction`/`language`/`script` are name-only, because
+that is what the 2026.02.01 binary does: `text("Hi", 10, "F", "center")` is not centred there while
+`halign="center"` is, measured by bounding box. So **`text()` and `textmetrics()` genuinely differ**
+— the latter takes all nine positionally — and neither can be assumed from the other. `font` being
+name-only made `text("Hi", 10, "Liberation Sans:style=Bold")` silently draw the default face.
+
 **`font` is a POSITIONAL argument in both metrics functions**, and so is everything after it:
 `fontmetrics(size, font)` and `textmetrics(text, size, font, direction, language, script, halign,
 valign, spacing)`. Verified against the 2026.02.01 binary rather than read off a doc page. Having
@@ -970,7 +977,15 @@ grep for `ponytail:`.
   restating the list, because three hand-written copies had already drifted far enough that `.off`
   could be written by neither the GUI nor the CLI while every test passed.
   Colour is carried by 3MF, AMF, OBJ (companion `.mtl`), PLY, VRML and X3D; STL and OFF compose
-  every body into one solid and store geometry only. **AMF** puts colour on the `<volume>` rather
+  every body into one solid and store geometry only.
+  **`ExportOptions::splitColors` picks what the file is FOR**, and is the axis worth asking a user
+  about rather than "should parts be separate": on (the default) writes one object per colour, which
+  is what a **multi-material** print wants — each colour is something the slicer assigns to a
+  filament. Off is a **single-material** print: everything unions into one welded solid, so touching
+  colour regions lose the coincident faces that stacking per-colour objects would leave, and the
+  per-triangle colour is dropped because such a print has no use for it. Implemented by forcing
+  `splitBodiesForExport`'s `allSame` branch, which already unions rather than concatenates —
+  concatenating the per-colour objects instead would have left the seam. **AMF** puts colour on the `<volume>` rather
   than the face, so an object whose triangles are not all one colour is written as one volume per
   colour — per-triangle `<color>` is legal in the spec but poorly supported by the slicers that are
   the audience for it.

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.14.0
+Version: 1.15.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/bindings/module.cpp

@@ -404,7 +404,8 @@ void applyPdfOptions(const nb::dict& d, oscadeval::ExportPdfOptions& pdf) {
 }
 
 nb::list exportModelPy(const std::string& path, const Geometry& geom, const std::string& format, bool asciiStl,
-                        bool stripSlivers, bool splitComponents, bool svgFill, const std::string& svgFillColor,
+                        bool stripSlivers, bool splitComponents, bool splitColors, bool svgFill,
+                        const std::string& svgFillColor,
                         bool svgStroke, const std::string& svgStrokeColor, double svgStrokeWidth,
                         nb::object pdfOptions) {
     oscadeval::ExportPdfOptions pdf;
@@ -418,6 +419,7 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
         opts.asciiStl = asciiStl;
         opts.stripSlivers = stripSlivers;
         opts.splitComponents = splitComponents;
+        opts.splitColors = splitColors;
         opts.svg.fill = svgFill;
         opts.svg.fillColor = svgFillColor;
         opts.svg.stroke = svgStroke;
@@ -850,7 +852,8 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
 
     m.def("export_model", &exportModelPy, nb::arg("path"), nb::arg("geometry"), nb::arg("format") = std::string(),
           nb::arg("ascii_stl") = false, nb::arg("strip_slivers") = true,
-          nb::arg("split_components") = false, nb::arg("svg_fill") = false,
+          nb::arg("split_components") = false, nb::arg("split_colors") = true,
+          nb::arg("svg_fill") = false,
           nb::arg("svg_fill_color") = std::string("white"), nb::arg("svg_stroke") = true,
           nb::arg("svg_stroke_color") = std::string("black"), nb::arg("svg_stroke_width") = 0.35,
           nb::arg("pdf_options") = nb::none(),
@@ -861,6 +864,10 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "`split_components` gives every disconnected piece its own object in the multi-object formats "
           "(3MF, AMF, OBJ, PLY, VRML, X3D). Off by default, matching OpenSCAD, which writes one object "
           "per colour however many pieces it is in.\n\n"
+          "`split_colors` (on by default) writes one object per colour -- what a MULTI-MATERIAL print "
+          "wants, each colour being something the slicer assigns to a filament. Turn it off for a "
+          "single-material print: everything welds into one solid, with no seams between colour "
+          "regions and no per-triangle colour it has no use for.\n\n"
           "The svg_* arguments are OpenSCAD's -O export-svg/... set and apply to .svg only. "
           "svg_stroke/svg_stroke_width also pad the page, so they are not purely cosmetic. An .svg "
           "export needs an all-2D model and raises otherwise, as OpenSCAD does.\n\n"

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/include/openscad_cpp_evaluator/export.hpp

@@ -53,7 +53,8 @@ struct ExportObject {
 // 1-based index is appended to `openParts` for the caller to warn about.
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies,
                                                 std::vector<int>* openParts = nullptr,
-                                                bool splitComponents = false);
+                                                bool splitComponents = false,
+                                                bool splitColors = true);
 
 // Writes a binary STL: composes every body's mesh into one solid (bodies
 // with no `.body` -- 2D-only sections -- or an empty Manifold are
@@ -236,6 +237,12 @@ struct ExportOptions {
     // pieces it is in; see that function's own comment for why the default
     // moved here.
     bool splitComponents = false;
+    // Rule 2 of splitBodiesForExport: one object per colour. That is what
+    // a MULTI-MATERIAL print wants -- each colour becomes something the
+    // slicer assigns to a filament. Turn it off for a single-material
+    // print, which wants one welded solid instead: no seams between
+    // colour regions, and no per-triangle colour it has no use for.
+    bool splitColors = true;
     // .svg only.
     ExportSvgOptions svg;
     // .pdf only.

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.14.0"
+version = "1.15.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/python/openscad_cpp_evaluator/__init__.py

@@ -293,6 +293,7 @@ def strip_slivers(verts, tris):
 
 def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
                  strip_slivers: bool = True, split_components: bool = False,
+                 split_colors: bool = True,
                  svg_fill: bool = False, svg_fill_color: str = "white",
                  svg_stroke: bool = True, svg_stroke_color: str = "black",
                  svg_stroke_width: float = 0.35, pdf_options: dict | None = None) -> list:
@@ -316,6 +317,12 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
     `split_components` gives every disconnected piece its own object in the
     multi-object formats. Off by default, which is what OpenSCAD writes.
 
+    `split_colors` (on by default) writes one object per colour -- what a
+    MULTI-MATERIAL print wants, each colour being something the slicer
+    assigns to a filament. Turn it off for a single-material print:
+    everything welds into one solid, with no seams between colour regions
+    and no per-triangle colour it has no use for.
+
     The `svg_*` arguments are OpenSCAD's `-O export-svg/...` set and apply
     to `.svg` only, which writes a 2D model at 1:1 in millimetres.
     `svg_stroke`/`svg_stroke_width` also pad the page, so they are not
@@ -335,7 +342,7 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
     """
     try:
         return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers,
-                                       split_components, svg_fill, svg_fill_color,
+                                       split_components, split_colors, svg_fill, svg_fill_color,
                                        svg_stroke, svg_stroke_color, svg_stroke_width,
                                        pdf_options))
     except Exception as e:

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/src/builtins/text.cpp

@@ -34,7 +34,18 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     const std::string text = asStringOr(getArg(args, 0, "text", Value{std::string("")}), "");
     const double size = toDoubleLenient(getArg(args, 1, "size", Value{10.0}));
-    const std::string fontSpec = asStringOr(getArg(args, std::nullopt, "font", Value{std::string("")}), "");
+    // font is POSITIONAL, at index 2: `text("Hi", 10, "Liberation Sans")`
+    // is how people write it and how the reference reads it -- measured
+    // against the 2026.02.01 binary, whose bounding box for the
+    // positional form matches the named one exactly.
+    //
+    // Only font. halign/valign/spacing/direction/language/script stay
+    // name-only, because the same measurement shows the reference
+    // ignoring them positionally: `text("Hi", 10, "F", "center")` is NOT
+    // centred there, while halign="center" is. text() and textmetrics()
+    // genuinely differ here -- textmetrics takes all nine positionally --
+    // so neither can be assumed from the other.
+    const std::string fontSpec = asStringOr(getArg(args, 2, "font", Value{std::string("")}), "");
     const std::string halign = asStringOr(getArg(args, std::nullopt, "halign", Value{std::string("left")}), "left");
     const std::string valign = asStringOr(getArg(args, std::nullopt, "valign", Value{std::string("baseline")}), "baseline");
     const double spacing = toDoubleLenient(getArg(args, std::nullopt, "spacing", Value{1.0}));

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/src/export.cpp

@@ -421,7 +421,7 @@ std::vector<std::array<float, 4>> carryTriColors(const std::vector<std::array<fl
 } // namespace
 
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts,
-                                                bool splitComponents) {
+                                                bool splitComponents, bool splitColors) {
     struct Solid {
         manifold::Manifold man;
         std::optional<std::array<float, 4>> color;
@@ -484,7 +484,15 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             if (k.hasColor) k.color = *solids[i].color;
             keys.push_back(k);
         }
-        const bool allSame = std::all_of(keys.begin(), keys.end(), [&](const ColorKey& k) { return k == keys[0]; });
+        // Splitting by colour is for a MULTI-MATERIAL print, where each
+        // colour becomes an object the slicer assigns to a filament. A
+        // single-material print wants the opposite: one welded solid, with
+        // no seams between colour regions for the slicer to treat as
+        // separate walls. Unioning everything here (rather than
+        // concatenating the per-colour objects afterwards) is what makes
+        // touching regions weld instead of leaving coincident faces.
+        const bool allSame = !splitColors ||
+            std::all_of(keys.begin(), keys.end(), [&](const ColorKey& k) { return k == keys[0]; });
 
         if (allSame) {
             // The common case by far, and it needs no per-body subtraction
@@ -496,7 +504,10 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             Claimed c;
             c.man = addAll(parts);
             c.color = solids[0].color;
-            c.triColors = solids[0].triColors;
+            // Per-triangle colour cannot survive a weld across colours --
+            // the union rebuilds the surface -- and a single-material
+            // print has no use for it anyway.
+            c.triColors = splitColors ? solids[0].triColors : std::vector<std::array<float, 4>>{};
             c.sourceTris = solids[0].tris;
             c.key = keys[0];
             claimedGroups.push_back(std::move(c));
@@ -1507,7 +1518,8 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         // its own -- that is what the file contains.
         for (std::string& w : checkExportBodies(bodies)) warnings.push_back(std::move(w));
         std::vector<int> openParts;
-        const std::vector<ExportObject> objects = splitBodiesForExport(bodies, &openParts, opts.splitComponents);
+        const std::vector<ExportObject> objects =
+            splitBodiesForExport(bodies, &openParts, opts.splitComponents, opts.splitColors);
         reportOpen(openParts);
         if (objects.empty()) throw std::runtime_error("No geometry to export");
         if (ext == ".3mf") {

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/tests/test_export.cpp

@@ -733,3 +733,63 @@ TEST(ExportPdf, ReachableThroughExportModelAndListedAsAnExtension) {
     std::remove(path.c_str());
 }
 
+
+// -- single-material vs multi-material -------------------------------------
+
+TEST(SplitColors, MultiMaterialGivesOneObjectPerColour) {
+    // The default: each colour becomes something a slicer can assign to a
+    // filament.
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(10); color(\"blue\") translate([12,0,0]) cube(10);");
+    const std::vector<ExportObject> objs = splitBodiesForExport(bodies, nullptr, false, /*splitColors=*/true);
+    EXPECT_EQ(objs.size(), 2u);
+}
+
+TEST(SplitColors, SingleMaterialGivesOneObject) {
+    // A single-material print has nothing to do with the colours, and
+    // splitting on them only gives the slicer parts to list.
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(10); color(\"blue\") translate([12,0,0]) cube(10);");
+    const std::vector<ExportObject> objs = splitBodiesForExport(bodies, nullptr, false, /*splitColors=*/false);
+    ASSERT_EQ(objs.size(), 1u);
+    EXPECT_TRUE(objs[0].triColors.empty());  // no per-triangle colour to carry
+}
+
+TEST(SplitColors, SingleMaterialWeldsTouchingColourRegions) {
+    // Unioned, not concatenated: two touching cubes of different colours
+    // must come out as one solid without the coincident interior faces
+    // that stacking the per-colour objects would leave behind.
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(10); color(\"blue\") translate([10,0,0]) cube(10);");
+    const std::vector<ExportObject> single = splitBodiesForExport(bodies, nullptr, false, /*splitColors=*/false);
+    ASSERT_EQ(single.size(), 1u);
+
+    const std::vector<ExportObject> multi = splitBodiesForExport(bodies, nullptr, false, true);
+    ASSERT_EQ(multi.size(), 2u);
+    size_t multiTris = 0;
+    for (const ExportObject& o : multi) multiTris += o.tris.size() / 3;
+
+    // Fewer triangles than the two objects have between them: the pair of
+    // coincident faces along the seam is gone, which is the difference
+    // between a welded solid and two boxes stacked in one object. (Not
+    // the 12 of a plain 20x10x10 box -- Manifold keeps the seam's
+    // vertices, so the faces crossing it stay split.)
+    EXPECT_LT(single[0].tris.size() / 3, multiTris);
+    EXPECT_EQ(single[0].tris.size() / 3, 20u);
+}
+
+TEST(SplitColors, SingleMaterialKeepsTheWholeVolume) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(10); color(\"blue\") translate([12,0,0]) cube(10);");
+    const std::vector<ExportObject> multi = splitBodiesForExport(bodies, nullptr, false, true);
+    const std::vector<ExportObject> single = splitBodiesForExport(bodies, nullptr, false, false);
+    size_t multiTris = 0;
+    for (const ExportObject& o : multi) multiTris += o.tris.size();
+    EXPECT_EQ(single[0].tris.size(), multiTris);  // same surface, one object
+}
+
+TEST(SplitColors, AnUncolouredModelIsUnaffectedEitherWay) {
+    std::vector<ColoredBody> bodies = evalToBodies("cube(10); translate([12,0,0]) cube(10);");
+    EXPECT_EQ(splitBodiesForExport(bodies, nullptr, false, true).size(), 1u);
+    EXPECT_EQ(splitBodiesForExport(bodies, nullptr, false, false).size(), 1u);
+}

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/tests/test_python_bindings.py

@@ -776,6 +776,27 @@ def test_list_fonts_reports_specs_that_actually_resolve(tmp_path):
     assert echoes == ['ECHO: "Regular"', 'ECHO: "Bold"', 'ECHO: "Italic"', 'ECHO: "Bold Italic"']
 
 
+def test_split_colors_chooses_single_or_multi_material(tmp_path):
+    """Same two-hand-written-parameter-lists trap as split_components."""
+    from openscad_cpp_evaluator import Evaluator, export_model
+
+    src = tmp_path / "two.scad"
+    src.write_text('color("red") cube(10); color("blue") translate([12,0,0]) cube(10);')
+    ev = Evaluator()
+    ev.evaluate(str(src), {})
+
+    def objects_in(path, **kwargs):
+        import zipfile
+        export_model(str(path), ev.geometry, **kwargs)
+        with zipfile.ZipFile(path) as z:
+            return z.read("3D/3dmodel.model").decode().count("<object ")
+
+    # Multi-material (the default): one object per colour for the slicer.
+    assert objects_in(tmp_path / "multi.3mf") == 2
+    # Single-material: one solid, colours irrelevant.
+    assert objects_in(tmp_path / "single.3mf", split_colors=False) == 1
+
+
 def test_strict_commas_reaches_the_parser(tmp_path):
     """Evaluator.evaluate(strict_commas=True) must survive both hand-written
     parameter lists -- the facade's and the nanobind binding's. The last

{openscad_cpp_evaluator-1.14.0 → openscad_cpp_evaluator-1.15.0}/tests/test_text.cpp

@@ -379,3 +379,30 @@ TEST(FontArgs, TheLaterPositionalsLineUpToo) {
     ASSERT_EQ(echoes.size(), 1u);
     EXPECT_EQ(echoes[0], "ECHO: true, true");
 }
+
+TEST(TextArgs, FontIsPositionalButTheRestAreNot) {
+    // text("Hi", 10, "Liberation Sans:style=Bold") silently drew the
+    // DEFAULT face: `font` was name-only, so the third argument went
+    // nowhere. Same defect as BelfrySCAD #381's, in the module people
+    // actually use.
+    //
+    // And only `font`: the reference accepts nothing after it
+    // positionally, which was measured rather than assumed --
+    // `text("Hi", 10, "F", "center")` is not centred in OpenSCAD
+    // 2026.02.01, while halign="center" is. textmetrics() differs from
+    // text() here, taking all nine positionally.
+    std::vector<std::string> echoes;
+    Evaluated e = evalSrc(
+        "p = render() { linear_extrude(1) text(\"Hi\", 10, \"Liberation Sans:style=Bold\"); };\n"
+        "n = render() { linear_extrude(1) text(\"Hi\", 10, font=\"Liberation Sans:style=Bold\"); };\n"
+        "d = render() { linear_extrude(1) text(\"Hi\", 10); };\n"
+        "h = render() { linear_extrude(1) text(\"Hi\", 10, \"Liberation Sans\", \"center\"); };\n"
+        "hn = render() { linear_extrude(1) text(\"Hi\", 10, \"Liberation Sans\", halign=\"center\"); };\n"
+        "echo(p.volume == n.volume, p.volume == d.volume, h.boundingbox == d.boundingbox,"
+        " hn.boundingbox == d.boundingbox);\n",
+        [&](const std::string& m) { echoes.push_back(m); });
+    ASSERT_EQ(echoes.size(), 1u);
+    // positional == named, positional != default, a 4th positional does
+    // NOTHING, and halign by name does move it.
+    EXPECT_EQ(echoes[0], "ECHO: true, false, true, false");
+}