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

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

@@ -231,6 +231,15 @@ 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.
+
 **Font support**: a `FontProvider` abstract interface (`font_provider.hpp`: `resolveFont`/
 `metrics`/`shapeText`/`glyphInkBounds`/`glyphOutline`) with `FreetypeFontProvider` as the built-in
 implementation everything here actually uses. `Evaluator`'s constructor takes an optional

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

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

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

@@ -24,6 +24,21 @@ struct ColoredBody {
     std::optional<std::array<float, 4>> color; // RGBA; nullopt = "no explicit color() -- follow the live theme"
     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.
+    //
+    // 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
+    // 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.
+    //
+    // 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;
     BodyRole role = BodyRole::Normal;
     std::optional<std::vector<std::array<float, 4>>> triColors; // per-triangle RGBA, multi-color CSG merges only
 
@@ -60,7 +75,7 @@ Value colorToValue(const std::optional<std::array<double, 4>>& color);
 std::optional<std::array<float, 4>> valueToColor(const Value& v);
 
 // Converts every top-level 2D-only result (`body` unset, `section` set --
-// e.g. a bare `circle();`) into a thin-extruded (1e-3 units tall) Manifold
+// e.g. a bare `circle();`) into a 1-unit-tall extruded Manifold
 // tagged `flatPreview = true`, so a mesh exporter/renderer that only
 // understands 3D Manifolds (writeStl/writeObj/writeOff/writeThreeMf) can
 // still show a 2D top-level result instead of silently dropping it. 3D

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

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

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

@@ -233,6 +233,10 @@ 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));
         } else if (b.body) {
             b.body = applyTransform3d(name, args, std::move(*b.body));

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

@@ -21,7 +21,13 @@ std::optional<std::array<float, 4>> valueToColor(const Value& v) {
 }
 
 namespace {
-constexpr double kTopLevel2dHeight = 1e-3;
+// The reference extrudes a 2D shape to exactly 1 unit for preview -- measured
+// against OpenSCAD at three camera tilts (60/70/80 degrees), which put it at
+// 0.92/1.00/0.99, the 60 being pixel-rounding on the shallowest angle. Ours
+// was 1e-3, which reads as a flat silhouette with no visible edge and, more
+// annoyingly, gives --viewall a different bounding box to fit, so every 2D
+// docs image came out at a different scale from the published one.
+constexpr double kTopLevel2dHeight = 1.0;
 } // namespace
 
 std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies) {
@@ -31,6 +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));
             flat.color = cb.color;
             flat.flatPreview = true;
             flat.role = cb.role;

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.3}/src/export.cpp

@@ -432,7 +432,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
     // A `flatPreview` body is a top-level 2D shape thin-extruded so it can be
     // SEEN (toRenderableBodies). The top level keeps 2D and 3D side by side
     // for exactly that reason -- but a mesh export of a mixed script must
-    // not smuggle a 1e-3-tall slab in beside the real solids, which is what
+    // not smuggle a 1-unit-tall slab in beside the real solids, which is what
     // the reference drops there too. A 2D-ONLY script still exports its
     // slab, unchanged: that is the only geometry there is, and dropping it
     // would leave nothing to write.

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.3}/tests/test_booleans.cpp

@@ -625,7 +625,7 @@ TEST(MixedDimensions, TopLevelWarnsButKeepsBothDimensions) {
 
 TEST(MixedDimensions, ExportDropsTheFlatSlabWhenRealSolidsArePresent) {
     // The top level keeps a 2D shape so it can be SEEN, thin-extruded by
-    // toRenderableBodies. A mesh export must not smuggle that 1e-3-tall slab
+    // toRenderableBodies. A mesh export must not smuggle that 1-unit-tall slab
     // in beside the real solids -- the reference drops it there too.
     Evaluated e = evalSrc("square(4); cube(1);");
     const std::vector<ColoredBody> renderable = toRenderableBodies(e.bodies);
@@ -633,7 +633,7 @@ TEST(MixedDimensions, ExportDropsTheFlatSlabWhenRealSolidsArePresent) {
 
     const std::vector<ExportObject> objects = splitBodiesForExport(renderable, nullptr);
     ASSERT_EQ(objects.size(), 1u) << "but only the cube is exported";
-    // The cube is a unit tall; the dropped slab would have been 1e-3.
+    // Only the cube survives, so the height is the cube's own.
     float zmin = 1e9f, zmax = -1e9f;
     for (size_t i = 2; i < objects[0].verts.size(); i += 3) {
         zmin = std::min(zmin, objects[0].verts[i]);
@@ -651,6 +651,44 @@ TEST(MixedDimensions, ExportKeepsTheFlatSlabWhenItIsTheOnlyGeometry) {
     EXPECT_EQ(objects.size(), 1u);
 }
 
+TEST(MixedDimensions, ATranslatedTwoDeeShapeKeepsItsZ) {
+    // A CrossSection is purely 2D, so `translate([0,0,-1]) square(10)` had
+    // nowhere to put the -1 and dropped it. Two 2D shapes meant to be
+    // layered then came out exactly coplanar, z-fought, and whichever drew
+    // last hid the other -- BOSL2's isosurface contour() Example 1 renders a
+    // green contour over a blue backdrop pushed down by 1, and the backdrop
+    // covered the contour completely.
+    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);
+    ASSERT_TRUE(renderable[0].body.has_value());
+    const manifold::Box box = renderable[0].body->BoundingBox();
+    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);
+
+    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);
+
+    // x/y still go into the CrossSection itself, not the offset.
+    Evaluated moved = evalSrc("translate([4,5,6]) square(10);");
+    ASSERT_EQ(moved.bodies.size(), 1u);
+    EXPECT_DOUBLE_EQ(moved.bodies[0].sectionZ, 6.0);
+    const manifold::Rect r = moved.bodies[0].section->Bounds();
+    EXPECT_NEAR(r.min.x, 4.0, 1e-9);
+    EXPECT_NEAR(r.min.y, 5.0, 1e-9);
+}
+
 TEST(MixedDimensions, UniformChildrenAreUntouched) {
     EXPECT_TRUE(dimWarnings("union() { cube(1); cube(2); }").empty());
     EXPECT_TRUE(dimWarnings("union() { square(1); square(2); }").empty());

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.3}/tests/test_export.cpp

@@ -91,7 +91,7 @@ TEST(ExportStl, NoGeometryThrows) {
 TEST(ToRenderableBodies, ThinExtrudesABareTopLevel2dShapeSoItCanExportAsStl) {
     // A bare `circle();` (no `body`, only `section`) would make writeStl
     // throw "No geometry to export" -- toRenderableBodies() converts it
-    // into a thin (1e-3 unit tall) Manifold first, mirroring the reference
+    // into a 1-unit-tall Manifold first, mirroring the reference
     // CLI's own to_renderable_bodies() call right before export. Without
     // this step, no top-level 2D-only script could ever export a mesh.
     std::vector<ColoredBody> bodies = evalToBodies("circle(2, $fn=32);");
@@ -104,7 +104,9 @@ TEST(ToRenderableBodies, ThinExtrudesABareTopLevel2dShapeSoItCanExportAsStl) {
     ASSERT_TRUE(renderable[0].body.has_value());
     EXPECT_TRUE(renderable[0].flatPreview);
     manifold::Box bbox = renderable[0].body->BoundingBox();
-    EXPECT_NEAR(bbox.max.z - bbox.min.z, 1e-3, 1e-9);
+    // 1 unit, matching what the reference extrudes a 2D preview to --
+    // measured against OpenSCAD at three camera tilts.
+    EXPECT_NEAR(bbox.max.z - bbox.min.z, 1.0, 1e-9);
 
     const std::string path = tempPath("flat_preview.stl").string();
     writeStl(path, renderable);