ChromaStack: design doc

docs/HLSD/chromastack.md: what the colour model is and why it is
Beer-Lambert, what the solve does, how a stack attaches to a texture
displacement layer, why the swaps are height ranges, what the preview
shader draws, and the geometry the whole thing assumes.

.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
-          retry xcrun stapler staple OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
+          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
-            retry xcrun stapler staple OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
+            xcrun stapler staple OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
           fi
 
       - name: Create DMG without notary
@@ -460,6 +460,10 @@ 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,15 +16,6 @@ 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 }}
@@ -44,7 +35,7 @@ jobs:
           # The PR merge commit plus its first parent, the base it is diffed against.
           fetch-depth: 2
 
-      - name: Look for changed files
+      - name: Look for changed C++ files
         id: changes
         run: |
           if git -c core.quotePath=false diff --name-only HEAD^1 -- src tests | grep -qE '\.(cpp|cc|cxx|hpp|h|hxx)$'; then
@@ -52,75 +43,18 @@ 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/.
-      # 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.
+      # Parsing needs the dependency headers, not a build of this PR's deps/, so
+      # a PR that changes deps/ falls back to the newest cache main has.
       - name: Restore cached deps
-        id: deps_cache
         if: steps.changes.outputs.cpp == 'true'
         uses: actions/cache/restore@v6
         with:
           path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
-          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 }}
+          key: linux-clang-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }}
           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,6 +497,47 @@ 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,18 +1,10 @@
 # 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

@@ -0,0 +1,239 @@
+# 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

@@ -1,135 +0,0 @@
-# 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.15",
+	"version": "02.08.00.14",
 	"force_update": "0",
 	"description": "the initial version of BBL configurations",
 	"machine_model_list": [

resources/shaders/110/chromastack.fs

@@ -0,0 +1,92 @@
+#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

@@ -0,0 +1,40 @@
+#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

@@ -0,0 +1,94 @@
+#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

@@ -0,0 +1,40 @@
+#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,27 +1,21 @@
 #!/usr/bin/env bash
-# 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.
+# 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.
 #
-# 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`.
+# Environment: GH_TOKEN, REPO, WORKFLOW_REF and BASE_REF, plus KEY_INPUTS,
+# WAIT_FOR, WAIT_SINCE, WAIT_MINUTES, KEY and ARCH for `wait`.
 # Writes key-inputs, wait-for and wait-since to $GITHUB_OUTPUT.
 set -uo pipefail
 
-workflow=${WORKFLOW_REF:-}
-workflow=${workflow%%@*}
-workflow=${WORKFLOW:-${workflow##*/}}
+workflow=${WORKFLOW_REF%%@*}
+workflow=${workflow##*/}
 
 # Must match the job names in build_all.yml, build_check_cache.yml and build_deps.yml.
-job=${JOB:-build_macos_arch (${ARCH:-})}
-check_job_name="$job / Check Cache"
-deps_job_name="$job / Build Deps / Build Deps"
+check_job_name="build_macos_arch (${ARCH:-}) / Check Cache"
+deps_job_name="build_macos_arch (${ARCH:-}) / Build Deps / Build Deps"
 
 out() { echo "$1" >> "${GITHUB_OUTPUT:-/dev/stdout}"; }
 
@@ -69,27 +63,8 @@ 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 "${CACHE_REF:-refs/heads/$BASE_REF}" --key "$KEY" --json key < /dev/null \
+  gh cache list -R "$REPO" --ref "refs/heads/$BASE_REF" --key "$KEY" --json key < /dev/null \
     | jq -e --arg key "$KEY" 'any(.[]; .key == $key)' > /dev/null
 }
 
@@ -112,11 +87,11 @@ wait_for() {
           key_saved && { echo "Found $KEY."; return; }
           sleep 20
         done
-        echo "Build $id finished its deps without saving $KEY."
+        echo "Build $id of $BASE_REF finished its deps without saving $KEY."
         return ;;
       "completed cancelled") ;;
       completed*)
-        echo "The deps job of build $id did not succeed."
+        echo "The deps job of build $id of $BASE_REF did not succeed."
         return ;;
       # The deps job exists only once the build's cache check has succeeded.
       "")
@@ -125,7 +100,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 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 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."
               warned=1
             fi ;;
           *)
@@ -143,12 +118,11 @@ wait_for() {
     seen="$seen $id"
     echo "Following build $id of $BASE_REF."
   done
-  echo "No build saved $KEY."
+  echo "No build of $BASE_REF saved $KEY."
 }
 
 case "${1:-}" in
   check) check ;;
-  own) own ;;
   wait) wait_for ;;
-  *) echo "usage: $0 check|own|wait" >&2; exit 2 ;;
+  *) echo "usage: $0 check|wait" >&2; exit 2 ;;
 esac

src/OrcaSlicer.cpp

@@ -99,7 +99,6 @@
 #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"
@@ -207,7 +206,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, "The plate has nothing to slice: it is empty, or no object on it is both printable and fully inside the print volume."},
+    {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_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."},
@@ -1464,7 +1463,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 = 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;
+    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;
     Semver file_version;
     std::map<size_t, bool> orients_requirement;
     std::vector<Preset*> project_presets;
@@ -5131,19 +5130,9 @@ int CLI::run(int argc, char **argv)
                 }
             }
         } else if (opt_key == "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();
-                    }
+            // Models are repaired by default.
+            //for (auto &model : m_models)
+            //    model.repair();
         } 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);
@@ -5153,7 +5142,6 @@ 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)
     {
@@ -5421,7 +5409,6 @@ 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
@@ -5894,7 +5881,6 @@ 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
@@ -6439,15 +6425,7 @@ 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;
-                            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);
+                            record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS, index+1, cli_errors[CLI_NO_SUITABLE_OBJECTS], sliced_info);
                             flush_and_exit(CLI_NO_SUITABLE_OBJECTS);
                         }
                         else if ((plate_to_slice != 0) || pre_check) {

src/libslic3r/CMakeLists.txt

@@ -325,6 +325,8 @@ set(lisbslic3r_sources
     Geometry/VoronoiUtils.cpp
     Geometry/VoronoiUtils.hpp
     Geometry/VoronoiVisualUtils.hpp
+    ChromaStack.cpp
+    ChromaStack.hpp
     IMEXArrange.cpp
     IMEXArrange.hpp
     IMEXHelpers.cpp
@@ -625,7 +627,6 @@ 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
 )
@@ -653,9 +654,7 @@ if (IS_CLANG_CL)
     target_compile_options(libslic3r_cgal PRIVATE -Wno-overriding-option)
 endif ()
 
-# 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)
+target_link_libraries(libslic3r_cgal PRIVATE ${_cgal_tgt} admesh libigl mcut boost_libs)
 
 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

@@ -0,0 +1,394 @@
+#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

@@ -0,0 +1,286 @@
+#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,29 +236,19 @@ 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(transform.Shape(), fullName);
+                namedSolids.emplace_back(TopoDS::CompSolid(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,7 +22,6 @@
 #include "libslic3r/BrimEarsPoint.hpp"
 #include "libslic3r/Config.hpp"
 #include "libslic3r/CustomGCode.hpp"
-#include "libslic3r/TextureDisplacement.hpp"
 #include "libslic3r_version.h"
 
 #include "bbs_3mf.hpp"
@@ -355,13 +354,6 @@ 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";
 
@@ -855,9 +847,6 @@ 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;
 
@@ -878,8 +867,6 @@ 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();
             }
         };
 
@@ -1213,11 +1200,6 @@ 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;
@@ -2091,13 +2073,6 @@ 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
@@ -3335,45 +3310,6 @@ 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');
@@ -4030,12 +3966,6 @@ 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));
         }
@@ -5387,18 +5317,6 @@ 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);
@@ -5414,8 +5332,6 @@ 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
@@ -5580,28 +5496,12 @@ 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
@@ -5905,12 +5805,6 @@ 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));
         }
@@ -6914,9 +6808,6 @@ 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>";
 
@@ -7341,14 +7232,10 @@ 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))
-                                    && same_texture_paint)
+                                    && (shared_volume->fuzzy_skin_facets.equals(volume->fuzzy_skin_facets)))
                                 {
                                     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}});
@@ -7764,20 +7651,6 @@ 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();
@@ -8227,42 +8100,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         return file_path;
     }
 
-    // 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)
+    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
@@ -8373,8 +8211,6 @@ bool _BBS_3MF_Exporter::_add_model_config_file_to_archive(mz_zip_archive& archiv
                             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,15 +1033,6 @@ 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)
@@ -1393,9 +1384,6 @@ 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
             {
@@ -4262,7 +4250,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.get_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.values.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
@@ -10907,8 +10895,7 @@ 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);
-        // 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);
+        gcode += toolchange_gcode_parsed;
 
         //BBS
         {

src/libslic3r/GCode/FanMover.cpp

@@ -445,11 +445,6 @@ 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,13 +2602,12 @@ void GCodeProcessorResult::reset() {
     //BBS: add mutex for protection of gcode result
     lock();
 
-    // moves and lines_ends grow with the print: free them, as no reset result reuses the capacity.
-    clear_and_shrink(moves);
+    moves.clear();
     plate_mass = {};
     object_masses.clear();
     body_masses.clear();
     support_masses.clear();
-    clear_and_shrink(lines_ends);
+    lines_ends.clear();
     printable_area = Pointfs();
     //BBS: add bed exclude area
     bed_exclude_area = Pointfs();
@@ -3599,10 +3598,6 @@ 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{ false };
+        bool m_manual_filament_change;
 
         //BBS: x, y offset for gcode generated
         double          m_x_offset{ 0 };

src/libslic3r/JumpPointSearch.cpp

@@ -0,0 +1,349 @@
+#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

@@ -0,0 +1,39 @@
+#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,6 +29,8 @@
 #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>
@@ -48,6 +50,7 @@
 #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>
@@ -655,6 +658,91 @@ 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,6 +77,9 @@ 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

@@ -1,28 +0,0 @@
-#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,7 +29,6 @@
 #include "TriangleMeshSlicer.hpp"
 #include "TriangleSelector.hpp"
 #include "MaterialType.hpp"
-#include "MeshRepair.hpp"
 
 #include "Format/AMF.hpp"
 #include "Format/svg.hpp"
@@ -2947,18 +2946,6 @@ 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>{};
 
@@ -2969,22 +2956,26 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
     unsigned int extruder_counter = 0;
     const Vec3d offset = this->get_offset();
 
-    for (std::unique_ptr<ModelVolume> &part : parts) {
+    for (TriangleMesh &mesh : meshes) {
+        if (mesh.empty())
+            // Repair may have removed unconnected triangles, thus emptying the mesh.
+            continue;
+
         if (idx == 0) {
-            this->set_mesh(part->m_mesh);
-            m_convex_hull = part->m_convex_hull;
+            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();
+            // 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), part.release());
+            this->object->volumes.insert(this->object->volumes.begin() + (++ivolume), new ModelVolume(object, *this, std::move(mesh)));
 
-        // 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);
@@ -2998,29 +2989,21 @@ 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,7 +77,6 @@ class Preset;
 class BBLProject;
 
 class KeyStore;
-struct MeshRepairStats;
 
 namespace UndoRedo {
 	class StackImpl;
@@ -888,13 +887,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); 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; }
+    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>(); }
     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.
@@ -1044,9 +1043,6 @@ 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_adhesiveness_category", "filament_cost", "filament_minimal_purge_on_wipe_tower",
+    "filament_flow_ratio", "filament_density", "filament_transmission_distance", "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,16 +2164,6 @@ 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);
@@ -2638,34 +2628,15 @@ 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)
+        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);
+
             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,16 +4188,6 @@ 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);
@@ -4206,6 +4196,12 @@ 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;
         }
@@ -4569,10 +4565,6 @@ 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]);
@@ -4597,8 +4589,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(result_presets.size(), 1);
-            filament_volume_map->values.resize(result_presets.size(), static_cast<int>(NozzleVolumeType::nvtStandard));
+            filament_map->values.resize(total, 1);
+            filament_volume_map->values.resize(total, static_cast<int>(NozzleVolumeType::nvtStandard));
         } else {
             // BBL: existing wholesale replace
             filament_color->values = ams_filament_colors;

src/libslic3r/Print.cpp

@@ -226,6 +226,7 @@ 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",
@@ -2991,15 +2992,6 @@ 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,6 +3441,20 @@ 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");
@@ -12866,11 +12880,10 @@ 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 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->tooltip = L("Repair the model's meshes if it is non-manifold mesh.");
+    def->set_default_value(new ConfigOptionBool(false));*/
 
     def = this->add("rotate", coFloat);
     def->label = L("Rotate");
@@ -13086,7 +13099,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(false));
+    def->set_default_value(new ConfigOptionBool(true));
 
     def = this->add("align_to_y_axis", coBool);
     def->label = L("Align to Y axis when arranging");

src/libslic3r/PrintConfig.hpp

@@ -1709,6 +1709,9 @@ 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,9 +982,6 @@ 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;
-                            const float eps = float(scale_(m_config.slice_closing_radius.value) * 1.5);
+                            static 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,15 +1976,37 @@ coordf_t TreeSupport::get_radius(const SupportNode* node)
     return node->radius;
 }
 
-// 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)
+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
 }
-const ExPolygons& TreeSupport::get_collision(coordf_t radius, size_t layer_nr)
+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)
 {
@@ -2805,12 +2827,7 @@ void TreeSupport::draw_circles()
 #endif  // SUPPORT_TREE_DEBUG_TO_SVG
 
     SupportLayerPtrs& ts_layers = m_object->support_layers();
-    // 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;
+    auto iter = std::remove_if(ts_layers.begin(), ts_layers.end(), [](SupportLayer* ts_layer) { return ts_layer->height < EPSILON; });
     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;
@@ -3054,7 +3071,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);
-                    const ExPolygons& avoid_layer = get_avoidance(next_radius, obj_layer_nr_next);
+                    auto avoid_layer = get_avoidance(next_radius, obj_layer_nr_next);
                     if (group_index == 0)
                     {
                         //Avoid collisions.
@@ -3258,7 +3275,7 @@ void TreeSupport::drop_nodes()
                 }
 #endif
                 coordf_t next_radius = calc_radius(node.dist_mm_to_top + height_next);
-                const ExPolygons& avoidance_next = get_avoidance(next_radius, obj_layer_nr_next);
+                auto 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;
@@ -3320,7 +3337,7 @@ void TreeSupport::drop_nodes()
                     p_node->to_buildplate = false;
                     return; // from parallel_for_each lambda
                 }
-                const ExPolygons& next_collision = get_collision(0, obj_layer_nr_next);
+                auto              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);
-    const ExPolygons& get_avoidance(coordf_t radius, size_t obj_layer_nr);
+    ExPolygons get_avoidance(coordf_t radius, size_t obj_layer_nr);
     // layer's expolygon expanded by radius+m_xy_distance
-    const ExPolygons& get_collision(coordf_t radius, size_t layer_nr);
+    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,7 +19,6 @@
 #include <mutex>
 #include <numeric>
 #include <optional>
-#include "nlohmann/json.hpp"
 #include <queue>
 #include <ratio>
 #include <string>
@@ -5167,260 +5166,5 @@ 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,6 +18,7 @@
 
 #include <array>
 
+#include "ChromaStack.hpp"
 #include "Point.hpp"
 #include "TriangleSelector.hpp"
 
@@ -293,16 +294,33 @@ 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);
+           lscm_uv_overrides, view_project_projective, view_project_matrix, color_enabled, chroma_enabled, chroma,
+           source);
     }
     template<class Archive> void load(Archive &ar)
     {
@@ -310,12 +328,14 @@ 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);
+           view_project_matrix, color_enabled, chroma_enabled, chroma, source);
         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);
@@ -397,41 +417,14 @@ 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, v2_flip_edges, color_mix_enabled, color_despeckle, color_mix_count,
-           active_slot, panel_mode);
+           v2_relocate, color_mix_enabled, color_despeckle, color_mix_count);
     }
 };
 
-// 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 << ": mesh repair finished.";
+                    BOOST_LOG_TRIVIAL(info) << log_prefix << ": Windows 3D mesh repair finished.";
                     if (!resample_face_colors(TriMesh(std::move(repaired_its))))
                         return false;
                 } else {
-                    BOOST_LOG_TRIVIAL(warning) << log_prefix << ": mesh repair failed: " << repair_error;
+                    BOOST_LOG_TRIVIAL(warning) << log_prefix << ": Windows 3D mesh repair failed: " << repair_error;
                 }
             } else {
-                BOOST_LOG_TRIVIAL(info) << log_prefix << ": importing mesh without repair.";
+                BOOST_LOG_TRIVIAL(info) << log_prefix << ": importing mesh without Windows 3D repair.";
             }
         }
     }

src/libslic3r/TriangleMeshDeal.hpp

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

src/libslic3r/Utils.hpp

@@ -109,6 +109,7 @@ 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,7 +1744,9 @@ std::string format_diameter_to_str(double diameter, int precision)
     return oss.str();
 }
 
-// Returns platform-specific string to be used as log output.
+// 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).
 std::string log_memory_info(bool ignore_loglevel)
 {
     std::string out;

src/libvgcode/src/SegmentTemplate.cpp

@@ -21,9 +21,7 @@ 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 };
 
-// 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 = {
+static constexpr const std::array<uint8_t, 24> INDEX_DATA = {
     0, 1, 2, // front spike
     0, 2, 3, // front spike
     0, 3, 4, // right/bottom body 
@@ -39,7 +37,7 @@ void SegmentTemplate::init()
     if (m_vao_id != 0)
         return;
 
-    m_size_in_bytes_gpu += VERTEX_DATA.size() * sizeof(uint8_t) + INDEX_DATA.size() * sizeof(uint16_t);
+    m_size_in_bytes_gpu += (VERTEX_DATA.size() + INDEX_DATA.size()) * sizeof(uint8_t);
 
     int curr_vertex_array;
     glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
@@ -63,7 +61,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(uint16_t), INDEX_DATA.data(), GL_STATIC_DRAW));
+    glsafe(glBufferData(GL_ELEMENT_ARRAY_BUFFER, INDEX_DATA.size() * sizeof(uint8_t), INDEX_DATA.data(), GL_STATIC_DRAW));
 
     glsafe(glBindBuffer(GL_ARRAY_BUFFER, curr_array_buffer));
     glsafe(glBindVertexArray(curr_vertex_array));
@@ -96,7 +94,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_SHORT,
+    glsafe(glDrawElementsInstanced(GL_TRIANGLES, static_cast<GLsizei>(INDEX_DATA.size()), GL_UNSIGNED_BYTE,
                                    nullptr, static_cast<GLsizei>(count)));
     glsafe(glBindVertexArray(curr_vertex_array));
 }

src/libvgcode/src/ViewerImpl.cpp

@@ -927,17 +927,15 @@ 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;
-    // 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<>();
+    m_valid_lines_bitset.clear();
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
     m_cog_marker.reset();
 #endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
@@ -1836,7 +1834,6 @@ 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,6 +416,8 @@ 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
@@ -800,6 +802,7 @@ 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,4 +1,5 @@
-#pragma once
+#ifndef slic3r_GUI_SingleChoice_hpp_
+#define slic3r_GUI_SingleChoice_hpp_
 
 #include "GUI_Utils.hpp"
 #include "Plater.hpp"
@@ -32,3 +33,5 @@ private:
 
 };
 }} // namespace Slic3r::GUI
+
+#endif

src/slic3r/GUI/ConfigExceptions.hpp

@@ -0,0 +1,19 @@
+#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,10 +1105,6 @@ 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,7 +8,6 @@
 #include <cstdlib>
 #include <chrono>
 #include <nlohmann/json.hpp>
-#include <wx/app.h>
 #include <wx/colour.h>
 #include <string>
 #include <wx/string.h>
@@ -34,36 +33,6 @@
 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)
@@ -231,22 +200,18 @@ wxString DevAms::GetDisplayName() const
 
 int DevAms::GetSlotCount() const
 {
-    // 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)
+    // 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)
+    {
         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 static_cast<int>(m_trays.size());
+    return 1;
 }
 
 DevAmsTray* DevAms::GetTray(const std::string& tray_id) const
@@ -337,21 +302,13 @@ int DevFilaSystem::GetExtruderIdByAmsId(const std::string& ams_id) const
     {
         return it->second->GetExtruderId();
     }
-
-    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);
-        }
-    }
-
-    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_MAIN_ID_STR)
+    else if (stoi(ams_id) == VIRTUAL_TRAY_MAIN_ID)
+    {
         return MAIN_EXTRUDER_ID;
-    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_DEPUTY_ID_STR)
+    }
+    else if (stoi(ams_id) == VIRTUAL_TRAY_DEPUTY_ID)
+    {
         return DEPUTY_EXTRUDER_ID;
-    if (!is_bbl_vendor && devPrinterUtil::IsVirtualSlot(ams_id)) {
-        return VIRTUAL_TRAY_MAIN_ID - std::stoi(ams_id);
     }
 
     assert(false && __FUNCTION__);
@@ -368,22 +325,9 @@ std::string DevFilaSystem::GetNozzleFlowStringByAmsId(const std::string& ams_id)
 std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
 {
     std::map<int, DevAmsSlotId> tray_id_map;
-    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;
-            }
-        }
-    }
+    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};
 
-    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) {
@@ -391,11 +335,9 @@ 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 (!is_bbl_vendor) {
-                        tray_index = generic_tray_index + slot_id_int;
-                    } else if (ams_item->GetAmsType() == DevAms::N3S) {
+                    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);
@@ -406,8 +348,6 @@ std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
                 }
             }
         }
-        if (!is_bbl_vendor)
-            generic_tray_index += static_cast<int>(ams_item->GetTrays().size());
     }
 
     return  tray_id_map;
@@ -516,13 +456,6 @@ 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;
@@ -862,18 +795,7 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
 
                                     if (type_id < 4)
                                     {
-                                        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;
-                                        }
+                                        curr_tray->is_exists = (obj->tray_exist_bits & (1 << (ams_id_int * 4 + tray_id_int))) != 0 ? true : false;
                                     }
                                     else if (type_id == DevAms::AMS_LITE_MIXED)
                                     {
@@ -929,9 +851,6 @@ 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++)
@@ -994,8 +913,6 @@ 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);
@@ -1078,22 +995,16 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
     }
 
     // --- external / direct spools -> obj->vt_slot ---
-    // 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, ...).
+    // extruder 0 -> main virtual slot, extruder >0 -> deputy.
     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);
-            if (ext < MAIN_EXTRUDER_ID || ext >= VIRTUAL_TRAY_MAIN_ID)
-                continue;
-
-            const int  vt_id = VIRTUAL_TRAY_MAIN_ID - ext;
+            const int  vt_id = (ext == MAIN_EXTRUDER_ID) ? VIRTUAL_TRAY_MAIN_ID : VIRTUAL_TRAY_DEPUTY_ID;
             DevAmsTray tray(std::to_string(vt_id));
             tray.is_exists       = e.value("loaded", false);
             tray.m_fila_type     = e.value("material", std::string());
@@ -1102,11 +1013,8 @@ 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);
-            external_slots.insert_or_assign(ext, std::move(tray));
+            obj->vt_slot.push_back(tray);
         }
-
-        for (auto& entry : external_slots)
-            obj->vt_slot.push_back(std::move(entry.second));
     }
 }
 

src/slic3r/GUI/GLCanvas3D.cpp

@@ -1514,8 +1514,6 @@ 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()
 {
@@ -2470,8 +2468,7 @@ void GLCanvas3D::_render_frame(bool scene_dirty, bool only_init)
     }
 
     m_in_render = true;
-    ++s_frames_in_progress;
-    Slic3r::ScopeGuard in_render_guard([this]() { m_in_render = false; --s_frames_in_progress; });
+    Slic3r::ScopeGuard in_render_guard([this]() { m_in_render = false; });
     (void)in_render_guard;
 
     if (m_canvas == nullptr)
@@ -2716,31 +2713,15 @@ 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.
-    // 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()) {
+    if (m_canvas->IsShownOnScreen()) {
         m_canvas->SwapBuffers();
         m_frame_profiler.mark("swap");
         if (!overlay_tick)
             m_render_stats.increment_fps_counter();
         m_presented_signature = signature;
     }
-    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";
-            }
-        }
+    else
         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,8 +643,6 @@ 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.
@@ -976,11 +974,6 @@ 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,6 +114,8 @@ 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,6 +719,9 @@ 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;
@@ -750,6 +753,7 @@ 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,6 +4862,12 @@ 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,6 +519,7 @@ 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,16 +1952,6 @@ 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,6 +2875,37 @@ 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();
@@ -6297,44 +6328,30 @@ 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 (obj_idxs.empty() || !wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager().check_gizmos_closed_except(GLGizmosManager::Undefined))
+    if (!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;
-    size_t                                             unchanged_models = 0;
-    bool                                               painting_removed = false;
+
+    std::vector<int> obj_idxs, vol_idxs;
+    get_selection_indexes(obj_idxs, vol_idxs);
 
     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);
@@ -6342,26 +6359,31 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
     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 = [&](const int obj_idx, const int vol_idx, int model_idx, ProgressDialog& progress_dlg)
+    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)
     {
-        ModelObject *mo = object(obj_idx);
-        if (!mo)
+        if (!object(obj_idx))
             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)
@@ -6369,29 +6391,33 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
             msg += "\n";
         }
 
-        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;
-        bool        modified = false;
-        if (!fix_model_with_cgal_gui(*mo, vol_idx, progress_dlg, msg, res, keep_painting, &modified))
-            return false;
-
-        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);
+        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();
+        std::string res;
+        if (!fix_model_with_cgal_gui(*(object(obj_idx)), vol_idx, progress_dlg, msg, res, keep_painting))
+            return false;
+        //wxGetApp().plater()->changed_mesh(obj_idx);
+        object(obj_idx)->ensure_on_bed();
+        plater->changed_mesh(obj_idx);
 
-        if (!res.empty())
-            failed_models.push_back({ model_name, res });
-        else if (modified)
+        const size_t volumes_after = object(obj_idx)->volumes.size();
+        if (volumes_after != volumes_before)
+            add_volumes_to_object_in_list(obj_idx);
+
+        plater->get_partplate_list().notify_instance_update(obj_idx, 0);
+        plater->sidebar().obj_list()->update_plate_values_for_items();
+
+        if (res.empty())
             succes_models.push_back(model_name);
         else
-            ++unchanged_models;
+            failed_models.push_back({ model_name, res });
+
+        update_item_error_icon(obj_idx, vol_idx);
+        update_info_items(obj_idx);
+
         return true;
     };
 
@@ -6404,7 +6430,11 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
     if (vol_idxs.empty()) {
         int vol_idx{ -1 };
         for (int obj_idx : obj_idxs) {
-            if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg))
+#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))
                 break;
             model_idx++;
         }
@@ -6412,7 +6442,7 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
     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))
+            if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg, succes_models, failed_models))
                 break;
             model_idx++;
         }
@@ -6420,29 +6450,20 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
     // Close the progress dialog
     progress_dlg.Update(100, "");
 
-    if (painting_removed)
-        plater->notify_painting_removed();
-
     // Show info notification
-    std::vector<wxString> blocks;
+    wxString msg;
     wxString bullet_suf = "\n   - ";
     if (!succes_models.empty()) {
-        wxString block = _L_PLURAL("The following model object has been repaired", "The following model objects have been repaired", succes_models.size()) + ":";
+        msg = _L_PLURAL("The following model object has been repaired", "The following model objects have been repaired", succes_models.size()) + ":";
         for (auto& model : succes_models)
-            block += bullet_suf + from_u8(model);
-        blocks.push_back(block);
+            msg += bullet_suf + from_u8(model);
+        msg += "\n\n";
     }
     if (!failed_models.empty()) {
-        wxString block = _L_PLURAL("Failed to repair the following model object", "Failed to repair the following model objects", failed_models.size()) + ":";
+        msg += _L_PLURAL("Failed to repair the following model object", "Failed to repair the following model objects", failed_models.size()) + ":\n";
         for (auto& model : failed_models)
-            block += bullet_suf + from_u8(model.first) + ": " + _(model.second);
-        blocks.push_back(block);
+            msg += bullet_suf + from_u8(model.first) + ": " + _(model.second);
     }
-    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,6 +47,9 @@ 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;
@@ -321,6 +324,11 @@ 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);
@@ -460,9 +468,6 @@ 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,11 +1036,6 @@ 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;
     }
@@ -1210,10 +1205,6 @@ 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,27 +197,6 @@ 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/
@@ -256,7 +235,11 @@ private:
     ModelVolume*       texture_volume();
     const ModelVolume* texture_volume() const;
 
-    void add_texture_layer();
+    // `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 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
@@ -283,9 +266,6 @@ 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
@@ -423,17 +403,114 @@ 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
@@ -534,11 +611,6 @@ 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;
@@ -770,8 +842,6 @@ 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
@@ -952,26 +1022,25 @@ private:
     bool m_preview_job_pending = false;
     void queue_preview_job();
 
-    // 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;
+    // 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{};
     // 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;
-    std::weak_ptr<const std::vector<unsigned char>> m_height_tex_source;
-    float                                           m_height_tex_smoothing = -1.f;
+    std::unique_ptr<GLTexture> m_height_tex;
+    const void                *m_height_tex_source    = nullptr;
+    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;
-    std::weak_ptr<const std::vector<unsigned char>> m_color_tex_source;
-    float                                           m_color_tex_smoothing = -1.f;
+    std::unique_ptr<GLTexture> m_color_tex;
+    const void                *m_color_tex_source    = nullptr;
+    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;
@@ -1009,12 +1078,9 @@ 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. 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.
+    // 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.
     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
@@ -1057,9 +1123,6 @@ 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,10 +420,7 @@ void GLGizmosManager::refresh_on_off_state()
 
 void GLGizmosManager::reset_all_states()
 {
-    // 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())
+    if (! m_enabled || m_serializing)
         return;
 
     const EType current = get_current_type();
@@ -438,9 +435,6 @@ 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
@@ -528,7 +522,7 @@ bool GLGizmosManager::is_running() const
 
 bool GLGizmosManager::open_gizmo_by_shortcut(Shortcut shortcut)
 {
-    if (!m_enabled || m_gizmos.empty())
+    if (!m_enabled)
         return false;
 
     // The text tool opens without a selection because it creates its own object.
@@ -1433,12 +1427,10 @@ void GLGizmosManager::update_hover_state(const EType &type)
 
 bool GLGizmosManager::activate_gizmo(EType type)
 {
-    // already activated
-    if (m_current == type)
-        return true;
+    assert(!m_gizmos.empty());
 
-    if (m_gizmos.empty())
-        return false;
+    // already activated
+    if (m_current == type) return true;
 
     if (m_current != Undefined) {
         // clean up previous gizmo

src/slic3r/GUI/Gizmos/GizmoObjectManipulation.cpp

@@ -925,9 +925,8 @@ 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();
+    ImGui::PopStyleVar(2);
     ImGuiWrapper::pop_toolbar_style();
 }
 
@@ -1132,11 +1131,10 @@ 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();
+    ImGui::PopStyleVar(2);
     ImGuiWrapper::pop_toolbar_style();
 }
 

src/slic3r/GUI/MultiTaskModel.cpp

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

src/slic3r/GUI/MultiTaskModel.hpp

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

src/slic3r/GUI/PartPlate.cpp

@@ -1880,6 +1880,13 @@ 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,8 +6070,6 @@ 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.)
  *
@@ -6137,26 +6135,13 @@ 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);
-            const int tray_index = is_bbl_vendor ? ams_id * 4 + slot_id : generic_tray_base + slot_id;
-            filament_ams_list.emplace(extruder + tray_index,
+            filament_ams_list.emplace(extruder + (ams_id * 4 + slot_id),
                                       build_tray_config(*tray.second, get_ams_name(ams_id, slot_id), std::to_string(ams_id), std::to_string(slot_id)));
         }
     }
@@ -14999,8 +14984,24 @@ 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);
 
-    // A closed mesh may still self-intersect, so fixing is always allowed.
+#if FIX_THROUGH_CGAL_ALWAYS
+    // Fixing always.
     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
@@ -22040,16 +22041,13 @@ void Plater::clear_before_change_mesh(int obj_idx)
         mv->mmu_segmentation_facets.reset();
         mv->fuzzy_skin_facets.reset();
     }
-    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."));
+    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."));
+    }
 }
 
 void Plater::changed_mesh(int obj_idx)

src/slic3r/GUI/Plater.hpp

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

@@ -0,0 +1,232 @@
+#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

@@ -0,0 +1,36 @@
+#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,7 +3098,6 @@ 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");
@@ -4534,6 +4533,7 @@ 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/MeshRepair.hpp"
+#include "libslic3r/MeshBoolean.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);
-        try {
-            if (!repair_mesh(tm, nullptr, error_message, [&cancel_callback](int) {
-                    if (cancel_callback && cancel_callback())
-                        throw Canceled();
-                }))
-                return false;
-        } catch (const Canceled &) {
+        if (!MeshBoolean::cgal::repair(tm, nullptr, error_message))
+            return false;
+
+        if (cancel_callback && cancel_callback())
             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 before importing."),
-        _L("Mesh repair"), wxYES_NO | wxCANCEL | wxICON_WARNING | wxYES_DEFAULT);
+        _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);
     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,7 +2704,17 @@ void TextureImportDialog::on_mesh_repair_decision_required(wxCommandEvent&)
     dlg.Fit();
     dlg.CenterOnParent();
     int ret = dlg.ShowModal();
-    if (ret == wxID_CANCEL) {
+    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) {
         m_cancel_flag = true;
         if (initial) {
             m_initial_computation_cancelled = true;
@@ -2717,9 +2727,8 @@ void TextureImportDialog::on_mesh_repair_decision_required(wxCommandEvent&)
         }
         return;
     }
-    m_mesh_repair_decision = (ret == wxID_NO)
-        ? Slic3r::TexturePaintingSettings::MeshRepairDecision::RepairAndImport
-        : Slic3r::TexturePaintingSettings::MeshRepairDecision::ImportWithoutRepair;
+    m_mesh_repair_decision = Slic3r::TexturePaintingSettings::MeshRepairDecision::ImportWithoutRepair;
+#endif
 
     start_computation(auto_color, initial);
 }

src/slic3r/GUI/UVEditorCanvas.cpp

@@ -36,7 +36,6 @@
 
 #include "3DScene.hpp"
 #include "BitmapCache.hpp"
-#include "GLCanvas3D.hpp"
 #include "GLShader.hpp"
 #include "GUI_App.hpp"
 #include "I18N.hpp"
@@ -940,8 +939,7 @@ 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 std::vector<int> selection_before = m_selection;
-            const int              hit              = island_at(uv);
+            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).
@@ -971,10 +969,6 @@ 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();
@@ -1325,13 +1319,8 @@ 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();
-    if (!GLCanvas3D::is_frame_in_progress())
-        Update();
+    Update();
 }
 
 void UVEditorCanvas::on_leave(wxMouseEvent &evt)
@@ -1352,16 +1341,6 @@ 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,12 +108,10 @@ 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, SelectionChanged
+        SetBackground, PickTexture, PaneClosed
     };
     void run_command(Command cmd, float value = 0.f);
     using CommandFn = std::function<void(Command, float)>;

src/slic3r/GUI/wxinit.h

@@ -0,0 +1,15 @@
+#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,115 +3,240 @@
 #include <algorithm>
 #include <atomic>
 #include <chrono>
+#include <cmath>
 #include <condition_variable>
-#include <cstddef>
+#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 <mutex>
+#include "slic3r/GUI/Widgets/ProgressDialog.hpp"
+#include <optional>
 #include <string>
 #include <thread>
+#include <utility>
 #include <vector>
-
 #include <wx/string.h>
 
-#include "libslic3r/Format/bbs_3mf.hpp"
-#include "libslic3r/MeshRepair.hpp"
+#include "libslic3r/MeshBoolean.hpp"
 #include "libslic3r/Model.hpp"
+#include "libslic3r/Format/bbs_3mf.hpp"
+#include "libslic3r/format.hpp"
 #include "libslic3r/Thread.hpp"
-#include "slic3r/GUI/I18N.hpp"
-#include "slic3r/GUI/Widgets/ProgressDialog.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.
 
 namespace Slic3r {
 
 namespace {
 
-class RepairCanceledException : public std::exception
+// Orca: Helper functions for analyzing mesh properties and transformations.
+
+bool is_not_3dimensional_part(const TriangleMesh &mesh)
 {
-public:
-    const char *what() const noexcept override { return "Model repair has been canceled"; }
-};
+    // 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;
+}
 
 } // namespace
 
-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)
+// 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)
 {
-    // Keeps the backup manager from reading a mesh while the worker replaces it.
+    // Hold SaveObjectGaurd to prevent backup manager from racing concurrent mesh mutations (use-after-free).
     SaveObjectGaurd backup_gaurd(model_object);
 
-    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;
+    // Orca: Synchronization primitives for progress updates between worker thread and GUI.
+    std::mutex mtx;
     std::condition_variable condition;
-    struct Progress
-    {
+    struct Progress {
         std::string message;
-        int         percent = 0;
-        bool        updated = false;
+        int         percent  = 0;
+        bool        updated  = false;
     } progress;
+
     std::atomic<bool> canceled = false;
     std::atomic<bool> finished = false;
-    bool              any_modified = false;
-    std::string       errors;
 
-    auto on_progress = [&mtx, &condition, &progress](const std::string &msg, int percent) {
-        std::lock_guard<std::mutex> lock(mtx);
+    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);
         progress.message = msg;
-        progress.percent = percent;
+        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.updated = true;
         condition.notify_all();
     };
 
-    auto worker_thread = std::thread([&]() {
-        set_current_thread_name("cgal_fix_model");
+    // 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]() {
         try {
-            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);
+	        set_current_thread_name("cgal_fix_model");
 
-                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;
+            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);
             }
-        } catch (const RepairCanceledException &) {
+
+            model_object.invalidate_bounding_box();
+
+            if (ivolume > 0)
+                --ivolume;
+            on_progress(_u8L("Repair finished"), 100);
+            success = true;
+            finished = true;
+        } catch (RepairCanceledException &) {
             canceled = true;
-        } catch (const std::exception &ex) {
-            errors += (errors.empty() ? "" : "\n") + std::string(ex.what());
+            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);
         }
-        // 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; });
-        // 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)))
+        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)))
             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,9 +12,8 @@ class Model;
 class ModelObject;
 class Print;
 
-// 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);
+// 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);
 
 } // namespace Slic3r
 

src/slic3r/Utils/MoonrakerPrinterAgent.cpp

@@ -59,42 +59,6 @@ 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;
@@ -477,7 +441,19 @@ 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
@@ -485,9 +461,11 @@ 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) {
-        if (ams_id < 32) {
-            ams_exist_bits |= (1UL << 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 
 
         nlohmann::json tray_array = nlohmann::json::array();
         int max_slot_in_this_ams = std::min(3, max_lane_index - ams_id * 4);
@@ -503,135 +481,43 @@ void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index,
                 }
             }
 
-            if (tray && tray->has_filament && slot_index < 32) {
-                tray_exist_bits |= (1UL << slot_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";
             }
 
-            static const AmsTrayData empty_tray;
-            tray_array.push_back(make_ams_tray_json(std::to_string(slot_id), tray ? *tray : empty_tray));
+            tray_array.push_back(tray_json);
         }
-
-        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();
@@ -642,6 +528,7 @@ void MoonrakerPrinterAgent::submit_ams_payload(const nlohmann::json& ams_array,
 
     // 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.
@@ -681,15 +568,17 @@ 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";
-        build_ams_payload_grouped(trays);
+        int ams_count = (max_lane_index + 4) / 4;
+        build_ams_payload(ams_count, max_lane_index, trays);
         return true;
     }
 
-    // Fall back to the Happy Hare `mmu` object for HH builds that do not publish lane_data
+    // Attempt Happy Hare first (more widely adopted, supports more filament changers)
     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";
-        build_ams_payload_grouped(trays);
+        int ams_count = (max_lane_index + 4) / 4;
+        build_ams_payload(ams_count, max_lane_index, trays);
         return true;
     }
 
@@ -795,30 +684,6 @@ 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())
@@ -922,39 +787,28 @@ 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;
         }
 
-        // 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) {
-            lane_index = lane_index_from_key(lane_key);
-            if (lane_index < 0) {
-                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;
             }
         }
 
+        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");
@@ -1059,121 +913,52 @@ bool MoonrakerPrinterAgent::fetch_hh_filament_info(std::vector<AmsTrayData>& tra
         return false;
     }
 
-    // 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.
+    // Parse gate data
     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);
 
-        AmsTrayData tray;
-        tray.slot_index = gate_idx;
-        tray.extruder_id = 0;
-
-        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;
+        // 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;
+
+        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);
+
+        max_lane_index = std::max(max_lane_index, gate_idx);
         trays.push_back(tray);
     }
 
-    max_lane_index = num_gates - 1;
+    if (trays.empty()) {
+        BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::fetch_hh_filament_info: No valid HH gates found";
+        return false;
+    }
 
     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;
-    }
-
-    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)
 {
     auto json = nlohmann::json::parse(json_str, nullptr, false);

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -7,7 +7,6 @@
 #include <functional>
 #include <cstdint>
 #include <atomic>
-#include <map>
 #include <memory>
 #include <mutex>
 #include <set>
@@ -89,7 +88,6 @@ 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)
@@ -101,10 +99,6 @@ 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;
@@ -169,22 +163,10 @@ 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

@@ -0,0 +1,19 @@
+#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,22 +31,6 @@ 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

@@ -1,89 +0,0 @@
-#!/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

@@ -1,83 +0,0 @@
-#!/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

@@ -1,35 +0,0 @@
-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,61 +178,6 @@ 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,29 +1748,3 @@ 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,10 +223,7 @@ 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", "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" })
+	for (const char *key : { "filament_type", "filament_vendor", "filament_start_gcode" })
 		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,79 +315,6 @@ 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,7 +43,6 @@
 #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"
@@ -157,81 +156,6 @@ 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,6 +37,7 @@ 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
@@ -53,7 +54,6 @@ 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,7 +28,6 @@
 #include <miniz.h>
 #include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/TriangleSelector.hpp"
-#include "libslic3r/TextureDisplacement.hpp"
 #include <memory>
 #include <cstdint>
 #include <ios>
@@ -39,7 +38,6 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <algorithm>
 #include <functional>
-#include <initializer_list>
 
 #include <catch2/catch_tostring.hpp>
 #include <Eigen/Core>
@@ -351,24 +349,6 @@ 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)
@@ -383,7 +363,19 @@ static void store_painted_cube(const std::string& path)
         selector.set_facet(1, EnforcerBlockerType::Extruder3);
         REQUIRE(volume->mmu_segmentation_facets.set(selector));
     }
-    store_project(model, path, SaveStrategy::Zip64 | SaveStrategy::Silence);
+    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));
 }
 
 // Loads `path` through the BBS importer into `model`, releasing the plates it returns. The
@@ -509,163 +501,6 @@ 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

@@ -0,0 +1,379 @@
+#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

@@ -1,255 +0,0 @@
-#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);
-}