openscad-cpp-evaluator 0.55.3__tar.gz → 0.55.5__tar.gz

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/CLAUDE.md

@@ -231,14 +231,31 @@ top-level 2D primitive/projection() script had been silently unexportable via th
 Fixed by porting `toRenderableBodies()` (`colored_body.hpp`/`.cpp`) and calling it from the CLI right
 before export, matching the reference's own call site exactly.
 
-`ColoredBody::sectionZ` rides alongside for the same reason. A `manifold::CrossSection` is purely
-2D, so `down(1) square(10)` had nowhere to put the `-1` and silently dropped it — and that is not
-cosmetic: BOSL2 layers 2D overlays by pushing one down (isosurface's `contour()` Example 1 puts a
-blue backdrop below a green contour), and with the offset lost the two slabs became exactly
-coplanar, z-fought, and whichever drew last covered the other completely. `generateTransform`
-accumulates the z of any `translate` applied to a section, and `toRenderableBodies()` translates the
-extruded slab by it. Only translation is carried — a 2D shape under a 3D *rotation* still loses it,
-which would need a full matrix per section and nothing has asked for that yet.
+`ColoredBody::sectionXform` rides alongside for the same reason. A `manifold::CrossSection` is
+purely 2D, so `down(1) square(10)` had nowhere to put the `-1` and `rotate([55,0,25]) text("Foo")`
+had nowhere to put the rotation — both were silently dropped, and neither is cosmetic: BOSL2 layers
+2D overlays by pushing one down (isosurface's `contour()` Example 1 puts a blue backdrop below a
+green contour, and the two slabs became exactly coplanar and z-fought), and turns 2D labels to face
+the camera with `rotate($vpr)` (skin's style figure, which came out lying flat and reading as a blob
+once the preview slab became a full unit tall). `generateTransform` accumulates whatever the
+CrossSection cannot hold into that matrix and `toRenderableBodies()` applies it to the extruded
+slab.
+
+Two rules keep the ordering honest. A transform the CrossSection *can* hold still goes into it, so
+2D booleans and `offset()` keep operating on real 2D geometry — but only while the carried matrix is
+still identity, since applying an outer transform to the section after an out-of-plane one would
+silently reorder them. A pure `translate` is the one exception: while nothing has yet rotated or
+scaled the section, its x/y goes into the section and only its z rides along, because translations
+commute and that keeps `down(1) square(10)` a real 2D shape. `resize()` is carried by neither — the
+reference passes 2D children through it unchanged.
+
+The same "geometry Manifold cannot hold" problem applies to `ColoredBody::rawMesh`, the raw triangles
+of a mesh Manifold rejected (an open surface — a height field, a partial `vnf_vertex_array`). Those
+were left where they were built, so `grid_copies(...) vnf_polyhedron(<open surface>)` stacked every
+copy at the origin and BOSL2's skin() style figure showed one shape where the reference shows seven.
+`transformMatrix3d` (transforms.cpp) gives the affine matrix for a transform and
+`generateTransform` applies it to those vertices too; `resize` returns nullopt there, being a
+function of a bounding box a display-only body does not have.
 
 **Font support**: a `FontProvider` abstract interface (`font_provider.hpp`: `resolveFont`/
 `metrics`/`shapeText`/`glyphInkBounds`/`glyphOutline`) with `FreetypeFontProvider` as the built-in

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/PKG-INFO

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

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -15,6 +15,7 @@ class FunctionLiteral;
 class ModuleDeclaration;
 class ModularCall;
 class ModularAssert;
+class ModularEcho;
 class Expression;
 } // namespace oscad
 
@@ -868,6 +869,11 @@ struct CompiledChunk {
     // unused and misleadingly defaulted.
     struct EchoSite {
         std::vector<std::optional<std::string>> argNames;
+        // The ModularEcho statement, when this site came from one -- an
+        // `echo(...) cube();` renders its child after echoing, exactly as
+        // AssertSite::node does for `assert(...) cube();`. Null for the
+        // EXPRESSION form (`echo(...) 1+1`), which has no children.
+        const oscad::ModularEcho* node = nullptr;
     };
 
     // One Op::CallModule site -- a ModularCall statically resolved (at

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -68,6 +68,9 @@ struct PendingCsgWrap {
     std::uint64_t randsBefore = 0;
     int siteIdx = -1;
     std::vector<Value> groupSizes;
+    // Parallel to groupSizes: whether a group that came out EMPTY is still
+    // an operand. See Op::CsgGroupEnd's `a`.
+    std::vector<Value> emptyIsAGroup;
     size_t groupStartSize = 0;
 };
 

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -25,20 +25,27 @@ struct ColoredBody {
     std::optional<manifold::CrossSection> section;
     bool flatPreview = false;
 
-    // Where a 2D `section` sits along Z. Only meaningful while `section` is
-    // set, and applied when toRenderableBodies() extrudes it.
+    // What a 2D `section` has been transformed BY that a CrossSection
+    // cannot itself hold: a translation along Z, a rotation out of the XY
+    // plane, anything with a Z component. Applied when
+    // toRenderableBodies() extrudes the section.
     //
     // A manifold::CrossSection is purely 2D, so `down(1) square(10)` had
-    // nowhere to put the -1 and silently dropped it. That is not merely
+    // nowhere to put the -1 and `rotate([55,0,25]) text("Foo")` had nowhere
+    // to put the rotation -- both were silently dropped. Neither is
     // cosmetic: BOSL2 layers 2D overlays by pushing one down (isosurface's
-    // contour() Example 1 puts a blue backdrop below a green contour), and
-    // with the offset lost the two slabs became exactly coplanar, z-fought,
-    // and whichever was drawn last covered the other completely.
+    // contour() Example 1), and turns 2D labels to face the camera with
+    // `rotate($vpr)` (skin's style figure), which came out lying flat and
+    // read as a blob once the preview slab became a full unit tall.
     //
-    // Only translation is carried. A 2D shape under a 3D ROTATION still
-    // loses it -- representing that needs a full matrix per section, which
-    // nothing has asked for yet.
-    double sectionZ = 0.0;
+    // Identity while every transform so far has been 2D-representable --
+    // those still go into the CrossSection itself, so 2D booleans and
+    // offset() keep working on real 2D geometry. From the first transform
+    // that is NOT representable, every later one composes here instead:
+    // applying an outer transform to the section after an out-of-plane one
+    // would put it in the wrong order.
+    manifold::mat3x4 sectionXform{manifold::vec3(1, 0, 0), manifold::vec3(0, 1, 0),
+                                   manifold::vec3(0, 0, 1), manifold::vec3(0, 0, 0)};
     BodyRole role = BodyRole::Normal;
     std::optional<std::vector<std::array<float, 4>>> triColors; // per-triangle RGBA, multi-color CSG merges only
 

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/pyproject.toml

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

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/python/openscad_cpp_evaluator/__init__.py

@@ -213,7 +213,8 @@ def _summarize_param(value, max_items: int = 6, max_len: int = 40) -> str:
 # Params keys never shown in format_csg_tree's per-node summary, regardless
 # of kind -- pure internal bookkeeping or already represented structurally
 # elsewhere in the tree. Mirrors the reference's _DUMP_HIDDEN_PARAM_KEYS.
-_DUMP_HIDDEN_PARAM_KEYS = frozenset({"color", "op", "name", "group_sizes"})
+_DUMP_HIDDEN_PARAM_KEYS = frozenset(
+    {"color", "op", "name", "group_sizes", "empty_is_a_group"})
 
 # Auto-generated tessellation data (not user-authored) for every kind except
 # polyhedron, where the equivalent data *is* the user's own points/faces.

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/src/builtins/booleans.cpp

@@ -108,16 +108,43 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
     if (!assignNodes.empty()) ev.evalChildren(assignNodes, blockCtx);
 
     std::vector<Value> groupSizes;
+    std::vector<Value> emptyIsAGroup;
     groupSizes.reserve(geoNodes.size());
+    emptyIsAGroup.reserve(geoNodes.size());
     for (const oscad::ASTNode* geoNode : geoNodes) {
         const size_t before = ev.currentTreeFrameSize();
         ev.evalChildren(std::vector<const oscad::ASTNode*>{geoNode}, blockCtx);
         groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
+        // Whether a statement that produced NOTHING still counts as an
+        // operand.
+        //
+        // The reference builds a node for a module instantiation and for a
+        // loop whatever they contain, so an empty one is an empty operand
+        // and annihilates an intersection. An `if` that takes no branch, a
+        // bare block, and a `*`-disabled statement build no node at all, so
+        // they are not operands and must be skipped.
+        //
+        // Every line of this was checked against OpenSCAD rather than
+        // reasoned about -- `intersection(){ cube(10); X; }` keeps the cube
+        // for `if(false) sphere(6)`, `{ }` and `*cube(1)`, and comes out
+        // empty for `for(i=[1:0]) sphere(6)`, `union(){}`, `group(){}` and
+        // a call to an empty user module.
+        const oscad::NodeKind k = geoNode->kind();
+        emptyIsAGroup.push_back(Value{
+                                       k == oscad::NodeKind::ModularCall ||
+                                       k == oscad::NodeKind::ModularFor ||
+                                       k == oscad::NodeKind::ModularIntersectionFor ||
+                                       k == oscad::NodeKind::ModularLet ||
+                                       k == oscad::NodeKind::ModularModifierShowOnly ||
+                                       k == oscad::NodeKind::ModularModifierHighlight ||
+                                       k == oscad::NodeKind::ModularModifierBackground});
     }
 
     CSGParams params;
     params["op"] = Value{op};
     params["group_sizes"] = Value{std::make_shared<const ValueList>(ValueList{std::move(groupSizes)})};
+    params["empty_is_a_group"] =
+        Value{std::make_shared<const ValueList>(ValueList{std::move(emptyIsAGroup)})};
     return params;
 }
 
@@ -180,16 +207,36 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
                                       const oscad::ASTNode&) {
     const std::string& op = std::get<std::string>(params.at("op"));
     const auto& groupSizes = std::get<ListPtr>(params.at("group_sizes"))->items;
+    const auto emptyIsAGroupIt = params.find("empty_is_a_group");
+    const std::vector<Value>* emptyIsAGroup =
+        emptyIsAGroupIt == params.end()
+            ? nullptr
+            : &std::get<ListPtr>(emptyIsAGroupIt->second)->items;
 
     std::vector<ColoredBody> allBg, allHi, allSo, allDo;
     std::optional<ColoredBody> csgResult;
     size_t idx = 0;
 
+    size_t stmtIndex = 0;
     for (const Value& sizeVal : groupSizes) {
         const size_t size = static_cast<size_t>(std::get<double>(sizeVal));
+        const size_t thisStmt = stmtIndex++;
         std::vector<ColoredBody> stmtBodies = flattenCsgTree(children, idx, size);
         idx += size;
 
+        // A statement that built no CSG node at all is not an operand --
+        // an `if` whose branch was not taken, or an empty block. Only a
+        // for-loop still counts as one when it produced nothing, matching
+        // the group node the reference builds for it regardless. Without
+        // this, `intersection(){ X; if (crop) Y; }` -- BOSL2's hirth()
+        // among others -- came out empty whenever the condition was false.
+        if (size == 0) {
+            const bool isGroup = emptyIsAGroup && thisStmt < emptyIsAGroup->size() &&
+                                  std::holds_alternative<bool>((*emptyIsAGroup)[thisStmt]) &&
+                                  std::get<bool>((*emptyIsAGroup)[thisStmt]);
+            if (!isGroup) continue;
+        }
+
         RoleSplit split = splitByRole(stmtBodies);
         allBg.insert(allBg.end(), split.background.begin(), split.background.end());
         allHi.insert(allHi.end(), split.highlight.begin(), split.highlight.end());

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/src/builtins/transforms.cpp

@@ -83,6 +83,15 @@ manifold::Manifold applyRotate(manifold::Manifold body, const Value& aArg, const
     return body.Transform(axisAngleMatrix(axis, angle * std::numbers::pi / 180.0));
 }
 
+// `a` applied after `b`, both as Manifold's column-major 3x4 affines.
+manifold::mat3x4 compose3x4(const manifold::mat3x4& a, const manifold::mat3x4& b) {
+    manifold::mat3x4 out;
+    for (int c = 0; c < 3; ++c)
+        out[c] = a[0] * b[c].x + a[1] * b[c].y + a[2] * b[c].z;
+    out[3] = a[0] * b[3].x + a[1] * b[3].y + a[2] * b[3].z + a[3];
+    return out;
+}
+
 // Converts a user-supplied 4x4/4x3 nested-list matrix (row-major, like
 // every OpenSCAD-facing representation) to Manifold's column-major 3x4
 // transform. Mirrors _to_matrix4x3.
@@ -117,6 +126,121 @@ manifold::mat2x3 toMat2x3(const Value& m) {
     return manifold::mat2x3(col0, col1, col2);
 }
 
+// The affine matrix a transform applies, for geometry Manifold cannot hold.
+//
+// A mesh Manifold rejected (an open surface -- a height field, a partial
+// `vnf_vertex_array`) survives only as ColoredBody::rawMesh, raw triangles
+// with no Manifold to transform. Those triangles were left where they were
+// built, so `grid_copies(...) vnf_polyhedron(<open surface>)` stacked every
+// copy at the origin and BOSL2's skin() style figure showed one shape where
+// the reference shows seven.
+//
+// nullopt for `resize`, which is not a fixed map at all: its scale comes
+// from the body's own bounding box, and a display-only body has no Manifold
+// to measure. Verified against Manifold's own operators by
+// TransformMatrix3d tests rather than assumed -- the Euler order especially.
+// True if `m` is a pure translation: nothing has rotated, scaled or
+// mirrored the section, so a further translation commutes with it.
+bool hasIdentityLinearPart(const manifold::mat3x4& m) {
+    for (int c = 0; c < 3; ++c) {
+        const manifold::vec3 want(c == 0 ? 1.0 : 0.0, c == 1 ? 1.0 : 0.0, c == 2 ? 1.0 : 0.0);
+        if (m[c] != want) return false;
+    }
+    return true;
+}
+
+bool isIdentity3x4(const manifold::mat3x4& m) {
+    for (int c = 0; c < 4; ++c) {
+        const manifold::vec3 want(c == 0 ? 1.0 : 0.0, c == 1 ? 1.0 : 0.0, c == 2 ? 1.0 : 0.0);
+        if (m[c] != want) return false;
+    }
+    return true;
+}
+
+// True if `m` maps the XY plane onto itself, so a CrossSection can hold it:
+// nothing leaves the plane (no Z from x or y, no Z offset) and Z maps to Z.
+bool preservesXYPlane(const manifold::mat3x4& m) {
+    return m[0].z == 0.0 && m[1].z == 0.0 && m[3].z == 0.0 &&
+           m[2].x == 0.0 && m[2].y == 0.0;
+}
+
+// Applies `m` to a raw mesh's vertex POSITIONS in place. Any further
+// per-vertex properties (normals and the like) are left alone: nothing
+// reads them off a display-only body, which is drawn from its triangles.
+void transformMeshInPlace(manifold::MeshGL& mesh, const manifold::mat3x4& m) {
+    const uint32_t stride = mesh.numProp;
+    if (stride < 3) return;
+    for (size_t i = 0; i + 2 < mesh.vertProperties.size(); i += stride) {
+        const double x = mesh.vertProperties[i];
+        const double y = mesh.vertProperties[i + 1];
+        const double z = mesh.vertProperties[i + 2];
+        const manifold::vec3 p = m[0] * x + m[1] * y + m[2] * z + m[3];
+        mesh.vertProperties[i] = static_cast<float>(p.x);
+        mesh.vertProperties[i + 1] = static_cast<float>(p.y);
+        mesh.vertProperties[i + 2] = static_cast<float>(p.z);
+    }
+}
+
+std::optional<manifold::mat3x4> transformMatrix3d(const std::string& name, const CallArgs& args) {
+    const manifold::mat3x4 ident(manifold::vec3(1, 0, 0), manifold::vec3(0, 1, 0),
+                                  manifold::vec3(0, 0, 1), manifold::vec3(0, 0, 0));
+    if (name == "translate") {
+        manifold::mat3x4 m = ident;
+        m[3] = toVec3(getArg(args, 0, "v", Value{}));
+        return m;
+    }
+    if (name == "rotate") {
+        const Value aArg = getArg(args, 0, "a", Value{0.0});
+        const Value vArg = getArg(args, 1, "v", Value{});
+        if (std::holds_alternative<ListPtr>(aArg)) {
+            const manifold::vec3 a = toVec3(aArg);
+            const double d2r = std::numbers::pi / 180.0;
+            // X, then Y, then Z -- the order Manifold::Rotate uses, which
+            // applyTransform3d hands the same angles to.
+            const manifold::mat3x4 rx = axisAngleMatrix(manifold::vec3(1, 0, 0), a.x * d2r);
+            const manifold::mat3x4 ry = axisAngleMatrix(manifold::vec3(0, 1, 0), a.y * d2r);
+            const manifold::mat3x4 rz = axisAngleMatrix(manifold::vec3(0, 0, 1), a.z * d2r);
+            return compose3x4(rz, compose3x4(ry, rx));
+        }
+        const double angle = toDoubleLenient(aArg);
+        const manifold::vec3 axis =
+            std::holds_alternative<std::monostate>(vArg) ? manifold::vec3(0, 0, 1) : toVec3(vArg);
+        return axisAngleMatrix(axis, angle * std::numbers::pi / 180.0);
+    }
+    if (name == "scale") {
+        Value v = getArg(args, 0, "v", Value{1.0});
+        manifold::vec3 sv = std::get_if<double>(&v)
+                                ? manifold::vec3(*std::get_if<double>(&v), *std::get_if<double>(&v),
+                                                  *std::get_if<double>(&v))
+                                : toVec3(v, 1.0, 1.0, 1.0);
+        manifold::mat3x4 m = ident;
+        m[0] = manifold::vec3(sv.x, 0, 0);
+        m[1] = manifold::vec3(0, sv.y, 0);
+        m[2] = manifold::vec3(0, 0, sv.z);
+        return m;
+    }
+    if (name == "mirror") {
+        manifold::vec3 n = toVec3(getArg(args, 0, "v", Value{}), 1.0, 0.0, 0.0);
+        const double len2 = n.x * n.x + n.y * n.y + n.z * n.z;
+        if (len2 <= 0.0) return ident;
+        manifold::mat3x4 m = ident;
+        // I - 2 n n^T / |n|^2, written column by column.
+        for (int c = 0; c < 3; ++c) {
+            const double nc = c == 0 ? n.x : (c == 1 ? n.y : n.z);
+            m[c] = manifold::vec3((c == 0 ? 1.0 : 0.0) - 2.0 * n.x * nc / len2,
+                                   (c == 1 ? 1.0 : 0.0) - 2.0 * n.y * nc / len2,
+                                   (c == 2 ? 1.0 : 0.0) - 2.0 * n.z * nc / len2);
+        }
+        return m;
+    }
+    if (name == "multmatrix") {
+        Value m = getArg(args, 0, "m", Value{});
+        if (std::holds_alternative<std::monostate>(m)) return ident;
+        return toMat3x4(m);
+    }
+    return std::nullopt;
+}
+
 manifold::Manifold applyTransform3d(const std::string& name, const CallArgs& args, manifold::Manifold body) {
     if (name == "translate") {
         return body.Translate(toVec3(getArg(args, 0, "v", Value{})));
@@ -233,13 +357,40 @@ std::vector<ColoredBody> generateTransform(Evaluator&, const CSGParams& params,
     std::vector<ColoredBody> result;
     for (ColoredBody b : flattenCsgTree(children)) {
         if (b.section) {
-            // The CrossSection takes x/y; z has nowhere to go in it, so it
-            // rides along on the body until the section is extruded. See
-            // ColoredBody::sectionZ.
-            if (name == "translate") b.sectionZ += toVec3(getArg(args, 0, "v", Value{})).z;
-            b.section = applyTransform2d(name, args, std::move(*b.section));
+            // A 2D-representable transform goes into the CrossSection, so
+            // 2D booleans and offset() keep operating on real 2D geometry.
+            // Anything else -- a Z translation, a rotation out of the XY
+            // plane -- has nowhere to go there and rides along on the body
+            // until the section is extruded. Once one of those has been
+            // seen, every LATER (outer) transform must ride along too, or
+            // it would be applied in the wrong order. See
+            // ColoredBody::sectionXform.
+            const std::optional<manifold::mat3x4> m = transformMatrix3d(name, args);
+            if (isIdentity3x4(b.sectionXform) && (!m || preservesXYPlane(*m))) {
+                b.section = applyTransform2d(name, args, std::move(*b.section));
+            } else if (name == "translate" && hasIdentityLinearPart(b.sectionXform)) {
+                // A translate SPLITS while nothing has rotated or scaled the
+                // section yet: x/y into the CrossSection, z into the carried
+                // transform. Translations commute, so the order is safe --
+                // and keeping x/y in the section is what lets a later 2D
+                // boolean or offset() still see real 2D geometry after a
+                // `down(1) square(10)`.
+                b.section = applyTransform2d(name, args, std::move(*b.section));
+                b.sectionXform[3].z += toVec3(getArg(args, 0, "v", Value{})).z;
+            } else if (m) {
+                b.sectionXform = compose3x4(*m, b.sectionXform);
+            }
+            // No `m` and already carrying a transform: only resize(), which
+            // the reference passes 2D children through unchanged anyway.
         } else if (b.body) {
             b.body = applyTransform3d(name, args, std::move(*b.body));
+            // A display-only body's real geometry is its raw triangles --
+            // the Manifold above is empty and moving it moves nothing. See
+            // transformMatrix3d.
+            if (b.rawMesh) {
+                if (std::optional<manifold::mat3x4> m = transformMatrix3d(name, args))
+                    transformMeshInPlace(*b.rawMesh, *m);
+            }
         }
         result.push_back(std::move(b));
     }

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/src/bytecode_compiler.cpp

@@ -1348,7 +1348,21 @@ public:
             }
             out.push_back({Op::CsgGroupStart, 0, 0, nullptr});
             compileStatementList(std::vector<const oscad::ASTNode*>{geoNode}, out);
-            out.push_back({Op::CsgGroupEnd, 0, 0, nullptr});
+            // `a` = whether a group that turns out EMPTY is still an
+            // operand: a module instantiation or a loop builds a node
+            // whatever it contains, an `if`/block/`*` does not. Mirrors
+            // resolveCsg's own "empty_is_a_group" (booleans.cpp), where the
+            // full reasoning and the OpenSCAD checks live.
+            const oscad::NodeKind k = geoNode->kind();
+            const int emptyIsAGroup = (
+                                       k == oscad::NodeKind::ModularCall ||
+                                       k == oscad::NodeKind::ModularFor ||
+                                       k == oscad::NodeKind::ModularIntersectionFor ||
+                                       k == oscad::NodeKind::ModularLet ||
+                                       k == oscad::NodeKind::ModularModifierShowOnly ||
+                                       k == oscad::NodeKind::ModularModifierHighlight ||
+                                       k == oscad::NodeKind::ModularModifierBackground) ? 1 : 0;
+            out.push_back({Op::CsgGroupEnd, emptyIsAGroup, 0, nullptr});
         }
         out.push_back({Op::CloseExprScope, 0, 0, nullptr});
         out.push_back({Op::PopCsgWrap, idx, 0, &call.position()});
@@ -1487,15 +1501,17 @@ public:
                 // form's own compile case (AssertOp's sibling, above in
                 // compileExpr) -- already statement-shaped (no value
                 // pushed, straight fall-through), so nothing new is needed
-                // there. `.children` is deliberately never read here,
-                // matching evalStatement's own ModularEcho case (doEcho
-                // only ever takes `.arguments` -- an echo statement's
-                // trailing children, if the grammar even produces any, are
-                // not evaluated today; this mirrors that exactly rather
-                // than silently changing behavior).
+                // there. `.children` IS read: `echo("x") cube();` renders the
+                // cube in the reference, and the grammar does produce those
+                // children. They used to be dropped on the assumption that it
+                // never did, which silently lost the geometry -- BOSL2's
+                // debug_region() draws its whole region through
+                // `for(...) echo(...) linear_extrude(...) region(...)` and came
+                // out as labels with nothing under them.
                 auto& n = static_cast<const oscad::ModularEcho&>(stmt);
                 out.push_back({Op::CheckDebugStatement, internNativeStatement(&stmt), 0, nullptr});
                 CompiledChunk::EchoSite site;
+                site.node = &n;          // statement form: it can have children
                 CompileScope exprScope;
                 for (const auto& argPtr : n.arguments) {
                     if (argPtr->kind() == NodeKind::NamedArgument) {

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/src/bytecode_vm.cpp

@@ -981,6 +981,12 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         f.stack.pop_back();
                     }
                     ev.emitEcho(pairs);
+                    // The STATEMENT form can carry children and the
+                    // reference renders them; same tail as
+                    // Op::AssertStatement below. Null node = the expression
+                    // form (`echo(...) 1+1`), which has none.
+                    if (site.node && !site.node->children.empty())
+                        ev.evalChildren(site.node->children, ctx);
                     ++f.pc;
                     break;
                 }
@@ -1311,7 +1317,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     // ITERATION child ctxs are pushed separately, by the
                     // compiled loop's own Op::ForIterNext.
                     ev.treeStack_.emplace_back();
-                    f.csgWrapStack.push_back({site.op, randsBefore, ins.a, {}, 0});
+                    f.csgWrapStack.push_back({site.op, randsBefore, ins.a, {}, {}, 0});
                     ++f.pc;
                     break;
                 }
@@ -1336,6 +1342,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         ev.evalChildren(std::vector<const oscad::ASTNode*>{stmt}, ctx);
                         pending.groupSizes.push_back(
                             Value{static_cast<double>(ev.treeStack_.back().size() - before)});
+                        // A spliced child is a plain statement, never a loop.
+                        pending.emptyIsAGroup.push_back(Value{false});
                     }
                     ++f.pc;
                     break;
@@ -1344,6 +1352,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     PendingCsgWrap& pending = f.csgWrapStack.back();
                     const size_t after = ev.treeStack_.back().size();
                     pending.groupSizes.push_back(Value{static_cast<double>(after - pending.groupStartSize)});
+                    pending.emptyIsAGroup.push_back(Value{ins.a != 0});
                     ++f.pc;
                     break;
                 }
@@ -1367,6 +1376,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     if (site.includeOpParam) params["op"] = Value{pending.op};
                     params["group_sizes"] =
                         Value{std::make_shared<const ValueList>(ValueList{std::move(pending.groupSizes)})};
+                    params["empty_is_a_group"] = Value{std::make_shared<const ValueList>(
+                        ValueList{std::move(pending.emptyIsAGroup)})};
                     // Mirrors Evaluator::buildTreeNode's own post-
                     // resolveBody() half exactly (csg_resolve.cpp).
                     const bool uncacheable =

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/src/colored_body.cpp

@@ -37,10 +37,10 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
         if (!cb.body && cb.section) {
             ColoredBody flat;
             flat.body = manifold::Manifold::Extrude(cb.section->ToPolygons(), kTopLevel2dHeight);
-            // Put it back where a 3D translate moved it -- the CrossSection
-            // could not hold that. See ColoredBody::sectionZ.
-            if (cb.sectionZ != 0.0)
-                flat.body = flat.body->Translate(manifold::vec3(0, 0, cb.sectionZ));
+            // Put it back where the transforms a CrossSection could not
+            // hold would have placed it -- a Z offset, a rotation out of
+            // the plane. See ColoredBody::sectionXform.
+            flat.body = flat.body->Transform(cb.sectionXform);
             flat.color = cb.color;
             flat.flatPreview = true;
             flat.role = cb.role;

{openscad_cpp_evaluator-0.55.3 → openscad_cpp_evaluator-0.55.5}/src/stmt_eval.cpp

@@ -241,9 +241,17 @@ void Evaluator::evalStatement(const oscad::ASTNode& node, EvalContext& ctx) {
         case oscad::NodeKind::ModularLet:
             evalLetBlock(static_cast<const oscad::ModularLet&>(node), ctx);
             return;
-        case oscad::NodeKind::ModularEcho:
-            doEcho(static_cast<const oscad::ModularEcho&>(node).arguments, ctx);
+        case oscad::NodeKind::ModularEcho: {
+            // `echo("x") cube();` echoes AND renders the cube, the way the
+            // reference does and the way ModularAssert already did here.
+            // Dropping the children silently lost geometry: BOSL2's
+            // debug_region() draws its whole region through
+            // `for(...) echo(...) linear_extrude(...) region(...)`.
+            const auto& e = static_cast<const oscad::ModularEcho&>(node);
+            doEcho(e.arguments, ctx);
+            if (!e.children.empty()) evalChildren(e.children, ctx);
             return;
+        }
         case oscad::NodeKind::ModularAssert:
             evalAssertStatement(static_cast<const oscad::ModularAssert&>(node), ctx);
             return;