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

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

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

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

@@ -225,7 +225,8 @@ 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);
+    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;
@@ -1701,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.27.0 → 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.27.0"
+version = "0.27.1"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

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

@@ -48,7 +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);
-            restampCachedIds(node.bodies);
+            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
@@ -76,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);
     }
@@ -105,7 +112,8 @@ std::vector<ColoredBody> Evaluator::generatePartialTree() {
     return generateTreeImpl(flat);
 }
 
-void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies) {
+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
@@ -113,8 +121,25 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies) {
     //
     // 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. Each new ID inherits the old one's node and color, so
-    // the parts keep pointing at the AST nodes that really produced them.
+    // 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();
@@ -124,8 +149,9 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies) {
             auto found = remap.find(id);
             if (found == remap.end()) {
                 const uint32_t fresh = manifold::Manifold::ReserveIDs(1);
-                auto node = idToNode.find(id);
-                if (node != idToNode.end()) idToNode[fresh] = node->second;
+                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;

{openscad_cpp_evaluator-0.27.0 → 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.27.0 → openscad_cpp_evaluator-0.27.1}/tests/test_manifold_cache.cpp

@@ -124,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);
@@ -187,6 +215,40 @@ TEST(ManifoldCache, IdenticalShapesAtDifferentCallSitesGetDistinctOriginalIds) {
     // 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