Address the review on saving texture displacement

Read each layer's texture from the archive only. `layer.path` comes from the project file, so following it let any .3mf pick a local file to read, a UNC path among them, and have the next save copy what it found into the archive. Reverts the disk fallback added in 8ecfee6a2. Store a paint mask only for the slots a triangle names. Eight empty strings per triangle cost every project hundreds of megabytes on a large mesh, whether or not it uses the feature. A slot's run is padded to the triangles seen so far on its first value, so it stays indexed by triangle, and ends at its last painted one. Report a malformed layer block instead of throwing out of the project load. The typed accessors throw on a value of the wrong type and nothing above them caught that, so one bad number cost the whole file rather than one volume's relief. Cover the store and load round trip in test_3mf.cpp: the layer, its image, the options and the paint, the two regressions above, paint at either end of the triangle list, two volumes sharing a slot, and the wrong-typed documents at the unit level.
Merge branch 'main' into feature/texdisp-3mf-persistence
2026-10-16 12:21:11 +00:00 · 2026-10-12 14:20:46 +02:00 · 2026-10-12 16:58:03 +08:00 · 2026-10-09 09:35:35 +02:00 · 2026-10-09 09:05:42 +02:00 · 2026-10-09 09:03:51 +02:00
30 changed files with 1128 additions and 2930 deletions
@@ -1,239 +0,0 @@
-# ChromaStack - High Level Design
-
-## Purpose and scope
-
-ChromaStack prints a colour picture on a single face of a model: a few filaments are printed one on
-top of another, the printer swaps filament at fixed layer boundaries, and the *height* of every
-pixel decides how many of those layers reach it. Filament is translucent, so a pixel that stops
-part-way through a run shows a blend of that run's filament and whatever is under it, which is
-where the colours come from - far more of them than there are filaments loaded.
-
-This is that model inside OrcaSlicer, as a mode of a texture displacement layer. The picture and
-the filament stack are the input; the output is a grayscale height map and a set of filament swaps.
-Nothing about it is a new pipeline: the height map is handed to the layer the user painted, so the
-existing projection, preview and bake turn it into real geometry, and the swaps are handed to the
-object's height ranges, which is the slicer's own way of printing a Z band in another filament.
-
-It does not import other filament-painting tools' project files, and it does not choose the filaments or
-their order - that is the user's artistic decision, and the panel exists to make its result
-visible before the print.
-
-## The colour model
-
-`libslic3r/ChromaStack.hpp` holds the whole of it, free of any GUI dependency, which is what lets the
-solve run against plain image bytes and be unit tested.
-
-A **stack** (`ChromaStack`) is a list of **bands** (`ChromaBand`), bottom-up: a filament and
-how many layers it gets. Alongside them it carries the print's layer height, which the colours
-depend on directly, and the **base**: how many layers of solid backing the picture sits on.
-
-The base is not a band. It is a measurement of the model - everything below the painted face, often
-a hundred layers or more on a tall part - while a band is a handful of layers the user chooses. It
-prints in the bottom band's filament, because that is what is loaded when the print starts, so it
-extends that band's height range down to the first layer instead of being a swap of its own. Only
-the bands are quantized into the height map, which is why the 255-layer limit
-(`CHROMA_MAX_RELIEF_LAYERS`) bounds the picture and not the stack.
-
-Each filament carries its **transmission distance** (TD), the usual measure for how deep
-light gets into it: about 1 for an opaque filament, 4 to 7 for a usefully translucent one, 8 and
-above for a nearly clear one. TD lives in the filament preset, as
-`filament_transmission_distance` - it is a property of the material, so it belongs with the
-material and ships with a profile rather than being retyped per project. It has no effect on
-slicing.
-
-`chroma_palette()` turns a stack into the colour it shows at every possible column height, which
-is all the solver ever needs. The model is Beer-Lambert absorption, layer by layer: a layer of
-thickness `h` in a filament of transmission distance `TD` passes
-
-    T = exp(-h / (CHROMA_TD_OPAQUE_FRACTION * TD / 3))
-
-of the light from under it and shows its own colour with the rest, so walking up from an opaque
-base,
-
-    C_k = (1 - T_k) * c_k + T_k * C_(k-1),  C_0 = c_1
-
-The constants say what TD means in physical terms: a filament stops showing what is behind it at
-about a tenth of its TD number (`CHROMA_TD_OPAQUE_FRACTION`), and three e-folding lengths of
-absorption pass 5% of the light, which is where the eye stops seeing through. Those are calibrated
-against how the community's TD step prints behave, not derived from first principles - TD is an
-empirical scale.
-
-How fast that happens is the single most useful fact about a stack, and `chroma_layers_to_opaque()`
-is it: a filament hides what is under it at about a tenth of its TD, so how many *layers* that takes
-depends entirely on how thick they are. TD 4 covers in two layers at 0.2 mm and in five at 0.08 mm.
-Below about two layers a band has no intermediate colours at all - the picture can only use the
-filament or not use it - which is why an otherwise sound stack prints as flat steps at a coarse
-layer height. The panel reports the number under the palette ramp, and warns when it falls below
-two, because nothing else makes it visible: the filaments look fine, the bands look long enough, and
-the result looks like the colour model is wrong when it is the layer height.
-
-How many of a picture's layers actually earn their place is a second question, and
-`chroma_distinct_levels()` answers it: a band eventually hides what is under it, and another layer of
-it then shows the colour the one below already showed. It is measured against the palette rather than
-against TD, because how long a band keeps paying depends on what is under it as much as on the
-filament - a light band over a dark one is finished in four or five layers, while a dark one over a
-light one goes on moving the colour perceptibly well past the depth at which it is nominally opaque,
-since the last few percent of light coming through still shifts a near-black colour. `Trim` shortens
-each band to its last layer that still changes anything.
-
-Beer-Lambert is also the only model that stays self-consistent applied per layer: transmittance
-multiplies, so a run of n layers of one filament passes `exp(-n h / d)` whether it is composited in
-one step or n, and the palette therefore does not depend on how the stack happens to be cut into
-bands. A unit test asserts exactly that. Compositing is done on linear light, because the quantity
-being attenuated is light rather than an sRGB code.
-
-The base is assumed opaque. That is what makes a column's colour depend only on the layers above it,
-and it is why the panel warns when the base is thin.
-
-## The solve
-
-`chroma_solve()` maps each pixel of the picture to the column height whose palette colour is
-closest to it, perceptually: both sides go to CIELAB and the match is a CIE76 distance. A 1-D
-palette of a few dozen entries makes the extra accuracy of CIEDE2000 hard to see and the cost of it
-easy to feel - several hundred million comparisons for a large picture - so the cheaper metric is
-the deliberate choice here, unlike the texture colour quantizer, which matches against a
-two-dimensional palette of filament mixes and uses a precomputed CIEDE2000 cube.
-
-Optional Floyd-Steinberg error diffusion, serpentine, trades the bands a photograph shows across a
-sky or a cheek for fine stipple. Off by default, since stipple is the artifact rather than the cure
-for flat-coloured artwork.
-
-Three things come back: the per-pixel layer count, the same thing as an 8-bit grayscale height map
-(0 at the base, 255 at the top of the stack), and the palette colours chosen, as an RGB image. The
-quantization belongs to the solve rather than to the displacement because the relief's steps have
-to land on layer boundaries, and a grey level is the only channel the displacement reads.
-
-The solve also reports the mean and worst colour difference it had to accept. That is the only
-honest answer to "will this stack reproduce my picture": under about 5 is a good match, over about
-15 means the filaments cannot reach the picture's colours and no number of layers will help.
-
-## How it attaches to a texture displacement layer
-
-A ChromaStack layer is an ordinary `TextureDisplacementLayer` whose height map is computed rather than
-imported:
-
- `chroma_source` keeps the picture the user chose, so the solve can be redone whenever the stack,
-  the layer height or the picture changes;
- `chroma` is the stack;
- `image_data` - the same field every other layer uses - holds whatever the last solve produced.
-
-So everything downstream needs no changes at all and knows nothing about colour stacks. It also
-means the solve writes `depth_mm` (the relief is exactly as tall as the layers above the base) and
-pins `invert`, `midlevel` and `smoothing`: blurring a solved height map moves its steps off the
-layer boundaries they were solved for.
-
-Colour by filament swap and the layer's own `color_enabled` (one filament per triangle, via
-`mmu_segmentation_facets`) are mutually exclusive, and the panel enforces it. They are two
-different ways of colouring the same surface, and painting the relief per triangle would hide the
-very stack the heights were solved against.
-
-## The filament swaps
-
-`chroma_ranges()` turns the bands into Z bands in the object's own coordinates, merging any two
-adjacent bands that share a filament, since nothing is swapped between them. The panel writes them
-onto the object as `layer_config_ranges`, each range carrying `extruder` - which
-`apply_to_print_region_config()` spreads over every feature filament the range does not otherwise
-override, i.e. the whole band prints in that filament - and `layer_height`, both because the solve
-is only valid at the height it was run at and because `layer_height_profile_from_ranges()` reads
-that option without checking it is there.
-
-Height ranges rather than colour-change custom G-code: they are object-relative, so they survive
-the object being moved, they are saved in the project file, and they appear in the object list where
-the user can see and edit them. The cost is that an object can only have one set of them, so
-applying a stack replaces whatever ranges the object had, with a confirmation when it had any.
-
-`ObjectList::rebuild_layer_ranges()` mirrors them in the object tree without touching the
-selection - changing the selection while a gizmo is open tears the gizmo down under the user.
-
-## Geometry the model assumes
-
-A filament swap happens at one Z across the whole plate, and the relief grows along the painted
-surface's normal. The two agree only where that surface is horizontal, so:
-
- the painted patch's height above the bottom of the object is what the base layer count has to
-  match, and the panel measures it from the patch and offers the number rather than leaving the user
-  to work it out;
- a patch that is not flat in Z gets a warning, because its colours will only be right where it is
-  level. The relief itself is still computed, since a gently domed plaque is a legitimate thing to
-  print and only the user can judge how much error is acceptable.
-
-The model itself is the user's: the stack needs a slab of the base thickness with a face to paint,
-and nothing here creates or thickens geometry.
-
-## Seeing the colours
-
-The colours are blends of translucent filaments. No single filament makes them, so they cannot be
-expressed as the per-triangle filament assignment the 3D scene paints with, and there is nothing for
-the ordinary view to draw. They exist in two places: the sliced preview, which shows the filament
-bands as they print, and an overlay the gizmo draws over whatever surface is on screen.
-
-That overlay is a shader, `resources/shaders/*/chromastack.*`, and it reads the colour from each
-fragment's own **print Z** rather than from the height map or from anything in the mesh. A filament
-swap happens at one Z across the whole plate, so the layer a point sits in is what decides its
-colour whatever the picture says. Two things follow. A band edge lands exactly on the layer boundary
-however coarse the triangles are - a per-triangle colouring puts it wherever the mesh happens to
-have an edge. And it keeps working after a bake, when the relief is real geometry, the paint has
-been cleared and the height map is attached to nothing on screen; the overlay is built from the live
-preview's displaced mesh before a bake and from the volume's own mesh after one.
-
-The stack's colours reach the shader as a texture of one texel per printed layer, because a base can
-be several hundred layers and no uniform array holds that. The mesh carries nothing about the stack,
-so editing the stack costs a palette upload rather than a mesh rebuild.
-
-On top of the colour the shader tries to look like printed plastic, because a flat shaded colour
-reads as a rendering and the whole point of the overlay is judging a print:
-
- the terminator is **wrapped** and the grazing angles **glow**, both scaled by the transmission
-  distance of the filament on top - filament translucent enough to be worth stacking scatters light
-  rather than reflecting it, and an opaque stack correctly gets neither;
- the walls carry **layer lines**, a groove at every layer boundary that also modulates the
-  specular, so a wall glints in stripes as a printed one does. Terraces get none: a terrace is one
-  layer's top surface and has no lines to show.
-
-Both effects are driven by the fragment's height, so they are free of any texture or UV, and both
-fade out through `fwidth` once a pixel covers more than about half a layer - lines finer than a
-pixel are noise, and a colour read from one layer out of the dozen under a pixel flickers as the
-camera moves. The palette lookup slides off the texel centres over the same range so the linear
-filter averages the bands a pixel covers instead of picking one of them.
-
-The overlay is drawn pulled forward and without depth writes, the same pass the painted-colour
-overlay uses, since it is the same surface as whatever is underneath it.
-
-## What the panel shows
-
-The kind of a layer is the layer's own, chosen when it is added and fixed from then on: **Add layer**
-offers *Relief layer* or *ChromaStack picture*, and the card carries its kind as a chip. There is no
-panel-wide mode, so one object can hold a picture on its face and a knurl on its rim, and a card
-never shows a control that cannot do anything on it.
-
-What the two cards do not share:
-
-| Control | Relief card | ChromaStack card |
-| --- | --- | --- |
-| Depth | slider | the solve writes it; the card prints the result |
-| Tile size | repeats the pattern | **Picture size**, the same number named for what it does |
-| Midlevel, Smoothing, Invert, Edge fade | present | absent: each would move the steps off the layer boundaries |
-| Colors, Mix filaments, Denoise | one filament per triangle | absent: swaps are how this card colours |
-| Tile, tile method | present | absent: one copy, never tiled |
-| Blend | four modes | absent: it is the top layer and replaces what is under it |
-| Picture, prediction, stack, palette, match, Dither, Solve, Apply swaps | absent | present |
-
-A ChromaStack card has no grip and cannot be reordered: its colours come from swapping filament at a
-height, so anything printed above it would bury them. An object may hold only one, refused when the
-layer is added rather than when the swaps are applied, because the swaps are the object's own height
-ranges and there is one set of those.
-
-The card itself, top to bottom: what it is in one line, the picture and the predicted print side by
-side at the same size, the match figures, the base with the measurement from the painted face offered
-beside it, a row per band - swatch, filament, layer count, TD - the colours the stack reaches as a
-ramp, the totals, dither with the layer height it is solved against, and the two actions. Base and
-band counts are typed fields rather than sliders: a base is measured in hundreds of layers and a band
-in single digits, and dragging past the end of a slider's range is how a stack silently loses its
-backing.
-
-The ramp is computed from the stack alone, before any solve. It is what answers "can these filaments
-print this picture" without spending a solve to find out they cannot: a short or flat ramp means the
-filaments are too alike, or too opaque, to give the picture anything to work with.
-
-A per-slot flag records that the stack has been edited since the last solve, because a stale height
-map looks exactly like a good one.
@@ -1,6 +1,6 @@
 {
 	"name": "Qidi",
-	"version": "02.04.00.17",
+	"version": "02.04.00.16",
 	"force_update": "0",
 	"description": "Qidi configurations",
 	"machine_model_list": [
@@ -83,7 +83,7 @@
 	"extruder_clearance_height_to_lid": "120",
 	"layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nLOG_Z\nG92 E0\n",
 	"machine_end_gcode": "M141 S0\nM104 S0\nM140 S0\nG1 E-3 F1800\nG0 Z{min(max_print_height, max_layer_z + 3)} F600\nG0 X0 Y0 F12000\n{if max_layer_z < max_print_height / 2}G1 Z{max_print_height / 2 + 10} F600{else}G1 Z{min(max_print_height, max_layer_z + 3)}{endif}",
-	"machine_start_gcode": "PRINT_START BED=[bed_temperature_initial_layer_single] HOTEND=[nozzle_temperature_initial_layer] CHAMBER=[chamber_temperature]\nM83\nM140 S[bed_temperature_initial_layer_single]\nM104 S[nozzle_temperature_initial_layer]\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 3} Z0\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 6}\nG1 Z1 F600\n",
+	"machine_start_gcode": "PRINT_START BED=[hot_plate_temp_initial_layer] HOTEND=[nozzle_temperature_initial_layer] CHAMBER=[chamber_temperature]\nM83\nM140 S[hot_plate_temp_initial_layer]\nM104 S[nozzle_temperature_initial_layer]\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 3} Z0\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 6}\nG1 Z1 F600\n",
 	"thumbnails_format": "PNG",
 	"default_filament_profile": [
 		"Generic PLA @Qidi Q1 Pro 0.4 nozzle"
@@ -100,7 +100,7 @@
 	"default_filament_profile": [
 		"Generic PLA @Qidi"
 	],
-	"machine_start_gcode": "G28\nM140 S[bed_temperature_initial_layer_single]\nM190 S[bed_temperature_initial_layer_single]\nM109 S[nozzle_temperature_initial_layer]\nG92 E-19\nG0 Y5 Z0.3 F3600\nG1 X5 E0 F2400\n",
+	"machine_start_gcode": "G28\nM140 S[hot_plate_temp_initial_layer]\nM190 S[hot_plate_temp_initial_layer]\nM109 S[nozzle_temperature_initial_layer]\nG92 E-19\nG0 Y5 Z0.3 F3600\nG1 X5 E0 F2400\n",
 	"machine_end_gcode": "M104 S0\nM140 S0\n;Retract the filament\nG92 E0\nG1 E-3 F300\nG28\nM84\n",
 	"scan_first_layer": "0"
 }
@@ -24,7 +24,7 @@
 		"210x210/COLPIC",
 		"110x110/PNG"
 	],
-	"machine_start_gcode": "PRINT_START\nG28\nM141 S0\nG0 Z50 F600\nM190 S[bed_temperature_initial_layer_single]\nG28 Z\nG29; mesh bed leveling ,comment this code to close it\nG0 X0 Y0 Z50 F6000\nM141 S{overall_chamber_temperature}\nM109 S[nozzle_temperature_initial_layer]\nM106 P3 S255\nM83\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 12} E{-10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 E{10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\n",
+	"machine_start_gcode": "PRINT_START\nG28\nM141 S0\nG0 Z50 F600\nM190 S[hot_plate_temp_initial_layer]\nG28 Z\nG29; mesh bed leveling ,comment this code to close it\nG0 X0 Y0 Z50 F6000\nM141 S{overall_chamber_temperature}\nM109 S[nozzle_temperature_initial_layer]\nM106 P3 S255\nM83\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 12} E{-10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 E{10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\n",
 	"machine_end_gcode": "M141 S0\nM104 S0\nM140 S0\nG1 E-3 F1800\nG0 Z{min(max_print_height, max_layer_z + 3)} F600\nG0 X0 Y0 F12000\n{if max_layer_z < max_print_height / 2}G1 Z{max_print_height / 2 + 10} F600{else}G1 Z{min(max_print_height, max_layer_z + 3)}{endif}",
 	"scan_first_layer": "0"
 }
@@ -1,92 +0,0 @@
-#version 110
-
-// What a ChromaStack print looks like, shaded per fragment.
-//
-// The colour is not a vertex attribute and not a texture on the surface: it is read from the
-// fragment's own height. A filament swap happens at one print Z across the whole plate, so the layer
-// a point sits in is what decides its colour - which means a band edge lands exactly on the layer
-// boundary however coarse the mesh is, and the same shader is right before a bake (on the preview's
-// displaced mesh) and after one (on the volume's own).
-//
-// On top of that it tries to look like printed plastic rather than like flat shaded colour: the
-// terminator is wrapped and the grazing angles glow, because filament translucent enough to be worth
-// stacking scatters light rather than reflecting it; and the walls carry layer lines, because that is
-// the first thing the eye uses to read a print as a print.
-
-#define INTENSITY_CORRECTION 0.6
-const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
-#define LIGHT_TOP_DIFFUSE    (0.8 * INTENSITY_CORRECTION)
-#define LIGHT_TOP_SPECULAR   (0.125 * INTENSITY_CORRECTION)
-#define LIGHT_TOP_SHININESS  20.0
-const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
-#define LIGHT_FRONT_DIFFUSE  (0.3 * INTENSITY_CORRECTION)
-#define INTENSITY_AMBIENT    0.3
-
-// The stack's colours, one texel per printed layer, bottom to top. A texture rather than a uniform
-// array because a base can be several hundred layers and no uniform array survives that.
-uniform sampler2D palette;
-uniform float     palette_size;  // texels in `palette`, i.e. the stack's total printed layers
-uniform float     base_z;        // world Z of the bottom of the object
-uniform float     layer_height;  // mm
-// How translucent the stack reads, 0 to 1, from the transmission distance of the filament on top.
-// It drives the wrap and the rim: an opaque stack should not glow.
-uniform float     translucency;
-uniform float     alpha;
-
-varying vec3  clipping_planes_dots;
-varying vec3  eye_normal;
-varying vec3  eye_position;
-varying vec3  world_normal;
-varying float world_z;
-
-void main()
-{
-    if (any(lessThan(clipping_planes_dots, vec3(0.0))))
-        discard;
-
-    float z_rel  = world_z - base_z;
-    float layers = max(z_rel / layer_height, 0.0);
-    // How much of a layer one pixel covers. Everything below is faded out as this grows: layer lines
-    // finer than a pixel are noise, and a colour read from one layer out of the dozen under a pixel
-    // flickers as the camera moves.
-    float px     = fwidth(layers);
-
-    // The layer this fragment sits in, 1-based. Up close that is an exact texel of the palette; once a
-    // pixel spans a layer or more it slides to a continuous coordinate so the linear filter averages
-    // the bands it covers instead of picking one of them at random.
-    float stepped = clamp(ceil(layers - 1.0e-4), 1.0, palette_size) - 0.5;
-    float smooth_ = clamp(layers, 0.5, palette_size - 0.5);
-    float u       = mix(stepped, smooth_, clamp(px - 0.5, 0.0, 1.0)) / palette_size;
-    vec3  albedo  = texture2D(palette, vec2(u, 0.5)).rgb;
-
-    vec3 N = normalize(eye_normal);
-    vec3 V = normalize(-eye_position);
-
-    // Layer lines, on the walls only: a terrace is one layer's top surface and has none to show. The
-    // groove runs round the part at every layer boundary, so it is a function of height alone.
-    float wall   = 1.0 - abs(world_normal.z);
-    float phase  = fract(layers);
-    float groove = smoothstep(0.0, 0.16, phase) * smoothstep(1.0, 0.84, phase);
-    groove       = mix(groove, 0.65, clamp(px * 1.5, 0.0, 1.0)); // fade to flat when too fine to resolve
-    float lines  = mix(1.0, 0.84 + 0.16 * groove, wall * 0.9);
-    albedo      *= lines;
-
-    // Diffuse, with a wrapped terminator: light entering translucent filament comes back out a little
-    // way round the curve, so the shaded side never goes as dark as an opaque surface's would.
-    float wrap    = 0.25 + 0.45 * translucency;
-    float ndotl   = dot(N, LIGHT_TOP_DIR);
-    float diffuse = max((ndotl + wrap) / (1.0 + wrap), 0.0) * LIGHT_TOP_DIFFUSE;
-    diffuse      += max((dot(N, LIGHT_FRONT_DIR) + wrap) / (1.0 + wrap), 0.0) * LIGHT_FRONT_DIFFUSE;
-
-    // Specular, strongest along a layer line, which is what makes a printed wall glint in stripes
-    // rather than evenly.
-    float spec = LIGHT_TOP_SPECULAR * pow(max(dot(V, reflect(-LIGHT_TOP_DIR, N)), 0.0), LIGHT_TOP_SHININESS);
-    spec      *= mix(1.0, 0.35 + 0.65 * groove, wall * 0.9);
-
-    // Scattering out of the edges: a translucent part lights up where it is seen at a grazing angle
-    // and where it is thin. Tinted by the filament, because what comes back out has been through it.
-    float rim = pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 4.0);
-
-    vec3 color = albedo * (INTENSITY_AMBIENT + diffuse) + vec3(spec) + albedo * rim * translucency * 0.55;
-    gl_FragColor = vec4(color, alpha);
-}
@@ -1,40 +0,0 @@
-#version 110
-
-uniform mat4 view_model_matrix;
-uniform mat4 projection_matrix;
-uniform mat3 view_normal_matrix;
-uniform mat4 volume_world_matrix;
-// The volume's normal matrix in world space, so the fragment shader can tell a wall from a terrace -
-// which is what decides whether layer lines show at all.
-uniform mat3 world_normal_matrix;
-// Clipping plane, x = min z, y = max z (the FFF/SLA preview's top/bottom cut).
-uniform vec2 z_range;
-// Clipping plane, general orientation (the section view).
-uniform vec4 clipping_plane;
-
-// GLModel's P3N3 layout, which is what init_from(indexed_triangle_set) produces - this shader needs
-// nothing per vertex that the mesh does not already carry, because the colour comes from the
-// fragment's own height rather than from anything baked into the vertices.
-attribute vec3 v_position;
-attribute vec3 v_normal;
-
-varying vec3  clipping_planes_dots;
-varying vec3  eye_normal;
-varying vec3  eye_position;
-varying vec3  world_normal;
-varying float world_z;
-
-void main()
-{
-    vec4 model_pos = vec4(v_position, 1.0);
-    vec4 world_pos = volume_world_matrix * model_pos;
-    world_z        = world_pos.z;
-    world_normal   = normalize(world_normal_matrix * v_normal);
-    eye_normal     = normalize(view_normal_matrix * v_normal);
-
-    vec4 eye_pos = view_model_matrix * model_pos;
-    eye_position = eye_pos.xyz;
-    gl_Position  = projection_matrix * eye_pos;
-
-    clipping_planes_dots = vec3(dot(world_pos, clipping_plane), world_pos.z - z_range.x, z_range.y - world_pos.z);
-}
@@ -1,94 +0,0 @@
-#version 140
-
-// What a ChromaStack print looks like, shaded per fragment.
-//
-// The colour is not a vertex attribute and not a texture on the surface: it is read from the
-// fragment's own height. A filament swap happens at one print Z across the whole plate, so the layer
-// a point sits in is what decides its colour - which means a band edge lands exactly on the layer
-// boundary however coarse the mesh is, and the same shader is right before a bake (on the preview's
-// displaced mesh) and after one (on the volume's own).
-//
-// On top of that it tries to look like printed plastic rather than like flat shaded colour: the
-// terminator is wrapped and the grazing angles glow, because filament translucent enough to be worth
-// stacking scatters light rather than reflecting it; and the walls carry layer lines, because that is
-// the first thing the eye uses to read a print as a print.
-
-#define INTENSITY_CORRECTION 0.6
-const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
-#define LIGHT_TOP_DIFFUSE    (0.8 * INTENSITY_CORRECTION)
-#define LIGHT_TOP_SPECULAR   (0.125 * INTENSITY_CORRECTION)
-#define LIGHT_TOP_SHININESS  20.0
-const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
-#define LIGHT_FRONT_DIFFUSE  (0.3 * INTENSITY_CORRECTION)
-#define INTENSITY_AMBIENT    0.3
-
-// The stack's colours, one texel per printed layer, bottom to top. A texture rather than a uniform
-// array because a base can be several hundred layers and no uniform array survives that.
-uniform sampler2D palette;
-uniform float     palette_size;  // texels in `palette`, i.e. the stack's total printed layers
-uniform float     base_z;        // world Z of the bottom of the object
-uniform float     layer_height;  // mm
-// How translucent the stack reads, 0 to 1, from the transmission distance of the filament on top.
-// It drives the wrap and the rim: an opaque stack should not glow.
-uniform float     translucency;
-uniform float     alpha;
-
-in vec3  clipping_planes_dots;
-in vec3  eye_normal;
-in vec3  eye_position;
-in vec3  world_normal;
-in float world_z;
-
-out vec4 out_color;
-
-void main()
-{
-    if (any(lessThan(clipping_planes_dots, vec3(0.0))))
-        discard;
-
-    float z_rel  = world_z - base_z;
-    float layers = max(z_rel / layer_height, 0.0);
-    // How much of a layer one pixel covers. Everything below is faded out as this grows: layer lines
-    // finer than a pixel are noise, and a colour read from one layer out of the dozen under a pixel
-    // flickers as the camera moves.
-    float px     = fwidth(layers);
-
-    // The layer this fragment sits in, 1-based. Up close that is an exact texel of the palette; once a
-    // pixel spans a layer or more it slides to a continuous coordinate so the linear filter averages
-    // the bands it covers instead of picking one of them at random.
-    float stepped = clamp(ceil(layers - 1.0e-4), 1.0, palette_size) - 0.5;
-    float smooth_ = clamp(layers, 0.5, palette_size - 0.5);
-    float u       = mix(stepped, smooth_, clamp(px - 0.5, 0.0, 1.0)) / palette_size;
-    vec3  albedo  = texture(palette, vec2(u, 0.5)).rgb;
-
-    vec3 N = normalize(eye_normal);
-    vec3 V = normalize(-eye_position);
-
-    // Layer lines, on the walls only: a terrace is one layer's top surface and has none to show. The
-    // groove runs round the part at every layer boundary, so it is a function of height alone.
-    float wall   = 1.0 - abs(world_normal.z);
-    float phase  = fract(layers);
-    float groove = smoothstep(0.0, 0.16, phase) * smoothstep(1.0, 0.84, phase);
-    groove       = mix(groove, 0.65, clamp(px * 1.5, 0.0, 1.0)); // fade to flat when too fine to resolve
-    float lines  = mix(1.0, 0.84 + 0.16 * groove, wall * 0.9);
-    albedo      *= lines;
-
-    // Diffuse, with a wrapped terminator: light entering translucent filament comes back out a little
-    // way round the curve, so the shaded side never goes as dark as an opaque surface's would.
-    float wrap    = 0.25 + 0.45 * translucency;
-    float ndotl   = dot(N, LIGHT_TOP_DIR);
-    float diffuse = max((ndotl + wrap) / (1.0 + wrap), 0.0) * LIGHT_TOP_DIFFUSE;
-    diffuse      += max((dot(N, LIGHT_FRONT_DIR) + wrap) / (1.0 + wrap), 0.0) * LIGHT_FRONT_DIFFUSE;
-
-    // Specular, strongest along a layer line, which is what makes a printed wall glint in stripes
-    // rather than evenly.
-    float spec = LIGHT_TOP_SPECULAR * pow(max(dot(V, reflect(-LIGHT_TOP_DIR, N)), 0.0), LIGHT_TOP_SHININESS);
-    spec      *= mix(1.0, 0.35 + 0.65 * groove, wall * 0.9);
-
-    // Scattering out of the edges: a translucent part lights up where it is seen at a grazing angle
-    // and where it is thin. Tinted by the filament, because what comes back out has been through it.
-    float rim = pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 4.0);
-
-    vec3 color = albedo * (INTENSITY_AMBIENT + diffuse) + vec3(spec) + albedo * rim * translucency * 0.55;
-    out_color  = vec4(color, alpha);
-}
@@ -1,40 +0,0 @@
-#version 140
-
-uniform mat4 view_model_matrix;
-uniform mat4 projection_matrix;
-uniform mat3 view_normal_matrix;
-uniform mat4 volume_world_matrix;
-// The volume's normal matrix in world space, so the fragment shader can tell a wall from a terrace -
-// which is what decides whether layer lines show at all.
-uniform mat3 world_normal_matrix;
-// Clipping plane, x = min z, y = max z (the FFF/SLA preview's top/bottom cut).
-uniform vec2 z_range;
-// Clipping plane, general orientation (the section view).
-uniform vec4 clipping_plane;
-
-// GLModel's P3N3 layout, which is what init_from(indexed_triangle_set) produces - this shader needs
-// nothing per vertex that the mesh does not already carry, because the colour comes from the
-// fragment's own height rather than from anything baked into the vertices.
-in vec3 v_position;
-in vec3 v_normal;
-
-out vec3  clipping_planes_dots;
-out vec3  eye_normal;
-out vec3  eye_position;
-out vec3  world_normal;
-out float world_z;
-
-void main()
-{
-    vec4 model_pos = vec4(v_position, 1.0);
-    vec4 world_pos = volume_world_matrix * model_pos;
-    world_z        = world_pos.z;
-    world_normal   = normalize(world_normal_matrix * v_normal);
-    eye_normal     = normalize(view_normal_matrix * v_normal);
-
-    vec4 eye_pos = view_model_matrix * model_pos;
-    eye_position = eye_pos.xyz;
-    gl_Position  = projection_matrix * eye_pos;
-
-    clipping_planes_dots = vec3(dot(world_pos, clipping_plane), world_pos.z - z_range.x, z_range.y - world_pos.z);
-}
@@ -325,8 +325,6 @@ set(lisbslic3r_sources
    Geometry/VoronoiUtils.cpp
    Geometry/VoronoiUtils.hpp
    Geometry/VoronoiVisualUtils.hpp
-    ChromaStack.cpp
-    ChromaStack.hpp
    IMEXArrange.cpp
    IMEXArrange.hpp
    IMEXHelpers.cpp
@@ -1,394 +0,0 @@
-#include "ChromaStack.hpp"
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <limits>
-#include <cstdlib>
-#include <numeric>
-
-#include <tbb/blocked_range.h>
-#include <tbb/parallel_for.h>
-
-#include <miniz.h>
-
-namespace Slic3r {
-
-// How many e-folding lengths of absorption count as "the colour beneath no longer shows". Three
-// passes 5% of the light, which is about where the eye stops seeing what is under a layer.
-static constexpr float OPAQUE_EFOLDS = 3.f;
-
-// TD is a filament property, so a zero or negative value in a preset is a data error rather than a
-// request for an infinitely opaque filament. Clamp instead: below this the filament is opaque at a
-// single layer anyway.
-static constexpr float TD_MIN_MM = 0.05f;
-static constexpr float TD_MAX_MM = 100.f;
-
-static float srgb_to_linear(float c)
-{
-    return c <= 0.04045f ? c / 12.92f : std::pow((c + 0.055f) / 1.055f, 2.4f);
-}
-
-static float linear_to_srgb(float c)
-{
-    return c <= 0.0031308f ? c * 12.92f : 1.055f * std::pow(c, 1.f / 2.4f) - 0.055f;
-}
-
-// CIELAB under D65, from non-linear sRGB in [0, 1]. Only used for nearest-colour search, so the
-// absolute white point matters far less than both sides using the same one.
-struct Lab
-{
-    float l = 0.f, a = 0.f, b = 0.f;
-};
-
-static Lab srgb_to_lab(float r, float g, float b)
-{
-    const float rl = srgb_to_linear(r), gl = srgb_to_linear(g), bl = srgb_to_linear(b);
-    const float x = (0.4124f * rl + 0.3576f * gl + 0.1805f * bl) / 0.95047f;
-    const float y = (0.2126f * rl + 0.7152f * gl + 0.0722f * bl);
-    const float z = (0.0193f * rl + 0.1192f * gl + 0.9505f * bl) / 1.08883f;
-    auto        f = [](float t) {
-        return t > 0.008856f ? std::cbrt(t) : (7.787f * t + 16.f / 116.f);
-    };
-    const float fx = f(x), fy = f(y), fz = f(z);
-    return Lab{ 116.f * fy - 16.f, 500.f * (fx - fy), 200.f * (fy - fz) };
-}
-
-static float delta_e(const Lab &p, const Lab &q)
-{
-    const float dl = p.l - q.l, da = p.a - q.a, db = p.b - q.b;
-    return std::sqrt(dl * dl + da * da + db * db);
-}
-
-int ChromaStack::relief_layers() const
-{
-    int n = 0;
-    for (const ChromaBand &band : bands)
-        n += std::max(0, band.layers);
-    return n;
-}
-
-int ChromaStack::total_layers() const { return std::max(0, base_layers) + relief_layers(); }
-
-float ChromaStack::depth_mm() const { return float(relief_layers()) * layer_height_mm; }
-
-std::vector<ColorRGB> chroma_palette(const ChromaStack &stack)
-{
-    const int total = stack.total_layers();
-    // No bands means no picture and no filament to print the base in, whatever base_layers says.
-    if (total <= 0 || stack.bands.empty() || stack.layer_height_mm <= 0.f)
-        return {};
-
-    // The filament each printed layer is in, bottom-up: the base first, in the bottom band's filament,
-    // then the bands themselves.
-    std::vector<const ChromaFilament *> per_layer;
-    per_layer.reserve(size_t(total));
-    for (int i = 0; i < std::max(0, stack.base_layers); ++i)
-        per_layer.push_back(&stack.bands.front().filament);
-    for (const ChromaBand &band : stack.bands)
-        for (int i = 0; i < band.layers; ++i)
-            per_layer.push_back(&band.filament);
-
-    std::vector<ColorRGB> palette(size_t(total) + 1);
-
-    // Linear light, walking up from an opaque base: C_0 is the bottom layer's own colour, so a
-    // column one layer tall comes out exactly that colour however translucent the filament is.
-    std::array<float, 3> acc{ srgb_to_linear(per_layer.front()->color.r()), srgb_to_linear(per_layer.front()->color.g()),
-                              srgb_to_linear(per_layer.front()->color.b()) };
-    auto                 store = [&palette](size_t k, const std::array<float, 3> &lin) {
-        palette[k] = ColorRGB(std::clamp(linear_to_srgb(lin[0]), 0.f, 1.f), std::clamp(linear_to_srgb(lin[1]), 0.f, 1.f),
-                              std::clamp(linear_to_srgb(lin[2]), 0.f, 1.f));
-    };
-    store(0, acc);
-
-    for (int k = 1; k <= total; ++k) {
-        const ChromaFilament &f  = *per_layer[size_t(k - 1)];
-        const float             td = std::clamp(f.td_mm, TD_MIN_MM, TD_MAX_MM);
-        // The depth at which this filament hides what is behind it, turned into the e-folding length
-        // of its absorption; see CHROMA_TD_OPAQUE_FRACTION.
-        const float efold = CHROMA_TD_OPAQUE_FRACTION * td / OPAQUE_EFOLDS;
-        const float t     = std::exp(-stack.layer_height_mm / efold);
-        const std::array<float, 3> own{ srgb_to_linear(f.color.r()), srgb_to_linear(f.color.g()),
-                                        srgb_to_linear(f.color.b()) };
-        for (int c = 0; c < 3; ++c)
-            acc[size_t(c)] = (1.f - t) * own[size_t(c)] + t * acc[size_t(c)];
-        store(size_t(k), acc);
-    }
-    return palette;
-}
-
-ChromaSolve chroma_solve(const uint8_t *rgb, int width, int height, const ChromaStack &stack)
-{
-    ChromaSolve solve;
-    const int     total  = stack.total_layers();
-    const int     base   = std::max(0, stack.base_layers);
-    const int     relief = stack.relief_layers();
-    if (rgb == nullptr || width <= 0 || height <= 0 || relief <= 0 || relief > CHROMA_MAX_RELIEF_LAYERS)
-        return solve;
-
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    if (int(palette.size()) != total + 1)
-        return solve;
-
-    // Only the heights the solver may choose: base (nothing of the relief printed) up to total.
-    const int               choices = relief + 1;
-    const size_t                        choice_count = size_t(choices);
-    std::vector<Lab>                    choice_lab(choice_count);
-    std::vector<std::array<uint8_t, 3>> choice_rgb(choice_count);
-    for (int i = 0; i < choices; ++i) {
-        const ColorRGB &c = palette[size_t(base + i)];
-        choice_lab[size_t(i)] = srgb_to_lab(c.r(), c.g(), c.b());
-        choice_rgb[size_t(i)] = { uint8_t(std::lround(c.r() * 255.f)), uint8_t(std::lround(c.g() * 255.f)),
-                                  uint8_t(std::lround(c.b() * 255.f)) };
-    }
-
-    const size_t count = size_t(width) * size_t(height);
-    solve.width        = width;
-    solve.height       = height;
-    solve.levels.resize(count);
-    solve.grey.resize(count);
-    solve.preview.resize(count * 3);
-
-    std::vector<float> errors(count, 0.f);
-
-    auto pick = [&](float r, float g, float b, float &out_error) {
-        const Lab target = srgb_to_lab(std::clamp(r, 0.f, 1.f), std::clamp(g, 0.f, 1.f), std::clamp(b, 0.f, 1.f));
-        int       best   = 0;
-        float     best_d = std::numeric_limits<float>::max();
-        for (int i = 0; i < choices; ++i) {
-            const float d = delta_e(target, choice_lab[size_t(i)]);
-            if (d < best_d) {
-                best_d = d;
-                best   = i;
-            }
-        }
-        out_error = best_d;
-        return best;
-    };
-
-    // The grey level a chosen height is written as. Rounded to the nearest of 256 levels, which for
-    // any practical layer budget (a few dozen) maps every height to its own level exactly - the
-    // relief's steps stay on layer boundaries, which is the whole point of quantizing here.
-    auto grey_of = [relief](int choice) {
-        return uint8_t(std::lround(255.0 * double(choice) / double(relief)));
-    };
-
-    auto write = [&](size_t px, int choice, float err) {
-        solve.levels[px]        = uint16_t(base + choice);
-        solve.grey[px]          = grey_of(choice);
-        solve.preview[px * 3]     = choice_rgb[size_t(choice)][0];
-        solve.preview[px * 3 + 1] = choice_rgb[size_t(choice)][1];
-        solve.preview[px * 3 + 2] = choice_rgb[size_t(choice)][2];
-        errors[px]              = err;
-    };
-
-    if (stack.dither) {
-        // Floyd-Steinberg, serpentine so the error does not drift consistently to one side. The
-        // diffusion buffer holds the two rows the kernel reaches, in sRGB - which is where the
-        // artifact being traded away lives, and what every reference implementation diffuses in.
-        const size_t                      row_len = size_t(width);
-        std::vector<std::array<float, 3>> row(row_len), next(row_len);
-        for (int x = 0; x < width; ++x) {
-            const uint8_t *src = rgb + size_t(x) * 3;
-            row[size_t(x)]     = { src[0] / 255.f, src[1] / 255.f, src[2] / 255.f };
-        }
-        for (int y = 0; y < height; ++y) {
-            if (y + 1 < height)
-                for (int x = 0; x < width; ++x) {
-                    const uint8_t *src = rgb + (size_t(y + 1) * size_t(width) + size_t(x)) * 3;
-                    next[size_t(x)]    = { src[0] / 255.f, src[1] / 255.f, src[2] / 255.f };
-                }
-            const bool ltr = (y % 2) == 0;
-            for (int i = 0; i < width; ++i) {
-                const int    x  = ltr ? i : width - 1 - i;
-                const size_t px = size_t(y) * size_t(width) + size_t(x);
-                float        err = 0.f;
-                const int    choice = pick(row[size_t(x)][0], row[size_t(x)][1], row[size_t(x)][2], err);
-                write(px, choice, err);
-
-                std::array<float, 3> residual{};
-                for (int c = 0; c < 3; ++c)
-                    residual[size_t(c)] = row[size_t(x)][size_t(c)] - choice_rgb[size_t(choice)][size_t(c)] / 255.f;
-
-                const int  ahead = ltr ? x + 1 : x - 1;
-                const int  back  = ltr ? x - 1 : x + 1;
-                auto spread = [&](std::vector<std::array<float, 3>> &dst, int at, float w) {
-                    if (at < 0 || at >= width)
-                        return;
-                    for (int c = 0; c < 3; ++c)
-                        dst[size_t(at)][size_t(c)] += residual[size_t(c)] * w;
-                };
-                spread(row, ahead, 7.f / 16.f);
-                if (y + 1 < height) {
-                    spread(next, back, 3.f / 16.f);
-                    spread(next, x, 5.f / 16.f);
-                    spread(next, ahead, 1.f / 16.f);
-                }
-            }
-            row.swap(next);
-        }
-    } else {
-        tbb::parallel_for(tbb::blocked_range<int>(0, height), [&](const tbb::blocked_range<int> &range) {
-            for (int y = range.begin(); y < range.end(); ++y)
-                for (int x = 0; x < width; ++x) {
-                    const size_t   px  = size_t(y) * size_t(width) + size_t(x);
-                    const uint8_t *src = rgb + px * 3;
-                    float          err = 0.f;
-                    write(px, pick(src[0] / 255.f, src[1] / 255.f, src[2] / 255.f, err), err);
-                }
-        });
-    }
-
-    solve.mean_delta_e = count == 0 ? 0. : std::accumulate(errors.begin(), errors.end(), 0.) / double(count);
-    solve.max_delta_e  = errors.empty() ? 0. : double(*std::max_element(errors.begin(), errors.end()));
-    return solve;
-}
-
-float chroma_layers_to_opaque(float td_mm, float layer_height_mm)
-{
-    if (layer_height_mm <= 0.f)
-        return 0.f;
-    return CHROMA_TD_OPAQUE_FRACTION * std::clamp(td_mm, TD_MIN_MM, TD_MAX_MM) / layer_height_mm;
-}
-
-// Below about one dE two colours are the same colour to the eye. Half of that is the threshold for
-// "this layer changed something", so a step has to be comfortably invisible before a layer is called
-// wasted.
-static constexpr float VISIBLE_DE = 0.5f;
-
-static float step_delta_e(const ColorRGB &a, const ColorRGB &b)
-{
-    return delta_e(srgb_to_lab(a.r(), a.g(), a.b()), srgb_to_lab(b.r(), b.g(), b.b()));
-}
-
-int chroma_distinct_levels(const ChromaStack &stack)
-{
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    const int                   base    = std::max(0, stack.base_layers);
-    if (int(palette.size()) <= base + 1)
-        return 0;
-    int n = 0;
-    for (size_t i = size_t(base) + 1; i < palette.size(); ++i)
-        if (step_delta_e(palette[i - 1], palette[i]) > VISIBLE_DE)
-            ++n;
-    return n;
-}
-
-void chroma_trim_bands(ChromaStack &stack)
-{
-    // Walked over the stack's own palette rather than over the filaments' TD, because how fast a band
-    // runs out of anything to say depends on what is under it as much as on the filament. A light band
-    // over a dark one is finished in four or five layers; a dark one over a light one goes on paying
-    // for many more, long past the depth at which it is nominally opaque, because the last few percent
-    // of light coming through still moves a near-black colour perceptibly.
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    if (palette.empty())
-        return;
-    int layer = std::max(0, stack.base_layers); // palette index of the layer under the band being looked at
-    for (ChromaBand &band : stack.bands) {
-        int keep = 1;
-        for (int i = 1; i <= band.layers; ++i) {
-            const size_t cur = size_t(layer) + size_t(i);
-            if (cur >= palette.size())
-                break;
-            if (step_delta_e(palette[cur - 1], palette[cur]) > VISIBLE_DE)
-                keep = i; // the last layer of this band that still changes the colour
-        }
-        layer += band.layers;
-        band.layers = std::clamp(keep, 1, band.layers);
-    }
-}
-
-int chroma_level_at(const ChromaStack &stack, double z_mm)
-{
-    const int total = stack.total_layers();
-    if (total <= 0 || stack.layer_height_mm <= 0.f)
-        return 0;
-    // Layer k occupies ((k-1)h, k h], so a point inside it rounds up. The epsilon keeps a surface
-    // sitting exactly on a layer boundary in the layer that printed it rather than in the one above,
-    // which is the difference between a terrace showing its own colour and showing the next band's.
-    const int k = int(std::ceil(z_mm / double(stack.layer_height_mm) - 1e-6));
-    return std::clamp(k, 1, total);
-}
-
-std::vector<unsigned char> chroma_encode_height_png(const ChromaSolve &solve)
-{
-    if (solve.empty())
-        return {};
-    size_t      size = 0;
-    void       *png  = tdefl_write_image_to_png_file_in_memory_ex(solve.grey.data(), solve.width, solve.height, 1, &size,
-                                                                  MZ_DEFAULT_LEVEL, MZ_FALSE);
-    if (png == nullptr || size == 0)
-        return {};
-    const unsigned char       *bytes = static_cast<const unsigned char *>(png);
-    std::vector<unsigned char> out(bytes, bytes + size);
-    mz_free(png);
-    return out;
-}
-
-std::vector<ChromaRange> chroma_ranges(const ChromaStack &stack, double z_bottom)
-{
-    std::vector<ChromaRange> out;
-    if (stack.layer_height_mm <= 0.f)
-        return out;
-    // The layer height is stored as a float, like every other dimension of a texture displacement
-    // layer, so multiplying it up leaves noise in the last few digits - 5 layers of 0.1 mm come out as
-    // 0.5000000074. The slicer derives its own layer boundaries from the print config in double
-    // precision and lands on 0.5 exactly, and a boundary that misses it by any amount is a boundary a
-    // layer can fall on the wrong side of. Rounding to the nanometre removes the noise without
-    // disturbing any layer height a profile can express.
-    const auto snap = [](double z) { return std::round(z * 1e6) / 1e6; };
-
-    // The base is printed in the bottom band's filament - it is what is loaded when the print starts -
-    // so it extends that band's range down to the first layer instead of being a swap of its own.
-    int  layer = std::max(0, stack.base_layers);
-    bool first = true;
-    for (const ChromaBand &band : stack.bands) {
-        if (band.layers <= 0)
-            continue;
-        const double z_min = snap(z_bottom + (first ? 0. : double(layer) * double(stack.layer_height_mm)));
-        first = false;
-        layer += band.layers;
-        const double z_max = snap(z_bottom + double(layer) * double(stack.layer_height_mm));
-        if (!out.empty() && out.back().filament == band.filament.filament)
-            out.back().z_max = z_max; // no swap happens here, so it is one range
-        else
-            out.push_back(ChromaRange{ z_min, z_max, band.filament.filament });
-    }
-    return out;
-}
-
-ChromaStack chroma_default_stack(const std::vector<ChromaFilament> &filaments, float layer_height_mm,
-                                     int base_layers, int relief_layers)
-{
-    ChromaStack stack;
-    stack.layer_height_mm = layer_height_mm > 0.f ? layer_height_mm : 0.08f;
-    stack.base_layers     = std::max(0, base_layers);
-    if (filaments.empty() || relief_layers <= 0)
-        return stack;
-
-    std::vector<ChromaFilament> ordered = filaments;
-    std::stable_sort(ordered.begin(), ordered.end(), [](const ChromaFilament &a, const ChromaFilament &b) {
-        // Relative luminance of the linear colour: the perceptual order, so a saturated yellow
-        // counts as light and a saturated blue as dark, which a plain r+g+b sum gets wrong.
-        auto lum = [](const ColorRGB &c) {
-            return 0.2126f * srgb_to_linear(c.r()) + 0.7152f * srgb_to_linear(c.g()) + 0.0722f * srgb_to_linear(c.b());
-        };
-        return lum(a.color) > lum(b.color);
-    });
-
-    const int count = int(ordered.size());
-    int       left  = relief_layers;
-    for (int i = 0; i < count; ++i) {
-        // Spread the remainder over the first bands rather than piling it onto the last one.
-        const int share = left / (count - i) + ((left % (count - i)) > 0 ? 1 : 0);
-        ChromaBand band;
-        band.filament = ordered[size_t(i)];
-        band.layers   = std::max(1, share);
-        left -= share;
-        stack.bands.push_back(band);
-    }
-    return stack;
-}
-
-} // namespace Slic3r
@@ -1,286 +0,0 @@
-#ifndef slic3r_ChromaStack_hpp_
-#define slic3r_ChromaStack_hpp_
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include <cereal/cereal.hpp>
-#include <cereal/types/vector.hpp>
-
-#include "Color.hpp"
-
-namespace Slic3r {
-
-// ChromaStack-style colour printing: a picture is reproduced on a single face by stacking thin layers
-// of a few filaments, swapping filament at fixed layer boundaries, and varying the *height* of each
-// pixel's column. Where the column is low, the layers above it are missing and the filament below
-// shows; where it is high, the topmost filament covers everything beneath it. Because filament is
-// translucent, a column that stops part-way through a run shows a blend of that run's filament and
-// what is under it, which is what gives far more colours than there are filaments loaded.
-//
-// So there are only two things to compute, and they are both here:
-//  - the *palette*: the colour the stack shows at every possible column height (chroma_palette());
-//  - the *height map*: per pixel, the column height whose palette colour is closest to the picture
-//    (chroma_solve()).
-//
-// Everything else is machinery that already exists. The height map is handed to a texture
-// displacement layer as its height texture, so the existing projection/preview/bake pipeline turns
-// it into real geometry (see TextureDisplacement.hpp), and the filament swaps are handed to the
-// object's height ranges (ModelObject::layer_config_ranges), which is the slicer's own way of
-// saying "print this Z band with that filament".
-
-// The depth of filament that blocks essentially all the light behind it, as a fraction of the
-// filament's transmission distance (TD).
-//
-// TD's scale is empirical, not physical: its values run from about 1
-// for an opaque filament to 10 and above for a nearly clear one, and the community's calibration
-// prints (the "seashell" step test) read a TD off the step where the colour beneath stops showing.
-// That step is about a tenth of the TD number, which is the only thing this constant encodes - a
-// filament of TD 2 stops hiding what is under it at roughly 0.2 mm, i.e. after two or three layers,
-// while one of TD 8 needs most of a millimetre. The model below turns that into a per-layer
-// transmittance; see chroma_palette().
-static constexpr float CHROMA_TD_OPAQUE_FRACTION = 0.1f;
-
-// What a fresh stack gets above the base. Twenty-four layers is about two millimetres at a fine layer
-// height: enough steps for a continuous tonal ramp, and still a print that finishes in an evening.
-static constexpr int CHROMA_DEFAULT_RELIEF_LAYERS = 24;
-
-// The most picture layers the solve can express. A column's height above the base is stored as one
-// byte per pixel in the 8-bit grayscale height map the displacement reads, so beyond this two
-// different heights would have to share a grey level and the relief's steps would stop landing on
-// layer boundaries - which is the one thing the quantization exists to guarantee.
-//
-// It bounds the bands, not the stack: the base is whatever the model already is under the painted
-// face, often hundreds of layers on a tall part, and nothing about it is quantized into the height
-// map. As a limit on the picture it is not one in practice - 255 layers is 20 mm of relief at
-// 0.08 mm, far past where a picture gains anything.
-static constexpr int CHROMA_MAX_RELIEF_LAYERS = 255;
-
-// The most filament changes one stack may hold. Every band is a swap the printer has to make, so this is
-// a limit on patience rather than on the model; the palette itself is bounded by the layer count.
-static constexpr size_t CHROMA_MAX_BANDS = 16;
-
-// One filament as the colour model sees it: what colour it is, and how far light gets into it.
-struct ChromaFilament
-{
-    // 0-based index into the project's filaments, which is what a height range's `extruder` option
-    // (1-based) is written from. -1 for a filament that is not loaded, which the GUI refuses to
-    // solve with rather than silently printing in the wrong colour.
-    int      filament = -1;
-    ColorRGB color;
-    // The filament preset's own name, so the panel can say which filament this is. Six similar greys
-    // are six identical swatches and six identical numbers otherwise. Stored rather than looked up on
-    // demand because a stack outlives the project's filament list - a preset can be swapped out from
-    // under a saved stack, and then the name is the only record of what it was solved against.
-    std::string name;
-    // Transmission distance, mm, as the filament preset reports it
-    // (`filament_transmission_distance`). Clamped to a sane range when the palette is built: zero
-    // would make a layer infinitely opaque and a negative value is meaningless.
-    float    td_mm = 4.f;
-
-    template<class Archive> void serialize(Archive &ar)
-    {
-        float r = color.r(), g = color.g(), b = color.b();
-        ar(filament, r, g, b, td_mm, name);
-        color = ColorRGB(r, g, b);
-    }
-};
-
-// A run of consecutive layers printed in one filament. The stack is a list of these, bottom-up, so
-// a band boundary is exactly where the print pauses and the filament is changed.
-struct ChromaBand
-{
-    ChromaFilament filament;
-    int              layers = 1;
-
-    template<class Archive> void serialize(Archive &ar) { ar(filament, layers); }
-};
-
-// The whole recipe: which filaments, in which order, how thick a layer is, and how much of the
-// bottom is solid backing rather than picture.
-struct ChromaStack
-{
-    std::vector<ChromaBand> bands; // bottom-up; bands.front() is the one the base is printed in
-
-    // The print's layer height, mm. Taken from the print profile rather than chosen here - a stack
-    // solved against 0.08 mm layers prints as the wrong picture at 0.2 mm, so the GUI re-solves when
-    // the profile's layer height changes.
-    float layer_height_mm = 0.08f;
-
-    // Layers of solid backing under the picture: everything the model already is below the painted
-    // face. Not part of any band - the bands are the picture - but printed in the bottom band's
-    // filament, since that is what is loaded when the print starts.
-    //
-    // Keeping it out of the bands is what lets it be what it really is: a measurement of the model,
-    // often a hundred layers or more, while a band is a handful. Folding the two together put a
-    // three-digit number on a slider meant for single digits and made "how thick is the backing" and
-    // "how many layers does the first filament get" the same control, which they are not.
-    //
-    // The colour model treats the base as opaque. That is what makes a column's colour depend only on
-    // the layers above it, and why the panel warns about a base thin enough to let the plate show
-    // through.
-    int  base_layers = 4;
-
-    // Whether `base_layers` follows the model or was typed in. It follows by default, and it should:
-    // the painted face is wherever the geometry puts it, and a base that disagrees with it shifts
-    // every colour in the picture - the stack ends up anchored at the bottom of the part instead of
-    // under the face, so the picture's whole range is squeezed into the first few millimetres and
-    // everything above it clamps to the top band.
-    //
-    // It cannot be measured once and left: a layer is created, and its picture chosen, before there
-    // is any paint to measure, and the face moves again whenever the part is scaled or the layer
-    // height changes. So the panel re-measures it every frame while this is set.
-    bool base_auto = true;
-
-    // Spread the quantization error into neighbouring pixels (Floyd-Steinberg, serpentine) instead
-    // of rounding each pixel to its nearest palette colour on its own. A palette of twenty or thirty
-    // colours has to cover a photograph's whole range, so plain rounding leaves visible bands across
-    // a sky or a cheek; diffusing the error trades them for fine stipple, which at a tenth of a
-    // millimetre per pixel reads as the intermediate colour. Off for flat-coloured artwork, where
-    // stipple is the artifact rather than the cure.
-    bool dither = false;
-
-    // Total printed layers, base included: what the tallest column is.
-    int  total_layers() const;
-    // Layers the picture is built from, i.e. the bands' own total above the base.
-    int  relief_layers() const;
-    // The relief's height in mm, which is the `depth_mm` of the texture displacement layer the
-    // height map is handed to.
-    float depth_mm() const;
-    bool  empty() const { return bands.empty(); }
-
-    template<class Archive> void serialize(Archive &ar) { ar(bands, layer_height_mm, base_layers, dither, base_auto); }
-};
-
-// The colour the stack shows at every column height: entry k is a column of exactly k printed
-// layers, so the vector has total_layers() + 1 entries.
-//
-// The model is Beer-Lambert absorption, layer by layer. A layer of thickness h in a filament of
-// transmission distance TD passes
-//
-//     T = exp(-h / (CHROMA_TD_OPAQUE_FRACTION * TD / 3))
-//
-// of the light coming from under it and shows its own colour with the rest, so
-//
-//     C_k = (1 - T_k) * c_k + T_k * C_(k-1)
-//
-// walking up from an opaque base, C_0 = c_1. The divisor is what makes "opaque at
-// CHROMA_TD_OPAQUE_FRACTION * TD" true: three e-folding lengths pass 5% of the light, which is
-// where the colour beneath stops being visible to the eye.
-//
-// Beer-Lambert is not just the physically honest choice here, it is the only one that stays
-// consistent when applied per layer: transmittance multiplies, so a run of n layers of one filament
-// passes exp(-n h / d) whether it is composited in one step or n, and the palette does not depend on
-// how the stack happens to be cut into bands.
-//
-// Compositing is done on linear light and the entries are converted back to sRGB, because the
-// quantity being attenuated is light, not an sRGB code.
-std::vector<ColorRGB> chroma_palette(const ChromaStack &stack);
-
-// What chroma_solve() produced.
-struct ChromaSolve
-{
-    int width  = 0;
-    int height = 0;
-
-    // Per pixel, row-major and top-to-bottom like DecodedHeightTexture: the column's printed layer
-    // count, between base_layers and total_layers(). Sixteen bits because it counts from the build
-    // plate, and the base alone can be several hundred layers on a tall part.
-    std::vector<uint16_t> levels;
-    // The same thing as the 8-bit grayscale height map the displacement samples: 0 at base_layers,
-    // 255 at total_layers(). This is what gets encoded as a PNG into the layer's `image_data`, which
-    // is why the solve has to be the thing that owns the quantization - the relief's steps have to
-    // land on layer boundaries, and a grey level is the only channel the displacement reads.
-    std::vector<uint8_t> grey;
-    // Per pixel RGB: the palette colour the solve chose, i.e. what the print is predicted to look
-    // like. Shown in the panel next to the source picture, since the 3D view can only show the
-    // relief - the colours do not exist until the print swaps filament.
-    std::vector<uint8_t> preview;
-
-    // How far the prediction landed from the picture, as a mean and worst-case CIE76 dE over all
-    // pixels. The panel reports it because it is the only honest answer to "will this stack
-    // reproduce my image": under about 5 is a good match, over about 15 means the filaments cannot
-    // reach the picture's colours and no amount of layers will fix it.
-    double mean_delta_e = 0.;
-    double max_delta_e  = 0.;
-
-    bool empty() const { return width <= 0 || height <= 0 || levels.empty(); }
-};
-
-// Solves `rgb` (width * height * 3 bytes, row-major, top-to-bottom) against the stack's palette.
-// An empty stack, a zero-sized image or a stack with no relief layers gives an empty result.
-ChromaSolve chroma_solve(const uint8_t *rgb, int width, int height, const ChromaStack &stack);
-
-// How many layers of this filament it takes to hide what is under it, at this layer height. The
-// single most useful number about a stack and the one nothing else makes visible: it is what decides
-// whether a band is a gradient or a step.
-//
-// A filament hides what is behind it at about CHROMA_TD_OPAQUE_FRACTION of its TD (see
-// chroma_palette()), so this is that depth in layers. Below two the band has no intermediate colours
-// at all - the picture can only use the filament or not use it - which is what a coarse layer height
-// does to an otherwise good stack: TD 4 at 0.2 mm covers in two layers, the same filament at 0.08 mm
-// in five.
-float chroma_layers_to_opaque(float td_mm, float layer_height_mm);
-
-// How many of the picture's layers actually change the colour.
-//
-// A band eventually stops saying anything: once it hides what is under it, another layer of it shows
-// the colour the one below already showed. Those layers still cost print time and still take up
-// relief height, and nothing about the stack makes them visible - the band looks like ten layers of
-// gradient and is, say, five of gradient and five of flat.
-//
-// Measured against the palette rather than against TD, because how long a band keeps paying depends
-// on what is under it as much as on the filament: a light band over a dark one is finished in four or
-// five layers, while a dark one over a light one goes on moving the colour perceptibly well past the
-// depth at which it is nominally opaque.
-int chroma_distinct_levels(const ChromaStack &stack);
-
-// Shortens every band to its last layer that still changes the colour. Bands already shorter than
-// that are left alone: they are still inside their fade, where every layer counts.
-void chroma_trim_bands(ChromaStack &stack);
-
-// The printed layer a point `z_mm` above the bottom of the object falls in: 1-based, clamped to the
-// stack, 0 for a stack that prints nothing. Pair it with chroma_palette() to get the colour shown
-// there.
-//
-// This, rather than the height map, is what decides the colour a surface shows. A filament swap
-// happens at one print Z across the whole plate, so every surface crossing that height changes colour
-// whatever the picture says - the terraces of the relief, the walls between them, and the sides of the
-// model alike. Colouring a preview this way is therefore not an approximation of the print; it is what
-// the print does, and it keeps working after the relief has been baked into the mesh and the height
-// map is no longer attached to anything on screen.
-int chroma_level_at(const ChromaStack &stack, double z_mm);
-
-// The solve's height map as an 8-bit grayscale PNG, ready to be stored in a
-// TextureDisplacementLayer's `image_data`.
-std::vector<unsigned char> chroma_encode_height_png(const ChromaSolve &solve);
-
-// One filament swap as an object height range: the Z band, in the object's own coordinates (0 at its
-// bottom), that prints in `filament` (0-based).
-struct ChromaRange
-{
-    double z_min = 0.;
-    double z_max = 0.;
-    int    filament = -1;
-};
-
-// The stack's bands as height ranges, in object coordinates, starting at `z_bottom` (which is 0 for
-// a stack whose base starts at the object's first layer). Bands printed in the same filament as the
-// band below are merged, so a stack that repeats a filament does not produce a pointless swap.
-std::vector<ChromaRange> chroma_ranges(const ChromaStack &stack, double z_bottom = 0.);
-
-// A starting point for a stack: the given filaments, lightest at the bottom, each with an equal
-// share of `relief_layers` on top of `base_layers`.
-//
-// Light-to-dark is the convention filament-painting guides teach, and it is not arbitrary: a dark
-// filament over a light one reads as a midtone at one or two layers and as the dark colour at four,
-// so putting the dark filaments last is what buys the long tonal ramp. The reverse order gives a few
-// washed-out steps and then nothing.
-ChromaStack chroma_default_stack(const std::vector<ChromaFilament> &filaments, float layer_height_mm,
-                                     int base_layers, int relief_layers);
-
-} // namespace Slic3r
-
-#endif // slic3r_ChromaStack_hpp_
@@ -22,6 +22,7 @@
 #include "libslic3r/BrimEarsPoint.hpp"
 #include "libslic3r/Config.hpp"
 #include "libslic3r/CustomGCode.hpp"
+#include "libslic3r/TextureDisplacement.hpp"
 #include "libslic3r_version.h"

 #include "bbs_3mf.hpp"
@@ -63,6 +64,7 @@
 #include <ostream>
 #include <sstream>
 #include <set>
+#include <iterator>
 #include <memory>
 #include <optional>
 #include <map>
@@ -354,6 +356,13 @@ static constexpr const char* CUSTOM_SUPPORTS_ATTR = "paint_supports";
 static constexpr const char* CUSTOM_FUZZY_SKIN_ATTR  = "paint_fuzzy_skin";
 static constexpr const char* CUSTOM_SEAM_ATTR = "paint_seam";
 static constexpr const char* MMU_SEGMENTATION_ATTR = "paint_color";
+// Texture displacement. One paint mask per layer slot, mirroring paint_color; the layer stack itself is
+// a JSON file in the archive, named by the volume metadata key below (see add_texture_displacement()).
+static constexpr const char* TEXTURE_DISPLACEMENT_ATTRS[Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS] = {
+    "paint_texture_0", "paint_texture_1", "paint_texture_2", "paint_texture_3",
+    "paint_texture_4", "paint_texture_5", "paint_texture_6", "paint_texture_7" };
+static constexpr const char* TEXTURE_DISPLACEMENT_KEY = "texture_displacement";
+static constexpr const char* TEXTURE_DISPLACEMENT_DIR = "Metadata/texture_displacement/";
 // BBS
 static constexpr const char* FACE_PROPERTY_ATTR = "face_property";

@@ -847,11 +856,30 @@ 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 by triangle like the masks above, but
+            // empty for a slot nothing paints and no longer than its last painted triangle.
+            // See push_texture_displacement().
+            std::vector<std::string> texture_displacement[TEXTURE_DISPLACEMENT_MAX_LAYERS];
            // BBS
            std::vector<std::string> face_properties;

            bool empty() { return vertices.empty() || triangles.empty(); }

+            // Records the paint mask of the triangle just appended, for one layer slot. A slot no
+            // triangle names keeps its vector empty instead of holding one empty string per triangle:
+            // eight slots over a million triangles would otherwise cost hundreds of megabytes, for
+            // every project, whether or not it uses the feature. The vector is padded up to the
+            // triangles seen so far the first time a value turns up, so it stays indexed by triangle,
+            // and both readers stop at its size, so trailing triangles without a value need nothing.
+            void push_texture_displacement(int slot, std::string &&mask_string) {
+                std::vector<std::string> &mask = texture_displacement[slot];
+                if (mask_string.empty() && mask.empty())
+                    return;
+                assert(!triangles.empty());
+                mask.resize(triangles.size() - 1);
+                mask.push_back(std::move(mask_string));
+            }
+
            // backup & restore
            void swap(Geometry& o) {
                std::swap(vertices, o.vertices);
@@ -867,6 +895,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                custom_seam.clear();
                mmu_segmentation.clear();
                fuzzy_skin.clear();
+                for (std::vector<std::string> &slot : texture_displacement)
+                    slot.clear();
            }
        };

@@ -1200,6 +1230,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
        /*IdToSlaSupportPointsMap m_sla_support_points;
        IdToSlaDrainHolesMap    m_sla_drain_holes;*/
        PathToEmbossShapeFileMap m_path_to_emboss_shape_files;
+        // Texture displacement: every file under Metadata/texture_displacement/, by archive path. Volumes
+        // are built only after the whole archive has been walked, so by the time a volume names its JSON
+        // every file it could refer to is already in here, whatever order the archive happened to be in.
+        std::map<std::string, std::string> m_texture_displacement_files;
+        void _apply_texture_displacement(ModelVolume &volume, const std::string &json_path);
        std::string m_curr_metadata_name;
        std::string m_curr_characters;
        std::string m_name;
@@ -2073,6 +2108,13 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                else if (_is_svg_shape_file(name)) {
                    _extract_embossed_svg_shape_file(name, archive, stat);
                }
+                else if (boost::algorithm::istarts_with(name, TEXTURE_DISPLACEMENT_DIR)) {
+                    std::string contents(stat.m_uncomp_size, '\0');
+                    if (mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, contents.data(), stat.m_uncomp_size, 0))
+                        m_texture_displacement_files.emplace(name, std::move(contents));
+                    else
+                        add_error("Error while reading texture displacement data");
+                }
                else if (!dont_load_config && boost::algorithm::iequals(name, SLICE_INFO_CONFIG_FILE)) {
                    m_parsing_slice_info = true;
                    //extract slice info from archive
@@ -3310,6 +3352,48 @@ 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 pixels come from the archive and nowhere else. A layer the archive carries no image for -
+        // saved while its texture had not been loaded, or written by a build that stored only the path -
+        // keeps its settings without an image, which the user recovers by picking the texture again.
+        // `layer.path` is left alone on purpose: it names a file on the machine the project was made on,
+        // so reading it here would let any project choose a local file to open - a UNC path among them -
+        // and have the next save copy it into the archive. The EmbossShape SVGs are read from the archive
+        // only, for the same reason.
+        for (TextureDisplacementLayer &layer : layers) {
+            if (layer.path_in_3mf.empty())
+                continue;
+            const auto image = m_texture_displacement_files.find(layer.path_in_3mf);
+            if (image == m_texture_displacement_files.end()) {
+                add_error("Missing texture displacement image: " + layer.path_in_3mf);
+                continue;
+            }
+            layer.image_data = std::make_shared<std::vector<unsigned char>>(image->second.begin(),
+                                                                            image->second.end());
+        }
+        volume.texture_displacement_layers  = std::move(layers);
+        volume.texture_displacement_options = options;
+    }
+
    void _BBS_3MF_Importer::_extract_embossed_svg_shape_file(const std::string &filename, mz_zip_archive &archive, const mz_zip_archive_file_stat &stat){
        assert(m_path_to_emboss_shape_files.find(filename) == m_path_to_emboss_shape_files.end());
        auto file = std::make_unique<std::string>(stat.m_uncomp_size, '\0');
@@ -3966,6 +4050,9 @@ 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)
+                m_curr_object->geometry.push_texture_displacement(
+                    slot, bbs_get_attribute_value_string(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot]));
            // BBS
            m_curr_object->geometry.face_properties.push_back(bbs_get_attribute_value_string(attributes, num_attributes, FACE_PROPERTY_ATTR));
        }
@@ -5317,6 +5404,18 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                volume->mmu_segmentation_facets.touch();
                volume->fuzzy_skin_facets.shrink_to_fit();
                volume->fuzzy_skin_facets.touch();
+                for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
+                    const std::vector<std::string> &mask = sub_object->geometry.texture_displacement[slot];
+                    if (mask.empty())
+                        continue; // 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 < mask.size(); ++i)
+                        if (!mask[i].empty())
+                            facets.set_triangle_from_string(i, mask[i]);
+                    facets.shrink_to_fit();
+                    facets.touch();
+                }
            }

            volume->set_type(volume_data->part_type);
@@ -5332,6 +5431,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
            for (const Metadata& metadata : volume_data->metadata) {
                if (metadata.key == NAME_KEY)
                    volume->name = metadata.value;
+                else if (metadata.key == TEXTURE_DISPLACEMENT_KEY)
+                    _apply_texture_displacement(*volume, metadata.value);
                //else if ((metadata.key == MODIFIER_KEY) && (metadata.value == "1"))
 				//	volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
 				//for old format
@@ -5496,12 +5597,28 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
            volume->seam_facets.shrink_to_fit();
            volume->mmu_segmentation_facets.shrink_to_fit();

+            for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
+                const std::vector<std::string> &mask = geometry.texture_displacement[slot];
+                if (mask.empty())
+                    continue; // written by a build without the feature
+                FacetsAnnotation &facets = volume->texture_displacement_facet(slot);
+                facets.reserve(triangles_count);
+                for (size_t i = 0; i < triangles_count; ++i) {
+                    const size_t index = volume_data.first_triangle_id + i;
+                    if (index < mask.size() && !mask[index].empty())
+                        facets.set_triangle_from_string(i, mask[index]);
+                }
+                facets.shrink_to_fit();
+                facets.touch();
+            }
            volume->set_type(volume_data.part_type);

            // apply the remaining volume's metadata
            for (const Metadata& metadata : volume_data.metadata) {
                if (metadata.key == NAME_KEY)
                    volume->name = metadata.value;
+                else if (metadata.key == TEXTURE_DISPLACEMENT_KEY)
+                    _apply_texture_displacement(*volume, metadata.value);
                //else if ((metadata.key == MODIFIER_KEY) && (metadata.value == "1"))
 				//	volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
 				//for old format
@@ -5805,6 +5922,9 @@ 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)
+                current_object->geometry.push_texture_displacement(
+                    slot, bbs_get_attribute_value_string(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot]));
            // BBS
            current_object->geometry.face_properties.push_back(bbs_get_attribute_value_string(attributes, num_attributes, FACE_PROPERTY_ATTR));
        }
@@ -6808,6 +6928,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
        stream << " <Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>\n";
        stream << " <Default Extension=\"model\" ContentType=\"application/vnd.ms-package.3dmanufacturing-3dmodel+xml\"/>\n";
        stream << " <Default Extension=\"png\" ContentType=\"image/png\"/>\n";
+        stream << " <Default Extension=\"jpg\" ContentType=\"image/jpeg\"/>\n";
+        stream << " <Default Extension=\"jpeg\" ContentType=\"image/jpeg\"/>\n";
+        stream << " <Default Extension=\"json\" ContentType=\"application/json\"/>\n";
        stream << " <Default Extension=\"gcode\" ContentType=\"text/x.gcode\"/>\n";
        stream << "</Types>";

@@ -7651,6 +7774,20 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                    output_buffer += "\"";
                }

+                // One attribute per texture displacement layer slot. Older readers ignore attributes they do
+                // not know, so a project written here still opens in a build without the feature - it just
+                // loses the paint, which is also all it could have done with it.
+                for (int slot = 0; slot < TEXTURE_DISPLACEMENT_MAX_LAYERS; ++slot) {
+                    const std::string texture_paint = volume->texture_displacement_facet(slot).get_triangle_as_string(i);
+                    if (texture_paint.empty())
+                        continue;
+                    output_buffer += " ";
+                    output_buffer += TEXTURE_DISPLACEMENT_ATTRS[slot];
+                    output_buffer += "=\"";
+                    output_buffer += texture_paint;
+                    output_buffer += "\"";
+                }
+
                // BBS
                if (i < its.properties.size()) {
                    std::string prop_str = its.properties[i].to_string();
@@ -8100,7 +8237,42 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
        return file_path;
    }

-    bool _BBS_3MF_Exporter::_add_model_config_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig& config, int export_plate_idx, bool save_gcode, bool use_loaded_id)
+    // Writes a volume's texture displacement stack into the archive and points the volume's metadata at it.
+// The layer settings go in as JSON and each layer's texture as the image file it was loaded from, both
+// referenced by path - the same split EmbossShape makes for its SVG. The image deliberately stays out of
+// the XML: it is binary and routinely megabytes, and base64 in an attribute would bloat the one file
+// every reader has to parse just to list the objects.
+static void add_texture_displacement(std::stringstream &stream, const ModelVolume &volume, mz_zip_archive &archive,
+                                     const std::string &id)
+{
+    if (volume.texture_displacement_layers.empty())
+        return;
+
+    // A copy, because path_in_3mf is only meaningful inside the archive being written and the volume
+    // being exported is const (and may be saved again, elsewhere, with different paths).
+    std::vector<TextureDisplacementLayer> layers = volume.texture_displacement_layers;
+    for (TextureDisplacementLayer &layer : layers) {
+        layer.path_in_3mf.clear();
+        if (!layer.image_data || layer.image_data->empty())
+            continue;
+        // Always .png: the importer converts whatever the user picked (jpg, bmp, ...) to an 8-bit
+        // greyscale PNG, so image_data is PNG whatever layer.path happens to be named.
+        const std::string path = std::string(TEXTURE_DISPLACEMENT_DIR) + id + "_" + std::to_string(layer.slot) + ".png";
+        // No deflate: a PNG is already compressed, so a second pass only costs time.
+        if (mz_zip_writer_add_mem(&archive, path.c_str(), layer.image_data->data(), layer.image_data->size(),
+                                  MZ_NO_COMPRESSION))
+            layer.path_in_3mf = path;
+    }
+
+    const std::string json      = texture_displacement_layers_to_json(layers, volume.texture_displacement_options);
+    const std::string json_path = std::string(TEXTURE_DISPLACEMENT_DIR) + id + ".json";
+    if (!mz_zip_writer_add_mem(&archive, json_path.c_str(), json.data(), json.size(), MZ_DEFAULT_COMPRESSION))
+        return;
+    stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << TEXTURE_DISPLACEMENT_KEY << "\" "
+           << VALUE_ATTR << "=\"" << xml_escape(json_path) << "\"/>\n";
+}
+
+bool _BBS_3MF_Exporter::_add_model_config_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig& config, int export_plate_idx, bool save_gcode, bool use_loaded_id)
    {
        std::stringstream stream;
        // Store mesh transformation in full precision, as the volumes are stored transformed and they need to be transformed back
@@ -8211,6 +8383,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                            if (const std::optional<EmbossShape> &es = volume->emboss_shape; es.has_value()) {
                                to_xml(stream, *es, *volume, archive, m_fullpath_sources);
                            }
+
+                            add_texture_displacement(stream, *volume, archive, std::to_string(volume->id().id));
                    
                            if (const std::optional<TextConfiguration> &tc = volume->text_configuration;
                                tc.has_value())
@@ -1487,7 +1487,7 @@ static std::vector<std::string> s_Preset_print_options{
 static std::vector<std::string> s_Preset_filament_options {/*"filament_colour", */ "default_filament_colour", "required_nozzle_HRC", "filament_diameter", "pellet_flow_coefficient", "volumetric_speed_coefficients", "filament_type",
                                                          "filament_soluble", "filament_is_support", "filament_printable", "filament_extruder_compatibility",
    "filament_max_volumetric_speed", "filament_adaptive_volumetric_speed",
-    "filament_flow_ratio", "filament_density", "filament_transmission_distance", "filament_adhesiveness_category", "filament_cost", "filament_minimal_purge_on_wipe_tower",
+    "filament_flow_ratio", "filament_density", "filament_adhesiveness_category", "filament_cost", "filament_minimal_purge_on_wipe_tower",
    "filament_tower_interface_pre_extrusion_dist", "filament_tower_interface_pre_extrusion_length", "filament_tower_ironing_area", "filament_tower_interface_purge_volume",
    "filament_tower_interface_print_temp",
    "nozzle_temperature", "nozzle_temperature_initial_layer",
@@ -226,7 +226,6 @@ bool Print::invalidate_state_by_config_options(const ConfigOptionResolver & /* n
        "filament_diameter",
         "volumetric_speed_coefficients",
        "filament_density",
-        "filament_transmission_distance",
        "filament_cost",
        "filament_notes",
        "outer_wall_acceleration",
@@ -3441,20 +3441,6 @@ void PrintConfigDef::init_fff_params()
    def->mode = comAdvanced;
    def->set_default_value(new ConfigOptionFloats { 0. });

-    def = this->add("filament_transmission_distance", coFloats);
-    def->label = L("Transmission distance");
-    def->tooltip = L("How deep light gets into this filament, in millimetres, also called its "
-                     "transmission distance or TD. About 1 for an opaque filament, 4 to 7 for a usefully "
-                     "translucent one, 8 and above for a nearly clear one. Used only to predict the "
-                     "colours of a ChromaStack in the texture displacement tool; it has no effect on "
-                     "slicing. Measure it with a step test print, or take a published value for the "
-                     "filament.");
-    def->sidetext = L("mm");
-    def->min = 0;
-    def->max = 100;
-    def->mode = comAdvanced;
-    def->set_default_value(new ConfigOptionFloats { 4. });
-
    def = this->add("filament_type", coStrings);
    def->label = L("Type");
    def->tooltip = L("Filament material type");
@@ -1709,9 +1709,6 @@ PRINT_CONFIG_CLASS_DEFINE(
    ((ConfigOptionStrings,             volumetric_speed_coefficients))
    ((ConfigOptionInts,              filament_adhesiveness_category))
    ((ConfigOptionFloats,              filament_density))
-    // Transmission distance: how deep light gets into this filament. Not used by
-    // slicing - it is the colour model of a ChromaStack stack (see ChromaStack.hpp).
-    ((ConfigOptionFloats,              filament_transmission_distance))
    ((ConfigOptionStrings,             filament_type))
    ((ConfigOptionBools,               filament_soluble))
    ((ConfigOptionStrings,             filament_ids))
@@ -19,6 +19,7 @@
 #include <mutex>
 #include <numeric>
 #include <optional>
+#include "nlohmann/json.hpp"
 #include <queue>
 #include <ratio>
 #include <string>
@@ -5166,5 +5167,256 @@ 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;
+    std::vector<TextureDisplacementLayer> out_layers;
+    // Past the parse, a value of the wrong type still throws: get<int>() on a string, get<float>() on
+    // null. Nothing between here and the project load catches that, so one bad number would fail the
+    // whole file instead of this one block. Report it malformed and let the volume load without it.
+    try {
+        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);
+        }
+
+        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);
+                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 (...) {
+        return false;
+    }
+
+    layers  = std::move(out_layers);
+    options = out_options;
+    return true;
+}

 } // namespace Slic3r
@@ -18,7 +18,6 @@

 #include <array>

-#include "ChromaStack.hpp"
 #include "Point.hpp"
 #include "TriangleSelector.hpp"

@@ -294,33 +293,16 @@ struct TextureDisplacementLayer
    // for the boundary to be drawn on.
    bool color_enabled = false;

-    // ChromaStack (see ChromaStack.hpp): when set, `image_data` is not a texture the user picked but the
-    // height map chroma_solve() computed, so that the whole displacement pipeline - preview, UV
-    // editor, bake - goes on reading one grayscale height map and needs to know nothing about colour
-    // stacks. The picture it was solved from is kept here instead, because the solve has to be redone
-    // whenever the stack, the print's layer height or the picture itself changes.
-    //
-    // A ChromaStack layer gets its colour from filament swaps at fixed Z, which is what `chroma`
-    // records and what the object's height ranges carry out. That is a different mechanism from
-    // `color_enabled` (per-triangle filament assignment), and the two are mutually exclusive: the
-    // panel turns colour off on a ChromaStack layer, since painting the relief in one filament per
-    // triangle would hide the very stack the heights were solved against.
-    bool                                        chroma_enabled = false;
-    ChromaStack                               chroma;
-    std::shared_ptr<std::vector<unsigned char>> chroma_source;
-
    bool empty() const { return !image_data || image_data->empty(); }

    template<class Archive> void save(Archive &ar) const
    {
        std::string blob = image_data ? std::string(image_data->begin(), image_data->end()) : std::string();
-        std::string source = chroma_source ? std::string(chroma_source->begin(), chroma_source->end()) : std::string();
        ar(slot, name, path, path_in_3mf, blob, depth_mm, tiling_scale, rotation_deg, offset, invert, tile_enabled,
           static_cast<int>(tile_method), static_cast<int>(projection_method), lscm_seam_angle_deg, islands,
           static_cast<int>(blend_mode), midlevel, island_padding_mm, lscm_seam_edges, view_project_right,
           view_project_up, smoothing, edge_smoothing, edge_smoothing_amount, auto_connect_islands, island_groups,
-           lscm_uv_overrides, view_project_projective, view_project_matrix, color_enabled, chroma_enabled, chroma,
-           source);
+           lscm_uv_overrides, view_project_projective, view_project_matrix, color_enabled);
    }
    template<class Archive> void load(Archive &ar)
    {
@@ -328,14 +310,12 @@ struct TextureDisplacementLayer
        int         tile_method_int       = 0;
        int         projection_method_int = 0;
        int         blend_mode_int        = 0;
-        std::string source;
        ar(slot, name, path, path_in_3mf, blob, depth_mm, tiling_scale, rotation_deg, offset, invert, tile_enabled,
           tile_method_int, projection_method_int, lscm_seam_angle_deg, islands, blend_mode_int, midlevel,
           island_padding_mm, lscm_seam_edges, view_project_right, view_project_up, smoothing, edge_smoothing,
           edge_smoothing_amount, auto_connect_islands, island_groups, lscm_uv_overrides, view_project_projective,
-           view_project_matrix, color_enabled, chroma_enabled, chroma, source);
+           view_project_matrix, color_enabled);
        image_data        = blob.empty() ? nullptr : std::make_shared<std::vector<unsigned char>>(blob.begin(), blob.end());
-        chroma_source   = source.empty() ? nullptr : std::make_shared<std::vector<unsigned char>>(source.begin(), source.end());
        tile_method       = static_cast<TextureTileMethod>(tile_method_int);
        projection_method = static_cast<TextureProjectionMethod>(projection_method_int);
        blend_mode        = static_cast<TextureBlendMode>(blend_mode_int);
@@ -417,14 +397,38 @@ struct TextureDisplacementOptions
    // finer than the mesh leaves behind, without eating features that are genuinely a facet wide.
    int          color_despeckle   = 2;

+    // Where the panel was left, rather than anything the bake reads. It lives with the volume because
+    // that is what it describes: reopening a project should put the user back on the layer they were
+    // editing, in the mode they were editing it in, not on slot 0 in Standard.
+    int active_slot = 0;
+    int panel_mode  = 0; // 0 Standard, 1 Pro
+
    template<class Archive> void serialize(Archive &ar)
    {
        ar(displace_border, smooth_enabled, smooth_strength, smooth_iterations, smooth_skip_border,
           pipeline_v2, v2_refine_mm, v2_regularize, v2_max_triangles_k,
-           v2_relocate, color_mix_enabled, color_despeckle, color_mix_count);
+           v2_relocate, v2_flip_edges, color_mix_enabled, color_despeckle, color_mix_count,
+           active_slot, panel_mode);
    }
 };

+// Project persistence (see bbs_3mf.cpp). The layer stack and the per-volume options are written to the
+// .3mf as JSON rather than through the cereal save()/load() above: those two are positional and
+// unversioned, which is right for the undo/redo stack they serve (one session, one binary) but would
+// make every future field a project-breaking change. A JSON object tolerates both directions - an
+// unknown key is ignored, a missing one keeps the member's default - so old projects keep loading and
+// new ones degrade gracefully in older builds.
+//
+// The texture image itself is *not* in here. It is a binary blob that belongs in the archive as a file
+// of its own, exactly as EmbossShape stores its SVG; `path_in_3mf` names that file, and the caller is
+// responsible for writing it and for filling `image_data` back in on load.
+std::string texture_displacement_layers_to_json(const std::vector<TextureDisplacementLayer> &layers,
+                                                const TextureDisplacementOptions            &options);
+// Returns false and leaves both outputs untouched when the text is not valid JSON.
+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.
@@ -114,8 +114,6 @@ std::pair<bool, std::string> GLShadersManager::init()
        valid &= append_shader("mm_gouraud", { prefix + "mm_gouraud.vs", prefix + "mm_gouraud.fs" });
    // Fast shaded preview for the texture displacement gizmo (see libslic3r/TextureDisplacement.hpp).
    valid &= append_shader("texture_displacement_shaded", { prefix + "texture_displacement_shaded.vs", prefix + "texture_displacement_shaded.fs" });
-    // ChromaStack: the printed colours on the model, read per fragment from its own height.
-    valid &= append_shader("chromastack", { prefix + "chromastack.vs", prefix + "chromastack.fs" });
    // UV-check overlay for the same gizmo: a procedural checker or a distortion heatmap over the
    // painted patch, to sanity-check the unwrap.
    valid &= append_shader("texture_displacement_uvcheck", { prefix + "texture_displacement_uvcheck.vs", prefix + "texture_displacement_uvcheck.fs" });
@@ -3232,16 +3232,9 @@ bool GUI_App::on_init_inner()
 #ifdef _MSW_DARK_MODE

 #ifndef __WINDOWS__
-    // The label colours and the dark mode flag were set above from the saved mode. When the system theme
-    // differs from it, refresh them, or dialogs that map their colours stay in the old mode for this session.
-    const bool saved_dark_mode = dark_mode();
    wxSystemAppearance app = wxSystemSettings::GetAppearance();
    GUI::wxGetApp().app_config->set("dark_color_mode", app.IsDark() ? "1" : "0");
    GUI::wxGetApp().app_config->save();
-    if (dark_mode() != saved_dark_mode) {
-        init_label_colours();
-        Update_dark_mode_flag();
-    }
 #endif // __APPLE__


@@ -2875,37 +2875,6 @@ void ObjectList::del_layer_from_object(const int obj_idx, const t_layer_height_r
    changed_object(obj_idx);
 }

-void ObjectList::rebuild_layer_ranges(const int obj_idx)
-{
-    if (obj_idx < 0 || obj_idx >= int(m_objects->size()))
-        return;
-    const wxDataViewItem obj_item = m_objects_model->GetItemById(obj_idx);
-    if (!obj_item.IsOk())
-        return;
-
-    const t_layer_config_ranges& ranges = object(obj_idx)->layer_config_ranges;
-    // Adding and deleting tree items fires selection events on GTK; suppress them as every other
-    // bulk edit of the tree here does.
-    const bool prevent_events = m_prevent_list_events;
-    m_prevent_list_events = true;
-    wxDataViewItem root = m_objects_model->GetLayerRootItem(obj_item);
-    if (root.IsOk()) {
-        m_objects_model->DeleteChildren(root);
-        if (ranges.empty())
-            m_objects_model->Delete(root);
-        else {
-            for (const auto& range : ranges)
-                add_layer_item(range.first, root);
-            Expand(root);
-        }
-    } else {
-        add_layer_root_item(obj_item);
-    }
-    m_prevent_list_events = prevent_events;
-
-    changed_object(obj_idx);
-}
-
 void ObjectList::del_layers_from_object(const int obj_idx)
 {
    object(obj_idx)->layer_config_ranges.clear();
@@ -324,11 +324,6 @@ public:
    void                del_settings_from_config(const wxDataViewItem& parent_item);
    void                del_instances_from_object(const int obj_idx);
    void                del_layer_from_object(const int obj_idx, const t_layer_height_range& layer_range);
-    // Mirrors an object's height ranges in the tree after they have been rewritten from outside the
-    // list - the texture displacement gizmo writes a whole set at once for a ChromaStack stack's
-    // filament swaps. Deliberately leaves the selection alone: changing it while a gizmo is open
-    // tears the gizmo down under the user.
-    void                rebuild_layer_ranges(const int obj_idx);
    void                del_layers_from_object(const int obj_idx);
    bool                del_from_cut_object(bool is_connector, bool is_model_part = false, bool is_negative_volume = false);
    bool                del_subobject_from_object(const int obj_idx, const int idx, const int type);
@@ -235,11 +235,7 @@ private:
    ModelVolume*       texture_volume();
    const ModelVolume* texture_volume() const;

-    // `chroma` picks the kind: a relief layer, a height map pushed into the surface, or a ChromaStack
-    // picture, a colour picture made of filament swaps. The kind is a property of the layer and is
-    // fixed when it is created - there is no panel-wide mode, so a plaque can carry a picture on its
-    // face and a knurl on its rim at the same time.
-    void add_texture_layer(bool chroma = false);
+    void add_texture_layer();
    void remove_texture_layer(int slot);
    // Moves the layer in `slot` to position `to_index` of the slot-ordered stack (an insertion index,
    // 0..layer count), which is the order blend modes apply in. Layers keep their data; what moves is
@@ -266,6 +262,9 @@ private:
    // Standard is active so what Preview shows is always what Bake will do. Returns true if it actually
    // changed something, so the caller can invalidate the preview.
    bool apply_standard_mode_presets(ModelVolume *mv);
+    // Copies the panel's own state (active layer, Standard/Pro) onto the volume, so the project file
+    // can carry it. Cheap and idempotent - called wherever either of the two changes.
+    void store_panel_state();
    // Standard mode's Bake: remesh to an even density, refine where the texture bends, then displace.
    // The order matters and is the whole reason this is one button - a height map can only move
    // existing vertices, so the mesh has to be prepared first, and remeshing after painting would drop
@@ -403,109 +402,6 @@ 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.
@@ -1078,9 +974,12 @@ private:
    PatchUnwrap m_uv_editor_unwrap;

    // When set, the panel is a free-floating window the user can drag anywhere (with a title bar to
-    // grab), instead of being pinned to the right of the gizmo toolbar. Persisted across gizmo
-    // open/close within a session, so the choice sticks while working.
+    // grab), instead of being pinned to the right of the gizmo toolbar. Kept in the application
+    // config rather than in the project: it describes the user's window, not the model, so opening
+    // someone else's project must not move their panel.
    bool m_undocked = false;
+    // The config key behind m_undocked.
+    static constexpr const char *UNDOCKED_CONFIG_KEY = "texture_displacement_panel_undocked";

    // Smooth scrolling for the panel body (everything between the header and the pinned Bake footer).
    // ImGui jumps a fixed number of lines per wheel notch, which on tall layer cards reads as a hard
@@ -4533,7 +4533,6 @@ void TabFilament::build()
        optgroup->append_single_option_line("filament_adhesiveness_category", "material_basic_information#adhesiveness-category");

        optgroup->append_single_option_line("filament_density", "material_basic_information#density");
-        optgroup->append_single_option_line("filament_transmission_distance", "material_basic_information#transmission-distance");
        optgroup->append_single_option_line("filament_shrink", "material_basic_information#shrinkage-xy");
        optgroup->append_single_option_line("filament_shrinkage_compensation_z", "material_basic_information#shrinkage-z");
        optgroup->append_single_option_line("filament_cost", "material_basic_information#price");
@@ -37,7 +37,6 @@ add_executable(${_TEST_NAME}_tests
    test_fill_plane_path.cpp
    test_fill_tpms_adaptive.cpp
    test_geometry.cpp
-    test_chromastack.cpp
    test_imex_arrange.cpp
    test_imex_helpers.cpp
    test_imex_zones.cpp
@@ -28,9 +28,12 @@
 #include <miniz.h>
 #include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/TriangleSelector.hpp"
+#include "libslic3r/TextureDisplacement.hpp"
+#include "libslic3r/PNGReadWrite.hpp"
 #include <memory>
 #include <cstdint>
 #include <ios>
+#include <iterator>
 #include <nlohmann/json.hpp>

 #include <boost/filesystem/operations.hpp>
@@ -349,6 +352,24 @@ static bool replace_in_3mf_entry(const std::string& path, const std::string& suf
    return replaced;
 }

+// Writes `model` out as a one-plate project, which is what the application's Save does with it.
+static void store_project(const std::string& path, Model& model)
+{
+    ScopedTemporaryDir backup_dir("orca_project_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));
+}
+
 // Stores a one-plate project holding a cube whose first two facets are painted Extruder2 and
 // Extruder3, which the exporter writes as paint_color="8" and paint_color="0C".
 static void store_painted_cube(const std::string& path)
@@ -363,19 +384,7 @@ static void store_painted_cube(const std::string& path)
        selector.set_facet(1, EnforcerBlockerType::Extruder3);
        REQUIRE(volume->mmu_segmentation_facets.set(selector));
    }
-    ScopedTemporaryDir backup_dir("orca_paint_src");
-    model.set_backup_path(backup_dir.string());
-
-    DynamicPrintConfig cfg;
-    PlateData          plate;
-    plate.plate_index = 0;
-    StoreParams sp;
-    sp.path     = path.c_str();
-    sp.model    = &model;
-    sp.config   = &cfg;
-    sp.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
-    sp.plate_data_list.push_back(&plate);
-    REQUIRE(store_bbs_3mf(sp));
+    store_project(path, model);
 }

 // Loads `path` through the BBS importer into `model`, releasing the plates it returns. The
@@ -2080,3 +2089,307 @@ TEST_CASE("Loading a gcode.3mf from a stream keeps the plate's pick and pattern
    CHECK(dst_plates.front()->pattern_bbox_file == "Metadata/plate_1.json");
    release_PlateData_list(dst_plates);
 }
+
+// Encodes a flat grayscale PNG the way the texture panel's import does, so what the archive carries
+// is a real texture rather than an opaque blob.
+static std::shared_ptr<std::vector<unsigned char>> make_gray_png(uint8_t value, size_t w = 4, size_t h = 4)
+{
+    ScopedTemporaryFile        file(".png");
+    const std::vector<uint8_t> pixels(w * h, value);
+    REQUIRE(png::write_gray_to_file(file.string(), w, h, pixels));
+
+    boost::nowide::ifstream    in(file.string(), std::ios::binary);
+    std::vector<unsigned char> bytes((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+    REQUIRE_FALSE(bytes.empty());
+    return std::make_shared<std::vector<unsigned char>>(std::move(bytes));
+}
+
+// Every entry name in a 3mf archive, with the separators normalised the way the importer sees them.
+static std::vector<std::string> zip_entry_names(const std::string& path)
+{
+    std::vector<std::string> names;
+    mz_zip_archive           zip;
+    mz_zip_zero_struct(&zip);
+    REQUIRE(open_zip_reader(&zip, path));
+    const mz_uint n = mz_zip_reader_get_num_files(&zip);
+    for (mz_uint i = 0; i < n; ++i) {
+        mz_zip_archive_file_stat st;
+        if (!mz_zip_reader_file_stat(&zip, i, &st) || st.m_is_directory)
+            continue;
+        std::string name(st.m_filename);
+        std::replace(name.begin(), name.end(), '\\', '/');
+        names.push_back(std::move(name));
+    }
+    close_zip_reader(&zip);
+    return names;
+}
+
+static const std::string TEXTURE_DISPLACEMENT_ENTRY_DIR = "Metadata/texture_displacement/";
+
+// Stores a one-plate project holding a cube with one texture displacement layer, painted on that
+// layer's own slot. The caller fills the layer in, and gets back the mask string the exporter wrote
+// for `painted_facet`, which is what the load has to reproduce.
+//
+// The painted facet is deliberately not the first one: the importer keeps a slot's masks only as far
+// as its last painted triangle, so a facet in the middle is the case where that run has to be padded
+// in front and left short at the back.
+static void store_texture_displaced_cube(const std::string& path, const TextureDisplacementLayer& layer,
+                                         const TextureDisplacementOptions& options, std::string& painted_mask,
+                                         int painted_facet = 5)
+{
+    Model        model;
+    ModelObject* object = model.add_object();
+    ModelVolume* volume = object->add_volume(make_cube(10., 10., 10.));
+    object->add_instance();
+
+    volume->texture_displacement_layers.push_back(layer);
+    volume->texture_displacement_options = options;
+    REQUIRE(painted_facet < int(volume->mesh().its.indices.size()));
+    {
+        TriangleSelector selector(volume->mesh());
+        selector.set_facet(painted_facet, EnforcerBlockerType::ENFORCER);
+        REQUIRE(volume->texture_displacement_facet(layer.slot).set(selector));
+    }
+    painted_mask = volume->texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facet);
+    REQUIRE_FALSE(painted_mask.empty());
+
+    store_project(path, model);
+}
+
+// Returns the only volume of the only object in the project at `path`, loaded through the importer.
+static const ModelVolume& load_single_volume(const std::string& path, Model& model, const ScopedTemporaryDir& backup_dir)
+{
+    REQUIRE(load_project(path, model, backup_dir));
+    REQUIRE(model.objects.size() == 1);
+    REQUIRE(model.objects.front()->volumes.size() == 1);
+    return *model.objects.front()->volumes.front();
+}
+
+// A texture displacement stack is the one paint tool whose settings live outside the volume's config:
+// the layer stack goes into the archive as its own JSON file, each layer's texture as a PNG beside it,
+// and the paint as a per-triangle attribute (see add_texture_displacement). A project only reopens
+// with its relief intact if all three come back together.
+TEST_CASE("A texture displacement layer, its texture and its paint survive a project round trip", "[3mf][TextureDisplacement]")
+{
+    TextureDisplacementLayer layer;
+    layer.slot              = 3; // not the first slot, so the per-slot attribute names have to line up
+    layer.name              = "Bark";
+    layer.path              = "/textures/bark.png";
+    layer.depth_mm          = 1.25f;
+    layer.tiling_scale      = 7.5f;
+    layer.midlevel          = 0.5f;
+    layer.invert            = true;
+    layer.tile_method       = TextureTileMethod::MirroredRepeat;
+    layer.projection_method = TextureProjectionMethod::LSCM;
+    layer.blend_mode        = TextureBlendMode::Subtract;
+    layer.lscm_seam_edges   = { { 1, 2 }, { 3, 5 } };
+    layer.image_data        = make_gray_png(128);
+
+    TextureDisplacementOptions options;
+    options.smooth_enabled    = true;
+    options.smooth_iterations = 4;
+    options.active_slot       = layer.slot;
+    options.panel_mode        = 1;
+
+    const int           painted_facet = 5;
+    std::string         painted;
+    ScopedTemporaryFile temp(".3mf");
+    store_texture_displaced_cube(temp.string(), layer, options, painted, painted_facet);
+
+    ScopedTemporaryDir backup_dir("orca_texdisp_dst");
+    Model              model;
+    const ModelVolume& volume = load_single_volume(temp.string(), model, backup_dir);
+
+    REQUIRE(volume.texture_displacement_layers.size() == 1);
+    const TextureDisplacementLayer& read = volume.texture_displacement_layers.front();
+    CHECK(read.slot == layer.slot);
+    CHECK(read.name == layer.name);
+    CHECK(read.path == layer.path);
+    CHECK_THAT(read.depth_mm, Catch::Matchers::WithinAbs(layer.depth_mm, 1e-6f));
+    CHECK_THAT(read.tiling_scale, Catch::Matchers::WithinAbs(layer.tiling_scale, 1e-6f));
+    CHECK_THAT(read.midlevel, Catch::Matchers::WithinAbs(layer.midlevel, 1e-6f));
+    CHECK(read.invert == layer.invert);
+    CHECK(read.tile_method == layer.tile_method);
+    CHECK(read.projection_method == layer.projection_method);
+    CHECK(read.blend_mode == layer.blend_mode);
+    CHECK(read.lscm_seam_edges == layer.lscm_seam_edges);
+
+    // The texture rides along in the archive, named after the slot it belongs to, byte for byte.
+    CHECK(boost::algorithm::starts_with(read.path_in_3mf, TEXTURE_DISPLACEMENT_ENTRY_DIR));
+    CHECK(boost::algorithm::ends_with(read.path_in_3mf, "_" + std::to_string(layer.slot) + ".png"));
+    REQUIRE(read.image_data);
+    CHECK(*read.image_data == *layer.image_data);
+
+    CHECK(volume.texture_displacement_options.smooth_enabled);
+    CHECK(volume.texture_displacement_options.smooth_iterations == options.smooth_iterations);
+    CHECK(volume.texture_displacement_options.active_slot == options.active_slot);
+    CHECK(volume.texture_displacement_options.panel_mode == options.panel_mode);
+
+    // The paint comes back on the facet it was put on, on its own slot and nowhere else.
+    CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facet) == painted);
+    CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(0).empty());
+    for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
+        if (slot != layer.slot)
+            CHECK(volume.texture_displacement_facet(slot).empty());
+}
+
+// A layer names the file its texture was imported from, which the library panel uses to point at the
+// entry the layer came from. That name must not be opened: the project may come from anyone, the path
+// may name any file the user can read - on Windows a UNC path names a host as well - and the next save
+// would copy whatever was found there into the archive. A layer the archive has no image for comes
+// back without pixels instead, which the user fixes by picking the texture again.
+TEST_CASE("A texture displacement layer whose image the archive lacks is not read from the path it names", "[3mf][TextureDisplacement][Regression]")
+{
+    // A file that really is there, so the test fails if the importer ever reaches for it.
+    ScopedTemporaryFile texture(".png");
+    REQUIRE(png::write_gray_to_file(texture.string(), 4, 4, std::vector<uint8_t>(16, 200)));
+
+    TextureDisplacementLayer layer;
+    layer.slot = 0;
+    layer.name = "Bark";
+    layer.path = texture.string(); // and no image_data: nothing for the exporter to put in the archive
+
+    std::string         painted;
+    ScopedTemporaryFile temp(".3mf");
+    store_texture_displaced_cube(temp.string(), layer, TextureDisplacementOptions{}, painted);
+
+    for (const std::string& name : zip_entry_names(temp.string()))
+        if (boost::algorithm::starts_with(name, TEXTURE_DISPLACEMENT_ENTRY_DIR))
+            CHECK_FALSE(boost::algorithm::ends_with(name, ".png"));
+
+    ScopedTemporaryDir backup_dir("orca_texdisp_dst");
+    Model              model;
+    const ModelVolume& volume = load_single_volume(temp.string(), model, backup_dir);
+
+    REQUIRE(volume.texture_displacement_layers.size() == 1);
+    CHECK(volume.texture_displacement_layers.front().path == texture.string());
+    CHECK_FALSE(bool(volume.texture_displacement_layers.front().image_data));
+    CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(5) == painted);
+}
+
+// The stack's JSON is arbitrary text by the time it is read back, and a value of the wrong type in it
+// throws out of the parse. That has to cost the volume its layers, not the project: the model, and the
+// paint the user can still build on, load as they would from a build without the feature.
+TEST_CASE("A malformed texture displacement block leaves the rest of the project loadable", "[3mf][TextureDisplacement][Regression]")
+{
+    TextureDisplacementLayer layer;
+    layer.slot       = 0;
+    layer.name       = "Bark";
+    layer.image_data = make_gray_png(128);
+
+    std::string         painted;
+    ScopedTemporaryFile temp(".3mf");
+    store_texture_displaced_cube(temp.string(), layer, TextureDisplacementOptions{}, painted);
+
+    REQUIRE(rewrite_3mf_entries(temp.string(), [](std::string& name, std::string& data) {
+        if (!boost::algorithm::starts_with(name, TEXTURE_DISPLACEMENT_ENTRY_DIR) ||
+            !boost::algorithm::ends_with(name, ".json"))
+            return false;
+        // `offset` goes through a typed accessor, so a string in it throws; a plain setting like
+        // depth_mm would be shrugged off by the parse instead, leaving the layer loadable.
+        data = R"({"version":1,"layers":[{"slot":0,"offset":["deep","deep"]}]})";
+        return true;
+    }));
+
+    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);
+    REQUIRE(model.objects.front()->volumes.size() == 1);
+    const ModelVolume& volume = *model.objects.front()->volumes.front();
+
+    CHECK(volume.texture_displacement_layers.empty());
+    CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(5) == painted);
+}
+
+// A slot's masks are kept only as far as its last painted triangle, so where the paint falls in the
+// list decides whether that run has to be padded in front of the paint, cut short behind it, or both.
+TEST_CASE("Texture displacement paint survives wherever it falls in the triangle list", "[3mf][TextureDisplacement]")
+{
+    const int painted_facet = GENERATE(0, 5, 11); // first, middle and last facet of a cube
+    INFO("painted facet " << painted_facet);
+
+    TextureDisplacementLayer layer;
+    layer.slot       = 0;
+    layer.name       = "Bark";
+    layer.image_data = make_gray_png(128);
+
+    std::string         painted;
+    ScopedTemporaryFile temp(".3mf");
+    store_texture_displaced_cube(temp.string(), layer, TextureDisplacementOptions{}, painted, painted_facet);
+
+    ScopedTemporaryDir backup_dir("orca_texdisp_dst");
+    Model              model;
+    const ModelVolume& volume = load_single_volume(temp.string(), model, backup_dir);
+
+    CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facet) == painted);
+    for (int facet = 0; facet < int(volume.mesh().its.indices.size()); ++facet)
+        if (facet != painted_facet)
+            CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(facet).empty());
+}
+
+// Each volume's stack is written under the volume's own id, and the paint of a whole object arrives as
+// one run of triangles that the volumes take their slices of. Two volumes using the same slot are the
+// case where both of those have to tell the volumes apart.
+TEST_CASE("Two volumes of one object keep their own texture displacement layers", "[3mf][TextureDisplacement]")
+{
+    const auto first_image  = make_gray_png(64);
+    const auto second_image = make_gray_png(192);
+    REQUIRE(*first_image != *second_image);
+
+    // The facet each volume is painted on, volume-local, so a mask landing on the wrong volume shows up.
+    const int   painted_facets[2] = { 0, 7 };
+    std::string painted[2];
+
+    ScopedTemporaryFile temp(".3mf");
+    {
+        Model        model;
+        ModelObject* object = model.add_object();
+        object->add_instance();
+        for (int i = 0; i < 2; ++i) {
+            ModelVolume*             volume = object->add_volume(make_cube(10., 10., 10.));
+            TextureDisplacementLayer layer;
+            layer.slot       = 0; // the same slot in both, which is what makes their names collide
+            layer.name       = i == 0 ? "First" : "Second";
+            layer.depth_mm   = i == 0 ? 0.5f : 1.5f;
+            layer.image_data = i == 0 ? first_image : second_image;
+            volume->texture_displacement_layers.push_back(layer);
+
+            TriangleSelector selector(volume->mesh());
+            selector.set_facet(painted_facets[i], EnforcerBlockerType::ENFORCER);
+            REQUIRE(volume->texture_displacement_facet(layer.slot).set(selector));
+            painted[i] = volume->texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facets[i]);
+            REQUIRE_FALSE(painted[i].empty());
+        }
+        store_project(temp.string(), model);
+    }
+
+    ScopedTemporaryDir backup_dir("orca_texdisp_dst");
+    Model              model;
+    REQUIRE(load_project(temp.string(), model, backup_dir));
+    REQUIRE(model.objects.size() == 1);
+    REQUIRE(model.objects.front()->volumes.size() == 2);
+
+    const std::shared_ptr<std::vector<unsigned char>> images[2] = { first_image, second_image };
+    const std::string                                 names[2]  = { "First", "Second" };
+    const float                                       depths[2] = { 0.5f, 1.5f };
+    std::string                                       entries[2];
+    for (int i = 0; i < 2; ++i) {
+        INFO("volume " << i);
+        const ModelVolume& volume = *model.objects.front()->volumes[i];
+        REQUIRE(volume.texture_displacement_layers.size() == 1);
+        const TextureDisplacementLayer& layer = volume.texture_displacement_layers.front();
+        CHECK(layer.name == names[i]);
+        CHECK_THAT(layer.depth_mm, Catch::Matchers::WithinAbs(depths[i], 1e-6f));
+        REQUIRE(layer.image_data);
+        CHECK(*layer.image_data == *images[i]);
+        CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facets[i]) == painted[i]);
+        CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facets[1 - i]).empty());
+        entries[i] = layer.path_in_3mf;
+    }
+    // Both volumes paint slot 0, so only the volume id keeps their textures apart in the archive.
+    CHECK(entries[0] != entries[1]);
+}
+
@@ -1,379 +0,0 @@
-#include <catch2/catch_approx.hpp>
-#include <catch2/catch_test_macros.hpp>
-#include <catch2/matchers/catch_matchers_floating_point.hpp>
-
-#include <algorithm>
-#include <cmath>
-#include <cstdint>
-#include <vector>
-
-#include "libslic3r/Color.hpp"
-#include "libslic3r/ChromaStack.hpp"
-#include "libslic3r/PNGReadWrite.hpp"
-
-using namespace Slic3r;
-using Catch::Matchers::WithinAbs;
-using Catch::Matchers::WithinRel;
-
-namespace {
-
-ChromaFilament filament(int index, const ColorRGB &color, float td_mm)
-{
-    ChromaFilament f;
-    f.filament = index;
-    f.color    = color;
-    f.td_mm    = td_mm;
-    return f;
-}
-
-ChromaBand band(const ChromaFilament &f, int layers)
-{
-    ChromaBand b;
-    b.filament = f;
-    b.layers   = layers;
-    return b;
-}
-
-// An opaque filament (TD 1 hides what is under it within 0.1 mm) and a translucent one (TD 8 needs
-// most of a millimetre), which is the whole range the model has to behave sensibly over.
-const ChromaFilament WHITE_OPAQUE      = filament(0, ColorRGB(1.f, 1.f, 1.f), 1.f);
-const ChromaFilament BLACK_OPAQUE      = filament(1, ColorRGB(0.f, 0.f, 0.f), 1.f);
-const ChromaFilament BLACK_TRANSLUCENT = filament(2, ColorRGB(0.f, 0.f, 0.f), 8.f);
-
-float luminance(const ColorRGB &c) { return 0.2126f * c.r() + 0.7152f * c.g() + 0.0722f * c.b(); }
-
-} // namespace
-
-TEST_CASE("A stack's palette has one entry per printed layer", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 4;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 10) };
-
-    // The base is backing under the picture, not part of a band: the bands are the 12 layers the
-    // picture is built from, and the stack is those on top of the 4 the model already has.
-    REQUIRE(stack.relief_layers() == 12);
-    REQUIRE(stack.total_layers() == 16);
-    REQUIRE_THAT(stack.depth_mm(), WithinAbs(12 * 0.08f, 1e-6f));
-
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    REQUIRE(palette.size() == 17);
-    // Index 0 is the base's own colour, so a column one layer tall is exactly its filament - whatever
-    // that filament's transmission distance.
-    REQUIRE(palette[0] == palette[1]);
-    REQUIRE_THAT(luminance(palette[1]), WithinAbs(1.f, 1e-3f));
-}
-
-TEST_CASE("A run of one filament gives the same palette however it is split into bands", "[ChromaStack]")
-{
-    // The property that justifies compositing layer by layer at all: transmittance multiplies, so
-    // cutting a run in two must not change the colours. A model without it would make the palette
-    // depend on how the stack was typed in.
-    ChromaStack one;
-    one.layer_height_mm = 0.1f;
-    one.base_layers     = 0;
-    one.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
-
-    ChromaStack split = one;
-    split.bands         = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 3), band(BLACK_TRANSLUCENT, 5) };
-
-    const std::vector<ColorRGB> a = chroma_palette(one);
-    const std::vector<ColorRGB> b = chroma_palette(split);
-    REQUIRE(a.size() == b.size());
-    for (size_t i = 0; i < a.size(); ++i)
-        REQUIRE_THAT(luminance(a[i]), WithinAbs(luminance(b[i]), 1e-5f));
-}
-
-TEST_CASE("A translucent filament darkens gradually and an opaque one at once", "[ChromaStack]")
-{
-    ChromaStack translucent;
-    translucent.layer_height_mm = 0.08f;
-    translucent.base_layers     = 0;
-    translucent.bands           = { band(WHITE_OPAQUE, 1), band(BLACK_TRANSLUCENT, 12) };
-    const std::vector<ColorRGB> slow = chroma_palette(translucent);
-
-    // Monotonically darker, and still short of the filament's own black after a single layer: that
-    // gradient is what a ChromaStack stack prints its midtones with.
-    for (size_t i = 2; i < slow.size(); ++i)
-        REQUIRE(luminance(slow[i]) < luminance(slow[i - 1]));
-    REQUIRE(luminance(slow[2]) > 0.5f);
-    // Twelve layers of a TD 8 filament pass under 3% of the light, which is the dark end of the ramp
-    // rather than true black - and that is the honest prediction, not a rounding artifact.
-    REQUIRE(luminance(slow.back()) < 0.25f);
-
-    ChromaStack opaque;
-    opaque.layer_height_mm = 0.08f;
-    opaque.base_layers     = 0;
-    opaque.bands           = { band(WHITE_OPAQUE, 1), band(BLACK_OPAQUE, 12) };
-    const std::vector<ColorRGB> fast = chroma_palette(opaque);
-    // TD 1 is opaque within about 0.1 mm, so two layers of it leave little of the white showing.
-    REQUIRE(luminance(fast[3]) < 0.2f);
-}
-
-TEST_CASE("Solving a picture of the palette's own colors reproduces it exactly", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
-
-    const std::vector<ColorRGB> palette = chroma_palette(stack);
-    const int                   relief  = stack.relief_layers();
-
-    // One pixel per reachable height, in order.
-    std::vector<uint8_t> rgb;
-    for (int i = 0; i <= relief; ++i) {
-        const ColorRGB &c = palette[size_t(stack.base_layers + i)];
-        rgb.push_back(uint8_t(std::lround(c.r() * 255.f)));
-        rgb.push_back(uint8_t(std::lround(c.g() * 255.f)));
-        rgb.push_back(uint8_t(std::lround(c.b() * 255.f)));
-    }
-
-    const ChromaSolve solve = chroma_solve(rgb.data(), relief + 1, 1, stack);
-    REQUIRE_FALSE(solve.empty());
-    REQUIRE(solve.width == relief + 1);
-    REQUIRE(solve.levels.size() == size_t(relief + 1));
-    // Every pixel comes back as the colour it was generated from, and the error is rounding only.
-    //
-    // The colour rather than the height: the bottom band prints in the same filament as the base, so
-    // its first layers show exactly the colour the base already showed, and any of those heights is a
-    // correct answer for that pixel. Asserting the height would be asserting which of several equally
-    // right answers the search happens to reach first.
-    for (int i = 0; i <= relief; ++i) {
-        const int chosen = int(solve.levels[size_t(i)]);
-        REQUIRE(chosen >= stack.base_layers);
-        REQUIRE(chosen <= stack.total_layers());
-        const ColorRGB &got  = palette[size_t(chosen)];
-        const ColorRGB &want = palette[size_t(stack.base_layers + i)];
-        REQUIRE_THAT(got.r(), WithinAbs(want.r(), 2.f / 255.f));
-        REQUIRE_THAT(got.g(), WithinAbs(want.g(), 2.f / 255.f));
-        REQUIRE_THAT(got.b(), WithinAbs(want.b(), 2.f / 255.f));
-    }
-    // Only 8-bit rounding of the palette separates the two, which near black is still under one dE.
-    REQUIRE(solve.max_delta_e < 2.);
-
-    // The height map's ends are the base and the top of the stack, which is what ties a grey level to
-    // a printed layer.
-    REQUIRE(solve.grey.front() == 0);
-    REQUIRE(solve.grey.back() == 255);
-}
-
-TEST_CASE("A picture the filaments cannot reach is reported as a poor match", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
-
-    // Saturated red against a stack of white and black: no height can produce it, and the panel's
-    // warning depends on the solve saying so rather than silently picking a grey.
-    const std::vector<uint8_t> red{ 255, 0, 0 };
-    const ChromaSolve        solve = chroma_solve(red.data(), 1, 1, stack);
-    REQUIRE_FALSE(solve.empty());
-    REQUIRE(solve.mean_delta_e > 15.);
-}
-
-TEST_CASE("Dithering keeps every pixel in the stack's range", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
-    stack.dither          = true;
-
-    // A flat mid-grey: the error diffusion has to spread it over neighbouring heights without ever
-    // leaving the stack, which is what a clamped palette index would quietly get wrong.
-    std::vector<uint8_t> grey(size_t(16 * 16) * 3, 128);
-    const ChromaSolve  solve = chroma_solve(grey.data(), 16, 16, stack);
-    REQUIRE_FALSE(solve.empty());
-    REQUIRE(solve.levels.size() == size_t(16 * 16));
-    const auto [lo, hi] = std::minmax_element(solve.levels.begin(), solve.levels.end());
-    REQUIRE(int(*lo) >= stack.base_layers);
-    REQUIRE(int(*hi) <= stack.total_layers());
-}
-
-TEST_CASE("The solved height map is an 8-bit grayscale PNG of the picture's size", "[ChromaStack]")
-{
-    // The displacement pipeline reads one thing from a layer: an 8-bit grayscale PNG. A solve that
-    // produced anything else would leave the relief silently flat.
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 6) };
-
-    std::vector<uint8_t> picture(size_t(8 * 4) * 3);
-    for (size_t i = 0; i < picture.size(); ++i)
-        picture[i] = uint8_t(i % 256);
-
-    const ChromaSolve              solve = chroma_solve(picture.data(), 8, 4, stack);
-    const std::vector<unsigned char> png   = chroma_encode_height_png(solve);
-    REQUIRE_FALSE(png.empty());
-
-    const png::ReadBuf  buf{ png.data(), png.size() };
-    png::ImageGreyscale decoded;
-    REQUIRE(png::is_png(buf));
-    REQUIRE(png::decode_png(buf, decoded));
-    REQUIRE(decoded.cols == 8);
-    REQUIRE(decoded.rows == 4);
-    REQUIRE(decoded.buf == solve.grey);
-}
-
-TEST_CASE("Each band becomes a height range, and a repeated filament is not a swap", "[ChromaStack]")
-{
-    ChromaStack stack;
-    stack.layer_height_mm = 0.1f;
-    stack.base_layers     = 0;
-    stack.bands           = { band(WHITE_OPAQUE, 5), band(BLACK_OPAQUE, 3), band(BLACK_OPAQUE, 2) };
-
-    const std::vector<ChromaRange> ranges = chroma_ranges(stack, 0.);
-    // Three bands, two filaments: the second and third merge, because nothing is swapped between them.
-    REQUIRE(ranges.size() == 2);
-    REQUIRE_THAT(ranges[0].z_min, WithinAbs(0., 1e-9));
-    REQUIRE_THAT(ranges[0].z_max, WithinAbs(0.5, 1e-9));
-    REQUIRE(ranges[0].filament == WHITE_OPAQUE.filament);
-    REQUIRE_THAT(ranges[1].z_min, WithinAbs(0.5, 1e-9));
-    REQUIRE_THAT(ranges[1].z_max, WithinAbs(1.0, 1e-9));
-    REQUIRE(ranges[1].filament == BLACK_OPAQUE.filament);
-}
-
-TEST_CASE("A default stack puts the lightest filament at the bottom", "[ChromaStack]")
-{
-    // Light to dark is what gives the long tonal ramp; the order is the one thing a seeded stack has
-    // to get right, since everything else is a layer count the user can drag.
-    const std::vector<ChromaFilament> loaded{ BLACK_OPAQUE, WHITE_OPAQUE,
-                                                filament(3, ColorRGB(0.5f, 0.5f, 0.5f), 4.f) };
-    const ChromaStack stack = chroma_default_stack(loaded, 0.08f, 4, 24);
-
-    REQUIRE(stack.bands.size() == 3);
-    REQUIRE(stack.bands.front().filament.filament == WHITE_OPAQUE.filament);
-    REQUIRE(stack.bands.back().filament.filament == BLACK_OPAQUE.filament);
-    REQUIRE(stack.base_layers == 4);
-    // The base is printed in the bottom band, so the relief is what was asked for and the base sits
-    // underneath it.
-    REQUIRE(stack.total_layers() == 4 + 24);
-    REQUIRE(stack.relief_layers() == 24);
-    REQUIRE_THAT(stack.layer_height_mm, WithinRel(0.08f));
-}
-
-TEST_CASE("An empty stack or picture solves to nothing", "[ChromaStack]")
-{
-    ChromaStack empty;
-    REQUIRE(chroma_palette(empty).empty());
-    REQUIRE(chroma_ranges(empty, 0.).empty());
-
-    // A base with nothing on it: there is no picture to solve, and no filament to print the base in.
-    ChromaStack base_only;
-    base_only.layer_height_mm = 0.08f;
-    base_only.base_layers     = 4;
-    REQUIRE(base_only.relief_layers() == 0);
-    REQUIRE(chroma_palette(base_only).empty());
-    const std::vector<uint8_t> pixel{ 128, 128, 128 };
-    REQUIRE(chroma_solve(pixel.data(), 1, 1, base_only).empty());
-
-    ChromaStack usable;
-    usable.layer_height_mm = 0.08f;
-    usable.base_layers     = 2;
-    usable.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_OPAQUE, 4) };
-    REQUIRE(chroma_solve(nullptr, 4, 4, usable).empty());
-}
-
-TEST_CASE("The base extends the bottom band's range down to the first layer", "[ChromaStack]")
-{
-    // The base is not a swap of its own: it prints in whatever is loaded at the start, which is the
-    // bottom band's filament, so the first range has to reach the build plate.
-    ChromaStack stack;
-    stack.layer_height_mm = 0.1f;
-    stack.base_layers     = 20;
-    stack.bands           = { band(WHITE_OPAQUE, 5), band(BLACK_OPAQUE, 5) };
-
-    const std::vector<ChromaRange> ranges = chroma_ranges(stack, 0.);
-    REQUIRE(ranges.size() == 2);
-    REQUIRE_THAT(ranges[0].z_min, WithinAbs(0., 1e-9));
-    REQUIRE_THAT(ranges[0].z_max, WithinAbs(2.5, 1e-9)); // 20 base + 5 band layers at 0.1 mm
-    REQUIRE_THAT(ranges[1].z_min, WithinAbs(2.5, 1e-9));
-    REQUIRE_THAT(ranges[1].z_max, WithinAbs(3.0, 1e-9));
-    REQUIRE(ranges.back().z_max == Catch::Approx(double(stack.total_layers()) * double(stack.layer_height_mm)));
-}
-
-TEST_CASE("A surface's color follows the printed layer it sits at", "[ChromaStack]")
-{
-    // What the preview colours by: a swap happens at one print Z, so the layer a surface sits in is
-    // what decides its colour, whatever the height map says.
-    ChromaStack stack;
-    stack.layer_height_mm = 0.1f;
-    stack.base_layers     = 2;
-    stack.bands           = { band(WHITE_OPAQUE, 3), band(BLACK_OPAQUE, 5) };
-
-    REQUIRE(chroma_level_at(stack, 0.05) == 1);  // inside the first layer
-    REQUIRE(chroma_level_at(stack, 0.10) == 1);  // exactly its top, which that layer printed
-    REQUIRE(chroma_level_at(stack, 0.15) == 2);
-    REQUIRE(chroma_level_at(stack, 0.50) == 5);  // the top of the base plus the white band
-    // Clamped at both ends: below the plate and above the stack there is nothing else to show.
-    REQUIRE(chroma_level_at(stack, -1.) == 1);
-    REQUIRE(chroma_level_at(stack, 99.) == stack.total_layers());
-}
-
-TEST_CASE("How fast a filament covers is its TD against the layer height", "[ChromaStack]")
-{
-    // The number that decides whether a band is a gradient or a step, and the one the panel reports:
-    // a filament hides what is under it at about a tenth of its TD, so how many layers that is
-    // depends entirely on how thick they are.
-    REQUIRE_THAT(chroma_layers_to_opaque(4.f, 0.2f), WithinRel(2.f, 1e-4f));
-    REQUIRE_THAT(chroma_layers_to_opaque(4.f, 0.08f), WithinRel(5.f, 1e-4f));
-    REQUIRE_THAT(chroma_layers_to_opaque(8.f, 0.08f), WithinRel(10.f, 1e-4f));
-    // An opaque filament at a coarse layer height covers within one layer, which is where a stack
-    // stops having any colours between its filaments at all.
-    REQUIRE(chroma_layers_to_opaque(1.f, 0.2f) < 1.f);
-    REQUIRE_THAT(chroma_layers_to_opaque(4.f, 0.f), WithinAbs(0.f, 1e-6f));
-}
-
-TEST_CASE("A finer layer height buys colors between the filaments", "[ChromaStack]")
-{
-    // The whole of the user-visible problem in one assertion: the same stack, the same filaments, two
-    // layer heights. The coarse one steps from white to black in two layers; the fine one fades.
-    const auto distinct = [](float layer_height) {
-        ChromaStack stack;
-        stack.layer_height_mm = layer_height;
-        stack.base_layers     = 0;
-        stack.bands           = { band(WHITE_OPAQUE, 1), band(filament(5, ColorRGB(0.f, 0.f, 0.f), 8.f), 10) };
-        const std::vector<ColorRGB> palette = chroma_palette(stack);
-        int                         n       = 0;
-        for (size_t i = 1; i < palette.size(); ++i)
-            if (std::abs(luminance(palette[i]) - luminance(palette[i - 1])) > 0.02f)
-                ++n;
-        return n;
-    };
-    REQUIRE(distinct(0.08f) > distinct(0.3f));
-}
-
-TEST_CASE("Layers past a filament's covering depth add no color", "[ChromaStack]")
-{
-    // The band is twice as long as the filament needs to hide what is under it, so half of it shows a
-    // colour the layer below already showed. That is invisible in the stack and obvious here.
-    ChromaStack stack;
-    stack.layer_height_mm = 0.08f;
-    stack.base_layers     = 0;
-    stack.bands           = { band(WHITE_OPAQUE, 1), band(filament(5, ColorRGB(0.f, 0.f, 0.f), 4.f), 10) };
-
-    // Trimming keeps every layer that still changes the colour and drops the rest, so the stack gets
-    // shorter and loses none of its colours.
-    const int distinct = chroma_distinct_levels(stack);
-    const int before   = stack.relief_layers();
-    chroma_trim_bands(stack);
-    REQUIRE(stack.relief_layers() <= before);
-    REQUIRE(chroma_distinct_levels(stack) == distinct);
-    // The white band is a single layer and has nothing to give up.
-    REQUIRE(stack.bands.front().layers == 1);
-
-    // A light band over a dark one is the case where layers really are wasted: it saturates within a
-    // few layers, and the rest of a long band shows what the layer below already showed.
-    ChromaStack light_over_dark;
-    light_over_dark.layer_height_mm = 0.08f;
-    light_over_dark.base_layers     = 0;
-    light_over_dark.bands = { band(filament(5, ColorRGB(0.f, 0.f, 0.f), 4.f), 1), band(WHITE_OPAQUE, 14) };
-    const int kept = chroma_distinct_levels(light_over_dark);
-    chroma_trim_bands(light_over_dark);
-    REQUIRE(light_over_dark.bands.back().layers < 14);
-    REQUIRE(chroma_distinct_levels(light_over_dark) == kept);
-}
@@ -2157,6 +2157,190 @@ TEST_CASE("A second bake beside a first comes out as fine as a single bake", "[T
    CHECK(second <= single * 5 / 4);
 }

+// The .3mf stores the layer stack as JSON (see texture_displacement_layers_to_json). Two properties
+// matter: everything the UV editor and the panel can set has to survive a round trip, and a document
+// written by a build that knew fewer fields has to keep loading, with the missing ones left at their
+// defaults rather than zeroed.
+TEST_CASE("Texture displacement layers survive a JSON round trip", "[TextureDisplacement]")
+{
+    std::vector<TextureDisplacementLayer> layers(2);
+    TextureDisplacementLayer             &a = layers[0];
+    a.slot                 = 0;
+    a.name                 = "Bark";
+    a.path                 = "/textures/bark.png";
+    a.depth_mm             = 1.25f;
+    a.tiling_scale         = 7.5f;
+    a.rotation_deg         = 30.f;
+    a.offset               = Vec2f(0.25f, -0.5f);
+    a.invert               = true;
+    a.midlevel             = 0.125f;
+    a.smoothing            = 0.75f;
+    a.edge_smoothing       = true;
+    a.edge_smoothing_amount = 0.25f;
+    a.auto_connect_islands = false;
+    a.tile_enabled         = false;
+    a.tile_method          = TextureTileMethod::MirroredRepeat;
+    a.projection_method    = TextureProjectionMethod::LSCM;
+    a.blend_mode           = TextureBlendMode::Subtract;
+    a.color_enabled        = true;
+    a.lscm_seam_angle_deg  = 45.f;
+    a.island_padding_mm    = 0.5f;
+    a.lscm_seam_edges      = { { 1, 2 }, { 3, 5 } };
+    a.islands              = { TextureIsland{ Vec2f(1.f, 2.f), 15.f, 1.5f }, TextureIsland{} };
+    a.island_groups        = { 0, 0 };
+    a.lscm_uv_overrides    = { { -4, Vec2f(0.5f, 0.75f) } };
+
+    TextureDisplacementLayer &b = layers[1];
+    b.slot                    = 1;
+    b.projection_method       = TextureProjectionMethod::ViewProjected;
+    b.view_project_right      = Vec3f(0.f, 1.f, 0.f);
+    b.view_project_up         = Vec3f(0.f, 0.f, 1.f);
+    b.view_project_projective = true;
+    for (size_t i = 0; i < b.view_project_matrix.size(); ++i)
+        b.view_project_matrix[i] = float(i) + 0.5f;
+
+    TextureDisplacementOptions options;
+    options.displace_border   = false;
+    options.smooth_enabled    = true;
+    options.smooth_strength   = 0.6f;
+    options.smooth_iterations = 5;
+    options.pipeline_v2       = false;
+    options.v2_max_triangles_k = 250;
+    options.color_mix_count   = 3;
+    options.color_despeckle   = 4;
+    options.active_slot       = 3;
+    options.panel_mode        = 1;
+
+    const std::string json = texture_displacement_layers_to_json(layers, options);
+
+    std::vector<TextureDisplacementLayer> read_layers;
+    TextureDisplacementOptions            read_options;
+    REQUIRE(texture_displacement_layers_from_json(json, read_layers, read_options));
+    REQUIRE(read_layers.size() == layers.size());
+
+    const TextureDisplacementLayer &ra = read_layers[0];
+    CHECK(ra.name == a.name);
+    CHECK(ra.path == a.path);
+    CHECK_THAT(ra.depth_mm, WithinAbs(a.depth_mm, 1e-6f));
+    CHECK_THAT(ra.tiling_scale, WithinAbs(a.tiling_scale, 1e-6f));
+    CHECK_THAT(ra.rotation_deg, WithinAbs(a.rotation_deg, 1e-6f));
+    CHECK(ra.offset.isApprox(a.offset));
+    CHECK(ra.invert == a.invert);
+    CHECK_THAT(ra.midlevel, WithinAbs(a.midlevel, 1e-6f));
+    CHECK_THAT(ra.smoothing, WithinAbs(a.smoothing, 1e-6f));
+    CHECK(ra.edge_smoothing == a.edge_smoothing);
+    CHECK_THAT(ra.edge_smoothing_amount, WithinAbs(a.edge_smoothing_amount, 1e-6f));
+    CHECK(ra.auto_connect_islands == a.auto_connect_islands);
+    CHECK(ra.tile_enabled == a.tile_enabled);
+    CHECK(ra.tile_method == a.tile_method);
+    CHECK(ra.projection_method == a.projection_method);
+    CHECK(ra.blend_mode == a.blend_mode);
+    CHECK(ra.color_enabled == a.color_enabled);
+    CHECK_THAT(ra.lscm_seam_angle_deg, WithinAbs(a.lscm_seam_angle_deg, 1e-6f));
+    CHECK_THAT(ra.island_padding_mm, WithinAbs(a.island_padding_mm, 1e-6f));
+    CHECK(ra.lscm_seam_edges == a.lscm_seam_edges);
+    REQUIRE(ra.islands.size() == a.islands.size());
+    CHECK(ra.islands[0].offset.isApprox(a.islands[0].offset));
+    CHECK_THAT(ra.islands[0].rotation_deg, WithinAbs(a.islands[0].rotation_deg, 1e-6f));
+    CHECK_THAT(ra.islands[0].scale, WithinAbs(a.islands[0].scale, 1e-6f));
+    CHECK(ra.island_groups == a.island_groups);
+    REQUIRE(ra.lscm_uv_overrides.size() == 1);
+    CHECK(ra.lscm_uv_overrides[0].first == -4);
+    CHECK(ra.lscm_uv_overrides[0].second.isApprox(Vec2f(0.5f, 0.75f)));
+
+    const TextureDisplacementLayer &rb = read_layers[1];
+    CHECK(rb.projection_method == TextureProjectionMethod::ViewProjected);
+    CHECK(rb.view_project_right.isApprox(b.view_project_right));
+    CHECK(rb.view_project_up.isApprox(b.view_project_up));
+    CHECK(rb.view_project_projective);
+    CHECK(rb.view_project_matrix == b.view_project_matrix);
+
+    CHECK(read_options.displace_border == options.displace_border);
+    CHECK(read_options.smooth_enabled == options.smooth_enabled);
+    CHECK_THAT(read_options.smooth_strength, WithinAbs(options.smooth_strength, 1e-6f));
+    CHECK(read_options.smooth_iterations == options.smooth_iterations);
+    CHECK(read_options.pipeline_v2 == options.pipeline_v2);
+    CHECK(read_options.v2_max_triangles_k == options.v2_max_triangles_k);
+    CHECK(read_options.color_mix_count == options.color_mix_count);
+    CHECK(read_options.color_despeckle == options.color_despeckle);
+    // Where the panel was left comes back with the rest, so a reopened project is on the same layer.
+    CHECK(read_options.active_slot == options.active_slot);
+    CHECK(read_options.panel_mode == options.panel_mode);
+}
+
+TEST_CASE("Texture displacement JSON keeps defaults for keys it does not carry", "[TextureDisplacement]")
+{
+    // What a build that knew fewer fields would have written: one layer, almost nothing set.
+    const std::string sparse = R"({"version":1,"layers":[{"slot":2,"name":"Old","depth_mm":0.75}]})";
+
+    std::vector<TextureDisplacementLayer> layers;
+    TextureDisplacementOptions            options;
+    REQUIRE(texture_displacement_layers_from_json(sparse, layers, options));
+    REQUIRE(layers.size() == 1);
+
+    const TextureDisplacementLayer  &l = layers[0];
+    const TextureDisplacementLayer   fresh;
+    const TextureDisplacementOptions defaults;
+    CHECK(l.slot == 2);
+    CHECK(l.name == "Old");
+    CHECK_THAT(l.depth_mm, WithinAbs(0.75f, 1e-6f));
+    // Everything absent keeps the struct's own default rather than becoming zero.
+    CHECK_THAT(l.tiling_scale, WithinAbs(fresh.tiling_scale, 1e-6f));
+    CHECK(l.auto_connect_islands == fresh.auto_connect_islands);
+    CHECK(l.tile_enabled == fresh.tile_enabled);
+    CHECK(l.projection_method == fresh.projection_method);
+    CHECK_THAT(l.lscm_seam_angle_deg, WithinAbs(fresh.lscm_seam_angle_deg, 1e-6f));
+    CHECK(options.color_mix_count == defaults.color_mix_count);
+    CHECK(options.pipeline_v2 == defaults.pipeline_v2);
+    CHECK(options.active_slot == defaults.active_slot);
+    CHECK(options.panel_mode == defaults.panel_mode);
+
+    std::vector<TextureDisplacementLayer> unused_layers;
+    TextureDisplacementOptions            unused_options;
+    CHECK(!texture_displacement_layers_from_json("not json at all", unused_layers, unused_options));
+}
+
+// The vectors, the islands and the UV overrides are read through nlohmann's typed accessors, which
+// throw on a value of the wrong type rather than returning anything. Nothing between here and the
+// project load catches that, so a document carrying one has to come back as "malformed block".
+TEST_CASE("Texture displacement JSON reports a value of the wrong type instead of throwing", "[TextureDisplacement]")
+{
+    const std::string json = GENERATE(
+        R"({"layers":[{"slot":0,"offset":["a","b"]}]})",
+        R"({"layers":[{"slot":0,"view_project_right":[1,null,3]}]})",
+        R"({"layers":[{"slot":0,"view_project_matrix":[1,2,3,4,5,6,7,8,9,10,11,"x"]}]})",
+        R"({"layers":[{"slot":0,"lscm_seam_edges":["a","b"]}]})",
+        R"({"layers":[{"slot":0,"islands":[[1,2,"a",4]]}]})",
+        R"({"layers":[{"slot":0,"lscm_uv_overrides":[[1,"a",3]]}]})");
+    INFO(json);
+
+    std::vector<TextureDisplacementLayer> layers;
+    TextureDisplacementOptions            options;
+    bool                                  parsed = true;
+    REQUIRE_NOTHROW(parsed = texture_displacement_layers_from_json(json, layers, options));
+    CHECK_FALSE(parsed);
+    CHECK(layers.empty());
+}
+
+// A plain setting is read through a helper that shrugs a wrong type off, which is the deliberate
+// other half of the case above: the field keeps its default and the rest of the layer still loads.
+TEST_CASE("Texture displacement JSON keeps the default for a setting of the wrong type", "[TextureDisplacement]")
+{
+    const std::string json = R"({"options":{"smooth_strength":"a lot"},"layers":[{"slot":"two","name":"Old","depth_mm":0.75}]})";
+
+    std::vector<TextureDisplacementLayer> layers;
+    TextureDisplacementOptions            options;
+    REQUIRE(texture_displacement_layers_from_json(json, layers, options));
+    REQUIRE(layers.size() == 1);
+
+    const TextureDisplacementLayer   fresh;
+    const TextureDisplacementOptions defaults;
+    CHECK(layers[0].slot == fresh.slot);
+    CHECK(layers[0].name == "Old");
+    CHECK_THAT(layers[0].depth_mm, WithinAbs(0.75f, 1e-6f));
+    CHECK_THAT(options.smooth_strength, WithinAbs(defaults.smooth_strength, 1e-6f));
+}
+
 TEST_CASE("whether a layer's texture has colour agrees with its decode", "[TextureDisplacement]")
 {
    TextureDisplacementLayer gray;
Author	SHA1	Message	Date
ExPikaPaka	682814878d	Address the review on saving texture displacement Read each layer's texture from the archive only. `layer.path` comes from the project file, so following it let any .3mf pick a local file to read, a UNC path among them, and have the next save copy what it found into the archive. Reverts the disk fallback added in `8ecfee6a2`. Store a paint mask only for the slots a triangle names. Eight empty strings per triangle cost every project hundreds of megabytes on a large mesh, whether or not it uses the feature. A slot's run is padded to the triangles seen so far on its first value, so it stays indexed by triangle, and ends at its last painted one. Report a malformed layer block instead of throwing out of the project load. The typed accessors throw on a value of the wrong type and nothing above them caught that, so one bad number cost the whole file rather than one volume's relief. Cover the store and load round trip in test_3mf.cpp: the layer, its image, the options and the paint, the two regressions above, paint at either end of the triangle list, two volumes sharing a slot, and the wrong-typed documents at the unit level.	2026-10-12 14:20:46 +02:00
SoftFever	30e48183e3	Merge branch 'main' into feature/texdisp-3mf-persistence # Conflicts: # src/libslic3r/TextureDisplacement.hpp # tests/libslic3r/test_texture_displacement.cpp	2026-10-12 16:58:03 +08:00
ExPikaPaka	8ecfee6a21	Save where the panel was left, and recover a texture the archive lacks The project carried the layer stack but not the user's place in it: a reopened project landed on slot 0 in Standard, whatever they had been editing. The active layer and Standard/Pro now live on the volume, next to the rest of its options, and come back with it. Docked/undocked goes to the application config instead - it describes the user's window, not the model, so opening someone else's project must not move their panel. A layer whose image_data was empty at save time was written with no texture and came back with none. It now falls back to the file the layer came from, which the importer put in the user's own texture library, so a project reopened on the same machine keeps its pixels. The texture is always stored as .png: the importer converts whatever the user picked, so the extension was being taken from a name that no longer described the bytes. Also adds v2_flip_edges to the cereal field list, which the undo stack was silently dropping.	2026-10-09 09:35:35 +02:00
ExPikaPaka	fbf4652e12	Fix the build and clang-tidy failures in the persistence change The round-trip test named a TextureTileMethod enumerator that does not exist (MirroredRepeat, not Mirror) and used a bare Approx, which Catch2 v3 keeps in its own namespace. The rest of the file compares floats with WithinAbs, so these follow it rather than reaching for Catch::Approx. bbs_3mf.cpp reads and writes the layer JSON but picked up the declarations through another header, and the same for boost::to_lower.	2026-10-09 09:05:42 +02:00
ExPikaPaka	be9ff50130	Merge remote-tracking branch 'origin/main' into feature/texdisp-3mf-persistence # Conflicts: # src/libslic3r/TextureDisplacement.cpp	2026-10-09 09:03:51 +02:00
SoftFever	dee1f1715f	Merge branch 'main' into feature/texdisp-3mf-persistence	2026-10-09 12:15:16 +08:00
ExPikaPaka	fcb1f62bd9	Save texture displacement in the project file A painted relief did not survive closing the project: nothing about the feature was written to the .3mf, so the layers, their textures and the paint mask were all lost on save. The layer struct's cereal save()/load() serve the undo/redo stack only, which is one session and one binary stream. Write the layer stack and the per-volume options as JSON in the archive, and each layer's texture as the image file it was loaded from, both referenced by path - the same split EmbossShape already makes for its SVG. The image stays out of the XML deliberately: it is binary and routinely megabytes, and base64 in an attribute would bloat the one file every reader parses just to list the objects. JSON rather than the cereal stream next to it because that one is positional and unversioned, which would make every future field a project-breaking change; an unknown key is ignored and a missing one keeps its default, so a project written by either side keeps loading. The paint masks go in as one attribute per layer slot, mirroring paint_color. Older readers ignore attributes they do not know, so a project written here still opens in a build without the feature - it loses the relief, which is all it could have done with it anyway. The layers are restored while the volume is being built rather than after the archive is walked: volumes are constructed only once the whole archive has been read, so a hook placed after the walk ran before any volume existed and restored nothing.	2026-10-05 08:36:22 +02:00