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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.49.7
+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.7 → openscad_cpp_evaluator-1.49.9}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -45,6 +45,16 @@ inline constexpr std::array<float, 4> kDefaultGeometryColor{0.9f, 0.85f, 0.1f, 1
 // geometry colour so a cut reads as a cut.
 inline constexpr std::array<float, 4> kCutFaceColor{157.0f / 255.0f, 203.0f / 255.0f, 81.0f / 255.0f, 1.0f};
 
+// What a per-triangle colour array holds for the two colours above, so a
+// renderer can still draw them in its live theme: baking the real values
+// painted every uncoloured difference() yellow and green whatever the
+// theme (BelfrySCAD #884's follow-up). Negative RGB is no colour a script
+// can make; alpha 1 keeps them opaque for a renderer's alpha split.
+// Export writes the real colours in their place (resolveThemeColors), so
+// files are unchanged.
+inline constexpr std::array<float, 4> kThemeBodyColor{-1.0f, -1.0f, -1.0f, 1.0f};
+inline constexpr std::array<float, 4> kThemeCutColor{-2.0f, -2.0f, -2.0f, 1.0f};
+
 struct ColoredBody {
     std::optional<manifold::Manifold> body;
     std::optional<std::array<float, 4>> color; // RGBA; nullopt = "no explicit color() -- follow the live theme"

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

{openscad_cpp_evaluator-1.49.7 → openscad_cpp_evaluator-1.49.9}/src/builtins/booleans.cpp

@@ -214,12 +214,12 @@ void attachTriColors(Evaluator& ev, ColoredBody& cb) {
         std::all_of(perRunColor.begin(), perRunColor.end(), [&](const auto& c) { return c == perRunColor.front(); });
     if (allSame) return;
 
-    std::vector<std::array<float, 4>> triColors(numTris, kDefaultGeometryColor);
+    std::vector<std::array<float, 4>> triColors(numTris, kThemeBodyColor);
     for (size_t i = 0; i + 1 < runIdx.size(); ++i) {
         const size_t start = runIdx[i] / 3;
         const size_t end = std::min<size_t>(runIdx[i + 1] / 3, numTris);
         if (start >= numTris) continue;
-        const std::array<float, 4> color = perRunColor[i].value_or(kDefaultGeometryColor);
+        const std::array<float, 4> color = perRunColor[i].value_or(kThemeBodyColor);
         for (size_t t = start; t < end; ++t) triColors[t] = color;
     }
     cb.triColors = std::move(triColors);
@@ -458,7 +458,7 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
         if (op == "difference" && res3d && !ev.measuring()) {
             for (ColoredBody& c : bodies3d) {
                 if (c.color || c.triColors) continue;
-                ev.recordRunColors(c, kCutFaceColor);
+                ev.recordRunColors(c, kThemeCutColor);
                 mixedColors = true;
             }
         }

{openscad_cpp_evaluator-1.49.7 → 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.7 → openscad_cpp_evaluator-1.49.9}/src/csg_generate.cpp

@@ -517,7 +517,7 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
         if (cb.triColors && cb.body) {
             const manifold::MeshGL rebuilt = cb.body->GetMeshGL();
             const size_t numTris = rebuilt.triVerts.size() / 3;
-            std::vector<std::array<float, 4>> triColors(numTris, cb.color.value_or(kDefaultGeometryColor));
+            std::vector<std::array<float, 4>> triColors(numTris, cb.color.value_or(kThemeBodyColor));
             for (size_t i = 0; i + 1 < rebuilt.runIndex.size() && i < rebuilt.runOriginalID.size(); ++i) {
                 auto it = runColor.find(rebuilt.runOriginalID[i]);
                 if (it == runColor.end()) continue;

{openscad_cpp_evaluator-1.49.7 → 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.7 → openscad_cpp_evaluator-1.49.9}/src/export.cpp

@@ -459,6 +459,16 @@ std::vector<std::string> mixedDimensionWarnings(const std::vector<ColoredBody>&
     return out;
 }
 
+// A file has no theme: the stand-ins a renderer draws in its theme's colours
+// are written as the colours they stand in for (colored_body.hpp).
+static std::vector<std::array<float, 4>> resolveThemeColors(std::vector<std::array<float, 4>> colors) {
+    for (auto& c : colors) {
+        if (c == kThemeBodyColor) c = kDefaultGeometryColor;
+        else if (c == kThemeCutColor) c = kCutFaceColor;
+    }
+    return colors;
+}
+
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts,
                                                 bool splitComponents, bool splitColors) {
     struct Solid {
@@ -492,7 +502,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             meshToArrays(*cb.rawMesh, obj.verts, obj.tris);
             if (obj.tris.empty()) continue;
             obj.color = cb.color.value_or(kDefaultExportColor);
-            if (cb.triColors) obj.triColors = *cb.triColors;
+            if (cb.triColors) obj.triColors = resolveThemeColors(*cb.triColors);
             loose.push_back(std::move(obj));
             if (openParts) openParts->push_back(index);
             continue;
@@ -501,7 +511,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
         Solid s;
         s.man = *cb.body;
         s.color = cb.color;
-        if (cb.triColors) s.triColors = *cb.triColors;
+        if (cb.triColors) s.triColors = resolveThemeColors(*cb.triColors);
         s.tris = s.man.GetMeshGL().triVerts;
         if (s.tris.empty()) continue;
         solids.push_back(std::move(s));

{openscad_cpp_evaluator-1.49.7 → 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);

{openscad_cpp_evaluator-1.49.7 → openscad_cpp_evaluator-1.49.9}/tests/test_multi_color_merge.cpp

@@ -1,4 +1,5 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
+#include "openscad_cpp_evaluator/export.hpp"
 #include "openscad_cpp_evaluator/manifold_cache.hpp"
 
 #include "test_helpers.hpp"
@@ -73,7 +74,7 @@ TEST(MultiColorCsgMerge, DifferenceCutFaceGetsTheCutGreen) {
     const auto distinct = distinctColors(*e.bodies[0].triColors);
     EXPECT_EQ(distinct.size(), 3u);
     EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, {0.0f, 1.0f, 1.0f, 0.5f}); }));
-    EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kCutFaceColor); }));
+    EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kThemeCutColor); }));
 }
 
 TEST(MultiColorCsgMerge, UncolouredMinuendCutByUncolouredToolStillShowsTheCut) {
@@ -84,6 +85,20 @@ TEST(MultiColorCsgMerge, UncolouredMinuendCutByUncolouredToolStillShowsTheCut) {
     ASSERT_TRUE(e.bodies[0].triColors.has_value());
     const auto distinct = distinctColors(*e.bodies[0].triColors);
     EXPECT_EQ(distinct.size(), 2u);
+    // Both are the theme stand-ins, not baked colours, so a renderer can
+    // draw them in its live theme rather than always yellow and green.
+    EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kThemeCutColor); }));
+    EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kThemeBodyColor); }));
+}
+
+TEST(MultiColorCsgMerge, ExportWritesRealColoursForTheThemeStandIns) {
+    // A file has no theme: the stand-ins are written as the colours they
+    // replaced, so exports are unchanged.
+    Evaluated e = evalSrc("difference() { cube(10); translate([5,5,-1]) cylinder(h=12, d=6, $fn=16); }");
+    const std::vector<ExportObject> objs = splitBodiesForExport(e.bodies, nullptr, false, true);
+    ASSERT_EQ(objs.size(), 1u);
+    const auto distinct = distinctColors(objs[0].triColors);
+    EXPECT_EQ(distinct.size(), 2u);
     EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kCutFaceColor); }));
     EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kDefaultGeometryColor); }));
 }