openscad-cpp-evaluator 0.54.0__tar.gz → 0.55.1__tar.gz

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/CLAUDE.md

@@ -699,6 +699,17 @@ grep for `ponytail:`.
   permanent cache miss for any subtree that called `rands()` while resolving, since such a
   subtree's resolved params aren't a pure function of its own content anymore (the actual `rands()`
   output also depends on every earlier `rands()` call's position in the whole evaluation's order).
+  A second, separate taint — `CSGNode::keyHasClosure`, set by `cacheKey()` itself rather than at
+  resolve time — does the same for any subtree holding a **function literal** in its params (the
+  `levelset(function (x,y,z) ..., ...)` shape). `canonValue()` can only key a closure by its AST
+  node's raw address, which is meaningful for exactly one parse: the next render frees that AST and
+  a fresh closure over *different* captured values can be allocated at the very same address, so
+  the key silently hits the previous render's geometry — the GUI symptom was an edited script
+  rendering its **old** shape until saved a second time. (The address also ignores the captured
+  values themselves, so two closures over one literal collide within a single render, which is what
+  `tests/test_manifold_cache.cpp` pins down deterministically.) Keying a closure honestly means
+  canonicalizing its captured `let_` trail, which is type-erased (`Closure::capturedLet` is a
+  `shared_ptr<void>`); until that exists such a subtree simply does not participate in the cache.
   Builtins are registered in `src/builtins/registry.cpp` as `(name string) -> (ResolveFn,
   GenerateFn)` pairs — `dispatch.hpp` has the exact reasoning for `GenerateFn`'s `Evaluator&`
   parameter (provenance-table writes only, no `EvalContext`/dynamic-scope access, so the

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/PKG-INFO

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

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/include/openscad_cpp_evaluator/csg_node.hpp

@@ -72,6 +72,21 @@ struct CSGNode {
     // on first cacheKey() call; every node here is always reached through a
     // non-const CSGNode&, so no `mutable` is needed to write it.
     std::optional<std::string> cachedKey;
+
+    // Set by the same cacheKey() pass that fills cachedKey: true if this
+    // node's own params, or any descendant's, hold a function literal.
+    //
+    // canonValue() can only key a closure by its AST node's raw address,
+    // and that address is meaningful for exactly one parse: the next
+    // render frees that AST, and a fresh closure over different captured
+    // values can be allocated at the very same address -- so the key
+    // silently hits the PREVIOUS render's geometry. (It also ignores the
+    // captured values themselves, so two closures over one literal share a
+    // key within a single render.) Keying a closure honestly would mean
+    // canonicalising its captured `let_` trail, which is type-erased; until
+    // that exists, such a subtree just does not participate in the cache.
+    // See csg_generate.cpp's lookup.
+    bool keyHasClosure = false;
 };
 
 

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -294,6 +294,15 @@ public:
     // depth-first on one thread.
     const oscad::Position* generateWarnEntry = nullptr;
 
+    // Set while generating anything beneath a hull(). An open mesh there is
+    // not a mistake to report: a convex hull needs only points, so BOSL2's
+    // hull_points(pts, fast=true) hands polyhedron() a deliberately garbage
+    // face list purely to carry the vertices in. The reference says nothing
+    // about it, and spheroid(circum=true, style="icosa") goes through that
+    // path -- warning would fire on an everyday BOSL2 call. Covers the whole
+    // subtree, not just direct children, since hull() consumes all of it.
+    bool insideHull = false;
+
     ColoredBody tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue);
 
     // tagGenerated()'s counterpart for a mesh Manifold refused to build --

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/pyproject.toml

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

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/src/builtins/import.cpp

@@ -318,10 +318,13 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
         const MeshDiagnosis d = checkMesh(mesh);
         std::string why = d.summary();
         if (why.empty()) why = manifoldErrorName(body.Status());
-        ev.warn("import: mesh is not a closed solid (" + why +
-                    "); drawing it as a surface, but it cannot take part in any CSG "
-                    "operation" + (repair ? "" : ". Try import(..., repair=true)"),
-                &node.position());
+        if (!ev.insideHull) {
+            ev.warn("import: mesh is not a closed solid (" + why +
+                        "); drawing it as a surface. hull() can still use its points, but "
+                        "it cannot take part in union/difference/intersection" +
+                        std::string(repair ? "" : ". Try import(..., repair=true)"),
+                    &node.position());
+        }
         // tagDisplayOnly carries a raw triangle soup for the renderer to
         // draw, and the renderer is float either way, so narrowing here
         // costs nothing this mesh will ever be measured on.

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/src/builtins/primitives_3d.cpp

@@ -802,10 +802,12 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
         // closed mesh with reversed winding, non-manifold vertices or
         // self-intersections builds perfectly well, and only an OPEN one
         // reaches this branch. The count points straight at the problem.
-        ev.warn("polyhedron: mesh is not closed -- " + std::to_string(countBoundaryEdges(mesh)) +
-                    " boundary edge(s); drawing it as a surface, but it cannot "
-                    "take part in any CSG operation",
-                &node.position());
+        if (!ev.insideHull) {
+            ev.warn("polyhedron: mesh is not closed -- " + std::to_string(countBoundaryEdges(mesh)) +
+                        " boundary edge(s); drawing it as a surface. hull() can still "
+                        "use its points, but it cannot take part in union/difference/intersection",
+                    &node.position());
+        }
         manifold::MeshGL soup;
         soup.numProp = 3;
         soup.vertProperties.assign(mesh.vertProperties.begin(), mesh.vertProperties.end());

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/src/builtins/topology.cpp

@@ -35,19 +35,51 @@ CSGParams resolveHull(Evaluator& ev, const oscad::ModularCall& node, EvalContext
 // matching the reference's own `if bodies_3d: ... else: sections...`
 // either/or dispatch). background/highlight/show_only bodies pass through
 // untouched, same as union/difference/intersection.
+// Vertex positions out of a MeshGL, whatever else it carries per vertex.
+// Only the first three properties are the position; numProp may be larger.
+static void appendVertices(const manifold::MeshGL& mesh, std::vector<manifold::vec3>& out) {
+    const size_t stride = mesh.numProp;
+    if (stride < 3) return;
+    for (size_t i = 0; i + 2 < mesh.vertProperties.size(); i += stride)
+        out.push_back({mesh.vertProperties[i], mesh.vertProperties[i + 1],
+                       mesh.vertProperties[i + 2]});
+}
+
 std::vector<ColoredBody> generateHull(Evaluator&, const CSGParams&, const std::vector<std::unique_ptr<CSGNode>>& children,
                                        const oscad::ASTNode&) {
     const std::vector<ColoredBody> bodies = flattenCsgTree(children);
     if (bodies.empty()) return {};
     const RoleSplit split = splitByRole(bodies);
 
+    // An open mesh has no Manifold, but a convex hull only ever needed its
+    // POINTS -- closedness is irrelevant to one. BOSL2 depends on this:
+    // hull_points(pts, fast=true) hands polyhedron() a deliberately garbage
+    // face list purely to carry the vertices into hull(), and
+    // spheroid(circum=true, style="icosa") goes through it. Dropping those
+    // children left the loose triangles to fall through un-hulled, which is
+    // what the reference does not do.
+    std::vector<manifold::vec3> loosePoints;
+    for (const ColoredBody& c : split.displayOnly) {
+        if (c.rawMesh) appendVertices(*c.rawMesh, loosePoints);
+    }
+
     std::optional<ColoredBody> hullResult;
-    if (!split.foreground.empty()) {
+    if (!split.foreground.empty() || !loosePoints.empty()) {
         std::vector<manifold::Manifold> bodies3d;
         for (const ColoredBody& c : split.foreground) {
             if (c.body) bodies3d.push_back(*c.body);
         }
-        if (!bodies3d.empty()) {
+        if (!loosePoints.empty()) {
+            // Hulling points and bodies together has to go through the
+            // point overload, so the solids contribute their vertices too.
+            for (const manifold::Manifold& m : bodies3d)
+                appendVertices(m.GetMeshGL(), loosePoints);
+            ColoredBody cb;
+            cb.body = manifold::Manifold::Hull(loosePoints);
+            cb.color = split.foreground.empty() ? split.displayOnly.front().color
+                                                : split.foreground.front().color;
+            hullResult = std::move(cb);
+        } else if (!bodies3d.empty()) {
             ColoredBody cb;
             cb.body = manifold::Manifold::Hull(bodies3d);
             cb.color = split.foreground.front().color;
@@ -71,7 +103,10 @@ std::vector<ColoredBody> generateHull(Evaluator&, const CSGParams&, const std::v
     result.insert(result.end(), split.background.begin(), split.background.end());
     result.insert(result.end(), split.highlight.begin(), split.highlight.end());
     result.insert(result.end(), split.showOnly.begin(), split.showOnly.end());
-    result.insert(result.end(), split.displayOnly.begin(), split.displayOnly.end());
+    // Only pass the open meshes through if they were NOT hulled; hull()
+    // consumes its children, so re-adding them would draw them twice.
+    if (loosePoints.empty())
+        result.insert(result.end(), split.displayOnly.begin(), split.displayOnly.end());
     return result;
 }
 

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/src/csg_generate.cpp

@@ -44,7 +44,15 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
         // re-deriving results that would just be discarded. Mirrors
         // generate_tree()'s own cache check exactly.
         std::optional<std::string> key;
-        if (manifoldCache_ && !node.uncacheable) key = cacheKey(node);
+        if (manifoldCache_ && !node.uncacheable) {
+            key = cacheKey(node);
+            // A key that serialized a function literal is not a pure
+            // function of content -- it embeds a raw AST address that the
+            // next parse can hand out again. Dropping the key here forces
+            // both the get() below and the put() further down to be
+            // skipped. See CSGNode::keyHasClosure.
+            if (node.keyHasClosure) key.reset();
+        }
         std::optional<std::vector<ColoredBody>> cached = key ? manifoldCache_->get(*key) : std::nullopt;
         if (cached) {
             node.bodies = std::move(*cached);
@@ -64,7 +72,13 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             std::vector<CSGNode*> childPtrs;
             childPtrs.reserve(node.children.size());
             for (const std::unique_ptr<CSGNode>& c : node.children) childPtrs.push_back(c.get());
+            // Saved and restored rather than left set, exactly as
+            // generateWarnEntry is: a sibling generated afterwards is not
+            // inside this hull.
+            const bool savedInsideHull = insideHull;
+            if (node.isBuiltin && node.kind == "hull") insideHull = true;
             generateTreeImpl(childPtrs);
+            insideHull = savedInsideHull;
 
             applyDimensionRules(node);
 

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/src/manifold_cache.cpp

@@ -93,6 +93,32 @@ std::string canonValue(const Value& v) {
         v);
 }
 
+// True if `v` is a function literal, or a list/object holding one at any
+// depth. Drives CSGNode::keyHasClosure -- see its doc comment for why a
+// closure cannot be keyed.
+bool valueHasClosure(const Value& v) {
+    return std::visit(
+        [](const auto& val) -> bool {
+            using T = std::decay_t<decltype(val)>;
+            if constexpr (std::is_same_v<T, ClosurePtr>) {
+                return true;
+            } else if constexpr (std::is_same_v<T, ListPtr>) {
+                if (!val) return false;
+                for (const Value& item : val->items)
+                    if (valueHasClosure(item)) return true;
+                return false;
+            } else if constexpr (std::is_same_v<T, ObjectPtr>) {
+                if (!val) return false;
+                for (const auto& [k, vv] : val->items)
+                    if (valueHasClosure(vv)) return true;
+                return false;
+            } else {
+                return false;
+            }
+        },
+        v);
+}
+
 std::string canonParams(const CSGParams& params) {
     std::vector<std::pair<std::string, std::string>> entries;
     entries.reserve(params.size());
@@ -120,13 +146,24 @@ std::string canonParams(const CSGParams& params) {
 std::string cacheKey(CSGNode& node) {
     if (node.cachedKey) return *node.cachedKey;
 
+    bool hasClosure = false;
+    for (const auto& [k, v] : node.params) {
+        if (valueHasClosure(v)) { hasClosure = true; break; }
+    }
+
     std::string out = "N(";
     appendLenPrefixed(out, node.kind);
     out += node.isBuiltin ? "1" : "0";
     appendLenPrefixed(out, canonParams(node.params));
     out += std::to_string(node.children.size()) + "[";
-    for (const auto& c : node.children) appendLenPrefixed(out, cacheKey(*c));
+    for (const auto& c : node.children) {
+        appendLenPrefixed(out, cacheKey(*c));
+        // A closure anywhere below poisons this key too: it is built from
+        // the children's keys.
+        hasClosure = hasClosure || c->keyHasClosure;
+    }
     out += "])";
+    node.keyHasClosure = hasClosure;
     node.cachedKey = out;
     return *node.cachedKey;
 }

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/tests/test_csg_tree.cpp

@@ -314,3 +314,81 @@ TEST(WarningTrace, FromClauseNamesOutermostFrameNotImmediateCaller) {
     EXPECT_NE(warning.find("from <string>, line 3"), std::string::npos) << warning;
     EXPECT_EQ(warning.find("from <string>, line 2"), std::string::npos) << warning;
 }
+
+// -- hull() over an open mesh ------------------------------------------
+//
+// A convex hull needs only its input's POINTS; whether the mesh that
+// carried them is closed is irrelevant. BOSL2 leans on this hard:
+// hull_points(pts, fast=true) hands polyhedron() a deliberately garbage
+// face list purely as a vehicle for the vertices, and
+// spheroid(circum=true, style="icosa") goes through that path. Treating
+// the open mesh as display-only left the loose triangles to fall out of
+// hull() un-hulled -- the model rendered as a scatter of shards where the
+// reference produced a solid.
+
+TEST(HullOpenMesh, HullsThePointsOfAMeshThatDoesNotClose) {
+    Evaluated e = evalSrc(
+        "pts = [[0,0,0],[10,0,0],[10,10,0],[0,10,0],\n"
+        "       [0,0,10],[10,0,10],[10,10,10],[0,10,10]];\n"
+        "hull() polyhedron(points=pts, faces=[[0,1,2],[3,4,5],[6,7,0]]);\n");
+
+    ASSERT_EQ(e.bodies.size(), 1u) << "the open mesh must be consumed, not passed through";
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_FALSE(e.bodies[0].isDisplayOnly());
+    EXPECT_EQ(e.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6);
+}
+
+TEST(HullOpenMesh, AnOpenMeshAndASolidHullTogether) {
+    // The solid's own vertices must survive the switch to the point-based
+    // hull: hulling only the loose points would silently shrink the result.
+    Evaluated e = evalSrc(
+        "hull() {\n"
+        "  polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]);\n"
+        "  translate([0,0,10]) cube(10);\n"
+        "}\n");
+
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_EQ(e.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+    // Hull of the z=0 square and the 10..20 cube: a prism, strictly larger
+    // than the cube alone.
+    EXPECT_GT(e.bodies[0].body->Volume(), 1000.0);
+}
+
+TEST(HullOpenMesh, AnOpenMeshOutsideAHullStillPassesThroughUntouched) {
+    Evaluated e = evalSrc(
+        "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]);\n");
+
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_TRUE(e.bodies[0].isDisplayOnly()) << "only hull() may consume it";
+}
+
+TEST(HullOpenMesh, NoWarningForAnOpenMeshInsideAHull) {
+    // The reference is silent here, and BOSL2 reaches this on an everyday
+    // spheroid(circum=true, style="icosa") -- warning would cry wolf.
+    std::string warning;
+    evalSrc("hull() polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0],\n"
+            "                          [0,0,10],[10,0,10],[10,10,10],[0,10,10]],\n"
+            "                  faces=[[0,1,2],[3,4,5],[6,7,0]]);\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_EQ(warning, "") << warning;
+}
+
+TEST(HullOpenMesh, SuppressionCoversTheWholeSubtreeNotJustDirectChildren) {
+    std::string warning;
+    evalSrc("hull() { translate([0,0,1]) polyhedron(\n"
+            "    points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]); cube(1); }\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_EQ(warning, "") << warning;
+}
+
+TEST(HullOpenMesh, ASiblingAfterAHullStillWarns) {
+    // The flag is restored on the way out; an open mesh that is NOT hulled
+    // is still a real mistake.
+    std::string warning;
+    evalSrc("hull() cube(1);\n"
+            "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]);\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_NE(warning.find("mesh is not closed"), std::string::npos) << warning;
+}

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.1}/tests/test_manifold_cache.cpp

@@ -121,6 +121,65 @@ TEST(ManifoldCacheUncacheable, RandsBeforeGeometryInModuleBodyTaintsSplicedSibli
     EXPECT_TRUE(e.tree[0]->uncacheable);
 }
 
+// -- closure taint ---------------------------------------------------------
+
+TEST(ManifoldCacheClosure, PlainNodeHasNoClosureTaint) {
+    Evaluated e = evalSrc("cube(5);");
+    ASSERT_EQ(e.tree.size(), 1u);
+    cacheKey(*e.tree[0]);
+    EXPECT_FALSE(e.tree[0]->keyHasClosure);
+}
+
+TEST(ManifoldCacheClosure, FunctionLiteralParamTaintsTheNode) {
+    Evaluated e = evalSrc(
+        "levelset(function (x,y,z) x*x+y*y+z*z-100,"
+        "         bounds=[[-15,-15,-15],[15,15,15]], edge=5);");
+    ASSERT_EQ(e.tree.size(), 1u);
+    cacheKey(*e.tree[0]);
+    EXPECT_TRUE(e.tree[0]->keyHasClosure);
+}
+
+TEST(ManifoldCacheClosure, TaintPropagatesUpThroughATransform) {
+    // The parent's key is built from the child's, so a closure below is
+    // just as unusable there.
+    Evaluated e = evalSrc(
+        "translate([1,0,0]) levelset(function (x,y,z) x*x+y*y+z*z-100,"
+        "         bounds=[[-15,-15,-15],[15,15,15]], edge=5);");
+    ASSERT_EQ(e.tree.size(), 1u);
+    EXPECT_EQ(e.tree[0]->kind, "translate");
+    cacheKey(*e.tree[0]);
+    EXPECT_TRUE(e.tree[0]->keyHasClosure);
+}
+
+// The bug this taint exists for, at full size: both closures come from the
+// SAME function literal (so canonValue's "F<pointer>" is byte-identical)
+// but capture different `r`. Every other cache-key input matches too, so
+// before the taint the second levelset() was served the first one's
+// geometry and both spheres came out radius 10.
+//
+// Deterministic on purpose: one evaluation, one AST, so the two closures
+// genuinely share a node address rather than relying on the allocator
+// handing back a freed one.
+TEST(ManifoldCacheClosure, TwoClosuresOverOneLiteralAreNotServedEachOthersGeometry) {
+    auto cache = std::make_shared<ManifoldCache>();
+    Evaluated e = evalSrcWithCache(
+        "function mk(r) = function (x,y,z) x*x+y*y+z*z-r*r;\n"
+        "levelset(mk(10), bounds=[[-15,-15,-15],[15,15,15]], edge=2);\n"
+        "translate([40,0,0])\n"
+        "  levelset(mk(5), bounds=[[-15,-15,-15],[15,15,15]], edge=2);\n",
+        cache);
+
+    ASSERT_EQ(e.bodies.size(), 2u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    ASSERT_TRUE(e.bodies[1].body.has_value());
+    const double volBig = e.bodies[0].body->Volume();
+    const double volSmall = e.bodies[1].body->Volume();
+    // Coarse sampling, so compare the two against each other rather than
+    // against 4/3*pi*r^3: r=10 vs r=5 is an 8x volume ratio.
+    EXPECT_GT(volBig, 2.0 * volSmall)
+        << "the second closure was served the first one's cached geometry";
+}
+
 // -- cache reuse -----------------------------------------------------------
 
 TEST(ManifoldCache, CacheHitSkipsRegeneratingTheSubtree) {