openscad-cpp-evaluator 1.19.2__tar.gz → 1.19.3__tar.gz

{openscad_cpp_evaluator-1.19.2 → openscad_cpp_evaluator-1.19.3}/PKG-INFO

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

{openscad_cpp_evaluator-1.19.2 → openscad_cpp_evaluator-1.19.3}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -23,6 +23,11 @@ enum class BodyRole { Normal, Highlight, Background, ShowOnly };
 // `role`/`triColors` are later-phase fields (modifier tagging -- Phase 3;
 // multi-color CSG merges -- Phase 3/8) included now so the struct shape
 // doesn't need reworking when those land.
+// The colour drawn for geometry with no explicit color() wherever a live
+// theme cannot be consulted -- per-triangle colour arrays, which are baked.
+// Matches the reference's SceneRenderer._default_color.
+inline constexpr std::array<float, 4> kDefaultGeometryColor{0.9f, 0.85f, 0.1f, 1.0f};
+
 struct ColoredBody {
     std::optional<manifold::Manifold> body;
     std::optional<std::array<float, 4>> color; // RGBA; nullopt = "no explicit color() -- follow the live theme"

{openscad_cpp_evaluator-1.19.2 → openscad_cpp_evaluator-1.19.3}/pyproject.toml

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

{openscad_cpp_evaluator-1.19.2 → openscad_cpp_evaluator-1.19.3}/src/builtins/booleans.cpp

@@ -150,14 +150,6 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
 
 namespace {
 
-// Matches the reference's own SceneRenderer._default_color -- shown for
-// geometry with no explicit color() override. ColoredBody::color normally
-// stays nullopt for uncolored geometry so a live renderer can resolve it
-// against its own color theme, but a per-triangle triColors override has
-// no such live-resolution mechanism, so a concrete fallback is needed here
-// specifically.
-constexpr std::array<float, 4> kDefaultGeometryColor{0.9f, 0.85f, 0.1f, 1.0f};
-
 // After a real boolean merge, `cb.color` is just one arbitrary child's
 // color (the first contributing operand above) -- every other child's own
 // color is otherwise lost, e.g. union()-ing an opaque cube with a

{openscad_cpp_evaluator-1.19.2 → openscad_cpp_evaluator-1.19.3}/src/csg_generate.cpp

@@ -338,28 +338,68 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
         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) {
+        // fresh ID -> the colour its triangles carried, multi-colour
+        // bodies only; what triColors is rebuilt from below.
+        std::unordered_map<uint32_t, std::array<float, 4>> runColor;
+        for (size_t run = 0; run < mesh.runOriginalID.size(); ++run) {
+            uint32_t& id = mesh.runOriginalID[run];
             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;
+                // The colour has to be re-recorded too, or a later merge
+                // cannot tell this body's runs apart from uncoloured ones
+                // (attachTriColors looks runs up here). Across renders
+                // the old ID was minted by an earlier Evaluator and this
+                // one's idToColor has never heard of it, so the cached
+                // body itself is the record: its own colour, or for a
+                // multi-colour merge the colour its triangles carry. This
+                // is what made `difference() { color("orange") cube();
+                // color("cyan") cylinder(); ... }` lose the cyan on the
+                // first re-render after an edit and go flat orange on the
+                // next (BelfrySCAD #412) -- every cached operand looked
+                // uncoloured, so the merge saw nothing to distinguish.
                 auto color = idToColor.find(id);
-                if (color != idToColor.end()) idToColor[fresh] = color->second;
+                if (color != idToColor.end()) {
+                    idToColor[fresh] = color->second;
+                } else if (cb.triColors && run + 1 < mesh.runIndex.size() &&
+                           mesh.runIndex[run] / 3 < cb.triColors->size()) {
+                    // ponytail: a run whose triangles carry the default
+                    // fallback colour reads back as that explicit colour
+                    // rather than "follow the theme"; the tint is the same.
+                    idToColor[fresh] = (*cb.triColors)[mesh.runIndex[run] / 3];
+                } else {
+                    idToColor[fresh] = cb.color;
+                }
+                if (cb.triColors && run + 1 < mesh.runIndex.size() &&
+                    mesh.runIndex[run] / 3 < cb.triColors->size()) {
+                    runColor[fresh] = (*cb.triColors)[mesh.runIndex[run] / 3];
+                }
                 found = remap.emplace(id, fresh).first;
             }
             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();
+        // triangles merged away), and triColors is indexed by triangle, so
+        // the old array no longer lines up. The RUNS survive the rebuild,
+        // and each run's colour was just recorded, so the array is
+        // rebuilt from them rather than dropped -- dropping it turned a
+        // fully cached multi-colour difference() flat (BelfrySCAD #412).
+        if (cb.triColors && cb.body) {
+            const manifold::MeshGL rebuilt = cb.body->GetMeshGL();
+            const size_t numTris = rebuilt.triVerts.size() / 3;
+            std::vector<std::array<float, 4>> triColors(numTris, cb.color.value_or(kDefaultGeometryColor));
+            for (size_t i = 0; i + 1 < rebuilt.runIndex.size() && i < rebuilt.runOriginalID.size(); ++i) {
+                auto it = runColor.find(rebuilt.runOriginalID[i]);
+                if (it == runColor.end()) continue;
+                const size_t start = rebuilt.runIndex[i] / 3;
+                const size_t end = std::min<size_t>(rebuilt.runIndex[i + 1] / 3, numTris);
+                for (size_t t = start; t < end; ++t) triColors[t] = it->second;
+            }
+            cb.triColors = std::move(triColors);
         }
     }
 }

{openscad_cpp_evaluator-1.19.2 → openscad_cpp_evaluator-1.19.3}/tests/test_manifold_cache.cpp

@@ -6,6 +6,7 @@
 
 #include <gtest/gtest.h>
 #include <algorithm>
+#include <array>
 #include <iterator>
 #include <numbers>
 #include <set>
@@ -327,6 +328,46 @@ TEST(ManifoldCache, ACachedMultiPartSubtreeKeepsOneIdPerPart) {
     EXPECT_EQ(all.size(), 4u) << "parts of the reused subtree share IDs";
 }
 
+namespace {
+// Distinct RGB triples a body's triangles carry (its flat colour if it has
+// no per-triangle colours).
+std::set<std::array<float, 3>> distinctColors(const ColoredBody& cb) {
+    std::set<std::array<float, 3>> out;
+    if (cb.triColors) {
+        for (const auto& c : *cb.triColors) out.insert({c[0], c[1], c[2]});
+    } else if (cb.color) {
+        out.insert({(*cb.color)[0], (*cb.color)[1], (*cb.color)[2]});
+    }
+    return out;
+}
+} // namespace
+
+TEST(ManifoldCache, CachedOperandsKeepTheirColoursInALaterMerge) {
+    // BelfrySCAD #412: edit one subtrahend's colour and re-render with the
+    // cache shared, as the GUI does. The unchanged operands are cache hits
+    // and their run colours were never re-recorded, so the merge saw them
+    // as uncoloured: first re-render lost the cyan, the next (every
+    // operand cached) collapsed to flat orange.
+    const std::string a =
+        "difference() { color(\"orange\") cube(20, center=true);"
+        " color(\"cyan\") cylinder(30, r=8, center=true, $fn=24);"
+        " color(\"magenta\") rotate([0,90,0]) cylinder(30, r=8, center=true, $fn=24); }";
+    const std::string b = [&] { std::string s = a; s.replace(s.find("magenta"), 7, "green"); return s; }();
+
+    const std::set<std::array<float, 3>> wantB = distinctColors(evalSrc(b).bodies[0]);
+    ASSERT_EQ(wantB.size(), 3u);
+
+    auto cache = std::make_shared<ManifoldCache>();
+    evalSrcWithCache(a, cache);
+    EXPECT_EQ(distinctColors(evalSrcWithCache(b, cache).bodies[0]), wantB) << "first re-render";
+    EXPECT_EQ(distinctColors(evalSrcWithCache(b, cache).bodies[0]), wantB) << "fully cached";
+    // And a cached multi-colour body merged again keeps every colour.
+    Evaluated wrapped = evalSrcWithCache("union() { " + b + " translate([30,0,0]) color(\"red\") cube(5); }", cache);
+    std::set<std::array<float, 3>> wantWrapped = wantB;
+    wantWrapped.insert({1.0f, 0.0f, 0.0f});
+    EXPECT_EQ(distinctColors(wrapped.bodies[0]), wantWrapped);
+}
+
 TEST(ManifoldCache, OutputIsIdenticalCacheOnVsCacheOffAcrossBuiltinCategories) {
     const std::vector<std::string> scripts = {
         "cube(3);",

{openscad_cpp_evaluator-1.19.2 → openscad_cpp_evaluator-1.19.3}/tests/test_multi_color_merge.cpp

@@ -36,7 +36,6 @@ std::vector<std::array<float, 4>> distinctColors(const std::vector<std::array<fl
     return out;
 }
 
-constexpr std::array<float, 4> kDefaultGeometryColor{0.9f, 0.85f, 0.1f, 1.0f};
 
 } // namespace