openscad-cpp-evaluator 1.29.0__tar.gz → 1.31.0__tar.gz

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.31.0}/CLAUDE.md

@@ -1569,6 +1569,51 @@ than the current pause point). Ported identically (same qualifier syntax, same e
 - `tools/cli/main.cpp` — a 3-line wrapper: builds `args` from `argv`, calls `runCli(args)` with the
   real `std::cin`/`std::cout`/`std::cerr`, returns its exit code.
 
+## Curve discretization: `$fn`/`$fe`/`$fa`/`$fs` (`Discretizer`, segments.hpp)
+
+A port of upstream's `CurveDiscretizer` (src/core/CurveDiscretizer.cc): circle/arc segment counts,
+`linear_extrude` slice counts (helix, conical helix, diagonal) and outline splitting. Every count was
+checked against the 2026.02.01 binary (`--enable=discretization-by-error`), including volumes, since
+the side-quad diagonal choice changes a twisted solid without changing its triangle count.
+
+- **`$fe`** (max radial error): `n = pi/acos(1 - fe/r)`, 5 once `fe/r >= 0.1909830056`, capped at the
+  `$fa`/`$fs`=0.01 count; replaces `$fa`/`$fs` entirely; arcs scale the UNceiled n. Upstream gates it
+  behind `--enable=discretization-by-error`; here it is always on (`supported_feature
+  ("discretization-by-error")`). Not predefined in the root ctx, as upstream: a bare read warns.
+- **Bugs this fixed**, all pre-existing and all silent:
+  - `linear_extrude(twist=)` without `slices` was ONE slice: 180 degrees collapsed to a straight prism.
+  - `slices=N` gave N+1 slices (Manifold's `nDivisions` is the copies between the ends).
+  - Twisted and non-uniformly-scaled extrusions never split their outline edges.
+  - Partial `rotate_extrude(angle=)` packed the full circle's count into the arc (Manifold's
+    `Revolve` takes the count for the arc it is given).
+  - Text curves used `$fn` at radius 0, halved, instead of `circular(size)/8 + 1`.
+  - A fractional `$fn` truncated instead of rounding up.
+- **Twisted/non-uniform extrusions are built by hand** (`extrudeTwisted`, extrude.cpp), not by
+  `Manifold::Extrude`: their side quads are not planar and upstream splits each along its SHORTER
+  diagonal (`sgn_vdiff`, ties broken by twist direction and hole-ness). `Manifold::Extrude` always picks
+  the same diagonal: same triangle count, different volume (241 vs 254 for a 180-degree twist).
+  Planar cases (no twist, uniform scale) and a top scaled to zero stay on `Manifold::Extrude`.
+- **1-2 section arcs** (short `rotate_extrude` angles at coarse settings): `Revolve` substitutes its own
+  default below 3, so these are an extrude warped round Z. The warp inverts the solid for a positive
+  angle, hence the mirror-in-Y dance.
+- Kept departure: `$fa`/`$fs` <= 0 fall back to 12/2 rather than upstream's clamp-to-0.01 with a warning.
+- Not ported: `linear_extrude(v=)` (accepted, ignored); DXF/SVG import arcs don't read the discretizer.
+
+## Cancel and the module recursion limit (#554)
+
+- **`Evaluator::setCancelFlag(shared_ptr<atomic<bool>>)`** -- bound as `CancelSignal` /
+  `Evaluator(cancel_signal=...)`. Once the flag is set, from any thread, evaluate() throws
+  `EvalError("Render cancelled")` at its next check: the top of `checkDebug` (every interpreted
+  statement and loop pass already calls it, hooks or not), `pollCancel()` every 1,024 VM
+  instructions in `driveVm`, and each top-level node in `generateTreeImpl`. A single Manifold op
+  already under way still finishes. Sticky, unlike `setFastContinueInterruptFlag`'s test-and-clear.
+  A host's echo callback was the only way in before, so a script that printed nothing could not
+  be stopped at all.
+- **`kMaxModuleCallDepth = 16384`** nested user module calls, checked in `enterUserCall` against
+  `moduleCallDepth_` -- "Recursion detected calling module 'm'", OpenSCAD's wording. Functions
+  keep `kMaxVmCallStackDepth` (1e6). `module m() { m(); }` went from 4.2 s / 3.3 GB to stopping
+  at once; OpenSCAD 2026.02.01 stops the same script near 14,000.
+
 ## Coverage
 
 `Evaluator(coverage=true)` records which parts of a run's source actually executed and

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.31.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.31.0}/bindings/module.cpp

@@ -503,10 +503,22 @@ nb::object coverageResultToPy(const std::optional<oscadeval::CoverageResult>& cr
     return result;
 }
 
+// A render's Cancel: .request() from any thread makes the evaluate() it was
+// passed to throw EvalError("Render cancelled") at its next check -- see
+// Evaluator::setCancelFlag. One per render; it is never cleared.
+class CancelSignal {
+public:
+    void request() { flag_->store(true, std::memory_order_relaxed); }
+    const std::shared_ptr<std::atomic<bool>>& flag() const { return flag_; }
+
+private:
+    std::shared_ptr<std::atomic<bool>> flag_ = std::make_shared<std::atomic<bool>>(false);
+};
+
 nb::object evaluate(const std::string& path, nb::dict viewportParams,
                      std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile,
                      bool generate, bool strictCommas, bool coverage, bool keepMinuendColor,
-                     double flatPreviewHeight) {
+                     double flatPreviewHeight, CancelSignal* cancelSignal) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -535,6 +547,7 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
             oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(program.nodes, path, logFn);
             oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile, coverage);
             ev.keepMinuendColor = keepMinuendColor;
+            if (cancelSignal) ev.setCancelFlag(cancelSignal->flag());
             ev.setUsedFileGlobals(used.usedFileGlobals);
             oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
             std::vector<oscadeval::ColoredBody> raw = ev.evaluate(used.processedNodes, ctx, vp, generate);
@@ -924,6 +937,10 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
 
     // See FastContinueSignal's own doc comment, above -- only a
     // constructor and request() are ever called from Python.
+    nb::class_<CancelSignal>(m, "CancelSignal")
+        .def(nb::init<>())
+        .def("request", &CancelSignal::request);
+
     nb::class_<FastContinueSignal>(m, "FastContinueSignal")
         .def(nb::init<>())
         .def("request", &FastContinueSignal::request);
@@ -993,7 +1010,7 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
           nb::arg("profile") = false, nb::arg("generate") = true, nb::arg("strict_commas") = false,
           nb::arg("coverage") = false, nb::arg("keep_minuend_color") = false,
-          nb::arg("flat_preview_height") = oscadeval::kTopLevel2dHeight,
+          nb::arg("flat_preview_height") = oscadeval::kTopLevel2dHeight, nb::arg("cancel_signal") = nullptr,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit, "
           "geometry, coverage_result).\n"
           "coverage=True records which statements, branch arms and bodies ran: coverage_result is a dict "
@@ -1006,7 +1023,9 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "are populated.\n\n"
           "strict_commas=True makes a trailing comma in a call argument list or a let/for "
           "assignment list a syntax error, as OpenSCAD 2021.01 did. List literals and parameter "
-          "declarations keep theirs, which 2021.01 accepted too.");
+          "declarations keep theirs, which 2021.01 accepted too.\n\n"
+          "cancel_signal: a CancelSignal whose request(), from any thread, stops this call with "
+          "EvalError('Render cancelled') -- even for a script that prints nothing.");
     m.def("parse_decls", &parseDecls, nb::arg("path"),
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
     m.def("strip_slivers", &stripSliversPy, nb::arg("verts"), nb::arg("tris"),

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.31.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -703,6 +703,23 @@ public:
         fastContinueInterrupt_ = std::move(flag);
     }
 
+    // A host's Cancel button. Set from any thread; the running evaluate()
+    // then throws EvalError("Render cancelled") at its next check: every
+    // interpreted statement and loop pass (checkDebug, which all of them
+    // already call), every 1024th VM instruction, and between top-level
+    // generate-pass nodes. A single Manifold operation already under way
+    // still runs to its end. Before this existed a host could only stop a
+    // script from its echo callback, so one that printed nothing ran to
+    // completion however long that took (#554). Sticky: never cleared here.
+    void setCancelFlag(std::shared_ptr<std::atomic<bool>> flag) { cancel_ = std::move(flag); }
+    void checkCancel() const {
+        if (cancel_ && cancel_->load(std::memory_order_relaxed)) throw EvalError("Render cancelled");
+    }
+    // The VM's per-instruction form: one relaxed load per 1024 instructions.
+    void pollCancel() {
+        if (cancel_ && (++cancelTicks_ & 0x3FF) == 0) checkCancel();
+    }
+
     // Checks whether a debug pause should happen at `node` (via the
     // injected DebugHooks::debugHook, if any -- a no-op otherwise),
     // applying any `mods` the hook returns to `ctx.let_` and throwing
@@ -1759,6 +1776,16 @@ public:
     // recalibrating for real.
     static constexpr size_t kMaxVmCallStackDepth = 1'000'000;
 
+    // Nested user MODULE calls, of any modules. Functions keep
+    // kMaxVmCallStackDepth: a deep function recursion builds nothing, but a
+    // module frame holds its whole subtree, so `module m() { m(); }` used
+    // to run to a million frames and 3.3 GB before stopping. OpenSCAD stops
+    // the same script at ~14,000 ("Recursion detected calling module"),
+    // 45 MB; this is that order, and far past any real library (BOSL2
+    // nests tens deep). Checked in enterUserCall, which every module call
+    // -- interpreted or compiled -- goes through (#554).
+    static constexpr int kMaxModuleCallDepth = 16384;
+
     // Counts native C++ nesting of driveVm itself -- NOT logical call
     // depth (that's vmCallStack_.size()/callStack_.size(), both of which
     // grow just as much for a pure VM-internal Op::CallModule hop, which
@@ -2074,6 +2101,9 @@ private:
     // default) means hook-skippable mode, if ever engaged, can't be
     // interrupted from outside a hook call.
     std::shared_ptr<std::atomic<bool>> fastContinueInterrupt_;
+    // See setCancelFlag. nullptr (the default): nothing can cancel.
+    std::shared_ptr<std::atomic<bool>> cancel_;
+    unsigned cancelTicks_ = 0;
     // The root EvalContext resolveTree() was called with -- lets
     // checkDebug()'s locals snapshot fall back to top-level script
     // variables when paused inside a nested user call, the same way the

openscad_cpp_evaluator-1.31.0/include/openscad_cpp_evaluator/segments.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "openscad_cpp_evaluator/eval_context.hpp"
+#include "openscad_cpp_evaluator/csg_node.hpp"
+
+#include <manifold/common.h>
+
+#include <optional>
+
+namespace oscadeval {
+
+// How curves become polygons: OpenSCAD's CurveDiscretizer (src/core/
+// CurveDiscretizer.cc, upstream master cc19000e0), ported. Every count here
+// matches the 2026.02.01 binary's.
+//
+// $fn > $fe > $fa/$fs. $fe is the most a curve's polygon may stray from the
+// true circle, measured along a radius to an edge's midpoint; when set (>=
+// 2^-20) it replaces $fa/$fs entirely. Upstream reads $fe only behind
+// --enable=discretization-by-error; this evaluator always honours it, and
+// advertises that as supported_feature("discretization-by-error").
+//
+// Departures from upstream, kept from before this port: $fa/$fs <= 0 fall
+// back to their defaults (12/2) rather than clamping to 0.01 with a warning.
+struct Discretizer {
+    double fn = 0.0;
+    double fe = 0.0;
+    double fa = 12.0;
+    double fs = 2.0;
+
+    static Discretizer fromCtx(const EvalContext& ctx);
+    // Stored in, and read back from, a node's params -- they are part of its
+    // cache key, and generate has only the params to go on.
+    static Discretizer fromParams(const CSGParams& params);
+    void store(CSGParams& params) const;
+
+    // Segments for `angle` degrees of arc at radius r. nullopt where
+    // upstream has none (r below 2^-20, a non-finite $fn/$fe/angle): every
+    // caller supplies its own fallback, as upstream's value_or() does.
+    std::optional<int> circular(double r, double angleDegrees = 360.0) const;
+
+    // linear_extrude slice counts: twist without scale, twist with uniform
+    // scale, and non-uniform scale (with or without twist).
+    std::optional<int> helixSlices(double rSqr, double height, double twistDegrees) const;
+    std::optional<int> conicalHelixSlices(double rSqr, double height, double twistDegrees, double scale) const;
+    std::optional<int> diagonalSlices(double deltaSqr, double height) const;
+
+    // Subdivide an outline's edges so a twisted or non-uniformly scaled
+    // extrusion keeps its shape between slices. `segments` is linear_extrude's
+    // own argument (0 = not given).
+    manifold::SimplePolygon splitOutline(const manifold::SimplePolygon& outline, double twistDegrees,
+                                         double scaleX, double scaleY, unsigned slices, unsigned segments) const;
+};
+
+// Full-circle segment count from ctx's $fn/$fe/$fa/$fs at radius r;
+// upstream's primitives fall back to 3.
+int fnSegmentsFromCtx(const EvalContext& ctx, double r = 0.0);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.31.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.31.0}/python/openscad_cpp_evaluator/__init__.py

@@ -13,12 +13,12 @@ from dataclasses import dataclass, field
 from typing import Optional
 
 from . import _openscad_cpp_evaluator as _ext
-from ._openscad_cpp_evaluator import FastContinueSignal, ManifoldCache
+from ._openscad_cpp_evaluator import CancelSignal, FastContinueSignal, ManifoldCache
 
 __all__ = [
     "Evaluator", "ColoredBody", "EvalError", "ParseError", "OscObject", "parse", "to_renderable_bodies",
     "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
-    "FastContinueSignal", "parse_ast", "parse_ast_string", "format_source",
+    "CancelSignal", "FastContinueSignal", "parse_ast", "parse_ast_string", "format_source",
     "check_mesh", "strip_slivers",
     "export_model", "export_extensions", "list_fonts",
 ]
@@ -565,7 +565,7 @@ class Evaluator:
 
     def __init__(self, echo_fn=None, debug_hook=None, error_break_fn=None, return_hook=None,
                  manifold_cache=None, profile=False, fast_continue_signal=None, coverage=False,
-                 keep_minuend_color=False, flat_preview_height=1.0):
+                 keep_minuend_color=False, flat_preview_height=1.0, cancel_signal=None):
         self._echo_fn = echo_fn
         self._debug_hook = debug_hook
         self._error_break_fn = error_break_fn
@@ -574,6 +574,11 @@ class Evaluator:
         self._profile = profile
         self._fast_continue_signal = fast_continue_signal
         self._coverage = coverage
+        # A CancelSignal: request() it from any thread and a running
+        # evaluate() raises EvalError("Render cancelled") -- the only way to
+        # stop a script that prints nothing. Plain path only; the debugger
+        # has its own stop.
+        self._cancel_signal = cancel_signal
         # keep_minuend_color=True: difference() paints the faces a
         # subtrahend exposes with the MINUEND's colour rather than the
         # subtrahend's (or the cut green). A viewer option; see
@@ -640,7 +645,7 @@ class Evaluator:
                  dyn_explicit, geometry, coverage_result) = _ext.evaluate(
                     source_path, vp, self._manifold_cache, self._profile, generate,
                     strict_commas, self._coverage, self._keep_minuend_color,
-                    self._flat_preview_height)
+                    self._flat_preview_height, self._cancel_signal)
                 # The evaluated bodies, still on the C++ side. Stashed like
                 # csg_tree/profile_result rather than returned, so
                 # evaluate()'s own 2-tuple result is unchanged -- callers

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.31.0}/src/builtins/extrude.cpp

@@ -5,7 +5,9 @@
 #include "openscad_cpp_evaluator/segments.hpp"
 
 #include <algorithm>
+#include <manifold/polygon.h>
 #include <cmath>
+#include <numbers>
 
 namespace oscadeval {
 
@@ -26,13 +28,110 @@ namespace oscadeval {
 // still not covered by PushBuiltinWrap) is behaviorally unobservable --
 // see computeRoofParams's own doc comment (roof.cpp) for the one builtin
 // in this group where that ISN'T true and a different split was needed.
+namespace {
+
+// Upstream's sgn_vdiff: which of two diagonals is shorter, treating lengths
+// within 1 part in 1e5 as a tie.
+int sgnVdiff(const manifold::vec2& v1, const manifold::vec2& v2) {
+    const double l1 = manifold::la::length(v1), l2 = manifold::la::length(v2);
+    return 2 * std::fabs(l1 - l2) * 1e5 > l1 + l2 ? (l1 < l2 ? -1 : 1) : 0;
+}
+
+// A twisted or non-uniformly scaled extrusion, built the way upstream's
+// linear_extrude.cc builds it. Its side quads are not planar, so which
+// diagonal splits each one changes the solid, and Manifold's own Extrude
+// always picks the same one: the result had OpenSCAD's triangle count and a
+// different volume (241 vs 254 for a 180-degree twist of square(5)).
+// Upstream splits along the SHORTER diagonal, breaking exact ties by twist
+// direction and whether the outline is a hole.
+manifold::Manifold extrudeTwisted(const manifold::Polygons& polys, double height, int slices, double twist,
+                                  double scaleX, double scaleY) {
+    size_t stride = 0;
+    for (const manifold::SimplePolygon& o : polys) stride += o.size();
+    const auto ringPoint = [&](const manifold::vec2& v, int j) {
+        const double t = static_cast<double>(j) / slices;
+        const double a = -twist * t * std::numbers::pi / 180.0;
+        return manifold::vec2((v.x * std::cos(a) - v.y * std::sin(a)) * (1 - (1 - scaleX) * t),
+                              (v.x * std::sin(a) + v.y * std::cos(a)) * (1 - (1 - scaleY) * t));
+    };
+
+    manifold::MeshGL64 mesh;
+    mesh.numProp = 3;
+    for (int j = 0; j <= slices; ++j) {
+        for (const manifold::SimplePolygon& o : polys) {
+            for (const manifold::vec2& v : o) {
+                const manifold::vec2 p = ringPoint(v, j);
+                mesh.vertProperties.insert(mesh.vertProperties.end(),
+                                           {p.x, p.y, height * j / slices});
+            }
+        }
+    }
+    const auto tri = [&](size_t a, size_t b, size_t c) { mesh.triVerts.insert(mesh.triVerts.end(), {a, b, c}); };
+
+    const bool backTwist = twist <= 0; // rotation_slice_top <= rotation_slice_bottom, every slice
+    for (int j = 1; j <= slices; ++j) {
+        const size_t bot = (j - 1) * stride, top = j * stride;
+        size_t cur = 0;
+        for (const manifold::SimplePolygon& o : polys) {
+            const size_t n = o.size();
+            double area2 = 0;
+            for (size_t i = 0; i < n; ++i) area2 += o[i].x * o[(i + 1) % n].y - o[(i + 1) % n].x * o[i].y;
+            const bool flip = (area2 < 0) != backTwist; // !positive xor back_twist
+            manifold::vec2 prevBot = ringPoint(o[0], j - 1), prevTop = ringPoint(o[0], j);
+            for (size_t i = 1; i <= n; ++i) {
+                const manifold::vec2 vBot = ringPoint(o[i % n], j - 1), vTop = ringPoint(o[i % n], j);
+                const size_t idx = cur + i % n, prev = cur + i - 1;
+                const int diff = sgnVdiff(prevBot - vTop, vBot - prevTop);
+                if (diff == -1 || (diff == 0 && !flip)) {
+                    tri(bot + idx, top + idx, bot + prev);
+                    tri(top + prev, bot + prev, top + idx);
+                } else {
+                    tri(bot + idx, top + prev, bot + prev);
+                    tri(bot + idx, top + idx, top + prev);
+                }
+                prevBot = vBot;
+                prevTop = vTop;
+            }
+            cur += n;
+        }
+    }
+
+    // Caps: one triangulation of the outline, reused at both ends.
+    manifold::PolygonsIdx indexed;
+    size_t cur = 0;
+    for (const manifold::SimplePolygon& o : polys) {
+        manifold::SimplePolygonIdx ring;
+        for (size_t i = 0; i < o.size(); ++i) ring.push_back({o[i], static_cast<int>(cur + i)});
+        indexed.push_back(std::move(ring));
+        cur += o.size();
+    }
+    const size_t topBase = static_cast<size_t>(slices) * stride;
+    for (const manifold::ivec3& t : manifold::TriangulateIdx(indexed)) {
+        tri(t.x, t.z, t.y);                                    // bottom faces down
+        tri(topBase + t.x, topBase + t.y, topBase + t.z);      // top faces up
+    }
+    return manifold::Manifold(mesh);
+}
+
+} // namespace
+
 BuiltinWrapParams computeLinearExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
 
     const double height = toDoubleLenient(getArg(args, 0, "height", Value{1.0}));
     const bool center = truthy(getArg(args, std::nullopt, "center", Value{false}));
     const double twist = toDoubleLenient(getArg(args, std::nullopt, "twist", Value{0.0}));
-    const int slices = static_cast<int>(toDoubleLenient(getArg(args, std::nullopt, "slices", Value{0.0})));
+    // Upstream's validate_integral: any finite number counts as given, and is
+    // truncated and clamped (slices >= 1, segments >= 0). Not given, the
+    // discretizer decides.
+    const auto integral = [&](const char* name, double lo) -> std::optional<double> {
+        const Value v = getArg(args, std::nullopt, name, Value{});
+        const double* d = std::get_if<double>(&v);
+        if (!d || !std::isfinite(*d)) return std::nullopt;
+        return *d < lo ? lo : std::trunc(*d);
+    };
+    const std::optional<double> slices = integral("slices", 1.0);
+    const std::optional<double> segments = integral("segments", 0.0);
     const Value scaleArg = getArg(args, std::nullopt, "scale", Value{});
 
     double scaleX = 1.0, scaleY = 1.0;
@@ -47,7 +146,9 @@ BuiltinWrapParams computeLinearExtrudeParams(Evaluator& ev, const oscad::Modular
     params["height"] = Value{height};
     params["center"] = Value{center};
     params["twist"] = Value{twist};
-    params["slices"] = Value{static_cast<double>(slices)};
+    params["slices"] = slices ? Value{*slices} : Value{};
+    params["segments"] = segments ? Value{*segments} : Value{};
+    Discretizer::fromCtx(effCtx).store(params);
     params["scale_x"] = Value{scaleX};
     params["scale_y"] = Value{scaleY};
     params["color"] = colorToValue(effCtx.color);
@@ -69,11 +170,60 @@ std::vector<ColoredBody> generateLinearExtrude(Evaluator& ev, const CSGParams& p
     if (!cs || cs->IsEmpty()) return {};
 
     const double height = std::get<double>(params.at("height"));
-    const int slices = static_cast<int>(std::get<double>(params.at("slices")));
     const double twist = std::get<double>(params.at("twist"));
-    const manifold::vec2 scaleTop(std::get<double>(params.at("scale_x")), std::get<double>(params.at("scale_y")));
+    const double scaleX = std::get<double>(params.at("scale_x"));
+    const double scaleY = std::get<double>(params.at("scale_y"));
+    const double* givenSlices = std::get_if<double>(&params.at("slices"));
+    const double* givenSegments = std::get_if<double>(&params.at("segments"));
+    const Discretizer disc = Discretizer::fromParams(params);
+    manifold::Polygons polys = cs->ToPolygons();
+
+    // Upstream's calc_num_slices (linear_extrude.cc).
+    const auto maxDeltaSqr = [&] {
+        double m = 0;
+        for (const manifold::SimplePolygon& o : polys)
+            for (const manifold::vec2& v : o) m = std::max(m, manifold::la::length2(v - manifold::vec2(v.x * scaleX, v.y * scaleY)));
+        return m;
+    };
+    const int twistFallback = std::max(static_cast<int>(std::ceil(twist / 120.0)), 1);
+    int slices = 1;
+    if (givenSlices) {
+        slices = static_cast<int>(*givenSlices);
+    } else if (twist != 0.0) {
+        double maxR1Sqr = 0;
+        for (const manifold::SimplePolygon& o : polys)
+            for (const manifold::vec2& v : o) maxR1Sqr = std::max(maxR1Sqr, manifold::la::length2(v));
+        if (scaleX == 1.0 && scaleY == 1.0) {
+            slices = disc.helixSlices(maxR1Sqr, height, twist).value_or(twistFallback);
+        } else if (scaleX != scaleY) {
+            slices = std::max(disc.diagonalSlices(maxDeltaSqr(), height).value_or(1),
+                              disc.helixSlices(maxR1Sqr, height, twist).value_or(twistFallback));
+        } else {
+            slices = disc.conicalHelixSlices(maxR1Sqr, height, twist, scaleX).value_or(twistFallback);
+        }
+    } else if (scaleX != scaleY) {
+        slices = disc.diagonalSlices(maxDeltaSqr(), height).value_or(1);
+    }
+
+    // Split outline edges where a straight one would lose the shape between
+    // slices: twist or non-uniform scale, or `segments` asked for. segments=0
+    // turns it off.
+    const unsigned segments = givenSegments ? static_cast<unsigned>(*givenSegments) : 0;
+    const bool nonLinear = twist != 0.0 || scaleX != scaleY;
+    if (!(givenSegments && segments == 0) && (segments > 0 || nonLinear)) {
+        for (manifold::SimplePolygon& o : polys)
+            o = disc.splitOutline(o, twist, scaleX, scaleY, static_cast<unsigned>(slices), segments);
+    }
 
-    manifold::Manifold body = manifold::Manifold::Extrude(cs->ToPolygons(), height, slices, -twist, scaleTop);
+    // Planar side quads (no twist, uniform scale) come out the same however
+    // they are split, so Manifold's own Extrude does. So does a top scaled to
+    // zero in either axis, where upstream's shorter-diagonal rule is
+    // reversed to avoid zero-thickness ears; a cone tip is Extrude's to make.
+    // Manifold's nDivisions is the copies BETWEEN the ends: slices - 1.
+    manifold::Manifold body =
+        nonLinear && scaleX > 0 && scaleY > 0 && height > 0
+            ? extrudeTwisted(polys, height, slices, twist, scaleX, scaleY)
+            : manifold::Manifold::Extrude(polys, height, slices - 1, -twist, manifold::vec2(scaleX, scaleY));
     if (std::get<bool>(params.at("center"))) body = body.Translate(manifold::vec3(0, 0, -height / 2));
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }
@@ -91,18 +241,9 @@ BuiltinWrapParams computeRotateExtrudeParams(Evaluator& ev, const oscad::Modular
 
     const double angle = toDoubleLenient(getArg(args, 0, "angle", Value{360.0}));
 
-    const auto dynOr = [&](const char* name, double fallback) {
-        const Value* v = effCtx.dyn->find(name);
-        if (!v) return fallback;
-        const double* d = std::get_if<double>(v);
-        return d ? *d : fallback;
-    };
-
     CSGParams params;
     params["angle"] = Value{angle};
-    params["fn"] = Value{dynOr("$fn", 0.0)};
-    params["fa"] = Value{dynOr("$fa", 12.0)};
-    params["fs"] = Value{dynOr("$fs", 2.0)};
+    Discretizer::fromCtx(effCtx).store(params);
     params["color"] = colorToValue(effCtx.color);
     return BuiltinWrapParams{std::move(params), std::move(effCtx)};
 }
@@ -121,12 +262,41 @@ std::vector<ColoredBody> generateRotateExtrude(Evaluator& ev, const CSGParams& p
     const std::optional<manifold::CrossSection> cs = toCrossSection(flattenCsgTree(children));
     if (!cs || cs->IsEmpty()) return {};
 
+    // Upstream (rotate_extrude.cc) sizes the arc by the profile's extent in X,
+    // measured from the axis: both ends start at 0.
     const manifold::Rect bounds = cs->Bounds();
-    const double maxX = std::max(std::fabs(bounds.min.x), std::fabs(bounds.max.x));
-    const int segs = fnSegments(std::get<double>(params.at("fn")), std::get<double>(params.at("fa")),
-                                 std::get<double>(params.at("fs")), maxX);
-
-    manifold::Manifold body = manifold::Manifold::Revolve(cs->ToPolygons(), segs, std::get<double>(params.at("angle")));
+    const double width = std::max(bounds.max.x, 0.0) - std::min(bounds.min.x, 0.0);
+    const double angle = std::get<double>(params.at("angle"));
+    const int sections = Discretizer::fromParams(params).circular(width, angle).value_or(
+        std::max(1, static_cast<int>(std::fabs(angle) / 360 * 3)));
+    // Revolve takes this as the section count for the arc it is given -- not
+    // per full circle, which is what it used to be handed, packing a whole
+    // circle's worth into a partial one.
+    manifold::Manifold body;
+    if (sections >= 3 || bounds.min.x < 0) {
+        // (A profile left of the axis keeps Revolve's handling; a 1-2 section
+        // arc of one is the only case still drawn with 3.)
+        body = manifold::Manifold::Revolve(cs->ToPolygons(), std::max(sections, 3), angle);
+    } else {
+        // Revolve substitutes its own default below 3 sections, but a short
+        // arc at coarse settings is 1 or 2 (upstream draws exactly that). So
+        // extrude the profile into that many sections and wrap them round the
+        // Z axis. The wrap turns the solid inside out for a positive angle, so
+        // then the profile goes in mirrored in Y and comes back out unmirrored.
+        const double sign = angle > 0 ? -1.0 : 1.0;
+        manifold::Polygons profile = cs->ToPolygons();
+        if (sign < 0) {
+            for (manifold::SimplePolygon& o : profile) {
+                for (manifold::vec2& v : o) v.y = -v.y;
+                std::reverse(o.begin(), o.end());
+            }
+        }
+        const double rad = angle * std::numbers::pi / 180.0;
+        body = manifold::Manifold::Extrude(profile, 1.0, sections - 1).Warp([rad, sign](manifold::vec3& v) {
+            const double a = v.z * rad;
+            v = manifold::vec3(v.x * std::cos(a), v.x * std::sin(a), sign * v.y);
+        });
+    }
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }
 

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.31.0}/src/builtins/function_builtins.cpp

@@ -1017,6 +1017,7 @@ const std::unordered_map<std::string, double>& featureLevels() {
         {"object-function", 1.0},    // object(), unconditional here
         {"roof-op", 1.0},            // roof(), method="voronoi" only
         {"svg-class", 1.0},          // import(svg, class=); id= is upstream's
+        {"discretization-by-error", 1.0}, // $fe, always on (upstream: behind --enable)
     };
     return levels;
 }