Keep GLCanvas3D Building With SLIC3R_CAD Off

The bed-axes toggle added for the Design tab's reference planes reads
m_design_sketch_tool, which only exists under SLIC3R_CAD. Compute the
flag once and read the sketch tool inside the same guard as its other
uses.

.github/workflows/build_all.yml

@@ -5,6 +5,7 @@ on:
     branches:
      - main
      - release/*
+     - belt-printer
     paths:
      - 'deps/**'
      - 'src/**'
@@ -261,6 +262,9 @@ jobs:
       date:
       ver:
       ver_pure:
+      # Belt-printer nightlies share the main nightly release but carry a `_belt`
+      # suffix so they never overwrite the main assets.
+      nightly_suffix: ${{ github.ref == 'refs/heads/belt-printer' && '_belt' || '' }}
     steps:
     - name: "Remove unneeded stuff to free disk space"
       run:
@@ -435,13 +439,13 @@ jobs:
         name: OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak
         path: '/__w/OrcaSlicer/OrcaSlicer/OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak'
     - name: Deploy Flatpak to nightly release
-      if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main'
+      if: github.repository == 'OrcaSlicer/OrcaSlicer' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/belt-printer')
       uses: WebFreak001/deploy-nightly@v3.2.0
       with:
         upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
         release_id: 137995723
         asset_path: /__w/OrcaSlicer/OrcaSlicer/OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak
-        asset_name: OrcaSlicer-Linux-flatpak_nightly_${{ matrix.variant.arch }}.flatpak
+        asset_name: OrcaSlicer-Linux-flatpak_nightly${{ env.nightly_suffix }}_${{ matrix.variant.arch }}.flatpak
         asset_content_type: application/octet-stream
         max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
     # The asset is /app (the exes link it at runtime) plus the build tree

.github/workflows/build_orca.yml

@@ -33,6 +33,11 @@ jobs:
       ubuntu-ver: '2404'
       ubuntu-ver-str: '_Ubuntu2404'
       ORCA_UPDATER_SIG_KEY: ${{ secrets.ORCA_UPDATER_SIG_KEY }}
+      # Branches whose builds are published to the nightly release. The
+      # belt-printer branch ships alongside main but its assets carry a `_belt`
+      # suffix (nightly_suffix) so they never overwrite the main nightly assets.
+      deploy_nightly: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/belt-printer' }}
+      nightly_suffix: ${{ github.ref == 'refs/heads/belt-printer' && '_belt' || '' }}
 
     steps:
       - name: Checkout
@@ -255,7 +260,7 @@ jobs:
 
  # Thanks to RaySajuuk, it's working now
       - name: Sign app and notary
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release/')) && runner.os == 'macOS' && inputs.macos-combine-only
+        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:
@@ -343,7 +348,7 @@ jobs:
           fi
 
       - name: Create DMG without notary
-        if: github.ref != 'refs/heads/main' && runner.os == 'macOS' && inputs.macos-combine-only
+        if: github.ref != 'refs/heads/main' && github.ref != 'refs/heads/belt-printer' && runner.os == 'macOS' && inputs.macos-combine-only
         working-directory: ${{ github.workspace }}
         run: |
           # Load the `retry` helper (retries flaky commands such as `hdiutil create`).
@@ -389,13 +394,13 @@ jobs:
           if-no-files-found: ignore
 
       - name: Deploy Mac release
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'macOS' && inputs.macos-combine-only && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && env.deploy_nightly == 'true' && runner.os == 'macOS' && inputs.macos-combine-only && !vars.SELF_HOSTED
         uses: WebFreak001/deploy-nightly@v3.2.0
         with:
           upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
           release_id: 137995723
           asset_path: ${{ github.workspace }}/OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
-          asset_name: OrcaSlicer_Mac_universal_nightly.dmg
+          asset_name: OrcaSlicer_Mac_universal_nightly${{ env.nightly_suffix }}.dmg
           asset_content_type: application/octet-stream
           max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
 
@@ -538,24 +543,24 @@ jobs:
           path: ${{ github.workspace }}/build/src/Release/OrcaSlicer_profile_validator.exe
 
       - name: Deploy Windows release portable
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && env.deploy_nightly == 'true' && runner.os == 'Windows' && !vars.SELF_HOSTED
         uses: WebFreak001/deploy-nightly@v3.2.0
         with:
           upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
           release_id: 137995723
           asset_path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_${{ env.ver }}${{ env.ARCH_SUFFIX }}_portable.zip
-          asset_name: OrcaSlicer_Windows${{ env.ARCH_SUFFIX }}_nightly_portable.zip
+          asset_name: OrcaSlicer_Windows${{ env.ARCH_SUFFIX }}_nightly${{ env.nightly_suffix }}_portable.zip
           asset_content_type: application/x-zip-compressed
           max_releases: 1
 
       - name: Deploy Windows release installer
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && env.deploy_nightly == 'true' && runner.os == 'Windows' && !vars.SELF_HOSTED
         uses: WebFreak001/deploy-nightly@v3.2.0
         with:
           upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
           release_id: 137995723
           asset_path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_Installer_${{ env.ver }}${{ env.ARCH_SUFFIX }}.exe
-          asset_name: OrcaSlicer_Windows_Installer${{ env.ARCH_SUFFIX }}_nightly.exe
+          asset_name: OrcaSlicer_Windows_Installer${{ env.ARCH_SUFFIX }}_nightly${{ env.nightly_suffix }}.exe
           asset_content_type: application/x-msdownload
           max_releases: 1
 
@@ -696,20 +701,23 @@ jobs:
           path: './build/src/dev-utils/Release/generate_system_cache'
 
       - name: Deploy Ubuntu release
-        if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED }}
+        if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && env.deploy_nightly == 'true' && runner.os == 'Linux' && !vars.SELF_HOSTED }}
         uses: WebFreak001/deploy-nightly@v3.2.0
         with:
           upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
           release_id: 137995723
           asset_path: ./build/OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_${{ env.ver }}.AppImage
-          asset_name: OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_nightly.AppImage
+          asset_name: OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_nightly${{ env.nightly_suffix }}.AppImage
           asset_content_type: application/octet-stream
           max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
       - name: Deploy Ubuntu release
         if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED && inputs.arch != 'aarch64' }}
-        run: |
-          git -c user.name="${GITHUB_ACTOR}" -c user.email="${GITHUB_ACTOR}@users.noreply.github.com" tag -f -a nightly-builds "${GITHUB_SHA}" -m nightly-builds
-          git push -f origin refs/tags/nightly-builds
+        uses: rickstaa/action-create-tag@v1
+        with:
+          tag: "nightly-builds"
+          tag_exists_error: false
+          force_push_tag: true
+          message: "nightly-builds"
 
       - name: Deploy Ubuntu OrcaSlicer_profile_validator release
         if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED && inputs.arch != 'aarch64' }}

.github/workflows/check_profiles.yml

@@ -74,26 +74,12 @@ jobs:
           set +e
           ./OrcaSlicer_profile_validator -p ${{ github.workspace }}/resources/profiles -l 2 2>&1 | tee ${{ runner.temp }}/validate_system.log
           exit ${PIPESTATUS[0]}
-      # The validator above is the nightly build of main, so it cannot slice profiles that use
-      # settings a PR adds to the engine: it reports their placeholders as undefined. A PR that
-      # changes src/ also runs Build all, whose Slice check runs this same sweep with the
-      # validator built from the PR, so the sweep below only runs for the other PRs.
-      - name: Detect engine changes
-        id: engine_changes
-        if: ${{ github.event_name == 'pull_request' }}
-        run: |
-          base=${{ github.event.pull_request.base.sha }}
-          if git fetch --no-tags --depth=1 origin "$base" && ! git diff --quiet "$base" HEAD -- src/; then
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-            echo "::notice::This PR changes src/, so Build all's Slice check slices the profiles with the PR-built validator."
-          fi
       # Slice a two-colour cube through every printer, and through every system process/filament whose
       # templates no printer's own slice reaches, so every custom g-code and filename_format shipped is
       # expanded (names in {if} branches not taken included) - catches undefined-placeholder /
       # invalid-flow bugs the static checks above cannot see.
       - name: validate slice (expand custom g-code)
         id: validate_slice
-        if: ${{ steps.engine_changes.outputs.changed != 'true' }}
         continue-on-error: true
         run: |
           set +e

.github/workflows/parity_nightly.yml

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

CMakeLists.txt

@@ -1084,10 +1084,10 @@ endif ()
 
 find_path(SPNAV_INCLUDE_DIR spnav.h)
 if (SPNAV_INCLUDE_DIR)
-    find_library(SPNAV_LIB NAMES libspnav.a spnav)
+    find_library(SPNAV_LIB NAMES libspnav.a) # Force linking libspnav statically
     if (SPNAV_LIB)
         add_definitions(-DHAVE_SPNAV)
-        message(STATUS "SPNAV library found: ${SPNAV_LIB}")
+        message(STATUS "SPNAV library found")
     else()
         message(STATUS "SPNAV library NOT found, Spacenavd not supported")
     endif()

README.md

@@ -68,8 +68,6 @@ If you come across any of these in search results, please <b>report them</b> as
   Regular updates fueled by continuous community contributions.
 - **Wide Printer Compatibility**  
   Supports a broad range of printers: Bambu Lab, Prusa, Creality, Voron, and more.
-- **[Belt Printer Support](https://www.orcaslicer.com/wiki/belt_printing)**  
-  Slice for belt / conveyor (infinite-Z) printers, with belt-aware supports and a tilted-bed preview. Contributed by [Joseph Robertson (@HarrierPigeon)](https://github.com/HarrierPigeon).
 - Additional features can be found in the [change notes](https://github.com/OrcaSlicer/OrcaSlicer/releases/).
 
 # Wiki
@@ -91,6 +89,17 @@ Visit our GitHub Releases page for the latest stable version of OrcaSlicer, reco
 🌙 **[Download the Latest Nightly Build](https://github.com/OrcaSlicer/OrcaSlicer/releases/tag/nightly-builds)**  
 Explore the latest developments in OrcaSlicer with our nightly builds. Feedback on these versions is highly appreciated.
 
+### Belt Printer Builds
+
+The [nightly release](https://github.com/OrcaSlicer/OrcaSlicer/releases/tag/nightly-builds) ships **two parallel builds**: the standard build and a belt-printer build. Both are attached to the same release — tell them apart by the filename suffix:
+
+- **Standard** — no suffix (e.g. `OrcaSlicer_Windows_Installer_x64_nightly.exe`)
+- **Belt** — `_belt` suffix (e.g. `OrcaSlicer_Windows_Installer_x64_nightly_belt.exe`)
+
+The `_belt` builds add **experimental support for belt / conveyor (infinite-Z) printers**, where the model is sliced against a tilted belt surface instead of a flat horizontal bed. They include ready-to-use belt printer profiles, the full belt slicing pipeline (mesh rotation and G-code transforms), belt-aware support generation, and a tilted-bed preview.
+
+> ⚠️ Belt printer support is under active development and is **not yet merged into `main`** — it currently ships only in these parallel `_belt` builds, produced from the [`belt-printer`](https://github.com/OrcaSlicer/OrcaSlicer/tree/belt-printer) branch. See tracking PR [#14394](https://github.com/OrcaSlicer/OrcaSlicer/pull/14394) and the original documentation in [#12998](https://github.com/OrcaSlicer/OrcaSlicer/pull/12998).
+
 # How to install
 
 ## Windows

build_linux.sh

@@ -8,10 +8,9 @@ SCRIPT_PATH=$(dirname "$(readlink -f "${0}")")
 pushd "${SCRIPT_PATH}" > /dev/null
 
 function usage() {
-    echo "Usage: ./${SCRIPT_NAME} [-1][-b][-c][-d][-D][-e][-F][-g][-h][-i][-j N][-J N][-p][-r][-s][-t][-u][-l][-L]"
+    echo "Usage: ./${SCRIPT_NAME} [-1][-b][-c][-d][-D][-e][-F][-g][-h][-i][-j N][-p][-r][-s][-t][-u][-l][-L]"
     echo "   -1: limit builds to one core (where possible)"
     echo "   -j N: limit builds to N cores (where possible)"
-    echo "   -J N: build up to N dependencies at a time, each still using -j jobs (default: 1)"
     echo "   -b: build in Debug mode"
     echo "   -c: force a clean build"
     echo "   -C: enable ANSI-colored compile output (GNU/Clang only)"
@@ -37,13 +36,12 @@ function usage() {
 }
 
 SLIC3R_PRECOMPILED_HEADERS="ON"
-DEPS_PARALLEL=""
 
 unset name
 BUILD_DIR=build
 BUILD_CONFIG=Release
 FORWARDED_ARGS=()
-while getopts ":1j:J:bcCdDeFghiprstulL" opt ; do
+while getopts ":1j:bcCdDeFghiprstulL" opt ; do
   case ${opt} in
     1 )
         export CMAKE_BUILD_PARALLEL_LEVEL=1
@@ -53,10 +51,6 @@ while getopts ":1j:J:bcCdDeFghiprstulL" opt ; do
         export CMAKE_BUILD_PARALLEL_LEVEL=$OPTARG
         FORWARDED_ARGS+=("-j" "$OPTARG")
         ;;
-    J )
-        DEPS_PARALLEL=$OPTARG
-        FORWARDED_ARGS+=("-J" "$OPTARG")
-        ;;
     b )
         BUILD_DIR=build-dbg
         BUILD_CONFIG=Debug
@@ -141,11 +135,6 @@ if [[ -n "${CLEAN_DOCKER_IMAGE}" ]] && [[ -z "${USE_DOCKER}" ]] ; then
     exit 1
 fi
 
-if [[ -n "${DEPS_PARALLEL}" ]] && ! [[ "${DEPS_PARALLEL}" =~ ^[1-9][0-9]*$ ]] ; then
-    echo "Error: -J expects a positive integer."
-    exit 1
-fi
-
 function check_available_memory_and_disk() {
     FREE_MEM_GB=$(free --gibi --total | grep 'Mem' | rev | cut --delimiter=" " --fields=1 | rev)
     MIN_MEM_GB=10
@@ -548,29 +537,7 @@ if [[ -n "${BUILD_DEPS}" ]] ; then
     fi
 
     print_and_run cmake -S deps -B deps/$BUILD_DIR "${CMAKE_C_CXX_COMPILER_CLANG[@]}" "${CMAKE_LLD_LINKER_ARGS[@]}" "${CMAKE_CCACHE_ARGS[@]}" -G Ninja "${COLORED_OUTPUT}" "${BUILD_ARGS[@]}"
-    # The top-level build runs one dependency at a time by default, which keeps the console
-    # output readable and lets that dependency's own build use all of CMAKE_BUILD_PARALLEL_LEVEL.
-    # -J raises the top level instead, and -j still applies in full to every dependency, so the
-    # worst case is -J times -j compile jobs at once. Ninja has no job server to share a pool
-    # across the nested builds, so that ceiling is not enforced anywhere: pick -J to suit the RAM.
-    DEPS_JOBS=1
-    if [[ -n "${DEPS_PARALLEL}" ]] ; then
-        DEPS_JOBS=${DEPS_PARALLEL}
-        SAVED_PARALLEL_LEVEL=${CMAKE_BUILD_PARALLEL_LEVEL-}
-        export CMAKE_BUILD_PARALLEL_LEVEL=${CMAKE_BUILD_PARALLEL_LEVEL:-$(nproc)}
-        echo "Building up to ${DEPS_JOBS} dependencies at a time, ${CMAKE_BUILD_PARALLEL_LEVEL} jobs each: up to $(( DEPS_JOBS * CMAKE_BUILD_PARALLEL_LEVEL )) compile jobs at once."
-    fi
-
-    print_and_run cmake --build deps/$BUILD_DIR -j"${DEPS_JOBS}"
-
-    if [[ -n "${DEPS_PARALLEL}" ]] ; then
-        # Give the whole -j back to the OrcaSlicer build below.
-        if [[ -n "${SAVED_PARALLEL_LEVEL}" ]] ; then
-            export CMAKE_BUILD_PARALLEL_LEVEL=${SAVED_PARALLEL_LEVEL}
-        else
-            unset CMAKE_BUILD_PARALLEL_LEVEL
-        fi
-    fi
+    print_and_run cmake --build deps/$BUILD_DIR -j1
 fi
 
 if [[ -n "${BUILD_ORCA}" ]] || [[ -n "${BUILD_TESTS}" ]] ; then

build_release_macos.sh

@@ -104,8 +104,8 @@ fi
 
 CMAKE_VERSION=$(cmake --version | head -1 | sed 's/[^0-9]*\([0-9]*\).*/\1/')
 if [ "$CMAKE_VERSION" -ge 4 ] 2>/dev/null; then
-  export CMAKE_POLICY_VERSION_MINIMUM=3.10
-  export CMAKE_POLICY_COMPAT="-DCMAKE_POLICY_VERSION_MINIMUM=3.10"
+  export CMAKE_POLICY_VERSION_MINIMUM=3.5
+  export CMAKE_POLICY_COMPAT="-DCMAKE_POLICY_VERSION_MINIMUM=3.5"
   echo "Detected CMake 4.x, adding compatibility flag (env + cmake arg)"
 else
   export CMAKE_POLICY_COMPAT=""

cmake/modules/FindGLEW.cmake

@@ -0,0 +1,359 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# PrusaSlicer specifics:
+# This file is backported from CMake 3.15 distribution to behave uniformly
+# across all versions of CMake. It explicitly adds GLEW_STATIC compile 
+# definition to static targets which is needed to prevent link errors.
+
+#[=======================================================================[.rst:
+FindGLEW
+--------
+
+Find the OpenGL Extension Wrangler Library (GLEW)
+
+Input Variables
+^^^^^^^^^^^^^^^
+
+The following variables may be set to influence this module’s behavior:
+
+``GLEW_USE_STATIC_LIBS``
+  to find and create :prop_tgt:`IMPORTED` target for static linkage.
+
+``GLEW_VERBOSE``
+  to output a detailed log of this module.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+This module defines the following :ref:`Imported Targets <Imported Targets>`:
+
+
+``GLEW::glew``
+  The GLEW shared library.
+``GLEW::glew_s``
+  The GLEW static library, if ``GLEW_USE_STATIC_LIBS`` is set to ``TRUE``.
+``GLEW::GLEW``
+  Duplicates either ``GLEW::glew`` or ``GLEW::glew_s`` based on availability.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module defines the following variables:
+
+``GLEW_INCLUDE_DIRS``
+  include directories for GLEW
+``GLEW_LIBRARIES``
+  libraries to link against GLEW
+``GLEW_SHARED_LIBRARIES``
+  libraries to link against shared GLEW
+``GLEW_STATIC_LIBRARIES``
+  libraries to link against static GLEW
+``GLEW_FOUND``
+  true if GLEW has been found and can be used
+``GLEW_VERSION``
+  GLEW version
+``GLEW_VERSION_MAJOR``
+  GLEW major version
+``GLEW_VERSION_MINOR``
+  GLEW minor version
+``GLEW_VERSION_MICRO``
+  GLEW micro version
+
+#]=======================================================================]
+
+include(FindPackageHandleStandardArgs)
+
+
+if(APPLE)
+  find_package(OpenGL QUIET)
+
+  if(OpenGL_FOUND)
+    if(GLEW_VERBOSE)
+      message(STATUS "FindGLEW: Found OpenGL Framework.")
+      message(STATUS "FindGLEW: OPENGL_LIBRARIES: ${OPENGL_LIBRARIES}")
+    endif()
+  else()
+    if(GLEW_VERBOSE)
+      message(STATUS "FindGLEW: could not find GLEW library.")
+    endif()
+    return()
+  endif()
+endif()
+
+
+function(__glew_set_find_library_suffix shared_or_static)
+  if((UNIX AND NOT APPLE) AND "${shared_or_static}" MATCHES "SHARED")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".so")
+  elseif((UNIX AND NOT APPLE) AND "${shared_or_static}" MATCHES "STATIC")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
+  elseif(APPLE AND "${shared_or_static}" MATCHES "SHARED")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib;.so")
+  elseif(APPLE AND "${shared_or_static}" MATCHES "STATIC")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
+  elseif(WIN32 AND "${shared_or_static}" MATCHES "SHARED")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib")
+  elseif(WIN32 AND "${shared_or_static}" MATCHES "STATIC")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib;.a;.dll.a")
+  endif()
+
+  set(CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_FIND_LIBRARY_SUFFIXES}" PARENT_SCOPE)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: CMAKE_FIND_LIBRARY_SUFFIXES for ${shared_or_static}: ${CMAKE_FIND_LIBRARY_SUFFIXES}")
+  endif()
+endfunction()
+
+
+if(GLEW_VERBOSE)
+  if(DEFINED GLEW_USE_STATIC_LIBS)
+    message(STATUS "FindGLEW: GLEW_USE_STATIC_LIBS: ${GLEW_USE_STATIC_LIBS}.")
+  else()
+    message(STATUS "FindGLEW: GLEW_USE_STATIC_LIBS is undefined. Treated as FALSE.")
+  endif()
+endif()
+
+find_path(GLEW_INCLUDE_DIR GL/glew.h)
+mark_as_advanced(GLEW_INCLUDE_DIR)
+
+set(GLEW_INCLUDE_DIRS ${GLEW_INCLUDE_DIR})
+
+if(GLEW_VERBOSE)
+  message(STATUS "FindGLEW: GLEW_INCLUDE_DIR: ${GLEW_INCLUDE_DIR}")
+  message(STATUS "FindGLEW: GLEW_INCLUDE_DIRS: ${GLEW_INCLUDE_DIRS}")
+endif()
+
+if("${CMAKE_GENERATOR_PLATFORM}" MATCHES "x64" OR "${CMAKE_GENERATOR}" MATCHES "Win64")
+  set(_arch "x64")
+elseif("${CMAKE_GENERATOR_PLATFORM}" MATCHES "ARM64")
+  set(_arch "x64")  # GLEW ships one header set; ARM64 uses the x64 import path
+else()
+  set(_arch "Win32")
+endif()
+
+
+set(__GLEW_CURRENT_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+
+__glew_set_find_library_suffix(SHARED)
+
+find_library(GLEW_SHARED_LIBRARY_RELEASE
+             NAMES GLEW glew glew32
+             PATH_SUFFIXES lib lib64 libx32 lib/Release/${_arch}
+             PATHS ENV GLEW_ROOT)
+
+find_library(GLEW_SHARED_LIBRARY_DEBUG
+             NAMES GLEWd glewd glew32d
+             PATH_SUFFIXES lib lib64
+             PATHS ENV GLEW_ROOT)
+
+
+__glew_set_find_library_suffix(STATIC)
+
+find_library(GLEW_STATIC_LIBRARY_RELEASE
+             NAMES GLEW glew glew32s
+             PATH_SUFFIXES lib lib64 libx32 lib/Release/${_arch}
+             PATHS ENV GLEW_ROOT)
+
+find_library(GLEW_STATIC_LIBRARY_DEBUG
+             NAMES GLEWds GLEWd glewd glewds glew32ds
+             PATH_SUFFIXES lib lib64
+             PATHS ENV GLEW_ROOT)
+
+set(CMAKE_FIND_LIBRARY_SUFFIXES ${__GLEW_CURRENT_FIND_LIBRARY_SUFFIXES})
+unset(__GLEW_CURRENT_FIND_LIBRARY_SUFFIXES)
+
+include(SelectLibraryConfigurations)
+
+select_library_configurations(GLEW_SHARED)
+select_library_configurations(GLEW_STATIC)
+
+if(NOT GLEW_USE_STATIC_LIBS)
+  set(GLEW_LIBRARIES ${GLEW_SHARED_LIBRARY})
+else()
+  set(GLEW_LIBRARIES ${GLEW_STATIC_LIBRARY})
+endif()
+
+
+if(GLEW_VERBOSE)
+  message(STATUS "FindGLEW: GLEW_SHARED_LIBRARY_RELEASE: ${GLEW_SHARED_LIBRARY_RELEASE}")
+  message(STATUS "FindGLEW: GLEW_STATIC_LIBRARY_RELEASE: ${GLEW_STATIC_LIBRARY_RELEASE}")
+  message(STATUS "FindGLEW: GLEW_SHARED_LIBRARY_DEBUG: ${GLEW_SHARED_LIBRARY_DEBUG}")
+  message(STATUS "FindGLEW: GLEW_STATIC_LIBRARY_DEBUG: ${GLEW_STATIC_LIBRARY_DEBUG}")
+  message(STATUS "FindGLEW: GLEW_SHARED_LIBRARY: ${GLEW_SHARED_LIBRARY}")
+  message(STATUS "FindGLEW: GLEW_STATIC_LIBRARY: ${GLEW_STATIC_LIBRARY}")
+  message(STATUS "FindGLEW: GLEW_LIBRARIES: ${GLEW_LIBRARIES}")
+endif()
+
+
+# Read version from GL/glew.h file
+if(EXISTS "${GLEW_INCLUDE_DIR}/GL/glew.h")
+  file(STRINGS "${GLEW_INCLUDE_DIR}/GL/glew.h" _contents REGEX "^VERSION_.+ [0-9]+")
+  if(_contents)
+    string(REGEX REPLACE ".*VERSION_MAJOR[ \t]+([0-9]+).*" "\\1" GLEW_VERSION_MAJOR "${_contents}")
+    string(REGEX REPLACE ".*VERSION_MINOR[ \t]+([0-9]+).*" "\\1" GLEW_VERSION_MINOR "${_contents}")
+    string(REGEX REPLACE ".*VERSION_MICRO[ \t]+([0-9]+).*" "\\1" GLEW_VERSION_MICRO "${_contents}")
+    set(GLEW_VERSION "${GLEW_VERSION_MAJOR}.${GLEW_VERSION_MINOR}.${GLEW_VERSION_MICRO}")
+  endif()
+endif()
+
+if(GLEW_VERBOSE)
+  message(STATUS "FindGLEW: GLEW_VERSION_MAJOR: ${GLEW_VERSION_MAJOR}")
+  message(STATUS "FindGLEW: GLEW_VERSION_MINOR: ${GLEW_VERSION_MINOR}")
+  message(STATUS "FindGLEW: GLEW_VERSION_MICRO: ${GLEW_VERSION_MICRO}")
+  message(STATUS "FindGLEW: GLEW_VERSION: ${GLEW_VERSION}")
+endif()
+
+find_package_handle_standard_args(GLEW
+                                  REQUIRED_VARS GLEW_INCLUDE_DIRS GLEW_LIBRARIES
+                                  VERSION_VAR GLEW_VERSION)
+
+if(NOT GLEW_FOUND)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: could not find GLEW library.")
+  endif()
+  return()
+endif()
+
+
+if(NOT TARGET GLEW::glew AND NOT GLEW_USE_STATIC_LIBS)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: Creating GLEW::glew imported target.")
+  endif()
+
+  add_library(GLEW::glew UNKNOWN IMPORTED)
+
+  set_target_properties(GLEW::glew
+                        PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${GLEW_INCLUDE_DIRS}")
+
+  if(APPLE)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL "4.0")
+      set_target_properties(GLEW::glew
+                            PROPERTIES INTERFACE_LINK_LIBRARIES "-framework OpenGL")
+    else()
+      set_target_properties(GLEW::glew
+                            PROPERTIES INTERFACE_LINK_LIBRARIES OpenGL::GL)
+    endif()
+  endif()
+
+  if(GLEW_SHARED_LIBRARY_RELEASE)
+    set_property(TARGET GLEW::glew
+                 APPEND
+                 PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+
+    set_target_properties(GLEW::glew
+                          PROPERTIES IMPORTED_LOCATION_RELEASE "${GLEW_SHARED_LIBRARY_RELEASE}")
+  endif()
+
+  if(GLEW_SHARED_LIBRARY_DEBUG)
+    set_property(TARGET GLEW::glew
+                 APPEND
+                 PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+
+    set_target_properties(GLEW::glew
+                          PROPERTIES IMPORTED_LOCATION_DEBUG "${GLEW_SHARED_LIBRARY_DEBUG}")
+  endif()
+
+elseif(NOT TARGET GLEW::glew_s AND GLEW_USE_STATIC_LIBS)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: Creating GLEW::glew_s imported target.")
+  endif()
+
+  add_library(GLEW::glew_s UNKNOWN IMPORTED)
+
+  set_target_properties(GLEW::glew_s
+                        PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${GLEW_INCLUDE_DIRS}")
+
+  set_target_properties(GLEW::glew_s PROPERTIES INTERFACE_COMPILE_DEFINITIONS GLEW_STATIC)
+
+  if(APPLE)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL "4.0")
+      set_target_properties(GLEW::glew_s
+                            PROPERTIES INTERFACE_LINK_LIBRARIES "-framework OpenGL")
+    else()
+      set_target_properties(GLEW::glew_s
+                            PROPERTIES INTERFACE_LINK_LIBRARIES OpenGL::GL)
+    endif()
+  endif()
+
+  if(GLEW_STATIC_LIBRARY_RELEASE)
+    set_property(TARGET GLEW::glew_s
+                 APPEND
+                 PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+
+    set_target_properties(GLEW::glew_s
+                          PROPERTIES IMPORTED_LOCATION_RELEASE "${GLEW_STATIC_LIBRARY_RELEASE}")
+  endif()
+
+  if(GLEW_STATIC_LIBRARY_DEBUG)
+    set_property(TARGET GLEW::glew_s
+                 APPEND
+                 PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+
+    set_target_properties(GLEW::glew_s
+                          PROPERTIES IMPORTED_LOCATION_DEBUG "${GLEW_STATIC_LIBRARY_DEBUG}")
+  endif()
+endif()
+
+if(NOT TARGET GLEW::GLEW)
+  if(GLEW_VERBOSE)
+    message(STATUS "FindGLEW: Creating GLEW::GLEW imported target.")
+  endif()
+
+  add_library(GLEW::GLEW UNKNOWN IMPORTED)
+
+  set_target_properties(GLEW::GLEW
+                        PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${GLEW_INCLUDE_DIRS}")
+
+  if(APPLE)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL "4.0")
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES INTERFACE_LINK_LIBRARIES "-framework OpenGL")
+    else()
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES INTERFACE_LINK_LIBRARIES OpenGL::GL)
+    endif()
+  endif()
+
+  if(TARGET GLEW::glew)
+    if(GLEW_SHARED_LIBRARY_RELEASE)
+      set_property(TARGET GLEW::GLEW
+                   APPEND
+                   PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES IMPORTED_LOCATION_RELEASE "${GLEW_SHARED_LIBRARY_RELEASE}")
+    endif()
+
+    if(GLEW_SHARED_LIBRARY_DEBUG)
+      set_property(TARGET GLEW::GLEW
+                   APPEND
+                   PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES IMPORTED_LOCATION_DEBUG "${GLEW_SHARED_LIBRARY_DEBUG}")
+    endif()
+
+  elseif(TARGET GLEW::glew_s)
+    if(GLEW_STATIC_LIBRARY_RELEASE)
+      set_property(TARGET GLEW::GLEW
+                   APPEND
+                   PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES IMPORTED_LOCATION_RELEASE "${GLEW_STATIC_LIBRARY_RELEASE}"
+                                       INTERFACE_COMPILE_DEFINITIONS GLEW_STATIC)
+    endif()
+
+    if(GLEW_STATIC_LIBRARY_DEBUG AND GLEW_USE_STATIC_LIBS)
+      set_property(TARGET GLEW::GLEW
+                   APPEND
+                   PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+
+      set_target_properties(GLEW::GLEW
+                            PROPERTIES IMPORTED_LOCATION_DEBUG "${GLEW_STATIC_LIBRARY_DEBUG}"
+                                       INTERFACE_COMPILE_DEFINITIONS GLEW_STATIC)
+    endif()
+
+  elseif(GLEW_VERBOSE)
+    message(WARNING "FindGLEW: no `GLEW::glew` or `GLEW::glew_s` target was created. Something went wrong in FindGLEW target creation.")
+  endif()
+endif()

deps/CGAL/CGAL.cmake

@@ -5,10 +5,10 @@ endif ()
 orcaslicer_add_cmake_project(
     CGAL
     # GIT_REPOSITORY https://github.com/CGAL/cgal.git
-    # GIT_TAG        28811b671a12b5caa9e3688569dadbc6b3728fe6 # v6.2.1
+    # GIT_TAG        3654f780ae0c64675cabaef0e5ddaf904c48b4b7 # releases/CGAL-5.6.3
     # For whatever reason, this keeps downloading forever (repeats downloads if finished)
-    URL      https://github.com/CGAL/cgal/releases/download/v6.2.1/CGAL-6.2.1.zip
-    URL_HASH SHA256=eebd737d9b7f0199647ba5c1f9f6c7a3d0651aacef9c2fd4dedc52da6c25edbe
+    URL      https://github.com/CGAL/cgal/releases/download/v5.6.3/CGAL-5.6.3.zip
+    URL_HASH SHA256=5d577acb4a9918ccb960491482da7a3838f8d363aff47e14d703f19fd84733d4
     DEPENDS dep_Boost dep_Eigen dep_GMP dep_MPFR
 )
 

deps/CMakeLists.txt

@@ -1,5 +1,5 @@
 if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "4.0")
-    set(CMAKE_POLICY_VERSION_MINIMUM 3.10 CACHE STRING "" FORCE)
+    set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "" FORCE)
 endif()
 
 #
@@ -24,7 +24,7 @@ endif()
 # therefore, unfortunately, the installation cannot be copied/moved elsewhere without re-installing wxWidgets.
 #
 
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.2)
 if (APPLE)
     # if CMAKE_OSX_DEPLOYMENT_TARGET is not set, set it to 12.0 (the lowest Xcode 27 accepts)
     if (NOT CMAKE_OSX_DEPLOYMENT_TARGET)
@@ -224,7 +224,7 @@ if (NOT IS_CROSS_COMPILE OR NOT APPLE)
         ${_source_dir_arg}
         ${_gen}
         CMAKE_ARGS
-            -DCMAKE_POLICY_VERSION_MINIMUM=3.10
+            -DCMAKE_POLICY_VERSION_MINIMUM=3.5
             -DCMAKE_INSTALL_PREFIX:STRING=${DESTDIR}
             -DCMAKE_MODULE_PATH:STRING=${PROJECT_SOURCE_DIR}/../cmake/modules
             -DCMAKE_PREFIX_PATH:STRING=${DESTDIR}
@@ -279,7 +279,7 @@ else()
         ${_source_dir_arg}
         ${_gen}
         CMAKE_ARGS
-            -DCMAKE_POLICY_VERSION_MINIMUM=3.10
+            -DCMAKE_POLICY_VERSION_MINIMUM=3.5
             -DCMAKE_INSTALL_PREFIX:STRING=${DESTDIR}
             -DCMAKE_PREFIX_PATH:STRING=${DESTDIR}
             -DCMAKE_IGNORE_PREFIX_PATH:STRING=${CMAKE_IGNORE_PREFIX_PATH}
@@ -379,8 +379,10 @@ include(Boost/Boost.cmake)
 
 include(Cereal/Cereal.cmake)
 include(Qhull/Qhull.cmake)
+include(GLEW/GLEW.cmake)
 
 include(GLFW/GLFW.cmake)
+include(OpenCSG/OpenCSG.cmake)
 set(SLVS_PKG "")
 if (SLIC3R_CAD)
     include(SLVS/SLVS.cmake)
@@ -476,6 +478,7 @@ set(_dep_list
     dep_Draco
     dep_NLopt
     dep_OpenVDB
+    dep_OpenCSG
     ${SLVS_PKG}
     dep_OpenCV
     dep_Eigen

deps/EXPAT/EXPAT.cmake

@@ -1,4 +1,6 @@
 orcaslicer_add_cmake_project(EXPAT
+  # GIT_REPOSITORY https://github.com/nigels-com/glew.git
+  # GIT_TAG 3a8eff7 # 2.1.0
   SOURCE_DIR          ${CMAKE_CURRENT_LIST_DIR}/expat
 )
 

deps/GLEW/GLEW.cmake

@@ -0,0 +1,14 @@
+# We have to check for OpenGL to compile GLEW
+set(OpenGL_GL_PREFERENCE "LEGACY") # to prevent a nasty warning by cmake
+find_package(OpenGL QUIET REQUIRED)
+
+orcaslicer_add_cmake_project(
+  GLEW
+  SOURCE_DIR  ${CMAKE_CURRENT_LIST_DIR}/glew
+  CMAKE_ARGS
+    -DGLEW_USE_EGL=OFF
+)
+
+if (MSVC)
+    add_debug_dep(dep_GLEW)
+endif ()

deps/GLEW/glew/CMakeLists.txt

@@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 3.0)
+project(GLEW)
+
+find_package(OpenGL REQUIRED)
+
+# Allow parent project to control EGL usage.
+# Default to OFF since OrcaSlicer forces GDK_BACKEND=x11 (using GLX contexts).
+# GLEW must use glXGetProcAddressARB (GLX) to match wxWidgets GL canvas.
+# Using EGL function loading with GLX contexts causes rendering failures.
+option(GLEW_USE_EGL "Use EGL instead of GLX for OpenGL function loading" OFF)
+
+if(GLEW_USE_EGL)
+    message(STATUS "Building GLEW with EGL support")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DGLEW_EGL")
+else()
+    message(STATUS "Building GLEW with GLX support")
+endif()
+
+add_library(GLEW src/glew.c)
+target_include_directories(GLEW PRIVATE include/)
+target_link_libraries(GLEW PUBLIC OpenGL::GL)
+
+if (NOT BUILD_SHARED_LIBS)
+    target_compile_definitions(GLEW PUBLIC GLEW_STATIC)
+endif ()
+
+include(GNUInstallDirs)
+
+install( 
+    FILES
+        ${PROJECT_SOURCE_DIR}/include/GL/glew.h
+        ${PROJECT_SOURCE_DIR}/include/GL/wglew.h
+        ${PROJECT_SOURCE_DIR}/include/GL/glxew.h
+        ${PROJECT_SOURCE_DIR}/include/GL/eglew.h
+    DESTINATION
+        ${CMAKE_INSTALL_INCLUDEDIR}/GL
+)
+
+install(TARGETS GLEW GLEW
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} 
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)

deps/GLEW/glew/LICENSE.txt

@@ -0,0 +1,73 @@
+The OpenGL Extension Wrangler Library
+Copyright (C) 2002-2007, Milan Ikits <milan ikits[]ieee org>
+Copyright (C) 2002-2007, Marcelo E. Magallon <mmagallo[]debian org>
+Copyright (C) 2002, Lev Povalahev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, 
+  this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, 
+  this list of conditions and the following disclaimer in the documentation 
+  and/or other materials provided with the distribution.
+* The name of the author may be used to endorse or promote products 
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Mesa 3-D graphics library
+Version:  7.0
+
+Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Copyright (c) 2007 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

deps/GLEW/glew/README.md

@@ -0,0 +1,251 @@
+# GLEW - The OpenGL Extension Wrangler Library
+
+The OpenGL Extension Wrangler Library (GLEW) is a cross-platform open-source C/C++ extension loading library. GLEW provides efficient run-time mechanisms for determining which OpenGL extensions are supported on the target platform. OpenGL core and extension functionality is exposed in a single header file. GLEW has been tested on a variety of operating systems, including Windows, Linux, Mac OS X, FreeBSD, Irix, and Solaris.
+
+![](http://glew.sourceforge.net/glew.png)
+
+http://glew.sourceforge.net/
+
+https://github.com/nigels-com/glew
+
+[![Build Status](https://travis-ci.org/nigels-com/glew.svg?branch=master)](https://travis-ci.org/nigels-com/glew)
+[![Gitter](https://badges.gitter.im/nigels-com/glew.svg)](https://gitter.im/nigels-com/glew?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![Download](https://img.shields.io/sourceforge/dm/glew.svg)](https://sourceforge.net/projects/glew/files/latest/download)
+
+## Table of Contents
+
+* [Downloads](#downloads)
+	* [Recent snapshots](#recent-snapshots)
+* [Build](#build)
+	* [Linux and Mac](#linux-and-mac)
+		* [Using GNU Make](#using-gnu-make)
+		* [Install build tools](#install-build-tools)
+		* [Build](#build-1)
+		* [Linux EGL](#linux-egl)
+		* [Linux mingw-w64](#linux-mingw-w64)
+	* [Using cmake](#using-cmake)
+		* [Install build tools](#install-build-tools-1)
+		* [Build](#build-2)
+	* [Windows](#windows)
+		* [Visual Studio](#visual-studio)
+		* [MSYS/Mingw](#msysmingw)
+		* [MSYS2/Mingw-w64](#msys2mingw-w64)
+* [glewinfo](#glewinfo)
+* [Code Generation](#code-generation)
+* [Authors](#authors)
+* [Contributions](#contributions)
+* [Copyright and Licensing](#copyright-and-licensing)
+
+## Downloads
+
+Current release is [2.1.0](https://sourceforge.net/projects/glew/files/glew/2.1.0/).
+[(Change Log)](http://glew.sourceforge.net/log.html)
+
+Sources available as
+[ZIP](https://sourceforge.net/projects/glew/files/glew/2.1.0/glew-2.1.0.zip/download) or
+[TGZ](https://sourceforge.net/projects/glew/files/glew/2.1.0/glew-2.1.0.tgz/download).
+
+Windows binaries for [32-bit and 64-bit](https://sourceforge.net/projects/glew/files/glew/2.1.0/glew-2.1.0-win32.zip/download).
+
+### Recent snapshots
+
+Snapshots may contain new features, bug-fixes or new OpenGL extensions ahead of tested, official releases.
+
+[glew-20200115.tgz](https://sourceforge.net/projects/glew/files/glew/snapshots/glew-20200115.tgz/download) *GLEW 2.2.0 RC3: fixes*
+
+[glew-20190928.tgz](https://sourceforge.net/projects/glew/files/glew/snapshots/glew-20190928.tgz/download) *GLEW 2.2.0 RC2: New extensions, bug fixes*
+
+## Build
+
+It is highly recommended to build from a tgz or zip release snapshot.
+The code generation workflow is a complex brew of gnu make, perl and python, that works best on Linux or Mac.
+The code generation is known to work on Windows using [MSYS2](https://www.msys2.org/).
+For most end-users of GLEW the official releases are the best choice, with first class support.
+
+### Linux and Mac
+
+#### Using GNU Make
+
+GNU make is the primary build system for GLEW, historically.
+It includes targets for building the sources and headers, for maintenance purposes.
+
+##### Install build tools
+
+Debian/Ubuntu/Mint:    `$ sudo apt-get install build-essential libxmu-dev libxi-dev libgl-dev`
+
+RedHat/CentOS/Fedora:  `$ sudo yum install libXmu-devel libXi-devel libGL-devel`
+
+FreeBSD: `# pkg install xorg lang/gcc git cmake gmake bash python perl5`
+
+##### Build
+
+	$ make
+	$ sudo make install
+	$ make clean
+
+Targets:    `all, glew.lib (sub-targets: glew.lib.shared, glew.lib.static), glew.bin, clean, install, uninstall`
+
+Variables:  `SYSTEM=linux-clang, GLEW_DEST=/usr/local, STRIP=`
+
+_Note: you may need to call `make` in the  **auto** folder first_
+
+##### Linux EGL
+
+	$ sudo apt install libegl1-mesa-dev
+	$ make SYSTEM=linux-egl
+
+##### Linux mingw-w64
+
+	$ sudo apt install mingw-w64
+	$ make SYSTEM=linux-mingw32
+	$ make SYSTEM=linux-mingw64
+
+#### Using cmake
+
+The cmake build is mostly contributer maintained.
+Due to the multitude of use cases this is maintained on a _best effort_ basis.
+Pull requests are welcome.
+
+*CMake 2.8.12 or higher is required.*
+
+##### Install build tools
+
+Debian/Ubuntu/Mint:   `$ sudo apt-get install build-essential libxmu-dev libxi-dev libgl-dev cmake git`
+
+RedHat/CentOS/Fedora: `$ sudo yum install libXmu-devel libXi-devel libGL-devel cmake git`
+
+##### Build
+
+	$ cd build
+	$ cmake ./cmake
+	$ make -j4
+
+| Target     | Description |
+| ---------- | ----------- |
+| glew       | Build the glew shared library. |
+| glew_s     | Build the glew static library. |
+| glewinfo   | Build the `glewinfo` executable (requires `BUILD_UTILS` to be `ON`). |
+| visualinfo | Build the `visualinfo` executable (requires `BUILD_UTILS` to be `ON`). |
+| install    | Install all enabled targets into `CMAKE_INSTALL_PREFIX`. |
+| clean      | Clean up build artifacts. |
+| all        | Build all enabled targets (default target). |
+
+| Variables       | Description |
+| --------------- | ----------- |
+| BUILD_UTILS     | Build the `glewinfo` and `visualinfo` executables. |
+| GLEW_REGAL      | Build in Regal mode. |
+| BUILD_FRAMEWORK | Build as MacOSX Framework.  Setting `CMAKE_INSTALL_PREFIX` to `/Library/Frameworks` is recommended. |
+
+### Windows
+
+#### Visual Studio
+
+Use the provided Visual Studio project file in build/vc15/
+
+Projects for vc6, vc10, vc12 and vc14 are also provided
+
+#### MSYS/Mingw
+
+Available from [Mingw](http://www.mingw.org/)
+
+Requirements: bash, make, gcc
+
+	$ mingw32-make
+	$ mingw32-make install
+	$ mingw32-make install.all
+
+Alternative toolchain:  `SYSTEM=mingw-win32`
+
+#### MSYS2/Mingw-w64
+
+Available from [Msys2](http://msys2.github.io/) and/or [Mingw-w64](http://mingw-w64.org/)
+
+Requirements: bash, make, gcc
+
+	$ pacman -S gcc make mingw-w64-i686-gcc mingw-w64-x86_64-gcc
+	$ make
+	$ make install
+	$ make install.all
+
+Alternative toolchain:  `SYSTEM=msys, SYSTEM=msys-win32, SYSTEM=msys-win64`
+
+## glewinfo
+
+`glewinfo` is a command-line tool useful for inspecting the capabilities of an
+OpenGL implementation and GLEW support for that.  Please include `glewinfo.txt`
+with bug reports, as appropriate.
+
+	---------------------------
+	    GLEW Extension Info
+	---------------------------
+
+	GLEW version 2.0.0
+	Reporting capabilities of pixelformat 3
+	Running on a Intel(R) HD Graphics 3000 from Intel
+	OpenGL version 3.1.0 - Build 9.17.10.4229 is supported
+
+	GL_VERSION_1_1:                                                OK
+	---------------
+
+	GL_VERSION_1_2:                                                OK
+	---------------
+	  glCopyTexSubImage3D:                                         OK
+	  glDrawRangeElements:                                         OK
+	  glTexImage3D:                                                OK
+	  glTexSubImage3D:                                             OK
+
+	...
+
+## Code Generation
+
+A Unix or Mac environment is needed for building GLEW from scratch to
+include new extensions, or customize the code generation. The extension
+data is regenerated from the top level source directory with:
+
+	make extensions
+
+An alternative to generating the GLEW sources from scratch is to
+download a pre-generated (unsupported) snapshot:
+
+https://sourceforge.net/projects/glew/files/glew/snapshots/
+
+## Authors
+
+GLEW is currently maintained by [Nigel Stewart](https://github.com/nigels-com)
+with bug fixes, new OpenGL extension support and new releases.
+
+GLEW was developed by [Milan Ikits](http://www.cs.utah.edu/~ikits/)
+and [Marcelo Magallon](http://wwwvis.informatik.uni-stuttgart.de/~magallon/).
+Aaron Lefohn, Joe Kniss, and Chris Wyman were the first users and also
+assisted with the design and debugging process.
+
+The acronym GLEW originates from Aaron Lefohn.
+Pasi Kärkkäinen identified and fixed several problems with
+GLX and SDL.  Nate Robins created the `wglinfo` utility, to
+which modifications were made by Michael Wimmer.
+
+## Contributions
+
+GLEW welcomes community contributions.  Typically these are co-ordinated
+via [Issues](https://github.com/nigels-com/glew/issues) or
+[Pull Requests](https://github.com/nigels-com/glew/pulls) in the
+GitHub web interface.
+
+Be sure to mention platform and compiler toolchain details when filing
+a bug report.  The output of `glewinfo` can be quite useful for discussion
+also.
+
+Generally GLEW is usually released once a year, around the time of the Siggraph
+computer graphics conference.  If you're not using the current release
+version of GLEW, be sure to check if the issue or bug is fixed there.
+
+## Copyright and Licensing
+
+GLEW is originally derived from the EXTGL project by Lev Povalahev.
+The source code is licensed under the
+[Modified BSD License](http://glew.sourceforge.net/glew.txt), the
+[Mesa 3-D License](http://glew.sourceforge.net/mesa.txt) (MIT) and the
+[Khronos License](http://glew.sourceforge.net/khronos.txt) (MIT).
+
+The automatic code generation scripts are released under the
+[GNU GPL](http://glew.sourceforge.net/gpl.txt).

deps/GLEW/glew/VERSION

@@ -0,0 +1 @@
+2.2.0

deps/OCCT/0001-BRepMesh-seam-pcurve-at-edge-parameter.patch

@@ -1,28 +0,0 @@
-diff --git a/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_ModelPreProcessor.cxx b/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_ModelPreProcessor.cxx
-index 6f63781..9b1c08e 100644
---- a/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_ModelPreProcessor.cxx
-+++ b/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_ModelPreProcessor.cxx
-@@ -210,10 +210,10 @@ private:
- 
-     // Define two pcurves of the seam-edge.
-     occ::handle<Geom2d_Curve> aPC1, aPC2;
--    double                    af, al;
-+    double                    af, al, af1, al1;
- 
-     aE.Orientation(TopAbs_FORWARD);
--    aPC1 = BRep_Tool::CurveOnSurface(aE, aF, af, al);
-+    aPC1 = BRep_Tool::CurveOnSurface(aE, aF, af1, al1);
- 
-     aE.Orientation(TopAbs_REVERSED);
-     aPC2 = BRep_Tool::CurveOnSurface(aE, aF, af, al);
-@@ -224,7 +224,9 @@ private:
-     }
- 
-     // Select the correct pcurve of the seam-edge.
--    const gp_Pnt2d& aFPntOfPC1 = aPC1->Value(aPC1->FirstParameter());
-+    // Use the edge's first parameter. A Geom2d_Line's FirstParameter() is -Precision::Infinite(),
-+    // where a direction of (2e-16, -1) from rounding error gives an X far outside the U range.
-+    const gp_Pnt2d aFPntOfPC1 = aPC1->Value(af1);
- 
-     if (std::abs(aLPntOfIPC1.X() - aFPntOfPC1.X()) > Precision::Confusion())
-     {

deps/OCCT/OCCT.cmake

@@ -25,16 +25,9 @@ endif()
 # shipped bytes. Windows ships only the DLLs libslic3r links, so the tab adds the TKFillet,
 # TKOffset and TKBool DLLs. See docs/HLSD/design-tab.md.
 
-if (IN_GIT_REPO)
-    set(OCCT_DIRECTORY_FLAG --directory ${BINARY_DIR_REL}/dep_OCCT-prefix/src/dep_OCCT)
-endif ()
-
 orcaslicer_add_cmake_project(OCCT
     URL https://github.com/Open-Cascade-SAS/OCCT/archive/refs/tags/V8_0_1.zip
     URL_HASH SHA256=7c033d917ee8f040c0512d289dcc5f02c148889d5bac17c3e25639accb44f0da
-    # Makes BRepMesh triangulate cone faces whose seam pcurve is slightly tilted
-    # (Open-Cascade-SAS/OCCT#572); remove the patch once an OCCT release includes the fix.
-    PATCH_COMMAND git apply ${OCCT_DIRECTORY_FLAG} --verbose --ignore-space-change --whitespace=fix ${CMAKE_CURRENT_LIST_DIR}/0001-BRepMesh-seam-pcurve-at-edge-parameter.patch
     #DEPENDS dep_Boost
     DEPENDS ${FREETYPE_PKG}
     CMAKE_ARGS

deps/OpenCSG/CMakeLists.txt.in

@@ -0,0 +1,101 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(OpenCSG)
+
+if (NOT BUILD_SHARED_LIBS)
+  set(GLEW_USE_STATIC_LIBS ON)
+elseif (MSVC)
+  set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+endif()
+
+find_package(OpenGL REQUIRED)
+
+set(GLEW_VERBOSE ON)
+find_package(GLEW 1.13.0 REQUIRED)
+
+set(_srcfiles 
+    src/area.cpp
+    src/batch.cpp
+    src/context.cpp
+    src/channelManager.cpp
+    src/frameBufferObject.cpp
+    src/frameBufferObjectExt.cpp
+    src/occlusionQuery.cpp
+    src/opencsgRender.cpp
+    src/openglHelper.cpp
+    src/pBufferTexture.cpp
+    src/primitive.cpp
+    src/primitiveHelper.cpp
+    src/renderGoldfeather.cpp
+    src/renderSCS.cpp
+    src/scissorMemo.cpp
+    src/settings.cpp
+    src/stencilManager.cpp
+    RenderTexture/RenderTexture.cpp
+    include/opencsg.h
+    src/opencsgConfig.h
+    src/area.h
+    src/batch.h
+    src/context.h
+    src/channelManager.h
+    src/frameBufferObject.h
+    src/frameBufferObjectExt.h
+    src/occlusionQuery.h
+    src/offscreenBuffer.h
+    src/opencsgRender.h
+    src/openglHelper.h
+    src/pBufferTexture.h
+    src/primitiveHelper.h
+    src/scissorMemo.h
+    src/settings.h
+    src/stencilManager.h
+)
+
+add_library(opencsg ${_srcfiles})
+target_include_directories(opencsg PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
+target_include_directories(opencsg PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>)
+target_link_libraries(opencsg PRIVATE GLEW::GLEW OpenGL::GL)
+
+include(CMakePackageConfigHelpers)
+
+include(GNUInstallDirs)
+
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"     
+    VERSION 1.4.2
+    COMPATIBILITY AnyNewerVersion
+)
+
+install(TARGETS opencsg 
+  EXPORT ${PROJECT_NAME}Targets
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} 
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+export(EXPORT ${PROJECT_NAME}Targets 
+       FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" 
+       NAMESPACE ${PROJECT_NAME}:: )
+
+set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+
+install(EXPORT ${PROJECT_NAME}Targets
+  FILE
+    "${PROJECT_NAME}Config.cmake"
+  NAMESPACE
+    ${PROJECT_NAME}::
+  DESTINATION
+    ${ConfigPackageLocation}
+)
+install(
+    FILES
+      ${PROJECT_SOURCE_DIR}/include/opencsg.h 
+    DESTINATION
+      ${CMAKE_INSTALL_INCLUDEDIR}/opencsg
+)
+install(
+    FILES
+      "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
+    DESTINATION
+      ${ConfigPackageLocation}
+)

deps/OpenCSG/OpenCSG.cmake

@@ -0,0 +1,17 @@
+
+orcaslicer_add_cmake_project(OpenCSG
+    # GIT_REPOSITORY https://github.com/floriankirsch/OpenCSG.git
+    # GIT_TAG 83e274457b46c9ad11a4ee599203250b1618f3b9 #v1.4.2
+    URL https://github.com/floriankirsch/OpenCSG/archive/refs/tags/opencsg-1-4-2-release.zip
+    URL_HASH SHA256=51afe0db79af8386e2027d56d685177135581e0ee82ade9d7f2caff8deab5ec5
+    PATCH_COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/CMakeLists.txt.in ./CMakeLists.txt
+    DEPENDS dep_GLEW
+)
+
+if (TARGET ${ZLIB_PKG})
+    add_dependencies(dep_OpenCSG ${ZLIB_PKG})
+endif()
+
+if (MSVC)
+    add_debug_dep(dep_OpenCSG)
+endif ()

deps/OpenSSL/OpenSSL.cmake

@@ -44,18 +44,6 @@ else()
     if(APPLE)
         set(_conf_cmd export MACOSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET} && ./Configure -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET})
     else()
-        # A static library that is embedded into a shared object must not export
-        # its symbols. On Linux the running process also loads the system OpenSSL
-        # 3.x (WebKitGTK/gnutls pull in libcrypto.so.3), and CPython's _ssl and
-        # _hashlib are dlopened (RTLD_LOCAL) DSOs that each embed this OpenSSL.
-        # With default visibility their unversioned OpenSSL references are
-        # preempted by that global 3.x copy, mixing the 1.1.1 and 3.x ABIs and
-        # corrupting the heap (ssl.create_default_context() aborts). Hidden
-        # visibility makes each embedded copy self-contained. Linux-only: macOS
-        # binds dylibs with a two-level namespace (no interposition) and ships no
-        # OpenSSL, and Windows has no equivalent flag and no system OpenSSL to
-        # collide with.
-        set(_openssl_extra_cflags -fvisibility=hidden)
         set(_conf_cmd env "CC=${CMAKE_C_COMPILER}" "LDFLAGS=${CMAKE_EXE_LINKER_FLAGS}" "./config")
     endif()
     set(_cross_comp_prefix_line "")
@@ -114,20 +102,3 @@ ExternalProject_Add_Step(dep_OpenSSL install_cmake_files
     COMMAND ${CMAKE_COMMAND} -E copy_directory openssl "${DESTDIR}${CMAKE_INSTALL_LIBDIR}/cmake/openssl"
     WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}"
 )
-
-if (NOT WIN32 AND NOT APPLE)
-    # OpenSSL's object rules do not depend on CFLAGS, so reconfiguring it (for
-    # example to add -fvisibility=hidden) relinks the archives from stale
-    # objects instead of recompiling them, and the change silently has no
-    # effect. Drop the objects whenever this recipe changes so the next build
-    # actually recompiles them.
-    ExternalProject_Get_Property(dep_OpenSSL SOURCE_DIR)
-    ExternalProject_Add_Step(dep_OpenSSL clean_objects
-        DEPENDEES configure
-        DEPENDERS build
-        COMMAND make clean
-        WORKING_DIRECTORY "${SOURCE_DIR}"
-        DEPENDS "${CMAKE_CURRENT_LIST_FILE}"
-        COMMENT "OpenSSL: cleaning objects after a recipe change"
-    )
-endif ()

deps/python3/python3.cmake

@@ -299,27 +299,3 @@ endif()
 if(TARGET dep_ZLIB)
     add_dependencies(dep_python3 dep_ZLIB)
 endif()
-
-if (NOT WIN32 AND NOT APPLE)
-    # CPython's Makefile rules for _ssl and _hashlib depend only on their own
-    # sources, not on the OpenSSL archives, so a rebuilt OpenSSL does not make
-    # them relink and they keep the previous symbols. On an incremental tree,
-    # drop the built modules and relink them against the current OpenSSL; a
-    # fresh build is left alone (its PGO target builds them). "make" alone is a
-    # no-op once PGO has run, so sharedmods is invoked explicitly.
-    ExternalProject_Get_Property(dep_python3 SOURCE_DIR)
-    file(GLOB _python_ssl_modules
-        "${SOURCE_DIR}/Modules/_ssl*.so"
-        "${SOURCE_DIR}/Modules/_hashlib*.so")
-    if (_python_ssl_modules)
-        ExternalProject_Add_Step(dep_python3 relink_ssl_extensions
-            DEPENDEES configure
-            DEPENDERS build
-            COMMAND sh -c "rm -f '${SOURCE_DIR}'/Modules/_ssl*.so '${SOURCE_DIR}'/Modules/_hashlib*.so && make -j${NPROC} sharedmods"
-            WORKING_DIRECTORY "${SOURCE_DIR}"
-            COMMENT "CPython: relinking _ssl/_hashlib against the current OpenSSL"
-            DEPENDS "${CMAKE_CURRENT_LIST_FILE}"
-                    "${CMAKE_CURRENT_LIST_DIR}/../OpenSSL/OpenSSL.cmake"
-        )
-    endif ()
-endif ()

deps_src/libigl/igl/copyleft/cgal/CGAL_includes.hpp

@@ -33,8 +33,8 @@
 
 // Axis-aligned bounding box tree for tet tri intersection
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 
 // Boolean operations
 #include <CGAL/Polyhedron_3.h>

deps_src/libigl/igl/copyleft/cgal/closest_facet.cpp

@@ -41,9 +41,9 @@ IGL_INLINE void igl::copyleft::cgal::closest_facet(
     const std::vector<std::vector<size_t> > & VF,
     const std::vector<std::vector<size_t> > & VFi,
     const CGAL::AABB_tree<
-      CGAL::AABB_traits_3<
+      CGAL::AABB_traits<
         Kernel, 
-        CGAL::AABB_triangle_primitive_3<
+        CGAL::AABB_triangle_primitive<
           Kernel, typename std::vector<
             typename Kernel::Triangle_3 >::iterator > > > & tree,
     const std::vector<typename Kernel::Triangle_3 > & triangles,
@@ -56,8 +56,8 @@ IGL_INLINE void igl::copyleft::cgal::closest_facet(
   typedef typename Kernel::Segment_3 Segment_3;
   typedef typename Kernel::Triangle_3 Triangle;
   typedef typename std::vector<Triangle>::iterator Iterator;
-  typedef typename CGAL::AABB_triangle_primitive_3<Kernel, Iterator> Primitive;
-  typedef typename CGAL::AABB_traits_3<Kernel, Primitive> AABB_triangle_traits;
+  typedef typename CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
+  typedef typename CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
   typedef typename CGAL::AABB_tree<AABB_triangle_traits> Tree;
 
   if (F.rows() <= 0 || I.rows() <= 0) {
@@ -451,8 +451,8 @@ IGL_INLINE void igl::copyleft::cgal::closest_facet(
   typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel;
   typedef Kernel::Triangle_3 Triangle;
   typedef std::vector<Triangle>::iterator Iterator;
-  typedef CGAL::AABB_triangle_primitive_3<Kernel, Iterator> Primitive;
-  typedef CGAL::AABB_traits_3<Kernel, Primitive> AABB_triangle_traits;
+  typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
+  typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
   typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
 
   if (F.rows() <= 0 || I.rows() <= 0) {
@@ -498,9 +498,9 @@ IGL_INLINE void igl::copyleft::cgal::closest_facet(
 #ifdef IGL_STATIC_LIBRARY
 // Explicit template instantiation
 // generated by autoexplicit.sh
-template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 1, -1, 3>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>>::iterator, CGAL::Boolean_tag<false>>, CGAL::Default>> const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>> const&, std::vector<bool, std::allocator<bool>> const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&);
+template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 1, -1, 3>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>>::iterator, CGAL::Boolean_tag<false>>, CGAL::Default>> const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>> const&, std::vector<bool, std::allocator<bool>> const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&);
 // generated by autoexplicit.sh
-template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>>::iterator, CGAL::Boolean_tag<false>>, CGAL::Default>> const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>> const&, std::vector<bool, std::allocator<bool>> const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&);
+template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, 3, 0, -1, 3>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, std::vector<std::vector<size_t, std::allocator<size_t>>, std::allocator<std::vector<size_t, std::allocator<size_t>>>> const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>>::iterator, CGAL::Boolean_tag<false>>, CGAL::Default>> const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3>> const&, std::vector<bool, std::allocator<bool>> const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1>>&);
 // generated by autoexplicit.sh
 template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(
     Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1> > const&, 
@@ -509,7 +509,7 @@ template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT,
     Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 1, -1, -1> > const&, 
     Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, 
     Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, 
-    Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> > const&, std::vector<bool, std::allocator<bool> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&);
+    Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> > const&, std::vector<bool, std::allocator<bool> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&);
 #include <cstdint>
 template void igl::copyleft::cgal::closest_facet<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, CGAL::Epeck, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(
 Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1> > const&, 
@@ -518,7 +518,7 @@ Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&,
 Eigen::MatrixBase<Eigen::Matrix<CGAL::Epeck::FT, -1, -1, 0, -1, -1> > const&, 
 Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, 
 Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, 
-Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, CGAL::AABB_tree<CGAL::AABB_traits_3<CGAL::Epeck, CGAL::AABB_triangle_primitive_3<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> > const&, std::vector<bool, std::allocator<bool> > const&, 
+Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, std::vector<std::vector<size_t, std::allocator<size_t> >, std::allocator<std::vector<size_t, std::allocator<size_t> > > > const&, CGAL::AABB_tree<CGAL::AABB_traits<CGAL::Epeck, CGAL::AABB_triangle_primitive<CGAL::Epeck, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> >::iterator, CGAL::Boolean_tag<false> >, CGAL::Default> > const&, std::vector<CGAL::Epeck::Triangle_3, std::allocator<CGAL::Epeck::Triangle_3> > const&, std::vector<bool, std::allocator<bool> > const&, 
 Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, 
 Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&);
 

deps_src/libigl/igl/copyleft/cgal/closest_facet.h

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

deps_src/libigl/igl/copyleft/cgal/component_inside_component.cpp

@@ -12,8 +12,8 @@
 #include "points_inside_component.h"
 
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 
 #include <cassert>

deps_src/libigl/igl/copyleft/cgal/extract_cells.cpp

@@ -23,8 +23,8 @@
 #include "../../vertex_triangle_adjacency.h"
 
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/intersections.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 
@@ -156,9 +156,9 @@ IGL_INLINE size_t igl::copyleft::cgal::extract_cells(
   std::vector<VectorXI> Is(num_components);
   std::vector<
     CGAL::AABB_tree<
-      CGAL::AABB_traits_3<
+      CGAL::AABB_traits<
         Kernel,
-        CGAL::AABB_triangle_primitive_3<
+        CGAL::AABB_triangle_primitive<
           Kernel, std::vector<
             Kernel::Triangle_3 >::iterator > > > > trees(num_components);
   std::vector< std::vector<Kernel::Triangle_3 > >

deps_src/libigl/igl/copyleft/cgal/hausdorff.cpp

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

deps_src/libigl/igl/copyleft/cgal/hausdorff.h

@@ -38,8 +38,8 @@ namespace igl
       IGL_INLINE void hausdorff(
         const Eigen::MatrixBase<DerivedV>& V,
         const CGAL::AABB_tree<
-          CGAL::AABB_traits_3<Kernel, 
-            CGAL::AABB_triangle_primitive_3<Kernel, 
+          CGAL::AABB_traits<Kernel, 
+            CGAL::AABB_triangle_primitive<Kernel, 
               typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
             >
           >

deps_src/libigl/igl/copyleft/cgal/outer_hull.cpp

@@ -12,8 +12,8 @@
 #include "../../remove_unreferenced.h"
 
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/intersections.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 

deps_src/libigl/igl/copyleft/cgal/outer_hull_legacy.cpp

@@ -12,8 +12,8 @@
 #include "../../remove_unreferenced.h"
 
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/intersections.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 

deps_src/libigl/igl/copyleft/cgal/point_mesh_squared_distance.cpp

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

deps_src/libigl/igl/copyleft/cgal/point_mesh_squared_distance.h

@@ -63,8 +63,8 @@ namespace igl
         const Eigen::MatrixBase<DerivedV> & V,
         const Eigen::MatrixBase<DerivedF> & F,
         CGAL::AABB_tree<
-          CGAL::AABB_traits_3<Kernel, 
-            CGAL::AABB_triangle_primitive_3<Kernel, 
+          CGAL::AABB_traits<Kernel, 
+            CGAL::AABB_triangle_primitive<Kernel, 
               typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
             >
           >
@@ -89,8 +89,8 @@ namespace igl
       IGL_INLINE void point_mesh_squared_distance(
         const Eigen::MatrixBase<DerivedP> & P,
         const CGAL::AABB_tree<
-          CGAL::AABB_traits_3<Kernel, 
-            CGAL::AABB_triangle_primitive_3<Kernel, 
+          CGAL::AABB_traits<Kernel, 
+            CGAL::AABB_triangle_primitive<Kernel, 
               typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
             >
           >

deps_src/libigl/igl/copyleft/cgal/points_inside_component.cpp

@@ -13,8 +13,8 @@
 #include "assign_scalar.h"
 
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 
 #include <cassert>
@@ -35,8 +35,8 @@ namespace igl {
             typedef Kernel::Triangle_3 Triangle;
             typedef Kernel::Plane_3 Plane_3;
             typedef std::vector<Triangle>::iterator Iterator;
-            typedef CGAL::AABB_triangle_primitive_3<Kernel, Iterator> Primitive;
-            typedef CGAL::AABB_traits_3<Kernel, Primitive> AABB_triangle_traits;
+            typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
+            typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
             typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
 
             template<typename DerivedF, typename DerivedI>

deps_src/libigl/igl/copyleft/cgal/signed_distance_isosurface.cpp

@@ -23,8 +23,8 @@
 #include <CGAL/IO/output_surface_facets_to_polyhedron.h>
 // Axis-aligned bounding box tree for tet tri intersection
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <vector>
 
 IGL_INLINE bool igl::copyleft::cgal::signed_distance_isosurface(

deps_src/libigl/igl/copyleft/cgal/submesh_aabb_tree.cpp

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

deps_src/libigl/igl/copyleft/cgal/submesh_aabb_tree.h

@@ -14,8 +14,8 @@
 #include <vector>
 
 #include <CGAL/AABB_tree.h>
-#include <CGAL/AABB_traits_3.h>
-#include <CGAL/AABB_triangle_primitive_3.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_triangle_primitive.h>
 #include <CGAL/intersections.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 
@@ -44,9 +44,9 @@ namespace igl
         const Eigen::MatrixBase<DerivedF>& F,
         const Eigen::MatrixBase<DerivedI>& I,
         CGAL::AABB_tree<
-          CGAL::AABB_traits_3<
+          CGAL::AABB_traits<
             Kernel, 
-            CGAL::AABB_triangle_primitive_3<
+            CGAL::AABB_triangle_primitive<
               Kernel, typename std::vector<
                 typename Kernel::Triangle_3 >::iterator > > > & tree,
         std::vector<typename Kernel::Triangle_3 > & triangles,

deps_src/libnest2d/include/libnest2d/placers/nfpplacer.hpp

@@ -88,18 +88,6 @@ struct NfpPConfig {
      */
     bool explore_holes = false;
 
-    /**
-     * @brief Keep the final pile on the bin.
-     *
-     * The final alignment centres the pile on the alignment target. A target
-     * near an edge (a belt printer starts its parts at the leading end of the
-     * belt) would push part of a pile that is larger than the room around that
-     * point off the bed; with this set the pile stops at the edge instead, and a
-     * pile that does not fit along an axis is centred on it. Off by default, so
-     * the alignment of every other printer is unchanged.
-     */
-    bool clamp_to_bin = false;
-
     /**
      * @brief If true, use all CPUs available. Run on a single core otherwise.
      */
@@ -1123,24 +1111,7 @@ private:
         default: ; // DONT_ALIGN
         }
 
-        auto d = cb - ci;
-
-        // Keep the pile on the bin (see Config::clamp_to_bin). The items' boxes carry
-        // their inflation, which is the margin left at the edge.
-        if (config_.clamp_to_bin) {
-            auto on_bin = [](Coord lo, Coord hi, Coord bin_lo, Coord bin_hi, Coord shift) {
-                if (hi - lo >= bin_hi - bin_lo)
-                    return (bin_lo + bin_hi) / 2 - (lo + hi) / 2;
-                if (lo + shift < bin_lo)
-                    shift = bin_lo - lo;
-                if (hi + shift > bin_hi)
-                    shift = bin_hi - hi;
-                return shift;
-            };
-            setX(d, on_bin(getX(bb.minCorner()), getX(bb.maxCorner()), getX(bbin.minCorner()), getX(bbin.maxCorner()), getX(d)));
-            setY(d, on_bin(getY(bb.minCorner()), getY(bb.maxCorner()), getY(bbin.minCorner()), getY(bbin.maxCorner()), getY(d)));
-            cb = ci + d;
-        }
+        auto d = cb - ci;       
 
         // BBS make sure the item won't clash with excluded regions
         // do we have wipe tower after arranging?

deps_src/mcut/include/mcut/internal/tpool.h

@@ -191,7 +191,7 @@ public:
             tail->next = std::move(p);
             tail = new_tail;
         }
-        disrupt_wait_for_data();
+        data_cond.notify_one();
     }
 
     void wait_and_pop(T& value)

docs/HLSD/adaptive-tpms-infill.md

@@ -1,221 +0,0 @@
-# Adaptive TPMS infill — High Level Design
-
-## Purpose and scope
-
-`tpms_adaptive` grades the sparse infill of the Gyroid, TPMS-D and TPMS-FK
-patterns inside the object: the cells grow continuously from the surface
-towards the center of the object. `distance_warp`, `smooth_blend` and
-`stepped_shells` follow the distance to the nearest surface, including the top
-and bottom, like concentric shells; `lobes` follows the whole 3D shape towards
-the center of each lobe of the object; `normal_z`, `normal_y` and `normal_x`
-follow each section of the object normal to that axis, so the grading does not
-change along the axis, as suits a profile extruded along it.
-`sparse_infill_density` is the density at the surface, `tpms_interior_density`
-the density at the center, and `tpms_adaptive_gradient` picks how the density
-goes from one to the other. Only internal sparse infill is graded; the Gyroid
-Z-buckling optimization does not apply to it.
-
-The design has two parts: a field built once per object, and a pattern made
-from it, warped around the center of each lobe of a body so that its cell size
-follows the field, or, in the modes following the distance to the surface,
-split into shells or blended between densities.
-
-## Radial field
-
-`TpmsRadialField` gives every point of an object the center of its lobe and a
-radial coordinate: 0 at the center, 1 at the surface along the ray from the
-center. `PrintObject::prepare_tpms_radial_fields()` builds it in
-`bridge_over_infill()`, next to the adaptive cubic octree, because the anchoring
-infill generated there has to match the printed infill. A field is built for
-every mode a region uses, and is shared by the regions using that mode: the
-field depends on the geometry only, the densities are applied per region in the
-fill. An object thinner than the grid cells has no body in the field; no field
-is kept then, and the infill falls back to the regular pattern. In the modes
-following the distance to the surface, the field also gives the depth of every
-point (see below).
-
-A regular 3D grid of cubic cells is rasterized from the `lslices` of the layers,
-so the field follows what is printed: negative volumes, the union of
-overlapping parts and holes are taken into account, and the mesh does not need
-to be closed. A padding node around the grid is always outside. The grid is
-capped at about a million nodes, with cells no smaller than 0.5 mm.
-
-- Bodies are the connected inside nodes. Each is graded on its own, so separate
-  parts of one object each get their own sparse center.
-- A body is split into lobes around the local maxima of the depth, by an exact
-  Euclidean distance transform (Felzenszwalb and Huttenlocher, one pass per
-  axis). Two maxima are in separate lobes when the depth along the segment
-  between them drops below 0.8 of the shallower one, like at the neck between
-  two united spheres; maxima shallower than 0.3 of the deepest one are ignored.
-  A maximum joins the first lobe whose first maximum it sees without a neck.
-  The lobes are made one at a time, the remaining maxima tested against the
-  first one in parallel, as a plate has a whole plane of them.
-  Where the depth ties along a line or a plane, as in a tall box, the lobe's
-  center is the node nearest to the middle of the tied nodes, so the center is
-  in the middle of the height and not a column.
-- A point belongs to the lobe it is nearest to relative to their depths, so the
-  side between two lobes is nearer to the smaller one. Near that side, within a
-  tenth of that relative distance, the patterns of the lobes morph into each
-  other, so the lines stay continuous. Every lobe in that range takes part, up
-  to four, so the morph is also continuous where three or four lobes meet.
-- The reach of a lobe is the distance from its center to the first exit along
-  24 x 48 latitude-longitude directions, smoothed twice over neighbouring
-  directions in log space. Towards a neighbouring lobe it stops at twice the
-  distance to the side between them, so that side is graded half way, as deep
-  as a neck is, rather than as sparse as the center or as dense as the surface.
-  Only the lobes whose centers are near enough to be nearer at the current
-  distance are compared along a ray, so many lobes, as in a perforated plate,
-  stay cheap.
-  The radial coordinate of a point is its distance to the center over the reach
-  in its direction. Behind a gap, as across the hole
-  of a ring, the radial coordinate is above 1 and the infill keeps the surface
-  density.
-- Every outside node belongs to its nearest body, so points near a surface find
-  their body without a search. With a single body, all nodes belong to it.
-
-In the 2D modes, every plane of nodes normal to the axis is a field of its own:
-the distance transform skips the axis, bodies, lobes and the nearest body are
-found within the plane, and the reach is sampled on a circle of 48 directions.
-A point is looked up in the two planes around it, the weights of their lobes
-interpolated along the axis, so the grading does not step between planes; a
-plane without a body uses the nearest one that has one. The planes are a cell
-apart, not a layer: where the sections change abruptly, as at a step, the
-patterns of the two planes morph into each other over that cell.
-
-A distance to the nearest surface would be the obvious field, but no smooth map
-follows it. By the divergence theorem, the mean scale of a map over a body is
-fixed by its values on the surface: a map that keeps the full density along the
-whole surface, as the distance would ask under the top and bottom, has the mean
-density of the uniform infill, the sparser core being paid for by lines crowding
-along the walls. The layers of a plate at different depths would also need
-different line spacings in the same directions, which no continuous map allows
-without shearing across the plate. Following the distance needs changes of the
-topology of the lattice (see below). The radial coordinate instead grades what a
-single map can: towards one point.
-
-## Warped pattern
-
-The pattern is evaluated on warped coordinates:
-
-    TPMS(f_surface * m(t) * (p - center))
-
-where `m` scales the pattern around the center of the lobe: its frequency is
-`m + t * m'` along the ray and `m` across it. `m(t)` is the mean of the target
-scale over the ball of radius `t`, `3 / t^3 * integral of s^2 * target(s) ds`, so
-the mean of the three, and with it the density, follows the gradient. The cells
-are round at the center; near the surface they are flattened, with the lines
-running parallel to it. Beyond the surface the target is the surface scale, so
-the warp extends continuously outside.
-
-In the 2D modes only the coordinates within the plane are warped, and `m(t)` is
-the mean over the disc, `2 / t^2 * integral of s * target(s) ds`. Along the axis
-the pattern keeps the interior frequency: scaling it with `m` would shear the
-pattern by the distance along the axis times the gradient of `m`, without bound
-on a long object. The cells are round at the center and stretched along the
-axis near the surface. With Normal Z the layers are graded exactly, since
-the lines of a layer follow its in-plane frequencies; normal to X or Y, the
-layers near the sides are as dense as the larger of the two frequencies in the
-layer, which is the surface one.
-
-Evaluating a TPMS at a frequency that varies with the position without such a
-map distorts it wherever the frequency changes, because the phase also changes
-with the gradient of the frequency times the distance from the origin. Fitting a
-smooth map to a varying isotropic scale in the least-squares sense (a Poisson
-problem per axis) cannot grade strongly: its divergence is the target scale plus
-a harmonic function pinned by the surface, which keeps the scale in the core
-near two thirds of the surface one. Following a distance exactly needs the
-lattice to change its topology, by blending lattices of different densities or
-filling shells of equal distance with them, as the modes following the distance
-to the surface do.
-
-The target scale at depth `d = 1 - t`, with `S` the surface and `I` the interior
-frequency, both from each pattern's own density calibration:
-
-| Gradient    | Scale                  |
-|-------------|------------------------|
-| Linear      | `1 + (I / S - 1) * d`  |
-| Quadratic   | `1 + (I / S - 1) * d^2`|
-| Exponential | `(I / S)^d`            |
-
-With a denser surface, quadratic keeps the surface density deepest and
-exponential drops fastest. A denser interior works the same way.
-
-The zero level is extracted with marching squares like the regular TPMS-FK, on
-a sampling grid fixed in the fill frame like the optimized Gyroid, so that every
-region of a layer connects its lines the same way at the saddles of the pattern.
-Loops narrower than two lines (shorter than `2 * PI * spacing`) are dropped, as
-they would print as blobs. The fill works in a frame rotated by the infill
-angle, so the radial field is looked up at the point rotated back into the
-object frame, and the center rotated into the fill frame. Both use the middle of
-the layer.
-
-## Modes following the distance to the surface
-
-`distance_warp`, `smooth_blend` and `stepped_shells` grade by the distance to
-the nearest surface, including the top and bottom, as concentric shells do. The
-depth of a point is that distance over the distance of the deepest point of its
-body, from 0 at the surface to 1; the field keeps it for every node and
-interpolates it between them. A tall box so keeps its whole axis as sparse as
-its center, and a plate is graded through its thickness.
-
-No single smooth pattern follows that depth without distortion (see above), so
-the three modes trade differently:
-
-- Distance warp keeps the lobes and the warp of Lobes, but its radial profile
-  comes from the depth. For every direction of a lobe, the mean depth over the
-  ball along the ray is sampled at 33 radii up to the reach, then smoothed over
-  the neighbouring directions like the reach. The radial coordinate is the one
-  of the linear profile with the same mean depth, `t = 4/3 * (1 - mean depth)`,
-  so with a linear gradient the mean cell size follows the depth exactly, and
-  with the others approximately. In a sphere or a cube, where the depth falls
-  linearly along every ray, it is Lobes. Elsewhere the profile changes with the
-  direction, and the warp shears where neighbouring directions differ, as in
-  plates and long bodies; right under the top of a long body the cells are
-  sparser within the layer, the warp moving their density into the height.
-  The profiles are smoothed over the directions like the reach, as sharper
-  ones shear the pattern across the layer, which adds lines. A long body is so
-  graded partly along its length, between Lobes and the distance.
-- Smooth blend evaluates the regular patterns of the two levels around the
-  target of every point and blends them by a smoothstep over the whole gap
-  between the levels, here at most 2.5 times apart. The density follows the
-  depth without steps, but where two lattices blend, part of their lines run
-  along the blend, so fewer levels print fewer extra lines. From 25% to 5%,
-  three levels print about 0.45 of the uniform infill in a deep core whose
-  levels alone would print 0.3; levels 1.5 times apart print 0.6 to 0.7, and a
-  single blend from the surface to the interior 0.6.
-- Stepped shells split each region of a layer into shells and fill every shell
-  with the regular pattern at its density. The densities are levels from the
-  surface to the interior density at most 1.5 times apart, five from 25% to 5%,
-  and a point takes the level nearest to its target on that geometric scale.
-  The shells are traced by marching squares of the continuous level over the
-  layer on a 0.5 mm grid fixed in the object, so every region of a layer gets
-  the same shells, and clipped to the region. Each shell is shrunk by half a
-  line, like a filled region, and its regular filler connects its lines along
-  that boundary, so the connections of two neighbouring shells lie side by side
-  instead of on top of each other. The pattern is never
-  distorted, but its lines end at every shell, and thin parts get thin shells.
-  The connections add lines: in the core of a 60 mm cube, about a third more
-  than the target.
-
-Stepped shells and Smooth blend need neither lobes nor reaches, which are not
-built for them.
-
-## Constraints
-
-- With `tpms_adaptive` disabled, or for other patterns, the fill parameters are reset
-  to their defaults, so they neither change the infill nor split fill batches.
-- `Layer::get_sparse_infill_max_void_area()` uses the sparser of the two
-  densities, as the voids at the center are that large.
-- At a sparse infill density of 100% the sparse infill is turned into solid
-  infill, so there is nothing to grade: the options are hidden and no field is
-  built.
-- The adaptive options invalidate `posPrepareInfill`, which rebuilds the field
-  and the anchoring infill.
-- An elongated body without a neck has one center, so its far ends are graded
-  as the outer part of the body, and the warp shears where the reach changes
-  quickly with the direction. A concave body, like an L, may be split into lobes
-  where its maxima cannot see each other in a straight line.
-- Across a ray, the scale is the mean of the gradient from the center, so the
-  layers right under the top and above the bottom are sparser than the surface
-  density in their middle, and a plate is graded from its middle outwards rather
-  than through its thickness.

docs/HLSD/center-of-mass.md

@@ -1,172 +0,0 @@
-# Center of mass markers — High Level Design
-
-## Purpose and scope
-
-The "Center of mass" item of the canvas toolbar menu, in the bottom left corner of the 3D view, marks
-where the mass of the plate, of each object instance and of each body of an assembly is centered,
-in Prepare and in Preview. It helps judge how parts will rest on the plate, for instance whether a
-tall or leaning part could tip. It is a view setting: it changes nothing in the model, the slice or
-the project file, and it does not reach plate thumbnails. The choice is kept in the app config as
-`show_center_of_mass`, off by default. The assembly view and the Design tab have no markers.
-
-Three kinds of marker share one shape, a sphere whose octants alternate between two colors:
-
-- each plate, black and white, for everything on it;
-- each object instance, light blue and white;
-- each body of an assembly, red and yellow;
-- in Preview, the supports and raft of each object instance, green and black.
-
-A click on a marker opens a box beside it with the weight and volume of what it stands for, where its
-center lies in that thing's bounding box and the size of the box, and its moments of inertia about
-axes through the center parallel to x, y and z.
-
-An assembly is an object of several parts or with negative volumes. Its bodies are the connected
-solids its parts make once united, the bodies the separated infills option centers its infill on
-(see separated-infills.md): parts that overlap or touch are one body, parts apart are separate
-bodies. An object of one body, and every object of a single part, has no body markers, as its object
-marker says it all.
-
-Mass is volume times density, the `filament_density` of the filament that prints it, or 1.245 g/cm³
-(`DEFAULT_FILAMENT_DENSITY`) for a filament without one. Prepare has the model only, so it takes each
-part as a solid of the density of its filament, the part's own or else its object's. It reads each
-filament's density from the filament's selected preset, edits not yet saved included, as slicing does:
-the plater's own config holds the values of the filament edited last only. Preview has
-what will be printed, so its markers come from the toolpaths, whose mass depends on walls, infill
-and flow as well. There the solid markers are for what is printed up to the top layer the layer
-slider shows: for the plate with brim, raft and supports, where the weight rests at that point of
-the print; for an object or a body, its own extrusions. Each has a faded twin for the same at the
-end of the print, so the slider shows the weight moving toward where it ends, and at the top layer
-the two meet. In Prepare the plate has the model alone, as brim, raft and supports exist only once
-sliced.
-
-## Prepare: from the meshes
-
-An object of one part takes the mass properties of its mesh at unit density, times its density, from
-`its_mass_properties()`, which handles a mesh in a single pass. Each triangle and a fixed vertex of
-the mesh span a tetrahedron whose signed volume is `V = a · (b × c) / 6`, with `a`, `b`, `c` taken
-relative to that vertex. By the divergence theorem these volumes add up to the volume of a closed
-mesh, their volume-weighted centroids to its center of mass, and their second moments
-`V (a aᵀ + b bᵀ + c cᵀ + s sᵀ) / 20`, with `s = a + b + c`, to its own. Shells facing inward, such as
-a cavity, subtract themselves, and flipping every triangle changes nothing. The sums are kept in
-double precision and relative to a vertex of the mesh rather than the origin, which keeps them exact
-for meshes far from it. The result keeps the spread of the mass about its center,
-`(x - c)(x - c)ᵀ` averaged over the mass, from which the moments of inertia follow.
-
-The CGAL routines that look alike do not compute this. `CGAL::centroid` weighs tetrahedra by their
-unsigned volume, so it fails on cavities and on any shell that is not star-shaped from the fan's
-apex; over triangles it returns the centroid of the surface, and over points the average of the
-vertices, which depends on the tessellation. `CGAL::barycenter` with the signed volumes as weights
-gives the same answer, but only after copying every tetrahedron into a vector of weighted points,
-and takes two and a half times as long.
-
-A mesh's result is in its own coordinates. Each `GLVolume` maps it to the world with its world
-matrix `M`, and weighs it by the volume times the absolute determinant of that matrix: a center of
-mass moves with any affine map, and the spread becomes `L S Lᵀ` for the linear part `L` of `M`, so no
-mesh is ever transformed. The `GLVolume`'s matrices, rather than the
-model's, let the markers follow an object while it is dragged, before the model is updated. Results
-are cached by `ModelVolume` id; a `ModelVolume` takes a new id whenever its mesh changes, which is
-the rule `reload_scene()` relies on to rebuild a `GLVolume`'s geometry, so a cached result never
-outlives its mesh.
-
-An assembly's parts overlap or touch, which the mesh formula would count twice, so `solid_bodies()`
-slices them instead, in the object's coordinates. It cuts the height into 500 slabs, 100 while a part
-is dragged, slices every part and negative volume at the middle of each slab, unites the parts and
-cuts the negative volumes away, and links the islands of neighboring slabs that overlap into bodies
-with `connected_bodies()`. Each island adds a prism of the slab's thickness at the density: its
-area, and its first and second moments of area, from the same sums over the outline as the area,
-with the slab's height for z. Where parts of different densities overlap, the later volume of the object counts, as
-slicing clips every part by the parts after it; each part then weighs the region it prints, which is
-credited to the island holding it. Each body also keeps the convex hull of its islands and the height
-they span, whose corners, once transformed, give its bounding box, tight while the instance turns
-about z only. The object is the sum of its bodies, its box that of its parts, as the object's size
-shows it, and each plate the sum of the object instances `PartPlateList::find_instance()` puts on it,
-so that an instance on no plate counts in none. The bodies are cached by `ModelObject` id with the volumes, types, densities and
-transformations they were sliced from.
-
-## Preview: from the toolpaths
-
-`GCodeProcessor` sums the masses while it processes the G-code, in the same pass that builds the
-moves, and leaves them in `GCodeProcessorResult`; `GCodeViewer` keeps a copy of them when it loads a
-result. Nothing is stored per move.
-
-Each extrusion weighs the volume of filament its E extrudes times the density of the filament that
-extrudes it, so a print of several materials weighs each as it is. Flow ratio, line widths, ironing
-and purging into infill all count
-as printed. Its mass spreads evenly along the segment the bead's center runs, half the layer height
-below the nozzle, in the frame of the stored moves: plate offset added, Z offset removed. Such a
-segment from `a` to `b` adds `m (a + b) / 2` to the moments and `m (a² + a b + b²) / 3` to the second
-moments along each axis, and its box widened by half the bead's height to the bounding box; not by
-half its width, which the processor only estimates, so that a box runs along the walls' center lines. Arcs are already split into segments by the processor. Walls, infill, top and bottom surfaces, ironing
-and gap fill make the parts. The brim and the support roles, the raft among them, count only in what
-the plate prints. The skirt, the prime tower and custom G-code count nowhere.
-
-The plate takes every extrusion, so it needs nothing more. The objects and bodies need the sliced
-objects, which the G-code does not describe, so the G-code export hands the processor a locator
-built from the `Print`; G-code opened from a file, or from a project sliced earlier, has no `Print`
-behind it, and so shows the plate alone. Object labels would not do: profiles turn the four kinds
-Orca writes on and off in every combination, and none of them tells the bodies apart.
-
-The locator numbers the object instances and, for each assembly, the bodies of every instance. It
-takes the bodies `PrintObject::prepare_infill()` found for separated infills, or, when that option
-did not need them, links the islands (`Layer::lslices`) of neighboring layers into bodies with the
-same `connected_bodies()`. For each extrusion of a part, it finds the first layer printed at or above
-its height, as spiral vase rises through each layer, and the island holding it with an
-`IslandLocator`, the one `solid_bodies()` credits its regions with: by the island's box, widened by
-1 mm for walls reaching past it, with a polygon test only where boxes overlap, and the nearest
-outline where none holds the point. The boxes of one layer's islands say nothing of the other
-instances, so an instance whose widened box reaches another's, as copies placed side by side do,
-tests the outlines alone, and outside them the nearest outline of all such instances wins. The island
-gives both the instance and the body. The island found last is tried first, as extrusions mostly follow each other on one
-island. Brim, raft and supports lie outside the islands. The brim counts in the plate only; a support
-or raft extrusion goes to the instance whose footprint, the box of its widened islands, holds it, the
-one whose center is nearest among several, or else the nearest footprint, as supports stand below and
-around their object.
-
-Each mass holds, for each layer id, the running total of what is printed up to that layer, the last
-of which is the faded marker's, so the solid marker for any slider position is a single lookup. The layer ids are those
-the moves carry, which are also the layers of libvgcode and of the slider; in a print by object they
-follow the order of printing, so the solid markers show the objects printed so far as they are.
-
-## Drawing
-
-`smooth_sphere()` with a resolution divisible by four leaves every triangle within one octant, so it
-splits into two models drawn with the `gouraud_light` shader in each kind's two colors. The radius is
-9 pixels for the plate, 7 for the objects, 6 for the supports and 5 for the bodies, scaled like the canvas toolbar for the
-display's DPI and kept constant on screen through the camera's inverse zoom. They are drawn in that
-order, so that markers at one place show as rings. The faded markers are the same spheres at 40%
-opacity, drawn before all the solid ones, which show over them where both meet.
-
-The centers usually lie inside the objects, so the markers are drawn without the depth test and show
-through the objects and anything in front of them. Back face culling keeps the far half of a sphere
-from covering the near one. They are drawn after the ambient occlusion pass, which would otherwise
-darken them as the surface behind them, and before FXAA, which smooths their edges.
-
-The markers are part of the cached scene, so toggling them, or changing a filament's density while
-they are shown, marks the scene dirty, and moving the layer slider redraws the scene with the solid
-markers where they belong. In Prepare they are hidden while any gizmo other than Move, Rotate, Scale
-and Lay on face is open, since the others work on the surface a marker would cover, and a hidden
-object has no markers.
-
-## Details
-
-The markers drawn last are kept, and a left click is tested against them before it selects: each
-center and a point a radius to its right are projected to the screen, and the click hits a marker
-within that distance. The solid markers are tested before the faded ones and the smaller kinds
-before the larger, the order in which they cover each other. A hit opens the details of that marker
-and keeps the click from changing the selection; a click anywhere else closes them. The box is an
-ImGui window beside the marker, redrawn with the overlay from the markers of the last scene, so it
-follows a dragged object, and in Preview the layer slider. It closes when its marker is gone, or when
-the number of markers of its kind changes, as then it may stand for something else.
-
-Its title says what the marker stands for: the plate, an object, an assembly or a part, the body of
-an assembly. The G-code export lists the object instances for the processor, marking assemblies, as
-it hands it the locator.
-
-Each marker carries its sums: mass, volume, first moments and the second moments about the origin
-along each axis, `Σ m x²`, `Σ m y²` and `Σ m z²`, which add up from parts to objects to plates. The
-moment of inertia about the axis through the center parallel to x is then
-`m (σy² + σz²)`, with `σ² = Σ m x² / m - c²` along each axis, and likewise for y and z. Masses are
-kept in mg, volume times density in g/cm³, and shown in g, volumes in cm³ and moments of inertia in
-g·mm². In Preview the box tells the finished print from what is printed up to the layer shown, the
-two weighing differently, and both are placed in the bounding box of everything the marker holds
-by the end.

docs/HLSD/preset-cache.md

@@ -39,7 +39,7 @@ presets are never serialized — they have their own storage and their own lifec
 
 | Location | Contents on a shipped build | Role |
 |---|---|---|
-| `resources/profiles/` | `<vendor>.opc` alone — the profile and its preset JSONs both pruned | What the app ships with and what installing copies from; read directly for vendors not installed |
+| `resources/profiles/` | `<vendor>.opc` alone — the profile and its preset JSONs both pruned | What the app ships with; what installing copies from, and the only thing it is read for |
 | `<data_dir>/system/` | `<vendor>.opc` alone, or `<vendor>.json` + `<vendor>/` after an update | What the user has installed |
 | `<data_dir>/system/` (dev build) | `<vendor>.json` + `<vendor>/` + `<vendor>.opc` written at runtime | A developer tree caches as it parses |
 | `<data_dir>/cache/wizard_profile_data.json` | The wizard's derived vendor catalog plus the stamps it was built from | Written and read by the setup wizard only; never shipped (see "The wizard's profile-data cache") |
@@ -182,11 +182,10 @@ one startup.
 
 **A vendor is loaded from where it is installed and nowhere else.** For startup that
 is `<data_dir>/system/`; resources reaches the app by being *installed* into that
-directory first, never by being loaded from. (The setup wizard and the Create Printer
-dialog also offer vendors the user has not installed, and load those from
-`resources/profiles`; see "The wizard's profile-data cache". The dialog's vendor-only and
-filament-only scans read a cache only where it is the whole installation, and never write
-one.) There is one lookup tier and one parse source:
+directory first, never by being loaded from. (The setup wizard is the one caller with
+a different notion of "where": it also shows vendors the user has not installed, and
+loads those from `resources/profiles` — see "The wizard's profile-data cache".) There
+is one lookup tier and one parse source:
 
 ```
 load vendor V from <data_dir>/system:

docs/HLSD/separated-infills.md

@@ -1,97 +0,0 @@
-# Separated infills — High Level Design
-
-## Purpose and scope
-
-An object's infill patterns are laid out from one reference point, the center
-of the object. When an object groups several parts that do not touch, every
-part cuts the same object-wide pattern at a different place, so equal parts get
-different infill. `separated_infills` lays the infill of every connected body
-out from the center of that body instead, as if the body were sliced on its own.
-
-The option covers sparse infill, internal solid infill and bridges. Top and
-bottom surfaces are left to `center_of_surface_pattern`, which centers the
-Archimedean Chords and Octagram Spiral surface patterns. The option is off by
-default; with it off, or for an object made of a single body, no fill changes.
-Adaptive Cubic and Support Cubic do not depend on the option: they always fill
-each body on its own (see Octree infill).
-
-## Bodies
-
-`PrintObject::prepare_infill()` groups the islands of every layer (`lslices`)
-into 3D connected bodies with `connected_bodies()` before bridges are detected,
-so bridge anchors and printed infill share one origin. Islands on adjacent layers belong to one body
-when their slices overlap. Parts that touch or overlap form one body. Separate
-parts, disconnected islands of one mesh, and interleaved parts that never touch,
-such as chain links, each form their own. Every island stores the index of its
-body in `Layer::lslices_separated_component_ids`, and
-`PrintObject::separated_body_bboxes()` holds the bounding box of each body over
-all its layers.
-
-The pass runs when a region uses separated infills, per-model surface centering
-or an octree infill pattern. It is skipped when the object has one model part
-that cannot be split, since a single body already shares the object center.
-
-## Centering a fill
-
-`infill_body()` matches each fill region to the island it overlaps most, among
-the islands whose bounding boxes overlap it, and the filler takes the bounding
-box of that island's body instead of the object's. The box covers every layer
-of the body, which is the box the body gets when sliced alone, so patterns that
-depend on its extent as well as its center come out the same too. Bridge
-anchoring (`Layer::generate_sparse_infill_polylines_for_anchoring()`) makes the
-same choice, so the anchors match the printed infill.
-
-The patterns follow the body's box in one of two ways:
-
-- Rectilinear and its variants, Line, Grid, Triangles, Tri-hexagon, Cubic,
-  Quarter Cubic, Lateral Lattice, Lateral Honeycomb and the plane-path patterns
-  (Hilbert Curve, Archimedean Chords, Octagram Spiral) are laid out from the
-  box: they phase their lines through its center, and Hilbert Curve and the Zig
-  Zag links start from its corner. `Fill::extended_object_bounding_box()`
-  extends the box about its center, so it also serves a box that is not
-  centered on the origin.
-- Honeycomb, 3D Honeycomb, Cross Hatch, Gyroid, TPMS-D and TPMS-FK are laid out
-  from the coordinate origin, which is the object center. They return true from
-  `Fill::aligned_to_origin()`, and `Fill::fill_surface()` moves each region so
-  that the box center lands on the origin, fills it, and moves the paths back.
-  With the default box the center is the origin, so nothing moves.
-
-`is_separable_infill_pattern()` lists these patterns. The settings show the
-option only when the sparse infill pattern is one of them.
-
-## Octree infill
-
-Adaptive Cubic and Support Cubic take their lines from an octree, laid out from
-the center of the mesh it is built from and refined near its surfaces. An
-octree of the whole object would lay every part out from the object's center
-and refine it near the other parts, so these patterns
-(`is_octree_infill_pattern()`) always fill each body on its own, and the
-settings hide the option for them.
-
-For an object of several bodies, `PrintObject::prepare_adaptive_infill_data()`
-builds one octree per body (`FillAdaptive::Octrees`) from the triangles of that
-body only, which is the octree the body gets when sliced alone. Each connected
-component of the mesh goes to the body that most of a few sampled triangles lie
-on. A sample is taken a layer height inside the solid, behind the triangle, and
-looked up in the islands of the nearest layer. Each internal bridge surface goes
-to the body of its island. The fill takes the octree of the region's body, from
-the same `infill_body()`. The octree of the whole object is built only for an
-object of a single body, or when some body received no triangles, which then
-uses it.
-
-The line spacing of an octree comes from the density, line width and multiline
-count of a region, so a modifier or a part with its own density needs octrees of
-its own. `adaptive_fill_line_spacing()` gives the spacing of each region, and
-`FillAdaptive::RegionOctrees` holds one set of octrees per distinct spacing,
-shared by the regions that have it. A set is built only for the bodies its
-regions fill. The fill takes the set of its region, then the octree of its body.
-
-## Patterns left out
-
-Lightning grows its trees over the whole object, so moving a reference point
-cannot center it on one body. Concentric and Spiral Inset follow the outline of
-each region and need no centering.
-
-Solid infill at full density spaces its lines over the extent of each region,
-so it is already independent of the other bodies. Only bridges, which keep
-their line spacing, and the plane-path solid patterns depend on the center.

localization/i18n/list.txt

@@ -295,6 +295,8 @@ src/slic3r/GUI/CAD/DesignSketchTool.cpp
 src/slic3r/GUI/CAD/SketchInlineEditor.cpp
 src/slic3r/GUI/CAD/DesignOffer.hpp
 src/slic3r/GUI/CAD/DesignTextDialog.cpp
+src/slic3r/GUI/Gizmos/GLGizmoPrimitive.cpp
+src/slic3r/GUI/Gizmos/GLGizmoSketch.cpp
 src/slic3r/GUI/KeyChord.cpp
 src/slic3r/GUI/Shortcuts.cpp
 src/libslic3r/CAD/CadDocument.cpp

resources/calib/temperature_tower/gen_belt_temp_tower.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""Belt temperature-tower asset generator (discrete-provini design).
-
-A vertical temperature tower cannot be sliced on a belt printer, so lay a row of
-DISCRETE provini (one per temperature) along the belt (designed Y) with a fixed
-surface gap. Each provino is the chevron+arc unit (belt_temp_provino_unit.stl,
-keel-first); its temperature is ENGRAVED upright into the 50 mm face — a raised
-number would be an unsupported overhang on the belt. The C++ calib_temp belt branch
-(Plater.cpp) injects one M104 per zone 70 layers INTO provino i:
-  print_z[i] = i * PITCH * cos(theta) + 70 * layer_height   (theta = 45)
-inside the body, not in the empty inter-provino gap (which has no sliced layers for
-the event to attach to). PITCH below is the shared geometry contract with that code —
-keep them in sync.
-
-Generates one STL per filament temp range used by Temp_Calibration_Dlg.
-"""
-import numpy as np, trimesh, os
-from matplotlib.textpath import TextPath
-from matplotlib.font_manager import FontProperties
-from shapely.geometry import Polygon as ShPoly
-from shapely.ops import unary_union
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-UNIT = os.path.join(HERE, 'belt_temp_provino_unit.stl')   # single provino, keel-first
-SURF_GAP = 25.0            # surface-to-surface gap between provini (mm) — user spec
-TEXT_H = 9.0
-TEXT_DEPTH = 0.8           # engraving depth (numbers are CUT into the face, not raised:
-                          # a raised number is an unsupported Y-overhang on the belt)
-TEXT_OVERSHOOT = 0.6       # extra height poking out of the face for a clean boolean cut
-
-# Temperature ranges (start, end) per filament family, 5 C step. File name encodes them.
-RANGES = [(230,190),(270,230),(250,230),(280,240),(240,210),(320,280)]
-
-unit = trimesh.load(UNIT)
-dY = unit.bounds[1,1] - unit.bounds[0,1]
-PITCH = dY + SURF_GAP                       # designed-Y pitch == C++ contract constant
-print(f"unit dY={dY:.2f}  PITCH={PITCH:.3f}  (C++ contract: print_z[i]=i*{PITCH:.3f}*cos45)")
-
-# 50 mm face normal (0,-1,1)/sqrt2 ; UPRIGHT basis u=+X det(+1) (verified non-mirrored)
-n = np.array([0,-1,1.])/np.sqrt(2)
-u = np.array([1,0,0.]); v = np.array([0,1,1.])/np.sqrt(2)
-R = np.column_stack([u,v,n])
-fn = unit.face_normals; fc = unit.triangles_center; fa = unit.area_faces
-sel = (fn@n) > 0.9
-face_c = (fc[sel]*fa[sel,None]).sum(0)/fa[sel].sum()
-
-def text_mesh(s):
-    tp = TextPath((0,0), s, size=TEXT_H, prop=FontProperties(family='DejaVu Sans'))
-    rings = [ShPoly(p) for p in tp.to_polygons() if len(p)>=3]
-    rings.sort(key=lambda r:r.area, reverse=True)
-    used=[False]*len(rings); parts=[]
-    for i,o in enumerate(rings):
-        if used[i]: continue
-        holes=[]
-        for j in range(i+1,len(rings)):
-            if not used[j] and o.contains(rings[j]): holes.append(rings[j].exterior.coords); used[j]=True
-        parts.append(ShPoly(o.exterior.coords,holes)); used[i]=True
-    poly = unary_union(parts)
-    geoms = list(poly.geoms) if poly.geom_type=='MultiPolygon' else [poly]
-    m = trimesh.util.concatenate([trimesh.creation.extrude_polygon(g,height=TEXT_DEPTH+TEXT_OVERSHOOT) for g in geoms])
-    c = m.bounds.mean(axis=0); m.apply_translation([-c[0],-c[1],0]); return m
-
-for t_start, t_end in RANGES:
-    temps = list(range(t_start, t_end-1, -5))
-    parts=[]
-    for i,T in enumerate(temps):
-        c = unit.copy(); c.apply_translation([0, i*PITCH, 0])
-        t = text_mesh(str(T)); M=np.eye(4); M[:3,:3]=R; t.apply_transform(M)
-        # place the text spanning from TEXT_DEPTH inside the face to TEXT_OVERSHOOT outside,
-        # then CUT it out of the provino (engrave) — no raised material, no Y-overhang.
-        t.apply_translation(face_c - n*TEXT_DEPTH + np.array([0,i*PITCH,0]))
-        c = trimesh.boolean.difference([c, t], engine='manifold')
-        parts.append(c)
-    asset = trimesh.util.concatenate(parts)
-    out = os.path.join(HERE, f"belt_temp_tower_{t_start}_{t_end}.stl")
-    asset.export(out)
-    dims = np.round(asset.bounds[1]-asset.bounds[0],1)
-    wt = all(p.is_watertight for p in parts)
-    print(f"  {t_start}->{t_end}: {len(temps)} zones  bbox={dims}  watertight={wt}  -> {os.path.basename(out)}")

resources/images/delete_all_filaments.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M5.5,14.5c-1.105,0-2-3.686-2-7s.895-7,2-7" style="fill:none;stroke:#009688;stroke-linecap:round;stroke-linejoin:round"/><line x1="8.67" y1="4.67" x2="14.33" y2="10.33" style="fill:none;stroke:#949494;stroke-linecap:square;stroke-linejoin:round"/><line x1="14.33" y1="4.67" x2="8.67" y2="10.33" style="fill:none;stroke:#949494;stroke-linecap:square;stroke-linejoin:round"/><path d="M3.5,13.7c-.294.511-.636.8-1,.8-1.1,0-2-3.686-2-7s.9-7,2-7c.365,0,.707.293,1,.805" style="fill:none;stroke:#949494;stroke-linecap:round;stroke-linejoin:round"/><path d="M6.727,4.5c.334-2.208,1-4,1.773-4,.354,0,.686.378.974,1" style="fill:none;stroke:#949494;stroke-linecap:round;stroke-linejoin:round"/><path d="M9.474,13.5c-.288.622-.62,1-.974,1-.77,0-1.439-1.792-1.773-4" style="fill:none;stroke:#949494;stroke-linecap:round;stroke-linejoin:round"/></svg>

resources/images/toolbar_modifier_cube_dark.svg

@@ -0,0 +1,4 @@
+<svg width="35" height="35" viewBox="0 0 35 35" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M17.0007 3.15607L5.26748 9.97446C5.0759 10.0857 4.8723 10.2988 4.71546 10.5713C4.55862 10.8438 4.47656 11.127 4.47656 11.349V24.4715C4.47656 24.6929 4.55879 24.9752 4.71606 25.2472C4.87328 25.5192 5.07737 25.7322 5.26956 25.8438L17.1143 32.6992C17.3061 32.8102 17.5904 32.8795 17.902 32.8782C18.2136 32.8768 18.4968 32.8049 18.6868 32.6927L30.2729 25.8523C30.4645 25.739 30.6677 25.524 30.8242 25.2501C30.9806 24.9761 31.0625 24.6919 31.0625 24.4693V11.2435C31.0625 11.0216 30.9805 10.7392 30.8238 10.4679C30.667 10.1966 30.4635 9.98491 30.2715 9.87455L18.582 3.15275C18.3912 3.04273 18.1054 2.97271 17.7915 2.97339C17.4777 2.97408 17.192 3.045 17.0007 3.15607ZM6.3957 11.3642C6.53284 11.1245 6.83831 11.0414 7.07799 11.1785L16.9733 16.8405C17.3553 17.0587 17.6738 17.4171 17.8953 17.7985C18.1169 18.1801 18.2703 18.6338 18.2717 19.0733L18.2893 30.4075C18.2897 30.6837 18.0662 30.9079 17.7901 30.9083C17.5139 30.9087 17.2897 30.6852 17.2893 30.4091L17.2717 19.0767C17.2708 18.8547 17.1879 18.5717 17.0305 18.3007C16.8729 18.0294 16.6691 17.8183 16.4776 17.709L6.58136 12.0465C6.34168 11.9093 6.25855 11.6039 6.3957 11.3642Z" fill="#4db6ac"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M19.0809 2.28613C18.7002 2.0665 18.2304 1.97243 17.7893 1.9734C17.3481 1.97436 16.8787 2.07053 16.4985 2.29133L4.76515 9.10978C4.38527 9.33044 4.06884 9.69007 3.84874 10.0725C3.6286 10.455 3.47656 10.9093 3.47656 11.349V24.4715C3.47656 24.9118 3.62953 25.3658 3.85033 25.7477C4.07118 26.1297 4.38804 26.4882 4.76735 26.7085L16.6135 33.5647C16.9954 33.7857 17.4651 33.8801 17.9064 33.8782C18.3475 33.8762 18.8161 33.7778 19.1954 33.5537L30.7814 26.7133C31.1591 26.4902 31.4737 26.1292 31.6925 25.746C31.9114 25.3627 32.0625 24.9084 32.0625 24.4693V11.2435C32.0625 10.8037 31.9104 10.3497 31.6896 9.96764C31.4689 9.58563 31.1515 9.22695 30.7698 9.00759L19.0809 2.28613ZM29.6625 11.8015C29.786 12.0485 29.6859 12.3489 29.4389 12.4723L20.3956 16.994C20.1486 17.1175 19.8483 17.0174 19.7248 16.7704C19.6013 16.5234 19.7014 16.2231 19.9484 16.0996L28.9917 11.5779C29.2387 11.4544 29.539 11.5545 29.6625 11.8015Z" fill="#bdbdbd"/>
+</svg>

resources/images/toolbar_sketch.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40">
+  <!-- Pencil body -->
+  <path d="M28.5 6.5l5 5L14 31l-5.5 1.5L10 27 28.5 6.5z" style="fill:#009688"/>
+  <!-- Pencil tip (dark) -->
+  <path d="M8.5 28.5l1.5 1.5 4.5-1L28.5 15l-3.5-3.5L8.5 28z" style="fill:#2b3436"/>
+  <!-- Pencil line -->
+  <line x1="10" y1="26" x2="25" y2="11" stroke="#2b3436" stroke-width="2"/>
+</svg>

resources/images/toolbar_sketch_dark.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40">
+  <!-- Pencil body (dark mode colors) -->
+  <path d="M28.5 6.5l5 5L14 31l-5.5 1.5L10 27 28.5 6.5z" style="fill:#4db6ac"/>
+  <!-- Pencil tip -->
+  <path d="M8.5 28.5l1.5 1.5 4.5-1L28.5 15l-3.5-3.5L8.5 28z" style="fill:#e0e0e0"/>
+  <!-- Pencil line -->
+  <line x1="10" y1="26" x2="25" y2="11" stroke="#e0e0e0" stroke-width="2"/>
+</svg>

resources/images/toolbar_tooltip.svg

@@ -1 +1 @@
-<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 15 15"><rect x="7" y="12" width="1" height="1" style="fill:#fefefe;"/><path d="M4.5,5.5c0-1.71,1.43-3.09,3.16-3,1.62.08,2.84,1.54,2.84,3.17h0c0,.61-.25,1.2-.69,1.62l-2.31,2.24v.97" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25"><circle cx="9.5" cy="12.5" r="9.5" style="fill:#009688"/><path d="M6.5,10.5a3,3,0,0,1,6,0c0,3-3,2-3,4v1" style="fill:none;stroke:#e6e6e6;stroke-linecap:round;stroke-linejoin:round"/><rect x="9" y="17" width="1" height="1" style="fill:#e6e6e6"/></svg>

resources/images/toolbar_tooltip_hover.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25"><circle cx="9.5" cy="12.5" r="9.5" style="fill:#33aba1"/><path d="M6.5,10.5a3,3,0,0,1,6,0c0,3-3,2-3,4v1" style="fill:none;stroke:#e6e6e6;stroke-linecap:round;stroke-linejoin:round"/><rect x="9" y="17" width="1" height="1" style="fill:#e6e6e6"/></svg>

resources/images/toolbar_video_guide.svg

@@ -1 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 15 15"><path d="M12.31,8l-8.14,4.16c-.31.16-.67-.07-.67-.41V3.27c0-.35.37-.57.68-.41l8.14,4.32c.33.17.33.65,0,.82Z" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/images/toolbar_wiki.svg

@@ -1 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 15 15"><path d="M7.5,3.5c2-2,5.1-1,6-1" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/><path d="M7.5,12.5c2-2,5.1-1,6-1" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/><path d="M7.5,3.5C5.5,1.5,2.4,2.5,1.5,2.5" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/><path d="M7.5,12.5c-2-2-5.1-1-6-1" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/><line x1="13.5" y1="11.5" x2="13.5" y2="2.5" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/><line x1="7.5" y1="12.5" x2="7.5" y2="3.5" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/><line x1="1.5" y1="11.5" x2="1.5" y2="2.5" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/></svg>

resources/profiles/BBL/process/0.08mm High Quality @BBL P2S 0.2 nozzle.json

@@ -10,7 +10,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"4000",
 		"4000"

resources/profiles/BBL/process/0.08mm High Quality @BBL P2S.json

@@ -10,7 +10,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"4000",
 		"4000",

resources/profiles/BBL/process/0.10mm Standard @BBL P2S 0.2 nozzle.json

@@ -9,7 +9,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"4000",
 		"4000"

resources/profiles/BBL/process/0.12mm Balanced Quality @BBL P2S 0.2 nozzle.json

@@ -9,7 +9,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"4000",
 		"4000"

resources/profiles/BBL/process/0.12mm High Quality @BBL P2S.json

@@ -10,7 +10,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"4000",
 		"4000",

resources/profiles/BBL/process/0.16mm High Quality @BBL P2S.json

@@ -11,7 +11,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"4000",
 		"4000",

resources/profiles/BBL/process/0.16mm Standard @BBL P2S.json

@@ -11,7 +11,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"10000",
 		"10000",

resources/profiles/BBL/process/0.18mm Balanced Quality @BBL P2S 0.6 nozzle.json

@@ -11,7 +11,6 @@
 		"30",
 		"30"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"10000",
 		"10000",

resources/profiles/BBL/process/0.20mm High Quality @BBL P2S.json

@@ -11,7 +11,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"4000",
 		"4000",

resources/profiles/BBL/process/0.20mm Standard @BBL P2S.json

@@ -11,7 +11,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"10000",
 		"10000",

resources/profiles/BBL/process/0.24mm Balanced Quality @BBL P2S 0.6 nozzle.json

@@ -11,7 +11,6 @@
 		"30",
 		"30"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"10000",
 		"10000",

resources/profiles/BBL/process/0.24mm Balanced Quality @BBL P2S 0.8 nozzle.json

@@ -10,7 +10,6 @@
 		"30",
 		"30"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"10000",
 		"10000"

resources/profiles/BBL/process/0.24mm Standard @BBL P2S.json

@@ -10,7 +10,6 @@
 		"50",
 		"50"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"10000",
 		"10000",

resources/profiles/BBL/process/0.30mm Standard @BBL P2S 0.6 nozzle.json

@@ -11,7 +11,6 @@
 		"30",
 		"30"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"10000",
 		"10000",

resources/profiles/BBL/process/0.32mm Balanced Quality @BBL P2S 0.8 nozzle.json

@@ -10,7 +10,6 @@
 		"30",
 		"30"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"10000",
 		"10000"

resources/profiles/BBL/process/0.40mm Standard @BBL P2S 0.8 nozzle.json

@@ -10,7 +10,6 @@
 		"30",
 		"30"
 	],
-	"enable_arc_fitting": "0",
 	"default_acceleration": [
 		"10000",
 		"10000"

resources/profiles/Creality.json

@@ -1,6 +1,6 @@
 {
 	"name": "Creality",
-	"version": "02.03.02.87",
+	"version": "02.03.02.86",
 	"force_update": "0",
 	"description": "Creality configurations",
 	"machine_model_list": [