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

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

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

{openscad_cpp_evaluator-1.19.1 → 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.1 → 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.1"
+version = "1.19.3"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.19.1 → 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.1 → openscad_cpp_evaluator-1.19.3}/src/builtins/primitives_3d.cpp

@@ -409,13 +409,20 @@ CSGParams resolveCylinder(Evaluator& ev, const oscad::ModularCall& node, EvalCon
     // per-end r1/r2, then the per-end d1/d2. So `cylinder(h=10, d=8, r1=5)`
     // is r1=5/r2=4, and `cylinder(h=10, r=5, r2=2)` is r1=5/r2=2. Both ends
     // default to 1 independently -- r2 does NOT fall back to r1.
+    //
+    // NUMBERS only, as the reference's isNumber() tests: a stray positional
+    // in a radius slot -- `cylinder(30, r=5, true)`, a mistyped center= --
+    // is ignored, not coerced. Lenient conversion turned that `true` into
+    // r1=1 and drew a cone where OpenSCAD draws the r=5 cylinder
+    // (BelfrySCAD #409).
+    const auto isNum = [](const Value& v) { return std::holds_alternative<double>(v); };
     double r1 = 1.0, r2 = 1.0;
-    if (!isUndef(rV)) r1 = r2 = toDoubleLenient(rV);
-    if (!isUndef(dV)) r1 = r2 = toDoubleLenient(dV) / 2.0;
-    if (!isUndef(r1V)) r1 = toDoubleLenient(r1V);
-    if (!isUndef(r2V)) r2 = toDoubleLenient(r2V);
-    if (!isUndef(d1V)) r1 = toDoubleLenient(d1V) / 2.0;
-    if (!isUndef(d2V)) r2 = toDoubleLenient(d2V) / 2.0;
+    if (isNum(rV)) r1 = r2 = std::get<double>(rV);
+    if (isNum(dV)) r1 = r2 = std::get<double>(dV) / 2.0;
+    if (isNum(r1V)) r1 = std::get<double>(r1V);
+    if (isNum(r2V)) r2 = std::get<double>(r2V);
+    if (isNum(d1V)) r1 = std::get<double>(d1V) / 2.0;
+    if (isNum(d2V)) r2 = std::get<double>(d2V) / 2.0;
 
     const int segs = fnSegmentsFromCtx(effCtx, std::max(r1, r2));
 

{openscad_cpp_evaluator-1.19.1 → 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.1 → openscad_cpp_evaluator-1.19.3}/src/text/freetype_font_provider.cpp

@@ -238,8 +238,15 @@ FreetypeFontProvider::FreetypeFontProvider() : impl_(std::make_unique<Impl>()) {
 FreetypeFontProvider::~FreetypeFontProvider() = default;
 
 FontHandle FreetypeFontProvider::resolveFont(const std::string& spec) {
-    const FontSpec parsed = parseFontSpec(spec);
-    if (parsed.families.empty()) return 0;
+    FontSpec parsed = parseFontSpec(spec);
+    if (parsed.families.empty()) {
+        // font=":style=bold" -- a style with no family names the DEFAULT
+        // family in that style, which is what fontconfig does with it and
+        // what BOSL2's text3d() example relies on (BelfrySCAD #405).
+        // Returning handle 0 here silently drew Regular.
+        if (parsed.style.empty()) return 0;
+        parsed.families.push_back(impl_->faces[0].metrics.family);
+    }
 
     const auto cached = impl_->bySpec.find(spec);
     if (cached != impl_->bySpec.end()) return cached->second;

{openscad_cpp_evaluator-1.19.1 → 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.1 → 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
 

{openscad_cpp_evaluator-1.19.1 → openscad_cpp_evaluator-1.19.3}/tests/test_primitives.cpp

@@ -51,6 +51,19 @@ TEST(Cylinder, StraightCylinderVolumeAndBoundsWhenCentered) {
     EXPECT_NEAR(e.bodies[0].body->Volume(), analytic, analytic * 0.02);
 }
 
+TEST(Cylinder, NonNumericRadiusIsIgnoredNotCoerced) {
+    // cylinder(30, r=5, true): the `true` lands in r1's slot. The reference
+    // applies a radius only if it isNumber(), so this is the r=5 cylinder;
+    // lenient conversion made it a cone from r1=1 (BelfrySCAD #409).
+    Evaluated e = evalSrc("cylinder(30, r=5, true, $fn=32);");
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    const double analytic = std::numbers::pi * 5.0 * 5.0 * 30.0;
+    EXPECT_NEAR(e.bodies[0].body->Volume(), analytic, analytic * 0.02);
+    // Same rule for every radius spelling, and a string is not a number.
+    Evaluated s = evalSrc("cylinder(h=30, r=5, r2=\"7\", $fn=32);");
+    EXPECT_NEAR(s.bodies[0].body->Volume(), analytic, analytic * 0.02);
+}
+
 TEST(Cylinder, UncenteredSitsOnZEqualsZero) {
     Evaluated e = evalSrc("cylinder(h=5, r=1, $fn=16);");
     manifold::Box bbox = e.bodies[0].body->BoundingBox();

{openscad_cpp_evaluator-1.19.1 → openscad_cpp_evaluator-1.19.3}/tests/test_text.cpp

@@ -380,6 +380,22 @@ TEST(FontArgs, TheLaterPositionalsLineUpToo) {
     EXPECT_EQ(echoes[0], "ECHO: true, true");
 }
 
+TEST(TextArgs, StyleWithoutFamilyStylesTheDefaultFace) {
+    // font=":style=bold" -- BOSL2's text3d() example 2 -- drew Regular:
+    // no family, so resolveFont handed back the default handle and never
+    // looked at the style (BelfrySCAD #405). It means the default family
+    // in bold, the same face "Liberation Sans:style=Bold" names.
+    std::vector<std::string> echoes;
+    evalSrc(
+        "b = render() { linear_extrude(1) text(\"Hi\", 10, font=\":style=bold\"); };\n"
+        "n = render() { linear_extrude(1) text(\"Hi\", 10, font=\"Liberation Sans:style=Bold\"); };\n"
+        "d = render() { linear_extrude(1) text(\"Hi\", 10); };\n"
+        "echo(b.volume == n.volume, b.volume == d.volume);\n",
+        [&](const std::string& m) { echoes.push_back(m); });
+    ASSERT_EQ(echoes.size(), 1u);
+    EXPECT_EQ(echoes[0], "ECHO: true, false");
+}
+
 TEST(TextArgs, FontIsPositionalButTheRestAreNot) {
     // text("Hi", 10, "Liberation Sans:style=Bold") silently drew the
     // DEFAULT face: `font` was name-only, so the third argument went