Merge branch 'main' into feat/ams-parsing

GCodeProcessorResult declares a copy assignment, which suppresses the
implicit
move assignment, so `*result = std::move(processor.extract_result())`
binds to
the copy and duplicates the whole moves array: 96 bytes per move,
measured at
147.7 MiB in one allocation for a 597k facet model at 0.08 mm, with the
source
staying alive until the export returns.

Add the move assignment. It assigns exactly the same 39 members in the
same
order as the copy, including the ones the copy deliberately leaves
alone, so a
target that carries its own filament maps and nozzle type keeps them. A
move
constructor is intentionally not added: the type holds a std::mutex, so
it is
neither copy nor move constructible today and a partial one would leave
ten
members uninitialised.

reset() now releases the two print sized vectors rather than clearing
them. Its
callers are the paths that discard a result, so the memory went back
only at the
next slice.

ViewerImpl::reset() does the same for the two vectors sized by the
print, which
is what keeps a discarded preview resident, and counts m_vertices_colors
in the
reported CPU memory, where it was missing.

.github/workflows/build_orca.yml

@@ -341,12 +341,12 @@ jobs:
           
           # Notarize main DMG
           xcrun notarytool submit "OrcaSlicer_Mac_universal_${{ env.ver }}.dmg" --apple-id "${{ secrets.APPLE_DEV_ACCOUNT }}" --team-id "${{ secrets.TEAM_ID }}" --password "${{ secrets.APP_PWD }}" --wait
-          xcrun stapler staple OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
+          retry xcrun stapler staple OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
 
           # Notarize profile validator DMG if it exists
           if [ -f "OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg" ]; then
             xcrun notarytool submit "OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg" --apple-id "${{ secrets.APPLE_DEV_ACCOUNT }}" --team-id "${{ secrets.TEAM_ID }}" --password "${{ secrets.APP_PWD }}" --wait
-            xcrun stapler staple OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
+            retry xcrun stapler staple OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
           fi
 
       - name: Create DMG without notary
@@ -460,10 +460,6 @@ jobs:
       - name: Build slicer Win
         if: runner.os == 'Windows'
         working-directory: ${{ github.workspace }}
-        # Orca: Removed Netfabb STL fixing service support in favor of CGAL.
-        # env:
-        #   WindowsSdkDir: 'C:\Program Files (x86)\Windows Kits\10\'
-        #   WindowsSDKVersion: '10.0.26100.0\'
         # --tests builds the unit tests too; the unit_tests_windows_* jobs run them.
         run: |
           # cache-path is the install directory inside the deps build directory.

.github/workflows/clang_tidy.yml

@@ -16,6 +16,15 @@ on:
 
 permissions:
   contents: read
+  # Listing caches and builds while waiting for a deps cache.
+  actions: read
+
+# Read by scripts/ci_deps_cache.sh.
+env:
+  REPO: ${{ github.repository }}
+  WORKFLOW: build_all.yml
+  BASE_REF: ${{ github.base_ref }}
+  JOB: build_linux (${{ vars.SELF_HOSTED && 'orca-lnx-server' || 'ubuntu-24.04' }})
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
@@ -35,7 +44,7 @@ jobs:
           # The PR merge commit plus its first parent, the base it is diffed against.
           fetch-depth: 2
 
-      - name: Look for changed C++ files
+      - name: Look for changed files
         id: changes
         run: |
           if git -c core.quotePath=false diff --name-only HEAD^1 -- src tests | grep -qE '\.(cpp|cc|cxx|hpp|h|hxx)$'; then
@@ -43,18 +52,75 @@ jobs:
           else
             echo "No C++ changes under src/ or tests/."
           fi
+          if ! git diff --quiet HEAD^1 -- deps; then
+            echo "deps=true" >> "$GITHUB_OUTPUT"
+          fi
+          echo "deps-key=linux-clang-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }}" >> "$GITHUB_OUTPUT"
 
-      # Parsing needs the dependency headers, not a build of this PR's deps/, so
-      # a PR that changes deps/ falls back to the newest cache main has.
+      # Parsing needs the dependency headers, not a build of this PR's deps/.
+      # Without an exact match the job waits for the build that saves it: this
+      # PR's own when it changes deps/, otherwise a running push build of the
+      # base branch with the same deps. With neither, a PR that keeps deps/
+      # falls back to the newest cache.
       - name: Restore cached deps
+        id: deps_cache
         if: steps.changes.outputs.cpp == 'true'
         uses: actions/cache/restore@v6
         with:
           path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
-          key: linux-clang-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }}
+          key: ${{ steps.changes.outputs.deps-key }}
+
+      - name: Look for a build to wait for
+        id: wait_check
+        if: steps.changes.outputs.cpp == 'true' && steps.deps_cache.outputs.cache-hit != 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: bash scripts/ci_deps_cache.sh ${{ steps.changes.outputs.deps == 'true' && 'own' || 'check' }}
+
+      # Linux Build Deps takes about 35 minutes on GitHub-hosted runners. The
+      # wait ends early when the deps job fails.
+      - name: Wait for the deps cache
+        if: steps.wait_check.outputs.wait-for != ''
+        timeout-minutes: 100
+        env:
+          GH_TOKEN: ${{ github.token }}
+          KEY: ${{ steps.changes.outputs.deps-key }}
+          CACHE_REF: ${{ steps.changes.outputs.deps == 'true' && github.ref || format('refs/heads/{0}', github.base_ref) }}
+          KEY_INPUTS: ${{ steps.wait_check.outputs.key-inputs }}
+          WAIT_FOR: ${{ steps.wait_check.outputs.wait-for }}
+          WAIT_SINCE: ${{ steps.wait_check.outputs.wait-since }}
+          WAIT_MINUTES: 90
+        run: bash scripts/ci_deps_cache.sh wait
+
+      - name: Restore the deps cache after waiting
+        id: waited_cache
+        if: steps.wait_check.outputs.wait-for != ''
+        uses: actions/cache/restore@v6
+        with:
+          path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
+          key: ${{ steps.changes.outputs.deps-key }}
+
+      - name: Fail without this PR's deps cache
+        if: steps.changes.outputs.deps == 'true' && steps.wait_check.outcome == 'success' && steps.waited_cache.outputs.cache-hit != 'true'
+        run: |
+          echo "::error::No deps cache ${{ steps.changes.outputs.deps-key }}. Check this PR's Linux Build Deps job, then rerun clang-tidy."
+          exit 1
+
+      - name: Restore the newest cached deps
+        id: newest_cache
+        if: steps.changes.outputs.deps != 'true' && steps.wait_check.outcome == 'success' && steps.waited_cache.outputs.cache-hit != 'true'
+        uses: actions/cache/restore@v6
+        with:
+          path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
+          key: ${{ steps.changes.outputs.deps-key }}
           restore-keys: linux-clang-cache-orcaslicer_deps-build-
           fail-on-cache-miss: true
 
+      - name: Warn about older deps
+        if: steps.newest_cache.outcome == 'success' && steps.newest_cache.outputs.cache-hit != 'true'
+        run: echo "::warning title=Older deps::No cache matches this PR's deps/, so clang-tidy parsed against ${{ steps.newest_cache.outputs.cache-matched-key }}. If it reports errors in code that uses a dependency, rerun clang-tidy once the base branch's Build all has saved the new deps."
+
       - name: Apt-Install Dependencies
         if: steps.changes.outputs.cpp == 'true' && !vars.SELF_HOSTED
         uses: ./.github/actions/apt-install-deps

CMakeLists.txt

@@ -497,47 +497,6 @@ endif()
 # Once we get rid of Perl and libslic3r is linked statically, we can get rid of -fPIC
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
-# WIN10SDK_PATH is used to point CMake to the WIN10 SDK installation directory.
-# We pick it from environment if it is not defined in another way
-# ORCA: Removed Netfabb STL fixing service support in favor of CGAL.
-# if(WIN32)
-#     if(NOT DEFINED WIN10SDK_PATH)
-#         if(DEFINED ENV{WIN10SDK_PATH})
-#                 set(WIN10SDK_PATH "$ENV{WIN10SDK_PATH}")
-#         endif()
-#     endif()
-#     if(DEFINED WIN10SDK_PATH)
-#         #BBS: modify win10sdk_path
-#         if (EXISTS "${WIN10SDK_PATH}/winrt/windows.graphics.printing3d.h")
-#             set(WIN10SDK_INCLUDE_PATH "${WIN10SDK_PATH}")
-#         else()
-#             message("WIN10SDK_PATH is invalid: ${WIN10SDK_PATH}")
-#             message("${WIN10SDK_PATH}/winrt/windows.graphics.printing3d.h was not found")
-#             message("STL fixing by the Netfabb service will not be compiled")
-#             unset(WIN10SDK_PATH)
-#         endif()
-#     else()
-#         # Try to use the default Windows 10 SDK path.
-#         if (DEFINED ENV{WindowsSdkDir} AND DEFINED ENV{WindowsSDKVersion})
-#             set(WIN10SDK_INCLUDE_PATH "$ENV{WindowsSdkDir}/Include/$ENV{WindowsSDKVersion}")
-#         else ()
-#             set(WIN10SDK_INCLUDE_PATH "C:/Program Files (x86)/Windows Kits/10/Include/10.0.26100.0")
-#         endif ()
-#         if (NOT EXISTS "${WIN10SDK_INCLUDE_PATH}/winrt/windows.graphics.printing3d.h")
-#             message("${WIN10SDK_INCLUDE_PATH}/winrt/windows.graphics.printing3d.h was not found")
-#             message("STL fixing by the Netfabb service will not be compiled")
-#             unset(WIN10SDK_INCLUDE_PATH)
-#         endif()
-#     endif()
-#     if(WIN10SDK_INCLUDE_PATH)
-#         message("Building with Win10 Netfabb STL fixing service support")
-#         add_definitions(-DHAS_WIN10SDK)
-#         include_directories(SYSTEM "${WIN10SDK_INCLUDE_PATH}")
-#     else()
-#         message("Building without Win10 Netfabb STL fixing service support")
-#     endif()
-# endif()
-
 if (APPLE)
     message("OS X SDK Path: ${CMAKE_OSX_SYSROOT}")
     if (CMAKE_OSX_DEPLOYMENT_TARGET)

cmake/modules/ClangClShowIncludes.cmake

@@ -1,10 +1,18 @@
 # ccache does not parse the -clang: arguments CMake uses for clang-cl's gcc-style
 # depfile, so a cache hit writes the object and no depfile, and Ninja then records
 # no headers for that object. ccache reproduces /showIncludes output on a hit.
+#
+# Clang also records the modification time of every input in a precompiled header
+# and rejects the header once one differs. ccache caches the compile that creates
+# the header, so a tree that regenerates cmake_pch.cxx gets back a header stamped
+# with the old file's time, and every compile that uses it fails. The build system
+# already rebuilds the header when an input changes. This covers the dependencies,
+# such as wxWidgets; PrecompiledHeader.cmake does the same for OrcaSlicer's targets.
 foreach (_lang C CXX)
     if (CMAKE_${_lang}_COMPILER_ID STREQUAL "Clang" AND
         CMAKE_${_lang}_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
         set(CMAKE_DEPFILE_FLAGS_${_lang} "/showIncludes")
         set(CMAKE_${_lang}_DEPFILE_FORMAT msvc)
+        list(APPEND CMAKE_${_lang}_COMPILE_OPTIONS_CREATE_PCH -Xclang -fno-pch-timestamp)
     endif ()
 endforeach ()

docs/HLSD/chromastack.md

@@ -1,239 +0,0 @@
-# ChromaStack - High Level Design
-
-## Purpose and scope
-
-ChromaStack prints a colour picture on a single face of a model: a few filaments are printed one on
-top of another, the printer swaps filament at fixed layer boundaries, and the *height* of every
-pixel decides how many of those layers reach it. Filament is translucent, so a pixel that stops
-part-way through a run shows a blend of that run's filament and whatever is under it, which is
-where the colours come from - far more of them than there are filaments loaded.
-
-This is that model inside OrcaSlicer, as a mode of a texture displacement layer. The picture and
-the filament stack are the input; the output is a grayscale height map and a set of filament swaps.
-Nothing about it is a new pipeline: the height map is handed to the layer the user painted, so the
-existing projection, preview and bake turn it into real geometry, and the swaps are handed to the
-object's height ranges, which is the slicer's own way of printing a Z band in another filament.
-
-It does not import other filament-painting tools' project files, and it does not choose the filaments or
-their order - that is the user's artistic decision, and the panel exists to make its result
-visible before the print.
-
-## The colour model
-
-`libslic3r/ChromaStack.hpp` holds the whole of it, free of any GUI dependency, which is what lets the
-solve run against plain image bytes and be unit tested.
-
-A **stack** (`ChromaStack`) is a list of **bands** (`ChromaBand`), bottom-up: a filament and
-how many layers it gets. Alongside them it carries the print's layer height, which the colours
-depend on directly, and the **base**: how many layers of solid backing the picture sits on.
-
-The base is not a band. It is a measurement of the model - everything below the painted face, often
-a hundred layers or more on a tall part - while a band is a handful of layers the user chooses. It
-prints in the bottom band's filament, because that is what is loaded when the print starts, so it
-extends that band's height range down to the first layer instead of being a swap of its own. Only
-the bands are quantized into the height map, which is why the 255-layer limit
-(`CHROMA_MAX_RELIEF_LAYERS`) bounds the picture and not the stack.
-
-Each filament carries its **transmission distance** (TD), the usual measure for how deep
-light gets into it: about 1 for an opaque filament, 4 to 7 for a usefully translucent one, 8 and
-above for a nearly clear one. TD lives in the filament preset, as
-`filament_transmission_distance` - it is a property of the material, so it belongs with the
-material and ships with a profile rather than being retyped per project. It has no effect on
-slicing.
-
-`chroma_palette()` turns a stack into the colour it shows at every possible column height, which
-is all the solver ever needs. The model is Beer-Lambert absorption, layer by layer: a layer of
-thickness `h` in a filament of transmission distance `TD` passes
-
-    T = exp(-h / (CHROMA_TD_OPAQUE_FRACTION * TD / 3))
-
-of the light from under it and shows its own colour with the rest, so walking up from an opaque
-base,
-
-    C_k = (1 - T_k) * c_k + T_k * C_(k-1),  C_0 = c_1
-
-The constants say what TD means in physical terms: a filament stops showing what is behind it at
-about a tenth of its TD number (`CHROMA_TD_OPAQUE_FRACTION`), and three e-folding lengths of
-absorption pass 5% of the light, which is where the eye stops seeing through. Those are calibrated
-against how the community's TD step prints behave, not derived from first principles - TD is an
-empirical scale.
-
-How fast that happens is the single most useful fact about a stack, and `chroma_layers_to_opaque()`
-is it: a filament hides what is under it at about a tenth of its TD, so how many *layers* that takes
-depends entirely on how thick they are. TD 4 covers in two layers at 0.2 mm and in five at 0.08 mm.
-Below about two layers a band has no intermediate colours at all - the picture can only use the
-filament or not use it - which is why an otherwise sound stack prints as flat steps at a coarse
-layer height. The panel reports the number under the palette ramp, and warns when it falls below
-two, because nothing else makes it visible: the filaments look fine, the bands look long enough, and
-the result looks like the colour model is wrong when it is the layer height.
-
-How many of a picture's layers actually earn their place is a second question, and
-`chroma_distinct_levels()` answers it: a band eventually hides what is under it, and another layer of
-it then shows the colour the one below already showed. It is measured against the palette rather than
-against TD, because how long a band keeps paying depends on what is under it as much as on the
-filament - a light band over a dark one is finished in four or five layers, while a dark one over a
-light one goes on moving the colour perceptibly well past the depth at which it is nominally opaque,
-since the last few percent of light coming through still shifts a near-black colour. `Trim` shortens
-each band to its last layer that still changes anything.
-
-Beer-Lambert is also the only model that stays self-consistent applied per layer: transmittance
-multiplies, so a run of n layers of one filament passes `exp(-n h / d)` whether it is composited in
-one step or n, and the palette therefore does not depend on how the stack happens to be cut into
-bands. A unit test asserts exactly that. Compositing is done on linear light, because the quantity
-being attenuated is light rather than an sRGB code.
-
-The base is assumed opaque. That is what makes a column's colour depend only on the layers above it,
-and it is why the panel warns when the base is thin.
-
-## The solve
-
-`chroma_solve()` maps each pixel of the picture to the column height whose palette colour is
-closest to it, perceptually: both sides go to CIELAB and the match is a CIE76 distance. A 1-D
-palette of a few dozen entries makes the extra accuracy of CIEDE2000 hard to see and the cost of it
-easy to feel - several hundred million comparisons for a large picture - so the cheaper metric is
-the deliberate choice here, unlike the texture colour quantizer, which matches against a
-two-dimensional palette of filament mixes and uses a precomputed CIEDE2000 cube.
-
-Optional Floyd-Steinberg error diffusion, serpentine, trades the bands a photograph shows across a
-sky or a cheek for fine stipple. Off by default, since stipple is the artifact rather than the cure
-for flat-coloured artwork.
-
-Three things come back: the per-pixel layer count, the same thing as an 8-bit grayscale height map
-(0 at the base, 255 at the top of the stack), and the palette colours chosen, as an RGB image. The
-quantization belongs to the solve rather than to the displacement because the relief's steps have
-to land on layer boundaries, and a grey level is the only channel the displacement reads.
-
-The solve also reports the mean and worst colour difference it had to accept. That is the only
-honest answer to "will this stack reproduce my picture": under about 5 is a good match, over about
-15 means the filaments cannot reach the picture's colours and no number of layers will help.
-
-## How it attaches to a texture displacement layer
-
-A ChromaStack layer is an ordinary `TextureDisplacementLayer` whose height map is computed rather than
-imported:
-
-- `chroma_source` keeps the picture the user chose, so the solve can be redone whenever the stack,
-  the layer height or the picture changes;
-- `chroma` is the stack;
-- `image_data` - the same field every other layer uses - holds whatever the last solve produced.
-
-So everything downstream needs no changes at all and knows nothing about colour stacks. It also
-means the solve writes `depth_mm` (the relief is exactly as tall as the layers above the base) and
-pins `invert`, `midlevel` and `smoothing`: blurring a solved height map moves its steps off the
-layer boundaries they were solved for.
-
-Colour by filament swap and the layer's own `color_enabled` (one filament per triangle, via
-`mmu_segmentation_facets`) are mutually exclusive, and the panel enforces it. They are two
-different ways of colouring the same surface, and painting the relief per triangle would hide the
-very stack the heights were solved against.
-
-## The filament swaps
-
-`chroma_ranges()` turns the bands into Z bands in the object's own coordinates, merging any two
-adjacent bands that share a filament, since nothing is swapped between them. The panel writes them
-onto the object as `layer_config_ranges`, each range carrying `extruder` - which
-`apply_to_print_region_config()` spreads over every feature filament the range does not otherwise
-override, i.e. the whole band prints in that filament - and `layer_height`, both because the solve
-is only valid at the height it was run at and because `layer_height_profile_from_ranges()` reads
-that option without checking it is there.
-
-Height ranges rather than colour-change custom G-code: they are object-relative, so they survive
-the object being moved, they are saved in the project file, and they appear in the object list where
-the user can see and edit them. The cost is that an object can only have one set of them, so
-applying a stack replaces whatever ranges the object had, with a confirmation when it had any.
-
-`ObjectList::rebuild_layer_ranges()` mirrors them in the object tree without touching the
-selection - changing the selection while a gizmo is open tears the gizmo down under the user.
-
-## Geometry the model assumes
-
-A filament swap happens at one Z across the whole plate, and the relief grows along the painted
-surface's normal. The two agree only where that surface is horizontal, so:
-
-- the painted patch's height above the bottom of the object is what the base layer count has to
-  match, and the panel measures it from the patch and offers the number rather than leaving the user
-  to work it out;
-- a patch that is not flat in Z gets a warning, because its colours will only be right where it is
-  level. The relief itself is still computed, since a gently domed plaque is a legitimate thing to
-  print and only the user can judge how much error is acceptable.
-
-The model itself is the user's: the stack needs a slab of the base thickness with a face to paint,
-and nothing here creates or thickens geometry.
-
-## Seeing the colours
-
-The colours are blends of translucent filaments. No single filament makes them, so they cannot be
-expressed as the per-triangle filament assignment the 3D scene paints with, and there is nothing for
-the ordinary view to draw. They exist in two places: the sliced preview, which shows the filament
-bands as they print, and an overlay the gizmo draws over whatever surface is on screen.
-
-That overlay is a shader, `resources/shaders/*/chromastack.*`, and it reads the colour from each
-fragment's own **print Z** rather than from the height map or from anything in the mesh. A filament
-swap happens at one Z across the whole plate, so the layer a point sits in is what decides its
-colour whatever the picture says. Two things follow. A band edge lands exactly on the layer boundary
-however coarse the triangles are - a per-triangle colouring puts it wherever the mesh happens to
-have an edge. And it keeps working after a bake, when the relief is real geometry, the paint has
-been cleared and the height map is attached to nothing on screen; the overlay is built from the live
-preview's displaced mesh before a bake and from the volume's own mesh after one.
-
-The stack's colours reach the shader as a texture of one texel per printed layer, because a base can
-be several hundred layers and no uniform array holds that. The mesh carries nothing about the stack,
-so editing the stack costs a palette upload rather than a mesh rebuild.
-
-On top of the colour the shader tries to look like printed plastic, because a flat shaded colour
-reads as a rendering and the whole point of the overlay is judging a print:
-
-- the terminator is **wrapped** and the grazing angles **glow**, both scaled by the transmission
-  distance of the filament on top - filament translucent enough to be worth stacking scatters light
-  rather than reflecting it, and an opaque stack correctly gets neither;
-- the walls carry **layer lines**, a groove at every layer boundary that also modulates the
-  specular, so a wall glints in stripes as a printed one does. Terraces get none: a terrace is one
-  layer's top surface and has no lines to show.
-
-Both effects are driven by the fragment's height, so they are free of any texture or UV, and both
-fade out through `fwidth` once a pixel covers more than about half a layer - lines finer than a
-pixel are noise, and a colour read from one layer out of the dozen under a pixel flickers as the
-camera moves. The palette lookup slides off the texel centres over the same range so the linear
-filter averages the bands a pixel covers instead of picking one of them.
-
-The overlay is drawn pulled forward and without depth writes, the same pass the painted-colour
-overlay uses, since it is the same surface as whatever is underneath it.
-
-## What the panel shows
-
-The kind of a layer is the layer's own, chosen when it is added and fixed from then on: **Add layer**
-offers *Relief layer* or *ChromaStack picture*, and the card carries its kind as a chip. There is no
-panel-wide mode, so one object can hold a picture on its face and a knurl on its rim, and a card
-never shows a control that cannot do anything on it.
-
-What the two cards do not share:
-
-| Control | Relief card | ChromaStack card |
-| --- | --- | --- |
-| Depth | slider | the solve writes it; the card prints the result |
-| Tile size | repeats the pattern | **Picture size**, the same number named for what it does |
-| Midlevel, Smoothing, Invert, Edge fade | present | absent: each would move the steps off the layer boundaries |
-| Colors, Mix filaments, Denoise | one filament per triangle | absent: swaps are how this card colours |
-| Tile, tile method | present | absent: one copy, never tiled |
-| Blend | four modes | absent: it is the top layer and replaces what is under it |
-| Picture, prediction, stack, palette, match, Dither, Solve, Apply swaps | absent | present |
-
-A ChromaStack card has no grip and cannot be reordered: its colours come from swapping filament at a
-height, so anything printed above it would bury them. An object may hold only one, refused when the
-layer is added rather than when the swaps are applied, because the swaps are the object's own height
-ranges and there is one set of those.
-
-The card itself, top to bottom: what it is in one line, the picture and the predicted print side by
-side at the same size, the match figures, the base with the measurement from the painted face offered
-beside it, a row per band - swatch, filament, layer count, TD - the colours the stack reaches as a
-ramp, the totals, dither with the layer height it is solved against, and the two actions. Base and
-band counts are typed fields rather than sliders: a base is measured in hundreds of layers and a band
-in single digits, and dragging past the end of a slider's range is how a stack silently loses its
-backing.
-
-The ramp is computed from the stack alone, before any solve. It is what answers "can these filaments
-print this picture" without spending a solve to find out they cannot: a short or flat ramp means the
-filaments are too alike, or too opaque, to give the picture anything to work with.
-
-A per-slot flag records that the stack has been edited since the last solve, because a stale height
-map looks exactly like a good one.

docs/HLSD/mesh-repair.md

@@ -0,0 +1,135 @@
+# Mesh repair — High Level Design
+
+## Purpose and scope
+
+Mesh repair turns a broken triangle mesh into closed, outward oriented shells that bound a solid, so that the
+mesh slices predictably and the other mesh tools (booleans, cut, painting) get valid input. It runs on demand:
+the *Fix Model* command of the context menu of an object or part and of the warning icon in the object list, *Fix
+All* and *Fix All Plates* in the context menu of a plate, the prompt the Cut tool shows when a cut leaves open edges,
+the *Repair and import* choice of texture import, and the `--repair` option of the command line. It is built on CGAL
+and is the only repair the application has, on every platform.
+
+`repair_mesh()` in `src/libslic3r/MeshRepair.cpp` does the work on one `TriangleMesh`, and `ModelVolume::repair()`
+applies it to a part: it replaces the mesh only when the repair changed it, and remaps or drops the painting of a
+replaced mesh. The GUI side, `fix_model_with_cgal_gui()` in `src/slic3r/Utils/FixModelByCgal.cpp`, runs it on a
+worker thread for each volume of an object, or for one volume, behind a progress dialog. `repair_mesh()` reports its
+progress between stages through a callback, which cancels the repair by throwing.
+
+## What the repaired mesh is
+
+The repair keeps what the slicer would print from the input. The slicer fills a layer where the winding number of
+the input surface is not zero (`MeshSlicingParams::SlicingMode::Regular` uses Clipper's nonzero fill rule), so:
+
+- Shells crossing each other print as their union. The repair keeps them as separate shells, as the parts of an
+  object are kept, and makes each of them an outward oriented solid.
+- A shell inside a solid that is oriented like it adds nothing, and the repair removes it.
+- A shell inside a solid that is oriented inward is a cavity, and stays one.
+- A whole mesh turned inside out prints as a solid, and the repair turns it outward.
+
+On top of that, it closes holes and cracks, gives inconsistently oriented triangles the orientation of their
+neighbours, drops degenerate, duplicate and stray flat geometry, and removes small self-intersections inside a shell,
+such as slivers and folds. Where none of this applies, it reports the mesh as unmodified and the caller keeps the
+original mesh, its painting and its object id.
+
+A volume is repaired in place and is never split into several parts: splitting by connectivity would turn a cavity
+into a separate solid part and fill it. Each solid of the result is a shell of its own, so *Split to parts* still
+separates them. Open pieces of the input whose borders meet exactly, which are pieces of one surface rather than
+solids, come out as the one shell they form.
+
+## Pipeline
+
+The input is treated as a triangle soup. Every stage after the first only runs on what the previous ones could
+not settle, so a valid mesh passes through quickly.
+
+### Valid parts first
+
+Parts of the input that are connected by vertex indices and are already closed, consistently oriented 2-manifolds
+skip the soup stages and go straight to the shell stages. Merging their points with coincident points of other
+parts would only make non-manifold junctions out of solids that touch, for example parts of an assembly exported
+together or voxels written as separate cubes.
+
+### Soup clean-up
+
+The rest of the soup has its coincident points merged. Triangles with repeated corners are dropped. Coincident
+triangles of opposite orientation are a wall between two solids touching face to face, so they cancel in pairs;
+of the remaining copies of a triangle one is kept. A connected region that would vanish entirely through
+cancelling is a two-sided export instead (every face written in both orientations), and keeps one copy of each
+triangle.
+
+Open edges then get their vertices welded within a tolerance of 1e-4 of the bounding box diagonal, which closes the
+cracks some exporters leave between triangles that should share corners. A vertex is never welded further than a
+quarter of its shortest edge, so welding cannot collapse fine detail. A soup that stays mostly open after welding has
+cracks wider than that tolerance, and is welded again with ten and then a hundred times the tolerance.
+
+### Work units
+
+The soup is cut into units repaired independently and in parallel: its connected parts, except that open parts whose
+bounding boxes touch share a unit, so that cracks and T-junctions between separately exported patches still close.
+
+### Building the mesh
+
+A unit whose edges are each shared by at most two triangles, running in opposite directions, and whose vertices each
+have a single fan of triangles, becomes a `Surface_mesh` directly. Any other unit is oriented first. Triangles are
+flipped so that neighbours across an edge shared by two of them agree, each part keeping the orientation the
+majority of its area had, which keeps inward oriented cavities inward. Edges where that is impossible or that more
+than two triangles share are cut, and each fan of triangles around a vertex gets its own copy of the vertex. If that
+still leaves an invalid mesh, CGAL's `orient_polygon_soup()` orients the unit instead, and the parts it flipped
+against their majority are reversed back. The linear pass exists because `orient_polygon_soup()` is several times
+slower on large soups that need only a few fixes.
+
+### Closing
+
+Compatible borders are stitched, parts that can be stitched once reversed are merged, and borders still open are
+snapped onto each other within the weld tolerance, which closes T-junctions. Exactly degenerate faces are removed.
+
+Holes are filled last. Planar border loops that face each other in one plane, one inside the other, bound a single
+region, such as a missing annulus at the end of a tube or a cap with features standing on it. Such a group is
+triangulated at once with a 2D constrained Delaunay triangulation that fills only the faces at odd nesting depth,
+so the openings inside the region stay open. The patch is used only if it closes every loop with the orientation
+of the triangles around it. Every other loop is filled on its own with `triangulate_hole()`, which uses a 2D
+constrained Delaunay triangulation when the loop is planar. Otherwise it searches the best triangulation among all
+triangles over the loop for loops of up to 100 edges, and among the triangles of a 3D Delaunay triangulation for
+longer ones, as the full search is cubic in the length of the loop. Beyond 200 edges the full search is not even
+used as a fallback, and a fan around the loop's centroid closes a loop nothing else could.
+
+The closed unit is split into its shells. The largest stays in place and the others are copied out, as converting
+the whole mesh again costs seconds on large models.
+
+### Shells
+
+The shells of all units, together with the valid parts set aside at the start, are handled independently and in
+parallel. Shells enclosing no volume, which hole filling makes out of stray flat patches, are dropped.
+
+Self-intersections inside a shell are removed locally with `experimental::remove_self_intersections()`, which
+remeshes the region around them. It is used only for local defects: a shell whose intersections involve more than
+5 % of its faces is left as it is, and a result that changes the enclosed volume by more than 0.1 % is undone. On
+heavily overlapping ornamental models the remeshing otherwise cuts parts down to slivers, while on genuine defects
+it changes the volume by thousandths of a percent. Overlaps left in place slice correctly. Remeshing can cut
+small pieces off a shell, so a shell it changed is split again and its pieces enclosing no volume are dropped.
+
+Shells crossing others are found through their bounding boxes and an AABB tree per shell, and are made outward
+oriented solids. For every other shell the winding number just outside it is summed from the orientation of the
+shells containing it, tested from a point on its largest face. The shell bounds the solid only if the winding
+number is zero on exactly one of its sides; it is then oriented so that the solid is inside, or dropped otherwise.
+
+Crossing shells are not united. Slicing unites them anyway, uniting them exactly costs tens of seconds on models
+made of many overlapping pieces, and it would fuse parts that *Split to parts* should keep apart.
+
+## Robustness
+
+The repair avoids `experimental::autorefine_and_remove_self_intersections()` and corefinement, which can crash on
+messy input, and uses only steps whose failures it can detect. A step that fails keeps its input. CGAL precondition
+failures surface as `repair_mesh()` returning false with the message as the error. The output is written in float,
+as every mesh in the application is.
+
+The result does not depend on thread scheduling. `libslic3r_cgal` is built with `CGAL_LINKED_WITH_TBB`. Units and
+shells are processed in parallel, but each on its own data, and their results are gathered in a fixed order;
+sorts compare complete keys, and the detected self-intersections are put in order before they are used. Snapping
+stays sequential, as its parallel version gives different results from run to run. Holes are filled with the full
+search wherever it is affordable, because the search among Delaunay triangles can choose between equally good fills
+differently from run to run, so only non-planar holes of more than 100 edges may still vary. On some inputs
+`experimental::remove_self_intersections()` itself places a few vertices differently from run to run.
+
+## Verification
+
+`tests/libslic3r/test_mesh_repair.cpp` covers each kind of defect above on small meshes with known volumes.

resources/profiles/BBL.json

@@ -1,7 +1,7 @@
 {
 	"name": "Bambulab",
 	"url": "http://www.bambulab.com/Parameters/vendor/BBL.json",
-	"version": "02.08.00.14",
+	"version": "02.08.00.15",
 	"force_update": "0",
 	"description": "the initial version of BBL configurations",
 	"machine_model_list": [

resources/shaders/110/chromastack.fs

@@ -1,92 +0,0 @@
-#version 110
-
-// What a ChromaStack print looks like, shaded per fragment.
-//
-// The colour is not a vertex attribute and not a texture on the surface: it is read from the
-// fragment's own height. A filament swap happens at one print Z across the whole plate, so the layer
-// a point sits in is what decides its colour - which means a band edge lands exactly on the layer
-// boundary however coarse the mesh is, and the same shader is right before a bake (on the preview's
-// displaced mesh) and after one (on the volume's own).
-//
-// On top of that it tries to look like printed plastic rather than like flat shaded colour: the
-// terminator is wrapped and the grazing angles glow, because filament translucent enough to be worth
-// stacking scatters light rather than reflecting it; and the walls carry layer lines, because that is
-// the first thing the eye uses to read a print as a print.
-
-#define INTENSITY_CORRECTION 0.6
-const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
-#define LIGHT_TOP_DIFFUSE    (0.8 * INTENSITY_CORRECTION)
-#define LIGHT_TOP_SPECULAR   (0.125 * INTENSITY_CORRECTION)
-#define LIGHT_TOP_SHININESS  20.0
-const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
-#define LIGHT_FRONT_DIFFUSE  (0.3 * INTENSITY_CORRECTION)
-#define INTENSITY_AMBIENT    0.3
-
-// The stack's colours, one texel per printed layer, bottom to top. A texture rather than a uniform
-// array because a base can be several hundred layers and no uniform array survives that.
-uniform sampler2D palette;
-uniform float     palette_size;  // texels in `palette`, i.e. the stack's total printed layers
-uniform float     base_z;        // world Z of the bottom of the object
-uniform float     layer_height;  // mm
-// How translucent the stack reads, 0 to 1, from the transmission distance of the filament on top.
-// It drives the wrap and the rim: an opaque stack should not glow.
-uniform float     translucency;
-uniform float     alpha;
-
-varying vec3  clipping_planes_dots;
-varying vec3  eye_normal;
-varying vec3  eye_position;
-varying vec3  world_normal;
-varying float world_z;
-
-void main()
-{
-    if (any(lessThan(clipping_planes_dots, vec3(0.0))))
-        discard;
-
-    float z_rel  = world_z - base_z;
-    float layers = max(z_rel / layer_height, 0.0);
-    // How much of a layer one pixel covers. Everything below is faded out as this grows: layer lines
-    // finer than a pixel are noise, and a colour read from one layer out of the dozen under a pixel
-    // flickers as the camera moves.
-    float px     = fwidth(layers);
-
-    // The layer this fragment sits in, 1-based. Up close that is an exact texel of the palette; once a
-    // pixel spans a layer or more it slides to a continuous coordinate so the linear filter averages
-    // the bands it covers instead of picking one of them at random.
-    float stepped = clamp(ceil(layers - 1.0e-4), 1.0, palette_size) - 0.5;
-    float smooth_ = clamp(layers, 0.5, palette_size - 0.5);
-    float u       = mix(stepped, smooth_, clamp(px - 0.5, 0.0, 1.0)) / palette_size;
-    vec3  albedo  = texture2D(palette, vec2(u, 0.5)).rgb;
-
-    vec3 N = normalize(eye_normal);
-    vec3 V = normalize(-eye_position);
-
-    // Layer lines, on the walls only: a terrace is one layer's top surface and has none to show. The
-    // groove runs round the part at every layer boundary, so it is a function of height alone.
-    float wall   = 1.0 - abs(world_normal.z);
-    float phase  = fract(layers);
-    float groove = smoothstep(0.0, 0.16, phase) * smoothstep(1.0, 0.84, phase);
-    groove       = mix(groove, 0.65, clamp(px * 1.5, 0.0, 1.0)); // fade to flat when too fine to resolve
-    float lines  = mix(1.0, 0.84 + 0.16 * groove, wall * 0.9);
-    albedo      *= lines;
-
-    // Diffuse, with a wrapped terminator: light entering translucent filament comes back out a little
-    // way round the curve, so the shaded side never goes as dark as an opaque surface's would.
-    float wrap    = 0.25 + 0.45 * translucency;
-    float ndotl   = dot(N, LIGHT_TOP_DIR);
-    float diffuse = max((ndotl + wrap) / (1.0 + wrap), 0.0) * LIGHT_TOP_DIFFUSE;
-    diffuse      += max((dot(N, LIGHT_FRONT_DIR) + wrap) / (1.0 + wrap), 0.0) * LIGHT_FRONT_DIFFUSE;
-
-    // Specular, strongest along a layer line, which is what makes a printed wall glint in stripes
-    // rather than evenly.
-    float spec = LIGHT_TOP_SPECULAR * pow(max(dot(V, reflect(-LIGHT_TOP_DIR, N)), 0.0), LIGHT_TOP_SHININESS);
-    spec      *= mix(1.0, 0.35 + 0.65 * groove, wall * 0.9);
-
-    // Scattering out of the edges: a translucent part lights up where it is seen at a grazing angle
-    // and where it is thin. Tinted by the filament, because what comes back out has been through it.
-    float rim = pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 4.0);
-
-    vec3 color = albedo * (INTENSITY_AMBIENT + diffuse) + vec3(spec) + albedo * rim * translucency * 0.55;
-    gl_FragColor = vec4(color, alpha);
-}

resources/shaders/110/chromastack.vs

@@ -1,40 +0,0 @@
-#version 110
-
-uniform mat4 view_model_matrix;
-uniform mat4 projection_matrix;
-uniform mat3 view_normal_matrix;
-uniform mat4 volume_world_matrix;
-// The volume's normal matrix in world space, so the fragment shader can tell a wall from a terrace -
-// which is what decides whether layer lines show at all.
-uniform mat3 world_normal_matrix;
-// Clipping plane, x = min z, y = max z (the FFF/SLA preview's top/bottom cut).
-uniform vec2 z_range;
-// Clipping plane, general orientation (the section view).
-uniform vec4 clipping_plane;
-
-// GLModel's P3N3 layout, which is what init_from(indexed_triangle_set) produces - this shader needs
-// nothing per vertex that the mesh does not already carry, because the colour comes from the
-// fragment's own height rather than from anything baked into the vertices.
-attribute vec3 v_position;
-attribute vec3 v_normal;
-
-varying vec3  clipping_planes_dots;
-varying vec3  eye_normal;
-varying vec3  eye_position;
-varying vec3  world_normal;
-varying float world_z;
-
-void main()
-{
-    vec4 model_pos = vec4(v_position, 1.0);
-    vec4 world_pos = volume_world_matrix * model_pos;
-    world_z        = world_pos.z;
-    world_normal   = normalize(world_normal_matrix * v_normal);
-    eye_normal     = normalize(view_normal_matrix * v_normal);
-
-    vec4 eye_pos = view_model_matrix * model_pos;
-    eye_position = eye_pos.xyz;
-    gl_Position  = projection_matrix * eye_pos;
-
-    clipping_planes_dots = vec3(dot(world_pos, clipping_plane), world_pos.z - z_range.x, z_range.y - world_pos.z);
-}

resources/shaders/140/chromastack.fs

@@ -1,94 +0,0 @@
-#version 140
-
-// What a ChromaStack print looks like, shaded per fragment.
-//
-// The colour is not a vertex attribute and not a texture on the surface: it is read from the
-// fragment's own height. A filament swap happens at one print Z across the whole plate, so the layer
-// a point sits in is what decides its colour - which means a band edge lands exactly on the layer
-// boundary however coarse the mesh is, and the same shader is right before a bake (on the preview's
-// displaced mesh) and after one (on the volume's own).
-//
-// On top of that it tries to look like printed plastic rather than like flat shaded colour: the
-// terminator is wrapped and the grazing angles glow, because filament translucent enough to be worth
-// stacking scatters light rather than reflecting it; and the walls carry layer lines, because that is
-// the first thing the eye uses to read a print as a print.
-
-#define INTENSITY_CORRECTION 0.6
-const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
-#define LIGHT_TOP_DIFFUSE    (0.8 * INTENSITY_CORRECTION)
-#define LIGHT_TOP_SPECULAR   (0.125 * INTENSITY_CORRECTION)
-#define LIGHT_TOP_SHININESS  20.0
-const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
-#define LIGHT_FRONT_DIFFUSE  (0.3 * INTENSITY_CORRECTION)
-#define INTENSITY_AMBIENT    0.3
-
-// The stack's colours, one texel per printed layer, bottom to top. A texture rather than a uniform
-// array because a base can be several hundred layers and no uniform array survives that.
-uniform sampler2D palette;
-uniform float     palette_size;  // texels in `palette`, i.e. the stack's total printed layers
-uniform float     base_z;        // world Z of the bottom of the object
-uniform float     layer_height;  // mm
-// How translucent the stack reads, 0 to 1, from the transmission distance of the filament on top.
-// It drives the wrap and the rim: an opaque stack should not glow.
-uniform float     translucency;
-uniform float     alpha;
-
-in vec3  clipping_planes_dots;
-in vec3  eye_normal;
-in vec3  eye_position;
-in vec3  world_normal;
-in float world_z;
-
-out vec4 out_color;
-
-void main()
-{
-    if (any(lessThan(clipping_planes_dots, vec3(0.0))))
-        discard;
-
-    float z_rel  = world_z - base_z;
-    float layers = max(z_rel / layer_height, 0.0);
-    // How much of a layer one pixel covers. Everything below is faded out as this grows: layer lines
-    // finer than a pixel are noise, and a colour read from one layer out of the dozen under a pixel
-    // flickers as the camera moves.
-    float px     = fwidth(layers);
-
-    // The layer this fragment sits in, 1-based. Up close that is an exact texel of the palette; once a
-    // pixel spans a layer or more it slides to a continuous coordinate so the linear filter averages
-    // the bands it covers instead of picking one of them at random.
-    float stepped = clamp(ceil(layers - 1.0e-4), 1.0, palette_size) - 0.5;
-    float smooth_ = clamp(layers, 0.5, palette_size - 0.5);
-    float u       = mix(stepped, smooth_, clamp(px - 0.5, 0.0, 1.0)) / palette_size;
-    vec3  albedo  = texture(palette, vec2(u, 0.5)).rgb;
-
-    vec3 N = normalize(eye_normal);
-    vec3 V = normalize(-eye_position);
-
-    // Layer lines, on the walls only: a terrace is one layer's top surface and has none to show. The
-    // groove runs round the part at every layer boundary, so it is a function of height alone.
-    float wall   = 1.0 - abs(world_normal.z);
-    float phase  = fract(layers);
-    float groove = smoothstep(0.0, 0.16, phase) * smoothstep(1.0, 0.84, phase);
-    groove       = mix(groove, 0.65, clamp(px * 1.5, 0.0, 1.0)); // fade to flat when too fine to resolve
-    float lines  = mix(1.0, 0.84 + 0.16 * groove, wall * 0.9);
-    albedo      *= lines;
-
-    // Diffuse, with a wrapped terminator: light entering translucent filament comes back out a little
-    // way round the curve, so the shaded side never goes as dark as an opaque surface's would.
-    float wrap    = 0.25 + 0.45 * translucency;
-    float ndotl   = dot(N, LIGHT_TOP_DIR);
-    float diffuse = max((ndotl + wrap) / (1.0 + wrap), 0.0) * LIGHT_TOP_DIFFUSE;
-    diffuse      += max((dot(N, LIGHT_FRONT_DIR) + wrap) / (1.0 + wrap), 0.0) * LIGHT_FRONT_DIFFUSE;
-
-    // Specular, strongest along a layer line, which is what makes a printed wall glint in stripes
-    // rather than evenly.
-    float spec = LIGHT_TOP_SPECULAR * pow(max(dot(V, reflect(-LIGHT_TOP_DIR, N)), 0.0), LIGHT_TOP_SHININESS);
-    spec      *= mix(1.0, 0.35 + 0.65 * groove, wall * 0.9);
-
-    // Scattering out of the edges: a translucent part lights up where it is seen at a grazing angle
-    // and where it is thin. Tinted by the filament, because what comes back out has been through it.
-    float rim = pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 4.0);
-
-    vec3 color = albedo * (INTENSITY_AMBIENT + diffuse) + vec3(spec) + albedo * rim * translucency * 0.55;
-    out_color  = vec4(color, alpha);
-}

resources/shaders/140/chromastack.vs

@@ -1,40 +0,0 @@
-#version 140
-
-uniform mat4 view_model_matrix;
-uniform mat4 projection_matrix;
-uniform mat3 view_normal_matrix;
-uniform mat4 volume_world_matrix;
-// The volume's normal matrix in world space, so the fragment shader can tell a wall from a terrace -
-// which is what decides whether layer lines show at all.
-uniform mat3 world_normal_matrix;
-// Clipping plane, x = min z, y = max z (the FFF/SLA preview's top/bottom cut).
-uniform vec2 z_range;
-// Clipping plane, general orientation (the section view).
-uniform vec4 clipping_plane;
-
-// GLModel's P3N3 layout, which is what init_from(indexed_triangle_set) produces - this shader needs
-// nothing per vertex that the mesh does not already carry, because the colour comes from the
-// fragment's own height rather than from anything baked into the vertices.
-in vec3 v_position;
-in vec3 v_normal;
-
-out vec3  clipping_planes_dots;
-out vec3  eye_normal;
-out vec3  eye_position;
-out vec3  world_normal;
-out float world_z;
-
-void main()
-{
-    vec4 model_pos = vec4(v_position, 1.0);
-    vec4 world_pos = volume_world_matrix * model_pos;
-    world_z        = world_pos.z;
-    world_normal   = normalize(world_normal_matrix * v_normal);
-    eye_normal     = normalize(view_normal_matrix * v_normal);
-
-    vec4 eye_pos = view_model_matrix * model_pos;
-    eye_position = eye_pos.xyz;
-    gl_Position  = projection_matrix * eye_pos;
-
-    clipping_planes_dots = vec3(dot(world_pos, clipping_plane), world_pos.z - z_range.x, z_range.y - world_pos.z);
-}

scripts/ci_deps_cache.sh

@@ -1,21 +1,27 @@
 #!/usr/bin/env bash
-# Lets a pull request's macOS deps build wait for a push build of the base
-# branch that builds the same deps, from a Linux job. `check` runs after a cache
-# miss and names a queued or running base build with the same deps/ and .github/
-# to wait for, unless the pull request changes either. `wait` waits until that
-# build saves KEY. actions/cache then confirms the entry can be restored.
+# Lets a pull request's macOS deps build, or its clang-tidy job, wait for a
+# build that saves the deps cache it needs, from a Linux job. `check` runs after
+# a cache miss and names a queued or running push build of the base branch with
+# the same deps/ and .github/ to wait for, unless the pull request changes either.
+# `own` names the pull request's own build instead, for clang-tidy when the pull
+# request changes deps/. `wait` waits until that build saves KEY under CACHE_REF,
+# or its deps job fails. actions/cache then confirms the entry can be restored.
 #
-# Environment: GH_TOKEN, REPO, WORKFLOW_REF and BASE_REF, plus KEY_INPUTS,
-# WAIT_FOR, WAIT_SINCE, WAIT_MINUTES, KEY and ARCH for `wait`.
+# Environment: GH_TOKEN, REPO, WORKFLOW_REF (or WORKFLOW, the build workflow's
+# file name) and BASE_REF, plus HEAD_SHA for `own`, and KEY_INPUTS, WAIT_FOR,
+# WAIT_SINCE, WAIT_MINUTES, KEY, CACHE_REF (default the base branch) and ARCH
+# (or JOB, the matrix job's name) for `wait`.
 # Writes key-inputs, wait-for and wait-since to $GITHUB_OUTPUT.
 set -uo pipefail
 
-workflow=${WORKFLOW_REF%%@*}
-workflow=${workflow##*/}
+workflow=${WORKFLOW_REF:-}
+workflow=${workflow%%@*}
+workflow=${WORKFLOW:-${workflow##*/}}
 
 # Must match the job names in build_all.yml, build_check_cache.yml and build_deps.yml.
-check_job_name="build_macos_arch (${ARCH:-}) / Check Cache"
-deps_job_name="build_macos_arch (${ARCH:-}) / Build Deps / Build Deps"
+job=${JOB:-build_macos_arch (${ARCH:-})}
+check_job_name="$job / Check Cache"
+deps_job_name="$job / Build Deps / Build Deps"
 
 out() { echo "$1" >> "${GITHUB_OUTPUT:-/dev/stdout}"; }
 
@@ -63,8 +69,27 @@ check() {
   fi
 }
 
+own() {
+  out "key-inputs=$(local_key_inputs HEAD)"
+  local id
+  # The build can be created a moment after this job.
+  for _ in 1 2 3 4 5; do
+    id=$(gh api -X GET "repos/$REPO/actions/workflows/$workflow/runs" \
+      -f head_sha="$HEAD_SHA" -f event=pull_request -f per_page=1 --jq '.workflow_runs[0].id // empty' < /dev/null)
+    [ -n "$id" ] && break
+    sleep 30
+  done
+  if [ -n "$id" ]; then
+    echo "Waiting for the deps cache of build $id of this pull request."
+    out "wait-for=$id"
+    out "wait-since=$(date +%s)"
+  else
+    echo "No build of this pull request is building its deps."
+  fi
+}
+
 key_saved() {
-  gh cache list -R "$REPO" --ref "refs/heads/$BASE_REF" --key "$KEY" --json key < /dev/null \
+  gh cache list -R "$REPO" --ref "${CACHE_REF:-refs/heads/$BASE_REF}" --key "$KEY" --json key < /dev/null \
     | jq -e --arg key "$KEY" 'any(.[]; .key == $key)' > /dev/null
 }
 
@@ -87,11 +112,11 @@ wait_for() {
           key_saved && { echo "Found $KEY."; return; }
           sleep 20
         done
-        echo "Build $id of $BASE_REF finished its deps without saving $KEY."
+        echo "Build $id finished its deps without saving $KEY."
         return ;;
       "completed cancelled") ;;
       completed*)
-        echo "The deps job of build $id of $BASE_REF did not succeed."
+        echo "The deps job of build $id did not succeed."
         return ;;
       # The deps job exists only once the build's cache check has succeeded.
       "")
@@ -100,7 +125,7 @@ wait_for() {
           completed*)
             check=$(jq -r --arg name "$check_job_name" 'first(.jobs[] | select(.name == $name) | .conclusion) // ""' <<< "$jobs")
             if [ -z "$warned" ] && { [ -z "$check" ] || [ "$check" = success ]; }; then
-              echo "::warning title=Deps wait::Build $id of $BASE_REF has no job named \"$deps_job_name\". If the build jobs were renamed, update scripts/ci_deps_cache.sh. This does not affect this pull request."
+              echo "::warning title=Deps wait::Build $id has no job named \"$deps_job_name\". If the build jobs were renamed, update scripts/ci_deps_cache.sh. This does not affect this pull request."
               warned=1
             fi ;;
           *)
@@ -118,11 +143,12 @@ wait_for() {
     seen="$seen $id"
     echo "Following build $id of $BASE_REF."
   done
-  echo "No build of $BASE_REF saved $KEY."
+  echo "No build saved $KEY."
 }
 
 case "${1:-}" in
   check) check ;;
+  own) own ;;
   wait) wait_for ;;
-  *) echo "usage: $0 check|wait" >&2; exit 2 ;;
+  *) echo "usage: $0 check|own|wait" >&2; exit 2 ;;
 esac

src/OrcaSlicer.cpp

@@ -99,6 +99,7 @@
 #include "libslic3r/Preset.hpp"
 #include "libslic3r/Geometry.hpp"
 #include "libslic3r/GCode.hpp"
+#include "libslic3r/MeshRepair.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/ModelArrange.hpp"
 #include "libslic3r/Platform.hpp"
@@ -206,7 +207,7 @@ std::map<int, std::string> cli_errors = {
     {CLI_OBJECT_ORIENT_FAILED, "An error occurred when auto-orienting object(s)."},
     {CLI_MODIFIED_PARAMS_TO_PRINTER, "Found modified parameter in printer preset in the 3mf file, which should not be changed."},
         {CLI_FILE_VERSION_NOT_SUPPORTED, "Unsupported 3MF version. Please make sure the 3MF file was created with the official version of Bambu Studio, not a beta version."},
-    {CLI_NO_SUITABLE_OBJECTS, "One of the plate is empty or has no object fully inside it. Please check that the 3mf contains no empty plate in Orca Slicer before uploading."},
+    {CLI_NO_SUITABLE_OBJECTS, "The plate has nothing to slice: it is empty, or no object on it is both printable and fully inside the print volume."},
     {CLI_VALIDATE_ERROR, "There are some incorrect slicing parameters in the 3mf. Please verify the slicing of all plates in Orca Slicer before uploading."},
     {CLI_OBJECTS_PARTLY_INSIDE, "Some objects are located over the boundary of the heated bed."},
     {CLI_EXPORT_CACHE_DIRECTORY_CREATE_FAILED, "Failed creating directory when exporting cache data."},
@@ -1463,7 +1464,7 @@ int CLI::run(int argc, char **argv)
     //int arrange_option;
     int plate_to_slice = 0, filament_count = 0, duplicate_count = 0, real_duplicate_count = 0, current_extruder_count = 1, new_extruder_count = 1, current_printer_variant_count = 1, current_print_variant_count = 1, new_printer_variant_count = 1;
     bool first_file = true, is_bbl_3mf = false, need_arrange = true, has_thumbnails = false, up_config_to_date = false, normative_check = true, duplicate_single_object = false, use_first_fila_as_default = false, minimum_save = false, enable_timelapse = false;
-    bool allow_rotations = true, skip_modified_gcodes = false, avoid_extrusion_cali_region = false, skip_useless_pick = false, allow_newer_file = false, current_is_multi_extruder = false, new_is_multi_extruder = false, allow_mix_temp = false, enable_wrapping_detect = false;
+    bool allow_rotations = false, skip_modified_gcodes = false, avoid_extrusion_cali_region = false, skip_useless_pick = false, allow_newer_file = false, current_is_multi_extruder = false, new_is_multi_extruder = false, allow_mix_temp = false, enable_wrapping_detect = false;
     Semver file_version;
     std::map<size_t, bool> orients_requirement;
     std::vector<Preset*> project_presets;
@@ -5130,9 +5131,19 @@ int CLI::run(int argc, char **argv)
                 }
             }
         } else if (opt_key == "repair") {
-            // Models are repaired by default.
-            //for (auto &model : m_models)
-            //    model.repair();
+            if (m_config.opt_bool(opt_key))
+                for (Model &model : m_models)
+                    for (ModelObject *object : model.objects) {
+                        for (ModelVolume *volume : object->volumes) {
+                            MeshRepairStats stats;
+                            std::string     error;
+                            if (!volume->repair(true, &stats, &error))
+                                BOOST_LOG_TRIVIAL(warning) << "repair of " << object->name << " / " << volume->name << " failed: " << error;
+                            else if (stats.modified)
+                                BOOST_LOG_TRIVIAL(info) << "repaired " << object->name << " / " << volume->name;
+                        }
+                        object->invalidate_bounding_box();
+                    }
         } else {
             boost::nowide::cerr << "error: option not implemented yet: " << opt_key << std::endl;
             record_exit_reson(outfile_dir, CLI_UNSUPPORTED_OPERATION, 0, cli_errors[CLI_UNSUPPORTED_OPERATION], sliced_info);
@@ -5142,6 +5153,7 @@ int CLI::run(int argc, char **argv)
 
     BOOST_LOG_TRIVIAL(info) << "finished model pre-process commands\n";
     bool oriented_or_arranged = false;
+    bool arranged_without_rotations = false;
     //BBS: add orient and arrange logic here
     for (auto& model : m_models)
     {
@@ -5409,6 +5421,7 @@ int CLI::run(int argc, char **argv)
                 BOOST_LOG_TRIVIAL(info) << boost::format("start plate %1%'s arranging...") % (i + 1);
                 arrangement::arrange(selected, unselected, beds, arrange_cfg);
                 //arrangement::arrange(unprintable, {}, beds, arrange_cfg);
+                arranged_without_rotations |= !arrange_cfg.allow_rotations;
                 BOOST_LOG_TRIVIAL(info) << boost::format("finished plate %1%'s arranging") % (i + 1);
 
                 //step-4: postprocess the bed index and result
@@ -5881,6 +5894,7 @@ int CLI::run(int argc, char **argv)
                 BOOST_LOG_TRIVIAL(info) << boost::format("start %1% th arranging...")%arrange_count;
                 arrangement::arrange(selected, unselected, beds, arrange_cfg);
                 arrangement::arrange(unprintable, {}, beds, arrange_cfg);
+                arranged_without_rotations |= !arrange_cfg.allow_rotations;
                 BOOST_LOG_TRIVIAL(info) << boost::format("finished %1% th arranging...")%arrange_count;
 
                 //Step-4:postprocess by partplate list&&apply the result
@@ -6425,7 +6439,15 @@ int CLI::run(int argc, char **argv)
 
                         if (count == 0) {
                             BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": Nothing to be sliced, Either the print is empty or no object is fully inside the print volume before apply." << std::endl;
-                            record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS, index+1, cli_errors[CLI_NO_SUITABLE_OBJECTS], sliced_info);
+                            std::string no_objects_reason = cli_errors[CLI_NO_SUITABLE_OBJECTS];
+                            if (arranged_without_rotations) {
+                                //ORCA: result.json is only written on Linux, so also print the reason to stderr.
+                                no_objects_reason = "No object is fully inside the print volume. Arrange ran without rotations."
+                                                    " If an object only fits the bed when rotated, pass --allow-rotations."
+                                                    " Otherwise the plate is empty or an object is larger than the printable area or height.";
+                                boost::nowide::cerr << "plate " << index+1 << ": " << no_objects_reason << std::endl;
+                            }
+                            record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS, index+1, no_objects_reason, sliced_info);
                             flush_and_exit(CLI_NO_SUITABLE_OBJECTS);
                         }
                         else if ((plate_to_slice != 0) || pre_check) {

src/libslic3r/CMakeLists.txt

@@ -325,8 +325,6 @@ set(lisbslic3r_sources
     Geometry/VoronoiUtils.cpp
     Geometry/VoronoiUtils.hpp
     Geometry/VoronoiVisualUtils.hpp
-    ChromaStack.cpp
-    ChromaStack.hpp
     IMEXArrange.cpp
     IMEXArrange.hpp
     IMEXHelpers.cpp
@@ -627,6 +625,7 @@ add_library(libslic3r_cgal STATIC
     CutSurface.hpp CutSurface.cpp
     IntersectionPoints.hpp IntersectionPoints.cpp
     MeshBoolean.hpp MeshBoolean.cpp
+    MeshRepair.hpp MeshRepair.cpp
     TryCatchSignal.hpp TryCatchSignal.cpp
     Triangulation.hpp Triangulation.cpp
 )
@@ -654,7 +653,9 @@ if (IS_CLANG_CL)
     target_compile_options(libslic3r_cgal PRIVATE -Wno-overriding-option)
 endif ()
 
-target_link_libraries(libslic3r_cgal PRIVATE ${_cgal_tgt} admesh libigl mcut boost_libs)
+# Lets CGAL algorithms given CGAL::Parallel_if_available_tag run on TBB.
+target_compile_definitions(libslic3r_cgal PRIVATE CGAL_LINKED_WITH_TBB)
+target_link_libraries(libslic3r_cgal PRIVATE ${_cgal_tgt} admesh libigl mcut boost_libs TBB::tbb)
 
 if (MSVC AND "${CMAKE_SIZEOF_VOID_P}" STREQUAL "4") # 32 bit MSVC workaround
     target_compile_definitions(libslic3r_cgal PRIVATE CGAL_DO_NOT_USE_MPZF)

src/libslic3r/ChromaStack.cpp

@@ -1,394 +0,0 @@
-#include "ChromaStack.hpp"
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <limits>
-#include <cstdlib>
-#include <numeric>
-
-#include <tbb/blocked_range.h>
-#include <tbb/parallel_for.h>
-
-#include <miniz.h>
-
-namespace Slic3r {
-
-// How many e-folding lengths of absorption count as "the colour beneath no longer shows". Three
-// passes 5% of the light, which is about where the eye stops seeing what is under a layer.
-static constexpr float OPAQUE_EFOLDS = 3.f;
-
-// TD is a filament property, so a zero or negative value in a preset is a data error rather than a
-// request for an infinitely opaque filament. Clamp instead: below this the filament is opaque at a
-// single layer anyway.
-static constexpr float TD_MIN_MM = 0.05f;
-static constexpr float TD_MAX_MM = 100.f;
-
-static float srgb_to_linear(float c)
-{
-    return c <= 0.04045f ? c / 12.92f : std::pow((c + 0.055f) / 1.055f, 2.4f);
-}
-
-static float linear_to_srgb(float c)
-{
-    return c <= 0.0031308f ? c * 12.92f : 1.055f * std::pow(c, 1.f / 2.4f) - 0.055f;
-}
-
-// CIELAB under D65, from non-linear sRGB in [0, 1]. Only used for nearest-colour search, so the
-// absolute white point matters far less than both sides using the same one.
-struct Lab
-{
-    float l = 0.f, a = 0.f, b = 0.f;
-};
-
-static Lab srgb_to_lab(float r, float g, float b)
-{
-    const float rl = srgb_to_linear(r), gl = srgb_to_linear(g), bl = srgb_to_linear(b);
-    const float x = (0.4124f * rl + 0.3576f * gl + 0.1805f * bl) / 0.95047f;
-    const float y = (0.2126f * rl + 0.7152f * gl + 0.0722f * bl);
-    const float z = (0.0193f * rl + 0.1192f * gl + 0.9505f * bl) / 1.08883f;
-    auto        f = [](float t) {
-        return t > 0.008856f ? std::cbrt(t) : (7.787f * t + 16.f / 116.f);
-    };
-    const float fx = f(x), fy = f(y), fz = f(z);
-    return Lab{ 116.f * fy - 16.f, 500.f * (fx - fy), 200.f * (fy - fz) };
-}
-
-static float delta_e(const Lab &p, const Lab &q)
-{
-    const float dl = p.l - q.l, da = p.a - q.a, db = p.b - q.b;
-    return std::sqrt(dl * dl + da * da + db * db);
-}
-
-int ChromaStack::relief_layers() const
-{
-    int n = 0;
-    for (const ChromaBand &band : bands)
-        n += std::max(0, band.layers);
-    return n;
-}
-
-int ChromaStack::total_layers() const { return std::max(0, base_layers) + relief_layers(); }
-
-float ChromaStack::depth_mm() const { return float(relief_layers()) * layer_height_mm; }
-
-std::vector<ColorRGB> chroma_palette(const ChromaStack &stack)
-{
-    const int total = stack.total_layers();
-    // No bands means no picture and no filament to print the base in, whatever base_layers says.
-    if (total <= 0 || stack.bands.empty() || stack.layer_height_mm <= 0.f)
-        return {};
-
-    // The filament each printed layer is in, bottom-up: the base first, in the bottom band's filament,
-    // then the bands themselves.
-    std::vector<const ChromaFilament *> per_layer;
-    per_layer.reserve(size_t(total));
-    for (int i = 0; i < std::max(0, stack.base_layers); ++i)
-        per_layer.push_back(&stack.bands.front().filament);
-    for (const ChromaBand &band : stack.bands)
-        for (int i = 0; i < band.layers; ++i)
-            per_layer.push_back(&band.filament);
-
-    std::vector<ColorRGB> palette(size_t(total) + 1);
-
-    // Linear light, walking up from an opaque base: C_0 is the bottom layer's own colour, so a
-    // column one layer tall comes out exactly that colour however translucent the filament is.
-    std::array<float, 3> acc{ srgb_to_linear(per_layer.front()->color.r()), srgb_to_linear(per_layer.front()->color.g()),
-                              srgb_to_linear(per_layer.front()->color.b()) };
-    auto                 store = [&palette](size_t k, const std::array<float, 3> &lin) {
-        palette[k] = ColorRGB(std::clamp(linear_to_srgb(lin[0]), 0.f, 1.f), std::clamp(linear_to_srgb(lin[1]), 0.f, 1.f),
-                              std::clamp(linear_to_srgb(lin[2]), 0.f, 1.f));
-    };
-    store(0, acc);
-
-    for (int k = 1; k <= total; ++k) {
-        const ChromaFilament &f  = *per_layer[size_t(k - 1)];
-        const float             td = std::clamp(f.td_mm, TD_MIN_MM, TD_MAX_MM);
-        // The depth at which this filament hides what is behind it, turned into the e-folding length
-        // of its absorption; see CHROMA_TD_OPAQUE_FRACTION.
-        const float efold = CHROMA_TD_OPAQUE_FRACTION * td / OPAQUE_EFOLDS;
-        const float t     = std::exp(-stack.layer_height_mm / efold);
-        const std::array<float, 3> own{ srgb_to_linear(f.color.r()), srgb_to_linear(f.color.g()),
-                                        srgb_to_linear(f.color.b()) };
-        for (int c = 0; c < 3; ++c)
-            acc[size_t(c)] = (1.f - t) * own[size_t(c)] + t * acc[size_t(c)];
-        store(size_t(k), acc);
-    }
-    return palette;
-}
-
-ChromaSolve chroma_solve(const uint8_t *rgb, int width, int height, const ChromaStack &stack)
-{
-    ChromaSolve solve;
-    const int     total  = stack.total_layers();
-    const int     base   = std::max(0, stack.base_layers);
-    const int     relief = stack.relief_layers();
-    if (rgb == nullptr || width <= 0 || height <= 0 || relief <= 0 || relief > CHROMA_MAX_RELIEF_LAYERS)
-        return solve;
-
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    if (int(palette.size()) != total + 1)
-        return solve;
-
-    // Only the heights the solver may choose: base (nothing of the relief printed) up to total.
-    const int               choices = relief + 1;
-    const size_t                        choice_count = size_t(choices);
-    std::vector<Lab>                    choice_lab(choice_count);
-    std::vector<std::array<uint8_t, 3>> choice_rgb(choice_count);
-    for (int i = 0; i < choices; ++i) {
-        const ColorRGB &c = palette[size_t(base + i)];
-        choice_lab[size_t(i)] = srgb_to_lab(c.r(), c.g(), c.b());
-        choice_rgb[size_t(i)] = { uint8_t(std::lround(c.r() * 255.f)), uint8_t(std::lround(c.g() * 255.f)),
-                                  uint8_t(std::lround(c.b() * 255.f)) };
-    }
-
-    const size_t count = size_t(width) * size_t(height);
-    solve.width        = width;
-    solve.height       = height;
-    solve.levels.resize(count);
-    solve.grey.resize(count);
-    solve.preview.resize(count * 3);
-
-    std::vector<float> errors(count, 0.f);
-
-    auto pick = [&](float r, float g, float b, float &out_error) {
-        const Lab target = srgb_to_lab(std::clamp(r, 0.f, 1.f), std::clamp(g, 0.f, 1.f), std::clamp(b, 0.f, 1.f));
-        int       best   = 0;
-        float     best_d = std::numeric_limits<float>::max();
-        for (int i = 0; i < choices; ++i) {
-            const float d = delta_e(target, choice_lab[size_t(i)]);
-            if (d < best_d) {
-                best_d = d;
-                best   = i;
-            }
-        }
-        out_error = best_d;
-        return best;
-    };
-
-    // The grey level a chosen height is written as. Rounded to the nearest of 256 levels, which for
-    // any practical layer budget (a few dozen) maps every height to its own level exactly - the
-    // relief's steps stay on layer boundaries, which is the whole point of quantizing here.
-    auto grey_of = [relief](int choice) {
-        return uint8_t(std::lround(255.0 * double(choice) / double(relief)));
-    };
-
-    auto write = [&](size_t px, int choice, float err) {
-        solve.levels[px]        = uint16_t(base + choice);
-        solve.grey[px]          = grey_of(choice);
-        solve.preview[px * 3]     = choice_rgb[size_t(choice)][0];
-        solve.preview[px * 3 + 1] = choice_rgb[size_t(choice)][1];
-        solve.preview[px * 3 + 2] = choice_rgb[size_t(choice)][2];
-        errors[px]              = err;
-    };
-
-    if (stack.dither) {
-        // Floyd-Steinberg, serpentine so the error does not drift consistently to one side. The
-        // diffusion buffer holds the two rows the kernel reaches, in sRGB - which is where the
-        // artifact being traded away lives, and what every reference implementation diffuses in.
-        const size_t                      row_len = size_t(width);
-        std::vector<std::array<float, 3>> row(row_len), next(row_len);
-        for (int x = 0; x < width; ++x) {
-            const uint8_t *src = rgb + size_t(x) * 3;
-            row[size_t(x)]     = { src[0] / 255.f, src[1] / 255.f, src[2] / 255.f };
-        }
-        for (int y = 0; y < height; ++y) {
-            if (y + 1 < height)
-                for (int x = 0; x < width; ++x) {
-                    const uint8_t *src = rgb + (size_t(y + 1) * size_t(width) + size_t(x)) * 3;
-                    next[size_t(x)]    = { src[0] / 255.f, src[1] / 255.f, src[2] / 255.f };
-                }
-            const bool ltr = (y % 2) == 0;
-            for (int i = 0; i < width; ++i) {
-                const int    x  = ltr ? i : width - 1 - i;
-                const size_t px = size_t(y) * size_t(width) + size_t(x);
-                float        err = 0.f;
-                const int    choice = pick(row[size_t(x)][0], row[size_t(x)][1], row[size_t(x)][2], err);
-                write(px, choice, err);
-
-                std::array<float, 3> residual{};
-                for (int c = 0; c < 3; ++c)
-                    residual[size_t(c)] = row[size_t(x)][size_t(c)] - choice_rgb[size_t(choice)][size_t(c)] / 255.f;
-
-                const int  ahead = ltr ? x + 1 : x - 1;
-                const int  back  = ltr ? x - 1 : x + 1;
-                auto spread = [&](std::vector<std::array<float, 3>> &dst, int at, float w) {
-                    if (at < 0 || at >= width)
-                        return;
-                    for (int c = 0; c < 3; ++c)
-                        dst[size_t(at)][size_t(c)] += residual[size_t(c)] * w;
-                };
-                spread(row, ahead, 7.f / 16.f);
-                if (y + 1 < height) {
-                    spread(next, back, 3.f / 16.f);
-                    spread(next, x, 5.f / 16.f);
-                    spread(next, ahead, 1.f / 16.f);
-                }
-            }
-            row.swap(next);
-        }
-    } else {
-        tbb::parallel_for(tbb::blocked_range<int>(0, height), [&](const tbb::blocked_range<int> &range) {
-            for (int y = range.begin(); y < range.end(); ++y)
-                for (int x = 0; x < width; ++x) {
-                    const size_t   px  = size_t(y) * size_t(width) + size_t(x);
-                    const uint8_t *src = rgb + px * 3;
-                    float          err = 0.f;
-                    write(px, pick(src[0] / 255.f, src[1] / 255.f, src[2] / 255.f, err), err);
-                }
-        });
-    }
-
-    solve.mean_delta_e = count == 0 ? 0. : std::accumulate(errors.begin(), errors.end(), 0.) / double(count);
-    solve.max_delta_e  = errors.empty() ? 0. : double(*std::max_element(errors.begin(), errors.end()));
-    return solve;
-}
-
-float chroma_layers_to_opaque(float td_mm, float layer_height_mm)
-{
-    if (layer_height_mm <= 0.f)
-        return 0.f;
-    return CHROMA_TD_OPAQUE_FRACTION * std::clamp(td_mm, TD_MIN_MM, TD_MAX_MM) / layer_height_mm;
-}
-
-// Below about one dE two colours are the same colour to the eye. Half of that is the threshold for
-// "this layer changed something", so a step has to be comfortably invisible before a layer is called
-// wasted.
-static constexpr float VISIBLE_DE = 0.5f;
-
-static float step_delta_e(const ColorRGB &a, const ColorRGB &b)
-{
-    return delta_e(srgb_to_lab(a.r(), a.g(), a.b()), srgb_to_lab(b.r(), b.g(), b.b()));
-}
-
-int chroma_distinct_levels(const ChromaStack &stack)
-{
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    const int                   base    = std::max(0, stack.base_layers);
-    if (int(palette.size()) <= base + 1)
-        return 0;
-    int n = 0;
-    for (size_t i = size_t(base) + 1; i < palette.size(); ++i)
-        if (step_delta_e(palette[i - 1], palette[i]) > VISIBLE_DE)
-            ++n;
-    return n;
-}
-
-void chroma_trim_bands(ChromaStack &stack)
-{
-    // Walked over the stack's own palette rather than over the filaments' TD, because how fast a band
-    // runs out of anything to say depends on what is under it as much as on the filament. A light band
-    // over a dark one is finished in four or five layers; a dark one over a light one goes on paying
-    // for many more, long past the depth at which it is nominally opaque, because the last few percent
-    // of light coming through still moves a near-black colour perceptibly.
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    if (palette.empty())
-        return;
-    int layer = std::max(0, stack.base_layers); // palette index of the layer under the band being looked at
-    for (ChromaBand &band : stack.bands) {
-        int keep = 1;
-        for (int i = 1; i <= band.layers; ++i) {
-            const size_t cur = size_t(layer) + size_t(i);
-            if (cur >= palette.size())
-                break;
-            if (step_delta_e(palette[cur - 1], palette[cur]) > VISIBLE_DE)
-                keep = i; // the last layer of this band that still changes the colour
-        }
-        layer += band.layers;
-        band.layers = std::clamp(keep, 1, band.layers);
-    }
-}
-
-int chroma_level_at(const ChromaStack &stack, double z_mm)
-{
-    const int total = stack.total_layers();
-    if (total <= 0 || stack.layer_height_mm <= 0.f)
-        return 0;
-    // Layer k occupies ((k-1)h, k h], so a point inside it rounds up. The epsilon keeps a surface
-    // sitting exactly on a layer boundary in the layer that printed it rather than in the one above,
-    // which is the difference between a terrace showing its own colour and showing the next band's.
-    const int k = int(std::ceil(z_mm / double(stack.layer_height_mm) - 1e-6));
-    return std::clamp(k, 1, total);
-}
-
-std::vector<unsigned char> chroma_encode_height_png(const ChromaSolve &solve)
-{
-    if (solve.empty())
-        return {};
-    size_t      size = 0;
-    void       *png  = tdefl_write_image_to_png_file_in_memory_ex(solve.grey.data(), solve.width, solve.height, 1, &size,
-                                                                  MZ_DEFAULT_LEVEL, MZ_FALSE);
-    if (png == nullptr || size == 0)
-        return {};
-    const unsigned char       *bytes = static_cast<const unsigned char *>(png);
-    std::vector<unsigned char> out(bytes, bytes + size);
-    mz_free(png);
-    return out;
-}
-
-std::vector<ChromaRange> chroma_ranges(const ChromaStack &stack, double z_bottom)
-{
-    std::vector<ChromaRange> out;
-    if (stack.layer_height_mm <= 0.f)
-        return out;
-    // The layer height is stored as a float, like every other dimension of a texture displacement
-    // layer, so multiplying it up leaves noise in the last few digits - 5 layers of 0.1 mm come out as
-    // 0.5000000074. The slicer derives its own layer boundaries from the print config in double
-    // precision and lands on 0.5 exactly, and a boundary that misses it by any amount is a boundary a
-    // layer can fall on the wrong side of. Rounding to the nanometre removes the noise without
-    // disturbing any layer height a profile can express.
-    const auto snap = [](double z) { return std::round(z * 1e6) / 1e6; };
-
-    // The base is printed in the bottom band's filament - it is what is loaded when the print starts -
-    // so it extends that band's range down to the first layer instead of being a swap of its own.
-    int  layer = std::max(0, stack.base_layers);
-    bool first = true;
-    for (const ChromaBand &band : stack.bands) {
-        if (band.layers <= 0)
-            continue;
-        const double z_min = snap(z_bottom + (first ? 0. : double(layer) * double(stack.layer_height_mm)));
-        first = false;
-        layer += band.layers;
-        const double z_max = snap(z_bottom + double(layer) * double(stack.layer_height_mm));
-        if (!out.empty() && out.back().filament == band.filament.filament)
-            out.back().z_max = z_max; // no swap happens here, so it is one range
-        else
-            out.push_back(ChromaRange{ z_min, z_max, band.filament.filament });
-    }
-    return out;
-}
-
-ChromaStack chroma_default_stack(const std::vector<ChromaFilament> &filaments, float layer_height_mm,
-                                     int base_layers, int relief_layers)
-{
-    ChromaStack stack;
-    stack.layer_height_mm = layer_height_mm > 0.f ? layer_height_mm : 0.08f;
-    stack.base_layers     = std::max(0, base_layers);
-    if (filaments.empty() || relief_layers <= 0)
-        return stack;
-
-    std::vector<ChromaFilament> ordered = filaments;
-    std::stable_sort(ordered.begin(), ordered.end(), [](const ChromaFilament &a, const ChromaFilament &b) {
-        // Relative luminance of the linear colour: the perceptual order, so a saturated yellow
-        // counts as light and a saturated blue as dark, which a plain r+g+b sum gets wrong.
-        auto lum = [](const ColorRGB &c) {
-            return 0.2126f * srgb_to_linear(c.r()) + 0.7152f * srgb_to_linear(c.g()) + 0.0722f * srgb_to_linear(c.b());
-        };
-        return lum(a.color) > lum(b.color);
-    });
-
-    const int count = int(ordered.size());
-    int       left  = relief_layers;
-    for (int i = 0; i < count; ++i) {
-        // Spread the remainder over the first bands rather than piling it onto the last one.
-        const int share = left / (count - i) + ((left % (count - i)) > 0 ? 1 : 0);
-        ChromaBand band;
-        band.filament = ordered[size_t(i)];
-        band.layers   = std::max(1, share);
-        left -= share;
-        stack.bands.push_back(band);
-    }
-    return stack;
-}
-
-} // namespace Slic3r

src/libslic3r/ChromaStack.hpp

@@ -1,286 +0,0 @@
-#ifndef slic3r_ChromaStack_hpp_
-#define slic3r_ChromaStack_hpp_
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include <cereal/cereal.hpp>
-#include <cereal/types/vector.hpp>
-
-#include "Color.hpp"
-
-namespace Slic3r {
-
-// ChromaStack-style colour printing: a picture is reproduced on a single face by stacking thin layers
-// of a few filaments, swapping filament at fixed layer boundaries, and varying the *height* of each
-// pixel's column. Where the column is low, the layers above it are missing and the filament below
-// shows; where it is high, the topmost filament covers everything beneath it. Because filament is
-// translucent, a column that stops part-way through a run shows a blend of that run's filament and
-// what is under it, which is what gives far more colours than there are filaments loaded.
-//
-// So there are only two things to compute, and they are both here:
-//  - the *palette*: the colour the stack shows at every possible column height (chroma_palette());
-//  - the *height map*: per pixel, the column height whose palette colour is closest to the picture
-//    (chroma_solve()).
-//
-// Everything else is machinery that already exists. The height map is handed to a texture
-// displacement layer as its height texture, so the existing projection/preview/bake pipeline turns
-// it into real geometry (see TextureDisplacement.hpp), and the filament swaps are handed to the
-// object's height ranges (ModelObject::layer_config_ranges), which is the slicer's own way of
-// saying "print this Z band with that filament".
-
-// The depth of filament that blocks essentially all the light behind it, as a fraction of the
-// filament's transmission distance (TD).
-//
-// TD's scale is empirical, not physical: its values run from about 1
-// for an opaque filament to 10 and above for a nearly clear one, and the community's calibration
-// prints (the "seashell" step test) read a TD off the step where the colour beneath stops showing.
-// That step is about a tenth of the TD number, which is the only thing this constant encodes - a
-// filament of TD 2 stops hiding what is under it at roughly 0.2 mm, i.e. after two or three layers,
-// while one of TD 8 needs most of a millimetre. The model below turns that into a per-layer
-// transmittance; see chroma_palette().
-static constexpr float CHROMA_TD_OPAQUE_FRACTION = 0.1f;
-
-// What a fresh stack gets above the base. Twenty-four layers is about two millimetres at a fine layer
-// height: enough steps for a continuous tonal ramp, and still a print that finishes in an evening.
-static constexpr int CHROMA_DEFAULT_RELIEF_LAYERS = 24;
-
-// The most picture layers the solve can express. A column's height above the base is stored as one
-// byte per pixel in the 8-bit grayscale height map the displacement reads, so beyond this two
-// different heights would have to share a grey level and the relief's steps would stop landing on
-// layer boundaries - which is the one thing the quantization exists to guarantee.
-//
-// It bounds the bands, not the stack: the base is whatever the model already is under the painted
-// face, often hundreds of layers on a tall part, and nothing about it is quantized into the height
-// map. As a limit on the picture it is not one in practice - 255 layers is 20 mm of relief at
-// 0.08 mm, far past where a picture gains anything.
-static constexpr int CHROMA_MAX_RELIEF_LAYERS = 255;
-
-// The most filament changes one stack may hold. Every band is a swap the printer has to make, so this is
-// a limit on patience rather than on the model; the palette itself is bounded by the layer count.
-static constexpr size_t CHROMA_MAX_BANDS = 16;
-
-// One filament as the colour model sees it: what colour it is, and how far light gets into it.
-struct ChromaFilament
-{
-    // 0-based index into the project's filaments, which is what a height range's `extruder` option
-    // (1-based) is written from. -1 for a filament that is not loaded, which the GUI refuses to
-    // solve with rather than silently printing in the wrong colour.
-    int      filament = -1;
-    ColorRGB color;
-    // The filament preset's own name, so the panel can say which filament this is. Six similar greys
-    // are six identical swatches and six identical numbers otherwise. Stored rather than looked up on
-    // demand because a stack outlives the project's filament list - a preset can be swapped out from
-    // under a saved stack, and then the name is the only record of what it was solved against.
-    std::string name;
-    // Transmission distance, mm, as the filament preset reports it
-    // (`filament_transmission_distance`). Clamped to a sane range when the palette is built: zero
-    // would make a layer infinitely opaque and a negative value is meaningless.
-    float    td_mm = 4.f;
-
-    template<class Archive> void serialize(Archive &ar)
-    {
-        float r = color.r(), g = color.g(), b = color.b();
-        ar(filament, r, g, b, td_mm, name);
-        color = ColorRGB(r, g, b);
-    }
-};
-
-// A run of consecutive layers printed in one filament. The stack is a list of these, bottom-up, so
-// a band boundary is exactly where the print pauses and the filament is changed.
-struct ChromaBand
-{
-    ChromaFilament filament;
-    int              layers = 1;
-
-    template<class Archive> void serialize(Archive &ar) { ar(filament, layers); }
-};
-
-// The whole recipe: which filaments, in which order, how thick a layer is, and how much of the
-// bottom is solid backing rather than picture.
-struct ChromaStack
-{
-    std::vector<ChromaBand> bands; // bottom-up; bands.front() is the one the base is printed in
-
-    // The print's layer height, mm. Taken from the print profile rather than chosen here - a stack
-    // solved against 0.08 mm layers prints as the wrong picture at 0.2 mm, so the GUI re-solves when
-    // the profile's layer height changes.
-    float layer_height_mm = 0.08f;
-
-    // Layers of solid backing under the picture: everything the model already is below the painted
-    // face. Not part of any band - the bands are the picture - but printed in the bottom band's
-    // filament, since that is what is loaded when the print starts.
-    //
-    // Keeping it out of the bands is what lets it be what it really is: a measurement of the model,
-    // often a hundred layers or more, while a band is a handful. Folding the two together put a
-    // three-digit number on a slider meant for single digits and made "how thick is the backing" and
-    // "how many layers does the first filament get" the same control, which they are not.
-    //
-    // The colour model treats the base as opaque. That is what makes a column's colour depend only on
-    // the layers above it, and why the panel warns about a base thin enough to let the plate show
-    // through.
-    int  base_layers = 4;
-
-    // Whether `base_layers` follows the model or was typed in. It follows by default, and it should:
-    // the painted face is wherever the geometry puts it, and a base that disagrees with it shifts
-    // every colour in the picture - the stack ends up anchored at the bottom of the part instead of
-    // under the face, so the picture's whole range is squeezed into the first few millimetres and
-    // everything above it clamps to the top band.
-    //
-    // It cannot be measured once and left: a layer is created, and its picture chosen, before there
-    // is any paint to measure, and the face moves again whenever the part is scaled or the layer
-    // height changes. So the panel re-measures it every frame while this is set.
-    bool base_auto = true;
-
-    // Spread the quantization error into neighbouring pixels (Floyd-Steinberg, serpentine) instead
-    // of rounding each pixel to its nearest palette colour on its own. A palette of twenty or thirty
-    // colours has to cover a photograph's whole range, so plain rounding leaves visible bands across
-    // a sky or a cheek; diffusing the error trades them for fine stipple, which at a tenth of a
-    // millimetre per pixel reads as the intermediate colour. Off for flat-coloured artwork, where
-    // stipple is the artifact rather than the cure.
-    bool dither = false;
-
-    // Total printed layers, base included: what the tallest column is.
-    int  total_layers() const;
-    // Layers the picture is built from, i.e. the bands' own total above the base.
-    int  relief_layers() const;
-    // The relief's height in mm, which is the `depth_mm` of the texture displacement layer the
-    // height map is handed to.
-    float depth_mm() const;
-    bool  empty() const { return bands.empty(); }
-
-    template<class Archive> void serialize(Archive &ar) { ar(bands, layer_height_mm, base_layers, dither, base_auto); }
-};
-
-// The colour the stack shows at every column height: entry k is a column of exactly k printed
-// layers, so the vector has total_layers() + 1 entries.
-//
-// The model is Beer-Lambert absorption, layer by layer. A layer of thickness h in a filament of
-// transmission distance TD passes
-//
-//     T = exp(-h / (CHROMA_TD_OPAQUE_FRACTION * TD / 3))
-//
-// of the light coming from under it and shows its own colour with the rest, so
-//
-//     C_k = (1 - T_k) * c_k + T_k * C_(k-1)
-//
-// walking up from an opaque base, C_0 = c_1. The divisor is what makes "opaque at
-// CHROMA_TD_OPAQUE_FRACTION * TD" true: three e-folding lengths pass 5% of the light, which is
-// where the colour beneath stops being visible to the eye.
-//
-// Beer-Lambert is not just the physically honest choice here, it is the only one that stays
-// consistent when applied per layer: transmittance multiplies, so a run of n layers of one filament
-// passes exp(-n h / d) whether it is composited in one step or n, and the palette does not depend on
-// how the stack happens to be cut into bands.
-//
-// Compositing is done on linear light and the entries are converted back to sRGB, because the
-// quantity being attenuated is light, not an sRGB code.
-std::vector<ColorRGB> chroma_palette(const ChromaStack &stack);
-
-// What chroma_solve() produced.
-struct ChromaSolve
-{
-    int width  = 0;
-    int height = 0;
-
-    // Per pixel, row-major and top-to-bottom like DecodedHeightTexture: the column's printed layer
-    // count, between base_layers and total_layers(). Sixteen bits because it counts from the build
-    // plate, and the base alone can be several hundred layers on a tall part.
-    std::vector<uint16_t> levels;
-    // The same thing as the 8-bit grayscale height map the displacement samples: 0 at base_layers,
-    // 255 at total_layers(). This is what gets encoded as a PNG into the layer's `image_data`, which
-    // is why the solve has to be the thing that owns the quantization - the relief's steps have to
-    // land on layer boundaries, and a grey level is the only channel the displacement reads.
-    std::vector<uint8_t> grey;
-    // Per pixel RGB: the palette colour the solve chose, i.e. what the print is predicted to look
-    // like. Shown in the panel next to the source picture, since the 3D view can only show the
-    // relief - the colours do not exist until the print swaps filament.
-    std::vector<uint8_t> preview;
-
-    // How far the prediction landed from the picture, as a mean and worst-case CIE76 dE over all
-    // pixels. The panel reports it because it is the only honest answer to "will this stack
-    // reproduce my image": under about 5 is a good match, over about 15 means the filaments cannot
-    // reach the picture's colours and no amount of layers will fix it.
-    double mean_delta_e = 0.;
-    double max_delta_e  = 0.;
-
-    bool empty() const { return width <= 0 || height <= 0 || levels.empty(); }
-};
-
-// Solves `rgb` (width * height * 3 bytes, row-major, top-to-bottom) against the stack's palette.
-// An empty stack, a zero-sized image or a stack with no relief layers gives an empty result.
-ChromaSolve chroma_solve(const uint8_t *rgb, int width, int height, const ChromaStack &stack);
-
-// How many layers of this filament it takes to hide what is under it, at this layer height. The
-// single most useful number about a stack and the one nothing else makes visible: it is what decides
-// whether a band is a gradient or a step.
-//
-// A filament hides what is behind it at about CHROMA_TD_OPAQUE_FRACTION of its TD (see
-// chroma_palette()), so this is that depth in layers. Below two the band has no intermediate colours
-// at all - the picture can only use the filament or not use it - which is what a coarse layer height
-// does to an otherwise good stack: TD 4 at 0.2 mm covers in two layers, the same filament at 0.08 mm
-// in five.
-float chroma_layers_to_opaque(float td_mm, float layer_height_mm);
-
-// How many of the picture's layers actually change the colour.
-//
-// A band eventually stops saying anything: once it hides what is under it, another layer of it shows
-// the colour the one below already showed. Those layers still cost print time and still take up
-// relief height, and nothing about the stack makes them visible - the band looks like ten layers of
-// gradient and is, say, five of gradient and five of flat.
-//
-// Measured against the palette rather than against TD, because how long a band keeps paying depends
-// on what is under it as much as on the filament: a light band over a dark one is finished in four or
-// five layers, while a dark one over a light one goes on moving the colour perceptibly well past the
-// depth at which it is nominally opaque.
-int chroma_distinct_levels(const ChromaStack &stack);
-
-// Shortens every band to its last layer that still changes the colour. Bands already shorter than
-// that are left alone: they are still inside their fade, where every layer counts.
-void chroma_trim_bands(ChromaStack &stack);
-
-// The printed layer a point `z_mm` above the bottom of the object falls in: 1-based, clamped to the
-// stack, 0 for a stack that prints nothing. Pair it with chroma_palette() to get the colour shown
-// there.
-//
-// This, rather than the height map, is what decides the colour a surface shows. A filament swap
-// happens at one print Z across the whole plate, so every surface crossing that height changes colour
-// whatever the picture says - the terraces of the relief, the walls between them, and the sides of the
-// model alike. Colouring a preview this way is therefore not an approximation of the print; it is what
-// the print does, and it keeps working after the relief has been baked into the mesh and the height
-// map is no longer attached to anything on screen.
-int chroma_level_at(const ChromaStack &stack, double z_mm);
-
-// The solve's height map as an 8-bit grayscale PNG, ready to be stored in a
-// TextureDisplacementLayer's `image_data`.
-std::vector<unsigned char> chroma_encode_height_png(const ChromaSolve &solve);
-
-// One filament swap as an object height range: the Z band, in the object's own coordinates (0 at its
-// bottom), that prints in `filament` (0-based).
-struct ChromaRange
-{
-    double z_min = 0.;
-    double z_max = 0.;
-    int    filament = -1;
-};
-
-// The stack's bands as height ranges, in object coordinates, starting at `z_bottom` (which is 0 for
-// a stack whose base starts at the object's first layer). Bands printed in the same filament as the
-// band below are merged, so a stack that repeats a filament does not produce a pointless swap.
-std::vector<ChromaRange> chroma_ranges(const ChromaStack &stack, double z_bottom = 0.);
-
-// A starting point for a stack: the given filaments, lightest at the bottom, each with an equal
-// share of `relief_layers` on top of `base_layers`.
-//
-// Light-to-dark is the convention filament-painting guides teach, and it is not arbitrary: a dark
-// filament over a light one reads as a midtone at one or two layers and as the dark colour at four,
-// so putting the dark filaments last is what buys the long tonal ramp. The reverse order gives a few
-// washed-out steps and then nothing.
-ChromaStack chroma_default_stack(const std::vector<ChromaFilament> &filaments, float layer_height_mm,
-                                     int base_layers, int relief_layers);
-
-} // namespace Slic3r
-
-#endif // slic3r_ChromaStack_hpp_

src/libslic3r/Format/STEP.cpp

@@ -236,19 +236,29 @@ static void getNamedSolids(const TopLoc_Location& location,
         int                      i = 0;
         switch (shape_type) {
         case TopAbs_COMPOUND:
-            if (!isSplitCompound) {
-                namedSolids.emplace_back(TopoDS::Compound(transform.Shape()), fullName);
-                break;
-            }
         case TopAbs_COMPSOLID:
             if (!isSplitCompound) {
-                namedSolids.emplace_back(TopoDS::CompSolid(transform.Shape()), fullName);
+                namedSolids.emplace_back(transform.Shape(), fullName);
             } else {
                 for (explorer.Init(transform.Shape(), TopAbs_SOLID); explorer.More(); explorer.Next()) {
                     i++;
                     const TopoDS_Shape& currentShape = explorer.Current();
                     namedSolids.emplace_back(TopoDS::Solid(currentShape), fullName + "-SOLID-" + std::to_string(i));
                 }
+                // Surface models have no solids: each shell outside a solid is a part, and loose faces stay together.
+                i = 0;
+                for (explorer.Init(transform.Shape(), TopAbs_SHELL, TopAbs_SOLID); explorer.More(); explorer.Next())
+                    namedSolids.emplace_back(explorer.Current(), fullName + "-SHELL-" + std::to_string(++i));
+                TopoDS_Compound loose_faces;
+                TopoDS_Builder  builder;
+                builder.MakeCompound(loose_faces);
+                bool has_loose_faces = false;
+                for (explorer.Init(transform.Shape(), TopAbs_FACE, TopAbs_SHELL); explorer.More(); explorer.Next()) {
+                    builder.Add(loose_faces, explorer.Current());
+                    has_loose_faces = true;
+                }
+                if (has_loose_faces)
+                    namedSolids.emplace_back(loose_faces, fullName);
             }
             break;
         case TopAbs_SOLID:

src/libslic3r/Format/bbs_3mf.cpp

@@ -22,6 +22,7 @@
 #include "libslic3r/BrimEarsPoint.hpp"
 #include "libslic3r/Config.hpp"
 #include "libslic3r/CustomGCode.hpp"
+#include "libslic3r/TextureDisplacement.hpp"
 #include "libslic3r_version.h"
 
 #include "bbs_3mf.hpp"
@@ -354,6 +355,13 @@ static constexpr const char* CUSTOM_SUPPORTS_ATTR = "paint_supports";
 static constexpr const char* CUSTOM_FUZZY_SKIN_ATTR  = "paint_fuzzy_skin";
 static constexpr const char* CUSTOM_SEAM_ATTR = "paint_seam";
 static constexpr const char* MMU_SEGMENTATION_ATTR = "paint_color";
+// Texture displacement. One paint mask per layer slot, mirroring paint_color; the layer stack itself is
+// a JSON file in the archive, named by the volume metadata key below (see add_texture_displacement()).
+static constexpr const char* TEXTURE_DISPLACEMENT_ATTRS[Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS] = {
+    "paint_texture_0", "paint_texture_1", "paint_texture_2", "paint_texture_3",
+    "paint_texture_4", "paint_texture_5", "paint_texture_6", "paint_texture_7" };
+static constexpr const char* TEXTURE_DISPLACEMENT_KEY = "texture_displacement";
+static constexpr const char* TEXTURE_DISPLACEMENT_DIR = "Metadata/texture_displacement/";
 // BBS
 static constexpr const char* FACE_PROPERTY_ATTR = "face_property";
 
@@ -847,6 +855,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             std::vector<std::string> custom_seam;
             std::vector<std::string> mmu_segmentation;
             std::vector<std::string> fuzzy_skin;
+            // One per texture displacement layer slot, indexed like `triangles` but stored only as far as the
+            // slot's last painted triangle: empty when the slot has no paint, which is nearly every file.
+            std::vector<std::string> texture_displacement[TEXTURE_DISPLACEMENT_MAX_LAYERS];
             // BBS
             std::vector<std::string> face_properties;
 
@@ -867,6 +878,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 custom_seam.clear();
                 mmu_segmentation.clear();
                 fuzzy_skin.clear();
+                for (std::vector<std::string> &slot : texture_displacement)
+                    slot.clear();
             }
         };
 
@@ -1200,6 +1213,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         /*IdToSlaSupportPointsMap m_sla_support_points;
         IdToSlaDrainHolesMap    m_sla_drain_holes;*/
         PathToEmbossShapeFileMap m_path_to_emboss_shape_files;
+        // Texture displacement: every file under Metadata/texture_displacement/, by archive path. Volumes
+        // are built only after the whole archive has been walked, so by the time a volume names its JSON
+        // every file it could refer to is already in here, whatever order the archive happened to be in.
+        std::map<std::string, std::string> m_texture_displacement_files;
+        void _apply_texture_displacement(ModelVolume &volume, const std::string &json_path);
         std::string m_curr_metadata_name;
         std::string m_curr_characters;
         std::string m_name;
@@ -2073,6 +2091,13 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 else if (_is_svg_shape_file(name)) {
                     _extract_embossed_svg_shape_file(name, archive, stat);
                 }
+                else if (boost::algorithm::istarts_with(name, TEXTURE_DISPLACEMENT_DIR)) {
+                    std::string contents(stat.m_uncomp_size, '\0');
+                    if (mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, contents.data(), stat.m_uncomp_size, 0))
+                        m_texture_displacement_files.emplace(name, std::move(contents));
+                    else
+                        add_error("Error while reading texture displacement data");
+                }
                 else if (!dont_load_config && boost::algorithm::iequals(name, SLICE_INFO_CONFIG_FILE)) {
                     m_parsing_slice_info = true;
                     //extract slice info from archive
@@ -3310,6 +3335,45 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         }
     }*/
 
+    // Restores one volume's texture displacement stack from the JSON it named. Called while the volume is
+    // being built, which is after the whole archive has been walked - so every file it can refer to is
+    // already extracted, and no deferral is needed.
+    //
+    // A missing or malformed JSON leaves the volume with no layers but keeps the paint mask it already
+    // loaded, which is the same state as a project saved by a build without the feature: recoverable by
+    // picking the texture again rather than a hard failure.
+    void _BBS_3MF_Importer::_apply_texture_displacement(ModelVolume &volume, const std::string &json_path)
+    {
+        const auto json = m_texture_displacement_files.find(json_path);
+        if (json == m_texture_displacement_files.end()) {
+            add_error("Missing texture displacement data: " + json_path);
+            return;
+        }
+        std::vector<TextureDisplacementLayer> layers;
+        TextureDisplacementOptions            options;
+        if (!texture_displacement_layers_from_json(json->second, layers, options)) {
+            add_error("Malformed texture displacement data: " + json_path);
+            return;
+        }
+        // The archive is the only source of a layer's pixels. `path` comes from the project file, so loading
+        // the project must never read the file it names: that would let whoever made the project pick any
+        // local (or, on Windows, network) file to read, and the next save would embed it in the archive.
+        // `path` stays a label of where the texture came from; a layer the archive carries no image for
+        // loads without one, its settings intact, until the user picks a texture again.
+        for (TextureDisplacementLayer &layer : layers) {
+            if (layer.path_in_3mf.empty())
+                continue;
+            const auto image = m_texture_displacement_files.find(layer.path_in_3mf);
+            if (image == m_texture_displacement_files.end()) {
+                add_error("Missing texture displacement image: " + layer.path_in_3mf);
+                continue;
+            }
+            layer.image_data = std::make_shared<std::vector<unsigned char>>(image->second.begin(), image->second.end());
+        }
+        volume.texture_displacement_layers  = std::move(layers);
+        volume.texture_displacement_options = options;
+    }
+
     void _BBS_3MF_Importer::_extract_embossed_svg_shape_file(const std::string &filename, mz_zip_archive &archive, const mz_zip_archive_file_stat &stat){
         assert(m_path_to_emboss_shape_files.find(filename) == m_path_to_emboss_shape_files.end());
         auto file = std::make_unique<std::string>(stat.m_uncomp_size, '\0');
@@ -3966,6 +4030,12 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             m_curr_object->geometry.custom_seam.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_SEAM_ATTR));
             m_curr_object->geometry.mmu_segmentation.push_back(bbs_get_attribute_value_string(attributes, num_attributes, MMU_SEGMENTATION_ATTR));
             m_curr_object->geometry.fuzzy_skin.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_FUZZY_SKIN_ATTR));
+            for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
+                if (const char *paint = bbs_get_attribute_value_charptr(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot])) {
+                    std::vector<std::string> &mask = m_curr_object->geometry.texture_displacement[slot];
+                    mask.resize(m_curr_object->geometry.triangles.size());
+                    mask.back() = paint;
+                }
             // BBS
             m_curr_object->geometry.face_properties.push_back(bbs_get_attribute_value_string(attributes, num_attributes, FACE_PROPERTY_ATTR));
         }
@@ -5317,6 +5387,18 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 volume->mmu_segmentation_facets.touch();
                 volume->fuzzy_skin_facets.shrink_to_fit();
                 volume->fuzzy_skin_facets.touch();
+                for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
+                    const std::vector<std::string> &mask = sub_object->geometry.texture_displacement[slot];
+                    if (mask.empty())
+                        continue; // no triangle painted on this slot
+                    FacetsAnnotation &facets = volume->texture_displacement_facet(slot);
+                    facets.reserve(triangles_count);
+                    for (size_t i = 0; i < triangles_count && i < mask.size(); ++i)
+                        if (!mask[i].empty())
+                            facets.set_triangle_from_string(i, mask[i]);
+                    facets.shrink_to_fit();
+                    facets.touch();
+                }
             }
 
             volume->set_type(volume_data->part_type);
@@ -5332,6 +5414,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             for (const Metadata& metadata : volume_data->metadata) {
                 if (metadata.key == NAME_KEY)
                     volume->name = metadata.value;
+                else if (metadata.key == TEXTURE_DISPLACEMENT_KEY)
+                    _apply_texture_displacement(*volume, metadata.value);
                 //else if ((metadata.key == MODIFIER_KEY) && (metadata.value == "1"))
 				//	volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
 				//for old format
@@ -5496,12 +5580,28 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             volume->seam_facets.shrink_to_fit();
             volume->mmu_segmentation_facets.shrink_to_fit();
 
+            for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
+                const std::vector<std::string> &mask = geometry.texture_displacement[slot];
+                if (mask.empty())
+                    continue; // written by a build without the feature
+                FacetsAnnotation &facets = volume->texture_displacement_facet(slot);
+                facets.reserve(triangles_count);
+                for (size_t i = 0; i < triangles_count; ++i) {
+                    const size_t index = volume_data.first_triangle_id + i;
+                    if (index < mask.size() && !mask[index].empty())
+                        facets.set_triangle_from_string(i, mask[index]);
+                }
+                facets.shrink_to_fit();
+                facets.touch();
+            }
             volume->set_type(volume_data.part_type);
 
             // apply the remaining volume's metadata
             for (const Metadata& metadata : volume_data.metadata) {
                 if (metadata.key == NAME_KEY)
                     volume->name = metadata.value;
+                else if (metadata.key == TEXTURE_DISPLACEMENT_KEY)
+                    _apply_texture_displacement(*volume, metadata.value);
                 //else if ((metadata.key == MODIFIER_KEY) && (metadata.value == "1"))
 				//	volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
 				//for old format
@@ -5805,6 +5905,12 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             current_object->geometry.custom_seam.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_SEAM_ATTR));
             current_object->geometry.mmu_segmentation.push_back(bbs_get_attribute_value_string(attributes, num_attributes, MMU_SEGMENTATION_ATTR));
             current_object->geometry.fuzzy_skin.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_FUZZY_SKIN_ATTR));
+            for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
+                if (const char *paint = bbs_get_attribute_value_charptr(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot])) {
+                    std::vector<std::string> &mask = current_object->geometry.texture_displacement[slot];
+                    mask.resize(current_object->geometry.triangles.size());
+                    mask.back() = paint;
+                }
             // BBS
             current_object->geometry.face_properties.push_back(bbs_get_attribute_value_string(attributes, num_attributes, FACE_PROPERTY_ATTR));
         }
@@ -6808,6 +6914,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         stream << " <Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>\n";
         stream << " <Default Extension=\"model\" ContentType=\"application/vnd.ms-package.3dmanufacturing-3dmodel+xml\"/>\n";
         stream << " <Default Extension=\"png\" ContentType=\"image/png\"/>\n";
+        stream << " <Default Extension=\"jpg\" ContentType=\"image/jpeg\"/>\n";
+        stream << " <Default Extension=\"jpeg\" ContentType=\"image/jpeg\"/>\n";
+        stream << " <Default Extension=\"json\" ContentType=\"application/json\"/>\n";
         stream << " <Default Extension=\"gcode\" ContentType=\"text/x.gcode\"/>\n";
         stream << "</Types>";
 
@@ -7232,10 +7341,14 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                             if (iter != m_shared_meshes.end())
                             {
                                 const ModelVolume* shared_volume = iter->second.second;
+                                bool same_texture_paint = true;
+                                for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS) && same_texture_paint; ++slot)
+                                    same_texture_paint = shared_volume->texture_displacement_facet(slot).equals(volume->texture_displacement_facet(slot));
                                 if ((shared_volume->supported_facets.equals(volume->supported_facets))
                                     && (shared_volume->seam_facets.equals(volume->seam_facets))
                                     && (shared_volume->mmu_segmentation_facets.equals(volume->mmu_segmentation_facets))
-                                    && (shared_volume->fuzzy_skin_facets.equals(volume->fuzzy_skin_facets)))
+                                    && (shared_volume->fuzzy_skin_facets.equals(volume->fuzzy_skin_facets))
+                                    && same_texture_paint)
                                 {
                                     auto data = iter->second.first;
                                     const_cast<_BBS_3MF_Exporter *>(this)->m_volume_paths.insert({volume, {data->sub_path, data->volumes_objectID.find(iter->second.second)->second}});
@@ -7651,6 +7764,20 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                     output_buffer += "\"";
                 }
 
+                // One attribute per texture displacement layer slot. Older readers ignore attributes they do
+                // not know, so a project written here still opens in a build without the feature - it just
+                // loses the paint, which is also all it could have done with it.
+                for (int slot = 0; slot < TEXTURE_DISPLACEMENT_MAX_LAYERS; ++slot) {
+                    const std::string texture_paint = volume->texture_displacement_facet(slot).get_triangle_as_string(i);
+                    if (texture_paint.empty())
+                        continue;
+                    output_buffer += " ";
+                    output_buffer += TEXTURE_DISPLACEMENT_ATTRS[slot];
+                    output_buffer += "=\"";
+                    output_buffer += texture_paint;
+                    output_buffer += "\"";
+                }
+
                 // BBS
                 if (i < its.properties.size()) {
                     std::string prop_str = its.properties[i].to_string();
@@ -8100,7 +8227,42 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         return file_path;
     }
 
-    bool _BBS_3MF_Exporter::_add_model_config_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig& config, int export_plate_idx, bool save_gcode, bool use_loaded_id)
+    // Writes a volume's texture displacement stack into the archive and points the volume's metadata at it.
+// The layer settings go in as JSON and each layer's texture as the image file it was loaded from, both
+// referenced by path - the same split EmbossShape makes for its SVG. The image deliberately stays out of
+// the XML: it is binary and routinely megabytes, and base64 in an attribute would bloat the one file
+// every reader has to parse just to list the objects.
+static void add_texture_displacement(std::stringstream &stream, const ModelVolume &volume, mz_zip_archive &archive,
+                                     const std::string &id)
+{
+    if (volume.texture_displacement_layers.empty())
+        return;
+
+    // A copy, because path_in_3mf is only meaningful inside the archive being written and the volume
+    // being exported is const (and may be saved again, elsewhere, with different paths).
+    std::vector<TextureDisplacementLayer> layers = volume.texture_displacement_layers;
+    for (TextureDisplacementLayer &layer : layers) {
+        layer.path_in_3mf.clear();
+        if (!layer.image_data || layer.image_data->empty())
+            continue;
+        // Always .png: the importer converts whatever the user picked (jpg, bmp, ...) to an 8-bit
+        // greyscale PNG, so image_data is PNG whatever layer.path happens to be named.
+        const std::string path = std::string(TEXTURE_DISPLACEMENT_DIR) + id + "_" + std::to_string(layer.slot) + ".png";
+        // No deflate: a PNG is already compressed, so a second pass only costs time.
+        if (mz_zip_writer_add_mem(&archive, path.c_str(), layer.image_data->data(), layer.image_data->size(),
+                                  MZ_NO_COMPRESSION))
+            layer.path_in_3mf = path;
+    }
+
+    const std::string json      = texture_displacement_layers_to_json(layers, volume.texture_displacement_options);
+    const std::string json_path = std::string(TEXTURE_DISPLACEMENT_DIR) + id + ".json";
+    if (!mz_zip_writer_add_mem(&archive, json_path.c_str(), json.data(), json.size(), MZ_DEFAULT_COMPRESSION))
+        return;
+    stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << TEXTURE_DISPLACEMENT_KEY << "\" "
+           << VALUE_ATTR << "=\"" << xml_escape(json_path) << "\"/>\n";
+}
+
+bool _BBS_3MF_Exporter::_add_model_config_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig& config, int export_plate_idx, bool save_gcode, bool use_loaded_id)
     {
         std::stringstream stream;
         // Store mesh transformation in full precision, as the volumes are stored transformed and they need to be transformed back
@@ -8211,6 +8373,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                             if (const std::optional<EmbossShape> &es = volume->emboss_shape; es.has_value()) {
                                 to_xml(stream, *es, *volume, archive, m_fullpath_sources);
                             }
+
+                            add_texture_displacement(stream, *volume, archive, std::to_string(volume->id().id));
                     
                             if (const std::optional<TextConfiguration> &tc = volume->text_configuration;
                                 tc.has_value())

src/libslic3r/GCode.cpp

@@ -1033,6 +1033,15 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
         return buf;
     }
 
+    // FanMover consumes these markers (and drops them) to avoid splitting a G1 inside custom gcode.
+    // Only written when FanMover runs, the same gate as its construction in GCode::process_layers.
+    static std::string wrap_custom_gcode_for_fan_mover(const FullPrintConfig &config, const std::string &gcode)
+    {
+        if (config.fan_speedup_time.value == 0 && config.fan_kickstart.value <= 0)
+            return gcode;
+        return ";_FAN_MOVER_SKIP_START\n" + gcode + ";_FAN_MOVER_SKIP_END\n";
+    }
+
     std::string WipeTowerIntegration::append_tcr(GCode& gcodegen, const WipeTower::ToolChangeResult& tcr, int new_filament_id, double z) const
     {
         if (new_filament_id != -1 && new_filament_id != tcr.new_tool)
@@ -1384,6 +1393,9 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
             toolchange_gcode_str = gcodegen.placeholder_parser_process("change_filament_gcode", change_filament_gcode, new_filament_id, &config);
 
             check_add_eol(toolchange_gcode_str);
+            // Type1 wipe tower path (every BBL printer): bracket the same way set_extruder() does,
+            // so FanMover doesn't split a G1 inside this custom gcode either.
+            toolchange_gcode_str = wrap_custom_gcode_for_fan_mover(gcodegen.config(), toolchange_gcode_str);
 
             //BBS
             {
@@ -4250,7 +4262,7 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
             config.set_key_value("nozzle_diameter_at_nozzle_id", new ConfigOptionFloats(get_nozzle_diameters_by_nozzle_id(group_result.get())));
             config.set_key_value("nozzle_volume_types", new ConfigOptionStrings(get_nozzle_volume_types_by_nozzle_id(group_result.get())));
             config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
-            std::string filament_start_gcode = this->placeholder_parser_process("filament_start_gcode", print.config().filament_start_gcode.values.at(initial_non_support_extruder_id), initial_non_support_extruder_id,&config);
+            std::string filament_start_gcode = this->placeholder_parser_process("filament_start_gcode", print.config().filament_start_gcode.get_at(initial_non_support_extruder_id), initial_non_support_extruder_id,&config);
             file.writeln(filament_start_gcode);
             // Mark the first filament used in print. Multi-nozzle printers (H2C) get ";VT%d H%d" where
             // H = dynamic ? nozzle_id : -1; existing single-nozzle printers keep the bare ";VT%d" so their
@@ -10895,7 +10907,8 @@ std::string GCode::set_extruder(unsigned int new_filament_id, double print_z, bo
 
         toolchange_gcode_parsed = placeholder_parser_process("change_filament_gcode", change_filament_gcode, new_filament_id, &dyn_config);
         check_add_eol(toolchange_gcode_parsed);
-        gcode += toolchange_gcode_parsed;
+        // toolchange_gcode_parsed is still read below (get_last_z_from_gcode, custom_gcode_changes_tool).
+        gcode += wrap_custom_gcode_for_fan_mover(m_config, toolchange_gcode_parsed);
 
         //BBS
         {

src/libslic3r/GCode/FanMover.cpp

@@ -445,6 +445,11 @@ void FanMover::_process_gcode_line(GCodeReader& reader, const GCodeReader::GCode
                 std::string extrusion_string = line.raw().substr(6, line.raw().size() - 6);
                 current_role = ExtrusionEntity::string_to_role(extrusion_string);
             }
+            if (line.raw().rfind(";_FAN_MOVER_SKIP_", 0) == 0) {
+                // Internal markers: read here, then dropped from the output.
+                m_is_custom_gcode = line.raw().rfind(";_FAN_MOVER_SKIP_START", 0) == 0;
+                time = -1;
+            }
             if (line.raw().size() > 16) {
                 if (line.raw().rfind("; custom gcode", 0) != std::string::npos) {
                     if (line.raw().rfind("; custom gcode end", 0) != std::string::npos)

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -2602,12 +2602,13 @@ void GCodeProcessorResult::reset() {
     //BBS: add mutex for protection of gcode result
     lock();
 
-    moves.clear();
+    // moves and lines_ends grow with the print: free them, as no reset result reuses the capacity.
+    clear_and_shrink(moves);
     plate_mass = {};
     object_masses.clear();
     body_masses.clear();
     support_masses.clear();
-    lines_ends.clear();
+    clear_and_shrink(lines_ends);
     printable_area = Pointfs();
     //BBS: add bed exclude area
     bed_exclude_area = Pointfs();
@@ -3598,6 +3599,10 @@ void GCodeProcessor::apply_config(const DynamicPrintConfig& config)
     if (has_scarf_joint_seam != nullptr)
         m_detect_layer_based_on_tag = m_detect_layer_based_on_tag || has_scarf_joint_seam->value;
 
+    const ConfigOptionBool* manual_filament_change = config.option<ConfigOptionBool>("manual_filament_change");
+    if (manual_filament_change != nullptr)
+        m_manual_filament_change = manual_filament_change->value;
+
     const ConfigOptionEnumGeneric *bed_type = config.option<ConfigOptionEnumGeneric>("curr_bed_type");
     if (bed_type != nullptr)
         m_result.bed_type = (BedType)bed_type->value;

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -1228,7 +1228,7 @@ inline constexpr float DEFAULT_FILAMENT_DENSITY = 1.245f;
         // m_result.nozzle_group_result, which is handed over only after the stream for the
         // pre-heat injector's second pass and gates the richer change-time model.
         std::shared_ptr<MultiNozzleUtils::NozzleGroupResultBase> m_nozzle_group_result;
-        bool m_manual_filament_change;
+        bool m_manual_filament_change{ false };
 
         //BBS: x, y offset for gcode generated
         double          m_x_offset{ 0 };

src/libslic3r/JumpPointSearch.cpp

@@ -1,349 +0,0 @@
-#include "JumpPointSearch.hpp"
-#include "BoundingBox.hpp"
-#include "ExPolygon.hpp"
-#include "Point.hpp"
-#include "libslic3r/AStar.hpp"
-#include "libslic3r/KDTreeIndirect.hpp"
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/Polyline.hpp"
-#include "libslic3r/libslic3r.h"
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstdlib>
-#include <iterator>
-#include <limits>
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include <oneapi/tbb/scalable_allocator.h>
-
-//#define DEBUG_FILES
-#ifdef DEBUG_FILES
-#include "libslic3r/SVG.hpp"
-#endif
-
-namespace Slic3r {
-
-// execute fn for each pixel on the line. If fn returns false, terminate the iteration
-template<typename PointFn> void dda(coord_t x0, coord_t y0, coord_t x1, coord_t y1, const PointFn &fn)
-{
-    coord_t dx    = abs(x1 - x0);
-    coord_t dy    = abs(y1 - y0);
-    coord_t x     = x0;
-    coord_t y     = y0;
-    coord_t n     = 1 + dx + dy;
-    coord_t x_inc = (x1 > x0) ? 1 : -1;
-    coord_t y_inc = (y1 > y0) ? 1 : -1;
-    coord_t error = dx - dy;
-    dx *= 2;
-    dy *= 2;
-
-    for (; n > 0; --n) {
-        if (!fn(x, y)) return;
-
-        if (error > 0) {
-            x += x_inc;
-            error -= dy;
-        } else {
-            y += y_inc;
-            error += dx;
-        }
-    }
-}
-
-// will draw the line twice, second time with and offset of 1 in the direction of normal
-// may call the fn on the same coordiantes multiple times!
-template<typename PointFn> void double_dda_with_offset(coord_t x0, coord_t y0, coord_t x1, coord_t y1, const PointFn &fn)
-{
-    Vec2d normal       = Point{y1 - y0, x1 - x0}.cast<double>().normalized();
-    normal.x()         = ceil(normal.x());
-    normal.y()         = ceil(normal.y());
-    Point start_offset = Point(x0, y0) + (normal).cast<coord_t>();
-    Point end_offset   = Point(x1, y1) + (normal).cast<coord_t>();
-
-    dda(x0, y0, x1, y1, fn);
-    dda(start_offset.x(), start_offset.y(), end_offset.x(), end_offset.y(), fn);
-}
-
-template<typename CellPositionType, typename CellQueryFn> class JPSTracer
-{
-public:
-    // Use incoming_dir [0,0] for starting points, so that all directions are checked from that point
-    struct Node
-    {
-        CellPositionType position;
-        CellPositionType incoming_dir;
-    };
-
-    JPSTracer(CellPositionType target, CellQueryFn is_passable) : target(target), is_passable(is_passable) {}
-
-private:
-    CellPositionType target;
-    CellQueryFn      is_passable; // should return boolean whether the cell is passable or not
-
-    CellPositionType find_jump_point(CellPositionType start, CellPositionType forward_dir) const
-    {
-        CellPositionType next = start + forward_dir;
-        while (next != target && is_passable(next) && !(is_jump_point(next, forward_dir))) { next = next + forward_dir; }
-
-        if (is_passable(next)) {
-            return next;
-        } else {
-            return start;
-        }
-    }
-
-    bool is_jump_point(CellPositionType pos, CellPositionType forward_dir) const
-    {
-        if (abs(forward_dir.x()) + abs(forward_dir.y()) == 2) {
-            // diagonal
-            CellPositionType horizontal_check_dir = CellPositionType{forward_dir.x(), 0};
-            CellPositionType vertical_check_dir   = CellPositionType{0, forward_dir.y()};
-
-            if (!is_passable(pos - horizontal_check_dir) && is_passable(pos + forward_dir - 2 * horizontal_check_dir)) { return true; }
-
-            if (!is_passable(pos - vertical_check_dir) && is_passable(pos + forward_dir - 2 * vertical_check_dir)) { return true; }
-
-            if (find_jump_point(pos, horizontal_check_dir) != pos) { return true; }
-
-            if (find_jump_point(pos, vertical_check_dir) != pos) { return true; }
-
-            return false;
-        } else { // horizontal or vertical
-            CellPositionType side_dir = CellPositionType(forward_dir.y(), forward_dir.x());
-
-            if (!is_passable(pos + side_dir) && is_passable(pos + forward_dir + side_dir)) { return true; }
-
-            if (!is_passable(pos - side_dir) && is_passable(pos + forward_dir - side_dir)) { return true; }
-
-            return false;
-        }
-    }
-
-public:
-    template<class Fn> void foreach_reachable(const Node &from, Fn &&fn) const
-    {
-        const CellPositionType &      pos         = from.position;
-        const CellPositionType &      forward_dir = from.incoming_dir;
-        std::vector<CellPositionType> dirs_to_check{};
-
-        if (abs(forward_dir.x()) + abs(forward_dir.y()) == 0) { // special case for starting point
-            dirs_to_check = all_directions;
-        } else if (abs(forward_dir.x()) + abs(forward_dir.y()) == 2) {
-            // diagonal
-            CellPositionType horizontal_check_dir = CellPositionType{forward_dir.x(), 0};
-            CellPositionType vertical_check_dir   = CellPositionType{0, forward_dir.y()};
-
-            if (!is_passable(pos - horizontal_check_dir) && is_passable(pos + forward_dir - 2 * horizontal_check_dir)) {
-                dirs_to_check.push_back(forward_dir - 2 * horizontal_check_dir);
-            }
-
-            if (!is_passable(pos - vertical_check_dir) && is_passable(pos + forward_dir - 2 * vertical_check_dir)) {
-                dirs_to_check.push_back(forward_dir - 2 * vertical_check_dir);
-            }
-
-            dirs_to_check.push_back(horizontal_check_dir);
-            dirs_to_check.push_back(vertical_check_dir);
-            dirs_to_check.push_back(forward_dir);
-
-        } else { // horizontal or vertical
-            CellPositionType side_dir = CellPositionType(forward_dir.y(), forward_dir.x());
-
-            if (!is_passable(pos + side_dir) && is_passable(pos + forward_dir + side_dir)) { dirs_to_check.push_back(forward_dir + side_dir); }
-
-            if (!is_passable(pos - side_dir) && is_passable(pos + forward_dir - side_dir)) { dirs_to_check.push_back(forward_dir - side_dir); }
-            dirs_to_check.push_back(forward_dir);
-        }
-
-        for (const CellPositionType &dir : dirs_to_check) {
-            CellPositionType jp = find_jump_point(pos, dir);
-            if (jp != pos) fn(Node{jp, dir});
-        }
-    }
-
-    float distance(Node a, Node b) const { return (a.position - b.position).template cast<double>().norm(); }
-
-    float goal_heuristic(Node n) const { return n.position == target ? -1.f : (target - n.position).template cast<double>().norm(); }
-
-    size_t unique_id(Node n) const { return (static_cast<size_t>(uint16_t(n.position.x())) << 16) + static_cast<size_t>(uint16_t(n.position.y())); }
-
-    const std::vector<CellPositionType> all_directions{{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
-};
-
-void JPSPathFinder::clear()
-{
-    inpassable.clear();
-    max_search_box.max = Pixel(std::numeric_limits<coord_t>::min(), std::numeric_limits<coord_t>::min());
-    max_search_box.min = Pixel(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max());
-    add_obstacles(bed_shape);
-}
-
-void JPSPathFinder::add_obstacles(const Lines &obstacles)
-{
-    auto store_obstacle = [&](coord_t x, coord_t y) {
-        max_search_box.max.x() = std::max(max_search_box.max.x(), x);
-        max_search_box.max.y() = std::max(max_search_box.max.y(), y);
-        max_search_box.min.x() = std::min(max_search_box.min.x(), x);
-        max_search_box.min.y() = std::min(max_search_box.min.y(), y);
-        inpassable.insert(Pixel{x, y});
-        return true;
-    };
-
-    for (const Line &l : obstacles) {
-        Pixel start = pixelize(l.a);
-        Pixel end   = pixelize(l.b);
-        double_dda_with_offset(start.x(), start.y(), end.x(), end.y(), store_obstacle);
-    }
-}
-
-Polyline JPSPathFinder::find_path(const Point &p0, const Point &p1)
-{
-    Pixel start = pixelize(p0);
-    Pixel end   = pixelize(p1);
-    if (inpassable.empty() || (start - end).cast<float>().norm() < 3.0) { return Polyline{p0, p1}; }
-
-    if (inpassable.find(start) != inpassable.end()) {
-        dda(start.x(), start.y(), end.x(), end.y(), [&](coord_t x, coord_t y) {
-            if (inpassable.find(Pixel(x, y)) == inpassable.end() || start == end) { // new start not found yet, and xy passable
-                start = Pixel(x, y);
-                return false;
-            }
-            return true;
-        });
-    }
-
-    if (inpassable.find(end) != inpassable.end()) {
-        dda(end.x(), end.y(), start.x(), start.y(), [&](coord_t x, coord_t y) {
-            if (inpassable.find(Pixel(x, y)) == inpassable.end() || start == end) { // new start not found yet, and xy passable
-                end = Pixel(x, y);
-                return false;
-            }
-            return true;
-        });
-    }
-
-    BoundingBox search_box = max_search_box;
-    search_box.max -= Pixel(1, 1);
-    search_box.min += Pixel(1, 1);
-
-    BoundingBox bounding_square(Points{start, end});
-    bounding_square.max += Pixel(5, 5);
-    bounding_square.min -= Pixel(5, 5);
-    coord_t bounding_square_size = 2 * std::max(bounding_square.size().x(), bounding_square.size().y());
-    bounding_square.max.x() += (bounding_square_size - bounding_square.size().x()) / 2;
-    bounding_square.min.x() -= (bounding_square_size - bounding_square.size().x()) / 2;
-    bounding_square.max.y() += (bounding_square_size - bounding_square.size().y()) / 2;
-    bounding_square.min.y() -= (bounding_square_size - bounding_square.size().y()) / 2;
-
-    // Intersection - limit the search box to a square area around the start and end, to fasten the path searching
-    search_box.max = search_box.max.cwiseMin(bounding_square.max);
-    search_box.min = search_box.min.cwiseMax(bounding_square.min);
-
-    auto cell_query = [&](Pixel pixel) { return search_box.contains(pixel) && (pixel == start || pixel == end || inpassable.find(pixel) == inpassable.end()); };
-
-    JPSTracer<Pixel, decltype(cell_query)> tracer(end, cell_query);
-    using QNode = astar::QNode<JPSTracer<Pixel, decltype(cell_query)>>;
-
-    std::unordered_map<size_t, QNode>          astar_cache{};
-    std::vector<Pixel, PointsAllocator<Pixel>> out_path;
-    std::vector<decltype(tracer)::Node>        out_nodes;
-
-    if (!astar::search_route(tracer, {start, {0, 0}}, std::back_inserter(out_nodes), astar_cache)) {
-        // path not found - just reconstruct the best path from astar cache.
-        // Note that astar_cache is NOT empty - at least the starting point should always be there
-        auto                coordiante_func = [&astar_cache](size_t idx, size_t dim) { return float(astar_cache[idx].node.position[dim]); };
-        std::vector<size_t> keys;
-        keys.reserve(astar_cache.size());
-        for (const auto &pair : astar_cache) { keys.push_back(pair.first); }
-        KDTreeIndirect<2, float, decltype(coordiante_func)> kd_tree(coordiante_func, keys);
-        size_t                                              closest_qnode = find_closest_point(kd_tree, end.cast<float>());
-
-        out_path.push_back(end);
-        while (closest_qnode != astar::Unassigned) {
-            out_path.push_back(astar_cache[closest_qnode].node.position);
-            closest_qnode = astar_cache[closest_qnode].parent;
-        }
-    } else {
-        for (const auto &node : out_nodes) { out_path.push_back(node.position); }
-        out_path.push_back(start);
-    }
-
-#ifdef DEBUG_FILES
-    auto scaled_points = [](const Points &ps) {
-        Points r;
-        for (const Point &p : ps) { r.push_back(Point::new_scale(p.x(), p.y())); }
-        return r;
-    };
-    auto          scaled_point = [](const Point &p) { return Point::new_scale(p.x(), p.y()); };
-    ::Slic3r::SVG svg(debug_out_path(("path_jps" + std::to_string(print_z) + "_" + std::to_string(rand() % 1000)).c_str()).c_str(),
-                      BoundingBox(scaled_point(search_box.min), scaled_point(search_box.max)));
-    for (const auto &p : inpassable) { svg.draw(scaled_point(p), "black", scale_(0.4)); }
-    for (const auto &qn : astar_cache) { svg.draw(scaled_point(qn.second.node.position), "blue", scale_(0.3)); }
-    svg.draw(Polyline(scaled_points(out_path)), "yellow", scale_(0.25));
-    svg.draw(scaled_point(end), "purple", scale_(0.4));
-    svg.draw(scaled_point(start), "green", scale_(0.4));
-#endif
-
-    std::vector<Pixel, PointsAllocator<Pixel>> tmp_path;
-    tmp_path.reserve(out_path.size());
-    // Some path found, reverse and remove points that do not change direction
-    std::reverse(out_path.begin(), out_path.end());
-    {
-        tmp_path.push_back(out_path.front()); // first point
-        for (size_t i = 1; i < out_path.size() - 1; i++) {
-            if ((out_path[i] - out_path[i - 1]).cast<float>().normalized() != (out_path[i + 1] - out_path[i]).cast<float>().normalized()) { tmp_path.push_back(out_path[i]); }
-        }
-        tmp_path.push_back(out_path.back()); // last_point
-        out_path = tmp_path;
-    }
-
-#ifdef DEBUG_FILES
-    svg.draw(Polyline(scaled_points(out_path)), "orange", scale_(0.20));
-#endif
-
-    tmp_path.clear();
-    // remove redundant jump points - there are points that change direction but are not needed - this inefficiency arises from the
-    // usage of grid search The removal alg tries to find the longest Px Px+k path without obstacles. If Px Px+k+1 is blocked, it will
-    // insert the Px+k point to result and continue search from Px+k
-    {
-        tmp_path.push_back(out_path.front()); // first point
-        size_t index_of_last_stored_point = 0;
-        for (size_t i = 1; i < out_path.size(); i++) {
-            if (i - index_of_last_stored_point < 2) continue;
-            bool passable       = true;
-            auto store_obstacle = [&](coord_t x, coord_t y) {
-                if (Pixel(x, y) != start && Pixel(x, y) != end && inpassable.find(Pixel(x, y)) != inpassable.end()) {
-                    passable = false;
-                    return false;
-                }
-                return true;
-            };
-            dda(tmp_path.back().x(), tmp_path.back().y(), out_path[i].x(), out_path[i].y(), store_obstacle);
-            if (!passable) {
-                tmp_path.push_back(out_path[i - 1]);
-                index_of_last_stored_point = i - 1;
-            }
-        }
-        tmp_path.push_back(out_path.back()); // last_point
-        out_path = tmp_path;
-    }
-
-#ifdef DEBUG_FILES
-    svg.draw(Polyline(scaled_points(out_path)), "red", scale_(0.15));
-    svg.Close();
-#endif
-
-    // before returing the path, transform it from pixels back to points.
-    // Also replace the first and last pixel by input points so that result path patches input params exactly.
-    for (Pixel &p : out_path) { p = unpixelize(p); }
-    out_path.front() = p0;
-    out_path.back()  = p1;
-
-    return Polyline(out_path);
-}
-
-} // namespace Slic3r

src/libslic3r/JumpPointSearch.hpp

@@ -1,39 +0,0 @@
-#pragma once
-#include "Line.hpp"
-#ifndef SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_
-#define SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_
-
-#include "BoundingBox.hpp"
-#include "Polygon.hpp"
-#include "libslic3r/Layer.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/Polyline.hpp"
-#include "libslic3r/libslic3r.h"
-#include <unordered_map>
-#include <unordered_set>
-
-namespace Slic3r {
-
-class JPSPathFinder
-{
-    using Pixel = Point;
-    std::unordered_set<Pixel, PointHash> inpassable;
-    coordf_t                             print_z;
-    BoundingBox                          max_search_box;
-    Lines                                bed_shape;
-
-    const coord_t resolution = scaled(1.5);
-    Pixel         pixelize(const Point &p) { return p / resolution; }
-    Point         unpixelize(const Pixel &p) { return p * resolution; }
-
-public:
-    JPSPathFinder() = default;
-    void     init_bed_shape(const Points &bed_shape) { this->bed_shape = (to_lines(Polygon{bed_shape})); };
-    void     clear();
-    void     add_obstacles(const Lines &obstacles);
-    Polyline find_path(const Point &start, const Point &end);
-};
-
-} // namespace Slic3r
-
-#endif /* SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_ */

src/libslic3r/MeshBoolean.cpp

@@ -29,8 +29,6 @@
 #include <CGAL/Polygon_mesh_processing/triangulate_hole.h>
 #include <CGAL/Polygon_mesh_processing/stitch_borders.h>
 #include <CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h>
-#include <CGAL/Polygon_mesh_processing/repair_degeneracies.h>
-#include <CGAL/Polygon_mesh_processing/manifoldness.h>
 #include <cstdint>
 #include <map>
 #include <algorithm>
@@ -50,7 +48,6 @@
 #include <CGAL/Polygon_mesh_processing/orient_polygon_soup.h>
 #include <CGAL/Polygon_mesh_processing/repair.h>
 #include <CGAL/Polygon_mesh_processing/remesh.h>
-#include <CGAL/Polygon_mesh_processing/repair_polygon_soup.h>
 #include <CGAL/Polygon_mesh_processing/orientation.h>
 // BBS: for segment
 #include <CGAL/mesh_segmentation.h>
@@ -658,91 +655,6 @@ bool empty(const CGALMesh &mesh)
     return mesh.m.is_empty();
 }
 
-bool repair(TriangleMesh& mesh, RepairedMeshErrors* repaired_errors, std::string* error)
-{
-    namespace PMP = CGAL::Polygon_mesh_processing;
-
-    if (mesh.empty())
-        return true;
-
-    try {
-        // 1) Convert to polygon soup
-        std::vector<_EpicMesh::Point>         points;
-        std::vector<std::vector<std::size_t>> polygons;
-
-        points.reserve(mesh.its.vertices.size());
-        polygons.reserve(mesh.its.indices.size());
-
-        for (const auto& v : mesh.its.vertices)
-            points.emplace_back(v.x(), v.y(), v.z());
-
-        for (const auto& f : mesh.its.indices)
-            polygons.push_back({size_t(f[0]), size_t(f[1]), size_t(f[2])});
-
-        // 2) Aggressive soup cleanup
-        PMP::repair_polygon_soup(points, polygons);
-
-        // 3) Convert soup → mesh
-        _EpicMesh cgal_mesh;
-        PMP::polygon_soup_to_polygon_mesh(points, polygons, cgal_mesh);
-
-        // 4) Remove degenerate geometry
-        PMP::remove_degenerate_faces(cgal_mesh);
-        PMP::remove_isolated_vertices(cgal_mesh);
-
-        // 5) Fix remaining non-manifold vertices
-        PMP::duplicate_non_manifold_vertices(cgal_mesh);
-
-        // 6) Boolean union (keeps only outer shell)
-        _EpicMesh tmp;
-        if (PMP::corefine_and_compute_union(cgal_mesh, cgal_mesh, tmp)) {
-            cgal_mesh = std::move(tmp);
-        }
-        // If it fails, continue anyway with previous mesh
-
-        // 7) Fill holes
-        if (!CGAL::is_closed(cgal_mesh)) {
-            using halfedge_descriptor = boost::graph_traits<_EpicMesh>::halfedge_descriptor;
-
-            std::vector<halfedge_descriptor> borders;
-            CGAL::extract_boundary_cycles(cgal_mesh, std::back_inserter(borders));
-
-            for (halfedge_descriptor h : borders) {
-                PMP::triangulate_and_refine_hole(cgal_mesh, h);
-            }
-        }
-
-        // 8) Final validity check
-        if (!CGAL::is_closed(cgal_mesh)) {
-            if (error)
-                *error = "Repair failed: mesh still open after hole filling.";
-            return false;
-        }
-
-        // 9) Ensure outward orientation
-        if (!PMP::does_bound_a_volume(cgal_mesh))
-            PMP::orient_to_bound_a_volume(cgal_mesh);
-
-        // 10) Convert back
-        indexed_triangle_set its = cgal_to_indexed_triangle_set(cgal_mesh);
-
-        RepairedMeshErrors errs{};
-        errs.facets_removed = 0;
-        errs.edges_fixed    = 0;
-
-        mesh = TriangleMesh(std::move(its), errs);
-
-        if (repaired_errors)
-            *repaired_errors = errs;
-
-        return true;
-    } catch (const std::exception& e) {
-        if (error)
-            *error = e.what();
-        return false;
-    }
-}
-
 CGALMeshPtr clone(const CGALMesh &m)
 {
     return CGALMeshPtr{new CGALMesh{m}};

src/libslic3r/MeshBoolean.hpp

@@ -77,9 +77,6 @@ TriangleMesh merge(std::vector<TriangleMesh> meshes);
 bool does_bound_a_volume(const CGALMesh &mesh);
 bool empty(const CGALMesh &mesh);
 
-// Repair a mesh using CGAL. Returns true on success. Optionally returns a summary of repairs and an error string.
-bool repair(TriangleMesh &mesh, RepairedMeshErrors *repaired_errors = nullptr, std::string *error = nullptr);
-
 // Real UV unwrap of an open mesh patch via CGAL's LSCM (Least Squares Conformal Maps) surface
 // parameterization. Returns one UV coordinate per input vertex (same indexing as `mesh.vertices`),
 // or nullopt if `mesh` isn't a single topological disk -- LSCM needs exactly one connected

src/libslic3r/MeshRepair.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <cstddef>
+#include <functional>
+#include <string>
+
+namespace Slic3r {
+
+class TriangleMesh;
+
+struct MeshRepairStats
+{
+    std::size_t welded_vertices    = 0;
+    std::size_t removed_triangles  = 0;
+    std::size_t reversed_shells    = 0;
+    std::size_t filled_holes       = 0;
+    std::size_t removed_shells     = 0;
+    std::size_t self_intersections = 0;
+    // False when the input already was closed, consistently oriented and free of self-intersections.
+    bool        modified           = false;
+};
+
+// Returns false, leaving the mesh untouched, if no solid can be built. progress gets the percentage done and may
+// throw to cancel. See docs/HLSD/mesh-repair.md.
+bool repair_mesh(TriangleMesh &mesh, MeshRepairStats *stats = nullptr, std::string *error = nullptr,
+                 const std::function<void(int)> &progress = {});
+
+} // namespace Slic3r

src/libslic3r/Model.cpp

@@ -29,6 +29,7 @@
 #include "TriangleMeshSlicer.hpp"
 #include "TriangleSelector.hpp"
 #include "MaterialType.hpp"
+#include "MeshRepair.hpp"
 
 #include "Format/AMF.hpp"
 #include "Format/svg.hpp"
@@ -2946,6 +2947,18 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
     if (text_configuration.has_value())
         text_configuration.reset();
 
+    // Parts without a convex hull enclose no volume; drop them here, as deleting volumes later could delete this one.
+    std::vector<std::unique_ptr<ModelVolume>> parts;
+    for (TriangleMesh &mesh : meshes)
+        if (!mesh.empty()) {
+            std::unique_ptr<ModelVolume> part(new ModelVolume(object, *this, std::move(mesh)));
+            if (const std::shared_ptr<const TriangleMesh> &hull = part->get_convex_hull_shared_ptr();
+                hull != nullptr && !hull->its.vertices.empty() && !hull->its.indices.empty())
+                parts.emplace_back(std::move(part));
+        }
+    if (parts.empty())
+        return 1;
+
     std::optional<TriangleSelector::SavedPainting> saved_painting = remap_paint ? save_painting() :
                                                                                   std::optional<TriangleSelector::SavedPainting>{};
 
@@ -2956,26 +2969,22 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
     unsigned int extruder_counter = 0;
     const Vec3d offset = this->get_offset();
 
-    for (TriangleMesh &mesh : meshes) {
-        if (mesh.empty())
-            // Repair may have removed unconnected triangles, thus emptying the mesh.
-            continue;
-
+    for (std::unique_ptr<ModelVolume> &part : parts) {
         if (idx == 0) {
-            this->set_mesh(std::move(mesh));
-            this->calculate_convex_hull();
+            this->set_mesh(part->m_mesh);
+            m_convex_hull = part->m_convex_hull;
             this->invalidate_convex_hull_2d();
             // Assign a new unique ID, so that a new GLVolume will be generated.
             this->set_new_unique_id();
-            // reset the source to disable reload from disk
-            this->source = ModelVolume::Source();
 
             // BBS: reset facet annotations
             this->reset_extra_facets();
         }
         else
-            this->object->volumes.insert(this->object->volumes.begin() + (++ivolume), new ModelVolume(object, *this, std::move(mesh)));
+            this->object->volumes.insert(this->object->volumes.begin() + (++ivolume), part.release());
 
+        // reset the source to disable reload from disk
+        this->object->volumes[ivolume]->source = ModelVolume::Source();
         this->object->volumes[ivolume]->set_offset(Vec3d::Zero());
         this->object->volumes[ivolume]->center_geometry_after_creation();
         this->object->volumes[ivolume]->translate(offset);
@@ -2989,21 +2998,29 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
         ++ idx;
     }
 
-    // discard volumes for which the convex hull was not generated or is degenerate
-    size_t i = 0;
-    while (i < this->object->volumes.size()) {
-        const std::shared_ptr<const TriangleMesh> &hull = this->object->volumes[i]->get_convex_hull_shared_ptr();
-        if (hull == nullptr || hull->its.vertices.empty() || hull->its.indices.empty()) {
-            this->object->delete_volume(i);
-            --idx;
-            --i;
-        }
-        ++i;
-    }
-
     return idx;
 }
 
+bool ModelVolume::repair(bool keep_painting, MeshRepairStats *stats_out, std::string *error, const std::function<void(int)> &progress)
+{
+    TriangleMesh    mesh = this->mesh();
+    MeshRepairStats stats;
+    const bool      ok = repair_mesh(mesh, &stats, error, progress);
+    if (stats_out)
+        *stats_out = stats;
+    if (!ok || !stats.modified)
+        return ok;
+
+    const std::optional<TriangleSelector::SavedPainting> saved_painting = keep_painting ? save_painting() : std::nullopt;
+    this->set_mesh(std::move(mesh));
+    this->calculate_convex_hull();
+    this->invalidate_convex_hull_2d();
+    // Assign a new unique ID, so that a new GLVolume will be generated.
+    this->set_new_unique_id();
+    this->restore_painting(saved_painting);
+    return true;
+}
+
 void ModelVolume::translate(const Vec3d& displacement)
 {
     set_offset(get_offset() + displacement);

src/libslic3r/Model.hpp

@@ -77,6 +77,7 @@ class Preset;
 class BBLProject;
 
 class KeyStore;
+struct MeshRepairStats;
 
 namespace UndoRedo {
 	class StackImpl;
@@ -887,13 +888,13 @@ public:
     // The triangular model.
     const TriangleMesh& mesh() const { return *m_mesh.get(); }
     std::shared_ptr<const TriangleMesh> mesh_ptr() const { return m_mesh; }
-    void                set_mesh(const TriangleMesh &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); }
-    void                set_mesh(TriangleMesh &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); }
-    void                set_mesh(const indexed_triangle_set &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); }
-    void                set_mesh(indexed_triangle_set &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); }
-    void                set_mesh(std::shared_ptr<const TriangleMesh> &mesh) { m_mesh = mesh; }
-    void                set_mesh(std::unique_ptr<const TriangleMesh> &&mesh) { m_mesh = std::move(mesh); }
-	void				reset_mesh() { m_mesh = std::make_shared<const TriangleMesh>(); }
+    void                set_mesh(const TriangleMesh &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); m_is_splittable = -1; }
+    void                set_mesh(TriangleMesh &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); m_is_splittable = -1; }
+    void                set_mesh(const indexed_triangle_set &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); m_is_splittable = -1; }
+    void                set_mesh(indexed_triangle_set &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); m_is_splittable = -1; }
+    void                set_mesh(std::shared_ptr<const TriangleMesh> &mesh) { m_mesh = mesh; m_is_splittable = -1; }
+    void                set_mesh(std::unique_ptr<const TriangleMesh> &&mesh) { m_mesh = std::move(mesh); m_is_splittable = -1; }
+	void				reset_mesh() { m_mesh = std::make_shared<const TriangleMesh>(); m_is_splittable = -1; }
     const std::shared_ptr<const TriangleMesh>& get_mesh_shared_ptr() const { return m_mesh; }
     // Configuration parameters specific to an object model geometry or a modifier volume, 
     // overriding the global Slic3r settings and the ModelObject settings.
@@ -1043,6 +1044,9 @@ public:
     // Return the number of volumes created from this one.
     // This is useful to assign different materials to different volumes of an object.
     size_t              split(unsigned int max_extruders, bool remap_paint);
+    // Replaces the mesh by its repair_mesh() result if that changed it. False if no solid can be built.
+    bool                repair(bool keep_painting, MeshRepairStats *stats = nullptr, std::string *error = nullptr,
+                               const std::function<void(int)> &progress = {});
     void                translate(double x, double y, double z) { translate(Vec3d(x, y, z)); }
     void                translate(const Vec3d& displacement);
     void                scale(const Vec3d& scaling_factors);

src/libslic3r/Preset.cpp

@@ -1487,7 +1487,7 @@ static std::vector<std::string> s_Preset_print_options{
 static std::vector<std::string> s_Preset_filament_options {/*"filament_colour", */ "default_filament_colour", "required_nozzle_HRC", "filament_diameter", "pellet_flow_coefficient", "volumetric_speed_coefficients", "filament_type",
                                                           "filament_soluble", "filament_is_support", "filament_printable", "filament_extruder_compatibility",
     "filament_max_volumetric_speed", "filament_adaptive_volumetric_speed",
-    "filament_flow_ratio", "filament_density", "filament_transmission_distance", "filament_adhesiveness_category", "filament_cost", "filament_minimal_purge_on_wipe_tower",
+    "filament_flow_ratio", "filament_density", "filament_adhesiveness_category", "filament_cost", "filament_minimal_purge_on_wipe_tower",
     "filament_tower_interface_pre_extrusion_dist", "filament_tower_interface_pre_extrusion_length", "filament_tower_ironing_area", "filament_tower_interface_purge_volume",
     "filament_tower_interface_print_temp",
     "nozzle_temperature", "nozzle_temperature_initial_layer",
@@ -2164,6 +2164,16 @@ int PresetCollection::get_differed_values_to_update(Preset& preset, std::map<std
         DynamicPrintConfig temp_config;
         std::vector<std::string> dirty_options = preset.config.diff(parent_preset->config);
 
+        // Send the variant layout even when it matches the parent's, as the local save does: the loader
+        // sizes the per-variant values by it and would otherwise keep only the first one.
+        std::string extruder_id_name, extruder_variant_name;
+        std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
+        Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
+        if (!extruder_id_name.empty())
+            dirty_options.emplace_back(extruder_id_name);
+        if (!extruder_variant_name.empty())
+            dirty_options.emplace_back(extruder_variant_name);
+
         for (auto option: dirty_options)
         {
             ConfigOption *opt_src = preset.config.option(option);
@@ -2628,15 +2638,34 @@ bool PresetCollection::load_user_preset(std::string name, std::map<std::string,
             new_config = default_preset.config;
         }
 
+        std::string extruder_id_name, extruder_variant_name;
+        std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
+        Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
+
+        // Older uploads left out a variant layout equal to the parent's but still sent one value per
+        // parent variant. Read those values against the parent's layout instead of cutting them to one.
+        if (inherit_preset && !cloud_config.has(extruder_variant_name)) {
+            const auto  *parent_variants = inherit_preset->config.option<ConfigOptionStrings>(extruder_variant_name);
+            const size_t variant_count   = parent_variants ? parent_variants->size() : 0;
+            bool         values_per_variant = false;
+            for (const std::string &key : cloud_config.keys()) {
+                const size_t stride = key_set2->count(key) ? 2 : key_set1->count(key) ? 1 : 0;
+                const auto  *values = dynamic_cast<const ConfigOptionVectorBase *>(cloud_config.option(key));
+                if (stride > 0 && key != extruder_id_name && values && variant_count > 1 && values->size() == variant_count * stride) {
+                    values_per_variant = true;
+                    break;
+                }
+            }
+            if (values_per_variant)
+                for (const std::string &key : {extruder_id_name, extruder_variant_name})
+                    if (!key.empty() && !cloud_config.has(key) && inherit_preset->config.has(key))
+                        cloud_config.set_key_value(key, inherit_preset->config.option(key)->clone());
+        }
+
         extend_default_config_length(cloud_config, false, {});
 
-        if (inherit_preset) {
-            std::string extruder_id_name, extruder_variant_name;
-            std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
-            Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
-
+        if (inherit_preset)
             new_config.update_diff_values_to_child_config(cloud_config, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
-        }
         else{
             new_config.apply(std::move(cloud_config));
             extend_default_config_length(new_config, true, default_preset.config);

src/libslic3r/PresetBundle.cpp

@@ -4188,6 +4188,16 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                         maps.erase(j);
                     }
                 }
+            }
+            if (is_placeholder) {
+                // Orca: an empty AMS slot is a placeholder, not a filament - never synthesize a
+                // preset for it. Kept here only to keep index alignment with ams_infos; the sync
+                // drops it so no filament slot is created or retained for an empty tray.
+                ams_filament_presets.push_back("");
+                ams_filament_colors.push_back("");
+                ams_filament_color_types.push_back("");
+                ams_multi_color_filment.push_back({});
+            } else if (use_map) {
                 ams_filament_presets.push_back("Generic PLA");//for unknow matieral
                 auto default_unknown_color = "#CECECE";
                 ams_filament_colors.push_back(default_unknown_color);
@@ -4196,12 +4206,6 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                     filament_multi_color.push_back(default_unknown_color);
                 }
                 ams_multi_color_filment.push_back(filament_multi_color);
-            } else if (is_placeholder) {
-                // Orca: push placeholders to keep index alignment with ams_infos
-                ams_filament_presets.push_back("");
-                ams_filament_colors.push_back("");
-                ams_filament_color_types.push_back("");
-                ams_multi_color_filment.push_back({});
             }
             continue;
         }
@@ -4565,6 +4569,10 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                     result_multi_colors.push_back(
                         i < ams_multi_color_filment.size() ? ams_multi_color_filment[i]
                                                            : std::vector<std::string>{ams_filament_colors[i]});
+                } else if (i < ams_infos.size() && ams_infos[i].is_placeholder) {
+                    // Orca: an empty AMS slot is a placeholder, not a filament, so drop it instead of
+                    // keeping or filling a slot for it. The device AMS panel still shows the empty tray.
+                    continue;
                 } else if (i < exist_presets.size()) {
                     // Empty tray or beyond tray count: keep existing filament
                     result_colors.push_back(exist_colors[i]);
@@ -4589,8 +4597,8 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
             filament_color_type->values = result_color_types;
             this->filament_presets      = result_presets;
             ams_multi_color_filment     = result_multi_colors;
-            filament_map->values.resize(total, 1);
-            filament_volume_map->values.resize(total, static_cast<int>(NozzleVolumeType::nvtStandard));
+            filament_map->values.resize(result_presets.size(), 1);
+            filament_volume_map->values.resize(result_presets.size(), static_cast<int>(NozzleVolumeType::nvtStandard));
         } else {
             // BBL: existing wholesale replace
             filament_color->values = ams_filament_colors;

src/libslic3r/Print.cpp

@@ -226,7 +226,6 @@ bool Print::invalidate_state_by_config_options(const ConfigOptionResolver & /* n
         "filament_diameter",
          "volumetric_speed_coefficients",
         "filament_density",
-        "filament_transmission_distance",
         "filament_cost",
         "filament_notes",
         "outer_wall_acceleration",
@@ -2992,6 +2991,15 @@ void  PrintObject::clear_shared_object()
 void  PrintObject::copy_layers_from_shared_object()
 {
     if (m_shared_object) {
+        // Orca: Print::process() calls this once per slice for each sharing object, after clear_shared_object() has
+        // emptied any earlier alias, so the vectors hold only layers this object sliced itself before it started sharing
+        // (or nothing). Free them here, as clear_support_layers() / clear_layers() would; those skip deletion while
+        // m_shared_object is set. The belt-only data they also free is always empty here, because belt printers never
+        // share layers.
+        for (SupportLayer *layer : m_support_layers)
+            delete layer;
+        for (Layer *layer : m_layers)
+            delete layer;
         m_layers.clear();
         m_support_layers.clear();
 

src/libslic3r/PrintConfig.cpp

@@ -3441,20 +3441,6 @@ void PrintConfigDef::init_fff_params()
     def->mode = comAdvanced;
     def->set_default_value(new ConfigOptionFloats { 0. });
 
-    def = this->add("filament_transmission_distance", coFloats);
-    def->label = L("Transmission distance");
-    def->tooltip = L("How deep light gets into this filament, in millimetres, also called its "
-                     "transmission distance or TD. About 1 for an opaque filament, 4 to 7 for a usefully "
-                     "translucent one, 8 and above for a nearly clear one. Used only to predict the "
-                     "colours of a ChromaStack in the texture displacement tool; it has no effect on "
-                     "slicing. Measure it with a step test print, or take a published value for the "
-                     "filament.");
-    def->sidetext = L("mm");
-    def->min = 0;
-    def->max = 100;
-    def->mode = comAdvanced;
-    def->set_default_value(new ConfigOptionFloats { 4. });
-
     def = this->add("filament_type", coStrings);
     def->label = L("Type");
     def->tooltip = L("Filament material type");
@@ -12880,10 +12866,11 @@ CLITransformConfigDef::CLITransformConfigDef()
     //def->cli = "orient|o";
     def->set_default_value(new ConfigOptionInt(0));
 
-    /*def = this->add("repair", coBool);
+    def = this->add("repair", coBool);
     def->label = L("Repair");
-    def->tooltip = L("Repair the model's meshes if it is non-manifold mesh.");
-    def->set_default_value(new ConfigOptionBool(false));*/
+    def->tooltip = L("Repair the meshes of the models as Fix Model does: close holes and cracks, orient them outward and "
+                     "remove self-intersections.");
+    def->set_default_value(new ConfigOptionBool(false));
 
     def = this->add("rotate", coFloat);
     def->label = L("Rotate");
@@ -13099,7 +13086,7 @@ CLIMiscConfigDef::CLIMiscConfigDef()
     def = this->add("allow_rotations", coBool);
     def->label = L("Allow rotation when arranging");
     def->tooltip = L("If enabled, Arrange will allow rotation when placing objects.");
-    def->set_default_value(new ConfigOptionBool(true));
+    def->set_default_value(new ConfigOptionBool(false));
 
     def = this->add("align_to_y_axis", coBool);
     def->label = L("Align to Y axis when arranging");

src/libslic3r/PrintConfig.hpp

@@ -1709,9 +1709,6 @@ PRINT_CONFIG_CLASS_DEFINE(
     ((ConfigOptionStrings,             volumetric_speed_coefficients))
     ((ConfigOptionInts,              filament_adhesiveness_category))
     ((ConfigOptionFloats,              filament_density))
-    // Transmission distance: how deep light gets into this filament. Not used by
-    // slicing - it is the colour model of a ChromaStack stack (see ChromaStack.hpp).
-    ((ConfigOptionFloats,              filament_transmission_distance))
     ((ConfigOptionStrings,             filament_type))
     ((ConfigOptionBools,               filament_soluble))
     ((ConfigOptionStrings,             filament_ids))

src/libslic3r/PrintObject.cpp

@@ -982,6 +982,9 @@ void PrintObject::generate_support_material(bool with_belt_brim)
             this->_generate_support_material();
             m_print->throw_if_canceled();
         }
+        // Orca: the tree support collision/avoidance caches and support nodes are only used while this step runs
+        // (detect_overhangs() rebuilds them from scratch), so don't keep them resident until the next slice.
+        this->clear_tree_support_preview_cache();
         // Belt brim rides here rather than in the brim step because its apron
         // prologue introduces print_z values below the object's first layer, and
         // those must exist before ToolOrdering is built at psWipeTower - one step

src/libslic3r/PrintObjectSlice.cpp

@@ -1532,7 +1532,7 @@ void PrintObject::slice_volumes()
                         if (min_growth < 0.f || elfoot > 0.f) {
                             // Apply the negative XY compensation. (the ones that is <0)
                             ExPolygons trimming;
-                            static const float eps = float(scale_(m_config.slice_closing_radius.value) * 1.5);
+                            const float eps = float(scale_(m_config.slice_closing_radius.value) * 1.5);
                             if (elfoot > 0.f) {
                                 ExPolygons expolygons_to_compensate = offset_ex(layer->merged(eps), -eps);
                                 lslices_elfoot_uncompensated[layer_id] = expolygons_to_compensate;

src/libslic3r/Support/TreeSupport.cpp

@@ -1976,37 +1976,15 @@ coordf_t TreeSupport::get_radius(const SupportNode* node)
     return node->radius;
 }
 
-ExPolygons TreeSupport::get_avoidance(coordf_t radius, size_t obj_layer_nr)
+// Orca: drop_nodes() calls these several times per node per layer, so they return a reference into the
+// TreeSupportData cache. The cache only ever inserts, so its entries never move while nodes drop in parallel.
+const ExPolygons& TreeSupport::get_avoidance(coordf_t radius, size_t obj_layer_nr)
 {
-#if USE_SUPPORT_3D
-    if (m_model_volumes) {
-        bool on_build_plate = m_object_config->support_on_build_plate_only.value;
-        const Polygons& avoid_polys = m_model_volumes->getAvoidance(radius, obj_layer_nr, TreeSupport3D::TreeModelVolumes::AvoidanceType::FastSafe, on_build_plate, true);
-        ExPolygons expolys;
-        for (auto& poly : avoid_polys)
-            expolys.emplace_back(std::move(poly));
-        return expolys;
-    }
-    return ExPolygons();
-#else
     return m_ts_data->get_avoidance(radius, obj_layer_nr);
-#endif
 }
-ExPolygons TreeSupport::get_collision(coordf_t radius, size_t layer_nr)
+const ExPolygons& TreeSupport::get_collision(coordf_t radius, size_t layer_nr)
 {
-#if USE_SUPPORT_3D
-    if (m_model_volumes) {
-        bool on_build_plate = m_object_config->support_on_build_plate_only.value;
-        const Polygons& collision_polys = m_model_volumes->getCollision(radius, layer_nr, true);
-        ExPolygons expolys;
-        for (auto& poly : collision_polys)
-            expolys.emplace_back(std::move(poly));
-        return expolys;
-    }
-#else
     return m_ts_data->get_collision(radius, layer_nr);
-#endif
-    return ExPolygons();
 }
 Polygons TreeSupport::get_collision_polys(coordf_t radius, size_t layer_nr)
 {
@@ -2827,7 +2805,12 @@ void TreeSupport::draw_circles()
 #endif  // SUPPORT_TREE_DEBUG_TO_SVG
 
     SupportLayerPtrs& ts_layers = m_object->support_layers();
-    auto iter = std::remove_if(ts_layers.begin(), ts_layers.end(), [](SupportLayer* ts_layer) { return ts_layer->height < EPSILON; });
+    // Orca: the vector owns its layers, so the dropped ones are deleted before they are erased.
+    // std::stable_partition (unlike std::remove_if) leaves exactly the dropped layers in the tail.
+    // Only heights below EPSILON are dropped; written as !(height < EPSILON), a NaN height is kept.
+    auto iter = std::stable_partition(ts_layers.begin(), ts_layers.end(), [](SupportLayer* ts_layer) { return !(ts_layer->height < EPSILON); });
+    for (auto it = iter; it != ts_layers.end(); ++it)
+        delete *it;
     ts_layers.erase(iter, ts_layers.end());
     for (int layer_nr = 0; layer_nr < ts_layers.size(); layer_nr++) {
         ts_layers[layer_nr]->upper_layer = layer_nr != ts_layers.size() - 1 ? ts_layers[layer_nr + 1] : nullptr;
@@ -3071,7 +3054,7 @@ void TreeSupport::drop_nodes()
                     //Insert a completely new node and let both original nodes fade.
                     Point next_position = (node.position + neighbours[0]) / 2; //Average position of the two nodes.
                     coordf_t next_radius = calc_radius(node.dist_mm_to_top+height_next);
-                    auto avoid_layer = get_avoidance(next_radius, obj_layer_nr_next);
+                    const ExPolygons& avoid_layer = get_avoidance(next_radius, obj_layer_nr_next);
                     if (group_index == 0)
                     {
                         //Avoid collisions.
@@ -3275,7 +3258,7 @@ void TreeSupport::drop_nodes()
                 }
 #endif
                 coordf_t next_radius = calc_radius(node.dist_mm_to_top + height_next);
-                auto avoidance_next = get_avoidance(next_radius, obj_layer_nr_next);
+                const ExPolygons& avoidance_next = get_avoidance(next_radius, obj_layer_nr_next);
 
                 Point  to_outside         = projection_onto(avoidance_next, node.position);
                 Point  direction_to_outer = to_outside - node.position;
@@ -3337,7 +3320,7 @@ void TreeSupport::drop_nodes()
                     p_node->to_buildplate = false;
                     return; // from parallel_for_each lambda
                 }
-                auto              next_collision = get_collision(0, obj_layer_nr_next);
+                const ExPolygons& next_collision = get_collision(0, obj_layer_nr_next);
                 const bool   to_buildplate  = !is_inside_ex(m_ts_data->m_layer_outlines[obj_layer_nr_next], next_layer_vertex);
                 // don't increase radius if next node will collide partially with the object (STUDIO-7883)
                 to_outside             = projection_onto(next_collision, next_layer_vertex);

src/libslic3r/Support/TreeSupport.hpp

@@ -536,9 +536,9 @@ private:
     coordf_t calc_branch_radius(coordf_t base_radius, coordf_t mm_to_top, double diameter_angle_scale_factor, bool use_min_distance=true);
     coordf_t   calc_radius(coordf_t mm_to_top);
     coordf_t get_radius(const SupportNode* node);
-    ExPolygons get_avoidance(coordf_t radius, size_t obj_layer_nr);
+    const ExPolygons& get_avoidance(coordf_t radius, size_t obj_layer_nr);
     // layer's expolygon expanded by radius+m_xy_distance
-    ExPolygons get_collision(coordf_t radius, size_t layer_nr);
+    const ExPolygons& get_collision(coordf_t radius, size_t layer_nr);
     // get Polygons instead of ExPolygons
     Polygons get_collision_polys(coordf_t radius, size_t layer_nr);
 

src/libslic3r/TextureDisplacement.cpp

@@ -19,6 +19,7 @@
 #include <mutex>
 #include <numeric>
 #include <optional>
+#include "nlohmann/json.hpp"
 #include <queue>
 #include <ratio>
 #include <string>
@@ -5166,5 +5167,260 @@ indexed_triangle_set cut_mesh_at_steps(const indexed_triangle_set &mesh, const s
     return out;
 }
 
+// ---------------------------------------------------------------------------------------------
+// Project persistence. See the declarations in TextureDisplacement.hpp for why this is JSON rather
+// than the cereal stream next to them.
+// ---------------------------------------------------------------------------------------------
+namespace {
+
+nlohmann::json vec2_to_json(const Vec2f &v) { return nlohmann::json::array({ v.x(), v.y() }); }
+nlohmann::json vec3_to_json(const Vec3f &v) { return nlohmann::json::array({ v.x(), v.y(), v.z() }); }
+
+Vec2f vec2_from_json(const nlohmann::json &j, const Vec2f &fallback)
+{
+    if (!j.is_array() || j.size() != 2)
+        return fallback;
+    return Vec2f(j[0].get<float>(), j[1].get<float>());
+}
+Vec3f vec3_from_json(const nlohmann::json &j, const Vec3f &fallback)
+{
+    if (!j.is_array() || j.size() != 3)
+        return fallback;
+    return Vec3f(j[0].get<float>(), j[1].get<float>(), j[2].get<float>());
+}
+
+// Reads key `k` into `out` when it is present and of the expected type, leaving `out` alone otherwise.
+// That "leave it alone" is the whole point: every member starts at its struct default, so a project
+// written by an older build simply keeps the defaults for whatever it did not know about.
+template<class T> void read(const nlohmann::json &j, const char *k, T &out)
+{
+    const auto it = j.find(k);
+    if (it == j.end())
+        return;
+    try {
+        out = it->get<T>();
+    } catch (...) {
+    }
+}
+void read_enum(const nlohmann::json &j, const char *k, int &out)
+{
+    const auto it = j.find(k);
+    if (it != j.end() && it->is_number_integer())
+        out = it->get<int>();
+}
+
+} // namespace
+
+std::string texture_displacement_layers_to_json(const std::vector<TextureDisplacementLayer> &layers,
+                                                const TextureDisplacementOptions            &options)
+{
+    nlohmann::json root;
+    root["version"] = 1;
+
+    nlohmann::json &opt = root["options"];
+    opt["displace_border"]    = options.displace_border;
+    opt["smooth_enabled"]     = options.smooth_enabled;
+    opt["smooth_strength"]    = options.smooth_strength;
+    opt["smooth_iterations"]  = options.smooth_iterations;
+    opt["smooth_skip_border"] = options.smooth_skip_border;
+    opt["pipeline_v2"]        = options.pipeline_v2;
+    opt["v2_refine_mm"]       = options.v2_refine_mm;
+    opt["v2_regularize"]      = options.v2_regularize;
+    opt["v2_max_triangles_k"] = options.v2_max_triangles_k;
+    opt["v2_relocate"]        = options.v2_relocate;
+    opt["v2_flip_edges"]      = options.v2_flip_edges;
+    opt["color_mix_enabled"]  = options.color_mix_enabled;
+    opt["color_despeckle"]    = options.color_despeckle;
+    opt["color_mix_count"]    = options.color_mix_count;
+    opt["active_slot"]        = options.active_slot;
+    opt["panel_mode"]         = options.panel_mode;
+
+    nlohmann::json &arr = root["layers"];
+    arr                 = nlohmann::json::array();
+    for (const TextureDisplacementLayer &l : layers) {
+        nlohmann::json j;
+        j["slot"]        = l.slot;
+        j["name"]        = l.name;
+        j["path"]        = l.path;
+        j["path_in_3mf"] = l.path_in_3mf;
+
+        j["depth_mm"]     = l.depth_mm;
+        j["tiling_scale"] = l.tiling_scale;
+        j["rotation_deg"] = l.rotation_deg;
+        j["offset"]       = vec2_to_json(l.offset);
+        j["invert"]       = l.invert;
+        j["midlevel"]     = l.midlevel;
+        j["smoothing"]    = l.smoothing;
+
+        j["edge_smoothing"]        = l.edge_smoothing;
+        j["edge_smoothing_amount"] = l.edge_smoothing_amount;
+        j["auto_connect_islands"]  = l.auto_connect_islands;
+
+        j["tile_enabled"]      = l.tile_enabled;
+        j["tile_method"]       = int(l.tile_method);
+        j["projection_method"] = int(l.projection_method);
+        j["blend_mode"]        = int(l.blend_mode);
+        j["color_enabled"]     = l.color_enabled;
+
+        j["lscm_seam_angle_deg"] = l.lscm_seam_angle_deg;
+        j["island_padding_mm"]   = l.island_padding_mm;
+
+        j["view_project_right"]      = vec3_to_json(l.view_project_right);
+        j["view_project_up"]         = vec3_to_json(l.view_project_up);
+        j["view_project_projective"] = l.view_project_projective;
+        j["view_project_matrix"]     = l.view_project_matrix;
+
+        // Flat pairs rather than nested arrays: shorter, and the reader can simply ignore a trailing
+        // odd element instead of having to validate every sub-array.
+        nlohmann::json &seams = j["lscm_seam_edges"];
+        seams                 = nlohmann::json::array();
+        for (const auto &[a, b] : l.lscm_seam_edges) {
+            seams.push_back(a);
+            seams.push_back(b);
+        }
+
+        nlohmann::json &islands = j["islands"];
+        islands                 = nlohmann::json::array();
+        for (const TextureIsland &island : l.islands)
+            islands.push_back(nlohmann::json::array(
+                { island.offset.x(), island.offset.y(), island.rotation_deg, island.scale }));
+
+        j["island_groups"] = l.island_groups;
+
+        nlohmann::json &overrides = j["lscm_uv_overrides"];
+        overrides                 = nlohmann::json::array();
+        for (const auto &[key, uv] : l.lscm_uv_overrides)
+            overrides.push_back(nlohmann::json::array({ key, uv.x(), uv.y() }));
+
+        arr.push_back(std::move(j));
+    }
+    return root.dump();
+}
+
+bool texture_displacement_layers_from_json(const std::string                     &text,
+                                           std::vector<TextureDisplacementLayer> &layers,
+                                           TextureDisplacementOptions            &options)
+{
+    nlohmann::json root;
+    try {
+        root = nlohmann::json::parse(text);
+    } catch (...) {
+        return false;
+    }
+    if (!root.is_object())
+        return false;
+
+    TextureDisplacementOptions out_options;
+    if (const auto it = root.find("options"); it != root.end() && it->is_object()) {
+        const nlohmann::json &opt = *it;
+        read(opt, "displace_border", out_options.displace_border);
+        read(opt, "smooth_enabled", out_options.smooth_enabled);
+        read(opt, "smooth_strength", out_options.smooth_strength);
+        read(opt, "smooth_iterations", out_options.smooth_iterations);
+        read(opt, "smooth_skip_border", out_options.smooth_skip_border);
+        read(opt, "pipeline_v2", out_options.pipeline_v2);
+        read(opt, "v2_refine_mm", out_options.v2_refine_mm);
+        read(opt, "v2_regularize", out_options.v2_regularize);
+        read(opt, "v2_max_triangles_k", out_options.v2_max_triangles_k);
+        read(opt, "v2_relocate", out_options.v2_relocate);
+        read(opt, "v2_flip_edges", out_options.v2_flip_edges);
+        read(opt, "color_mix_enabled", out_options.color_mix_enabled);
+        read(opt, "color_despeckle", out_options.color_despeckle);
+        read(opt, "color_mix_count", out_options.color_mix_count);
+        read(opt, "active_slot", out_options.active_slot);
+        read(opt, "panel_mode", out_options.panel_mode);
+        out_options.active_slot = std::clamp(out_options.active_slot, 0, int(TEXTURE_DISPLACEMENT_MAX_LAYERS) - 1);
+        out_options.panel_mode  = std::clamp(out_options.panel_mode, 0, 1);
+    }
+
+    std::vector<TextureDisplacementLayer> out_layers;
+    // read() skips a value of the wrong type, but the vector, matrix, seam, island and UV-override arrays
+    // below read their numbers with get<>(), which throws on one; that rejects the document, like text that
+    // does not parse.
+    try {
+        if (const auto it = root.find("layers"); it != root.end() && it->is_array()) {
+            for (const nlohmann::json &j : *it) {
+                if (!j.is_object())
+                    continue;
+                TextureDisplacementLayer l;
+                read(j, "slot", l.slot);
+                // The panel and the paint masks are indexed by slot, so a layer without a valid one rejects the
+                // document rather than reaching them.
+                if (l.slot < 0 || l.slot >= int(TEXTURE_DISPLACEMENT_MAX_LAYERS))
+                    return false;
+                read(j, "name", l.name);
+                read(j, "path", l.path);
+                read(j, "path_in_3mf", l.path_in_3mf);
+
+                read(j, "depth_mm", l.depth_mm);
+                read(j, "tiling_scale", l.tiling_scale);
+                read(j, "rotation_deg", l.rotation_deg);
+                if (const auto o = j.find("offset"); o != j.end())
+                    l.offset = vec2_from_json(*o, l.offset);
+                read(j, "invert", l.invert);
+                read(j, "midlevel", l.midlevel);
+                read(j, "smoothing", l.smoothing);
+
+                read(j, "edge_smoothing", l.edge_smoothing);
+                read(j, "edge_smoothing_amount", l.edge_smoothing_amount);
+                read(j, "auto_connect_islands", l.auto_connect_islands);
+
+                read(j, "tile_enabled", l.tile_enabled);
+                read(j, "color_enabled", l.color_enabled);
+                int tile_method = int(l.tile_method), projection = int(l.projection_method), blend = int(l.blend_mode);
+                read_enum(j, "tile_method", tile_method);
+                read_enum(j, "projection_method", projection);
+                read_enum(j, "blend_mode", blend);
+                l.tile_method       = TextureTileMethod(tile_method);
+                l.projection_method = TextureProjectionMethod(std::clamp(projection, 0, 4));
+                l.blend_mode        = TextureBlendMode(blend);
+
+                read(j, "lscm_seam_angle_deg", l.lscm_seam_angle_deg);
+                read(j, "island_padding_mm", l.island_padding_mm);
+
+                if (const auto v = j.find("view_project_right"); v != j.end())
+                    l.view_project_right = vec3_from_json(*v, l.view_project_right);
+                if (const auto v = j.find("view_project_up"); v != j.end())
+                    l.view_project_up = vec3_from_json(*v, l.view_project_up);
+                read(j, "view_project_projective", l.view_project_projective);
+                if (const auto v = j.find("view_project_matrix"); v != j.end() && v->is_array() && v->size() == 12)
+                    for (size_t i = 0; i < 12; ++i)
+                        l.view_project_matrix[i] = (*v)[i].get<float>();
+
+                if (const auto v = j.find("lscm_seam_edges"); v != j.end() && v->is_array())
+                    for (size_t i = 0; i + 1 < v->size(); i += 2)
+                        l.lscm_seam_edges.emplace_back((*v)[i].get<int>(), (*v)[i + 1].get<int>());
+
+                if (const auto v = j.find("islands"); v != j.end() && v->is_array())
+                    for (const nlohmann::json &e : *v) {
+                        if (!e.is_array() || e.size() != 4)
+                            continue;
+                        TextureIsland island;
+                        island.offset       = Vec2f(e[0].get<float>(), e[1].get<float>());
+                        island.rotation_deg = e[2].get<float>();
+                        island.scale        = e[3].get<float>();
+                        l.islands.push_back(island);
+                    }
+
+                read(j, "island_groups", l.island_groups);
+
+                if (const auto v = j.find("lscm_uv_overrides"); v != j.end() && v->is_array())
+                    for (const nlohmann::json &e : *v) {
+                        if (!e.is_array() || e.size() != 3)
+                            continue;
+                        l.lscm_uv_overrides.emplace_back(e[0].get<int>(), Vec2f(e[1].get<float>(), e[2].get<float>()));
+                    }
+
+                out_layers.push_back(std::move(l));
+            }
+        }
+    } catch (const nlohmann::json::exception &) {
+        return false;
+    }
+
+    layers  = std::move(out_layers);
+    options = out_options;
+    return true;
+}
 
 } // namespace Slic3r

src/libslic3r/TextureDisplacement.hpp

@@ -18,7 +18,6 @@
 
 #include <array>
 
-#include "ChromaStack.hpp"
 #include "Point.hpp"
 #include "TriangleSelector.hpp"
 
@@ -294,33 +293,16 @@ struct TextureDisplacementLayer
     // for the boundary to be drawn on.
     bool color_enabled = false;
 
-    // ChromaStack (see ChromaStack.hpp): when set, `image_data` is not a texture the user picked but the
-    // height map chroma_solve() computed, so that the whole displacement pipeline - preview, UV
-    // editor, bake - goes on reading one grayscale height map and needs to know nothing about colour
-    // stacks. The picture it was solved from is kept here instead, because the solve has to be redone
-    // whenever the stack, the print's layer height or the picture itself changes.
-    //
-    // A ChromaStack layer gets its colour from filament swaps at fixed Z, which is what `chroma`
-    // records and what the object's height ranges carry out. That is a different mechanism from
-    // `color_enabled` (per-triangle filament assignment), and the two are mutually exclusive: the
-    // panel turns colour off on a ChromaStack layer, since painting the relief in one filament per
-    // triangle would hide the very stack the heights were solved against.
-    bool                                        chroma_enabled = false;
-    ChromaStack                               chroma;
-    std::shared_ptr<std::vector<unsigned char>> chroma_source;
-
     bool empty() const { return !image_data || image_data->empty(); }
 
     template<class Archive> void save(Archive &ar) const
     {
         std::string blob = image_data ? std::string(image_data->begin(), image_data->end()) : std::string();
-        std::string source = chroma_source ? std::string(chroma_source->begin(), chroma_source->end()) : std::string();
         ar(slot, name, path, path_in_3mf, blob, depth_mm, tiling_scale, rotation_deg, offset, invert, tile_enabled,
            static_cast<int>(tile_method), static_cast<int>(projection_method), lscm_seam_angle_deg, islands,
            static_cast<int>(blend_mode), midlevel, island_padding_mm, lscm_seam_edges, view_project_right,
            view_project_up, smoothing, edge_smoothing, edge_smoothing_amount, auto_connect_islands, island_groups,
-           lscm_uv_overrides, view_project_projective, view_project_matrix, color_enabled, chroma_enabled, chroma,
-           source);
+           lscm_uv_overrides, view_project_projective, view_project_matrix, color_enabled);
     }
     template<class Archive> void load(Archive &ar)
     {
@@ -328,14 +310,12 @@ struct TextureDisplacementLayer
         int         tile_method_int       = 0;
         int         projection_method_int = 0;
         int         blend_mode_int        = 0;
-        std::string source;
         ar(slot, name, path, path_in_3mf, blob, depth_mm, tiling_scale, rotation_deg, offset, invert, tile_enabled,
            tile_method_int, projection_method_int, lscm_seam_angle_deg, islands, blend_mode_int, midlevel,
            island_padding_mm, lscm_seam_edges, view_project_right, view_project_up, smoothing, edge_smoothing,
            edge_smoothing_amount, auto_connect_islands, island_groups, lscm_uv_overrides, view_project_projective,
-           view_project_matrix, color_enabled, chroma_enabled, chroma, source);
+           view_project_matrix, color_enabled);
         image_data        = blob.empty() ? nullptr : std::make_shared<std::vector<unsigned char>>(blob.begin(), blob.end());
-        chroma_source   = source.empty() ? nullptr : std::make_shared<std::vector<unsigned char>>(source.begin(), source.end());
         tile_method       = static_cast<TextureTileMethod>(tile_method_int);
         projection_method = static_cast<TextureProjectionMethod>(projection_method_int);
         blend_mode        = static_cast<TextureBlendMode>(blend_mode_int);
@@ -417,14 +397,41 @@ struct TextureDisplacementOptions
     // finer than the mesh leaves behind, without eating features that are genuinely a facet wide.
     int          color_despeckle   = 2;
 
+    // Where the panel was left, rather than anything the bake reads. It lives with the volume because
+    // that is what it describes: reopening a project should put the user back on the layer they were
+    // editing, in the mode they were editing it in, not on slot 0 in Standard.
+    int active_slot = 0;
+    int panel_mode  = 0; // 0 Standard, 1 Pro
+
     template<class Archive> void serialize(Archive &ar)
     {
         ar(displace_border, smooth_enabled, smooth_strength, smooth_iterations, smooth_skip_border,
            pipeline_v2, v2_refine_mm, v2_regularize, v2_max_triangles_k,
-           v2_relocate, color_mix_enabled, color_despeckle, color_mix_count);
+           v2_relocate, v2_flip_edges, color_mix_enabled, color_despeckle, color_mix_count,
+           active_slot, panel_mode);
     }
 };
 
+// Project persistence (see bbs_3mf.cpp). The layer stack and the per-volume options are written to the
+// .3mf as JSON rather than through the cereal save()/load() above: those two are positional and
+// unversioned, which is right for the undo/redo stack they serve (one session, one binary) but would
+// make every future field a project-breaking change. A JSON object tolerates both directions - an
+// unknown key is ignored, a missing one keeps the member's default - so old projects keep loading and
+// new ones degrade gracefully in older builds.
+//
+// The texture image itself is *not* in here. It is a binary blob that belongs in the archive as a file
+// of its own, exactly as EmbossShape stores its SVG; `path_in_3mf` names that file, and the caller is
+// responsible for writing it and for filling `image_data` back in on load.
+std::string texture_displacement_layers_to_json(const std::vector<TextureDisplacementLayer> &layers,
+                                                const TextureDisplacementOptions            &options);
+// Returns false and leaves both outputs untouched when the text is not a valid JSON object, a number in a
+// layer's vector, matrix, seam, island or UV-override array has the wrong type, or a layer's slot is
+// missing or outside [0, TEXTURE_DISPLACEMENT_MAX_LAYERS). Any other value of the wrong type or shape
+// keeps its default.
+bool texture_displacement_layers_from_json(const std::string                      &text,
+                                           std::vector<TextureDisplacementLayer>  &layers,
+                                           TextureDisplacementOptions             &options);
+
 // How much detail a height texture carries: central differences of the grey image, the mean gradient
 // and the share of texels steeper than 30 grey levels, mapped to how many texels one mesh edge may
 // span (1 for a hard-edged image, 4 for a smooth one). Cached per image, like the decode.

src/libslic3r/TextureToColor/TextureToColor.cpp

@@ -673,14 +673,14 @@ static bool repair_cluster_smooth(
                     [&]() { return cancelled(); }, &repair_error);
                 if (repaired) {
                     if (cancelled()) return false;
-                    BOOST_LOG_TRIVIAL(info) << log_prefix << ": Windows 3D mesh repair finished.";
+                    BOOST_LOG_TRIVIAL(info) << log_prefix << ": mesh repair finished.";
                     if (!resample_face_colors(TriMesh(std::move(repaired_its))))
                         return false;
                 } else {
-                    BOOST_LOG_TRIVIAL(warning) << log_prefix << ": Windows 3D mesh repair failed: " << repair_error;
+                    BOOST_LOG_TRIVIAL(warning) << log_prefix << ": mesh repair failed: " << repair_error;
                 }
             } else {
-                BOOST_LOG_TRIVIAL(info) << log_prefix << ": importing mesh without Windows 3D repair.";
+                BOOST_LOG_TRIVIAL(info) << log_prefix << ": importing mesh without repair.";
             }
         }
     }

src/libslic3r/TriangleMeshDeal.hpp

@@ -1,5 +1,4 @@
-#ifndef libslic3r_Timer_hpp_
-#define libslic3r_Timer_hpp_
+#pragma once
 
 #include "TriangleMesh.hpp"
 
@@ -10,5 +9,3 @@ public:
     static TriangleMesh smooth_triangle_mesh(const TriangleMesh &mesh,bool& ok);
 };
 } // namespace Slic3r
-
-#endif // libslic3r_Timer_hpp_

src/libslic3r/Utils.hpp

@@ -109,7 +109,6 @@ extern std::string format_memsize_MB(size_t n);
 extern std::string format_memsize(size_t bytes, unsigned int decimals = 1);
 // Return string to be added to the boost::log output to inform about the current process memory allocation.
 // The string is non-empty if the loglevel >= info (3) or ignore_loglevel==true.
-// Latter is used to get the memory info from SysInfoDialog.
 extern std::string log_memory_info(bool ignore_loglevel = false);
 extern void disable_multi_threading();
 // Returns the size of physical memory (RAM) in bytes.

src/libslic3r/utils.cpp

@@ -1744,9 +1744,7 @@ std::string format_diameter_to_str(double diameter, int precision)
     return oss.str();
 }
 
-// Returns platform-specific string to be used as log output or parsed in SysInfoDialog.
-// The latter parses the string with (semi)colons as separators, it should look about as
-// "desc1: value1; desc2: value2" or similar (spaces should not matter).
+// Returns platform-specific string to be used as log output.
 std::string log_memory_info(bool ignore_loglevel)
 {
     std::string out;

src/libvgcode/src/SegmentTemplate.cpp

@@ -21,7 +21,9 @@ namespace libvgcode {
 // the triangles that share it: the shader runs 8 times per segment instead of 24.
 static constexpr const std::array<uint8_t, 8> VERTEX_DATA = { 0, 1, 2, 3, 4, 5, 6, 7 };
 
-static constexpr const std::array<uint8_t, 24> INDEX_DATA = {
+// 16-bit indices: GCN 1/2 GPUs have no 8-bit index support, and some of their drivers
+// emulate it wrongly in instanced draws.
+static constexpr const std::array<uint16_t, 24> INDEX_DATA = {
     0, 1, 2, // front spike
     0, 2, 3, // front spike
     0, 3, 4, // right/bottom body 
@@ -37,7 +39,7 @@ void SegmentTemplate::init()
     if (m_vao_id != 0)
         return;
 
-    m_size_in_bytes_gpu += (VERTEX_DATA.size() + INDEX_DATA.size()) * sizeof(uint8_t);
+    m_size_in_bytes_gpu += VERTEX_DATA.size() * sizeof(uint8_t) + INDEX_DATA.size() * sizeof(uint16_t);
 
     int curr_vertex_array;
     glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
@@ -61,7 +63,7 @@ void SegmentTemplate::init()
     // and restored together with the vao.
     glsafe(glGenBuffers(1, &m_ibo_id));
     glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id));
-    glsafe(glBufferData(GL_ELEMENT_ARRAY_BUFFER, INDEX_DATA.size() * sizeof(uint8_t), INDEX_DATA.data(), GL_STATIC_DRAW));
+    glsafe(glBufferData(GL_ELEMENT_ARRAY_BUFFER, INDEX_DATA.size() * sizeof(uint16_t), INDEX_DATA.data(), GL_STATIC_DRAW));
 
     glsafe(glBindBuffer(GL_ARRAY_BUFFER, curr_array_buffer));
     glsafe(glBindVertexArray(curr_vertex_array));
@@ -94,7 +96,7 @@ void SegmentTemplate::render(size_t count)
     glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
 
     glsafe(glBindVertexArray(m_vao_id));
-    glsafe(glDrawElementsInstanced(GL_TRIANGLES, static_cast<GLsizei>(INDEX_DATA.size()), GL_UNSIGNED_BYTE,
+    glsafe(glDrawElementsInstanced(GL_TRIANGLES, static_cast<GLsizei>(INDEX_DATA.size()), GL_UNSIGNED_SHORT,
                                    nullptr, static_cast<GLsizei>(count)));
     glsafe(glBindVertexArray(curr_vertex_array));
 }

src/libvgcode/src/ViewerImpl.cpp

@@ -927,15 +927,17 @@ void ViewerImpl::reset()
     m_used_extruders.clear();
     m_total_time = { 0.0f, 0.0f };
     m_travels_time = { 0.0f, 0.0f };
-    m_vertices.clear();
-    m_vertices_colors.clear();
     // swap rather than clear: these are sized by the print, and a reset means the memory
     // should go back, not sit reserved until the next load
+    std::vector<PathVertex>().swap(m_vertices);
+    std::vector<float>().swap(m_vertices_colors);
     for (std::vector<float>& times : m_layer_start_times)
         std::vector<float>().swap(times);
     std::vector<uint32_t>().swap(m_layer_first_vertex);
     m_layers_in_vertex_order = false;
-    m_valid_lines_bitset.clear();
+    // BitSet::clear() only zeroes the bits, it keeps the blocks allocated; load() builds a new
+    // bitset anyway and it is never read while m_vertices is empty
+    m_valid_lines_bitset = BitSet<>();
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
     m_cog_marker.reset();
 #endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
@@ -1834,6 +1836,7 @@ size_t ViewerImpl::get_used_cpu_memory() const
     ret += sizeof(m_extrusion_roles_colors);
     ret += sizeof(m_options_colors);
     ret += STDVEC_MEMSIZE(m_vertices, PathVertex);
+    ret += STDVEC_MEMSIZE(m_vertices_colors, float);
     for (const std::vector<float>& times : m_layer_start_times)
         ret += STDVEC_MEMSIZE(times, float);
     ret += STDVEC_MEMSIZE(m_layer_first_vertex, uint32_t);

src/slic3r/CMakeLists.txt

@@ -416,8 +416,6 @@ set(SLIC3R_GUI_SOURCES
     GUI/MultiSendMachineModel.hpp
     GUI/MultiTaskManagerPage.cpp
     GUI/MultiTaskManagerPage.hpp
-    GUI/MultiTaskModel.cpp
-    GUI/MultiTaskModel.hpp
     GUI/NetworkTestDialog.cpp
     GUI/NetworkTestDialog.hpp
     GUI/Notebook.cpp
@@ -802,7 +800,6 @@ set(SLIC3R_GUI_SOURCES
     Utils/PrintHost.hpp
     Utils/Process.cpp
     Utils/Process.hpp
-    Utils/Profile.hpp
     Utils/RaycastManager.cpp
     Utils/RaycastManager.hpp
     Utils/Repetier.cpp

src/slic3r/GUI/CloneDialog.hpp

@@ -1,5 +1,4 @@
-#ifndef slic3r_GUI_SingleChoice_hpp_
-#define slic3r_GUI_SingleChoice_hpp_
+#pragma once
 
 #include "GUI_Utils.hpp"
 #include "Plater.hpp"
@@ -33,5 +32,3 @@ private:
 
 };
 }} // namespace Slic3r::GUI
-
-#endif

src/slic3r/GUI/ConfigExceptions.hpp

@@ -1,19 +0,0 @@
-#include <exception> 
-#include <stdexcept>
-
-#include "libslic3r/Exception.hpp"
-
-namespace Slic3r {
-
-class ConfigError : public Slic3r::RuntimeError { 
-	using Slic3r::RuntimeError::RuntimeError;
-};
-
-namespace GUI {
-
-class ConfigGUITypeError : public ConfigError { 
-	using ConfigError::ConfigError;
-};
-
-} // namespace GUI
-} // namespace Slic3r

src/slic3r/GUI/ConfigManipulation.cpp

@@ -1105,6 +1105,10 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, in
     toggle_field("support_filament", have_support_material || have_skirt);
 
     toggle_line("raft_contact_distance", have_raft && !have_support_soluble);
+    // Orca:Hide raft expansion when raft is not enabled
+    toggle_line("raft_expansion", have_raft);
+    // Orca: Slim, Strong and Hybrid tree supports size their raft by first layer expansion only.
+    toggle_field("raft_expansion", !(is_tree(support_type) && (support_style == smsTreeSlim || support_style == smsTreeStrong || support_style == smsTreeHybrid)));
 
     // Orca: First-layer density is available for supports broadly.
     toggle_field("raft_first_layer_density", have_support_material);

src/slic3r/GUI/DeviceCore/DevFilaSystem.cpp

@@ -8,6 +8,7 @@
 #include <cstdlib>
 #include <chrono>
 #include <nlohmann/json.hpp>
+#include <wx/app.h>
 #include <wx/colour.h>
 #include <string>
 #include <wx/string.h>
@@ -33,6 +34,36 @@
 using namespace nlohmann;
 
 namespace Slic3r {
+
+bool devPrinterUtil::IsVirtualSlot(int ams_id)
+{
+    // When the app or preset bundle is unavailable we cannot know the vendor's
+    // extruder count, so fall back deterministically to the fixed Bambu pair
+    // {255, 254} rather than guessing from an unknown generic layout.
+    if (wxTheApp == nullptr || GUI::wxGetApp().preset_bundle == nullptr || GUI::wxGetApp().preset_bundle->is_bbl_vendor())
+        return ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID;
+
+    const int extruder_count = GUI::wxGetApp().preset_bundle->get_printer_extruder_count();
+    return ams_id >= VIRTUAL_TRAY_MAIN_ID - extruder_count + 1 && ams_id <= VIRTUAL_TRAY_MAIN_ID;
+}
+
+bool devPrinterUtil::IsVirtualSlot(const std::string& ams_id)
+{
+    // Strict: only a fully numeric string is a valid slot id. std::stoi alone
+    // would accept trailing garbage (e.g. "255abc" -> 255).
+    if (ams_id.empty())
+        return false;
+    for (char c : ams_id) {
+        if (c < '0' || c > '9')
+            return false;
+    }
+    try {
+        return IsVirtualSlot(std::stoi(ams_id));
+    } catch (...) {
+        return false;
+    }
+}
+
 static int _hex_digit_to_int(const char c) { return (c >= '0' && c <= '9') ? c - '0' : (c >= 'A' && c <= 'F') ? c - 'A' + 10 : (c >= 'a' && c <= 'f') ? c - 'a' + 10 : -1; }
 
 wxColour DevAmsTray::decode_color(const std::string &color)
@@ -200,18 +231,22 @@ wxString DevAms::GetDisplayName() const
 
 int DevAms::GetSlotCount() const
 {
-    // GetAmsType() maps AMS_LITE_MIXED -> AMS_LITE, so N9 reports 4 slots like AMS-Lite.
-    auto ams_type = GetAmsType();
-    if (ams_type == AMS || ams_type == AMS_LITE || ams_type == N3F)
-    {
-        return 4;
-    }
-    else if (ams_type == N3S)
-    {
+    // N3S is a 1-slot Bambu contract, so report 1 regardless of whether the
+    // preset bundle is momentarily unavailable (m_trays.size() can be 0).
+    if (GetAmsType() == N3S)
         return 1;
+
+    if (wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr &&
+        GUI::wxGetApp().preset_bundle->is_bbl_vendor()) {
+        // GetAmsType() maps AMS_LITE_MIXED -> AMS_LITE, so N9 reports 4 slots like AMS-Lite.
+        auto ams_type = GetAmsType();
+        if (ams_type == AMS || ams_type == AMS_LITE || ams_type == N3F)
+        {
+            return 4;
+        }
     }
 
-    return 1;
+    return static_cast<int>(m_trays.size());
 }
 
 DevAmsTray* DevAms::GetTray(const std::string& tray_id) const
@@ -302,13 +337,21 @@ int DevFilaSystem::GetExtruderIdByAmsId(const std::string& ams_id) const
     {
         return it->second->GetExtruderId();
     }
-    else if (stoi(ams_id) == VIRTUAL_TRAY_MAIN_ID)
-    {
-        return MAIN_EXTRUDER_ID;
+
+    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
+    if (!is_bbl_vendor && GetOwner()) {
+        for (const auto& tray : GetOwner()->vt_slot) {
+            if (tray.id == ams_id)
+                return VIRTUAL_TRAY_MAIN_ID - std::stoi(ams_id);
+        }
     }
-    else if (stoi(ams_id) == VIRTUAL_TRAY_DEPUTY_ID)
-    {
+
+    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_MAIN_ID_STR)
+        return MAIN_EXTRUDER_ID;
+    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_DEPUTY_ID_STR)
         return DEPUTY_EXTRUDER_ID;
+    if (!is_bbl_vendor && devPrinterUtil::IsVirtualSlot(ams_id)) {
+        return VIRTUAL_TRAY_MAIN_ID - std::stoi(ams_id);
     }
 
     assert(false && __FUNCTION__);
@@ -325,9 +368,22 @@ std::string DevFilaSystem::GetNozzleFlowStringByAmsId(const std::string& ams_id)
 std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
 {
     std::map<int, DevAmsSlotId> tray_id_map;
-    tray_id_map[VIRTUAL_TRAY_MAIN_ID]   = DevAmsSlotId{VIRTUAL_TRAY_MAIN_ID, 0};
-    tray_id_map[VIRTUAL_TRAY_DEPUTY_ID] = DevAmsSlotId{VIRTUAL_TRAY_DEPUTY_ID, 0};
+    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
+    if (is_bbl_vendor) {
+        tray_id_map[VIRTUAL_TRAY_MAIN_ID]   = DevAmsSlotId{VIRTUAL_TRAY_MAIN_ID, 0};
+        tray_id_map[VIRTUAL_TRAY_DEPUTY_ID] = DevAmsSlotId{VIRTUAL_TRAY_DEPUTY_ID, 0};
+    } else if (GetOwner()) {
+        for (const auto& tray : GetOwner()->vt_slot) {
+            try {
+                const int tray_id = std::stoi(tray.id);
+                tray_id_map[tray_id] = DevAmsSlotId{tray_id, 0};
+            } catch (...) {
+                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " invalid virtual tray id: " << tray.id;
+            }
+        }
+    }
 
+    int generic_tray_index = 0;
     for (auto& [ams_id, ams_item] : GetAmsList()) {
         for (auto &[slot_id, slot_item] : ams_item->GetTrays()) {
             if (ams_item && slot_item) {
@@ -335,9 +391,11 @@ std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
                     int ams_id_int  = stoi(ams_id);
                     int slot_id_int = stoi(slot_id);
                     int tray_index  = -1;
-                    if (ams_item->GetAmsType() == DevAms::N3S) {
+                    if (!is_bbl_vendor) {
+                        tray_index = generic_tray_index + slot_id_int;
+                    } else if (ams_item->GetAmsType() == DevAms::N3S) {
                         tray_index = ams_id_int;
-                    } else if(ams_item->GetAmsType() == DevAms::AMS_LITE && ams_item->IsAmsLiteMixed()) {
+                    } else if (ams_item->GetAmsType() == DevAms::AMS_LITE && ams_item->IsAmsLiteMixed()) {
                         tray_index = 24 + slot_id_int;
                     } else {
                         tray_index = (ams_id_int * 4 + slot_id_int);
@@ -348,6 +406,8 @@ std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
                 }
             }
         }
+        if (!is_bbl_vendor)
+            generic_tray_index += static_cast<int>(ams_item->GetTrays().size());
     }
 
     return  tray_id_map;
@@ -456,6 +516,13 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                     ams_id_set.insert(it->first);
                 }
 
+                // Bambu trays index their exist bit as ams_id*4+tray_id; a generic (non-Bambu) unit
+                // reports its own lane count, so its trays carry a cumulative lane index instead.
+                // Same index DevFilaSystem::GetTrayIndexMap() builds and the agent sets bits with.
+                const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr &&
+                                           GUI::wxGetApp().preset_bundle->is_bbl_vendor();
+                int generic_tray_base = 0;
+
                 for (auto it = j_ams.begin(); it != j_ams.end(); it++)
                 {
                     if (!it->contains("id")) continue;
@@ -795,7 +862,18 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
 
                                     if (type_id < 4)
                                     {
-                                        curr_tray->is_exists = (obj->tray_exist_bits & (1 << (ams_id_int * 4 + tray_id_int))) != 0 ? true : false;
+                                        if (is_bbl_vendor)
+                                        {
+                                            curr_tray->is_exists = (obj->tray_exist_bits & (1 << (ams_id_int * 4 + tray_id_int))) != 0 ? true : false;
+                                        }
+                                        else
+                                        {
+                                            // A generic unit is not four slots wide, so its trays carry a
+                                            // cumulative lane index across units instead of ams_id*4+tray_id.
+                                            const int tray_bit = generic_tray_base + tray_id_int;
+                                            curr_tray->is_exists = tray_bit >= 0 && tray_bit < 32 &&
+                                                                   (obj->tray_exist_bits & (1UL << tray_bit)) != 0;
+                                        }
                                     }
                                     else if (type_id == DevAms::AMS_LITE_MIXED)
                                     {
@@ -851,6 +929,9 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                             }
                         }
                     }
+                    if (!is_bbl_vendor && it->contains("tray") && (*it)["tray"].is_array()) {
+                        generic_tray_base += static_cast<int>((*it)["tray"].size());
+                    }
                 }
                 // remove not in amsList
                 for (auto it = ams_id_set.begin(); it != ams_id_set.end(); it++)
@@ -913,6 +994,8 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
             }
 
             ams->m_exist               = true;
+            ams->m_binded_extruder_set = {ext_id};
+            ams->m_binded_switcher_pos.reset();
             ams->m_current_temperature = u.value("temperature", (float) INVALID_AMS_TEMPERATURE);
             ams->m_humidity_percent    = u.value("humidity_percent", -1);
             ams->m_left_dry_time       = u.value("dry_time_min", 0);
@@ -995,16 +1078,22 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
     }
 
     // --- external / direct spools -> obj->vt_slot ---
-    // extruder 0 -> main virtual slot, extruder >0 -> deputy.
+    // Keep one virtual slot per extruder. The legacy two-extruder mapping uses
+    // 255 for extruder 0 and 254 for extruder 1; continue that sequence for
+    // additional extruders (253, 252, ...).
     if (obj && data.contains("external") && data["external"].is_array())
     {
+        std::map<int, DevAmsTray> external_slots;
         obj->vt_slot.clear();
         for (const auto& e : data["external"])
         {
             if (!e.is_object())
                 continue;
             const int  ext   = e.value("extruder", MAIN_EXTRUDER_ID);
-            const int  vt_id = (ext == MAIN_EXTRUDER_ID) ? VIRTUAL_TRAY_MAIN_ID : VIRTUAL_TRAY_DEPUTY_ID;
+            if (ext < MAIN_EXTRUDER_ID || ext >= VIRTUAL_TRAY_MAIN_ID)
+                continue;
+
+            const int  vt_id = VIRTUAL_TRAY_MAIN_ID - ext;
             DevAmsTray tray(std::to_string(vt_id));
             tray.is_exists       = e.value("loaded", false);
             tray.m_fila_type     = e.value("material", std::string());
@@ -1013,8 +1102,11 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
             tray.nozzle_temp_min = std::to_string(e.value("nozzle_temp_min", 0));
             tray.nozzle_temp_max = std::to_string(e.value("nozzle_temp_max", 0));
             tray.remain          = e.value("remain_percent", -1);
-            obj->vt_slot.push_back(tray);
+            external_slots.insert_or_assign(ext, std::move(tray));
         }
+
+        for (auto& entry : external_slots)
+            obj->vt_slot.push_back(std::move(entry.second));
     }
 }
 

src/slic3r/GUI/GLCanvas3D.cpp

@@ -1514,6 +1514,8 @@ wxDEFINE_EVENT(EVT_GLCANVAS_PRINTABLE, SimpleEvent);
 const double GLCanvas3D::DefaultCameraZoomToBoxMarginFactor = 1.25;
 const double GLCanvas3D::DefaultCameraZoomToBedMarginFactor = 2.00;
 const double GLCanvas3D::DefaultCameraZoomToPlateMarginFactor = 1.25;
+// Main-thread only: _render_frame never runs off it, so no atomic is needed.
+int GLCanvas3D::s_frames_in_progress = 0;
 
 void GLCanvas3D::load_arrange_settings()
 {
@@ -2468,7 +2470,8 @@ void GLCanvas3D::_render_frame(bool scene_dirty, bool only_init)
     }
 
     m_in_render = true;
-    Slic3r::ScopeGuard in_render_guard([this]() { m_in_render = false; });
+    ++s_frames_in_progress;
+    Slic3r::ScopeGuard in_render_guard([this]() { m_in_render = false; --s_frames_in_progress; });
     (void)in_render_guard;
 
     if (m_canvas == nullptr)
@@ -2713,15 +2716,31 @@ void GLCanvas3D::_render_frame(bool scene_dirty, bool only_init)
 
     // On Wayland, eglSwapBuffers blocks when the canvas is hidden or
     // occluded. Skip the swap to avoid stalling the render loop.
-    if (m_canvas->IsShownOnScreen()) {
+    // Code run from inside this frame - a modal dialog a gizmo opened from its ImGui panel, a
+    // synchronous paint of another canvas - may have made a different surface current. Bind this one
+    // again before presenting, so the swap is not issued against a window the context no longer
+    // belongs to: on Mesa/X11 that is a fatal BadMatch, not the no-op it is on other platforms. Draws
+    // already issued before this point cannot be redirected - only this swap is protected.
+    if (m_canvas->IsShownOnScreen() && _set_current()) {
         m_canvas->SwapBuffers();
         m_frame_profiler.mark("swap");
         if (!overlay_tick)
             m_render_stats.increment_fps_counter();
         m_presented_signature = signature;
     }
-    else
+    else {
+        if (m_canvas->IsShownOnScreen()) {
+            // Logged once: if the rebind fails it does so every frame, and a warning per frame would
+            // bury everything else.
+            static bool rebind_failure_logged = false;
+            if (!rebind_failure_logged) {
+                rebind_failure_logged = true;
+                BOOST_LOG_TRIVIAL(warning) << "GLCanvas3D: could not rebind the GL context to this canvas before "
+                                              "SwapBuffers(); the frame is not presented";
+            }
+        }
         m_presented_signature.reset();
+    }
 }
 
 // Everything drawn into the 3D scene, from the clear to the post processing passes, ending in the

src/slic3r/GUI/GLCanvas3D.hpp

@@ -643,6 +643,8 @@ private:
 #endif
     unsigned int m_last_w, m_last_h;
     bool m_in_render;
+    // How many canvases are inside _render_frame() right now - see is_frame_in_progress().
+    static int s_frames_in_progress;
     wxTimer m_timer;
     wxTimer m_timer_set_color;
     // Armed by each frame that draws the FPS overlay; its tick requests an overlay-only frame.
@@ -974,6 +976,11 @@ public:
     void on_change_color_mode(bool is_dark, bool reinit = true);
     const bool get_dark_mode_status() { return m_is_dark; }
     void set_as_dirty() { m_dirty = true; }
+    // True while any GLCanvas3D is inside _render_frame(). The other surfaces that share the app's one
+    // GL context (the UV editor canvas) check this before making themselves current: a frame interrupted
+    // by another surface finishes drawing into that surface and then presents a window the context no
+    // longer belongs to, which on Mesa/X11 is a fatal X error (BadMatch) rather than a no-op.
+    static bool is_frame_in_progress() { return s_frames_in_progress > 0; }
     void requires_check_outside_state() { m_requires_check_outside_state = true; }
 
     unsigned int get_volumes_count() const { return (unsigned int)m_volumes.volumes.size(); }

src/slic3r/GUI/GLShadersManager.cpp

@@ -114,8 +114,6 @@ std::pair<bool, std::string> GLShadersManager::init()
         valid &= append_shader("mm_gouraud", { prefix + "mm_gouraud.vs", prefix + "mm_gouraud.fs" });
     // Fast shaded preview for the texture displacement gizmo (see libslic3r/TextureDisplacement.hpp).
     valid &= append_shader("texture_displacement_shaded", { prefix + "texture_displacement_shaded.vs", prefix + "texture_displacement_shaded.fs" });
-    // ChromaStack: the printed colours on the model, read per fragment from its own height.
-    valid &= append_shader("chromastack", { prefix + "chromastack.vs", prefix + "chromastack.fs" });
     // UV-check overlay for the same gizmo: a procedural checker or a distortion heatmap over the
     // painted patch, to sanity-check the unwrap.
     valid &= append_shader("texture_displacement_uvcheck", { prefix + "texture_displacement_uvcheck.vs", prefix + "texture_displacement_uvcheck.fs" });

src/slic3r/GUI/GLTexture.cpp

@@ -719,9 +719,6 @@ void GLTexture::render_sub_texture(unsigned int tex_id, float left, float right,
     // does not treat anti-aliased icon edges as window transparency.
     glsafe(::glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 
-    glsafe(::glEnable(GL_TEXTURE_2D));
-    glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE));
-
     glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)tex_id));
 
     GLModel::Geometry init_data;
@@ -753,7 +750,6 @@ void GLTexture::render_sub_texture(unsigned int tex_id, float left, float right,
 
     glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
-    glsafe(::glDisable(GL_TEXTURE_2D));
     glsafe(::glDisable(GL_BLEND));
 }
 

src/slic3r/GUI/GUI_App.cpp

@@ -4862,12 +4862,6 @@ void GUI_App::recreate_GUI(const wxString &msg_name)
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "recreate_GUI exit";
 }
 
-void GUI_App::system_info()
-{
-    //SysInfoDialog dlg;
-    //dlg.ShowModal();
-}
-
 void GUI_App::keyboard_shortcuts(ShortcutContext page, wxWindow* parent)
 {
     KBShortcutsDialog dlg(parent != nullptr ? parent : mainframe, page);

src/slic3r/GUI/GUI_App.hpp

@@ -519,7 +519,6 @@ public:
     void            check_printer_presets();
 
     void            recreate_GUI(const wxString& message);
-    void            system_info();
     void            keyboard_shortcuts(ShortcutContext page, wxWindow* parent = nullptr);   // the main frame when null
     void            troubleshoot();
     void            load_project(wxWindow *parent, wxString& input_file) const;

src/slic3r/GUI/GUI_Factories.cpp

@@ -1952,6 +1952,16 @@ void MenuFactory::create_plate_menu()
         },
         "", nullptr, []() { return !plater()->get_partplate_list().get_selected_plate()->get_objects().empty(); }, m_parent);
 
+    // fix objects on current plate
+    append_menu_item(menu, wxID_ANY, _L("Fix All"), _L("Fix all models on the current plate"),
+        [](wxCommandEvent&) { obj_list()->fix_all_through_cgal(false); }, "", nullptr,
+        []() { return !plater()->get_partplate_list().get_selected_plate()->empty(); }, m_parent);
+
+    // fix objects on all plates
+    append_menu_item(menu, wxID_ANY, _L("Fix All Plates"), _L("Fix all models on all plates"),
+        [](wxCommandEvent&) { obj_list()->fix_all_through_cgal(true); }, "", nullptr,
+        []() { return !plater()->model().objects.empty(); }, m_parent);
+
     // orient objects on current plate
     append_menu_item(menu, wxID_ANY, _L("Auto Rotate"), _L("Auto rotate current plate"),
         [](wxCommandEvent&) {

src/slic3r/GUI/GUI_ObjectList.cpp

@@ -2875,37 +2875,6 @@ void ObjectList::del_layer_from_object(const int obj_idx, const t_layer_height_r
     changed_object(obj_idx);
 }
 
-void ObjectList::rebuild_layer_ranges(const int obj_idx)
-{
-    if (obj_idx < 0 || obj_idx >= int(m_objects->size()))
-        return;
-    const wxDataViewItem obj_item = m_objects_model->GetItemById(obj_idx);
-    if (!obj_item.IsOk())
-        return;
-
-    const t_layer_config_ranges& ranges = object(obj_idx)->layer_config_ranges;
-    // Adding and deleting tree items fires selection events on GTK; suppress them as every other
-    // bulk edit of the tree here does.
-    const bool prevent_events = m_prevent_list_events;
-    m_prevent_list_events = true;
-    wxDataViewItem root = m_objects_model->GetLayerRootItem(obj_item);
-    if (root.IsOk()) {
-        m_objects_model->DeleteChildren(root);
-        if (ranges.empty())
-            m_objects_model->Delete(root);
-        else {
-            for (const auto& range : ranges)
-                add_layer_item(range.first, root);
-            Expand(root);
-        }
-    } else {
-        add_layer_root_item(obj_item);
-    }
-    m_prevent_list_events = prevent_events;
-
-    changed_object(obj_idx);
-}
-
 void ObjectList::del_layers_from_object(const int obj_idx)
 {
     object(obj_idx)->layer_config_ranges.clear();
@@ -6328,30 +6297,44 @@ void ObjectList::rename_item()
 }
 
 void ObjectList::fix_through_cgal()
+{
+    std::vector<int> obj_idxs, vol_idxs;
+    get_selection_indexes(obj_idxs, vol_idxs);
+    fix_through_cgal(obj_idxs, vol_idxs);
+}
+
+void ObjectList::fix_all_through_cgal(bool all_plates)
+{
+    std::vector<int> obj_idxs;
+    if (all_plates) {
+        for (int obj_idx = 0; obj_idx < int(m_objects->size()); ++obj_idx)
+            obj_idxs.push_back(obj_idx);
+    } else {
+        for (const ModelObject *mo : wxGetApp().plater()->get_partplate_list().get_selected_plate()->get_objects_on_this_plate())
+            obj_idxs.push_back(int(std::find(m_objects->begin(), m_objects->end(), mo) - m_objects->begin()));
+        std::sort(obj_idxs.begin(), obj_idxs.end());
+        obj_idxs.erase(std::unique(obj_idxs.begin(), obj_idxs.end()), obj_idxs.end());
+    }
+    fix_through_cgal(obj_idxs, {});
+}
+
+void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::vector<int> &vol_idxs)
 {
     // Do not fix anything when a gizmo is open. There might be issues with updates
     // and what is worse, the snapshot time would refer to the internal stack.
-    if (!wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager().check_gizmos_closed_except(GLGizmosManager::Undefined))
+    if (obj_idxs.empty() || !wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager().check_gizmos_closed_except(GLGizmosManager::Undefined))
         return;
 
     //          model_name
     std::vector<std::string>                           succes_models;
     //                   model_name     failing reason
     std::vector<std::pair<std::string, std::string>>   failed_models;
-
-    std::vector<int> obj_idxs, vol_idxs;
-    get_selection_indexes(obj_idxs, vol_idxs);
+    size_t                                             unchanged_models = 0;
+    bool                                               painting_removed = false;
 
     std::vector<std::string> model_names;
 
-    // clear selections from the non-broken models if any exists
-    // and than fill names of models to repairing
     if (vol_idxs.empty()) {
-#if !FIX_THROUGH_CGAL_ALWAYS
-        for (int i = int(obj_idxs.size())-1; i >= 0; --i)
-                if (object(obj_idxs[i])->get_repaired_errors_count() == 0)
-                    obj_idxs.erase(obj_idxs.begin()+i);
-#endif // FIX_THROUGH_CGAL_ALWAYS
         for (int obj_idx : obj_idxs)
             if (object(obj_idx))
                 model_names.push_back(object(obj_idx)->name);
@@ -6359,31 +6342,26 @@ void ObjectList::fix_through_cgal()
     else {
         ModelObject* obj = object(obj_idxs.front());
         if (obj) {
-#if !FIX_THROUGH_CGAL_ALWAYS
-            for (int i = int(vol_idxs.size()) - 1; i >= 0; --i)
-                if (obj->get_repaired_errors_count(vol_idxs[i]) == 0)
-                    vol_idxs.erase(vol_idxs.begin() + i);
-#endif // FIX_THROUGH_CGAL_ALWAYS
             for (int vol_idx : vol_idxs)
                 model_names.push_back(obj->volumes[vol_idx]->name);
         }
     }
 
     auto plater = wxGetApp().plater();
+    const bool keep_painting = GUI::wxGetApp().app_config->get_bool("keep_painting");
 
-    auto fix_and_update_progress = [this, plater, model_names](const int obj_idx, const int vol_idx,
-                                          int model_idx,
-                                          ProgressDialog& progress_dlg,
-                                          std::vector<std::string>& succes_models,
-                                          std::vector<std::pair<std::string, std::string>>& failed_models)
+    auto fix_and_update_progress = [&](const int obj_idx, const int vol_idx, int model_idx, ProgressDialog& progress_dlg)
     {
-        if (!object(obj_idx))
+        ModelObject *mo = object(obj_idx);
+        if (!mo)
             return false;
 
         const std::string& model_name = model_names[model_idx];
         wxString msg = _L("Repairing model object");
         if (model_names.size() == 1)
             msg += ": " + from_u8(model_name) + "\n";
+        else if (model_names.size() > 10)
+            msg += ": " + from_u8(model_name) + wxString::Format(" (%d/%d)", model_idx + 1, int(model_names.size())) + "\n";
         else {
             msg += ":\n";
             for (int i = 0; i < int(model_names.size()); ++i)
@@ -6391,33 +6369,29 @@ void ObjectList::fix_through_cgal()
             msg += "\n";
         }
 
-        const bool keep_painting = GUI::wxGetApp().app_config->get_bool("keep_painting");
-        if (!keep_painting) {
-            plater->clear_before_change_mesh(obj_idx);
-        }
-        const size_t volumes_before = object(obj_idx)->volumes.size();
+        auto count_painted = [mo]() { return std::count_if(mo->volumes.begin(), mo->volumes.end(), [](const ModelVolume *mv) { return mv->is_any_painted(); }); };
+        const auto  painted_before = count_painted();
         std::string res;
-        if (!fix_model_with_cgal_gui(*(object(obj_idx)), vol_idx, progress_dlg, msg, res, keep_painting))
+        bool        modified = false;
+        if (!fix_model_with_cgal_gui(*mo, vol_idx, progress_dlg, msg, res, keep_painting, &modified))
             return false;
-        //wxGetApp().plater()->changed_mesh(obj_idx);
-        object(obj_idx)->ensure_on_bed();
-        plater->changed_mesh(obj_idx);
 
-        const size_t volumes_after = object(obj_idx)->volumes.size();
-        if (volumes_after != volumes_before)
-            add_volumes_to_object_in_list(obj_idx);
+        if (modified) {
+            painting_removed = painting_removed || count_painted() < painted_before;
+            mo->ensure_on_bed();
+            plater->changed_mesh(obj_idx);
+            plater->get_partplate_list().notify_instance_update(obj_idx, 0);
+            plater->sidebar().obj_list()->update_plate_values_for_items();
+            update_item_error_icon(obj_idx, vol_idx);
+            update_info_items(obj_idx);
+        }
 
-        plater->get_partplate_list().notify_instance_update(obj_idx, 0);
-        plater->sidebar().obj_list()->update_plate_values_for_items();
-
-        if (res.empty())
+        if (!res.empty())
+            failed_models.push_back({ model_name, res });
+        else if (modified)
             succes_models.push_back(model_name);
         else
-            failed_models.push_back({ model_name, res });
-
-        update_item_error_icon(obj_idx, vol_idx);
-        update_info_items(obj_idx);
-
+            ++unchanged_models;
         return true;
     };
 
@@ -6430,11 +6404,7 @@ void ObjectList::fix_through_cgal()
     if (vol_idxs.empty()) {
         int vol_idx{ -1 };
         for (int obj_idx : obj_idxs) {
-#if !FIX_THROUGH_CGAL_ALWAYS
-            if (object(obj_idx)->get_repaired_errors_count(vol_idx) == 0)
-                continue;
-#endif // FIX_THROUGH_CGAL_ALWAYS
-            if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg, succes_models, failed_models))
+            if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg))
                 break;
             model_idx++;
         }
@@ -6442,7 +6412,7 @@ void ObjectList::fix_through_cgal()
     else {
         int obj_idx{ obj_idxs.front() };
         for (int vol_idx : vol_idxs) {
-            if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg, succes_models, failed_models))
+            if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg))
                 break;
             model_idx++;
         }
@@ -6450,20 +6420,29 @@ void ObjectList::fix_through_cgal()
     // Close the progress dialog
     progress_dlg.Update(100, "");
 
+    if (painting_removed)
+        plater->notify_painting_removed();
+
     // Show info notification
-    wxString msg;
+    std::vector<wxString> blocks;
     wxString bullet_suf = "\n   - ";
     if (!succes_models.empty()) {
-        msg = _L_PLURAL("The following model object has been repaired", "The following model objects have been repaired", succes_models.size()) + ":";
+        wxString block = _L_PLURAL("The following model object has been repaired", "The following model objects have been repaired", succes_models.size()) + ":";
         for (auto& model : succes_models)
-            msg += bullet_suf + from_u8(model);
-        msg += "\n\n";
+            block += bullet_suf + from_u8(model);
+        blocks.push_back(block);
     }
     if (!failed_models.empty()) {
-        msg += _L_PLURAL("Failed to repair the following model object", "Failed to repair the following model objects", failed_models.size()) + ":\n";
+        wxString block = _L_PLURAL("Failed to repair the following model object", "Failed to repair the following model objects", failed_models.size()) + ":";
         for (auto& model : failed_models)
-            msg += bullet_suf + from_u8(model.first) + ": " + _(model.second);
+            block += bullet_suf + from_u8(model.first) + ": " + _(model.second);
+        blocks.push_back(block);
     }
+    if (unchanged_models > 0)
+        blocks.push_back(format_wxstr(_L_PLURAL("%1$d model object needed no repair.", "%1$d model objects needed no repair.", unchanged_models), unchanged_models));
+    wxString msg;
+    for (const wxString &block : blocks)
+        msg += (msg.IsEmpty() ? "" : "\n\n") + block;
     if (msg.IsEmpty())
         msg = _L("Repairing was canceled");
     plater->get_notification_manager()->push_notification(NotificationType::CgalFinished, NotificationManager::NotificationLevel::PrintInfoShortNotificationLevel, into_u8(msg));

src/slic3r/GUI/GUI_ObjectList.hpp

@@ -47,9 +47,6 @@ typedef double                                      coordf_t;
 typedef std::pair<coordf_t, coordf_t>               t_layer_height_range;
 typedef std::map<t_layer_height_range, ModelConfig> t_layer_config_ranges;
 
-// Manifold mesh may contain self-intersections, so we want to always allow fixing the mesh.
-#define FIX_THROUGH_CGAL_ALWAYS 1
-
 namespace GUI {
 
 enum class Shortcut : uint8_t;
@@ -324,11 +321,6 @@ public:
     void                del_settings_from_config(const wxDataViewItem& parent_item);
     void                del_instances_from_object(const int obj_idx);
     void                del_layer_from_object(const int obj_idx, const t_layer_height_range& layer_range);
-    // Mirrors an object's height ranges in the tree after they have been rewritten from outside the
-    // list - the texture displacement gizmo writes a whole set at once for a ChromaStack stack's
-    // filament swaps. Deliberately leaves the selection alone: changing it while a gizmo is open
-    // tears the gizmo down under the user.
-    void                rebuild_layer_ranges(const int obj_idx);
     void                del_layers_from_object(const int obj_idx);
     bool                del_from_cut_object(bool is_connector, bool is_model_part = false, bool is_negative_volume = false);
     bool                del_subobject_from_object(const int obj_idx, const int idx, const int type);
@@ -468,6 +460,9 @@ public:
     void split_instances();
     void rename_item();
     void fix_through_cgal();
+    // Fixes every object on the selected plate, or on all plates.
+    void fix_all_through_cgal(bool all_plates);
+    void fix_through_cgal(const std::vector<int> &obj_idxs, const std::vector<int> &vol_idxs);
     void simplify();
     void smooth_mesh();
     void update_item_error_icon(const int obj_idx, int vol_idx) const ;

src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp

@@ -1036,6 +1036,11 @@ bool GLGizmoPainterBase::on_mouse(const wxMouseEvent &mouse_event)
     Vec2d mouse_pos = mouse_coord.cast<double>();
 
     if (mouse_event.Moving()) {
+        // No button is down, yet a stroke is still open: its release went elsewhere, as a paint drag does not
+        // capture the mouse. End the stroke as that release would have.
+        if (m_button_down != Button::None)
+            gizmo_event(m_button_down == Button::Left ? SLAGizmoEventType::LeftUp : SLAGizmoEventType::RightUp, mouse_pos,
+                        mouse_event.ShiftDown(), mouse_event.AltDown(), false);
         gizmo_event(SLAGizmoEventType::Moving, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), false);
         return false;
     }
@@ -1205,6 +1210,10 @@ void GLGizmoPainterBase::on_set_state()
         m_old_mo_id = -1;
         //m_iva.release_geometry();
         m_triangle_selectors.clear();
+        // A stroke still open goes with the selectors. Its state must not carry into the next session, where the
+        // first move would end it as if released and the first press would paint a line from its last position.
+        m_button_down      = Button::None;
+        m_last_mouse_click = Vec2d::Zero();
 
         //Camera& camera = wxGetApp().plater()->get_camera();
         //camera.look_at(camera.get_position(), m_previous_target, Vec3d::UnitZ());

src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp

@@ -197,6 +197,27 @@ public:
     };
     static PaintedColors painted_colors(const TriangleMesh &mesh, const TriangleSelector::TriangleSplittingData &paint);
 
+    // The view while the UV editor's selected islands are highlighted on the model. The highlight lies on the
+    // undisplaced surface, so the Normal view's relief hides it wherever it rises: Normal gives way to Fast
+    // while islands are selected and comes back once none are. A view the user clicks in the View row is
+    // theirs - the pane's background buttons are not a pick, Height only meaning "the texture view".
+    struct IslandViewFollow
+    {
+        bool shown       = false; // the highlight, as of the last step()
+        bool switched    = false; // Fast was switched on for the highlight, so Normal comes back once it is gone
+        bool keep_normal = false; // the user picked Normal in the View row while the highlight was shown
+        // The view to apply this frame (0 Normal, 1 Fast), or -1 for none. `view` is the one on screen, numbered as
+        // apply_view_mode() takes it; `debug_open` a debug stage on screen, which holds Normal itself.
+        int  step(bool shown_now, int view, bool debug_open);
+        // A View row button clicked, the active one included. The row is drawn after step() in the same frame,
+        // so `shown` is this frame's.
+        void picked(int view)
+        {
+            switched    = false;
+            keep_normal = shown && view == 0;
+        }
+    };
+
     void render_painter_gizmo() override;
 
     // Intercepts mouse input while "Adjust Texture" mode is on (dragging the on-canvas offset/
@@ -235,11 +256,7 @@ private:
     ModelVolume*       texture_volume();
     const ModelVolume* texture_volume() const;
 
-    // `chroma` picks the kind: a relief layer, a height map pushed into the surface, or a ChromaStack
-    // picture, a colour picture made of filament swaps. The kind is a property of the layer and is
-    // fixed when it is created - there is no panel-wide mode, so a plaque can carry a picture on its
-    // face and a knurl on its rim at the same time.
-    void add_texture_layer(bool chroma = false);
+    void add_texture_layer();
     void remove_texture_layer(int slot);
     // Moves the layer in `slot` to position `to_index` of the slot-ordered stack (an insertion index,
     // 0..layer count), which is the order blend modes apply in. Layers keep their data; what moves is
@@ -266,6 +283,9 @@ private:
     // Standard is active so what Preview shows is always what Bake will do. Returns true if it actually
     // changed something, so the caller can invalidate the preview.
     bool apply_standard_mode_presets(ModelVolume *mv);
+    // Copies the panel's own state (active layer, Standard/Pro) onto the volume, so the project file
+    // can carry it. Cheap and idempotent - called wherever either of the two changes.
+    void store_panel_state();
     // Standard mode's Bake: remesh to an even density, refine where the texture bends, then displace.
     // The order matters and is the whole reason this is one button - a height map can only move
     // existing vertices, so the mesh has to be prepared first, and remeshing after painting would drop
@@ -403,114 +423,17 @@ private:
     void set_layer_texture(TextureDisplacementLayer &layer, const TextureLibraryEntry &entry);
     void import_custom_texture(TextureDisplacementLayer &layer);
 
-    // ---- ChromaStack (see libslic3r/ChromaStack.hpp) ----
-    //
-    // A ChromaStack layer is an ordinary texture displacement layer whose height map is computed rather
-    // than imported: the picture the user picked is kept in `chroma_source`, the stack in
-    // `chroma`, and `image_data` holds whatever the last solve produced. Everything downstream -
-    // projection, preview, bake - therefore needs no changes at all, and this is the whole of the
-    // feature's GUI side: pick a picture, edit the stack, solve, hand the filament swaps to the
-    // object's height ranges.
-
-    // The project's loaded filaments as the colour model sees them: colour from the project, TD from
-    // each filament's preset. Index is the filament index the swaps are written from.
-    static std::vector<ChromaFilament> chroma_filaments();
-    // The layer height the print profile is set to, mm; 0 when there is no print preset. The solve is
-    // only valid for the layer height it was run at, so the panel compares it against the stack's.
-    static float print_layer_height();
-
-    // Where the active layer's painted patch sits, in the object's own printed coordinates - which is
-    // what the stack has to be lined up with, because a filament swap happens at a print Z and the
-    // relief grows upward from this patch.
-    struct ChromaPatch
-    {
-        bool  valid     = false;
-        float top_mm    = 0.f; // the patch's surface above the bottom of the object
-        float spread_mm = 0.f; // how far from flat the patch is in Z; 0 is a horizontal face
-        // The patch's extent in the plane the texture is projected from, in the bake frame - i.e. the
-        // (x, y) the Z-facing plane of the tri-planar projection samples by. This is what the picture
-        // has to be placed against: tiling_scale and offset are in that space, not in the patch's.
-        Vec2f planar_min = Vec2f::Zero();
-        Vec2f planar_max = Vec2f::Zero();
-    };
-    ChromaPatch chroma_patch(const TextureDisplacementLayer &layer) const;
-    // The painted face's height in layers, which is what the stack's base has to be: -1 when nothing
-    // is painted yet or there is no layer height to divide by.
-    int         chroma_measured_base(const TextureDisplacementLayer &layer) const;
-    // Extracting the painted patch is far too expensive to repeat once a frame, which is how often the
-    // panel wants the number. The paint's own timestamp and the transform the patch was measured in are
-    // between them everything the answer depends on.
-    mutable std::array<ChromaPatch, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_chroma_patch_cache{};
-    mutable std::array<uint64_t, TEXTURE_DISPLACEMENT_MAX_LAYERS>      m_chroma_patch_stamp{};
-    mutable std::array<Transform3d, TEXTURE_DISPLACEMENT_MAX_LAYERS>   m_chroma_patch_trafo{};
-    // The patch is measured in two frames at once - the instance's, for the print height, and the
-    // bake's, for the placement - so both are part of what the cached answer depends on.
-    mutable std::array<Transform3d, TEXTURE_DISPLACEMENT_MAX_LAYERS>   m_chroma_patch_bake{};
-
-    // Picks a colour picture for the layer, turns ChromaStack on, and seeds a stack from the loaded
-    // filaments and the patch if the layer has none yet. Solves straight away, so the relief appears
-    // without a second click.
-    void chroma_pick_picture(TextureDisplacementLayer &layer);
-    // Re-runs the solve and replaces the layer's height map with its result. False (with the reason
-    // shown to the user) when the layer has no picture, no stack or no relief layers.
-    bool chroma_solve_layer(TextureDisplacementLayer &layer);
-    // Writes the stack's filament swaps onto the object as height ranges, replacing whatever ranges it
-    // had. Takes its own undo snapshot.
-    void chroma_apply_swaps(const TextureDisplacementLayer &layer);
-    // The stack's swaps as the object's height ranges already express them: true when applying would
-    // change nothing, which is what the panel's hint keys off.
-    bool chroma_swaps_applied(const TextureDisplacementLayer &layer) const;
-    // The whole of a ChromaStack card between its header and More settings: the picture and the print
-    // it predicts, the base, the filaments and the colours they reach, and the two actions.
-    void render_chroma_card(TextureDisplacementLayer &layer, float card_pad, float label_w, float wrap_w);
-
-    // The surface drawn in the colours the stack will print, over whatever neutral surface is there:
-    // the live preview's displaced mesh before a bake, the volume's own mesh after one. Every triangle
-    // takes the palette colour of the printed layer its centroid falls in (chroma_level_at()), which
-    // is what the eye will see at that height - so the relief's terraces read as the picture, the walls
-    // between them show the bands they cut through, and looking straight down gives the blended colours
-    // the whole feature exists to produce.
-    //
-    // Nothing else in the application can show this: the colours are blends of translucent filaments
-    // that no single filament can make, so they cannot be expressed as the per-triangle filament
-    // assignment the 3D scene paints with. They exist only here and in the sliced preview.
-    void rebuild_chroma_colors(const TextureDisplacementLayer &layer);
-    bool render_chroma_colors(const TextureDisplacementLayer &layer);
-    GLModel m_chroma_color_model;
-    // The surface the overlay was built from. The mesh alone: the colours are not in it, so a change
-    // to the stack costs a palette upload rather than a mesh rebuild.
-    size_t  m_chroma_color_key = 0;
-    // The stack's colours, one texel per printed layer, and what they were built from. A texture
-    // because a uniform array cannot hold a base of several hundred layers.
-    std::unique_ptr<GLTexture> m_chroma_palette_tex;
-    size_t                     m_chroma_palette_key = 0;
-    bool                       m_show_chroma_colors = true;
-
-    // What the last solve of each slot reported, for the panel. Not saved: it is a property of the
-    // solve, and a project is reopened with whatever height map the solve produced.
-    struct ChromaReport
-    {
-        bool   valid = false;
-        double mean  = 0.;
-        double max   = 0.;
-    };
-    std::array<ChromaReport, TEXTURE_DISPLACEMENT_MAX_LAYERS>              m_chroma_report{};
-    // The predicted print, per slot: the palette colours the solve chose, as a panel thumbnail. The
-    // 3D view cannot show this - the colours do not exist until the print swaps filament - so it is
-    // the only place the user sees what the stack will actually produce.
-    std::array<std::unique_ptr<GLTexture>, TEXTURE_DISPLACEMENT_MAX_LAYERS>  m_chroma_preview;
-    // The source picture's thumbnail, beside the prediction, keyed by the image it was built from.
-    std::array<std::unique_ptr<GLTexture>, TEXTURE_DISPLACEMENT_MAX_LAYERS>  m_chroma_source_thumb;
-    std::array<const void *, TEXTURE_DISPLACEMENT_MAX_LAYERS>                m_chroma_source_key{};
-    // Per slot: the stack has been edited since the height map was solved, so the relief on screen is the
-    // previous stack's. Nothing else can show this - a stale height map looks like a perfectly good one.
-    std::array<bool, TEXTURE_DISPLACEMENT_MAX_LAYERS>                        m_chroma_stale{};
-
     // Paint / Erase, from the panel. See get_left_button_state_type().
     bool m_erase_mode = false;
     // Per slot: whether the layer's card shows every setting or only Depth, Tile size and Rotation.
     // Panel state only, not saved with the project.
     std::array<bool, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_layer_expanded{};
+    // The slider whose edit icon was just clicked, as its ImGui id, and the frame it was clicked on.
+    // The row acts on it on the next frame - ImGui's keyboard-focus request only takes effect a frame
+    // later - and clears it; the frame number is what retires a request whose row has gone off screen
+    // in the meantime. Panel state only, not saved with the project.
+    std::string m_slider_type_request;
+    int         m_slider_type_request_frame = 0;
 
     // "Adjust Texture" mode: instead of painting, dragging an on-canvas handle changes the active
     // layer's offset. The handle is a flat panel lying in the paint patch's own tangent plane
@@ -611,6 +534,11 @@ private:
     // The panel's view modes: 0 Normal, 1 Fast, 2 Checker, 3 Distortion. Shared by the View row and the pane's
     // background buttons, so both switch views the same way.
     void apply_view_mode(int mode);
+    // The view on screen, numbered as apply_view_mode() takes it.
+    int  view_mode() const;
+    // Run once a frame, after the pane's commands: switches the view as m_island_view says.
+    void             follow_island_highlight();
+    IslandViewFollow m_island_view;
     // The pane header's thumbnail of the active layer's texture, rebuilt only when its image changes.
     static constexpr int       UV_THUMB_PX       = 64;
     const void                *m_uv_thumb_source = nullptr;
@@ -842,6 +770,8 @@ private:
     // in place. Rebuilt whenever the pane's selection differs from the one it was built for.
     GLModel          m_island_overlay_glmodel;
     std::vector<int> m_island_overlay_selection;
+    // The pane's selection while the overlay applies - the pane open over an unwrapped LSCM layer - else null.
+    const std::vector<int> *island_highlight_selection();
     void             rebuild_island_overlay(const std::vector<int> &selection);
     void             render_island_overlay();
     // Set on every paint event, cleared when the overlay is rebuilt in render_painter_gizmo(). Kept
@@ -1022,25 +952,26 @@ private:
     bool m_preview_job_pending = false;
     void queue_preview_job();
 
-    // Per-slot GPU thumbnail cache for the layer list panel, keyed by the image_data pointer that
-    // was current the last time each thumbnail was built (see get_layer_thumbnail()).
-    std::array<std::unique_ptr<GLTexture>, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_thumbnails;
-    std::array<const void *, TEXTURE_DISPLACEMENT_MAX_LAYERS>               m_thumbnail_source{};
+    // Per-slot GPU thumbnail cache for the layer list panel, each keyed by the image_data it was built from
+    // (see get_layer_thumbnail()). Held weakly rather than by address, as decode_height_texture()'s cache is:
+    // an image freed and replaced by another at the same address must not pass for it.
+    std::array<std::unique_ptr<GLTexture>, TEXTURE_DISPLACEMENT_MAX_LAYERS>                       m_thumbnails;
+    std::array<std::weak_ptr<const std::vector<unsigned char>>, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_thumbnail_source;
     // The smoothing each cached thumbnail was built at, so a smoothing change re-uploads it.
-    std::array<float, TEXTURE_DISPLACEMENT_MAX_LAYERS>                      m_thumbnail_smoothing{};
+    std::array<float, TEXTURE_DISPLACEMENT_MAX_LAYERS>                                            m_thumbnail_smoothing{};
 
     // Full-resolution height texture for the preview shader, keyed the same way (see
     // get_layer_height_texture()). A smoothing change re-uploads it, so the fast preview shows the
     // blur the bake will apply.
-    std::unique_ptr<GLTexture> m_height_tex;
-    const void                *m_height_tex_source    = nullptr;
-    float                      m_height_tex_smoothing = -1.f;
+    std::unique_ptr<GLTexture>                      m_height_tex;
+    std::weak_ptr<const std::vector<unsigned char>> m_height_tex_source;
+    float                                           m_height_tex_smoothing = -1.f;
 
     // The same, for the layer's *colour*, which the fast preview quantizes per fragment so it shows
     // the image at texel resolution rather than at the mesh's. Null for a grayscale texture.
-    std::unique_ptr<GLTexture> m_color_tex;
-    const void                *m_color_tex_source    = nullptr;
-    float                      m_color_tex_smoothing = -1.f;
+    std::unique_ptr<GLTexture>                      m_color_tex;
+    std::weak_ptr<const std::vector<unsigned char>> m_color_tex_source;
+    float                                           m_color_tex_smoothing = -1.f;
 
     // Library textures the picker has shown at least once, keyed by file path (see LibraryTexture).
     std::map<std::string, LibraryTexture> m_library_textures;
@@ -1078,9 +1009,12 @@ private:
     PatchUnwrap m_uv_editor_unwrap;
 
     // When set, the panel is a free-floating window the user can drag anywhere (with a title bar to
-    // grab), instead of being pinned to the right of the gizmo toolbar. Persisted across gizmo
-    // open/close within a session, so the choice sticks while working.
+    // grab), instead of being pinned to the right of the gizmo toolbar. Kept in the application
+    // config rather than in the project: it describes the user's window, not the model, so opening
+    // someone else's project must not move their panel.
     bool m_undocked = false;
+    // The config key behind m_undocked.
+    static constexpr const char *UNDOCKED_CONFIG_KEY = "texture_displacement_panel_undocked";
 
     // Smooth scrolling for the panel body (everything between the header and the pinned Bake footer).
     // ImGui jumps a fixed number of lines per wheel notch, which on tall layer cards reads as a hard
@@ -1123,6 +1057,9 @@ private:
     std::vector<std::pair<wxString, wxString>> m_shortcuts_bucket_fill;
     // Contains all shortcuts in the format of {shortcut, description}, e.g. {alt + _L("Left mouse button"), _L("Part_selection")}
     std::vector<std::pair<wxString, wxString>> m_shortcuts_gap_fill;
+    // The two ways every slider in the panel takes a typed value. They hold whatever tool is selected,
+    // so they are tacked onto each of the lists above and stand on their own when no tool is active.
+    std::vector<std::pair<wxString, wxString>> m_shortcuts_sliders;
 
     // Icons for the panel's icon buttons (tools, views, mapping, tiling, layer actions). Loaded through IconManager with
     // the same colour/monochrome variants the main toolbar uses, so an inactive button shows the icon in

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -420,7 +420,10 @@ void GLGizmosManager::refresh_on_off_state()
 
 void GLGizmosManager::reset_all_states()
 {
-    if (! m_enabled || m_serializing)
+    // The restore/new-project event can run before deferred OpenGL resource
+    // loading has populated the gizmo list.  There is nothing to reset until
+    // initialization completes.
+    if (! m_enabled || m_serializing || m_gizmos.empty())
         return;
 
     const EType current = get_current_type();
@@ -435,6 +438,9 @@ void GLGizmosManager::reset_all_states()
 
 bool GLGizmosManager::open_gizmo(EType type)
 {
+    if (m_gizmos.empty())
+        return false;
+
     int idx = static_cast<int>(type);
 
     // re-open same type cause closing
@@ -522,7 +528,7 @@ bool GLGizmosManager::is_running() const
 
 bool GLGizmosManager::open_gizmo_by_shortcut(Shortcut shortcut)
 {
-    if (!m_enabled)
+    if (!m_enabled || m_gizmos.empty())
         return false;
 
     // The text tool opens without a selection because it creates its own object.
@@ -1427,10 +1433,12 @@ void GLGizmosManager::update_hover_state(const EType &type)
 
 bool GLGizmosManager::activate_gizmo(EType type)
 {
-    assert(!m_gizmos.empty());
-
     // already activated
-    if (m_current == type) return true;
+    if (m_current == type)
+        return true;
+
+    if (m_gizmos.empty())
+        return false;
 
     if (m_current != Undefined) {
         // clean up previous gizmo

src/slic3r/GUI/Gizmos/GizmoObjectManipulation.cpp

@@ -925,8 +925,9 @@ void GizmoObjectManipulation::do_render_move_window(ImGuiWrapper *imgui_wrapper,
 
     m_last_active_item = current_active_id;
     last_move_input_window_width = ImGui::GetWindowWidth();
+    ImGui::PopStyleVar();
     imgui_wrapper->end();
-    ImGui::PopStyleVar(2);
+    ImGui::PopStyleVar();
     ImGuiWrapper::pop_toolbar_style();
 }
 
@@ -1131,10 +1132,11 @@ void GizmoObjectManipulation::do_render_rotate_window(ImGuiWrapper *imgui_wrappe
 
     m_last_active_item = current_active_id;
     last_rotate_input_window_width = ImGui::GetWindowWidth();
+    ImGui::PopStyleVar();
     imgui_wrapper->end();
 
     // BBS
-    ImGui::PopStyleVar(2);
+    ImGui::PopStyleVar();
     ImGuiWrapper::pop_toolbar_style();
 }
 

src/slic3r/GUI/MultiTaskModel.cpp

@@ -1,6 +0,0 @@
-
-namespace Slic3r {
-namespace GUI {
-
-} // namespace GUI
-} // namespace Slic3r

src/slic3r/GUI/MultiTaskModel.hpp

@@ -1,11 +0,0 @@
-#ifndef slic3r_MultiTaskModel_hpp_
-#define slic3r_MultiTaskModel_hpp_
-
-namespace Slic3r { 
-namespace GUI {
-
-
-} // namespace GUI
-} // namespace Slic3r
-
-#endif

src/slic3r/GUI/PartPlate.cpp

@@ -1880,13 +1880,6 @@ void PartPlate::render_exclude_area(bool force_default_color) {
 	// draw exclude area
 	glsafe(::glDepthMask(GL_FALSE));
 
-	if (m_selected) {
-		glsafe(::glColor4fv(select_color.data()));
-	}
-	else {
-		glsafe(::glColor4fv(unselect_color.data()));
-	}
-
 	m_exclude_triangles.set_color(m_selected ? select_color : unselect_color);
     m_exclude_triangles.render();
 	glsafe(::glDepthMask(GL_TRUE));

src/slic3r/GUI/Plater.cpp

@@ -6070,6 +6070,8 @@ void Sidebar::on_bed_type_change(BedType bed_type)
  * - Map key encoding:
  *   - Virtual trays: 0x10000 + vt_tray.id (first/main extruder), or just vt_tray.id (secondary)
  *   - AMS trays: 0x10000 + (ams_id * 4 + slot_id) (main extruder), or (ams_id * 4 + slot_id) (secondary)
+ *   - Generic (non-Bambu) units are not four slots wide: their trays index by a cumulative lane
+ *     count across units instead of ams_id * 4 + slot_id
  *   - The 0x10000 flag indicates the main/right extruder
  * - Map value: DynamicPrintConfig with filament properties (id, type, color, etc.)
  *
@@ -6135,13 +6137,26 @@ std::map<int, DynamicPrintConfig> Sidebar::build_filament_ams_list(MachineObject
         return std::string();
     };
 
+    const bool is_bbl_vendor = wxTheApp != nullptr && wxGetApp().preset_bundle != nullptr && wxGetApp().preset_bundle->is_bbl_vendor();
+
     auto list = obj->GetFilaSystem()->GetAmsList();
     for (auto ams : list) {
         int ams_id   = std::stoi(ams.first);
         int extruder = ams.second->GetExtruderId() ? 0 : 0x10000; // Main (first) extruder at right
+        // Bambu units are four slots wide; a generic unit reports its own lane count and its trays
+        // carry a cumulative lane index. The AMS map is keyed by string id, so count preceding units
+        // numerically to keep this the same index the parser and the agent use.
+        int generic_tray_base = 0;
+        if (!is_bbl_vendor) {
+            for (const auto& other : list) {
+                if (std::stoi(other.first) < ams_id)
+                    generic_tray_base += static_cast<int>(other.second->GetTrays().size());
+            }
+        }
         for (auto tray : ams.second->GetTrays()) {
             int  slot_id = std::stoi(tray.first);
-            filament_ams_list.emplace(extruder + (ams_id * 4 + slot_id),
+            const int tray_index = is_bbl_vendor ? ams_id * 4 + slot_id : generic_tray_base + slot_id;
+            filament_ams_list.emplace(extruder + tray_index,
                                       build_tray_config(*tray.second, get_ams_name(ams_id, slot_id), std::to_string(ams_id), std::to_string(slot_id)));
         }
     }
@@ -14984,24 +14999,8 @@ bool Plater::priv::can_fix_through_cgal() const
     std::vector<int> obj_idxs, vol_idxs;
     sidebar->obj_list()->get_selection_indexes(obj_idxs, vol_idxs);
 
-#if FIX_THROUGH_CGAL_ALWAYS
-    // Fixing always.
+    // A closed mesh may still self-intersect, so fixing is always allowed.
     return ! obj_idxs.empty() || ! vol_idxs.empty();
-#else // FIX_THROUGH_CGAL_ALWAYS
-    // Fixing only if the model is not manifold.
-    if (vol_idxs.empty()) {
-        for (auto obj_idx : obj_idxs)
-            if (model.objects[obj_idx]->get_repaired_errors_count() > 0)
-                return true;
-        return false;
-    }
-
-    int obj_idx = obj_idxs.front();
-    for (auto vol_idx : vol_idxs)
-        if (model.objects[obj_idx]->get_repaired_errors_count(vol_idx) > 0)
-            return true;
-    return false;
-#endif // FIX_THROUGH_CGAL_ALWAYS
 }
 
 bool Plater::priv::can_simplify() const
@@ -22041,13 +22040,16 @@ void Plater::clear_before_change_mesh(int obj_idx)
         mv->mmu_segmentation_facets.reset();
         mv->fuzzy_skin_facets.reset();
     }
-    if (paint_removed) {
-        // snapshot_time is captured by copy so the lambda knows where to undo/redo to.
-        get_notification_manager()->push_notification(
-                    NotificationType::CustomSupportsAndSeamRemovedAfterRepair,
-                    NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
-                    _u8L("Custom supports and color painting were removed before repairing."));
-    }
+    if (paint_removed)
+        notify_painting_removed();
+}
+
+void Plater::notify_painting_removed()
+{
+    get_notification_manager()->push_notification(
+                NotificationType::CustomSupportsAndSeamRemovedAfterRepair,
+                NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
+                _u8L("Custom supports and color painting were removed before repairing."));
 }
 
 void Plater::changed_mesh(int obj_idx)

src/slic3r/GUI/Plater.hpp

@@ -599,6 +599,7 @@ public:
     void reslice_SLA_until_step(SLAPrintObjectStep step, const ModelObject &object, bool postpone_error_messages = false);
 
     void clear_before_change_mesh(int obj_idx);
+    void notify_painting_removed();
     void changed_mesh(int obj_idx);
 
     void changed_object(ModelObject &object);

src/slic3r/GUI/SysInfoDialog.cpp

@@ -1,232 +0,0 @@
-#include "SysInfoDialog.hpp"
-#include "I18N.hpp"
-#include "3DScene.hpp"
-#include "GUI.hpp"
-#include "../Utils/UndoRedo.hpp"
-#include "Plater.hpp"
-
-#include <string>
-
-#include <Eigen/Core>
-
-#include <wx/clipbrd.h>
-#include <wx/platinfo.h>
-#include "GUI_App.hpp"
-#include "MainFrame.hpp"
-#include "wxExtensions.hpp"
-#include "libslic3r/BlacklistedLibraryCheck.hpp"
-#include "libslic3r/Color.hpp"
-#include "format.hpp"
-
-#ifdef _WIN32
-	// The standard Windows includes.
-	#define WIN32_LEAN_AND_MEAN
-	#ifndef NOMINMAX
-	#define NOMINMAX
-	#endif
-	#include <Windows.h>
-	#include <psapi.h>
-#endif /* _WIN32 */
-
-namespace Slic3r {
-namespace GUI {
-
-std::string get_main_info(bool format_as_html)
-{
-    std::stringstream out;
-
-    std::string b_start  = format_as_html ? "<b>"  : "";
-    std::string b_end    = format_as_html ? "</b>" : "";
-    std::string line_end = format_as_html ? "<br>" : "\n";
-
-    if (!format_as_html)
-        out << b_start << (wxGetApp().is_editor() ? SLIC3R_APP_FULL_NAME : GCODEVIEWER_APP_NAME) << b_end << line_end;
-    out << b_start << "Version:   "             << b_end << SLIC3R_VERSION << line_end;
-    out << b_start << "Build:     " << b_end << (wxGetApp().is_editor() ? SLIC3R_BUILD_ID : GCODEVIEWER_BUILD_ID) << line_end;
-    out << line_end;
-    out << b_start << "Operating System:    "   << b_end << wxPlatformInfo::Get().GetOperatingSystemFamilyName() << line_end;
-    out << b_start << "System Architecture: "   << b_end << wxPlatformInfo::Get().GetArchName() << line_end;
-    out << b_start <<
-#if defined _WIN32
-        "Windows Version:     "
-#else
-        // Hopefully some kind of unix / linux.
-        "System Version:      "
-#endif
-        << b_end << wxPlatformInfo::Get().GetOperatingSystemDescription() << line_end;
-    out << b_start << "Total RAM size [MB]: "  << b_end << Slic3r::format_memsize_MB(Slic3r::total_physical_memory());
-
-    return out.str();
-}
-
-std::string get_mem_info(bool format_as_html)
-{
-    std::stringstream out;
-
-    std::string b_start  = format_as_html ? "<b>"  : "";
-    std::string b_end    = format_as_html ? "</b>" : "";
-    std::string line_end = format_as_html ? "<br>" : "\n";
-
-    std::string mem_info_str = log_memory_info(true);
-    std::istringstream mem_info(mem_info_str);
-    std::string value;
-    while (std::getline(mem_info, value, ':')) {
-        out << b_start << (value+": ") << b_end;
-        std::getline(mem_info, value, ';');
-        out << value << line_end;
-    }
-
-    const Slic3r::UndoRedo::Stack &stack = wxGetApp().plater()->undo_redo_stack_main();
-    out << b_start << "RAM size reserved for the Undo / Redo stack: "  << b_end << Slic3r::format_memsize_MB(stack.get_memory_limit()) << line_end;
-    out << b_start << "RAM size occupied by the Undo / Redo stack: "  << b_end << Slic3r::format_memsize_MB(stack.memsize()) << line_end << line_end;
-
-    return out.str();
-}
-
-SysInfoDialog::SysInfoDialog()
-    : DPIDialog(static_cast<wxWindow*>(wxGetApp().mainframe), wxID_ANY, (wxGetApp().is_editor() ? wxString(SLIC3R_APP_FULL_NAME) : wxString(GCODEVIEWER_APP_NAME)) + " - " + _L("System Information"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
-{
-	wxColour bgr_clr = wxGetApp().get_window_default_clr();//wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
-	SetBackgroundColour(bgr_clr);
-    SetFont(wxGetApp().normal_font());
-
-    wxBoxSizer* hsizer = new wxBoxSizer(wxHORIZONTAL);
-    hsizer->SetMinSize(wxSize(50 * wxGetApp().em_unit(), -1));
-
-	auto main_sizer = new wxBoxSizer(wxVERTICAL);
-	main_sizer->Add(hsizer, 1, wxEXPAND | wxALL, 10);
-
-    // logo
-    m_logo_bmp = ScalableBitmap(this, wxGetApp().logo_name(), 192);
-    m_logo = new wxStaticBitmap(this, wxID_ANY, m_logo_bmp.bmp());
-	hsizer->Add(m_logo, 0, wxALIGN_CENTER_VERTICAL);
-
-    wxBoxSizer* vsizer = new wxBoxSizer(wxVERTICAL);
-    hsizer->Add(vsizer, 1, wxEXPAND|wxLEFT, 20);
-
-    // title
-    {
-        wxStaticText* title = new wxStaticText(this, wxID_ANY, wxGetApp().is_editor() ? SLIC3R_APP_FULL_NAME : GCODEVIEWER_APP_NAME, wxDefaultPosition, wxDefaultSize);
-        wxFont title_font = wxGetApp().bold_font();
-        title_font.SetFamily(wxFONTFAMILY_ROMAN);
-        title_font.SetPointSize(22);
-        title->SetFont(title_font);
-        vsizer->Add(title, 0, wxEXPAND | wxTOP, wxGetApp().em_unit()/*50*/);
-    }
-
-    // main_info_text
-    wxFont font = get_default_font(this);
-    const auto text_clr = wxGetApp().get_label_clr_default();//wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
-    auto text_clr_str = encode_color(ColorRGB(text_clr.Red(), text_clr.Green(), text_clr.Blue()));
-    auto bgr_clr_str = encode_color(ColorRGB(bgr_clr.Red(), bgr_clr.Green(), bgr_clr.Blue()));
-
-    const int fs = font.GetPointSize() - 1;
-    int size[] = { static_cast<int>(fs*1.5), static_cast<int>(fs*1.4), static_cast<int>(fs*1.3), fs, fs, fs, fs };
-
-    m_html = new wxHtmlWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHW_SCROLLBAR_NEVER);
-    {
-        m_html->SetFonts(font.GetFaceName(), font.GetFaceName(), size);
-        m_html->SetBorders(2);
-		const auto text = wxString::Format(
-            "<html>"
-            "<body bgcolor= %s link= %s>"
-            "<font color=%s>"
-            "%s"
-            "</font>"
-            "</body>"
-            "</html>", bgr_clr_str, text_clr_str, text_clr_str,
-            get_main_info(true));
-        m_html->SetPage(text);
-        vsizer->Add(m_html, 1, wxEXPAND | wxBOTTOM, wxGetApp().em_unit());
-    }
-
-    // opengl_info
-    m_opengl_info_html = new wxHtmlWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHW_SCROLLBAR_AUTO);
-    {
-        m_opengl_info_html->SetMinSize(wxSize(-1, 16 * wxGetApp().em_unit()));
-        m_opengl_info_html->SetFonts(font.GetFaceName(), font.GetFaceName(), size);
-        m_opengl_info_html->SetBorders(10);
-        wxString blacklisted_libraries_message;
-#ifdef WIN32
-        std::wstring blacklisted_libraries = BlacklistedLibraryCheck::get_instance().get_blacklisted_string().c_str();
-        if (! blacklisted_libraries.empty())
-            blacklisted_libraries_message = wxString("<br><b>") + _L("Blacklisted libraries loaded into OrcaSlicer process:") + "</b><br>" + blacklisted_libraries;
-#endif // WIN32
-       const auto text = GUI::format_wxstr(
-            "<html>"
-            "<body bgcolor= %s link= %s>"
-            "<font color=%s>"
-            "%s<br>%s<br>%s<br>%s"
-            "</font>"
-            "</body>"
-            "</html>", bgr_clr_str, text_clr_str, text_clr_str,
-            blacklisted_libraries_message,
-            get_mem_info(true), wxGetApp().get_gl_info(false),
-            "<b>" + _L("SIMD is supported:") + "</b> " + Eigen::SimdInstructionSetsInUse());
-
-        m_opengl_info_html->SetPage(text);
-        main_sizer->Add(m_opengl_info_html, 1, wxEXPAND | wxBOTTOM, 15);
-    }
-
-    wxStdDialogButtonSizer* buttons = this->CreateStdDialogButtonSizer(wxOK);
-    m_btn_copy_to_clipboard = new wxButton(this, wxID_ANY, _L("Copy to Clipboard"), wxDefaultPosition, wxDefaultSize);
-
-    buttons->Insert(0, m_btn_copy_to_clipboard, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 5);
-    m_btn_copy_to_clipboard->Bind(wxEVT_BUTTON, &SysInfoDialog::onCopyToClipboard, this);
-
-    this->SetEscapeId(wxID_OK);
-    this->Bind(wxEVT_BUTTON, &SysInfoDialog::onCloseDialog, this, wxID_OK);
-    main_sizer->Add(buttons, 0, wxEXPAND | wxRIGHT | wxBOTTOM, 3);
-
-    wxGetApp().UpdateDlgDarkUI(this, true);
-
-//     this->Bind(wxEVT_LEFT_DOWN, &SysInfoDialog::onCloseDialog, this);
-//     logo->Bind(wxEVT_LEFT_DOWN, &SysInfoDialog::onCloseDialog, this);
-
-	SetSizer(main_sizer);
-	main_sizer->SetSizeHints(this);
-}
-
-void SysInfoDialog::on_dpi_changed(const wxRect &suggested_rect)
-{
-    m_logo_bmp.msw_rescale();
-    m_logo->SetBitmap(m_logo_bmp.bmp());
-
-    wxFont font = get_default_font(this);
-    const int fs = font.GetPointSize() - 1;
-    int font_size[] = { static_cast<int>(fs*1.5), static_cast<int>(fs*1.4), static_cast<int>(fs*1.3), fs, fs, fs, fs };
-
-    m_html->SetFonts(font.GetFaceName(), font.GetFaceName(), font_size);
-    m_html->Refresh();
-
-    const int& em = em_unit();
-
-    msw_buttons_rescale(this, em, { wxID_OK, m_btn_copy_to_clipboard->GetId() });
-
-    m_opengl_info_html->SetMinSize(wxSize(-1, 16 * em));
-    m_opengl_info_html->SetFonts(font.GetFaceName(), font.GetFaceName(), font_size);
-    m_opengl_info_html->Refresh();
-
-    const wxSize& size = wxSize(65 * em, 55 * em);
-
-    SetMinSize(size);
-    Fit();
-
-    Refresh();
-}
-
-void SysInfoDialog::onCopyToClipboard(wxEvent &)
-{
-    wxTheClipboard->Open();
-    const auto text = get_main_info(false) + "\n" + wxGetApp().get_gl_info(true);
-    wxTheClipboard->SetData(new wxTextDataObject(text));
-    wxTheClipboard->Close();
-}
-
-void SysInfoDialog::onCloseDialog(wxEvent &)
-{
-    this->EndModal(wxID_CLOSE);
-}
-
-} // namespace GUI
-} // namespace Slic3r

src/slic3r/GUI/SysInfoDialog.hpp

@@ -1,36 +0,0 @@
-#ifndef slic3r_GUI_SysInfoDialog_hpp_
-#define slic3r_GUI_SysInfoDialog_hpp_
-
-#include <wx/event.h>
-#include <wx/wx.h>
-#include <wx/html/htmlwin.h>
-
-#include "GUI_Utils.hpp"
-#include "wxExtensions.hpp"
-
-namespace Slic3r { 
-namespace GUI {
-
-class SysInfoDialog : public DPIDialog
-{
-    ScalableBitmap  m_logo_bmp;
-    wxStaticBitmap* m_logo;
-    wxHtmlWindow*   m_opengl_info_html;
-    wxHtmlWindow*   m_html;
-
-    wxButton*       m_btn_copy_to_clipboard;
-
-public:
-    SysInfoDialog();
-
-protected:
-    void on_dpi_changed(const wxRect &suggested_rect) override;
-    
-private:
-    void onCopyToClipboard(wxEvent &);
-    void onCloseDialog(wxEvent &);
-};
-} // namespace GUI
-} // namespace Slic3r
-
-#endif

src/slic3r/GUI/Tab.cpp

@@ -3098,6 +3098,7 @@ void TabPrint::build()
         optgroup = page->new_optgroup(L("Raft"), L"param_raft");
         optgroup->append_single_option_line("raft_layers", "support_settings_raft");
         optgroup->append_single_option_line("raft_contact_distance", "support_settings_raft");
+        optgroup->append_single_option_line("raft_expansion", "support_settings_raft");
 
         optgroup = page->new_optgroup(L("Filament for Supports"), L"param_support_filament");
         optgroup->append_single_option_line("support_filament", "support_settings_filament#base");
@@ -4533,7 +4534,6 @@ void TabFilament::build()
         optgroup->append_single_option_line("filament_adhesiveness_category", "material_basic_information#adhesiveness-category");
 
         optgroup->append_single_option_line("filament_density", "material_basic_information#density");
-        optgroup->append_single_option_line("filament_transmission_distance", "material_basic_information#transmission-distance");
         optgroup->append_single_option_line("filament_shrink", "material_basic_information#shrinkage-xy");
         optgroup->append_single_option_line("filament_shrinkage_compensation_z", "material_basic_information#shrinkage-z");
         optgroup->append_single_option_line("filament_cost", "material_basic_information#price");

src/slic3r/GUI/TextureImportDialog.cpp

@@ -14,7 +14,7 @@
 #include "Widgets/StateColor.hpp"
 #include "Widgets/StaticLine.hpp"
 #include "libslic3r/ColorDecomposeRecipe.hpp"
-#include "libslic3r/MeshBoolean.hpp"
+#include "libslic3r/MeshRepair.hpp"
 #include "libslic3r/TriangleSelector.hpp"
 
 #include <utility>
@@ -2436,25 +2436,25 @@ void TextureImportDialog::start_computation(bool auto_color, bool initial)
     settings.target_colors_num = auto_color ? 0 : (size_t)m_param_color_count;
     settings.smooth_weight     = m_param_smooth / 10.0;
     settings.mesh_repair_decision = m_mesh_repair_decision;
-    // BBS repairs the mesh through the Windows 3D SDK, which is only available on Windows
-    // builds that ship the SDK. Orca's CGAL-based repair (MeshBoolean::cgal::repair) works
-    // on all three platforms, so use that instead.
     settings.mesh_repair_callback = [](const indexed_triangle_set& mesh,
                                        indexed_triangle_set&       repaired_mesh,
                                        std::function<void(const char*, unsigned)> progress_callback,
                                        std::function<bool()>       cancel_callback,
                                        std::string*                error_message) -> bool {
-        if (cancel_callback && cancel_callback())
-            return false;
         if (progress_callback)
             progress_callback(_u8L("Repairing mesh").c_str(), 0);
 
+        struct Canceled {};
         TriangleMesh tm(mesh);
-        if (!MeshBoolean::cgal::repair(tm, nullptr, error_message))
-            return false;
-
-        if (cancel_callback && cancel_callback())
+        try {
+            if (!repair_mesh(tm, nullptr, error_message, [&cancel_callback](int) {
+                    if (cancel_callback && cancel_callback())
+                        throw Canceled();
+                }))
+                return false;
+        } catch (const Canceled &) {
             return false;
+        }
         repaired_mesh = tm.its;
         if (progress_callback)
             progress_callback(_u8L("Repairing mesh").c_str(), 100);
@@ -2683,12 +2683,12 @@ void TextureImportDialog::on_mesh_repair_decision_required(wxCommandEvent&)
         m_progress_dlg = nullptr;
     }
 
-#ifdef HAS_WIN10SDK
     Slic3r::GUI::MessageDialog dlg(initial ? GetParent() : this,
-        _L("The mesh has non-manifold geometry or open boundaries. You can import it as-is or repair it with Windows 3D repair service before importing."),
-        _L("Mesh repair"), wxYES_NO | wxICON_WARNING | wxYES_DEFAULT);
+        _L("The mesh has non-manifold geometry or open boundaries. You can import it as-is or repair it before importing."),
+        _L("Mesh repair"), wxYES_NO | wxCANCEL | wxICON_WARNING | wxYES_DEFAULT);
     dlg.SetButtonLabel(wxID_YES, _L("Import without repair"));
     dlg.SetButtonLabel(wxID_NO, _L("Repair and import"), true);
+    dlg.SetButtonLabel(wxID_CANCEL, _L("Cancel"));
     // "Repair and import" is the recommended action here, so the accent moves off the default YES
     // button onto NO. MsgDialog::add_button already styled both as ButtonType::Choice, so restyling
     // with the same type swaps only the palette and leaves the geometry alone.
@@ -2704,17 +2704,7 @@ void TextureImportDialog::on_mesh_repair_decision_required(wxCommandEvent&)
     dlg.Fit();
     dlg.CenterOnParent();
     int ret = dlg.ShowModal();
-    m_mesh_repair_decision = (ret == wxID_NO)
-        ? Slic3r::TexturePaintingSettings::MeshRepairDecision::RepairAndImport
-        : Slic3r::TexturePaintingSettings::MeshRepairDecision::ImportWithoutRepair;
-#else
-    Slic3r::GUI::MessageDialog dlg(initial ? GetParent() : this,
-        _L("Please note that the mesh has non-manifold geometry or open boundaries."),
-        _L("Mesh issue"), wxOK | wxCANCEL | wxICON_WARNING | wxOK_DEFAULT);
-    dlg.SetButtonLabel(wxID_OK, _L("Continue"), true);
-    dlg.SetButtonLabel(wxID_CANCEL, _L("Cancel"));
-    int ret = dlg.ShowModal();
-    if (ret != wxID_OK) {
+    if (ret == wxID_CANCEL) {
         m_cancel_flag = true;
         if (initial) {
             m_initial_computation_cancelled = true;
@@ -2727,8 +2717,9 @@ void TextureImportDialog::on_mesh_repair_decision_required(wxCommandEvent&)
         }
         return;
     }
-    m_mesh_repair_decision = Slic3r::TexturePaintingSettings::MeshRepairDecision::ImportWithoutRepair;
-#endif
+    m_mesh_repair_decision = (ret == wxID_NO)
+        ? Slic3r::TexturePaintingSettings::MeshRepairDecision::RepairAndImport
+        : Slic3r::TexturePaintingSettings::MeshRepairDecision::ImportWithoutRepair;
 
     start_computation(auto_color, initial);
 }

src/slic3r/GUI/UVEditorCanvas.cpp

@@ -36,6 +36,7 @@
 
 #include "3DScene.hpp"
 #include "BitmapCache.hpp"
+#include "GLCanvas3D.hpp"
 #include "GLShader.hpp"
 #include "GUI_App.hpp"
 #include "I18N.hpp"
@@ -939,7 +940,8 @@ void UVEditorCanvas::on_mouse(wxMouseEvent &evt)
             m_active_edge = (hit.first >= 0 && is_edge_selected(hit)) ? hit : std::pair<int, int>{ -1, -1 };
             m_gesture     = (m_active_edge.first >= 0) ? Gesture::MoveEdge : Gesture::Pan;
         } else {
-            const int hit = island_at(uv);
+            const std::vector<int> selection_before = m_selection;
+            const int              hit              = island_at(uv);
             if (hit >= 0) {
                 if (evt.ShiftDown()) {
                     // Shift adds to the selection (and makes the clicked one the new primary).
@@ -969,6 +971,10 @@ void UVEditorCanvas::on_mouse(wxMouseEvent &evt)
                 m_selected_island = -1;
             }
             m_gesture = (m_selected_island >= 0) ? Gesture::MoveIsland : Gesture::Pan;
+            // The owner shows the selection on the model and would not hear of this click otherwise in time: a
+            // click that clears the selection starts no gesture, and one that sets it reports only on release.
+            if (m_selection != selection_before)
+                run_command(Command::SelectionChanged);
         }
         grab_mouse();
         Refresh();
@@ -1319,8 +1325,13 @@ void UVEditorCanvas::on_size(wxSizeEvent &evt)
     // Update() flushes it immediately - still through the normal paint path (unlike calling
     // render() directly), which matters because this canvas shares the app's one GL context with
     // the 3D view and must not hijack it outside its own paint.
+    // Not while a 3D canvas frame is in progress, though: wxGTK delivers this size event synchronously
+    // when the texture displacement gizmo relays out the pane from its ImGui panel, i.e. from inside
+    // that frame, and flushing the paint there would take the shared context away from it. The Refresh()
+    // then runs the paint once the frame is over.
     Refresh();
-    Update();
+    if (!GLCanvas3D::is_frame_in_progress())
+        Update();
 }
 
 void UVEditorCanvas::on_leave(wxMouseEvent &evt)
@@ -1341,6 +1352,16 @@ void UVEditorCanvas::render()
 {
     if (m_context == nullptr || !IsShownOnScreen())
         return;
+    // Painted from inside a 3D canvas frame - a modal dialog the gizmo opened from its ImGui panel runs
+    // this paint, as does any other synchronous event raised there. Making this surface current now
+    // would take the shared context away from that canvas mid-frame: its remaining draws would land
+    // here and, on Mesa/X11, its SwapBuffers() would be a fatal BadMatch. Skip, but ask for another
+    // paint so the skipped one is not simply lost. The pane stays stale for as long as a nested modal
+    // loop keeps a frame on the stack, which is behind the dialog anyway.
+    if (GLCanvas3D::is_frame_in_progress()) {
+        Refresh();
+        return;
+    }
 
     // wxGLCanvas::SetCurrent() genuinely fails (returns false) on a canvas that isn't shown on
     // screen, and can also fail on a pixel-format mismatch with the context - and every GL call

src/slic3r/GUI/UVEditorCanvas.hpp

@@ -108,10 +108,12 @@ public:
     // the command callback - the canvas has the selection and the view, the gizmo has the layer.
     // `value` carries the new setting for the Set* commands (an angle, a flag as 0/1, or an index into
     // SelectMode / Background) and is 0 otherwise.
+    // SelectionChanged is sent by the canvas itself when a click changes the island selection. It carries
+    // nothing: the owner reads selected_islands() back, and only needs telling that it should look.
     enum class Command {
         FrameAll, ToggleSnap, AverageScale, CutSelectedIsland, ProjectFromView, JoinSelected, UnjoinSelected,
         Unwrap, SetSeamAngle, SetConnectIslands, SetSelectMode, SetMarkSeams, SetSeamPath, ClearSeams, ClearUVEdits,
-        SetBackground, PickTexture, PaneClosed
+        SetBackground, PickTexture, PaneClosed, SelectionChanged
     };
     void run_command(Command cmd, float value = 0.f);
     using CommandFn = std::function<void(Command, float)>;

src/slic3r/GUI/wxinit.h

@@ -1,15 +0,0 @@
-#ifndef slic3r_wxinit_hpp_
-#define slic3r_wxinit_hpp_
-
-#include <wx/wx.h>
-#include <wx/intl.h>
-#include <wx/html/htmlwin.h>
-
-// Perl redefines a _ macro, so we undef this one
-#undef _
-
-// We do want to use translation however, so define it as __ so we can do a find/replace
-// later when we no longer need to undef _
-#define __(s)                     wxGetTranslation((s))
-
-#endif

src/slic3r/Utils/FixModelByCgal.cpp

@@ -3,240 +3,115 @@
 #include <algorithm>
 #include <atomic>
 #include <chrono>
-#include <cmath>
 #include <condition_variable>
-#include "libslic3r/TriangleMesh.hpp"
-#include "libslic3r/BoundingBox.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/libslic3r.h"
-#include <exception>
 #include <cstddef>
-#include "libslic3r/Exception.hpp"
-#include <limits>
+#include <exception>
 #include <mutex>
-#include "slic3r/GUI/Widgets/ProgressDialog.hpp"
-#include <optional>
 #include <string>
 #include <thread>
-#include <utility>
 #include <vector>
+
 #include <wx/string.h>
 
-#include "libslic3r/MeshBoolean.hpp"
-#include "libslic3r/Model.hpp"
 #include "libslic3r/Format/bbs_3mf.hpp"
-#include "libslic3r/format.hpp"
+#include "libslic3r/MeshRepair.hpp"
+#include "libslic3r/Model.hpp"
 #include "libslic3r/Thread.hpp"
-#include "../GUI/I18N.hpp"
-#include "libslic3r/TriangleSelector.hpp"
-
-// Orca: This file provides utilities for repairing 3D model meshes using the CGAL library, handling mesh splitting, merging, and boolean operations.
+#include "slic3r/GUI/I18N.hpp"
+#include "slic3r/GUI/Widgets/ProgressDialog.hpp"
 
 namespace Slic3r {
 
 namespace {
 
-// Orca: Helper functions for analyzing mesh properties and transformations.
-
-bool is_not_3dimensional_part(const TriangleMesh &mesh)
+class RepairCanceledException : public std::exception
 {
-    // Orca: Determines if a mesh is degenerate or represents a non-3dimensional part by checking volume and bounding box dimensions.
-    if (mesh.its.indices.empty())
-        return true;
-
-    indexed_triangle_set tmp = mesh.its;
-    its_remove_degenerate_faces(tmp, true);
-    if (tmp.indices.empty())
-        return true;
-
-    const BoundingBoxf3 bbox = mesh.bounding_box();
-    const Vec3d size = bbox.size();
-    const double min_dim = std::min(size.x(), std::min(size.y(), size.z()));
-    const double max_dim = std::max(size.x(), std::max(size.y(), size.z()));
-    if (min_dim <= EPSILON)
-        return true;
-
-    const double volume = std::abs(its_volume(mesh.its));
-    const double bbox_volume = size.x() * size.y() * size.z();
-    if (volume <= EPSILON)
-        return true;
-
-    const double min_relative_thickness = 1e-6;
-    const double min_volume_ratio = 1e-6;
-    if (min_dim / max_dim <= min_relative_thickness)
-        return true;
-    if (bbox_volume > 0.0 && volume / bbox_volume <= min_volume_ratio)
-        return true;
-
-    return false;
-}
+public:
+    const char *what() const noexcept override { return "Model repair has been canceled"; }
+};
 
 } // namespace
 
-// Orca: Exception class for handling user-initiated cancellation of model repair operations.
-class RepairCanceledException : public std::exception {
-public:
-    const char* what() const noexcept override { return "Model repair has been canceled"; }
-};
-
-// Orca: Main function to repair model objects using CGAL, with progress dialog and cancellation support.
-// Returns false if fixing was canceled. fix_result contains error message if failed.
-bool fix_model_with_cgal_gui(ModelObject &model_object, int volume_idx, GUI::ProgressDialog &progress_dialog, const wxString &msg_header, std::string &fix_result, bool keep_painting)
+bool fix_model_with_cgal_gui(ModelObject &model_object, int volume_idx, GUI::ProgressDialog &progress_dialog, const wxString &msg_header, std::string &fix_result, bool keep_painting,
+                             bool *modified)
 {
-    // Hold SaveObjectGaurd to prevent backup manager from racing concurrent mesh mutations (use-after-free).
+    // Keeps the backup manager from reading a mesh while the worker replaces it.
     SaveObjectGaurd backup_gaurd(model_object);
 
-    // Orca: Synchronization primitives for progress updates between worker thread and GUI.
-    std::mutex mtx;
-    std::condition_variable condition;
-    struct Progress {
-        std::string message;
-        int         percent  = 0;
-        bool        updated  = false;
-    } progress;
+    std::vector<ModelVolume *> volumes;
+    if (volume_idx < 0)
+        volumes = model_object.volumes;
+    else if (std::size_t(volume_idx) < model_object.volumes.size())
+        volumes.push_back(model_object.volumes[volume_idx]);
 
+    std::mutex              mtx;
+    std::condition_variable condition;
+    struct Progress
+    {
+        std::string message;
+        int         percent = 0;
+        bool        updated = false;
+    } progress;
     std::atomic<bool> canceled = false;
     std::atomic<bool> finished = false;
+    bool              any_modified = false;
+    std::string       errors;
 
-    bool   success = false;
-    size_t ivolume = 0;
-
-    // Orca: Lambda for updating progress from worker thread.
-    auto on_progress = [&mtx, &condition, &ivolume, &model_object, &progress](const std::string &msg, unsigned prcnt) {
-        std::unique_lock<std::mutex> lock(mtx);
+    auto on_progress = [&mtx, &condition, &progress](const std::string &msg, int percent) {
+        std::lock_guard<std::mutex> lock(mtx);
         progress.message = msg;
-        const size_t total = std::max<size_t>(1, model_object.volumes.size());
-        progress.percent = int(std::floor((float(prcnt) + float(ivolume) * 100.f) / float(total)));
+        progress.percent = percent;
         progress.updated = true;
         condition.notify_all();
     };
 
-    // Orca: Worker thread that performs the actual model repair operations.
-    auto worker_thread = std::thread([&model_object, volume_idx, &ivolume, on_progress, &success, &canceled, &finished, &fix_result, keep_painting]() {
+    auto worker_thread = std::thread([&]() {
+        set_current_thread_name("cgal_fix_model");
         try {
-	        set_current_thread_name("cgal_fix_model");
+            for (std::size_t i = 0; i < volumes.size(); ++i) {
+                ModelVolume      *volume = volumes[i];
+                const std::string name   = volumes.size() > 1 ? volume->name : std::string();
+                const auto        report = [&](int percent) {
+                    if (canceled)
+                        throw RepairCanceledException();
+                    on_progress(name, int((100 * i + std::size_t(percent)) / volumes.size()));
+                };
+                report(0);
 
-            size_t start_volume = volume_idx == -1 ? 0 : size_t(volume_idx);
-            size_t end_volume   = volume_idx == -1 ? std::numeric_limits<size_t>::max() : size_t(volume_idx);
-
-            for (ivolume = start_volume; ivolume < model_object.volumes.size(); ++ivolume) {
-                if (volume_idx != -1 && ivolume > end_volume)
-                    break;
-                if (canceled)
-                    throw RepairCanceledException();
-
-                on_progress(_u8L("Repairing model object"), 10);
-
-                ModelVolume *volume = model_object.volumes[ivolume];
-
-                // Orca: Split splittable volumes into parts for individual processing.
-                size_t parts_count = 1;
-                if (volume->is_splittable()) {
-                    parts_count = volume->split(1, keep_painting);
-                    if (parts_count > 1) {
-                        const std::string msg = Slic3r::format(L("Split into %1% parts"), parts_count);
-                        on_progress(msg, 10);
-                    }
-                }
-
-                size_t part_end = std::min(ivolume + parts_count - 1, model_object.volumes.size() - 1);
-                if (volume_idx != -1)
-                    end_volume = part_end;
-
-                size_t removed_parts = 0;
-                for (size_t idx = part_end + 1; idx > ivolume; --idx) {
-                    const size_t part_idx = idx - 1;
-                    const ModelVolume *part_volume = model_object.volumes[part_idx];
-                    if (!is_not_3dimensional_part(part_volume->mesh()))
-                        continue;
-
-                    model_object.delete_volume(part_idx);
-                    ++removed_parts;
-                    if (part_end > 0)
-                        --part_end;
-                    else
-                        part_end = 0;
-                    if (volume_idx != -1)
-                        end_volume = part_end;
-                }
-
-                if (removed_parts >= parts_count) {
-                    ivolume = part_end;
-                    on_progress(_u8L("Repair finished"), 100);
-                    continue;
-                }
-
-                for (size_t part_idx = ivolume; part_idx <= part_end && part_idx < model_object.volumes.size(); ++part_idx) {
-                    ModelVolume *part_volume = model_object.volumes[part_idx];
-                    TriangleMesh mesh = part_volume->mesh();
-                    if (its_num_open_edges(mesh.its) != 0) {
-
-                        // Save painting for later remap
-                        const std::optional<TriangleSelector::SavedPainting> saved_painting = keep_painting ?
-                                                                                            part_volume->save_painting() :
-                                                                                            std::optional<TriangleSelector::SavedPainting>{};
-
-                        std::string error;
-                        if (!MeshBoolean::cgal::repair(mesh, nullptr, &error))
-                            throw Slic3r::RuntimeError(error.empty() ? _u8L("Repair failed") : error);
-
-                        part_volume->set_mesh(std::move(mesh));
-                        part_volume->calculate_convex_hull();
-                        part_volume->invalidate_convex_hull_2d();
-                        part_volume->set_new_unique_id();
-
-                        // Remap paint back
-                        part_volume->restore_painting(saved_painting);
-                    }
-                }
-
-                ivolume = part_end;
-
-                on_progress(_u8L("Repair finished"), 100);
+                MeshRepairStats stats;
+                std::string     error;
+                if (!volume->repair(keep_painting, &stats, &error, report))
+                    errors += (errors.empty() ? "" : "\n") + (volumes.size() > 1 ? volume->name + ": " : std::string()) + error;
+                any_modified = any_modified || stats.modified;
             }
-
-            model_object.invalidate_bounding_box();
-
-            if (ivolume > 0)
-                --ivolume;
-            on_progress(_u8L("Repair finished"), 100);
-            success = true;
-            finished = true;
-        } catch (RepairCanceledException &) {
+        } catch (const RepairCanceledException &) {
             canceled = true;
-            finished = true;
-            on_progress(_u8L("Repair canceled"), 100);
-        } catch (std::exception &ex) {
-            success = false;
-            finished = true;
-            fix_result = ex.what();
-            on_progress(ex.what(), 100);
+        } catch (const std::exception &ex) {
+            errors += (errors.empty() ? "" : "\n") + std::string(ex.what());
         }
+        // Volumes repaired before a cancel or an error keep their new mesh.
+        model_object.invalidate_bounding_box();
+        finished = true;
+        on_progress(_u8L("Repair finished"), 100);
     });
 
-    // Orca: Main GUI loop to update progress dialog and handle cancellation.
     while (!finished) {
         std::unique_lock<std::mutex> lock(mtx);
-        condition.wait_for(lock, std::chrono::milliseconds(250), [&progress]{ return progress.updated; });
-
-        // Decrease progress percent slightly to avoid auto-closing.
-        if (!progress_dialog.Update(progress.percent - 1, msg_header + _(progress.message)))
+        condition.wait_for(lock, std::chrono::milliseconds(250), [&progress] { return progress.updated; });
+        // One percent short of the maximum, so that the dialog does not close itself.
+        if (!progress_dialog.Update(std::max(0, progress.percent - 1), msg_header + wxString::FromUTF8(progress.message)))
             canceled = true;
         else
             progress_dialog.Fit();
-
         progress.updated = false;
     }
 
-    if (canceled) {
-        // Nothing to show.
-    } else if (success) {
-        fix_result.clear();
-    }
-
     if (worker_thread.joinable())
         worker_thread.join();
 
+    fix_result = canceled ? std::string() : errors;
+    if (modified)
+        *modified = any_modified;
     return !canceled;
 }
 

src/slic3r/Utils/FixModelByCgal.hpp

@@ -12,8 +12,9 @@ class Model;
 class ModelObject;
 class Print;
 
-// Return false if fixing was canceled. fix_result is empty on success.
-extern bool fix_model_with_cgal_gui(ModelObject &model_object, int volume_idx, GUI::ProgressDialog &progress_dlg, const wxString &msg_header, std::string &fix_result, bool keep_painting);
+// Return false if fixing was canceled. fix_result is empty on success; modified tells whether any mesh changed.
+extern bool fix_model_with_cgal_gui(ModelObject &model_object, int volume_idx, GUI::ProgressDialog &progress_dlg, const wxString &msg_header, std::string &fix_result, bool keep_painting,
+                                    bool *modified = nullptr);
 
 } // namespace Slic3r
 

src/slic3r/Utils/MoonrakerPrinterAgent.cpp

@@ -59,6 +59,42 @@ namespace websocket = beast::websocket;
 namespace net       = boost::asio;
 using tcp           = net::ip::tcp;
 
+// Decimal value of a string that is nothing but digits, or -1 when it is empty or not a number.
+int decimal_number(const std::string& digits)
+{
+    if (digits.empty() || !std::all_of(digits.begin(), digits.end(), [](unsigned char c) { return std::isdigit(c) != 0; }))
+        return -1;
+    try {
+        return std::stoi(digits);
+    } catch (...) {
+        return -1;
+    }
+}
+
+// Lane database keys address a lane either as "T<N>" (0-based tool index) or as "lane<N>"
+// (1-based, the AFC/Happy Hare style). Returns -1 when the key carries no usable lane number.
+int lane_index_from_key(const std::string& lane_key)
+{
+    if (lane_key.size() > 1 && (lane_key[0] == 'T' || lane_key[0] == 't'))
+        return decimal_number(lane_key.substr(1));
+    if (lane_key.size() > 4 && lane_key.compare(0, 4, "lane") == 0) {
+        const int lane_number = decimal_number(lane_key.substr(4));
+        return lane_number > 0 ? lane_number - 1 : -1;
+    }
+    return -1;
+}
+
+// AFC names toolheads "extruder", "extruder1", ... and derives the toolhead index from the name
+// itself (AFC_lane.lane_extruder_index): no suffix is 0, otherwise the suffix is the index.
+int extruder_index_from_name(const std::string& toolhead)
+{
+    if (toolhead == "extruder")
+        return 0;
+    if (toolhead.size() > 8 && toolhead.compare(0, 8, "extruder") == 0)
+        return decimal_number(toolhead.substr(8));
+    return -1;
+}
+
 struct WsEndpoint
 {
     std::string host;
@@ -441,19 +477,7 @@ int MoonrakerPrinterAgent::set_queue_on_main_fn(QueueOnMainFn fn)
 
 void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays)
 {
-
-    // Look up MachineObject via DeviceManager
-    auto* dev_manager = GUI::wxGetApp().getDeviceManager();
-    if (!dev_manager) {
-        return;
-    }
-    MachineObject* obj = dev_manager->get_my_machine(device_info.dev_id);
-    if (!obj) {
-        return;
-    }
-
     // Build BBL-format JSON for DevFilaSystemParser::ParseV1_0
-    nlohmann::json ams_json = nlohmann::json::object();
     nlohmann::json ams_array = nlohmann::json::array();
 
     // Calculate ams_exist_bits and tray_exist_bits
@@ -461,11 +485,9 @@ void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index,
     unsigned long tray_exist_bits = 0;
 
     for (int ams_id = 0; ams_id < ams_count; ++ams_id) {
-        ams_exist_bits |= (1 << ams_id);
-
-        nlohmann::json ams_unit = nlohmann::json::object();
-        ams_unit["id"] = std::to_string(ams_id);
-        ams_unit["info"] = "0002";  // treat as AMS_LITE 
+        if (ams_id < 32) {
+            ams_exist_bits |= (1UL << ams_id);
+        }
 
         nlohmann::json tray_array = nlohmann::json::array();
         int max_slot_in_this_ams = std::min(3, max_lane_index - ams_id * 4);
@@ -481,43 +503,135 @@ void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index,
                 }
             }
 
-            nlohmann::json tray_json = nlohmann::json::object();
-            tray_json["id"] = std::to_string(slot_id);
-            tray_json["tag_uid"] = "0000000000000000";
-
-            if (tray && tray->has_filament) {
-                tray_exist_bits |= (1 << slot_index);
-
-                tray_json["tray_info_idx"] = tray->tray_info_idx;
-                tray_json["tray_type"] = tray->tray_type;
-                tray_json["tray_color"] = normalize_color_value(tray->tray_color);
-
-                // Add temperature data if provided
-                if (tray->bed_temp > 0) {
-                    tray_json["bed_temp"] = std::to_string(tray->bed_temp);
-                }
-                if (tray->nozzle_temp > 0) {
-                    tray_json["nozzle_temp_max"] = std::to_string(tray->nozzle_temp);
-                }
-            } else {
-                tray_json["tray_info_idx"] = "";
-                tray_json["tray_type"] = "";
-                tray_json["tray_color"] = "00000000";
-                tray_json["tray_slot_placeholder"] = "1";
+            if (tray && tray->has_filament && slot_index < 32) {
+                tray_exist_bits |= (1UL << slot_index);
             }
 
-            tray_array.push_back(tray_json);
+            static const AmsTrayData empty_tray;
+            tray_array.push_back(make_ams_tray_json(std::to_string(slot_id), tray ? *tray : empty_tray));
         }
+
+        nlohmann::json ams_unit = nlohmann::json::object();
+        ams_unit["id"] = std::to_string(ams_id);
+        // Generic unit: type 1 (AMS) maps to AMSModel::GENERIC_AMS, which drives the
+        // variable-lane rendering. This is not a real Bambu AMS-Lite.
+        ams_unit["info"] = "0001";
         ams_unit["tray"] = tray_array;
         ams_array.push_back(ams_unit);
     }
 
+    BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::build_ams_payload: Parsed " << trays.size() << " trays";
+    submit_ams_payload(ams_array, ams_exist_bits, tray_exist_bits);
+}
+
+void MoonrakerPrinterAgent::build_ams_payload_grouped(const std::vector<AmsTrayData>& trays)
+{
+    // One AMS box per extruder, best effort. Lane-data changers (AFC, recent Happy Hare) report an
+    // extruder per lane but no physical box layout, so a box here is a logical feed group, not a
+    // discovered unit. Lanes without an extruder fall back to the main extruder.
+    std::map<int, std::vector<const AmsTrayData*>> boxes;
+    for (const auto& tray : trays) {
+        boxes[tray.extruder_id].push_back(&tray);
+    }
+
+    nlohmann::json ams_array = nlohmann::json::array();
+    unsigned long ams_exist_bits = 0;
+    unsigned long tray_exist_bits = 0;
+
+    int ams_id = 0;
+    // Cumulative lane index across all boxes, in box then slot order. A lane maps to exactly one
+    // extruder, so this is the lane's identity; the parser derives the same index for generic units.
+    int lane_index = 0;
+    for (auto& [extruder_id, lanes] : boxes) {
+        if (ams_id < 32) {
+            ams_exist_bits |= (1UL << ams_id);
+        }
+
+        // Keep a deterministic slot order within the box.
+        std::stable_sort(lanes.begin(), lanes.end(),
+                         [](const AmsTrayData* a, const AmsTrayData* b) { return a->slot_index < b->slot_index; });
+
+        nlohmann::json tray_array = nlohmann::json::array();
+        for (size_t slot = 0; slot < lanes.size(); ++slot) {
+            const AmsTrayData& tray = *lanes[slot];
+            // A logical feed group is not a four-slot Bambu AMS: the bit is the lane's cumulative
+            // index, not ams_id*4+slot. DevFilaSystemParser::ParseV1_0 reads the same index.
+            const int bit = lane_index++;
+            if (tray.has_filament && bit < 32) {
+                tray_exist_bits |= (1UL << bit);
+            }
+            tray_array.push_back(make_ams_tray_json(std::to_string(slot), tray));
+        }
+
+        nlohmann::json ams_unit = nlohmann::json::object();
+        ams_unit["id"] = std::to_string(ams_id);
+        // info: bits 0-3 = unit type (1 = AMS, i.e. AMSModel::GENERIC_AMS), bits 8-11 = bound
+        // extruder id. A logical feed group is a generic unit, not a Bambu AMS-Lite.
+        const int   info_val   = 1 | ((extruder_id & 0x0F) << 8);
+        const char* hex_digits = "0123456789ABCDEF";
+        std::string info       = "0000";
+        info[3] = hex_digits[info_val & 0x0F];
+        info[2] = hex_digits[(info_val >> 4) & 0x0F];
+        info[1] = hex_digits[(info_val >> 8) & 0x0F];
+        info[0] = hex_digits[(info_val >> 12) & 0x0F];
+        ams_unit["info"] = info;
+        ams_unit["tray"] = tray_array;
+        ams_array.push_back(ams_unit);
+        ++ams_id;
+    }
+
+    BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::build_ams_payload_grouped: Parsed " << trays.size()
+                            << " trays in " << boxes.size() << " extruder box(es)";
+    submit_ams_payload(ams_array, ams_exist_bits, tray_exist_bits);
+}
+
+nlohmann::json MoonrakerPrinterAgent::make_ams_tray_json(const std::string& tray_id, const AmsTrayData& tray)
+{
+    nlohmann::json tray_json = nlohmann::json::object();
+    tray_json["id"] = tray_id;
+    tray_json["tag_uid"] = "0000000000000000";
+
+    if (tray.has_filament) {
+        tray_json["tray_info_idx"] = tray.tray_info_idx;
+        tray_json["tray_type"] = tray.tray_type;
+        tray_json["tray_color"] = normalize_color_value(tray.tray_color);
+
+        // Add temperature data if provided
+        if (tray.bed_temp > 0) {
+            tray_json["bed_temp"] = std::to_string(tray.bed_temp);
+        }
+        if (tray.nozzle_temp > 0) {
+            tray_json["nozzle_temp_max"] = std::to_string(tray.nozzle_temp);
+        }
+    } else {
+        tray_json["tray_info_idx"] = "";
+        tray_json["tray_type"] = "";
+        tray_json["tray_color"] = "00000000";
+        tray_json["tray_slot_placeholder"] = "1";
+    }
+
+    return tray_json;
+}
+
+void MoonrakerPrinterAgent::submit_ams_payload(const nlohmann::json& ams_array, unsigned long ams_exist_bits, unsigned long tray_exist_bits)
+{
+    // Look up MachineObject via DeviceManager
+    auto* dev_manager = GUI::wxGetApp().getDeviceManager();
+    if (!dev_manager) {
+        return;
+    }
+    MachineObject* obj = dev_manager->get_my_machine(device_info.dev_id);
+    if (!obj) {
+        return;
+    }
+
     // Format as hex strings (matching BBL protocol)
     std::ostringstream ams_exist_ss;
     ams_exist_ss << std::hex << std::uppercase << ams_exist_bits;
     std::ostringstream tray_exist_ss;
     tray_exist_ss << std::hex << std::uppercase << tray_exist_bits;
 
+    nlohmann::json ams_json = nlohmann::json::object();
     ams_json["ams"] = ams_array;
     ams_json["ams_exist_bits"] = ams_exist_ss.str();
     ams_json["tray_exist_bits"] = tray_exist_ss.str();
@@ -528,7 +642,6 @@ void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index,
 
     // Call the parser to populate DevFilaSystem
     DevFilaSystemParser::ParseV1_0(print_json, obj, obj->GetFilaSystem().get(), false);
-    BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::build_ams_payload: Parsed " << trays.size() << " trays";
 
     // Set printer_type so update_sync_status() can match it against the preset's printer type.
     // Without this, the comparison fails and all sync badges are cleared.
@@ -568,17 +681,15 @@ bool MoonrakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSync
     if (fetch_moonraker_filament_data(trays, max_lane_index)) {
         BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::fetch_filament_info: Detected Moonraker filament system with "
                                 << (max_lane_index + 1) << " lanes";
-        int ams_count = (max_lane_index + 4) / 4;
-        build_ams_payload(ams_count, max_lane_index, trays);
+        build_ams_payload_grouped(trays);
         return true;
     }
 
-    // Attempt Happy Hare first (more widely adopted, supports more filament changers)
+    // Fall back to the Happy Hare `mmu` object for HH builds that do not publish lane_data
     if (fetch_hh_filament_info(trays, max_lane_index)) {
         BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::fetch_filament_info: Detected Happy Hare MMU with "
                                 << (max_lane_index + 1) << " gates";
-        int ams_count = (max_lane_index + 4) / 4;
-        build_ams_payload(ams_count, max_lane_index, trays);
+        build_ams_payload_grouped(trays);
         return true;
     }
 
@@ -684,6 +795,30 @@ int MoonrakerPrinterAgent::safe_json_int(const nlohmann::json& obj, const char*
     return 0;
 }
 
+int MoonrakerPrinterAgent::safe_json_int_flexible(const nlohmann::json& obj, const char* key, int default_value)
+{
+    auto it = obj.find(key);
+    if (it == obj.end())
+        return default_value;
+    if (it->is_number_integer())
+        return it->get<int>();
+    if (it->is_string()) {
+        const std::string s = it->get<std::string>();
+        if (s.empty())
+            return default_value;
+        try {
+            std::size_t consumed = 0;
+            const int   value    = std::stoi(s, &consumed);
+            if (consumed != s.size()) // reject partial parses such as "2oops"
+                return default_value;
+            return value;
+        } catch (...) {
+            return default_value;
+        }
+    }
+    return default_value;
+}
+
 std::string MoonrakerPrinterAgent::safe_array_string(const nlohmann::json& arr, int idx)
 {
     if (arr.is_array() && idx >= 0 && idx < static_cast<int>(arr.size()) && arr[idx].is_string())
@@ -787,28 +922,39 @@ bool MoonrakerPrinterAgent::fetch_moonraker_filament_data(std::vector<AmsTrayDat
     trays.clear();
     max_lane_index = 0;
 
+    // The lane_data namespace carries no extruder field; read the lane -> toolhead binding from the
+    // AFC printer objects so lanes on different toolheads end up in different AMS boxes.
+    std::map<std::string, int> lane_extruder;
+    fetch_afc_lane_extruders(lane_extruder);
+
     for (const auto& [lane_key, lane_obj] : value.items()) {
         if (!lane_obj.is_object()) {
             continue;
         }
 
-        // Extract lane index from the "lane" field (tool number, 0-based)
-        std::string lane_str = safe_json_string(lane_obj, "lane");
-        int lane_index = -1;
-        if (!lane_str.empty()) {
-            try {
-                lane_index = std::stoi(lane_str);
-            } catch (...) {
-                lane_index = -1;
-            }
-        }
-
+        // Lane tool number (0-based). AFC reports it as a string in the documented sample but it
+        // can also be a number; accept either and skip lanes without a usable index. Databases
+        // written without a "lane" field fall back to the key, which names the lane either as
+        // "T<N>" (0-based) or as "lane<N>" (1-based).
+        int lane_index = safe_json_int_flexible(lane_obj, "lane", -1);
         if (lane_index < 0) {
-            continue;
+            lane_index = lane_index_from_key(lane_key);
+            if (lane_index < 0) {
+                continue;
+            }
         }
 
         AmsTrayData tray;
         tray.slot_index = lane_index;
+        // AFC exposes the lane's extruder/toolhead as "extruder_index"; tolerate "extruder_id" as
+        // an alias. lane_data has neither, so fall back to the AFC lane objects and only then to
+        // the main extruder (best effort).
+        tray.extruder_id = safe_json_int_flexible(lane_obj, "extruder_index",
+                              safe_json_int_flexible(lane_obj, "extruder_id", -1));
+        if (tray.extruder_id < 0) {
+            const auto it = lane_extruder.find(lane_key);
+            tray.extruder_id = it != lane_extruder.end() ? it->second : 0;
+        }
         tray.tray_color = safe_json_string(lane_obj, "color");
         tray.tray_type = safe_json_string(lane_obj, "material");
         tray.bed_temp = safe_json_int(lane_obj, "bed_temp");
@@ -913,50 +1059,119 @@ bool MoonrakerPrinterAgent::fetch_hh_filament_info(std::vector<AmsTrayData>& tra
         return false;
     }
 
-    // Parse gate data
+    // Parse gate data. Every gate becomes a lane so empty/unknown gates surface
+    // as empty AMS slots rather than vanishing. HH is single-extruder, so all
+    // lanes belong to feed group 0.
     trays.clear();
-    max_lane_index = 0;
 
     for (int gate_idx = 0; gate_idx < num_gates; ++gate_idx) {
         // Check gate_status: -1 = unknown, 0 = empty, 1 or 2 = available
         int status = safe_array_int(gate_status, gate_idx);
-        if (status <= 0) {
-            continue;  // Skip unknown or empty gates
-        }
-
-        // Extract gate data
         std::string material = safe_array_string(gate_material, gate_idx);
         std::string color = safe_array_string(gate_color, gate_idx);
         int nozzle_temp = safe_array_int(gate_temperature, gate_idx);
 
-        // Skip if no material type (empty gate)
-        if (material.empty()) {
-            continue;
-        }
-
         AmsTrayData tray;
         tray.slot_index = gate_idx;
-        tray.tray_type = material;
-        tray.tray_color = color;
-        tray.nozzle_temp = nozzle_temp;
-        tray.bed_temp = 0;  // HH doesn't provide bed temp in gate arrays
-        tray.has_filament = true;
+        tray.extruder_id = 0;
 
-        auto* bundle = GUI::wxGetApp().preset_bundle;
-        tray.tray_info_idx = bundle
-            ? bundle->filaments.filament_id_by_type(tray.tray_type)
-            : map_filament_type_to_generic_id(tray.tray_type);
+        if (status > 0 && !material.empty()) {
+            tray.tray_type = material;
+            tray.tray_color = color;
+            tray.nozzle_temp = nozzle_temp;
+            tray.bed_temp = 0;  // HH doesn't provide bed temp in gate arrays
+            tray.has_filament = true;
+
+            auto* bundle = GUI::wxGetApp().preset_bundle;
+            tray.tray_info_idx = bundle
+                ? bundle->filaments.filament_id_by_type(tray.tray_type)
+                : map_filament_type_to_generic_id(tray.tray_type);
+        } else {
+            tray.has_filament = false;
+        }
 
-        max_lane_index = std::max(max_lane_index, gate_idx);
         trays.push_back(tray);
     }
 
-    if (trays.empty()) {
-        BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::fetch_hh_filament_info: No valid HH gates found";
+    max_lane_index = num_gates - 1;
+
+    return true;
+}
+
+// AFC writes its filament data into the lane_data database namespace, and the records of the
+// fixture/agent write path carry no extruder field, so the lane -> toolhead binding has to be read
+// from the printer objects: each AFC_lane <name>.extruder names the toolhead its lane feeds, and
+// the toolhead's name carries its own index. Best effort: on failure every lane keeps the fallback
+// of the main extruder.
+bool MoonrakerPrinterAgent::fetch_afc_lane_extruders(std::map<std::string, int>& lane_extruder)
+{
+    auto query_objects = [this](const std::string& query_string, nlohmann::json& out) {
+        auto http = Http::get(join_url(device_info.base_url, "/printer/objects/query?" + query_string));
+        if (!device_info.api_key.empty()) {
+            http.header("X-Api-Key", device_info.api_key);
+        }
+        std::string body;
+        unsigned    status_code = 0;
+        http.timeout_connect(5)
+            .timeout_max(10)
+            .on_complete([&](std::string response, unsigned status) {
+                body        = std::move(response);
+                status_code = status;
+            })
+            .perform_sync();
+        if (status_code != 200) {
+            return false;
+        }
+        out = nlohmann::json::parse(body, nullptr, false, true);
+        return !out.is_discarded();
+    };
+
+    nlohmann::json afc_json;
+    if (!query_objects("AFC", afc_json) || !afc_json.contains("result") ||
+        !afc_json["result"].contains("status") || !afc_json["result"]["status"].contains("AFC")) {
         return false;
     }
 
-    return true;
+    const auto& afc   = afc_json["result"]["status"]["AFC"];
+    const auto& lanes = afc.contains("lanes") ? afc["lanes"] : nlohmann::json::array();
+    if (!lanes.is_array() || lanes.empty()) {
+        return false;
+    }
+
+    // Query every lane object in one request; the object names are "AFC_lane <lane name>".
+    std::string query_string;
+    for (const auto& lane : lanes) {
+        if (!lane.is_string()) {
+            return false;
+        }
+        if (!query_string.empty()) {
+            query_string += "&";
+        }
+        query_string += "AFC_lane%20" + lane.get<std::string>();
+    }
+
+    nlohmann::json lanes_json;
+    if (!query_objects(query_string, lanes_json) || !lanes_json.contains("result") ||
+        !lanes_json["result"].contains("status")) {
+        return false;
+    }
+
+    const auto& status = lanes_json["result"]["status"];
+    for (const auto& lane : lanes) {
+        const std::string name = lane.get<std::string>();
+        const std::string key  = "AFC_lane " + name;
+        if (!status.contains(key) || !status[key].is_object() || !status[key].contains("extruder") ||
+            !status[key]["extruder"].is_string()) {
+            continue;
+        }
+        const std::string toolhead = status[key]["extruder"].get<std::string>();
+        const int toolhead_index   = extruder_index_from_name(toolhead);
+        if (toolhead_index >= 0) {
+            lane_extruder[name] = toolhead_index;
+        }
+    }
+
+    return !lane_extruder.empty();
 }
 
 int MoonrakerPrinterAgent::handle_request(const std::string& dev_id, const std::string& json_str)

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -7,6 +7,7 @@
 #include <functional>
 #include <cstdint>
 #include <atomic>
+#include <map>
 #include <memory>
 #include <mutex>
 #include <set>
@@ -88,6 +89,7 @@ protected:
     // Tray data for AMS payload building
     struct AmsTrayData {
         int         slot_index = 0;      // 0-based slot index
+        int         extruder_id = 0;     // Extruder this lane feeds (AFC extruder_index); 0 when unknown
         bool        has_filament = false;
         std::string tray_type;           // Material type (e.g., "PLA", "ASA")
         std::string tray_color;          // Raw color (#RRGGBB, 0xRRGGBB, or RRGGBBAA)
@@ -99,6 +101,10 @@ protected:
     // Build ams JSON and call parser
     void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
 
+    // Build ams JSON with one box per extruder (best effort, for lane_data-based filament
+    // changers such as AFC) and call the parser. Boxes are ordered by extruder id.
+    void build_ams_payload_grouped(const std::vector<AmsTrayData>& trays);
+
     // Methods that derived classes may need to override or access
     virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
     virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
@@ -163,10 +169,22 @@ private:
     // System-specific filament fetch methods
     bool fetch_hh_filament_info(std::vector<AmsTrayData>& trays, int& max_lane_index);
     bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    // Lane name -> toolhead index, read from the AFC printer objects (the lane_data database has no
+    // extruder field). Returns false when AFC is not present or the objects cannot be read.
+    bool fetch_afc_lane_extruders(std::map<std::string, int>& lane_extruder);
+
+    // Build one BBL tray JSON object (placeholder when the tray has no filament).
+    static nlohmann::json make_ams_tray_json(const std::string& tray_id, const AmsTrayData& tray);
+
+    // Wrap the AMS boxes into the payload ParseV1_0 understands and apply the pull-mode
+    // readiness state (printer_type, push counters, storage, module versions).
+    void submit_ams_payload(const nlohmann::json& ams_array, unsigned long ams_exist_bits, unsigned long tray_exist_bits);
 
     // JSON helper methods
     static std::string safe_json_string(const nlohmann::json& obj, const char* key);
     static int safe_json_int(const nlohmann::json& obj, const char* key);
+    // Accepts either a JSON number or a numeric string (AFC reports some fields as strings).
+    static int safe_json_int_flexible(const nlohmann::json& obj, const char* key, int default_value);
     static std::string safe_array_string(const nlohmann::json& arr, int idx);
     static int safe_array_int(const nlohmann::json& arr, int idx);
     static std::string normalize_color_value(const std::string& color);

src/slic3r/Utils/Profile.hpp

@@ -1,19 +0,0 @@
-#ifndef slic3r_GUI_Profile_hpp_
-#define slic3r_GUI_Profile_hpp_
-
-// Profiling support using the Shiny intrusive profiler
-//#define SLIC3R_PROFILE_GUI
-#if defined(SLIC3R_PROFILE) && defined(SLIC3R_PROFILE_GUI)
-	#include <Shiny/Shiny.h>
-	#define SLIC3R_GUI_PROFILE_FUNC() PROFILE_FUNC()
-	#define SLIC3R_GUI_PROFILE_BLOCK(name) PROFILE_BLOCK(name)
-	#define SLIC3R_GUI_PROFILE_UPDATE() PROFILE_UPDATE()
-	#define SLIC3R_GUI_PROFILE_OUTPUT(x) PROFILE_OUTPUT(x)
-#else
-	#define SLIC3R_GUI_PROFILE_FUNC()
-	#define SLIC3R_GUI_PROFILE_BLOCK(name)
-	#define SLIC3R_GUI_PROFILE_UPDATE()
-	#define SLIC3R_GUI_PROFILE_OUTPUT(x)
-#endif
-
-#endif // slic3r_GUI_Profile_hpp_

tests/cli/CMakeLists.txt

@@ -31,6 +31,22 @@ set_tests_properties(cli_project_missing_keys PROPERTIES
     SKIP_RETURN_CODE 77
     TIMEOUT 900)
 
+add_test(NAME cli_arrange_rotations
+    COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_arrange_rotations.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON}
+        ${CMAKE_SOURCE_DIR}/resources/profiles/BBL)
+set_tests_properties(cli_arrange_rotations PROPERTIES
+    LABELS "CLI;RequiresApp"
+    SKIP_RETURN_CODE 77
+    TIMEOUT 900)
+
+add_test(NAME cli_no_suitable_objects
+    COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_no_suitable_objects.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON}
+        ${CMAKE_SOURCE_DIR}/resources/profiles/BBL)
+set_tests_properties(cli_no_suitable_objects PROPERTIES
+    LABELS "CLI;RequiresApp"
+    SKIP_RETURN_CODE 77
+    TIMEOUT 900)
+
 add_test(NAME cli_malformed_input
     COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_malformed_input.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON})
 set_tests_properties(cli_malformed_input PROPERTIES

tests/cli/test_cli_arrange_rotations.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+# End-to-end check of the CLI's arrange rotation policy.
+#
+# Arrange is translate-only unless --allow-rotations is passed, so a bar that fits the bed only
+# diagonally is not placed and the plate ends up with nothing fully inside the print volume. The
+# run must then say that rotations were off, on stderr as well as in result.json, because
+# result.json is written on Linux only. Passing the flag must place the same bar and slice it, and
+# an object that fits axis-aligned must be unaffected by the default.
+#
+# usage: test_cli_arrange_rotations.sh <orca-slicer binary> <python3> <resources/profiles/BBL>
+set -u
+
+BIN="${1:-}"
+PY="${2:-python3}"
+PROFILES="${3:-}"
+# 77 is the test's SKIP_RETURN_CODE.
+[ -x "$BIN" ] || { echo "SKIP: orca-slicer binary not found: $BIN"; exit 77; }
+[ -d "$PROFILES" ] || { echo "FAIL: profiles directory not found: $PROFILES"; exit 1; }
+
+WORK="$(mktemp -d "${TMPDIR:-/tmp}/orca-cli-arrange-rotations.XXXXXX")"
+trap 'rm -rf "$WORK"' EXIT
+
+# box <file> <x> <y> <z>: an ASCII STL box, so the test needs no fixture.
+box() {
+    "$PY" - "$@" <<'EOF'
+import sys
+
+out, sx, sy, sz = sys.argv[1], float(sys.argv[2]), float(sys.argv[3]), float(sys.argv[4])
+v = [(x, y, z) for z in (0, sz) for y in (0, sy) for x in (0, sx)]
+with open(out, "w") as f:
+    f.write("solid box\n")
+    for a, b, c, d in ((0, 2, 3, 1), (4, 5, 7, 6), (0, 1, 5, 4), (2, 6, 7, 3), (0, 4, 6, 2), (1, 3, 7, 5)):
+        for tri in ((v[a], v[b], v[c]), (v[a], v[c], v[d])):
+            f.write("facet normal 0 0 0\nouter loop\n")
+            for p in tri:
+                f.write("vertex %g %g %g\n" % p)
+            f.write("endloop\nendfacet\n")
+    f.write("endsolid box\n")
+EOF
+}
+
+# Longer than the 256 mm bed edge, shorter than its 362 mm diagonal: it fits only turned.
+box "$WORK/bar.stl" 300 10 5
+# Fits axis-aligned, so the default must not change anything for it.
+box "$WORK/cube.stl" 10 10 10
+
+# slice <tag> <input> [option...] -> $WORK/<tag>/{rc,stdout,stderr,result.json}
+slice() {
+    local out="$WORK/$1" input="$2"; shift 2
+    mkdir -p "$out"
+    timeout 300 "$BIN" --datadir "$out/datadir" \
+        --load-settings "$PROFILES/machine/Bambu Lab X1 Carbon 0.4 nozzle.json;$PROFILES/process/0.20mm Standard @BBL X1C.json" \
+        --load-defaultfila "$@" --slice 0 --outputdir "$out" "$input" \
+        > "$out/stdout" 2> "$out/stderr"
+    echo "$?" > "$out/rc"
+}
+
+# exit_code <tag>: the CLI's negative code as the shell saw it, e.g. -50 arrives as 206.
+exit_code() { "$PY" -c "import sys; rc = int(open(sys.argv[1]).read()); print(rc - 256 if rc > 127 else rc)" "$WORK/$1/rc"; }
+
+fail() { echo "FAIL: $*"; exit 1; }
+
+# 1. Default: no flag, so no rotations, so the bar does not fit and the reason names rotation.
+slice default "$WORK/bar.stl"
+[ "$(exit_code default)" = "-50" ] || fail "default: expected -50, got $(exit_code default)"
+grep -q "Arrange ran without rotations" "$WORK/default/stderr" \
+    || fail "default: stderr does not mention rotations: $(cat "$WORK/default/stderr")"
+"$PY" - "$WORK/default/result.json" <<'EOF' || exit 1
+import json, sys
+
+result = json.load(open(sys.argv[1]))
+if result["return_code"] != -50:
+    sys.exit("FAIL: result.json return_code %s, expected -50" % result["return_code"])
+if "Arrange ran without rotations" not in result["error_string"]:
+    sys.exit("FAIL: result.json error_string does not mention rotations: %s" % result["error_string"])
+EOF
+
+# 2. The flag is coBool, so it takes no value: it must place the same bar and slice it.
+slice rotations "$WORK/bar.stl" --allow-rotations
+[ "$(exit_code rotations)" = "0" ] || fail "--allow-rotations: expected 0, got $(exit_code rotations); $(tail -n 5 "$WORK/rotations/stdout")"
+[ -s "$WORK/rotations/plate_1.gcode" ] || fail "--allow-rotations: no g-code written"
+
+# 3. An object that fits axis-aligned is unaffected by the default, and says nothing about rotation.
+slice cube "$WORK/cube.stl"
+[ "$(exit_code cube)" = "0" ] || fail "cube: expected 0, got $(exit_code cube); $(tail -n 5 "$WORK/cube/stdout")"
+[ -s "$WORK/cube/plate_1.gcode" ] || fail "cube: no g-code written"
+grep -q "Arrange ran without rotations" "$WORK/cube/stderr" && fail "cube: unexpected rotation message on a successful run"
+
+echo "PASS: arrange rotation default, its failure message, and the opt-in flag"

tests/cli/test_cli_no_suitable_objects.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# The reason recorded for CLI_NO_SUITABLE_OBJECTS (-50) has to fit the input the CLI was given.
+# Any input format is arranged and sliced, so an object larger than the bed empties the plate just
+# as a 3mf with an empty plate does, and the recorded reason must not send such a caller off to
+# inspect a 3mf or an upload that is not part of their run.
+#
+# usage: test_cli_no_suitable_objects.sh <orca-slicer binary> <python3> <resources/profiles/BBL>
+set -u
+
+BIN="${1:-}"
+PY="${2:-python3}"
+PROFILES="${3:-}"
+# 77 is the test's SKIP_RETURN_CODE.
+[ -x "$BIN" ] || { echo "SKIP: orca-slicer binary not found: $BIN"; exit 77; }
+[ -d "$PROFILES" ] || { echo "FAIL: profiles directory not found: $PROFILES"; exit 1; }
+
+WORK="$(mktemp -d "${TMPDIR:-/tmp}/orca-cli-no-suitable-objects.XXXXXX")"
+trap 'rm -rf "$WORK"' EXIT
+
+# box <file> <x> <y> <z>: an ASCII STL box, so the test needs no fixture.
+box() {
+    "$PY" - "$@" <<'EOF'
+import sys
+
+out, sx, sy, sz = sys.argv[1], float(sys.argv[2]), float(sys.argv[3]), float(sys.argv[4])
+v = [(x, y, z) for z in (0, sz) for y in (0, sy) for x in (0, sx)]
+with open(out, "w") as f:
+    f.write("solid box\n")
+    for a, b, c, d in ((0, 2, 3, 1), (4, 5, 7, 6), (0, 1, 5, 4), (2, 6, 7, 3), (0, 4, 6, 2), (1, 3, 7, 5)):
+        for tri in ((v[a], v[b], v[c]), (v[a], v[c], v[d])):
+            f.write("facet normal 0 0 0\nouter loop\n")
+            for p in tri:
+                f.write("vertex %g %g %g\n" % p)
+            f.write("endloop\nendfacet\n")
+    f.write("endsolid box\n")
+EOF
+}
+
+# Wider than the 256 mm bed and wider than its 362 mm diagonal, so no placement can fit it.
+box "$WORK/slab.stl" 400 400 5
+# Fits, so the run must succeed: proves the harness itself is sound.
+box "$WORK/cube.stl" 10 10 10
+
+# slice <tag> <input> [option...] -> $WORK/<tag>/{rc,stdout,stderr,result.json}
+slice() {
+    local out="$WORK/$1" input="$2"; shift 2
+    mkdir -p "$out"
+    timeout 300 "$BIN" --datadir "$out/datadir" \
+        --load-settings "$PROFILES/machine/Bambu Lab X1 Carbon 0.4 nozzle.json;$PROFILES/process/0.20mm Standard @BBL X1C.json" \
+        "$@" --slice 0 --outputdir "$out" "$input" \
+        > "$out/stdout" 2> "$out/stderr"
+    echo "$?" > "$out/rc"
+}
+
+# exit_code <tag>: the CLI's negative code as the shell saw it, e.g. -50 arrives as 206.
+exit_code() { "$PY" -c "import sys; rc = int(open(sys.argv[1]).read()); print(rc - 256 if rc > 127 else rc)" "$WORK/$1/rc"; }
+
+fail() { echo "FAIL: $*"; exit 1; }
+
+# --allow-rotations keeps this on the generic reason: a translate-only arrange has its own,
+# more specific one. The slab is wider than the 362 mm bed diagonal, so rotation cannot place it.
+slice slab "$WORK/slab.stl" --allow-rotations
+[ "$(exit_code slab)" = "-50" ] || fail "slab: expected -50, got $(exit_code slab); $(tail -n 5 "$WORK/slab/stdout")"
+"$PY" - "$WORK/slab/result.json" <<'EOF' || exit 1
+import json, sys
+
+result = json.load(open(sys.argv[1]))
+if result["return_code"] != -50:
+    sys.exit("FAIL: result.json return_code %s, expected -50" % result["return_code"])
+reason = result["error_string"]
+if not reason.strip():
+    sys.exit("FAIL: result.json carries no error_string")
+# The run was handed an STL and asked for g-code: neither a 3mf nor an upload exists to check.
+for word in ("3mf", "3MF", "upload"):
+    if word in reason:
+        sys.exit("FAIL: error_string mentions %r for an STL run: %s" % (word, reason))
+EOF
+
+slice cube "$WORK/cube.stl"
+[ "$(exit_code cube)" = "0" ] || fail "cube: expected 0, got $(exit_code cube); $(tail -n 5 "$WORK/cube/stdout")"
+[ -s "$WORK/cube/plate_1.gcode" ] || fail "cube: no g-code written"
+
+echo "PASS: the no-suitable-objects reason fits a non-3mf run"

tests/data/surface_model_geometric_set.step

@@ -0,0 +1,35 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION((''),'2;1');
+FILE_NAME('surface_model_geometric_set','2026-10-12T00:00:00',(''),(''),'','','');
+FILE_SCHEMA(('CONFIG_CONTROL_DESIGN'));
+ENDSEC;
+DATA;
+#1=APPLICATION_CONTEXT('configuration controlled 3d designs of mechanical parts and assemblies');
+#2=APPLICATION_PROTOCOL_DEFINITION('international standard','config_control_design',1994,#1);
+#3=MECHANICAL_CONTEXT('',#1,'mechanical');
+#4=PRODUCT('surfaces','surfaces','',(#3));
+#5=PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE('','',#4,.NOT_KNOWN.);
+#6=DESIGN_CONTEXT('',#1,'design');
+#7=PRODUCT_DEFINITION('','',#5,#6);
+#8=PRODUCT_DEFINITION_SHAPE('','',#7);
+#9=SHAPE_DEFINITION_REPRESENTATION(#8,#20);
+#10=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#11=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#12=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#13=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-6),#10,'distance_accuracy_value','');
+#14=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#13))GLOBAL_UNIT_ASSIGNED_CONTEXT((#10,#11,#12))REPRESENTATION_CONTEXT('',''));
+#15=CARTESIAN_POINT('',(0.,0.,0.));
+#16=DIRECTION('',(0.,0.,1.));
+#17=DIRECTION('',(1.,0.,0.));
+#18=AXIS2_PLACEMENT_3D('',#15,#16,#17);
+#19=GEOMETRIC_SET('',(#30,#40));
+#20=GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION('',(#18,#19),#14);
+#30=RECTANGULAR_TRIMMED_SURFACE('',#31,0.,10.,0.,10.,.T.,.T.);
+#31=PLANE('',#18);
+#40=RECTANGULAR_TRIMMED_SURFACE('',#41,0.,10.,0.,10.,.T.,.T.);
+#41=PLANE('',#42);
+#42=AXIS2_PLACEMENT_3D('',#43,#16,#17);
+#43=CARTESIAN_POINT('',(0.,0.,10.));
+ENDSEC;
+END-ISO-10303-21;

tests/fff_print/test_gcodeprocessor.cpp

@@ -178,6 +178,61 @@ bool is_block_move(const GCodeProcessorResult::MoveVertex &move)
 
 } // namespace
 
+TEST_CASE("Loaded manual tool change comments switch subsequent moves when enabled", "[GCodeProcessor][Regression]")
+{
+    const bool manual_filament_change = GENERATE(false, true);
+    CAPTURE(manual_filament_change);
+    const DynamicPrintConfig config = Test::multifilament_config(2, {
+        { "gcode_flavor",           "marlin" },
+        { "filament_type",          "PLA;PETG" },
+        { "manual_filament_change", manual_filament_change },
+    });
+    const bool was_bbl_printer = GCodeProcessor::s_IsBBLPrinter;
+    const ScopeGuard restore_bbl_printer([was_bbl_printer] { GCodeProcessor::s_IsBBLPrinter = was_bbl_printer; });
+    GCodeProcessor::s_IsBBLPrinter = false;
+
+    ScopedTemporaryFile temp(".gcode");
+    {
+        std::ofstream out(temp.string());
+        REQUIRE(out.is_open());
+        out << "; generated by OrcaSlicer\n"
+            << "G90\nM83\nT0\n"
+            << "G1 X10 Y10 Z0.2 F3000\n"
+            << "G1 X20 E1\n"
+            << "; MANUAL_TOOL_CHANGE T1\n"
+            << "G1 X30\nG1 X40 E1\nG1 X50\nG1 X60 E1\n";
+        // Let process_file load the embedded DynamicPrintConfig, as the standalone viewer does.
+        out << "; CONFIG_BLOCK_START\n";
+        for (const std::string &key : config.keys())
+            out << "; " << key << " = " << config.opt_serialize(key) << '\n';
+        out << "; CONFIG_BLOCK_END\n";
+        REQUIRE(out.good());
+    }
+
+    GCodeProcessor processor;
+    processor.process_file(temp.string());
+    const auto &result = processor.get_result();
+    REQUIRE(result.filaments_count == 2);
+
+    constexpr unsigned int tool_change_line = 7;
+    size_t before = 0;
+    size_t after = 0;
+    for (const auto &move : result.moves) {
+        if (!is_block_move(move))
+            continue;
+        CAPTURE(move.gcode_id, move.type);
+        if (move.gcode_id < tool_change_line) {
+            ++before;
+            CHECK(move.extruder_id == 0);
+        } else if (move.gcode_id > tool_change_line) {
+            ++after;
+            CHECK(move.extruder_id == (manual_filament_change ? 1 : 0));
+        }
+    }
+    REQUIRE(before > 0);
+    REQUIRE(after > 0);
+}
+
 TEST_CASE("Actual speed moves are inserted on their block's segment just before its move", "[GCodeProcessor]")
 {
     // 60 squares take several planner passes, which remap the blocks kept between passes.

tests/fff_print/test_gcodewriter.cpp

@@ -1748,3 +1748,29 @@ TEST_CASE("Percent accelerations resolve against the option they are a percentag
         REQUIRE(accelerations_by_role[role_name] == std::set<int>{ value });
     }
 }
+
+TEST_CASE("Initial filament start G-code tolerates a list shorter than the filament count", "[GCodeWriter]")
+{
+    // Two filaments but only one filament_start_gcode entry, and the only object prints on
+    // filament 2, so the BBL export starts on a filament past the end of the list.
+    DynamicPrintConfig config = multifilament_config(2);
+    config.set_key_value("filament_start_gcode", new ConfigOptionStrings({"; filament start"}));
+
+    Model model;
+    auto *obj = model.add_object();
+    obj->add_volume(cube(20));
+    obj->add_instance();
+    obj->config.set_key_value("extruder", new ConfigOptionInt(2));
+
+    Print print;
+    print.is_BBL_printer() = true;
+    arrange_objects_on_test_bed(model, config);
+    for (auto *mo : model.objects) {
+        mo->ensure_on_bed();
+        print.auto_assign_extruders(mo);
+    }
+    print.apply(model, config);
+    print.validate();
+
+    REQUIRE_NOTHROW(Slic3r::Test::gcode(print));
+}

tests/fff_print/test_helpers.cpp

@@ -223,7 +223,10 @@ DynamicPrintConfig multifilament_config(unsigned int filaments, std::initializer
 	// These are read by filament id during export but absent from filament_option_keys(),
 	// so set_num_filaments leaves them size 1; size them too, else out-of-range access.
 	const auto &defaults = FullPrintConfig::defaults();
-	for (const char *key : { "filament_type", "filament_vendor", "filament_start_gcode" })
+	for (const char *key : { "filament_type", "filament_vendor", "filament_start_gcode", "filament_change_length", "filament_change_length_nc",
+	                         "filament_ramming_travel_time", "filament_ramming_travel_time_nc",
+	                         "filament_ramming_volumetric_speed", "filament_ramming_volumetric_speed_nc",
+	                         "nozzle_temperature", "nozzle_temperature_initial_layer" })
 		static_cast<ConfigOptionVectorBase *>(config.option(key, true))->resize(filaments, defaults.option(key));
 
 	// flush_volumes_matrix must be sized filaments*filaments or export rejects it.

tests/fff_print/test_multifilament.cpp

@@ -315,6 +315,79 @@ TEST_CASE("Per-object wall filament override is honored", "[MultiFilament]")
     CHECK(tools_for_role(gcode, "infill")    == std::set<int>{ 0 }); // infill not overridden: stays on F1
 }
 
+// FanMover's guard against splitting a G1 inside custom gcode keys off the ";_FAN_MOVER_SKIP_START/END"
+// markers GCode::set_extruder() must emit around change_filament_gcode's output. Direct
+// toolchanges and Type2's wipe-tower toolchange (append_tcr2() calls set_extruder()) both go
+// through it; Type1's wipe-tower toolchange (WipeTowerIntegration::append_tcr(), append_tcr2's only
+// sibling caller of change_filament_gcode) needs the same bracketing of its own.
+TEST_CASE("Toolchange gcode is bracketed against FanMover splitting its moves", "[MultiFilament]")
+{
+    const std::string custom_gcode = "; fan full\nM106 P1 S255\nM400 S3\nG1 X77 F5000\nG1 X91 F3000\n";
+
+    // "direct": no prime tower, GCode::set_extruder() runs the toolchange. By-object sequencing
+    // with a per-object filament override is what makes one happen at all without a tower.
+    // "type1": a Type1 prime tower routes the toolchange through WipeTowerIntegration::append_tcr()
+    // instead (append_tcr2, Type2's equivalent, itself calls set_extruder() - so Type2 needs no
+    // separate case here).
+    const std::string path = GENERATE(as<std::string>{}, "direct", "type1");
+    CAPTURE(path);
+
+    std::string gcode_str;
+    if (path == "direct") {
+        const std::vector<std::vector<Slic3r::ConfigBase::SetDeserializeItem>> per_object_overrides = {
+            {}, { { "outer_wall_filament_id", "2" }, { "inner_wall_filament_id", "2" } }
+        };
+        DynamicPrintConfig config = multifilament_config(2, {
+            { "skirt_loops",           0 },
+            { "brim_type",             "no_brim" },
+            { "print_sequence",        "by object" },
+            { "change_filament_gcode", custom_gcode },
+            { "fan_speedup_time",      0.5 },
+            { "fan_kickstart",         0.1 },
+        });
+        gcode_str = slice_with_object_overrides({ cube(20), cube(20) }, config, per_object_overrides);
+    } else {
+        const std::vector<std::vector<Slic3r::ConfigBase::SetDeserializeItem>> per_object_overrides = {
+            { { "extruder", "1" } }, { { "extruder", "2" } }
+        };
+        DynamicPrintConfig config = multifilament_config(2, {
+            { "change_filament_gcode", custom_gcode },
+            { "fan_speedup_time",      0.5 },
+            { "fan_kickstart",         0.1 },
+            { "enable_prime_tower",    true },
+            { "wipe_tower_type",       "type1" },
+            { "prime_tower_width",     35 },
+            { "wipe_tower_x",          120 },
+            { "wipe_tower_y",          120 },
+            { "printable_area",        "0x0,200x0,200x200,0x200" },
+            { "skirt_loops",           0 },
+            { "brim_type",             "no_brim" },
+        });
+        gcode_str = slice_with_object_overrides({ cube(20), cube(20) }, config, per_object_overrides);
+    }
+
+    // The resolved-settings config footer echoes "change_filament_gcode = ..." with its value
+    // escaped, so drop it before counting or its own copy of "G1 X77 F5000" is miscounted.
+    const size_t footer_start = gcode_str.find("; CONFIG_BLOCK_START");
+    REQUIRE(footer_start != std::string::npos);
+    gcode_str.erase(footer_start);
+
+    auto count_occurrences = [](const std::string &haystack, const std::string &needle) {
+        size_t count = 0, pos = 0;
+        while ((pos = haystack.find(needle, pos)) != std::string::npos) {
+            ++count;
+            pos += needle.size();
+        }
+        return count;
+    };
+    const size_t total_waypoints = count_occurrences(gcode_str, "G1 X77 F5000");
+    const size_t bracketed       = count_occurrences(gcode_str, "M400 S3\nG1 X77 F5000");
+    REQUIRE(total_waypoints > 0);
+    CHECK(bracketed == total_waypoints);
+    // FanMover drops its own markers; only the start-of-print toolchange, which it never processes, keeps them.
+    CHECK(count_occurrences(gcode_str, ";_FAN_MOVER_SKIP_START") <= 1);
+}
+
 // With wait_for_temp_on_wipe_tower the blocking M109 moves from right after the Tn command to
 // a stop point parked beside the wipe tower (heat-up drool falls next to the tower, not onto
 // its top): tagged with _WAIT_FOR_TEMP_ON_WIPE_TOWER, after the toolchange and before the

tests/fff_print/test_print.cpp

@@ -43,6 +43,7 @@
 #include "libslic3r/GCode/GCodeProcessor.hpp"
 #include "libslic3r/Exception.hpp"
 #include "libslic3r/LifecycleEvents.hpp"
+#include "libslic3r/Utils.hpp"
 
 #include "test_helpers.hpp"
 #include "test_utils.hpp"
@@ -156,6 +157,81 @@ SCENARIO("Changing the number of solid shell layers does not make all surfaces i
     }
 }
 
+// Two copies of one object share a single slice. When a copy that has sliced itself becomes identical to an
+// earlier object, it keeps its own layers while that object slices and only then takes the shared layers over.
+TEST_CASE("An object that starts sharing another object's slices keeps its own layers until it takes them over", "[Print][Regression]")
+{
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({
+        { "layer_height",               0.2 },
+        { "initial_layer_print_height", 0.2 },
+        { "raft_layers",                1 }, // each object gets support layers of its own
+        { "sparse_infill_density",      "20%" }, // object_a's override below differs from this
+    });
+    // Activates the slicing-pipeline hook installed for the second slice below.
+    config.set_key_value("slicing_pipeline_plugin", new ConfigOptionStrings({"probe"}));
+
+    Print print;
+    Model model;
+    init_print({cube(20)}, print, model, config);
+    ModelObject *object_a = model.objects.front();
+    // add_object() gives the copy extruder 1, and objects only share slices when their configs match.
+    object_a->config.set_key_value("extruder", new ConfigOptionInt(1));
+    ModelObject *object_b = model.add_object(*object_a); // shares object_a's mesh
+    for (ModelInstance *instance : object_b->instances)
+        instance->set_offset(instance->get_offset() + Vec3d(40., 0., 0.));
+    // A per-object override makes the objects differ, so each slices itself.
+    object_a->config.set_key_value("sparse_infill_density", new ConfigOptionPercent(40));
+
+    print.apply(model, config);
+    print.process();
+    REQUIRE(print.objects().size() == 2);
+    // The non-const accessors hand out the layer vectors themselves, which the checks below compare.
+    PrintObject *print_b = print.get_object(1);
+    REQUIRE(print_b->model_object()->id() == object_b->id()); // Print slices its own copy of the model
+    REQUIRE(print_b->get_shared_object() == nullptr);
+    const LayerPtrs        own_layers         = print_b->layers();
+    const SupportLayerPtrs own_support_layers = print_b->support_layers();
+    REQUIRE(!own_layers.empty());
+    REQUIRE(!own_support_layers.empty());
+
+    // Without the override the objects are identical again: print_a redoes the steps the setting invalidated,
+    // and print_b shares it.
+    object_a->config.erase("sparse_infill_density");
+    print.apply(model, config);
+    REQUIRE(print.objects().size() == 2);
+    PrintObject *print_a = print.get_object(0);
+
+    // Erasing the override invalidates print_a's posPrepareInfill and the steps after it. Its hook is the first one
+    // print_a fires, and it runs after print_b starts sharing but before print_b takes the shared layers over.
+    bool hook_fired          = false;
+    bool shared_while_a_runs = false;
+    bool kept_layers         = false;
+    bool kept_support_layers = false;
+    {
+        Print::set_slicing_pipeline_hook_fn([&](Print &, const PrintObject *object, SlicingPipelineStepPlugin) {
+            if (object != print_a || hook_fired)
+                return;
+            hook_fired          = true;
+            shared_while_a_runs = print_b->get_shared_object() == print_a;
+            kept_layers         = print_b->layers() == own_layers;
+            kept_support_layers = print_b->support_layers() == own_support_layers;
+        });
+        const ScopeGuard reset_hook([] { Print::set_slicing_pipeline_hook_fn(nullptr); });
+        print.process();
+    }
+
+    REQUIRE(hook_fired);
+    CHECK(print.objects()[1] == print_b);
+    CHECK(shared_while_a_runs);
+    CHECK(kept_layers);
+    CHECK(kept_support_layers);
+    CHECK(print_b->get_shared_object() == print_a);
+    REQUIRE(!print_a->layers().empty());
+    CHECK(print_b->layers() == print_a->layers());
+    CHECK(print_b->support_layers() == print_a->support_layers());
+}
+
 // ---------------------------------------------------------------------------
 // Print::validate() warning collection
 //

tests/libslic3r/CMakeLists.txt

@@ -37,7 +37,6 @@ add_executable(${_TEST_NAME}_tests
     test_fill_plane_path.cpp
     test_fill_tpms_adaptive.cpp
     test_geometry.cpp
-    test_chromastack.cpp
     test_imex_arrange.cpp
     test_imex_helpers.cpp
     test_imex_zones.cpp
@@ -54,6 +53,7 @@ add_executable(${_TEST_NAME}_tests
     test_stl.cpp
     test_triangle_selector.cpp
     test_meshboolean.cpp
+    test_mesh_repair.cpp
     test_trianglemesh_slicer.cpp
     test_marchingsquares.cpp
     test_lay_on_face.cpp

tests/libslic3r/test_3mf.cpp

@@ -28,6 +28,7 @@
 #include <miniz.h>
 #include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/TriangleSelector.hpp"
+#include "libslic3r/TextureDisplacement.hpp"
 #include <memory>
 #include <cstdint>
 #include <ios>
@@ -38,6 +39,7 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <algorithm>
 #include <functional>
+#include <initializer_list>
 
 #include <catch2/catch_tostring.hpp>
 #include <Eigen/Core>
@@ -349,6 +351,24 @@ static bool replace_in_3mf_entry(const std::string& path, const std::string& suf
     return replaced;
 }
 
+// Stores `model` as a one-plate project.
+static void store_project(Model& model, const std::string& path, SaveStrategy strategy)
+{
+    ScopedTemporaryDir backup_dir("orca_paint_src");
+    model.set_backup_path(backup_dir.string());
+
+    DynamicPrintConfig cfg;
+    PlateData          plate;
+    plate.plate_index = 0;
+    StoreParams sp;
+    sp.path     = path.c_str();
+    sp.model    = &model;
+    sp.config   = &cfg;
+    sp.strategy = strategy;
+    sp.plate_data_list.push_back(&plate);
+    REQUIRE(store_bbs_3mf(sp));
+}
+
 // Stores a one-plate project holding a cube whose first two facets are painted Extruder2 and
 // Extruder3, which the exporter writes as paint_color="8" and paint_color="0C".
 static void store_painted_cube(const std::string& path)
@@ -363,19 +383,7 @@ static void store_painted_cube(const std::string& path)
         selector.set_facet(1, EnforcerBlockerType::Extruder3);
         REQUIRE(volume->mmu_segmentation_facets.set(selector));
     }
-    ScopedTemporaryDir backup_dir("orca_paint_src");
-    model.set_backup_path(backup_dir.string());
-
-    DynamicPrintConfig cfg;
-    PlateData          plate;
-    plate.plate_index = 0;
-    StoreParams sp;
-    sp.path     = path.c_str();
-    sp.model    = &model;
-    sp.config   = &cfg;
-    sp.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
-    sp.plate_data_list.push_back(&plate);
-    REQUIRE(store_bbs_3mf(sp));
+    store_project(model, path, SaveStrategy::Zip64 | SaveStrategy::Silence);
 }
 
 // Loads `path` through the BBS importer into `model`, releasing the plates it returns. The
@@ -501,6 +509,163 @@ TEST_CASE("A project with malformed paint data loads without the damaged facet",
     REQUIRE(selector.num_facets(EnforcerBlockerType::Extruder3) == 1);
 }
 
+// Paints `triangles` of `volume` on texture displacement layer slot `slot`.
+static void paint_texture_slot(ModelVolume& volume, int slot, std::initializer_list<int> triangles)
+{
+    TriangleSelector selector(volume.mesh());
+    for (const int triangle : triangles)
+        selector.set_facet(triangle, EnforcerBlockerType::ENFORCER);
+    REQUIRE(volume.texture_displacement_facet(slot).set(selector));
+}
+
+// Every triangle's texture paint on every slot, in the form the exporter writes it, so two volumes
+// compare equal only when the same triangles are painted on the same slots.
+static std::vector<std::string> texture_paint(const ModelVolume& volume)
+{
+    std::vector<std::string> paint;
+    for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
+        for (size_t i = 0; i < volume.mesh().its.indices.size(); ++i)
+            paint.push_back(volume.texture_displacement_facet(slot).get_triangle_as_string(int(i)));
+    return paint;
+}
+
+// A cube with one texture displacement layer in slot 2 and texture paint on gapped triangles of two
+// slots. The layer's image bytes need not decode: the archive stores them as they are.
+static ModelVolume& add_texture_displaced_cube(Model& model)
+{
+    ModelObject* object = model.add_object();
+    ModelVolume* volume = object->add_volume(make_cube(10., 10., 10.));
+    object->add_instance();
+
+    TextureDisplacementLayer layer;
+    layer.slot       = 2;
+    layer.name       = "Bark";
+    layer.depth_mm   = 1.25f;
+    layer.image_data = std::make_shared<std::vector<unsigned char>>(std::vector<unsigned char>{ 0x89, 'P', 'N', 'G', 1, 2, 3 });
+    volume->texture_displacement_layers.push_back(layer);
+    volume->texture_displacement_options.active_slot = 2;
+
+    paint_texture_slot(*volume, 2, { 3, 7 });
+    paint_texture_slot(*volume, 5, { 10 });
+    return *volume;
+}
+
+TEST_CASE("Texture displacement layers, textures and paint survive a project round trip", "[3mf]")
+{
+    // A single model file, and one file per object (read by a separate importer).
+    const SaveStrategy strategy = GENERATE(SaveStrategy::Zip64 | SaveStrategy::Silence,
+                                           SaveStrategy::Zip64 | SaveStrategy::Silence | SaveStrategy::SplitModel);
+    INFO("save strategy " << int(strategy));
+
+    ScopedTemporaryFile temp(".3mf");
+    Model               source;
+    const ModelVolume&  painted = add_texture_displaced_cube(source);
+    const std::vector<std::string> paint = texture_paint(painted);
+    REQUIRE(std::count_if(paint.begin(), paint.end(), [](const std::string& s) { return !s.empty(); }) == 3);
+    store_project(source, temp.string(), strategy);
+
+    ScopedTemporaryDir backup_dir("orca_texdisp_dst");
+    Model              model;
+    REQUIRE(load_project(temp.string(), model, backup_dir));
+    REQUIRE(model.objects.size() == 1);
+    const ModelVolume& volume = *model.objects.front()->volumes.front();
+
+    REQUIRE(volume.texture_displacement_layers.size() == 1);
+    const TextureDisplacementLayer& layer = volume.texture_displacement_layers.front();
+    CHECK(layer.slot == 2);
+    CHECK(layer.name == "Bark");
+    CHECK_THAT(layer.depth_mm, Catch::Matchers::WithinAbs(1.25f, 1e-6f));
+    REQUIRE(layer.image_data);
+    CHECK(*layer.image_data == *painted.texture_displacement_layers.front().image_data);
+    CHECK(volume.texture_displacement_options.active_slot == 2);
+    CHECK(texture_paint(volume) == paint);
+}
+
+TEST_CASE("Volumes sharing a mesh keep their own texture displacement paint", "[3mf]")
+{
+    Model        source;
+    ModelObject* first_object = source.add_object();
+    ModelVolume* first        = first_object->add_volume(make_cube(10., 10., 10.));
+    first_object->add_instance();
+    ModelVolume* second = source.add_object(*first_object)->volumes.front();
+    REQUIRE(second->mesh_ptr() == first->mesh_ptr());
+    paint_texture_slot(*first, 0, { 3 });
+    paint_texture_slot(*second, 0, { 7 });
+
+    // What a project save from the app uses: one file per object, an identical mesh written once.
+    ScopedTemporaryFile temp(".3mf");
+    store_project(source, temp.string(),
+                  SaveStrategy::Zip64 | SaveStrategy::Silence | SaveStrategy::SplitModel | SaveStrategy::ShareMesh);
+
+    ScopedTemporaryDir backup_dir("orca_texdisp_dst");
+    Model              model;
+    REQUIRE(load_project(temp.string(), model, backup_dir));
+    REQUIRE(model.objects.size() == 2);
+    CHECK(texture_paint(*model.objects[0]->volumes.front()) == texture_paint(*first));
+    CHECK(texture_paint(*model.objects[1]->volumes.front()) == texture_paint(*second));
+}
+
+TEST_CASE("A texture displacement layer never loads its image from outside the project", "[3mf]")
+{
+    // A file the layer names, on the machine opening the project, that the project did not carry.
+    ScopedTemporaryFile texture(".png");
+    {
+        boost::nowide::ofstream file(texture.string(), std::ios::binary);
+        file << "not part of the project";
+    }
+    REQUIRE(boost::filesystem::file_size(texture.path()) > 0);
+
+    Model        source;
+    ModelObject* object = source.add_object();
+    ModelVolume* volume = object->add_volume(make_cube(10., 10., 10.));
+    object->add_instance();
+    TextureDisplacementLayer layer;
+    layer.slot     = 0;
+    layer.name     = "Elsewhere";
+    layer.path     = texture.string();
+    layer.depth_mm = 0.75f;
+    volume->texture_displacement_layers.push_back(layer);
+
+    ScopedTemporaryFile temp(".3mf");
+    store_project(source, temp.string(), SaveStrategy::Zip64 | SaveStrategy::Silence);
+
+    ScopedTemporaryDir backup_dir("orca_texdisp_dst");
+    Model              model;
+    REQUIRE(load_project(temp.string(), model, backup_dir));
+    REQUIRE(model.objects.size() == 1);
+    const std::vector<TextureDisplacementLayer>& layers = model.objects.front()->volumes.front()->texture_displacement_layers;
+    REQUIRE(layers.size() == 1);
+    CHECK(layers.front().name == "Elsewhere");
+    CHECK_THAT(layers.front().depth_mm, Catch::Matchers::WithinAbs(0.75f, 1e-6f));
+    CHECK_FALSE(layers.front().image_data);
+}
+
+TEST_CASE("A project with a malformed texture displacement value still loads", "[3mf][Regression]")
+{
+    const auto [from, to] = GENERATE(table<std::string, std::string>({
+        { "\"islands\":[]", "\"islands\":[[null,0,0,1]]" }, // a number that is null
+        { "\"slot\":2", "\"slot\":8" },                     // a slot past the last
+    }));
+    INFO(from << " -> " << to);
+
+    ScopedTemporaryFile temp(".3mf");
+    Model               source;
+    const ModelVolume&  painted = add_texture_displaced_cube(source);
+    store_project(source, temp.string(), SaveStrategy::Zip64 | SaveStrategy::Silence);
+    REQUIRE(replace_in_3mf_entry(temp.string(), ".json", from, to));
+
+    ScopedTemporaryDir backup_dir("orca_texdisp_dst");
+    Model              model;
+    bool               loaded = false;
+    REQUIRE_NOTHROW(loaded = load_project(temp.string(), model, backup_dir));
+    REQUIRE(loaded);
+    REQUIRE(model.objects.size() == 1);
+    const ModelVolume& volume = *model.objects.front()->volumes.front();
+    // The layer stack is dropped as a whole; the paint, stored apart from it, still loads.
+    CHECK(volume.texture_displacement_layers.empty());
+    CHECK(texture_paint(volume) == texture_paint(painted));
+}
+
 // The recipe lives only in the BBS-native backend, because that is the only one that runs:
 // store_bbs_3mf is the sole exporter the app calls, and 3mf.cpp's load_3mf is reached only for
 // files fingerprinted as PrusaSlicer's, which never carry a recipe. This locks in both halves:

tests/libslic3r/test_chromastack.cpp

@@ -1,379 +0,0 @@
-#include <catch2/catch_approx.hpp>
-#include <catch2/catch_test_macros.hpp>
-#include <catch2/matchers/catch_matchers_floating_point.hpp>
-
-#include <algorithm>
-#include <cmath>
-#include <cstdint>
-#include <vector>
-
-#include "libslic3r/Color.hpp"
-#include "libslic3r/ChromaStack.hpp"
-#include "libslic3r/PNGReadWrite.hpp"
-
-using namespace Slic3r;
-using Catch::Matchers::WithinAbs;
-using Catch::Matchers::WithinRel;
-
-namespace {
-
-ChromaFilament filament(int index, const ColorRGB &color, float td_mm)
-{
-    ChromaFilament f;
-    f.filament = index;
-    f.color    = color;
-    f.td_mm    = td_mm;
-    return f;
-}
-
-ChromaBand band(const ChromaFilament &f, int layers)
-{
-    ChromaBand b;
-    b.filament = f;
-    b.layers   = layers;
-    return b;
-}
-
-// An opaque filament (TD 1 hides what is under it within 0.1 mm) and a translucent one (TD 8 needs
-// most of a millimetre), which is the whole range the model has to behave sensibly over.
-const ChromaFilament WHITE_OPAQUE      = filament(0, ColorRGB(1.f, 1.f, 1.f), 1.f);
-const ChromaFilament BLACK_OPAQUE      = filament(1, ColorRGB(0.f, 0.f, 0.f), 1.f);
-const ChromaFilament BLACK_TRANSLUCENT = filament(2, ColorRGB(0.f, 0.f, 0.f), 8.f);
-
-float luminance(const ColorRGB &c) { return 0.2126f * c.r() + 0.7152f * c.g() + 0.0722f * c.b(); }
-
-} // namespace
-
-TEST_CASE("A stack's palette has one entry per printed layer", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 4;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 10) };
-
-    // The base is backing under the picture, not part of a band: the bands are the 12 layers the
-    // picture is built from, and the stack is those on top of the 4 the model already has.
-    REQUIRE(stack.relief_layers() == 12);
-    REQUIRE(stack.total_layers() == 16);
-    REQUIRE_THAT(stack.depth_mm(), WithinAbs(12 * 0.08f, 1e-6f));
-
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    REQUIRE(palette.size() == 17);
-    // Index 0 is the base's own colour, so a column one layer tall is exactly its filament - whatever
-    // that filament's transmission distance.
-    REQUIRE(palette[0] == palette[1]);
-    REQUIRE_THAT(luminance(palette[1]), WithinAbs(1.f, 1e-3f));
-}
-
-TEST_CASE("A run of one filament gives the same palette however it is split into bands", "[ChromaStack]")
-{
-    // The property that justifies compositing layer by layer at all: transmittance multiplies, so
-    // cutting a run in two must not change the colours. A model without it would make the palette
-    // depend on how the stack was typed in.
-    ChromaStack one;
-    one.layer_height_mm = 0.1f;
-    one.base_layers     = 0;
-    one.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
-
-    ChromaStack split = one;
-    split.bands         = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 3), band(BLACK_TRANSLUCENT, 5) };
-
-    const std::vector<ColorRGB> a = chroma_palette(one);
-    const std::vector<ColorRGB> b = chroma_palette(split);
-    REQUIRE(a.size() == b.size());
-    for (size_t i = 0; i < a.size(); ++i)
-        REQUIRE_THAT(luminance(a[i]), WithinAbs(luminance(b[i]), 1e-5f));
-}
-
-TEST_CASE("A translucent filament darkens gradually and an opaque one at once", "[ChromaStack]")
-{
-    ChromaStack translucent;
-    translucent.layer_height_mm = 0.08f;
-    translucent.base_layers     = 0;
-    translucent.bands           = { band(WHITE_OPAQUE, 1), band(BLACK_TRANSLUCENT, 12) };
-    const std::vector<ColorRGB> slow = chroma_palette(translucent);
-
-    // Monotonically darker, and still short of the filament's own black after a single layer: that
-    // gradient is what a ChromaStack stack prints its midtones with.
-    for (size_t i = 2; i < slow.size(); ++i)
-        REQUIRE(luminance(slow[i]) < luminance(slow[i - 1]));
-    REQUIRE(luminance(slow[2]) > 0.5f);
-    // Twelve layers of a TD 8 filament pass under 3% of the light, which is the dark end of the ramp
-    // rather than true black - and that is the honest prediction, not a rounding artifact.
-    REQUIRE(luminance(slow.back()) < 0.25f);
-
-    ChromaStack opaque;
-    opaque.layer_height_mm = 0.08f;
-    opaque.base_layers     = 0;
-    opaque.bands           = { band(WHITE_OPAQUE, 1), band(BLACK_OPAQUE, 12) };
-    const std::vector<ColorRGB> fast = chroma_palette(opaque);
-    // TD 1 is opaque within about 0.1 mm, so two layers of it leave little of the white showing.
-    REQUIRE(luminance(fast[3]) < 0.2f);
-}
-
-TEST_CASE("Solving a picture of the palette's own colors reproduces it exactly", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
-
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    const int                   relief  = stack.relief_layers();
-
-    // One pixel per reachable height, in order.
-    std::vector<uint8_t> rgb;
-    for (int i = 0; i <= relief; ++i) {
-        const ColorRGB &c = palette[size_t(stack.base_layers + i)];
-        rgb.push_back(uint8_t(std::lround(c.r() * 255.f)));
-        rgb.push_back(uint8_t(std::lround(c.g() * 255.f)));
-        rgb.push_back(uint8_t(std::lround(c.b() * 255.f)));
-    }
-
-    const ChromaSolve solve = chroma_solve(rgb.data(), relief + 1, 1, stack);
-    REQUIRE_FALSE(solve.empty());
-    REQUIRE(solve.width == relief + 1);
-    REQUIRE(solve.levels.size() == size_t(relief + 1));
-    // Every pixel comes back as the colour it was generated from, and the error is rounding only.
-    //
-    // The colour rather than the height: the bottom band prints in the same filament as the base, so
-    // its first layers show exactly the colour the base already showed, and any of those heights is a
-    // correct answer for that pixel. Asserting the height would be asserting which of several equally
-    // right answers the search happens to reach first.
-    for (int i = 0; i <= relief; ++i) {
-        const int chosen = int(solve.levels[size_t(i)]);
-        REQUIRE(chosen >= stack.base_layers);
-        REQUIRE(chosen <= stack.total_layers());
-        const ColorRGB &got  = palette[size_t(chosen)];
-        const ColorRGB &want = palette[size_t(stack.base_layers + i)];
-        REQUIRE_THAT(got.r(), WithinAbs(want.r(), 2.f / 255.f));
-        REQUIRE_THAT(got.g(), WithinAbs(want.g(), 2.f / 255.f));
-        REQUIRE_THAT(got.b(), WithinAbs(want.b(), 2.f / 255.f));
-    }
-    // Only 8-bit rounding of the palette separates the two, which near black is still under one dE.
-    REQUIRE(solve.max_delta_e < 2.);
-
-    // The height map's ends are the base and the top of the stack, which is what ties a grey level to
-    // a printed layer.
-    REQUIRE(solve.grey.front() == 0);
-    REQUIRE(solve.grey.back() == 255);
-}
-
-TEST_CASE("A picture the filaments cannot reach is reported as a poor match", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
-
-    // Saturated red against a stack of white and black: no height can produce it, and the panel's
-    // warning depends on the solve saying so rather than silently picking a grey.
-    const std::vector<uint8_t> red{ 255, 0, 0 };
-    const ChromaSolve        solve = chroma_solve(red.data(), 1, 1, stack);
-    REQUIRE_FALSE(solve.empty());
-    REQUIRE(solve.mean_delta_e > 15.);
-}
-
-TEST_CASE("Dithering keeps every pixel in the stack's range", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
-    stack.dither          = true;
-
-    // A flat mid-grey: the error diffusion has to spread it over neighbouring heights without ever
-    // leaving the stack, which is what a clamped palette index would quietly get wrong.
-    std::vector<uint8_t> grey(size_t(16 * 16) * 3, 128);
-    const ChromaSolve  solve = chroma_solve(grey.data(), 16, 16, stack);
-    REQUIRE_FALSE(solve.empty());
-    REQUIRE(solve.levels.size() == size_t(16 * 16));
-    const auto [lo, hi] = std::minmax_element(solve.levels.begin(), solve.levels.end());
-    REQUIRE(int(*lo) >= stack.base_layers);
-    REQUIRE(int(*hi) <= stack.total_layers());
-}
-
-TEST_CASE("The solved height map is an 8-bit grayscale PNG of the picture's size", "[ChromaStack]")
-{
-    // The displacement pipeline reads one thing from a layer: an 8-bit grayscale PNG. A solve that
-    // produced anything else would leave the relief silently flat.
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 6) };
-
-    std::vector<uint8_t> picture(size_t(8 * 4) * 3);
-    for (size_t i = 0; i < picture.size(); ++i)
-        picture[i] = uint8_t(i % 256);
-
-    const ChromaSolve              solve = chroma_solve(picture.data(), 8, 4, stack);
-    const std::vector<unsigned char> png   = chroma_encode_height_png(solve);
-    REQUIRE_FALSE(png.empty());
-
-    const png::ReadBuf  buf{ png.data(), png.size() };
-    png::ImageGreyscale decoded;
-    REQUIRE(png::is_png(buf));
-    REQUIRE(png::decode_png(buf, decoded));
-    REQUIRE(decoded.cols == 8);
-    REQUIRE(decoded.rows == 4);
-    REQUIRE(decoded.buf == solve.grey);
-}
-
-TEST_CASE("Each band becomes a height range, and a repeated filament is not a swap", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.1f;
-    stack.base_layers     = 0;
-    stack.bands           = { band(WHITE_OPAQUE, 5), band(BLACK_OPAQUE, 3), band(BLACK_OPAQUE, 2) };
-
-    const std::vector<ChromaRange> ranges = chroma_ranges(stack, 0.);
-    // Three bands, two filaments: the second and third merge, because nothing is swapped between them.
-    REQUIRE(ranges.size() == 2);
-    REQUIRE_THAT(ranges[0].z_min, WithinAbs(0., 1e-9));
-    REQUIRE_THAT(ranges[0].z_max, WithinAbs(0.5, 1e-9));
-    REQUIRE(ranges[0].filament == WHITE_OPAQUE.filament);
-    REQUIRE_THAT(ranges[1].z_min, WithinAbs(0.5, 1e-9));
-    REQUIRE_THAT(ranges[1].z_max, WithinAbs(1.0, 1e-9));
-    REQUIRE(ranges[1].filament == BLACK_OPAQUE.filament);
-}
-
-TEST_CASE("A default stack puts the lightest filament at the bottom", "[ChromaStack]")
-{
-    // Light to dark is what gives the long tonal ramp; the order is the one thing a seeded stack has
-    // to get right, since everything else is a layer count the user can drag.
-    const std::vector<ChromaFilament> loaded{ BLACK_OPAQUE, WHITE_OPAQUE,
-                                                filament(3, ColorRGB(0.5f, 0.5f, 0.5f), 4.f) };
-    const ChromaStack stack = chroma_default_stack(loaded, 0.08f, 4, 24);
-
-    REQUIRE(stack.bands.size() == 3);
-    REQUIRE(stack.bands.front().filament.filament == WHITE_OPAQUE.filament);
-    REQUIRE(stack.bands.back().filament.filament == BLACK_OPAQUE.filament);
-    REQUIRE(stack.base_layers == 4);
-    // The base is printed in the bottom band, so the relief is what was asked for and the base sits
-    // underneath it.
-    REQUIRE(stack.total_layers() == 4 + 24);
-    REQUIRE(stack.relief_layers() == 24);
-    REQUIRE_THAT(stack.layer_height_mm, WithinRel(0.08f));
-}
-
-TEST_CASE("An empty stack or picture solves to nothing", "[ChromaStack]")
-{
-    ChromaStack empty;
-    REQUIRE(chroma_palette(empty).empty());
-    REQUIRE(chroma_ranges(empty, 0.).empty());
-
-    // A base with nothing on it: there is no picture to solve, and no filament to print the base in.
-    ChromaStack base_only;
-    base_only.layer_height_mm = 0.08f;
-    base_only.base_layers     = 4;
-    REQUIRE(base_only.relief_layers() == 0);
-    REQUIRE(chroma_palette(base_only).empty());
-    const std::vector<uint8_t> pixel{ 128, 128, 128 };
-    REQUIRE(chroma_solve(pixel.data(), 1, 1, base_only).empty());
-
-    ChromaStack usable;
-    usable.layer_height_mm = 0.08f;
-    usable.base_layers     = 2;
-    usable.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_OPAQUE, 4) };
-    REQUIRE(chroma_solve(nullptr, 4, 4, usable).empty());
-}
-
-TEST_CASE("The base extends the bottom band's range down to the first layer", "[ChromaStack]")
-{
-    // The base is not a swap of its own: it prints in whatever is loaded at the start, which is the
-    // bottom band's filament, so the first range has to reach the build plate.
-    ChromaStack stack;
-    stack.layer_height_mm = 0.1f;
-    stack.base_layers     = 20;
-    stack.bands           = { band(WHITE_OPAQUE, 5), band(BLACK_OPAQUE, 5) };
-
-    const std::vector<ChromaRange> ranges = chroma_ranges(stack, 0.);
-    REQUIRE(ranges.size() == 2);
-    REQUIRE_THAT(ranges[0].z_min, WithinAbs(0., 1e-9));
-    REQUIRE_THAT(ranges[0].z_max, WithinAbs(2.5, 1e-9)); // 20 base + 5 band layers at 0.1 mm
-    REQUIRE_THAT(ranges[1].z_min, WithinAbs(2.5, 1e-9));
-    REQUIRE_THAT(ranges[1].z_max, WithinAbs(3.0, 1e-9));
-    REQUIRE(ranges.back().z_max == Catch::Approx(double(stack.total_layers()) * double(stack.layer_height_mm)));
-}
-
-TEST_CASE("A surface's color follows the printed layer it sits at", "[ChromaStack]")
-{
-    // What the preview colours by: a swap happens at one print Z, so the layer a surface sits in is
-    // what decides its colour, whatever the height map says.
-    ChromaStack stack;
-    stack.layer_height_mm = 0.1f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 3), band(BLACK_OPAQUE, 5) };
-
-    REQUIRE(chroma_level_at(stack, 0.05) == 1);  // inside the first layer
-    REQUIRE(chroma_level_at(stack, 0.10) == 1);  // exactly its top, which that layer printed
-    REQUIRE(chroma_level_at(stack, 0.15) == 2);
-    REQUIRE(chroma_level_at(stack, 0.50) == 5);  // the top of the base plus the white band
-    // Clamped at both ends: below the plate and above the stack there is nothing else to show.
-    REQUIRE(chroma_level_at(stack, -1.) == 1);
-    REQUIRE(chroma_level_at(stack, 99.) == stack.total_layers());
-}
-
-TEST_CASE("How fast a filament covers is its TD against the layer height", "[ChromaStack]")
-{
-    // The number that decides whether a band is a gradient or a step, and the one the panel reports:
-    // a filament hides what is under it at about a tenth of its TD, so how many layers that is
-    // depends entirely on how thick they are.
-    REQUIRE_THAT(chroma_layers_to_opaque(4.f, 0.2f), WithinRel(2.f, 1e-4f));
-    REQUIRE_THAT(chroma_layers_to_opaque(4.f, 0.08f), WithinRel(5.f, 1e-4f));
-    REQUIRE_THAT(chroma_layers_to_opaque(8.f, 0.08f), WithinRel(10.f, 1e-4f));
-    // An opaque filament at a coarse layer height covers within one layer, which is where a stack
-    // stops having any colours between its filaments at all.
-    REQUIRE(chroma_layers_to_opaque(1.f, 0.2f) < 1.f);
-    REQUIRE_THAT(chroma_layers_to_opaque(4.f, 0.f), WithinAbs(0.f, 1e-6f));
-}
-
-TEST_CASE("A finer layer height buys colors between the filaments", "[ChromaStack]")
-{
-    // The whole of the user-visible problem in one assertion: the same stack, the same filaments, two
-    // layer heights. The coarse one steps from white to black in two layers; the fine one fades.
-    const auto distinct = [](float layer_height) {
-        ChromaStack stack;
-        stack.layer_height_mm = layer_height;
-        stack.base_layers     = 0;
-        stack.bands           = { band(WHITE_OPAQUE, 1), band(filament(5, ColorRGB(0.f, 0.f, 0.f), 8.f), 10) };
-        const std::vector<ColorRGB> palette = chroma_palette(stack);
-        int                         n       = 0;
-        for (size_t i = 1; i < palette.size(); ++i)
-            if (std::abs(luminance(palette[i]) - luminance(palette[i - 1])) > 0.02f)
-                ++n;
-        return n;
-    };
-    REQUIRE(distinct(0.08f) > distinct(0.3f));
-}
-
-TEST_CASE("Layers past a filament's covering depth add no color", "[ChromaStack]")
-{
-    // The band is twice as long as the filament needs to hide what is under it, so half of it shows a
-    // colour the layer below already showed. That is invisible in the stack and obvious here.
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 0;
-    stack.bands           = { band(WHITE_OPAQUE, 1), band(filament(5, ColorRGB(0.f, 0.f, 0.f), 4.f), 10) };
-
-    // Trimming keeps every layer that still changes the colour and drops the rest, so the stack gets
-    // shorter and loses none of its colours.
-    const int distinct = chroma_distinct_levels(stack);
-    const int before   = stack.relief_layers();
-    chroma_trim_bands(stack);
-    REQUIRE(stack.relief_layers() <= before);
-    REQUIRE(chroma_distinct_levels(stack) == distinct);
-    // The white band is a single layer and has nothing to give up.
-    REQUIRE(stack.bands.front().layers == 1);
-
-    // A light band over a dark one is the case where layers really are wasted: it saturates within a
-    // few layers, and the rest of a long band shows what the layer below already showed.
-    ChromaStack light_over_dark;
-    light_over_dark.layer_height_mm = 0.08f;
-    light_over_dark.base_layers     = 0;
-    light_over_dark.bands = { band(filament(5, ColorRGB(0.f, 0.f, 0.f), 4.f), 1), band(WHITE_OPAQUE, 14) };
-    const int kept = chroma_distinct_levels(light_over_dark);
-    chroma_trim_bands(light_over_dark);
-    REQUIRE(light_over_dark.bands.back().layers < 14);
-    REQUIRE(chroma_distinct_levels(light_over_dark) == kept);
-}

tests/libslic3r/test_mesh_repair.cpp

@@ -0,0 +1,255 @@
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers.hpp>
+#include <catch2/matchers/catch_matchers_floating_point.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <libslic3r/MeshBoolean.hpp>
+#include <libslic3r/MeshRepair.hpp>
+#include <libslic3r/Point.hpp>
+#include <libslic3r/libslic3r.h>
+#include <libslic3r/TriangleMesh.hpp>
+
+using namespace Slic3r;
+using Catch::Matchers::WithinRel;
+
+namespace {
+
+indexed_triangle_set cube(double size, const Vec3d &offset = Vec3d::Zero())
+{
+    TriangleMesh mesh = make_cube(size, size, size);
+    mesh.translate(offset.cast<float>());
+    return mesh.its;
+}
+
+indexed_triangle_set merged(const std::vector<indexed_triangle_set> &parts)
+{
+    indexed_triangle_set out;
+    for (const indexed_triangle_set &part : parts)
+        its_merge(out, part);
+    return out;
+}
+
+// Every triangle with its own three vertices, as some exporters write meshes.
+indexed_triangle_set soup(const indexed_triangle_set &its)
+{
+    indexed_triangle_set out;
+    for (const stl_triangle_vertex_indices &f : its.indices) {
+        const int first = int(out.vertices.size());
+        for (int k = 0; k < 3; ++k)
+            out.vertices.push_back(its.vertices[f[k]]);
+        out.indices.emplace_back(first, first + 1, first + 2);
+    }
+    return out;
+}
+
+double regular_polygon_area(int sides, double radius) { return 0.5 * sides * radius * radius * std::sin(2. * PI / sides); }
+
+// Closed by vertex indices, outward oriented and free of self-intersections.
+void check_solid(const TriangleMesh &mesh, double volume)
+{
+    CHECK(its_num_open_edges(mesh.its) == 0);
+    CHECK_THAT(its_volume(mesh.its), WithinRel(volume, 1e-4));
+    CHECK_FALSE(MeshBoolean::cgal::does_self_intersect(mesh));
+}
+
+} // namespace
+
+TEST_CASE("A triangle soup repairs into the solid it describes", "[MeshRepair]")
+{
+    TriangleMesh mesh(soup(cube(20.)));
+    MeshRepairStats stats;
+    REQUIRE(repair_mesh(mesh, &stats));
+    CHECK(stats.modified);
+    check_solid(mesh, 20. * 20. * 20.);
+    CHECK(mesh.its.vertices.size() == 8);
+}
+
+TEST_CASE("Flipped triangles take the orientation of their neighbours", "[MeshRepair]")
+{
+    indexed_triangle_set its = cube(20.);
+    std::swap(its.indices[1][1], its.indices[1][2]);
+    std::swap(its.indices[5][1], its.indices[5][2]);
+    TriangleMesh mesh(std::move(its));
+    REQUIRE(repair_mesh(mesh));
+    check_solid(mesh, 20. * 20. * 20.);
+}
+
+TEST_CASE("An inside-out mesh is turned outward", "[MeshRepair]")
+{
+    indexed_triangle_set its = cube(20.);
+    its_flip_triangles(its);
+    TriangleMesh mesh(std::move(its));
+    REQUIRE(repair_mesh(mesh));
+    check_solid(mesh, 20. * 20. * 20.);
+}
+
+TEST_CASE("Holes are filled", "[MeshRepair]")
+{
+    indexed_triangle_set its = cube(20.);
+    its.indices.erase(its.indices.begin(), its.indices.begin() + 3);
+    TriangleMesh mesh(std::move(its));
+    MeshRepairStats stats;
+    REQUIRE(repair_mesh(mesh, &stats));
+    CHECK(stats.filled_holes > 0);
+    check_solid(mesh, 20. * 20. * 20.);
+}
+
+TEST_CASE("Cracks between triangles that should share corners are closed", "[MeshRepair]")
+{
+    indexed_triangle_set its = soup(cube(20.));
+    // Shift the corners of two triangles by far less than a micron, as float rounding in an exporter would.
+    for (std::size_t v = 0; v < 6; ++v)
+        its.vertices[v] += Vec3f(1e-5f, -1e-5f, 1e-5f);
+    TriangleMesh mesh(std::move(its));
+    MeshRepairStats stats;
+    REQUIRE(repair_mesh(mesh, &stats));
+    CHECK(stats.welded_vertices > 0);
+    check_solid(mesh, 20. * 20. * 20.);
+}
+
+TEST_CASE("A T-junction is closed", "[MeshRepair]")
+{
+    // The top of the cube is split at the middle of its front edge, which the front side does not share.
+    indexed_triangle_set its;
+    its.vertices = {{0, 0, 0}, {20, 0, 0}, {20, 20, 0}, {0, 20, 0}, {0, 0, 20}, {20, 0, 20}, {20, 20, 20}, {0, 20, 20}, {10, 0, 20}};
+    its.indices  = {{0, 2, 1}, {0, 3, 2}, {4, 8, 7}, {8, 6, 7}, {8, 5, 6}, {0, 1, 5}, {0, 5, 4},
+                    {1, 2, 6}, {1, 6, 5}, {2, 3, 7}, {2, 7, 6}, {3, 0, 4}, {3, 4, 7}};
+    TriangleMesh mesh(std::move(its));
+    REQUIRE(repair_mesh(mesh));
+    check_solid(mesh, 20. * 20. * 20.);
+}
+
+TEST_CASE("Crossing shells stay separate parts and are made solid", "[MeshRepair]")
+{
+    indexed_triangle_set inside_out = cube(20., {10., 10., 10.});
+    its_flip_triangles(inside_out);
+    TriangleMesh mesh(merged({cube(20.), inside_out}));
+    MeshRepairStats stats;
+    REQUIRE(repair_mesh(mesh, &stats));
+    CHECK(stats.reversed_shells == 1);
+    CHECK(its_num_open_edges(mesh.its) == 0);
+    CHECK_THAT(its_volume(mesh.its), WithinRel(2 * 8000., 1e-4));
+    CHECK(mesh.split().size() == 2);
+}
+
+TEST_CASE("Solids touching face to face in a soup lose the wall between them", "[MeshRepair]")
+{
+    // The mirrored copy shares the wall at x = 10 with exactly the same triangles, reversed.
+    TriangleMesh right = make_cube(10., 10., 10.);
+    right.mirror(X);
+    right.translate(20.f, 0.f, 0.f);
+    TriangleMesh mesh(soup(merged({cube(10.), right.its})));
+    REQUIRE(repair_mesh(mesh));
+    check_solid(mesh, 2 * 1000.);
+    CHECK(mesh.split().size() == 1);
+}
+
+TEST_CASE("A shell inside a solid follows the nonzero winding rule of slicing", "[MeshRepair]")
+{
+    SECTION("Oriented like the outer shell, it adds nothing and is removed")
+    {
+        TriangleMesh mesh(merged({cube(20.), cube(10., {5., 5., 5.})}));
+        REQUIRE(repair_mesh(mesh));
+        check_solid(mesh, 8000.);
+        CHECK(mesh.its.indices.size() == 12);
+    }
+    SECTION("Oriented inward, it is a cavity and stays")
+    {
+        indexed_triangle_set cavity = cube(10., {5., 5., 5.});
+        its_flip_triangles(cavity);
+        TriangleMesh mesh(merged({cube(20.), cavity}));
+        MeshRepairStats stats;
+        REQUIRE(repair_mesh(mesh, &stats));
+        CHECK_FALSE(stats.modified);
+        CHECK_THAT(its_volume(mesh.its), WithinRel(8000. - 1000., 1e-4));
+    }
+}
+
+TEST_CASE("A pipe missing its end caps gets annular caps", "[MeshRepair]")
+{
+    const int    n = 64;
+    const double h = 20., r_out = 10., r_in = 7.;
+    indexed_triangle_set its;
+    for (const double r : {r_out, r_in})
+        for (int k = 0; k < n; ++k) {
+            const double a = 2. * PI * k / n;
+            its.vertices.emplace_back(float(r * std::cos(a)), float(r * std::sin(a)), 0.f);
+            its.vertices.emplace_back(float(r * std::cos(a)), float(r * std::sin(a)), float(h));
+        }
+    for (int k = 0; k < n; ++k) {
+        const int a0 = 2 * k, b0 = a0 + 1, a1 = 2 * ((k + 1) % n), b1 = a1 + 1;
+        its.indices.emplace_back(a0, a1, b1);
+        its.indices.emplace_back(a0, b1, b0);
+        its.indices.emplace_back(2 * n + a0, 2 * n + b1, 2 * n + a1);
+        its.indices.emplace_back(2 * n + a0, 2 * n + b0, 2 * n + b1);
+    }
+    TriangleMesh mesh(std::move(its));
+    REQUIRE(repair_mesh(mesh));
+    check_solid(mesh, h * (regular_polygon_area(n, r_out) - regular_polygon_area(n, r_in)));
+}
+
+TEST_CASE("A stray flat triangle is dropped", "[MeshRepair]")
+{
+    indexed_triangle_set its = cube(20.);
+    its.vertices.insert(its.vertices.end(), {{30, 0, 0}, {40, 0, 0}, {30, 10, 0}});
+    its.indices.emplace_back(8, 9, 10);
+    TriangleMesh mesh(std::move(its));
+    MeshRepairStats stats;
+    REQUIRE(repair_mesh(mesh, &stats));
+    CHECK(stats.removed_shells == 1);
+    check_solid(mesh, 8000.);
+}
+
+TEST_CASE("A two-sided export keeps one side of each triangle", "[MeshRepair]")
+{
+    indexed_triangle_set back = cube(20.);
+    its_flip_triangles(back);
+    TriangleMesh mesh(soup(merged({cube(20.), back})));
+    REQUIRE(repair_mesh(mesh));
+    check_solid(mesh, 8000.);
+}
+
+TEST_CASE("A valid mesh is left untouched", "[MeshRepair]")
+{
+    TriangleMesh       mesh = make_sphere(10., 2. * PI / 36.);
+    const TriangleMesh original = mesh;
+    MeshRepairStats    stats;
+    REQUIRE(repair_mesh(mesh, &stats));
+    CHECK_FALSE(stats.modified);
+    CHECK(mesh.its.vertices == original.its.vertices);
+    CHECK(mesh.its.indices == original.its.indices);
+}
+
+TEST_CASE("A mesh enclosing no volume is reported and left untouched", "[MeshRepair]")
+{
+    indexed_triangle_set its;
+    its.vertices = {{0, 0, 0}, {10, 0, 0}, {10, 10, 0}, {0, 10, 0}};
+    its.indices  = {{0, 1, 2}, {0, 2, 3}};
+    TriangleMesh mesh(its);
+    std::string  error;
+    CHECK_FALSE(repair_mesh(mesh, nullptr, &error));
+    CHECK_FALSE(error.empty());
+    CHECK(mesh.its.indices.size() == 2);
+}
+
+TEST_CASE("Progress is reported in order and throwing from it cancels the repair", "[MeshRepair]")
+{
+    TriangleMesh     mesh(soup(cube(20.)));
+    std::vector<int> reported;
+    REQUIRE(repair_mesh(mesh, nullptr, nullptr, [&reported](int percent) { reported.push_back(percent); }));
+    CHECK_FALSE(reported.empty());
+    CHECK(std::is_sorted(reported.begin(), reported.end()));
+
+    struct Canceled {};
+    TriangleMesh       canceled(soup(cube(20.)));
+    const TriangleMesh original = canceled;
+    CHECK_THROWS_AS(repair_mesh(canceled, nullptr, nullptr, [](int) { throw Canceled(); }), Canceled);
+    CHECK(canceled.its.vertices == original.its.vertices);
+    CHECK(canceled.its.indices == original.its.indices);
+}