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

{openscad_cpp_evaluator-0.55.4 → 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.4 → openscad_cpp_evaluator-0.55.5}/PKG-INFO

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

{openscad_cpp_evaluator-0.55.4 → 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.4 → 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.4 → 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.4"
+version = "0.55.5"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-0.55.4 → 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.4 → openscad_cpp_evaluator-0.55.5}/src/bytecode_compiler.cpp

@@ -1501,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.4 → 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;
                 }

{openscad_cpp_evaluator-0.55.4 → 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.4 → 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;

{openscad_cpp_evaluator-0.55.4 → openscad_cpp_evaluator-0.55.5}/tests/test_booleans.cpp

@@ -731,7 +731,6 @@ TEST(MixedDimensions, ATranslatedTwoDeeShapeKeepsItsZ) {
     Evaluated e = evalSrc("translate([0,0,-1]) square(10, center=true);");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
-    EXPECT_DOUBLE_EQ(e.bodies[0].sectionZ, -1.0);
 
     const std::vector<ColoredBody> renderable = toRenderableBodies(e.bodies);
     ASSERT_EQ(renderable.size(), 1u);
@@ -740,23 +739,115 @@ TEST(MixedDimensions, ATranslatedTwoDeeShapeKeepsItsZ) {
     EXPECT_NEAR(box.min.z, -1.0, 1e-9) << "the extruded slab sits where it was moved to";
 }
 
-TEST(MixedDimensions, TwoDeeZOffsetsAccumulateAndDefaultToZero) {
-    Evaluated flat = evalSrc("square(10);");
-    ASSERT_EQ(flat.bodies.size(), 1u);
-    EXPECT_DOUBLE_EQ(flat.bodies[0].sectionZ, 0.0);
+TEST(MixedDimensions, ARotatedTwoDeeShapeLeavesTheXYPlane) {
+    // `rotate([90,0,0]) square(10)` stands the square up. A CrossSection
+    // cannot hold that either, and dropping it left BOSL2's `rotate($vpr)`
+    // labels lying flat -- which read as blobs once the preview slab became
+    // a full unit tall rather than a 1e-3 sliver.
+    Evaluated e = evalSrc("rotate([90,0,0]) square(10);");
+    const std::vector<ColoredBody> renderable = toRenderableBodies(e.bodies);
+    ASSERT_EQ(renderable.size(), 1u);
+    const manifold::Box box = renderable[0].body->BoundingBox();
+    // Standing up: 10 tall in Z, and flat (the slab thickness) in Y.
+    EXPECT_NEAR(box.max.z - box.min.z, 10.0, 1e-6);
+    EXPECT_NEAR(box.max.y - box.min.y, 1.0, 1e-6) << "the 1-unit slab is now the Y extent";
+    EXPECT_NEAR(box.max.x - box.min.x, 10.0, 1e-6);
+}
 
-    Evaluated stacked = evalSrc(
-        "translate([0,0,2]) translate([0,0,3]) square(10);");
-    ASSERT_EQ(stacked.bodies.size(), 1u);
-    EXPECT_DOUBLE_EQ(stacked.bodies[0].sectionZ, 5.0);
+TEST(MixedDimensions, TwoDeeTransformsComposeInSourceOrder) {
+    // The outer translate must act AFTER the rotation, not before it: with
+    // the rotation carried separately, applying a later transform to the
+    // CrossSection would silently reorder them.
+    Evaluated e = evalSrc("translate([0,0,7]) rotate([90,0,0]) square(10);");
+    const std::vector<ColoredBody> renderable = toRenderableBodies(e.bodies);
+    ASSERT_EQ(renderable.size(), 1u);
+    const manifold::Box box = renderable[0].body->BoundingBox();
+    EXPECT_NEAR(box.min.z, 7.0, 1e-6) << "lifted after standing up";
+    EXPECT_NEAR(box.max.z, 17.0, 1e-6);
+}
 
-    // x/y still go into the CrossSection itself, not the offset.
+TEST(MixedDimensions, PlanarTransformsStillGoIntoTheCrossSection) {
+    // Anything the CrossSection CAN hold still goes there, so 2D booleans
+    // and offset() keep working on real 2D geometry.
     Evaluated moved = evalSrc("translate([4,5,6]) square(10);");
     ASSERT_EQ(moved.bodies.size(), 1u);
-    EXPECT_DOUBLE_EQ(moved.bodies[0].sectionZ, 6.0);
+    ASSERT_TRUE(moved.bodies[0].section.has_value());
     const manifold::Rect r = moved.bodies[0].section->Bounds();
-    EXPECT_NEAR(r.min.x, 4.0, 1e-9);
+    EXPECT_NEAR(r.min.x, 4.0, 1e-9) << "x/y went into the section itself";
     EXPECT_NEAR(r.min.y, 5.0, 1e-9);
+
+    // ...and the z rode along, so the extruded slab still lands at 6.
+    const std::vector<ColoredBody> renderable = toRenderableBodies(moved.bodies);
+    EXPECT_NEAR(renderable[0].body->BoundingBox().min.z, 6.0, 1e-9);
+
+    // Two stacked z offsets accumulate rather than the last one winning.
+    Evaluated stacked = evalSrc("translate([0,0,2]) translate([0,0,3]) square(10);");
+    const std::vector<ColoredBody> r2 = toRenderableBodies(stacked.bodies);
+    EXPECT_NEAR(r2[0].body->BoundingBox().min.z, 5.0, 1e-9);
+}
+
+// -- transforms on a display-only (open surface) body ---------------------
+
+namespace {
+// A cube with one face left off: Manifold rejects it, so it survives only
+// as ColoredBody::rawMesh -- the shape that ignored every transform.
+constexpr const char* kOpenBox =
+    "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0],"
+    "                   [0,0,10],[10,0,10],[10,10,10],[0,10,10]],"
+    " faces=[[0,1,2,3],[4,5,1,0],[5,6,2,1],[6,7,3,2],[7,4,0,3]]);";
+
+std::array<double, 6> rawBounds(const Evaluated& e) {
+    std::array<double, 6> b{1e30, 1e30, 1e30, -1e30, -1e30, -1e30};
+    for (const ColoredBody& cb : e.bodies) {
+        if (!cb.rawMesh) continue;
+        const auto& mesh = *cb.rawMesh;
+        for (size_t i = 0; i + 2 < mesh.vertProperties.size(); i += mesh.numProp) {
+            for (int k = 0; k < 3; ++k) {
+                b[static_cast<size_t>(k)] = std::min(b[static_cast<size_t>(k)],
+                                                      static_cast<double>(mesh.vertProperties[i + static_cast<size_t>(k)]));
+                b[static_cast<size_t>(k + 3)] = std::max(b[static_cast<size_t>(k + 3)],
+                                                         static_cast<double>(mesh.vertProperties[i + static_cast<size_t>(k)]));
+            }
+        }
+    }
+    return b;
+}
+} // namespace
+
+TEST(DisplayOnlyTransforms, RawTrianglesFollowTheSameTransformAsASolid) {
+    // The open box and a closed cube occupy the same 10-cube, so after the
+    // SAME transform their bounding boxes must still agree. They did not:
+    // the raw triangles were left where they were built, so every copy of
+    // an open surface stacked at the origin -- BOSL2's skin() style figure
+    // showed one shape where the reference shows seven.
+    const char* xforms[] = {
+        "translate([5,-3,2])",
+        "rotate([30,40,50])",
+        "scale([2,0.5,1.5])",
+        "mirror([1,1,0])",
+        "multmatrix([[1,0.2,0,4],[0,1,0,5],[0,0,1,6]])",
+        "rotate(35, v=[1,2,3])",
+    };
+    for (const char* x : xforms) {
+        Evaluated open = evalSrc(std::string(x) + " " + kOpenBox);
+        Evaluated solid = evalSrc(std::string(x) + " cube(10);");
+        ASSERT_EQ(solid.bodies.size(), 1u) << x;
+        const manifold::Box want = solid.bodies[0].body->BoundingBox();
+        const std::array<double, 6> got = rawBounds(open);
+        EXPECT_NEAR(got[0], want.min.x, 1e-4) << x;
+        EXPECT_NEAR(got[1], want.min.y, 1e-4) << x;
+        EXPECT_NEAR(got[2], want.min.z, 1e-4) << x;
+        EXPECT_NEAR(got[3], want.max.x, 1e-4) << x;
+        EXPECT_NEAR(got[4], want.max.y, 1e-4) << x;
+        EXPECT_NEAR(got[5], want.max.z, 1e-4) << x;
+    }
+}
+
+TEST(DisplayOnlyTransforms, EachCopyLandsSomewhereDifferent) {
+    Evaluated e = evalSrc(std::string("for (i = [0:2]) translate([20*i, 0, 0]) ") + kOpenBox);
+    const std::array<double, 6> b = rawBounds(e);
+    EXPECT_NEAR(b[0], 0.0, 1e-6);
+    EXPECT_NEAR(b[3], 50.0, 1e-6) << "three copies 20 apart span 0..50, not one box";
 }
 
 TEST(MixedDimensions, UniformChildrenAreUntouched) {

{openscad_cpp_evaluator-0.55.4 → openscad_cpp_evaluator-0.55.5}/tests/test_control_flow.cpp

@@ -845,6 +845,38 @@ TEST(ExprEvalFunctionCall, CallingANonFunctionVariableWarnsAndIsUndef) {
     EXPECT_NE(warnings.back().find("Ignoring unknown function 'x'"), std::string::npos);
 }
 
+TEST(EchoStatement, RendersItsChildren) {
+    // `echo("x") cube();` -- echo used as a statement PREFIX. The reference
+    // echoes and then renders the child; we echoed and dropped it, on the
+    // stated assumption that the grammar never produced children here. It
+    // does. BOSL2's debug_region() draws its whole region through
+    // `for(...) echo(...) linear_extrude(...) region(...)` and came out as
+    // labels with nothing under them.
+    const char* cases[] = {
+        "echo(\"hi\") cube(10);",
+        "echo(\"hi\") { cube(10); }",
+        "echo(\"a\") echo(\"b\") cube(10);",
+        "for (i = [0:1]) echo(\"hi\") translate([i*20,0,0]) cube(10);",
+        "union() { echo(\"hi\") cube(10); }",
+    };
+    for (const char* src : cases) {
+        Evaluated e = evalSrc(src);
+        const bool anyVolume = std::any_of(
+            e.bodies.begin(), e.bodies.end(),
+            [](const ColoredBody& b) { return b.body && !b.body->IsEmpty(); });
+        EXPECT_TRUE(anyVolume) << src;
+    }
+}
+
+TEST(EchoStatement, StillEchoesAndKeepsArgumentsSeparateFromChildren) {
+    std::string captured;
+    Evaluated e = evalSrc("echo(\"fired\") cube(2);",
+                          [&](const std::string& msg) { captured = msg; });
+    EXPECT_EQ(captured, "ECHO: \"fired\"");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6);
+}
+
 TEST(Intersection, EchoInADisabledStatementStillFires) {
     // echo() runs during resolve, so its side effect happens whatever the
     // geometry does. The result is the cube(2): neither the disabled
@@ -1761,3 +1793,4 @@ TEST(RangeDirection, EveryRangeBuildingConstructWarns) {
         << "returned from a function";
 }
 
+