openscad-cpp-evaluator 1.49.8__tar.gz → 1.49.9__tar.gz

{openscad_cpp_evaluator-1.49.8 → openscad_cpp_evaluator-1.49.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.49.8
+Version: 1.49.9
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.49.8 → openscad_cpp_evaluator-1.49.9}/pyproject.toml

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

{openscad_cpp_evaluator-1.49.8 → openscad_cpp_evaluator-1.49.9}/src/builtins/modifiers.cpp

@@ -25,10 +25,16 @@ std::vector<ColoredBody> generateBackground(Evaluator&, const CSGParams&,
     return result;
 }
 
+// Only the ordinary bodies are re-tagged. A `#` or `%` inside the subtree
+// keeps its own look, as in OpenSCAD -- and a `#` operand's drawing-only
+// copy (HighlightGhost) has to stay one: stamped ShowOnly, it was drawn as
+// solid geometry, so a cut-away cylinder stood out of the part (BelfrySCAD
+// #912).
 std::vector<ColoredBody> generateShowOnly(Evaluator&, const CSGParams&,
                                            const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode&) {
     std::vector<ColoredBody> result = flattenCsgTree(children);
-    for (ColoredBody& b : result) b.role = BodyRole::ShowOnly;
+    for (ColoredBody& b : result)
+        if (b.role == BodyRole::Normal) b.role = BodyRole::ShowOnly;
     return result;
 }
 

{openscad_cpp_evaluator-1.49.8 → openscad_cpp_evaluator-1.49.9}/src/csg_resolve.cpp

@@ -335,7 +335,10 @@ std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalCont
     if (anyShowOnly) {
         std::vector<ColoredBody> filtered;
         for (ColoredBody& b : result) {
-            if (b.role == BodyRole::ShowOnly || b.role == BodyRole::Highlight || b.role == BodyRole::HighlightGhost)
+            // rerootAtShowOnly already dropped everything outside the `!`;
+            // what is left is its subtree, `%` and `#` bodies included.
+            if (b.role == BodyRole::ShowOnly || b.role == BodyRole::Highlight ||
+                b.role == BodyRole::HighlightGhost || b.role == BodyRole::Background)
                 filtered.push_back(std::move(b));
         }
         return filtered;

{openscad_cpp_evaluator-1.49.8 → openscad_cpp_evaluator-1.49.9}/tests/test_booleans.cpp

@@ -336,6 +336,38 @@ TEST(Modifiers, MoreThanOneShowOnlyTakesTheFirstAndWarns) {
     })) << "no warning in: " << (echoed.empty() ? "(nothing)" : echoed.front());
 }
 
+// BelfrySCAD #912: a `#` operand inside a `!` subtree. The cut still
+// happens, and the operand's drawing-only copy stays a HighlightGhost --
+// stamped ShowOnly, it was drawn as solid, standing out of the part.
+TEST(Modifiers, ShowOnlyKeepsAHighlightedOperandsGhost) {
+    Evaluated e = evaluateSrc(
+        "module M() difference() { cube(10); translate([5,5,-5]) #cylinder(h=20, r=2, $fn=16); }\n"
+        "!M();");
+    ASSERT_EQ(e.bodies.size(), 2u);
+    const auto solid = std::find_if(e.bodies.begin(), e.bodies.end(),
+                                    [](const ColoredBody& b) { return b.role == BodyRole::ShowOnly; });
+    const auto ghost = std::find_if(e.bodies.begin(), e.bodies.end(),
+                                    [](const ColoredBody& b) { return b.role == BodyRole::HighlightGhost; });
+    ASSERT_NE(solid, e.bodies.end());
+    ASSERT_NE(ghost, e.bodies.end());
+    EXPECT_LT(solid->body->Volume(), 1000.0 - 40.0) << "the cylinder was not cut away";
+}
+
+// As in OpenSCAD: inside the `!`, `%` and `#` keep their looks; outside it,
+// nothing survives.
+TEST(Modifiers, ShowOnlyKeepsBackgroundAndHighlightInsideIt) {
+    Evaluated e = evaluateSrc(
+        "!union() { cube(10); %translate([15,0,0]) cube(10); #translate([0,15,0]) cube(10); }\n"
+        "translate([-20,0,0]) cube(5);");
+    std::vector<BodyRole> roles;
+    for (const ColoredBody& b : e.bodies) roles.push_back(b.role);
+    EXPECT_EQ(std::count(roles.begin(), roles.end(), BodyRole::Background), 1);
+    // A `#` union operand is merged into the solid and drawn by its red copy.
+    EXPECT_EQ(std::count(roles.begin(), roles.end(), BodyRole::HighlightGhost), 1);
+    EXPECT_EQ(std::count(roles.begin(), roles.end(), BodyRole::ShowOnly), 1);
+    EXPECT_EQ(e.bodies.size(), 3u) << "the cube outside the ! survived";
+}
+
 TEST(Modifiers, NoShowOnlyMeansAllRolesPassThrough) {
     Evaluated e = evaluateSrc("%cube(1); cube(2);");
     EXPECT_EQ(e.bodies.size(), 2u);