openscad-cpp-evaluator 0.34.0__tar.gz → 0.36.0__tar.gz

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.36.0}/CLAUDE.md

@@ -561,6 +561,29 @@ grep for `ponytail:`.
   color instead of preserving each part's own, matching real OpenSCAD's actual behavior once fixed
   (cross-checked triangle-color-count-and-values against the Python reference directly, not just
   “does it run”).
+- `src/builtins/primitives_3d.cpp` — `sphere(style=)` is a BelfrySCAD extension naming the
+  tessellation, using BOSL2's five `spheroid()` style names and constructions: `"orig"` (the default,
+  and what OpenSCAD's own sphere() builds — rings offset half a step from the poles, no pole vertex),
+  `"aligned"` (a vertex at each pole, so an `$fn` divisible by 4 also lands vertices exactly on ±X
+  and ±Y), `"stagger"` (aligned with alternate rings rotated half a face), `"octa"` and `"icosa"`.
+  Only `"orig"` renders the same in real OpenSCAD.
+
+  `"octa"` is `Manifold::Sphere`, which already *is* a subdivided octahedron (`Shape::Octahedron`
+  then `Subdivide`). Same 146/288 topology as BOSL2's at `$fn=24`, ~0.05% apart in volume because
+  Manifold distributes the subdivision differently. `"icosa"` samples each icosahedral face against
+  its own corners rather than rotating copies of one sampled face the way BOSL2 does — the sampling
+  is affine in those corners, so it is the same points with far less machinery — and welds the
+  shared edges itself so the mesh reaches Manifold already manifold.
+
+  **BOSL2's VNF winding is the opposite of Manifold's**, so `buildAligned` emits every triangle with
+  its last two indices swapped. Without it the solid is inside-out, which `Manifold::Volume()`
+  reports as a NEGATIVE volume — and which comparing `|volume|` (as an STL-based check naturally
+  does) hides completely. Two of the tests assert a positive volume specifically to catch this.
+
+  Note when checking any of this against BOSL2: **BOSL2 shadows `sphere()`** with its own module, so
+  a file that includes BOSL2 to "compare against the reference" is comparing BOSL2 with itself. Call
+  `spheroid()` from a BOSL2-including file and `sphere()` from one without.
+
 - `src/builtins/dxf_dim.cpp` — `dxf_dim()`/`dxf_cross()`, which read a measurement out of a DXF file
   rather than out of the model. Ported from the reference's `io/dxfdim.cc` plus the DIMENSION/LINE
   half of `io/DxfData.cc`: `dxf_dim()` returns the first matching DIMENSION's value by its type
@@ -591,7 +614,7 @@ grep for `ponytail:`.
   All 25 module/shape combinations were diffed against OpenSCAD 2026.02.01 warning for warning, with
   the surviving geometry compared by STL volume.
 
-- `src/builtins/topology.cpp` — `hull()`/`minkowski()`/`fill()`. All three splice their children transparently in
+- `src/builtins/topology.cpp` — `hull()`/`minkowski()`/`minkowski_difference()`/`fill()`. All four splice their children transparently in
   the CSG tree exactly like union/difference/intersection (resolve just evaluates them for the
   side effect); `hull()` picks an all-3D (`Manifold::Hull`) or all-2D (`CrossSection::Hull`) hull of
   the *foreground* (role-split) children, falling back to sections only when no child has a body;
@@ -604,6 +627,19 @@ grep for `ponytail:`.
   which matters because two outers can overlap once the holes between them are gone. Ported from
   the reference's `applyFill2D`, and checked shape-for-shape against OpenSCAD 2026.02.01 by
   extruding and comparing STL volumes.
+
+  `minkowski_difference()` is erosion, and a deliberate BelfrySCAD extension: OpenSCAD has no such
+  module and no way to spell the operation in the language, since `minkowski()` only ever sums.
+  Reads the same way — first child is the body, every child after it is a tool eroded away in turn
+  (`Manifold::MinkowskiDifference`). 3D only, matching `minkowski()`'s own 3D-wins dispatch, since
+  Manifold has no CrossSection erosion and 2D already has one in `offset(r=-N)`.
+
+  Worth knowing why this is a module rather than an extension of `offset()`: a *positive* 3D offset
+  is already expressible as `minkowski() { X; sphere(r); }`, so `offset(r=N)` on a solid would have
+  been pure sugar. Erosion is the half that is genuinely unavailable, and naming it after the
+  operation beats borrowing a 2D name for it. Eroding a cube by a cube is exact (no curved tool to
+  tessellate), which is what the tests assert on; a sphere tool lands a little large, and that gap
+  is the sphere's tessellation rather than an error in the erosion.
 - `src/builtins/extrude.cpp` — `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`. All three
   union every 2D child into one `CrossSection` via `toCrossSection` first. `rotate_extrude`'s
   segment count can't be resolved until generate time (it depends on the merged children's bounds,

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.36.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.36.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.36.0}/src/builtins/builtins.hpp

@@ -165,6 +165,11 @@ std::vector<ColoredBody> generateHull(Evaluator& ev, const CSGParams& params,
 Value builtinDxfDim(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
 Value builtinDxfCross(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
 
+CSGParams resolveMinkowskiDifference(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
+std::vector<ColoredBody> generateMinkowskiDifference(Evaluator& ev, const CSGParams& params,
+                                                      const std::vector<std::unique_ptr<CSGNode>>& children,
+                                                      const oscad::ASTNode& node);
+
 CSGParams resolveFill(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateFill(Evaluator& ev, const CSGParams& params,
                                        const std::vector<std::unique_ptr<CSGNode>>& children,

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.36.0}/src/builtins/primitives_3d.cpp

@@ -5,10 +5,12 @@
 #include "openscad_cpp_evaluator/segments.hpp"
 
 #include <algorithm>
+#include <array>
 #include <cmath>
 #include <cstdint>
 #include <map>
 #include <numbers>
+#include <set>
 
 namespace oscadeval {
 
@@ -100,22 +102,48 @@ std::vector<ColoredBody> generateCube(Evaluator& ev, const CSGParams& params, co
 // _resolve_sphere/_generate_sphere exactly, including the "stacks =
 // max(2, ceil(n/2))" ring count and the fan-cap winding.
 
-CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
-    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    Value dArg = getArg(args, std::nullopt, "d", Value{});
-    double r;
-    if (!isUndef(dArg)) {
-        r = toDoubleLenient(dArg) / 2.0;
-    } else {
-        Value rArg = getArg(args, 0, "r", Value{});
-        r = isUndef(rArg) ? 1.0 : toDoubleLenient(rArg);
-    }
+// sphere(r|d, style) -- `style` is a BelfrySCAD extension naming the
+// tessellation, with the same five names and the same constructions as
+// BOSL2's spheroid():
+//
+//   "orig"    stacked rings offset half a step from the poles, no pole
+//             vertex. What OpenSCAD's own sphere() builds, hence the name,
+//             and still the default here.
+//   "aligned" a vertex at each pole and rings on the latitudes between, so
+//             an $fn divisible by 4 puts vertices exactly on +-X and +-Y.
+//   "stagger" "aligned" with alternate rings rotated half a face, giving
+//             triangles that alternate direction rather than stacking.
+//   "octa"    a subdivided octahedron projected onto the sphere.
+//   "icosa"   a subdivided icosahedron projected onto the sphere -- the most
+//             uniform of the five.
+//
+// Only "orig" matches real OpenSCAD; the rest are additions, so a script
+// using them will not render the same shape elsewhere.
 
-    const int n = fnSegmentsFromCtx(effCtx, r); // longitude segments
-    const int stacks = std::max(2, static_cast<int>(std::ceil(n / 2.0)));
-    const double step = std::numbers::pi / stacks;
+namespace {
 
-    std::vector<double> verts; // flat x,y,z,...
+// BOSL2's spherical_to_xyz(r, theta, phi): theta around Z from +X, phi down
+// from +Z.
+std::array<double, 3> sphericalToXyz(double r, double thetaDeg, double phiDeg) {
+    const double th = thetaDeg * std::numbers::pi / 180.0;
+    const double ph = phiDeg * std::numbers::pi / 180.0;
+    return {r * std::sin(ph) * std::cos(th), r * std::sin(ph) * std::sin(th), r * std::cos(ph)};
+}
+
+struct SphereMesh {
+    std::vector<double> verts;   // flat x,y,z
+    std::vector<int> tris;
+};
+
+void pushVert(SphereMesh& m, const std::array<double, 3>& p) {
+    m.verts.insert(m.verts.end(), {p[0], p[1], p[2]});
+}
+
+// "orig": rings at (i+0.5) steps, no pole vertices, capped by a fan at each
+// end. Unchanged from the original implementation.
+SphereMesh buildOrig(double r, int n, int stacks) {
+    SphereMesh m;
+    const double step = std::numbers::pi / stacks;
     std::vector<std::vector<int>> rings(static_cast<size_t>(stacks));
     for (int s = 0; s < stacks; ++s) {
         const double lat = -std::numbers::pi / 2.0 + (s + 0.5) * step;
@@ -123,44 +151,214 @@ CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         const double z = r * std::sin(lat);
         for (int seg = 0; seg < n; ++seg) {
             const double angle = 2.0 * std::numbers::pi * seg / n;
-            rings[static_cast<size_t>(s)].push_back(static_cast<int>(verts.size() / 3));
-            verts.push_back(ringR * std::cos(angle));
-            verts.push_back(ringR * std::sin(angle));
-            verts.push_back(z);
+            rings[static_cast<size_t>(s)].push_back(static_cast<int>(m.verts.size() / 3));
+            pushVert(m, {ringR * std::cos(angle), ringR * std::sin(angle), z});
         }
     }
-
-    std::vector<int> tris;
     const auto& bot = rings.front();
-    for (int i = 1; i < n - 1; ++i) {
-        tris.insert(tris.end(), {bot[0], bot[static_cast<size_t>(i) + 1], bot[static_cast<size_t>(i)]});
-    }
+    for (int i = 1; i < n - 1; ++i) m.tris.insert(m.tris.end(), {bot[0], bot[size_t(i) + 1], bot[size_t(i)]});
     for (int s = 0; s < stacks - 1; ++s) {
-        const auto& lo = rings[static_cast<size_t>(s)];
-        const auto& hi = rings[static_cast<size_t>(s) + 1];
+        const auto& lo = rings[size_t(s)];
+        const auto& hi = rings[size_t(s) + 1];
         for (int seg = 0; seg < n; ++seg) {
-            const int a = lo[static_cast<size_t>(seg)], b = lo[static_cast<size_t>((seg + 1) % n)];
-            const int c = hi[static_cast<size_t>(seg)], d = hi[static_cast<size_t>((seg + 1) % n)];
-            tris.insert(tris.end(), {a, b, d});
-            tris.insert(tris.end(), {a, d, c});
+            const int a = lo[size_t(seg)], b = lo[size_t((seg + 1) % n)];
+            const int c = hi[size_t(seg)], d = hi[size_t((seg + 1) % n)];
+            m.tris.insert(m.tris.end(), {a, b, d});
+            m.tris.insert(m.tris.end(), {a, d, c});
         }
     }
     const auto& top = rings.back();
-    for (int i = 1; i < n - 1; ++i) {
-        tris.insert(tris.end(), {top[0], top[static_cast<size_t>(i)], top[static_cast<size_t>(i) + 1]});
+    for (int i = 1; i < n - 1; ++i) m.tris.insert(m.tris.end(), {top[0], top[size_t(i)], top[size_t(i) + 1]});
+    return m;
+}
+
+// "aligned"/"stagger": pole, vsides-1 rings, pole. Vertex order and face
+// indices follow BOSL2's spheroid() exactly so the two agree triangle for
+// triangle, not merely in shape.
+SphereMesh buildAligned(double r, int hsides, int vsides, bool stagger) {
+    SphereMesh m;
+    pushVert(m, sphericalToXyz(r, 0, 0));                      // north pole, index 0
+    for (int i = 1; i <= vsides - 1; ++i) {
+        const double phi = i * 180.0 / vsides;
+        for (int j = 0; j < hsides; ++j) {
+            const double theta = (j + ((stagger && i % 2 != 0) ? 0.5 : 0.0)) * 360.0 / hsides;
+            pushVert(m, sphericalToXyz(r, theta, phi));
+        }
+    }
+    pushVert(m, sphericalToXyz(r, 0, 180));                    // south pole, last index
+    const int lv = static_cast<int>(m.verts.size() / 3);
+
+    // BOSL2's VNF winding is the opposite of what Manifold wants, so every
+    // triangle below is emitted with its last two indices swapped. Without
+    // that the solid comes out inside-out -- and invisibly so if you only
+    // ever check |volume|, which is how this first went unnoticed.
+    const auto tri = [&m](int a, int b, int c) { m.tris.insert(m.tris.end(), {a, c, b}); };
+
+    for (int i = 0; i < hsides; ++i) {
+        const int b2 = lv - 2 - hsides;
+        tri(i + 1, 0, ((i + 1) % hsides) + 1);
+        tri(lv - 1, b2 + i + 1, b2 + ((i + 1) % hsides) + 1);
     }
+    for (int i = 0; i <= vsides - 3; ++i) {
+        const int base = 1 + hsides * i;
+        for (int j = 0; j < hsides; ++j) {
+            if (stagger && i % 2 != 0) {
+                tri(base + j, base + hsides + j % hsides, base + hsides + (j + hsides - 1) % hsides);
+                tri(base + j, base + (j + 1) % hsides, base + hsides + j);
+            } else {
+                tri(base + j, base + (j + 1) % hsides, base + hsides + (j + 1) % hsides);
+                tri(base + j, base + hsides + (j + 1) % hsides, base + hsides + j);
+            }
+        }
+    }
+    return m;
+}
 
-    std::vector<Value> vertsValues;
-    vertsValues.reserve(verts.size());
-    for (double v : verts) vertsValues.push_back(Value{v});
-    std::vector<Value> trisValues;
-    trisValues.reserve(tris.size());
-    for (int t : tris) trisValues.push_back(Value{static_cast<double>(t)});
+// "icosa": subdivide every icosahedral face into a triangular grid and push
+// each sample out to the sphere. BOSL2 subsamples one face and rotates
+// copies onto the rest; sampling each face against its own corners is the
+// same points (the sampling is affine in those corners) with far less
+// machinery. Coincident vertices along shared edges are welded here rather
+// than left for Manifold, so the mesh arrives already manifold.
+SphereMesh buildIcosa(double r, int hsides) {
+    const double phi = (1.0 + std::sqrt(5.0)) / 2.0;
+    std::vector<std::array<double, 3>> ico;
+    for (int i : {-1, 1}) {
+        for (int j : {-1, 1}) {
+            ico.push_back({0.0, double(i), double(j) * phi});
+            ico.push_back({double(i), double(j) * phi, 0.0});
+            ico.push_back({double(j) * phi, 0.0, double(i)});
+        }
+    }
+    // Hull faces by brute force: a triple is a face when every other vertex
+    // lies on one side of its plane. 12 vertices, so 220 triples.
+    std::vector<std::array<int, 3>> faces;
+    const int nv = static_cast<int>(ico.size());
+    for (int a = 0; a < nv; ++a)
+        for (int b = a + 1; b < nv; ++b)
+            for (int c = b + 1; c < nv; ++c) {
+                const std::array<double, 3> u{ico[b][0] - ico[a][0], ico[b][1] - ico[a][1], ico[b][2] - ico[a][2]};
+                const std::array<double, 3> v{ico[c][0] - ico[a][0], ico[c][1] - ico[a][1], ico[c][2] - ico[a][2]};
+                const std::array<double, 3> nrm{u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2],
+                                                 u[0] * v[1] - u[1] * v[0]};
+                int pos = 0, neg = 0;
+                for (int k = 0; k < nv; ++k) {
+                    if (k == a || k == b || k == c) continue;
+                    const double d = nrm[0] * (ico[k][0] - ico[a][0]) + nrm[1] * (ico[k][1] - ico[a][1]) +
+                                     nrm[2] * (ico[k][2] - ico[a][2]);
+                    if (d > 1e-9) ++pos;
+                    if (d < -1e-9) ++neg;
+                }
+                if (pos && neg) continue;
+                // Orient outward: the normal must point away from the centre.
+                if (neg == 0) faces.push_back({a, c, b});
+                else faces.push_back({a, b, c});
+            }
+
+    const int steps = std::max(1, static_cast<int>(std::lround(std::max(5, hsides) / 5.0)));
+    const int N = steps - 1;   // BOSL2's N; the grid has N+2 rows
+
+    SphereMesh m;
+    std::map<std::array<long long, 3>, int> weld;
+    const auto add = [&](const std::array<double, 3>& p) {
+        const double len = std::sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2]);
+        const std::array<double, 3> u{r * p[0] / len, r * p[1] / len, r * p[2] / len};
+        const std::array<long long, 3> key{std::llround(u[0] * 1e9), std::llround(u[1] * 1e9),
+                                            std::llround(u[2] * 1e9)};
+        auto it = weld.find(key);
+        if (it != weld.end()) return it->second;
+        const int idx = static_cast<int>(m.verts.size() / 3);
+        pushVert(m, u);
+        weld.emplace(key, idx);
+        return idx;
+    };
+
+    for (const std::array<int, 3>& f : faces) {
+        const std::array<double, 3>& p0 = ico[f[0]];
+        const std::array<double, 3>& p1 = ico[f[1]];
+        const std::array<double, 3>& p2 = ico[f[2]];
+        // Row i has N+2-i samples, mirroring _subsample_triangle.
+        std::vector<std::vector<int>> grid;
+        for (int i = 0; i <= N + 1; ++i) {
+            std::vector<int> row;
+            for (int j = 0; j <= N + 1 - i; ++j) {
+                const double a = double(i) / (N + 1), b = double(j) / (N + 1);
+                row.push_back(add({p0[0] + (p1[0] - p0[0]) * a + (p2[0] - p0[0]) * b,
+                                    p0[1] + (p1[1] - p0[1]) * a + (p2[1] - p0[1]) * b,
+                                    p0[2] + (p1[2] - p0[2]) * a + (p2[2] - p0[2]) * b}));
+            }
+            grid.push_back(std::move(row));
+        }
+        for (int i = 0; i <= N; ++i) {
+            for (int j = 0; j <= N - i; ++j) {
+                m.tris.insert(m.tris.end(), {grid[i][j], grid[i + 1][j], grid[i][j + 1]});
+                if (j < N - i) {
+                    m.tris.insert(m.tris.end(), {grid[i + 1][j], grid[i + 1][j + 1], grid[i][j + 1]});
+                }
+            }
+        }
+    }
+    return m;
+}
+
+} // namespace
+
+CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    Value dArg = getArg(args, std::nullopt, "d", Value{});
+    double r;
+    if (!isUndef(dArg)) {
+        r = toDoubleLenient(dArg) / 2.0;
+    } else {
+        Value rArg = getArg(args, 0, "r", Value{});
+        r = isUndef(rArg) ? 1.0 : toDoubleLenient(rArg);
+    }
+
+    const Value styleArg = getArg(args, std::nullopt, "style", Value{});
+    std::string style = "orig";
+    if (const std::string* sv = std::get_if<std::string>(&styleArg)) {
+        static const std::set<std::string> known{"orig", "aligned", "stagger", "octa", "icosa"};
+        if (known.count(*sv)) {
+            style = *sv;
+        } else {
+            ev.warn("sphere: unknown style \"" + *sv + "\"; expected one of orig, aligned, stagger, octa, icosa",
+                    &node.position());
+        }
+    } else if (!isUndef(styleArg)) {
+        ev.warn("sphere: style must be a string", &node.position());
+    }
+
+    const int hsides = fnSegmentsFromCtx(effCtx, r);
+    const int vsides = std::max(2, static_cast<int>(std::ceil(hsides / 2.0)));
 
     CSGParams params;
+    params["style"] = Value{style};
+    params["r"] = Value{r};
+    params["segs"] = Value{static_cast<double>(hsides)};
+    params["color"] = colorToValue(effCtx.color);
+
+    if (style == "octa") {
+        // Manifold::Sphere IS a subdivided octahedron (Shape::Octahedron,
+        // then Subdivide), so this needs no mesh of our own -- generate
+        // calls it directly.
+        params["verts"] = Value{std::make_shared<const ValueList>(ValueList{})};
+        params["tris"] = Value{std::make_shared<const ValueList>(ValueList{})};
+        return params;
+    }
+
+    const SphereMesh m = style == "aligned"   ? buildAligned(r, hsides, vsides, false)
+                         : style == "stagger" ? buildAligned(r, hsides, vsides, true)
+                         : style == "icosa"   ? buildIcosa(r, hsides)
+                                              : buildOrig(r, hsides, vsides);
+
+    std::vector<Value> vertsValues;
+    vertsValues.reserve(m.verts.size());
+    for (double v : m.verts) vertsValues.push_back(Value{v});
+    std::vector<Value> trisValues;
+    trisValues.reserve(m.tris.size());
+    for (int t : m.tris) trisValues.push_back(Value{static_cast<double>(t)});
     params["verts"] = Value{std::make_shared<const ValueList>(ValueList{std::move(vertsValues)})};
     params["tris"] = Value{std::make_shared<const ValueList>(ValueList{std::move(trisValues)})};
-    params["color"] = colorToValue(effCtx.color);
     return params;
 }
 
@@ -174,6 +372,11 @@ std::vector<ColoredBody> generateSphere(Evaluator& ev, const CSGParams& params,
     for (const Value& t : std::get<ListPtr>(params.at("tris"))->items) {
         mesh.triVerts.push_back(static_cast<uint64_t>(std::get<double>(t)));
     }
+    if (std::get<std::string>(params.at("style")) == "octa") {
+        manifold::Manifold octa = manifold::Manifold::Sphere(
+            std::get<double>(params.at("r")), static_cast<int>(std::get<double>(params.at("segs"))));
+        return {ev.tagGenerated(std::move(octa), node, params.at("color"))};
+    }
     manifold::Manifold body(mesh);
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.36.0}/src/builtins/registry.cpp

@@ -35,6 +35,7 @@ const std::unordered_map<std::string_view, ResolveFn>& resolveDispatch() {
         {"projection", &resolveProjection},
         {"roof", &resolveRoof},
         {"fill", &resolveFill},
+        {"minkowski_difference", &resolveMinkowskiDifference},
         {"offset", &resolveOffset},
         {"surface", &resolveSurface},
         {"text", &resolveText},
@@ -74,6 +75,7 @@ const std::unordered_map<std::string_view, GenerateFn>& generateDispatch() {
         {"projection", &generateProjection},
         {"roof", &generateRoof},
         {"fill", &generateFill},
+        {"minkowski_difference", &generateMinkowskiDifference},
         {"offset", &generateOffset},
         {"surface", &generateSurface},
         {"text", &generateText},
@@ -90,7 +92,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
     static const std::unordered_map<std::string, std::vector<std::string>> table = {
         // -- builtin modules ---------------------------------------------
         {"cube", {"size", "center"}},
-        {"sphere", {"r", "d"}},
+        {"sphere", {"r", "d", "style"}},
         {"cylinder", {"h", "r1", "r2", "center", "r", "d", "d1", "d2"}},
         {"polyhedron", {"points", "faces", "convexity", "triangles"}},
         {"square", {"size", "center"}},
@@ -119,6 +121,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"projection", {"cut", "convexity"}},
         {"roof", {"method", "convexity"}},
         {"fill", {}},
+        {"minkowski_difference", {}},
         {"offset", {"r", "delta", "chamfer"}},
         {"surface", {"file", "center", "convexity", "invert"}},
         {"text", {"text", "size", "font", "direction", "language", "script", "halign", "valign", "spacing"}},

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.36.0}/src/builtins/topology.cpp

@@ -313,4 +313,66 @@ std::vector<ColoredBody> generateMinkowski(Evaluator& ev, const CSGParams&, cons
     return out;
 }
 
+// minkowski_difference() -- erosion, the operation `minkowski()` has no
+// inverse for. A BelfrySCAD extension: OpenSCAD has no equivalent module and
+// no way to express it in the language, since minkowski() only ever sums.
+// Shrinking a part by a clearance, or hollowing one to a wall thickness,
+// otherwise needs hand-built difference() scaffolding that is not the same
+// operation.
+//
+// Reads like minkowski(): the first child is the body being eroded, and
+// every child after it is a tool eroded away from it in turn. 3D only, same
+// as minkowski()'s own 3D path -- Manifold has no CrossSection erosion, and
+// 2D already has one in offset(r=-N).
+
+CSGParams resolveMinkowskiDifference(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    (void)args;
+    ev.evalChildren(node.children, effCtx);
+    return CSGParams{};
+}
+
+std::vector<ColoredBody> generateMinkowskiDifference(Evaluator& ev, const CSGParams&,
+                                                      const std::vector<std::unique_ptr<CSGNode>>& children,
+                                                      const oscad::ASTNode& node) {
+    const std::vector<ColoredBody> bodies = flattenCsgTree(children);
+    const RoleSplit split = splitByRole(bodies);
+
+    std::vector<const ColoredBody*> bodies3d;
+    for (const ColoredBody& c : split.foreground) {
+        if (c.body) bodies3d.push_back(&c);
+    }
+
+    std::vector<ColoredBody> passthrough;
+    passthrough.insert(passthrough.end(), split.background.begin(), split.background.end());
+    passthrough.insert(passthrough.end(), split.highlight.begin(), split.highlight.end());
+    passthrough.insert(passthrough.end(), split.showOnly.begin(), split.showOnly.end());
+    passthrough.insert(passthrough.end(), split.displayOnly.begin(), split.displayOnly.end());
+
+    if (bodies3d.empty()) return passthrough;
+    if (bodies3d.size() == 1) {
+        // Nothing to erode with, so nothing happens -- the same no-op
+        // minkowski() gives for a single child.
+        std::vector<ColoredBody> result = {*bodies3d.front()};
+        result.insert(result.end(), passthrough.begin(), passthrough.end());
+        return result;
+    }
+
+    manifold::Manifold result = *bodies3d.front()->body;
+    for (size_t i = 1; i < bodies3d.size(); ++i) result = result.MinkowskiDifference(*bodies3d[i]->body);
+    if (result.Status() != manifold::Manifold::Error::NoError) {
+        ev.warn("minkowski_difference: result is not manifold", &node.position());
+    }
+
+    ColoredBody cb;
+    cb.body = std::move(result);
+    cb.color = bodies3d.front()->color;
+    // Per-triangle colour cannot survive an erosion: the surface it was
+    // indexed against is gone.
+    cb.triColors.reset();
+    std::vector<ColoredBody> out = {std::move(cb)};
+    out.insert(out.end(), passthrough.begin(), passthrough.end());
+    return out;
+}
+
 } // namespace oscadeval

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.36.0}/tests/test_booleans.cpp

@@ -620,3 +620,82 @@ TEST(MixedDimensions, UniformChildrenAreUntouched) {
     ASSERT_EQ(e.bodies.size(), 1u);
     EXPECT_NEAR(e.bodies[0].body->Volume(), 2.0, 1e-9);
 }
+
+// -- minkowski_difference() -----------------------------------------------
+//
+// Erosion: the operation minkowski() has no inverse for. A BelfrySCAD
+// extension, because OpenSCAD has no equivalent module and no way to spell
+// it in the language -- minkowski() only ever sums.
+//
+// Eroding a cube by a cube is exact (no curved tool to tessellate), so those
+// expectations are equalities rather than tolerances.
+
+TEST(MinkowskiDifference, ErodesACubeExactly) {
+    // A 10-cube eroded by a 2-cube is an 8-cube: every face moves in by the
+    // tool's half-width.
+    Evaluated e = evalSrc("minkowski_difference() { cube(10, center=true); cube(2, center=true); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 512.0, 1e-6);
+    const manifold::Box bb = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bb.min.x, -4.0, 1e-9);
+    EXPECT_NEAR(bb.max.x, 4.0, 1e-9);
+}
+
+TEST(MinkowskiDifference, ErodesByASphereToWithinTessellation) {
+    // Same 8-cube, but the tool is a polyhedral sphere whose inradius is a
+    // touch under 1, so the result is a touch larger. That gap IS the
+    // tessellation and shrinks with $fn -- it is not an error in the erosion.
+    Evaluated e = evalSrc("minkowski_difference() { cube(10, center=true); sphere(1, $fn=64); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 512.0, 1.0);
+    EXPECT_GT(e.bodies[0].body->Volume(), 512.0);
+}
+
+TEST(MinkowskiDifference, ShrinksANonConvexBodyOnEverySide) {
+    // The case that motivates the module: a plate with holes, shrunk by a
+    // clearance. The bounding box must come in by the tool's radius all
+    // round -- 20x20x4 becomes 18x18x2.
+    Evaluated e = evalSrc(
+        "minkowski_difference() {"
+        "  difference() { cube([20,20,4], center=true);"
+        "                 for (x=[-6,0,6]) translate([x,0,0]) cylinder(h=6,r=2.5,center=true,$fn=24); }"
+        "  sphere(1, $fn=24); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    const manifold::Box bb = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bb.max.x, 9.0, 0.05);
+    EXPECT_NEAR(bb.max.y, 9.0, 0.05);
+    EXPECT_NEAR(bb.max.z, 1.0, 0.05);
+}
+
+TEST(MinkowskiDifference, SingleChildIsANoOp) {
+    // Nothing to erode with, so nothing happens -- the same shape
+    // minkowski() gives a lone child back.
+    Evaluated e = evalSrc("minkowski_difference() { cube(10, center=true); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-9);
+}
+
+TEST(MinkowskiDifference, NoChildrenIsEmpty) {
+    Evaluated e = evalSrc("minkowski_difference();");
+    EXPECT_TRUE(e.bodies.empty());
+}
+
+TEST(MinkowskiDifference, ErodesSuccessivelyByEveryToolAfterTheFirst) {
+    // Two 2-cube tools take 1 off each side twice: 10 -> 8 -> 6.
+    Evaluated e = evalSrc(
+        "minkowski_difference() { cube(10, center=true); cube(2, center=true); cube(2, center=true); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 216.0, 1e-6);
+}
+
+TEST(MinkowskiDifference, TwoDeeChildrenAreIgnoredLikeMinkowskis) {
+    // 3D only, matching minkowski()'s own 3D-wins dispatch. 2D erosion
+    // already exists as offset(r=-N).
+    Evaluated e = evalSrc("minkowski_difference() { square(10); square(2); }");
+    EXPECT_TRUE(e.bodies.empty());
+}