openscad-cpp-evaluator 1.12.0__tar.gz → 1.13.0__tar.gz

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/CLAUDE.md

@@ -793,6 +793,24 @@ grep for `ponytail:`.
   color instead of preserving each part's own, matching real OpenSCAD's actual behavior once fixed
   (cross-checked triangle-color-count-and-values against the Python reference directly, not just
   “does it run”).
+  Two things that pipeline depends on, both learned from BelfrySCAD #372 (`union() { color("red")
+  stroke(...); text(); }` came out entirely red):
+  **`color()` records its colour against the body's RUN IDS**, not only in `cb.color`
+  (`recordRunColors`, `color.cpp`). `tagGenerated()` covers a body coloured at birth — the colour
+  reaches a primitive through the context — but not one that already existed when colour was applied
+  to it, which is every module that wraps FORWARDED children: `module setcolor(clr) { color(clr)
+  children(); }` (BOSL2's `stroke()` has exactly that) generates the children in the caller's
+  colourless context, so nothing recorded them as red and after the merge every run looked
+  uncoloured. Uses `Manifold::OriginalID()` where the body is still one original, so the common case
+  costs no mesh build.
+  **An unknown run falls back to `nullopt`, never `cb.color`** — `cb.color` is the *first* child's
+  colour, so falling back to it made an uncoloured sibling look identically coloured, `allSame` came
+  out true, and nothing was tagged at all.
+  And the invariant behind both: **`triColors` must index the body's CURRENT mesh**. The renderer
+  masks its vertex arrays with it, so a stale length is an `IndexError` and a blank viewport rather
+  than a wrong colour. Anything that re-meshes clears it — `simplify()`, `minkowski_difference()`,
+  and the ID-retag rebuild when the triangle count moves — and `bodyToDict` drops a mismatched array
+  as a backstop for whichever one gets missed next.
   **2D cannot use any of that, and keeps colour geometrically instead** (`Part2d`, same file): a
   `CrossSection` is contours, not a mesh, so nothing in it remembers which child an edge came from
   and there is no provenance for `attachTriColors` to read back. So the 2D accumulator holds **one

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/bindings/module.cpp

@@ -168,6 +168,13 @@ nb::dict bodyToDict(oscadeval::ColoredBody& cb) {
     // (numTri, 4) float32 array or None). The renderer reads this to split
     // one merged body's triangles across separate opaque/translucent draw
     // buffers.
+    // Size-checked, not trusted: a per-triangle array that disagrees with
+    // the mesh it is meant to index makes the renderer raise IndexError and
+    // draw nothing. Dropping it costs the per-triangle colours of one body
+    // and keeps the model on screen. Everything that can invalidate it is
+    // supposed to clear it (simplify(), minkowski_difference(), the retag
+    // rebuild); this is the backstop for the one that gets missed.
+    if (cb.triColors && cb.triColors->size() != numTri) cb.triColors.reset();
     if (cb.triColors) {
         const std::vector<std::array<float, 4>>& src = *cb.triColors;
         std::vector<float> flat;

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -1237,6 +1237,13 @@ public:
     // it), which no RAII guard can span.
     bool measuring_ = false;
 
+    // True while a render() expression is measuring geometry it will then
+    // discard. The provenance tables (idToNode/idToColor) are not written
+    // during that, so anything outside this class applying the same guard
+    // -- color.cpp records run colours the way tagGenerated does -- reads
+    // it here.
+    bool measuring() const { return measuring_; }
+
     // Test-only accessors for the invariants above -- a leaked measuring_ or
     // an unbalanced treeStack_ is otherwise silent until something much
     // later goes mysteriously wrong.

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/src/builtins/booleans.cpp

@@ -184,7 +184,13 @@ void attachTriColors(Evaluator& ev, ColoredBody& cb) {
     perRunColor.reserve(runIds.size());
     for (uint32_t rid : runIds) {
         auto it = ev.idToColor.find(rid);
-        perRunColor.push_back(it != ev.idToColor.end() ? it->second : cb.color);
+        // nullopt, NOT cb.color, when a run has no recorded colour of its
+        // own. cb.color is the FIRST child's colour, so falling back to it
+        // made an uncoloured child look identically coloured, `allSame`
+        // came out true, and the whole merge kept one colour -- which is
+        // the "union() { color("red") a; b; } is all red" bug. nullopt is
+        // what an uncoloured body means everywhere else: follow the theme.
+        perRunColor.push_back(it != ev.idToColor.end() ? it->second : std::nullopt);
     }
     const bool allSame =
         std::all_of(perRunColor.begin(), perRunColor.end(), [&](const auto& c) { return c == perRunColor.front(); });

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/src/builtins/color.cpp

@@ -50,12 +50,42 @@ CSGParams resolveColor(Evaluator& ev, const oscad::ModularCall& node, EvalContex
     return std::move(result.params);
 }
 
-std::vector<ColoredBody> generateColor(Evaluator&, const CSGParams& params,
+namespace {
+
+// Stamping cb.color is not enough: the colour has to be recorded against
+// the body's RUN IDS too.
+//
+// attachTriColors (booleans.cpp) reads `idToColor` back AFTER a merge has
+// thrown the individual bodies away -- run IDs are all it has left to go
+// on -- and a run it cannot find looks uncoloured. tagGenerated() records
+// the colour a body was BORN with, which covers `color("red") cube(10)`
+// because the colour reaches the primitive through the context. It does
+// not cover a body that already existed when colour was applied to it,
+// which is every module whose geometry comes out of its own CSG:
+// `union() { color("red") stroke(...); text(); }` had no red recorded for
+// the stroke's runs at all, so every run looked identical, the merge kept
+// the first child's colour, and the whole thing came out red.
+void recordRunColors(Evaluator& ev, const ColoredBody& b, const std::optional<std::array<float, 4>>& rgba) {
+    if (!b.body || b.body->IsEmpty()) return;
+    // A body that is still one original knows its own ID without building
+    // a mesh -- the common case, and the cheap one.
+    const int original = b.body->OriginalID();
+    if (original >= 0) {
+        ev.idToColor[static_cast<uint32_t>(original)] = rgba;
+        return;
+    }
+    for (uint32_t id : b.body->GetMeshGL().runOriginalID) ev.idToColor[id] = rgba;
+}
+
+} // namespace
+
+std::vector<ColoredBody> generateColor(Evaluator& ev, const CSGParams& params,
                                         const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode&) {
     const auto rgba = valueToColor(params.at("rgba"));
     std::vector<ColoredBody> result;
     for (ColoredBody b : flattenCsgTree(children)) {
         b.color = rgba;
+        if (!ev.measuring()) recordRunColors(ev, b, rgba);
         result.push_back(std::move(b));
     }
     return result;

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/src/builtins/topology.cpp

@@ -481,7 +481,14 @@ std::vector<ColoredBody> generateSimplify(Evaluator& ev, const CSGParams& params
                 const manifold::vec3 d = bb.Size();
                 tol = kDefaultSimplifyFraction * std::sqrt(d.x * d.x + d.y * d.y + d.z * d.z);
             }
-            if (tol > 0.0) cb.body = b.body->Simplify(tol);
+            if (tol > 0.0) {
+                cb.body = b.body->Simplify(tol);
+                // triColors is indexed by triangle, and decimation changes
+                // how many there are -- carrying it across leaves the
+                // renderer masking a 550-triangle mesh with a 556-entry
+                // array, which is an IndexError, not a wrong colour.
+                cb.triColors.reset();
+            }
         } else if (b.section) {
             double tol = explicitValue;
             if (!explicitTol) {

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/src/csg_generate.cpp

@@ -331,7 +331,16 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
             }
             id = found->second;
         }
+        const size_t trisBefore = mesh.triVerts.size() / 3;
         cb.body = manifold::Manifold(mesh);
+        // Rebuilding a Manifold from a mesh can clean it up (degenerate
+        // triangles merged away), and triColors is indexed by triangle. An
+        // array that no longer matches is worse than none: the renderer
+        // masks its vertex arrays with it and raises IndexError rather
+        // than drawing anything at all.
+        if (cb.triColors && cb.body && cb.body->GetMeshGL().triVerts.size() / 3 != trisBefore) {
+            cb.triColors.reset();
+        }
     }
 }
 

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.13.0}/tests/test_booleans.cpp

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <gtest/gtest.h>
+#include <set>
 
 using namespace oscadeval;
 using namespace oscadeval::test;
@@ -1554,3 +1555,81 @@ TEST(Union2dColor, ExtrudingAColouredUnionStillDropsColour) {
     EXPECT_FALSE(e.bodies[0].color.has_value());
     EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6);
 }
+
+
+// -- 3D colour survives a merge (BelfrySCAD #372) -------------------------
+
+namespace {
+
+std::set<std::array<float, 4>> distinctTriColors(const ColoredBody& b) {
+    std::set<std::array<float, 4>> out;
+    if (b.triColors) out.insert(b.triColors->begin(), b.triColors->end());
+    return out;
+}
+
+} // namespace
+
+TEST(Union3dColor, ColourAppliedToForwardedChildrenSurvivesTheMerge) {
+    // The reported case, reduced out of BOSL2. Its stroke() colours what
+    // it draws through exactly this shape -- a module that wraps FORWARDED
+    // children in color(). The children were generated in the caller's
+    // context, where there is no colour, so tagGenerated() recorded them as
+    // uncoloured; color() then stamped cb.color and nothing else. After the
+    // merge, attachTriColors had only run IDs to go on, every one of them
+    // looked uncoloured, they all "matched", and the union kept the first
+    // child's colour -- the whole model came out red.
+    Evaluated e = evalSrc(
+        "module setcolor(clr) { color(clr) children(); }\n"
+        "union() {"
+        "  setcolor(\"red\") cube(10);"
+        "  translate([12,0,0]) cube(10);"
+        "}");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].triColors.has_value());
+    const auto colours = distinctTriColors(e.bodies[0]);
+    EXPECT_EQ(colours.size(), 2u);
+    EXPECT_EQ(colours.count(std::array<float, 4>{1, 0, 0, 1}), 1u);
+}
+
+TEST(Union3dColor, AnUncolouredChildDoesNotInheritTheColouredOne) {
+    // perRunColor's fallback used to be cb.color -- the FIRST child's
+    // colour -- so an uncoloured sibling looked identically coloured, the
+    // "do the colours differ?" test said no, and nothing was tagged at all.
+    Evaluated e = evalSrc(
+        "union() { color(\"red\") cube(10); translate([12,0,0]) cube(10); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].triColors.has_value());
+    const auto colours = distinctTriColors(e.bodies[0]);
+    EXPECT_EQ(colours.size(), 2u);
+    EXPECT_EQ(colours.count(std::array<float, 4>{1, 0, 0, 1}), 1u);
+    // ... and the other half is the default, not red.
+    for (const auto& c : colours) {
+        if (c != std::array<float, 4>{1, 0, 0, 1}) EXPECT_NE(c[0], 1.0f);
+    }
+}
+
+TEST(Union3dColor, EveryTriangleIsAccountedFor) {
+    // triColors must index the body's CURRENT mesh exactly: the renderer
+    // masks its vertex arrays with it, so a stale length is an IndexError
+    // and a blank viewport, not a wrong colour.
+    Evaluated e = evalSrc(
+        "union() { color(\"red\") cube(10); color(\"blue\") translate([12,0,0]) cube(10); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].triColors.has_value());
+    EXPECT_EQ(e.bodies[0].triColors->size(), e.bodies[0].body->GetMeshGL().triVerts.size() / 3);
+}
+
+TEST(Union3dColor, SimplifyDropsPerTriangleColoursRatherThanKeepingStaleOnes) {
+    // Decimation changes the triangle count; an array indexed against the
+    // old one cannot be salvaged, and handing it on crashes the renderer.
+    Evaluated e = evalSrc(
+        "simplify(0.5) union() {"
+        "  color(\"red\") sphere(10, $fn=32);"
+        "  color(\"blue\") translate([25,0,0]) sphere(10, $fn=32);"
+        "}");
+    ASSERT_FALSE(e.bodies.empty());
+    for (const ColoredBody& b : e.bodies) {
+        if (!b.body || !b.triColors) continue;
+        EXPECT_EQ(b.triColors->size(), b.body->GetMeshGL().triVerts.size() / 3);
+    }
+}