Fix gizmo checkbox contrast; align Texture Displacement styling and panel refresh behavior (#16076)

* Fix gizmo checkbox styling and Texture Displacement resize

Use shared BBL checkboxes in Texture Displacement and restore white toolbar checkmarks so other gizmos keep proper checkbox contrast. Also fix Texture Displacement resizing only after mouse movement by requesting additional frames while its layout is still changing.

* Fix gizmo checkbox styling and Texture Displacement resize

Use shared BBL checkboxes in Texture Displacement and restore white toolbar checkmarks so other gizmos keep proper checkbox contrast. Also fix Texture Displacement resizing only after mouse movement by requesting additional frames while its layout is still changing.

* Update GLGizmoTextureDisplacement.cpp

---------

Co-authored-by: yw4z <ywsyildiz@gmail.com>

.clang-tidy

@@ -7,15 +7,9 @@ CheckOptions:
   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
+  # GTK or pthread one), library internals and forward declarations, CPython's
+  # headers behind Python.h, 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. 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,
@@ -29,11 +23,7 @@ CheckOptions:
     .*[/\\]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;
@@ -54,9 +44,4 @@ CheckOptions:
     fcntl\.h;
     termios\.h;
     [/\\](um|shared)[/\\].*;
-    sal\.h;
-    clipper[/\\]clipper\.hpp;
-    png(lib)?conf\.h;
-    mcut[/\\]platform\.h;
-    boost[/\\]polygon[/\\].*;
-    lzo(conf|defs)\.h
+    sal\.h

.github/workflows/build_orca.yml

@@ -259,6 +259,7 @@ jobs:
  # Thanks to RaySajuuk, it's working now
       - name: Sign app and notary
         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
+        timeout-minutes: 30
         working-directory: ${{ github.workspace }}
         env:
           BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}

deps_src/CMakeLists.txt

@@ -15,7 +15,6 @@ 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)

deps_src/clipper/CMakeLists.txt

@@ -1,20 +0,0 @@
-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
-)

deps_src/clipper/clipper.hpp

@@ -1,606 +0,0 @@
-/*******************************************************************************
-*                                                                              *
-* 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

deps_src/clipper/clipper_z.cpp

@@ -1,7 +0,0 @@
-// 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"

deps_src/clipper/clipper_z.hpp

@@ -1,18 +0,0 @@
-// 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

deps_src/clipper2/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.10)
-project(Clipper2 VERSION 1.5.2 LANGUAGES C CXX)
+project(Clipper2 VERSION 2.0.1 LANGUAGES C CXX)
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_CXX_STANDARD 17)
@@ -19,6 +19,7 @@ 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
 )
 
@@ -26,6 +27,7 @@ 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
 )
 
@@ -36,6 +38,9 @@ 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)

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.core.h

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  12 May 2024                                                     *
+* Date      :  12 October 2025                                                 *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2024                                         *
+* Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  Core Clipper Library structures and functions                   *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -251,6 +251,20 @@ 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>;
@@ -688,29 +702,28 @@ namespace Clipper2Lib {
     return (x > 0) - (x < 0); 
   }
 
-  struct MultiplyUInt64Result
+  struct UInt128Struct
   {
-    const uint64_t result = 0;
-    const uint64_t carry = 0;
+    const uint64_t lo = 0;
+    const uint64_t hi = 0;
 
-    bool operator==(const MultiplyUInt64Result& other) const
+    bool operator==(const UInt128Struct& other) const
     {
-      return result == other.result && carry == other.carry;
-    };
+      return lo == other.lo && hi == other.hi;
     };
 
-  inline MultiplyUInt64Result Multiply(uint64_t a, uint64_t b) // #834, #835
+  };
+
+  inline UInt128Struct MultiplyUInt64(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);
-    const uint64_t result = lo(x3) << 32 | lo(x1);
-    const uint64_t carry = hi(a) * hi(b) + hi(x2) + hi(x3);
-
-    return { result, carry };
+    return { uint64_t(lo(x3) << 32 | lo(x1)), uint64_t(hi(a) * hi(b) + hi(x2) + hi(x3)) };
   }
 
   // returns true if (and only if) a * b == c * d
@@ -727,14 +740,50 @@ 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 abs_ab = Multiply(abs_a, abs_b);
-    const auto abs_cd = Multiply(abs_c, abs_d);
+    const auto ab = MultiplyUInt64(abs_a, abs_b);
+    const auto cd = MultiplyUInt64(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 abs_ab == abs_cd && sign_ab == sign_cd;
+    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;
 #endif
   }
 
@@ -838,6 +887,10 @@ 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
@@ -845,7 +898,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 GetSegmentIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
+  inline bool GetLineIntersectPt(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);
@@ -891,11 +944,14 @@ 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 GetSegmentIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
+  inline bool GetLineIntersectPt(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
@@ -913,6 +969,9 @@ 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;
   }
@@ -949,21 +1008,44 @@ namespace Clipper2Lib {
   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)
     {
-      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
+      //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 {
-      return (GetSign(CrossProduct(seg1a, seg2a, seg2b)) *
-        GetSign(CrossProduct(seg1b, seg2a, seg2b)) < 0) &&
-        (GetSign(CrossProduct(seg2a, seg1a, seg1b)) *
-          GetSign(CrossProduct(seg2b, seg1a, seg1b)) < 0);
+      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
+    }
+    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
     }
   }
 
@@ -1051,7 +1133,7 @@ namespace Clipper2Lib {
         val = 1 - val; // toggle val
       else
       {
-        double d = CrossProduct(*prev, *curr, pt);
+        int d = CrossProductSign(*prev, *curr, pt);
         if (d == 0) return PointInPolygonResult::IsOn;
         if ((d < 0) == is_above) val = 1 - val;
       }
@@ -1065,7 +1147,7 @@ namespace Clipper2Lib {
       if (curr == cend) curr = cbegin;
       if (curr == cbegin) prev = cend - 1;
       else prev = curr - 1;
-      double d = CrossProduct(*prev, *curr, pt);
+      int d = CrossProductSign(*prev, *curr, pt);
       if (d == 0) return PointInPolygonResult::IsOn;
       if ((d < 0) == is_above) val = 1 - val;
     }

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.engine.h

@@ -15,6 +15,13 @@
 #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
@@ -50,6 +57,7 @@ namespace Clipper2Lib {
 	}
 
 	struct Vertex {
+		CLIPPER2_NODE_ALLOCATOR
 		Point64 pt;
 		Vertex* next = nullptr;
 		Vertex* prev = nullptr;
@@ -57,6 +65,7 @@ namespace Clipper2Lib {
 	};
 
 	struct OutPt {
+		CLIPPER2_NODE_ALLOCATOR
 		Point64 pt;
 		OutPt*	next = nullptr;
 		OutPt*	prev = nullptr;
@@ -81,6 +90,7 @@ 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;
@@ -106,6 +116,7 @@ namespace Clipper2Lib {
 	///////////////////////////////////////////////////////////////////
 
 	struct Active {
+		CLIPPER2_NODE_ALLOCATOR
 		Point64 bot;
 		Point64 top;
 		int64_t curr_x = 0;		//current (updated at every new scanline)
@@ -133,6 +144,7 @@ namespace Clipper2Lib {
 	};
 
 	struct LocalMinima {
+		CLIPPER2_NODE_ALLOCATOR
 		Vertex* vertex;
 		PathType polytype;
 		bool is_open;
@@ -303,6 +315,7 @@ 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
@@ -330,6 +343,7 @@ 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)
 		{
@@ -388,7 +402,8 @@ 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(); });
 		}
 
@@ -462,7 +477,8 @@ 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(); });
 		}
 	};

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.export.h

@@ -116,13 +116,10 @@ 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;
@@ -816,6 +813,24 @@ 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);

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.h

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  27 April 2024                                                   *
+* Date      :  5 March 2025                                                    *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2024                                         *
+* Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  This module provides a simple interface to the Clipper Library  *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -13,14 +13,15 @@
 #include "clipper2/clipper.core.h"
 #include "clipper2/clipper.engine.h"
 #include "clipper2/clipper.offset.h"
-#include "clipper2/clipper.minkowski.h"
 #include "clipper2/clipper.rectclip.h"
+#include "clipper2/clipper.minkowski.h"
+#include "clipper2/clipper.triangulation.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,
@@ -154,7 +155,7 @@
     if (!delta) return paths;
     if (error_code) return PathsD();
     const double scale = std::pow(10, precision);
-    ClipperOffset clip_offset(miter_limit, arc_tolerance);
+    ClipperOffset clip_offset(miter_limit, arc_tolerance * scale);
     clip_offset.AddPaths(ScalePaths<int64_t,double>(paths, scale, error_code), jt, et);
     if (error_code) return PathsD();
     Paths64 solution;
@@ -355,6 +356,29 @@
 #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)
@@ -615,29 +639,6 @@
     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)
@@ -669,13 +670,13 @@
         start = curr;
         do
         {
-          curr = GetNext(curr, high, flags);
+          curr = details::GetNext(curr, high, flags);
         } while (curr != start && distSqr[curr] > epsSqr);
         if (curr == start) break;
       }
 
-      prior = GetPrior(curr, high, flags);
-      next = GetNext(curr, high, flags);
+      prior = details::GetPrior(curr, high, flags);
+      next = details::GetNext(curr, high, flags);
       if (next == prior) break;
 
       // flag for removal the smaller of adjacent 'distances'
@@ -684,14 +685,14 @@
         prior2 = prior;
         prior = curr;
         curr = next;
-        next = GetNext(next, high, flags);
+        next = details::GetNext(next, high, flags);
       }
       else
-        prior2 = GetPrior(prior, high, flags);
+        prior2 = details::GetPrior(prior, high, flags);
 
       flags[curr] = true;
       curr = next;
-      next = GetNext(next, high, flags);
+      next = details::GetNext(next, high, flags);
 
       if (isClosedPath || ((curr != high) && (curr != 0)))
         distSqr[curr] = PerpendicDistFromLineSqrd(path[curr], path[prior], path[next]);
@@ -716,6 +717,35 @@
     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)

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.triangulation.h

@@ -0,0 +1,30 @@
+/*******************************************************************************
+* 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

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.version.h

@@ -1,6 +1,6 @@
 #ifndef CLIPPER_VERSION_H
 #define CLIPPER_VERSION_H
 
-constexpr auto CLIPPER2_VERSION = "1.5.2";
+constexpr auto CLIPPER2_VERSION = "2.0.1";
 
 #endif  // CLIPPER_VERSION_H

deps_src/clipper2/Clipper2Lib/src/clipper.engine.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  17 September 2024                                               *
+* Date      :  5 November 2025                                                 *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2024                                         *
+* Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  This is the main polygon clipping module                        *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -10,6 +10,8 @@
 #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
@@ -27,6 +29,26 @@ 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 
@@ -482,8 +504,7 @@ namespace Clipper2Lib {
   inline void SetOwner(OutRec* outrec, OutRec* new_owner)
   {
     //precondition1: new_owner is never null
-    while (new_owner->owner && !new_owner->owner->pts)
-      new_owner->owner = new_owner->owner->owner;
+    new_owner->owner = GetRealOutRec(new_owner->owner);
     OutRec* tmp = new_owner;
     while (tmp && tmp != outrec) tmp = tmp->owner;
     if (tmp) new_owner->owner = outrec->owner;
@@ -536,9 +557,9 @@ namespace Clipper2Lib {
         val = 1 - val; // toggle val
       else
       {
-        double d = CrossProduct(op2->prev->pt, op2->pt, pt);
-        if (d == 0) return PointInPolygonResult::IsOn;
-        if ((d < 0) == is_above) val = 1 - val;
+        int i = CrossProductSign(op2->prev->pt, op2->pt, pt);
+        if (i == 0) return PointInPolygonResult::IsOn;
+        if ((i < 0) == is_above) val = 1 - val;
       }
       is_above = !is_above;
       op2 = op2->next;
@@ -546,9 +567,9 @@ namespace Clipper2Lib {
 
     if (is_above != starting_above)
     {
-      double d = CrossProduct(op2->prev->pt, op2->pt, pt);
-      if (d == 0) return PointInPolygonResult::IsOn;
-      if ((d < 0) == is_above) val = 1 - val;
+      int i = CrossProductSign(op2->prev->pt, op2->pt, pt);
+      if (i == 0) return PointInPolygonResult::IsOn;
+      if ((i < 0) == is_above) val = 1 - val;
     }
 
     if (val == 0) return PointInPolygonResult::IsOutside;
@@ -578,29 +599,30 @@ namespace Clipper2Lib {
     return result;
   }
 
-  inline bool Path1InsidePath2(OutPt* op1, OutPt* op2)
+  inline bool Path2ContainsPath1(OutPt* op1, OutPt* op2)
   {
-    // 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;
+    // this function accommodates rounding errors that 
+    // can cause path micro intersections
+    PointInPolygonResult pip = PointInPolygonResult::IsOn;
     OutPt* op = op1;
-    do
+    do {
+      switch (PointInOpPolygon(op->pt, op2))
       {
-      result = PointInOpPolygon(op->pt, op2);
-      if (result == PointInPolygonResult::IsOutside) ++outside_cnt;
-      else if (result == PointInPolygonResult::IsInside) --outside_cnt;
+      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;
+      }
       op = op->next;
-    } 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;
+    } while (op != op1);
+    // result unclear, so try again using cleaned paths
+    return Path2ContainsPath1(GetCleanPath(op1), GetCleanPath(op2)); // (#973)
   }
-
-  //------------------------------------------------------------------------------
-  //------------------------------------------------------------------------------
 
   void AddLocMin(LocalMinimaList& list,
     Vertex& vert, PathType polytype, bool is_open)
@@ -1126,21 +1148,19 @@ namespace Clipper2Lib {
         return newcomer.curr_x > resident.curr_x;
 
     //get the turning direction  a1.top, a2.bot, a2.top
-    double d = CrossProduct(resident.top, newcomer.bot, newcomer.top);
-    if (d != 0) return d < 0;
+    int i = CrossProductSign(resident.top, newcomer.bot, newcomer.top);
+    if (i != 0) return i < 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 CrossProduct(newcomer.bot,
-        resident.top, NextVertex(resident)->pt) <= 0;
+      return (CrossProductSign(newcomer.bot, resident.top, NextVertex(resident)->pt) <= 0);
     }
     else if (!IsMaxima(newcomer) && (newcomer.top.y > resident.top.y))
     {
-      return CrossProduct(newcomer.bot,
-        newcomer.top, NextVertex(newcomer)->pt) >= 0;
+      return (CrossProductSign(newcomer.bot, newcomer.top, NextVertex(newcomer)->pt) >= 0);
     }
 
     int64_t y = newcomer.bot.y;
@@ -1155,7 +1175,7 @@ namespace Clipper2Lib {
       resident.bot, resident.top)) return true;
     else
       //compare turning direction of the alternate bound
-      return (CrossProduct(PrevPrevVertex(resident)->pt,
+      return (CrossProductSign(PrevPrevVertex(resident)->pt,
         newcomer.bot, PrevPrevVertex(newcomer)->pt) > 0) == newcomerIsLeft;
   }
 
@@ -1565,7 +1585,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
@@ -1574,7 +1594,7 @@ namespace Clipper2Lib {
     outrec->pts = prevOp;
 
     Point64 ip;
-    GetSegmentIntersectPt(prevOp->pt, splitOp->pt,
+    GetLineIntersectPt(prevOp->pt, splitOp->pt,
       splitOp->next->pt, nextNextOp->pt, ip);
 
 #ifdef USINGZ
@@ -1630,7 +1650,7 @@ namespace Clipper2Lib {
 
       if (using_polytree_)
       {
-        if (Path1InsidePath2(prevOp, newOp))
+        if (Path2ContainsPath1(prevOp, newOp))
         {
           newOr->splits = new OutRecList();
           newOr->splits->emplace_back(outrec);
@@ -1652,20 +1672,33 @@ 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;
         }
+      }
       else
         op2 = op2->next;
 
@@ -2112,9 +2145,8 @@ namespace Clipper2Lib {
       e->prev_in_sel = e->prev_in_ael;
       e->next_in_sel = e->next_in_ael;
       e->jump = e->next_in_sel;
-      if (e->join_with == JoinWith::Left)
-        e->curr_x = e->prev_in_ael->curr_x; // also avoids complications
-      else
+      // it is safe to ignore 'joined' edges here because
+      // if necessary they will be split in IntersectEdges()
       e->curr_x = TopX(*e, top_y);
       e = e->next_in_ael;
     }
@@ -2262,15 +2294,14 @@ 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);
     fromOr->splits->clear();
   }
 
-
   void ClipperBase::ProcessHorzJoins()
   {
     for (const HorzJoin& j : horz_join_list_)
@@ -2300,7 +2331,7 @@ namespace Clipper2Lib {
 
         if (using_polytree_) //#498, #520, #584, D#576, #618
         {          
-          if (Path1InsidePath2(or1->pts, or2->pts))
+          if (Path2ContainsPath1(or1->pts, or2->pts))
           {
             //swap or1's & or2's pts
             OutPt* tmp = or1->pts;
@@ -2311,7 +2342,7 @@ namespace Clipper2Lib {
             //or2 is now inside or1
             or2->owner = or1;
           }
-          else if (Path1InsidePath2(or2->pts, or1->pts))
+          else if (Path2ContainsPath1(or2->pts, or1->pts))
           {
             or2->owner = or1;
           }
@@ -2324,12 +2355,13 @@ namespace Clipper2Lib {
         else
           or2->owner = or1;
       }
-      else
+      else // joining, not splitting
       {
         or2->pts = nullptr;
         if (using_polytree_)
         {
           SetOwner(or2, or1);
+          if (or2->splits) 
             MoveSplits(or2, or1); //#618
         }
         else
@@ -2350,7 +2382,7 @@ namespace Clipper2Lib {
   void ClipperBase::AddNewIntersectNode(Active& e1, Active& e2, int64_t top_y)
   {
     Point64 ip;
-    if (!GetSegmentIntersectPt(e1.bot, e1.top, e2.bot, e2.top, ip))
+    if (!GetLineIntersectPt(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
@@ -2934,22 +2966,28 @@ namespace Clipper2Lib {
 
   bool ClipperBase::CheckSplitOwner(OutRec* outrec, OutRecList* splits)
   {
-    for (auto split : *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)
     {
+      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;    
-      else if (CheckBounds(split) &&
-        IsValidOwner(outrec, split) &&
-        split->bounds.Contains(outrec->bounds) &&
-        Path1InsidePath2(outrec->pts, split->pts))
-      {
-        outrec->owner = split; //found in split
+
+      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 false;
   }
@@ -2960,13 +2998,12 @@ 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) &&
-        Path1InsidePath2(outrec->pts, outrec->owner->pts)) break;
+        Path2ContainsPath1(outrec->pts, outrec->owner->pts)) break;
       outrec->owner = outrec->owner->owner;
     }
 
@@ -3029,6 +3066,7 @@ namespace Clipper2Lib {
     {
       OutRec* outrec = outrec_list_[i];
       if (!outrec || !outrec->pts) continue;
+
       if (outrec->is_open)
       {
         Path64 path;

deps_src/clipper2/Clipper2Lib/src/clipper.offset.cpp

@@ -1,6 +1,6 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  22 January 2025                                                 *
+* Date      :  11 October 2025                                                 *
 * Website   :  https://www.angusj.com                                          *
 * Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  Path Offset (Inflate/Shrink)                                    *
@@ -37,22 +37,28 @@ const double arc_const = 0.002; // <-- 1/500
 // Miscellaneous methods
 //------------------------------------------------------------------------------
 
-std::optional<size_t> GetLowestClosedPathIdx(const Paths64& paths)
+void GetLowestClosedPathInfo(const Paths64& paths, std::optional<size_t>& idx, bool& is_neg_area)
 {
-    std::optional<size_t> result;
+	idx.reset();
 	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;
-            result = i;
+			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;
 			botPt.x = pt.x;
 			botPt.y = pt.y;
 		}
 	}
-	return result;
 }
 
 inline double Hypot(double x, double y)
@@ -145,15 +151,16 @@ ClipperOffset::Group::Group(const Paths64& _paths, JoinType _join_type, EndType
 
 	if (end_type == EndType::Polygon)
 	{
-		lowest_path_idx = GetLowestClosedPathIdx(paths_in);
+		bool is_neg_area;
+		GetLowestClosedPathInfo(paths_in, lowest_path_idx, is_neg_area);
 		// 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()) && Area(paths_in[lowest_path_idx.value()]) < 0;
+    is_reversed = lowest_path_idx.has_value() && is_neg_area;
 	}
 	else
 	{
-    lowest_path_idx = std::nullopt;
+    lowest_path_idx.reset();
 		is_reversed = false;
 	}
 }
@@ -236,7 +243,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;
-		GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt);
+		GetLineIntersectPt(pt1, pt2, pt3, pt4, pt);
 		//get the second intersect point through reflecion
         path_out.emplace_back(ReflectPoint(pt, ptQ));
         path_out.emplace_back(pt);
@@ -245,7 +252,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;
-		GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt);
+		GetLineIntersectPt(pt1, pt2, pt3, pt4, pt);
         path_out.emplace_back(pt);
 		//get the second intersect point through reflecion
         path_out.emplace_back(ReflectPoint(pt, ptQ));
@@ -291,7 +298,8 @@ 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
-	int steps = static_cast<int>(std::ceil(steps_per_rad_ * std::abs(angle))); // #448, #456
+	// 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);
 	for (int i = 1; i < steps; ++i) // ie 1 less than steps
 	{
 		offsetVec = PointD(offsetVec.x * step_cos_ - step_sin_ * offsetVec.y,
@@ -366,10 +374,30 @@ 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);
     solution->emplace_back(path_out);
 }
@@ -604,7 +632,7 @@ void ClipperOffset::ExecuteInternal(double delta)
 	bool paths_reversed = CheckReverseOrientation();
 	//clean up self-intersections ...
 	Clipper64 c;
-	c.PreserveCollinear(false);
+	c.PreserveCollinear(preserve_collinear_);
 	//the solution should retain the orientation of the input
 	c.ReverseSolution(reverse_solution_ != paths_reversed);
 #ifdef USINGZ

deps_src/clipper2/Clipper2Lib/src/clipper.rectclip.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  5 July 2024                                                     *
+* Date      :  11 October 2025                                                 *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2024                                         *
+* Copyright :  Angus Johnson 2010-2025                                         *
 * 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)
   {
-    double res1 = CrossProduct(p1, p3, p4);
-    double res2 = CrossProduct(p2, p3, p4);
+    int res1 = CrossProductSign(p1, p3, p4);
+    int res2 = CrossProductSign(p2, p3, p4);
     if (res1 == 0)
     {
       ip = p1;
@@ -97,8 +97,8 @@ namespace Clipper2Lib {
     }
     if ((res1 > 0) == (res2 > 0)) return false;
 
-    double res3 = CrossProduct(p3, p1, p2);
-    double res4 = CrossProduct(p4, p1, p2);
+    int res3 = CrossProductSign(p3, p1, p2);
+    int res4 = CrossProductSign(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 GetSegmentIntersectPt(p1, p2, p3, p4, ip);
+    return GetLineIntersectPt(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 CrossProduct(prev_pt, rect_mp, curr_pt) < 0;
+      return CrossProductSign(prev_pt, rect_mp, curr_pt) < 0;
     else
       return HeadingClockwise(prev, curr);
   }

deps_src/clipper2/Clipper2Lib/src/clipper2_z.cpp

@@ -6,3 +6,4 @@
 #include "clipper.engine.cpp"
 #include "clipper.offset.cpp"
 #include "clipper.rectclip.cpp"
+#include "clipper.triangulation.cpp"

deps_src/libnest2d/include/libnest2d/backends/libslic3r/geometries.hpp

@@ -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::ClipperLib::jtSquare);
+    auto res = Slic3r::offset_ex(sh, distance, Slic3r::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::ClipperLib::jtSquare);
+    auto res = Slic3r::offset(sh, distance, Slic3r::jtSquare);
     if (!res.empty()) sh = res.front();
 }
 

docs/HLSD/polygon-clipping.md

@@ -0,0 +1,131 @@
+# 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`.

docs/HLSD/scene-benchmark.md

@@ -0,0 +1,93 @@
+# 3D Scene Benchmark: High Level Design
+
+## Why it exists
+
+Rendering changes, such as the realistic view, shadows or SSAO, need a number to compare
+before and after, and user reports of a slow viewport need a way to say how slow. The FPS
+overlay and the render timings overlay show live values while someone drags the camera,
+which varies from run to run with the model, the path of the mouse and the view.
+
+The benchmark renders a fixed model along a fixed camera path in both 3D views, so two
+runs on the same machine differ only by the code or the settings, and prints a report that
+can be pasted into an issue.
+
+## What it does
+
+`run_scene_benchmark()` in `src/slic3r/GUI/SceneBenchmark.cpp` is reached from Help >
+Benchmark 3D Scene, the command palette and Preferences > Graphics. After a confirmation
+it starts a new project, which asks to save the current one if needed, loads the
+OrcaSliced Combo handy model and arranges it. A small dialog in a corner of the 3D view
+then shows the progress; every other window is disabled until the run ends, so a click
+cannot change the scene being measured. Cancel or Esc stops the run.
+
+The run goes through these stages, driven by a timer while it waits and by idle events
+while it renders:
+
+1. Loading: waits until the UI job worker is idle, so the arrange job has moved the
+   objects. The orbit target is the center of the objects on the current plate, and the
+   base zoom fits their bounding box in the viewport.
+2. Prepare: renders the scene in the Prepare view.
+3. Slicing: slices the plate and switches to Preview, then waits for the G-code preview
+   to load. If slicing fails, the report holds Prepare alone.
+4. Preview: renders the scene in the Preview view, with the slicing progress notification
+   hidden.
+5. Layers: renders the Preview view again while the layer slider moves, which is what
+   makes dragging it feel slow on large prints.
+
+The dialog then shows the report, with a button to copy it. A scene cut short, because its
+view was hidden, is left out of the report.
+
+## Rendering a scene
+
+Each scene renders 30 warm-up frames, then the camera path twice, 360 frames each time.
+
+- The first pass times the frames. A frame's time is the interval between the starts of
+  consecutive benchmark frames, so it includes the event loop between them.
+- The second pass averages the render timings. The frame profiler flushes the GL command
+  queue after each section, which slows a frame down, so it only runs in this pass.
+  `FrameProfiler::start_averaging()` flags every frame begun afterwards, and
+  `finish_averaging()` waits for the flagged frames still on the GPU and returns the mean
+  CPU and GPU time of each section per profiled frame.
+- A section's GPU time is taken between a timestamp before its commands and one after
+  them. The first is only sent along with those commands, so when the GPU finishes a
+  section before the CPU has issued the next one, the wait counts in neither.
+
+The dialog renders one frame per idle event by calling `GLCanvas3D::render()`, which
+redraws the whole scene. While `GLCanvas3D::set_benchmarking()` is on, the canvas does not
+render from its own idle handler, so no other frame is drawn in between, and it skips the
+picking pass and the FPS and render timings overlays, which depend on the mouse and on
+preferences. The FPS cap does not apply, since it only paces idle redraws.
+
+VSync is turned off for the scene through `wxGLCanvas::SetSwapInterval(0)`, so the frame
+rate is what the GPU and CPU can reach rather than the display's refresh rate, and the
+previous interval is restored afterwards. When the platform cannot report the current
+interval (EGL), it is left as it is and the report says so.
+
+The camera path makes two turns around the target while the view rises three times from
+25 degrees below the plate to 85 degrees above it and the zoom goes twice between 0.6 and
+1.4 times the base zoom. The camera stays at the default distance, so the perspective is
+the same in every run. The camera the scene started with is restored at its end.
+
+The Layers scene holds the camera at the start of that path and moves the top of the layer
+slider instead, from the last layer down to the first and back up in each pass. It goes
+through `IMSlider::SetHigherValue()`, as a drag does, so every frame applies a new layer
+range to the toolpaths and the objects before drawing them, including a new shadow map when
+the shadows are static. Its warm-up frames lead into the start of the path, so the slider
+moves in every frame. The slider position it started from is restored at its end.
+
+## The report
+
+The report is plain English text, so it reads the same in every language:
+
+- The version and build commit, the GPU and OpenGL version, the viewport size and camera
+  type, and the graphics settings that change the cost of a frame: MSAA samples as read
+  from the framebuffer, FXAA, the scene cache, VSync and the realistic view options.
+- The printer and process presets the model was sliced with, marked when they have
+  unsaved changes, and the toolpath vertices and layers they produced, since the Preview
+  scenes cost more with more toolpaths.
+- For each scene, the average FPS and the average, median, 95th percentile, 99th
+  percentile and maximum frame time. Percentiles are nearest-rank, so each is a measured
+  frame (`frame_time_stats()`).
+- For each scene, the render timings table: the CPU and GPU milliseconds of each section
+  of a frame, and their total. Without timer queries (OpenGL 3.3 or `ARB_timer_query`) the
+  table says that the driver does not support them.

docs/HLSD/section-view.md

@@ -0,0 +1,105 @@
+# Section view — High Level Design
+
+## Purpose and scope
+
+Section view hides whatever lies between the camera and a plane, so the user can look inside
+objects in Prepare and in the assembly view, and inside the toolpaths in Preview. 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 user controls it from the section button of the canvas toolbar in the bottom left corner of
+the 3D view. The button opens a panel above it with a slider for the depth of the cut, a "Set
+viewing angle" button that turns the plane to face the camera at the same depth, and a button that
+resets the depth to zero. The panel is an ordinary overlay window, not a popup, so the scene keeps
+taking clicks and drags while it is open; the button or Esc closes it again. Esc closes the panel
+before it closes a gizmo or clears the selection. The button is highlighted
+while a section cuts the scene and has shortcuts of its own: the mouse wheel over it moves the
+plane, a right click switches the section off and back on, and a middle click sets the viewing
+angle. Alt + mouse wheel moves the plane anywhere in the 3D view, with or without a gizmo open.
+
+## State
+
+Prepare and Preview share one section view, so a cut made in either tab is the same cut in the
+other. The assembly view, whose objects sit apart from their places on the plate, and the Design
+tab keep their own. The section itself is two values.
+
+- **Ratio**, from 0 to 1. At 0 the section is off. As the ratio grows, the plane sweeps the
+  sphere around the objects, from its side facing the camera to the opposite side, so at 1
+  everything is cut away.
+- **Normal**, taken from the camera direction the first time the section is switched on, and
+  again whenever the user sets the viewing angle. The plane keeps that orientation while the
+  camera orbits and while the section is off, so the cut face can be seen from any side and
+  bringing the depth back to 0 does not lose the angle.
+
+The ratio in use when the section is switched off is kept, and the right click on the button
+brings the section back at that ratio, which restores the same cut. Whether the panel is open is
+shared along with the section.
+
+The sphere is recomputed every frame from the volumes of the canvas the section view belongs to:
+the objects on the current plate, or every object when that plate is empty. Preview holds no
+objects of its own, so it places the plane across the volumes of Prepare, which makes it cut the
+toolpaths exactly where Prepare cuts the objects. Only G-code opened on its own, without objects,
+is measured by its toolpaths. In the assembly view the sphere is around the whole assembly. The
+ratio therefore keeps its meaning when objects move or the user switches plates. It is not a
+fixed position in world space.
+
+Only the tab on screen can change the section, and switching tabs redraws the whole scene and
+closes the open gizmo, so neither tab ever shows a stale cut.
+
+## Where the plane applies
+
+`GLCanvas3D::_get_section_view_plane()` turns the state into a plane in the convention of
+`ClippingPlane::is_point_clipped()`. Everything that draws or picks the scene reads that plane.
+
+- **Volumes.** The plane goes to the `clipping_plane` uniform of the volume shaders. The same
+  uniform serves the gouraud, phong and X-ray passes and the colour picking pass.
+- **Cut faces.** Clipping only discards fragments, which would leave the cut volumes hollow.
+  `_render_section_view_caps()` draws their cut faces with one `MeshClipper` per model part the
+  plane passes through. A clipper recomputes its face only when the plane or the volume moves.
+  Modifiers, the wipe tower and SLA auxiliaries get no face.
+- **Toolpaths.** libvgcode takes the plane through `Viewer::set_clipping_plane()`. It draws each
+  extrusion as only the faces of a diamond-section prism that turn towards the camera, so
+  discarding the fragments on the clipped side would leave open shells. Instead, the segment
+  shader follows the view ray from a fragment that is cut away to the plane. When the
+  extrusion's diamond section still holds that point, the fragment is shaded as the cut face, lit
+  as the plane faces; otherwise it is discarded. The cut face keeps the depth of the fragment it
+  replaces, which is safe: along that ray everything else still shown lies behind the plane. The
+  shader writes no `gl_FragDepth`, so early depth testing survives. Option markers are cut away
+  whole, by their centres. The shadow casters draw with a program of their own, which takes the
+  plane and discards the fragments on the clipped side, so what is cut away casts no shadow either.
+  Their cut faces are not drawn, since the part left behind casts the shadow of its own section.
+  Preview shells are drawn by another shader and are not clipped.
+- **Picking.** `get_raycaster_clipping_plane()` returns the same plane, so hover, selection and
+  the perspective pan anchor ignore what the user cannot see.
+
+## Gizmos
+
+A gizmo that clips its object itself owns the gizmo data pool's `ObjectClipper`, and its plane
+replaces the canvas section while the gizmo is open. `GLGizmosManager::get_clipping_plane()`
+reports that plane, or nothing when no open gizmo has a clipper. There are two cases.
+
+- **Painting tools and brim ears** show the canvas section on the object they edit.
+  `GLGizmosManager::update_section_view()` copies the ratio and normal into their clipper
+  whenever the pool is updated or the section changes. The clipper then places the plane across
+  the edited instance, which is the only object shown. The painting tools keep clipping their
+  own triangles, raycasts and cut face through it. Brim ears always cut horizontally from the
+  top, because the ears sit on the plate. At ratio 0 the clipper holds no plane at all, so the
+  raycasts are not clipped.
+- **Cut and mesh boolean** use the clipper for their own purposes, so the canvas section is
+  suspended while they are open.
+
+Every other gizmo, including move, rotate and scale, leaves the canvas section in place.
+
+## Alt + mouse wheel
+
+The canvas handles Alt + wheel after the gizmos had their turn, so it works the same in every
+tab and with any gizmo open. On Windows, releasing Alt when no key was pressed since it went down
+opens the window menu, and a wheel turn does not count as a key. Under the custom title bar that
+menu is invisible, yet it takes the keyboard and the next click, which looks like a frozen 3D
+view. After Alt + wheel the canvas therefore consumes the Alt release instead of passing it on.
+
+## Redraw
+
+The button and the panel are part of the ImGui overlay, which is built after the frame's scene is
+drawn. A change to the section therefore marks the scene dirty and asks for one more frame. The
+cached scene is never reused across a change.

localization/i18n/list.txt

@@ -180,6 +180,7 @@ src/slic3r/GUI/PrivacyUpdateDialog.cpp
 src/slic3r/GUI/PublishDialog.cpp
 src/slic3r/GUI/PublishSettingsDialog.cpp
 src/slic3r/GUI/SavePresetDialog.cpp
+src/slic3r/GUI/SceneBenchmark.cpp
 src/slic3r/GUI/Search.cpp
 src/slic3r/GUI/SettingsIndex.cpp
 src/slic3r/GUI/SpeedDialDialog.cpp

resources/images/canvas_section.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36"><circle cx="17.5" cy="17.5" r="17.5" style="fill:#fafafa;"/><polygon points="13.82,11.62 21.18,15.88 21.18,23.38 13.82,19.12" style="fill:#2b3436; fill-opacity:.55;"/><polygon points="8.75,14.55 16.11,18.80 16.11,26.30 8.75,22.05" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="8.75,14.55 12.43,12.43 19.79,16.68 16.11,18.80" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="19.79,16.68 19.79,24.18 16.11,26.30" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polygon points="13.82,11.62 17.50,9.50 24.86,13.75 24.86,21.25 21.18,23.38 13.82,19.12" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round;"/><polyline points="13.82,11.62 21.18,15.88 24.86,13.75" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round;"/><line x1="21.18" y1="15.88" x2="21.18" y2="23.38" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/images/canvas_section_active.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36"><circle cx="17.5" cy="17.5" r="17.5" style="fill:#009688;"/><polygon points="13.82,11.62 21.18,15.88 21.18,23.38 13.82,19.12" style="fill:#ffffff; fill-opacity:.55;"/><polygon points="8.75,14.55 16.11,18.80 16.11,26.30 8.75,22.05" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="8.75,14.55 12.43,12.43 19.79,16.68 16.11,18.80" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="19.79,16.68 19.79,24.18 16.11,26.30" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polygon points="13.82,11.62 17.50,9.50 24.86,13.75 24.86,21.25 21.18,23.38 13.82,19.12" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/><polyline points="13.82,11.62 21.18,15.88 24.86,13.75" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/><line x1="21.18" y1="15.88" x2="21.18" y2="23.38" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/images/canvas_section_active_dark.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36"><circle cx="17.5" cy="17.5" r="17.5" style="fill:#00675b;"/><polygon points="13.82,11.62 21.18,15.88 21.18,23.38 13.82,19.12" style="fill:#ffffff; fill-opacity:.55;"/><polygon points="8.75,14.55 16.11,18.80 16.11,26.30 8.75,22.05" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="8.75,14.55 12.43,12.43 19.79,16.68 16.11,18.80" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="19.79,16.68 19.79,24.18 16.11,26.30" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polygon points="13.82,11.62 17.50,9.50 24.86,13.75 24.86,21.25 21.18,23.38 13.82,19.12" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/><polyline points="13.82,11.62 21.18,15.88 24.86,13.75" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/><line x1="21.18" y1="15.88" x2="21.18" y2="23.38" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/images/canvas_section_active_dark_hover.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36"><circle cx="17.5" cy="17.5" r="17.5" style="fill:#008172;"/><polygon points="13.82,11.62 21.18,15.88 21.18,23.38 13.82,19.12" style="fill:#ffffff; fill-opacity:.55;"/><polygon points="8.75,14.55 16.11,18.80 16.11,26.30 8.75,22.05" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="8.75,14.55 12.43,12.43 19.79,16.68 16.11,18.80" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="19.79,16.68 19.79,24.18 16.11,26.30" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polygon points="13.82,11.62 17.50,9.50 24.86,13.75 24.86,21.25 21.18,23.38 13.82,19.12" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/><polyline points="13.82,11.62 21.18,15.88 24.86,13.75" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/><line x1="21.18" y1="15.88" x2="21.18" y2="23.38" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/images/canvas_section_active_hover.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36"><circle cx="17.5" cy="17.5" r="17.5" style="fill:#26a69a;"/><polygon points="13.82,11.62 21.18,15.88 21.18,23.38 13.82,19.12" style="fill:#ffffff; fill-opacity:.55;"/><polygon points="8.75,14.55 16.11,18.80 16.11,26.30 8.75,22.05" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="8.75,14.55 12.43,12.43 19.79,16.68 16.11,18.80" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="19.79,16.68 19.79,24.18 16.11,26.30" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polygon points="13.82,11.62 17.50,9.50 24.86,13.75 24.86,21.25 21.18,23.38 13.82,19.12" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/><polyline points="13.82,11.62 21.18,15.88 24.86,13.75" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/><line x1="21.18" y1="15.88" x2="21.18" y2="23.38" style="fill:none; stroke:#ffffff; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/images/canvas_section_dark.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36"><circle cx="17.5" cy="17.5" r="17.5" style="fill:#393c42;"/><polygon points="13.82,11.62 21.18,15.88 21.18,23.38 13.82,19.12" style="fill:#b6b6b6; fill-opacity:.55;"/><polygon points="8.75,14.55 16.11,18.80 16.11,26.30 8.75,22.05" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="8.75,14.55 12.43,12.43 19.79,16.68 16.11,18.80" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="19.79,16.68 19.79,24.18 16.11,26.30" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polygon points="13.82,11.62 17.50,9.50 24.86,13.75 24.86,21.25 21.18,23.38 13.82,19.12" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round;"/><polyline points="13.82,11.62 21.18,15.88 24.86,13.75" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round;"/><line x1="21.18" y1="15.88" x2="21.18" y2="23.38" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/images/canvas_section_dark_hover.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36"><circle cx="17.5" cy="17.5" r="17.5" style="fill:#283232;"/><polygon points="13.82,11.62 21.18,15.88 21.18,23.38 13.82,19.12" style="fill:#b6b6b6; fill-opacity:.55;"/><polygon points="8.75,14.55 16.11,18.80 16.11,26.30 8.75,22.05" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="8.75,14.55 12.43,12.43 19.79,16.68 16.11,18.80" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="19.79,16.68 19.79,24.18 16.11,26.30" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polygon points="13.82,11.62 17.50,9.50 24.86,13.75 24.86,21.25 21.18,23.38 13.82,19.12" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round;"/><polyline points="13.82,11.62 21.18,15.88 24.86,13.75" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round;"/><line x1="21.18" y1="15.88" x2="21.18" y2="23.38" style="fill:none; stroke:#b6b6b6; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/images/canvas_section_hover.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 36 36"><circle cx="17.5" cy="17.5" r="17.5" style="fill:#e5f0ee;"/><polygon points="13.82,11.62 21.18,15.88 21.18,23.38 13.82,19.12" style="fill:#2b3436; fill-opacity:.55;"/><polygon points="8.75,14.55 16.11,18.80 16.11,26.30 8.75,22.05" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="8.75,14.55 12.43,12.43 19.79,16.68 16.11,18.80" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polyline points="19.79,16.68 19.79,24.18 16.11,26.30" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round; stroke-opacity:.45;"/><polygon points="13.82,11.62 17.50,9.50 24.86,13.75 24.86,21.25 21.18,23.38 13.82,19.12" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round;"/><polyline points="13.82,11.62 21.18,15.88 24.86,13.75" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round;"/><line x1="21.18" y1="15.88" x2="21.18" y2="23.38" style="fill:none; stroke:#2b3436; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/shaders/110/gouraud.fs

@@ -63,6 +63,10 @@ uniform float shadow_map_texel;
 
 // LIGHT_TOP_DIR in eye space (matches the diffuse light used for shading in gouraud.vs).
 const vec3 SHADOW_LIGHT_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
+// ORCA: realistic view - static shadows also light the scene from their fixed light.
+uniform bool use_static_light;
+uniform vec3 static_light_dir;
+vec3 top_light_dir() { return use_static_light ? static_light_dir : SHADOW_LIGHT_DIR; }
 
 varying vec3 clipping_planes_dots;
 varying float color_clip_plane_dot;
@@ -155,7 +159,7 @@ float shadow_shade()
     // Slope-scaled depth bias: larger where the surface grazes / faces away from the light. This
     // suppresses self-shadow acne without discarding real shadows cast by other objects onto
     // back-facing surfaces (e.g. the shaded back/tip of a cone sitting inside a larger shadow).
-    float NdotL = dot(normalize(eye_normal), SHADOW_LIGHT_DIR);
+    float NdotL = dot(normalize(eye_normal), top_light_dir());
     float bias = mix(0.0004, 0.004, clamp(1.0 - NdotL, 0.0, 1.0));
     // 5x5 PCF: softens shadow edges into a smooth penumbra and blurs residual facet acne.
     float sum = 0.0;

resources/shaders/110/gouraud.vs

@@ -39,6 +39,10 @@ uniform vec2 z_range;
 uniform vec4 clipping_plane;
 // Color clip plane - general orientation. Used by the cut gizmo.
 uniform vec4 color_clip_plane;
+// ORCA: realistic view - static shadows also light the scene from their fixed light.
+uniform bool use_static_light;
+uniform vec3 static_light_dir;
+vec3 top_light_dir() { return use_static_light ? static_light_dir : LIGHT_TOP_DIR; }
 
 attribute vec3 v_position;
 attribute vec3 v_normal;
@@ -60,11 +64,11 @@ void main()
 
 	// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
 	// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
-	float NdotL = max(dot(eye_normal, LIGHT_TOP_DIR), 0.0);
+	float NdotL = max(dot(eye_normal, top_light_dir()), 0.0);
 
 	intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
     vec4 position = view_model_matrix * vec4(v_position, 1.0);
-    intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(position.xyz), reflect(-LIGHT_TOP_DIR, eye_normal)), 0.0), LIGHT_TOP_SHININESS);
+    intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(position.xyz), reflect(-top_light_dir(), eye_normal)), 0.0), LIGHT_TOP_SHININESS);
 
 	// Perform the same lighting calculation for the 2nd light source (no specular applied).
 	NdotL = max(dot(eye_normal, LIGHT_FRONT_DIR), 0.0);

resources/shaders/110/phong.fs

@@ -70,6 +70,10 @@ uniform sampler2D shadow_map;
 uniform mat4 shadow_light_vp;
 uniform float shadow_intensity;
 uniform float shadow_map_texel;
+// ORCA: realistic view - static shadows also light the scene from their fixed light.
+uniform bool use_static_light;
+uniform vec3 static_light_dir;
+vec3 top_light_dir() { return use_static_light ? static_light_dir : LIGHT_TOP_DIR; }
 
 varying vec3 clipping_planes_dots;
 varying float color_clip_plane_dot;
@@ -193,7 +197,7 @@ float shadow_shade()
     // Slope-scaled depth bias: larger where the surface grazes / faces away from the light. This
     // suppresses self-shadow acne without discarding real shadows cast by other objects onto
     // back-facing surfaces (e.g. the shaded back/tip of a cone sitting inside a larger shadow).
-    float NdotL = dot(normalize(eye_normal), LIGHT_TOP_DIR);
+    float NdotL = dot(normalize(eye_normal), top_light_dir());
     float bias = mix(0.0004, 0.004, clamp(1.0 - NdotL, 0.0, 1.0));
     // 5x5 PCF: softens shadow edges into a smooth penumbra and blurs residual facet acne.
     float sum = 0.0;
@@ -248,9 +252,9 @@ void main()
     vec3 normal = normalize(eye_normal);
     vec3 view_dir = normalize(-eye_position);
 
-    float NdotL_top = max(dot(normal, LIGHT_TOP_DIR), 0.0);
+    float NdotL_top = max(dot(normal, top_light_dir()), 0.0);
     float diffuse = INTENSITY_AMBIENT + NdotL_top * LIGHT_TOP_DIFFUSE;
-    vec3 half_top = normalize(LIGHT_TOP_DIR + view_dir);
+    vec3 half_top = normalize(top_light_dir() + view_dir);
     float specular = LIGHT_TOP_SPECULAR * pow(max(dot(normal, half_top), 0.0), LIGHT_TOP_SHININESS);
 
     float NdotL_front = max(dot(normal, LIGHT_FRONT_DIR), 0.0);

resources/shaders/110/printbed_shadow.fs

@@ -6,6 +6,8 @@ uniform sampler2D shadow_map;
 uniform mat4 shadow_light_vp;
 uniform float shadow_intensity;
 uniform float shadow_map_texel;
+// Plate area a shadow can reach, min xy then max xy; the rest is skipped before any lookup.
+uniform vec4 shadow_bounds;
 
 varying vec4 world_pos;
 
@@ -33,6 +35,8 @@ float shadow_occlusion()
 
 void main()
 {
+    if (any(lessThan(world_pos.xy, shadow_bounds.xy)) || any(greaterThan(world_pos.xy, shadow_bounds.zw)))
+        discard;
     float occ = shadow_occlusion();
     if (occ <= 0.0)
         discard;

resources/shaders/140/gouraud.fs

@@ -72,6 +72,10 @@ uniform float shadow_map_texel;
 
 // LIGHT_TOP_DIR in eye space (matches the diffuse light used for shading in gouraud.vs).
 const vec3 SHADOW_LIGHT_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
+// ORCA: realistic view - static shadows also light the scene from their fixed light.
+uniform bool use_static_light;
+uniform vec3 static_light_dir;
+vec3 top_light_dir() { return use_static_light ? static_light_dir : SHADOW_LIGHT_DIR; }
 
 in vec3 clipping_planes_dots;
 in float color_clip_plane_dot;
@@ -206,7 +210,7 @@ float shadow_shade()
     // Slope-scaled depth bias: larger where the surface grazes / faces away from the light. This
     // suppresses self-shadow acne without discarding real shadows cast by other objects onto
     // back-facing surfaces (e.g. the shaded back/tip of a cone sitting inside a larger shadow).
-    float NdotL = dot(normalize(eye_normal), SHADOW_LIGHT_DIR);
+    float NdotL = dot(normalize(eye_normal), top_light_dir());
     float bias = mix(0.0004, 0.004, clamp(1.0 - NdotL, 0.0, 1.0));
     // 5x5 PCF: softens shadow edges into a smooth penumbra and blurs residual facet acne.
     float sum = 0.0;

resources/shaders/140/gouraud.vs

@@ -39,6 +39,10 @@ uniform vec2 z_range;
 uniform vec4 clipping_plane;
 // Color clip plane - general orientation. Used by the cut gizmo.
 uniform vec4 color_clip_plane;
+// ORCA: realistic view - static shadows also light the scene from their fixed light.
+uniform bool use_static_light;
+uniform vec3 static_light_dir;
+vec3 top_light_dir() { return use_static_light ? static_light_dir : LIGHT_TOP_DIR; }
 
 in vec3 v_position;
 in vec3 v_normal;
@@ -60,11 +64,11 @@ void main()
 
 	// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
 	// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
-	float NdotL = max(dot(eye_normal, LIGHT_TOP_DIR), 0.0);
+	float NdotL = max(dot(eye_normal, top_light_dir()), 0.0);
 
 	intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
     vec4 position = view_model_matrix * vec4(v_position, 1.0);
-    intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(position.xyz), reflect(-LIGHT_TOP_DIR, eye_normal)), 0.0), LIGHT_TOP_SHININESS);
+    intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(position.xyz), reflect(-top_light_dir(), eye_normal)), 0.0), LIGHT_TOP_SHININESS);
 
 	// Perform the same lighting calculation for the 2nd light source (no specular applied).
 	NdotL = max(dot(eye_normal, LIGHT_FRONT_DIR), 0.0);

resources/shaders/140/phong.fs

@@ -80,6 +80,10 @@ uniform sampler2D shadow_map;
 uniform mat4 shadow_light_vp;
 uniform float shadow_intensity;
 uniform float shadow_map_texel;
+// ORCA: realistic view - static shadows also light the scene from their fixed light.
+uniform bool use_static_light;
+uniform vec3 static_light_dir;
+vec3 top_light_dir() { return use_static_light ? static_light_dir : LIGHT_TOP_DIR; }
 
 in vec3 clipping_planes_dots;
 in float color_clip_plane_dot;
@@ -250,7 +254,7 @@ float shadow_shade()
     // Slope-scaled depth bias: larger where the surface grazes / faces away from the light. This
     // suppresses self-shadow acne without discarding real shadows cast by other objects onto
     // back-facing surfaces (e.g. the shaded back/tip of a cone sitting inside a larger shadow).
-    float NdotL = dot(normalize(eye_normal), LIGHT_TOP_DIR);
+    float NdotL = dot(normalize(eye_normal), top_light_dir());
     float bias = mix(0.0004, 0.004, clamp(1.0 - NdotL, 0.0, 1.0));
     // 5x5 PCF: softens shadow edges into a smooth penumbra and blurs residual facet acne.
     float sum = 0.0;
@@ -305,9 +309,9 @@ void main()
     vec3 normal = normalize(eye_normal);
     vec3 view_dir = normalize(-eye_position);
 
-    float NdotL_top = max(dot(normal, LIGHT_TOP_DIR), 0.0);
+    float NdotL_top = max(dot(normal, top_light_dir()), 0.0);
     float diffuse = INTENSITY_AMBIENT + NdotL_top * LIGHT_TOP_DIFFUSE;
-    vec3 half_top = normalize(LIGHT_TOP_DIR + view_dir);
+    vec3 half_top = normalize(top_light_dir() + view_dir);
     float specular = LIGHT_TOP_SPECULAR * pow(max(dot(normal, half_top), 0.0), LIGHT_TOP_SHININESS);
 
     float NdotL_front = max(dot(normal, LIGHT_FRONT_DIR), 0.0);

resources/shaders/140/printbed_shadow.fs

@@ -6,6 +6,8 @@ uniform sampler2D shadow_map;
 uniform mat4 shadow_light_vp;
 uniform float shadow_intensity;
 uniform float shadow_map_texel;
+// Plate area a shadow can reach, min xy then max xy; the rest is skipped before any lookup.
+uniform vec4 shadow_bounds;
 
 in vec4 world_pos;
 
@@ -35,6 +37,8 @@ float shadow_occlusion()
 
 void main()
 {
+    if (any(lessThan(world_pos.xy, shadow_bounds.xy)) || any(greaterThan(world_pos.xy, shadow_bounds.zw)))
+        discard;
     float occ = shadow_occlusion();
     if (occ <= 0.0)
         discard;

src/libslic3r/AABBMesh.cpp

@@ -1,19 +1,10 @@
 #include "AABBMesh.hpp"
-#include "Point.hpp"
-#include <Eigen/Core>
 #include <Execution/ExecutionTBB.hpp>
 
-#include <igl/Hit.h>
-#include <cstddef>
-#include <cassert>
-#include <cmath>
-#include <algorithm>
 #include <libslic3r/AABBTreeIndirect.hpp>
 #include <libslic3r/TriangleMesh.hpp>
 
-#include <limits>
 #include <numeric>
-#include <vector>
 
 #ifdef SLIC3R_HOLE_RAYCASTER
 #include <libslic3r/SLA/Hollowing.hpp>

src/libslic3r/AABBMesh.hpp

@@ -1,10 +1,6 @@
 #ifndef PRUSASLICER_AABBMESH_H
 #define PRUSASLICER_AABBMESH_H
 
-#include <cstddef>
-#include <limits>
-#include <cmath>
-#include <cassert>
 #include <memory>
 #include <vector>
 

src/libslic3r/AABBTreeIndirect.hpp

@@ -6,20 +6,15 @@
 #ifndef slic3r_AABBTreeIndirect_hpp_
 #define slic3r_AABBTreeIndirect_hpp_
 
-#include <Eigen/Core>
 #include <algorithm>
-#include <cstddef>
-#include <cassert>
 #include <limits>
 #include <type_traits>
-#include <utility>
 #include <vector>
 
 #include <Eigen/Geometry>
 
 #include "BoundingBox.hpp"
 #include "Utils.hpp" // for next_highest_power_of_2()
-#include "libslic3r.h"
 
 // Definition of the ray intersection hit structure.
 #include <igl/Hit.h>

src/libslic3r/AABBTreeLines.hpp

@@ -6,15 +6,9 @@
 #include "libslic3r.h"
 #include "libslic3r/AABBTreeIndirect.hpp"
 #include "libslic3r/Line.hpp"
-#include <Eigen/Core>
 #include <algorithm>
-#include <cassert>
 #include <cmath>
-#include <cstddef>
-#include <tuple>
-#include <limits>
 #include <type_traits>
-#include <utility>
 #include <vector>
 
 namespace Slic3r {

src/libslic3r/AStar.hpp

@@ -1,11 +1,7 @@
 #ifndef ASTAR_HPP
 #define ASTAR_HPP
 
-#include <cassert>
 #include <cmath> // std::isinf() is here
-#include <type_traits>
-#include <cstddef>
-#include <limits>
 #include <unordered_map>
 
 #include "libslic3r/MutablePriorityQueue.hpp"

src/libslic3r/Algorithm/LineSplit.cpp

@@ -1,19 +1,8 @@
 #include "LineSplit.hpp"
 
 #include "AABBTreeLines.hpp"
-#include "libslic3r/ClipperZUtils.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/Line.hpp"
-#include "libslic3r/ExPolygon.hpp"
 #include "SVG.hpp"
 #include "Utils.hpp"
-#include <limits>
-#include "libslic3r/libslic3r.h"
-#include <algorithm>
-#include <cstddef>
-#include <cassert>
-#include <vector>
-#include <utility>
 
 //#define DEBUG_SPLIT_LINE
 
@@ -25,7 +14,7 @@ static std::atomic<std::uint32_t> g_dbg_id = 0;
 #endif
 
 // Z for points from clip polygon
-static constexpr auto CLIP_IDX = std::numeric_limits<ClipperLib_Z::cInt>::max();
+static constexpr auto CLIP_IDX = std::numeric_limits<coord_t>::max();
 
 static void cb_split_line(const ClipperZUtils::ZPoint& e1bot,
                    const ClipperZUtils::ZPoint& e1top,
@@ -102,14 +91,7 @@ SplittedLine do_split_line(const ClipperZUtils::ZPath& path, const ExPolygons& c
                 clip_path.emplace_back(ClipperZUtils::to_zpath<false>(hole.points, CLIP_IDX));
         }
 
-        ClipperLib_Z::Clipper zclipper;
-        zclipper.PreserveCollinear(true);
-        zclipper.ZFillFunction(cb_split_line);
-        zclipper.AddPaths(clip_path, ClipperLib_Z::ptClip, true);
-        zclipper.AddPath(path, ClipperLib_Z::ptSubject, false);
-        ClipperLib_Z::PolyTree polytree;
-        zclipper.Execute(ClipperLib_Z::ctIntersection, polytree, ClipperLib_Z::pftNonZero, ClipperLib_Z::pftNonZero);
-        ClipperLib_Z::PolyTreeToPaths(std::move(polytree), intersections);
+        intersections = ClipperZUtils::clip_zpaths(ctIntersection, ClipperZUtils::ZPaths{ path }, true, clip_path, cb_split_line, true);
     }
     if (intersections.empty()) {
         return {};

src/libslic3r/Algorithm/LineSplit.hpp

@@ -2,11 +2,6 @@
 #define SRC_LIBSLIC3R_ALGORITHM_LINE_SPLIT_HPP_
 
 #include "ClipperZUtils.hpp"
-#include "libslic3r/Point.hpp"
-#include <cstdint>
-#include <cstddef>
-#include <vector>
-#include "libslic3r/ExPolygon.hpp"
 
 namespace Slic3r {
 namespace Algorithm {
@@ -55,7 +50,7 @@ SplittedLine split_line(const PathType& path, const ExPolygons& clip, bool close
     // Convert the input path into an open ZPath
     ClipperZUtils::ZPath p;
     p.reserve(path.size() + (closed ? 1 : 0));
-    ClipperLib_Z::cInt z = 0;
+    coord_t z = 0;
     for (const auto& point : path) {
         p.emplace_back(point.x(), point.y(), z);
         z++;

src/libslic3r/Algorithm/RegionExpansion.cpp

@@ -1,30 +1,16 @@
 #include "RegionExpansion.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/ExPolygon.hpp"
-#include "libslic3r/libslic3r.h"
-#include "libslic3r/Polyline.hpp"
-#include "libslic3r/Polygon.hpp"
 
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include <cassert>
-#include <iterator>
-#include <cstdint>
 #include <libslic3r/AABBTreeIndirect.hpp>
 #include <libslic3r/ClipperZUtils.hpp>
 #include <libslic3r/ClipperUtils.hpp>
 #include <libslic3r/Utils.hpp>
 
-#include <math.h>
 #include <numeric>
-#include <vector>
-#include <utility>
 
 namespace Slic3r {
 namespace Algorithm {
 
-// Calculating radius discretization according to ClipperLib offsetter code, see void ClipperOffset::DoOffset(double delta)
+// Calculating radius discretization according to the Clipper offsetter code, see ClipperOffset::DoGroupOffset()
 inline double clipper_round_offset_error(double offset, double arc_tolerance)
 {
     static constexpr const double def_arc_tolerance = 0.25;
@@ -75,7 +61,6 @@ RegionExpansionParameters RegionExpansionParameters::build(
 
     // Accuracy of the offsetter for wave propagation.
     out.arc_tolerance        = scaled<double>(0.1);
-    out.shortest_edge_length = out.initial_step * ClipperOffsetShortestEdgeFactor;
 
     // Maximum inflation of seed contours over the boundary. Used to trim boundary to speed up
     // clipping during wave propagation. Needs to be in sync with the offsetter accuracy.
@@ -89,25 +74,20 @@ RegionExpansionParameters RegionExpansionParameters::build(
 
 // similar to expolygons_to_zpaths(), but each contour is expanded before converted to zpath.
 // The expanded contours are then opened (the first point is repeated at the end).
-static ClipperLib_Z::Paths expolygons_to_zpaths_expanded_opened(
+static ClipperZUtils::ZPaths expolygons_to_zpaths_expanded_opened(
     const ExPolygons &src, const float expansion, coord_t &base_idx)
 {
-    ClipperLib_Z::Paths out;
+    ClipperZUtils::ZPaths out;
     out.reserve(2 * std::accumulate(src.begin(), src.end(), size_t(0),
         [](const size_t acc, const ExPolygon &expoly) { return acc + expoly.num_contours(); }));
-    ClipperLib::ClipperOffset offsetter;
-    offsetter.ShortestEdgeLength = expansion * ClipperOffsetShortestEdgeFactor;
-    ClipperLib::Paths expansion_cache;
     for (const ExPolygon &expoly : src) {
         for (size_t icontour = 0; icontour < expoly.num_contours(); ++ icontour) {
-            // Execute reorients the contours so that the outer most contour has a positive area. Thus the output
-            // contours will be CCW oriented even though the input paths are CW oriented.
-            // Offset is applied after contour reorientation, thus the signum of the offset value is reversed.
-            offsetter.Clear();
-            offsetter.AddPath(expoly.contour_or_hole(icontour).points, ClipperLib::jtSquare, ClipperLib::etClosedPolygon);
-            expansion_cache.clear();
-            offsetter.Execute(expansion_cache, icontour == 0 ? expansion : -expansion);
-            append(out, ClipperZUtils::to_zpaths<true>(expansion_cache, base_idx));
+            // Orient CCW, then grow the contour and shrink the holes. The output contours are CCW.
+            Polygon contour = expoly.contour_or_hole(icontour);
+            if (! contour.is_counter_clockwise())
+                contour.reverse();
+            for (const Polygon &expanded : offset(contour, icontour == 0 ? expansion : -expansion, jtSquare))
+                out.emplace_back(ClipperZUtils::to_zpath<true>(expanded.points, base_idx));
         }
         ++ base_idx;
     }
@@ -118,21 +98,21 @@ static ClipperLib_Z::Paths expolygons_to_zpaths_expanded_opened(
 // Thus some pieces of the clipped polygons may now become split at the ends of the source polygons.
 // Those ends are sorted lexicographically in "splits".
 // Reconnect those split pieces.
-static inline void merge_splits(ClipperLib_Z::Paths &paths, std::vector<std::pair<ClipperLib_Z::IntPoint, int>> &splits)
+static inline void merge_splits(ClipperZUtils::ZPaths &paths, std::vector<std::pair<ClipperZUtils::ZPoint, int>> &splits)
 {
     for (auto it_path = paths.begin(); it_path != paths.end(); ) {
-        ClipperLib_Z::Path &path = *it_path;
+        ClipperZUtils::ZPath &path = *it_path;
         assert(path.size() >= 2);
         bool merged = false;
         if (path.size() >= 2) {
-            const ClipperLib_Z::IntPoint &front = path.front();
-            const ClipperLib_Z::IntPoint &back  = path.back();
+            const ClipperZUtils::ZPoint &front = path.front();
+            const ClipperZUtils::ZPoint &back  = path.back();
             // The path before clipping was supposed to cross the clipping boundary or be fully out of it.
             // Thus the clipped contour is supposed to become open, with one exception: The anchor expands into a closed hole.
             if (front.x() != back.x() || front.y() != back.y()) {
                 // Look up the ends in "splits", possibly join the contours.
                 // "splits" maps into the other piece connected to the same end point.
-                auto find_end = [&splits](const ClipperLib_Z::IntPoint &pt) -> std::pair<ClipperLib_Z::IntPoint, int>* {
+                auto find_end = [&splits](const ClipperZUtils::ZPoint &pt) -> std::pair<ClipperZUtils::ZPoint, int>* {
                     auto it = std::lower_bound(splits.begin(), splits.end(), pt,
                         [](const auto &l, const auto &r){ return ClipperZUtils::zpoint_lower(l.first, r); });
                     return it != splits.end() && it->first == pt ? &(*it) : nullptr;
@@ -150,7 +130,7 @@ static inline void merge_splits(ClipperLib_Z::Paths &paths, std::vector<std::pai
                         end->second = int(it_path - paths.begin());
                     } else {
                         // Open end was found and matched with end->second
-                        ClipperLib_Z::Path &other_path = paths[end->second];
+                        ClipperZUtils::ZPath &other_path = paths[end->second];
                         polylines_merge(other_path, other_path.front() == end->first, std::move(path), end_front);
                         if (std::next(it_path) == paths.end()) {
                             paths.pop_back();
@@ -226,7 +206,7 @@ std::vector<WaveSeed> wave_seeds(
     using Intersection  = ClipperZUtils::ClipperZIntersectionVisitor::Intersection;
     using Intersections = ClipperZUtils::ClipperZIntersectionVisitor::Intersections;
 
-    ClipperLib_Z::Paths segments;
+    ClipperZUtils::ZPaths segments;
     Intersections         intersections;
 
     coord_t               idx_boundary_begin = 1;
@@ -234,28 +214,21 @@ std::vector<WaveSeed> wave_seeds(
     coord_t               idx_src_end;
 
     {
-        ClipperLib_Z::Clipper zclipper;
         ClipperZUtils::ClipperZIntersectionVisitor visitor(intersections);
-        zclipper.ZFillFunction(visitor.clipper_callback());
         // as closed contours
-        zclipper.AddPaths(ClipperZUtils::expolygons_to_zpaths(boundary, idx_boundary_end), ClipperLib_Z::ptClip, true);
+        ClipperZUtils::ZPaths zboundary = ClipperZUtils::expolygons_to_zpaths(boundary, idx_boundary_end);
         // as open contours
-        std::vector<std::pair<ClipperLib_Z::IntPoint, int>> zsrc_splits;
-        {
+        std::vector<std::pair<ClipperZUtils::ZPoint, int>> zsrc_splits;
         idx_src_end = idx_boundary_end;
-            ClipperLib_Z::Paths zsrc = expolygons_to_zpaths_expanded_opened(src, tiny_expansion, idx_src_end);
-            zclipper.AddPaths(zsrc, ClipperLib_Z::ptSubject, false);
+        ClipperZUtils::ZPaths zsrc = expolygons_to_zpaths_expanded_opened(src, tiny_expansion, idx_src_end);
         zsrc_splits.reserve(zsrc.size());
-            for (const ClipperLib_Z::Path &path : zsrc) {
+        for (const ClipperZUtils::ZPath &path : zsrc) {
             assert(path.size() >= 2);
             assert(path.front() == path.back());
             zsrc_splits.emplace_back(path.front(), -1);
         }
         std::sort(zsrc_splits.begin(), zsrc_splits.end(), [](const auto &l, const auto &r){ return ClipperZUtils::zpoint_lower(l.first, r.first); });
-        }
-        ClipperLib_Z::PolyTree polytree;
-        zclipper.Execute(ClipperLib_Z::ctIntersection, polytree, ClipperLib_Z::pftNonZero, ClipperLib_Z::pftNonZero);
-        ClipperLib_Z::PolyTreeToPaths(std::move(polytree), segments);
+        segments = ClipperZUtils::clip_zpaths(ctIntersection, zsrc, true, zboundary, visitor.clipper_callback());
         merge_splits(segments, zsrc_splits);
     }
 
@@ -270,10 +243,10 @@ std::vector<WaveSeed> wave_seeds(
     WaveSeeds out;
     out.reserve(segments.size());
     int iseed = 0;
-    for (const ClipperLib_Z::Path &path : segments) {
+    for (const ClipperZUtils::ZPath &path : segments) {
         assert(path.size() >= 2);
-        ClipperLib_Z::IntPoint front = path.front();
-        ClipperLib_Z::IntPoint back  = path.back();
+        ClipperZUtils::ZPoint front = path.front();
+        ClipperZUtils::ZPoint back  = path.back();
         // Both ends of a seed segment are supposed to be inside a single boundary expolygon.
         // Thus as long as the seed contour is not closed, it should be open at a boundary point.
         assert((front == back && front.z() >= idx_boundary_end && front.z() < idx_src_end) || 
@@ -294,7 +267,7 @@ std::vector<WaveSeed> wave_seeds(
             // boundary ID is not directly available).
             coord_t src_z = -1, boundary_z = -1;
             // Scan all path points for the information we need.
-            for (const ClipperLib_Z::IntPoint &point : path) {
+            for (const ClipperZUtils::ZPoint &point : path) {
                 if (point.z() >= idx_boundary_end && point.z() < idx_src_end && src_z < 0)
                     src_z = point.z();
                 else if (point.z() >= idx_boundary_begin && point.z() < idx_boundary_end && boundary_z < 0)
@@ -325,7 +298,7 @@ std::vector<WaveSeed> wave_seeds(
             // See https://github.com/prusa3d/PrusaSlicer/issues/12469.
             // Segement is open, yet its first point seems to be part of boundary polygon.
             // Take the first point with src polygon index.
-            for (const ClipperLib_Z::IntPoint &point : path) {
+            for (const ClipperZUtils::ZPoint &point : path) {
                 if (point.z() >= idx_boundary_end) {
                     front = point;
                     back = point;
@@ -374,17 +347,13 @@ std::vector<WaveSeed> wave_seeds(
     return out;
 }
 
-static ClipperLib::Paths wavefront_initial(ClipperLib::ClipperOffset &co, const ClipperLib::Paths &polylines, float offset)
+static Polygons wavefront_initial(const VecOfPoints &polylines, float offset, double arc_tolerance)
 {
-    ClipperLib::Paths out;
+    Polygons out;
     out.reserve(polylines.size());
-    ClipperLib::Paths out_this;
-    for (const ClipperLib::Path &path : polylines) {
+    for (const Points &path : polylines) {
         assert(path.size() >= 2);
-        co.Clear();
-        co.AddPath(path, jtRound, path.front() == path.back() ? ClipperLib::etClosedLine : ClipperLib::etOpenRound);
-        co.Execute(out_this, offset);
-        append(out, std::move(out_this));
+        append(out, Slic3r::offset(Polyline(path), offset, jtRound, arc_tolerance, path.front() == path.back() ? etClosedLine : etOpenRound));
     }
     return out;
 }
@@ -392,43 +361,24 @@ static ClipperLib::Paths wavefront_initial(ClipperLib::ClipperOffset &co, const
 // Input polygons may consist of multiple expolygons, even nested expolygons.
 // After inflation some polygons may thus overlap, however the overlap is being resolved during the successive
 // clipping operation, thus it is not being done here.
-static ClipperLib::Paths wavefront_step(ClipperLib::ClipperOffset &co, const ClipperLib::Paths &polygons, float offset)
+static Polygons wavefront_step(const Polygons &polygons, float offset, double arc_tolerance)
 {
-    ClipperLib::Paths out;
+    Polygons out;
     out.reserve(polygons.size());
-    ClipperLib::Paths out_this;
-    for (const ClipperLib::Path &polygon : polygons) {
-        co.Clear();
-        // Execute reorients the contours so that the outer most contour has a positive area. Thus the output
-        // contours will be CCW oriented even though the input paths are CW oriented.
-        // Offset is applied after contour reorientation, thus the signum of the offset value is reversed.
-        co.AddPath(polygon, jtRound, ClipperLib::etClosedPolygon);
-        bool ccw = ClipperLib::Orientation(polygon);
-        co.Execute(out_this, ccw ? offset : - offset);
-        if (! ccw) {
-            // Reverse the resulting contours.
-            for (ClipperLib::Path &path : out_this)
-                std::reverse(path.begin(), path.end());
-        }
-        append(out, std::move(out_this));
-    }
+    for (const Polygon &polygon : polygons)
+        // CCW contours grow, CW holes shrink.
+        append(out, Slic3r::offset(polygon, offset, jtRound, arc_tolerance));
     return out;
 }
 
-static ClipperLib::Paths wavefront_clip(const ClipperLib::Paths &wavefront, const Polygons &clipping)
+static Polygons wavefront_clip(const Polygons &wavefront, const Polygons &clipping)
 {
-    ClipperLib::Clipper clipper;
-    clipper.AddPaths(wavefront, ClipperLib::ptSubject, true);
-    clipper.AddPaths(ClipperUtils::PolygonsProvider(clipping),  ClipperLib::ptClip, true);
-    ClipperLib::Paths out;
-    clipper.Execute(ClipperLib::ctIntersection, out, ClipperLib::pftPositive, ClipperLib::pftPositive);
-    return out;
+    return intersection(wavefront, clipping, pftPositive);
 }
 
 static Polygons propagate_wave_from_boundary(
-    ClipperLib::ClipperOffset   &co,
     // Seed of the wave: Open polylines very close to the boundary.
-    const ClipperLib::Paths     &seed,
+    const VecOfPoints           &seed,
     // Boundary inside which the waveform will propagate.
     const ExPolygon             &boundary,
     // How much to inflate the seed lines to produce the first wave area.
@@ -439,25 +389,24 @@ static Polygons propagate_wave_from_boundary(
     const size_t                 num_other_steps,
     // Maximum inflation of seed contours over the boundary. Used to trim boundary to speed up
     // clipping during wave propagation.
-    const float                  max_inflation)
+    const float                  max_inflation,
+    // Accuracy of the round offsets.
+    const double                 arc_tolerance)
 {
     assert(! seed.empty() && seed.front().size() >= 2);
     Polygons clipping = ClipperUtils::clip_clipper_polygons_with_subject_bbox(boundary, get_extents<true>(seed).inflated(max_inflation));
-    ClipperLib::Paths polygons = wavefront_clip(wavefront_initial(co, seed, initial_step), clipping);
+    Polygons polygons = wavefront_clip(wavefront_initial(seed, initial_step, arc_tolerance), clipping);
     // Now offset the remaining 
     for (size_t ioffset = 0; ioffset < num_other_steps; ++ ioffset)
-        polygons = wavefront_clip(wavefront_step(co, polygons, other_step), clipping);
-    return to_polygons(polygons);
+        polygons = wavefront_clip(wavefront_step(polygons, other_step, arc_tolerance), clipping);
+    return polygons;
 }
 
 // Resulting regions are sorted by boundary id and source id.
 std::vector<RegionExpansion> propagate_waves(const WaveSeeds &seeds, const ExPolygons &boundary, const RegionExpansionParameters &params)
 {
     std::vector<RegionExpansion> out;
-    ClipperLib::Paths            paths;
-    ClipperLib::ClipperOffset co;
-    co.ArcTolerance       = params.arc_tolerance;
-    co.ShortestEdgeLength = params.shortest_edge_length;
+    VecOfPoints                  paths;
     for (auto it_seed = seeds.begin(); it_seed != seeds.end();) {
         auto it = it_seed;
         paths.clear();
@@ -466,7 +415,7 @@ std::vector<RegionExpansion> propagate_waves(const WaveSeeds &seeds, const ExPol
         // Propagate the wavefront while clipping it with the trimmed boundary.
         // Collect the expanded polygons, merge them with the source polygons.
         RegionExpansion re;
-        for (Polygon &polygon : propagate_wave_from_boundary(co, paths, boundary[it_seed->boundary], params.initial_step, params.other_step, params.num_other_steps, params.max_inflation))
+        for (Polygon &polygon : propagate_wave_from_boundary(paths, boundary[it_seed->boundary], params.initial_step, params.other_step, params.num_other_steps, params.max_inflation, params.arc_tolerance))
             out.push_back({ std::move(polygon), it_seed->src, it_seed->boundary });
         it_seed = it;
     }

src/libslic3r/Algorithm/RegionExpansion.hpp

@@ -1,12 +1,10 @@
 #ifndef SRC_LIBSLIC3R_ALGORITHM_REGION_EXPANSION_HPP_
 #define SRC_LIBSLIC3R_ALGORITHM_REGION_EXPANSION_HPP_
 
-#include <cstddef>
 #include <cstdint>
 #include <libslic3r/Point.hpp>
 #include <libslic3r/Polygon.hpp>
 #include <libslic3r/ExPolygon.hpp>
-#include <vector>
 
 namespace Slic3r {
 namespace Algorithm {
@@ -27,7 +25,6 @@ struct RegionExpansionParameters
 
     // Accuracy of the offsetter for wave propagation.
     double                 arc_tolerance;
-    double                 shortest_edge_length;
 
     static RegionExpansionParameters build(
         // Scaled expansion value

src/libslic3r/AnyPtr.hpp

@@ -1,7 +1,6 @@
 #ifndef ANYPTR_HPP
 #define ANYPTR_HPP
 
-#include <boost/variant/variant.hpp>
 #include <memory>
 #include <type_traits>
 #include <boost/variant.hpp>

src/libslic3r/AppConfig.cpp

@@ -1,8 +1,3 @@
-#include "Technologies.hpp"
-#include "Config.hpp"
-#include "PrintConfig.hpp"
-#include "calib.hpp"
-#include "Semver.hpp"
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/Format/DRC.hpp"
@@ -14,18 +9,9 @@
 #include "LocalesUtils.hpp"
 #include "Thread.hpp"
 #include "format.hpp"
-#include "libslic3r_version.h"
 #include "nlohmann/json.hpp"
 
 #include <algorithm>
-#include <string>
-#include <exception>
-#include <boost/none.hpp>
-#include <cstddef>
-#include <system_error>
-#include <chrono>
-#include <map>
-#include <cstring>
 #include <utility>
 #include <vector>
 #include <stdexcept>
@@ -318,6 +304,9 @@ void AppConfig::set_defaults()
     if (get(SETTING_OPENGL_SHOW_FPS_OVERLAY).empty())
         set_bool(SETTING_OPENGL_SHOW_FPS_OVERLAY, false);
 
+    if (get(SETTING_OPENGL_SHOW_RENDER_TIMINGS).empty())
+        set_bool(SETTING_OPENGL_SHOW_RENDER_TIMINGS, false);
+
     if (get(SETTING_OPENGL_REALISTIC_MODE).empty())
         set_bool(SETTING_OPENGL_REALISTIC_MODE, false);
 
@@ -330,8 +319,9 @@ void AppConfig::set_defaults()
     if (get(SETTING_OPENGL_SHADING_MODEL).empty())
         set(SETTING_OPENGL_SHADING_MODEL, "gouraud");
 
-    if (get(SETTING_OPENGL_PHONG_BASIC_PLATE_SHADOWS).empty())
-        set_bool(SETTING_OPENGL_PHONG_BASIC_PLATE_SHADOWS, false);
+    // Replaces the on/off setting, whose shadows turned with the camera.
+    if (get(SETTING_OPENGL_REALISTIC_SHADOWS).empty())
+        set(SETTING_OPENGL_REALISTIC_SHADOWS, get_bool(SETTING_OPENGL_PHONG_BASIC_PLATE_SHADOWS) ? "orbit" : "off");
 
     if (get(SETTING_OPENGL_PHONG_SMOOTH_NORMALS).empty())
         set_bool(SETTING_OPENGL_PHONG_SMOOTH_NORMALS, false);

src/libslic3r/AppConfig.hpp

@@ -5,11 +5,8 @@
 #include <chrono>
 #include <map>
 #include <string>
-#include "LocalesUtils.hpp"
 #include "nlohmann/json.hpp"
 #include <boost/algorithm/string/trim_all.hpp>
-#include <utility>
-#include <vector>
 
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Semver.hpp"
@@ -40,10 +37,13 @@ using namespace nlohmann;
 #define SETTING_OPENGL_SCENE_CACHE "opengl_scene_cache"
 #define SETTING_OPENGL_SKIP_IDENTICAL_FRAMES "opengl_skip_identical_frames"
 #define SETTING_OPENGL_SHOW_FPS_OVERLAY "opengl_show_fps_overlay"
+#define SETTING_OPENGL_SHOW_RENDER_TIMINGS "opengl_show_render_timings"
 #define SETTING_OPENGL_REALISTIC_MODE "opengl_realistic_mode"
 #define SETTING_OPENGL_REALISTIC_PHONG "opengl_realistic_phong"
 #define SETTING_OPENGL_SHADING_MODEL "opengl_shading_model"
 #define SETTING_OPENGL_PHONG_BASIC_PLATE_SHADOWS "opengl_phong_basic_plate_shadows"
+// off, static (light fixed in the world) or orbit (light turning with the camera)
+#define SETTING_OPENGL_REALISTIC_SHADOWS "opengl_realistic_shadows"
 #define SETTING_OPENGL_PHONG_SSAO "opengl_phong_ssao"
 #define SETTING_OPENGL_PHONG_SMOOTH_NORMALS "opengl_phong_smooth_normals"
 #define SETTING_OPENGL_REALISTIC_PREVIEW "opengl_realistic_preview"

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.cpp

@@ -2,9 +2,7 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include "BeadingStrategy.hpp"
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Point.hpp"
-#include <vector>
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.cpp

@@ -12,7 +12,6 @@
 #include "DistributedBeadingStrategy.hpp"
 #include "RedistributeBeadingStrategy.hpp"
 #include "OuterWallInsetBeadingStrategy.hpp"
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne {

src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.cpp

@@ -6,7 +6,6 @@
 #include <cassert>
 
 #include "DistributedBeadingStrategy.hpp"
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.cpp

@@ -3,12 +3,10 @@
 
 #include <boost/log/trivial.hpp>
 #include <cassert>
-#include <string>
 #include <utility>
 #include <cstddef>
 
 #include "LimitedBeadingStrategy.hpp"
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 

src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.cpp

@@ -6,7 +6,6 @@
 #include <algorithm>
 #include <utility>
 
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.cpp

@@ -7,7 +7,6 @@
 #include <numeric>
 #include <utility>
 
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.cpp

@@ -4,11 +4,8 @@
 #include "WideningBeadingStrategy.hpp"
 
 #include <algorithm>
-#include <string>
 #include <utility>
-#include <vector>
 
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/SkeletalTrapezoidation.cpp

@@ -10,18 +10,10 @@
 #include <cmath>
 #include <cstdint>
 #include <limits>
-#include <math.h>
-#include <list>
-#include <memory>
 #include <utility>
 #include <cassert>
 #include <cstdlib>
-#include <vector>
 
-#include "libslic3r/Point.hpp"
-#include "libslic3r/libslic3r.h"
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 #include "libslic3r/Geometry/VoronoiUtils.hpp"
 #include "ankerl/unordered_dense.h"
 #include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"

src/libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp

@@ -4,12 +4,10 @@
 #ifndef SKELETAL_TRAPEZOIDATION_EDGE_H
 #define SKELETAL_TRAPEZOIDATION_EDGE_H
 
-#include <cassert>
 #include <memory> // smart pointers
 #include <list>
 #include <vector>
 
-#include "libslic3r/libslic3r.h"
 #include "utils/ExtrusionJunction.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/SkeletalTrapezoidationGraph.cpp

@@ -6,17 +6,11 @@
 #include <ankerl/unordered_dense.h>
 #include <boost/log/trivial.hpp>
 #include <algorithm>
-#include <cstdint>
 #include <iostream>
 #include <cassert>
 #include <cinttypes>
-#include <optional>
-#include <utility>
 
 #include "../Line.hpp"
-#include "libslic3r/Arachne/utils/HalfEdge.hpp"
-#include "libslic3r/libslic3r.h"
-#include "libslic3r/Arachne/utils/HalfEdgeNode.hpp"
 #include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"
 #include "libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp"
 #include "libslic3r/Point.hpp"

src/libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp

@@ -6,7 +6,6 @@
 
 #include <memory> // smart pointers
 
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/WallToolPaths.cpp

@@ -2,31 +2,12 @@
 // CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include <algorithm> //For std::partition_copy and std::min_element.
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <cassert>
-#include <cmath>
-#include <math.h>
-#include <limits>
 #include <unordered_set>
 
 #include "WallToolPaths.hpp"
 
-#include "libslic3r/PrintConfig.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
-#include "libslic3r/Line.hpp"
-#include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
-#include "libslic3r/Flow.hpp"
-#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp"
-#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
-#include "libslic3r/Arachne/utils/SparsePointGrid.hpp"
-#include "libslic3r/Arachne/utils/SquareGrid.hpp"
 #include "SkeletalTrapezoidation.hpp"
 #include "../ClipperUtils.hpp"
-#include "libslic3r/libslic3r.h"
 #include "utils/linearAlg2D.hpp"
 #include "EdgeGrid.hpp"
 #include "utils/SparseLineGrid.hpp"
@@ -36,8 +17,6 @@
 #include "Utils.hpp"
 
 #include <boost/log/trivial.hpp>
-#include <utility>
-#include <vector>
 
 //#define ARACHNE_STITCH_PATCH_DEBUG
 
@@ -284,10 +263,8 @@ std::unique_ptr<LocToLineGrid>                                               cre
  */
 void fixSelfIntersections(const coord_t epsilon, Polygons &thiss)
 {
-    if (epsilon < 1) {
-        ClipperLib::SimplifyPolygons(ClipperUtils::PolygonsProvider(thiss), ClipperLib::pftEvenOdd);
+    if (epsilon < 1)
         return;
-    }
 
     const int64_t half_epsilon = (epsilon + 1) / 2;
 
@@ -325,8 +302,6 @@ void fixSelfIntersections(const coord_t epsilon, Polygons &thiss)
             }
         }
     }
-
-    ClipperLib::SimplifyPolygons(ClipperUtils::PolygonsProvider(thiss), ClipperLib::pftEvenOdd);
 }
 
 /*!
@@ -373,18 +348,11 @@ void removeDegenerateVerts(Polygons &thiss)
 
 void removeSmallAreas(Polygons &thiss, const double min_area_size, const bool remove_holes)
 {
-    auto to_path = [](const Polygon &poly) -> ClipperLib::Path {
-        ClipperLib::Path out;
-        for (const Point &pt : poly.points)
-            out.emplace_back(ClipperLib::cInt(pt.x()), ClipperLib::cInt(pt.y()));
-        return out;
-    };
-
     auto new_end = thiss.end();
     if (remove_holes) {
         for (auto it = thiss.begin(); it < new_end;) {
             // All polygons smaller than target are removed by replacing them with a polygon from the back of the vector.
-            if (fabs(ClipperLib::Area(to_path(*it))) < min_area_size) {
+            if (fabs(it->area()) < min_area_size) {
                 --new_end;
                 *it = std::move(*new_end);
                 continue; // Don't increment the iterator such that the polygon just swapped in is checked next.
@@ -395,7 +363,7 @@ void removeSmallAreas(Polygons &thiss, const double min_area_size, const bool re
         // For each polygon, computes the signed area, move small outlines at the end of the vector and keep pointer on small holes
         Polygons small_holes;
         for (auto it = thiss.begin(); it < new_end;) {
-            if (double area = ClipperLib::Area(to_path(*it)); fabs(area) < min_area_size) {
+            if (double area = it->area(); fabs(area) < min_area_size) {
                 if (area >= 0) {
                     --new_end;
                     if (it < new_end) {
@@ -794,7 +762,7 @@ void WallToolPaths::separateOutInnerContour()
     //To get a correct shape, we need to make the outside contour positive and any holes inside negative.
     //This can be done by applying the even-odd rule to the shape. This rule is not sensitive to the winding order of the polygon.
     //The even-odd rule would be incorrect if the polygon self-intersects, but that should never be generated by the skeletal trapezoidation.
-    inner_contour = union_(inner_contour, ClipperLib::PolyFillType::pftEvenOdd);
+    inner_contour = union_(inner_contour, pftEvenOdd);
 }
 
 const Polygons& WallToolPaths::getInnerContour()

src/libslic3r/Arachne/WallToolPaths.hpp

@@ -4,16 +4,10 @@
 #ifndef CURAENGINE_WALLTOOLPATHS_H
 #define CURAENGINE_WALLTOOLPATHS_H
 
-#include <cstddef>
-#include <boost/container_hash/hash.hpp>
 #include <memory>
 #include <ankerl/unordered_dense.h>
-#include <vector>
-#include <utility>
 
 #include "BeadingStrategy/BeadingStrategyFactory.hpp"
-#include "libslic3r/libslic3r.h"
-#include "libslic3r/Point.hpp"
 #include "utils/ExtrusionLine.hpp"
 #include "../Polygon.hpp"
 #include "../PrintConfig.hpp"

src/libslic3r/Arachne/utils/ExtrusionJunction.hpp

@@ -6,9 +6,6 @@
 #define UTILS_EXTRUSION_JUNCTION_H
 
 #include "../../Point.hpp"
-#include "libslic3r/libslic3r.h"
-#include <cstddef>
-#include <vector>
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/utils/ExtrusionLine.cpp

@@ -2,16 +2,11 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include <algorithm>
-#include <cassert>
 #include <cmath>
-#include <cstdint>
 #include <cstdlib>
-#include <vector>
 
 #include "ExtrusionLine.hpp"
 #include "../../VariableWidth.hpp"
-#include "libslic3r/libslic3r.h"
-#include "libslic3r/Point.hpp"
 #include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/ExtrusionEntity.hpp"
@@ -292,9 +287,9 @@ double ExtrusionLine::area() const
 } // namespace Slic3r::Arachne
 
 namespace Slic3r {
-void extrusion_paths_append(ExtrusionPaths &dst, const ClipperLib_Z::Paths &extrusion_paths, const ExtrusionRole role, const Flow &flow)
+void extrusion_paths_append(ExtrusionPaths &dst, const ClipperZUtils::ZPaths &extrusion_paths, const ExtrusionRole role, const Flow &flow)
 {
-    for (const ClipperLib_Z::Path &extrusion_path : extrusion_paths) {
+    for (const ClipperZUtils::ZPath &extrusion_path : extrusion_paths) {
         ThickPolyline thick_polyline = Arachne::to_thick_polyline(extrusion_path);
         Slic3r::append(dst, thick_polyline_to_multi_path(thick_polyline, role, flow, scaled<float>(0.05), float(SCALED_EPSILON)).paths);
     }

src/libslic3r/Arachne/utils/ExtrusionLine.hpp

@@ -5,7 +5,7 @@
 #ifndef UTILS_EXTRUSION_LINE_H
 #define UTILS_EXTRUSION_LINE_H
 
-#include <clipper/clipper_z.hpp>
+#include "../../ClipperZUtils.hpp"
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -22,7 +22,6 @@
 #include "../../BoundingBox.hpp"
 #include "../../ExtrusionEntity.hpp"
 #include "../../Flow.hpp"
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Point.hpp"
 
 namespace Slic3r {
@@ -295,7 +294,7 @@ using VariableWidthLines = std::vector<ExtrusionLine>; //<! The ExtrusionLines g
 
 namespace Slic3r {
 
-void extrusion_paths_append(ExtrusionPaths &dst, const ClipperLib_Z::Paths &extrusion_paths, const ExtrusionRole role, const Flow &flow);
+void extrusion_paths_append(ExtrusionPaths &dst, const ClipperZUtils::ZPaths &extrusion_paths, const ExtrusionRole role, const Flow &flow);
 void extrusion_paths_append(ExtrusionPaths &dst, const Arachne::ExtrusionLine &extrusion, const ExtrusionRole role, const Flow &flow);
 
 } // namespace Slic3r

src/libslic3r/Arachne/utils/PolygonsPointIndex.hpp

@@ -4,9 +4,6 @@
 #ifndef UTILS_POLYGONS_POINT_INDEX_H
 #define UTILS_POLYGONS_POINT_INDEX_H
 
-#include <utility>
-#include <functional>
-#include <cstddef>
 #include <vector>
 
 #include "../../Point.hpp"

src/libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp

@@ -6,10 +6,7 @@
 
 #include <vector>
 
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/Point.hpp"
 #include "PolygonsPointIndex.hpp"
-#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/utils/PolylineStitcher.cpp

@@ -4,7 +4,6 @@
 #include "PolylineStitcher.hpp"
 
 #include "ExtrusionLine.hpp"
-#include "libslic3r/Point.hpp"
 #include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
 #include "libslic3r/Polygon.hpp"
 

src/libslic3r/Arachne/utils/SparseGrid.hpp

@@ -6,14 +6,11 @@
 #define UTILS_SPARSE_GRID_H
 
 #include <cassert>
-#include <unordered_map>
-#include <cstddef>
 #include <vector>
 #include <functional>
 
 #include "../../Point.hpp"
 #include "SquareGrid.hpp"
-#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne {
 

src/libslic3r/Arachne/utils/SparseLineGrid.hpp

@@ -6,15 +6,10 @@
 #define UTILS_SPARSE_LINE_GRID_H
 
 #include <cassert>
-#include <cstddef>
-#include <utility>
-#include <unordered_map>
 #include <vector>
 #include <functional>
 
-#include "libslic3r/Point.hpp"
 #include "SparseGrid.hpp"
-#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne {
 

src/libslic3r/Arachne/utils/SparsePointGrid.hpp

@@ -6,13 +6,9 @@
 #define UTILS_SPARSE_POINT_GRID_H
 
 #include <cassert>
-#include <cstddef>
-#include <cstdint>
 #include <vector>
 
-#include "libslic3r/Point.hpp"
 #include "SparseGrid.hpp"
-#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne {
 

src/libslic3r/Arachne/utils/SquareGrid.cpp

@@ -4,11 +4,7 @@
 #include "SquareGrid.hpp"
 
 #include <cassert>
-#include <cstdint>
-#include <utility>
-#include <functional>
 
-#include "libslic3r/libslic3r.h"
 #include "libslic3r/Point.hpp"
 
 using namespace Slic3r::Arachne;

src/libslic3r/Arachne/utils/linearAlg2D.hpp

@@ -5,9 +5,6 @@
 #define UTILS_LINEAR_ALG_2D_H
 
 #include "../../Point.hpp"
-#include <cstdint>
-#include <math.h>
-#include <cmath>
 
 namespace Slic3r::Arachne::LinearAlg2D
 {

src/libslic3r/ArcFitter.cpp

@@ -1,14 +1,8 @@
 #include "ArcFitter.hpp"
-#include "Point.hpp"
-#include "Circle.hpp"
-#include "MultiPoint.hpp"
 #include "Polyline.hpp"
-#include "libslic3r.h"
 
 #include <cmath>
 #include <cassert>
-#include <vector>
-#include <cstddef>
 
 namespace Slic3r {
 

src/libslic3r/ArcFitter.hpp

@@ -2,9 +2,6 @@
 #define slic3r_ArcFitter_hpp_
 
 #include "Circle.hpp"
-#include <cstddef>
-#include "Point.hpp"
-#include <vector>
 
 namespace Slic3r {
 

src/libslic3r/Arrange.cpp

@@ -1,28 +1,9 @@
 #include "Arrange.hpp"
-#include "ExPolygon.hpp"
-#include "Point.hpp"
 #include "Print.hpp"
 #include "BoundingBox.hpp"
-#include "PrintConfig.hpp"
 #include "libslic3r.h"
 
-#include <Eigen/Core>
-#include <boost/geometry/index/parameters.hpp>
-#include <functional>
-#include <algorithm>
-#include <cstdlib>
-#include <cmath>
-#include <cstddef>
-#include <boost/geometry/algorithms/convert.hpp>
-#include <array>
-#include <boost/geometry/index/predicates.hpp>
-#include <iterator>
-#include <exception>
 #include <libnest2d/backends/libslic3r/geometries.hpp>
-#include "libnest2d/common.hpp"
-#include "libnest2d/geometry_traits_nfp.hpp"
-#include "libnest2d/nester.hpp"
-#include "libnest2d/geometry_traits.hpp"
 #include <libnest2d/optimizers/nlopt/subplex.hpp>
 #include <libnest2d/placers/nfpplacer.hpp>
 #include <libnest2d/selections/firstfit.hpp>
@@ -32,11 +13,6 @@
 #include <ClipperUtils.hpp>
 
 #include <boost/geometry/index/rtree.hpp>
-#include <utility>
-#include <vector>
-#include <tuple>
-#include <set>
-#include <string>
 
 #if defined(_MSC_VER) && defined(__clang__)
 #define BOOST_NO_CXX17_HDR_STRING_VIEW
@@ -79,7 +55,7 @@ namespace Slic3r {
 
 template<class Tout = double, class = FloatingOnly<Tout>, int...EigenArgs>
 inline constexpr Eigen::Matrix<Tout, 2, EigenArgs...> unscaled(
-    const Slic3r::ClipperLib::IntPoint &v) noexcept
+    const Slic3r::Point &v) noexcept
 {
     return Eigen::Matrix<Tout, 2, EigenArgs...>{unscaled<Tout>(v.x()),
                                                 unscaled<Tout>(v.y())};
@@ -429,7 +405,7 @@ protected:
         // 2) X distance of item corner to bed corner (low weight)
         // 3) item row occupancy (useful when rotation is enabled)
         // 4）需要允许往屏蔽区域的左边或下边去一点，不然很多物体可能认为摆不进去，实际上我们最后是可以做平移的
-    double dist_for_BOTTOM_LEFT(Box ibb, const ClipperLib::IntPoint& origin_pack)
+    double dist_for_BOTTOM_LEFT(Box ibb, const Slic3r::Point& origin_pack)
     {
         double dist_corner_y = ibb.minCorner().y() - origin_pack.y();
         double dist_corner_x = ibb.minCorner().x() - origin_pack.x();
@@ -445,7 +421,7 @@ protected:
         return bindist;
     }
 
-    double dist_to_bin(const Box& ibb, const ClipperLib::IntPoint& origin_pack, typename Packer::PlacementConfig::Alignment starting_point_alignment)
+    double dist_to_bin(const Box& ibb, const Slic3r::Point& origin_pack, typename Packer::PlacementConfig::Alignment starting_point_alignment)
     {
         double bindist = 0;
         if (starting_point_alignment == PConfig::Alignment::BOTTOM_LEFT)
@@ -463,7 +439,7 @@ protected:
     // as it possibly can be but at the same time, it has to provide
     // reasonable results.
     std::tuple<double /*score*/, Box /*farthest point from bin center*/>
-    objfunc(const Item &item, const ClipperLib::IntPoint &origin_pack)
+    objfunc(const Item &item, const Slic3r::Point &origin_pack)
     {
         const double bin_area = m_bin_area;
         const SpatIndex& spatindex = m_rtree;
@@ -1038,7 +1014,12 @@ void _arrange(
 inline Box to_nestbin(const BoundingBox &bb) { return Box{{bb.min(X), bb.min(Y)}, {bb.max(X), bb.max(Y)}};}
 inline Circle to_nestbin(const CircleBed &c) { return Circle({c.center()(0), c.center()(1)}, c.radius()); }
 inline ExPolygon to_nestbin(const Polygon &p) { return ExPolygon{p}; }
-inline Box to_nestbin(const InfiniteBed &bed) { return Box::infinite({bed.center.x(), bed.center.y()}); }
+// libnest2d's infinite box reaches the int64 limit, where Clipper2's double math is no longer exact.
+inline Box to_nestbin(const InfiniteBed &bed)
+{
+    const coord_t r = coord_t(1) << 50;
+    return Box{{bed.center.x() - r, bed.center.y() - r}, {bed.center.x() + r, bed.center.y() + r}};
+}
 
 inline coord_t width(const BoundingBox& box) { return box.max.x() - box.min.x(); }
 inline coord_t height(const BoundingBox& box) { return box.max.y() - box.min.y(); }
@@ -1146,8 +1127,6 @@ void arrange(ArrangePolygons &      arrangables,
              const BedT &           bed,
              const ArrangeParams &  params)
 {
-    namespace clppr = Slic3r::ClipperLib;
-
     std::vector<Item> items, fixeditems;
     items.reserve(arrangables.size());
 

src/libslic3r/Arrange.hpp

@@ -2,17 +2,8 @@
 #define ARRANGE_HPP
 
 #include "ExPolygon.hpp"
-#include "Point.hpp"
-#include "Polygon.hpp"
 #include "PrintConfig.hpp"
 #include "Print.hpp"
-#include <cmath>
-#include "libslic3r.h"
-#include <vector>
-#include <string>
-#include <functional>
-#include <iostream>
-#include <ostream>
 
 #define BED_SHRINK_SEQ_PRINT 5
 

src/libslic3r/BoundingBox.cpp

@@ -1,8 +1,5 @@
 #include "BoundingBox.hpp"
-#include "Point.hpp"
 #include "Polygon.hpp"
-#include "libslic3r.h"
-#include <Eigen/Core>
 #include <algorithm>
 #include <assert.h>
 

src/libslic3r/BoundingBox.hpp

@@ -5,10 +5,7 @@
 #include "Exception.hpp"
 #include "Point.hpp"
 #include "Polygon.hpp"
-#include <cassert>
-#include <cstddef>
 #include <ostream>
-#include <vector>
 
 namespace Slic3r {
 

src/libslic3r/BridgeDetector.cpp

@@ -1,18 +1,7 @@
 #include "BridgeDetector.hpp"
-#include "BoundingBox.hpp"
 #include "ClipperUtils.hpp"
-#include "ExPolygon.hpp"
 #include "Geometry.hpp"
-#include "libslic3r.h"
-#include "Polygon.hpp"
-#include "Line.hpp"
-#include "Polyline.hpp"
-#include "Point.hpp"
 #include <algorithm>
-#include <utility>
-#include <vector>
-#include <cstddef>
-#include <cmath>
 
 namespace Slic3r {
 

src/libslic3r/BridgeDetector.hpp

@@ -9,14 +9,7 @@
 #include "PrincipalComponents2D.hpp"
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
-#include <cmath>
-#include <cstdlib>
-#include <limits>
 #include <string>
-#include <vector>
-#include <tuple>
-#include <unordered_map>
-#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/Brim.cpp

@@ -1,37 +1,18 @@
-#include "BoundingBox.hpp"
-#include "BrimEarsPoint.hpp"
 #include "ClipperUtils.hpp"
 #include "EdgeGrid.hpp"
-#include "ExPolygon.hpp"
-#include "Flow.hpp"
-#include "Geometry.hpp"
-#include "ExtrusionEntity.hpp"
 #include "Layer.hpp"
-#include "Point.hpp"
-#include "ObjectID.hpp"
-#include "Polygon.hpp"
-#include "Line.hpp"
-#include "MultiPoint.hpp"
-#include "Polyline.hpp"
 #include "Print.hpp"
-#include "PrintBase.hpp"
 #include "ShortestPath.hpp"
 #include "libslic3r.h"
 #include "PrintConfig.hpp"
 #include "MaterialType.hpp"
 #include "Model.hpp"
 #include <algorithm>
-#include <cstddef>
-#include <cmath>
 #include <cstdint>
 #include <limits>
-#include <map>
-#include <string>
 #include <tbb/parallel_for.h>
 
 #include <boost/log/trivial.hpp>
-#include <utility>
-#include <vector>
 
 #ifndef NDEBUG
     // #define BRIM_DEBUG_TO_SVG

src/libslic3r/Brim.hpp

@@ -4,10 +4,8 @@
 #include "ExPolygon.hpp"
 #include "ObjectID.hpp"
 #include "Point.hpp"
-#include "Polygon.hpp"
 
 #include<map>
-#include <utility>
 #include<vector>
 
 namespace Slic3r {

src/libslic3r/BrimEarsPoint.hpp

@@ -1,10 +1,7 @@
 #ifndef BRIMEARSPOINT_HPP
 #define BRIMEARSPOINT_HPP
 
-#include <cstdlib>
-#include "libslic3r.h"
 #include <libslic3r/Point.hpp>
-#include <vector>
 
 
 namespace Slic3r {

src/libslic3r/BuildVolume.cpp

@@ -1,24 +1,11 @@
 #include "BuildVolume.hpp"
-#include "BoundingBox.hpp"
 #include "ClipperUtils.hpp"
-#include "Polygon.hpp"
-#include "Geometry/Circle.hpp"
-#include "ExtrusionEntity.hpp"
 #include "TriangleMesh.hpp"
 #include "Geometry/ConvexHull.hpp"
 #include "GCode/GCodeProcessor.hpp"
 #include "Point.hpp"
-#include "libslic3r.h"
 
-#include <algorithm>
 #include <boost/log/trivial.hpp>
-#include <vector>
-#include <cassert>
-#include <cstdlib>
-#include <limits>
-#include <utility>
-#include <cstddef>
-#include <string_view>
 
 namespace Slic3r {
 

src/libslic3r/BuildVolume.hpp

@@ -5,13 +5,9 @@
 #include "Geometry/Circle.hpp"
 #include "Polygon.hpp"
 #include "BoundingBox.hpp"
-#include "libslic3r.h"
 #include <admesh/stl.h>
 
-#include <array>
 #include <string_view>
-#include <vector>
-#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CAD/CadDocument.cpp

@@ -1,14 +1,8 @@
 #include "libslic3r/CAD/CadDocument.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/CAD/SketchEngine.hpp"
-#include "libslic3r/CAD/GeometryEngine.hpp"
 #include "libslic3r/CAD/SketchConstraints.hpp"
 #include "libslic3r/CAD/SketchSolver.hpp"
 #include "libslic3r/CAD/SketchImport.hpp"   // transform_regions for imported art
 
-#include <Standard_Handle.hxx>
-#include <TopAbs_ShapeEnum.hxx>
-#include <Standard_TypeDef.hxx>
 #include <array>
 
 #include <Standard_Failure.hxx>
@@ -32,10 +26,6 @@
 #include <BRepOffsetAPI_DraftAngle.hxx>
 #include <Bnd_Box.hxx>
 #include <BRepBndLib.hxx>
-#include <functional>
-#include <exception>
-#include <cstdint>
-#include <cereal/cereal.hpp>
 #include <gp_Pln.hxx>
 #include <TopTools_ListOfShape.hxx>
 #include <BRepPrimAPI_MakeCylinder.hxx>
@@ -79,18 +69,12 @@
 #include <cmath>
 #include <cctype>
 #include <cstdio>
-#include <math.h>
-#include <map>
-#include <set>
 #include <stdexcept>
 #include <algorithm>
 #include <sstream>
 
 #include <cereal/archives/binary.hpp>
 #include <BRepTools.hxx>
-#include <string>
-#include <vector>
-#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CAD/CadDocument.hpp

@@ -1,20 +1,16 @@
 #ifndef slic3r_CadDocument_hpp_
 #define slic3r_CadDocument_hpp_
 
-#include "libslic3r/Point.hpp"
 #include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/CAD/SketchEngine.hpp"
 #include "libslic3r/CAD/GeometryEngine.hpp"   // FaceGroup
 #include "libslic3r/Color.hpp"            // ColorRGBA (per-body display colour override)
 
-#include <TopoDS_Face.hxx>
 #include <TopoDS_Shape.hxx>
 #include <TopoDS_Wire.hxx>
 #include <cereal/cereal.hpp>
 #include <cereal/types/vector.hpp>
 #include <cereal/types/string.hpp>
-#include <cstdint>
-#include <cstddef>
 #include <map>
 #include <cereal/types/map.hpp>
 #include <string>

src/libslic3r/CAD/GeometryEngine.cpp

@@ -1,25 +1,12 @@
 #include "libslic3r/CAD/GeometryEngine.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/TriangleMesh.hpp"
 
 #include <BRepMesh_IncrementalMesh.hxx>
 #include <BRep_Tool.hxx>
 #include <BRepAdaptor_Surface.hxx>
 #include <BRepLProp_SLProps.hxx>
-#include <TopAbs_ShapeEnum.hxx>
-#include <cstddef>
-#include <algorithm>
-#include <GeomAbs_SurfaceType.hxx>
-#include <TopAbs_Orientation.hxx>
-#include <Standard_Handle.hxx>
-#include <cstdint>
-#include <Poly_Triangle.hxx>
-#include <GeomAbs_CurveType.hxx>
 #include <gp_Cylinder.hxx>
 #include <BRepFilletAPI_MakeFillet.hxx>
 #include <BRepFilletAPI_MakeChamfer.hxx>
-#include <math.h>
-#include <gp_Mat.hxx>
 #include <stdexcept>
 #include <TopExp_Explorer.hxx>
 #include <TopoDS.hxx>
@@ -56,9 +43,6 @@
 #include <array>
 #include <map>
 #include <cmath>
-#include <vector>
-#include <string>
-#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CAD/GeometryEngine.hpp

@@ -1,7 +1,6 @@
 #ifndef slic3r_GeometryEngine_hpp_
 #define slic3r_GeometryEngine_hpp_
 
-#include "libslic3r/Point.hpp"
 #include "libslic3r/TriangleMesh.hpp"
 
 #include <BRepPrimAPI_MakeBox.hxx>
@@ -9,8 +8,6 @@
 #include <BRepPrimAPI_MakeSphere.hxx>
 #include <BRepPrimAPI_MakeCone.hxx>
 #include <BRepPrimAPI_MakeTorus.hxx>
-#include <TopoDS_Shape.hxx>
-#include <array>
 #include <gp_Ax2.hxx>
 #include <TopoDS_Solid.hxx>
 #include <TopoDS_Face.hxx>

src/libslic3r/CAD/SketchConstraints.cpp

@@ -1,11 +1,6 @@
 #include "libslic3r/CAD/SketchConstraints.hpp"
-#include "libslic3r/Point.hpp"
-#include <Eigen/Core>
 #include <Eigen/Dense>
-#include <algorithm>
 #include <cmath>
-#include <cstddef>
-#include <vector>
 
 namespace Slic3r {
 

src/libslic3r/CAD/SketchConstraints.hpp

@@ -2,7 +2,6 @@
 #define slic3r_SketchConstraints_hpp_
 
 #include "libslic3r/Point.hpp"
-#include <Eigen/Core>
 #include <vector>
 #include <Eigen/Dense>
 

src/libslic3r/CAD/SketchEngine.cpp

@@ -1,18 +1,7 @@
 #include "libslic3r/CAD/SketchEngine.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/TriangleMesh.hpp"
 
-#include <Standard_Handle.hxx>
-#include <GeomAbs_SurfaceType.hxx>
-#include <GeomAbs_JoinType.hxx>
-#include <TopAbs_ShapeEnum.hxx>
-#include <Standard_TypeDef.hxx>
-#include <TopAbs_Orientation.hxx>
-#include <Poly_Triangle.hxx>
-#include <TopAbs_State.hxx>
 #include <algorithm>
 #include <cmath>
-#include <cstddef>
 #include <limits>
 
 #include <BRepBuilderAPI_MakeWire.hxx>
@@ -58,11 +47,8 @@
 #include <TopoDS_Wire.hxx>
 #include <GeomAPI_IntCS.hxx>
 #include <map>
-#include <math.h>
 #include <tuple>
 #include <stdexcept>
-#include <vector>
-#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CAD/SketchImport.cpp

@@ -1,8 +1,5 @@
 #include "libslic3r/CAD/SketchImport.hpp"
 
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/EmbossShape.hpp"
 #include "libslic3r/Emboss.hpp"
 #include "libslic3r/NSVGUtils.hpp"
 #include "libslic3r/ExPolygon.hpp"
@@ -12,11 +9,6 @@
 
 #include <algorithm>
 #include <limits>
-#include <vector>
-#include <string>
-#include <memory>
-#include <utility>
-#include <nanosvg/nanosvg.h>
 
 namespace Slic3r {
 

src/libslic3r/CAD/SketchInference.cpp

@@ -1,13 +1,7 @@
 #include "libslic3r/CAD/SketchInference.hpp"
-#include "libslic3r/CAD/SketchEngine.hpp"
-#include "libslic3r/Point.hpp"
 
 #include <algorithm>
 #include <cmath>
-#include <vector>
-#include <cstddef>
-#include <optional>
-#include <math.h>
 
 namespace Slic3r {
 

src/libslic3r/CAD/SketchInference.hpp

@@ -1,9 +1,7 @@
 #ifndef slic3r_SketchInference_hpp_
 #define slic3r_SketchInference_hpp_
 
-#include "libslic3r/Point.hpp"
 #include "libslic3r/CAD/SketchEngine.hpp"
-#include <math.h>
 #include <vector>
 #include <optional>
 #include <cmath>