openscad-cpp-evaluator 1.33.0__tar.gz → 1.35.0__tar.gz

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/.github/workflows/ci.yml

@@ -50,8 +50,21 @@ jobs:
       # Linux/macOS use (CMAKE_BUILD_TYPE already picked the config), but
       # required on Windows's default multi-config Visual Studio
       # generator, which ignores CMAKE_BUILD_TYPE entirely.
+      # A bounded job count on the Unix runners. A bare `-j` becomes `make -j`,
+      # which starts EVERY compile at once; on macos-latest (3 vCPU, 7 GB) a
+      # pile of template-heavy translation units that size ran the build at
+      # 852-2000 s against Linux's ~300 s. Windows keeps the bare -j: MSBuild
+      # reads it as "use the cores", which is already bounded.
       - name: Build
-        run: cmake --build build --config Release -j
+        shell: bash
+        run: |
+          case "$RUNNER_OS" in
+            macOS) JOBS=$(sysctl -n hw.ncpu) ;;
+            Linux) JOBS=$(nproc) ;;
+            *)     JOBS= ;;
+          esac
+          echo "building with -j ${JOBS:-<unbounded: MSBuild>}"
+          cmake --build build --config Release -j $JOBS
 
       # Bytecode VM on (the default as of the Phase 5 rollout decision --
       # see evaluator.hpp's own bytecodeVmEnabled() comment) and off

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/.github/workflows/wheels.yml

@@ -38,8 +38,16 @@ jobs:
             name: macos-arm64
           - runner: macos-15-intel
             name: macos-x86_64
+          # Two Windows jobs, one per architecture, both on the x86_64 runner
+          # (ARM64 is cross-compiled; see CIBW_ARCHS_WINDOWS). As one job they
+          # built one after the other -- 7 min each, 14.5 min for the job,
+          # the slowest in the release -- when neither needs the other.
           - runner: windows-latest
             name: windows-x86_64
+            archs: AMD64
+          - runner: windows-latest
+            name: windows-arm64
+            archs: ARM64
     runs-on: ${{ matrix.runner }}
     steps:
       - uses: actions/checkout@v7
@@ -65,7 +73,7 @@ jobs:
           # ARM64 build at all, so building on an ARM runner would have to
           # emulate it. cibuildwheel skips CIBW_TEST_COMMAND for the
           # cross-compiled wheel, since an x86_64 host cannot run it.
-          CIBW_ARCHS_WINDOWS: "AMD64 ARM64"
+          CIBW_ARCHS_WINDOWS: ${{ matrix.archs }}
           # delvewheel vendors the MSVC runtime into the wheel, but on an
           # x86_64 host it can only find the x86_64 copy -- repairing the
           # cross-built ARM64 wheel died with "Unable to find library:

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/CLAUDE.md

@@ -1185,10 +1185,21 @@ grep for `ponytail:`.
 - `include/openscad_cpp_evaluator/mesh_import.hpp`, `src/import/mesh_import.cpp` — STL (ASCII +
   binary, exact-match vertex welding)/OBJ/OFF/3MF mesh loaders, returning plain `(verts, tris)` —
   no `Evaluator`/`Value` dependency, so these are reusable from both `import()` contexts below.
+- `src/import/scene_import.cpp` — AMF, X3D and VRML97 import, the three multi-object formats export
+  writes that nothing could read back (current upstream OpenSCAD removed its AMF importer, so all
+  three go beyond it). Geometry only, like the loaders above, but each format's scene structure is
+  honoured: X3D/VRML `Transform`s nest and apply in full (`T·C·R·SR·S·SR⁻¹·C⁻¹`), `DEF`/`USE`
+  resolves, `ccw FALSE` flips winding, `IndexedFaceSet` polygons fan-triangulate (a last polygon
+  without `-1` counts), and X3D's `IndexedTriangleSet`/`TriangleSet` are read. X3D goes through a
+  small real XML parser (comments, CDATA, DOCTYPE, entities); VRML through a tokenizer + generic
+  node parser that steps over `PROTO`/`EXTERNPROTO`/`ROUTE` (VRML 1.0 is refused by name). AMF's
+  `unit` scales to mm, and a zipped AMF (`PK` header) is read through `readStoredZipEntryBySuffix`.
+  What is not a mesh — primitives (Box, Sphere, ...), `Inline`, AMF constellations — lands in
+  `LoadedMesh::warnings`, which both `import()` faces emit as `import: '<file>': ...`.
 - `include/openscad_cpp_evaluator/import_builtin.hpp`, `include/openscad_cpp_evaluator/
   zip_stored.hpp` (+ `src/zip_stored.cpp`), `src/builtins/import.cpp` — `import()`'s two faces:
   `resolveImport`/`generateImport` (registered in `registry.cpp` like any other builtin *module* —
-  a geometry statement, STL/OBJ/OFF/3MF/DXF/SVG) and `importAsValue` (called directly from
+  a geometry statement, STL/OBJ/OFF/3MF/AMF/X3D/VRML/DXF/SVG) and `importAsValue` (called directly from
   `user_calls.cpp`'s `evalFunctionCall`, special-cased *before* the `isBuiltinFunctionName` gate
   since `import` isn't in that table — returns a VNF `[[verts],[faces]]` for a mesh file, a Region
   `[[[x,y],...],...]` for DXF/SVG, or the JSON file's content as native values).

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/CMakeLists.txt

@@ -79,6 +79,15 @@ if(MSVC)
   # unconditionally (a POSIX extension our code already relies on), so no
   # equivalent is needed there.
   add_compile_definitions(_USE_MATH_DEFINES)
+  # /MP: compile a target's source files in parallel. MSBuild's own /m (what
+  # `cmake --build -j` passes) runs PROJECTS in parallel but each project's
+  # files one at a time, and nearly everything here is one big library, so a
+  # Windows build was close to serial (CI's Build step ~665 s against Linux's
+  # ~250). Visual Studio generators only: under Ninja every compiler call is
+  # already one file, and Ninja does the parallelism itself.
+  if(CMAKE_GENERATOR MATCHES "Visual Studio")
+    add_compile_options(/MP)
+  endif()
 endif()
 
 # The nanobind Python extension (bindings/) links the static evaluator lib

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/bindings/module.cpp

@@ -73,9 +73,10 @@ oscadeval::Value pyToValue(nb::handle v) {
     if (nb::isinstance<nb::int_>(v) || nb::isinstance<nb::float_>(v)) return oscadeval::Value{nb::cast<double>(v)};
     if (nb::isinstance<nb::str>(v)) return oscadeval::Value{nb::cast<std::string>(v)};
     if (nb::isinstance<nb::list>(v) || nb::isinstance<nb::tuple>(v)) {
-        oscadeval::ValueList vl;
-        for (nb::handle item : nb::borrow<nb::sequence>(v)) vl.items.push_back(pyToValue(item));
-        return oscadeval::Value{oscadeval::ListPtr(std::make_shared<const oscadeval::ValueList>(std::move(vl)))};
+        std::vector<oscadeval::Value> items;
+        for (nb::handle item : nb::borrow<nb::sequence>(v)) items.push_back(pyToValue(item));
+        return oscadeval::Value{oscadeval::ListPtr(
+            std::make_shared<const oscadeval::ValueList>(oscadeval::ValueList{std::move(items)}))};
     }
     return oscadeval::Value{}; // monostate = undef
 }

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/include/openscad_cpp_evaluator/mesh_import.hpp

@@ -13,6 +13,9 @@ namespace oscadeval {
 struct LoadedMesh {
     std::vector<std::array<double, 3>> verts;
     std::vector<std::array<int, 3>> tris;
+    // What the loader read but could not turn into mesh (X3D/VRML primitives,
+    // Inline, AMF constellations), for import() to warn about.
+    std::vector<std::string> warnings;
 };
 
 // Each throws std::runtime_error with a message suitable for wrapping into
@@ -23,5 +26,11 @@ LoadedMesh loadStl(const std::string& path);
 LoadedMesh loadObj(const std::string& path);
 LoadedMesh loadOff(const std::string& path);
 LoadedMesh loadThreeMf(const std::string& path);
+// scene_import.cpp: the three multi-object formats export writes. AMF (plain
+// or zipped, `unit` scaled to mm), X3D and VRML97 (Transforms applied,
+// DEF/USE resolved, polygons fan-triangulated). Geometry only, like the rest.
+LoadedMesh loadAmf(const std::string& path);
+LoadedMesh loadX3d(const std::string& path);
+LoadedMesh loadVrml(const std::string& path);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/include/openscad_cpp_evaluator/value.hpp

@@ -2,7 +2,9 @@
 
 #include "openscad_cpp_evaluator/osc_range.hpp"
 
+#include <atomic>
 #include <functional>
+#include <initializer_list>
 #include <memory>
 #include <optional>
 #include <string>
@@ -98,13 +100,70 @@ inline std::shared_ptr<TrailView<Value>> capturedLetTrail(const Closure& c) {
     return std::static_pointer_cast<TrailView<Value>>(c.capturedLet);
 }
 
-// Defined after Value so both can hold Value by value -- the standard
-// recursive-variant pattern (indirection through a forward-declared,
-// heap-allocated aggregate).
+// A list's elements: a read-only view of the first `size()` elements of a
+// buffer that other lists may share. Lists that are prefixes of one another
+// share one buffer, which is what makes repeated appending cheap: `acc`
+// and `concat(acc, [x])` are the same buffer, the second one element
+// longer (listAppend). Defined after Value so both can hold Value by value
+// -- the standard recursive-variant pattern.
+//
+// The buffer only ever grows within the capacity it was given, so element
+// addresses never move while any view of it is alive, and an element, once
+// written, is never changed. `used` is how far the longest view reaches;
+// only a list ending exactly there may extend it, claiming the new slots
+// with one compare-and-swap, so two lists sharing a prefix can never write
+// the same slot (the loser copies).
+struct ListBuffer {
+    std::vector<Value> v;
+    std::atomic<size_t> used;
+    // Set when this buffer came from appending: a list that was appended
+    // to once is likely to be again, so ITS copies grow geometrically,
+    // while a one-off concat's result is allocated at exactly its size.
+    bool fromAppend = false;
+    explicit ListBuffer(std::vector<Value>&& items) : v(std::move(items)), used(v.size()) {}
+};
+
+class ListItems {
+public:
+    ListItems() = default;
+    ListItems(std::vector<Value>&& items)                       // NOLINT: implicit, as the old vector was
+        : buf_(std::make_shared<ListBuffer>(std::move(items))), n_(buf_->v.size()) {}
+    ListItems(const std::vector<Value>& items) : ListItems(std::vector<Value>(items)) {}  // NOLINT
+    ListItems(std::initializer_list<Value> items) : ListItems(std::vector<Value>(items)) {}
+
+    size_t size() const { return n_; }
+    bool empty() const { return n_ == 0; }
+    const Value* data() const { return buf_ ? buf_->v.data() : nullptr; }
+    const Value* begin() const { return data(); }
+    const Value* end() const { return data() + n_; }
+    const Value& operator[](size_t i) const { return data()[i]; }
+    const Value& at(size_t i) const;
+    const Value& front() const { return data()[0]; }
+    const Value& back() const { return data()[n_ - 1]; }
+    // A copy as a plain vector, for the few callers that build on one.
+    // Explicit, so a copy is never made by accident binding a reference.
+    explicit operator std::vector<Value>() const { return std::vector<Value>(begin(), end()); }
+    std::vector<Value> toVector() const { return std::vector<Value>(begin(), end()); }
+
+private:
+    ListItems(std::shared_ptr<ListBuffer> buf, size_t n) : buf_(std::move(buf)), n_(n) {}
+    std::shared_ptr<ListBuffer> buf_;
+    size_t n_ = 0;
+    friend ListPtr listAppend(const ListPtr& base, std::vector<Value>&& extra);
+};
+
 struct ValueList {
-    std::vector<Value> items;
+    ListItems items;
 };
 
+// `base` followed by `extra`, sharing base's buffer whenever base is the
+// longest list using it and the buffer has room: amortized O(|extra|)
+// rather than O(|base| + |extra|), which is what turns the idiomatic
+// tail-recursive accumulator, f(i, concat(acc, [x])), from quadratic into
+// linear. Safe whatever else still holds `base`: base keeps seeing only
+// its own elements.
+ListPtr listAppend(const ListPtr& base, std::vector<Value>&& extra);
+
 // Insertion-ordered key/value pairs, not a map: object()'s iteration order
 // and `==` are order-sensitive (doc: openscad_evaluator/docs/evaluator.md,
 // the object() entry).

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/src/CMakeLists.txt

@@ -23,6 +23,7 @@ add_library(openscad_cpp_evaluator STATIC
   mesh_check.cpp
   zip_stored.cpp
   import/mesh_import.cpp
+  import/scene_import.cpp
   import/surface_load.cpp
   import/dxf_import.cpp
   import/svg_import.cpp

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/src/builtins/booleans.cpp

@@ -313,7 +313,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;
     const auto emptyIsAGroupIt = params.find("empty_is_a_group");
-    const std::vector<Value>* emptyIsAGroup =
+    const ListItems* emptyIsAGroup =
         emptyIsAGroupIt == params.end()
             ? nullptr
             : &std::get<ListPtr>(emptyIsAGroupIt->second)->items;

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/src/builtins/function_builtins.cpp

@@ -616,11 +616,11 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
     const unsigned numReturns = static_cast<unsigned>(static_cast<long long>(nrRaw));
     const unsigned indexCol = static_cast<unsigned>(static_cast<long long>(icRaw));
 
-    static const std::vector<Value> kNoItems;
+    static const ListItems kNoItems;
     const ListPtr* tablePtr = std::get_if<ListPtr>(&tableArg);
-    const std::vector<Value>& table = (tablePtr && *tablePtr) ? (*tablePtr)->items : kNoItems;
+    const ListItems& table = (tablePtr && *tablePtr) ? (*tablePtr)->items : kNoItems;
 
-    const auto itemsOf = [](const Value& v) -> const std::vector<Value>& {
+    const auto itemsOf = [](const Value& v) -> const ListItems& {
         const ListPtr* l = std::get_if<ListPtr>(&v);
         return (l && *l) ? (*l)->items : kNoItems;
     };
@@ -629,7 +629,7 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
     // only when the entry really is a long enough vector.
     const auto hits = [&](const Value& needle, const Value& entry) {
         if (indexCol == 0 && oscEqual(needle, entry)) return true;
-        const std::vector<Value>& ev2 = itemsOf(entry);
+        const ListItems& ev2 = itemsOf(entry);
         return indexCol < ev2.size() && oscEqual(needle, ev2[indexCol]);
     };
     const auto num = [](size_t j) { return Value{static_cast<double>(j)}; };
@@ -682,7 +682,7 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
             unsigned matchCount = 0;
             std::vector<Value> resultvec;
             for (size_t j = 0; j < table.size(); ++j) {
-                const std::vector<Value>& entryVec = itemsOf(table[j]);
+                const ListItems& entryVec = itemsOf(table[j]);
                 if (entryVec.size() <= indexCol) {
                     ev.warn("Invalid entry in search vector at index " + std::to_string(j) +
                                 ", required number of values in the entry: " + std::to_string(indexCol + 1) +
@@ -1162,9 +1162,9 @@ bool checkMinMax(Evaluator& ev, const std::string& name, const CallArgs& args, c
         return false;
     }
     if (nPos == 1 && std::holds_alternative<ListPtr>(positionalAt(args, 0))) {
-        static const std::vector<Value> kEmptyItems;
+        static const ListItems kEmptyItems;
         const ListPtr& l = std::get<ListPtr>(positionalAt(args, 0));
-        const std::vector<Value>& items = l ? l->items : kEmptyItems;
+        const ListItems& items = l ? l->items : kEmptyItems;
         if (items.empty()) {
             warnArity(ev, name, "at least 1 vector element", 0, pos);
             return false;
@@ -1346,14 +1346,21 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
                                  toDoubleLenient(getArg(args, 2, "value_count", Value{})), getArg(args, 3, "seed", Value{}));
         }
         case BuiltinFnId::Concat: {
+            // Everything after the first argument, appended to the first
+            // when it is a list: listAppend extends its buffer in place when
+            // it can, so an accumulator loop is linear, not quadratic.
+            const size_t count = positionalCount(args);
+            const ListPtr* first = count ? std::get_if<ListPtr>(&positionalAt(args, 0)) : nullptr;
             std::vector<Value> out;
-            for (const Value& a : allPositional(args)) {
+            for (size_t i = (first && *first) ? 1 : 0; i < count; ++i) {
+                const Value& a = positionalAt(args, i);
                 if (const ListPtr* l = std::get_if<ListPtr>(&a); l && *l) {
                     out.insert(out.end(), (*l)->items.begin(), (*l)->items.end());
                 } else {
                     out.push_back(a);
                 }
             }
+            if (first && *first) return Value{listAppend(*first, std::move(out))};
             return listOf(std::move(out));
         }
         case BuiltinFnId::Len: {

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/src/builtins/import.cpp

@@ -46,10 +46,16 @@ LoadedMesh loadMeshByExt(const std::string& path, const std::string& ext) {
     if (ext == ".stl") return loadStl(path);
     if (ext == ".obj") return loadObj(path);
     if (ext == ".off") return loadOff(path);
+    if (ext == ".amf") return loadAmf(path);
+    if (ext == ".x3d") return loadX3d(path);
+    if (ext == ".wrl") return loadVrml(path);
     return loadThreeMf(path);
 }
 
-bool isMeshExt(const std::string& ext) { return ext == ".stl" || ext == ".obj" || ext == ".off" || ext == ".3mf"; }
+bool isMeshExt(const std::string& ext) {
+    return ext == ".stl" || ext == ".obj" || ext == ".off" || ext == ".3mf" || ext == ".amf" || ext == ".x3d" ||
+           ext == ".wrl";
+}
 
 
 Value jsonToValue(const nlohmann::ordered_json& j) {
@@ -208,7 +214,10 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         params["dxf"] = Value{ext == ".dxf"};
         return params;
     }
-    if (ext == ".dxf" || ext == ".svg" || ext == ".pdf") {
+    // .pdf is not here: it used to be, handed to the SVG parser, which hung on
+    // a PDF's bytes. Nothing reads PDF (OpenSCAD does not either), so it takes
+    // the ordinary "unsupported file type" error below.
+    if (ext == ".dxf" || ext == ".svg") {
         std::vector<Contour2d> contours;
         bool filteredMiss = false;
         try {
@@ -257,6 +266,7 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         } catch (const std::exception& e) {
             ev.error(std::string("import: ") + e.what(), node);
         }
+        for (const std::string& w : mesh.warnings) ev.warn("import: '" + path + "': " + w, &node.position());
         std::vector<Value> vertsFlat;
         vertsFlat.reserve(mesh.verts.size() * 3);
         for (const auto& v : mesh.verts) {
@@ -428,8 +438,12 @@ Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& n
 
     try {
         if (ext == ".json") return loadJsonAsValue(path);
-        if (isMeshExt(ext)) return meshToVnf(loadMeshByExt(path, ext));
-        if (ext == ".dxf" || ext == ".svg" || ext == ".pdf") {
+        if (isMeshExt(ext)) {
+            const LoadedMesh mesh = loadMeshByExt(path, ext);
+            for (const std::string& w : mesh.warnings) ev.warn("import: '" + path + "': " + w, &node.position());
+            return meshToVnf(mesh);
+        }
+        if (ext == ".dxf" || ext == ".svg") {
             std::vector<Contour2d> contours;
             if (ext == ".dxf") {
                 std::optional<std::string> layer;

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/src/builtins/primitives_3d.cpp

@@ -133,7 +133,7 @@ CSGParams resolveCube(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     } else if (l && *l && (*l)->items.size() == 3 &&
                std::all_of((*l)->items.begin(), (*l)->items.end(),
                            [](const Value& v) { return std::holds_alternative<double>(v); })) {
-        sizeVec = (*l)->items;
+        sizeVec = (*l)->items.toVector();
     } else if (!std::holds_alternative<std::monostate>(sizeArg)) {
         ev.warn("Unable to convert cube(size=" + fmtValue(sizeArg) +
                     ", ...) parameter to a number or a vec3 of numbers",

{openscad_cpp_evaluator-1.33.0 → openscad_cpp_evaluator-1.35.0}/src/expr_eval.cpp

@@ -42,7 +42,7 @@ std::optional<bool> valueLess(const Value& a, const Value& b) {
 
     const ListPtr& la = std::get<ListPtr>(a);
     const ListPtr& lb = std::get<ListPtr>(b);
-    static const std::vector<Value> kEmpty;
+    static const ListItems kEmpty;
     const auto& ia = la ? la->items : kEmpty;
     const auto& ib = lb ? lb->items : kEmpty;
     const size_t n = std::min(ia.size(), ib.size());