openscad-cpp-evaluator 1.25.0__tar.gz → 1.26.0__tar.gz

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.26.0}/CLAUDE.md

@@ -1687,6 +1687,20 @@ the former is worth dragging.
 A cache hit restamps to the chain reaching the geometry *now*, not the one that
 first produced it: a module called twice genuinely is two call chains.
 
+**A 2D shape is picked by `ColoredBody::sectionId`.** A `CrossSection` is contours
+with no run IDs, so a top-level 2D shape had no `idToNode` entry at all: its preview
+slab got fresh IDs from `Manifold::Extrude` in `toRenderableBodies`, after the table
+was built, and a click on it mapped to no source (it blocked BelfrySCAD's extrude
+gizmo, which exists to act on exactly those). Now the generate loop calls
+`tagSections` after every builtin's `GenerateFn`: any 2D body without an ID gets one
+reserved from Manifold's counter, attributed to that node. A transform keeps the ID
+it was given (it edits the body in place), so a 2D shape stays its primitive, as a
+solid's runs do; an op that builds a *new* section -- a 2D `union()`, `offset()`,
+`hull()` -- claims it, so the whole union is one pick. `restampCachedIds` restamps it
+by the solid rule (across renders, to the reused node), `recordRunColors` records its
+colour, and `toRenderableBodies` rebuilds the slab from a `MeshGL` whose one run
+carries it. Tested in `tests/test_python_bindings.py` (`_picked_text`).
+
 No stored script path is needed to tell the user's file from a library:
 `callStack_.front()` is by construction the call made from top level.
 
@@ -1695,7 +1709,7 @@ Exposed to Python as `node.call_sites` (innermost-first `_CallFrame`s, each a
 
 `Evaluator::measuring_` is set for the whole generate. It suppresses the four
 writes that exist solely to describe *drawn* geometry — `idToNode`/`idToColor`/`idToCallChain` in
-`tagGenerated` and `tagDisplayOnly`, the `restampCachedIds` call on a cache hit,
+`tagGenerated`, `tagDisplayOnly` and `tagSections`, the `restampCachedIds` call on a cache hit,
 and `cacheProducer_` — because those tables are cleared once per pass, so a leak
 is permanent and surfaces later as wrong click-to-source. It also suppresses
 `checkDebug`, which would otherwise inject stops at the paused statement's own

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.26.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.26.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -42,6 +42,15 @@ struct ColoredBody {
     std::optional<manifold::CrossSection> section;
     bool flatPreview = false;
 
+    // The originalID a 2D `section` is picked by. A CrossSection is contours
+    // and carries no run IDs, so a 2D shape had no entry in idToNode and a
+    // click on its preview slab mapped to no source at all. Reserved from
+    // Manifold's own counter (so it cannot collide with a solid's ID) by the
+    // generate loop, for the node that built the section -- a primitive, or
+    // an op like union() that made a new one; a transform keeps the one it
+    // was given. toRenderableBodies() gives the slab this ID.
+    std::optional<uint32_t> sectionId;
+
     // What a 2D `section` has been transformed BY that a CrossSection
     // cannot itself hold: a translation along Z, a rotation out of the XY
     // plane, anything with a Z component. Applied when

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.26.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -283,6 +283,9 @@ public:
     // attributes there).
     // Give cached bodies fresh originalIDs so a second call site reusing
     // them is not confused with the first. See its definition.
+    // Give every 2D body in `bodies` that has no sectionId yet one of its
+    // own, attributed to `node`. See ColoredBody::sectionId.
+    void tagSections(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node, uint32_t callChain);
     void restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
                           const oscad::ASTNode* producer, uint32_t callChain);
 

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.26.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.26.0}/src/colored_body.cpp

@@ -37,6 +37,18 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
         if (!cb.body && cb.section) {
             ColoredBody flat;
             flat.body = manifold::Manifold::Extrude(cb.section->ToPolygons(), kTopLevel2dHeight);
+            if (cb.sectionId && !flat.body->IsEmpty()) {
+                // One run carrying the section's own ID, so a click on the
+                // slab finds the node that built the shape (see
+                // ColoredBody::sectionId). Manifold keeps a MeshGL's
+                // runOriginalID when it is given one.
+                manifold::MeshGL mesh = flat.body->GetMeshGL();
+                mesh.runOriginalID = {*cb.sectionId};
+                mesh.runIndex = {0, static_cast<uint32_t>(mesh.triVerts.size())};
+                mesh.runTransform.clear();
+                mesh.faceID.clear();
+                flat.body = manifold::Manifold(mesh);
+            }
             // Put it back where the transforms a CrossSection could not
             // hold would have placed it -- a Z offset, a rotation out of
             // the plane. See ColoredBody::sectionXform.

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.26.0}/src/csg_generate.cpp

@@ -124,6 +124,7 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
                 generateWarnEntry = node.warnEntry;
                 generateCallChain = node.callChain;
                 node.bodies = it->second(*this, node.params, node.children, *node.node);
+                if (!measuring_) tagSections(node.bodies, *node.node, node.callChain);
                 generateWarnEntry = savedWarnEntry;
                 generateCallChain = savedCallChain;
             } else {
@@ -393,6 +394,16 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
     // 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) {
+        // A 2D body's one ID, restamped by the same rule as a solid's runs.
+        if (cb.sectionId) {
+            const uint32_t fresh = manifold::Manifold::ReserveIDs(1);
+            auto old = idToNode.find(*cb.sectionId);
+            idToNode[fresh] =
+                (old != idToNode.end() && old->second != producer) ? old->second : &node;
+            idToCallChain[fresh] = callChain;
+            idToColor[fresh] = cb.color;
+            cb.sectionId = fresh;
+        }
         if (!cb.body || cb.body->IsEmpty()) continue;
         manifold::MeshGL mesh = cb.body->GetMeshGL();
         if (mesh.runOriginalID.empty()) continue;
@@ -475,6 +486,7 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
 
 
 void Evaluator::recordRunColors(ColoredBody& b, const std::optional<std::array<float, 4>>& rgba) {
+    if (b.sectionId) idToColor[*b.sectionId] = rgba;
     if (!b.body || bodyIsEmpty(b)) return;
     // A body that is still one original knows its own ID without building
     // a mesh -- the common case, and the cheap one.
@@ -486,6 +498,18 @@ void Evaluator::recordRunColors(ColoredBody& b, const std::optional<std::array<f
     for (uint32_t id : b.body->GetMeshGL().runOriginalID) idToColor[id] = rgba;
 }
 
+void Evaluator::tagSections(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
+                            uint32_t callChain) {
+    for (ColoredBody& cb : bodies) {
+        if (!cb.section || cb.body || cb.sectionId) continue;
+        const uint32_t id = manifold::Manifold::ReserveIDs(1);
+        idToNode[id] = &node;
+        idToColor[id] = cb.color;
+        idToCallChain[id] = callChain;
+        cb.sectionId = id;
+    }
+}
+
 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-1.25.0 → openscad_cpp_evaluator-1.26.0}/tests/test_python_bindings.py

@@ -1046,3 +1046,53 @@ def test_svg_class_is_feature_detectable(tmp_path):
     out = []
     Evaluator(echo_fn=out.append).evaluate(str(scad), generate=False)
     assert "1" in out[0], out
+
+
+def _picked_text(tmp_path, src, cache=None, name="s.scad"):
+    """What a click on each body would select: the source text its run IDs
+    map to, per body, in body order."""
+    script = tmp_path / name
+    script.write_text(src)
+    ev = Evaluator(manifold_cache=cache) if cache else Evaluator()
+    bodies, id_to_node = ev.evaluate(str(script), {})
+    out = []
+    for b in bodies:
+        ids = [int(i) for i in b.body.to_mesh().run_original_id]
+        out.append([src[id_to_node[i].position.start_offset:id_to_node[i].position.end_offset]
+                    if i in id_to_node else None for i in ids])
+    return out
+
+
+def test_a_2d_shape_can_be_picked_back_to_its_source(tmp_path):
+    """A CrossSection carries no run IDs, so a 2D shape's preview slab used
+    to map to no node at all and could not be selected (BelfrySCAD's
+    extrude gizmo needs exactly that)."""
+    picked = _picked_text(tmp_path, "square(3);\ncircle(4);\n")
+    assert picked == [["square(3);"], ["circle(4);"]]
+
+
+def test_a_transform_keeps_the_2d_shape_it_moved(tmp_path):
+    picked = _picked_text(tmp_path, "translate([10, 0]) circle(4);\n")
+    assert len(picked) == 1 and picked[0][0] is not None
+    assert picked[0][0].startswith("circle(4)") or picked[0][0].startswith("translate")
+
+
+def test_a_2d_union_is_its_own_shape(tmp_path):
+    src = "union() { square(3); circle(4); }\n"
+    assert _picked_text(tmp_path, src) == [[src.strip()]]
+
+
+def test_a_cached_2d_shape_is_picked_as_a_solid_would_be(tmp_path):
+    """A cache hit restamps IDs; a 2D shape's must follow, or the second
+    render of an unchanged script loses every 2D selection. It follows the
+    same rule a solid's runs do: across renders the old ID is unknown, so it
+    goes to the reused node -- here the whole translate() statement."""
+    def two_renders(src):
+        cache = ManifoldCache()
+        return _picked_text(tmp_path, src, cache), _picked_text(tmp_path, src, cache)
+
+    flat = two_renders("square(3);\ntranslate([10, 0]) circle(4);\n")
+    solid = two_renders("cube(3);\ntranslate([10, 0, 0]) sphere(4);\n")
+    assert all(t is not None for render in flat for body in render for t in body)
+    assert flat[1] == [["square(3);"], ["translate([10, 0]) circle(4);"]]
+    assert solid[1] == [["cube(3);"], ["translate([10, 0, 0]) sphere(4);"]]