Merge branch 'main' into feat/networking-foundation

fix: clean diff
chore: port add_platform_root_certificates to 15711
2026-10-12 10:21:17 +00:00 · 2026-10-01 22:50:48 +08:00 · 2026-10-01 22:50:00 +08:00 · 2026-10-01 14:20:56 +08:00 · 2026-10-01 13:55:37 +08:00 · 2026-10-01 13:55:29 +08:00
3592 changed files with 2547875 additions and 2644376 deletions
@@ -1,75 +0,0 @@
-# clang-tidy configuration, enforced by the clang-tidy CI job on the lines a pull
-# request changes (scripts/clang_tidy_diff.py). Two things are reported.
-# Missing includes: a file should include the header for every symbol it uses, not
-# rely on the precompiled header or another header's includes. Run with --fix to
-# add them.
-# Using-directives and using-declarations in the global namespace of a header:
-# they reach every file that includes the header, and a using-declaration also
-# makes the header look like the one to include for that name. Qualify the name
-# in the header, and put the using in the source files that want it.
-# Every check listed here gates pull requests, so enable a new one only once the
-# code it flags on touched lines is reasonable to fix in passing.
-Checks: '-*,misc-include-cleaner,google-global-names-in-headers'
-WarningsAsErrors: '*'
-CheckOptions:
-  # Missing includes only. Builds without the precompiled header break on these.
-  misc-include-cleaner.UnusedIncludes: false
-  # Headers that declare a symbol but are not the one to include: per-platform
-  # implementations of wxWidgets and Boost.Thread (a Linux run would suggest the
-  # GTK or pthread one), library internals and forward declarations (MSVC's STL
-  # __msvc_* and the Windows UCRT's corecrt_* included), CPython's headers behind
-  # Python.h (python3.x/ on Linux and macOS, libpython/include/ on Windows),
-  # curl's behind curl.h, oneTBB's behind tbb/, and
-  # admesh's stl.h, which the include path also exposes without its directory.
-  # Clipper's own clipper.hpp is only included through libslic3r/clipper.hpp or
-  # clipper_z.hpp, which configure it first, and Boost.Polygon's headers only
-  # work through boost/polygon/polygon.hpp or voronoi.hpp. Clipper2's headers
-  # are included through clipper2/clipper.h, or clipper2_z.hpp, which defines
-  # USINGZ first. minilzo's config
-  # headers are internal to minilzo.h.
-  # FFmpeg's C headers are left alone because they are only included inside
-  # extern "C", which an inserted include would miss. OS-specific headers (GLib,
-  # GTK, D-Bus, POSIX, the Windows SDK) are only used inside platform #if blocks,
-  # and an include added at the top of the file would break the other platforms'
-  # builds. A symbol these provide is not reported missing.
-  # Write every / as [/\\] so the patterns also match Windows paths.
-  # No comments inside the block below, because a # there silently becomes part of a pattern.
-  misc-include-cleaner.IgnoreHeaders: >-
-    wx[/\\](gtk|gtk1|msw|osx|unix|x11|motif|univ|qt|dfb|generic|private)[/\\].*;
-    .*[/\\]detail[/\\].*;
-    .*[/\\]impl[/\\].*;
-    .*_fwd\.hpp;
-    python3\.[0-9]+[/\\].*;
-    libpython[/\\]include[/\\].*;
-    bits[/\\].*;
-    corecrt_.*\.h;
-    __msvc_.*\.hpp;
-    boost[/\\]multiprecision[/\\]fwd\.hpp;
-    imconfig\.h;
-    expat_external\.h;
-    admesh[/\\]stl\.h;
-    boost[/\\]thread[/\\](pthread|win32)[/\\].*;
-    boost[/\\]regex[/\\]v[0-9]+[/\\].*;
-    curl[/\\](easy|multi|system|urlapi|header|options|websockets|mprintf)\.h;
-    oneapi[/\\]tbb[/\\].*;
-    opencv2[/\\]core[/\\]hal[/\\].*;
-    openssl[/\\]ossl_typ\.h;
-    libav[a-z]+[/\\].*;
-    libsw[a-z]+[/\\].*;
-    glib-2\.0[/\\].*;
-    gtk-3\.0[/\\].*;
-    dbus-1\.0[/\\].*;
-    sys[/\\].*;
-    unistd\.h;
-    strings\.h;
-    fcntl\.h;
-    termios\.h;
-    [/\\](um|shared)[/\\].*;
-    sal\.h;
-    tchar\.h;
-    clipper[/\\]clipper\.hpp;
-    png(lib)?conf\.h;
-    mcut[/\\]platform\.h;
-    boost[/\\]polygon[/\\].*;
-    clipper2[/\\]clipper\.(core|engine|offset|minkowski|rectclip|export|triangulation|version)\.h;
-    lzo(conf|defs)\.h
@@ -105,12 +105,11 @@ Rules:
   `single_extruder_multi_material` off, and in the app when the printer tab loads a printer with a
   different number of extruders, the pair is rebuilt from `extruder_variant_list` (one
   `Direct Drive Standard` per extruder when the list is absent) and the variant arrays are resized to
-   the rebuilt pair, padded with their first value or cut. The `machine_max_*` limits are padded the
-   same way, so extruder 2 and up of a list-less printer take extruder 1's normal limit as their
-   silent one too. The resize skips `hotend_heating_rate` / `hotend_cooling_rate`: they keep their
-   width, and an extruder beyond it reads their first value. With the three in agreement that changes
-   nothing; a pair written without the list is replaced. A listed variant the pair lacks is a menu
-   choice that reads variant index 0.
+   the rebuilt pair, padded with their first value or cut. The resize skips the `machine_max_*` limits
+   and `hotend_heating_rate` / `hotend_cooling_rate`: they keep their width, and an extruder beyond it
+   reads their first value, so extruder 2 and up of a list-less printer take extruder 1's normal limit
+   as their silent one too. With the three in agreement that changes nothing; a pair written without
+   the list is replaced. A listed variant the pair lacks is a menu choice that reads variant index 0.
   - The pair without `extruder_variant_list` slices, but the sidebar offers no variant switch and
     the app cannot add variants to a list-less process: nothing is lost while every extruder
     has exactly one variant, and every further variant is unreachable.
@@ -30,9 +30,8 @@ how you read the wx docs:
 Look things up in the source the app is built from — it beats memory, and 3.3 changed real behaviour:

 ```bash
-WX=$(find -L deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets' 2>/dev/null | head -1)
-# macOS: deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets   Linux, Windows: deps/<tree>/dep_wxWidgets-prefix/...
-# -L follows a worktree's deps/<tree> symlinked to the main checkout. Not a glob: zsh aborts on one that matches nothing.
+WX=$(find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets' | head -1)
+# macOS: deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets   Linux: deps/build/dep_wxWidgets-prefix/...
 # If deps are not built: git clone --depth 1 -b v3.3.2 https://github.com/SoftFever/Orca-deps-wxWidgets
 grep -n "CaptureMouse" -A 30 $WX/interface/wx/window.h      # documented contract (doxygen source)
 grep -rn "@onlyfor\|not implemented" $WX/interface/wx/popupwin.h   # documented platform limits
@@ -41,13 +40,6 @@ grep -n "IsDark" $WX/docs/changes.txt                         # what changed in
 grep -n "NotifyCaptureLost" -r $WX/src/osx $WX/src/gtk $WX/src/msw   # what each port actually does
 ```

-On Windows these lookups are bash: run them from Git Bash. PowerShell has no `grep`, and its `find` is
-Windows' text-search `find.exe`. To locate the wx tree from PowerShell:
-
-```powershell
-$WX = Resolve-Path deps\*\dep_wxWidgets-prefix\src\dep_wxWidgets, deps\*\*\dep_wxWidgets-prefix\src\dep_wxWidgets -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty Path
-```
-
 `interface/wx/<class>.h` is the documentation; `src/common` holds shared behaviour and
 `src/{msw,osx,gtk,unix,generic}` the per-port implementation. When the docs and the source disagree,
 the source is what runs — the references mark such facts **[source]**. Orca-side design docs live in
@@ -214,8 +206,7 @@ known class with a pitfall entry and a fixing commit.
 - **macOS:** capture-lost is never sent (a leaked capture freezes all clicks); transient popups hover-
  dismiss across a gap — anchor flush and re-verify the cursor; native modals (file/dir dialogs, native
  message boxes) and generic progress dialogs re-activate the main window, so re-raise a secondary window
-  afterwards with a deferred, liveness-guarded `Raise()` — but never `Raise()` a `wxPopupWindow`, which makes
-  it the key window; a live menu accelerator consumes the key before
+  afterwards with a deferred, liveness-guarded `Raise()`; a live menu accelerator consumes the key before
  any wx key event; Control+click arrives as a right-click.
 - **Windows:** `IsDark()` and `wxSYS_COLOUR_*` follow the system app mode, not Orca's theme — use
  `dark_mode()`; menu bitmaps follow `check_dark_mode()`; windows are not double-buffered by default in
@@ -331,10 +331,6 @@ OrcaSlicer: integer spinners are `::SpinInput` ([below](#spininput)); progress b
 Contract:
 - A page must be created with the book as its parent and added once; the book owns and deletes it
  (`interface/wx/bookctrl.h:253-254, 273`). `RemovePage` detaches without deleting, and you then own it (`:324-330`).
- Removing the selected page selects the page before it (the new first page if it was first) through `SetSelection`,
-  so that page is shown and PAGE_CHANGING/CHANGED are sent; removing a page before the selection only shifts the
-  index. This is `wxBookCtrlBase::DoSetSelectionAfterRemoval` (`src/common/bookctrl.cpp:477-495` **[source]**),
-  called from `DoRemovePage` by `wxSimplebook`, `wxChoicebook`, `wxListbook`, `wxToolbook` and Orca's `Notebook`.
 - `GetSelection()` inside a `PAGE_CHANGED` handler may return the old or the new page depending on the platform; use
  `event.GetSelection()` (`interface/wx/bookctrl.h:160-166`).
 - `wxSimplebook` has no UI; switch with `ChangeSelection()`. `SetSelection()` sends PAGE_CHANGING/CHANGED
@@ -10,7 +10,7 @@ wx asserts are compiled out in Orca (`wxDEBUG_LEVEL=0`), so every misuse below t
 an assert fails silently. "GTK" means wxGTK3, Orca's Linux default (X11 and Wayland); GTK2 is only
 an opt-out build (`-DDEP_WX_GTK3=OFF`), noted where it differs. Paths starting `interface/`,
 `include/`, `src/`, `docs/` are in the wx tree
-(located as in `SKILL.md` §Ground truth); Orca paths are
+(`find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets'`); Orca paths are
 relative to `src/slic3r/GUI/`.

 Contents: [Rules](#rules) · [Mouse capture](#mouse-capture) · [Mouse events](#mouse-events) ·
@@ -332,9 +332,7 @@ indices: pages come and go per printer and per feature flag.
  pages depending on the printer and on `use_printer_agents`; a removed page stays registered but is
  not prebuilt (its `LazyPage::in_book()` is false).
 - Plugin pages are appended by `PluginPages::initialize` (`plugin/host/PluginPages.hpp`) with
-  namespaced ids (`plugin.<plugin_key>.<name>`) that cannot collide with `TAB_ID_*`. Each is a
-  `LazyPage<PluginPage>` with order −1, destroyed when its capability goes away.
-  → [Deferred construction](#deferred-construction-lazy-lazypage-stagedbuild-idlescheduler)
+  namespaced ids (`plugin.<plugin_key>.<name>`) that cannot collide with `TAB_ID_*`.

 ### Preset tabs

@@ -405,13 +403,9 @@ page object to insert and remove by pointer). `LazyPage(parent, name, order, fac
 factory is `new Panel(parent)`. Its `Show(true)` builds the panel the first time (only once the
 top-level frame is shown — `MainFrame::Show` completes the start page on the frame's first show) and
 forwards later shows/hides to the panel, so the panel's own `Show()` override stays its activation
-hook. The build runs before the placeholder's own `wxPanel::Show(true)`, so an on-demand build creates
-its controls in a hidden window as a prebuild does: on MSW each control created or moved inside a
-shown window re-clips and repaints its shown siblings, which made a large panel's first show take
-seconds. A lazy panel's constructor therefore runs off screen (except the start page's) and must not
-rely on `IsShownOnScreen()`. A panel built while its page is hidden stays hidden, and `when_built`
-gives it the dark-UI pass the frame ran before it existed (`apply_dark_ui_to_lazy_panel`).
-`pending()` is true only while the page is in the book.
+hook. A panel built while its page is hidden stays hidden, and `when_built` gives it the dark-UI pass
+the frame ran before it existed (`apply_dark_ui_to_lazy_panel`). `pending()` is true only while the page
+is in the book.

 ### Staged construction: StagedBuild

@@ -535,32 +529,6 @@ the main frame does nothing to a panel after creating it.
  m_idle.add(m_diff_dialog);
  ```
  Cite: `IdleScheduler::tick`, `docs/HLSD/deferred-page-construction.md`.
- **Rule:** A lazy page that can be destroyed while the main frame lives takes a negative order and
-  stays out of `m_lazy_pages`.
-  **Why:** `m_lazy_pages` and `PrebuildQueue` hold raw `LazyBase*` and nothing removes one
-  (`PrebuildQueue` has only `add` and `clear`). The queue calls `pending()` on every task each slice,
-  and `prebuild_pages_when_idle` reads every entry of `m_lazy_pages`, so a page destroyed while still
-  listed can be read after it is freed. A page only taken out of the book is fine: it stays registered
-  and its `pending()` is false (`MainFrame::show_device`).
-  ```cpp
-  // Right (PluginPages::create_page): order -1, and no m_lazy_pages.push_back
-  auto* page = new GUI::LazyPage<PluginPage>(m_parent, name, -1, [capability](wxWindow* parent) {
-      return new PluginPage(parent, capability);
-  });
-  ```
-  Cite: `PluginPages::create_page`, `PluginPages::remove_page`.
- **Rule:** Remove several lazy pages from a book left to right.
-  **Why:** removing the selected page selects and shows the page before it
-  (`references/controls-dataview.md` §Book controls), and showing an unbuilt `LazyPage` while the frame
-  is shown builds it. In any other order the page before the selected one can be one removed next,
-  built only to be destroyed; left to right it is one that stays (unless the selected page is the
-  book's first).
-  ```cpp
-  // Right (PluginPages::shutdown): m_order is the tabs' left-to-right order
-  for (const PluginCapabilityId& id : std::vector<PluginCapabilityId>(m_order))
-      remove_page(id);
-  ```
-  Cite: `PluginPages::shutdown`, `PluginPages::relayout`, `PluginPages::on_plugin_deregister`.

 ## Plater and Sidebar

@@ -645,10 +613,8 @@ Spacing constants come from `SidebarProps` (`Plater.hpp`): `TitlebarMargin()`, `

 ### Docking

-Docks are `AuiMgr`s (`AuiMgr.hpp`), a `wxAuiManager` subclass carrying Orca's dock art, theme and
-Wayland rule (`references/webview-gl-aui-media.md`). `Plater::priv` owns `m_aui_mgr`, managing the
-plater; the Design tab owns its own for its sidebar (`DesignPanel::m_aui`, layout in
-`design_window_layout`). Plater panes: `"sidebar"` (left, no close
+`Plater::priv` owns `AuiMgr m_aui_mgr` (a `wxAuiManager` subclass whose `CreateFloatingFrame` returns a
+themed `FloatFrame : wxAuiFloatingFrame`), managing the plater. Panes: `"sidebar"` (left, no close
 button, not top/bottom dockable), `"main"` (`CenterPane()`, the `panel_3d`), `"uv_editor"` (right,
 hidden until the texture-displacement gizmo shows it), plus dynamic dock panes. The default perspective
 is saved right after `AddPane`; the app-config `window_layout` is applied with
@@ -6,7 +6,7 @@ to write a custom control on the wx side and how to author an Orca widget on the
 `StaticBox`/`StateHandler` foundation. Read it before writing or reviewing any `wxEVT_PAINT`
 handler, `render`/`doRender` method, `messureSize`, or a new class under `src/slic3r/GUI/Widgets/`.

-wx cites are relative to the pinned wx 3.3.2 tree (located as in `SKILL.md` §Ground truth).
+wx cites are relative to the pinned wx 3.3.2 tree (`deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets`).
 Orca builds wx with `wxBUILD_DEBUG_LEVEL=0` and `libslic3r_gui` with `wxDEBUG_LEVEL=0`: every
 wx assert below is compiled out and `wxCHECK*` returns silently, so paint misuse shows up only as
 wrong, missing or stale pixels, never as an assert dialog.
@@ -78,9 +78,8 @@ Contents: [Rules](#rules) · [The wx build Orca uses](#the-wx-build-orca-uses)
  `references/colours-dark-mode.md`.
 - The checked-out source is the tree that every wx citation in this skill refers to:
  `deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets` on macOS and
-  `deps/<tree>/dep_wxWidgets-prefix/src/dep_wxWidgets` on Linux and Windows (`deps/build` for a
-  release build; `build_win.bat` names the others). Locate it with the bash or PowerShell lookup in
-  `SKILL.md` §Ground truth. On macOS its
+  `deps/build/dep_wxWidgets-prefix/src/dep_wxWidgets` on Linux. Find it with
+  `find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets'`. On macOS its
  `src/osx/cocoa/colour.mm` already has the patch applied.
 - **Flatpak builds wx separately.** `deps/CMakeLists.txt` leaves `dep_wxWidgets` out of the deps
  target when `FLATPAK` is set. Instead, `scripts/flatpak/com.orcaslicer.OrcaSlicer.yml` has its own
@@ -271,14 +270,6 @@ Each bullet names the mechanism and the file that owns it.
 - **Painting:** in 3.3.2 windows are not double-buffered by default (the 3.3.0 global
  `WS_EX_COMPOSITED` was reverted, `docs/changes.txt:308`). Custom widgets buffer by hand →
  `references/painting-custom-widgets.md`.
- **Building large panels:** every control is a native child window, and outside a sizer pass a move
-  or resize is immediate, repainting when the window is shown [source: `src/msw/window.cpp:2036`
-  `DoMoveSibling` → `MSWMoveWindowToAnyPosition(..., IsShown())`]; `wxStaticText::SetLabel`/`SetFont`
-  resize the control that way (`src/common/stattextcmn.cpp:334` `AutoResizeIfNecessary`). Created
-  inside a shown parent, each control re-clips and erases its shown, overlapping siblings, so the
-  cost grows with the number already built and hundreds of controls take seconds. Build a large
-  panel while its parent is hidden and show it once complete — `LazyPage::Show` builds its panel
-  before showing the page for this reason → `references/orca-architecture.md` §Deferred construction.
 - **Modal loops:** idle events do not run inside the Windows sizing/moving modal loop, so the 3D
  canvas renders from `on_paint` on MSW (c06a0223a7) → `references/webview-gl-aui-media.md` §GLCanvas3D rendering.
 - **Mouse capture:** `wxEVT_MOUSE_CAPTURE_LOST` and `wxEVT_MOUSE_CAPTURE_CHANGED` are delivered →
@@ -482,7 +473,7 @@ start there when looking for prior art. The sites below are exemplars, cited by
  data-view cell editors an explicit top-level transient parent.
  `DropDown::ShouldDismissOnTopWindowDeactivate` handles Wayland chains.
 - `CheckBox::CheckBox`, `SwitchButton`, `RadioBox`, `ScalableButton` (`wxExtensions.cpp`),
-  `PresetComboBoxes` call `RemoveButtonBorder`; `TextInput` and `SpinInput` call
+  `ObjColorDialog`, `PresetComboBoxes` call `RemoveButtonBorder`; `TextInput` and `SpinInput` call
  `RemoveInputBorder` on their inner `wxTextCtrl`.
 - `Plater::priv::priv` together with `sanitize_window_layout_for_wayland`: AUI floating is disabled on
  Wayland.
@@ -820,7 +811,7 @@ widgets do it in their constructors.
  (`"*.GtkBitmapToggleButton"`, class `"GtkEntry"`). The first call changes every matching widget in
  the process, not just the one passed in.

-**Callers:** `CheckBox::CheckBox`, `SwitchButton`, `RadioBox`, `ScalableButton` and
+**Callers:** `CheckBox::CheckBox`, `SwitchButton`, `RadioBox`, `ScalableButton`, `ObjColorDialog` and
 `PresetComboBoxes` (`RemoveButtonBorder`); the inner `wxTextCtrl` of `TextInput` and `SpinInput`
 (`RemoveInputBorder`). A new owner-drawn control built on a native GTK widget needs the same call.

@@ -5,7 +5,7 @@ How wx 3.3.2 popups and menus behave on each port, and the Orca wrappers built o
 `append_menu_item`, `Plater::PopupMenu` and the macOS menubar versus `BBLTopbar`. Read it before you add
 or change anything that opens over other UI and must close by itself, or any context menu or menubar item.

-wx cites are relative to the wx tree root (located as in `SKILL.md` §Ground truth).
+wx cites are relative to the wx tree root (`deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets`).
 **[source]** marks behaviour derived from the implementation that the wx docs do not state or contradict.
 Orca builds wx with `wxBUILD_DEBUG_LEVEL=0`, so every "asserts" below means "fails silently in Orca".
 "GTK" means wxGTK3 (X11 and Wayland), the default Linux build; GTK2 is only an opt-out (`-DDEP_WX_GTK3=OFF`).
@@ -57,9 +57,8 @@ Contents: [Rules](#rules) · [1. Choosing the window kind](#1-choosing-the-windo
 17. Don't shrink a dropdown below two rows to fit the screen. (§7)
 18. Content that needs typing focus or hosts a `wxWebView` uses a frameless `wxDialog` that hides on
    deactivation, not a transient popup. (§10)
-19. Display-only overlays (HUDs, toasts) use a plain `wxPopupWindow`: `Show()` never gives it focus and it
-    never auto-dismisses. Never `Raise()` any `wxPopupWindow`: `Raise()` is for top-level windows only, and on
-    macOS it makes the popup the key window. (§4, §5, §10)
+19. Display-only overlays (HUDs, toasts) use a plain `wxPopupWindow`: it never takes focus and never
+    auto-dismisses. (§4, §10)
 20. On MSW, don't `SetFocus()` another window on hover while `wxCurrentPopupWindow` is non-null. (§8)
 21. Menu items use `wxID_ANY` and read `item->GetId()`. `wxNewId()` is deprecated. (§13)
 22. Set a menu item's bitmap before `Append`. Don't expect icons on check or radio items. Never call
@@ -357,13 +356,6 @@ compensates for (§6).
  with `ShowWithoutActivating` → `setHidesOnDeactivate:YES` + `orderFront` (`src/osx/carbon/popupwin.cpp:56-75`,
  `nonownedwnd.mm:938-945`). When the app deactivates, Cocoa hides the panel and shows it again on reactivation.
  wx never calls `OnDismiss`, and `IsShown()` stays true. This applies to plain `wxPopupWindow` overlays too.
- `Raise()` activates the popup. It is `makeKeyAndOrderFront` (`src/osx/nonownedwnd_osx.cpp:289-295`,
-  `nonownedwnd.mm:897-899`), and `wxNSPanel` answers `canBecomeKeyWindow` with YES (`nonownedwnd.mm:271`), so
-  the popup becomes the key window. Keys go to it, and the frame loses key status: `windowDidResignKey` →
-  `HandleActivated(0, false)` → `wxEVT_ACTIVATE(false)` on the frame (`nonownedwnd.mm:567-576`,
-  `nonownedwnd_osx.cpp:303-310`). Hiding the key popup gives key back to the frame, which then gets
-  `wxEVT_ACTIVATE(true)` (observed; AppKit behaviour, not in the wx tree). A popup at `NSPopUpMenuWindowLevel`
-  is already above its frame, so `Raise()` buys nothing.
 - Capture: `Show(true)` makes `m_child` capture the mouse ("Assume that the mouse is outside the popup to begin
  with", `popupcmn.cpp:421-426`). `OnIdle` releases the capture while the cursor is inside and re-captures it
  outside, but only when the mouse position has changed since the last idle pass. `s_posLast` is a
@@ -747,26 +739,8 @@ created with `wxBORDER_NONE | wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT | wxF
 - **Rule:** For overlays that must never take keyboard focus (above a GL surface), use a plain
  `wxPopupWindow(top, wxBORDER_NONE)`, not a `wxFrame`.
  **Why:** A frame took the X input focus and swallowed every shortcut until the user clicked the canvas. A popup
-  window does not take focus when shown. On macOS these overlays hide while the app is inactive (§5).
+  window cannot take focus. On macOS these overlays hide while the app is inactive (§5).
  Cite: `CAD/DesignCanvas.cpp` (`m_hud`, `m_status_hud`).
- **Rule:** Never `Raise()` a `wxPopupWindow`. To bring an overlay up, `Show()` it if it is hidden, then
-  `Move()` it.
-  **Why:** `Raise()` is documented for top-level windows only (`interface/wx/window.h:3028-3029`), and a popup
-  derives from `wxNonOwnedWindow`, not `wxTopLevelWindow` (`include/wx/popupwin.h:33`). On macOS it makes the
-  popup the key window (§5): the popup takes the keys meant for the window below it, and the frame receives
-  `wxEVT_ACTIVATE(false)`. A frame activate handler that hides the overlay on deactivation and re-places it on
-  activation then loops: each `Raise()` deactivates the frame, the hide reactivates it, and the re-place raises
-  again, recursing until the main thread's stack overflows. A popup's `Show()` is `ShowWithoutActivating`
-  and is safe.
-  ```cpp
-  // Wrong
-  if (!overlay->IsShown()) overlay->Show();
-  overlay->Move(pos);
-  overlay->Raise();
-  // Right
-  if (!overlay->IsShown()) overlay->Show();
-  overlay->Move(pos);
-  ```

 ## 11. wxComboCtrl / wxComboPopup

@@ -7,7 +7,7 @@ yields and nested event loops, progress dialogs, startup, shutdown and exception
 screen, and the access rules for `wxGetApp()` and `app_config`. Read it whenever code runs off the
 main thread, defers work, starts a timer, yields, shows progress, or runs during startup or shutdown.

-wx cites are relative to the pinned wx 3.3.2 tree (located as in `SKILL.md` §Ground truth).
+wx cites are relative to the pinned wx 3.3.2 tree (`deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets`).
 Orca builds wx with `wxBUILD_DEBUG_LEVEL=0` and `libslic3r_gui` with `wxDEBUG_LEVEL=0`, so `wxASSERT`
 is compiled out and `wxCHECK*` returns silently: a timer started off the main thread never fires on macOS,
 `Exit()` on a loop that is not the active one is ignored, `Start(0)` on macOS fails — all without
@@ -88,7 +88,6 @@ available; GTK2/WebKit1 is an opt-out configuration the GUI does not support.
 24. ImGui text uses `_u8L`; ImGui sizes are physical pixels (scale by `GLCanvas3D::get_scale()`);
    a font atlas must fit `GL_MAX_TEXTURE_SIZE`. §[ImGui boundary](#the-imgui-layer-boundary)
 25. After `AddPane` or any `wxAuiPaneInfo` change, call `wxAuiManager::Update()` once for the batch.
-    Keep a docked pane hidden until the managed window has been laid out.
    §[AUI](#wxauimanager-and-orcas-docking)
 26. Give every pane a unique, stable `Name()` free of layout delimiters (`|`, `;`, `=`, `\`).
    §[AUI](#wxauimanager-and-orcas-docking)
@@ -921,16 +920,6 @@ widgets beside the canvas (a sibling, not a child over it), or in a popup.
 - **Update.** "Update() must be invoked after AddPane() or InsertPane() … any number of changes may be
  made to wxAuiPaneInfo structures (retrieved with wxAuiManager::GetPane), but to realize the changes,
  Update() must be called" (`interface/wx/aui/framemanager.h:747-756`). Batch, then `Update()` once.
- **Dock size** [source]. The docs limit "any new dock" to a `SetDockSizeConstraint` fraction of the
-  window (`interface/wx/aui/framemanager.h:660-672`). The source applies it to the managed window's client
-  size at the `Update()` that creates the dock, sizing the dock from its panes' `best_size` and then
-  raising it to their `min_size` (`src/aui/framemanager.cpp:2748-2848`); a dock with a resizable pane
-  keeps that size (`2674-2677`), and resizing the managed window only re-lays the docks out
-  (`4542-4546`). A pane first shown before its managed window is laid out — a `wxDefaultSize` window is
-  20×20 until its first sizer layout (`references/sizers-layout.md`) — docks at that width or its
-  `min_size` and stays there. Hiding a dock's last shown pane empties it, and the next `Update()`
-  removes it (`2733-2738`) with any `dock_size` a `LoadPerspective` restored, so the pane comes back
-  at its `best_size`.
 - **Names** [source]. A duplicate `Name()` hits `wxFAIL` (silent in Orca); duplicate and empty names
  get a random identifier (`src/aui/framemanager.cpp:949-1010`), which `LoadPerspective` can never
  match. `AddPane` rejects a null window, but its "already managed" check looks up `paneInfo.window`
@@ -964,12 +953,11 @@ widgets beside the canvas (a sibling, not a child over it), or in a popup.
 - `wxAuiNotebook` (not used by Orca): page indices are logical; use `GetPagePosition()` for on-screen
  order (`docs/changes.txt:121-126`); the default tab art changed (`35-37`).

-**OrcaSlicer.** Orca's docks use `AuiMgr` (`AuiMgr.hpp`), a `wxAuiManager` whose `CreateFloatingFrame`
-returns a `wxAuiFloatingFrame` that applies `UpdateFrameDarkUI`. `init(window)` calls
-`SetManagedWindow(window)` and `SetDockSizeConstraint(1, 1)`, clears `wxAUI_MGR_ALLOW_FLOATING` on
-Wayland and sets the dock-art metrics and colours; `apply_color_mode()` re-colours captions, sashes and
-borders and is called from the owner's theme-switch handler. `Plater::priv::m_aui_mgr` manages the
-Plater (Prepare and Preview); `DesignPanel::m_aui` manages the Design tab's body below its toolbar.
+**OrcaSlicer.** `Plater::priv` owns `AuiMgr m_aui_mgr`, a `wxAuiManager` whose `CreateFloatingFrame`
+returns `FloatFrame : wxAuiFloatingFrame` (applies `UpdateFrameDarkUI`).
+- Setup: `SetManagedWindow(q)` (the Plater), `SetDockSizeConstraint(1, 1)`; on Wayland clears
+  `wxAUI_MGR_ALLOW_FLOATING` (`disable_wayland_floating`); dock-art metrics set here, colours in the
+  dark-mode update (`Plater::priv::apply_color_mode`).
 - Panes: `"sidebar"` (left, no close button, not top/bottom dockable, `BestSize` in em units),
  `"uv_editor"` (right, hidden; forced hidden again after a layout load), `"main"`
  (`CenterPane().PaneBorder(false)`, holding `panel_3d` with View3D, Preview and AssembleView in one
@@ -978,8 +966,8 @@ Plater (Prepare and Preview); `DesignPanel::m_aui` manages the Design tab's body
  `window_layout` app-config string goes through `sanitize_window_layout_for_wayland` (strips
  floating/floatable bits on Wayland) and `LoadPerspective(layout, false)`, falling back to the default
  on failure; then one `Update()`. `Plater::priv::reset` saves `SavePerspective()` back to
-  `window_layout`. `AuiMgr::track_docked_size` copies a docked pane's size into `BestSize` on idle
-  (wxAUI does not record a dragged sash there), so the width persists. `Plater::priv::reset_window_layout` is the model for
+  `window_layout`. An idle handler copies the docked sidebar width into `BestSize` (wxAUI does not record
+  a dragged sash there), so the width persists. `Plater::priv::reset_window_layout` is the model for
  re-establishing panes after a load: it loads the default perspective, then re-shows each plugin pane
  the perspective does not list.
 - Plugin panes: `Plater::add_dock_pane(window, name, caption, dock, size, on_close)` (window must be a
@@ -989,29 +977,13 @@ Plater (Prepare and Preview); `DesignPanel::m_aui` manages the Design tab's body
  `Destroy()`s without running `on_close`; `show_dock_pane` toggles and updates. Pane names come from
  `plugin_pane_name` (`DockPanel.cpp`), which replaces `|`, `;`, `=`, `\` — the perspective-string
  delimiters.
- Other pages: a page outside the Plater docks through its own `AuiMgr` member, since the Plater's
-  manages only the Plater. Its managed window is a body panel below the page's toolbar; a sidebar
-  takes `AuiMgr::sidebar_pane_info()`; the layout has its own app-config key, is reset from
-  `Plater::reset_window_layout`, and is saved by a `shutdown()` called from `MainFrame::shutdown`,
-  which also detaches a floating pane (Lifetime below). Where floating is disabled it forces
-  `Dock().Floatable(false)` after loading, as plugin panes do. A `LazyPage` builds its panel at 20×20
-  and lays it out only as the tab shows, so the sidebar stays hidden until the tab is first shown (Dock
-  size above). `DesignPanel` is the model
-  (`docs/HLSD/design-tab.md`). A `GLCanvas3D` beside such a sidebar gets that sidebar's collapse
-  button with `set_collapse_toolbar`; without it the canvas falls back to the Plater's button, which
-  collapses Prepare's sidebar.
 - Lifetime: no explicit `UnInit`. `m_aui_mgr` is a `Plater::priv` member, so it is destroyed in
  `~Plater`, before `~wxWindow` destroys the Plater's children (`wxWindowBase::DestroyChildren`,
  `src/common/wincmn.cpp:586-609`); a floating frame is such a child (`CreateFloatingFrame(m_frame, …)`,
  `src/aui/framemanager.cpp:3151`), so a pane still floating at that point outlives the manager [source].
-  Plugin panes are removed earlier (`MainFrame::shutdown` → `Plater::remove_dock_panes`). A handler
-  that can outlive its pane looks the pane up when it runs, as `track_docked_size` does: an idle
-  handler bound on the pane's window outlives the `DetachPane` in `DesignPanel::shutdown`. Never detach
-  a pane whose `GetPane()` reference is captured (Pane references above). `DesignPanel::shutdown` is
-  the model for a member manager: it detaches a
-  floating sidebar, which `Destroy()`s the frame into the pending-delete list, and the main frame's
-  deletion deletes pending top-level children before its own children (`~wxTopLevelWindowBase`,
-  `src/common/toplvcmn.cpp:67-93`), while the panel and its manager are still alive [source].
+  Plugin panes are removed earlier (`MainFrame::shutdown` → `Plater::remove_dock_panes`). The sidebar
+  `GetPane()` reference captured by the idle lambda is safe across `AddPane`; never `DetachPane` a pane
+  whose reference is captured.

 **Pitfalls.**
 - **Rule:** Call `Update()` once after a batch of `AddPane`/`wxAuiPaneInfo` changes.
@@ -6,9 +6,10 @@ port; what Orca's `DPIDialog`/`DPIFrame` add; the Orca dialog recipe; and the `M
 Read it before writing or reviewing any dialog, frame, close handler, `Destroy()`/`delete`, or code
 that keeps a pointer to a window across an event, a `CallAfter` or a modal loop.

-wx cites are relative to the pinned wx 3.3.2 tree (located as in `SKILL.md` §Ground truth). wx is
-built with `wxBUILD_DEBUG_LEVEL=0` and `libslic3r_gui` with `wxDEBUG_LEVEL=0`: every wx assert
-quoted below is compiled out, so misuse fails silently (dropped call, stuck loop, freed memory), never with an assert dialog. "GTK" below
+wx cites are relative to the pinned wx 3.3.2 tree (`find deps -maxdepth 5 -type d -path
+'*dep_wxWidgets-prefix/src/dep_wxWidgets'`). wx is built with `wxBUILD_DEBUG_LEVEL=0` and
+`libslic3r_gui` with `wxDEBUG_LEVEL=0`: every wx assert quoted below is compiled out, so misuse
+fails silently (dropped call, stuck loop, freed memory), never with an assert dialog. "GTK" below
 means wxGTK as Orca builds it on Linux: GTK3 by default (X11 or Wayland); GTK2 is only an opt-out.

 Contents: [Rules](#rules) · [1 Creating and parenting](#1-creating-and-parenting-windows) ·
@@ -427,8 +428,7 @@ this function does *not* show it", top-level windows only (`interface/wx/window.
 since 3.3 (`docs/changes.txt:144-146`). **[source]** MSW = `::SetForegroundWindow`, subject to the
 foreground lock — Windows may only flash the taskbar button (`src/msw/toplevel.cpp:650-655`); GTK =
 `gtk_window_present` only if shown (`src/gtk/toplevel.cpp:1301-1310`; during a deferred X11 first show it
-already counts as shown); macOS = `makeKeyAndOrderFront` only if shown (`src/osx/nonownedwnd_osx.cpp:289-295`, `src/osx/cocoa/nonownedwnd.mm:897-899`),
-which also makes a `wxPopupWindow` the key window — never `Raise()` a popup (`references/popups-menus.md` §5, §10).
+already counts as shown); macOS = `makeKeyAndOrderFront` only if shown (`src/osx/nonownedwnd_osx.cpp:289-295`, `src/osx/cocoa/nonownedwnd.mm:896-899`).

 **Enable.** `Enable(false)` on a parent disables children logically: `IsEnabled()` reflects ancestors,
 `IsThisEnabled()` the window's own flag (`interface/wx/window.h:3060-3070, 3116-3138`). **[source]** On MSW/macOS wx
@@ -14,7 +14,7 @@ Contents: [Rules](#rules) · [1 Reading the change logs](#1-reading-the-change-l
 [8 Migration done in Orca](#8-migration-already-done-in-orca)

 All `docs/`, `interface/`, `include/`, `src/`, `build/` cites are relative to the pinned wx tree
-(located as in `SKILL.md` §Ground truth), except paths
+(`find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets'`), except paths
 explicitly called Orca's (`deps/…`, Orca's `src/CMakeLists.txt`) and bare Orca file + symbol cites.

 ## Rules
@@ -198,7 +198,7 @@ change, its line, and what it means for Orca.
 | `wxAuiGenericTabArt` subclasses (also via `wxAuiMSWTabArt`) override `DrawPageTab()`/`GetPageTabSize()` instead of `DrawTab()`/`GetTabSize()`; direct `wxAuiTabArt` subclasses still work | :115-120 | none: no Orca tab art |
 | `wxAuiNotebook` page index is logical (reorder-independent); `GetPagePosition()` gives the screen position | :122-126 | none; index math under `wxAUI_NB_TAB_MOVE` is what breaks |
 | `wxListbook`/`wxChoicebook` interpret mnemonics in page titles "just as the other wx*book classes already did" | :128-130 | Orca uses neither (`BedShapeDialog` uses `wxSimplebook` + a combo); every book interprets `&` (`interface/wx/bookctrl.h:141-147`) → rule 11 |
-| `wxAUI_MGR_HINT_FADE` is not in the default `wxAuiManager` style | :132-133 | Orca's `AuiMgr` keeps the default flags (minus `wxAUI_MGR_ALLOW_FLOATING` on Wayland, `AuiMgr::init`), so the docking hint no longer fades; add the flag if wanted |
+| `wxAUI_MGR_HINT_FADE` is not in the default `wxAuiManager` style | :132-133 | Plater's `AuiMgr` keeps the default flags (minus `wxAUI_MGR_ALLOW_FLOATING` on Wayland, `Plater::priv::priv`), so the docking hint no longer fades; add the flag if wanted |
 | `wxPrintDialogData::SetAllPages(false)`/`SetSelection(false)` changed meaning | :135-137 | none |
 | `wxGetTranslation()` returns `wxString` by value | :139-142 | pitfall below |
 | `wxWindow::Raise()` no longer shows a hidden window on any port | :144-146 | pitfall below; ba867cc534 |
@@ -10,6 +10,3 @@
 # resume after `call :label`. With LF endings that offset can land wrong and the
 # label lookup fails, so keep these CRLF whatever the platform.
 *.bat text eol=crlf
-
-# OCCT BRep fixtures, kept byte for byte as OCCT wrote them.
-*.brep -text
@@ -5,6 +5,7 @@ on:
    branches:
     - main
     - release/*
+     - belt-printer
    paths:
     - 'deps/**'
     - 'src/**'
@@ -44,7 +45,7 @@ on:


  schedule:
-      - cron: '15 2 * * *' # 10:15 AM Singapore time (UTC+8), when macOS runners are least busy
+      - cron: '0 17 * * *' # run once a day at 1 AM Singapore time (UTC+8)

  workflow_dispatch: # allows for manual dispatch
    inputs:
@@ -126,7 +127,7 @@ jobs:
    if: ${{ !cancelled() && (github.event_name != 'schedule' || github.repository == 'OrcaSlicer/OrcaSlicer') }}
    uses: ./.github/workflows/build_check_cache.yml
    with:
-      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-15' }}
+      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-14' }}
      arch: ${{ matrix.arch }}
      build-deps-only: ${{ inputs.build-deps-only || false }}
      force-build: ${{ github.event_name == 'schedule' }}
@@ -137,7 +138,7 @@ jobs:
    if: ${{ !cancelled() && needs.build_macos_arch.result == 'success' && !inputs.build-deps-only && (github.event_name != 'schedule' || github.repository == 'OrcaSlicer/OrcaSlicer') }}
    uses: ./.github/workflows/build_orca.yml
    with:
-      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-15' }}
+      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-14' }}
      arch: universal
      macos-combine-only: true
    secrets: inherit
@@ -181,7 +182,7 @@ jobs:
    if: ${{ !cancelled() && success() }}
    uses: ./.github/workflows/unit_tests.yml
    with:
-      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-15' }}
+      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-14' }}
      artifact: ${{ github.sha }}-tests-macos-arm64
      test-dir: build/arm64/tests
  # Slice a two-colour cube through every shipped printer, and through every
@@ -261,6 +262,9 @@ jobs:
      date:
      ver:
      ver_pure:
+      # Belt-printer nightlies share the main nightly release but carry a `_belt`
+      # suffix so they never overwrite the main assets.
+      nightly_suffix: ${{ github.ref == 'refs/heads/belt-printer' && '_belt' || '' }}
    steps:
    - name: "Remove unneeded stuff to free disk space"
      run:
@@ -435,13 +439,13 @@ jobs:
        name: OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak
        path: '/__w/OrcaSlicer/OrcaSlicer/OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak'
    - name: Deploy Flatpak to nightly release
-      if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main'
+      if: github.repository == 'OrcaSlicer/OrcaSlicer' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/belt-printer')
      uses: WebFreak001/deploy-nightly@v3.2.0
      with:
        upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
        release_id: 137995723
        asset_path: /__w/OrcaSlicer/OrcaSlicer/OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak
-        asset_name: OrcaSlicer-Linux-flatpak_nightly_${{ matrix.variant.arch }}.flatpak
+        asset_name: OrcaSlicer-Linux-flatpak_nightly${{ env.nightly_suffix }}_${{ matrix.variant.arch }}.flatpak
        asset_content_type: application/octet-stream
        max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
    # The asset is /app (the exes link it at runtime) plus the build tree
@@ -1,198 +1,73 @@
-name: Check Cache
-
-on:
-  workflow_call:
-    inputs:
-      os:
-        required: true
-        type: string
-      arch:
-        required: false
-        type: string
-      compiler:
-        required: false
-        type: string
-        default: msvc
-      build-deps-only:
-        required: false
-        type: boolean
-      force-build:
-        required: false
-        type: boolean
-  
-# Read by scripts/ci_deps_cache.sh.
-env:
-  REPO: ${{ github.repository }}
-  WORKFLOW_REF: ${{ github.workflow_ref }}
-  BASE_REF: ${{ github.base_ref }}
-
-jobs:
-  check_cache: # determines if there is a cache and outputs variables used in caching process
-    name: Check Cache
-    # Hosted macOS runners are scarce, so their lookup runs on Linux.
-    runs-on: ${{ startsWith(inputs.os, 'macos-') && 'ubuntu-24.04' || inputs.os }}
-    outputs:
-      cache-key: ${{ steps.set_outputs.outputs.cache-key }}
-      cache-path: ${{ steps.set_outputs.outputs.cache-path }}
-      valid-cache: ${{ steps.cache_deps.outputs.cache-hit }}
-      macos-path: ${{ steps.macos_path.outputs.path }}
-      key-inputs: ${{ steps.wait_check.outputs.key-inputs }}
-      wait-for: ${{ steps.wait_check.outputs.wait-for }}
-      wait-since: ${{ steps.wait_check.outputs.wait-since }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v7
-        with:
-          lfs: 'false'
-          # The wait check compares the merge commit with its first parent.
-          fetch-depth: ${{ startsWith(inputs.os, 'macos-') && 2 || 1 }}
-          # Fetches only deps/, which the key hashes, and the wait script.
-          sparse-checkout: |
-            /deps/
-            /scripts/ci_deps_cache.sh
-          sparse-checkout-cone-mode: false
-        
-      - name: set outputs
-        id: set_outputs
-        env:
-          # Anything that changes how the tree is built belongs in the key, or a job
-          # restores one it cannot use. Linux amd64 passes no arch deliberately, so
-          # 'linux-clang' keeps the cache it already has.
-          cache-os: ${{ (runner.os == 'macOS' || startsWith(inputs.os, 'macos-')) && format('{0}-{1}', inputs.os, inputs.arch) || (runner.os == 'Windows' && format('windows-{0}-{1}', inputs.arch, inputs.compiler) || format('linux-clang{0}', inputs.arch && format('-{0}', inputs.arch) || '')) }}
-          # The Windows ARM64 deps build in build-arm64, all others under build;
-          # build_deps.yml and build_orca.yml pass the Windows directory to build_win.bat.
-          dep-folder-name: ${{ (runner.os == 'macOS' || startsWith(inputs.os, 'macos-')) && format('/{0}', inputs.arch) || (runner.os == 'Windows' && inputs.arch == 'arm64') && '-arm64/OrcaSlicer_dep' || '/OrcaSlicer_dep' }}
-          output-cmd: ${{ runner.os == 'Windows' && '$env:GITHUB_OUTPUT' || '"$GITHUB_OUTPUT"'}}
-        run: |
-          echo cache-key=${{ env.cache-os }}-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }} >> ${{ env.output-cmd }}
-          # Relative to the workspace, which differs from the build's when this job runs on Linux.
-          echo cache-path=deps/build${{ env.dep-folder-name }} >> ${{ env.output-cmd }}
-            
-      # actions/cache matches the path too, so a Linux lookup for macOS uses the
-      # workspace of a hosted macOS job.
-      - name: macOS cache path
-        id: macos_path
-        if: ${{ startsWith(inputs.os, 'macos-') }}
-        run: echo "path=/Users/runner/work/${GITHUB_REPOSITORY#*/}/${GITHUB_REPOSITORY#*/}/${{ steps.set_outputs.outputs.cache-path }}" >> "$GITHUB_OUTPUT"
-
-      - name: load cache
-        id: cache_deps
-        uses: actions/cache@v6
-        with:
-          path: ${{ steps.macos_path.outputs.path || format('{0}/{1}', github.workspace, steps.set_outputs.outputs.cache-path) }}
-          key: ${{ steps.set_outputs.outputs.cache-key }}
-          lookup-only: true
-        
-      # A pull request that misses the cache can wait for a base branch build of the same deps.
-      - name: check for a base branch build to wait for
-        id: wait_check
-        if: ${{ startsWith(inputs.os, 'macos-') && github.event_name == 'pull_request' && steps.cache_deps.outputs.cache-hit != 'true' }}
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: bash scripts/ci_deps_cache.sh check
-
-  wait_for_deps:
-    name: Wait for base branch deps
-    needs: [check_cache]
-    if: ${{ needs.check_cache.outputs.wait-for != '' }}
-    runs-on: ubuntu-24.04
-    env:
-      WAIT_MINUTES: 120
-    # Must exceed WAIT_MINUTES.
-    timeout-minutes: 130
-    # Waiting runs queue here, and only the first one holds a runner.
-    concurrency:
-      group: deps-wait-${{ github.base_ref }}-${{ needs.check_cache.outputs.cache-key }}
-      queue: max
-    outputs:
-      hit: ${{ steps.lookup.outputs.cache-hit }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v7
-        with:
-          sparse-checkout: scripts/ci_deps_cache.sh
-          sparse-checkout-cone-mode: false
-
-      - name: wait for the deps cache
-        env:
-          GH_TOKEN: ${{ github.token }}
-          KEY: ${{ needs.check_cache.outputs.cache-key }}
-          KEY_INPUTS: ${{ needs.check_cache.outputs.key-inputs }}
-          WAIT_FOR: ${{ needs.check_cache.outputs.wait-for }}
-          WAIT_SINCE: ${{ needs.check_cache.outputs.wait-since }}
-          ARCH: ${{ inputs.arch }}
-        run: bash scripts/ci_deps_cache.sh wait
-
-      - name: load cache
-        id: lookup
-        uses: actions/cache@v6
-        with:
-          path: ${{ needs.check_cache.outputs.macos-path }}
-          key: ${{ needs.check_cache.outputs.cache-key }}
-          lookup-only: true
-
-  # Hosted macOS runners are scarce, so a pull request's macOS build waits until
-  # one is free that push and nightly builds do not need. See the script.
-  macos_admission:
-    name: Wait for a macOS runner
-    needs: [check_cache, wait_for_deps]
-    if: ${{ !cancelled() && needs.check_cache.result == 'success' && startsWith(inputs.os, 'macos-') && github.event_name == 'pull_request' && !contains(github.event.pull_request.labels.*.name, 'macos-priority') }}
-    runs-on: ubuntu-24.04
-    env:
-      WAIT_MINUTES: 240
-      PRIORITY: false
-    # Must exceed WAIT_MINUTES.
-    timeout-minutes: 250
-    # One line for every arch of every pull request, and only its first job polls.
-    concurrency:
-      group: macos-admission
-      queue: max
-    steps: &macos_admission_steps
-      - name: Checkout
-        uses: actions/checkout@v7
-        with:
-          sparse-checkout: scripts/ci_macos_admission.py
-          sparse-checkout-cone-mode: false
-
-      - name: wait for a macOS runner
-        env:
-          GH_TOKEN: ${{ github.token }}
-          MACOS_RUNNER_LIMIT: ${{ vars.MACOS_RUNNER_LIMIT }}
-        # -u, or the log shows nothing until the wait ends.
-        run: python3 -u scripts/ci_macos_admission.py
-
-  # The macos-priority label, when the run starts, puts a pull request in its own
-  # line, which the normal one yields to. The names are fixed, because a skipped
-  # job is listed under its unevaluated name, and the script matches both.
-  macos_admission_priority:
-    name: Wait for a macOS runner (priority)
-    needs: [check_cache, wait_for_deps]
-    if: ${{ !cancelled() && needs.check_cache.result == 'success' && startsWith(inputs.os, 'macos-') && github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'macos-priority') }}
-    runs-on: ubuntu-24.04
-    env:
-      WAIT_MINUTES: 240
-      PRIORITY: true
-    # Must exceed WAIT_MINUTES.
-    timeout-minutes: 250
-    concurrency:
-      group: macos-admission-priority
-      queue: max
-    steps: *macos_admission_steps
-
-  build_deps: # call next step
-    name: Build Deps
-    needs: [check_cache, wait_for_deps, macos_admission, macos_admission_priority]
-    # A failed wait counts as no cache, so the deps are built here. A failed
-    # admission still builds rather than skip macOS.
-    if: ${{ !cancelled() && needs.check_cache.result == 'success' }}
-    uses: ./.github/workflows/build_deps.yml
-    with:
-      cache-key: ${{ needs.check_cache.outputs.cache-key }}
-      cache-path: ${{ needs.check_cache.outputs.cache-path }}
-      valid-cache: ${{ needs.check_cache.outputs.valid-cache == 'true' || needs.wait_for_deps.outputs.hit == 'true' }}
-      os: ${{ inputs.os }}
-      arch: ${{ inputs.arch }}
-      compiler: ${{ inputs.compiler }}
-      build-deps-only: ${{ inputs.build-deps-only }}
-      force-build: ${{ inputs.force-build }}
-    secrets: inherit
+name: Check Cache
+
+on:
+  workflow_call:
+    inputs:
+      os:
+        required: true
+        type: string
+      arch:
+        required: false
+        type: string
+      compiler:
+        required: false
+        type: string
+        default: msvc
+      build-deps-only:
+        required: false
+        type: boolean
+      force-build:
+        required: false
+        type: boolean
+  
+jobs:
+  check_cache: # determines if there is a cache and outputs variables used in caching process
+    name: Check Cache
+    runs-on: ${{ inputs.os }}
+    outputs:
+      cache-key: ${{ steps.set_outputs.outputs.cache-key }}
+      cache-path: ${{ steps.set_outputs.outputs.cache-path }}
+      valid-cache: ${{ steps.cache_deps.outputs.cache-hit }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+        with:
+          lfs: 'false'
+        
+      - name: set outputs
+        id: set_outputs
+        env:
+          # Anything that changes how the tree is built belongs in the key, or a job
+          # restores one it cannot use. Linux amd64 passes no arch deliberately, so
+          # 'linux-clang' keeps the cache it already has.
+          cache-os: ${{ runner.os == 'macOS' && format('macos-{0}', inputs.arch) || (runner.os == 'Windows' && format('windows-{0}-{1}', inputs.arch, inputs.compiler) || format('linux-clang{0}', inputs.arch && format('-{0}', inputs.arch) || '')) }}
+          # The Windows ARM64 deps build in build-arm64, all others under build;
+          # build_deps.yml and build_orca.yml pass the Windows directory to build_win.bat.
+          dep-folder-name: ${{ runner.os == 'macOS' && format('/{0}', inputs.arch) || (runner.os == 'Windows' && inputs.arch == 'arm64') && '-arm64/OrcaSlicer_dep' || '/OrcaSlicer_dep' }}
+          output-cmd: ${{ runner.os == 'Windows' && '$env:GITHUB_OUTPUT' || '"$GITHUB_OUTPUT"'}}
+        run: |
+          echo cache-key=${{ env.cache-os }}-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }} >> ${{ env.output-cmd }}
+          echo cache-path=${{ github.workspace }}/deps/build${{ env.dep-folder-name }} >> ${{ env.output-cmd }}
+            
+      - name: load cache
+        id: cache_deps
+        uses: actions/cache@v6
+        with:
+          path: ${{ steps.set_outputs.outputs.cache-path }}
+          key: ${{ steps.set_outputs.outputs.cache-key }}
+          lookup-only: true
+        
+  build_deps: # call next step
+    name: Build Deps
+    needs: [check_cache]
+    uses: ./.github/workflows/build_deps.yml
+    with:
+      cache-key: ${{ needs.check_cache.outputs.cache-key }}
+      cache-path: ${{ needs.check_cache.outputs.cache-path }}
+      valid-cache: ${{ needs.check_cache.outputs.valid-cache == 'true' }}
+      os: ${{ inputs.os }}
+      arch: ${{ inputs.arch }}
+      compiler: ${{ inputs.compiler }}
+      build-deps-only: ${{ inputs.build-deps-only }}
+      force-build: ${{ inputs.force-build }}
+    secrets: inherit
@@ -45,15 +45,32 @@ jobs:
      - name: load cached deps
        uses: actions/cache@v6
        with:
-          path: ${{ github.workspace }}/${{ inputs.cache-path }}
+          path: ${{ inputs.cache-path }}
          key: ${{ inputs.cache-key }}

      - uses: lukka/get-cmake@latest
+        # The windows-11-arm runner needs CMake <= 3.31 (handled in the next step).
+        if: ${{ !(runner.os == 'Windows' && inputs.arch == 'arm64') }}
        with:
          cmakeVersion: "~4.3.0"  # use most recent 4.3.x version
          useLocalCache: true         # <--= Use the local cache (default is 'false').
          useCloudCache: true

+      - name: Install CMake 3.31.x (Windows ARM64)
+        # windows-11-arm ships CMake 4.x, which removed pre-3.5 policy
+        # compatibility AND has incomplete ASM_ARMASM linker modules
+        # (breaks Boost.Context on ARM64). Pin to the last 3.x release.
+        if: runner.os == 'Windows' && inputs.arch == 'arm64'
+        shell: pwsh
+        run: |
+          $ver = "3.31.6"
+          $url = "https://github.com/Kitware/CMake/releases/download/v$ver/cmake-$ver-windows-arm64.zip"
+          Invoke-WebRequest -Uri $url -OutFile "$env:RUNNER_TEMP\cmake.zip"
+          Expand-Archive -Path "$env:RUNNER_TEMP\cmake.zip" -DestinationPath "$env:RUNNER_TEMP\cmake" -Force
+          $cmakeBin = "$env:RUNNER_TEMP\cmake\cmake-$ver-windows-arm64\bin"
+          if (-not (Test-Path "$cmakeBin\cmake.exe")) { throw "cmake.exe not found at $cmakeBin" }
+          Add-Content -Path $env:GITHUB_PATH -Value $cmakeBin
+
      - name: setup dev on Windows
        if: runner.os == 'Windows'
        uses: microsoft/setup-msbuild@v3
@@ -122,7 +139,7 @@ jobs:
              choco install strawberryperl
            }
            # cache-path is the install directory inside the deps build directory.
-            $deps = (Split-Path "${{ github.workspace }}/${{ inputs.cache-path }}").Replace('\', '/')
+            $deps = (Split-Path "${{ inputs.cache-path }}").Replace('\', '/')
            # -l compiles with Visual Studio's clang-cl and -x builds with Ninja; --msvc --msbuild is cl under the Visual Studio generator.
            $flags = if ("${{ inputs.compiler }}" -eq "clang") { "-l", "-x" } else { "--msvc", "--msbuild" }
            .\build_win.bat -d --arch ${{ inputs.arch }} --deps-dir $deps @flags
@@ -33,6 +33,11 @@ jobs:
      ubuntu-ver: '2404'
      ubuntu-ver-str: '_Ubuntu2404'
      ORCA_UPDATER_SIG_KEY: ${{ secrets.ORCA_UPDATER_SIG_KEY }}
+      # Branches whose builds are published to the nightly release. The
+      # belt-printer branch ships alongside main but its assets carry a `_belt`
+      # suffix (nightly_suffix) so they never overwrite the main nightly assets.
+      deploy_nightly: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/belt-printer' }}
+      nightly_suffix: ${{ github.ref == 'refs/heads/belt-printer' && '_belt' || '' }}

    steps:
      - name: Checkout
@@ -44,16 +49,33 @@ jobs:
        if: ${{ !(runner.os == 'macOS' && inputs.macos-combine-only) }}
        uses: actions/cache@v6
        with:
-          path: ${{ github.workspace }}/${{ inputs.cache-path }}
+          path: ${{ inputs.cache-path }}
          key: ${{ inputs.cache-key }}
          fail-on-cache-miss: true

      - uses: lukka/get-cmake@latest
+        # The windows-11-arm runner needs CMake <= 3.31 (handled in the next step).
+        if: ${{ !(runner.os == 'Windows' && inputs.arch == 'arm64') }}
        with:
          cmakeVersion: "~4.3.0"  # use most recent 4.3.x version
          useLocalCache: true         # <--= Use the local cache (default is 'false').
          useCloudCache: true

+      - name: Install CMake 3.31.x (Windows ARM64)
+        # windows-11-arm ships CMake 4.x, which removed pre-3.5 policy
+        # compatibility AND has incomplete ASM_ARMASM linker modules
+        # (breaks Boost.Context on ARM64). Pin to the last 3.x release.
+        if: runner.os == 'Windows' && inputs.arch == 'arm64'
+        shell: pwsh
+        run: |
+          $ver = "3.31.6"
+          $url = "https://github.com/Kitware/CMake/releases/download/v$ver/cmake-$ver-windows-arm64.zip"
+          Invoke-WebRequest -Uri $url -OutFile "$env:RUNNER_TEMP\cmake.zip"
+          Expand-Archive -Path "$env:RUNNER_TEMP\cmake.zip" -DestinationPath "$env:RUNNER_TEMP\cmake" -Force
+          $cmakeBin = "$env:RUNNER_TEMP\cmake\cmake-$ver-windows-arm64\bin"
+          if (-not (Test-Path "$cmakeBin\cmake.exe")) { throw "cmake.exe not found at $cmakeBin" }
+          Add-Content -Path $env:GITHUB_PATH -Value $cmakeBin
+
      # Compiler cache. Pushes save it, so main keeps it warm; pull requests
      # restore it and discard what they compiled. Objects are keyed on the
      # preprocessed source, the compiler and the flags, so a leg only ever
@@ -178,19 +200,10 @@ jobs:
      - name: Free disk space
        if: runner.os == 'macOS' && !inputs.macos-combine-only && !vars.SELF_HOSTED
        run: |
-          df -hI /
-          # Deleting the unused Xcodes takes minutes, so only do it when the
-          # build might not fit. A cold build uses under 4 GiB after this step.
-          avail_gib=$(df -g / | awk 'NR == 2 { print $4 }')
-          if [ "$avail_gib" -ge 15 ]; then
-            echo "$avail_gib GiB free, enough for the build"
-            exit 0
-          fi
-          # Keep only the selected Xcode
-          xcode=$(basename "$(cd "$(xcode-select -p)/../.." && pwd -P)")
-          sudo find /Applications -maxdepth 1 -type d -name "Xcode_*.app" ! -name "$xcode" -exec rm -rf {} +
+          df -hI /dev/disk3s1s1
+          sudo find /Applications -maxdepth 1 -type d -name "Xcode_*.app" ! -name "Xcode_15.4.app" -exec rm -rf {} +
          sudo rm -rf ~/Library/Developer/CoreSimulator/Caches/*
-          df -hI /
+          df -hI /dev/disk3s1s1

      - name: Build slicer mac
        if: runner.os == 'macOS' && !inputs.macos-combine-only
@@ -262,8 +275,7 @@ jobs:

 # Thanks to RaySajuuk, it's working now
      - name: Sign app and notary
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release/')) && runner.os == 'macOS' && inputs.macos-combine-only
-        timeout-minutes: 30
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/belt-printer' || startsWith(github.ref, 'refs/heads/release/')) && runner.os == 'macOS' && inputs.macos-combine-only
        working-directory: ${{ github.workspace }}
        env:
          BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}
@@ -350,7 +362,7 @@ jobs:
          fi

      - name: Create DMG without notary
-        if: github.ref != 'refs/heads/main' && runner.os == 'macOS' && inputs.macos-combine-only
+        if: github.ref != 'refs/heads/main' && github.ref != 'refs/heads/belt-printer' && runner.os == 'macOS' && inputs.macos-combine-only
        working-directory: ${{ github.workspace }}
        run: |
          # Load the `retry` helper (retries flaky commands such as `hdiutil create`).
@@ -396,13 +408,13 @@ jobs:
          if-no-files-found: ignore

      - name: Deploy Mac release
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'macOS' && inputs.macos-combine-only && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && env.deploy_nightly == 'true' && runner.os == 'macOS' && inputs.macos-combine-only && !vars.SELF_HOSTED
        uses: WebFreak001/deploy-nightly@v3.2.0
        with:
          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
          release_id: 137995723
          asset_path: ${{ github.workspace }}/OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
-          asset_name: OrcaSlicer_Mac_universal_nightly.dmg
+          asset_name: OrcaSlicer_Mac_universal_nightly${{ env.nightly_suffix }}.dmg
          asset_content_type: application/octet-stream
          max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted

@@ -467,7 +479,7 @@ jobs:
        # --tests builds the unit tests too; the unit_tests_windows_* jobs run them.
        run: |
          # cache-path is the install directory inside the deps build directory.
-          $deps = (Split-Path "${{ github.workspace }}/${{ inputs.cache-path }}").Replace('\', '/')
+          $deps = (Split-Path "${{ inputs.cache-path }}").Replace('\', '/')
          # -l compiles with Visual Studio's clang-cl and -x builds with Ninja; --msvc --msbuild is cl under the Visual Studio generator.
          $flags = if ("${{ inputs.compiler }}" -eq "clang") { "-l", "-x" } else { "--msvc", "--msbuild" }
          .\build_win.bat -s --tests -i --arch ${{ inputs.arch }} --build-dir $env:BUILD_DIR --deps-dir $deps @flags
@@ -545,24 +557,24 @@ jobs:
          path: ${{ github.workspace }}/build/src/Release/OrcaSlicer_profile_validator.exe

      - name: Deploy Windows release portable
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && env.deploy_nightly == 'true' && runner.os == 'Windows' && !vars.SELF_HOSTED
        uses: WebFreak001/deploy-nightly@v3.2.0
        with:
          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
          release_id: 137995723
          asset_path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_${{ env.ver }}${{ env.ARCH_SUFFIX }}_portable.zip
-          asset_name: OrcaSlicer_Windows${{ env.ARCH_SUFFIX }}_nightly_portable.zip
+          asset_name: OrcaSlicer_Windows${{ env.ARCH_SUFFIX }}_nightly${{ env.nightly_suffix }}_portable.zip
          asset_content_type: application/x-zip-compressed
          max_releases: 1

      - name: Deploy Windows release installer
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && env.deploy_nightly == 'true' && runner.os == 'Windows' && !vars.SELF_HOSTED
        uses: WebFreak001/deploy-nightly@v3.2.0
        with:
          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
          release_id: 137995723
          asset_path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_Installer_${{ env.ver }}${{ env.ARCH_SUFFIX }}.exe
-          asset_name: OrcaSlicer_Windows_Installer${{ env.ARCH_SUFFIX }}_nightly.exe
+          asset_name: OrcaSlicer_Windows_Installer${{ env.ARCH_SUFFIX }}_nightly${{ env.nightly_suffix }}.exe
          asset_content_type: application/x-msdownload
          max_releases: 1

@@ -703,20 +715,23 @@ jobs:
          path: './build/src/dev-utils/Release/generate_system_cache'

      - name: Deploy Ubuntu release
-        if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED }}
+        if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && env.deploy_nightly == 'true' && runner.os == 'Linux' && !vars.SELF_HOSTED }}
        uses: WebFreak001/deploy-nightly@v3.2.0
        with:
          upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
          release_id: 137995723
          asset_path: ./build/OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_${{ env.ver }}.AppImage
-          asset_name: OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_nightly.AppImage
+          asset_name: OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_nightly${{ env.nightly_suffix }}.AppImage
          asset_content_type: application/octet-stream
          max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
      - name: Deploy Ubuntu release
        if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED && inputs.arch != 'aarch64' }}
-        run: |
-          git -c user.name="${GITHUB_ACTOR}" -c user.email="${GITHUB_ACTOR}@users.noreply.github.com" tag -f -a nightly-builds "${GITHUB_SHA}" -m nightly-builds
-          git push -f origin refs/tags/nightly-builds
+        uses: rickstaa/action-create-tag@v1
+        with:
+          tag: "nightly-builds"
+          tag_exists_error: false
+          force_push_tag: true
+          message: "nightly-builds"

      - name: Deploy Ubuntu OrcaSlicer_profile_validator release
        if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED && inputs.arch != 'aarch64' }}
@@ -74,26 +74,12 @@ jobs:
          set +e
          ./OrcaSlicer_profile_validator -p ${{ github.workspace }}/resources/profiles -l 2 2>&1 | tee ${{ runner.temp }}/validate_system.log
          exit ${PIPESTATUS[0]}
-      # The validator above is the nightly build of main, so it cannot slice profiles that use
-      # settings a PR adds to the engine: it reports their placeholders as undefined. A PR that
-      # changes src/ also runs Build all, whose Slice check runs this same sweep with the
-      # validator built from the PR, so the sweep below only runs for the other PRs.
-      - name: Detect engine changes
-        id: engine_changes
-        if: ${{ github.event_name == 'pull_request' }}
-        run: |
-          base=${{ github.event.pull_request.base.sha }}
-          if git fetch --no-tags --depth=1 origin "$base" && ! git diff --quiet "$base" HEAD -- src/; then
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-            echo "::notice::This PR changes src/, so Build all's Slice check slices the profiles with the PR-built validator."
-          fi
      # Slice a two-colour cube through every printer, and through every system process/filament whose
      # templates no printer's own slice reaches, so every custom g-code and filename_format shipped is
      # expanded (names in {if} branches not taken included) - catches undefined-placeholder /
      # invalid-flow bugs the static checks above cannot see.
      - name: validate slice (expand custom g-code)
        id: validate_slice
-        if: ${{ steps.engine_changes.outputs.changed != 'true' }}
        continue-on-error: true
        run: |
          set +e
@@ -1,89 +0,0 @@
-name: clang-tidy
-
-# Runs clang-tidy, with the checks in .clang-tidy, over the C++ lines a pull
-# request changes (scripts/clang_tidy_diff.py). The compile database is
-# configured without the precompiled header, so code that only builds because
-# the PCH supplied an include fails here.
-#
-# No paths filter: the job is a required check, and a workflow skipped by a
-# paths filter leaves a required check pending forever. A PR with no C++
-# changes finishes after the first step.
-on:
-  pull_request:
-    branches:
-      - main
-      - release/*
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
-  cancel-in-progress: true
-
-jobs:
-  clang_tidy:
-    # Branch protection requires this check by name. Renaming the job disables
-    # that gate.
-    name: clang-tidy
-    runs-on: ${{ vars.SELF_HOSTED && 'orca-lnx-server' || 'ubuntu-24.04' }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v7
-        with:
-          lfs: 'false'
-          # The PR merge commit plus its first parent, the base it is diffed against.
-          fetch-depth: 2
-
-      - name: Look for changed C++ files
-        id: changes
-        run: |
-          if git -c core.quotePath=false diff --name-only HEAD^1 -- src tests | grep -qE '\.(cpp|cc|cxx|hpp|h|hxx)$'; then
-            echo "cpp=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "No C++ changes under src/ or tests/."
-          fi
-
-      # Parsing needs the dependency headers, not a build of this PR's deps/, so
-      # a PR that changes deps/ falls back to the newest cache main has.
-      - name: Restore cached deps
-        if: steps.changes.outputs.cpp == 'true'
-        uses: actions/cache/restore@v6
-        with:
-          path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
-          key: linux-clang-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }}
-          restore-keys: linux-clang-cache-orcaslicer_deps-build-
-          fail-on-cache-miss: true
-
-      - name: Apt-Install Dependencies
-        if: steps.changes.outputs.cpp == 'true' && !vars.SELF_HOSTED
-        uses: ./.github/actions/apt-install-deps
-
-      - name: Install clang-tidy
-        if: steps.changes.outputs.cpp == 'true'
-        run: |
-          python3 -m venv "$RUNNER_TEMP/clang-tidy"
-          "$RUNNER_TEMP/clang-tidy/bin/pip" install --quiet -r scripts/clang_tidy_requirements.txt
-
-      # DEP_BUILD_DIR is named outright: CMake would otherwise derive it from the build
-      # directory's name and look for the dependencies in deps/build-tidy.
-      - name: Configure without the precompiled header
-        if: steps.changes.outputs.cpp == 'true'
-        run: >
-          cmake -S . -B build-tidy -G Ninja
-          -DCMAKE_BUILD_TYPE=Release
-          -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
-          -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
-          -DSLIC3R_PCH=OFF -DORCA_TOOLS=ON -DBUILD_TESTS=ON
-          -DDEP_BUILD_DIR=${{ github.workspace }}/deps/build
-
-      # The one header the build generates rather than the configure.
-      - name: Generate git_commit_hash.h
-        if: steps.changes.outputs.cpp == 'true'
-        run: cmake --build build-tidy --target git_commit_hash_header
-
-      - name: Run clang-tidy on the changed lines
-        if: steps.changes.outputs.cpp == 'true'
-        run: >
-          python3 scripts/clang_tidy_diff.py -p build-tidy --base HEAD^1
-          --clang-tidy "$RUNNER_TEMP/clang-tidy/bin/clang-tidy" -j "$(nproc)"
@@ -1,28 +0,0 @@
-# Reports the newest push build of main that was not cancelled, for the README badge.
-name: Main build status
-
-on:
-  workflow_run:
-    workflows: ["Build all"]
-    types: [completed]
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  actions: read
-
-jobs:
-  status:
-    if: github.repository == 'OrcaSlicer/OrcaSlicer'
-    runs-on: ubuntu-latest
-    steps:
-      - env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          for attempt in 1 2 3; do
-            conclusion=$(gh api "repos/${{ github.repository }}/actions/workflows/build_all.yml/runs?branch=main&event=push&status=completed&per_page=100" \
-              --jq '[.workflow_runs[] | select(.conclusion != "cancelled")][0].conclusion') && break
-            sleep 10
-          done
-          echo "Latest finished push build of main: $conclusion"
-          [ "$conclusion" = success ]
@@ -156,7 +156,7 @@ jobs:
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends \
-            libopengl0 libgl1 libegl1 libwebkit2gtk-4.1-0
+            libopengl0 libglu1-mesa libgl1 libegl1 libwebkit2gtk-4.1-0

      - uses: actions/setup-python@v6
        with:
@@ -224,7 +224,7 @@ jobs:
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends \
            xvfb xdotool imagemagick openbox mesa-utils \
-            libopengl0 libgl1 libegl1 libwebkit2gtk-4.1-0
+            libopengl0 libglu1-mesa libgl1 libegl1 libwebkit2gtk-4.1-0

      - name: Run the parity harness
        run: |
@@ -303,7 +303,7 @@ jobs:
      - name: Mint profiles-repo token
        id: token
        if: steps.vendors.outputs.vendors != ''
-        uses: actions/create-github-app-token@v3
+        uses: actions/create-github-app-token@v1
        with:
          app-id: ${{ secrets.PROFILES_APP_ID }}
          private-key: ${{ secrets.PROFILES_APP_PRIVATE_KEY }}
@@ -96,7 +96,7 @@ jobs:
      issues: write
    runs-on: ubuntu-latest
    steps:
-      - name: Auto-label localization changes and remind contributors about the glossary
+      - name: Auto-label and remind about the localization glossary
        uses: actions/github-script@v9
        with:
          script: |
@@ -106,37 +106,37 @@ jobs:

            const pr = context.payload.pull_request;

-            // Mirrors the `localization/**` paths filter in check_locale.yml
+            // List changed files once (mirrors the `localization/**` paths filter in check_locale.yml)
            const files = await github.paginate(github.rest.pulls.listFiles, {
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: pr.number,
              per_page: 100
            });
-            if (!files.some((file) => file.filename.startsWith('localization/'))) {
-              core.info('No localization changes detected; skipping Localization label.');
-              return;
-            }
+            const touchesLocalization = files.some((file) => file.filename.startsWith('localization/'));
+            const onlyPoFiles = files.length > 0 && files.every((file) => file.filename.endsWith('.po'));

-            try {
-              await github.rest.issues.addLabels({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: pr.number,
-                labels: ['Localization']
-              });
-              core.info('Applied Localization label.');
-            } catch (error) {
-              if (isPermissionDenied(error)) {
-                core.warning('Cannot add Localization label because token cannot write.');
-              } else {
-                throw error;
+            // If the PR changes only .po files, automatically apply the Localization label
+            if (onlyPoFiles) {
+              try {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: pr.number,
+                  labels: ['Localization']
+                });
+                core.info('Applied Localization label (PR changes only .po files).');
+              } catch (error) {
+                if (isPermissionDenied(error)) {
+                  core.warning('Cannot add Localization label because token cannot write.');
+                } else {
+                  throw error;
+                }
              }
            }

-            // Collaborators know the glossary; only remind outside contributors
-            if (['COLLABORATOR', 'OWNER', 'MEMBER'].includes(pr.author_association)) {
-              core.info('Author is a collaborator; skipping glossary reminder.');
+            if (!touchesLocalization) {
+              core.info('No localization changes detected; skipping glossary reminder.');
              return;
            }

@@ -44,6 +44,14 @@ jobs:
        uses: actions/download-artifact@v8
        with:
          name: ${{ inputs.artifact }}
+      # run_unit_tests.sh installs the plugin tests' numpy with the uv the build stages
+      # beside them; the Windows arm64 build bundles none, so put one on PATH there.
+      - name: Install uv
+        if: runner.os == 'Windows' && runner.arch == 'ARM64'
+        uses: astral-sh/setup-uv@v10.2.0
+        with:
+          version: "0.11.21"  # ORCA_UV_VERSION in CMakeLists.txt
+          enable-cache: false
      - uses: lukka/get-cmake@latest
        with:
          cmakeVersion: "~4.3.0"  # use most recent 4.3.x version
@@ -13,7 +13,7 @@ jobs:
        uses: actions/checkout@v7

      - name: Setup Python
-        uses: actions/setup-python@v7
+        uses: actions/setup-python@v6
        with:
          python-version: '3.12'

@@ -4,17 +4,15 @@ OrcaSlicer — open-source C++17 3D slicer. wxWidgets GUI, CMake build system.

 ## Build Commands

-Build the Release configuration unless asked otherwise.
-
 ```bash
 # macOS
-cmake --build build/arm64 --config Release --target all --
+cmake --build build/arm64 --config RelWithDebInfo --target all --

 # Linux
-cmake --build build --config Release --target all --
+cmake --build build --config RelWithDebInfo --target all --

-# Windows
-cmake --build . --config Release --target ALL_BUILD -- -m
+# Windows (replace %build_type% with Debug/Release/RelWithDebInfo)
+cmake --build . --config %build_type% --target ALL_BUILD -- -m
 ```

 ## Testing
@@ -38,7 +36,6 @@ ctest --test-dir ./tests/fff_print -C Release

 - C++17, selective C++20. PascalCase classes, snake_case functions/variables
 - `#pragma once` for headers. Smart pointers and RAII preferred
- Include what you use: include the header for every symbol a file uses, and keep headers compilable on their own. Never rely on the precompiled header or a transitive include. The `clang-tidy` CI job enforces this on changed lines; run the same check locally with `scripts/run_clang_tidy.sh` (`scripts\run_clang_tidy.ps1` on Windows), which sets up everything it needs
 - Parallelization via TBB — be mindful of shared state
 - Always use `SetSizerAndFit(sizer)` instead of `SetSizer(sizer)` on top level window. Unless `SetSizer` must be called before the full layout is built, call `sizer->SetSizeHints(window)` afterwards in this case.

@@ -92,7 +89,6 @@ See the [Localization guide](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/
 - Plural entries: read `nplurals` from the catalog's `Plural-Forms` header (it is **not** always 2 — ja/ko/zh/th/vi use 1, ru/cs/pl/lt use 3, uk uses 4). Each form must be genuinely inflected for its quantity; repeating one sentence across all forms is a bug in Slavic/Baltic languages, though it is correct for Turkish and Hungarian.
 - An entry whose `msgstr` equals its `msgid` is untranslated even though it is not empty; a plural entry with any empty form is likewise incomplete.
 - Mark machine-produced translations with an `# AI Translated` translator comment. Don't add it to a human translation you didn't actually rewrite.
- When you can't be sure of a machine translation's meaning or UI wording, also add `# Needs human review: <what to check>`. Never use `fuzzy` for this — fuzzy entries are hidden from users.
 - Don't reflow or re-wrap unrelated entries — keep the diff limited to the strings you changed.

 ### Verifying
@@ -135,7 +135,6 @@ set(ORCA_UV_SHA256_aarch64-apple-darwin      "1f921d491ba5ffeea774eb04d6681ecee3
 set(ORCA_UV_SHA256_x86_64-apple-darwin       "f3c8e5708a84b920c18b691214d54d2b0da6b984789caae95d47c95120cb7765")
 set(ORCA_UV_SHA256_aarch64-unknown-linux-gnu "88e800834007cc5efd4675f166eb2a51e7e3ad19876d85fa8805a6fb5c922397")
 set(ORCA_UV_SHA256_x86_64-unknown-linux-gnu  "8c88519b0ef0af9801fcdee419bbb12116bd9e6b18e162ae093c932d8b264050")
-set(ORCA_UV_SHA256_aarch64-pc-windows-msvc   "74e443f8004022dde57a1bd0d10c097830f9ea8feb4ec927db52cd5d805c2f48")
 set(ORCA_UV_SHA256_x86_64-pc-windows-msvc    "ace861f360c6de2babedc1607d0f454b6b09a820dbc8182dc15af927e4df9589")

 # Version-scoped cache dir so a version bump invalidates the cached binary.
@@ -174,10 +173,7 @@ if(NOT ORCA_BUNDLED_UV_EXECUTABLE)
                set(ORCA_UV_ARCH "x86_64-unknown-linux-gnu")
            endif()
        elseif(_orca_uv_proc MATCHES "aarch64|arm64|ARM64")
-            if(WIN32)
-                set(ORCA_UV_ARCH "aarch64-pc-windows-msvc")
-                set(ORCA_UV_EXT "zip")
-            elseif(APPLE)
+            if(APPLE)
                set(ORCA_UV_ARCH "aarch64-apple-darwin")
            else()
                set(ORCA_UV_ARCH "aarch64-unknown-linux-gnu")
@@ -823,9 +819,7 @@ if(SLIC3R_STATIC)
    set(TBB_STATIC 1)
 endif()
 set(TBB_DEBUG 1)
-if ("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo" OR MSVC)
-    set(CMAKE_MAP_IMPORTED_CONFIG_RELWITHDEBINFO RelWithDebInfo Release "")
-endif()
+set(CMAKE_MAP_IMPORTED_CONFIG_RELWITHDEBINFO RelWithDebInfo Release "")
 find_package(TBB REQUIRED)
 # include_directories(SYSTEM ${TBB_INCLUDE_DIRS})
 # add_definitions(${TBB_DEFINITIONS})
@@ -1084,10 +1078,10 @@ endif ()

 find_path(SPNAV_INCLUDE_DIR spnav.h)
 if (SPNAV_INCLUDE_DIR)
-    find_library(SPNAV_LIB NAMES libspnav.a spnav)
+    find_library(SPNAV_LIB NAMES libspnav.a) # Force linking libspnav statically
    if (SPNAV_LIB)
        add_definitions(-DHAVE_SPNAV)
-        message(STATUS "SPNAV library found: ${SPNAV_LIB}")
+        message(STATUS "SPNAV library found")
    else()
        message(STATUS "SPNAV library NOT found, Spacenavd not supported")
    endif()
@@ -1131,8 +1125,7 @@ function(orcaslicer_copy_dlls target config postfix output_dlls)
    if (NOT OCCT_LIBS)
        message(FATAL_ERROR "OCCT_LIBS is not set; libslic3r must be configured first.")
    endif ()
-    string(TOUPPER "${config}" _config_upper)
-    set(_occt_bin "${OCCT_BIN_DIR_${_config_upper}}")
+    set(_occt_bin "${CMAKE_PREFIX_PATH}/bin/occt")
    set(_occt_dlls "")
    set(_occt_staged "")
    set(_missing_occt "")
@@ -1308,14 +1301,6 @@ if (WIN32)
    endif()
    set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
    include(InstallRequiredSystemLibraries)
-    # A missing MSVC runtime is an error because an installer without it cannot start on a clean machine.
-    set(_orca_runtime_names ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS})
-    list(TRANSFORM _orca_runtime_names REPLACE "^.*/" "")
-    if (MSVC AND (NOT "msvcp140.dll" IN_LIST _orca_runtime_names OR NOT "vcruntime140.dll" IN_LIST _orca_runtime_names))
-        set(_orca_runtime_error "CMake ${CMAKE_VERSION} did not find msvcp140.dll and vcruntime140.dll for MSVC ${MSVC_VERSION}. Update CMake to a release that supports this Visual Studio.")
-        message(WARNING "${_orca_runtime_error}")
-        install(CODE "message(FATAL_ERROR \"${_orca_runtime_error}\")")
-    endif ()
    install (PROGRAMS ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS} DESTINATION ".")
 elseif (SLIC3R_FHS)
    # CMAKE_INSTALL_FULL_DATAROOTDIR: read-only architecture-independent data root (share)
@@ -6,7 +6,7 @@

 <a href="https://trendshift.io/repositories/15552" target="_blank"><img src="https://trendshift.io/api/badge/repositories/15552" alt="OrcaSlicer%2FOrcaSlicer | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

-[![GitHub Repo stars](https://img.shields.io/github/stars/OrcaSlicer/OrcaSlicer)](https://github.com/OrcaSlicer/OrcaSlicer/stargazers) [![Build all](https://img.shields.io/github/actions/workflow/status/OrcaSlicer/OrcaSlicer/main_build_status.yml?label=Build%20all)](https://github.com/OrcaSlicer/OrcaSlicer/actions/workflows/build_all.yml)
+[![GitHub Repo stars](https://img.shields.io/github/stars/OrcaSlicer/OrcaSlicer)](https://github.com/OrcaSlicer/OrcaSlicer/stargazers) [![Build all](https://github.com/OrcaSlicer/OrcaSlicer/actions/workflows/build_all.yml/badge.svg?branch=main)](https://github.com/OrcaSlicer/OrcaSlicer/actions/workflows/build_all.yml)

 OrcaSlicer: an open source Next-Gen Slicing Software for Precision 3D Prints.  
 Optimize your prints with ultra-fast slicing, intelligent support generation, and seamless printer compatibility—engineered for perfection.
@@ -68,10 +68,6 @@ If you come across any of these in search results, please <b>report them</b> as
  Regular updates fueled by continuous community contributions.
 - **Wide Printer Compatibility**  
  Supports a broad range of printers: Bambu Lab, Prusa, Creality, Voron, and more.
- **[Belt Printer Support](https://www.orcaslicer.com/wiki/belt_printing)**  
-  Slice for belt / conveyor (infinite-Z) printers, with belt-aware supports and a tilted-bed preview. Contributed by [Joseph Robertson (@HarrierPigeon)](https://github.com/HarrierPigeon).
- **[IDEX/IQEX Parallel Printing Support](https://www.orcaslicer.com/wiki/idex_iqex_parallel_printing)**  
-  Print copies or mirror images of a part on every carriage of an IDEX or IQEX printer at once, with the mode chosen per plate and nozzle clearance zones shown on the bed. Contributed by [Clifford (@cgarwood82)](https://github.com/cgarwood82).
 - Additional features can be found in the [change notes](https://github.com/OrcaSlicer/OrcaSlicer/releases/).

 # Wiki
@@ -93,6 +89,17 @@ Visit our GitHub Releases page for the latest stable version of OrcaSlicer, reco
 🌙 **[Download the Latest Nightly Build](https://github.com/OrcaSlicer/OrcaSlicer/releases/tag/nightly-builds)**  
 Explore the latest developments in OrcaSlicer with our nightly builds. Feedback on these versions is highly appreciated.

+### Belt Printer Builds
+
+The [nightly release](https://github.com/OrcaSlicer/OrcaSlicer/releases/tag/nightly-builds) ships **two parallel builds**: the standard build and a belt-printer build. Both are attached to the same release — tell them apart by the filename suffix:
+
+- **Standard** — no suffix (e.g. `OrcaSlicer_Windows_Installer_x64_nightly.exe`)
+- **Belt** — `_belt` suffix (e.g. `OrcaSlicer_Windows_Installer_x64_nightly_belt.exe`)
+
+The `_belt` builds add **experimental support for belt / conveyor (infinite-Z) printers**, where the model is sliced against a tilted belt surface instead of a flat horizontal bed. They include ready-to-use belt printer profiles, the full belt slicing pipeline (mesh rotation and G-code transforms), belt-aware support generation, and a tilted-bed preview.
+
+> ⚠️ Belt printer support is under active development and is **not yet merged into `main`** — it currently ships only in these parallel `_belt` builds, produced from the [`belt-printer`](https://github.com/OrcaSlicer/OrcaSlicer/tree/belt-printer) branch. See tracking PR [#14394](https://github.com/OrcaSlicer/OrcaSlicer/pull/14394) and the original documentation in [#12998](https://github.com/OrcaSlicer/OrcaSlicer/pull/12998).
+
 # How to install

 ## Windows
@@ -8,10 +8,9 @@ SCRIPT_PATH=$(dirname "$(readlink -f "${0}")")
 pushd "${SCRIPT_PATH}" > /dev/null

 function usage() {
-    echo "Usage: ./${SCRIPT_NAME} [-1][-b][-c][-d][-D][-e][-F][-g][-h][-i][-j N][-J N][-p][-r][-s][-t][-u][-l][-L]"
+    echo "Usage: ./${SCRIPT_NAME} [-1][-b][-c][-d][-D][-e][-F][-g][-h][-i][-j N][-p][-r][-s][-t][-u][-l][-L]"
    echo "   -1: limit builds to one core (where possible)"
    echo "   -j N: limit builds to N cores (where possible)"
-    echo "   -J N: build up to N dependencies at a time, each still using -j jobs (default: 1)"
    echo "   -b: build in Debug mode"
    echo "   -c: force a clean build"
    echo "   -C: enable ANSI-colored compile output (GNU/Clang only)"
@@ -37,13 +36,12 @@ function usage() {
 }

 SLIC3R_PRECOMPILED_HEADERS="ON"
-DEPS_PARALLEL=""

 unset name
 BUILD_DIR=build
 BUILD_CONFIG=Release
 FORWARDED_ARGS=()
-while getopts ":1j:J:bcCdDeFghiprstulL" opt ; do
+while getopts ":1j:bcCdDeFghiprstulL" opt ; do
  case ${opt} in
    1 )
        export CMAKE_BUILD_PARALLEL_LEVEL=1
@@ -53,10 +51,6 @@ while getopts ":1j:J:bcCdDeFghiprstulL" opt ; do
        export CMAKE_BUILD_PARALLEL_LEVEL=$OPTARG
        FORWARDED_ARGS+=("-j" "$OPTARG")
        ;;
-    J )
-        DEPS_PARALLEL=$OPTARG
-        FORWARDED_ARGS+=("-J" "$OPTARG")
-        ;;
    b )
        BUILD_DIR=build-dbg
        BUILD_CONFIG=Debug
@@ -141,11 +135,6 @@ if [[ -n "${CLEAN_DOCKER_IMAGE}" ]] && [[ -z "${USE_DOCKER}" ]] ; then
    exit 1
 fi

-if [[ -n "${DEPS_PARALLEL}" ]] && ! [[ "${DEPS_PARALLEL}" =~ ^[1-9][0-9]*$ ]] ; then
-    echo "Error: -J expects a positive integer."
-    exit 1
-fi
-
 function check_available_memory_and_disk() {
    FREE_MEM_GB=$(free --gibi --total | grep 'Mem' | rev | cut --delimiter=" " --fields=1 | rev)
    MIN_MEM_GB=10
@@ -548,29 +537,7 @@ if [[ -n "${BUILD_DEPS}" ]] ; then
    fi

    print_and_run cmake -S deps -B deps/$BUILD_DIR "${CMAKE_C_CXX_COMPILER_CLANG[@]}" "${CMAKE_LLD_LINKER_ARGS[@]}" "${CMAKE_CCACHE_ARGS[@]}" -G Ninja "${COLORED_OUTPUT}" "${BUILD_ARGS[@]}"
-    # The top-level build runs one dependency at a time by default, which keeps the console
-    # output readable and lets that dependency's own build use all of CMAKE_BUILD_PARALLEL_LEVEL.
-    # -J raises the top level instead, and -j still applies in full to every dependency, so the
-    # worst case is -J times -j compile jobs at once. Ninja has no job server to share a pool
-    # across the nested builds, so that ceiling is not enforced anywhere: pick -J to suit the RAM.
-    DEPS_JOBS=1
-    if [[ -n "${DEPS_PARALLEL}" ]] ; then
-        DEPS_JOBS=${DEPS_PARALLEL}
-        SAVED_PARALLEL_LEVEL=${CMAKE_BUILD_PARALLEL_LEVEL-}
-        export CMAKE_BUILD_PARALLEL_LEVEL=${CMAKE_BUILD_PARALLEL_LEVEL:-$(nproc)}
-        echo "Building up to ${DEPS_JOBS} dependencies at a time, ${CMAKE_BUILD_PARALLEL_LEVEL} jobs each: up to $(( DEPS_JOBS * CMAKE_BUILD_PARALLEL_LEVEL )) compile jobs at once."
-    fi
-
-    print_and_run cmake --build deps/$BUILD_DIR -j"${DEPS_JOBS}"
-
-    if [[ -n "${DEPS_PARALLEL}" ]] ; then
-        # Give the whole -j back to the OrcaSlicer build below.
-        if [[ -n "${SAVED_PARALLEL_LEVEL}" ]] ; then
-            export CMAKE_BUILD_PARALLEL_LEVEL=${SAVED_PARALLEL_LEVEL}
-        else
-            unset CMAKE_BUILD_PARALLEL_LEVEL
-        fi
-    fi
+    print_and_run cmake --build deps/$BUILD_DIR -j1
 fi

 if [[ -n "${BUILD_ORCA}" ]] || [[ -n "${BUILD_TESTS}" ]] ; then
@@ -104,8 +104,8 @@ fi

 CMAKE_VERSION=$(cmake --version | head -1 | sed 's/[^0-9]*\([0-9]*\).*/\1/')
 if [ "$CMAKE_VERSION" -ge 4 ] 2>/dev/null; then
-  export CMAKE_POLICY_VERSION_MINIMUM=3.10
-  export CMAKE_POLICY_COMPAT="-DCMAKE_POLICY_VERSION_MINIMUM=3.10"
+  export CMAKE_POLICY_VERSION_MINIMUM=3.5
+  export CMAKE_POLICY_COMPAT="-DCMAKE_POLICY_VERSION_MINIMUM=3.5"
  echo "Detected CMake 4.x, adding compatibility flag (env + cmake arg)"
 else
  export CMAKE_POLICY_COMPAT=""
@@ -282,7 +282,11 @@ if "%install_deps%" == "ON" (
        call :note_failed "Visual Studio" !errorlevel!
    )

-    call :print_and_run winget install !winget_args! --id=Kitware.CMake
+    REM CMake 4 dropped pre-3.5 policy support and ships incomplete ASM_ARMASM
+    REM linker modules, which breaks Boost.Context on ARM64. CI pins the same way.
+    set "cmake_version_flag="
+    if /I "%arch%" == "ARM64" set "cmake_version_flag=--version 3.31.8"
+    call :print_and_run winget install !winget_args! --id=Kitware.CMake !cmake_version_flag!
    call :note_failed CMake !errorlevel!
    call :print_and_run winget install !winget_args! --id=StrawberryPerl.StrawberryPerl
    call :note_failed Perl !errorlevel!
@@ -0,0 +1,359 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# PrusaSlicer specifics:
+# This file is backported from CMake 3.15 distribution to behave uniformly
+# across all versions of CMake. It explicitly adds GLEW_STATIC compile 
+# definition to static targets which is needed to prevent link errors.
+
+#[=======================================================================[.rst:
+FindGLEW
+--------
+
+Find the OpenGL Extension Wrangler Library (GLEW)
+
+Input Variables
+^^^^^^^^^^^^^^^
+
+The following variables may be set to influence this module’s behavior:
+
+``GLEW_USE_STATIC_LIBS``
+  to find and create :prop_tgt:`IMPORTED` target for static linkage.
+
+``GLEW_VERBOSE``
+  to output a detailed log of this module.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+This module defines the following :ref:`Imported Targets <Imported Targets>`:
+
+
+``GLEW::glew``
+  The GLEW shared library.
+``GLEW::glew_s``
+  The GLEW static library, if ``GLEW_USE_STATIC_LIBS`` is set to ``TRUE``.
+``GLEW::GLEW``
+  Duplicates either ``GLEW::glew`` or ``GLEW::glew_s`` based on availability.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module defines the following variables:
+
+``GLEW_INCLUDE_DIRS``
+  include directories for GLEW
+``GLEW_LIBRARIES``
+  libraries to link against GLEW
+``GLEW_SHARED_LIBRARIES``
+  libraries to link against shared GLEW
+``GLEW_STATIC_LIBRARIES``
+  libraries to link against static GLEW
+``GLEW_FOUND``
+  true if GLEW has been found and can be used
+``GLEW_VERSION``
+  GLEW version
+``GLEW_VERSION_MAJOR``
+  GLEW major version
+``GLEW_VERSION_MINOR``
+  GLEW minor version
+``GLEW_VERSION_MICRO``
+  GLEW micro version
+
+#]=======================================================================]
+
+include(FindPackageHandleStandardArgs)
+
+
+if(APPLE)
+  find_package(OpenGL QUIET)
+
+  if(OpenGL_FOUND)
+    if(GLEW_VERBOSE)
+      message(STATUS "FindGLEW: Found OpenGL Framework.")
+      message(STATUS "FindGLEW: OPENGL_LIBRARIES: ${OPENGL_LIBRARIES}")
+    endif()
+  else()
+    if(GLEW_VERBOSE)
+      message(STATUS "FindGLEW: could not find GLEW library.")
+    endif()
+    return()
+  endif()
+endif()
+
+
+function(__glew_set_find_library_suffix shared_or_static)
+  if((UNIX AND NOT APPLE) AND "${shared_or_static}" MATCHES "SHARED")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".so")
+  elseif((UNIX AND NOT APPLE) AND "${shared_or_static}" MATCHES "STATIC")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
+  elseif(APPLE AND "${shared_or_static}" MATCHES "SHARED")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib;.so")
+  elseif(APPLE AND "${shared_or_static}" MATCHES "STATIC")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
+  elseif(WIN32 AND "${shared_or_static}" MATCHES "SHARED")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib")
+  elseif(WIN32 AND "${shared_or_static}" MATCHES "STATIC")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib;.a;.dll.a")
+  endif()
+
+  set(CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_FIND_LIBRARY_SUFFIXES}" PARENT_SCOPE)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: CMAKE_FIND_LIBRARY_SUFFIXES for ${shared_or_static}: ${CMAKE_FIND_LIBRARY_SUFFIXES}")
+  endif()
+endfunction()
+
+
+if(GLEW_VERBOSE)
+  if(DEFINED GLEW_USE_STATIC_LIBS)
+    message(STATUS "FindGLEW: GLEW_USE_STATIC_LIBS: ${GLEW_USE_STATIC_LIBS}.")
+  else()
+    message(STATUS "FindGLEW: GLEW_USE_STATIC_LIBS is undefined. Treated as FALSE.")
+  endif()
+endif()
+
+find_path(GLEW_INCLUDE_DIR GL/glew.h)
+mark_as_advanced(GLEW_INCLUDE_DIR)
+
+set(GLEW_INCLUDE_DIRS ${GLEW_INCLUDE_DIR})
+
+if(GLEW_VERBOSE)
+  message(STATUS "FindGLEW: GLEW_INCLUDE_DIR: ${GLEW_INCLUDE_DIR}")
+  message(STATUS "FindGLEW: GLEW_INCLUDE_DIRS: ${GLEW_INCLUDE_DIRS}")
+endif()
+
+if("${CMAKE_GENERATOR_PLATFORM}" MATCHES "x64" OR "${CMAKE_GENERATOR}" MATCHES "Win64")
+  set(_arch "x64")
+elseif("${CMAKE_GENERATOR_PLATFORM}" MATCHES "ARM64")
+  set(_arch "x64")  # GLEW ships one header set; ARM64 uses the x64 import path
+else()
+  set(_arch "Win32")
+endif()
+
+
+set(__GLEW_CURRENT_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+
+__glew_set_find_library_suffix(SHARED)
+
+find_library(GLEW_SHARED_LIBRARY_RELEASE
+             NAMES GLEW glew glew32
+             PATH_SUFFIXES lib lib64 libx32 lib/Release/${_arch}
+             PATHS ENV GLEW_ROOT)
+
+find_library(GLEW_SHARED_LIBRARY_DEBUG
+             NAMES GLEWd glewd glew32d
+             PATH_SUFFIXES lib lib64
+             PATHS ENV GLEW_ROOT)
+
+
+__glew_set_find_library_suffix(STATIC)
+
+find_library(GLEW_STATIC_LIBRARY_RELEASE
+             NAMES GLEW glew glew32s
+             PATH_SUFFIXES lib lib64 libx32 lib/Release/${_arch}
+             PATHS ENV GLEW_ROOT)
+
+find_library(GLEW_STATIC_LIBRARY_DEBUG
+             NAMES GLEWds GLEWd glewd glewds glew32ds
+             PATH_SUFFIXES lib lib64
+             PATHS ENV GLEW_ROOT)
+
+set(CMAKE_FIND_LIBRARY_SUFFIXES ${__GLEW_CURRENT_FIND_LIBRARY_SUFFIXES})
+unset(__GLEW_CURRENT_FIND_LIBRARY_SUFFIXES)
+
+include(SelectLibraryConfigurations)
+
+select_library_configurations(GLEW_SHARED)
+select_library_configurations(GLEW_STATIC)
+
+if(NOT GLEW_USE_STATIC_LIBS)
+  set(GLEW_LIBRARIES ${GLEW_SHARED_LIBRARY})
+else()
+  set(GLEW_LIBRARIES ${GLEW_STATIC_LIBRARY})
+endif()
+
+
+if(GLEW_VERBOSE)
+  message(STATUS "FindGLEW: GLEW_SHARED_LIBRARY_RELEASE: ${GLEW_SHARED_LIBRARY_RELEASE}")
+  message(STATUS "FindGLEW: GLEW_STATIC_LIBRARY_RELEASE: ${GLEW_STATIC_LIBRARY_RELEASE}")
+  message(STATUS "FindGLEW: GLEW_SHARED_LIBRARY_DEBUG: ${GLEW_SHARED_LIBRARY_DEBUG}")
+  message(STATUS "FindGLEW: GLEW_STATIC_LIBRARY_DEBUG: ${GLEW_STATIC_LIBRARY_DEBUG}")
+  message(STATUS "FindGLEW: GLEW_SHARED_LIBRARY: ${GLEW_SHARED_LIBRARY}")
+  message(STATUS "FindGLEW: GLEW_STATIC_LIBRARY: ${GLEW_STATIC_LIBRARY}")
+  message(STATUS "FindGLEW: GLEW_LIBRARIES: ${GLEW_LIBRARIES}")
+endif()
+
+
+# Read version from GL/glew.h file
+if(EXISTS "${GLEW_INCLUDE_DIR}/GL/glew.h")
+  file(STRINGS "${GLEW_INCLUDE_DIR}/GL/glew.h" _contents REGEX "^VERSION_.+ [0-9]+")
+  if(_contents)
+    string(REGEX REPLACE ".*VERSION_MAJOR[ \t]+([0-9]+).*" "\\1" GLEW_VERSION_MAJOR "${_contents}")
+    string(REGEX REPLACE ".*VERSION_MINOR[ \t]+([0-9]+).*" "\\1" GLEW_VERSION_MINOR "${_contents}")
+    string(REGEX REPLACE ".*VERSION_MICRO[ \t]+([0-9]+).*" "\\1" GLEW_VERSION_MICRO "${_contents}")
+    set(GLEW_VERSION "${GLEW_VERSION_MAJOR}.${GLEW_VERSION_MINOR}.${GLEW_VERSION_MICRO}")
+  endif()
+endif()
+
+if(GLEW_VERBOSE)
+  message(STATUS "FindGLEW: GLEW_VERSION_MAJOR: ${GLEW_VERSION_MAJOR}")
+  message(STATUS "FindGLEW: GLEW_VERSION_MINOR: ${GLEW_VERSION_MINOR}")
+  message(STATUS "FindGLEW: GLEW_VERSION_MICRO: ${GLEW_VERSION_MICRO}")
+  message(STATUS "FindGLEW: GLEW_VERSION: ${GLEW_VERSION}")
+endif()
+
+find_package_handle_standard_args(GLEW
+                                  REQUIRED_VARS GLEW_INCLUDE_DIRS GLEW_LIBRARIES
+                                  VERSION_VAR GLEW_VERSION)
+
+if(NOT GLEW_FOUND)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: could not find GLEW library.")
+  endif()
+  return()
+endif()
+
+
+if(NOT TARGET GLEW::glew AND NOT GLEW_USE_STATIC_LIBS)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: Creating GLEW::glew imported target.")
+  endif()
+
+  add_library(GLEW::glew UNKNOWN IMPORTED)
+
+  set_target_properties(GLEW::glew
+                        PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${GLEW_INCLUDE_DIRS}")
+
+  if(APPLE)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL "4.0")
+      set_target_properties(GLEW::glew
+                            PROPERTIES INTERFACE_LINK_LIBRARIES "-framework OpenGL")
+    else()
+      set_target_properties(GLEW::glew
+                            PROPERTIES INTERFACE_LINK_LIBRARIES OpenGL::GL)
+    endif()
+  endif()
+
+  if(GLEW_SHARED_LIBRARY_RELEASE)
+    set_property(TARGET GLEW::glew
+                 APPEND
+                 PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+
+    set_target_properties(GLEW::glew
+                          PROPERTIES IMPORTED_LOCATION_RELEASE "${GLEW_SHARED_LIBRARY_RELEASE}")
+  endif()
+
+  if(GLEW_SHARED_LIBRARY_DEBUG)
+    set_property(TARGET GLEW::glew
+                 APPEND
+                 PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+
+    set_target_properties(GLEW::glew
+                          PROPERTIES IMPORTED_LOCATION_DEBUG "${GLEW_SHARED_LIBRARY_DEBUG}")
+  endif()
+
+elseif(NOT TARGET GLEW::glew_s AND GLEW_USE_STATIC_LIBS)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: Creating GLEW::glew_s imported target.")
+  endif()
+
+  add_library(GLEW::glew_s UNKNOWN IMPORTED)
+
+  set_target_properties(GLEW::glew_s
+                        PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${GLEW_INCLUDE_DIRS}")
+
+  set_target_properties(GLEW::glew_s PROPERTIES INTERFACE_COMPILE_DEFINITIONS GLEW_STATIC)
+
+  if(APPLE)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL "4.0")
+      set_target_properties(GLEW::glew_s
+                            PROPERTIES INTERFACE_LINK_LIBRARIES "-framework OpenGL")
+    else()
+      set_target_properties(GLEW::glew_s
+                            PROPERTIES INTERFACE_LINK_LIBRARIES OpenGL::GL)
+    endif()
+  endif()
+
+  if(GLEW_STATIC_LIBRARY_RELEASE)
+    set_property(TARGET GLEW::glew_s
+                 APPEND
+                 PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+
+    set_target_properties(GLEW::glew_s
+                          PROPERTIES IMPORTED_LOCATION_RELEASE "${GLEW_STATIC_LIBRARY_RELEASE}")
+  endif()
+
+  if(GLEW_STATIC_LIBRARY_DEBUG)
+    set_property(TARGET GLEW::glew_s
+                 APPEND
+                 PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+
+    set_target_properties(GLEW::glew_s
+                          PROPERTIES IMPORTED_LOCATION_DEBUG "${GLEW_STATIC_LIBRARY_DEBUG}")
+  endif()
+endif()
+
+if(NOT TARGET GLEW::GLEW)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: Creating GLEW::GLEW imported target.")
+  endif()
+
+  add_library(GLEW::GLEW UNKNOWN IMPORTED)
+
+  set_target_properties(GLEW::GLEW
+                        PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${GLEW_INCLUDE_DIRS}")
+
+  if(APPLE)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL "4.0")
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES INTERFACE_LINK_LIBRARIES "-framework OpenGL")
+    else()
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES INTERFACE_LINK_LIBRARIES OpenGL::GL)
+    endif()
+  endif()
+
+  if(TARGET GLEW::glew)
+    if(GLEW_SHARED_LIBRARY_RELEASE)
+      set_property(TARGET GLEW::GLEW
+                   APPEND
+                   PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES IMPORTED_LOCATION_RELEASE "${GLEW_SHARED_LIBRARY_RELEASE}")
+    endif()
+
+    if(GLEW_SHARED_LIBRARY_DEBUG)
+      set_property(TARGET GLEW::GLEW
+                   APPEND
+                   PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES IMPORTED_LOCATION_DEBUG "${GLEW_SHARED_LIBRARY_DEBUG}")
+    endif()
+
+  elseif(TARGET GLEW::glew_s)
+    if(GLEW_STATIC_LIBRARY_RELEASE)
+      set_property(TARGET GLEW::GLEW
+                   APPEND
+                   PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES IMPORTED_LOCATION_RELEASE "${GLEW_STATIC_LIBRARY_RELEASE}"
+                                       INTERFACE_COMPILE_DEFINITIONS GLEW_STATIC)
+    endif()
+
+    if(GLEW_STATIC_LIBRARY_DEBUG AND GLEW_USE_STATIC_LIBS)
+      set_property(TARGET GLEW::GLEW
+                   APPEND
+                   PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES IMPORTED_LOCATION_DEBUG "${GLEW_STATIC_LIBRARY_DEBUG}"
+                                       INTERFACE_COMPILE_DEFINITIONS GLEW_STATIC)
+    endif()
+
+  elseif(GLEW_VERBOSE)
+    message(WARNING "FindGLEW: no `GLEW::glew` or `GLEW::glew_s` target was created. Something went wrong in FindGLEW target creation.")
+  endif()
+endif()
@@ -5,10 +5,10 @@ endif ()
 orcaslicer_add_cmake_project(
    CGAL
    # GIT_REPOSITORY https://github.com/CGAL/cgal.git
-    # GIT_TAG        28811b671a12b5caa9e3688569dadbc6b3728fe6 # v6.2.1
+    # GIT_TAG        3654f780ae0c64675cabaef0e5ddaf904c48b4b7 # releases/CGAL-5.6.3
    # For whatever reason, this keeps downloading forever (repeats downloads if finished)
-    URL      https://github.com/CGAL/cgal/releases/download/v6.2.1/CGAL-6.2.1.zip
-    URL_HASH SHA256=eebd737d9b7f0199647ba5c1f9f6c7a3d0651aacef9c2fd4dedc52da6c25edbe
+    URL      https://github.com/CGAL/cgal/releases/download/v5.6.3/CGAL-5.6.3.zip
+    URL_HASH SHA256=5d577acb4a9918ccb960491482da7a3838f8d363aff47e14d703f19fd84733d4
    DEPENDS dep_Boost dep_Eigen dep_GMP dep_MPFR
 )

@@ -1,5 +1,5 @@
 if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "4.0")
-    set(CMAKE_POLICY_VERSION_MINIMUM 3.10 CACHE STRING "" FORCE)
+    set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "" FORCE)
 endif()

 #
@@ -24,7 +24,7 @@ endif()
 # therefore, unfortunately, the installation cannot be copied/moved elsewhere without re-installing wxWidgets.
 #

-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.2)
 if (APPLE)
    # if CMAKE_OSX_DEPLOYMENT_TARGET is not set, set it to 12.0 (the lowest Xcode 27 accepts)
    if (NOT CMAKE_OSX_DEPLOYMENT_TARGET)
@@ -224,7 +224,7 @@ if (NOT IS_CROSS_COMPILE OR NOT APPLE)
        ${_source_dir_arg}
        ${_gen}
        CMAKE_ARGS
-            -DCMAKE_POLICY_VERSION_MINIMUM=3.10
+            -DCMAKE_POLICY_VERSION_MINIMUM=3.5
            -DCMAKE_INSTALL_PREFIX:STRING=${DESTDIR}
            -DCMAKE_MODULE_PATH:STRING=${PROJECT_SOURCE_DIR}/../cmake/modules
            -DCMAKE_PREFIX_PATH:STRING=${DESTDIR}
@@ -279,7 +279,7 @@ else()
        ${_source_dir_arg}
        ${_gen}
        CMAKE_ARGS
-            -DCMAKE_POLICY_VERSION_MINIMUM=3.10
+            -DCMAKE_POLICY_VERSION_MINIMUM=3.5
            -DCMAKE_INSTALL_PREFIX:STRING=${DESTDIR}
            -DCMAKE_PREFIX_PATH:STRING=${DESTDIR}
            -DCMAKE_IGNORE_PREFIX_PATH:STRING=${CMAKE_IGNORE_PREFIX_PATH}
@@ -379,8 +379,10 @@ include(Boost/Boost.cmake)

 include(Cereal/Cereal.cmake)
 include(Qhull/Qhull.cmake)
+include(GLEW/GLEW.cmake)

 include(GLFW/GLFW.cmake)
+include(OpenCSG/OpenCSG.cmake)
 set(SLVS_PKG "")
 if (SLIC3R_CAD)
    include(SLVS/SLVS.cmake)
@@ -476,6 +478,7 @@ set(_dep_list
    dep_Draco
    dep_NLopt
    dep_OpenVDB
+    dep_OpenCSG
    ${SLVS_PKG}
    dep_OpenCV
    dep_Eigen
@@ -1,4 +1,6 @@
 orcaslicer_add_cmake_project(EXPAT
+  # GIT_REPOSITORY https://github.com/nigels-com/glew.git
+  # GIT_TAG 3a8eff7 # 2.1.0
  SOURCE_DIR          ${CMAKE_CURRENT_LIST_DIR}/expat
 )

@@ -0,0 +1,14 @@
+# We have to check for OpenGL to compile GLEW
+set(OpenGL_GL_PREFERENCE "LEGACY") # to prevent a nasty warning by cmake
+find_package(OpenGL QUIET REQUIRED)
+
+orcaslicer_add_cmake_project(
+  GLEW
+  SOURCE_DIR  ${CMAKE_CURRENT_LIST_DIR}/glew
+  CMAKE_ARGS
+    -DGLEW_USE_EGL=OFF
+)
+
+if (MSVC)
+    add_debug_dep(dep_GLEW)
+endif ()
@@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 3.0)
+project(GLEW)
+
+find_package(OpenGL REQUIRED)
+
+# Allow parent project to control EGL usage.
+# Default to OFF since OrcaSlicer forces GDK_BACKEND=x11 (using GLX contexts).
+# GLEW must use glXGetProcAddressARB (GLX) to match wxWidgets GL canvas.
+# Using EGL function loading with GLX contexts causes rendering failures.
+option(GLEW_USE_EGL "Use EGL instead of GLX for OpenGL function loading" OFF)
+
+if(GLEW_USE_EGL)
+    message(STATUS "Building GLEW with EGL support")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DGLEW_EGL")
+else()
+    message(STATUS "Building GLEW with GLX support")
+endif()
+
+add_library(GLEW src/glew.c)
+target_include_directories(GLEW PRIVATE include/)
+target_link_libraries(GLEW PUBLIC OpenGL::GL)
+
+if (NOT BUILD_SHARED_LIBS)
+    target_compile_definitions(GLEW PUBLIC GLEW_STATIC)
+endif ()
+
+include(GNUInstallDirs)
+
+install( 
+    FILES
+        ${PROJECT_SOURCE_DIR}/include/GL/glew.h
+        ${PROJECT_SOURCE_DIR}/include/GL/wglew.h
+        ${PROJECT_SOURCE_DIR}/include/GL/glxew.h
+        ${PROJECT_SOURCE_DIR}/include/GL/eglew.h
+    DESTINATION
+        ${CMAKE_INSTALL_INCLUDEDIR}/GL
+)
+
+install(TARGETS GLEW GLEW
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} 
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
@@ -0,0 +1,73 @@
+The OpenGL Extension Wrangler Library
+Copyright (C) 2002-2007, Milan Ikits <milan ikits[]ieee org>
+Copyright (C) 2002-2007, Marcelo E. Magallon <mmagallo[]debian org>
+Copyright (C) 2002, Lev Povalahev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, 
+  this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, 
+  this list of conditions and the following disclaimer in the documentation 
+  and/or other materials provided with the distribution.
+* The name of the author may be used to endorse or promote products 
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Mesa 3-D graphics library
+Version:  7.0
+
+Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Copyright (c) 2007 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
@@ -0,0 +1,251 @@
+# GLEW - The OpenGL Extension Wrangler Library
+
+The OpenGL Extension Wrangler Library (GLEW) is a cross-platform open-source C/C++ extension loading library. GLEW provides efficient run-time mechanisms for determining which OpenGL extensions are supported on the target platform. OpenGL core and extension functionality is exposed in a single header file. GLEW has been tested on a variety of operating systems, including Windows, Linux, Mac OS X, FreeBSD, Irix, and Solaris.
+
+![](http://glew.sourceforge.net/glew.png)
+
+http://glew.sourceforge.net/
+
+https://github.com/nigels-com/glew
+
+[![Build Status](https://travis-ci.org/nigels-com/glew.svg?branch=master)](https://travis-ci.org/nigels-com/glew)
+[![Gitter](https://badges.gitter.im/nigels-com/glew.svg)](https://gitter.im/nigels-com/glew?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![Download](https://img.shields.io/sourceforge/dm/glew.svg)](https://sourceforge.net/projects/glew/files/latest/download)
+
+## Table of Contents
+
+* [Downloads](#downloads)
+	* [Recent snapshots](#recent-snapshots)
+* [Build](#build)
+	* [Linux and Mac](#linux-and-mac)
+		* [Using GNU Make](#using-gnu-make)
+		* [Install build tools](#install-build-tools)
+		* [Build](#build-1)
+		* [Linux EGL](#linux-egl)
+		* [Linux mingw-w64](#linux-mingw-w64)
+	* [Using cmake](#using-cmake)
+		* [Install build tools](#install-build-tools-1)
+		* [Build](#build-2)
+	* [Windows](#windows)
+		* [Visual Studio](#visual-studio)
+		* [MSYS/Mingw](#msysmingw)
+		* [MSYS2/Mingw-w64](#msys2mingw-w64)
+* [glewinfo](#glewinfo)
+* [Code Generation](#code-generation)
+* [Authors](#authors)
+* [Contributions](#contributions)
+* [Copyright and Licensing](#copyright-and-licensing)
+
+## Downloads
+
+Current release is [2.1.0](https://sourceforge.net/projects/glew/files/glew/2.1.0/).
+[(Change Log)](http://glew.sourceforge.net/log.html)
+
+Sources available as
+[ZIP](https://sourceforge.net/projects/glew/files/glew/2.1.0/glew-2.1.0.zip/download) or
+[TGZ](https://sourceforge.net/projects/glew/files/glew/2.1.0/glew-2.1.0.tgz/download).
+
+Windows binaries for [32-bit and 64-bit](https://sourceforge.net/projects/glew/files/glew/2.1.0/glew-2.1.0-win32.zip/download).
+
+### Recent snapshots
+
+Snapshots may contain new features, bug-fixes or new OpenGL extensions ahead of tested, official releases.
+
+[glew-20200115.tgz](https://sourceforge.net/projects/glew/files/glew/snapshots/glew-20200115.tgz/download) *GLEW 2.2.0 RC3: fixes*
+
+[glew-20190928.tgz](https://sourceforge.net/projects/glew/files/glew/snapshots/glew-20190928.tgz/download) *GLEW 2.2.0 RC2: New extensions, bug fixes*
+
+## Build
+
+It is highly recommended to build from a tgz or zip release snapshot.
+The code generation workflow is a complex brew of gnu make, perl and python, that works best on Linux or Mac.
+The code generation is known to work on Windows using [MSYS2](https://www.msys2.org/).
+For most end-users of GLEW the official releases are the best choice, with first class support.
+
+### Linux and Mac
+
+#### Using GNU Make
+
+GNU make is the primary build system for GLEW, historically.
+It includes targets for building the sources and headers, for maintenance purposes.
+
+##### Install build tools
+
+Debian/Ubuntu/Mint:    `$ sudo apt-get install build-essential libxmu-dev libxi-dev libgl-dev`
+
+RedHat/CentOS/Fedora:  `$ sudo yum install libXmu-devel libXi-devel libGL-devel`
+
+FreeBSD: `# pkg install xorg lang/gcc git cmake gmake bash python perl5`
+
+##### Build
+
+	$ make
+	$ sudo make install
+	$ make clean
+
+Targets:    `all, glew.lib (sub-targets: glew.lib.shared, glew.lib.static), glew.bin, clean, install, uninstall`
+
+Variables:  `SYSTEM=linux-clang, GLEW_DEST=/usr/local, STRIP=`
+
+_Note: you may need to call `make` in the  **auto** folder first_
+
+##### Linux EGL
+
+	$ sudo apt install libegl1-mesa-dev
+	$ make SYSTEM=linux-egl
+
+##### Linux mingw-w64
+
+	$ sudo apt install mingw-w64
+	$ make SYSTEM=linux-mingw32
+	$ make SYSTEM=linux-mingw64
+
+#### Using cmake
+
+The cmake build is mostly contributer maintained.
+Due to the multitude of use cases this is maintained on a _best effort_ basis.
+Pull requests are welcome.
+
+*CMake 2.8.12 or higher is required.*
+
+##### Install build tools
+
+Debian/Ubuntu/Mint:   `$ sudo apt-get install build-essential libxmu-dev libxi-dev libgl-dev cmake git`
+
+RedHat/CentOS/Fedora: `$ sudo yum install libXmu-devel libXi-devel libGL-devel cmake git`
+
+##### Build
+
+	$ cd build
+	$ cmake ./cmake
+	$ make -j4
+
+| Target     | Description |
+| ---------- | ----------- |
+| glew       | Build the glew shared library. |
+| glew_s     | Build the glew static library. |
+| glewinfo   | Build the `glewinfo` executable (requires `BUILD_UTILS` to be `ON`). |
+| visualinfo | Build the `visualinfo` executable (requires `BUILD_UTILS` to be `ON`). |
+| install    | Install all enabled targets into `CMAKE_INSTALL_PREFIX`. |
+| clean      | Clean up build artifacts. |
+| all        | Build all enabled targets (default target). |
+
+| Variables       | Description |
+| --------------- | ----------- |
+| BUILD_UTILS     | Build the `glewinfo` and `visualinfo` executables. |
+| GLEW_REGAL      | Build in Regal mode. |
+| BUILD_FRAMEWORK | Build as MacOSX Framework.  Setting `CMAKE_INSTALL_PREFIX` to `/Library/Frameworks` is recommended. |
+
+### Windows
+
+#### Visual Studio
+
+Use the provided Visual Studio project file in build/vc15/
+
+Projects for vc6, vc10, vc12 and vc14 are also provided
+
+#### MSYS/Mingw
+
+Available from [Mingw](http://www.mingw.org/)
+
+Requirements: bash, make, gcc
+
+	$ mingw32-make
+	$ mingw32-make install
+	$ mingw32-make install.all
+
+Alternative toolchain:  `SYSTEM=mingw-win32`
+
+#### MSYS2/Mingw-w64
+
+Available from [Msys2](http://msys2.github.io/) and/or [Mingw-w64](http://mingw-w64.org/)
+
+Requirements: bash, make, gcc
+
+	$ pacman -S gcc make mingw-w64-i686-gcc mingw-w64-x86_64-gcc
+	$ make
+	$ make install
+	$ make install.all
+
+Alternative toolchain:  `SYSTEM=msys, SYSTEM=msys-win32, SYSTEM=msys-win64`
+
+## glewinfo
+
+`glewinfo` is a command-line tool useful for inspecting the capabilities of an
+OpenGL implementation and GLEW support for that.  Please include `glewinfo.txt`
+with bug reports, as appropriate.
+
+	---------------------------
+	    GLEW Extension Info
+	---------------------------
+
+	GLEW version 2.0.0
+	Reporting capabilities of pixelformat 3
+	Running on a Intel(R) HD Graphics 3000 from Intel
+	OpenGL version 3.1.0 - Build 9.17.10.4229 is supported
+
+	GL_VERSION_1_1:                                                OK
+	---------------
+
+	GL_VERSION_1_2:                                                OK
+	---------------
+	  glCopyTexSubImage3D:                                         OK
+	  glDrawRangeElements:                                         OK
+	  glTexImage3D:                                                OK
+	  glTexSubImage3D:                                             OK
+
+	...
+
+## Code Generation
+
+A Unix or Mac environment is needed for building GLEW from scratch to
+include new extensions, or customize the code generation. The extension
+data is regenerated from the top level source directory with:
+
+	make extensions
+
+An alternative to generating the GLEW sources from scratch is to
+download a pre-generated (unsupported) snapshot:
+
+https://sourceforge.net/projects/glew/files/glew/snapshots/
+
+## Authors
+
+GLEW is currently maintained by [Nigel Stewart](https://github.com/nigels-com)
+with bug fixes, new OpenGL extension support and new releases.
+
+GLEW was developed by [Milan Ikits](http://www.cs.utah.edu/~ikits/)
+and [Marcelo Magallon](http://wwwvis.informatik.uni-stuttgart.de/~magallon/).
+Aaron Lefohn, Joe Kniss, and Chris Wyman were the first users and also
+assisted with the design and debugging process.
+
+The acronym GLEW originates from Aaron Lefohn.
+Pasi K&auml;rkk&auml;inen identified and fixed several problems with
+GLX and SDL.  Nate Robins created the `wglinfo` utility, to
+which modifications were made by Michael Wimmer.
+
+## Contributions
+
+GLEW welcomes community contributions.  Typically these are co-ordinated
+via [Issues](https://github.com/nigels-com/glew/issues) or
+[Pull Requests](https://github.com/nigels-com/glew/pulls) in the
+GitHub web interface.
+
+Be sure to mention platform and compiler toolchain details when filing
+a bug report.  The output of `glewinfo` can be quite useful for discussion
+also.
+
+Generally GLEW is usually released once a year, around the time of the Siggraph
+computer graphics conference.  If you're not using the current release
+version of GLEW, be sure to check if the issue or bug is fixed there.
+
+## Copyright and Licensing
+
+GLEW is originally derived from the EXTGL project by Lev Povalahev.
+The source code is licensed under the
+[Modified BSD License](http://glew.sourceforge.net/glew.txt), the
+[Mesa 3-D License](http://glew.sourceforge.net/mesa.txt) (MIT) and the
+[Khronos License](http://glew.sourceforge.net/khronos.txt) (MIT).
+
+The automatic code generation scripts are released under the
+[GNU GPL](http://glew.sourceforge.net/gpl.txt).
@@ -0,0 +1 @@
+2.2.0
@@ -1,28 +0,0 @@
-diff --git a/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_ModelPreProcessor.cxx b/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_ModelPreProcessor.cxx
-index 6f63781..9b1c08e 100644
--- a/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_ModelPreProcessor.cxx
-+++ b/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_ModelPreProcessor.cxx
-@@ -210,10 +210,10 @@ private:
- 
-     // Define two pcurves of the seam-edge.
-     occ::handle<Geom2d_Curve> aPC1, aPC2;
-    double                    af, al;
-+    double                    af, al, af1, al1;
- 
-     aE.Orientation(TopAbs_FORWARD);
-    aPC1 = BRep_Tool::CurveOnSurface(aE, aF, af, al);
-+    aPC1 = BRep_Tool::CurveOnSurface(aE, aF, af1, al1);
- 
-     aE.Orientation(TopAbs_REVERSED);
-     aPC2 = BRep_Tool::CurveOnSurface(aE, aF, af, al);
-@@ -224,7 +224,9 @@ private:
-     }
- 
-     // Select the correct pcurve of the seam-edge.
-    const gp_Pnt2d& aFPntOfPC1 = aPC1->Value(aPC1->FirstParameter());
-+    // Use the edge's first parameter. A Geom2d_Line's FirstParameter() is -Precision::Infinite(),
-+    // where a direction of (2e-16, -1) from rounding error gives an X far outside the U range.
-+    const gp_Pnt2d aFPntOfPC1 = aPC1->Value(af1);
- 
-     if (std::abs(aLPntOfIPC1.X() - aFPntOfPC1.X()) > Precision::Confusion())
-     {
@@ -0,0 +1,264 @@
+diff --git a/adm/cmake/occt_defs_flags.cmake b/adm/cmake/occt_defs_flags.cmake
+index 00000000..00000001 100644
+--- a/adm/cmake/occt_defs_flags.cmake
+++ b/adm/cmake/occt_defs_flags.cmake
+@@ -134,7 +134,11 @@
+     set (CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
+   endif()
+   # Optimize size of binaries
+-  set (CMAKE_SHARED_LINKER_FLAGS "-Wl,-s ${CMAKE_SHARED_LINKER_FLAGS}")
+  # clang-cl reports the Clang compiler ID, and OCCT builds shared on Windows,
+  # where the MSVC-style linker gets this flag as an argument it does not know.
+  if (NOT WIN32)
+    set (CMAKE_SHARED_LINKER_FLAGS "-Wl,-s ${CMAKE_SHARED_LINKER_FLAGS}")
+  endif()
+ elseif(MINGW)
+   add_definitions(-D_WIN32_WINNT=0x0601)
+   # _WIN32_WINNT=0x0601 (use Windows 7 SDK)
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index d98acc0f..28eb8eb4 100644
+--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+@@ -225,7 +225,7 @@ if (NOT DEFINED INSTALL_DIR_BIN)
+   if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
+     set (INSTALL_DIR_BIN "bin" CACHE PATH "${INSTALL_DIR_BIN_DESCR}")
+   else()
+-    set (INSTALL_DIR_BIN "${OS_WITH_BIT}/${COMPILER}/bin" CACHE PATH "${INSTALL_DIR_BIN_DESCR}")
+    set (INSTALL_DIR_BIN "bin/occt" CACHE PATH "${INSTALL_DIR_BIN_DESCR}")
+   endif()
+ endif()
+ 
+@@ -243,11 +243,11 @@ if (NOT DEFINED INSTALL_DIR_LIB)
+   if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
+     set (INSTALL_DIR_LIB "lib" CACHE PATH "${INSTALL_DIR_LIB_DESCR}")
+   else()
+-    set (INSTALL_DIR_LIB "${OS_WITH_BIT}/${COMPILER}/lib" CACHE PATH "${INSTALL_DIR_LIB_DESCR}")
+    set (INSTALL_DIR_LIB "lib/occt" CACHE PATH "${INSTALL_DIR_LIB_DESCR}")
+   endif()
+ endif()
+ 
+-# OCCT headers: <prefix>/inc for windows,
+# OCCT headers: <prefix>/include for windows,
+ #               <prefix>/include/opencascade-7.0.0 for unix
+ if (NOT DEFINED INSTALL_DIR_INCLUDE)
+   if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
+@@ -256,7 +256,7 @@ if (NOT DEFINED INSTALL_DIR_INCLUDE)
+       set (INSTALL_DIR_INCLUDE "include/opencascade-${OCC_VERSION_STRING_EXT}" CACHE PATH "${INSTALL_DIR_INCLUDE_DESCR}" FORCE)
+     endif()
+   else()
+-    set (INSTALL_DIR_INCLUDE "inc" CACHE PATH "${INSTALL_DIR_INCLUDE_DESCR}")
+    set (INSTALL_DIR_INCLUDE "include/occt" CACHE PATH "${INSTALL_DIR_INCLUDE_DESCR}")
+   endif()
+ endif()
+ 
+@@ -330,7 +330,7 @@ if (NOT DEFINED INSTALL_DIR_CMAKE)
+       set (INSTALL_DIR_CMAKE "lib/cmake/opencascade" CACHE PATH "${INSTALL_DIR_CMAKE_DESCR}")
+     endif()
+   else()
+-    set (INSTALL_DIR_CMAKE "cmake" CACHE PATH "${INSTALL_DIR_CMAKE_DESCR}")
+    set (INSTALL_DIR_CMAKE "lib/cmake/occt" CACHE PATH "${INSTALL_DIR_CMAKE_DESCR}")
+   endif()
+ endif()
+ 
+@@ -338,13 +338,13 @@ endif()
+ OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/occt_resources")
+ 
+ # install LICENSE_LGPL_21.txt and OCCT_LGPL_EXCEPTION.txt files
+-if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
+-  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" "${INSTALL_DIR_DOC}")
+-  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" "${INSTALL_DIR_DOC}")
+-else()
+-  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" ".")
+-  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" ".")
+-endif()
+#if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
+#  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" "${INSTALL_DIR_DOC}")
+#  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" "${INSTALL_DIR_DOC}")
+#else()
+#  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" ".")
+#  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" ".")
+#endif()
+ 
+ if(APPLE)
+   set (INSTALL_NAME_DIR "" CACHE STRING "install_name library suffix on OS X (e.g. @executable_path/../Frameworks)")
+@@ -850,34 +850,34 @@ endif()
+ 
+ # build directories
+ if (SINGLE_GENERATOR)
+-  set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/lib${BIN_LETTER}")
+-  set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin${BIN_LETTER}")
+-  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/lib${BIN_LETTER}")
+  set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/occt")
+  set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/occt")
+  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/occt")
+   if (WIN32)
+-    set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin${BIN_LETTER}")
+    set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/occt")
+   endif()
+ endif()
+ 
+-set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/lib")
+-set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin")
+-set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/lib")
+set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/lib/occt")
+set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/bin/occt")
+set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/lib/occt")
+ 
+-set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/libi")
+-set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bini")
+-set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/libi")
+set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/lib/occt/RelWithDebInfo")
+set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/bin/occt/RelWithDebInfo")
+set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/lib/occt/RelWithDebInfo")
+ 
+-set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/libd")
+-set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bind")
+-set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/libd")
+set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/lib/occt/Debug")
+set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/bin/occt/Debug")
+set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/lib/occt/Debug")
+ 
+ if (WIN32)
+-  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE        "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin")
+-  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bini")
+-  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG          "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bind")
+  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE        "${CMAKE_BINARY_DIR}/bin/occt")
+  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/bin/occt/RelWithDebInfo")
+  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG          "${CMAKE_BINARY_DIR}/bin/occt/Debug")
+ endif()
+ 
+ string(TIMESTAMP CURRENT_TIME "%H:%M:%S")
+-message (STATUS "\nInfo: \(${CURRENT_TIME}\) Start collecting all OCCT header files into ${CMAKE_BINARY_DIR}/inc ...")
+message (STATUS "\nInfo: \(${CURRENT_TIME}\) Start collecting all OCCT header files into ${CMAKE_BINARY_DIR}/include/occt ...")
+ 
+ # collect all the headers to <binary dir>/inc folder
+ COLLECT_AND_INSTALL_OCCT_HEADER_FILES ("${CMAKE_BINARY_DIR}" "${BUILD_TOOLKITS}" "${CMAKE_SOURCE_DIR}/src" "${INSTALL_DIR_INCLUDE}")
+@@ -984,9 +984,9 @@ if (EXISTS "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}/custom.${SCRIPT_EXT}")
+ 
+   set (CUSTOM_CONTENT "${CUSTOM_CONTENT} ${ADDITIONAL_CUSTOM_CONTENT}")
+ 
+-  file (WRITE "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}/custom.${SCRIPT_EXT}" "${CUSTOM_CONTENT}")
+  #file (WRITE "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}/custom.${SCRIPT_EXT}" "${CUSTOM_CONTENT}")
+ else()
+-  OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.main" "custom.${SCRIPT_EXT}" "custom.${SCRIPT_EXT}" "${INSTALL_DIR_SCRIPT}")
+  #OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.main" "custom.${SCRIPT_EXT}" "custom.${SCRIPT_EXT}" "${INSTALL_DIR_SCRIPT}")
+ endif()
+ 
+ if (WIN32)
+@@ -1007,7 +1007,7 @@ endforeach()
+ 
+ # write current custom.bat/sh (for install directory)
+ set (SUB_CUSTOM_BUILD_NAME "custom_${COMPILER}_${COMPILER_BITNESS}.install.${SCRIPT_EXT}")
+-OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.install.${SCRIPT_EXT}.in" "${SUB_CUSTOM_BUILD_NAME}" "${SUB_CUSTOM_NAME}" "${INSTALL_DIR_SCRIPT}")
+#OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.install.${SCRIPT_EXT}.in" "${SUB_CUSTOM_BUILD_NAME}" "${SUB_CUSTOM_NAME}" "${INSTALL_DIR_SCRIPT}")
+ 
+ # write current custom.bat/sh (for build directory)
+ OCCT_CONFIGURE ("adm/templates/custom.build.${SCRIPT_EXT}.in" "${SUB_CUSTOM_NAME}")
+@@ -1019,9 +1019,9 @@ endif()
+ 
+ if (WIN32)
+   # env script for draw in building environment
+-  OCCT_CONFIGURE ("adm/templates/env.${SCRIPT_EXT}.in" "env.${SCRIPT_EXT}")
+  #OCCT_CONFIGURE ("adm/templates/env.${SCRIPT_EXT}.in" "env.${SCRIPT_EXT}")
+   # install env script
+-  install (FILES "${CMAKE_BINARY_DIR}/env.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SCRIPT}")
+  #install (FILES "${CMAKE_BINARY_DIR}/env.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SCRIPT}")
+   # copy build.bat and install.bat scripts to CMake binary folder
+   OCCT_COPY_FILE_OR_DIR ("adm/templates/build.bat" "${CMAKE_BINARY_DIR}")
+   OCCT_COPY_FILE_OR_DIR ("adm/templates/install.bat" "${CMAKE_BINARY_DIR}")
+@@ -1043,12 +1043,12 @@ endif()
+ FILE_TO_LIST ("adm/RESOURCES" RESOURCES)
+ foreach(RESOURCE ${RESOURCES})
+   get_filename_component(RESOURCE_FOLDER ${RESOURCE} DIRECTORY)
+-  if(NOT "${RESOURCE_FOLDER}" STREQUAL "")
+-    get_filename_component(RESOURCE_FOLDER ${RESOURCE_FOLDER} NAME)
+-    OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}/${RESOURCE_FOLDER}")
+-  else()
+-    OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}")
+-  endif()
+  #if(NOT "${RESOURCE_FOLDER}" STREQUAL "")
+  #  get_filename_component(RESOURCE_FOLDER ${RESOURCE_FOLDER} NAME)
+  #  OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}/${RESOURCE_FOLDER}")
+  #else()
+  #  OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}")
+  #endif()
+ endforeach()
+ 
+ if (BUILD_SAMPLES_QT)
+diff --git a/adm/cmake/occt_macros.cmake b/adm/cmake/occt_macros.cmake
+index 224c96b1..8c94a1c5 100644
+--- a/adm/cmake/occt_macros.cmake
+++ b/adm/cmake/occt_macros.cmake
+@@ -608,7 +608,7 @@ macro (OCCT_INSERT_CODE_FOR_TARGET)
+   install(CODE "if (\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^([Rr][Ee][Ll][Ee][Aa][Ss][Ee])$\")
+     set (OCCT_INSTALL_BIN_LETTER \"\")
+   elseif (\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^([Rr][Ee][Ll][Ww][Ii][Tt][Hh][Dd][Ee][Bb][Ii][Nn][Ff][Oo])$\")
+-    set (OCCT_INSTALL_BIN_LETTER \"i\")
+    set (OCCT_INSTALL_BIN_LETTER \"\")
+   elseif (\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^([Dd][Ee][Bb][Uu][Gg])$\")
+     set (OCCT_INSTALL_BIN_LETTER \"d\")
+   endif()")
+diff --git a/adm/cmake/occt_toolkit.cmake b/adm/cmake/occt_toolkit.cmake
+index 550e0e2f..7ac1a3b8 100644
+--- a/adm/cmake/occt_toolkit.cmake
+++ b/adm/cmake/occt_toolkit.cmake
+@@ -241,7 +241,7 @@
+     else()
+       set (aReleasePdbConf)
+     endif()
+-    install (FILES  ${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin\${OCCT_INSTALL_BIN_LETTER}/${PROJECT_NAME}.pdb
+    install (FILES  $<TARGET_PDB_FILE:${PROJECT_NAME}>
+              CONFIGURATIONS Debug ${aReleasePdbConf} RelWithDebInfo
+              DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
+   endif()
+diff --git a/src/Font/Font_FTFont.cxx b/src/Font/Font_FTFont.cxx
+index 5ae9899f..0a17372b 100644
+--- a/src/Font/Font_FTFont.cxx
+++ b/src/Font/Font_FTFont.cxx
+@@ -103,9 +103,11 @@ bool Font_FTFont::Init (const Handle(NCollection_Buffer)& theData,
+   {
+     throw Standard_ProgramError ("Font_FTFont, Light and Normal hinting styles are mutually exclusive");
+   }
+#ifdef HAVE_FREETYPE
+   setLoadFlag (FT_LOAD_TARGET_LIGHT,   (theParams.FontHinting & Font_Hinting_Light) != 0);
+   setLoadFlag (FT_LOAD_NO_HINTING,     (theParams.FontHinting & Font_Hinting_Normal) == 0
+                                     && (theParams.FontHinting & Font_Hinting_Light)  == 0);
+#endif
+ 
+   // manage native / autohinting
+   if ((theParams.FontHinting & Font_Hinting_ForceAutohint) != 0
+@@ -113,8 +115,10 @@ bool Font_FTFont::Init (const Handle(NCollection_Buffer)& theData,
+   {
+     throw Standard_ProgramError ("Font_FTFont, ForceAutohint and NoAutohint are mutually exclusive");
+   }
+#ifdef HAVE_FREETYPE
+   setLoadFlag (FT_LOAD_FORCE_AUTOHINT, (theParams.FontHinting & Font_Hinting_ForceAutohint) != 0);
+   setLoadFlag (FT_LOAD_NO_AUTOHINT,    (theParams.FontHinting & Font_Hinting_NoAutohint) != 0);
+#endif
+ 
+   if (!myFTLib->IsValid())
+   {
+From 7236e83dcc1e7284e66dc61e612154617ef715d6 Mon Sep 17 00:00:00 2001
+From: dpasukhi <dpasukhi@opencascade.com>
+Date: Tue, 27 Aug 2024 11:33:29 +0100
+Subject: [PATCH] 0033808: Coding - FreeType Use unsigned point and contour
+ indexing in `FT_Outline`
+
+Changes to auto instead of specific type
+---
+ src/StdPrs/StdPrs_BRepFont.cxx | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/StdPrs/StdPrs_BRepFont.cxx b/src/StdPrs/StdPrs_BRepFont.cxx
+index ab2d9b3c9f..cd701879b1 100644
+--- a/src/StdPrs/StdPrs_BRepFont.cxx
+++ b/src/StdPrs/StdPrs_BRepFont.cxx
+@@ -457,7 +457,7 @@ Standard_Boolean StdPrs_BRepFont::renderGlyph (const Standard_Utf32Char theChar,
+   for (short aContour = 0, aStartIndex = 0; aContour < anOutline->n_contours; ++aContour)
+   {
+     const FT_Vector* aPntList = &anOutline->points[aStartIndex];
+-    const char* aTags      = &anOutline->tags[aStartIndex];
+    const auto* aTags      = &anOutline->tags[aStartIndex];
+     const short anEndIndex = anOutline->contours[aContour];
+     const short aPntsNb    = (anEndIndex - aStartIndex) + 1;
+     aStartIndex = anEndIndex + 1;
@@ -1,5 +1,5 @@
-# clang-cl cannot emit some OCCT sources for ARM64 (llvm/llvm-project#62081).
-# cl and clang-cl share an ABI.
+# clang-cl cannot emit IGESAppli_GeneralModule.cxx on ARM64
+# (llvm/llvm-project#62081). cl and clang-cl share an ABI.
 set(_occt_compiler_args "")
 if ("${DEPS_ARCH}" STREQUAL "arm64" AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
    set(_occt_compiler_args -DCMAKE_C_COMPILER:STRING=cl -DCMAKE_CXX_COMPILER:STRING=cl)
@@ -15,38 +15,31 @@ endif()
 # (fillet/offset/loft), whose only consumer is the parametric Design/CAD tab. With it OFF
 # the deps prefix matches upstream exactly.
 #
-# With it ON OCCT also builds TKFillet (used via BRepFilletAPI), TKOffset (used via
-# BRepOffsetAPI), and TKFeat, TKHelix, TKXMesh and TKExpress, which nothing here references
-# but which the module flag builds anyway, since module flags are all-or-nothing. The
-# module's other toolkits are built either way, because DataExchange (the STEP path)
-# depends on them.
+# With it ON the delta is THREE toolkits, not two: TKFillet (7.40 MiB archive, used via
+# BRepFilletAPI), TKOffset (5.38 MiB, used via BRepOffsetAPI) and TKFeat (4.42 MiB), which
+# nothing here references but which the module flag builds anyway -- it is all-or-nothing
+# per module. The module's other nine toolkits are built either way, because DataExchange
+# (the STEP path upstream already ships) depends on them.
 #
 # On macOS/Linux OCCT links statically, so an unreferenced toolkit costs build time and no
-# shipped bytes. Windows ships only the DLLs libslic3r links, so the tab adds the TKFillet,
-# TKOffset and TKBool DLLs. See docs/HLSD/design-tab.md.
+# shipped bytes. The Windows figure is a real DLL cost and has NOT been measured -- an
+# earlier "3.77 MiB, Windows only" note here covered only two of the three toolkits and is
+# not a number to quote. See docs/HLSD/design-tab.md.

 if (IN_GIT_REPO)
    set(OCCT_DIRECTORY_FLAG --directory ${BINARY_DIR_REL}/dep_OCCT-prefix/src/dep_OCCT)
 endif ()

 orcaslicer_add_cmake_project(OCCT
-    URL https://github.com/Open-Cascade-SAS/OCCT/archive/refs/tags/V8_0_1.zip
-    URL_HASH SHA256=7c033d917ee8f040c0512d289dcc5f02c148889d5bac17c3e25639accb44f0da
-    # Makes BRepMesh triangulate cone faces whose seam pcurve is slightly tilted
-    # (Open-Cascade-SAS/OCCT#572); remove the patch once an OCCT release includes the fix.
-    PATCH_COMMAND git apply ${OCCT_DIRECTORY_FLAG} --verbose --ignore-space-change --whitespace=fix ${CMAKE_CURRENT_LIST_DIR}/0001-BRepMesh-seam-pcurve-at-edge-parameter.patch
+    URL https://github.com/Open-Cascade-SAS/OCCT/archive/refs/tags/V7_6_0.zip
+    URL_HASH SHA256=28334f0e98f1b1629799783e9b4d21e05349d89e695809d7e6dfa45ea43e1dbc
+    #PATCH_COMMAND ${PATCH_CMD} ${CMAKE_CURRENT_LIST_DIR}/0001-OCCT-fix.patch
+    PATCH_COMMAND git apply ${OCCT_DIRECTORY_FLAG} --verbose --ignore-space-change --whitespace=fix ${CMAKE_CURRENT_LIST_DIR}/0001-OCCT-fix.patch
    #DEPENDS dep_Boost
    DEPENDS ${FREETYPE_PKG}
    CMAKE_ARGS
        -DCMAKE_CXX_STANDARD=17
        -DBUILD_LIBRARY_TYPE=${library_build_type}
-        # With the Unix layout, OCCT's resources and licenses go under share/ and its scripts
-        # into bin/occt on Windows too. libslic3r finds the CMake package in lib/cmake/occt.
-        -DINSTALL_DIR_LAYOUT=Unix
-        -DINSTALL_DIR_BIN=bin/occt
-        -DINSTALL_DIR_LIB=lib/occt
-        -DINSTALL_DIR_INCLUDE=include/occt
-        -DINSTALL_DIR_CMAKE=lib/cmake/occt
        -DUSE_TK=OFF
        -DUSE_TBB=OFF
 	#-DUSE_FREETYPE=OFF
@@ -0,0 +1,101 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(OpenCSG)
+
+if (NOT BUILD_SHARED_LIBS)
+  set(GLEW_USE_STATIC_LIBS ON)
+elseif (MSVC)
+  set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+endif()
+
+find_package(OpenGL REQUIRED)
+
+set(GLEW_VERBOSE ON)
+find_package(GLEW 1.13.0 REQUIRED)
+
+set(_srcfiles 
+    src/area.cpp
+    src/batch.cpp
+    src/context.cpp
+    src/channelManager.cpp
+    src/frameBufferObject.cpp
+    src/frameBufferObjectExt.cpp
+    src/occlusionQuery.cpp
+    src/opencsgRender.cpp
+    src/openglHelper.cpp
+    src/pBufferTexture.cpp
+    src/primitive.cpp
+    src/primitiveHelper.cpp
+    src/renderGoldfeather.cpp
+    src/renderSCS.cpp
+    src/scissorMemo.cpp
+    src/settings.cpp
+    src/stencilManager.cpp
+    RenderTexture/RenderTexture.cpp
+    include/opencsg.h
+    src/opencsgConfig.h
+    src/area.h
+    src/batch.h
+    src/context.h
+    src/channelManager.h
+    src/frameBufferObject.h
+    src/frameBufferObjectExt.h
+    src/occlusionQuery.h
+    src/offscreenBuffer.h
+    src/opencsgRender.h
+    src/openglHelper.h
+    src/pBufferTexture.h
+    src/primitiveHelper.h
+    src/scissorMemo.h
+    src/settings.h
+    src/stencilManager.h
+)
+
+add_library(opencsg ${_srcfiles})
+target_include_directories(opencsg PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
+target_include_directories(opencsg PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>)
+target_link_libraries(opencsg PRIVATE GLEW::GLEW OpenGL::GL)
+
+include(CMakePackageConfigHelpers)
+
+include(GNUInstallDirs)
+
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"     
+    VERSION 1.4.2
+    COMPATIBILITY AnyNewerVersion
+)
+
+install(TARGETS opencsg 
+  EXPORT ${PROJECT_NAME}Targets
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} 
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+export(EXPORT ${PROJECT_NAME}Targets 
+       FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" 
+       NAMESPACE ${PROJECT_NAME}:: )
+
+set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+
+install(EXPORT ${PROJECT_NAME}Targets
+  FILE
+    "${PROJECT_NAME}Config.cmake"
+  NAMESPACE
+    ${PROJECT_NAME}::
+  DESTINATION
+    ${ConfigPackageLocation}
+)
+install(
+    FILES
+      ${PROJECT_SOURCE_DIR}/include/opencsg.h 
+    DESTINATION
+      ${CMAKE_INSTALL_INCLUDEDIR}/opencsg
+)
+install(
+    FILES
+      "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
+    DESTINATION
+      ${ConfigPackageLocation}
+)
@@ -0,0 +1,17 @@
+
+orcaslicer_add_cmake_project(OpenCSG
+    # GIT_REPOSITORY https://github.com/floriankirsch/OpenCSG.git
+    # GIT_TAG 83e274457b46c9ad11a4ee599203250b1618f3b9 #v1.4.2
+    URL https://github.com/floriankirsch/OpenCSG/archive/refs/tags/opencsg-1-4-2-release.zip
+    URL_HASH SHA256=51afe0db79af8386e2027d56d685177135581e0ee82ade9d7f2caff8deab5ec5
+    PATCH_COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/CMakeLists.txt.in ./CMakeLists.txt
+    DEPENDS dep_GLEW
+)
+
+if (TARGET ${ZLIB_PKG})
+    add_dependencies(dep_OpenCSG ${ZLIB_PKG})
+endif()
+
+if (MSVC)
+    add_debug_dep(dep_OpenCSG)
+endif ()
@@ -29,33 +29,12 @@ if(WIN32)
    # driven through nmake from a Ninja configure step.
    set(_conf_cmd ${CMAKE_COMMAND} -E env ${_openssl_msvc_env} perl Configure )
    set(_cross_comp_prefix_line "")
-    if("${DEPS_ARCH}" STREQUAL "arm64")
-        # OpenSSL's VC configs pass /Gs0, which puts a __chkstk probe in every
-        # function. MSVC 14.51 and 14.52 (VS 2026) for ARM64 emit that call
-        # before the prologue saves LR, so the function returns into itself;
-        # in tls_parse_all_extensions that breaks every TLS handshake. 14.44
-        # (VS 2022) is unaffected. Restore cl's default threshold: Configure
-        # appends /Gs4096 after /Gs0, and the later option wins.
-        set(_openssl_extra_cflags /Gs4096)
-    endif()
    set(_make_cmd ${CMAKE_COMMAND} -E env ${_openssl_msvc_env} nmake)
    set(_install_cmd ${CMAKE_COMMAND} -E env ${_openssl_msvc_env} nmake install_sw )
 else()
    if(APPLE)
        set(_conf_cmd export MACOSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET} && ./Configure -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET})
    else()
-        # A static library that is embedded into a shared object must not export
-        # its symbols. On Linux the running process also loads the system OpenSSL
-        # 3.x (WebKitGTK/gnutls pull in libcrypto.so.3), and CPython's _ssl and
-        # _hashlib are dlopened (RTLD_LOCAL) DSOs that each embed this OpenSSL.
-        # With default visibility their unversioned OpenSSL references are
-        # preempted by that global 3.x copy, mixing the 1.1.1 and 3.x ABIs and
-        # corrupting the heap (ssl.create_default_context() aborts). Hidden
-        # visibility makes each embedded copy self-contained. Linux-only: macOS
-        # binds dylibs with a two-level namespace (no interposition) and ships no
-        # OpenSSL, and Windows has no equivalent flag and no system OpenSSL to
-        # collide with.
-        set(_openssl_extra_cflags -fvisibility=hidden)
        set(_conf_cmd env "CC=${CMAKE_C_COMPILER}" "LDFLAGS=${CMAKE_EXE_LINKER_FLAGS}" "./config")
    endif()
    set(_cross_comp_prefix_line "")
@@ -92,7 +71,6 @@ ExternalProject_Add(dep_OpenSSL
        # prefix stays single-layout.
        "--libdir=lib"
        ${_cross_comp_prefix_line}
-        ${_openssl_extra_cflags}
        no-shared
        no-asm
        no-ssl3-method
@@ -114,20 +92,3 @@ ExternalProject_Add_Step(dep_OpenSSL install_cmake_files
    COMMAND ${CMAKE_COMMAND} -E copy_directory openssl "${DESTDIR}${CMAKE_INSTALL_LIBDIR}/cmake/openssl"
    WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}"
 )
-
-if (NOT WIN32 AND NOT APPLE)
-    # OpenSSL's object rules do not depend on CFLAGS, so reconfiguring it (for
-    # example to add -fvisibility=hidden) relinks the archives from stale
-    # objects instead of recompiling them, and the change silently has no
-    # effect. Drop the objects whenever this recipe changes so the next build
-    # actually recompiles them.
-    ExternalProject_Get_Property(dep_OpenSSL SOURCE_DIR)
-    ExternalProject_Add_Step(dep_OpenSSL clean_objects
-        DEPENDEES configure
-        DEPENDERS build
-        COMMAND make clean
-        WORKING_DIRECTORY "${SOURCE_DIR}"
-        DEPENDS "${CMAKE_CURRENT_LIST_FILE}"
-        COMMENT "OpenSSL: cleaning objects after a recipe change"
-    )
-endif ()
@@ -299,27 +299,3 @@ endif()
 if(TARGET dep_ZLIB)
    add_dependencies(dep_python3 dep_ZLIB)
 endif()
-
-if (NOT WIN32 AND NOT APPLE)
-    # CPython's Makefile rules for _ssl and _hashlib depend only on their own
-    # sources, not on the OpenSSL archives, so a rebuilt OpenSSL does not make
-    # them relink and they keep the previous symbols. On an incremental tree,
-    # drop the built modules and relink them against the current OpenSSL; a
-    # fresh build is left alone (its PGO target builds them). "make" alone is a
-    # no-op once PGO has run, so sharedmods is invoked explicitly.
-    ExternalProject_Get_Property(dep_python3 SOURCE_DIR)
-    file(GLOB _python_ssl_modules
-        "${SOURCE_DIR}/Modules/_ssl*.so"
-        "${SOURCE_DIR}/Modules/_hashlib*.so")
-    if (_python_ssl_modules)
-        ExternalProject_Add_Step(dep_python3 relink_ssl_extensions
-            DEPENDEES configure
-            DEPENDERS build
-            COMMAND sh -c "rm -f '${SOURCE_DIR}'/Modules/_ssl*.so '${SOURCE_DIR}'/Modules/_hashlib*.so && make -j${NPROC} sharedmods"
-            WORKING_DIRECTORY "${SOURCE_DIR}"
-            COMMENT "CPython: relinking _ssl/_hashlib against the current OpenSSL"
-            DEPENDS "${CMAKE_CURRENT_LIST_FILE}"
-                    "${CMAKE_CURRENT_LIST_DIR}/../OpenSSL/OpenSSL.cmake"
-        )
-    endif ()
-endif ()
@@ -15,6 +15,7 @@ add_subdirectory(stb_dxt)     # Header-only STB DXT compression library
 # Static libraries
 add_subdirectory(Shiny)
 add_subdirectory(admesh)
+add_subdirectory(clipper)
 add_subdirectory(clipper2)
 add_subdirectory(expat)
 add_subdirectory(glu-libtess)
@@ -75,19 +75,6 @@ static FILE *stl_open_count_facets(stl_file *stl, const char *file, unsigned int
      		break;
    	}
  	}
-  	// Zero normals and coordinates like 10 or 15 have no byte above 127, so the test above can miss a binary file.
-  	// Its size still matches its facet count; text read as that count would need a file of gigabytes.
-  	if (stl->stats.type == ascii) {
-    	uint32_t header_num_facets;
-    	fseek(fp, custom_header_length, SEEK_SET);
-    	if (fread(&header_num_facets, sizeof(uint32_t), 1, fp) == 1) {
-#if BOOST_ENDIAN_BIG_BYTE
-      		stl_internal_reverse_quads((char*)&header_num_facets, 4);
-#endif /* BOOST_ENDIAN_BIG_BYTE */
-      		if (header_size + uint64_t(header_num_facets) * SIZEOF_STL_FACET == file_size)
-        		stl->stats.type = binary;
-    	}
-  	}
  	rewind(fp);

  	uint32_t num_facets = 0;
@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.13)
+project(clipper)
+
+add_library(clipper STATIC
+# We are using ClipperLib compiled as part of the libslic3r project using Slic3r::Point as its base type.
+#    clipper.cpp
+#    clipper.hpp
+    clipper_z.cpp
+    clipper_z.hpp
+)
+
+target_include_directories(clipper SYSTEM
+    PUBLIC
+        ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(clipper 
+    PUBLIC Eigen3::Eigen
+    PRIVATE TBB::tbb TBB::tbbmalloc
+)
@@ -0,0 +1,606 @@
+/*******************************************************************************
+*                                                                              *
+* Author    :  Angus Johnson                                                   *
+* Version   :  6.4.2                                                           *
+* Date      :  27 February 2017                                                *
+* Website   :  http://www.angusj.com                                           *
+* Copyright :  Angus Johnson 2010-2017                                         *
+*                                                                              *
+* License:                                                                     *
+* Use, modification & distribution is subject to Boost Software License Ver 1. *
+* http://www.boost.org/LICENSE_1_0.txt                                         *
+*                                                                              *
+* Attributions:                                                                *
+* The code in this library is an extension of Bala Vatti's clipping algorithm: *
+* "A generic solution to polygon clipping"                                     *
+* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63.             *
+* http://portal.acm.org/citation.cfm?id=129906                                 *
+*                                                                              *
+* Computer graphics and geometric modeling: implementation and algorithms      *
+* By Max K. Agoston                                                            *
+* Springer; 1 edition (January 4, 2005)                                        *
+* http://books.google.com/books?q=vatti+clipping+agoston                       *
+*                                                                              *
+* See also:                                                                    *
+* "Polygon Offsetting by Computing Winding Numbers"                            *
+* Paper no. DETC2005-85513 pp. 565-575                                         *
+* ASME 2005 International Design Engineering Technical Conferences             *
+* and Computers and Information in Engineering Conference (IDETC/CIE2005)      *
+* September 24-28, 2005 , Long Beach, California, USA                          *
+* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf              *
+*                                                                              *
+*******************************************************************************/
+
+#ifndef clipper_hpp
+#define clipper_hpp
+
+#include <inttypes.h>
+#include <functional>
+
+#include <Eigen/Geometry> 
+
+#include <oneapi/tbb/scalable_allocator.h>
+
+#define CLIPPER_VERSION "6.2.6"
+
+//CLIPPERLIB_USE_XYZ: adds a Z member to IntPoint. Adds a minor cost to perfomance.
+//#define CLIPPERLIB_USE_XYZ
+
+//use_lines: Enables line clipping. Adds a very minor cost to performance.
+#define use_lines
+  
+//use_deprecated: Enables temporary support for the obsolete functions
+//#define use_deprecated  
+
+#include <array>
+#include <vector>
+#include <deque>
+#include <stdexcept>
+#include <cstring>
+#include <cstdlib>
+#include <ostream>
+#include <functional>
+#include <queue>
+
+#ifdef CLIPPERLIB_NAMESPACE_PREFIX
+  namespace CLIPPERLIB_NAMESPACE_PREFIX {
+#endif // CLIPPERLIB_NAMESPACE_PREFIX
+
+#ifdef CLIPPERLIB_USE_XYZ
+  namespace ClipperLib_Z {
+#else
+  namespace ClipperLib {
+#endif
+
+enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
+enum PolyType { ptSubject, ptClip };
+//By far the most widely used winding rules for polygon filling are
+//EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
+//Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
+//see http://glprogramming.com/red/chapter11.html
+enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
+
+// If defined, Clipper will work with 32bit signed int coordinates to reduce memory
+// consumption and to speed up exact orientation predicate calculation.
+// In that case, coordinates and their differences (vectors of the coordinates) have to fit int32_t.
+// #define CLIPPERLIB_INT32
+
+// Point coordinate type
+#ifdef CLIPPERLIB_INT32
+  // Coordinates and their differences (vectors of the coordinates) have to fit int32_t.
+  using cInt = int32_t;
+  using CrossProductType = int64_t;
+#else
+  using cInt = int64_t;
+  using CrossProductType = double;
+  // Maximum cInt value to allow a cross product calculation using 32bit expressions.
+  static constexpr cInt const loRange = 0x3FFFFFFF; // 0x3FFFFFFF = 1 073 741 823
+  // Maximum allowed cInt value.
+  static constexpr cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL;
+#endif // CLIPPERLIB_INT32
+
+#ifdef CLIPPERLIB_INTPOINT_TYPE
+using IntPoint = CLIPPERLIB_INTPOINT_TYPE;
+#else // CLIPPERLIB_INTPOINT_TYPE
+using IntPoint = Eigen::Matrix<cInt, 
+#ifdef CLIPPERLIB_USE_XYZ
+  3
+#else // CLIPPERLIB_USE_XYZ
+  2
+#endif // CLIPPERLIB_USE_XYZ
+  , 1, Eigen::DontAlign>;
+#endif // CLIPPERLIB_INTPOINT_TYPE
+
+using DoublePoint = Eigen::Matrix<double, 2, 1, Eigen::DontAlign>;
+
+//------------------------------------------------------------------------------
+
+template<typename BaseType>
+using Allocator = tbb::scalable_allocator<BaseType>;
+//using Allocator = std::allocator<BaseType>;
+using Path      = std::vector<IntPoint, Allocator<IntPoint>>;
+using Paths     = std::vector<Path, Allocator<Path>>;
+
+inline Path& operator <<(Path& poly, const IntPoint& p) {poly.push_back(p); return poly;}
+inline Paths& operator <<(Paths& polys, const Path& p) {polys.push_back(p); return polys;}
+
+std::ostream& operator <<(std::ostream &s, const IntPoint &p);
+std::ostream& operator <<(std::ostream &s, const Path &p);
+std::ostream& operator <<(std::ostream &s, const Paths &p);
+
+//------------------------------------------------------------------------------
+
+#ifdef CLIPPERLIB_USE_XYZ
+typedef std::function<void(const IntPoint& e1bot, const IntPoint& e1top, const IntPoint& e2bot, const IntPoint& e2top, IntPoint& pt)> ZFillCallback;
+#endif
+
+enum InitOptions {ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4};
+enum JoinType {jtSquare, jtRound, jtMiter};
+enum EndType {etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound};
+
+class PolyNode;
+typedef std::vector<PolyNode*, Allocator<PolyNode*>> PolyNodes;
+
+class PolyNode 
+{ 
+public:
+    PolyNode() : Parent(0), Index(0), m_IsOpen(false) {}
+    virtual ~PolyNode(){};
+    Path Contour;
+    PolyNodes Childs;
+    PolyNode* Parent;
+    // Traversal of the polygon tree in a depth first fashion.
+    PolyNode* GetNext() const { return Childs.empty() ? GetNextSiblingUp() : Childs.front(); }
+    bool IsHole() const;
+    bool IsOpen() const { return m_IsOpen; }  
+    int  ChildCount() const { return (int)Childs.size(); }
+private:
+    unsigned Index; //node index in Parent.Childs
+    bool m_IsOpen;
+    JoinType m_jointype;
+    EndType m_endtype;
+    PolyNode* GetNextSiblingUp() const { return Parent ? ((Index == Parent->Childs.size() - 1) ? Parent->GetNextSiblingUp() : Parent->Childs[Index + 1]) : nullptr; }
+    void AddChild(PolyNode& child);
+    friend class Clipper; //to access Index
+    friend class ClipperOffset;
+    friend class PolyTree; //to implement the PolyTree::move operator
+};
+
+class PolyTree: public PolyNode
+{ 
+public:
+    PolyTree() {}
+    PolyTree(PolyTree &&src) { *this = std::move(src); }
+    virtual ~PolyTree(){Clear();};
+    PolyTree& operator=(PolyTree &&src) { 
+        AllNodes   = std::move(src.AllNodes);
+        Contour    = std::move(src.Contour);
+        Childs     = std::move(src.Childs);
+        Parent     = nullptr;
+        Index      = src.Index;
+        m_IsOpen   = src.m_IsOpen;
+        m_jointype = src.m_jointype;
+        m_endtype  = src.m_endtype;
+        for (size_t i = 0; i < Childs.size(); ++ i)
+          Childs[i]->Parent = this;
+        return *this; 
+    }
+    PolyNode* GetFirst() const { return Childs.empty() ? nullptr : Childs.front(); }
+    void Clear() {  AllNodes.clear(); Childs.clear(); }
+    int Total() const;
+    void RemoveOutermostPolygon();
+private:
+    PolyTree(const PolyTree &src) = delete;
+    PolyTree& operator=(const PolyTree &src) = delete;
+    std::vector<PolyNode, Allocator<PolyNode>> AllNodes;
+    friend class Clipper; //to access AllNodes
+};
+
+double Area(const Path &poly);
+inline bool Orientation(const Path &poly) { return Area(poly) >= 0; }
+int PointInPolygon(const IntPoint &pt, const Path &path);
+
+// Union with "strictly simple" fix enabled.
+Paths SimplifyPolygon(const Path &in_poly, PolyFillType fillType = pftNonZero, bool strictly_simple = true);
+
+void CleanPolygon(const Path& in_poly, Path& out_poly, double distance = 1.415);
+void CleanPolygon(Path& poly, double distance = 1.415);
+void CleanPolygons(const Paths& in_polys, Paths& out_polys, double distance = 1.415);
+void CleanPolygons(Paths& polys, double distance = 1.415);
+
+void MinkowskiSum(const Path& pattern, const Path& path, Paths& solution, bool pathIsClosed);
+void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed);
+void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution);
+
+void PolyTreeToPaths(const PolyTree& polytree, Paths& paths);
+void PolyTreeToPaths(PolyTree&& polytree, Paths& paths);
+void ClosedPathsFromPolyTree(const PolyTree& polytree, Paths& paths);
+void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths);
+
+void ReversePath(Path& p);
+void ReversePaths(Paths& p);
+
+struct IntRect { cInt left; cInt top; cInt right; cInt bottom; };
+
+//enums that are used internally ...
+enum EdgeSide { esLeft = 1, esRight = 2};
+
+// namespace Internal {
+  //forward declarations (for stuff used internally) ...
+  struct TEdge {
+    // Bottom point of this edge (with minimum Y).
+    IntPoint Bot;
+    // Current position.
+    IntPoint Curr;
+    // Top point of this edge (with maximum Y).
+    IntPoint Top;
+    // Slope (dx/dy). For horiontal edges, the slope is set to HORIZONTAL (-1.0E+40).
+    double Dx;
+    PolyType PolyTyp;
+    EdgeSide Side;
+    // Winding number delta. 1 or -1 depending on winding direction, 0 for open paths and flat closed paths.
+    int WindDelta;
+    int WindCnt;
+    int WindCnt2; //winding count of the opposite polytype
+    int OutIdx;
+    // Next edge in the input path.
+    TEdge *Next;
+    // Previous edge in the input path.
+    TEdge *Prev;
+    // Next edge in the Local Minima List chain.
+    TEdge *NextInLML;
+    TEdge *NextInAEL;
+    TEdge *PrevInAEL;
+    TEdge *NextInSEL;
+    TEdge *PrevInSEL;
+  };
+
+  struct IntersectNode {
+    IntersectNode(TEdge *Edge1, TEdge *Edge2, IntPoint Pt) :
+      Edge1(Edge1), Edge2(Edge2), Pt(Pt) {}
+    TEdge          *Edge1;
+    TEdge          *Edge2;
+    IntPoint        Pt;
+  };
+
+  struct LocalMinimum {
+    cInt          Y;
+    TEdge        *LeftBound;
+    TEdge        *RightBound;
+  };
+
+  // Point of an output polygon.
+  // 36B on 64bit system without CLIPPERLIB_USE_XYZ.
+  struct OutPt {
+    // 4B
+    int       Idx;
+    // 16B without CLIPPERLIB_USE_XYZ / 24B with CLIPPERLIB_USE_XYZ
+    IntPoint  Pt;
+    // 4B on 32bit system, 8B on 64bit system
+    OutPt    *Next;
+    // 4B on 32bit system, 8B on 64bit system
+    OutPt    *Prev;
+  };
+
+  using OutPts = std::vector<OutPt, Allocator<OutPt>>;
+
+  // Output polygon.
+  struct OutRec {
+      int       Idx;
+      bool      IsHole;
+      bool      IsOpen;
+      //The 'FirstLeft' field points to another OutRec that contains or is the
+      //'parent' of OutRec. It is 'first left' because the ActiveEdgeList (AEL) is
+      //parsed left from the current edge (owning OutRec) until the owner OutRec
+      //is found. This field simplifies sorting the polygons into a tree structure
+      //which reflects the parent/child relationships of all polygons.
+      //This field should be renamed Parent, and will be later.
+      OutRec* FirstLeft;
+      // Used only by void Clipper::BuildResult2(PolyTree& polytree)
+      PolyNode* PolyNd;
+      // Linked list of output points, dynamically allocated.
+      OutPt* Pts;
+      OutPt* BottomPt;
+  };
+
+  struct Join {
+    Join(OutPt *OutPt1, OutPt *OutPt2, IntPoint OffPt) :
+      OutPt1(OutPt1), OutPt2(OutPt2), OffPt(OffPt) {}
+    OutPt    *OutPt1;
+    OutPt    *OutPt2;
+    IntPoint  OffPt;
+  };
+// }; // namespace Internal
+
+//------------------------------------------------------------------------------
+
+//ClipperBase is the ancestor to the Clipper class. It should not be
+//instantiated directly. This class simply abstracts the conversion of sets of
+//polygon coordinates into edge objects that are stored in a LocalMinima list.
+class ClipperBase
+{
+public:
+  ClipperBase() : 
+#ifndef CLIPPERLIB_INT32
+    m_UseFullRange(false), 
+#endif // CLIPPERLIB_INT32
+    m_HasOpenPaths(false) {}
+  ~ClipperBase() { Clear(); }
+  bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed);
+
+  template<typename PathsProvider>
+  bool AddPaths(PathsProvider &&paths_provider, PolyType PolyTyp, bool Closed)
+  {
+    size_t num_paths = paths_provider.size();
+    if (num_paths == 0)
+        return false;
+    if (num_paths == 1)
+        return AddPath(*paths_provider.begin(), PolyTyp, Closed);
+
+    std::vector<int, Allocator<int>> num_edges(num_paths, 0);
+    int num_edges_total = 0;
+    size_t i = 0;
+    for (const Path &pg : paths_provider) {
+      // Remove duplicate end point from a closed input path.
+      // Remove duplicate points from the end of the input path.
+      int highI = (int)pg.size() -1;
+      if (Closed) 
+        while (highI > 0 && (pg[highI] == pg[0])) 
+          --highI;
+      while (highI > 0 && (pg[highI] == pg[highI -1])) 
+        --highI;
+      if ((Closed && highI < 2) || (!Closed && highI < 1))
+        highI = -1;
+      num_edges[i ++] = highI + 1;
+      num_edges_total += highI + 1;
+    }
+    if (num_edges_total == 0)
+      return false;
+
+    // Allocate a new edge array.
+    std::vector<TEdge, Allocator<TEdge>> edges(num_edges_total);
+    // Fill in the edge array.
+    bool result = false;
+    TEdge *p_edge = edges.data();
+    i = 0;
+    for (const Path &pg : paths_provider) {
+      if (num_edges[i] && !pg.empty()) {
+        bool res = AddPathInternal(pg, num_edges[i] - 1, PolyTyp, Closed, p_edge);
+        if (res) {
+          p_edge += num_edges[i];
+          result = true;
+        }
+      }
+      ++ i;
+    }
+    if (result)
+      // At least some edges were generated. Remember the edge array.
+      m_edges.emplace_back(std::move(edges));
+    return result;
+  }
+
+  void Clear();
+  IntRect GetBounds();
+  // By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before clipping.
+  // When enabled the PreserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.
+  bool PreserveCollinear() const {return m_PreserveCollinear;};
+  void PreserveCollinear(bool value) {m_PreserveCollinear = value;};
+protected:
+  bool AddPathInternal(const Path &pg, int highI, PolyType PolyTyp, bool Closed, TEdge* edges);
+  TEdge* AddBoundsToLML(TEdge *e, bool IsClosed);
+  void Reset();
+  TEdge* ProcessBound(TEdge* E, bool IsClockwise);
+  TEdge* DescendToMin(TEdge *&E);
+  void AscendToMax(TEdge *&E, bool Appending, bool IsClosed);
+
+  // Local minima (Y, left edge, right edge) sorted by ascending Y.
+  std::vector<LocalMinimum, Allocator<LocalMinimum>> m_MinimaList;
+
+#ifdef CLIPPERLIB_INT32
+  static constexpr const bool m_UseFullRange = false;
+#else // CLIPPERLIB_INT32
+  // True if the input polygons have abs values higher than loRange, but lower than hiRange.
+  // False if the input polygons have abs values lower or equal to loRange.
+  bool              m_UseFullRange;
+#endif // CLIPPERLIB_INT32
+
+  // A vector of edges per each input path.
+  using Edges = std::vector<TEdge, Allocator<TEdge>>;
+  std::vector<Edges, Allocator<Edges>> m_edges;
+  // Don't remove intermediate vertices of a collinear sequence of points.
+  bool             m_PreserveCollinear;
+  // Is any of the paths inserted by AddPath() or AddPaths() open?
+  bool             m_HasOpenPaths;
+};
+//------------------------------------------------------------------------------
+
+class Clipper : public ClipperBase
+{
+public:
+  Clipper(int initOptions = 0);
+  ~Clipper() { Clear(); }
+  void Clear() { ClipperBase::Clear(); DisposeAllOutRecs(); }
+  bool Execute(ClipType clipType,
+      Paths &solution,
+      PolyFillType fillType = pftEvenOdd) 
+    { return Execute(clipType, solution, fillType, fillType); }
+  bool Execute(ClipType clipType,
+      Paths &solution,
+      PolyFillType subjFillType,
+      PolyFillType clipFillType);
+  bool Execute(ClipType clipType,
+      PolyTree &polytree,
+      PolyFillType fillType = pftEvenOdd)
+    { return Execute(clipType, polytree, fillType, fillType); }
+  bool Execute(ClipType clipType,
+      PolyTree &polytree,
+      PolyFillType subjFillType,
+      PolyFillType clipFillType);
+  bool ReverseSolution() const { return m_ReverseOutput; };
+  void ReverseSolution(bool value) {m_ReverseOutput = value;};
+  bool StrictlySimple() const {return m_StrictSimple;};
+  void StrictlySimple(bool value) {m_StrictSimple = value;};
+  //set the callback function for z value filling on intersections (otherwise Z is 0)
+#ifdef CLIPPERLIB_USE_XYZ
+  void ZFillFunction(ZFillCallback zFillFunc) { m_ZFill = zFillFunc; }
+#endif
+protected:
+  void Reset();
+  virtual bool ExecuteInternal();
+private:
+  
+  // Output polygons.
+  std::deque<OutRec, Allocator<OutRec>>  m_PolyOuts;
+  // Output points, allocated by a continuous sets of m_OutPtsChunkSize.
+  static constexpr const size_t m_OutPtsChunkSize = 32;
+  std::deque<std::array<OutPt, m_OutPtsChunkSize>, Allocator<std::array<OutPt, m_OutPtsChunkSize>>> m_OutPts;
+  // List of free output points, to be used before taking a point from m_OutPts or allocating a new chunk.
+  OutPt                *m_OutPtsFree;
+  size_t                m_OutPtsChunkLast;
+
+  std::vector<Join, Allocator<Join>>     m_Joins;
+  std::vector<Join, Allocator<Join>>     m_GhostJoins;
+  std::vector<IntersectNode, Allocator<IntersectNode>> m_IntersectList;
+  ClipType              m_ClipType;
+  // A priority queue (a binary heap) of Y coordinates.
+  using cInts = std::vector<cInt, Allocator<cInt>>;
+  std::priority_queue<cInt, cInts> m_Scanbeam;
+  // Maxima are collected by ProcessEdgesAtTopOfScanbeam(), consumed by ProcessHorizontal().
+  cInts                 m_Maxima;
+  TEdge                *m_ActiveEdges;
+  TEdge                *m_SortedEdges;
+  PolyFillType          m_ClipFillType;
+  PolyFillType          m_SubjFillType;
+  bool                  m_ReverseOutput;
+  // Does the result go to a PolyTree or Paths?
+  bool                  m_UsingPolyTree; 
+  bool                  m_StrictSimple;
+#ifdef CLIPPERLIB_USE_XYZ
+  ZFillCallback         m_ZFill; //custom callback 
+#endif
+  void SetWindingCount(TEdge& edge) const;
+  bool IsEvenOddFillType(const TEdge& edge) const 
+    { return (edge.PolyTyp == ptSubject) ? m_SubjFillType == pftEvenOdd : m_ClipFillType == pftEvenOdd; }
+  bool IsEvenOddAltFillType(const TEdge& edge) const
+    { return (edge.PolyTyp == ptSubject) ? m_ClipFillType == pftEvenOdd : m_SubjFillType == pftEvenOdd; }
+  void InsertLocalMinimaIntoAEL(const cInt botY);
+  void InsertEdgeIntoAEL(TEdge *edge, TEdge* startEdge);
+  void AddEdgeToSEL(TEdge *edge);
+  void CopyAELToSEL();
+  void DeleteFromSEL(TEdge *e);
+  void DeleteFromAEL(TEdge *e);
+  void UpdateEdgeIntoAEL(TEdge *&e);
+  void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2);
+  bool IsContributing(const TEdge& edge) const;
+  bool IsTopHorz(const cInt XPos);
+  void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
+  void DoMaxima(TEdge *e);
+  void ProcessHorizontals();
+  void ProcessHorizontal(TEdge *horzEdge);
+  void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
+  OutPt* AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
+  OutRec* GetOutRec(int idx);
+  void AppendPolygon(TEdge *e1, TEdge *e2);
+  void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
+  OutRec* CreateOutRec();
+  OutPt* AddOutPt(TEdge *e, const IntPoint &pt);
+  OutPt* GetLastOutPt(TEdge *e);
+  OutPt* AllocateOutPt();
+  OutPt* DupOutPt(OutPt* outPt, bool InsertAfter);
+  // Add the point to a list of free points.
+  void DisposeOutPt(OutPt *pt) { pt->Next = m_OutPtsFree; m_OutPtsFree = pt; }
+  void DisposeOutPts(OutPt*& pp) { if (pp != nullptr) { pp->Prev->Next = m_OutPtsFree; m_OutPtsFree = pp; } }
+  void DisposeAllOutRecs();
+  bool ProcessIntersections(const cInt topY);
+  void BuildIntersectList(const cInt topY);
+  void ProcessEdgesAtTopOfScanbeam(const cInt topY);
+  void BuildResult(Paths& polys);
+  void BuildResult2(PolyTree& polytree);
+  void SetHoleState(TEdge *e, OutRec *outrec);
+  bool FixupIntersectionOrder();
+  void FixupOutPolygon(OutRec &outrec);
+  void FixupOutPolyline(OutRec &outrec);
+  bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl);
+  void FixHoleLinkage(OutRec &outrec);
+  bool JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2);
+  bool JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b, const IntPoint &Pt, bool DiscardLeft);
+  void JoinCommonEdges();
+  void DoSimplePolygons();
+  void FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec);
+  void FixupFirstLefts2(OutRec* InnerOutRec, OutRec* OuterOutRec);
+  void FixupFirstLefts3(OutRec* OldOutRec, OutRec* NewOutRec);
+#ifdef CLIPPERLIB_USE_XYZ
+  void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2);
+#endif
+};
+//------------------------------------------------------------------------------
+
+class ClipperOffset 
+{
+public:
+  ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25, double shortestEdgeLength = 0.) :
+    MiterLimit(miterLimit), ArcTolerance(roundPrecision), ShortestEdgeLength(shortestEdgeLength), m_lowest(-1, 0) {}
+  ~ClipperOffset() { Clear(); }
+  void AddPath(const Path& path, JoinType joinType, EndType endType);
+  template<typename PathsProvider>
+  void AddPaths(PathsProvider &&paths, JoinType joinType, EndType endType) {
+    for (const Path &path : paths)
+      AddPath(path, joinType, endType);
+  }
+  void Execute(Paths& solution, double delta);
+  void Execute(PolyTree& solution, double delta);
+  void Clear();
+  double MiterLimit;
+  double ArcTolerance;
+  double ShortestEdgeLength;
+
+private:
+  Paths m_destPolys;
+  Path m_srcPoly;
+  Path m_destPoly;
+  std::vector<DoublePoint, Allocator<DoublePoint>> m_normals;
+  double m_delta, m_sinA, m_sin, m_cos;
+  double m_miterLim, m_StepsPerRad;
+  // x: index of the lowest contour in m_polyNodes
+  // y: index of the lowest point in the lowest contour
+  IntPoint m_lowest;
+  PolyNode m_polyNodes;
+
+  void FixOrientations();
+  void DoOffset(double delta);
+  void OffsetPoint(int j, int& k, JoinType jointype);
+  void DoSquare(int j, int k);
+  void DoMiter(int j, int k, double r);
+  void DoRound(int j, int k);
+};
+//------------------------------------------------------------------------------
+
+class clipperException : public std::exception
+{
+  public:
+    clipperException(const char* description): m_descr(description) {}
+    virtual ~clipperException() throw() {}
+    virtual const char* what() const throw() {return m_descr.c_str();}
+  private:
+    std::string m_descr;
+};
+//------------------------------------------------------------------------------
+
+// Union with "strictly simple" fix enabled.
+template<typename PathsProvider>
+inline Paths SimplifyPolygons(PathsProvider &&in_polys, PolyFillType fillType = pftNonZero, bool strictly_simple = true) {
+    Clipper c;
+    c.StrictlySimple(strictly_simple);
+    c.AddPaths(std::forward<PathsProvider>(in_polys), ptSubject, true);
+    Paths out;
+    c.Execute(ctUnion, out, fillType, fillType);
+    return out;
+}
+
+} //ClipperLib namespace
+
+#ifdef CLIPPERLIB_NAMESPACE_PREFIX
+} // namespace CLIPPERLIB_NAMESPACE_PREFIX
+#endif // CLIPPERLIB_NAMESPACE_PREFIX
+
+#endif //clipper_hpp
@@ -0,0 +1,7 @@
+// Hackish wrapper around the ClipperLib library to compile the Clipper library with the Z support.
+
+// Enable the Z coordinate support.
+#define CLIPPERLIB_USE_XYZ
+
+// and let it compile
+#include "clipper.cpp"
@@ -0,0 +1,18 @@
+// Hackish wrapper around the ClipperLib library to compile the Clipper library with the Z support.
+
+#ifndef clipper_z_hpp
+#ifdef clipper_hpp
+#error "You should include clipper_z.hpp before clipper.hpp"
+#endif
+
+#define clipper_z_hpp
+
+// Enable the Z coordinate support.
+#define CLIPPERLIB_USE_XYZ
+
+#include "clipper.hpp"
+
+#undef clipper_hpp
+#undef CLIPPERLIB_USE_XYZ
+
+#endif // clipper_z_hpp
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.10)
-project(Clipper2 VERSION 2.0.1 LANGUAGES C CXX)
+project(Clipper2 VERSION 1.5.2 LANGUAGES C CXX)

 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_CXX_STANDARD 17)
@@ -19,7 +19,6 @@ set(CLIPPER2_INC
  Clipper2Lib/include/clipper2/clipper.minkowski.h
  Clipper2Lib/include/clipper2/clipper.offset.h
  Clipper2Lib/include/clipper2/clipper.rectclip.h
-  Clipper2Lib/include/clipper2/clipper.triangulation.h
  Clipper2Lib/include/clipper2/clipper2_z.hpp
 )

@@ -27,7 +26,6 @@ set(CLIPPER2_SRC
  Clipper2Lib/src/clipper.engine.cpp
  Clipper2Lib/src/clipper.offset.cpp
  Clipper2Lib/src/clipper.rectclip.cpp
-  Clipper2Lib/src/clipper.triangulation.cpp
  Clipper2Lib/src/clipper2_z.cpp
 )

@@ -38,9 +36,6 @@ target_include_directories(Clipper2
  PUBLIC Clipper2Lib/include
 )

-# Engine nodes are allocated through tbbmalloc (see clipper.engine.cpp).
-target_link_libraries(Clipper2 PRIVATE TBB::tbbmalloc)
-
 if (WIN32)
  if (MSVC AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    target_compile_options(Clipper2 PRIVATE /W4 /WX)
@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  12 October 2025                                                 *
+* Date      :  12 May 2024                                                     *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2025                                         *
+* Copyright :  Angus Johnson 2010-2024                                         *
 * Purpose   :  Core Clipper Library structures and functions                   *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -251,20 +251,6 @@ namespace Clipper2Lib {
  template <typename T>
  using Paths = std::vector<Path<T>>;

-  template <typename T, typename T2=T>
-  Path<T>& operator<<(Path<T>& poly, const Point<T2>& p)
-  {
-    poly.emplace_back(p);
-    return poly;
-  }
-
-  template <typename T>
-  Paths<T>& operator<<(Paths<T>& polys, const Path<T>& p)
-  {
-    polys.emplace_back(p);
-    return polys;
-  }
-
  using Path64 = Path<int64_t>;
  using PathD = Path<double>;
  using Paths64 = std::vector< Path64>;
@@ -699,31 +685,32 @@ namespace Clipper2Lib {

  inline int TriSign(int64_t x) // returns 0, 1 or -1
  {
-    return (x > 0) - (x < 0); 
+    return (x > 0) - (x < 0);
  }

-  struct UInt128Struct
+  struct MultiplyUInt64Result
  {
-    const uint64_t lo = 0;
-    const uint64_t hi = 0;
+    const uint64_t result = 0;
+    const uint64_t carry = 0;

-    bool operator==(const UInt128Struct& other) const
+    bool operator==(const MultiplyUInt64Result& other) const
    {
-      return lo == other.lo && hi == other.hi;
+      return result == other.result && carry == other.carry;
    };
-
  };

-  inline UInt128Struct MultiplyUInt64(uint64_t a, uint64_t b) // #834, #835
+  inline MultiplyUInt64Result Multiply(uint64_t a, uint64_t b) // #834, #835
  {
-    // note to self - lamba expressions follow
    const auto lo = [](uint64_t x) { return x & 0xFFFFFFFF; };
    const auto hi = [](uint64_t x) { return x >> 32; };

    const uint64_t x1 = lo(a) * lo(b);
    const uint64_t x2 = hi(a) * lo(b) + hi(x1);
    const uint64_t x3 = lo(a) * hi(b) + lo(x2);
-    return { uint64_t(lo(x3) << 32 | lo(x1)), uint64_t(hi(a) * hi(b) + hi(x2) + hi(x3)) };
+    const uint64_t result = lo(x3) << 32 | lo(x1);
+    const uint64_t carry = hi(a) * hi(b) + hi(x2) + hi(x3);
+
+    return { result, carry };
  }

  // returns true if (and only if) a * b == c * d
@@ -740,50 +727,14 @@ namespace Clipper2Lib {
    const auto abs_c = static_cast<uint64_t>(std::abs(c));
    const auto abs_d = static_cast<uint64_t>(std::abs(d));

-    const auto ab = MultiplyUInt64(abs_a, abs_b);
-    const auto cd = MultiplyUInt64(abs_c, abs_d);
+    const auto abs_ab = Multiply(abs_a, abs_b);
+    const auto abs_cd = Multiply(abs_c, abs_d);

    // nb: it's important to differentiate 0 values here from other values
    const auto sign_ab = TriSign(a) * TriSign(b);
    const auto sign_cd = TriSign(c) * TriSign(d);

-    return ab == cd && sign_ab == sign_cd;
-#endif
-  }
-
-  template <typename T>
-  inline int CrossProductSign(const Point<T>& pt1, const Point<T>& pt2, const Point<T>& pt3)
-  {
-    const auto a = pt2.x - pt1.x;
-    const auto b = pt3.y - pt2.y;
-    const auto c = pt2.y - pt1.y;
-    const auto d = pt3.x - pt2.x;
-
-#if (defined(__clang__) || defined(__GNUC__)) && UINTPTR_MAX >= UINT64_MAX
-    const auto ab = static_cast<__int128_t>(a) * static_cast<__int128_t>(b);
-    const auto cd = static_cast<__int128_t>(c) * static_cast<__int128_t>(d);
-    if (ab > cd) return 1;
-    else if (ab < cd) return -1;
-    else return 0;
-#else
-    const auto ab = MultiplyUInt64(std::abs(a), std::abs(b));
-    const auto cd = MultiplyUInt64(std::abs(c), std::abs(d));
-
-    const auto sign_ab = TriSign(a) * TriSign(b);
-    const auto sign_cd = TriSign(c) * TriSign(d);
-
-    if (sign_ab == sign_cd)
-    {
-      int result;
-      if (ab.hi == cd.hi)
-      {
-        if (ab.lo == cd.lo) return 0;
-        result = (ab.lo > cd.lo) ? 1 : -1;
-      }
-      else result = (ab.hi > cd.hi) ? 1 : -1;
-      return (sign_ab > 0) ? result : -result;
-    }
-    return (sign_ab > sign_cd) ? 1 : -1;
+    return abs_ab == abs_cd && sign_ab == sign_cd;
 #endif
  }

@@ -887,10 +838,6 @@ namespace Clipper2Lib {
    return Area<T>(poly) >= 0;
  }

-  // GetLineIntersectPt - a 'true' result is non-parallel. The 'ip' will also
-  // be constrained to seg1. However, it's possible that 'ip' won't be inside
-  // seg2, even when 'ip' hasn't been constrained (ie 'ip' is inside seg1).
-
 #if CLIPPER2_HI_PRECISION
  // caution: this will compromise performance
  // https://github.com/AngusJohnson/Clipper2/issues/317#issuecomment-1314023253
@@ -898,7 +845,7 @@ namespace Clipper2Lib {
  #define CC_MIN(x,y) ((x)>(y)?(y):(x))
  #define CC_MAX(x,y) ((x)<(y)?(y):(x))
  template<typename T>
-  inline bool GetLineIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
+  inline bool GetSegmentIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
    const Point<T>& ln2a, const Point<T>& ln2b, Point<T>& ip)
  {
    double ln1dy = static_cast<double>(ln1b.y - ln1a.y);
@@ -944,14 +891,11 @@ namespace Clipper2Lib {
      ip.x = originx + static_cast<T>(hitx);
      ip.y = originy + static_cast<T>(hity);
    }
-#ifdef USINGZ
-    ip.z = 0;
-#endif
    return true;
 }
 #else
  template<typename T>
-  inline bool GetLineIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
+  inline bool GetSegmentIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
    const Point<T>& ln2a, const Point<T>& ln2b, Point<T>& ip)
  {
    // https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
@@ -969,10 +913,7 @@ namespace Clipper2Lib {
    {
      ip.x = static_cast<T>(ln1a.x + t * dx1);
      ip.y = static_cast<T>(ln1a.y + t * dy1);
-#ifdef USINGZ
-      ip.z = 0;
-#endif
-    }
+  }
    return true;
  }
 #endif
@@ -999,53 +940,30 @@ namespace Clipper2Lib {
  }

  template<typename T>
-  inline int GetSign(const T& val) 
-  { 
-    if (!val) return 0; 
+  inline int GetSign(const T& val)
+  {
+    if (!val) return 0;
    return (val > 0) ? 1 : -1;
  }

  inline bool SegmentsIntersect(const Point64& seg1a, const Point64& seg1b,
    const Point64& seg2a, const Point64& seg2b, bool inclusive = false)
  {
-    double dy1 = static_cast<double>(seg1b.y - seg1a.y);
-    double dx1 = static_cast<double>(seg1b.x - seg1a.x);
-    double dy2 = static_cast<double>(seg2b.y - seg2a.y);
-    double dx2 = static_cast<double>(seg2b.x - seg2a.x);
-    double cp = dy1 * dx2 - dy2 * dx1;
-    if (cp == 0) return false; // ie parallel segments
-
    if (inclusive)
    {
-      //result **includes** segments that touch at an end point
-      double t = ((seg1a.x - seg2a.x) * dy2 - (seg1a.y - seg2a.y) * dx2);
-      if (t == 0) return true;
-      if (t > 0)
-      {
-        if (cp < 0 || t > cp) return false;
-      }
-      else if (cp > 0 || t < cp) return false; // false when t more neg. than cp
-
-      t = ((seg1a.x - seg2a.x) * dy1 - (seg1a.y - seg2a.y) * dx1);
-      if (t == 0) return true;
-      if (t > 0)  return (cp > 0 && t <= cp);
-      else return (cp < 0 && t >= cp);        // true when t less neg. than cp
+      double res1 = CrossProduct(seg1a, seg2a, seg2b);
+      double res2 = CrossProduct(seg1b, seg2a, seg2b);
+      if (res1 * res2 > 0) return false;
+      double res3 = CrossProduct(seg2a, seg1a, seg1b);
+      double res4 = CrossProduct(seg2b, seg1a, seg1b);
+      if (res3 * res4 > 0) return false;
+      return (res1 || res2 || res3 || res4); // ensures not collinear
    }
-    else 
-    {
-      //result **excludes** segments that touch at an end point
-      double t = ((seg1a.x - seg2a.x) * dy2 - (seg1a.y - seg2a.y) * dx2);
-      if (t == 0) return false;
-      if (t > 0)
-      {
-        if (cp < 0 || t >= cp) return false;
-      }
-      else if (cp > 0 || t <= cp ) return false; // false when t more neg. than cp
-
-      t = ((seg1a.x - seg2a.x) * dy1 - (seg1a.y - seg2a.y) * dx1);
-      if (t == 0) return false;
-      if (t > 0)  return (cp > 0 && t < cp);
-      else return (cp < 0 && t > cp); // true when t less neg. than cp
+    else {
+      return (GetSign(CrossProduct(seg1a, seg2a, seg2b)) *
+        GetSign(CrossProduct(seg1b, seg2a, seg2b)) < 0) &&
+        (GetSign(CrossProduct(seg2a, seg1a, seg1b)) *
+          GetSign(CrossProduct(seg2b, seg1a, seg1b)) < 0);
    }
  }

@@ -1133,7 +1051,7 @@ namespace Clipper2Lib {
        val = 1 - val; // toggle val
      else
      {
-        int d = CrossProductSign(*prev, *curr, pt);
+        double d = CrossProduct(*prev, *curr, pt);
        if (d == 0) return PointInPolygonResult::IsOn;
        if ((d < 0) == is_above) val = 1 - val;
      }
@@ -1147,7 +1065,7 @@ namespace Clipper2Lib {
      if (curr == cend) curr = cbegin;
      if (curr == cbegin) prev = cend - 1;
      else prev = curr - 1;
-      int d = CrossProductSign(*prev, *curr, pt);
+      double d = CrossProduct(*prev, *curr, pt);
      if (d == 0) return PointInPolygonResult::IsOn;
      if ((d < 0) == is_above) val = 1 - val;
    }
@@ -15,13 +15,6 @@
 #include <functional>
 #include <memory>

-// Orca: engine nodes are allocated through tbbmalloc, see clipper.engine.cpp.
-#define CLIPPER2_NODE_ALLOCATOR \
-	static void* operator new(size_t size); \
-	static void operator delete(void* ptr) noexcept; \
-	static void* operator new[](size_t size); \
-	static void operator delete[](void* ptr) noexcept;
-
 #ifdef USINGZ
 namespace Clipper2Lib_Z {
 #else
@@ -57,7 +50,6 @@ namespace Clipper2Lib {
 	}

 	struct Vertex {
-		CLIPPER2_NODE_ALLOCATOR
 		Point64 pt;
 		Vertex* next = nullptr;
 		Vertex* prev = nullptr;
@@ -65,7 +57,6 @@ namespace Clipper2Lib {
 	};

 	struct OutPt {
-		CLIPPER2_NODE_ALLOCATOR
 		Point64 pt;
 		OutPt*	next = nullptr;
 		OutPt*	prev = nullptr;
@@ -90,7 +81,6 @@ namespace Clipper2Lib {
 	//OutRec: contains a path in the clipping solution. Edges in the AEL will
 	//have OutRec pointers assigned when they form part of the clipping solution.
 	struct OutRec {
-		CLIPPER2_NODE_ALLOCATOR
 		size_t idx = 0;
 		OutRec* owner = nullptr;
 		Active* front_edge = nullptr;
@@ -116,7 +106,6 @@ namespace Clipper2Lib {
 	///////////////////////////////////////////////////////////////////

 	struct Active {
-		CLIPPER2_NODE_ALLOCATOR
 		Point64 bot;
 		Point64 top;
 		int64_t curr_x = 0;		//current (updated at every new scanline)
@@ -144,7 +133,6 @@ namespace Clipper2Lib {
 	};

 	struct LocalMinima {
-		CLIPPER2_NODE_ALLOCATOR
 		Vertex* vertex;
 		PathType polytype;
 		bool is_open;
@@ -315,7 +303,6 @@ namespace Clipper2Lib {
 	protected:
 		PolyPath* parent_;
 	public:
-		CLIPPER2_NODE_ALLOCATOR
 		PolyPath(PolyPath* parent = nullptr): parent_(parent){}
 		virtual ~PolyPath() {};
 		//https://en.cppreference.com/w/cpp/language/rule_of_three
@@ -343,16 +330,15 @@ namespace Clipper2Lib {
 			//Even levels except level 0
 			return lvl && !(lvl & 1);
 		}
-		// Area() of the namespace this header is compiled into (Clipper2Lib or Clipper2Lib_Z).
-		template<typename T>
-		static double Clipper2LibArea(const Path<T> &poly)
-		{
+        template<typename T>
+        static double Clipper2LibArea(const Path<T> &poly)
+        {
 #ifdef USINGZ
-			return Clipper2Lib_Z::Area<T>(poly);
+            return Clipper2Lib_Z::Area<T>(poly);
 #else
-			return Clipper2Lib::Area<T>(poly);
+            return Clipper2Lib::Area<T>(poly);
 #endif
-		}
+        }
 	};

 	typedef typename std::vector<std::unique_ptr<PolyPath64>> PolyPath64List;
@@ -402,8 +388,7 @@ namespace Clipper2Lib {

 		double Area() const
 		{
-			return std::accumulate(childs_.cbegin(), childs_.cend(),
-				Clipper2LibArea<int64_t>(polygon_),
+			return std::accumulate(childs_.cbegin(), childs_.cend(), Clipper2LibArea<int64_t>(polygon_),
 				[](double a, const auto& child) {return a + child->Area(); });
 		}

@@ -477,8 +462,7 @@ namespace Clipper2Lib {

 		double Area() const
 		{
-			return std::accumulate(childs_.begin(), childs_.end(),
-				Clipper2LibArea<double>(polygon_),
+			return std::accumulate(childs_.begin(), childs_.end(), Clipper2LibArea<double>(polygon_),
 				[](double a, const auto& child) {return a + child->Area(); });
 		}
 	};
@@ -19,17 +19,17 @@

 The path structures used extensively in other parts of this library are all
 based on std::vector classes. Since C++ classes can't be accessed by other
-languages, these paths are exported here as very simple array structures 
-(either of int64_t or double) that can be parsed by just about any 
+languages, these paths are exported here as very simple array structures
+(either of int64_t or double) that can be parsed by just about any
 programming language.

 These 2D paths are defined by series of x and y coordinates together with an
 optional user-defined 'z' value (see Z-values below). Hence, a vertex refers
-to a single x and y coordinate (+/- a user-defined value). Data structures 
-have names with suffixes that indicate the array type (either int64_t or 
-double). For example, the data structure CPath64 contains an array of int64_t 
-values, whereas the data structure CPathD contains an array of double. 
-Where documentation omits the type suffix (eg CPath), it is referring to an 
+to a single x and y coordinate (+/- a user-defined value). Data structures
+have names with suffixes that indicate the array type (either int64_t or
+double). For example, the data structure CPath64 contains an array of int64_t
+values, whereas the data structure CPathD contains an array of double.
+Where documentation omits the type suffix (eg CPath), it is referring to an
 array whose data type could be either int64_t or double.

 For conciseness, the following letters are used in the diagrams below:
@@ -39,10 +39,10 @@ A: Number of elements in an array


 CPath64 and CPathD:
-These are arrays of either int64_t or double values. Apart from 
-the first two elements, these arrays are a series of vertices 
-that together define a path. The very first element contains the 
-number of vertices (N) in the path, while second element should 
+These are arrays of either int64_t or double values. Apart from
+the first two elements, these arrays are a series of vertices
+that together define a path. The very first element contains the
+number of vertices (N) in the path, while second element should
 contain a 0 value.
 _______________________________________________________________
 | counters | vertex1      | vertex2      | ... | vertexN      |
@@ -52,9 +52,9 @@ _______________________________________________________________

 CPaths64 and CPathsD:
 These are also arrays of either int64_t or double values that
-contain any number of consecutive CPath structures. However, 
+contain any number of consecutive CPath structures. However,
 preceding the first path is a pair of values. The first value
-contains the length of the entire array structure (A), and the 
+contains the length of the entire array structure (A), and the
 second contains the number (ie count) of contained paths (C).
  Memory allocation for CPaths64 = A * sizeof(int64_t)
  Memory allocation for CPathsD  = A * sizeof(double)
@@ -65,12 +65,12 @@ __________________________________________


 CPolytree64 and CPolytreeD:
-The entire polytree structure is an array of int64_t or double. The 
-first element in the array indicates the array's total length (A). 
-The second element indicates the number (C) of CPolyPath structures 
+The entire polytree structure is an array of int64_t or double. The
+first element in the array indicates the array's total length (A).
+The second element indicates the number (C) of CPolyPath structures
 that are the TOP LEVEL CPolyPath in the polytree, and these top
-level CPolyPath immediately follow these first two array elements. 
-These top level CPolyPath structures may, in turn, contain nested 
+level CPolyPath immediately follow these first two array elements.
+These top level CPolyPath structures may, in turn, contain nested
 CPolyPath children, and these collectively make a tree structure.
 _________________________________________________________
 | counters | CPolyPath1 | CPolyPath2 | ... | CPolyPathC |
@@ -116,10 +116,13 @@ the four vertices that define the two segments that are intersecting.
 #include "clipper2/clipper.engine.h"
 #include "clipper2/clipper.offset.h"
 #include "clipper2/clipper.rectclip.h"
-#include "clipper2/clipper.triangulation.h"
 #include <cstdlib>

+#ifdef USINGZ
+namespace Clipper2Lib_Z {
+#else
 namespace Clipper2Lib {
+#endif

 typedef int64_t* CPath64;
 typedef int64_t* CPaths64;
@@ -251,9 +254,9 @@ ZCallback64 dllCallback64 = nullptr;
 ZCallbackD  dllCallbackD  = nullptr;

 constexpr int EXPORT_VERTEX_DIMENSIONALITY = 3;
-#else    
+#else
 constexpr int EXPORT_VERTEX_DIMENSIONALITY  = 2;
-#endif 
+#endif

 template <typename T>
 static void GetPathCountAndCPathsArrayLen(const Paths<T>& paths,
@@ -393,7 +396,7 @@ static Path<T> ConvertCPathToPathT(T* path)
 #ifdef USINGZ
      z_type z = Reinterpret<z_type>(*v++);
      result.emplace_back(x, y, z);
-#else  
+#else
      result.emplace_back(x, y);
 #endif
  }
@@ -411,7 +414,7 @@ static Paths<T> ConvertCPathsToPathsT(T* paths)
  for (size_t i = 0; i < cnt; ++i)
  {
    size_t cnt2 = static_cast<size_t>(*v);
-    v += 2; 
+    v += 2;
    Path<T> path;
    path.reserve(cnt2);
    for (size_t j = 0; j < cnt2; ++j)
@@ -444,7 +447,7 @@ static Path64 ConvertCPathDToPath64WithScale(const CPathD path, double scale)
 #ifdef USINGZ
        z_type z = Reinterpret<z_type>(*v++);
        result.emplace_back(x, y, z);
-#else  
+#else
        result.emplace_back(x, y);
 #endif
    }
@@ -489,7 +492,7 @@ static void CreateCPolyPath64(const PolyPath64* pp, int64_t*& v)
  {
    *v++ = pt.x;
    *v++ = pt.y;
-#ifdef USINGZ   
+#ifdef USINGZ
    * v++ = Reinterpret<int64_t>(pt.z); // raw memory copy
 #endif
  }
@@ -505,7 +508,7 @@ static void CreateCPolyPathD(const PolyPathD* pp, double*& v)
  {
    *v++ = pt.x;
    *v++ = pt.y;
-#ifdef USINGZ   
+#ifdef USINGZ
    * v++ = Reinterpret<double>(pt.z); // raw memory copy
 #endif
  }
@@ -813,24 +816,6 @@ EXTERN_DLL_EXPORT CPaths64 MinkowskiDiff64(const CPath64& cpattern, const CPath6
  return CreateCPathsFromPathsT(solution);
 }

-EXTERN_DLL_EXPORT CPaths64 Triangulate64(const CPaths64 paths, bool use_delaunay)
-{
-  Paths64 pp = ConvertCPathsToPathsT(paths);
-  Paths64 sol;
-  if (Triangulate(pp, sol, use_delaunay) != TriangulateResult::success) return nullptr;
-  return CreateCPathsFromPathsT(sol);
-}
-
-EXTERN_DLL_EXPORT CPathsD TriangulateD(const CPathsD paths, int decimal_precison, bool use_delaunay)
-{
-  if (decimal_precison < -8 || decimal_precison > 8) return nullptr;
-  const double scale = std::pow(10, decimal_precison);
-  Paths64 pp = ConvertCPathsDToPaths64(paths, scale);
-  Paths64 sol;
-  if (Triangulate(pp, sol, use_delaunay) != TriangulateResult::success) return nullptr;
-  return CreateCPathsDFromPaths64(sol, 1 / scale);
-}
-
 #ifdef USINGZ
 typedef void (*DLLZCallback64)(const Point64& e1bot, const Point64& e1top, const Point64& e2bot, const Point64& e2top, Point64& pt);
 typedef void (*DLLZCallbackD)(const PointD& e1bot, const PointD& e1top, const PointD& e2bot, const PointD& e2top, PointD& pt);
@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  5 March 2025                                                    *
+* Date      :  27 April 2024                                                   *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2025                                         *
+* Copyright :  Angus Johnson 2010-2024                                         *
 * Purpose   :  This module provides a simple interface to the Clipper Library  *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -13,15 +13,14 @@
 #include "clipper2/clipper.core.h"
 #include "clipper2/clipper.engine.h"
 #include "clipper2/clipper.offset.h"
-#include "clipper2/clipper.rectclip.h"
 #include "clipper2/clipper.minkowski.h"
-#include "clipper2/clipper.triangulation.h"
+#include "clipper2/clipper.rectclip.h"
 #include <type_traits>

 #ifdef USINGZ
-namespace Clipper2Lib_Z {
+  namespace Clipper2Lib_Z {
 #else
-namespace Clipper2Lib {
+  namespace Clipper2Lib {
 #endif

  inline Paths64 BooleanOp(ClipType cliptype, FillRule fillrule,
@@ -155,14 +154,14 @@ namespace Clipper2Lib {
    if (!delta) return paths;
    if (error_code) return PathsD();
    const double scale = std::pow(10, precision);
-    ClipperOffset clip_offset(miter_limit, arc_tolerance * scale);
+    ClipperOffset clip_offset(miter_limit, arc_tolerance);
    clip_offset.AddPaths(ScalePaths<int64_t,double>(paths, scale, error_code), jt, et);
    if (error_code) return PathsD();
    Paths64 solution;
    clip_offset.Execute(delta * scale, solution);
    return ScalePaths<double, int64_t>(solution, 1 / scale, error_code);
  }
-  
+
  template <typename T>
  inline Path<T> TranslatePath(const Path<T>& path, T dx, T dy)
  {
@@ -356,29 +355,6 @@ namespace Clipper2Lib {
 #endif
    }

-    inline size_t GetNext(size_t current, size_t high,
-      const std::vector<bool>& flags)
-    {
-      ++current;
-      while (current <= high && flags[current]) ++current;
-      if (current <= high) return current;
-      current = 0;
-      while (flags[current]) ++current;
-      return current;
-    }
-
-    inline size_t GetPrior(size_t current, size_t high,
-      const std::vector<bool>& flags)
-    {
-      if (current == 0) current = high;
-      else --current;
-      while (current > 0 && flags[current]) --current;
-      if (!flags[current]) return current;
-      current = high;
-      while (flags[current]) --current;
-      return current;
-    }
-
  } // end details namespace

  inline std::ostream& operator<< (std::ostream& os, const PolyTree64& pp)
@@ -639,6 +615,29 @@ namespace Clipper2Lib {
    return result;
  }

+  inline size_t GetNext(size_t current, size_t high,
+    const std::vector<bool>& flags)
+  {
+    ++current;
+    while (current <= high && flags[current]) ++current;
+    if (current <= high) return current;
+    current = 0;
+    while (flags[current]) ++current;
+    return current;
+  }
+
+  inline size_t GetPrior(size_t current, size_t high,
+    const std::vector<bool>& flags)
+  {
+    if (current == 0) current = high;
+    else --current;
+    while (current > 0 && flags[current]) --current;
+    if (!flags[current]) return current;
+    current = high;
+    while (flags[current]) --current;
+    return current;
+  }
+
  template <typename T>
  inline Path<T> SimplifyPath(const Path<T> &path,
    double epsilon, bool isClosedPath = true)
@@ -670,13 +669,13 @@ namespace Clipper2Lib {
        start = curr;
        do
        {
-          curr = details::GetNext(curr, high, flags);
+          curr = GetNext(curr, high, flags);
        } while (curr != start && distSqr[curr] > epsSqr);
        if (curr == start) break;
      }

-      prior = details::GetPrior(curr, high, flags);
-      next = details::GetNext(curr, high, flags);
+      prior = GetPrior(curr, high, flags);
+      next = GetNext(curr, high, flags);
      if (next == prior) break;

      // flag for removal the smaller of adjacent 'distances'
@@ -685,14 +684,14 @@ namespace Clipper2Lib {
        prior2 = prior;
        prior = curr;
        curr = next;
-        next = details::GetNext(next, high, flags);
+        next = GetNext(next, high, flags);
      }
      else
-        prior2 = details::GetPrior(prior, high, flags);
+        prior2 = GetPrior(prior, high, flags);

      flags[curr] = true;
      curr = next;
-      next = details::GetNext(next, high, flags);
+      next = GetNext(next, high, flags);

      if (isClosedPath || ((curr != high) && (curr != 0)))
        distSqr[curr] = PerpendicDistFromLineSqrd(path[curr], path[prior], path[next]);
@@ -717,35 +716,6 @@ namespace Clipper2Lib {
    return result;
  }

- 
-  template <typename T>
-  inline bool Path2ContainsPath1(const Path<T>& path1, const Path<T>& path2)
-  {
-    // precondition: paths must not intersect, except for
-    // transient (and presumed 'micro') path intersections 
-    PointInPolygonResult pip = PointInPolygonResult::IsOn;
-    for (const Point<T>& pt : path1)
-    {
-      switch (PointInPolygon(pt, path2))
-      {
-      case PointInPolygonResult::IsOutside: 
-        if (pip == PointInPolygonResult::IsOutside) return false; 
-        pip = PointInPolygonResult::IsOutside; 
-        break;
-      case PointInPolygonResult::IsInside:
-        if (pip == PointInPolygonResult::IsInside) return true;
-        pip = PointInPolygonResult::IsInside;
-        break;
-      default: 
-        break;
-      }
-    }
-    if (pip != PointInPolygonResult::IsInside) return false;
-    // result is likely true but check midpoint
-    Point<T> mp1 = GetBounds(path1).MidPoint();
-    return PointInPolygon(mp1, path2) == PointInPolygonResult::IsInside;
-  }
-
  template <typename T>
  inline void RDP(const Path<T> path, std::size_t begin,
    std::size_t end, double epsSqrd, std::vector<bool>& flags)
@@ -39,7 +39,7 @@ private:
 	class Group {
 	public:
 		Paths64 paths_in;
-    std::optional<size_t> lowest_path_idx{};
+        std::optional<size_t> lowest_path_idx{};
 		bool is_reversed = false;
 		JoinType join_type;
 		EndType end_type;
@@ -100,7 +100,7 @@ public:
 	void AddPath(const Path64& path, JoinType jt_, EndType et_);
 	void AddPaths(const Paths64& paths, JoinType jt_, EndType et_);
 	void Clear() { groups_.clear(); norms.clear(); };
-	
+
 	void Execute(double delta, Paths64& sols_64);
 	void Execute(double delta, PolyTree64& polytree);
 	void Execute(DeltaCallback64 delta_cb, Paths64& paths);
@@ -114,7 +114,7 @@ public:

 	bool PreserveCollinear() const { return preserve_collinear_; }
 	void PreserveCollinear(bool preserve_collinear){preserve_collinear_ = preserve_collinear;}
-	
+
 	bool ReverseSolution() const { return reverse_solution_; }
 	void ReverseSolution(bool reverse_solution) {reverse_solution_ = reverse_solution;}

@@ -1,30 +0,0 @@
-/*******************************************************************************
-* Author    :  Angus Johnson                                                   *
-* Date      :  6 December 2025                                                 *
-* Release   :  BETA RELEASE                                                    *
-* Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2025                                         *
-* Purpose   :  Delaunay Triangulation                                          *
-* License   :  https://www.boost.org/LICENSE_1_0.txt                           *
-*******************************************************************************/
-
-#ifndef CLIPPER_TRIANGULATION_H
-#define CLIPPER_TRIANGULATION_H
-
-#include <stack>
-#include "clipper2/clipper.core.h"
-
-#ifdef USINGZ
-namespace Clipper2Lib_Z {
-#else
-namespace Clipper2Lib {
-#endif
-
-  enum class TriangulateResult { success, fail, no_polygons, paths_intersect };
-
-  // Triangulate - this function will not accept intesecting paths
-  TriangulateResult Triangulate(const Paths64& pp, Paths64& solution, bool useDelaunay = true);
-  TriangulateResult Triangulate(const PathsD& pp, int decPlaces, PathsD& solution, bool useDelaunay = true);
-
-} // Clipper2Lib namespace
-#endif  // CLIPPER_TRIANGULATION_H
@@ -1,6 +1,6 @@
 #ifndef CLIPPER_VERSION_H
 #define CLIPPER_VERSION_H

-constexpr auto CLIPPER2_VERSION = "2.0.1";
+constexpr auto CLIPPER2_VERSION = "1.5.2";

 #endif  // CLIPPER_VERSION_H
@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  5 November 2025                                                 *
+* Date      :  17 September 2024                                               *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2025                                         *
+* Copyright :  Angus Johnson 2010-2024                                         *
 * Purpose   :  This is the main polygon clipping module                        *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -10,8 +10,6 @@
 #include "clipper2/clipper.engine.h"
 #include "clipper2/clipper.h"
 #include <stdexcept>
-#include <new>
-#include <oneapi/tbb/scalable_allocator.h>

 // https://github.com/AngusJohnson/Clipper2/discussions/334
 // #discussioncomment-4248602
@@ -29,30 +27,10 @@ namespace Clipper2Lib_Z {
 namespace Clipper2Lib {
 #endif

-  // Orca: tbbmalloc scales far better than the default heap when all slicing threads clip at once.
-  static void* NodeAlloc(size_t size)
-  {
-    if (void* p = scalable_malloc(size)) return p;
-    throw std::bad_alloc();
-  }
-
-#define CLIPPER2_DEFINE_NODE_ALLOCATOR(T) \
-  void* T::operator new(size_t size) { return NodeAlloc(size); } \
-  void T::operator delete(void* ptr) noexcept { scalable_free(ptr); } \
-  void* T::operator new[](size_t size) { return NodeAlloc(size); } \
-  void T::operator delete[](void* ptr) noexcept { scalable_free(ptr); }
-  CLIPPER2_DEFINE_NODE_ALLOCATOR(Vertex)
-  CLIPPER2_DEFINE_NODE_ALLOCATOR(OutPt)
-  CLIPPER2_DEFINE_NODE_ALLOCATOR(OutRec)
-  CLIPPER2_DEFINE_NODE_ALLOCATOR(Active)
-  CLIPPER2_DEFINE_NODE_ALLOCATOR(LocalMinima)
-  CLIPPER2_DEFINE_NODE_ALLOCATOR(PolyPath)
-#undef CLIPPER2_DEFINE_NODE_ALLOCATOR
-
  static const Rect64 invalid_rect = Rect64(false);

-  // Every closed path (ie polygon) is made up of a series of vertices forming edge 
-  // 'bounds' that alternate between ascending bounds (containing edges going up 
+  // Every closed path (ie polygon) is made up of a series of vertices forming edge
+  // 'bounds' that alternate between ascending bounds (containing edges going up
  // relative to the Y-axis) and descending bounds. 'Local Minima' refers to
  // vertices where ascending and descending bounds join at the bottom, and
  // 'Local Maxima' are where ascending and descending bounds join at the top.
@@ -504,7 +482,8 @@ namespace Clipper2Lib {
  inline void SetOwner(OutRec* outrec, OutRec* new_owner)
  {
    //precondition1: new_owner is never null
-    new_owner->owner = GetRealOutRec(new_owner->owner);
+    while (new_owner->owner && !new_owner->owner->pts)
+      new_owner->owner = new_owner->owner->owner;
    OutRec* tmp = new_owner;
    while (tmp && tmp != outrec) tmp = tmp->owner;
    if (tmp) new_owner->owner = outrec->owner;
@@ -557,9 +536,9 @@ namespace Clipper2Lib {
        val = 1 - val; // toggle val
      else
      {
-        int i = CrossProductSign(op2->prev->pt, op2->pt, pt);
-        if (i == 0) return PointInPolygonResult::IsOn;
-        if ((i < 0) == is_above) val = 1 - val;
+        double d = CrossProduct(op2->prev->pt, op2->pt, pt);
+        if (d == 0) return PointInPolygonResult::IsOn;
+        if ((d < 0) == is_above) val = 1 - val;
      }
      is_above = !is_above;
      op2 = op2->next;
@@ -567,9 +546,9 @@ namespace Clipper2Lib {

    if (is_above != starting_above)
    {
-      int i = CrossProductSign(op2->prev->pt, op2->pt, pt);
-      if (i == 0) return PointInPolygonResult::IsOn;
-      if ((i < 0) == is_above) val = 1 - val;
+      double d = CrossProduct(op2->prev->pt, op2->pt, pt);
+      if (d == 0) return PointInPolygonResult::IsOn;
+      if ((d < 0) == is_above) val = 1 - val;
    }

    if (val == 0) return PointInPolygonResult::IsOutside;
@@ -599,31 +578,30 @@ namespace Clipper2Lib {
    return result;
  }

-  inline bool Path2ContainsPath1(OutPt* op1, OutPt* op2)
+  inline bool Path1InsidePath2(OutPt* op1, OutPt* op2)
  {
-    // this function accommodates rounding errors that 
-    // can cause path micro intersections
-    PointInPolygonResult pip = PointInPolygonResult::IsOn;
+    // we need to make some accommodation for rounding errors
+    // so we won't jump if the first vertex is found outside
+    PointInPolygonResult result;
+    int outside_cnt = 0;
    OutPt* op = op1;
-    do {
-      switch (PointInOpPolygon(op->pt, op2))
-      {
-      case PointInPolygonResult::IsOutside:
-        if (pip == PointInPolygonResult::IsOutside) return false;
-        pip = PointInPolygonResult::IsOutside;
-        break;
-      case PointInPolygonResult::IsInside:
-        if (pip == PointInPolygonResult::IsInside) return true;
-        pip = PointInPolygonResult::IsInside;
-        break;
-      default: break;
-      }
+    do
+    {
+      result = PointInOpPolygon(op->pt, op2);
+      if (result == PointInPolygonResult::IsOutside) ++outside_cnt;
+      else if (result == PointInPolygonResult::IsInside) --outside_cnt;
      op = op->next;
-    } while (op != op1);
-    // result unclear, so try again using cleaned paths
-    return Path2ContainsPath1(GetCleanPath(op1), GetCleanPath(op2)); // (#973)
+    } while (op != op1 && std::abs(outside_cnt) < 2);
+    if (std::abs(outside_cnt) > 1) return (outside_cnt < 0);
+    // since path1's location is still equivocal, check its midpoint
+    Point64 mp = GetBounds(GetCleanPath(op1)).MidPoint();
+    Path64 path2 = GetCleanPath(op2);
+    return PointInPolygon(mp, path2) != PointInPolygonResult::IsOutside;
  }

+  //------------------------------------------------------------------------------
+  //------------------------------------------------------------------------------
+
  void AddLocMin(LocalMinimaList& list,
    Vertex& vert, PathType polytype, bool is_open)
  {
@@ -1148,19 +1126,21 @@ namespace Clipper2Lib {
        return newcomer.curr_x > resident.curr_x;

    //get the turning direction  a1.top, a2.bot, a2.top
-    int i = CrossProductSign(resident.top, newcomer.bot, newcomer.top);
-    if (i != 0) return i < 0;
+    double d = CrossProduct(resident.top, newcomer.bot, newcomer.top);
+    if (d != 0) return d < 0;

    //edges must be collinear to get here
    //for starting open paths, place them according to
    //the direction they're about to turn
    if (!IsMaxima(resident) && (resident.top.y > newcomer.top.y))
    {
-      return (CrossProductSign(newcomer.bot, resident.top, NextVertex(resident)->pt) <= 0);
+      return CrossProduct(newcomer.bot,
+        resident.top, NextVertex(resident)->pt) <= 0;
    }
    else if (!IsMaxima(newcomer) && (newcomer.top.y > resident.top.y))
    {
-      return (CrossProductSign(newcomer.bot, newcomer.top, NextVertex(newcomer)->pt) >= 0);
+      return CrossProduct(newcomer.bot,
+        newcomer.top, NextVertex(newcomer)->pt) >= 0;
    }

    int64_t y = newcomer.bot.y;
@@ -1175,7 +1155,7 @@ namespace Clipper2Lib {
      resident.bot, resident.top)) return true;
    else
      //compare turning direction of the alternate bound
-      return (CrossProductSign(PrevPrevVertex(resident)->pt,
+      return (CrossProduct(PrevPrevVertex(resident)->pt,
        newcomer.bot, PrevPrevVertex(newcomer)->pt) > 0) == newcomerIsLeft;
  }

@@ -1585,7 +1565,7 @@ namespace Clipper2Lib {
    FixSelfIntersects(outrec);
  }

-  void ClipperBase::DoSplitOp (OutRec* outrec, OutPt* splitOp)
+  void ClipperBase::DoSplitOp(OutRec* outrec, OutPt* splitOp)
  {
    // splitOp.prev -> splitOp &&
    // splitOp.next -> splitOp.next.next are intersecting
@@ -1594,7 +1574,7 @@ namespace Clipper2Lib {
    outrec->pts = prevOp;

    Point64 ip;
-    GetLineIntersectPt(prevOp->pt, splitOp->pt,
+    GetSegmentIntersectPt(prevOp->pt, splitOp->pt,
      splitOp->next->pt, nextNextOp->pt, ip);

 #ifdef USINGZ
@@ -1650,7 +1630,7 @@ namespace Clipper2Lib {

      if (using_polytree_)
      {
-        if (Path2ContainsPath1(prevOp, newOp))
+        if (Path1InsidePath2(prevOp, newOp))
        {
          newOr->splits = new OutRecList();
          newOr->splits->emplace_back(outrec);
@@ -1672,32 +1652,19 @@ namespace Clipper2Lib {
  void ClipperBase::FixSelfIntersects(OutRec* outrec)
  {
    OutPt* op2 = outrec->pts;
-    if (op2->prev == op2->next->next) 
-      return; // because triangles can't self-intersect
    for (; ; )
    {
+      // triangles can't self-intersect
+      if (op2->prev == op2->next->next) break;
      if (SegmentsIntersect(op2->prev->pt,
        op2->pt, op2->next->pt, op2->next->next->pt))
      {
-        if (SegmentsIntersect(op2->prev->pt,
-          op2->pt, op2->next->next->pt, op2->next->next->next->pt))
-        {
-          // adjacent intersections (ie a micro self-intersections)
-          op2 = DuplicateOp(op2, false);
-          op2->pt = op2->next->next->next->pt;
-          op2 = op2->next;
-        }
-        else
-        {
-          if (op2 == outrec->pts || op2->next == outrec->pts)
-            outrec->pts = outrec->pts->prev;
-          DoSplitOp(outrec, op2);
-          if (!outrec->pts) break;
-          op2 = outrec->pts;
-          if (op2->prev == op2->next->next)
-            break; // again, because triangles can't self-intersect
-          continue;
-        }
+        if (op2 == outrec->pts || op2->next == outrec->pts)
+          outrec->pts = outrec->pts->prev;
+        DoSplitOp(outrec, op2);
+        if (!outrec->pts) break;
+        op2 = outrec->pts;
+        continue;
      }
      else
        op2 = op2->next;
@@ -1838,14 +1805,14 @@ namespace Clipper2Lib {

      switch (fillrule_)
      {
-      case FillRule::Positive: 
-        if (edge_c->wind_cnt != 1) return; 
+      case FillRule::Positive:
+        if (edge_c->wind_cnt != 1) return;
        break;
-      case FillRule::Negative: 
-        if (edge_c->wind_cnt != -1) return; 
+      case FillRule::Negative:
+        if (edge_c->wind_cnt != -1) return;
        break;
-      default: 
-        if (std::abs(edge_c->wind_cnt) != 1) return; 
+      default:
+        if (std::abs(edge_c->wind_cnt) != 1) return;
      }

 #ifdef USINGZ
@@ -1966,7 +1933,7 @@ namespace Clipper2Lib {
    const bool e1_windcnt_in_01 = old_e1_windcnt == 0 || old_e1_windcnt == 1;
    const bool e2_windcnt_in_01 = old_e2_windcnt == 0 || old_e2_windcnt == 1;

-    if ((!IsHotEdge(e1) && !e1_windcnt_in_01) || 
+    if ((!IsHotEdge(e1) && !e1_windcnt_in_01) ||
      (!IsHotEdge(e2) && !e2_windcnt_in_01))
        return;

@@ -2145,9 +2112,10 @@ namespace Clipper2Lib {
      e->prev_in_sel = e->prev_in_ael;
      e->next_in_sel = e->next_in_ael;
      e->jump = e->next_in_sel;
-      // it is safe to ignore 'joined' edges here because
-      // if necessary they will be split in IntersectEdges()
-      e->curr_x = TopX(*e, top_y);
+      if (e->join_with == JoinWith::Left)
+        e->curr_x = e->prev_in_ael->curr_x; // also avoids complications
+      else
+        e->curr_x = TopX(*e, top_y);
      e = e->next_in_ael;
    }
  }
@@ -2294,14 +2262,15 @@ namespace Clipper2Lib {

  void MoveSplits(OutRec* fromOr, OutRec* toOr)
  {
+    if (!fromOr->splits) return;
    if (!toOr->splits) toOr->splits = new OutRecList();
    OutRecList::iterator orIter = fromOr->splits->begin();
    for (; orIter != fromOr->splits->end(); ++orIter)
-      if (toOr != *orIter) // #987
-        toOr->splits->emplace_back(*orIter);
+      toOr->splits->emplace_back(*orIter);
    fromOr->splits->clear();
  }

+
  void ClipperBase::ProcessHorzJoins()
  {
    for (const HorzJoin& j : horz_join_list_)
@@ -2330,8 +2299,8 @@ namespace Clipper2Lib {
        }

        if (using_polytree_) //#498, #520, #584, D#576, #618
-        {          
-          if (Path2ContainsPath1(or1->pts, or2->pts))
+        {
+          if (Path1InsidePath2(or1->pts, or2->pts))
          {
            //swap or1's & or2's pts
            OutPt* tmp = or1->pts;
@@ -2342,7 +2311,7 @@ namespace Clipper2Lib {
            //or2 is now inside or1
            or2->owner = or1;
          }
-          else if (Path2ContainsPath1(or2->pts, or1->pts))
+          else if (Path1InsidePath2(or2->pts, or1->pts))
          {
            or2->owner = or1;
          }
@@ -2355,14 +2324,13 @@ namespace Clipper2Lib {
        else
          or2->owner = or1;
      }
-      else // joining, not splitting
+      else
      {
        or2->pts = nullptr;
        if (using_polytree_)
        {
          SetOwner(or2, or1);
-          if (or2->splits) 
-            MoveSplits(or2, or1); //#618
+          MoveSplits(or2, or1); //#618
        }
        else
          or2->owner = or1;
@@ -2382,7 +2350,7 @@ namespace Clipper2Lib {
  void ClipperBase::AddNewIntersectNode(Active& e1, Active& e2, int64_t top_y)
  {
    Point64 ip;
-    if (!GetLineIntersectPt(e1.bot, e1.top, e2.bot, e2.top, ip))
+    if (!GetSegmentIntersectPt(e1.bot, e1.top, e2.bot, e2.top, ip))
      ip = Point64(e1.curr_x, top_y); //parallel edges

    //rounding errors can occasionally place the calculated intersection
@@ -2966,28 +2934,22 @@ namespace Clipper2Lib {

  bool ClipperBase::CheckSplitOwner(OutRec* outrec, OutRecList* splits)
  {
-    // nb: use indexing (not an iterator) in case 'splits' is modified inside this loop (#1029)
-    for (size_t idx = 0; idx < splits->size(); ++idx)
+    for (auto split : *splits)
    {
-      OutRec* split = (*splits)[idx]; 
-      if (!split->pts && split->splits &&
-        CheckSplitOwner(outrec, split->splits)) return true; //#942
      split = GetRealOutRec(split);
-      if (!split || split == outrec || split->recursive_split == outrec) continue;
+      if(!split || split == outrec || split->recursive_split == outrec) continue;
      split->recursive_split = outrec; // prevent infinite loops

      if (split->splits && CheckSplitOwner(outrec, split->splits))
-        return true;    
-
-      if (!CheckBounds(split) || !split->bounds.Contains(outrec->bounds) ||
-        !Path2ContainsPath1(outrec->pts, split->pts)) continue;
-     
-      if (!IsValidOwner(outrec, split)) // split is owned by outrec! (#957)
-          split->owner = outrec->owner;
-
-      outrec->owner = split;
-      return true;
-      
+          return true;
+      else if (CheckBounds(split) &&
+        IsValidOwner(outrec, split) &&
+        split->bounds.Contains(outrec->bounds) &&
+        Path1InsidePath2(outrec->pts, split->pts))
+      {
+        outrec->owner = split; //found in split
+        return true;
+      }
    }
    return false;
  }
@@ -2998,12 +2960,13 @@ namespace Clipper2Lib {
    // post-condition: if a valid path, outrec will have a polypath

    if (outrec->polypath || outrec->bounds.IsEmpty()) return;
+
    while (outrec->owner)
    {
      if (outrec->owner->splits && CheckSplitOwner(outrec, outrec->owner->splits)) break;
      if (outrec->owner->pts && CheckBounds(outrec->owner) &&
        outrec->owner->bounds.Contains(outrec->bounds) &&
-        Path2ContainsPath1(outrec->pts, outrec->owner->pts)) break;
+        Path1InsidePath2(outrec->pts, outrec->owner->pts)) break;
      outrec->owner = outrec->owner->owner;
    }

@@ -3066,7 +3029,6 @@ namespace Clipper2Lib {
    {
      OutRec* outrec = outrec_list_[i];
      if (!outrec || !outrec->pts) continue;
-
      if (outrec->is_open)
      {
        Path64 path;
@@ -1,6 +1,6 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  11 October 2025                                                 *
+* Date      :  22 January 2025                                                 *
 * Website   :  https://www.angusj.com                                          *
 * Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  Path Offset (Inflate/Shrink)                                    *
@@ -37,35 +37,29 @@ const double arc_const = 0.002; // <-- 1/500
 // Miscellaneous methods
 //------------------------------------------------------------------------------

-void GetLowestClosedPathInfo(const Paths64& paths, std::optional<size_t>& idx, bool& is_neg_area)
+std::optional<size_t> GetLowestClosedPathIdx(const Paths64& paths)
 {
-	idx.reset();
+    std::optional<size_t> result;
 	Point64 botPt = Point64(INT64_MAX, INT64_MIN);
 	for (size_t i = 0; i < paths.size(); ++i)
 	{
-		double a = MAX_DBL;
 		for (const Point64& pt : paths[i])
 		{
 			if ((pt.y < botPt.y) ||
 				((pt.y == botPt.y) && (pt.x >= botPt.x))) continue;
-			if (a == MAX_DBL) 
-			{
-				a = Area(paths[i]);
-				if (a == 0) break; // invalid closed path, so break from inner loop
-				is_neg_area = a < 0;
-			}
-      idx = i;
+            result = i;
 			botPt.x = pt.x;
 			botPt.y = pt.y;
 		}
 	}
+	return result;
 }

 inline double Hypot(double x, double y)
 {
 	// given that this is an internal function, and given the x and y parameters
 	// will always be coordinate values (or the difference between coordinate values),
-	// x and y should always be within INT64_MIN to INT64_MAX. Consequently, 
+	// x and y should always be within INT64_MIN to INT64_MAX. Consequently,
 	// there should be no risk that the following computation will overflow
 	// see https://stackoverflow.com/a/32436148/359538
 	return std::sqrt(x * x + y * y);
@@ -151,16 +145,15 @@ ClipperOffset::Group::Group(const Paths64& _paths, JoinType _join_type, EndType

 	if (end_type == EndType::Polygon)
 	{
-		bool is_neg_area;
-		GetLowestClosedPathInfo(paths_in, lowest_path_idx, is_neg_area);
+		lowest_path_idx = GetLowestClosedPathIdx(paths_in);
 		// the lowermost path must be an outer path, so if its orientation is negative,
 		// then flag the whole group is 'reversed' (will negate delta etc.)
 		// as this is much more efficient than reversing every path.
-    is_reversed = lowest_path_idx.has_value() && is_neg_area;
+    is_reversed = (lowest_path_idx.has_value()) && Area(paths_in[lowest_path_idx.value()]) < 0;
 	}
 	else
 	{
-    lowest_path_idx.reset();
+    lowest_path_idx = std::nullopt;
 		is_reversed = false;
 	}
 }
@@ -243,7 +236,7 @@ void ClipperOffset::DoSquare(const Path64& path, size_t j, size_t k)
 	{
 		PointD pt4 = PointD(pt3.x + vec.x * group_delta_, pt3.y + vec.y * group_delta_);
 		PointD pt = ptQ;
-		GetLineIntersectPt(pt1, pt2, pt3, pt4, pt);
+		GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt);
 		//get the second intersect point through reflecion
        path_out.emplace_back(ReflectPoint(pt, ptQ));
        path_out.emplace_back(pt);
@@ -252,7 +245,7 @@ void ClipperOffset::DoSquare(const Path64& path, size_t j, size_t k)
 	{
 		PointD pt4 = GetPerpendicD(path[j], norms[k], group_delta_);
 		PointD pt = ptQ;
-		GetLineIntersectPt(pt1, pt2, pt3, pt4, pt);
+		GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt);
        path_out.emplace_back(pt);
 		//get the second intersect point through reflecion
        path_out.emplace_back(ReflectPoint(pt, ptQ));
@@ -298,8 +291,7 @@ void ClipperOffset::DoRound(const Path64& path, size_t j, size_t k, double angle
 #else
    path_out.emplace_back(pt.x + offsetVec.x, pt.y + offsetVec.y);
 #endif
-	// Orca: round the step count like Clipper1 did, so round offsets keep their vertices.
-	int steps = std::max(static_cast<int>(std::round(steps_per_rad_ * std::abs(angle))), 1);
+	int steps = static_cast<int>(std::ceil(steps_per_rad_ * std::abs(angle))); // #448, #456
 	for (int i = 1; i < steps; ++i) // ie 1 less than steps
 	{
 		offsetVec = PointD(offsetVec.x * step_cos_ - step_sin_ * offsetVec.y,
@@ -341,9 +333,9 @@ void ClipperOffset::OffsetPoint(Group& group, const Path64& path, size_t j, size
 	if (cos_a > -0.999 && (sin_a * group_delta_ < 0)) // test for concavity first (#593)
 	{
 		// is concave
-		// by far the simplest way to construct concave joins, especially those joining very 
-		// short segments, is to insert 3 points that produce negative regions. These regions 
-		// will be removed later by the finishing union operation. This is also the best way 
+		// by far the simplest way to construct concave joins, especially those joining very
+		// short segments, is to insert 3 points that produce negative regions. These regions
+		// will be removed later by the finishing union operation. This is also the best way
 		// to ensure that path reversals (ie over-shrunk paths) are removed.
 #ifdef USINGZ
        path_out.emplace_back(GetPerpendic(path[j], norms[k], group_delta_), path[j].z);
@@ -374,31 +366,11 @@ void ClipperOffset::OffsetPoint(Group& group, const Path64& path, size_t j, size
 		DoSquare(path, j, k);
 }

-// Orca: join concave corners at the crossing of both edge offsets where safe, 3-point loops make dense inward offsets slow.
-static bool OffsetConcaveCrossing(const Path64& path, const PathD& norms, size_t j, size_t k, size_t next,
-	double delta, Path64& path_out)
-{
-	const double sin_a = CrossProduct(norms[j], norms[k]);
-	const double cos_a = DotProduct(norms[j], norms[k]);
-	if (cos_a <= -0.999 || sin_a * delta >= 0) return false;
-	const double x = std::fabs(delta * sin_a) / (1 + cos_a);
-	if (4 * x * x > DistanceSqr(path[k], path[j]) || 4 * x * x > DistanceSqr(path[j], path[next])) return false;
-	const double q = delta / (1 + cos_a);
-#ifdef USINGZ
-	path_out.emplace_back(path[j].x + (norms[k].x + norms[j].x) * q, path[j].y + (norms[k].y + norms[j].y) * q, path[j].z);
-#else
-	path_out.emplace_back(path[j].x + (norms[k].x + norms[j].x) * q, path[j].y + (norms[k].y + norms[j].y) * q);
-#endif
-	return true;
-}
-
 void ClipperOffset::OffsetPolygon(Group& group, const Path64& path)
 {
 	path_out.clear();
 	for (Path64::size_type j = 0, k = path.size() - 1; j < path.size(); k = j, ++j)
-		if (deltaCallback64_ || path[j] == path[k] ||
-			!OffsetConcaveCrossing(path, norms, j, k, j + 1 == path.size() ? 0 : j + 1, group_delta_, path_out))
-			OffsetPoint(group, path, j, k);
+		OffsetPoint(group, path, j, k);
    solution->emplace_back(path_out);
 }

@@ -408,7 +380,7 @@ void ClipperOffset::OffsetOpenJoined(Group& group, const Path64& path)
 	Path64 reverse_path(path);
 	std::reverse(reverse_path.begin(), reverse_path.end());

-	//rebuild normals 
+	//rebuild normals
 	std::reverse(norms.begin(), norms.end());
    norms.emplace_back(norms[0]);
 	norms.erase(norms.begin());
@@ -629,10 +601,10 @@ void ClipperOffset::ExecuteInternal(double delta)

 	if (!solution->size()) return;

-	bool paths_reversed = CheckReverseOrientation();
+		bool paths_reversed = CheckReverseOrientation();
 	//clean up self-intersections ...
 	Clipper64 c;
-	c.PreserveCollinear(preserve_collinear_);
+	c.PreserveCollinear(false);
 	//the solution should retain the orientation of the input
 	c.ReverseSolution(reverse_solution_ != paths_reversed);
 #ifdef USINGZ
@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  11 October 2025                                                 *
+* Date      :  5 July 2024                                                     *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2025                                         *
+* Copyright :  Angus Johnson 2010-2024                                         *
 * Purpose   :  FAST rectangular clipping                                       *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -77,8 +77,8 @@ namespace Clipper2Lib {
  bool GetSegmentIntersection(const Point64& p1,
    const Point64& p2, const Point64& p3, const Point64& p4, Point64& ip)
  {
-    int res1 = CrossProductSign(p1, p3, p4);
-    int res2 = CrossProductSign(p2, p3, p4);
+    double res1 = CrossProduct(p1, p3, p4);
+    double res2 = CrossProduct(p2, p3, p4);
    if (res1 == 0)
    {
      ip = p1;
@@ -97,8 +97,8 @@ namespace Clipper2Lib {
    }
    if ((res1 > 0) == (res2 > 0)) return false;

-    int res3 = CrossProductSign(p3, p1, p2);
-    int res4 = CrossProductSign(p4, p1, p2);
+    double res3 = CrossProduct(p3, p1, p2);
+    double res4 = CrossProduct(p4, p1, p2);
    if (res3 == 0)
    {
      ip = p3;
@@ -116,7 +116,7 @@ namespace Clipper2Lib {
    if ((res3 > 0) == (res4 > 0)) return false;

    // segments must intersect to get here
-    return GetLineIntersectPt(p1, p2, p3, p4, ip);
+    return GetSegmentIntersectPt(p1, p2, p3, p4, ip);
  }

  inline bool GetIntersection(const Path64& rectPath,
@@ -227,7 +227,7 @@ namespace Clipper2Lib {
    const Point64& prev_pt, const Point64& curr_pt, const Point64& rect_mp)
  {
    if (AreOpposites(prev, curr))
-      return CrossProductSign(prev_pt, rect_mp, curr_pt) < 0;
+      return CrossProduct(prev_pt, rect_mp, curr_pt) < 0;
    else
      return HeadingClockwise(prev, curr);
  }
@@ -6,4 +6,3 @@
 #include "clipper.engine.cpp"
 #include "clipper.offset.cpp"
 #include "clipper.rectclip.cpp"
-#include "clipper.triangulation.cpp"
@@ -33,8 +33,8 @@

 // Axis-aligned bounding box tree for tet tri intersection
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>

 // Boolean operations
 #include <CGAL/Polyhedron_3.h>
@@ -41,9 +41,9 @@ IGL_INLINE void igl::copyleft::cgal::closest_facet(
    const std::vector<std::vector<size_t> > & VF,
    const std::vector<std::vector<size_t> > & VFi,
    const CGAL::AABB_tree<
-      CGAL::AABB_traits_3<
+      CGAL::AABB_traits<
        Kernel, 
-        CGAL::AABB_triangle_primitive_3<
+        CGAL::AABB_triangle_primitive<
          Kernel, typename std::vector<
            typename Kernel::Triangle_3 >::iterator > > > & tree,
    const std::vector<typename Kernel::Triangle_3 > & triangles,
@@ -56,8 +56,8 @@ IGL_INLINE void igl::copyleft::cgal::closest_facet(
  typedef typename Kernel::Segment_3 Segment_3;
  typedef typename Kernel::Triangle_3 Triangle;
  typedef typename std::vector<Triangle>::iterator Iterator;
-  typedef typename CGAL::AABB_triangle_primitive_3<Kernel, Iterator> Primitive;
-  typedef typename CGAL::AABB_traits_3<Kernel, Primitive> AABB_triangle_traits;
+  typedef typename CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
+  typedef typename CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef typename CGAL::AABB_tree<AABB_triangle_traits> Tree;

  if (F.rows() <= 0 || I.rows() <= 0) {
@@ -451,8 +451,8 @@ IGL_INLINE void igl::copyleft::cgal::closest_facet(
  typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel;
  typedef Kernel::Triangle_3 Triangle;
  typedef std::vector<Triangle>::iterator Iterator;
-  typedef CGAL::AABB_triangle_primitive_3<Kernel, Iterator> Primitive;
-  typedef CGAL::AABB_traits_3<Kernel, Primitive> AABB_triangle_traits;
+  typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
+  typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;

  if (F.rows() <= 0 || I.rows() <= 0) {
@@ -498,9 +498,9 @@ IGL_INLINE void igl::copyleft::cgal::closest_facet(
 #ifdef IGL_STATIC_LIBRARY
 // Explicit template instantiation
 // generated by autoexplicit.sh
-template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 1, -1, 3>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>>::iterator, CGAL::Boolean_tag<false>>, CGAL::Default>> const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>> const&, std::vector<bool, std::allocator<bool>> const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&);
+template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 1, -1, 3>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>>::iterator, CGAL::Boolean_tag<false>>, CGAL::Default>> const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>> const&, std::vector<bool, std::allocator<bool>> const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&);
 // generated by autoexplicit.sh
-template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>>::iterator, CGAL::Boolean_tag<false>>, CGAL::Default>> const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>> const&, std::vector<bool, std::allocator<bool>> const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&);
+template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>>::iterator, CGAL::Boolean_tag<false>>, CGAL::Default>> const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>> const&, std::vector<bool, std::allocator<bool>> const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&);
 // generated by autoexplicit.sh
 template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(
    Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1> > const&, 
@@ -509,7 +509,7 @@ template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT,
    Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1> > const&, 
    Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, 
    Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, 
-    Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> > const&, std::vector<bool, std::allocator<bool> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&);
+    Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> > const&, std::vector<bool, std::allocator<bool> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&);
 #include <cstdint>
 template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(
 Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1> > const&, 
@@ -518,7 +518,7 @@ Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&,
 Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1> > const&, 
 Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, 
 Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, 
-Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> > const&, std::vector<bool, std::allocator<bool> > const&, 
+Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> > const&, std::vector<bool, std::allocator<bool> > const&, 
 Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, 
 Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&);

@@ -14,8 +14,8 @@
 #include <vector>

 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/intersections.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>

@@ -67,9 +67,9 @@ namespace igl
          const std::vector<std::vector<size_t> > & VF,
          const std::vector<std::vector<size_t> > & VFi,
          const CGAL::AABB_tree<
-            CGAL::AABB_traits_3<
+            CGAL::AABB_traits<
              Kernel, 
-              CGAL::AABB_triangle_primitive_3<
+              CGAL::AABB_triangle_primitive<
                Kernel, typename std::vector<
                  typename Kernel::Triangle_3 >::iterator > > > & tree,
          const std::vector<typename Kernel::Triangle_3 > & triangles,
@@ -139,9 +139,9 @@ namespace igl
          const std::vector<std::vector<size_t> > & VF,
          const std::vector<std::vector<size_t> > & VFi,
          const CGAL::AABB_tree<
-            CGAL::AABB_traits_3<
+            CGAL::AABB_traits<
              Kernel, 
-              CGAL::AABB_triangle_primitive_3<
+              CGAL::AABB_triangle_primitive<
                Kernel, typename std::vector<
                  typename Kernel::Triangle_3 >::iterator > > > & tree,
          const std::vector<typename Kernel::Triangle_3 > & triangles,
@@ -12,8 +12,8 @@
 #include "points_inside_component.h"

 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>

 #include <cassert>
@@ -23,8 +23,8 @@
 #include "../../vertex_triangle_adjacency.h"

 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/intersections.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>

@@ -156,9 +156,9 @@ IGL_INLINE size_t igl::copyleft::cgal::extract_cells(
  std::vector<VectorXI> Is(num_components);
  std::vector<
    CGAL::AABB_tree<
-      CGAL::AABB_traits_3<
+      CGAL::AABB_traits<
        Kernel,
-        CGAL::AABB_triangle_primitive_3<
+        CGAL::AABB_triangle_primitive<
          Kernel, std::vector<
            Kernel::Triangle_3 >::iterator > > > > trees(num_components);
  std::vector< std::vector<Kernel::Triangle_3 > >
@@ -9,8 +9,8 @@ template <
 IGL_INLINE void igl::copyleft::cgal::hausdorff(
  const Eigen::MatrixBase<DerivedV>& V,
  const CGAL::AABB_tree<
-    CGAL::AABB_traits_3<Kernel, 
-      CGAL::AABB_triangle_primitive_3<Kernel, 
+    CGAL::AABB_traits<Kernel, 
+      CGAL::AABB_triangle_primitive<Kernel, 
        typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
      >
    >
@@ -27,8 +27,8 @@ IGL_INLINE void igl::copyleft::cgal::hausdorff(
  {
    CGAL::Point_3<Kernel> query(x,y,z);
    typename CGAL::AABB_tree<
-      CGAL::AABB_traits_3<Kernel, 
-        CGAL::AABB_triangle_primitive_3<Kernel, 
+      CGAL::AABB_traits<Kernel, 
+        CGAL::AABB_triangle_primitive<Kernel, 
          typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
        >
      >
@@ -41,5 +41,5 @@ IGL_INLINE void igl::copyleft::cgal::hausdorff(
 #ifdef IGL_STATIC_LIBRARY
 // Explicit template instantiation
 // generated by autoexplicit.sh
-template void igl::copyleft::cgal::hausdorff<Eigen::Matrix<double, -1, -1, 0, -1, -1>, CGAL::Simple_cartesian<double>, double>(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Simple_cartesian<double>, CGAL::AABB_triangle_primitive_3<CGAL::Simple_cartesian<double>, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > > const&, double&, double&);
+template void igl::copyleft::cgal::hausdorff<Eigen::Matrix<double, -1, -1, 0, -1, -1>, CGAL::Simple_cartesian<double>, double>(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Simple_cartesian<double>, CGAL::AABB_triangle_primitive<CGAL::Simple_cartesian<double>, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > > const&, double&, double&);
 #endif
@@ -38,8 +38,8 @@ namespace igl
      IGL_INLINE void hausdorff(
        const Eigen::MatrixBase<DerivedV>& V,
        const CGAL::AABB_tree<
-          CGAL::AABB_traits_3<Kernel, 
-            CGAL::AABB_triangle_primitive_3<Kernel, 
+          CGAL::AABB_traits<Kernel, 
+            CGAL::AABB_triangle_primitive<Kernel, 
              typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
            >
          >
@@ -12,8 +12,8 @@
 #include "../../remove_unreferenced.h"

 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/intersections.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>

@@ -12,8 +12,8 @@
 #include "../../remove_unreferenced.h"

 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/intersections.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>

@@ -29,8 +29,8 @@ IGL_INLINE void igl::copyleft::cgal::point_mesh_squared_distance(
  using namespace std;
  typedef CGAL::Triangle_3<Kernel> Triangle_3; 
  typedef typename std::vector<Triangle_3>::iterator Iterator;
-  typedef CGAL::AABB_triangle_primitive_3<Kernel, Iterator> Primitive;
-  typedef CGAL::AABB_traits_3<Kernel, Primitive> AABB_triangle_traits;
+  typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
+  typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
  Tree tree;
  vector<Triangle_3> T;
@@ -43,8 +43,8 @@ IGL_INLINE void igl::copyleft::cgal::point_mesh_squared_distance_precompute(
  const Eigen::MatrixBase<DerivedV> & V,
  const Eigen::MatrixBase<DerivedF> & F,
  CGAL::AABB_tree<
-    CGAL::AABB_traits_3<Kernel, 
-      CGAL::AABB_triangle_primitive_3<Kernel, 
+    CGAL::AABB_traits<Kernel, 
+      CGAL::AABB_triangle_primitive<Kernel, 
        typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
      >
    >
@@ -90,8 +90,8 @@ template <
 IGL_INLINE void igl::copyleft::cgal::point_mesh_squared_distance(
  const Eigen::MatrixBase<DerivedP> & P,
  const CGAL::AABB_tree<
-    CGAL::AABB_traits_3<Kernel, 
-      CGAL::AABB_triangle_primitive_3<Kernel, 
+    CGAL::AABB_traits<Kernel, 
+      CGAL::AABB_triangle_primitive<Kernel, 
        typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
      >
    >
@@ -103,8 +103,8 @@ IGL_INLINE void igl::copyleft::cgal::point_mesh_squared_distance(
 {
  typedef CGAL::Triangle_3<Kernel> Triangle_3; 
  typedef typename std::vector<Triangle_3>::iterator Iterator;
-  typedef CGAL::AABB_triangle_primitive_3<Kernel, Iterator> Primitive;
-  typedef CGAL::AABB_traits_3<Kernel, Primitive> AABB_triangle_traits;
+  typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
+  typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
  typedef typename Tree::Point_and_primitive_id Point_and_primitive_id;
  typedef CGAL::Point_3<Kernel>    Point_3;
@@ -134,7 +134,7 @@ IGL_INLINE void igl::copyleft::cgal::point_mesh_squared_distance(
 template void igl::copyleft::cgal::point_mesh_squared_distance<CGAL::Epeck, Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>> const&, Eigen::PlainObjectBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>>&);
 template void igl::copyleft::cgal::point_mesh_squared_distance<CGAL::Epeck,   Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>,   Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1,   -1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 1, 0, -1, 1>,   Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>   >(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3,   0, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0,   -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>   > const&,   Eigen::PlainObjectBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 1,   0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&,   Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&);
 template void igl::copyleft::cgal::point_mesh_squared_distance<CGAL::Epeck, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&);
-template void igl::copyleft::cgal::point_mesh_squared_distance<CGAL::Simple_cartesian<double>, Eigen::Matrix<double, -1, 3, 1, -1, 3>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Simple_cartesian<double>, CGAL::AABB_triangle_primitive_3<CGAL::Simple_cartesian<double>, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> >&);
-template void igl::copyleft::cgal::point_mesh_squared_distance_precompute<CGAL::Simple_cartesian<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Simple_cartesian<double>, CGAL::AABB_triangle_primitive_3<CGAL::Simple_cartesian<double>, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> >&, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >&);
-template void igl::copyleft::cgal::point_mesh_squared_distance_precompute<CGAL::Simple_cartesian<double>, Eigen::Matrix<double, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Simple_cartesian<double>, CGAL::AABB_triangle_primitive_3<CGAL::Simple_cartesian<double>, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> >&, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >&);
+template void igl::copyleft::cgal::point_mesh_squared_distance<CGAL::Simple_cartesian<double>, Eigen::Matrix<double, -1, 3, 1, -1, 3>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Simple_cartesian<double>, CGAL::AABB_triangle_primitive<CGAL::Simple_cartesian<double>, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> >&);
+template void igl::copyleft::cgal::point_mesh_squared_distance_precompute<CGAL::Simple_cartesian<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Simple_cartesian<double>, CGAL::AABB_triangle_primitive<CGAL::Simple_cartesian<double>, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> >&, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >&);
+template void igl::copyleft::cgal::point_mesh_squared_distance_precompute<CGAL::Simple_cartesian<double>, Eigen::Matrix<double, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Simple_cartesian<double>, CGAL::AABB_triangle_primitive<CGAL::Simple_cartesian<double>, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> >&, std::vector<CGAL::Triangle_3<CGAL::Simple_cartesian<double> >, std::allocator<CGAL::Triangle_3<CGAL::Simple_cartesian<double> > > >&);
 #endif
@@ -63,8 +63,8 @@ namespace igl
        const Eigen::MatrixBase<DerivedV> & V,
        const Eigen::MatrixBase<DerivedF> & F,
        CGAL::AABB_tree<
-          CGAL::AABB_traits_3<Kernel, 
-            CGAL::AABB_triangle_primitive_3<Kernel, 
+          CGAL::AABB_traits<Kernel, 
+            CGAL::AABB_triangle_primitive<Kernel, 
              typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
            >
          >
@@ -89,8 +89,8 @@ namespace igl
      IGL_INLINE void point_mesh_squared_distance(
        const Eigen::MatrixBase<DerivedP> & P,
        const CGAL::AABB_tree<
-          CGAL::AABB_traits_3<Kernel, 
-            CGAL::AABB_triangle_primitive_3<Kernel, 
+          CGAL::AABB_traits<Kernel, 
+            CGAL::AABB_triangle_primitive<Kernel, 
              typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
            >
          >
@@ -13,8 +13,8 @@
 #include "assign_scalar.h"

 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>

 #include <cassert>
@@ -35,8 +35,8 @@ namespace igl {
            typedef Kernel::Triangle_3 Triangle;
            typedef Kernel::Plane_3 Plane_3;
            typedef std::vector<Triangle>::iterator Iterator;
-            typedef CGAL::AABB_triangle_primitive_3<Kernel, Iterator> Primitive;
-            typedef CGAL::AABB_traits_3<Kernel, Primitive> AABB_triangle_traits;
+            typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
+            typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
            typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;

            template<typename DerivedF, typename DerivedI>
@@ -23,8 +23,8 @@
 #include <CGAL/IO/output_surface_facets_to_polyhedron.h>
 // Axis-aligned bounding box tree for tet tri intersection
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <vector>

 IGL_INLINE bool igl::copyleft::cgal::signed_distance_isosurface(
@@ -18,9 +18,9 @@ IGL_INLINE void igl::copyleft::cgal::submesh_aabb_tree(
  const Eigen::MatrixBase<DerivedF>& F,
  const Eigen::MatrixBase<DerivedI>& I,
  CGAL::AABB_tree<
-    CGAL::AABB_traits_3<
+    CGAL::AABB_traits<
      Kernel, 
-      CGAL::AABB_triangle_primitive_3<
+      CGAL::AABB_triangle_primitive<
        Kernel, typename std::vector<
          typename Kernel::Triangle_3 >::iterator > > > & tree,
  std::vector<typename Kernel::Triangle_3 > & triangles,
@@ -51,7 +51,7 @@ IGL_INLINE void igl::copyleft::cgal::submesh_aabb_tree(
 #ifdef IGL_STATIC_LIBRARY
 // Explicit template instantiation
 // generated by autoexplicit.sh
-template void igl::copyleft::cgal::submesh_aabb_tree<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> > > >&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >&, std::vector<bool, std::allocator<bool> >&);
-template void igl::copyleft::cgal::submesh_aabb_tree<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> > > >&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >&, std::vector<bool, std::allocator<bool> >&);
-template void igl::copyleft::cgal::submesh_aabb_tree<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> > > >&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >&, std::vector<bool, std::allocator<bool> >&);
+template void igl::copyleft::cgal::submesh_aabb_tree<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> > > >&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >&, std::vector<bool, std::allocator<bool> >&);
+template void igl::copyleft::cgal::submesh_aabb_tree<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> > > >&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >&, std::vector<bool, std::allocator<bool> >&);
+template void igl::copyleft::cgal::submesh_aabb_tree<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> > > >&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >&, std::vector<bool, std::allocator<bool> >&);
 #endif
@@ -14,8 +14,8 @@
 #include <vector>

 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/intersections.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>

@@ -44,9 +44,9 @@ namespace igl
        const Eigen::MatrixBase<DerivedF>& F,
        const Eigen::MatrixBase<DerivedI>& I,
        CGAL::AABB_tree<
-          CGAL::AABB_traits_3<
+          CGAL::AABB_traits<
            Kernel, 
-            CGAL::AABB_triangle_primitive_3<
+            CGAL::AABB_triangle_primitive<
              Kernel, typename std::vector<
                typename Kernel::Triangle_3 >::iterator > > > & tree,
        std::vector<typename Kernel::Triangle_3 > & triangles,
@@ -132,14 +132,14 @@ template<>
 inline void offset(Slic3r::ExPolygon& sh, coord_t distance, const PolygonTag&)
 {
 #define DISABLE_BOOST_OFFSET
-    auto res = Slic3r::offset_ex(sh, distance, Slic3r::jtSquare);
+    auto res = Slic3r::offset_ex(sh, distance, Slic3r::ClipperLib::jtSquare);
    if (!res.empty()) sh = res.front();
 }

 template<>
 inline void offset(Slic3r::Polygon& sh, coord_t distance, const PathTag&)
 {
-    auto res = Slic3r::offset(sh, distance, Slic3r::jtSquare);
+    auto res = Slic3r::offset(sh, distance, Slic3r::ClipperLib::jtSquare);
    if (!res.empty()) sh = res.front();
 }

@@ -88,18 +88,6 @@ struct NfpPConfig {
     */
    bool explore_holes = false;

-    /**
-     * @brief Keep the final pile on the bin.
-     *
-     * The final alignment centres the pile on the alignment target. A target
-     * near an edge (a belt printer starts its parts at the leading end of the
-     * belt) would push part of a pile that is larger than the room around that
-     * point off the bed; with this set the pile stops at the edge instead, and a
-     * pile that does not fit along an axis is centred on it. Off by default, so
-     * the alignment of every other printer is unchanged.
-     */
-    bool clamp_to_bin = false;
-
    /**
     * @brief If true, use all CPUs available. Run on a single core otherwise.
     */
@@ -1123,24 +1111,7 @@ private:
        default: ; // DONT_ALIGN
        }

-        auto d = cb - ci;
-
-        // Keep the pile on the bin (see Config::clamp_to_bin). The items' boxes carry
-        // their inflation, which is the margin left at the edge.
-        if (config_.clamp_to_bin) {
-            auto on_bin = [](Coord lo, Coord hi, Coord bin_lo, Coord bin_hi, Coord shift) {
-                if (hi - lo >= bin_hi - bin_lo)
-                    return (bin_lo + bin_hi) / 2 - (lo + hi) / 2;
-                if (lo + shift < bin_lo)
-                    shift = bin_lo - lo;
-                if (hi + shift > bin_hi)
-                    shift = bin_hi - hi;
-                return shift;
-            };
-            setX(d, on_bin(getX(bb.minCorner()), getX(bb.maxCorner()), getX(bbin.minCorner()), getX(bbin.maxCorner()), getX(d)));
-            setY(d, on_bin(getY(bb.minCorner()), getY(bb.maxCorner()), getY(bbin.minCorner()), getY(bbin.maxCorner()), getY(d)));
-            cb = ci + d;
-        }
+        auto d = cb - ci;       

        // BBS make sure the item won't clash with excluded regions
        // do we have wipe tower after arranging?
@@ -191,7 +191,7 @@ public:
            tail->next = std::move(p);
            tail = new_tail;
        }
-        disrupt_wait_for_data();
+        data_cond.notify_one();
    }

    void wait_and_pop(T& value)
@@ -19,7 +19,11 @@ if(Qhull_FOUND)
 message(STATUS "Using qhull from system.")
 if(SLIC3R_STATIC)
    slic3r_remap_configs("Qhull::qhullcpp;Qhull::qhullstatic_r" RelWithDebInfo Release)
-    target_link_libraries(qhull INTERFACE Qhull::qhullcpp Qhull::qhullstatic_r)
+    if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
+        target_link_libraries(qhull INTERFACE Qhull::qhullcpp_d Qhull::qhullstatic_rd)
+    else()
+        target_link_libraries(qhull INTERFACE Qhull::qhullcpp Qhull::qhullstatic_r)
+    endif()
 else()
    slic3r_remap_configs("Qhull::qhullcpp;Qhull::qhull_r" RelWithDebInfo Release)
    target_link_libraries(qhull INTERFACE Qhull::qhullcpp Qhull::qhull_r)
@@ -1,221 +0,0 @@
-# Adaptive TPMS infill — High Level Design
-
-## Purpose and scope
-
-`tpms_adaptive` grades the sparse infill of the Gyroid, TPMS-D and TPMS-FK
-patterns inside the object: the cells grow continuously from the surface
-towards the center of the object. `distance_warp`, `smooth_blend` and
-`stepped_shells` follow the distance to the nearest surface, including the top
-and bottom, like concentric shells; `lobes` follows the whole 3D shape towards
-the center of each lobe of the object; `normal_z`, `normal_y` and `normal_x`
-follow each section of the object normal to that axis, so the grading does not
-change along the axis, as suits a profile extruded along it.
-`sparse_infill_density` is the density at the surface, `tpms_interior_density`
-the density at the center, and `tpms_adaptive_gradient` picks how the density
-goes from one to the other. Only internal sparse infill is graded; the Gyroid
-Z-buckling optimization does not apply to it.
-
-The design has two parts: a field built once per object, and a pattern made
-from it, warped around the center of each lobe of a body so that its cell size
-follows the field, or, in the modes following the distance to the surface,
-split into shells or blended between densities.
-
-## Radial field
-
-`TpmsRadialField` gives every point of an object the center of its lobe and a
-radial coordinate: 0 at the center, 1 at the surface along the ray from the
-center. `PrintObject::prepare_tpms_radial_fields()` builds it in
-`bridge_over_infill()`, next to the adaptive cubic octree, because the anchoring
-infill generated there has to match the printed infill. A field is built for
-every mode a region uses, and is shared by the regions using that mode: the
-field depends on the geometry only, the densities are applied per region in the
-fill. An object thinner than the grid cells has no body in the field; no field
-is kept then, and the infill falls back to the regular pattern. In the modes
-following the distance to the surface, the field also gives the depth of every
-point (see below).
-
-A regular 3D grid of cubic cells is rasterized from the `lslices` of the layers,
-so the field follows what is printed: negative volumes, the union of
-overlapping parts and holes are taken into account, and the mesh does not need
-to be closed. A padding node around the grid is always outside. The grid is
-capped at about a million nodes, with cells no smaller than 0.5 mm.
-
- Bodies are the connected inside nodes. Each is graded on its own, so separate
-  parts of one object each get their own sparse center.
- A body is split into lobes around the local maxima of the depth, by an exact
-  Euclidean distance transform (Felzenszwalb and Huttenlocher, one pass per
-  axis). Two maxima are in separate lobes when the depth along the segment
-  between them drops below 0.8 of the shallower one, like at the neck between
-  two united spheres; maxima shallower than 0.3 of the deepest one are ignored.
-  A maximum joins the first lobe whose first maximum it sees without a neck.
-  The lobes are made one at a time, the remaining maxima tested against the
-  first one in parallel, as a plate has a whole plane of them.
-  Where the depth ties along a line or a plane, as in a tall box, the lobe's
-  center is the node nearest to the middle of the tied nodes, so the center is
-  in the middle of the height and not a column.
- A point belongs to the lobe it is nearest to relative to their depths, so the
-  side between two lobes is nearer to the smaller one. Near that side, within a
-  tenth of that relative distance, the patterns of the lobes morph into each
-  other, so the lines stay continuous. Every lobe in that range takes part, up
-  to four, so the morph is also continuous where three or four lobes meet.
- The reach of a lobe is the distance from its center to the first exit along
-  24 x 48 latitude-longitude directions, smoothed twice over neighbouring
-  directions in log space. Towards a neighbouring lobe it stops at twice the
-  distance to the side between them, so that side is graded half way, as deep
-  as a neck is, rather than as sparse as the center or as dense as the surface.
-  Only the lobes whose centers are near enough to be nearer at the current
-  distance are compared along a ray, so many lobes, as in a perforated plate,
-  stay cheap.
-  The radial coordinate of a point is its distance to the center over the reach
-  in its direction. Behind a gap, as across the hole
-  of a ring, the radial coordinate is above 1 and the infill keeps the surface
-  density.
- Every outside node belongs to its nearest body, so points near a surface find
-  their body without a search. With a single body, all nodes belong to it.
-
-In the 2D modes, every plane of nodes normal to the axis is a field of its own:
-the distance transform skips the axis, bodies, lobes and the nearest body are
-found within the plane, and the reach is sampled on a circle of 48 directions.
-A point is looked up in the two planes around it, the weights of their lobes
-interpolated along the axis, so the grading does not step between planes; a
-plane without a body uses the nearest one that has one. The planes are a cell
-apart, not a layer: where the sections change abruptly, as at a step, the
-patterns of the two planes morph into each other over that cell.
-
-A distance to the nearest surface would be the obvious field, but no smooth map
-follows it. By the divergence theorem, the mean scale of a map over a body is
-fixed by its values on the surface: a map that keeps the full density along the
-whole surface, as the distance would ask under the top and bottom, has the mean
-density of the uniform infill, the sparser core being paid for by lines crowding
-along the walls. The layers of a plate at different depths would also need
-different line spacings in the same directions, which no continuous map allows
-without shearing across the plate. Following the distance needs changes of the
-topology of the lattice (see below). The radial coordinate instead grades what a
-single map can: towards one point.
-
-## Warped pattern
-
-The pattern is evaluated on warped coordinates:
-
-    TPMS(f_surface * m(t) * (p - center))
-
-where `m` scales the pattern around the center of the lobe: its frequency is
-`m + t * m'` along the ray and `m` across it. `m(t)` is the mean of the target
-scale over the ball of radius `t`, `3 / t^3 * integral of s^2 * target(s) ds`, so
-the mean of the three, and with it the density, follows the gradient. The cells
-are round at the center; near the surface they are flattened, with the lines
-running parallel to it. Beyond the surface the target is the surface scale, so
-the warp extends continuously outside.
-
-In the 2D modes only the coordinates within the plane are warped, and `m(t)` is
-the mean over the disc, `2 / t^2 * integral of s * target(s) ds`. Along the axis
-the pattern keeps the interior frequency: scaling it with `m` would shear the
-pattern by the distance along the axis times the gradient of `m`, without bound
-on a long object. The cells are round at the center and stretched along the
-axis near the surface. With Normal Z the layers are graded exactly, since
-the lines of a layer follow its in-plane frequencies; normal to X or Y, the
-layers near the sides are as dense as the larger of the two frequencies in the
-layer, which is the surface one.
-
-Evaluating a TPMS at a frequency that varies with the position without such a
-map distorts it wherever the frequency changes, because the phase also changes
-with the gradient of the frequency times the distance from the origin. Fitting a
-smooth map to a varying isotropic scale in the least-squares sense (a Poisson
-problem per axis) cannot grade strongly: its divergence is the target scale plus
-a harmonic function pinned by the surface, which keeps the scale in the core
-near two thirds of the surface one. Following a distance exactly needs the
-lattice to change its topology, by blending lattices of different densities or
-filling shells of equal distance with them, as the modes following the distance
-to the surface do.
-
-The target scale at depth `d = 1 - t`, with `S` the surface and `I` the interior
-frequency, both from each pattern's own density calibration:
-
-| Gradient    | Scale                  |
-|-------------|------------------------|
-| Linear      | `1 + (I / S - 1) * d`  |
-| Quadratic   | `1 + (I / S - 1) * d^2`|
-| Exponential | `(I / S)^d`            |
-
-With a denser surface, quadratic keeps the surface density deepest and
-exponential drops fastest. A denser interior works the same way.
-
-The zero level is extracted with marching squares like the regular TPMS-FK, on
-a sampling grid fixed in the fill frame like the optimized Gyroid, so that every
-region of a layer connects its lines the same way at the saddles of the pattern.
-Loops narrower than two lines (shorter than `2 * PI * spacing`) are dropped, as
-they would print as blobs. The fill works in a frame rotated by the infill
-angle, so the radial field is looked up at the point rotated back into the
-object frame, and the center rotated into the fill frame. Both use the middle of
-the layer.
-
-## Modes following the distance to the surface
-
-`distance_warp`, `smooth_blend` and `stepped_shells` grade by the distance to
-the nearest surface, including the top and bottom, as concentric shells do. The
-depth of a point is that distance over the distance of the deepest point of its
-body, from 0 at the surface to 1; the field keeps it for every node and
-interpolates it between them. A tall box so keeps its whole axis as sparse as
-its center, and a plate is graded through its thickness.
-
-No single smooth pattern follows that depth without distortion (see above), so
-the three modes trade differently:
-
- Distance warp keeps the lobes and the warp of Lobes, but its radial profile
-  comes from the depth. For every direction of a lobe, the mean depth over the
-  ball along the ray is sampled at 33 radii up to the reach, then smoothed over
-  the neighbouring directions like the reach. The radial coordinate is the one
-  of the linear profile with the same mean depth, `t = 4/3 * (1 - mean depth)`,
-  so with a linear gradient the mean cell size follows the depth exactly, and
-  with the others approximately. In a sphere or a cube, where the depth falls
-  linearly along every ray, it is Lobes. Elsewhere the profile changes with the
-  direction, and the warp shears where neighbouring directions differ, as in
-  plates and long bodies; right under the top of a long body the cells are
-  sparser within the layer, the warp moving their density into the height.
-  The profiles are smoothed over the directions like the reach, as sharper
-  ones shear the pattern across the layer, which adds lines. A long body is so
-  graded partly along its length, between Lobes and the distance.
- Smooth blend evaluates the regular patterns of the two levels around the
-  target of every point and blends them by a smoothstep over the whole gap
-  between the levels, here at most 2.5 times apart. The density follows the
-  depth without steps, but where two lattices blend, part of their lines run
-  along the blend, so fewer levels print fewer extra lines. From 25% to 5%,
-  three levels print about 0.45 of the uniform infill in a deep core whose
-  levels alone would print 0.3; levels 1.5 times apart print 0.6 to 0.7, and a
-  single blend from the surface to the interior 0.6.
- Stepped shells split each region of a layer into shells and fill every shell
-  with the regular pattern at its density. The densities are levels from the
-  surface to the interior density at most 1.5 times apart, five from 25% to 5%,
-  and a point takes the level nearest to its target on that geometric scale.
-  The shells are traced by marching squares of the continuous level over the
-  layer on a 0.5 mm grid fixed in the object, so every region of a layer gets
-  the same shells, and clipped to the region. Each shell is shrunk by half a
-  line, like a filled region, and its regular filler connects its lines along
-  that boundary, so the connections of two neighbouring shells lie side by side
-  instead of on top of each other. The pattern is never
-  distorted, but its lines end at every shell, and thin parts get thin shells.
-  The connections add lines: in the core of a 60 mm cube, about a third more
-  than the target.
-
-Stepped shells and Smooth blend need neither lobes nor reaches, which are not
-built for them.
-
-## Constraints
-
- With `tpms_adaptive` disabled, or for other patterns, the fill parameters are reset
-  to their defaults, so they neither change the infill nor split fill batches.
- `Layer::get_sparse_infill_max_void_area()` uses the sparser of the two
-  densities, as the voids at the center are that large.
- At a sparse infill density of 100% the sparse infill is turned into solid
-  infill, so there is nothing to grade: the options are hidden and no field is
-  built.
- The adaptive options invalidate `posPrepareInfill`, which rebuilds the field
-  and the anchoring infill.
- An elongated body without a neck has one center, so its far ends are graded
-  as the outer part of the body, and the warp shears where the reach changes
-  quickly with the direction. A concave body, like an L, may be split into lobes
-  where its maxima cannot see each other in a straight line.
- Across a ray, the scale is the mean of the gradient from the center, so the
-  layers right under the top and above the bottom are sparser than the surface
-  density in their middle, and a plate is graded from its middle outwards rather
-  than through its thickness.
@@ -1,172 +0,0 @@
-# Center of mass markers — High Level Design
-
-## Purpose and scope
-
-The "Center of mass" item of the canvas toolbar menu, in the bottom left corner of the 3D view, marks
-where the mass of the plate, of each object instance and of each body of an assembly is centered,
-in Prepare and in Preview. It helps judge how parts will rest on the plate, for instance whether a
-tall or leaning part could tip. It is a view setting: it changes nothing in the model, the slice or
-the project file, and it does not reach plate thumbnails. The choice is kept in the app config as
-`show_center_of_mass`, off by default. The assembly view and the Design tab have no markers.
-
-Three kinds of marker share one shape, a sphere whose octants alternate between two colors:
-
- each plate, black and white, for everything on it;
- each object instance, light blue and white;
- each body of an assembly, red and yellow;
- in Preview, the supports and raft of each object instance, green and black.
-
-A click on a marker opens a box beside it with the weight and volume of what it stands for, where its
-center lies in that thing's bounding box and the size of the box, and its moments of inertia about
-axes through the center parallel to x, y and z.
-
-An assembly is an object of several parts or with negative volumes. Its bodies are the connected
-solids its parts make once united, the bodies the separated infills option centers its infill on
-(see separated-infills.md): parts that overlap or touch are one body, parts apart are separate
-bodies. An object of one body, and every object of a single part, has no body markers, as its object
-marker says it all.
-
-Mass is volume times density, the `filament_density` of the filament that prints it, or 1.245 g/cm³
-(`DEFAULT_FILAMENT_DENSITY`) for a filament without one. Prepare has the model only, so it takes each
-part as a solid of the density of its filament, the part's own or else its object's. It reads each
-filament's density from the filament's selected preset, edits not yet saved included, as slicing does:
-the plater's own config holds the values of the filament edited last only. Preview has
-what will be printed, so its markers come from the toolpaths, whose mass depends on walls, infill
-and flow as well. There the solid markers are for what is printed up to the top layer the layer
-slider shows: for the plate with brim, raft and supports, where the weight rests at that point of
-the print; for an object or a body, its own extrusions. Each has a faded twin for the same at the
-end of the print, so the slider shows the weight moving toward where it ends, and at the top layer
-the two meet. In Prepare the plate has the model alone, as brim, raft and supports exist only once
-sliced.
-
-## Prepare: from the meshes
-
-An object of one part takes the mass properties of its mesh at unit density, times its density, from
-`its_mass_properties()`, which handles a mesh in a single pass. Each triangle and a fixed vertex of
-the mesh span a tetrahedron whose signed volume is `V = a · (b × c) / 6`, with `a`, `b`, `c` taken
-relative to that vertex. By the divergence theorem these volumes add up to the volume of a closed
-mesh, their volume-weighted centroids to its center of mass, and their second moments
-`V (a aᵀ + b bᵀ + c cᵀ + s sᵀ) / 20`, with `s = a + b + c`, to its own. Shells facing inward, such as
-a cavity, subtract themselves, and flipping every triangle changes nothing. The sums are kept in
-double precision and relative to a vertex of the mesh rather than the origin, which keeps them exact
-for meshes far from it. The result keeps the spread of the mass about its center,
-`(x - c)(x - c)ᵀ` averaged over the mass, from which the moments of inertia follow.
-
-The CGAL routines that look alike do not compute this. `CGAL::centroid` weighs tetrahedra by their
-unsigned volume, so it fails on cavities and on any shell that is not star-shaped from the fan's
-apex; over triangles it returns the centroid of the surface, and over points the average of the
-vertices, which depends on the tessellation. `CGAL::barycenter` with the signed volumes as weights
-gives the same answer, but only after copying every tetrahedron into a vector of weighted points,
-and takes two and a half times as long.
-
-A mesh's result is in its own coordinates. Each `GLVolume` maps it to the world with its world
-matrix `M`, and weighs it by the volume times the absolute determinant of that matrix: a center of
-mass moves with any affine map, and the spread becomes `L S Lᵀ` for the linear part `L` of `M`, so no
-mesh is ever transformed. The `GLVolume`'s matrices, rather than the
-model's, let the markers follow an object while it is dragged, before the model is updated. Results
-are cached by `ModelVolume` id; a `ModelVolume` takes a new id whenever its mesh changes, which is
-the rule `reload_scene()` relies on to rebuild a `GLVolume`'s geometry, so a cached result never
-outlives its mesh.
-
-An assembly's parts overlap or touch, which the mesh formula would count twice, so `solid_bodies()`
-slices them instead, in the object's coordinates. It cuts the height into 500 slabs, 100 while a part
-is dragged, slices every part and negative volume at the middle of each slab, unites the parts and
-cuts the negative volumes away, and links the islands of neighboring slabs that overlap into bodies
-with `connected_bodies()`. Each island adds a prism of the slab's thickness at the density: its
-area, and its first and second moments of area, from the same sums over the outline as the area,
-with the slab's height for z. Where parts of different densities overlap, the later volume of the object counts, as
-slicing clips every part by the parts after it; each part then weighs the region it prints, which is
-credited to the island holding it. Each body also keeps the convex hull of its islands and the height
-they span, whose corners, once transformed, give its bounding box, tight while the instance turns
-about z only. The object is the sum of its bodies, its box that of its parts, as the object's size
-shows it, and each plate the sum of the object instances `PartPlateList::find_instance()` puts on it,
-so that an instance on no plate counts in none. The bodies are cached by `ModelObject` id with the volumes, types, densities and
-transformations they were sliced from.
-
-## Preview: from the toolpaths
-
-`GCodeProcessor` sums the masses while it processes the G-code, in the same pass that builds the
-moves, and leaves them in `GCodeProcessorResult`; `GCodeViewer` keeps a copy of them when it loads a
-result. Nothing is stored per move.
-
-Each extrusion weighs the volume of filament its E extrudes times the density of the filament that
-extrudes it, so a print of several materials weighs each as it is. Flow ratio, line widths, ironing
-and purging into infill all count
-as printed. Its mass spreads evenly along the segment the bead's center runs, half the layer height
-below the nozzle, in the frame of the stored moves: plate offset added, Z offset removed. Such a
-segment from `a` to `b` adds `m (a + b) / 2` to the moments and `m (a² + a b + b²) / 3` to the second
-moments along each axis, and its box widened by half the bead's height to the bounding box; not by
-half its width, which the processor only estimates, so that a box runs along the walls' center lines. Arcs are already split into segments by the processor. Walls, infill, top and bottom surfaces, ironing
-and gap fill make the parts. The brim and the support roles, the raft among them, count only in what
-the plate prints. The skirt, the prime tower and custom G-code count nowhere.
-
-The plate takes every extrusion, so it needs nothing more. The objects and bodies need the sliced
-objects, which the G-code does not describe, so the G-code export hands the processor a locator
-built from the `Print`; G-code opened from a file, or from a project sliced earlier, has no `Print`
-behind it, and so shows the plate alone. Object labels would not do: profiles turn the four kinds
-Orca writes on and off in every combination, and none of them tells the bodies apart.
-
-The locator numbers the object instances and, for each assembly, the bodies of every instance. It
-takes the bodies `PrintObject::prepare_infill()` found for separated infills, or, when that option
-did not need them, links the islands (`Layer::lslices`) of neighboring layers into bodies with the
-same `connected_bodies()`. For each extrusion of a part, it finds the first layer printed at or above
-its height, as spiral vase rises through each layer, and the island holding it with an
-`IslandLocator`, the one `solid_bodies()` credits its regions with: by the island's box, widened by
-1 mm for walls reaching past it, with a polygon test only where boxes overlap, and the nearest
-outline where none holds the point. The boxes of one layer's islands say nothing of the other
-instances, so an instance whose widened box reaches another's, as copies placed side by side do,
-tests the outlines alone, and outside them the nearest outline of all such instances wins. The island
-gives both the instance and the body. The island found last is tried first, as extrusions mostly follow each other on one
-island. Brim, raft and supports lie outside the islands. The brim counts in the plate only; a support
-or raft extrusion goes to the instance whose footprint, the box of its widened islands, holds it, the
-one whose center is nearest among several, or else the nearest footprint, as supports stand below and
-around their object.
-
-Each mass holds, for each layer id, the running total of what is printed up to that layer, the last
-of which is the faded marker's, so the solid marker for any slider position is a single lookup. The layer ids are those
-the moves carry, which are also the layers of libvgcode and of the slider; in a print by object they
-follow the order of printing, so the solid markers show the objects printed so far as they are.
-
-## Drawing
-
-`smooth_sphere()` with a resolution divisible by four leaves every triangle within one octant, so it
-splits into two models drawn with the `gouraud_light` shader in each kind's two colors. The radius is
-9 pixels for the plate, 7 for the objects, 6 for the supports and 5 for the bodies, scaled like the canvas toolbar for the
-display's DPI and kept constant on screen through the camera's inverse zoom. They are drawn in that
-order, so that markers at one place show as rings. The faded markers are the same spheres at 40%
-opacity, drawn before all the solid ones, which show over them where both meet.
-
-The centers usually lie inside the objects, so the markers are drawn without the depth test and show
-through the objects and anything in front of them. Back face culling keeps the far half of a sphere
-from covering the near one. They are drawn after the ambient occlusion pass, which would otherwise
-darken them as the surface behind them, and before FXAA, which smooths their edges.
-
-The markers are part of the cached scene, so toggling them, or changing a filament's density while
-they are shown, marks the scene dirty, and moving the layer slider redraws the scene with the solid
-markers where they belong. In Prepare they are hidden while any gizmo other than Move, Rotate, Scale
-and Lay on face is open, since the others work on the surface a marker would cover, and a hidden
-object has no markers.
-
-## Details
-
-The markers drawn last are kept, and a left click is tested against them before it selects: each
-center and a point a radius to its right are projected to the screen, and the click hits a marker
-within that distance. The solid markers are tested before the faded ones and the smaller kinds
-before the larger, the order in which they cover each other. A hit opens the details of that marker
-and keeps the click from changing the selection; a click anywhere else closes them. The box is an
-ImGui window beside the marker, redrawn with the overlay from the markers of the last scene, so it
-follows a dragged object, and in Preview the layer slider. It closes when its marker is gone, or when
-the number of markers of its kind changes, as then it may stand for something else.
-
-Its title says what the marker stands for: the plate, an object, an assembly or a part, the body of
-an assembly. The G-code export lists the object instances for the processor, marking assemblies, as
-it hands it the locator.
-
-Each marker carries its sums: mass, volume, first moments and the second moments about the origin
-along each axis, `Σ m x²`, `Σ m y²` and `Σ m z²`, which add up from parts to objects to plates. The
-moment of inertia about the axis through the center parallel to x is then
-`m (σy² + σz²)`, with `σ² = Σ m x² / m - c²` along each axis, and likewise for y and z. Masses are
-kept in mg, volume times density in g/cm³, and shown in g, volumes in cm³ and moments of inertia in
-g·mm². In Preview the box tells the finished print from what is printed up to the layer shown, the
-two weighing differently, and both are placed in the bounding box of everything the marker holds
-by the end.
@@ -38,11 +38,7 @@ no wx dependency and is unit-tested.
 The notebook needs a page object for a tab to exist and for tabs to be inserted and
 removed by pointer, and the placeholder is that object. It builds the real panel inside
 itself the first time it is shown and forwards showing and hiding afterwards, so a panel's
-own show handling stays its activation hook. The build runs before the placeholder shows
-itself, so a panel built on demand is created in a hidden window as a prebuilt one is: on
-Windows every control created or moved inside a shown window re-clips and repaints its
-shown siblings, which makes building a large panel into a shown page many times slower.
-Nothing builds while the main window is
+own show handling stays its activation hook. Nothing builds while the main window is
 hidden; the window's first show builds the start page. A page that is out of the book is
 not prebuilt. A panel built while its page is hidden stays hidden, and gets the theming
 the window applied before the panel existed.
@@ -13,9 +13,8 @@ known.
 Its coupling to the rest of the application is deliberately narrow. It adds no stage to the
 slicing pipeline and touches neither the preset system nor `Tab`. It reaches the rest of Orca
 in two places: **Commit to Plate**, which hands finished solids to Prepare as ordinary model
-objects (by default one assembly object with a part per body, which keeps the bodies' relative
-placement, or one object per body), and one optional 3MF archive entry that carries the recipe.
-Everything else is contained in `src/libslic3r/CAD/` and `src/slic3r/GUI/CAD/`.
+objects, and one optional 3MF archive entry that carries the recipe. Everything else is
+contained in `src/libslic3r/CAD/` and `src/slic3r/GUI/CAD/`.

 The user-facing manual lives in the wiki
 ([Design Tab](https://www.orcaslicer.com/wiki/design_tab)), not here. This document covers the
@@ -52,13 +51,14 @@ widens the existing OCCT build by one module flag in `deps/OCCT/OCCT.cmake`:
 -DBUILD_MODULE_ModelingAlgorithms=${SLIC3R_CAD}
 ```

-Most of that module's toolkits are built either way, because `DataExchange`, which the STEP
-importer uses, depends on them. With the flag on, OCCT also builds `TKFillet` (used through
-`BRepFilletAPI`), `TKOffset` (`BRepOffsetAPI`), and `TKFeat`, `TKHelix`, `TKXMesh` and
-`TKExpress`, which nothing here references but which the module flag builds anyway, because
-OCCT's module flags are all-or-nothing. On macOS and Linux OCCT links statically, so an
-unreferenced toolkit costs build time and no shipped bytes. On Windows OCCT builds shared and
-only the linked toolkits ship, so the tab adds the `TKFillet`, `TKOffset` and `TKBool` DLLs.
+Most of that module's twelve toolkits were already being built, because `DataExchange` — the
+STEP path upstream ships — depends on them. The delta is `TKFillet` (used through
+`BRepFilletAPI`), `TKOffset` (`BRepOffsetAPI`) and `TKFeat`, which nothing here references but
+which the module flag builds anyway, because OCCT's module flags are all-or-nothing. On macOS
+and Linux OCCT links statically, so an unreferenced toolkit costs build time and no shipped
+bytes; on Windows OCCT builds shared, so the cost there is real DLL bytes. That Windows figure
+has not been measured, and `OCCT.cmake` says so rather than carrying a number that was derived
+from an incomplete toolkit list.

 On Windows the packaging step asserts that every linked OCCT toolkit has a shipped DLL and
 fails the configure with the name of any that is missing, because the alternative failure — a
@@ -117,11 +117,6 @@ that keep it survivable are:
 `Import` features embed the imported solid as an OCCT BRep string inside the recipe rather than
 referencing the source file, so a project opens without the STEP or mesh it was built from.
 The cost is that saved projects are coupled to an OCCT BRep revision.
-`tests/data/cad_brep_occt76.brep` holds a solid written by OCCT 7.6, and its test fails if the
-bundled OCCT can no longer read it.
-A Text feature follows the same rule: it stores the outlines it was vectorised into alongside
-its string, font and height, so the project opens identically on a machine that lacks the font;
-the three parameters are only what an edit reopens the dialog with.

 ## The interaction contract

@@ -135,8 +130,8 @@ contract between them is stated in code rather than spread across handlers.
 | --- | --- | --- |
 | `Transient` | a value field or a popup menu | closes it; the tool stays armed |
 | `Gesture` | an uncommitted delta — an entity being drawn, a body being dragged | reverts it; committed work is untouched |
-| `Tool` | a feature card, Sketch waiting for its plane, an armed sketch tool, a constrain session | exits it; drawn entities survive |
-| `Idle` | nothing transient | clears the selection, a Feature tree or Bodies row included; leaves a sketch session only if it is empty |
+| `Tool` | a feature card, an armed sketch tool, a constrain session | exits it; drawn entities survive |
+| `Idle` | nothing transient | clears the selection; leaves a sketch session only if it is empty |

 `cad_escape_level()` is a `constexpr` free function over a POD of four booleans rather than a
 method on the panel, so the ordering that is the entire contract is checkable without a window,
@@ -149,176 +144,18 @@ explicit selection, the sketch ribbon's Cancel, which asks first, or `Ctrl+Z`. A
 *session* is deliberately not a `Tool` level; it is the environment the `Idle` level lives in,
 which makes the destructive path unrepresentable rather than merely unlikely.

-A body Move is the one `Gesture` that outlives the press: its gizmo stays up between drags until
-Confirm keeps the placement or `Esc` or Cancel puts the body back. Until then the selection is
-held — a click off the gizmo only steers the camera — and undo is refused, since the placement
-is not in the history. Anything that starts another edit (a feature card, a sketch, placing
-imported art or text, another body's Move, a rebuild) keeps the placement, as switching gizmos
-keeps a move in Prepare. The panel ends the Move in one place (`DesignPanel::end_body_move`), so
-the gizmo, the Move / Rotate card and the ✓/✗ cannot outlive one another.
+Right-click is read at button-up against two independent budgets — 3 px of drift and 200 ms —
+because drift alone still popped a menu at the end of a slow, careful orbit. The raycast uses
+the press position, not the release. An armed sketch tool that already consumed the right
+button (to terminate a chain, say) declines to also open a menu, through a read-and-clear flag.
+Past either budget the event is navigation, and navigation does not transition the state
+machine.

-Right-click is read at button-up against one budget, 3 px of drift, applied to the whole press
-rather than to its end points: a press that wandered past the budget at any moment is
-navigation, even if it comes back to where it started, which is what stops a slow, careful
-orbit from ending in a menu. There is no time budget — a gesture that means something different
-when it is slow is exactly what the interaction charter rules out. The raycast uses the press
-position, not the release. The sketch tool sees a right press only once the release has shown it
-was a click: the press itself goes to the camera, which may pan or orbit with that button, and the
-canvas replays it to the tool on a stationary release. A tool that uses the click (to terminate a
-chain, say) keeps the menu closed. Past either budget the event is navigation, and navigation
-does not transition the state machine.
-
-Navigation itself is Prepare's: the camera reads the drag actions set in Preferences > Control
-for each button, and in the Touchpad camera style a move with Alt held orbits and one with Shift
-held pans, whatever tool is armed. The left button is shared with picking and drawing, so a tool
-handle or a press that draws takes it first, as a gizmo does in Prepare; a whole body is swept
-with a rectangle on plain left-drag only while no camera action is assigned to the left button,
-and with Shift+left-drag otherwise — Prepare's own rectangle selection.
-
-Entering a sketch changes two things at once so the mode is legible: a banner above the
+Entering a sketch changes three things at once so the mode is legible: a banner above the
 canvas (a sibling of the canvas, not a child over it — on GTK a child window over a
-`wxGLCanvas` is a native window and does not reliably stack over GL), and `N` to look normal to
-the plane. The printer bed stays: there is no sketch grid, so the plate grid is the only ground
-reference a sketch has. Code that changes either belongs with a change to this section.
-
-Sketch mode is never entered without a plane under it, so the banner, the sketch keys and the
-sketch offer always have a session to act on. Sketch on a picked flat face or reference plane opens
-the session on it at once. With nothing picked it stays in Feature mode and waits for one — an
-armed `Tool`, left with `Esc` or ✗, and ended by anything that starts another edit — and the
-reference plane or flat face clicked next opens the session. A picked plane is a selection like a
-face: the sketch on it uses it up, and `Esc` or a click on nothing lets go of it, so a plane that
-can no longer be seen never decides where the next sketch goes.
-
-The reference planes — XY, XZ and YZ through the modeling origin, with their half-axes — are
-drawn on demand, because three translucent squares over every model are noise once they are not
-the thing being picked. Sketch brings them up while it waits for a plane, which is exactly when
-they are picked, and the session the pick opens takes them away; a live session draws none. The
-Feature tree's Origin row keeps them up outside a sketch. Its state is a view preference in
-AppConfig rather than part of the recipe, so it costs the project format nothing. The Plane tool
-keeps its own rule: the planes and the datums as Offset bases, and nothing for the other methods,
-where a click on a plane would rewrite the datum's references. The `P` and `A` keys are a
-separate, unpickable view helper and do not follow the Origin row.
-
-The Bed row, under the Origin row, is the printer bed's switch in the same way: it draws or hides
-the bed and its plate grid in every mode. It is a view preference in AppConfig too, and the bed is
-shown until it is turned off.
-
-The two rows are view switches, not history, and the tree says so: they sit unframed on the Feature
-tree's card, above the features' own framed list, and stay put while the features scroll. A click
-never selects either row, since a selected Origin or Bed would have nothing to edit, move or
-delete; the eye and the right-click menu are the only targets, and a row's label dims while its
-thing is hidden, as a hidden body's does. Because the block never takes the focus, `Ctrl+Shift+O`
-and `Ctrl+Shift+B` flip the Origin and the Bed from the keyboard.
-
-## Rendering the bodies
-
-The tab draws its bodies through the same `GLCanvas3D` object path as Prepare, so how they look
-is decided in the shared object shader, not in the tab. The slicer's two lights both sit near
-the camera, which leaves the sides of a part in nearly one tone; the Design canvas asks for a
-studio model instead — a world-space sky/ground hemisphere, a key and a fill light, a
-plastic-like highlight and a darker silhouette — through `GLCanvas3D::set_studio_lighting()`
-and the phong shader's `lighting_model` uniform. The program is shared by every canvas, so each
-use sets the uniform (0 for the slicer's canvases) rather than relying on a default: a canvas
-that left it alone would inherit whatever the last canvas chose.
-
-The B-rep edges of every body are drawn over it by the sketch overlay as thin view-facing
-ribbons, depth tested and pulled a few pixels toward the eye so they win against the faces that
-meet at them and still hide behind faces in front; lines are not used because they do not
-rasterise under the software GL context the tab also supports. Seams of closed surfaces and
-degenerate edges are left out (`GeometryEngine::display_edges`), and the polylines are sampled
-once per shape, keyed by its `TShape`, because a recompute that leaves a body unchanged is the
-common case.
-
-While a feature card is open, its preview ghost is the whole model the candidate would produce,
-drawn translucent over the bodies, so every face the feature leaves alone is in both at the same
-depth. The ghost is drawn with a depth bias that pushes it back (`GLVolume::depth_bias`), so on a shared face
-the body always wins instead of the two copies z-fighting, and the ghost shows only where the
-result reaches past the bodies. Material a feature removes lies inside the old solid and would not
-show at all, so the tools whose result mostly coincides with the body — Fillet/Chamfer, Draft,
-Hole and the Mate hover — hide the bodies once the preview is valid and draw the result alone,
-opaque.
-
-## Showing what is selected
-
-A selection is drawn on the faces it names, never as a tint over the body: a translucent
-selection colour blended into the body's own colour turns a different hue on every body and
-vanishes on one close to it. Selected faces are split out of their body into a volume of their
-own, which the canvas draws opaque in the selection colour through the same shader and lighting
-as the body (`DesignCanvas::rebuild_bodies`); the sketch overlay outlines them with a cased line
-— a dark band under a selection-coloured one — so the outline still reads on a body that wears
-the selection colour itself. A body picked whole, a face picked in the viewport and the faces of
-the Feature tree's selected feature all draw this way. The hover pre-highlight is the outline
-alone, uncased: it promises a click, it is not one. The automatic body colours keep clear of the
-selection colour's blues and teals, so no body looks selected before anything is picked; a colour
-the user sets on a body is theirs, and the cased outline keeps its selection readable.
-
-Selecting a feature row lights the faces that feature made, not the whole body it sits on, so a
-fillet row shows its round and the extrude under it keeps the faces the fillet trimmed.
-`CadDocument::faces_made_by` answers it without per-feature history: it replays the recipe to
-just before the feature and then the feature alone, and a face of the finished model belongs to
-the feature when an interior point of it lies on the boundary afterwards and not before, facing
-the same way — the facing keeps a block stacked on a base the owner of its bottom face. A feature
-that makes no face of its own, such as a Boolean union, answers with the bodies it changed. The
-replay costs up to a recompute, so the panel finds the faces once per row and topology
-generation, off the UI thread, and only while no feature card is open. One selection is live at
-a time: a viewport pick clears the feature row and a feature row clears the viewport pick, as the
-Feature tree and Bodies list do between themselves. `Esc`, a click on empty space and an
-empty rubber band all let go of it, whichever list or pick made it — except while a body Move is
-open, which holds the selection until it ends (see the interaction contract).
-
-Zoom to selection, on a Feature tree or Bodies row and in its right-click menu, frames one thing
-along the current view direction, as the canvas's Fit button frames the selection. On a body it
-frames the body whole, hidden or not, from its display mesh: the viewport never selects a hidden
-body, so the selection cannot stand in for it. On a sketch it frames the sketch's own geometry,
-drawn, consumed or suppressed; on any other feature, the faces the feature made, found as the row
-highlight finds them and from the same cache. From the offer it frames whatever the selection is,
-a body again included. A feature that is not a sketch and makes no faces, such as a datum plane
-or a suppressed Extrude, has no Zoom to selection.
-
-## Following the app
-
-The tab is a page of Orca's main window and answers to the same settings as Prepare.
-
- **Theme.** Its chrome is coloured from a table of light/dark token pairs. A theme switch
-  reaches `DesignPanel::on_sys_color_changed` from `MainFrame`, which moves every colour that is
-  one theme's token onto the other theme's and then runs the app's own dark pass; the icons are
-  Orca's sidebar grey, which the icon cache maps per theme, so they are re-rasterised rather
-  than re-tinted.
- **Scale.** Sizes are in DIP, and a DPI change reaches `DesignPanel::msw_rescale`, which
-  re-rasterises every icon (button faces, flyout rows, card headers, the feature and body lists'
-  row icons).
- **Sidebar icons.** Every clickable icon in the sidebar shows a hover chip. The card-header and
-  constraint-row buttons are Orca's self-painted `Button`, because a native button cannot take a
-  hover background on macOS. The Feature tree and Bodies lists are a custom-drawn
-  `DesignRowList` rather than a `wxTreeCtrl`, so each row carries its own actions — Zoom to
-  selection, Edit, Show/hide and Delete on a feature, Zoom to selection, Move, Show/hide and
-  Delete on a body, and only Show/hide on the Origin and Bed rows, a separate non-selectable list
-  above the features — and the eye shows whether that row is hidden. A feature with nothing to
-  frame keeps a blank cell where Zoom to selection would be, so every icon stays in its column.
- **Plates.** This is the one thing the tab does not follow. The canvas has a bed of its own at
-  the printer bed's home position, whichever plate Prepare has current, and a new document's
-  modeling origin is that bed's centre. A bed that followed the current plate would slide out
-  from under a design: the origin is fixed once per document, baked into every sketch plane and
-  saved in the recipe, while the current plate can change between visits. Commit to Plate does
-  not need it either, since the committed object is placed on an empty spot of the current
-  plate. What the canvas does read from the plate is moved onto its bed: the exclude areas, the
-  plate box the camera orbits about when nothing is picked (`GLCanvas3D::_current_plate_box`),
-  and the first view, which starts from Prepare's camera turned to the tab's iso view: the CAD
-  isometric from the front-right corner that Home returns to, not Prepare's front-left one.
- **Viewport text.** The status line and the active tool's values are drawn by the canvas in
-  its ImGui pass, so they go with the canvas: a top-level window over GL does not follow its
-  frame and was left floating over other applications.
- **Undo.** The tab keeps its own history (the recipe is not part of Prepare's snapshots), but
-  it has no Undo/Redo of its own: the top bar, `Ctrl+Z` and Edit drive it while the tab is
-  shown, greyed to what an undo would actually do.
- **Docking.** The sidebar docks like Prepare's — either side, floating, resized, or collapsed
-  with the canvas's collapse button or `Shift+Tab` — through its own AUI manager under the
-  toolbar, because Prepare's manages the Plater and the Plater is not on this page. The button is
-  the canvas's own toolbar rather than Prepare's, which collapses Prepare's sidebar. The layout,
-  collapse included, is kept apart from Prepare's (`design_window_layout`) and starts where
-  Prepare's sidebar is, at its width, so the canvas edge holds still across the tab switch until
-  the user moves one of them. A floating sidebar is a top-level window, so it is hidden with the
-  tab rather than left over the other pages, and View > Reset Window Layout resets both tabs.
+`wxGLCanvas` is a native window and does not reliably stack over GL), the printer bed muted so
+a plate grid is never read as a sketch grid, and `N` to look normal to the plane. Code that
+changes any of the three belongs with a change to this section.

 ## The offer is generated, not hand-written

@@ -326,13 +163,9 @@ Right-clicking geometry opens the *offer*: eight families in a fixed order, each
 permanent row index, verbs that do not apply shown disabled **in place with their reason**
 rather than removed. The invariant is that a verb's row index is identical in every selection
 where it appears and that adding a verb never moves an existing one — the hand learns the
-position, so the menu is never re-sorted, compacted or adaptively ordered. Above the families
-sits one *flat* row, holding Rename, Color and Zoom to selection — what a selection is opened for
-most: its verbs are items of their own at the top of the menu rather than a family's submenu. It
-is appended after the eight, so it moved no existing index, and it reads the same from the
-viewport and from a row of the Bodies list.
+position, so the menu is never re-sorted, compacted or adaptively ordered.

-An invariant across 93 verbs and 20 selection kinds does not survive by review, so the map
+An invariant across 92 verbs and 20 selection kinds does not survive by review, so the map
 exists once, as data: `scripts/CAD/tool_atlas.json` carries every verb with its row, key, icon,
 accepted selections, preconditions and refusal string, and `scripts/CAD/gen_offer_table.py`
 emits `src/slic3r/GUI/CAD/DesignOffer.hpp` from it. The header is checked in and never
@@ -361,7 +194,6 @@ scripted action and a clicked one cannot diverge. It is off unless the variable
 | `src/libslic3r/CAD/SketchSolver.*` | constraint solving, over the vendored solver |
 | `src/libslic3r/slvs/` | vendored 2D constraint solver (GPLv3) |
 | `src/slic3r/GUI/CAD/DesignPanel.*` | the tab: toolbar, feature cards, tree, key maps |
-| `src/slic3r/GUI/CAD/DesignRowList.*` | the Feature tree and Bodies lists, with per-row actions |
 | `src/slic3r/GUI/CAD/DesignCanvas.*` | viewport integration |
 | `src/slic3r/GUI/CAD/DesignSketchTool.*` | in-canvas sketching |
 | `src/slic3r/GUI/CAD/DesignInteraction.hpp` | the Esc level contract |
@@ -1,131 +0,0 @@
-# Polygon Clipping — High Level Design
-
-## Purpose and scope
-
-Almost every stage of slicing works on 2D regions: slices, perimeters, infill
-areas, bridges, supports and brims are all produced by boolean operations and
-offsets on polygons. libslic3r does this through two interfaces, both built on
-the Clipper2 library vendored in `deps_src/clipper2`:
-
- `ClipperUtils` (`src/libslic3r/ClipperUtils.hpp`) takes and returns Slic3r
-  geometry: `Polygon(s)`, `ExPolygon(s)`, `Polyline(s)`, `Lines` and
-  `Surfaces`. It provides unions, intersections, differences and xor, closed
-  and open offsets, morphological opening and closing, variable width offsets
-  and polyline clipping.
- `ClipperZUtils` (`src/libslic3r/ClipperZUtils.hpp`) clips paths whose
-  vertices carry a Z value, which callers use to tag vertices with a source
-  index or an extrusion width.
-
-No other code calls Clipper2.
-
-`ClipperUtils` declares its own `JoinType`, `EndType`, `PolyFillType` and
-`ClipType` enums and maps them to Clipper2's. Every call builds its own
-Clipper2 objects and shares no state, so slicing threads can clip
-concurrently.
-
-Clipping is one of the largest costs of slicing, and nearly all of it goes
-through `ClipperUtils`. The layer is therefore designed for throughput as much
-as for predictable geometry.
-
-## Vendored Clipper2
-
-`deps_src/clipper2` builds the static target `Clipper2`. It carries four
-changes to the upstream sources that must be carried over when Clipper2 is
-updated. The namespace switch sits at the top of every header and source, the
-other three are marked with `Orca:` comments.
-
-| Change | Files | Why |
-| --- | --- | --- |
-| Z build in its own namespace | all headers and sources, `clipper2_z.cpp`, `clipper2_z.hpp` | The library is compiled a second time with `USINGZ` in namespace `Clipper2Lib_Z`, so the 2D and the Z variants link into one binary. |
-| Engine nodes from tbbmalloc | `clipper.engine.h`, `clipper.engine.cpp` | Vertices, active edges, output points and records, local minima and `PolyTree` nodes are allocated one by one. `CLIPPER2_NODE_ALLOCATOR` routes them through `scalable_malloc`, because the default heap does not scale when all slicing threads clip at once. |
-| Concave joins at the edge crossing | `clipper.offset.cpp` | For closed paths, a concave corner is joined at the crossing of the two offset edges when that point lies within half of both adjacent edges. The upstream 3-point loop makes inward offsets of dense curves very slow to union. |
-| Rounded arc steps | `clipper.offset.cpp` | Round joins use the rounded number of steps, not the ceiling, which keeps the vertex count of round offsets that the rest of the code is tuned for. |
-
-## ClipperUtils semantics
-
-The callers of `ClipperUtils` rely on a fixed set of behaviours. Where
-Clipper2 behaves differently by default, the wrapper adjusts it.
-
-### Booleans
-
- The fill rule is non-zero unless the function takes a `PolyFillType`. One
-  rule applies to both subject and clip; Clipper2 has no per-operand rule.
- Collinear vertices are removed from the result. Clipper2 keeps them by
-  default, so every boolean sets `PreserveCollinear(false)`.
- Outer contours are CCW and holes are CW. No output contour touches
-  itself: where one would pass twice through a vertex, it is split there into
-  two contours.
- `ExPolygons` results are built from one `PolyTree64` pass. An island inside
-  a hole becomes an `ExPolygon` of its own.
- `ApplySafetyOffset::Yes` grows the clip polygons by `ClipperSafetyOffset`
-  before an intersection or a difference, so that edges shared by subject and
-  clip do not leave slivers.
- Open polylines are clipped with the non-zero rule and keep their direction.
-
-### Offsets
-
- Before offsetting, input vertices closer than
-  `ClipperOffsetShortestEdgeFactor` × |delta| to the previously kept vertex
-  are dropped. This bounds the work on dense contours, and the error it
-  introduces is far below the offset distance.
- The miter limit is at least 2. For `jtRound`, a positive `miterLimit`
-  argument is the arc tolerance, capped at |delta| / 4, and 0.25 is used
-  otherwise. Other joins use the smaller of 0.25 and |delta| / 4 for round end
-  caps.
- A single `Polygon` keeps its orientation: a CCW polygon grows with a
-  positive delta, a CW polygon is a hole and shrinks.
- `Polygons` follow the same rule per path. When every CW path lies strictly
-  inside the bounding box of a CCW path, which is the usual case of contours
-  with their holes, all paths are offset in one Clipper2 group. Otherwise
-  each path is offset on its own and the results are united, with the
-  non-zero rule when growing and the positive rule when shrinking.
- `ExPolygons` and `Surfaces` are offset as one group after the contours are
-  oriented CCW and the holes CW, whatever their input orientation.
- Zero-area paths vanish under a negative offset instead of growing.
- Polyline offsets use the requested end type. Clipper2 already unites the
-  result, so no further union is done.
-
-### Coordinate range
-
-Clipper2 computes intersections and slopes in doubles, which hold integers
-exactly only up to 2^53 (about 9e15 units, 9,000 km). Geometry passed to
-`ClipperUtils` must stay well inside that range; near the int64 limit the
-results shift by hundreds of units. This is why the arrange `InfiniteBed` is a
-box of ±2^50 units around its centre rather than libnest2d's infinite box,
-which reaches ±2.3e18.
-
-## ClipperZUtils
-
-`ZPoint` is a `Vec3crd`, and a `ZPath` is a vector of them.
-`clip_zpaths()` runs one boolean with the non-zero rule on the Clipper2 Z
-build. The subject may be open, the clip is closed, and the result lists the
-closed paths before the open ones.
-
-The Z of each output vertex follows these rules:
-
- An input vertex keeps its Z.
- An intersection that lies on an end point of one of the two crossing edges
-  takes that end point's Z, preferring the subject edge.
- Any other intersection gets its Z from the callback, which receives both
-  crossing edges, the subject edge first.
-
-Clipper2 calls the callback only when it creates an output vertex at an
-intersection, not for every crossing it processes. A callback that records
-intersections, like `ClipperZIntersectionVisitor`, therefore sees only those.
-
-The users are:
-
-| User | Z carries |
-| --- | --- |
-| `Algorithm::wave_seeds()` (region expansion) | source and boundary index; intersections get a negative index into the visitor's list of crossing pairs |
-| `Algorithm::split_line()` | index of the source vertex; an intersection gets the negated index of its source edge, so the pieces can be put back in path order |
-| `PerimeterGenerator` overhang and top-surface clipping of Arachne walls | extrusion width, interpolated along the edge at intersections |
-| Tree support anchors in `SupportCommon` | index of the source contour, -1 at intersections |
-| `extrusion_paths_append()` | extrusion width, turned into extrusion paths |
-
-## Testing
-
-`tests/libslic3r/test_clipper_utils.cpp` and `test_clipper_offset.cpp` cover
-the wrapper's booleans, orientation and offset rules. The perimeter, support
-and region expansion users are exercised by the slicing tests in
-`tests/fff_print`.
@@ -2,584 +2,238 @@

 ## Purpose and scope

-Precise Seam lets a helper volume decide where the seam of an object goes. The
-user attaches a mesh to an object as a Precise Seam modifier. On every layer,
-the part of the external perimeter that lies inside the modifier's slice
-determines where the seam must, may or must not be placed. The helper is a
-persistent model object rather than paint on the surface, so it keeps working
-when the design changes. A body swept along a path on the surface can guide the
-seam along any trajectory.
+Precise Seam places the seam where a helper volume intersects the external
+wall. The user attaches a mesh to an object as a Precise Seam modifier, and on
+every layer the seam placer reads the modifier's slice to decide where the seam
+of each external perimeter may, must or must not go. The same mesh keeps
+working after the model changes, so the seam does not have to be repainted
+after every design revision, and a swept helper body can guide the seam along
+any path.

-The modifier is non-printing geometry. It takes no part in object slicing,
-region assignment, filament selection or brim adhesion, and it affects only seam
-placement during G-code export. Objects without Precise Seam volumes follow the
-regular seam placement unchanged.
+The modifier is non-printing geometry. It does not take part in slicing, region
+assignment, filament selection or brim adhesion. It affects only seam
+placement, which runs during G-code export.

-Precise Seam does not replace the seam placer. It feeds it: a modifier inserts
-the points it needs into the perimeter and changes the enforced/blocked type of
-seam candidates, the same typing mechanism as seam painting, and the configured
-seam position then chooses among them.
+## Volume types and priority

-## Modifier types
-
-Precise Seam adds six `ModelVolumeType` values after `SUPPORT_ENFORCER`, strong
-types first and weak types after them. `is_precise_seam()`,
+Precise Seam adds six `ModelVolumeType` values after `SUPPORT_ENFORCER`. The
+strong types come first and the weak types follow. `is_precise_seam()`,
 `is_precise_seam_strong()` and `is_precise_seam_weak()` are range checks that
 depend on this order.

-| Type | Group | Effect on an intersected perimeter |
+| Type | Group | Effect on the perimeter |
 | --- | --- | --- |
-| `PRECISE_SEAM_CENTER` | strong | seam at the midpoint, by arc length, of the intersection |
+| `PRECISE_SEAM_CENTER` | strong | seam at the arc-length midpoint of the intersection |
 | `PRECISE_SEAM_LEFT` | strong | seam at the first point of the intersection |
 | `PRECISE_SEAM_RIGHT` | strong | seam at the last point of the intersection |
 | `PRECISE_SEAM_ENFORCED` | weak | intersection marked as enforced |
 | `PRECISE_SEAM_BLOCKED` | weak | intersection marked as blocked |
 | `PRECISE_SEAM_NEUTRAL` | weak | intersection reset to neutral |

-A strong modifier fixes a single point. The perimeter gets exactly one enforced
-seam candidate there, and every other candidate is blocked. A weak modifier
-retypes, and where needed adds, the candidates inside its intersection, like
-painting does.
-
-An **intersection** is a continuous part of the external perimeter's centerline
-that lies inside the modifier's slice on that layer. It is a portion of the
-perimeter, never a chord through the object. The centerline lies half an
-extrusion width inside the model surface and depends on print settings, so a
-modifier must reach clearly past the surface to cross it unambiguously.
-
-### Terms
-
- **Segment:** an intersection as the code represents it (`PerimeterSegment`).
-  User-facing texts call it an intersection.
- **Fragment:** a piece of the perimeter returned by clipping, before it is tied
-  to the source contour.
- **Interval:** the bound part of one source edge, given by the edge index and a
-  parameter range on that edge.
- **Zone:** a weak segment with its type (Enforced, Blocked or Neutral).
- **Boundary:** an end of a zone, inserted into the perimeter polygon.
- **Candidate:** a seam candidate of the seam placer, built from the points of
-  the processed perimeter polygon (painted enforcers may add more).
-
-First and last are taken along the perimeter oriented counter-clockwise as seen
-from above. On an outer wall seen from outside, Left is therefore the left end
-of the intersection. On the wall of a hole seen from inside the hole, the two
-ends are swapped. Mirroring an object does not mirror the mode: perimeters stay
-counter-clockwise, so Left remains the left end seen from outside, and the seam
-moves to the other end of the modifier instead of following the mirrored model.
-
-## Priority
+A strong modifier fixes one point. A weak modifier only changes the
+enforced/blocked type of seam candidates, and the configured seam position then
+chooses among them. First and last are taken along the perimeter made
+counter-clockwise seen from above. On an outer wall seen from outside, Left is
+the left end of the intersection. On the wall of a hole seen from inside the
+hole, the two ends are swapped.

 The order of volumes in the object is the priority order, highest first.
 `ModelObject::sort_volumes()` keeps every strong modifier before every weak one
 and preserves the user's order within each group. The object list lets the user
-drag a modifier only within its own group. A type change that crosses the group
-boundary moves the volume to the end of its new group, with the lowest priority
-there.
+drag a modifier only within its own group. A type change that crosses a group
+boundary moves the volume to the end of its new group, where it has the lowest
+priority. Strong modifiers are tried in this order, and the first one that
+yields a seam on a perimeter wins. Weak modifiers are applied from the lowest
+priority to the highest, so the highest one overwrites any overlapping zone.

- **Strong:** modifiers are tried in priority order on each perimeter. The first
-  one that yields a usable segment decides the seam. Within that modifier the
-  longest segment wins; lengths are never compared across modifiers. Once a
-  strong point is placed, no later strong modifier and no weak modifier is
-  processed for that perimeter.
- **Weak:** every weak modifier applies. They are applied from the lowest
-  priority to the highest, so the highest one overwrites overlapping zones. A
-  Blocked modifier that fully contains a perimeter is the exception: it is
-  skipped there (see [Full containment](#full-containment)).
+## Model storage and 3MF compatibility

-A strong modifier without a usable segment, even one whose fragments were all
-discarded, passes the turn to the next one.
-
-## Data flow
-
-1. **Invalidation.** `Print::apply()` treats a change of Precise Seam volumes as
-   a change of seam placement and invalidates G-code export; the object is not
-   resliced (see [Print invalidation](#print-invalidation)).
-2. **Modifier slices.** `SeamPlacer::init()` collects each object's Precise Seam
-   volumes once, slices every volume separately and caches its regions with
-   their bounding boxes.
-3. **Perimeters.** Seam candidates are gathered in parallel over the layers.
-   For objects with Precise Seam volumes, each external perimeter polygon is
-   normalized and prepared once for all modifiers.
-4. **Extraction.** For each modifier, the perimeter is clipped against the
-   modifier's regions on that layer. The clipped fragments are bound back to the
-   source edges of the perimeter and assembled into segments.
-5. **Strong, then weak.** Strong modifiers try to insert one seam point into the
-   perimeter polygon. If none succeeds, weak modifiers insert their zone
-   boundaries and subdivide enforced edges.
-6. **Candidates.** The seam placer builds candidates from the modified polygon.
-   Painting assigns types first, weak zones overwrite them, and a strong point
-   makes its candidate the only enforced one.
-7. **Selection and restoration.** The configured seam position chooses the
-   seams and aligns them. Afterwards the exact strong points are restored.
-8. **Warnings.** After all objects are processed, `SeamPlacer::init()` prepares
-   one combined warning text if any problem was found; G-code export issues it.
-
-## Modifier slices
-
-`init_precise_seam_data()` collects the Precise Seam volumes of each object:
-strong ones in priority order and weak ones in reverse, so that weak zones can
-be applied with last-write-wins. Each volume is sliced separately with
-`PrintObject::slice_single_volume_regions()`, at the object's layer heights and
-with the same centered transformation as the object. The slices keep every
-region's outer contour together with its holes as an `ExPolygon`. Volumes are
-not merged, so each keeps its own priority, and a modifier may have several
-regions on one layer.
-
-`prepare_modifier_slices()` moves the slices into `ModifierRegionsCache`,
-pairing each region with the bounding box of its exterior. Empty layers keep
-their slots, so the cache is indexed by object layer; `Layer::id()` includes raft
-layers, which are subtracted. The cache is filled before candidates are gathered
-and is only read afterwards, shared by both modifier kinds and all worker
-threads without locking.
-
-## Perimeter preparation
-
-The seam placer works on external perimeter loops, including the walls of
-holes. For objects with Precise Seam volumes, consecutive duplicate points and
-the repeated closing point of each extrusion loop are removed: adjacent
-extrusion paths share endpoints, and the resulting zero-length edges would
-prevent point insertion at their junctions. Distinct visits to one point of a
-self-touching contour are kept. Objects without Precise Seam volumes keep their
-original points, so ordinary seam candidates are unaffected.
-
-Each polygon is made counter-clockwise. A single `PreparedPerimeter` is then
-built for all modifiers of that perimeter. It holds a validity check (at least
-three points, no consecutive or closing duplicates), the bounding box, and the
-clipping line: the polygon as an open polyline with its first point repeated at
-the end. The preparation borrows the polygon and is used only while the polygon
-is unchanged: strong processing returns immediately after inserting its point,
-and weak processing collects all segments before it inserts anything. An
-invalid perimeter receives no Precise Seam processing.
-
-## Segment extraction
-
-`extract_perimeter_segments()` turns one modifier's regions on one layer into
-segments of the perimeter, each with its geometry and its position on the
-source contour. Both modifier kinds consume these segments; the extractor is
-told the modifier type so that it prepares only the data that type needs.
-
-### Clipping
-
-Regions whose bounding box does not overlap the perimeter's are skipped. The
-clipping line is intersected with each remaining region by `intersection_pl()`,
-which clips an open path against an `ExPolygon` with its holes attached, using
-the nonzero rule. Clipping an open line yields only pieces of the perimeter, so
-a modifier crossing the whole object produces two separate pieces rather than a
-chord through the body. Holes in a modifier and several regions of one modifier
-simply produce more pieces. The line is cut at vertex zero, so a piece crossing
-that vertex arrives as two fragments. A border that only touches the line can
-come back as a single point; such fragments carry no coverage and are dropped
-before binding.
-
-### Binding fragments to source edges
-
-Clipper returns coordinates only. Insertion needs the source edge of every
-point, and coordinates alone are ambiguous where a contour visits the same
-point twice. Each fragment is therefore bound to the source edges it covers,
-producing intervals: an edge index with a parameter range on that edge.
-
- **Exact path.** For fragments with interior points, the second point is used
-  as an anchor that must equal a source vertex exactly. Clipping keeps the
-  vertices of an open path unchanged, including collinear ones. The following
-  points must match successive source vertices in either direction; later
-  occurrences of the anchor are tried if a sequence does not match. Only the two
-  end cuts are projected onto their edges.
- **Projection path.** Two-point fragments, and fragments the exact path cannot
-  match, are bound by projection. The first source edge that holds both points
-  of the first pair, with distinct parameters, establishes the edge and
-  direction. Every following pair must continue on the same edge or cross to the
-  neighboring edge at their actual shared vertex, in the same direction. A pair
-  continuing on the same edge reuses the previous pair's parameter for their
-  shared point, so the two projections of one point cannot differ.
- **Failure.** A fragment that cannot be bound continuously is rolled back and
-  discarded. Earlier fragments and other fragments are unaffected. The failure
-  is counted, logged and reported to the user (see
-  [Diagnostics](#diagnostics-and-warnings)).
-
-Two rare rounding cases are handled only after both paths have failed, so the
-normal path never pays for them:
-
- **Cut beside a vertex.** When a modifier boundary crosses within about one
-  coordinate unit of a source vertex, Clipper can place the cut at the vertex's
-  height but a few units beside it. The end pair then collapses to the vertex's
-  parameter or misses both neighboring edges. An end cut closer than the
-  snapping radius to a vertex of the fragment's own chain is snapped to that
-  vertex: either its neighbor in the fragment (the cut is a rounded copy of it
-  and is dropped) or a vertex that shares a source edge with that neighbor. The
-  neighbor wins whenever it is within the radius. Ends that are themselves source
-  vertices and ambiguous choices are left unchanged. Binding is then retried
-  once with the same strict rules, so a wrong candidate can only fail again.
- **Contact.** A fragment that still fails but is shorter than the snapping
-  radius is accepted as a contact and binds nothing. Insertion would collapse it
-  onto one point anyway.
-
-Both outcomes are recoveries, not failures: they show no user warning but leave
-a log marker.
-
-### Assembling segments
-
-The intervals are sorted by edge and parameter. Intervals on the same occurrence
-of an edge are united when they overlap or meet, by parameter or at the same
-integer point; equal coordinates on different edges are never united. A
-parameter of 1 is stored as parameter 0 of the next edge, so intervals on
-adjacent edges meet exactly at their shared vertex. Consecutive intervals that
-meet form one `PerimeterSegment`, and the last segment is joined with the first
-when they meet at vertex zero, undoing the artificial cut of the clipping line.
-
-Each segment keeps its polyline, the source edge of every polyline edge, and its
-begin and end positions on the source contour.
-
-### Full containment
-
-A modifier that covers the whole perimeter has no boundaries on it. The policy
-follows seam painting, where painting a whole perimeter green is a meaningful
-choice and forbidding the seam all round is not:
-
- **Seam Enforced** types the whole perimeter, like a perimeter painted green all
-  round, with subdivision applied as described under [Weak modifiers](#weak-modifiers).
- **Seam Neutral** types the whole perimeter Neutral, like an unmarked perimeter,
-  clearing painting and lower zones.
- **Seam Blocked** is skipped for the perimeter, with the full-containment
-  warning. The seam cannot avoid the whole perimeter, so the modifier does not
-  override anything below it: lower zones and painting stay in effect.
- **Seam Center, Left and Right** are skipped with the same warning: there is no
-  intersection to place the point on.
-
-Enforced and Neutral take part in the usual priority order (see
-[Weak modifiers](#weak-modifiers)).
-
-The perimeter is fully contained when the united intervals cover every source
-edge from parameter 0 to 1. A modifier boundary that merely touches the
-perimeter counts as well:
-
- At a vertex or on an axis-aligned edge, clipping splits the line exactly at the
-  touch, the pieces meet at one point, and the coverage is complete.
- On an inclined edge the touching point is usually not representable on the
-  integer grid. The boundary pokes a few units across and leaves a real gap, so
-  a single segment covers everything except that gap.
-
-Weak insertion would collapse such a segment's boundaries onto one vertex and
-turn the intended zone into a single candidate, and strong would put the seam at
-the touch. A single segment is therefore also full containment in the cases
-where insertion collapses it, exactly up to edges shorter than 2 µm:
-
- the uncovered length from its end to its begin is below 1 µm, or
- the gap spans one vertex, or starts at a vertex and ends on the next edge, and
-  both ends lie within 1 µm of the vertex that ends the first gap edge, since
-  each end then snaps onto it from its own edge.
-
-A cheap filter runs first: both cases bring the segment's ends within 2 µm of
-each other.
-
-## Strong modifiers
-
-For a strong modifier, the extractor prepares each segment's target point
-before anything is inserted, together with the source edge it lies on:
-
- **Left:** the segment's first point.
- **Right:** the segment's last point.
- **Center:** the point at half the segment's arc length.
-
-Arc length is the sum of Euclidean edge lengths, not the chord or a vertex count.
-
-`insert_strong_seam_point()` selects the longest segment of the first modifier
-that has one. Exactly equal lengths are resolved by the prepared target points:
-greater bed Y first, then smaller X; a complete tie keeps the first segment.
-Slice coordinates already include instance rotation and have the bed axes;
-centering and XY translation do not change this order. Nearly equal lengths are
-not treated as equal, so exact ties occur mainly on axis-aligned geometry.
-Geometrically equal segments, such as a symmetric modifier crossing both faces
-of a thin wall, differ only by rounding noise that varies between layers, so
-the chosen face may alternate. This is accepted deliberately: such a modifier is
-ambiguous by itself: more than one segment raises the "multiple intersections"
-warning. The user should make the modifier cross the perimeter once.
-
-The selected point is inserted on its source edge. A point within 1 µm of an
-existing vertex is snapped to that vertex. Helper points are added 1 µm on both
-sides of it, except on an adjacent edge shorter than 2 µm, which already bounds
-the distance.
-
-When the candidates are built, the candidate at the inserted point is the only
-enforced one and becomes the central enforcer; every other candidate is blocked.
-Every seam position mode therefore selects it. Alignment and random placement
-can still move the final position, so after alignment
-`restore_precise_seam_positions()` writes the exact point and its index back
-into every perimeter that has a strong seam.
-
-## Weak modifiers
-
-`collect_weak_modifier_segments()` extracts the segments of every weak modifier
-before the polygon is modified, so all positions refer to the same contour. Each
-segment becomes a zone with a type and two boundaries, kept in application
-order, lowest priority first. Full containment of an Enforced or Neutral
-modifier becomes a whole-perimeter zone at its place in that order: it has no
-boundaries and takes part in no insertion or helper step below. The boundaries
-carry their positions on the source contour; these remain as provenance after
-insertion and are not indices into the modified polygon.
-
-`prepare_weak_modifier_segments()` then changes the polygon:
-
-1. **Boundary insertion.** Insertion events are sorted by decreasing source edge
-   and parameter, and the polygon is modified from its end towards its start. A
-   pending boundary's source index therefore stays valid. Vertex zero has the
-   canonical position `(0, 0)` and is
-   processed last, and a point on the closing edge is appended rather than
-   inserted at index zero. A boundary within 1 µm of either endpoint of its
-   current edge, an original vertex or a boundary inserted earlier, is snapped to
-   that point, so coincident boundaries share a vertex. A zone narrower than
-   1 µm collapses into a single vertex.
-2. **Helper points.** A helper point is added 1 µm outside every boundary,
-   unless the edge there is shorter than 2 µm, which already bounds it. The
-   helpers keep the edges at a boundary short, so a seam placed along such an
-   edge stays close to the boundary. Coincident boundaries share their helpers.
-3. **Enforced subdivision.** Zone types are resolved for the polygon's edges in
-   priority order. The edges of a zone are those from its left boundary up to,
-   but not including, its right boundary; a whole-perimeter zone types every
-   edge. Enforced edges longer than `SeamPlacer::enforcer_oversampling_distance`
-   (0.2 mm) are subdivided into steps of at most that length; shorter edges and
-   existing vertices are kept.
-   The regular seam placer then chooses the seam as for painted seams.
-
-When candidates are built, painting assigns their types first.
-`apply_weak_modifiers_to_perimeter()` then overwrites the types of the
-candidates between the boundaries of each zone, both boundaries included,
-lowest priority first; a whole-perimeter zone types every candidate. Blocked
-and Enforced zones therefore take precedence over painting, and Neutral clears
-painting inside its zone.
-
-## Numeric tolerances
-
-Coordinates are integers in scaled units: 1 nm by default, and 10 nm when a bed
-larger than 2147 mm switches `SCALING_FACTOR`. Both Precise Seam tolerances are
-deliberately defined in units rather than physical distances. Clipper truncates
-cuts to whole units at any scale, so the on-edge tolerance must follow the unit; the
-snapping radius scales with it to keep its margin over single-precision
-candidate coordinates, which are coarser on large beds. Distances quoted in
-this document in nanometers and
-micrometers assume the default unit; on large printers they are ten times
-larger. The enforced subdivision step is a physical distance and stays 0.2 mm.
-
-| Value | Role |
-| --- | --- |
-| `MACHINE_PRECISION_SQUARED` (2.5 units², about 1.6 nm) | A point lies on an edge if it is this close. It absorbs Clipper's truncation of cuts to whole units (under √2 units from the edge) and never bridges a real gap: a one-unit uncovered gap stays a gap. |
-| `TOLERANCE_LINEAR` (1000 units, 1 µm) | Insertion snaps points this close to an existing vertex, and helper points are placed this far from boundaries. The same radius bounds the rounding fallback, contacts and the sub-micron full-containment rule, so those decisions match what insertion would produce anyway. |
-| `enforcer_oversampling_distance` (0.2 mm) | Maximum step of enforced subdivision. |
-
-Raising the on-edge tolerance would not help with cuts beside a vertex: more
-points past a vertex would be clamped to its parameter and collapse. Lowering it
-would reject ordinary rounded cuts. The snapping radius is kept far above
-clipping precision for robustness: seam candidates hold single-precision
-coordinates, whose step is about 8 to 15 nm at typical object coordinates
-(about 0.25 µm 3 m from the object's centre, on large beds only), and
-weak boundaries and the strong point are located among the candidates by those
-coordinates, so distinct points must stay clearly distinct. 1 µm is also far
-below printing precision.
-
-## Diagnostics and warnings
-
-One `PreciseSeamWarnings` instance is shared by all objects and layers of a
-`SeamPlacer::init()` call. After all objects are processed, `SeamPlacer::init()`
-prepares at most one warning text, available through `precise_seam_warning()`.
-G-code export issues it as one non-critical warning with the ID
-`SlicingPreciseSeamWarning`. It is a single line, "Precise Seam: <causes>. Seam
-placement may differ from expected.", because the export warnings dialog shows
-only the first line of each warning. Repeated warning events replace the
-notification instead of appending to it. Except for the "had no effect" cause,
-the causes name the modifier types involved, as the menu names them, in menu
-order and each type once, for example "(Seam Left, Seam Enforced)".
-The causes are:
-
- **failed to process some intersections (types):** at least one fragment was
-  discarded by binding. Other segments remain usable.
- **multiple intersections with a perimeter, only one was used (types):**
-  a Seam Center, Left or Right modifier had more than one segment on a
-  perimeter (see [Strong modifiers](#strong-modifiers)).
- **a perimeter is fully inside a modifier, the modifier was not applied to it
-  (types):** a Seam Center, Left, Right or Blocked modifier was skipped for a
-  perimeter (see [Full containment](#full-containment)).
- **modifier "<name>" of "<object>" had no effect on the seam (it might not reach
-  the centerline of the printed perimeter):** a modifier was evaluated on at
-  least one perimeter and never gave a segment, full containment or a discarded
-  fragment. Only the first such modifier in print and volume order is named,
-  followed by "(N in total)" when there are several.
-
-  Only the effect is certain, so the cause is given as a hint. A modifier is
-  evaluated only when its turn comes: on a perimeter where a higher strong
-  modifier placed the seam, lower strong and all weak modifiers are not
-  evaluated. A modifier that was never evaluated is not reported, since nothing
-  is known about it. A point contact gives no segment and does not count as
-  reaching the perimeter.
-
-The log records the following diagnostic markers:
-
- `[PreciseSeamIntersectionFailed]` for a discarded fragment, with object,
-  modifier, layer, height, fragment and failing pair, the failure reason and
-  point counts.
- `[PreciseSeamFragmentRecovered]` for a recovery, with `outcome=bound` or
-  `outcome=contact`, the same location fields and the original failure reason.
- `[PreciseSeamNoEffect]` for every modifier of the "had no effect" cause, with
-  the object and modifier names. Unlike the user warning, the log lists all of
-  them.
-
-Failures and recoveries are counted separately. The first 10 of each per
-`init()` call are logged in detail, in parallel processing order; if a limit is
-exceeded, one summary marker reports the total and the number omitted.
-
-## Known limitations
-
- **The modifier must reach the perimeter centerline.** Contacts are taken as
-  clipping returns them, without offsets or tangency rules, so boundaries that
-  only graze the centerline are the user's responsibility. Several near-touches
-  on inclined edges can leave several segments separated by gaps of a few units;
-  their zones then cover nearly the whole perimeter instead of being treated as
-  full containment.
- **Self-touching perimeters.** Extraction keeps distinct visits of one
-  coordinate apart through its source-edge bindings, but the consumers locate
-  inserted points by coordinates. A weak zone is typed and subdivided from the
-  first vertex with its boundary coordinate, while boundary helpers are added at
-  every such vertex. A strong point marks every candidate at its coordinate as
-  enforced, and the last one is restored after alignment. If a boundary or a
-  strong point falls exactly on a repeated coordinate, a zone may therefore start
-  from another visit, or the seam may start at another visit of the same point.
-  Carrying visit identity through insertion, refinement, candidates and
-  restoration would touch the whole pipeline, so it is not done for this rare
-  geometry. Overlapping source visits are likewise outside the binding contract.
-
-## Integration with the application
-
-### Other seam settings
-
- Precise Seam takes part only in outer and hole perimeter seam placement. In
-  spiral vase mode the seam placer is not used for perimeters, so the modifiers
-  have no effect.
- Scarf seams, the seam gap and wiping start from the chosen point exactly as
-  they would from an ordinary seam.
- Seam painting acts only from model parts, the volumes the seam gizmo shows and
-  edits, and from negative volumes. Painting retained on a volume after a change
-  from part to a Precise Seam, ordinary or support modifier is ignored. A type
-  change back to a model part reactivates any retained painting.
-  Negative volumes keep it on purpose: painting a
-  part and turning it into a negative volume is the only way to paint the wall
-  of the hole it cuts. That painting still affects the seam but is invisible in
-  the gizmo and cannot be edited there; this is known technical debt.
-  If painting them is ever made editable, G-code invalidation must track it too:
-  `model_custom_seam_data_changed()` checks model parts only.
-
-### Model storage and 3MF compatibility
-
-Projects must stay readable by earlier releases, and a Precise Seam volume must
-not change a print there. Both 3MF writers therefore store it as an ordinary
-parameter modifier: `modifier_part` in the Bambu-format part subtype, and
-`ParameterModifier` together with the legacy `modifier` flag in the
-Prusa-format volume metadata. The seam mode is written separately under
+Projects must stay readable by earlier releases, and the modifier must not
+change a print there. Both 3MF writers therefore store a Precise Seam volume as
+an ordinary parameter modifier: `modifier_part` in the Bambu-format part
+subtype, and `ParameterModifier` together with the legacy `modifier` flag in
+the Prusa-format volume metadata. The seam mode is written separately under
 `precise_seam_type`, using the names from `ModelVolume::type_to_string()`
 (`precise_seam_center` and so on).

-On load, the mode is applied after all other volume metadata, regardless of XML
-key order, and only when the base type is a modifier. A missing or unknown mode
-leaves an ordinary modifier, and seam metadata on any other base type is
-ignored. Files that stored the seam mode directly as the volume type still load.
-A project saved again by an earlier release loses the seam mode for good: the
-volumes stay ordinary modifiers without settings.
+On load, the mode applies after all other volume metadata, regardless of XML
+key order, and only when the base type is a modifier. Missing or unknown modes
+leave an ordinary modifier. Seam metadata on any other base type is ignored.
+Files that stored the seam mode directly as the volume type still load.

 A Precise Seam volume keeps any per-volume settings it had as a part or
 modifier, but they are inactive and the object list shows no settings item for
 it. The writers prefix these keys with `precise_seam_config:`, so an earlier
-reader drops them as unknown options and loads a modifier without settings,
-which has no effect on the print. The current reader restores the keys only when
-the volume ends up as a Precise Seam type, so the settings return when the user
-changes the type back.
+reader drops them as unknown options. The volume therefore loads there as a
+modifier without settings and has no effect on the print. The current reader
+restores the keys only when the volume ends up as a Precise Seam type, so the
+settings return when the user changes the type back. Configuration values are
+XML-escaped in both writers, for every volume type.

-### Print invalidation
+## Print invalidation

 `Print::apply()` compares the Precise Seam volumes of each object by type, ID
-and transformation. Adding, removing, moving, reordering or retyping one cancels
-background processing and invalidates only `psGCodeExport`; the sliced layers
-are kept. `model_volume_list_update_supports_and_seams()` then brings the
-support and Precise Seam volumes of the print's model copy in line with the new
-model in one pass. A volume may switch between these two families, since neither
-affects object slicing; such a switch also changes the support volumes, so the
-support step is invalidated as well.
+and transformation. Adding, removing, moving, reordering or retyping one
+cancels background processing and invalidates only `psGCodeExport`; the sliced
+layers are kept. `model_volume_list_update_supports_and_seams()` then brings
+the support and Precise Seam volumes of the print's model copy in line with the
+new model in one pass. A volume may switch between the two families, since
+neither affects slicing. A conversion to or from a part or ordinary modifier
+changes the solid and modifier volume lists and reslices as before.

-A conversion to or from a part or an ordinary modifier changes the solid and
-modifier volume lists and reslices the object as before. The volume keeps its
-ID across the type change, so the region cache treats a former support or
-Precise Seam volume that became a part or modifier as new, since it was never
-cached.
+## Modifier slices

-Removing the last helper of a single-part object reslices it, as removing any
-last modifier would.
+`SeamPlacer::init()` collects the Precise Seam volumes of each object once:
+strong ones in priority order and weak ones reversed. It slices each volume
+separately with `PrintObject::slice_single_volume()`, which shares
+`slice_modifier_volumes()` with support blockers and enforcers but does not
+merge volumes, so each keeps its own priority. The result is cached per volume
+and indexed by object layer; `Layer::id()` includes raft layers, which are
+subtracted. Seam candidates are then gathered in parallel over the layers and
+read the cache without locking.

-### User interface
+Objects without Precise Seam volumes follow the unchanged seam placement path.
+For objects that have them, perimeter extraction also removes consecutive
+duplicate points and the repeated closing point of each extrusion loop.
+Zero-length edges at path junctions would otherwise prevent point insertion
+there. Distinct visits to one point of a self-touching contour are kept.
+
+## Finding the wall segment
+
+The seam placer works on the external perimeter loops of each layer, both
+outer contours and holes, each made counter-clockwise. For every modifier
+polygon on the layer that overlaps the perimeter's bounding box, the region
+enclosed by the perimeter is clipped against the modifier polygon. The boundary
+of each intersection polygon alternates between runs that follow the perimeter
+and runs that follow the modifier outline. The wall segment is the longest
+continuous run of intersection vertices that lie on the perimeter, measured in
+vertices.
+
+The fast path first finds an intersection vertex that exactly matches a
+perimeter vertex. It then walks forward and backward, expecting the adjacent
+perimeter vertex and falling back to projection when Clipper has merged or
+split collinear edges. A vertex counts as on the perimeter when its projection
+is within about 1.6 nm, which covers Clipper's rounding. If no vertex matches
+exactly, or every vertex lies on the perimeter, the general path projects all
+vertices. When every vertex is on the perimeter, the edge midpoints are checked
+instead: a modifier chord can join two perimeter vertices directly, and the
+chords split the vertex ring into runs. If no edge leaves the perimeter, the
+perimeter lies entirely inside the modifier.
+
+`Polygon::point_projection()` optionally reports the edge that holds the
+projection, and every point of the segment keeps the index of its perimeter
+edge. New points are inserted on that edge. A point within 1 µm of an existing
+vertex snaps to that vertex instead.
+
+## Strong modifiers
+
+For a strong modifier, the target is the first point, the last point or the
+arc-length midpoint of the segment. The midpoint is projected back onto the
+original perimeter, because Clipper may have merged several perimeter edges
+into one segment edge. The target is inserted into the perimeter, and a helper
+point is inserted 1 µm before and after it. Strong modifiers are tried in
+priority order, the first valid intersection decides the seam, and weak
+modifiers are not processed for that perimeter.
+
+When candidates are built, the inserted point is the only enforced candidate
+and becomes the central enforcer; every other candidate is blocked. The seam
+position modes then pick that point: Aligned and Aligned Back prefer the central
+enforcer, while Back, Random and Nearest rank enforced candidates above blocked
+ones. Alignment and random placement can still move the final position along an
+edge. After alignment, `restore_precise_seam_positions()` writes the exact point
+and its index back into every perimeter that has a strong seam. Inner walls take
+their seam from the external seam as usual, including staggering.
+
+## Weak modifiers
+
+Weak modifiers produce one segment per intersection polygon, so one modifier can
+mark several zones on one perimeter. All segment boundaries are inserted into
+the perimeter in order of decreasing arc length. Each insertion then leaves the
+indices of the pending, shorter ones unchanged; a point on the closing edge is
+appended rather than inserted at index zero. A helper point is added 1 µm
+outside each boundary. Random placement picks a position along the edge that
+follows a candidate. These helpers keep that edge 1 µm long at each boundary, so
+a zone cannot extend or intrude further than that. Boundaries that coincide
+share their helper points.
+
+The zone types are then resolved in priority order, and the edges of enforced
+zones are subdivided into steps of at most
+`SeamPlacer::enforcer_oversampling_distance` (0.2 mm). The middle candidate of
+the longest enforced patch is therefore close to the geometric middle of the
+zone. That patch is measured in candidates, across the closing edge, regardless
+of where the contour starts; the same rule applies to painted seams.
+
+Candidates first receive their type from seam painting. The weak zones then
+overwrite it, lowest priority first. Blocked and Enforced zones therefore take
+precedence over painting, and Neutral clears painting inside its zone.
+
+## Unsupported geometry and warnings
+
+Some modifier shapes cannot be resolved to one seam or one zone per crossing.
+They are detected cheaply and reported rather than guessed:
+
+- A strong modifier that crosses a perimeter in more than one place uses only
+  its first valid segment. The other crossings are ignored.
+- A modifier that crosses the whole region enclosed by the perimeter is
+  detected when the modifier outline minus that region leaves more than one
+  piece, none of them a hole. Its intersection holds two wall runs, and only
+  one of them is used.
+- A modifier whose slice has a hole on a layer, found as a clockwise polygon in
+  the flattened slice, is skipped on that layer. The flattened slice no longer
+  records which hole belongs to which contour.
+- A perimeter that lies entirely inside a modifier is ignored by that modifier.
+
+The conditions are atomic flags shared by all layers and objects. After all
+objects are processed, `SeamPlacer::init()` issues at most one non-critical
+warning with the ID `SlicingPreciseSeamWarning`. The warning is a single line
+that lists every cause found, because the export warnings dialog shows only the
+first line of each warning. Repeated warning events replace this notification
+instead of appending text to it.
+
+## User interface

 - *Add Precise Seam* in the object menu creates a Center modifier from a
  primitive or a loaded mesh. Text and SVG volumes cannot become Precise Seam
-  modifiers: the menu does not offer it, and `ObjectList::set_volume_type()`
+  modifiers: the menu does not offer them, and `ObjectList::set_volume_type()`
  refuses the change.
 - *Change Type* has a single *Precise Seam* entry. It converts other volumes to
  Center and keeps the mode of volumes that are already Precise Seam. The
-  *Precise Seam Type* submenu appears only when every selected item is a Precise
-  Seam volume, including settings rows that resolve to one, and sets the chosen
-  mode on all of them.
+  *Precise Seam Type* submenu appears only when every selected item is a
+  Precise Seam volume, including settings rows that resolve to one. It sets the
+  chosen mode on all selected volumes.
 - Each mode has its own icon in the object list and its own color in the 3D
-  view, at 60% opacity: warm orange, gold and dark orange for Center, Left and
-  Right; green, red and gray for Enforced, Blocked and Neutral. The three strong
-  colors are close shades of one orange because all three mark strong
-  modifiers; the object list icons tell the modes apart.
- Precise Seam volumes have no filament and cannot be pasted into SLA objects.
-  Python plugins see them as `ModelVolumeType` values and through the
-  `is_precise_seam*()` methods.
+  view, at 60% opacity: warm oranges for the strong modes, and green, red and
+  gray for Enforced, Blocked and Neutral.
+- Object list drops map visible rows to volume indices while skipping hidden
+  cut connectors, and they refresh the row-to-volume map of the object.
+- Precise Seam volumes have no filament, block pasting into SLA, and are exposed
+  to Python plugins as `ModelVolumeType` values plus the `is_precise_seam*()`
+  methods.

 ## Implementation and verification

- [PreciseSeam.cpp](../../src/libslic3r/GCode/PreciseSeam.cpp) implements the
-  modifier cache, perimeter preparation, segment extraction and binding, strong
-  selection and insertion, weak-zone preparation and application, and position
-  restoration. [PreciseSeam.hpp](../../src/libslic3r/GCode/PreciseSeam.hpp)
-  declares the contracts; [PreciseSeamInternal.hpp](../../src/libslic3r/GCode/PreciseSeamInternal.hpp)
-  exposes the binding internals to tests.
- [SeamPlacer.cpp](../../src/libslic3r/GCode/SeamPlacer.cpp) fills the cache,
-  normalizes perimeters, calls both consumers while gathering candidates,
-  restores strong positions after alignment and prepares the warning text, which
-  [GCode.cpp](../../src/libslic3r/GCode.cpp) issues during G-code export.
+- [PreciseSeam.cpp](../../src/libslic3r/GCode/PreciseSeam.cpp) implements segment
+  detection, point insertion, weak-zone resolution and position restoration.
+  [SeamPlacer.cpp](../../src/libslic3r/GCode/SeamPlacer.cpp) integrates it into
+  candidate gathering and issues the warning.
 - [Model.hpp](../../src/libslic3r/Model.hpp) defines the types and their order,
  [PrintApply.cpp](../../src/libslic3r/PrintApply.cpp) handles invalidation, and
-  [PrintObjectSlice.cpp](../../src/libslic3r/PrintObjectSlice.cpp) slices single
-  volumes into structured regions. [bbs_3mf.cpp](../../src/libslic3r/Format/bbs_3mf.cpp)
-  and [3mf.cpp](../../src/libslic3r/Format/3mf.cpp) store them.
+  [PrintObjectSlice.cpp](../../src/libslic3r/PrintObjectSlice.cpp) slices the
+  modifiers. [bbs_3mf.cpp](../../src/libslic3r/Format/bbs_3mf.cpp) and
+  [3mf.cpp](../../src/libslic3r/Format/3mf.cpp) store them.
 - [GUI_Factories.cpp](../../src/slic3r/GUI/GUI_Factories.cpp) and
  [GUI_ObjectList.cpp](../../src/slic3r/GUI/GUI_ObjectList.cpp) provide the menus,
-  type changes and ordering; [3DScene.cpp](../../src/slic3r/GUI/3DScene.cpp)
-  defines the colors.
- [Segment extraction tests](../../tests/libslic3r/test_precise_seam.cpp) cover
-  clipping and binding: holes and components, contour origin and reversal,
-  repeated coordinates, collinear vertices and rounding, rollback and the
-  diagnostic limits, the rounding fallback on synthetic and real Clipper
-  fragments, contacts, and full containment including touches and sub-micron
-  gaps on inclined edges and around vertices.
+  type changes and ordering.
 - [Precise Seam tests](../../tests/fff_print/test_precise_seam.cpp) cover the
-  consumers: strong targets in every mode, including a midpoint on an existing
-  vertex or the closing edge, longest-arc selection and tie order in bed axes,
-  priorities, weak boundaries that coincide or share an edge, enforced
-  subdivision, whole-perimeter weak zones with painting and priorities, weak
-  zones over painting's oversampled candidates, the warning type masks, usage
-  tracking for the "had no effect" warning, volume sorting of strong and weak
-  groups, restoration of strong points after alignment, raft layer indexing and
-  structured slices. End-to-end tests slice a real object with Precise Seam
-  volumes and check the outer wall starts in the exported G-code: every strong
-  mode under several seam positions and with a raft, Enforced and Blocked zones,
-  a modifier with a hole, and the user warning.
+  strong positions, including a midpoint on an existing vertex or the closing
+  edge. They also cover shared and coincident weak boundaries, every warning,
+  and the priority order.
 - [Seam placer tests](../../tests/fff_print/test_seam_placer.cpp) cover
  enforced-patch selection independent of the contour start, fully painted
-  contours, duplicate removal, and `Print::apply()` synchronization through type
-  changes and restored model snapshots. The duplicate-removal test also checks
-  the "had no effect" warning text prepared by `init()` for a helper that never
-  reaches the loop. Further tests check that adding, moving, retyping or
-  removing a Precise Seam volume invalidates only G-code export, and that seam
-  painting acts only from model parts and negative volumes, including after a
-  type change back to part.
+  contours, duplicate removal, and `Print::apply()` synchronization through
+  type changes and restored model snapshots.
 - [3MF tests](../../tests/libslic3r/test_precise_seam_3mf.cpp) cover the round
-  trip of every mode and of inactive settings, attribute escaping, and the
-  metadata combinations that restore a seam mode.
+  trip of every mode and of inactive settings, attribute escaping, and which
+  metadata combinations restore a seam mode.
  [Plugin tests](../../tests/slic3rutils/test_precise_seam_plugin.cpp) cover the
  Python bindings.
@@ -39,7 +39,7 @@ presets are never serialized — they have their own storage and their own lifec

 | Location | Contents on a shipped build | Role |
 |---|---|---|
-| `resources/profiles/` | `<vendor>.opc` alone — the profile and its preset JSONs both pruned | What the app ships with and what installing copies from; read directly for vendors not installed |
+| `resources/profiles/` | `<vendor>.opc` alone — the profile and its preset JSONs both pruned | What the app ships with; what installing copies from, and the only thing it is read for |
 | `<data_dir>/system/` | `<vendor>.opc` alone, or `<vendor>.json` + `<vendor>/` after an update | What the user has installed |
 | `<data_dir>/system/` (dev build) | `<vendor>.json` + `<vendor>/` + `<vendor>.opc` written at runtime | A developer tree caches as it parses |
 | `<data_dir>/cache/wizard_profile_data.json` | The wizard's derived vendor catalog plus the stamps it was built from | Written and read by the setup wizard only; never shipped (see "The wizard's profile-data cache") |
@@ -182,11 +182,10 @@ one startup.

 **A vendor is loaded from where it is installed and nowhere else.** For startup that
 is `<data_dir>/system/`; resources reaches the app by being *installed* into that
-directory first, never by being loaded from. (The setup wizard and the Create Printer
-dialog also offer vendors the user has not installed, and load those from
-`resources/profiles`; see "The wizard's profile-data cache". The dialog's vendor-only and
-filament-only scans read a cache only where it is the whole installation, and never write
-one.) There is one lookup tier and one parse source:
+directory first, never by being loaded from. (The setup wizard is the one caller with
+a different notion of "where": it also shows vendors the user has not installed, and
+loads those from `resources/profiles` — see "The wizard's profile-data cache".) There
+is one lookup tier and one parse source:

 ```
 load vendor V from <data_dir>/system:
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ian Chua	73f2c2f53e	Merge branch 'main' into feat/networking-foundation	2026-10-01 22:50:48 +08:00
peachismomo	c840d6cce7	fix: clean diff	2026-10-01 22:50:00 +08:00
Ian Chua	c50519026c	chore: port add_platform_root_certificates to 15711	2026-10-01 14:20:56 +08:00
Ian Chua	0a0f050479	fix: remove unrelated moonraker.cpp changes	2026-10-01 13:55:37 +08:00
Ian Chua	4c6f93400c	chore: remove duplcate http include	2026-10-01 13:55:29 +08:00
peachismomo	d3a30f3778	fix: regression after merge	2026-10-01 00:37:48 +08:00
peachismomo	5ec6712847	Merge branch 'main' into feat/networking-foundation	2026-10-01 00:32:14 +08:00
peachismomo	221cb8334b	feat: add foundation for configurable printer agent connection	2026-10-01 00:15:37 +08:00