openscad-cpp-evaluator 0.26.1__tar.gz → 0.27.1__tar.gz

{openscad_cpp_evaluator-0.26.1 → openscad_cpp_evaluator-0.27.1}/PKG-INFO

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

{openscad_cpp_evaluator-0.26.1 → openscad_cpp_evaluator-0.27.1}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -223,6 +223,11 @@ public:
     // evaluate()/resolveTree()+generateTree() complete. Mirrors the
     // reference's Evaluator.id_to_node/id_to_color (also plain public
     // attributes there).
+    // Give cached bodies fresh originalIDs so a second call site reusing
+    // them is not confused with the first. See its definition.
+    void restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
+                          const oscad::ASTNode* producer);
+
     std::unordered_map<uint32_t, const oscad::ASTNode*> idToNode;
     std::unordered_map<uint32_t, std::optional<std::array<float, 4>>> idToColor;
 
@@ -1697,6 +1702,13 @@ private:
     EchoFn echoFn_;
     std::shared_ptr<FontProvider> fontProvider_; // null until first fontProvider() call if not injected
     std::shared_ptr<ManifoldCache> manifoldCache_; // opt-in, see the constructor's own doc comment
+
+    // Cache key -> the AST node whose generation filled that entry, for
+    // this render only (cleared alongside idToNode, whose pointers share
+    // the same lifetime). restampCachedIds() uses it to tell a cached ID
+    // that stands for the reused node itself from one that stands for a
+    // node deeper inside it; see there.
+    std::unordered_map<std::string, const oscad::ASTNode*> cacheProducer_;
     std::uint64_t randsCallCount_ = 0; // see noteRandsCall()
 
     // -- Debugging (Phase 9) --------------------------------------------

{openscad_cpp_evaluator-0.26.1 → openscad_cpp_evaluator-0.27.1}/pyproject.toml

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

{openscad_cpp_evaluator-0.26.1 → openscad_cpp_evaluator-0.27.1}/src/csg_generate.cpp

@@ -48,6 +48,11 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
         std::optional<std::vector<ColoredBody>> cached = key ? manifoldCache_->get(*key) : std::nullopt;
         if (cached) {
             node.bodies = std::move(*cached);
+            if (node.node) {
+                auto producer = cacheProducer_.find(*key);
+                restampCachedIds(node.bodies, *node.node,
+                                 producer == cacheProducer_.end() ? nullptr : producer->second);
+            }
         } else {
             // Recurse into children first (bottom-up) -- populates each
             // child's own .bodies in place so flattenCsgTree/a GenerateFn
@@ -75,7 +80,10 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
                 // Mirrors generate_tree()'s own fallback.
                 node.bodies = flattenCsgTree(node.children);
             }
-            if (key) manifoldCache_->put(*key, node.bodies);
+            if (key) {
+                manifoldCache_->put(*key, node.bodies);
+                cacheProducer_[*key] = node.node;
+            }
         }
         for (const ColoredBody& b : node.bodies) topLevelBodies.push_back(b);
     }
@@ -104,6 +112,56 @@ std::vector<ColoredBody> Evaluator::generatePartialTree() {
     return generateTreeImpl(flat);
 }
 
+void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
+                                 const oscad::ASTNode* producer) {
+    // A cache hit hands back the geometry AND the originalIDs of whichever
+    // call site first produced it. Those IDs are provenance -- "which node
+    // made this" -- not content, so two identical shapes at two call sites
+    // came back sharing one identity and selecting either picked both.
+    //
+    // Each distinct run gets a fresh ID, one per run rather than one per
+    // body, so a cached subtree made of several parts stays selectable
+    // part by part. Which node a fresh ID points at depends on what the old
+    // one stood for:
+    //
+    //   - the reused node itself (`producer`): two separate pieces of
+    //     source wrote the same shape, so this copy belongs to the node
+    //     reusing it, not the one that happened to be generated first.
+    //   - something deeper inside it -- the cube and sphere inside a module
+    //     called twice: both calls really do come from that one line of the
+    //     module body, so the old node is the honest answer and re-pointing
+    //     it at the call site would collapse every part of the call onto a
+    //     single line.
+    //
+    // Across renders the old IDs predate this render's idToNode, so nothing
+    // is known about their structure and everything falls to `node`.
+    //
+    // ponytail: two subtrees identical down to their transforms still
+    // share one attribution, since only the inner node is a cache hit and
+    // its producer check keeps the first copy's descendants. They occupy
+    // the same space, so there is nothing to select apart.
+    for (ColoredBody& cb : bodies) {
+        if (!cb.body || cb.body->IsEmpty()) continue;
+        manifold::MeshGL mesh = cb.body->GetMeshGL();
+        if (mesh.runOriginalID.empty()) continue;
+        std::unordered_map<uint32_t, uint32_t> remap;
+        for (uint32_t& id : mesh.runOriginalID) {
+            auto found = remap.find(id);
+            if (found == remap.end()) {
+                const uint32_t fresh = manifold::Manifold::ReserveIDs(1);
+                auto old = idToNode.find(id);
+                idToNode[fresh] =
+                    (old != idToNode.end() && old->second != producer) ? old->second : &node;
+                auto color = idToColor.find(id);
+                if (color != idToColor.end()) idToColor[fresh] = color->second;
+                found = remap.emplace(id, fresh).first;
+            }
+            id = found->second;
+        }
+        cb.body = manifold::Manifold(mesh);
+    }
+}
+
 ColoredBody Evaluator::tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue) {
     manifold::MeshGL mesh = body.GetMeshGL();
     std::optional<std::array<float, 4>> color = valueToColor(colorValue);

{openscad_cpp_evaluator-0.26.1 → openscad_cpp_evaluator-0.27.1}/src/csg_resolve.cpp

@@ -205,6 +205,7 @@ template <typename NodeList>
 std::vector<std::unique_ptr<CSGNode>> Evaluator::resolveTreeImpl(const NodeList& nodes, EvalContext& ctx) {
     idToNode.clear();
     idToColor.clear();
+    cacheProducer_.clear(); // holds AST pointers, same lifetime as idToNode's
     treeStack_.clear();
     treeStack_.emplace_back();
     rootCtx_ = &ctx;

{openscad_cpp_evaluator-0.26.1 → openscad_cpp_evaluator-0.27.1}/tests/test_manifold_cache.cpp

@@ -5,7 +5,10 @@
 #include "test_helpers.hpp"
 
 #include <gtest/gtest.h>
+#include <algorithm>
+#include <iterator>
 #include <numbers>
+#include <set>
 
 using namespace oscadeval;
 using namespace oscadeval::test;
@@ -121,20 +124,48 @@ TEST(ManifoldCacheUncacheable, RandsBeforeGeometryInModuleBodyTaintsSplicedSibli
 // -- cache reuse -----------------------------------------------------------
 
 TEST(ManifoldCache, CacheHitSkipsRegeneratingTheSubtree) {
+    // Read through the children: a hit serves the whole subtree at once, so
+    // the child is never generated and its own .bodies stays empty while
+    // the parent's is populated. (idToNode is no longer a proxy for this --
+    // restampCachedIds() populates it on a hit too, on purpose, or nothing
+    // served from cache would be selectable.)
+    const char* src = "translate([1,0,0]) cube(5, center=true);";
     auto cache = std::make_shared<ManifoldCache>();
-    Evaluated first = evalSrcWithCache("cube(5, center=true);", cache);
-    ASSERT_FALSE(first.ev.idToNode.empty()); // real generate work happened, tagGenerated() ran
 
-    Evaluated second = evalSrcWithCache("cube(5, center=true);", cache);
-    // A cache hit means generateCube() (and thus tagGenerated()) never ran
-    // for the second Evaluator's own node -- its idToNode stays empty even
-    // though its bodies are populated (served from the cache).
-    EXPECT_TRUE(second.ev.idToNode.empty());
+    Evaluated first = evalSrcWithCache(src, cache);
+    ASSERT_EQ(first.tree.size(), 1u);
+    ASSERT_EQ(first.tree[0]->children.size(), 1u);
+    EXPECT_FALSE(first.tree[0]->children[0]->bodies.empty()) << "the cube really was generated";
+
+    Evaluated second = evalSrcWithCache(src, cache);
+    ASSERT_EQ(second.tree.size(), 1u);
+    ASSERT_EQ(second.tree[0]->children.size(), 1u);
+    EXPECT_TRUE(second.tree[0]->children[0]->bodies.empty())
+        << "a cache hit regenerated the subtree it was supposed to replace";
+
     ASSERT_EQ(second.bodies.size(), 1u);
     ASSERT_TRUE(second.bodies[0].body.has_value());
     EXPECT_NEAR(second.bodies[0].body->Volume(), 125.0, 1e-9);
 }
 
+// Geometry served from the cache must still map back to source. Before
+// this, a re-render of an unchanged file was all cache hits against a
+// fresh Evaluator, so no ID carried a node and nothing in the viewport
+// could be picked at all.
+TEST(ManifoldCache, GeometryServedFromAnEarlierEvaluateStillMapsToItsSource) {
+    auto cache = std::make_shared<ManifoldCache>();
+    evalSrcWithCache("cube(5, center=true);", cache);
+
+    Evaluated second = evalSrcWithCache("cube(5, center=true);", cache);
+    ASSERT_EQ(second.bodies.size(), 1u);
+    const manifold::MeshGL mesh = second.bodies[0].body->GetMeshGL();
+    ASSERT_FALSE(mesh.runOriginalID.empty());
+    for (uint32_t id : mesh.runOriginalID) {
+        ASSERT_EQ(second.ev.idToNode.count(id), 1u) << "cached geometry has no source node";
+        EXPECT_NE(second.ev.idToNode.at(id), nullptr);
+    }
+}
+
 TEST(ManifoldCache, DifferentParamsAreNotServedEachOthersCachedResult) {
     auto cache = std::make_shared<ManifoldCache>();
     Evaluated a = evalSrcWithCache("cube(2, center=true);", cache);
@@ -156,6 +187,88 @@ TEST(ManifoldCache, UncacheableNodeAlwaysRegeneratesNeverHitsOrPopulatesCache) {
     EXPECT_FALSE(second.ev.idToNode.empty());
 }
 
+// A cache hit must not hand back the originalIDs of whichever call site
+// first produced the geometry. Those IDs are provenance, and sharing them
+// made two identical shapes one thing to a UI: selecting either picked
+// both. Common in CAD, where arrays of identical parts are the norm.
+TEST(ManifoldCache, IdenticalShapesAtDifferentCallSitesGetDistinctOriginalIds) {
+    auto cache = std::make_shared<ManifoldCache>();
+    Evaluated e = evalSrcWithCache(
+        "translate([0,0,0]) cylinder(h=20,r=4,$fn=32);\n"
+        "translate([25,0,0]) cylinder(h=20,r=4,$fn=32);\n", cache);
+    ASSERT_EQ(e.bodies.size(), 2u);
+
+    // Held in locals: GetMeshGL() returns by value, so taking begin() and
+    // end() from two separate calls walks between unrelated buffers.
+    const manifold::MeshGL meshA = e.bodies[0].body->GetMeshGL();
+    const manifold::MeshGL meshB = e.bodies[1].body->GetMeshGL();
+    const std::set<uint32_t> first(meshA.runOriginalID.begin(), meshA.runOriginalID.end());
+    const std::set<uint32_t> second(meshB.runOriginalID.begin(), meshB.runOriginalID.end());
+    ASSERT_FALSE(first.empty());
+    ASSERT_FALSE(second.empty());
+    std::vector<uint32_t> shared;
+    std::set_intersection(first.begin(), first.end(), second.begin(), second.end(),
+                           std::back_inserter(shared));
+    EXPECT_TRUE(shared.empty()) << "the two cylinders share an originalID";
+
+    // Both still resolve to a node, so re-stamping does not lose the
+    // mapping selection needs.
+    for (uint32_t id : first) EXPECT_EQ(e.ev.idToNode.count(id), 1u);
+    for (uint32_t id : second) EXPECT_EQ(e.ev.idToNode.count(id), 1u);
+
+    // ...and to *different* nodes. Distinct IDs alone only separated them
+    // in the viewport: inheriting the first call site's node left the
+    // editor highlighting one line whichever cylinder was picked.
+    for (uint32_t a : first)
+        for (uint32_t b : second)
+            EXPECT_NE(e.ev.idToNode.at(a), e.ev.idToNode.at(b))
+                << "both cylinders point at one source node";
+}
+
+// The other half of that rule. A cached ID standing for something *inside*
+// the reused node keeps its own node: both calls of a module really do
+// come from the one body that spells the parts out. Re-pointing those at
+// the call site would collapse every part of the call onto a single line
+// -- the same defect as above, one level down.
+TEST(ManifoldCache, PartsOfAReusedModuleKeepTheirOwnSourceNodes) {
+    auto cache = std::make_shared<ManifoldCache>();
+    Evaluated e = evalSrcWithCache(
+        "module pair() { cube(2); translate([5,0,0]) sphere(1,$fn=8); }\n"
+        "pair();\n"
+        "translate([0,20,0]) pair();\n", cache);
+    ASSERT_EQ(e.bodies.size(), 4u); // cube, sphere, cube, sphere
+
+    std::vector<const oscad::ASTNode*> nodes;
+    for (const ColoredBody& b : e.bodies) {
+        const manifold::MeshGL mesh = b.body->GetMeshGL();
+        ASSERT_EQ(mesh.runOriginalID.size(), 1u);
+        const uint32_t id = mesh.runOriginalID[0];
+        ASSERT_EQ(e.ev.idToNode.count(id), 1u);
+        nodes.push_back(e.ev.idToNode.at(id));
+    }
+    EXPECT_NE(nodes[0], nodes[1]) << "cube and sphere are not the same source";
+    EXPECT_EQ(nodes[0], nodes[2]) << "the second call's cube lost the cube() that wrote it";
+    EXPECT_EQ(nodes[1], nodes[3]) << "the second call's sphere lost the sphere() that wrote it";
+}
+
+// Re-stamping is per run, not per body, so a cached subtree made of
+// several parts stays selectable part by part rather than collapsing into
+// one -- which is what Manifold's own AsOriginal() would have done.
+TEST(ManifoldCache, ACachedMultiPartSubtreeKeepsOneIdPerPart) {
+    auto cache = std::make_shared<ManifoldCache>();
+    Evaluated e = evalSrcWithCache(
+        "module pair() { cube(2); translate([5,0,0]) sphere(1,$fn=8); }\n"
+        "pair();\n"
+        "translate([0,20,0]) pair();\n", cache);
+    ASSERT_EQ(e.bodies.size(), 4u);
+    std::set<uint32_t> all;
+    for (const ColoredBody& b : e.bodies) {
+        const manifold::MeshGL mesh = b.body->GetMeshGL();
+        for (uint32_t id : mesh.runOriginalID) all.insert(id);
+    }
+    EXPECT_EQ(all.size(), 4u) << "parts of the reused subtree share IDs";
+}
+
 TEST(ManifoldCache, OutputIsIdenticalCacheOnVsCacheOffAcrossBuiltinCategories) {
     const std::vector<std::string> scripts = {
         "cube(3);",