openscad-cpp-evaluator 0.13.10__tar.gz → 0.15.0__tar.gz

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/bindings/module.cpp

@@ -129,7 +129,11 @@ const char* roleToString(oscadeval::BodyRole role) {
 // tri_verts (nTri, 3), run_original_id (nRun,), run_index (nRun+1,) -- the
 // same flat 3*triangle units manifold3d's own run_index uses).
 nb::dict bodyToDict(oscadeval::ColoredBody& cb) {
-    manifold::MeshGL mesh = cb.body->GetMeshGL();
+    // A display-only body's Manifold is empty by construction, so its
+    // GetMeshGL() would hand back nothing -- take the raw triangle soup
+    // that failed to build instead. Everything downstream reads plain
+    // arrays, so the two cases are indistinguishable from here on.
+    manifold::MeshGL mesh = cb.isDisplayOnly() ? *cb.rawMesh : cb.body->GetMeshGL();
     const size_t numProp = mesh.numProp;
     const size_t numVert = numProp ? mesh.vertProperties.size() / numProp : 0;
     const size_t numTri = mesh.triVerts.size() / 3;
@@ -184,7 +188,9 @@ void collectIdSpans(const oscadeval::Evaluator& ev, std::vector<IdSpan>& out) {
 nb::list bodiesToList(std::vector<oscadeval::ColoredBody>& bodies) {
     nb::list out;
     for (oscadeval::ColoredBody& cb : bodies) {
-        if (!cb.body || cb.body->IsEmpty()) continue;
+        // isDisplayOnly() bodies are ALWAYS IsEmpty() -- that's what made
+        // an open polyhedron() silently vanish here rather than render.
+        if (!cb.isDisplayOnly() && (!cb.body || cb.body->IsEmpty())) continue;
         out.append(bodyToDict(cb));
     }
     return out;
@@ -210,7 +216,7 @@ nb::object csgNodeToPy(const oscadeval::CSGNode& node) {
     for (const auto& [k, v] : node.params) params[nb::str(k.c_str())] = valueToPy(v);
     nb::list bodies;
     for (const oscadeval::ColoredBody& cb : node.bodies) {
-        if (!cb.body || cb.body->IsEmpty()) continue;
+        if (!cb.isDisplayOnly() && (!cb.body || cb.body->IsEmpty())) continue;
         // ColoredBody here is const in this walk (tree ownership stays with
         // the caller) -- GetMeshGL() itself is logically read-only, so a
         // const_cast here is safe/local, mirroring bodyToDict's mutating

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -26,6 +26,27 @@ struct ColoredBody {
     bool flatPreview = false;
     BodyRole role = BodyRole::Normal;
     std::optional<std::vector<std::array<float, 4>>> triColors; // per-triangle RGBA, multi-color CSG merges only
+
+    // Set ONLY when a mesh could not be built into a valid Manifold -- in
+    // practice a polyhedron() whose faces don't close the surface (it has
+    // boundary edges), which Manifold reports by returning an *empty* body
+    // with Status() == NotManifold rather than by failing. Note the status
+    // name is misleading: a closed mesh with reversed winding, non-manifold
+    // vertices or self-intersections builds fine; only an OPEN one lands
+    // here.
+    //
+    // Carrying the raw triangle soup alongside lets the renderer still draw
+    // what the script described, which is far more use for spotting the
+    // missing face than an empty viewport. `body` is deliberately left set
+    // (and empty), so every existing `cb.body->...` path keeps working.
+    //
+    // Such a body is display-only: it can never take part in a CSG
+    // operation, since there is no Manifold for Manifold to operate on.
+    // splitByRole() pulls it aside much as it does a `%` background body,
+    // and the CSG/hull/minkowski generators re-join it unchanged.
+    std::optional<manifold::MeshGL> rawMesh;
+
+    bool isDisplayOnly() const { return rawMesh.has_value(); }
 };
 
 // `EvalContext::color`/CSGParams round-trip: a resolve function reads

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -236,6 +236,18 @@ public:
     // comment for why that reference exists at all).
     ColoredBody tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue);
 
+    // tagGenerated()'s counterpart for a mesh Manifold refused to build --
+    // an open polyhedron(). Returns a display-only ColoredBody (see
+    // ColoredBody::rawMesh) carrying the triangle soup as-is, so it can
+    // still be drawn even though no CSG operation can ever touch it.
+    //
+    // A failed Manifold has no run IDs of its own, so one is reserved here
+    // and written onto the raw mesh -- otherwise the body would be
+    // invisible to selection and to the originalID -> AST node mapping
+    // that drives click-to-source, which is exactly when a user most wants
+    // to click the broken thing and be shown the line that made it.
+    ColoredBody tagDisplayOnly(manifold::MeshGL mesh, const oscad::ASTNode& node, const Value& colorValue);
+
     // Raises an OpenSCAD-level runtime error: throws EvalError with the
     // formatted "ERROR: {msg}{TRACE lines}" message (see eval_error.hpp),
     // walking the real user function/module call stack for the TRACE lines

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/src/builtins/booleans.cpp

@@ -27,8 +27,19 @@ RoleSplit splitByRole(const std::vector<ColoredBody>& bodies) {
     for (const ColoredBody& c : bodies) {
         if (c.role == BodyRole::Background) r.background.push_back(c);
     }
+    // Checked before the foreground sweep below and excluded from it: a
+    // display-only body has an empty Manifold, so letting it reach a
+    // boolean would silently zero the whole operation (the same failure
+    // mode invalid operands caused before they were filtered out).
     for (const ColoredBody& c : bodies) {
-        if (c.role != BodyRole::Background && c.role != BodyRole::ShowOnly) r.foreground.push_back(c);
+        if (c.isDisplayOnly() && c.role != BodyRole::Background && c.role != BodyRole::ShowOnly) {
+            r.displayOnly.push_back(c);
+        }
+    }
+    for (const ColoredBody& c : bodies) {
+        if (c.role != BodyRole::Background && c.role != BodyRole::ShowOnly && !c.isDisplayOnly()) {
+            r.foreground.push_back(c);
+        }
     }
     for (const ColoredBody& c : r.foreground) {
         if (c.role == BodyRole::Highlight) r.highlight.push_back(c);
@@ -160,7 +171,7 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
     const std::string& op = std::get<std::string>(params.at("op"));
     const auto& groupSizes = std::get<ListPtr>(params.at("group_sizes"))->items;
 
-    std::vector<ColoredBody> allBg, allHi, allSo;
+    std::vector<ColoredBody> allBg, allHi, allSo, allDo;
     std::optional<ColoredBody> csgResult;
     size_t idx = 0;
 
@@ -173,6 +184,7 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
         allBg.insert(allBg.end(), split.background.begin(), split.background.end());
         allHi.insert(allHi.end(), split.highlight.begin(), split.highlight.end());
         allSo.insert(allSo.end(), split.showOnly.begin(), split.showOnly.end());
+        allDo.insert(allDo.end(), split.displayOnly.begin(), split.displayOnly.end());
 
         std::vector<ColoredBody> bodies3d, sections2d;
         for (const ColoredBody& c : split.foreground) {
@@ -251,6 +263,7 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
     result.insert(result.end(), allBg.begin(), allBg.end());
     result.insert(result.end(), allHi.begin(), allHi.end());
     result.insert(result.end(), allSo.begin(), allSo.end());
+    result.insert(result.end(), allDo.begin(), allDo.end());
     return result;
 }
 

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/src/builtins/builtins.hpp

@@ -77,11 +77,23 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params,
 // splitting/2D-merge logic.
 struct RoleSplit {
     std::vector<ColoredBody> background;
-    std::vector<ColoredBody> foreground; // role != Background && role != ShowOnly
+    std::vector<ColoredBody> foreground; // role != Background && role != ShowOnly, and not display-only
     std::vector<ColoredBody> highlight;  // the subset of `foreground` that's role == Highlight
     std::vector<ColoredBody> showOnly;
+    // Bodies with no Manifold to operate on (an open polyhedron -- see
+    // ColoredBody::rawMesh). Split out for the same reason showOnly is:
+    // they must survive a CSG/hull/minkowski step untouched rather than be
+    // merged into it, since there is nothing to merge. Kept separate from
+    // `background` because they render as ordinary geometry, not as a
+    // translucent ghost.
+    std::vector<ColoredBody> displayOnly;
 };
 RoleSplit splitByRole(const std::vector<ColoredBody>& bodies);
+
+// manifold::ToString(Manifold::Error) only exists under MANIFOLD_DEBUG --
+// not enabled in this build -- so this mirrors it. Shared by import.cpp and
+// primitives_3d.cpp, both of which report why a mesh wouldn't build.
+std::string manifoldErrorName(manifold::Manifold::Error e);
 std::optional<manifold::CrossSection> toCrossSection(const std::vector<ColoredBody>& bodies);
 
 // Merges a statement's bodies into one (3D union, else 2D union, else an

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/src/builtins/extrude.cpp

@@ -181,8 +181,19 @@ std::vector<ColoredBody> generateProjection(Evaluator&, const CSGParams& params,
 BuiltinWrapParams computeOffsetParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
 
-    const Value rArg = getArg(args, std::nullopt, "r", Value{});
+    // `r` owns position 0 (offset(2) == offset(r=2)); delta/chamfer are
+    // named-only, matching the reference. `r` also wins outright when both
+    // are given -- the reference never even looks at delta in that case.
+    Value rArg = getArg(args, 0, "r", Value{});
     const Value deltaArg = getArg(args, std::nullopt, "delta", Value{});
+    // A bare offset() is offset(r=1), not a pass-through: the reference
+    // initialises delta to 1 with a round join and only ever overwrites it
+    // from an argument, so "neither given" lands on the same state "r=1"
+    // does. Verified against OpenSCAD 2022.08.22 -- offset() and offset(r=1)
+    // produce a byte-identical mesh for the same input.
+    if (std::holds_alternative<std::monostate>(rArg) && std::holds_alternative<std::monostate>(deltaArg)) {
+        rArg = Value{1.0};
+    }
     const bool chamfer = truthy(getArg(args, std::nullopt, "chamfer", Value{false}));
 
     CSGParams params;

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/src/builtins/function_builtins.cpp

@@ -279,7 +279,13 @@ Value builtinSearch(const CallArgs& args) {
 }
 
 Value builtinLookup(const CallArgs& args) {
-    const double key = toDoubleLenient(getArg(args, 0, "key", Value{}));
+    // Guarded here rather than via scalarNumericArity() -- the second
+    // argument is a table, so the all-arguments-are-numbers rule can't
+    // apply. Without this, toDoubleLenient() turns a non-numeric key into
+    // 0.0 and the lookup silently returns the table's first value.
+    const Value keyArg = getArg(args, 0, "key", Value{});
+    if (!std::holds_alternative<double>(keyArg)) return Value{};
+    const double key = std::get<double>(keyArg);
     const Value tableArg = getArg(args, 1, "table", Value{});
     const ListPtr* tablePtr = std::get_if<ListPtr>(&tableArg);
     if (!tablePtr || !*tablePtr) return Value{};
@@ -359,11 +365,35 @@ Value builtinFontmetrics(Evaluator& ev, const CallArgs& args) {
     });
 }
 
-const std::unordered_set<std::string>& numericOnlyNames() {
-    static const std::unordered_set<std::string> names = {
-        "abs", "sign", "ceil", "floor", "round", "sqrt", "ln", "log", "exp", "sin", "cos", "tan",
-        "asin", "acos", "atan", "atan2", "pow", "max", "min", "norm", "cross",
+// Take only scalar numbers, mapped to how many leading positional
+// arguments must each actually BE a number. Anything else there (undef, a
+// string, a list, a bool, an object) is a type error yielding undef, and
+// so is supplying fewer arguments than the arity -- matching the
+// reference, which rejects the call outright rather than coercing.
+//
+// This has to be checked up front rather than left to each case below:
+// toDoubleLenient() silently turns undef/string/list into 0.0, which
+// would make `cos(misspelled_var)` quietly 1 instead of undef, and a
+// typo'd variable then produces plausible-looking geometry instead of an
+// obvious failure. Arity is deliberately a floor, not an exact match --
+// the reference also rejects EXTRA arguments, but tightening that too
+// risks breaking working library code for no correctness gain here.
+const std::unordered_map<std::string, size_t>& scalarNumericArity() {
+    static const std::unordered_map<std::string, size_t> arity = {
+        {"abs", 1}, {"sign", 1}, {"ceil", 1}, {"floor", 1}, {"round", 1}, {"sqrt", 1},
+        {"ln", 1}, {"log", 1}, {"exp", 1}, {"sin", 1}, {"cos", 1}, {"tan", 1},
+        {"asin", 1}, {"acos", 1}, {"atan", 1}, {"atan2", 2}, {"pow", 2}, {"rands", 3},
     };
+    return arity;
+}
+
+// Numeric functions that legitimately take a LIST argument, so the
+// all-arguments-must-be-numbers rule above can't apply -- each validates
+// its own operands, and only needs the bool case caught here (Value's
+// bool and double are distinct alternatives, but the reference rejects
+// `max(true, 1)` as a type error rather than treating true as 1).
+const std::unordered_set<std::string>& numericOnlyNames() {
+    static const std::unordered_set<std::string> names = {"max", "min", "norm", "cross"};
     return names;
 }
 
@@ -479,7 +509,13 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
     // elsewhere before reaching here) -- mirrors the old chain's fallthrough.
     if (idIt == ids.end()) return Value{};
 
-    if (numericOnlyNames().count(name)) {
+    if (const auto arityIt = scalarNumericArity().find(name); arityIt != scalarNumericArity().end()) {
+        const std::vector<Value> positional = allPositional(args);
+        if (positional.size() < arityIt->second) return Value{};
+        for (size_t i = 0; i < arityIt->second; ++i) {
+            if (!std::holds_alternative<double>(positional[i])) return Value{};
+        }
+    } else if (numericOnlyNames().count(name)) {
         for (const Value& v : allPositional(args)) {
             if (isBoolOrListContainsBool(v)) return Value{};
         }

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/src/builtins/import.cpp

@@ -49,29 +49,6 @@ LoadedMesh loadMeshByExt(const std::string& path, const std::string& ext) {
 
 bool isMeshExt(const std::string& ext) { return ext == ".stl" || ext == ".obj" || ext == ".off" || ext == ".3mf"; }
 
-// manifold::ToString(Manifold::Error) only exists under MANIFOLD_DEBUG --
-// not enabled in this project's build -- so this mirrors it locally for the
-// not-manifold warning message.
-std::string manifoldErrorName(manifold::Manifold::Error e) {
-    switch (e) {
-        case manifold::Manifold::Error::NoError: return "NoError";
-        case manifold::Manifold::Error::NonFiniteVertex: return "NonFiniteVertex";
-        case manifold::Manifold::Error::NotManifold: return "NotManifold";
-        case manifold::Manifold::Error::VertexOutOfBounds: return "VertexOutOfBounds";
-        case manifold::Manifold::Error::PropertiesWrongLength: return "PropertiesWrongLength";
-        case manifold::Manifold::Error::MissingPositionProperties: return "MissingPositionProperties";
-        case manifold::Manifold::Error::MergeVectorsDifferentLengths: return "MergeVectorsDifferentLengths";
-        case manifold::Manifold::Error::MergeIndexOutOfBounds: return "MergeIndexOutOfBounds";
-        case manifold::Manifold::Error::TransformWrongLength: return "TransformWrongLength";
-        case manifold::Manifold::Error::RunIndexWrongLength: return "RunIndexWrongLength";
-        case manifold::Manifold::Error::FaceIDWrongLength: return "FaceIDWrongLength";
-        case manifold::Manifold::Error::InvalidConstruction: return "InvalidConstruction";
-        case manifold::Manifold::Error::ResultTooLarge: return "ResultTooLarge";
-        case manifold::Manifold::Error::InvalidTangents: return "InvalidTangents";
-        case manifold::Manifold::Error::Cancelled: return "Cancelled";
-    }
-    return "Unknown";
-}
 
 Value jsonToValue(const nlohmann::ordered_json& j) {
     if (j.is_boolean()) return Value{j.get<bool>()};
@@ -135,6 +112,30 @@ Value meshToVnf(const LoadedMesh& mesh) {
 
 } // namespace
 
+// manifold::ToString(Manifold::Error) only exists under MANIFOLD_DEBUG --
+// not enabled in this project's build -- so this mirrors it locally for the
+// not-manifold warning message.
+std::string manifoldErrorName(manifold::Manifold::Error e) {
+    switch (e) {
+        case manifold::Manifold::Error::NoError: return "NoError";
+        case manifold::Manifold::Error::NonFiniteVertex: return "NonFiniteVertex";
+        case manifold::Manifold::Error::NotManifold: return "NotManifold";
+        case manifold::Manifold::Error::VertexOutOfBounds: return "VertexOutOfBounds";
+        case manifold::Manifold::Error::PropertiesWrongLength: return "PropertiesWrongLength";
+        case manifold::Manifold::Error::MissingPositionProperties: return "MissingPositionProperties";
+        case manifold::Manifold::Error::MergeVectorsDifferentLengths: return "MergeVectorsDifferentLengths";
+        case manifold::Manifold::Error::MergeIndexOutOfBounds: return "MergeIndexOutOfBounds";
+        case manifold::Manifold::Error::TransformWrongLength: return "TransformWrongLength";
+        case manifold::Manifold::Error::RunIndexWrongLength: return "RunIndexWrongLength";
+        case manifold::Manifold::Error::FaceIDWrongLength: return "FaceIDWrongLength";
+        case manifold::Manifold::Error::InvalidConstruction: return "InvalidConstruction";
+        case manifold::Manifold::Error::ResultTooLarge: return "ResultTooLarge";
+        case manifold::Manifold::Error::InvalidTangents: return "InvalidTangents";
+        case manifold::Manifold::Error::Cancelled: return "Cancelled";
+    }
+    return "Unknown";
+}
+
 namespace {
 
 Value contoursToValue(const std::vector<Contour2d>& contours) {
@@ -269,7 +270,15 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
 
     manifold::Manifold body(mesh);
     if (body.Status() != manifold::Manifold::Error::NoError) {
-        ev.warn("import: mesh is not manifold (" + manifoldErrorName(body.Status()) + ")", &node.position());
+        // Same treatment as an open polyhedron() (see generatePolyhedron):
+        // keep the triangles so the file can still be LOOKED at. Previously
+        // this warned and then handed back an empty body, which was dropped
+        // downstream -- so a broken STL warned once and showed nothing,
+        // giving no way to see what was actually wrong with it.
+        ev.warn("import: mesh is not a closed solid (" + manifoldErrorName(body.Status()) +
+                    "); drawing it as a surface, but it cannot take part in any CSG operation",
+                &node.position());
+        return {ev.tagDisplayOnly(std::move(mesh), node, params.at("color"))};
     }
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/src/builtins/primitives_3d.cpp

@@ -14,6 +14,45 @@ namespace oscadeval {
 
 namespace {
 bool isUndef(const Value& v) { return std::holds_alternative<std::monostate>(v); }
+
+// Edges used by an odd number of triangles -- i.e. the mesh's open border.
+// A closed solid has none; every edge is shared by exactly two faces.
+//
+// Counted on the UNDIRECTED edge (sorted endpoints) rather than the
+// directed half-edge, so a hole reads as a hole regardless of winding:
+// counting directed edges would also flag a merely back-to-front face,
+// which builds into a perfectly valid solid and is not what this reports.
+// Whether a mesh Manifold rejected is nonetheless safe to hand to a
+// renderer. Only NotManifold qualifies: it means "the triangles are fine,
+// they just don't close a solid", which is exactly the open-surface case
+// worth drawing. Every other status (NonFiniteVertex above all, but also
+// VertexOutOfBounds and friends) means the vertex data itself is broken --
+// drawing NaN coordinates would poison the scene bounding box and send the
+// camera auto-fit to infinity, which is worse than showing nothing. The
+// explicit finite check is belt-and-braces, since nothing documents that a
+// NotManifold mesh can't ALSO contain a NaN.
+bool isDrawableFailure(const manifold::Manifold& body, const manifold::MeshGL& mesh) {
+    if (body.Status() != manifold::Manifold::Error::NotManifold) return false;
+    if (mesh.triVerts.empty()) return false;
+    return std::all_of(mesh.vertProperties.begin(), mesh.vertProperties.end(),
+                        [](float v) { return std::isfinite(v); });
+}
+
+size_t countBoundaryEdges(const manifold::MeshGL& mesh) {
+    std::map<std::pair<uint32_t, uint32_t>, int> uses;
+    for (size_t i = 0; i + 2 < mesh.triVerts.size(); i += 3) {
+        const uint32_t v[3] = {mesh.triVerts[i], mesh.triVerts[i + 1], mesh.triVerts[i + 2]};
+        for (int e = 0; e < 3; ++e) {
+            const uint32_t a = v[e], b = v[(e + 1) % 3];
+            ++uses[{std::min(a, b), std::max(a, b)}];
+        }
+    }
+    size_t open = 0;
+    for (const auto& [edge, count] : uses) {
+        if (count % 2 != 0) ++open;
+    }
+    return open;
+}
 } // namespace
 
 // cube(size = 1, center = false) -- mirrors _resolve_cube/_generate_cube.
@@ -144,34 +183,38 @@ std::vector<ColoredBody> generateSphere(Evaluator& ev, const CSGParams& params,
 CSGParams resolveCylinder(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     const double h = toDoubleLenient(getArg(args, 0, "h", Value{1.0}));
-    Value rV = getArg(args, 1, "r", Value{});
-    Value r1V = getArg(args, std::nullopt, "r1", Value{});
-    Value r2V = getArg(args, std::nullopt, "r2", Value{});
+    // Positional order is (h, r1, r2, center); r/d/d1/d2 are named-only.
+    // NOTE r1/r2 -- not r -- own positions 1 and 2, so `cylinder(10, 5, 2)`
+    // is a cone, and `cylinder(10, 5)` is a cone tapering to the r2 default
+    // of 1 rather than a straight r=5 cylinder. Both match the reference.
+    Value rV = getArg(args, std::nullopt, "r", Value{});
     Value dV = getArg(args, std::nullopt, "d", Value{});
+    Value r1V = getArg(args, 1, "r1", Value{});
+    Value r2V = getArg(args, 2, "r2", Value{});
     Value d1V = getArg(args, std::nullopt, "d1", Value{});
     Value d2V = getArg(args, std::nullopt, "d2", Value{});
-    const bool center = truthy(getArg(args, std::nullopt, "center", Value{false}));
-
-    std::optional<double> r = isUndef(rV) ? std::nullopt : std::optional<double>(toDoubleLenient(rV));
-    std::optional<double> r1 = isUndef(r1V) ? std::nullopt : std::optional<double>(toDoubleLenient(r1V));
-    std::optional<double> r2 = isUndef(r2V) ? std::nullopt : std::optional<double>(toDoubleLenient(r2V));
-
-    if (!isUndef(dV) && !r) r = toDoubleLenient(dV) / 2.0;
-    if (!isUndef(d1V) && !r1) r1 = toDoubleLenient(d1V) / 2.0;
-    if (!isUndef(d2V) && !r2) r2 = toDoubleLenient(d2V) / 2.0;
-    if (r) {
-        r1 = *r;
-        r2 = *r;
-    }
-    if (!r1) r1 = 1.0;
-    if (!r2) r2 = *r1;
-
-    const int segs = fnSegmentsFromCtx(effCtx, std::max(*r1, *r2));
+    const bool center = truthy(getArg(args, 3, "center", Value{false}));
+
+    // Application order is significant and mirrors the reference's own
+    // sequence of independent `if (x.isNumber()) ...` assignments: r, then
+    // d (which overrides r outright rather than deferring to it), then the
+    // 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.
+    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;
+
+    const int segs = fnSegmentsFromCtx(effCtx, std::max(r1, r2));
 
     CSGParams params;
     params["h"] = Value{h};
-    params["r1"] = Value{*r1};
-    params["r2"] = Value{*r2};
+    params["r1"] = Value{r1};
+    params["r2"] = Value{r2};
     params["center"] = Value{center};
     params["segs"] = Value{static_cast<double>(segs)};
     params["color"] = colorToValue(effCtx.color);
@@ -288,6 +331,31 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
         mesh.triVerts.push_back(static_cast<uint32_t>(std::get<double>(t)));
     }
     manifold::Manifold body(mesh);
+    if (isDrawableFailure(body, mesh)) {
+        // An open surface -- faces that don't close the solid. Manifold
+        // signals that by returning an EMPTY body rather than throwing, so
+        // without this branch the polyhedron simply vanishes from the
+        // render with nothing said, leaving the author to guess which face
+        // they forgot.
+        //
+        // Report the boundary-edge count rather than Manifold's own
+        // "NotManifold" status string, which is actively misleading here: a
+        // closed mesh with reversed winding, non-manifold vertices or
+        // self-intersections builds perfectly well, and only an OPEN one
+        // reaches this branch. The count points straight at the problem.
+        ev.warn("polyhedron: mesh is not closed -- " + std::to_string(countBoundaryEdges(mesh)) +
+                    " boundary edge(s); drawing it as a surface, but it cannot "
+                    "take part in any CSG operation",
+                &node.position());
+        return {ev.tagDisplayOnly(std::move(mesh), node, params.at("color"))};
+    }
+    if (body.Status() != manifold::Manifold::Error::NoError) {
+        // Broken vertex data rather than merely-open topology (a NaN
+        // coordinate, an out-of-range index). Not drawable, so this keeps
+        // the old drop-it behaviour -- but says so, which it never used to.
+        ev.warn(std::string("polyhedron: ") + manifoldErrorName(body.Status()) + "; geometry discarded",
+                &node.position());
+    }
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }
 

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/src/builtins/topology.cpp

@@ -61,6 +61,7 @@ std::vector<ColoredBody> generateHull(Evaluator&, const CSGParams&, const std::v
     result.insert(result.end(), split.background.begin(), split.background.end());
     result.insert(result.end(), split.highlight.begin(), split.highlight.end());
     result.insert(result.end(), split.showOnly.begin(), split.showOnly.end());
+    result.insert(result.end(), split.displayOnly.begin(), split.displayOnly.end());
     return result;
 }
 
@@ -89,6 +90,7 @@ std::vector<ColoredBody> generateMinkowski(Evaluator& ev, const CSGParams&, cons
     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) {

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/src/builtins/transforms.cpp

@@ -3,6 +3,7 @@
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
 
+#include <array>
 #include <cmath>
 #include <numbers>
 
@@ -32,6 +33,21 @@ manifold::vec2 toVec2(const Value& v, double defaultX = 0.0, double defaultY = 0
     return manifold::vec2(defaultX, defaultY);
 }
 
+// resize()'s `auto` argument: a bare bool applies to all three axes, a
+// list applies element-wise (missing elements are false), anything else
+// (including undef) disables auto entirely. Mirrors the reference's
+// Value::toBool()/vector handling.
+std::array<bool, 3> toAutoAxes(const Value& v) {
+    if (const bool* b = std::get_if<bool>(&v)) return {*b, *b, *b};
+    if (const ListPtr* l = std::get_if<ListPtr>(&v); l && *l) {
+        const auto& items = (*l)->items;
+        std::array<bool, 3> out{false, false, false};
+        for (size_t i = 0; i < 3 && i < items.size(); ++i) out[i] = truthy(items[i]);
+        return out;
+    }
+    return {false, false, false};
+}
+
 // Rodrigues' rotation formula as a 3x4 transform (rotate(angle, axis) --
 // the axis form, as opposed to rotate([x,y,z]) Euler angles, which uses
 // Manifold's own Rotate() directly and never needs this). Mirrors
@@ -117,13 +133,35 @@ manifold::Manifold applyTransform3d(const std::string& name, const CallArgs& arg
         return body.Mirror(toVec3(getArg(args, 0, "v", Value{}), 1.0, 0.0, 0.0));
     }
     if (name == "resize") {
-        const manifold::vec3 newSize = toVec3(getArg(args, 0, "newsize", Value{}));
+        const manifold::vec3 newSizeV = toVec3(getArg(args, 0, "newsize", Value{}));
+        std::array<bool, 3> autoAxes = toAutoAxes(getArg(args, 1, "auto", Value{}));
         const manifold::Box bbox = body.BoundingBox();
-        const manifold::vec3 span = bbox.max - bbox.min;
-        const double sx = (newSize.x != 0.0 && span.x != 0.0) ? newSize.x / span.x : 1.0;
-        const double sy = (newSize.y != 0.0 && span.y != 0.0) ? newSize.y / span.y : 1.0;
-        const double sz = (newSize.z != 0.0 && span.z != 0.0) ? newSize.z / span.z : 1.0;
-        return body.Scale(manifold::vec3(sx, sy, sz));
+        const manifold::vec3 spanV = bbox.max - bbox.min;
+        const double ns[3] = {newSizeV.x, newSizeV.y, newSizeV.z};
+        const double span[3] = {spanV.x, spanV.y, spanV.z};
+
+        // An `auto` axis takes the scale factor of whichever axis asked for
+        // the LARGEST new size -- not its own (it has none) and not the
+        // first specified one. Mirrors the reference's newsizemax_index:
+        // ties keep the earlier axis, and an all-zero newsize leaves the
+        // factor at 1 so `resize([0,0,0], true)` is a no-op.
+        int maxIdx = 0;
+        for (int i = 1; i < 3; ++i) {
+            if (ns[i] > ns[maxIdx]) maxIdx = i;
+        }
+        const double autoScale = (ns[maxIdx] != 0.0 && span[maxIdx] != 0.0) ? ns[maxIdx] / span[maxIdx] : 1.0;
+
+        double scale[3];
+        for (int i = 0; i < 3; ++i) {
+            if (ns[i] != 0.0 && span[i] != 0.0) {
+                scale[i] = ns[i] / span[i];
+            } else if (ns[i] == 0.0 && autoAxes[static_cast<size_t>(i)]) {
+                scale[i] = autoScale;
+            } else {
+                scale[i] = 1.0;
+            }
+        }
+        return body.Scale(manifold::vec3(scale[0], scale[1], scale[2]));
     }
     if (name == "multmatrix") {
         Value m = getArg(args, 0, "m", Value{});

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/src/csg_generate.cpp

@@ -110,4 +110,27 @@ ColoredBody Evaluator::tagGenerated(manifold::Manifold body, const oscad::ASTNod
     return cb;
 }
 
+ColoredBody Evaluator::tagDisplayOnly(manifold::MeshGL mesh, const oscad::ASTNode& node, const Value& colorValue) {
+    const std::optional<std::array<float, 4>> color = valueToColor(colorValue);
+
+    // A Manifold that failed to build carries no run IDs, so reserve one
+    // and describe the whole soup as a single run. ReserveIDs() draws from
+    // the same global counter Manifold hands to real bodies, so an ID
+    // minted here can never collide with one of theirs.
+    const uint32_t originalId = manifold::Manifold::ReserveIDs(1);
+    mesh.runOriginalID = {originalId};
+    mesh.runIndex = {0, static_cast<uint32_t>(mesh.triVerts.size())};
+    idToNode[originalId] = &node;
+    idToColor[originalId] = color;
+
+    ColoredBody cb;
+    // Left set-but-empty rather than nullopt: consumers dereference
+    // cb.body unconditionally, and an empty Manifold is also the honest
+    // answer to "what solid is this?" -- there isn't one.
+    cb.body = manifold::Manifold();
+    cb.color = color;
+    cb.rawMesh = std::move(mesh);
+    return cb;
+}
+
 } // namespace oscadeval

{openscad_cpp_evaluator-0.13.10 → openscad_cpp_evaluator-0.15.0}/tests/test_extrude_roof.cpp

@@ -151,11 +151,27 @@ TEST(Offset, NegativeDeltaShrinksTheSquare) {
     EXPECT_NEAR(e.bodies[0].section->Area(), 2.0 * 2.0, 1e-6);
 }
 
-TEST(Offset, NoRadiusOrDeltaPassesThroughFirstChild) {
-    Evaluated e = evalSrc("offset() square(4, center=true);");
-    ASSERT_EQ(e.bodies.size(), 1u);
-    ASSERT_TRUE(e.bodies[0].section.has_value());
-    EXPECT_NEAR(e.bodies[0].section->Area(), 16.0, 1e-6);
+// `r` owns position 0, so offset(2) == offset(r=2). It used to be
+// named-only, making a bare offset(2) a silent no-op.
+TEST(Offset, FirstPositionalArgumentIsRadius) {
+    Evaluated positional = evalSrc("offset(1, $fn=64) square(4, center=true);");
+    Evaluated named = evalSrc("offset(r=1, $fn=64) square(4, center=true);");
+    ASSERT_TRUE(positional.bodies[0].section.has_value());
+    EXPECT_NEAR(positional.bodies[0].section->Area(), named.bodies[0].section->Area(), 1e-9);
+    EXPECT_GT(positional.bodies[0].section->Area(), 16.0);
+}
+
+// A bare offset() is offset(r=1), NOT a pass-through -- the reference
+// initialises its delta to 1 with a round join and only overwrites it from
+// an argument. Verified against OpenSCAD 2022.08.22, where offset() and
+// offset(r=1) produce identical geometry.
+TEST(Offset, NoRadiusOrDeltaDefaultsToRadiusOne) {
+    Evaluated bare = evalSrc("offset() square(4, center=true);");
+    Evaluated explicitR = evalSrc("offset(r=1) square(4, center=true);");
+    ASSERT_EQ(bare.bodies.size(), 1u);
+    ASSERT_TRUE(bare.bodies[0].section.has_value());
+    EXPECT_NEAR(bare.bodies[0].section->Area(), explicitR.bodies[0].section->Area(), 1e-9);
+    EXPECT_GT(bare.bodies[0].section->Area(), 16.0); // grew, rather than passing through
 }
 
 // -- roof -----------------------------------------------------------------