Merge branch 'main' into feat/orcacloud-homepage

resources/shaders/110/texture_displacement_shaded.fs

@@ -72,21 +72,17 @@ varying float weight;
 varying float island_active;
 varying vec2  vertex_uv;
 
-// The cylinder's own frame, built exactly as libslic3r's project_cylindrical() builds it - right
-// handed, so the angle taken from it grows anticlockwise about the axis, which seen from outside the
-// cylinder is to the viewer's right rather than mirrored.
+// The cylinder's own frame, built exactly as libslic3r's project_cylindrical() builds it - including
+// the handedness, which comes out left-handed for an axis of +Z. Copied rather than "corrected", so
+// the preview wraps the texture the same way round as the bake.
 void cylinder_frame(out vec3 up, out vec3 right, out vec3 fwd)
 {
     up = (length(patch_axis) > 1e-8) ? normalize(patch_axis) : vec3(0.0, 0.0, 1.0);
     vec3 arbitrary = (abs(up.z) < 0.9) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
     right = normalize(cross(up, arbitrary));
-    fwd   = normalize(cross(up, right));
+    fwd   = normalize(cross(right, up));
 }
 
-// Which side of a world plane a face is on, with zero counting as the positive side. Not GLSL's own
-// sign(), which returns 0 there and would collapse the coordinate onto a line.
-float box_face_sign(float n) { return n >= 0.0 ? 1.0 : -1.0; }
-
 // The raw, millimetre-valued projection of `p` (a position in the texture frame), before the layer's
 // tiling/rotation/aspect/offset - a term-for-term transcription of libslic3r's project_planar(),
 // project_cylindrical() and project_spherical(). `n` is read by the planar mode only.
@@ -98,7 +94,7 @@ vec2 projection_raw(vec3 p, vec3 n)
         vec3  rel = p - patch_center;
         float x   = dot(rel, right);
         float y   = dot(rel, fwd);
-        return vec2(atan(y, x) * sqrt(x * x + y * y), -dot(rel, up));
+        return vec2(atan(y, x) * sqrt(x * x + y * y), dot(rel, up));
     }
     if (projection_mode == 2) {                 // Spherical: (longitude, latitude) * radius
         vec3  rel    = p - patch_center;
@@ -106,18 +102,10 @@ vec2 projection_raw(vec3 p, vec3 n)
         if (radius < 1e-8)
             return vec2(0.0);
         vec3 dir = rel / radius;
-        return vec2(atan(dir.y, dir.x), -asin(clamp(dir.z, -1.0, 1.0))) * radius;
+        return vec2(atan(dir.y, dir.x), asin(clamp(dir.z, -1.0, 1.0))) * radius;
     }
-    // Triplanar: drop the dominant normal axis. v is negated so the image's first pixel row (v = 0)
-    // sits at the top of the model instead of upside down, and u is flipped on the far side of each
-    // plane so the two faces sharing it are not mirror images. libslic3r's box_plane_yz() and its two
-    // siblings, term for term.
-    vec3 an = abs(n);
-    if (an.x >= an.y && an.x >= an.z)
-        return vec2(box_face_sign(n.x) * p.y, -p.z);
-    if (an.y >= an.x && an.y >= an.z)
-        return vec2(-box_face_sign(n.y) * p.x, -p.z);
-    return vec2(box_face_sign(n.z) * p.x, -p.y);
+    vec3 an = abs(n);                           // Triplanar: drop the dominant normal axis
+    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
 }
 
 // The two surface directions projection_raw()'s u and v run along at `p`, plus how many raw units one
@@ -136,7 +124,7 @@ void projection_axes(vec3 p, vec3 n, out vec3 t, out vec3 b, out vec2 units_per_
         vec2  xy  = vec2(dot(rel, right), dot(rel, fwd));
         float r   = length(xy);
         t = (r > 1e-6) ? (fwd * xy.x - right * xy.y) / r : right; // circumferential: u runs along it
-        b = -up;                                                  // v is the distance *against* the axis
+        b = up;                                                   // v is the distance along the axis
         return;
     }
     if (projection_mode == 2) {
@@ -145,20 +133,20 @@ void projection_axes(vec3 p, vec3 n, out vec3 t, out vec3 b, out vec2 units_per_
         vec3  dir = (r > 1e-8) ? rel / r : vec3(0.0, 0.0, 1.0);
         float c   = length(dir.xy);                               // cos(latitude)
         t = (c > 1e-6) ? vec3(-dir.y, dir.x, 0.0) / c : vec3(1.0, 0.0, 0.0);
-        b = -cross(dir, t);                                       // v grows away from the pole, unit length
+        b = cross(dir, t);                                        // increasing latitude, unit length
         units_per_mm = vec2(1.0 / max(c, 1e-3), 1.0);
         return;
     }
-    vec3 an = abs(n);                          // the same signed basis projection_raw() uses
-    if (an.x >= an.y && an.x >= an.z) {        // planar = (+-y, -z)
-        t = vec3(0.0, box_face_sign(n.x), 0.0);
-        b = vec3(0.0, 0.0, -1.0);
-    } else if (an.y >= an.x && an.y >= an.z) { // planar = (+-x, -z)
-        t = vec3(-box_face_sign(n.y), 0.0, 0.0);
-        b = vec3(0.0, 0.0, -1.0);
-    } else {                                   // planar = (+-x, -y)
-        t = vec3(box_face_sign(n.z), 0.0, 0.0);
-        b = vec3(0.0, -1.0, 0.0);
+    vec3 an = abs(n);
+    if (an.x >= an.y && an.x >= an.z) {        // planar = p.yz
+        t = vec3(0.0, 1.0, 0.0);
+        b = vec3(0.0, 0.0, 1.0);
+    } else if (an.y >= an.x && an.y >= an.z) { // planar = p.xz
+        t = vec3(1.0, 0.0, 0.0);
+        b = vec3(0.0, 0.0, 1.0);
+    } else {                                   // planar = p.xy
+        t = vec3(1.0, 0.0, 0.0);
+        b = vec3(0.0, 1.0, 0.0);
     }
 }
 

resources/shaders/110/texture_displacement_uvcheck.fs

@@ -36,20 +36,14 @@ varying vec4  world_pos;
 varying float distortion;
 varying vec2  vertex_uv;
 
-// Right handed (up x right), like libslic3r's project_cylindrical(), so the angle taken from it grows
-// anticlockwise about the axis - to the viewer's right when seen from outside the cylinder.
 void cylinder_frame(out vec3 up, out vec3 right, out vec3 fwd)
 {
     up = (length(patch_axis) > 1e-8) ? normalize(patch_axis) : vec3(0.0, 0.0, 1.0);
     vec3 arbitrary = (abs(up.z) < 0.9) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
     right = normalize(cross(up, arbitrary));
-    fwd   = normalize(cross(up, right));
+    fwd   = normalize(cross(right, up));
 }
 
-// Which side of a world plane a face is on, with zero counting as the positive side. Not GLSL's own
-// sign(), which returns 0 there and would collapse the coordinate onto a line.
-float box_face_sign(float n) { return n >= 0.0 ? 1.0 : -1.0; }
-
 // Term for term libslic3r's project_planar() / project_cylindrical() / project_spherical(), in mm.
 vec2 projection_raw(vec3 p, vec3 n)
 {
@@ -59,7 +53,7 @@ vec2 projection_raw(vec3 p, vec3 n)
         vec3  rel = p - patch_center;
         float x   = dot(rel, right);
         float y   = dot(rel, fwd);
-        return vec2(atan(y, x) * sqrt(x * x + y * y), -dot(rel, up));
+        return vec2(atan(y, x) * sqrt(x * x + y * y), dot(rel, up));
     }
     if (projection_mode == 2) {
         vec3  rel    = p - patch_center;
@@ -67,16 +61,10 @@ vec2 projection_raw(vec3 p, vec3 n)
         if (radius < 1e-8)
             return vec2(0.0);
         vec3 dir = rel / radius;
-        return vec2(atan(dir.y, dir.x), -asin(clamp(dir.z, -1.0, 1.0))) * radius;
+        return vec2(atan(dir.y, dir.x), asin(clamp(dir.z, -1.0, 1.0))) * radius;
     }
-    // v negated so the image's first pixel row sits at the top of the model, u flipped on the far side
-    // of each plane so the two faces sharing it are not mirror images - see libslic3r's box_plane_yz().
     vec3 an = abs(n);
-    if (an.x >= an.y && an.x >= an.z)
-        return vec2(box_face_sign(n.x) * p.y, -p.z);
-    if (an.y >= an.x && an.y >= an.z)
-        return vec2(-box_face_sign(n.y) * p.x, -p.z);
-    return vec2(box_face_sign(n.z) * p.x, -p.y);
+    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
 }
 
 vec2 project_uv(vec3 p, vec3 n)

resources/shaders/140/texture_displacement_shaded.fs

@@ -138,21 +138,17 @@ in vec2  vertex_uv;
 
 out vec4 out_color;
 
-// The cylinder's own frame, built exactly as libslic3r's project_cylindrical() builds it - right
-// handed, so the angle taken from it grows anticlockwise about the axis, which seen from outside the
-// cylinder is to the viewer's right rather than mirrored.
+// The cylinder's own frame, built exactly as libslic3r's project_cylindrical() builds it - including
+// the handedness, which comes out left-handed for an axis of +Z. Copied rather than "corrected", so
+// the preview wraps the texture the same way round as the bake.
 void cylinder_frame(out vec3 up, out vec3 right, out vec3 fwd)
 {
     up = (length(patch_axis) > 1e-8) ? normalize(patch_axis) : vec3(0.0, 0.0, 1.0);
     vec3 arbitrary = (abs(up.z) < 0.9) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
     right = normalize(cross(up, arbitrary));
-    fwd   = normalize(cross(up, right));
+    fwd   = normalize(cross(right, up));
 }
 
-// Which side of a world plane a face is on, with zero counting as the positive side. Not GLSL's own
-// sign(), which returns 0 there and would collapse the coordinate onto a line.
-float box_face_sign(float n) { return n >= 0.0 ? 1.0 : -1.0; }
-
 // The raw, millimetre-valued projection of `p` (a position in the texture frame), before the layer's
 // tiling/rotation/aspect/offset - a term-for-term transcription of libslic3r's project_planar(),
 // project_cylindrical() and project_spherical(). `n` is read by the planar mode only.
@@ -164,7 +160,7 @@ vec2 projection_raw(vec3 p, vec3 n)
         vec3  rel = p - patch_center;
         float x   = dot(rel, right);
         float y   = dot(rel, fwd);
-        return vec2(atan(y, x) * sqrt(x * x + y * y), -dot(rel, up));
+        return vec2(atan(y, x) * sqrt(x * x + y * y), dot(rel, up));
     }
     if (projection_mode == 2) {                 // Spherical: (longitude, latitude) * radius
         vec3  rel    = p - patch_center;
@@ -172,18 +168,10 @@ vec2 projection_raw(vec3 p, vec3 n)
         if (radius < 1e-8)
             return vec2(0.0);
         vec3 dir = rel / radius;
-        return vec2(atan(dir.y, dir.x), -asin(clamp(dir.z, -1.0, 1.0))) * radius;
+        return vec2(atan(dir.y, dir.x), asin(clamp(dir.z, -1.0, 1.0))) * radius;
     }
-    // Triplanar: drop the dominant normal axis. v is negated so the image's first pixel row (v = 0)
-    // sits at the top of the model instead of upside down, and u is flipped on the far side of each
-    // plane so the two faces sharing it are not mirror images. libslic3r's box_plane_yz() and its two
-    // siblings, term for term.
-    vec3 an = abs(n);
-    if (an.x >= an.y && an.x >= an.z)
-        return vec2(box_face_sign(n.x) * p.y, -p.z);
-    if (an.y >= an.x && an.y >= an.z)
-        return vec2(-box_face_sign(n.y) * p.x, -p.z);
-    return vec2(box_face_sign(n.z) * p.x, -p.y);
+    vec3 an = abs(n);                           // Triplanar: drop the dominant normal axis
+    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
 }
 
 // The two surface directions projection_raw()'s u and v run along at `p`, plus how many raw units one
@@ -202,7 +190,7 @@ void projection_axes(vec3 p, vec3 n, out vec3 t, out vec3 b, out vec2 units_per_
         vec2  xy  = vec2(dot(rel, right), dot(rel, fwd));
         float r   = length(xy);
         t = (r > 1e-6) ? (fwd * xy.x - right * xy.y) / r : right; // circumferential: u runs along it
-        b = -up;                                                  // v is the distance *against* the axis
+        b = up;                                                   // v is the distance along the axis
         return;
     }
     if (projection_mode == 2) {
@@ -211,20 +199,20 @@ void projection_axes(vec3 p, vec3 n, out vec3 t, out vec3 b, out vec2 units_per_
         vec3  dir = (r > 1e-8) ? rel / r : vec3(0.0, 0.0, 1.0);
         float c   = length(dir.xy);                               // cos(latitude)
         t = (c > 1e-6) ? vec3(-dir.y, dir.x, 0.0) / c : vec3(1.0, 0.0, 0.0);
-        b = -cross(dir, t);                                       // v grows away from the pole, unit length
+        b = cross(dir, t);                                        // increasing latitude, unit length
         units_per_mm = vec2(1.0 / max(c, 1e-3), 1.0);
         return;
     }
-    vec3 an = abs(n);                          // the same signed basis projection_raw() uses
-    if (an.x >= an.y && an.x >= an.z) {        // planar = (+-y, -z)
-        t = vec3(0.0, box_face_sign(n.x), 0.0);
-        b = vec3(0.0, 0.0, -1.0);
-    } else if (an.y >= an.x && an.y >= an.z) { // planar = (+-x, -z)
-        t = vec3(-box_face_sign(n.y), 0.0, 0.0);
-        b = vec3(0.0, 0.0, -1.0);
-    } else {                                   // planar = (+-x, -y)
-        t = vec3(box_face_sign(n.z), 0.0, 0.0);
-        b = vec3(0.0, -1.0, 0.0);
+    vec3 an = abs(n);
+    if (an.x >= an.y && an.x >= an.z) {        // planar = p.yz
+        t = vec3(0.0, 1.0, 0.0);
+        b = vec3(0.0, 0.0, 1.0);
+    } else if (an.y >= an.x && an.y >= an.z) { // planar = p.xz
+        t = vec3(1.0, 0.0, 0.0);
+        b = vec3(0.0, 0.0, 1.0);
+    } else {                                   // planar = p.xy
+        t = vec3(1.0, 0.0, 0.0);
+        b = vec3(0.0, 1.0, 0.0);
     }
 }
 

resources/shaders/140/texture_displacement_uvcheck.fs

@@ -47,20 +47,14 @@ in vec2  vertex_uv;
 
 out vec4 out_color;
 
-// Right handed (up x right), like libslic3r's project_cylindrical(), so the angle taken from it grows
-// anticlockwise about the axis - to the viewer's right when seen from outside the cylinder.
 void cylinder_frame(out vec3 up, out vec3 right, out vec3 fwd)
 {
     up = (length(patch_axis) > 1e-8) ? normalize(patch_axis) : vec3(0.0, 0.0, 1.0);
     vec3 arbitrary = (abs(up.z) < 0.9) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
     right = normalize(cross(up, arbitrary));
-    fwd   = normalize(cross(up, right));
+    fwd   = normalize(cross(right, up));
 }
 
-// Which side of a world plane a face is on, with zero counting as the positive side. Not GLSL's own
-// sign(), which returns 0 there and would collapse the coordinate onto a line.
-float box_face_sign(float n) { return n >= 0.0 ? 1.0 : -1.0; }
-
 // Term for term libslic3r's project_planar() / project_cylindrical() / project_spherical(), in mm.
 vec2 projection_raw(vec3 p, vec3 n)
 {
@@ -70,7 +64,7 @@ vec2 projection_raw(vec3 p, vec3 n)
         vec3  rel = p - patch_center;
         float x   = dot(rel, right);
         float y   = dot(rel, fwd);
-        return vec2(atan(y, x) * sqrt(x * x + y * y), -dot(rel, up));
+        return vec2(atan(y, x) * sqrt(x * x + y * y), dot(rel, up));
     }
     if (projection_mode == 2) {
         vec3  rel    = p - patch_center;
@@ -78,16 +72,10 @@ vec2 projection_raw(vec3 p, vec3 n)
         if (radius < 1e-8)
             return vec2(0.0);
         vec3 dir = rel / radius;
-        return vec2(atan(dir.y, dir.x), -asin(clamp(dir.z, -1.0, 1.0))) * radius;
+        return vec2(atan(dir.y, dir.x), asin(clamp(dir.z, -1.0, 1.0))) * radius;
     }
-    // v negated so the image's first pixel row sits at the top of the model, u flipped on the far side
-    // of each plane so the two faces sharing it are not mirror images - see libslic3r's box_plane_yz().
     vec3 an = abs(n);
-    if (an.x >= an.y && an.x >= an.z)
-        return vec2(box_face_sign(n.x) * p.y, -p.z);
-    if (an.y >= an.x && an.y >= an.z)
-        return vec2(-box_face_sign(n.y) * p.x, -p.z);
-    return vec2(box_face_sign(n.z) * p.x, -p.y);
+    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
 }
 
 vec2 project_uv(vec3 p, vec3 n)

resources/web/homepage/css/home.css

@@ -548,6 +548,20 @@ body
 	overflow-y:auto;
 }
 
+/*---- Cloud mode: OrcaCloud is a native pane to the right of the app panel, so this page
+      is reduced to its left nav column (the class is toggled by SetCloudMode in js/home.js). ----*/
+body.cloud-mode #RightBoard
+{
+	display: none;
+}
+
+body.cloud-mode #LeftBoard
+{
+	/*---- 262px of column plus its 1px separator is the width the app gives the nav. ----*/
+	height: 100%;
+	overflow-y: auto;
+}
+
 #ContentBoard
 {
 	overflow-y:auto;

resources/web/homepage/index.html

@@ -90,7 +90,7 @@
 			<div class="BtnIcon "><img class="LeftIcon" src="img/i2.png" /></div>
 			<div data-i18n="recent">Recent</div> 
 		</div>
-	    <div class="BtnItem BtnShortcut" onClick="OpenUrlInLocalBrowser('https://cloud.orcaslicer.com')">
+	    <div class="BtnItem BtnShortcut" onClick="GotoCloud()">
 			<div class="BtnIcon "><img class="ShortcutBrandIcon" src="../image/logo.png" /></div>
 			<div class="ShortcutTextRow">
 				<div>OrcaCloud</div>

resources/web/homepage/js/home.js

@@ -145,8 +145,36 @@ function HandleStudio( pVal )
   }
 }
 
+/*---- OrcaCloud opens as a native pane beside this page, so the shell only switches its
+      own cloud-mode state and asks the app to show or hide that pane (WebViewPanel::set_cloud_mode). ----*/
+var m_CloudMode=false;
+
+function SetCloudMode( bOn )
+{
+	if( m_CloudMode==bOn )
+		return;
+
+	m_CloudMode=bOn;
+	$("body").toggleClass("cloud-mode", bOn);
+}
+
+function GotoCloud()
+{
+	$(".BtnItem").removeClass("BtnItemSelected");
+	$(".BtnShortcut").addClass("BtnItemSelected");
+	SetCloudMode(true);
+	SendSimpleCommand("homepage_open_cloud");
+}
+
 function GotoMenu( strMenu )
 {
+	/*---- Any board in the right region means leaving the cloud pane. ----*/
+	if( m_CloudMode )
+	{
+		SetCloudMode(false);
+		SendSimpleCommand("homepage_close_cloud");
+	}
+
 	let MenuList=$(".BtnItem");
 	let nAll=MenuList.length;
 	

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -2602,13 +2602,12 @@ void GCodeProcessorResult::reset() {
     //BBS: add mutex for protection of gcode result
     lock();
 
-    // moves and lines_ends grow with the print: free them, as no reset result reuses the capacity.
-    clear_and_shrink(moves);
+    moves.clear();
     plate_mass = {};
     object_masses.clear();
     body_masses.clear();
     support_masses.clear();
-    clear_and_shrink(lines_ends);
+    lines_ends.clear();
     printable_area = Pointfs();
     //BBS: add bed exclude area
     bed_exclude_area = Pointfs();

src/libslic3r/TextureDisplacement.cpp

@@ -158,33 +158,12 @@ struct SmoothedTextureCache
     {
         std::weak_ptr<const std::vector<unsigned char>> source;
         float                                           smoothing = 0.f;
-        // Part of the key, not of the result: smoothing is applied *after* the panel's adjustments, so a
-        // blur computed over one set of adjustments is not the blur another set would give.
-        TextureAdjustments                              adjust;
         DecodedHeightTexture                            texture;
     };
     std::mutex                                   mutex;
     std::unordered_map<const void *, Entry>      entries;
 };
 SmoothedTextureCache g_smoothed_texture_cache;
-
-// The adjusted copy, cached between the raw decode and the smoothed one. Needed for the same reason the
-// smoothed cache is: while a slider in the image-adjustment panel moves, the thumbnail, the shaded
-// preview's height and colour textures, the UV editor backdrop and the displacement preview job all ask
-// for the same (image, adjustments) pair within one frame, and each of them running a full-size resample
-// of its own is what would make the panel unusable on a large texture.
-struct AdjustedTextureCache
-{
-    struct Entry
-    {
-        std::weak_ptr<const std::vector<unsigned char>> source;
-        TextureAdjustments                              adjust;
-        DecodedHeightTexture                            texture;
-    };
-    std::mutex                              mutex;
-    std::unordered_map<const void *, Entry> entries;
-};
-AdjustedTextureCache g_adjusted_texture_cache;
 } // namespace
 
 namespace {
@@ -360,34 +339,6 @@ DecodedHeightTexture decode_height_texture(const TextureDisplacementLayer &layer
         entries[key] = { std::weak_ptr<const std::vector<unsigned char>>(layer.image_data), result };
     }
 
-    // The image-adjustment panel's live edits, on top of the decode and before the smoothing. Before,
-    // because `preview_adjust` is an edit to the image while `smoothing` is a live low-pass over whatever
-    // the image is - the same order the panel presents them in, and the same order a commit bakes in.
-    //
-    // Nothing applies here once the panel has closed: it resets preview_adjust to identity, and identity
-    // is a no-op that costs one comparison.
-    if (!layer.preview_adjust.identity()) {
-        bool have_adjusted = false;
-        {
-            std::lock_guard<std::mutex> lock(g_adjusted_texture_cache.mutex);
-            auto it = g_adjusted_texture_cache.entries.find(key);
-            if (it != g_adjusted_texture_cache.entries.end() && it->second.adjust == layer.preview_adjust &&
-                it->second.source.lock() == layer.image_data) {
-                result        = it->second.texture;
-                have_adjusted = true;
-            }
-        }
-        if (!have_adjusted) {
-            result = apply_texture_adjustments(result, layer.preview_adjust);
-            std::lock_guard<std::mutex> lock(g_adjusted_texture_cache.mutex);
-            auto &entries = g_adjusted_texture_cache.entries;
-            for (auto it = entries.begin(); it != entries.end();)
-                it = it->second.source.expired() ? entries.erase(it) : std::next(it);
-            entries[key] = { std::weak_ptr<const std::vector<unsigned char>>(layer.image_data),
-                             layer.preview_adjust, result };
-        }
-    }
-
     // Smoothing radius scales with the texture so the same slider value blurs the same *fraction* of
     // the image whatever resolution it came in at, and stays continuous in the slider - see
     // smooth_height_pixels(). The cap is a cost limit, not part of the mapping: the blur is
@@ -398,7 +349,7 @@ DecodedHeightTexture decode_height_texture(const TextureDisplacementLayer &layer
             std::lock_guard<std::mutex> lock(g_smoothed_texture_cache.mutex);
             auto it = g_smoothed_texture_cache.entries.find(key);
             if (it != g_smoothed_texture_cache.entries.end() && it->second.smoothing == layer.smoothing &&
-                it->second.adjust == layer.preview_adjust && it->second.source.lock() == layer.image_data)
+                it->second.source.lock() == layer.image_data)
                 return it->second.texture;
         }
         const float span   = 0.05f * float(std::min(result.width, result.height));
@@ -422,70 +373,12 @@ DecodedHeightTexture decode_height_texture(const TextureDisplacementLayer &layer
         auto &entries = g_smoothed_texture_cache.entries;
         for (auto it = entries.begin(); it != entries.end();)
             it = it->second.source.expired() ? entries.erase(it) : std::next(it);
-        entries[key] = { std::weak_ptr<const std::vector<unsigned char>>(layer.image_data), layer.smoothing,
-                         layer.preview_adjust, result };
+        entries[key] = { std::weak_ptr<const std::vector<unsigned char>>(layer.image_data), layer.smoothing, result };
     }
     return result;
 }
 
 namespace {
-// Fraction of the short side that TextureAdjustments::blur == 1 blurs over, and the cost cap on it.
-// Deliberately the same pair decode_height_texture() uses for the Smoothing slider - see
-// adjustment_blur_radius().
-constexpr float SOURCE_BLUR_SPAN   = 0.05f;
-constexpr float SOURCE_BLUR_MAX_PX = 48.f;
-
-// Radius of the unsharp mask's blurred reference, in texels. Small and only mildly resolution-dependent:
-// a sharpen is meant to act on the finest detail the image holds, so its radius tracks the texel grid
-// rather than the picture's size. 1024x1024 gives ~2 texels, the usual photo-editor default.
-float unsharp_radius(int width, int height)
-{
-    return std::max(1.f, 0.002f * float(std::min(width, height)));
-}
-
-// Brightness as a *lift* toward white (or toward black) rather than an additive offset: positive b maps
-// v to v + b*(1 - v), negative to v*(1 + b). Both reach the endpoint exactly at |b| == 1 while staying
-// monotonic and non-clipping in between, which an additive shift does not - it drives a whole region to
-// a flat 255 and, because this image is also the height map, that region bakes as flat relief rather
-// than as bright relief. Keeping the curve injective keeps the detail in it.
-float apply_brightness(float v, float b)
-{
-    return b >= 0.f ? v + b * (1.f - v) : v * (1.f + b);
-}
-
-// Contrast about the 0.5 pivot. Gain is 1/(1-c) going up (c == 1 would be an infinite-slope threshold, so
-// the caller's clamp keeps it finite) and 1+c going down, reaching a flat mid-grey at c == -1.
-float apply_contrast(float v, float c)
-{
-    const float gain = c >= 0.f ? 1.f / std::max(1e-3f, 1.f - c) : 1.f + c;
-    return (v - 0.5f) * gain + 0.5f;
-}
-
-// Blur then sharpen one 8-bit channel in place. Shared by the grayscale path and by each of a colour
-// image's three channels, so every channel gets the identical spatial treatment and a colour image's
-// hue cannot shift just because its channels were filtered differently.
-void adjust_channel_spatial(std::vector<uint8_t> &channel, int width, int height, float blur, float sharpness)
-{
-    if (blur > 0.f)
-        smooth_height_pixels(channel, width, height, adjustment_blur_radius(blur, width, height));
-
-    if (sharpness <= 0.f)
-        return;
-
-    // Unsharp mask: push each texel away from its local average by `amount` times the difference. The
-    // blurred reference is a copy, so the sharpen reads the un-sharpened neighbourhood everywhere rather
-    // than its own partly-written output.
-    std::vector<uint8_t> base = channel;
-    smooth_height_pixels(base, width, height, unsharp_radius(width, height));
-    const float amount = 1.5f * std::clamp(sharpness, 0.f, 1.f);
-    tbb::parallel_for(tbb::blocked_range<size_t>(0, channel.size()), [&](const tbb::blocked_range<size_t> &r) {
-        for (size_t i = r.begin(); i < r.end(); ++i) {
-            const float v = float(channel[i]) + amount * (float(channel[i]) - float(base[i]));
-            channel[i]    = uint8_t(std::lround(std::clamp(v, 0.f, 255.f)));
-        }
-    });
-}
-
 struct TextureDetailCache
 {
     std::mutex mutex;
@@ -494,150 +387,6 @@ struct TextureDetailCache
 TextureDetailCache g_texture_detail_cache;
 } // namespace
 
-float adjustment_blur_radius(float blur, int width, int height)
-{
-    if (blur <= 0.f || width <= 0 || height <= 0)
-        return 0.f;
-    const float span = SOURCE_BLUR_SPAN * float(std::min(width, height));
-    return std::clamp(blur, 0.f, 1.f) * std::min(span, SOURCE_BLUR_MAX_PX);
-}
-
-DecodedHeightTexture downscale_height_texture(const DecodedHeightTexture &src, int max_px)
-{
-    if (src.empty() || max_px <= 0 || (src.width <= max_px && src.height <= max_px))
-        return src;
-
-    const int  scale = std::max(1, (std::max(src.width, src.height) + max_px - 1) / max_px);
-    const int  w     = std::max(1, src.width / scale);
-    const int  h     = std::max(1, src.height / scale);
-    const bool color = src.has_color();
-
-    DecodedHeightTexture out;
-    out.width  = w;
-    out.height = h;
-    out.pixels.resize(size_t(w) * size_t(h));
-    if (color)
-        out.rgb.resize(size_t(w) * size_t(h) * 3);
-
-    tbb::parallel_for(tbb::blocked_range<int>(0, h), [&](const tbb::blocked_range<int> &r) {
-        for (int y = r.begin(); y < r.end(); ++y)
-            for (int x = 0; x < w; ++x) {
-                // The source block this destination texel covers. The max() keeps the block non-empty
-                // when rounding would otherwise collapse it.
-                const int x0 = x * src.width / w, x1 = std::max(x0 + 1, (x + 1) * src.width / w);
-                const int y0 = y * src.height / h, y1 = std::max(y0 + 1, (y + 1) * src.height / h);
-                uint32_t  sum_h = 0, sum_c[3] = { 0, 0, 0 }, n = 0;
-                for (int sy = y0; sy < y1 && sy < src.height; ++sy)
-                    for (int sx = x0; sx < x1 && sx < src.width; ++sx, ++n) {
-                        const size_t si = size_t(sy) * size_t(src.width) + size_t(sx);
-                        sum_h += src.pixels[si];
-                        if (color)
-                            for (int c = 0; c < 3; ++c)
-                                sum_c[c] += src.rgb[si * 3 + size_t(c)];
-                    }
-                const size_t di = size_t(y) * size_t(w) + size_t(x);
-                out.pixels[di]  = n > 0 ? uint8_t(sum_h / n) : 0;
-                if (color)
-                    for (int c = 0; c < 3; ++c)
-                        out.rgb[di * 3 + size_t(c)] = n > 0 ? uint8_t(sum_c[c] / n) : 0;
-            }
-    });
-    return out;
-}
-
-DecodedHeightTexture apply_texture_adjustments(const DecodedHeightTexture &src, const TextureAdjustments &adj)
-{
-    DecodedHeightTexture out = src;
-    if (src.empty() || adj.identity())
-        return out;
-
-    const int    w = out.width;
-    const int    h = out.height;
-    const size_t n = size_t(w) * size_t(h);
-
-    const float brightness = std::clamp(adj.brightness, -1.f, 1.f);
-    // Short of 1, so apply_contrast()'s gain stays finite; at this value it is already a 1000x slope,
-    // i.e. a threshold in all but name.
-    const float contrast   = std::clamp(adj.contrast, -1.f, 0.999f);
-    const float blur       = std::clamp(adj.blur, 0.f, 1.f);
-    const float sharpness  = std::clamp(adj.sharpness, 0.f, 1.f);
-
-    // The tonal pass: a 256-entry lookup table, because brightness and contrast are the same scalar
-    // curve for every texel and every channel. Building it once beats evaluating two curves a few
-    // million times, and it is what keeps this pass off the panel's critical path.
-    std::array<uint8_t, 256> tone{};
-    for (int i = 0; i < 256; ++i) {
-        float v = float(i) / 255.f;
-        v       = apply_brightness(v, brightness);
-        v       = apply_contrast(v, contrast);
-        tone[size_t(i)] = uint8_t(std::lround(std::clamp(v, 0.f, 1.f) * 255.f));
-    }
-
-    if (!out.has_color()) {
-        // Grayscale: one channel, and hue has nothing to turn.
-        tbb::parallel_for(tbb::blocked_range<size_t>(0, n), [&](const tbb::blocked_range<size_t> &r) {
-            for (size_t i = r.begin(); i < r.end(); ++i)
-                out.pixels[i] = tone[out.pixels[i]];
-        });
-        adjust_channel_spatial(out.pixels, w, h, blur, sharpness);
-        return out;
-    }
-
-    // Colour: tone each channel through the same table, then rotate the hue about the luminance axis.
-    //
-    // The rotation is feColorMatrix's hueRotate matrix (SVG filters), which holds Rec.709 luma fixed.
-    // The height below is taken with decode_height_texture()'s Rec.601 coefficients instead, so a hue
-    // turn is not perfectly height-neutral - a few levels at full saturation. Reconciling the two would
-    // mean a different rotation than every other tool's, which is the worse trade: the user is watching
-    // the colour, and the height follows the colour by construction either way.
-    const float  theta = adj.hue_deg * float(M_PI) / 180.f;
-    const float  c     = std::cos(theta);
-    const float  s     = std::sin(theta);
-    const float  m[9]  = {
-        0.213f + c * 0.787f - s * 0.213f, 0.715f - c * 0.715f - s * 0.715f, 0.072f - c * 0.072f + s * 0.928f,
-        0.213f - c * 0.213f + s * 0.143f, 0.715f + c * 0.285f + s * 0.140f, 0.072f - c * 0.072f - s * 0.283f,
-        0.213f - c * 0.213f - s * 0.787f, 0.715f - c * 0.715f + s * 0.715f, 0.072f + c * 0.928f + s * 0.072f,
-    };
-    const bool turn_hue = adj.hue_deg != 0.f;
-
-    tbb::parallel_for(tbb::blocked_range<size_t>(0, n), [&](const tbb::blocked_range<size_t> &r) {
-        for (size_t i = r.begin(); i < r.end(); ++i) {
-            const float rr = float(tone[out.rgb[i * 3]]);
-            const float gg = float(tone[out.rgb[i * 3 + 1]]);
-            const float bb = float(tone[out.rgb[i * 3 + 2]]);
-            const float nr = turn_hue ? m[0] * rr + m[1] * gg + m[2] * bb : rr;
-            const float ng = turn_hue ? m[3] * rr + m[4] * gg + m[5] * bb : gg;
-            const float nb = turn_hue ? m[6] * rr + m[7] * gg + m[8] * bb : bb;
-            out.rgb[i * 3]     = uint8_t(std::lround(std::clamp(nr, 0.f, 255.f)));
-            out.rgb[i * 3 + 1] = uint8_t(std::lround(std::clamp(ng, 0.f, 255.f)));
-            out.rgb[i * 3 + 2] = uint8_t(std::lround(std::clamp(nb, 0.f, 255.f)));
-        }
-    });
-
-    // The spatial pass wants one channel at a time (smooth_height_pixels() is a single-channel blur, and
-    // reusing it is what keeps this consistent with Smoothing), so de-interleave, filter, re-interleave.
-    if (blur > 0.f || sharpness > 0.f) {
-        std::vector<uint8_t> channel(n);
-        for (int ch = 0; ch < 3; ++ch) {
-            for (size_t i = 0; i < n; ++i)
-                channel[i] = out.rgb[i * 3 + size_t(ch)];
-            adjust_channel_spatial(channel, w, h, blur, sharpness);
-            for (size_t i = 0; i < n; ++i)
-                out.rgb[i * 3 + size_t(ch)] = channel[i];
-        }
-    }
-
-    // Height is the luminance of the colour that came out, not the toned luminance of the colour that
-    // went in: the two differ once hue rotation or a per-channel clamp has moved the channels around,
-    // and a height that disagrees with the colour it is stored next to is the bug this avoids.
-    tbb::parallel_for(tbb::blocked_range<size_t>(0, n), [&](const tbb::blocked_range<size_t> &r) {
-        for (size_t i = r.begin(); i < r.end(); ++i)
-            out.pixels[i] = uint8_t(std::lround(0.299 * out.rgb[i * 3] + 0.587 * out.rgb[i * 3 + 1] +
-                                                0.114 * out.rgb[i * 3 + 2]));
-    });
-    return out;
-}
-
 TextureDetail analyze_texture_detail(const TextureDisplacementLayer &layer)
 {
     TextureDetail out;
@@ -743,57 +492,6 @@ V2Resolution recommend_v2_resolution(const indexed_triangle_set
     return out;
 }
 
-namespace {
-// Which side of a world plane a face is on, with an exactly zero component counted as the positive
-// side. The tie never shows: a normal component of zero carries zero tri-planar blend weight (see
-// triplanar_weights()), so the plane it orients contributes nothing at that point.
-inline float box_face_sign(float n) { return n >= 0.f ? 1.f : -1.f; }
-
-// The box projection's 2D basis for one of the three world planes, oriented the way a viewer
-// standing outside the model sees that face.
-//
-// v runs *down* the image, because that is what v means to the sampler: v = 0 is the texture's first
-// pixel row, i.e. its top (DecodedHeightTexture::sample(); the UV editor negates Y on screen for the
-// same reason, see UVEditorCanvas::render()). So v = -z on the four upright planes and v = -y on the
-// horizontal one, which is what puts the top of an image at the top of the model rather than
-// upside down.
-//
-// u then has to depend on which *side* of the plane the face is on, or one of the two faces sharing
-// a plane comes out left-right mirrored: with a single u per plane, a portrait image reads upright on
-// +X and 180 degrees round on -X. Fixing that is the sign below, chosen so that u x v == -normal,
-// i.e. (right, down, into the surface) is right-handed for a viewer outside:
-//
-//   face  u     v       face  u     v       face  u     v
-//   +X    +y    -z      +Y    -x    -z      +Z    +x    -y
-//   -X    -y    -z      -Y    +x    -z      -Z    -x    -y
-//
-// The sign flips where its own normal component crosses zero, and the blend weight of the plane it
-// belongs to is exactly zero there, so the blended tri-planar sum stays continuous across the flip -
-// it is not a return of the hard axis switch described on TextureProjectionMethod::Triplanar.
-inline Vec2f box_plane_yz(const Vec3f &p, float nx) { return Vec2f(box_face_sign(nx) * p.y(), -p.z()); }
-inline Vec2f box_plane_xz(const Vec3f &p, float ny) { return Vec2f(-box_face_sign(ny) * p.x(), -p.z()); }
-inline Vec2f box_plane_xy(const Vec3f &p, float nz) { return Vec2f(box_face_sign(nz) * p.x(), -p.y()); }
-} // namespace
-
-void box_projection_axes(const Vec3f &normal, Vec3f &u_axis, Vec3f &v_axis)
-{
-    // The same table as box_plane_yz()/box_plane_xz()/box_plane_xy(), handed out as a pair of world
-    // directions for the plane the normal is closest to. Two shapes of one table, because the bake's
-    // hot path wants the closed form and the GUI wants the axes; the test suite checks them against
-    // each other so they cannot drift apart.
-    const Vec3f n = normal.cwiseAbs();
-    if (n.x() >= n.y() && n.x() >= n.z()) {
-        u_axis = box_face_sign(normal.x()) * Vec3f::UnitY();
-        v_axis = -Vec3f::UnitZ();
-    } else if (n.y() >= n.x() && n.y() >= n.z()) {
-        u_axis = -box_face_sign(normal.y()) * Vec3f::UnitX();
-        v_axis = -Vec3f::UnitZ();
-    } else {
-        u_axis = box_face_sign(normal.z()) * Vec3f::UnitX();
-        v_axis = -Vec3f::UnitY();
-    }
-}
-
 Vec2f project_planar(const Vec3f &position, const Vec3f &normal)
 {
     // Planar-project onto the two axes orthogonal to the dominant component of `normal`. Called
@@ -804,26 +502,23 @@ Vec2f project_planar(const Vec3f &position, const Vec3f &normal)
     // other face in the same patch - exactly the bug an earlier version of this feature had).
     const Vec3f n = normal.cwiseAbs();
     if (n.x() >= n.y() && n.x() >= n.z())
-        return box_plane_yz(position, normal.x());
+        return Vec2f(position.y(), position.z());
     if (n.y() >= n.x() && n.y() >= n.z())
-        return box_plane_xz(position, normal.y());
-    return box_plane_xy(position, normal.z());
+        return Vec2f(position.x(), position.z());
+    return Vec2f(position.x(), position.y());
 }
 
 namespace {
 // Wrapped around patch_axis, centered at patch_center. u is the arc length (mm) around the axis at
-// this point's own radius, v is the distance along the axis, measured *against* it - a reasonable
-// approximation for roughly cylindrical selections, not an exact fit for arbitrary geometry.
+// this point's own radius, v is the signed distance along the axis - a reasonable approximation
+// for roughly cylindrical selections, not an exact fit for arbitrary geometry.
 Vec2f project_cylindrical(const Vec3f &position, const Vec3f &patch_center, const Vec3f &patch_axis)
 {
     Vec3f up = patch_axis;
     up       = (up.norm() > 1e-8f) ? Vec3f(up.normalized()) : Vec3f::UnitZ();
     const Vec3f arbitrary = (std::abs(up.dot(Vec3f::UnitZ())) < 0.9f) ? Vec3f::UnitZ() : Vec3f::UnitX();
     const Vec3f right     = Vec3f(up.cross(arbitrary).normalized());
-    // up x right, not right x up: that makes (right, fwd, up) right-handed, so the angle below grows
-    // anticlockwise about the axis - which, seen from outside the cylinder, is to the viewer's right.
-    // The other way round the texture wraps on mirrored, as if seen through the model from behind.
-    const Vec3f fwd       = Vec3f(up.cross(right).normalized());
+    const Vec3f fwd       = Vec3f(right.cross(up).normalized());
 
     const Vec3f rel        = position - patch_center;
     const float along_axis = rel.dot(up);
@@ -832,9 +527,7 @@ Vec2f project_cylindrical(const Vec3f &position, const Vec3f &patch_center, cons
     const float radius     = std::sqrt(x * x + y * y);
     const float angle      = std::atan2(y, x);
 
-    // Negated, like every other projection's v: v = 0 is the texture's top row, so v has to grow
-    // *down* the axis for the top of the image to sit at the top of the model.
-    return Vec2f(angle * radius, -along_axis);
+    return Vec2f(angle * radius, along_axis);
 }
 
 // Longitude/latitude around patch_center. u/v are scaled by this point's own distance from the
@@ -850,9 +543,7 @@ Vec2f project_spherical(const Vec3f &position, const Vec3f &patch_center)
     const Vec3f dir       = rel / radius;
     const float longitude = std::atan2(dir.y(), dir.x());
     const float latitude  = std::asin(std::clamp(dir.z(), -1.f, 1.f));
-    // Longitude already grows to the right as seen from outside; latitude grows toward the north
-    // pole, so it is negated to put the image's top row (v = 0) at the top of the model.
-    return Vec2f(longitude, -latitude) * radius;
+    return Vec2f(longitude, latitude) * radius;
 }
 
 // CGAL's LSCM parameterizer expects a clean mesh with no isolated (unreferenced) vertices - but
@@ -1147,26 +838,9 @@ std::vector<int> segment_into_charts(const indexed_triangle_set &mesh, const std
 // solve at all, and why this also serves as the fallback for a chart LSCM cannot handle.
 std::vector<Vec2f> project_to_tangent_plane(const indexed_triangle_set &chart, const Vec3f &normal)
 {
-    // Oriented like the box projection (see box_projection_axes()), so a chart reads the right way up
-    // and unmirrored instead of being flattened to whichever basis a cross product happened to give.
-    // For a chart whose normal *is* a world axis - a cube face, which is the common case once the
-    // seam angle has cut the patch along its sharp edges - this is exactly the box basis, so such a
-    // face unwraps to the same orientation Triplanar would have given it.
-    Vec3f u, v;
-    box_projection_axes(normal, u, v);
-    // The box axes lie in the tangent plane already when the normal is a world axis; for any other
-    // normal, u is squared up against it and v follows. u x v == -normal keeps the chart the way
-    // round a viewer outside the model sees it (a plain normal x u would mirror it).
-    u = u - normal * normal.dot(u);
-    if (u.norm() <= 1e-6f) {
-        // Out of reach for a unit normal - the box basis puts u perpendicular to the normal's own
-        // dominant axis, so the two can never be within 45 degrees of each other - but a caller
-        // handing over an unnormalized normal should still get a usable basis rather than a NaN.
-        const Vec3f seed = (std::abs(normal.z()) < 0.9f) ? Vec3f::UnitZ() : Vec3f::UnitX();
-        u = seed.cross(normal);
-    }
-    u = Vec3f(u.normalized());
-    v = Vec3f(u.cross(normal).normalized());
+    const Vec3f seed = (std::abs(normal.z()) < 0.9f) ? Vec3f::UnitZ() : Vec3f::UnitX();
+    const Vec3f u    = Vec3f(seed.cross(normal).normalized());
+    const Vec3f v    = Vec3f(normal.cross(u).normalized());
 
     std::vector<Vec2f> uvs(chart.vertices.size());
     for (size_t i = 0; i < chart.vertices.size(); ++i)
@@ -2141,10 +1815,8 @@ float sample_layer_height(const DecodedHeightTexture &texture, const TextureDisp
             return texture.sample(uv, layer.tile_enabled, layer.tile_method);
         }
         // Flat projection onto the captured projector plane. Single-valued per point, so unlike
-        // blended triplanar it is one sample, and it is what "project from view" places. The
-        // projector's up axis is negated because v runs *down* the image (v = 0 is its first pixel
-        // row), the same reason the projective branch above measures window y downward.
-        return sample_at(Vec2f(position.dot(layer.view_project_right), -position.dot(layer.view_project_up)));
+        // blended triplanar it is one sample, and it is what "project from view" places.
+        return sample_at(Vec2f(position.dot(layer.view_project_right), position.dot(layer.view_project_up)));
     case TextureProjectionMethod::LSCM: // no usable unwrap for this patch - fall back to Triplanar
     case TextureProjectionMethod::Triplanar:
     default: break;
@@ -2159,15 +1831,14 @@ float sample_layer_height(const DecodedHeightTexture &texture, const TextureDisp
     const float w_sum = w.x() + w.y() + w.z();
     if (w_sum < 1e-8f)
         // Degenerate normal: no axis is meaningfully dominant, so no blend is meaningful either.
-        return sample_at(box_plane_xy(position, normal.z()));
+        return sample_at(Vec2f(position.x(), position.y()));
     w /= w_sum;
 
-    // Each plane drops the axis it is named for and is oriented for the side of that plane the normal
-    // points to, matching project_planar()'s own convention (which the GUI's on-canvas placement
-    // gizmo also relies on). See box_plane_yz() for why the orientation is not simply (y, z).
-    return w.x() * sample_at(box_plane_yz(position, normal.x())) +
-           w.y() * sample_at(box_plane_xz(position, normal.y())) +
-           w.z() * sample_at(box_plane_xy(position, normal.z()));
+    // Each plane drops the axis it is named for, matching project_planar()'s own convention (which
+    // the GUI's on-canvas placement gizmo also relies on).
+    return w.x() * sample_at(Vec2f(position.y(), position.z())) +
+           w.y() * sample_at(Vec2f(position.x(), position.z())) +
+           w.z() * sample_at(Vec2f(position.x(), position.y()));
 }
 
 bool sample_layer_color(const DecodedHeightTexture &texture, const TextureDisplacementLayer &layer,
@@ -2229,8 +1900,7 @@ bool sample_layer_color(const DecodedHeightTexture &texture, const TextureDispla
             out = texture.sample_color(uv, layer.tile_enabled, layer.tile_method);
             return true;
         } else {
-            // Negated up, exactly as sample_layer_height() does it.
-            const Vec2f p(position.dot(layer.view_project_right), -position.dot(layer.view_project_up));
+            const Vec2f p(position.dot(layer.view_project_right), position.dot(layer.view_project_up));
             if (!covered(p))
                 return false;
             out = sample_at(p);
@@ -2246,7 +1916,7 @@ bool sample_layer_color(const DecodedHeightTexture &texture, const TextureDispla
     Vec3f w = triplanar_weights(normal);
     const float w_sum = w.x() + w.y() + w.z();
     if (w_sum < 1e-8f) {
-        const Vec2f p = box_plane_xy(position, normal.z());
+        const Vec2f p(position.x(), position.y());
         if (!covered(p))
             return false;
         out = sample_at(p);
@@ -2257,8 +1927,8 @@ bool sample_layer_color(const DecodedHeightTexture &texture, const TextureDispla
     // A blend of three planes is only "not covered" where *every* contributing plane is outside the
     // placement; where some are, the covered ones are renormalised so the colour does not fade toward
     // black at the edge of an untiled tri-planar layer.
-    const std::array<Vec2f, 3> planes = { box_plane_yz(position, normal.x()), box_plane_xz(position, normal.y()),
-                                          box_plane_xy(position, normal.z()) };
+    const std::array<Vec2f, 3> planes = { Vec2f(position.y(), position.z()), Vec2f(position.x(), position.z()),
+                                          Vec2f(position.x(), position.y()) };
     Vec3f acc     = Vec3f::Zero();
     float acc_w   = 0.f;
     for (int i = 0; i < 3; ++i)

src/libslic3r/TextureDisplacement.hpp

@@ -154,38 +154,6 @@ struct TextureIsland
 // chart to its true mm area, so a freshly unwrapped patch has uniform texel density to begin with.
 void average_island_scales(std::vector<TextureIsland> &islands);
 
-// Photo-style adjustments to a layer's source image, as the gizmo's image-adjustment panel sets them.
-//
-// These are *not* layer parameters: nothing here is stored on TextureDisplacementLayer and nothing here is
-// re-applied at bake time. The panel applies them once, to the image, and the result becomes the layer's
-// image - so the adjusted pixels feed the colour and the displacement together, and a brightness change
-// really does change the relief. That is the intended behaviour: one image, one source of truth, rather
-// than a second set of knobs the bake would have to replay in the right order.
-//
-// Contrast with TextureDisplacementLayer::smoothing, which *is* a layer parameter applied on every decode:
-// `blur` here is a destructive edit of the image, `smoothing` is a live low-pass over whatever the image is.
-struct TextureAdjustments
-{
-    float brightness = 0.f; // [-1, 1]; 0 unchanged, -1 black, +1 white
-    float contrast   = 0.f; // [-1, 1]; 0 unchanged, -1 flat mid-grey, +1 hard threshold
-    float sharpness  = 0.f; // [0, 1];  0 unchanged. Unsharp-mask amount
-    float blur       = 0.f; // [0, 1];  0 unchanged. Fraction of SOURCE_BLUR_SPAN, as `smoothing` is
-    float hue_deg    = 0.f; // [-180, 180]; 0 unchanged. No effect on a grayscale image - grey has no hue
-
-    bool identity() const
-    {
-        return brightness == 0.f && contrast == 0.f && sharpness == 0.f && blur == 0.f && hue_deg == 0.f;
-    }
-    // Exact equality, which is what is wanted: these come straight off sliders, and the question asked of
-    // them is "is this still the value the preview on screen was computed from", not "are these close".
-    bool operator==(const TextureAdjustments &o) const
-    {
-        return brightness == o.brightness && contrast == o.contrast && sharpness == o.sharpness &&
-               blur == o.blur && hue_deg == o.hue_deg;
-    }
-    bool operator!=(const TextureAdjustments &o) const { return !(*this == o); }
-};
-
 // One texture asset plus its projection/displacement parameters. Several layers may be painted
 // onto overlapping areas of the same volume: their displacements are combined per vertex, in slot
 // order, each layer folding into the total via its own TextureBlendMode (see
@@ -309,18 +277,6 @@ struct TextureDisplacementLayer
     //  - zero or positive: a mesh vertex, every unwrapped copy of it (how edits were stored before).
     std::vector<std::pair<int, Vec2f>> lscm_uv_overrides;
 
-    // Live, unsaved image adjustments from the gizmo's image-adjustment panel, applied by
-    // decode_height_texture() on top of the decoded image - so while the panel is open the relief, the
-    // colour, the thumbnails and the bake all see the adjusted image, and moving a slider really does
-    // change the displacement. See TextureAdjustments.
-    //
-    // Deliberately *not* serialized, by either save()/load() here or the .3mf: it is the state of an open
-    // editor, not a property of the layer. The panel resets it when it closes, and "Save as copy" resolves
-    // it by writing a new image and pointing the layer at that - which is the only way an adjustment
-    // becomes permanent. A project saved mid-adjustment therefore stores the unadjusted image, which is
-    // the honest answer: nothing was committed.
-    TextureAdjustments preview_adjust;
-
     // How this layer folds into the displacement accumulated by the layers below it. Ignored for
     // the lowest-slot painted layer, which has nothing beneath it to combine with (the GUI shows
     // it as the "Base" layer and hides the control).
@@ -548,36 +504,6 @@ struct DecodedHeightTexture
     bool texel_tap(const Vec2f &uv, bool tile_enabled, TextureTileMethod tile_method, TexelTap &out) const;
 };
 
-// Applies `adj` to `src` and returns the result; `src` is left alone. An empty `src`, or an identity
-// `adj`, gives back a copy.
-//
-// Order is tonal, then spatial: brightness, contrast and hue per texel first, then blur, then sharpness.
-// Sharpness last is what lets the two spatial knobs be used together - blur to kill speckle, then
-// sharpness to put the real edges back - instead of the blur simply undoing the sharpen.
-//
-// Grayscale in, grayscale out (`rgb` stays empty): promoting a grey image to RGB would hand the layer's
-// colour feature a row of identical greys to "colour" the model with, and triple the stored PNG for it.
-// For a colour image the height is recomputed as the luminance of the *adjusted* colour, with
-// decode_height_texture()'s own coefficients, so the relief and the colour can never drift apart.
-DecodedHeightTexture apply_texture_adjustments(const DecodedHeightTexture &src, const TextureAdjustments &adj);
-
-// Blur radius, in texels, that TextureAdjustments::blur == 1 means on a `min(width, height)`-sized image:
-// the same 5%-of-the-short-side span the Smoothing slider uses, under the same 48-texel cost cap, so the
-// two controls bite at the same rate and a user moving between them is not surprised.
-float adjustment_blur_radius(float blur, int width, int height);
-
-// Box-filters `src` down so neither side exceeds `max_px`, preserving aspect; never upscales, and
-// returns a copy when it already fits. Colour and height are filtered the same way, and the height
-// stays the height - it is not recomputed from the filtered colour, because a box filter is linear and
-// luminance is linear in the channels, so the two agree already.
-//
-// This is what lets the adjustment panel's live preview cost depend on the size of the box it is drawn
-// in rather than on the size of the image: adjusting a downscaled copy per slider frame, and the
-// full-size image only once, on commit. A box filter (rather than a plain decimation) is the point -
-// these textures are high-frequency by nature, and dropping texels would alias the preview into
-// showing detail the adjustment is not actually producing.
-DecodedHeightTexture downscale_height_texture(const DecodedHeightTexture &src, int max_px);
-
 // Decode a layer's raw image bytes into sampleable height data, plus colour when the source has any.
 // Both 8-bit grayscale PNGs (the shipped library, and anything imported before colour was kept) and
 // colour PNGs are accepted; for a colour source the height is its luminance, using the same
@@ -625,24 +551,11 @@ struct TextureColorSettings
     bool empty() const { return palette.empty(); }
 };
 
-// The two world directions the box projection takes its u and v along on a face whose outward
-// normal is `normal`: the plane is the one that normal is closest to, and the pair is oriented as a
-// viewer standing outside the model sees it - u to their right, v *down* the image, which is the
-// direction v runs in the texture (v = 0 is the image's first pixel row, see
-// DecodedHeightTexture::sample()). So an image comes out the way it looks in a file manager rather
-// than upside down, and it is not mirrored on the three faces facing the other way.
-//
-// Exposed because the GUI needs the same basis for the on-canvas "adjust texture placement" gizmo
-// (its ring's zero angle and its offset handle's plane), and it must not be a second, drifting copy
-// of the table.
-void box_projection_axes(const Vec3f &normal, Vec3f &u_axis, Vec3f &v_axis);
-
 // Raw dominant-axis planar projection of `position` (in mm, not yet scaled/rotated/offset by any
-// layer), dropping the axis position that best aligns with `normal`. Equivalent to projecting onto
-// box_projection_axes()' pair. Exposed on its own (rather than only inline inside
-// project_texture_displacement_uv()) so GUI code - the on-canvas "adjust texture placement" gizmo -
-// can map a dragged 3D point into the exact same 2D space tiling_scale/rotation_deg/offset operate
-// in, without duplicating the axis-selection logic.
+// layer), dropping the axis position that best aligns with `normal`. Exposed on its own (rather
+// than only inline inside project_texture_displacement_uv()) so GUI code - the on-canvas
+// "adjust texture placement" gizmo - can map a dragged 3D point into the exact same 2D space
+// tiling_scale/rotation_deg/offset operate in, without duplicating the axis-selection logic.
 Vec2f project_planar(const Vec3f &position, const Vec3f &normal);
 
 // Applies a layer's tiling_scale/rotation_deg/offset to an already-projected planar coordinate

src/libvgcode/src/ViewerImpl.cpp

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

src/slic3r/GUI/GUI_App.cpp

@@ -41,6 +41,7 @@
 #include <boost/filesystem/exception.hpp>
 #include <boost/locale/encoding_utf.hpp>
 #include <boost/log/detail/native_typeof.hpp>
+#include <cstdint>
 #include <iomanip>
 #include <iostream>
 #include <cassert>
@@ -325,6 +326,13 @@ namespace GUI {
 
 class MainFrame;
 
+// The OrcaCloud agent behind the shared NetworkAgent, or null when networking/OrcaCloud is not
+// available (e.g. stealth mode or the network plugin still loading).
+static std::shared_ptr<OrcaCloudServiceAgent> get_orca_cloud_agent(NetworkAgent* agent)
+{
+    return agent ? std::dynamic_pointer_cast<OrcaCloudServiceAgent>(agent->get_cloud_agent()) : nullptr;
+}
+
 void start_ping_test()
 {
     return;
@@ -2272,7 +2280,9 @@ void GUI_App::init_networking_callbacks()
             if (return_code == 5) {
                 GUI::wxGetApp().CallAfter([this, provider = event.provider] {
                     BOOST_LOG_TRIVIAL(info) << "logout: login expired";
-                    this->request_user_logout(provider);
+                    // Involuntary: the desktop lost its session on its own. Leave the webview's
+                    // own session alone (guide §8).
+                    this->request_user_logout(provider, /*user_initiated=*/false);
                     MessageDialog msg_dlg(nullptr, _L("Login information expired. Please login again."), "", wxAPPLY | wxOK);
                     if (msg_dlg.ShowModal() == wxOK) {
                         return;
@@ -5243,7 +5253,7 @@ void GUI_App::post_logout_to_webview(const std::string& provider)
     }
 }
 
-void GUI_App::request_user_logout(const std::string& provider/* = ORCA_CLOUD_PROVIDER*/)
+void GUI_App::request_user_logout(const std::string& provider/* = ORCA_CLOUD_PROVIDER*/, bool user_initiated)
 {
     if (m_agent && m_agent->is_user_login(provider)) {
         m_agent->user_logout(true, provider);
@@ -5256,6 +5266,21 @@ void GUI_App::request_user_logout(const std::string& provider/* = ORCA_CLOUD_PRO
         }
 
         if (provider == ORCA_CLOUD_PROVIDER) {
+            // Invalidate any handoff still in flight, so a token minted for the signed-out
+            // account is never loaded into the pane.
+            ++m_cloud_handoff_gen;
+            m_cloud_handoff_state.clear();
+
+            // An explicit user sign-out also ends the webview's own cloud session (guide §8).
+            // A session the desktop lost on its own must NOT do this: a 2FA user would otherwise
+            // loop through the code prompt on every desktop re-login.
+            if (user_initiated) {
+                if (auto orca = get_orca_cloud_agent(m_agent)) {
+                    if (WebViewPanel* home = WebViewPanel::if_built())
+                        home->cloud_signed_out(from_u8(orca->build_web_session_signout_url()));
+                }
+            }
+
             /* delete old user settings */
             bool     transfer_preset_changes = false;
             wxString header = _L("Some presets are modified.") + "\n" +
@@ -5377,7 +5402,7 @@ std::string GUI_App::handle_web_request(std::string cmd)
             else if (command_str.compare("homepage_logout") == 0) {
                 CallAfter([this] {
                     BOOST_LOG_TRIVIAL(info) << "logout: homepage_logout";
-                    request_user_logout();
+                    request_user_logout(ORCA_CLOUD_PROVIDER, /*user_initiated=*/true);
                 });
             }
             else if (command_str.compare("get_orca_login_info") == 0) {
@@ -5392,7 +5417,7 @@ std::string GUI_App::handle_web_request(std::string cmd)
             else if (command_str.compare("homepage_bambu_logout") == 0) {
                 CallAfter([this] {
                     BOOST_LOG_TRIVIAL(info) << "logout: homepage_bambu_logout";
-                    request_user_logout(BBL_CLOUD_PROVIDER);
+                    request_user_logout(BBL_CLOUD_PROVIDER, /*user_initiated=*/true);
                 });
             }
             else if (command_str.compare("homepage_orca_login_or_register") == 0) {
@@ -5401,7 +5426,7 @@ std::string GUI_App::handle_web_request(std::string cmd)
             else if (command_str.compare("homepage_orca_logout") == 0) {
                 CallAfter([this] {
                     BOOST_LOG_TRIVIAL(info) << "logout: homepage_orca_logout";
-                    request_user_logout(ORCA_CLOUD_PROVIDER);
+                    request_user_logout(ORCA_CLOUD_PROVIDER, /*user_initiated=*/true);
                 });
             }
             else if (command_str.compare("homepage_modeldepot") == 0) {
@@ -5413,6 +5438,20 @@ std::string GUI_App::handle_web_request(std::string cmd)
             else if (command_str.compare("homepage_openproject") == 0) {
                 this->request_open_project({});
             }
+            else if (command_str.compare("homepage_open_cloud") == 0) {
+                // Deferred: set_cloud_mode() may create a second native webview, which must
+                // not run inside this webview's script-message callback.
+                CallAfter([this]() {
+                    if (WebViewPanel* home = WebViewPanel::if_built())
+                        home->set_cloud_mode(true, cloud_webview_handoff());
+                });
+            }
+            else if (command_str.compare("homepage_close_cloud") == 0) {
+                CallAfter([]() {
+                    if (WebViewPanel* home = WebViewPanel::if_built())
+                        home->set_cloud_mode(false);
+                });
+            }
             else if (command_str.compare("get_recent_projects") == 0) {
                 if (mainframe) {
                     if (WebViewPanel* home = WebViewPanel::if_built()) {
@@ -5685,7 +5724,9 @@ void GUI_App::on_http_error(wxCommandEvent &evt)
             if (!provider.empty() && m_agent->is_user_login(provider)) {
                 if (std::chrono::steady_clock::now() - m_last_401_error_time > 30s) {
                     BOOST_LOG_TRIVIAL(warning) << "logout: http error 401.";
-                    this->request_user_logout(provider);
+                    // Involuntary: a 401 means the desktop session was rejected. Leave the
+                    // webview's own session alone (guide §8).
+                    this->request_user_logout(provider, /*user_initiated=*/false);
 
                     if (!m_show_http_error_msgdlg) {
                         MessageDialog msg_dlg(nullptr, _L("Login information expired. Please login again."), "", wxAPPLY | wxOK);
@@ -5829,6 +5870,93 @@ void GUI_App::on_update_machine_list(wxCommandEvent &evt)
      }*/
 }
 
+wxString GUI_App::cloud_webview_handoff()
+{
+    // The cloud pane loads the Start URL, not a token: the page checks the webview's own session
+    // and asks for a handoff itself (guide §4). Signed out, user_id is omitted and the page will
+    // post request_web_session, which is what opens the desktop login dialog.
+    auto orca = get_orca_cloud_agent(m_agent);
+    if (!orca)
+        return {};
+    return from_u8(orca->build_web_session_start_url());
+}
+
+void GUI_App::request_cloud_web_session(const std::string& state)
+{
+    if (state.empty())
+        return;
+
+    // Only the newest request counts: a newer state supersedes any mint or login still in flight.
+    m_cloud_handoff_state = state;
+    const uint64_t gen    = ++m_cloud_handoff_gen;
+
+    auto orca = get_orca_cloud_agent(m_agent);
+    if (!orca || !orca->is_user_login()) {
+        // Desktop signed out: open the desktop login dialog and stop here. On success
+        // on_user_login_handle reloads the Start URL, which makes the page request again; on
+        // cancel nothing happens (the guide's "on cancel, do nothing"). The newest state is
+        // already stored, so a repeat request while the dialog is open is dropped rather than
+        // stacking another dialog.
+        if (!login_dlg || !login_dlg->IsShown())
+            request_login(true, ORCA_CLOUD_PROVIDER);
+        return;
+    }
+
+    mint_cloud_web_session(state, gen);
+}
+
+void GUI_App::mint_cloud_web_session(const std::string& state, uint64_t gen)
+{
+    auto orca = get_orca_cloud_agent(m_agent);
+    if (!orca)
+        return;
+
+    // The endpoint call blocks on network I/O (and possibly a cross-process token refresh), so
+    // it must not run on the UI thread. Hand off to a worker and marshal the token back.
+    boost::thread([this, orca, state, gen]() {
+        std::string  token_hash;
+        std::string  error_code;
+        unsigned int http_code = 0;
+        orca->request_web_session_handoff(token_hash, error_code, http_code);
+
+        if (is_closing())
+            return;
+
+        if (token_hash.empty()) {
+            // No token: 401 after retry, 409/429/503 or a transport error. The page owns its own
+            // "Sign-in link expired"/"Try again" UI; the desktop stays silent. Never log the body
+            // (it may echo account data), only the status/error code.
+            BOOST_LOG_TRIVIAL(warning) << "cloud web session handoff not minted - http_code=" << http_code
+                                       << " error_code=" << error_code;
+            return;
+        }
+
+        GUI::wxGetApp().CallAfter([this, state, gen, token_hash]() {
+            on_cloud_web_session_minted(state, gen, token_hash);
+        });
+    }).detach();
+}
+
+void GUI_App::on_cloud_web_session_minted(const std::string& state, uint64_t gen, const std::string& token_hash)
+{
+    if (is_closing())
+        return;
+    // Drop a result for a superseded request (a newer request_web_session, login or sign-out).
+    if (gen != m_cloud_handoff_gen || state != m_cloud_handoff_state)
+        return;
+    if (token_hash.empty())
+        return;
+
+    auto orca = get_orca_cloud_agent(m_agent);
+    if (!orca)
+        return;
+
+    // Load the Complete URL in the SAME webview that posted request_web_session, because the
+    // state lives in that webview's session storage (guide §3/§7).
+    if (WebViewPanel* home = WebViewPanel::if_built())
+        home->load_cloud_url(from_u8(orca->build_web_session_complete_url(token_hash, state)));
+}
+
 void GUI_App::on_user_login_handle(wxCommandEvent &evt)
 {
     if (!m_agent) { return; }
@@ -5884,6 +6012,16 @@ void GUI_App::on_user_login_handle(wxCommandEvent &evt)
     if (app_config->get("sync_user_preset") == "true") {
         start_sync_user_preset();
     }
+
+    // Re-seed the embedded OrcaCloud pane if it is already open, so it picks up the new session
+    // without waiting for the next open. On a fresh login or account switch this invalidates any
+    // in-flight handoff for the previous account and loads the Start URL with the new user_id, so
+    // the page drops the old account and re-requests (guide §8).
+    ++m_cloud_handoff_gen;
+    m_cloud_handoff_state.clear();
+    if (WebViewPanel* home = WebViewPanel::if_built())
+        if (home->cloud_mode_active())
+            home->set_cloud_mode(true, cloud_webview_handoff());
 }
 
 
@@ -7952,8 +8090,11 @@ void GUI_App::on_stealth_mode_enter()
 {
     stop_sync_user_preset();
     BOOST_LOG_TRIVIAL(info) << "logout: on_stealth_mode_enter";
-    request_user_logout(ORCA_CLOUD_PROVIDER);
-    request_user_logout(BBL_CLOUD_PROVIDER);
+    // Stealth mode forces a desktop logout, but the user did not choose "Sign out": guide §8 ties
+    // ?signout=1 to the explicit desktop sign-out only. Leave the cloud webview's own session
+    // alone, so it is re-checked (and re-seeded with the right account) on the next open.
+    request_user_logout(ORCA_CLOUD_PROVIDER, /*user_initiated=*/false);
+    request_user_logout(BBL_CLOUD_PROVIDER, /*user_initiated=*/false);
     if (WebViewPanel* home = WebViewPanel::if_built()) {
         home->SendCloudProvidersInfo();
     }

src/slic3r/GUI/GUI_App.hpp

@@ -361,6 +361,11 @@ private:
     bool             m_side_popup_status{false};
     bool             m_show_http_error_msgdlg{false};
     std::chrono::steady_clock::time_point m_last_401_error_time;
+    // OrcaCloud webview session handoff: the newest request_web_session state from the cloud pane
+    // and a generation counter so a superseded mint/login result is dropped (guide §5, "only the
+    // newest request counts").
+    std::string      m_cloud_handoff_state;
+    uint64_t         m_cloud_handoff_gen { 0 };
     bool             m_show_error_msgdlg{false};
     wxString         m_info_dialog_content;
     HttpServer       m_http_server;
@@ -540,7 +545,11 @@ public:
 
     void            request_user_login(int online_login = 0, const std::string& provider = ORCA_CLOUD_PROVIDER);
     void            request_user_handle(int online_login = 0, const std::string& provider = ORCA_CLOUD_PROVIDER);
-    void            request_user_logout(const std::string& provider = ORCA_CLOUD_PROVIDER);
+    // `user_initiated` distinguishes a user sign-out from the desktop losing its session on its
+    // own (refresh failed, 401). Only an explicit sign-out also ends the cloud webview's own
+    // session; an involuntary one leaves the webview alone (guide §8). Defaults to the safe
+    // direction: a new caller that forgets the flag will not silently sign the webview out.
+    void            request_user_logout(const std::string& provider = ORCA_CLOUD_PROVIDER, bool user_initiated = false);
     void            post_logout_to_webview(const std::string& provider);
     int             request_user_unbind(std::string dev_id, const std::string& provider = ORCA_CLOUD_PROVIDER);
     std::string     handle_web_request(std::string cmd);
@@ -556,6 +565,15 @@ public:
     void            on_update_machine_list(wxCommandEvent& evt);
     void            on_user_login(wxCommandEvent &evt);
     void            on_user_login_handle(wxCommandEvent& evt);
+    // OrcaCloud webview session handoff (guide §5/§7). cloud_webview_handoff builds the cloud
+    // pane's Start URL (with the desktop user_id while signed in). request_cloud_web_session is
+    // called from the pane when the page asks for a session; it opens the desktop login dialog if
+    // signed out, otherwise mints a one-time token on a worker thread and loads the Complete URL
+    // in the same webview.
+    wxString        cloud_webview_handoff();
+    void            request_cloud_web_session(const std::string& state);
+    void            mint_cloud_web_session(const std::string& state, uint64_t gen);
+    void            on_cloud_web_session_minted(const std::string& state, uint64_t gen, const std::string& token_hash);
     void            enable_user_preset_folder(bool enable);
 
     // BBS

src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.cpp

@@ -43,7 +43,6 @@
 #include <cstdint>
 #include <functional>
 #include <chrono>
-#include <future>
 #include <cstdio>
 #include <glad/gl.h>
 #include <imgui.h>
@@ -121,14 +120,6 @@ constexpr int THUMBNAIL_MAX_PX = 128;
 // blur of it - which is what made Fast look flatter and softer than the result it was previewing.
 constexpr int HEIGHT_TEX_MAX_PX = 2048;
 
-// Size the image-adjustment panel's live preview is computed and uploaded at. The panel draws the image
-// in a box about 240 px wide, so there is nothing to show above this - and the preview is recomputed on
-// every slider move, which is what makes its cost worth bounding. Measured on a 1024x1024 with every
-// knob engaged, a full-size pass is 13-19 ms grayscale / 40-60 ms in colour (130-190 ms at 2048 in
-// colour); the same pass on a 384 px copy is 3-4 ms / 9-12 ms, and it runs off the UI thread besides.
-// The full-size image is only ever adjusted once, on commit.
-constexpr int ADJUST_PREVIEW_MAX_PX = 384;
-
 // How many rings of vertex-adjacent triangles either side of the paint's edge join the border refine
 // band (see collect_paint_region()). Two is enough to grade the size change without the band's own
 // cost growing to matter: it is a ring around a perimeter, not an area.
@@ -544,10 +535,6 @@ void GLGizmoTextureDisplacement::on_shutdown()
     // progress poll, and its completion handler then finds nothing to do.
     m_preview_generation->fetch_add(1);
     m_preview_job_pending = false;
-    // The adjustment panel holds a full-size decode of its layer's image, which is the largest thing
-    // here; a closed gizmo should not keep it alive. Discards the edit, as closing the gizmo on an open
-    // panel implies.
-    close_image_adjust();
     // The palette caches hold the last volume's images; a closed gizmo should not keep them alive.
     m_palette_cache.clear();
     m_palette_quantizer      = nullptr;
@@ -1275,9 +1262,8 @@ std::vector<Vec2f> GLGizmoTextureDisplacement::compute_layer_vertex_uvs(const in
                     uv[vi] = Vec2f(-1e6f, -1e6f);
                 continue;
             }
-            // Negated up, as sample_layer_height()'s affine branch has it: v runs down the image.
             const Vec2f planar(patch.vertices[vi].dot(layer.view_project_right),
-                               -patch.vertices[vi].dot(layer.view_project_up));
+                               patch.vertices[vi].dot(layer.view_project_up));
             uv[vi] = apply_uv_transform(planar, layer, aspect);
         }
         return uv;
@@ -2484,12 +2470,9 @@ void GLGizmoTextureDisplacement::update_uv_editor()
     // before, and independently of, the unwrap - the texture belongs on screen before anything is unwrapped - and
     // only when the choice, the layer's image or its smoothing changed, because the height image is large.
     const UVBackground desired_bg = (m_uv_check_mode == UVCheckMode::Checker) ? UVBackground::Checker : UVBackground::Height;
-    const bool bg_smoothing_changed = (desired_bg == UVBackground::Height) &&
-                                      (m_uv_editor_bg_smoothing != layer->smoothing ||
-                                       !(m_uv_editor_bg_adjust == layer->preview_adjust));
+    const bool bg_smoothing_changed = (desired_bg == UVBackground::Height) && (m_uv_editor_bg_smoothing != layer->smoothing);
     if (desired_bg != m_uv_editor_bg || layer->image_data.get() != m_uv_editor_bg_image || bg_smoothing_changed) {
         m_uv_editor_bg_smoothing = layer->smoothing;
-        m_uv_editor_bg_adjust    = layer->preview_adjust;
         m_uv_editor_bg_image     = layer->image_data.get();
         m_uv_editor_bg           = desired_bg;
         if (desired_bg == UVBackground::Checker) {
@@ -3361,10 +3344,19 @@ Vec3f GLGizmoTextureDisplacement::adjust_handle_center(const TextureDisplacement
 
 void GLGizmoTextureDisplacement::adjust_tangent_basis(Vec3f &u_axis, Vec3f &v_axis) const
 {
-    // libslic3r's own basis, asked for rather than restated here, so the ring's "0 degrees" and the
-    // offset handle's plane always agree with what project_texture_displacement_uv() does - including
-    // v pointing *down* the texture and u flipping on the far side of each plane.
-    box_projection_axes(m_adjust_anchor_normal, u_axis, v_axis);
+    // Mirrors project_planar()'s own dominant-axis choice exactly, so the ring's "0 degrees" and
+    // the offset handle's plane always agree with what project_texture_displacement_uv() does.
+    const Vec3f n = m_adjust_anchor_normal.cwiseAbs();
+    if (n.x() >= n.y() && n.x() >= n.z()) {
+        u_axis = Vec3f::UnitY();
+        v_axis = Vec3f::UnitZ();
+    } else if (n.y() >= n.x() && n.y() >= n.z()) {
+        u_axis = Vec3f::UnitX();
+        v_axis = Vec3f::UnitZ();
+    } else {
+        u_axis = Vec3f::UnitX();
+        v_axis = Vec3f::UnitY();
+    }
 }
 
 void GLGizmoTextureDisplacement::render_adjust_texture_gizmo()
@@ -3760,7 +3752,6 @@ void GLGizmoTextureDisplacement::ensure_panel_icons()
         "texture_displacement_checker.svg", "texture_displacement_distortion.svg",
         "texture_displacement_wireframe.svg", "texture_displacement_cross.svg",
         "texture_displacement_uv_select_island.svg", "texture_displacement_uv_select_edge.svg",
-        "cog.svg", // the layer card's "adjust image" button
         "texture_displacement_uv_select_vertex.svg",
         // Paint / Erase, brush cursor shape, mapping, tiling, placement and the dock toggle.
         "texture_displacement_add.svg", "texture_displacement_add_negative.svg", "circle_paint.svg",
@@ -4073,338 +4064,6 @@ void GLGizmoTextureDisplacement::render_texture_library_popup(const ImVec2 &pane
         m_picker_open_request = true;
     }
 }
-bool GLGizmoTextureDisplacement::load_image_adjust_source(const TextureDisplacementLayer &layer)
-{
-    if (layer.empty())
-        return false;
-
-    // The *raw* image: neither the layer's Smoothing nor the panel's own preview_adjust, so what the
-    // sliders act on is always the image as it is actually stored rather than the last preview of it.
-    // Without clearing preview_adjust here the adjustment would compound on itself every reload.
-    TextureDisplacementLayer raw = layer;
-    raw.smoothing                = 0.f;
-    raw.preview_adjust           = TextureAdjustments{};
-
-    DecodedHeightTexture decoded = decode_height_texture(raw);
-    if (decoded.empty())
-        return false;
-
-    m_adjust_source         = std::move(decoded);
-    m_adjust_preview_source = downscale_height_texture(m_adjust_source, ADJUST_PREVIEW_MAX_PX);
-    m_adjust_source_image   = layer.image_data.get();
-    // The unadjusted image, so the box is filled now rather than one background pass later. Pairing it
-    // with an identity `shown` is what makes update_image_adjust_preview() relaunch for the sliders'
-    // current values against the new source instead of deciding it is already showing them.
-    m_adjust_preview_shown = TextureAdjustments{};
-    m_adjust_preview_tex   = upload_height_thumbnail(m_adjust_preview_source, ADJUST_PREVIEW_MAX_PX);
-    m_adjust_preview_valid = m_adjust_preview_tex != nullptr;
-    return true;
-}
-
-void GLGizmoTextureDisplacement::open_image_adjust(const TextureDisplacementLayer &layer)
-{
-    if (layer.empty() || layer.slot < 0)
-        return;
-
-    close_image_adjust(); // reverts and clears any previous panel
-
-    if (!load_image_adjust_source(layer))
-        return;
-
-    m_adjust           = TextureAdjustments{};
-    m_adjust_applied   = TextureAdjustments{};
-    m_adjust_slot      = layer.slot;
-    const ModelVolume *mv = texture_volume();
-    m_adjust_volume_id = mv != nullptr ? mv->id().id : 0;
-}
-
-void GLGizmoTextureDisplacement::invalidate_adjust_textures()
-{
-    // The GPU copies of a layer's image - the list thumbnail, the preview shader's height and colour
-    // textures - are keyed on the image_data pointer and the layer's Smoothing, and a live adjustment
-    // changes neither: the pointer still names the same PNG. Rather than widen three cache keys for a
-    // panel that is open a few seconds at a time, the panel drops the copies itself whenever it moves
-    // the adjustment. Resetting the source is enough; the next get_layer_*() rebuilds from the decode,
-    // which does see the adjustment.
-    m_thumbnail_source.fill({});
-    m_color_tex_source.reset();
-    m_height_tex_source.reset();
-}
-
-void GLGizmoTextureDisplacement::close_image_adjust()
-{
-    // Revert the layer's live adjustment. Every exit that reaches here is a discard: a commit resets
-    // preview_adjust itself, before pointing the layer at the file that already carries the edit, so this
-    // cannot undo a committed adjustment.
-    //
-    // Found by the id recorded when the panel opened rather than through texture_volume(), which answers
-    // for the *current* selection. One of the ways to get here is the selection having moved on, and
-    // reverting the newly selected object's layer instead would both miss the adjustment that is still
-    // live on the original volume and clear one the user never touched.
-    bool reverted = false;
-    if (m_adjust_slot >= 0 && m_adjust_volume_id != 0)
-        for (ModelObject *mo : wxGetApp().model().objects) {
-            for (ModelVolume *mv : mo->volumes) {
-                if (mv->id().id != m_adjust_volume_id)
-                    continue;
-                for (TextureDisplacementLayer &l : mv->texture_displacement_layers)
-                    if (l.slot == m_adjust_slot && !l.preview_adjust.identity()) {
-                        l.preview_adjust = TextureAdjustments{};
-                        reverted         = true;
-                    }
-            }
-        }
-
-    if (reverted)
-        invalidate_adjust_textures();
-
-    // std::async's future blocks here until the pass finishes. That is a few milliseconds on an image
-    // this small, and the alternative - a detached thread writing into the members of a closed panel -
-    // is worse.
-    if (m_adjust_preview_job.valid())
-        m_adjust_preview_job.wait();
-    m_adjust_preview_job = {};
-
-    m_adjust_slot           = -1;
-    m_adjust                = TextureAdjustments{};
-    m_adjust_applied        = TextureAdjustments{};
-    m_adjust_source         = DecodedHeightTexture{};
-    m_adjust_preview_source = DecodedHeightTexture{};
-    m_adjust_source_image   = nullptr;
-    m_adjust_volume_id      = 0;
-    m_adjust_preview_tex.reset();
-    m_adjust_preview_valid = false;
-
-    // Only while the gizmo is up: on_shutdown() also comes through here, and rebuilding a preview for a
-    // gizmo that is closing would be work for a model nobody is looking at. The reverted layer data is
-    // what matters there, and that is already done above.
-    if (reverted && m_state == On) {
-        rebuild_preview();
-        m_parent.set_as_dirty();
-    }
-}
-
-void GLGizmoTextureDisplacement::update_image_adjust_preview()
-{
-    if (m_adjust_preview_source.empty())
-        return;
-
-    // Collect a finished pass. wait_for(0) rather than get() outright: this runs inside the frame, and
-    // blocking on the worker here would hand back to the UI thread the very stall the worker exists to
-    // spare it.
-    if (m_adjust_preview_job.valid() &&
-        m_adjust_preview_job.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
-        const DecodedHeightTexture adjusted = m_adjust_preview_job.get();
-        m_adjust_preview_job                = {};
-        if (std::unique_ptr<GLTexture> tex = upload_height_thumbnail(adjusted, ADJUST_PREVIEW_MAX_PX)) {
-            m_adjust_preview_tex   = std::move(tex);
-            m_adjust_preview_shown = m_adjust_preview_running;
-            m_adjust_preview_valid = true;
-        }
-    }
-
-    // One pass at a time: whatever the sliders did while it ran is picked up by the next launch, so a
-    // drag collapses to the value the sliders ended on instead of queuing one pass per frame.
-    if (!m_adjust_preview_job.valid() && m_adjust != m_adjust_preview_shown) {
-        m_adjust_preview_running = m_adjust;
-        // Captured by value: the pass must not read members the UI thread goes on editing while it runs.
-        m_adjust_preview_job = std::async(std::launch::async,
-                                          [src = m_adjust_preview_source, adj = m_adjust_preview_running] {
-                                              return apply_texture_adjustments(src, adj);
-                                          });
-    }
-
-    // A pass in flight has no other way to get its result on screen: without a redraw request the canvas
-    // can sit idle, and the preview would only catch up on the next unrelated frame.
-    if (m_adjust_preview_job.valid())
-        m_parent.set_as_dirty();
-}
-
-void GLGizmoTextureDisplacement::commit_image_adjust(TextureDisplacementLayer &layer)
-{
-    if (m_adjust_source.empty() || m_adjust.identity()) {
-        // Nothing was changed, so there is nothing to save.
-        close_image_adjust();
-        return;
-    }
-
-    // The full-size pass, once: 13-19 ms grayscale / 40-60 ms colour on a 1024x1024 with every knob
-    // engaged. Run on the UI thread deliberately, unlike the live preview: this is a single click, and the
-    // rebuild that follows it - a CPU mesh displacement of the painted patch - is already an order of
-    // magnitude more work, synchronously, so moving only this off the thread would buy nothing a user
-    // could perceive.
-    const DecodedHeightTexture adjusted = apply_texture_adjustments(m_adjust_source, m_adjust);
-
-    std::string                              error;
-    const std::string                        stem  = layer.name.empty() ? std::string("texture") : layer.name;
-    const std::optional<TextureLibraryEntry> entry = save_texture_to_library(adjusted, stem, error);
-    if (!entry) {
-        show_error(nullptr, error);
-        return; // the panel stays open, and the layer keeps the live adjustment: the edit is not lost
-    }
-
-    // Cleared *before* the layer is pointed at the new file, and this ordering is the whole correctness of
-    // the commit: the saved image already has the adjustment baked into its pixels, so leaving
-    // preview_adjust set would apply brightness, contrast and the rest a second time on top of itself.
-    layer.preview_adjust = TextureAdjustments{};
-    // set_layer_texture() does the rest - the name, the recently-used ordering, a fresh image_data buffer
-    // (which is what invalidates every cache keyed by the old pointer), the undo snapshot and the rebuild.
-    set_layer_texture(layer, *entry);
-
-    close_image_adjust();
-}
-
-void GLGizmoTextureDisplacement::render_image_adjust_window(const ImVec2 &panel_min, const ImVec2 &panel_max)
-{
-    if (m_adjust_slot < 0)
-        return;
-
-    ModelVolume *mv = texture_volume();
-    // A different volume is selected than the one this panel was opened on. Slots are numbered per
-    // volume, so looking m_adjust_slot up here would find an unrelated layer rather than nothing.
-    if (mv == nullptr || mv->id().id != m_adjust_volume_id) {
-        close_image_adjust();
-        return;
-    }
-
-    TextureDisplacementLayer *layer = nullptr;
-    for (TextureDisplacementLayer &l : mv->texture_displacement_layers)
-        if (l.slot == m_adjust_slot)
-            layer = &l;
-    if (layer == nullptr) {
-        // The layer went away under the panel (removed, or merged away by an undo).
-        close_image_adjust();
-        return;
-    }
-
-    // The layer's image can be swapped from the texture picker while this panel is open - the panel is a
-    // window now, so the rest of the gizmo stays usable behind it. Re-read the source when that happens,
-    // keeping the slider positions: the user is adjusting this layer, and the 3D view has already moved to
-    // the new image (decode_height_texture() reads layer.image_data, which changed), so re-reading here is
-    // also what keeps the panel's photo and the model showing the same thing.
-    if (layer->image_data.get() != m_adjust_source_image && !load_image_adjust_source(*layer)) {
-        close_image_adjust(); // the new image cannot be decoded; nothing left to adjust
-        return;
-    }
-
-    const float img_w = std::round(m_imgui->scaled(16.f));
-    const float gap   = m_imgui->scaled(0.5f);
-    // Placed beside the panel on first appearance only, and left wherever the user drags it after that -
-    // it is a window, not a popup, so its position is theirs to keep.
-    const float win_w = img_w + 2.f * ImGui::GetStyle().WindowPadding.x;
-    const bool  left  = panel_min.x - gap - win_w >= 0.f;
-    ImGui::SetNextWindowPos(ImVec2(left ? panel_min.x - gap - win_w : panel_max.x + gap,
-                                   panel_min.y + m_imgui->scaled(4.f)), ImGuiCond_Appearing);
-
-    bool keep_open = true;
-    if (!ImGui::Begin((_u8L("Adjust image") + "##texture_adjust").c_str(), &keep_open,
-                      ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse)) {
-        ImGui::End();
-        if (!keep_open)
-            close_image_adjust();
-        return;
-    }
-
-    // Collect a finished pass and start one for the current slider values before the image is drawn, so
-    // the newest available result is what lands on screen this frame.
-    update_image_adjust_preview();
-
-    // The photo itself, at the image's own aspect so a non-square texture is not stretched.
-    const float aspect = m_adjust_source.height > 0 ? float(m_adjust_source.width) / float(m_adjust_source.height) : 1.f;
-    const float img_h  = std::round(img_w / std::max(0.05f, aspect));
-    if (m_adjust_preview_valid && m_adjust_preview_tex)
-        ImGui::Image((ImTextureID) (intptr_t) m_adjust_preview_tex->get_id(), ImVec2(img_w, img_h));
-    else
-        ImGui::Dummy(ImVec2(img_w, img_h));
-
-    // The label column is sized off the widest of the five labels, so the tracks line up whatever the
-    // translation does to their lengths.
-    float label_w = 0.f;
-    for (const wxString &l : { _L("Brightness"), _L("Contrast"), _L("Sharpness"), _L("Blur"), _L("Hue") })
-        label_w = std::max(label_w, ImGui::CalcTextSize(into_u8(l).c_str()).x);
-    label_w += m_imgui->scaled(1.2f);
-    // An explicit track width rather than a fill-to-the-right one: this window is AlwaysAutoResize, so its
-    // width comes from its content, and an item asking for "whatever is left" would make the width depend
-    // on itself. The image above sets the content width, and the sliders match it.
-    const float slider_w = std::max(m_imgui->scaled(4.f), img_w - label_w);
-
-    const auto row = [&](const char *id, const wxString &label, float *v, float v_min, float v_max,
-                         const char *format, bool enabled, const std::string &tip) {
-        const float x0 = ImGui::GetCursorPosX();
-        ImGui::AlignTextToFramePadding();
-        m_imgui->text(label);
-        ImGui::SameLine();
-        ImGui::SetCursorPosX(std::max(ImGui::GetCursorPosX(), x0 + label_w));
-        ImGui::SetNextItemWidth(slider_w);
-        m_imgui->disabled_begin(!enabled);
-        ImGui::SliderFloat(id, v, v_min, v_max, format, ImGuiSliderFlags_AlwaysClamp);
-        m_imgui->disabled_end();
-        // Only on an enabled row: a disabled item does not report hover, so a tooltip on one would never
-        // be shown. What has to be said about a disabled slider is written out below it instead.
-        if (enabled && !tip.empty() && ImGui::IsItemHovered())
-            m_imgui->tooltip(tip, ImGui::GetFontSize() * 20.f);
-    };
-
-    row("##adj_brightness", _L("Brightness"), &m_adjust.brightness, -1.f, 1.f, "%.2f", true, {});
-    row("##adj_contrast", _L("Contrast"), &m_adjust.contrast, -1.f, 1.f, "%.2f", true, {});
-    row("##adj_sharpness", _L("Sharpness"), &m_adjust.sharpness, 0.f, 1.f, "%.2f", true,
-        _u8L("Brings out the finest detail in the image. Applied after Blur, so the two can be used "
-             "together: blur away the speckle, then sharpen the edges that remain."));
-    row("##adj_blur", _L("Blur"), &m_adjust.blur, 0.f, 1.f, "%.2f", true,
-        _u8L("Blurs the image itself. The layer's own Smoothing slider softens the relief without altering "
-             "the image, and is the one to reach for first."));
-    // Grey has no hue to turn, and the shipped library is grayscale - so on most textures this is a
-    // slider that would visibly do nothing. Disabled with the reason given, rather than hidden.
-    const bool has_color = m_adjust_source.has_color();
-    row("##adj_hue", _L("Hue"), &m_adjust.hue_deg, -180.f, 180.f, "%.0f°", has_color, {});
-    if (!has_color) {
-        ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + img_w);
-        ImGui::TextDisabled("%s", _u8L("This texture is grayscale, so it has no hue to shift.").c_str());
-        ImGui::PopTextWrapPos();
-    }
-
-    if (m_imgui->button(_L("Reset")))
-        m_adjust = TextureAdjustments{};
-
-    // Hand the sliders to the layer, which is what puts the adjusted image in front of the displacement:
-    // decode_height_texture() applies preview_adjust, so the relief, the colour and the thumbnails all
-    // follow from here. Written every frame rather than only on a change, so an undo snapshot or a
-    // reselection that resets the layer cannot leave the model showing an adjustment the panel has moved
-    // on from.
-    layer->preview_adjust = m_adjust;
-    if (m_adjust != m_adjust_applied) {
-        m_adjust_applied = m_adjust;
-        invalidate_adjust_textures();
-        // Marked dirty rather than rebuilt here: the panel's own flag is consumed by the main panel's
-        // "rebuild once the mouse is released" rule, so dragging a slider recomputes the displacement
-        // once, on release, instead of on every frame of the drag. That is what keeps the UI responsive
-        // while a full-size resample and a mesh displacement happen behind it.
-        m_preview_params_dirty = true;
-        // This window is drawn after the block that consumes that flag, so the rebuild happens on a later
-        // frame - which means there has to *be* one. Cheap insurance: a slider release that generated no
-        // further canvas event would otherwise leave the flag set and the model unchanged until something
-        // unrelated redrew.
-        m_parent.set_as_dirty();
-    }
-
-    ImGui::Separator();
-    m_imgui->text_wrapped(_u8L("The model updates when you release a slider. Save as copy writes the "
-                               "adjusted image to your texture library and points this layer at it."), img_w);
-
-    const bool cancel = m_imgui->button(_L("Cancel"));
-    ImGui::SameLine();
-    // Nothing to save until a slider has actually moved.
-    m_imgui->disabled_begin(m_adjust.identity());
-    const bool as_copy = m_imgui->button(_L("Save as copy"));
-    m_imgui->disabled_end();
-
-    ImGui::End();
-
-    if (cancel || !keep_open)
-        close_image_adjust();
-    else if (as_copy)
-        commit_image_adjust(*layer);
-}
 
 void GLGizmoTextureDisplacement::remove_texture_layer(int slot)
 {
@@ -6929,7 +6588,7 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                 ImGui::SameLine();
 
                 const std::string not_painted = _u8L("not painted");
-                const float right_w = (painted ? 0.f : ImGui::CalcTextSize(not_painted.c_str()).x + gap_s) + 4.f * frame_h + 3.f * gap_s;
+                const float right_w = (painted ? 0.f : ImGui::CalcTextSize(not_painted.c_str()).x + gap_s) + 3.f * frame_h + 2.f * gap_s;
                 const float name_w  = std::max(frame_h, ImGui::GetWindowContentRegionMax().x - card_pad - ImGui::GetCursorPosX() - gap_s - right_w);
                 ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(orca.x, orca.y, orca.z, 0.2f));
                 ImGui::PushStyleColor(ImGuiCol_HeaderActive, ImVec4(orca.x, orca.y, orca.z, 0.35f));
@@ -6943,16 +6602,6 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                     ImGui::SameLine();
                     ImGui::TextDisabled("%s", not_painted.c_str());
                 }
-                // Between the name and the order arrows: it acts on the image the name refers to, so it
-                // belongs with the name rather than with the controls that reorder the stack.
-                ImGui::SameLine();
-                m_imgui->disabled_begin(busy || layer.empty());
-                if (icon_button(613 + layer.slot, "cog.svg", frame_h, _L("Adjust image"),
-                                _u8L("Brightness, contrast, sharpness, blur and hue, shown on the image and on the "
-                                     "model as you set them. Save as copy writes the result to your texture library "
-                                     "and points this layer at it.")))
-                    open_image_adjust(layer);
-                m_imgui->disabled_end();
                 ImGui::SameLine();
                 m_imgui->disabled_begin(busy || li == 0);
                 if (icon_button(611, "texture_displacement_move_up.svg", frame_h, _L("Move up"), _L("Move up - applied earlier"))) {
@@ -7750,15 +7399,10 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
         set_active_layer(m_picker_slot);
 
     // In this window's scope, where the popup's open request and the popup itself share one ID stack.
-    ImVec2 panel_rect_min, panel_rect_max;
     {
         const ImVec2 win_min = ImGui::GetWindowPos();
         const ImVec2 win_sz  = ImGui::GetWindowSize();
         render_texture_library_popup(win_min, ImVec2(win_min.x + win_sz.x, win_min.y + win_sz.y));
-        // Only recorded here. The image-adjustment panel is a top-level window rather than a popup, so it
-        // cannot be begun inside this one; it is drawn after GizmoImguiEnd() below.
-        panel_rect_min = win_min;
-        panel_rect_max = ImVec2(win_min.x + win_sz.x, win_min.y + win_sz.y);
     }
 
     // ImGui sliders report "changed" continuously on every frame while being dragged, not just once on
@@ -7996,11 +7640,6 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
         m_parent.request_extra_frame();
     }
     GizmoImguiEnd();
-
-    // Outside the gizmo's window, because it is a window of its own: a floating, non-modal panel that
-    // leaves the 3D view live so the relief can be watched while the sliders move. No-op when closed.
-    render_image_adjust_window(panel_rect_min, panel_rect_max);
-
     ImGuiWrapper::pop_toolbar_style();
 
     // Drawn last, over everything, via the foreground draw list: the +/- add-remove sign next to the 3D

src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp

@@ -23,7 +23,6 @@
 #include "libslic3r/Point.hpp"
 #include <imgui.h>
 #include <map>
-#include <future>
 #include <memory>
 #include <optional>
 #include "slic3r/GUI/Gizmos/GLGizmoBase.hpp"
@@ -436,71 +435,6 @@ private:
     std::string m_slider_type_request;
     int         m_slider_type_request_frame = 0;
 
-    // ---- The image-adjustment panel ----
-    //
-    // Brightness/contrast/sharpness/blur/hue over one layer's image, shown on the image itself and
-    // updating as the sliders move. What it produces is not a set of layer parameters: it replaces the
-    // layer's *image*, so the adjusted pixels feed the colour and the displacement together and a
-    // brightness change moves the relief too (see TextureAdjustments).
-    //
-    // An ordinary floating window rather than a popup, and deliberately so. A popup dims the canvas
-    // behind it and closes on any click outside itself, which between them make it impossible to watch the
-    // relief change on the model - which is the whole point of adjusting the image here rather than in an
-    // image editor. A window leaves the 3D view live, clickable and orbitable while the panel is open.
-    void render_image_adjust_window(const ImVec2 &panel_min, const ImVec2 &panel_max);
-    // Opens the panel for `layer`, decoding its image into m_adjust_source. Sliders never re-decode
-    // the PNG.
-    void open_image_adjust(const TextureDisplacementLayer &layer);
-    // Reads `layer`'s stored image into the panel's source buffers and records which image it came from.
-    // Called when the panel opens and again whenever the layer's image is swapped under it, which is why
-    // it leaves the slider values alone. False when the image cannot be decoded.
-    bool load_image_adjust_source(const TextureDisplacementLayer &layer);
-    // Resolves the panel: writes the adjusted image into the user's texture library as a new file and
-    // points `layer` at it, which is the only way an adjustment becomes permanent. Closes the panel.
-    void commit_image_adjust(TextureDisplacementLayer &layer);
-    // Closes the panel and reverts the layer's live preview_adjust to identity, so every exit that is not
-    // a commit - Cancel, the window's close button, the gizmo closing - leaves the layer as it was found.
-    void close_image_adjust();
-    // Collects a finished preview and starts one for the current slider values. One at a time, so a drag
-    // coalesces into "whatever the sliders last said" instead of a queue of superseded frames.
-    void update_image_adjust_preview();
-
-    int                m_adjust_slot = -1; // the layer the panel is open for; -1 when closed
-    TextureAdjustments m_adjust;           // what the sliders currently say
-    // What the layer's live preview_adjust was last set from, so a slider move can be told from a frame in
-    // which nothing happened and only the former asks the displacement to be recomputed.
-    TextureAdjustments m_adjust_applied;
-
-    // The layer's image as it was when the panel opened, and a small copy of it. The sliders are applied
-    // to the small copy for the live preview and to the full-size one exactly once, on commit. Measured on
-    // a 1024x1024 with every knob engaged, a full-size pass costs 13-19 ms grayscale and 40-60 ms in
-    // colour (130-190 ms at 2048 in colour) - far too much to repeat per slider frame. The same pass on a
-    // 384 px copy is 3-4 ms / 9-12 ms, and that is all the preview box can show anyway.
-    DecodedHeightTexture m_adjust_source;
-    DecodedHeightTexture m_adjust_preview_source;
-    // Which image_data the two buffers above were decoded from, so the panel can notice the layer's image
-    // being swapped from the texture picker while it is open and re-read it. Compared, never dereferenced.
-    const void          *m_adjust_source_image = nullptr;
-    // And which volume the panel was opened on. Slot numbers are per volume, so without this a change of
-    // selection would silently rebind the open panel to whichever layer happens to hold the same slot on
-    // the newly selected object - a different image, under a panel the user opened for this one.
-    size_t               m_adjust_volume_id = 0;
-    // The preview image on screen, re-uploaded whenever a background pass finishes.
-    std::unique_ptr<GLTexture> m_adjust_preview_tex;
-
-    // The live preview runs on its own thread rather than on the UI thread or on the plater's job
-    // worker. Not the UI thread because even the small pass is milliseconds and this runs while a slider
-    // is being dragged; not the job worker because that is a single FIFO shared with Bake and the
-    // displacement preview (see queue_preview_job()), where a per-frame image filter would sit behind -
-    // and delay - multi-second mesh work.
-    std::future<DecodedHeightTexture> m_adjust_preview_job;
-    TextureAdjustments                m_adjust_preview_running; // what the in-flight pass is computing
-    TextureAdjustments                m_adjust_preview_shown;   // what m_adjust_preview_tex holds
-    bool                              m_adjust_preview_valid = false;
-    // Drops the GPU copies of the layer's image so the next frame rebuilds them from the decode, which
-    // is where the live adjustment is applied. Called whenever the panel moves or reverts it.
-    void invalidate_adjust_textures();
-
     // "Adjust Texture" mode: instead of painting, dragging an on-canvas handle changes the active
     // layer's offset. The handle is a flat panel lying in the paint patch's own tangent plane
     // (a "pan" - drag anywhere on it for free 2D movement), plus two arrows along the patch's
@@ -519,8 +453,8 @@ private:
     // obvious whether the next stroke adds paint (default) or erases it (Shift). Uses ImGui's
     // foreground draw list, so it must be called from inside the gizmo's ImGui frame.
     void render_paint_cursor_hint();
-    // Mesh-local tangent-plane basis at m_adjust_anchor_normal: box_projection_axes(), so dragging
-    // on-canvas maps consistently onto offset whichever face the anchor is on.
+    // Mesh-local tangent-plane basis at m_adjust_anchor_normal, matching project_planar()'s
+    // dominant-axis convention so dragging on-canvas maps consistently onto offset.
     void adjust_tangent_basis(Vec3f &u_axis, Vec3f &v_axis) const;
 
     // The plane a drag is measured against: the paint patch's anchor, lifted clear of the surface.
@@ -981,7 +915,6 @@ private:
     enum class UVBackground { None, Height, Checker };
     UVBackground m_uv_editor_bg = UVBackground::None;
     float        m_uv_editor_bg_smoothing = -1.f; // smoothing the height backdrop was uploaded at
-    TextureAdjustments m_uv_editor_bg_adjust;        // and the live image adjustment it was uploaded at
     const void  *m_uv_editor_bg_image     = nullptr; // the layer image it was uploaded from
     // Per-chart distortion heatmap colour for the UV pane (#7/#14), computed once when the unwrap is
     // re-solved (relative stretch doesn't change when islands are merely moved), fed to the canvas only

src/slic3r/GUI/Preferences.cpp

@@ -645,7 +645,7 @@ wxBoxSizer *PreferencesDialog::create_item_region_combobox(wxString title, wxStr
                 combobox->SetSelection(current_region);
                 return;
             } else {
-                wxGetApp().request_user_logout();
+                wxGetApp().request_user_logout(ORCA_CLOUD_PROVIDER, /*user_initiated=*/true);
                 config->set("region", region.ToStdString());
                 auto area = config->get_country_code();
                 if (agent) {
@@ -2479,7 +2479,7 @@ wxBoxSizer* PreferencesDialog::create_debug_page()
                 AppConfig* config = GUI::wxGetApp().app_config;
                 std::string country_code = config->get_country_code();
                 if (agent) {
-                    wxGetApp().request_user_logout();
+                    wxGetApp().request_user_logout(ORCA_CLOUD_PROVIDER, /*user_initiated=*/true);
                     agent->set_country_code(country_code);
                 }
                 ConfirmBeforeSendDialog confirm_dlg(this, wxID_ANY, _L("Warning"), ConfirmBeforeSendDialog::VisibleButtons::ONLY_CONFIRM);  // ORCA VisibleButtons instead ButtonStyle 

src/slic3r/GUI/TextureLibrary.cpp

@@ -27,7 +27,6 @@
 #include <wx/mstream.h>
 
 #include "libslic3r/PNGReadWrite.hpp"
-#include "libslic3r/TextureDisplacement.hpp"
 #include "libslic3r/Utils.hpp"
 
 #include "libslic3r/AppConfig.hpp"
@@ -159,28 +158,6 @@ bool encode_png_bytes(const wxImage &image, std::vector<unsigned char> &out, std
                                   : encode_gray_png_bytes(image, out, error);
 }
 
-// A wxImage over decoded pixels, so the encoders above can be reached from an in-memory image as well as
-// from a file. Grayscale is expanded to the three equal channels wxImage always stores, which is what
-// image_has_color() then reads as "no colour" - so a grey image still encodes as a grayscale PNG.
-//
-// `scratch` holds the pixel buffer: the wxImage is constructed over it without taking ownership, so it
-// has to outlive every use of the returned image.
-wxImage image_from_decoded(const DecodedHeightTexture &image, std::vector<unsigned char> &scratch)
-{
-    if (image.empty())
-        return wxImage();
-
-    const size_t n = size_t(image.width) * size_t(image.height);
-    scratch.resize(n * 3);
-    if (image.has_color())
-        scratch.assign(image.rgb.begin(), image.rgb.end());
-    else
-        for (size_t i = 0; i < n; ++i)
-            scratch[i * 3] = scratch[i * 3 + 1] = scratch[i * 3 + 2] = image.pixels[i];
-
-    return wxImage(image.width, image.height, scratch.data(), /* static_data */ true);
-}
-
 std::vector<unsigned char> read_file_bytes(const std::string &path)
 {
     std::ifstream ifs(path, std::ios::binary);
@@ -209,42 +186,6 @@ bool is_supported_height_map(const std::vector<unsigned char> &bytes)
 std::vector<TextureLibraryEntry> g_library;
 bool                             g_library_scanned = false;
 
-// Writes `bytes` into the user's own texture folder as `stem`.png, uniquified so an existing texture -
-// shipped-name collision, or a second edit of the same source - is never overwritten. Returns the new
-// file's library entry. Shared by import_texture_to_library() and save_texture_to_library(), which
-// differ only in where their bytes came from.
-std::optional<TextureLibraryEntry> write_user_texture(const std::vector<unsigned char> &bytes, const std::string &stem,
-                                                      std::string &error)
-{
-    const std::string user_dir = user_texture_dir();
-    if (user_dir.empty()) {
-        error = _u8L("Could not create the folder for imported textures.");
-        return std::nullopt;
-    }
-
-    boost::filesystem::path dest = boost::filesystem::path(user_dir) / (stem + ".png");
-    for (int i = 2; boost::filesystem::exists(dest); ++i)
-        dest = boost::filesystem::path(user_dir) / (stem + " (" + std::to_string(i) + ").png");
-
-    {
-        boost::nowide::ofstream ofs(dest.string(), std::ios::binary);
-        ofs.write(reinterpret_cast<const char *>(bytes.data()), std::streamsize(bytes.size()));
-        if (!ofs.good()) {
-            error = _u8L("Failed to save the imported texture.");
-            return std::nullopt;
-        }
-    }
-
-    texture_library(true); // pick the new file up
-    const std::string dest_str = dest.string();
-    for (const TextureLibraryEntry &e : g_library)
-        if (e.path == dest_str)
-            return e;
-
-    error = _u8L("Failed to save the imported texture.");
-    return std::nullopt;
-}
-
 // The user's own textures, most recently used first, kept in the app config. File names are stored rather
 // than paths so the order survives a moved data directory; '/' separates them because no platform allows
 // it inside a file name. Bounded so a long-lived config does not grow a line without end.
@@ -376,6 +317,12 @@ bool remove_user_texture(const std::string &path, std::string &error)
 
 std::optional<TextureLibraryEntry> import_texture_to_library(const std::string &source_path, std::string &error)
 {
+    const std::string user_dir = user_texture_dir();
+    if (user_dir.empty()) {
+        error = _u8L("Could not create the folder for imported textures.");
+        return std::nullopt;
+    }
+
     wxImage image;
     if (!image.LoadFile(from_u8(source_path)) || !image.IsOk()) {
         error = _u8L("Could not load the selected image.");
@@ -386,7 +333,30 @@ std::optional<TextureLibraryEntry> import_texture_to_library(const std::string &
     if (!encode_png_bytes(image, bytes, error))
         return std::nullopt;
 
-    return write_user_texture(bytes, boost::filesystem::path(source_path).stem().string(), error);
+    // Never overwrite an existing texture (the user's or, if they picked the same name twice, their
+    // own earlier import) - uniquify instead.
+    const std::string       stem = boost::filesystem::path(source_path).stem().string();
+    boost::filesystem::path dest = boost::filesystem::path(user_dir) / (stem + ".png");
+    for (int i = 2; boost::filesystem::exists(dest); ++i)
+        dest = boost::filesystem::path(user_dir) / (stem + " (" + std::to_string(i) + ").png");
+
+    {
+        boost::nowide::ofstream ofs(dest.string(), std::ios::binary);
+        ofs.write(reinterpret_cast<const char *>(bytes.data()), std::streamsize(bytes.size()));
+        if (!ofs.good()) {
+            error = _u8L("Failed to save the imported texture.");
+            return std::nullopt;
+        }
+    }
+
+    texture_library(true); // pick the new file up
+    const std::string dest_str = dest.string();
+    for (const TextureLibraryEntry &e : g_library)
+        if (e.path == dest_str)
+            return e;
+
+    error = _u8L("Failed to save the imported texture.");
+    return std::nullopt;
 }
 
 std::shared_ptr<std::vector<unsigned char>> load_texture_image_data(const std::string &path, std::string &error)
@@ -412,21 +382,4 @@ std::shared_ptr<std::vector<unsigned char>> load_texture_image_data(const std::s
     return std::make_shared<std::vector<unsigned char>>(std::move(converted));
 }
 
-std::optional<TextureLibraryEntry> save_texture_to_library(const DecodedHeightTexture &image, const std::string &stem,
-                                                           std::string &error)
-{
-    std::vector<unsigned char> scratch;
-    const wxImage              wx = image_from_decoded(image, scratch);
-    if (!wx.IsOk()) {
-        error = _u8L("The selected image is empty.");
-        return std::nullopt;
-    }
-
-    std::vector<unsigned char> bytes;
-    if (!encode_png_bytes(wx, bytes, error))
-        return std::nullopt;
-
-    return write_user_texture(bytes, stem.empty() ? std::string("texture") : stem, error);
-}
-
 } // namespace Slic3r::GUI

src/slic3r/GUI/TextureLibrary.hpp

@@ -6,8 +6,6 @@
 #include <string>
 #include <vector>
 
-#include "libslic3r/TextureDisplacement.hpp"
-
 namespace Slic3r::GUI {
 
 // One selectable height-map texture in the texture-displacement gizmo's texture picker.
@@ -59,14 +57,6 @@ std::optional<TextureLibraryEntry> import_texture_to_library(const std::string &
 // Returns nullptr with `error` set if the file cannot be read or decoded at all.
 std::shared_ptr<std::vector<unsigned char>> load_texture_image_data(const std::string &path, std::string &error);
 
-// Writes `image` into user_texture_dir() as a new PNG named after `stem` (uniquified if taken, so an
-// existing texture is never overwritten) and returns its library entry. The in-memory counterpart of
-// import_texture_to_library(), for an image that was edited rather than read off disk.
-//
-// Returns nullopt with `error` set on failure.
-std::optional<TextureLibraryEntry> save_texture_to_library(const DecodedHeightTexture &image, const std::string &stem,
-                                                           std::string &error);
-
 } // namespace Slic3r::GUI
 
 #endif // slic3r_TextureLibrary_hpp_

src/slic3r/GUI/WebGuideDialog.cpp

@@ -1,4 +1,5 @@
 #include "WebGuideDialog.hpp"
+#include "CloudProvider.hpp"
 #include "ConfigWizard.hpp"
 
 #include <algorithm>
@@ -753,7 +754,7 @@ void GuideFrame::OnScriptMessage(wxWebViewEvent &evt)
                     if (wxGetApp().is_user_login()) {
                         BOOST_LOG_TRIVIAL(info) << "logout: user_logout on user_guide_finish";
                         // agent->user_logout();
-                        wxGetApp().request_user_logout();
+                        wxGetApp().request_user_logout(ORCA_CLOUD_PROVIDER, /*user_initiated=*/true);
                     }
                 }
             }

src/slic3r/GUI/WebViewDialog.cpp

@@ -36,12 +36,17 @@
 #include <wx/textdlg.h>
 #include <wx/toplevel.h>
 #include <wx/url.h>
+#include <wx/uri.h>
 
 #include <slic3r/GUI/Widgets/WebView.hpp>
 #include <slic3r/GUI/Widgets/WebViewHostDialog.hpp>
 #include <wx/webview.h>
 #include <wx/utils.h>
 #include <wx/window.h>
+
+#ifdef __linux__
+#include <webkit2/webkit2.h>
+#endif
 #include <wx/infobar.h>
 
 namespace pt = boost::property_tree;
@@ -55,6 +60,13 @@ namespace GUI {
 
     #define LOGIN_INFO_UPDATE_TIMER_ID 10002
 
+// OrcaCloud is a native pane of its own: the site refuses to be framed
+// (x-frame-options: DENY / CSP frame-ancestors 'none').
+static const char *const kCloudUrl = "https://cloud.orcaslicer.com";
+// #LeftBoard in resources/web/homepage/css/home.css is a 262px column plus a 1px right
+// border; the homepage keeps that width as the nav column while the cloud pane is open.
+static const int kLeftNavWidth = 263;
+
 // The home page's strings (resources/web/homepage), keyed by their data-i18n and T() ids.
 static json home_page_strings()
 {
@@ -134,7 +146,11 @@ WebViewPanel::WebViewPanel(wxWindow *parent)
     m_reset_on_show = WebView::NeedsRecreateOnShow();
     SetSizer(topsizer);
 
-    topsizer->Add(m_browser, wxSizerFlags().Expand().Proportion(1));
+    // The homepage shell is the left nav column; when OrcaCloud opens, its page lives in a
+    // second native pane beside it (the site refuses to be framed).
+    m_content_sizer = new wxBoxSizer(wxHORIZONTAL);
+    m_content_sizer->Add(m_browser, wxSizerFlags().Expand().Proportion(1));
+    topsizer->Add(m_content_sizer, wxSizerFlags().Expand().Proportion(1));
 
     // Log backend information
     /* m_browser->GetUserAgent() may lead crash
@@ -290,12 +306,282 @@ void WebViewPanel::create_browser()
     m_browser->Hide();
 }
 
+// The cloud page gets its own native view, created on first use and kept alive afterwards
+// so its session and scroll position survive hiding.
+void WebViewPanel::create_cloud_browser()
+{
+    m_cloud_browser = WebView::CreateWebView(this, wxEmptyString);
+
+#ifdef __linux__
+    // The pane's web session is a cookie (guide §3), and WebKitGTK keeps cookies only in memory
+    // unless a persistent store is set up, so without this the sign-in is lost on every restart
+    // (and on every reset_browser). Each wxWebView has its own context, so give the cloud pane its
+    // own store instead of sharing PrinterWebView's. Mirrors PrinterWebView::create_browser.
+    if (auto* wv = static_cast<WebKitWebView*>(m_cloud_browser->GetNativeBackend())) {
+        const auto cookies_path = boost::filesystem::path(data_dir() + "/cache/cloud_cookies.db");
+        auto*      cookie_manager = webkit_web_context_get_cookie_manager(webkit_web_view_get_context(wv));
+        webkit_cookie_manager_set_persistent_storage(cookie_manager, cookies_path.c_str(),
+                                                     WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE);
+    }
+#endif
+
+    // Webview events are command events, so they would otherwise propagate up to the
+    // panel's handlers, which drive the homepage view. Keep the cloud pane's events here.
+    m_cloud_browser->Bind(wxEVT_WEBVIEW_NAVIGATING, &WebViewPanel::OnCloudWebViewEvent, this);
+    m_cloud_browser->Bind(wxEVT_WEBVIEW_NAVIGATED, &WebViewPanel::OnCloudWebViewEvent, this);
+    m_cloud_browser->Bind(wxEVT_WEBVIEW_LOADED, &WebViewPanel::OnCloudWebViewEvent, this);
+    m_cloud_browser->Bind(wxEVT_WEBVIEW_TITLE_CHANGED, &WebViewPanel::OnCloudWebViewEvent, this);
+    m_cloud_browser->Bind(wxEVT_WEBVIEW_ERROR, &WebViewPanel::OnCloudWebViewEvent, this);
+    m_cloud_browser->Bind(wxEVT_WEBVIEW_NEWWINDOW, &WebViewPanel::OnCloudWebViewEvent, this);
+    m_cloud_browser->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, &WebViewPanel::OnCloudWebViewEvent, this);
+
+    m_cloud_browser->Hide();
+    if (m_content_sizer)
+        m_content_sizer->Add(m_cloud_browser, wxSizerFlags().Expand().Proportion(1));
+}
+
+// The scheme://host[:port] origin of an http(s) URL, lower-cased and with the default port
+// dropped, or empty for any other scheme or a malformed URL. Comparing origins (not a string
+// prefix) is what keeps a lookalike host such as "https://cloud.orcaslicer.com.evil.com" out.
+static wxString http_origin_of(const wxString& url)
+{
+    const wxURI uri(url);
+    if (!uri.HasScheme() || !uri.HasServer())
+        return {};
+    const wxString scheme = uri.GetScheme().Lower();
+    if (scheme != "http" && scheme != "https")
+        return {};
+    wxString origin = scheme + "://" + uri.GetServer().Lower();
+    const wxString port = uri.GetPort();
+    if (!port.IsEmpty() && port != (scheme == "https" ? "443" : "80"))
+        origin += ":" + port;
+    return origin;
+}
+
+// Whether a NAVIGATING event will replace the pane's top-level document rather than load a
+// subframe. Edge and macOS report the target frame; WebKitGTK does not (IsTargetMainFrame() is
+// always false there), so a user-gesture navigation stands in: a page's own embedded frames load
+// without a gesture and stay put, while a user following a link to another site does not.
+static bool cloud_navigation_is_top_level(const wxWebViewEvent& evt)
+{
+#ifdef __WXGTK__
+    return evt.GetNavigationAction() == wxWEBVIEW_NAV_ACTION_USER;
+#else
+    return evt.IsTargetMainFrame();
+#endif
+}
+
+// Sends an off-site navigation to the system browser instead of embedding it. Deferred: this runs
+// inside a native webview navigation callback, so launching must not re-enter it.
+static void open_cloud_url_externally(const wxString& url)
+{
+    if (url.empty())
+        return;
+    BOOST_LOG_TRIVIAL(info) << "cloud pane: opening externally " << WebView::RedactUrl(url).ToUTF8().data();
+    wxGetApp().CallAfter([url] { wxLaunchDefaultBrowser(url); });
+}
+
+// Consumed on the cloud view so it never reaches the homepage handlers. {web} pages stay in the
+// pane; every other site (OAuth providers included) opens in the system browser (guide §3).
+void WebViewPanel::OnCloudWebViewEvent(wxWebViewEvent& evt)
+{
+    const wxEventType event_type = evt.GetEventType();
+    if (event_type == wxEVT_WEBVIEW_NAVIGATING) {
+        const wxString url = evt.GetURL();
+        // Guide §3: keep every {web} page in the pane and open other sites (OAuth providers
+        // included) in the system browser. Only top-level navigations are diverted, and
+        // should_divert_cloud_url() excludes same-origin URLs and internal schemes.
+        if (should_divert_cloud_url(url) && cloud_navigation_is_top_level(evt)) {
+            evt.Veto();
+            open_cloud_url_externally(url);
+        }
+    } else if (event_type == wxEVT_WEBVIEW_NEWWINDOW) {
+        const wxString url = evt.GetURL();
+        if (!url.empty()) {
+            if (is_cloud_origin(url))
+                load_cloud_url(url);
+            else
+                open_cloud_url_externally(url);
+        }
+        evt.Veto();
+    } else if (event_type == wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED) {
+        on_cloud_script_message(evt.GetString().utf8_string());
+    } else if (event_type == wxEVT_WEBVIEW_LOADED || event_type == wxEVT_WEBVIEW_ERROR) {
+        // A Start URL deferred behind a sign-out (see load_cloud_after_signout).
+        if (!m_cloud_after_signout_url.IsEmpty()) {
+            const wxString next = std::exchange(m_cloud_after_signout_url, wxString());
+            load_cloud_url(next);
+        }
+    }
+}
+
+// The page asks for a web session by posting JSON through window.wx; only the newest request
+// counts (tracked in GUI_App). Nothing here touches the UI directly: the desktop login dialog and
+// the network mint must not run on the webview's message-dispatch stack.
+void WebViewPanel::on_cloud_script_message(const std::string& body)
+{
+    const json msg = json::parse(body, nullptr, false);
+    if (msg.is_discarded() || !msg.is_object() || msg.value("command", std::string()) != "request_web_session")
+        return;
+
+    std::string state;
+    if (msg.contains("data") && msg["data"].is_object())
+        state = msg["data"].value("state", std::string());
+    if (state.empty())
+        return;
+
+    wxGetApp().CallAfter([state = std::move(state)] { wxGetApp().request_cloud_web_session(state); });
+}
+
+void WebViewPanel::apply_cloud_layout(bool cloud_on)
+{
+    if (!m_content_sizer)
+        return;
+
+    // Cloud mode pins the homepage to the nav column width; otherwise it fills the panel.
+    if (m_browser) {
+        if (wxSizerItem* item = m_content_sizer->GetItem(m_browser))
+            item->SetProportion(cloud_on ? 0 : 1);
+        // kLeftNavWidth is in DIP: the web view's CSS px are DIP, so scale to physical pixels.
+        m_browser->SetMinSize(cloud_on ? m_browser->FromDIP(wxSize(kLeftNavWidth, -1)) : wxDefaultSize);
+    }
+    Layout();
+}
+
+void WebViewPanel::load_cloud_url(const wxString& url)
+{
+    if (url.empty())
+        return;
+    // Track the origin of whatever the pane is told to load (Start URL, Complete URL, sign-out or
+    // the plain cloud fallback), so navigation policy has the right origin from the first load on.
+    const wxString origin = http_origin_of(url);
+    if (!origin.IsEmpty())
+        m_cloud_base_url = origin;
+    if (!m_cloud_browser)
+        return;
+    // Raw LoadURL: WebView::LoadUrl re-serialises through wxURI, which must not alter the
+    // fragment that carries the one-time handoff token. Log only the redacted URL.
+    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << ": " << WebView::RedactUrl(url).ToUTF8().data();
+    m_cloud_browser->LoadURL(url);
+}
+
+bool WebViewPanel::is_cloud_origin(const wxString& url) const
+{
+    const wxString origin = http_origin_of(url);
+    return !origin.IsEmpty() && !m_cloud_base_url.IsEmpty() && origin == m_cloud_base_url;
+}
+
+bool WebViewPanel::should_divert_cloud_url(const wxString& url) const
+{
+    const wxString origin = http_origin_of(url);
+    // Unknown cloud origin or a non-web scheme: never divert (the pane must keep working).
+    if (origin.IsEmpty() || m_cloud_base_url.IsEmpty())
+        return false;
+    return origin != m_cloud_base_url;
+}
+
+// Explicit sign-out ends the pane's own web session. That session is a cookie JS cannot clear
+// (HttpOnly, guide §3/§8) and ClearHistory() is a no-op on WebKitGTK, so drop the pane's stored
+// data natively. wx 3.3.2 ignores the type mask on every backend (any non-zero mask clears
+// everything) and needs an invalid `since` to delete cookies, so the default "all" call is used.
+void WebViewPanel::clear_cloud_storage()
+{
+    if (m_cloud_browser)
+        m_cloud_browser->ClearBrowsingData(wxWEBVIEW_BROWSING_DATA_ALL);
+}
+
+void WebViewPanel::load_cloud_after_signout(const wxString& url)
+{
+    if (m_cloud_pending_signout && !m_cloud_signout_url.IsEmpty()) {
+        // The pane did not exist when the user signed out, so its persisted session must be
+        // cleared before the sign-out page runs and `url` loads once that navigation finishes
+        // (see OnCloudWebViewEvent).
+        m_cloud_pending_signout    = false;
+        m_cloud_after_signout_url  = url;
+        clear_cloud_storage();
+        load_cloud_url(m_cloud_signout_url);
+        return;
+    }
+    load_cloud_url(url);
+}
+
+void WebViewPanel::schedule_cloud_load(const wxString& url)
+{
+    if (!m_cloud_browser) {
+        load_cloud_after_signout(url);
+        return;
+    }
+    // CreateWebView queues the "wx" handler add on the view (macOS/Linux); queue the load behind
+    // it so the page's first scripts already see the bridge (guide §3).
+    m_cloud_browser->CallAfter([this, url]() { load_cloud_after_signout(url); });
+}
+
+void WebViewPanel::cloud_signed_out(const wxString& signout_url)
+{
+    if (signout_url.empty())
+        return;
+    m_cloud_signout_url = signout_url;
+    // The next Start URL must re-seed the pane (it now reflects the signed-out state), so forget
+    // the previous seed regardless of which branch below runs.
+    m_cloud_seed_url.clear();
+    if (m_cloud_browser) {
+        m_cloud_pending_signout = false;
+        // Run the sign-out page (ends the server-side session), then clear the pane's stored data.
+        load_cloud_url(signout_url);
+        clear_cloud_storage();
+    } else {
+        // Pane never opened this run: clear the persisted session on its first open.
+        m_cloud_pending_signout = true;
+    }
+}
+
+void WebViewPanel::set_cloud_mode(bool on, const wxString& url)
+{
+    if (on) {
+        // load_cloud_url records the origin from whatever it loads, including the plain cloud
+        // fallback used when `url` is empty.
+        if (!m_cloud_browser) {
+            create_cloud_browser();
+            m_cloud_seed_url = url;
+            schedule_cloud_load(url.empty() ? wxString(kCloudUrl) : url);
+        } else if (!url.empty() && url != m_cloud_seed_url) {
+            // Re-seed only when the Start URL actually changed — a login, an account switch or a
+            // sign-out changes it; an ordinary re-open does not (guide §8). Reloading an unchanged
+            // Start URL re-runs the page's auth check on every open, which flashes "Signing you
+            // in…" and re-requests a session (guide §10: mint when the page asks, not per open).
+            // The pane is kept alive, so an unchanged open just shows the page it already holds.
+            m_cloud_seed_url = url;
+            load_cloud_after_signout(url);
+        }
+        m_cloud_browser->Show();
+    } else if (m_cloud_browser) {
+        // Closing keeps the pane alive with its session, so re-opening does not have to sign in
+        // again (guide §10). Nothing is cleared here.
+        m_cloud_browser->Hide();
+    }
+    apply_cloud_layout(on && m_cloud_browser != nullptr);
+}
+
 void WebViewPanel::reset_browser()
 {
+    // Rebuild both views the same way, keeping the cloud pane's open/closed state.
+    const bool cloud_on = m_cloud_browser && m_cloud_browser->IsShown();
+
     m_browser->Destroy(); // also removes it from the sizer
     create_browser();
-    GetSizer()->Add(m_browser, wxSizerFlags().Expand().Proportion(1));
-    Layout();
+    m_content_sizer->Insert(size_t(0), m_browser, wxSizerFlags().Expand().Proportion(1));
+
+    if (m_cloud_browser) {
+        m_cloud_browser->Destroy();
+        m_cloud_browser = nullptr;
+        create_cloud_browser();
+        schedule_cloud_load(wxString(kCloudUrl));
+        m_cloud_browser->Show(cloud_on);
+        // The rebuilt pane holds no seed, so the next open loads the Start URL again.
+        m_cloud_seed_url.clear();
+    }
+
+    apply_cloud_layout(cloud_on);
 }
 
 bool WebViewPanel::Show(bool show)
@@ -645,7 +931,7 @@ void WebViewPanel::update_mode()
     */
 void WebViewPanel::OnNavigationRequest(wxWebViewEvent& evt)
 {
-    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << ": " << evt.GetURL().ToUTF8().data();
+    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << ": " << WebView::RedactUrl(evt.GetURL()).ToUTF8().data();
     const wxString &url = evt.GetURL();
     if (url.StartsWith("File://") || url.StartsWith("file://")) {
         if (!url.Contains("/web/homepage/index.html")) {
@@ -691,7 +977,7 @@ void WebViewPanel::OnNavigationComplete(wxWebViewEvent& evt)
 {
     m_browser->Show();
     Layout();
-    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << ": " << evt.GetURL().ToUTF8().data();
+    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << ": " << WebView::RedactUrl(evt.GetURL()).ToUTF8().data();
     if (wxGetApp().get_mode() == comDevelop)
         wxLogMessage("%s", "Navigation complete; url='" + evt.GetURL() + "'");
     UpdateState();
@@ -710,6 +996,9 @@ void WebViewPanel::OnDocumentLoaded(wxWebViewEvent& evt)
         if (wxGetApp().get_mode() == comDevelop)
             wxLogMessage("%s", "Document loaded; url='" + evt.GetURL() + "'");
     }
+    // A reloaded homepage loses its cloud-mode class; restore it if the pane is open.
+    if (m_cloud_browser && m_cloud_browser->IsShown())
+        RunScript("SetCloudMode(true)");
     UpdateState();
     SendCloudProvidersInfo();
 }
@@ -725,7 +1014,7 @@ void WebViewPanel::OnTitleChanged(wxWebViewEvent &evt)
     */
 void WebViewPanel::OnNewWindow(wxWebViewEvent& evt)
 {
-    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << ": " << evt.GetURL().ToUTF8().data();
+    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << ": " << WebView::RedactUrl(evt.GetURL()).ToUTF8().data();
     wxString flag = " (other)";
 
     if (evt.GetNavigationAction() == wxWEBVIEW_NAV_ACTION_USER)

src/slic3r/GUI/WebViewDialog.hpp

@@ -28,6 +28,7 @@
 #include "wx/fs_mem.h"
 #include "wx/stdpaths.h"
 #include <wx/panel.h>
+#include <wx/sizer.h>
 #include <wx/tbarbase.h>
 #include "wx/textctrl.h"
 #include <wx/timer.h>
@@ -114,14 +115,62 @@ public:
 
     void update_mode();
 
+    // Shows/hides the native OrcaCloud pane beside this homepage nav column. `url` is the
+    // cloud Start URL ({web}/auth/handoff?next=…&user_id=…), which the page uses to decide
+    // whether it already has a session; empty falls back to the plain cloud page.
+    void set_cloud_mode(bool on, const wxString& url = wxString());
+
+    // True while the OrcaCloud pane exists and is visible.
+    bool cloud_mode_active() const { return m_cloud_browser && m_cloud_browser->IsShown(); }
+
+    // Loads `url` in the cloud pane — the webview that owns the session handoff. Raw LoadURL (no
+    // wxURI re-serialisation) so the Complete URL's #fragment stays intact; never logged.
+    void load_cloud_url(const wxString& url);
+
+    // Clears the cloud pane's own session on an explicit desktop sign-out. If the pane has not
+    // been created yet, the sign-out is remembered and applied when it is first opened.
+    void cloud_signed_out(const wxString& signout_url);
+
     bool Show(bool show = true) override;
 private:
     void create_browser();
+    void create_cloud_browser();
     void reset_browser();
+    // Consumes the cloud pane's webview events so they stay off the homepage handlers.
+    void OnCloudWebViewEvent(wxWebViewEvent& evt);
+    // True when `url` has the same scheme/host/port as the cloud origin ({web}).
+    bool is_cloud_origin(const wxString& url) const;
+    // True when a navigation to `url` must leave the pane: an http(s) URL on another origin than
+    // the (known) cloud origin. False for non-web schemes and while the origin is unknown.
+    bool should_divert_cloud_url(const wxString& url) const;
+    // Parses a request_web_session message and defers it to GUI_App.
+    void on_cloud_script_message(const std::string& body);
+    // Loads `url`, first clearing a lazily-required sign-out (see cloud_signed_out).
+    void load_cloud_after_signout(const wxString& url);
+    // First load of a freshly created pane: deferred so CreateWebView's queued "wx" handler add
+    // runs first and the page sees window.wx at load time (guide §3).
+    void schedule_cloud_load(const wxString& url);
+    // Clears the pane's stored web data (its cookie-backed session) on an explicit sign-out.
+    void clear_cloud_storage();
+    // Re-applies the content sizer's proportions and min sizes for the cloud state.
+    void apply_cloud_layout(bool cloud_on);
 
     wxWebView* m_browser;
+    wxWebView* m_cloud_browser{nullptr};
+    wxBoxSizer* m_content_sizer{nullptr};
     wxString m_home_url;
     bool m_reset_on_show{false};
+    // {web} origin (scheme://host[:port]) of the loaded pane. Set from every load, including the
+    // plain cloud fallback, so navigation policy can keep {web} pages in the pane and send other
+    // sites to the system browser.
+    wxString m_cloud_base_url;
+    // Start URL the pane was last seeded with. An open whose URL matches this is an ordinary
+    // re-open (nothing changed), so it only shows the pane instead of reloading it (guide §10).
+    wxString m_cloud_seed_url;
+    // Sign-out clear the pane must apply once it exists / next loads.
+    wxString m_cloud_signout_url;
+    wxString m_cloud_after_signout_url;
+    bool     m_cloud_pending_signout{false};
     wxButton *  m_button_stop;
     wxTextCtrl *m_url;
 #if !BBL_RELEASE_TO_PUBLIC

src/slic3r/GUI/Widgets/WebView.cpp

@@ -418,6 +418,12 @@ bool WebView::DownloadAndInstallWebViewRuntime()
     return DownloadAndInstallWV2RT() == 0;
 }
 #endif
+wxString WebView::RedactUrl(const wxString& url)
+{
+    const size_t cut = url.find_first_of(wxString("?#"));
+    return cut == wxString::npos ? url : url.Left(cut);
+}
+
 void WebView::LoadUrl(wxWebView * webView, wxString const &url)
 {
     auto url2  = url;
@@ -425,7 +431,7 @@ void WebView::LoadUrl(wxWebView * webView, wxString const &url)
     url2.Replace("\\", "/");
 #endif
     if (!url2.empty()) { url2 = wxURI(url2).BuildURI(); }
-    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << url2.ToUTF8();
+    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << RedactUrl(url2).ToUTF8();
     webView->LoadURL(url2);
 }
 

src/slic3r/GUI/Widgets/WebView.hpp

@@ -21,6 +21,10 @@ public:
 #endif
     static void LoadUrl(wxWebView * webView, wxString const &url);
 
+    // Returns the URL truncated at the first '?' or '#', so a query/fragment carrying secrets
+    // (e.g. a session-handoff token) is never written to a log.
+    static wxString RedactUrl(const wxString& url);
+
     static bool RunScript(wxWebView * webView, wxString const & msg);
 
     // Marks "wx" as registered so CreateWebView's deferred add skips the duplicate.

src/slic3r/Utils/Http.cpp

@@ -482,6 +482,14 @@ void Http::priv::http_perform()
 	if (!postfields.empty()) {
 		::curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfields.c_str());
 		::curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, postfields.size());
+	} else if (method == "POST" && form == nullptr && mime == nullptr) {
+		// A POST with no body. Without CURLOPT_POSTFIELDS, curl takes the request body from
+		// the read callback, but form_file_read_cb only has a usable user pointer for a PUT
+		// (set_put_body) or a streamed multipart part (form_add_file); for an empty POST it
+		// dereferences libcurl's default READDATA as a form_file and crashes. Point curl at a
+		// zero-length body so the read callback is never used.
+		::curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfields.c_str());
+		::curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, static_cast<curl_off_t>(0));
 	}
 
 	CURLcode res = ::curl_easy_perform(curl);

src/slic3r/Utils/OrcaCloudServiceAgent.cpp

@@ -108,6 +108,10 @@ constexpr const char* ORCA_CLOUD_PRINTER       = "/api/v1/printers";
 
 constexpr const char* ORCA_CLOUD_LOGIN_PATH = "/orcaslicer-login";
 
+// Gateway endpoint that mints a one-time web-session handoff token for the signed-in desktop
+// user. The cloud pane reloads the returned token into the webview (see build_web_session_*).
+constexpr const char* ORCA_WEB_SESSION_HANDOFF_PATH = "/api/v1/account/web-session-handoff";
+
 constexpr const char* CONFIG_ORCA_API_URL   = "orca_api_url";
 constexpr const char* CONFIG_ORCA_AUTH_URL  = "orca_auth_url";
 constexpr const char* CONFIG_ORCA_CLOUD_URL = "orca_cloud_url";
@@ -3018,6 +3022,148 @@ std::string OrcaCloudServiceAgent::get_cloud_login_url(const std::string& langua
     return url;
 }
 
+// Percent-encodes every byte outside the RFC 3986 unreserved set (A-Za-z0-9-._~), so token values
+// survive fragment parsing intact. Deliberately tiny: no URL-encoder dependency.
+static std::string percent_encode_unreserved(const std::string& s)
+{
+    static const char* const hex = "0123456789ABCDEF";
+    std::string out;
+    out.reserve(s.size());
+    for (unsigned char c : s) {
+        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
+            c == '-' || c == '.' || c == '_' || c == '~') {
+            out.push_back(static_cast<char>(c));
+        } else {
+            out.push_back('%');
+            out.push_back(hex[c >> 4]);
+            out.push_back(hex[c & 0x0F]);
+        }
+    }
+    return out;
+}
+
+std::string OrcaCloudServiceAgent::build_web_session_start_url(const std::string& next) const
+{
+    if (cloud_base_url.empty())
+        return "";
+
+    // The page replaces a `next` that is not a same-site path with /app/profiles, so pass a
+    // same-site path (the guide's default) and let it validate.
+    std::string url = cloud_base_url + "/auth/handoff?next=" +
+                      percent_encode_unreserved(next.empty() ? "/app/profiles" : next);
+
+    std::lock_guard<std::mutex> lock(session_mutex);
+    if (session.logged_in && !session.user_id.empty())
+        url += "&user_id=" + percent_encode_unreserved(session.user_id);
+    return url;
+}
+
+std::string OrcaCloudServiceAgent::build_web_session_complete_url(const std::string& token_hash,
+                                                                  const std::string& state) const
+{
+    if (cloud_base_url.empty() || token_hash.empty() || state.empty())
+        return "";
+
+    // Fragment (not query) so the one-time token never reaches a server or a log.
+    return cloud_base_url + "/auth/handoff#token_hash=" + percent_encode_unreserved(token_hash) +
+           "&state=" + percent_encode_unreserved(state);
+}
+
+std::string OrcaCloudServiceAgent::build_web_session_signout_url() const
+{
+    if (cloud_base_url.empty())
+        return "";
+    return cloud_base_url + "/auth/handoff?signout=1";
+}
+
+// Extracts the machine-readable code from a handoff error body. 401 uses {"error":"<code>"};
+// the other statuses use {"error":{"code":"<code>","message":"..."}}.
+static std::string handoff_error_code(const std::string& body)
+{
+    const json j = json::parse(body, nullptr, false);
+    if (j.is_discarded() || !j.is_object() || !j.contains("error"))
+        return "";
+    const auto& err = j["error"];
+    if (err.is_string())
+        return err.get<std::string>();
+    if (err.is_object() && err.contains("code") && err["code"].is_string())
+        return err["code"].get<std::string>();
+    return "";
+}
+
+int OrcaCloudServiceAgent::request_web_session_handoff(std::string& token_hash, std::string& error_code,
+                                                       unsigned int& http_code)
+{
+    token_hash.clear();
+    error_code.clear();
+    http_code = 0;
+
+    const std::string url = api_base_url + ORCA_WEB_SESSION_HANDOFF_PATH;
+    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: POST " << ORCA_WEB_SESSION_HANDOFF_PATH;
+
+    // Refresh the desktop token the usual way before minting (newest access token).
+    ensure_token_fresh("web_session_handoff");
+
+    auto perform = [&]() {
+        HttpResult result;
+        try {
+            auto http = Http::post(url);
+            http.tls_verify(true);
+
+            const std::string token = get_access_token();
+
+            auto headers = data_headers();
+            for (const auto& pair : headers) {
+                http.header(pair.first, pair.second);
+            }
+            if (!token.empty()) {
+                http.header("Authorization", "Bearer " + token);
+            }
+
+            // No request body: the endpoint identifies the user by the bearer token alone.
+            http.on_complete([&](std::string resp_body, unsigned resp_status) {
+                    result.success = true;
+                    result.status  = resp_status;
+                    result.body    = resp_body;
+                })
+                .on_error([&](std::string resp_body, std::string error, unsigned resp_status) {
+                    result.success = false;
+                    result.status  = resp_status == 0 ? 404 : resp_status;
+                    result.body    = resp_body;
+                    BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: web-session-handoff HTTP error - " << error;
+                })
+                .timeout_max(30)
+                .perform_sync();
+
+        } catch (const std::exception& e) {
+            BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: web-session-handoff exception - " << e.what();
+        }
+        return result;
+    };
+
+    HttpResult res = perform();
+    // Reuse the shared 401 policy (refresh once, then retry), exactly like http_get/http_post:
+    // `suppress` is true for a transient refresh failure (keep the session and token, no logout)
+    // and false when the refresh token was rejected — so a 401 that remains after the refresh
+    // surfaces through the generic HTTP-error callback and drives the normal desktop logout.
+    // Every other handoff status (409/429/503/transport) stays silent here, so the page can
+    // offer "Try again" instead of the desktop showing a generic cloud error.
+    const bool suppress = resolve_unauthorized(res, perform, "web_session_handoff");
+    if (!suppress && res.status == 401)
+        invoke_http_error_callback(res.status, res.body);
+
+    http_code = res.status;
+    if (res.status == 200) {
+        const json j = json::parse(res.body, nullptr, false);
+        if (!j.is_discarded() && j.is_object() && j.contains("token_hash") && j["token_hash"].is_string())
+            token_hash = j["token_hash"].get<std::string>();
+    } else {
+        error_code = handoff_error_code(res.body);
+    }
+
+    return (res.success && res.status == 200) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED;
+}
+
 int OrcaCloudServiceAgent::get_mw_user_preference(std::function<void(std::string)> callback)
 {
     BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_mw_user_preference (stub)";

src/slic3r/Utils/OrcaCloudServiceAgent.hpp

@@ -203,6 +203,28 @@ public:
     // ========================================================================
     std::string get_cloud_service_host() override;
     std::string get_cloud_login_url(const std::string& language = "") override;
+
+    // ========================================================================
+    // OrcaCloud webview session handoff (OrcaCloud "Webview Session Handoff" guide)
+    // ========================================================================
+    // The cloud pane never receives the desktop's access/refresh tokens. Instead the page posts
+    // request_web_session, the desktop mints a single-use token through the gateway and loads the
+    // Complete URL; the site then signs itself in. These builders return "" when no cloud URL is
+    // configured.
+    //
+    // Start URL: {web}/auth/handoff?next=<path>[&user_id=<desktop user id>]. `next` defaults to
+    // /app/profiles; user_id is included only while signed in.
+    std::string build_web_session_start_url(const std::string& next = std::string()) const;
+    // Complete URL: {web}/auth/handoff#token_hash=<hash>&state=<state>. Both values URL-encoded.
+    std::string build_web_session_complete_url(const std::string& token_hash, const std::string& state) const;
+    // Clears only the webview's own session; loaded on an explicit desktop sign-out.
+    std::string build_web_session_signout_url() const;
+    // POST {api}/api/v1/account/web-session-handoff with the desktop access token (no body),
+    // refreshing once on 401 through the shared policy. On 200 writes the single-use `token_hash`;
+    // otherwise writes the server's error code (e.g. WEB_SESSION_HANDOFF_UNAVAILABLE) into
+    // `error_code`. Blocking: call from a worker thread. Never logs the token.
+    int request_web_session_handoff(std::string& token_hash, std::string& error_code, unsigned int& http_code);
+
     int connect_server() override;
     bool is_server_connected() override;
     int refresh_connection() override;

tests/libslic3r/test_texture_displacement.cpp

@@ -28,7 +28,6 @@
 
 #include <algorithm>
 #include <array>
-#include <functional>
 #include <cmath>
 #include <fstream>
 #include <limits>
@@ -1302,294 +1301,6 @@ TEST_CASE("TextureDisplacement: the step cutter only cuts inside the region", "[
     }
 }
 
-// ---- Image adjustments (the gizmo's image-adjustment panel) ----------------------------------------
-
-// A grayscale ramp 0..255 across the width, so every input level is present exactly once per row and a
-// tonal curve can be read straight off the output.
-static DecodedHeightTexture make_gray_ramp(int w = 256, int h = 4)
-{
-    DecodedHeightTexture t;
-    t.width  = w;
-    t.height = h;
-    t.pixels.resize(size_t(w) * size_t(h));
-    for (int y = 0; y < h; ++y)
-        for (int x = 0; x < w; ++x)
-            t.pixels[size_t(y) * size_t(w) + size_t(x)] = uint8_t(x * 255 / std::max(1, w - 1));
-    return t;
-}
-
-// A one-texel checkerboard of 0 and 255 - the highest spatial frequency the grid can hold, which is what
-// a blur has to remove and a downscale has to average rather than drop.
-static DecodedHeightTexture make_gray_checkerboard(int w = 16, int h = 16)
-{
-    DecodedHeightTexture t;
-    t.width  = w;
-    t.height = h;
-    t.pixels.resize(size_t(w) * size_t(h));
-    for (int y = 0; y < h; ++y)
-        for (int x = 0; x < w; ++x)
-            t.pixels[size_t(y) * size_t(w) + size_t(x)] = ((x + y) % 2 == 0) ? 0 : 255;
-    return t;
-}
-
-static DecodedHeightTexture make_rgb_flat(uint8_t r, uint8_t g, uint8_t b, int w = 8, int h = 8)
-{
-    DecodedHeightTexture t;
-    t.width  = w;
-    t.height = h;
-    t.pixels.resize(size_t(w) * size_t(h));
-    t.rgb.resize(size_t(w) * size_t(h) * 3);
-    for (size_t i = 0; i < size_t(w) * size_t(h); ++i) {
-        t.rgb[i * 3]     = r;
-        t.rgb[i * 3 + 1] = g;
-        t.rgb[i * 3 + 2] = b;
-        t.pixels[i]      = uint8_t(std::lround(0.299 * r + 0.587 * g + 0.114 * b));
-    }
-    return t;
-}
-
-TEST_CASE("an adjustment that moves no slider returns the image unchanged", "[TextureDisplacement]")
-{
-    const DecodedHeightTexture src = make_gray_ramp();
-    const DecodedHeightTexture out = apply_texture_adjustments(src, TextureAdjustments{});
-    CHECK(out.width == src.width);
-    CHECK(out.height == src.height);
-    CHECK(out.pixels == src.pixels);
-    CHECK(TextureAdjustments{}.identity());
-}
-
-TEST_CASE("brightness reaches pure white and pure black only at the ends of its range", "[TextureDisplacement]")
-{
-    const DecodedHeightTexture src = make_gray_ramp();
-
-    TextureAdjustments up;
-    up.brightness = 1.f;
-    const DecodedHeightTexture white = apply_texture_adjustments(src, up);
-    CHECK(std::all_of(white.pixels.begin(), white.pixels.end(), [](uint8_t v) { return v == 255; }));
-
-    TextureAdjustments down;
-    down.brightness = -1.f;
-    const DecodedHeightTexture black = apply_texture_adjustments(src, down);
-    CHECK(std::all_of(black.pixels.begin(), black.pixels.end(), [](uint8_t v) { return v == 0; }));
-}
-
-TEST_CASE("brightness lifts the image without flattening it into a clipped plateau", "[TextureDisplacement]")
-{
-    // The reason brightness is a lift toward white rather than an additive offset: an offset would drive
-    // everything above mid-grey to a flat 255, and since this image is also the height map that region
-    // would bake as flat relief. Half a stop up must leave almost nothing at pure white.
-    const DecodedHeightTexture src = make_gray_ramp();
-    TextureAdjustments         adj;
-    adj.brightness = 0.5f;
-    const DecodedHeightTexture out = apply_texture_adjustments(src, adj);
-
-    REQUIRE(out.pixels.size() == src.pixels.size());
-    const size_t clipped = size_t(std::count(out.pixels.begin(), out.pixels.end(), uint8_t(255)));
-    CHECK(clipped * 100 < out.pixels.size()); // under 1%; an additive shift would clip half the ramp
-
-    // Every texel got brighter, and the curve stays ordered: brighter in means brighter out.
-    for (size_t i = 0; i < out.pixels.size(); ++i)
-        REQUIRE(out.pixels[i] >= src.pixels[i]);
-    for (int x = 1; x < out.width; ++x)
-        REQUIRE(out.pixels[size_t(x)] >= out.pixels[size_t(x - 1)]);
-}
-
-TEST_CASE("contrast at its lowest flattens the image to mid-grey and at its highest spreads it apart",
-          "[TextureDisplacement]")
-{
-    const DecodedHeightTexture src = make_gray_ramp();
-
-    TextureAdjustments flat;
-    flat.contrast = -1.f;
-    const DecodedHeightTexture grey = apply_texture_adjustments(src, flat);
-    // One value everywhere - the pivot. Which exact level that rounds to is not the point.
-    CHECK(std::adjacent_find(grey.pixels.begin(), grey.pixels.end(), std::not_equal_to<uint8_t>()) ==
-          grey.pixels.end());
-
-    TextureAdjustments hard;
-    hard.contrast = 1.f;
-    const DecodedHeightTexture split = apply_texture_adjustments(src, hard);
-    // A threshold about the pivot: the dark end of the ramp goes to black, the light end to white.
-    CHECK(split.pixels[0] == 0);
-    CHECK(split.pixels[size_t(split.width - 1)] == 255);
-}
-
-TEST_CASE("blur removes the finest detail and sharpness exaggerates an edge", "[TextureDisplacement]")
-{
-    // Blur: a one-texel checkerboard is the highest frequency the grid holds, so a blur has to collapse it
-    // toward its own mean. Measured as mean absolute deviation, which needs no assumption about the mean.
-    const DecodedHeightTexture checker = make_gray_checkerboard(32, 32);
-    const auto                 deviation = [](const DecodedHeightTexture &t) {
-        double mean = 0.;
-        for (uint8_t v : t.pixels)
-            mean += double(v);
-        mean /= double(t.pixels.size());
-        double dev = 0.;
-        for (uint8_t v : t.pixels)
-            dev += std::abs(double(v) - mean);
-        return dev / double(t.pixels.size());
-    };
-    TextureAdjustments blur;
-    blur.blur = 1.f;
-    CHECK(deviation(apply_texture_adjustments(checker, blur)) < 0.25 * deviation(checker));
-
-    // Sharpness: an unsharp mask pushes each side of a step further from the other, so the step
-    // overshoots - darker than the dark side just inside it, brighter than the bright side just inside.
-    DecodedHeightTexture step;
-    step.width  = 64;
-    step.height = 8;
-    step.pixels.assign(size_t(step.width) * size_t(step.height), 100);
-    for (int y = 0; y < step.height; ++y)
-        for (int x = step.width / 2; x < step.width; ++x)
-            step.pixels[size_t(y) * size_t(step.width) + size_t(x)] = 150;
-
-    TextureAdjustments sharp;
-    sharp.sharpness = 1.f;
-    const DecodedHeightTexture sharpened = apply_texture_adjustments(step, sharp);
-    const size_t               row       = size_t(step.height / 2) * size_t(step.width);
-    const size_t               mid       = size_t(step.width / 2);
-    CHECK(sharpened.pixels[row + mid - 1] < 100); // undershoot on the dark side of the step
-    CHECK(sharpened.pixels[row + mid] > 150);     // overshoot on the light side
-}
-
-TEST_CASE("a grayscale image stays grayscale and its hue slider does nothing", "[TextureDisplacement]")
-{
-    const DecodedHeightTexture src = make_gray_ramp();
-    REQUIRE_FALSE(src.has_color());
-
-    TextureAdjustments hue;
-    hue.hue_deg = 120.f;
-    const DecodedHeightTexture out = apply_texture_adjustments(src, hue);
-    // Not promoted to RGB: a grey image has no colour to offer the layer's colour feature, and storing it
-    // as RGB would triple the PNG for a row of identical greys.
-    CHECK_FALSE(out.has_color());
-    CHECK(out.rgb.empty());
-    CHECK(out.pixels == src.pixels);
-}
-
-TEST_CASE("a colour image's height stays the luminance of its adjusted colour", "[TextureDisplacement]")
-{
-    // The invariant that keeps the relief and the colour from drifting apart: whatever the adjustment did
-    // to the channels, the height is recomputed from the channels that came out.
-    const DecodedHeightTexture src = make_rgb_flat(200, 60, 30);
-    REQUIRE(src.has_color());
-
-    TextureAdjustments adj;
-    adj.brightness = 0.2f;
-    adj.contrast   = 0.3f;
-    adj.hue_deg    = 75.f;
-    const DecodedHeightTexture out = apply_texture_adjustments(src, adj);
-    REQUIRE(out.has_color());
-
-    for (size_t i = 0; i < out.pixels.size(); ++i) {
-        const long expect = std::lround(0.299 * out.rgb[i * 3] + 0.587 * out.rgb[i * 3 + 1] +
-                                        0.114 * out.rgb[i * 3 + 2]);
-        REQUIRE(long(out.pixels[i]) == expect);
-    }
-    // The hue turn actually moved the colour, so the check above is not passing on an unchanged image.
-    CHECK(out.rgb != src.rgb);
-}
-
-TEST_CASE("a full turn of the hue leaves a colour where it started", "[TextureDisplacement]")
-{
-    const DecodedHeightTexture src = make_rgb_flat(200, 60, 30);
-    TextureAdjustments         adj;
-    adj.hue_deg                    = 360.f;
-    const DecodedHeightTexture out = apply_texture_adjustments(src, adj);
-    REQUIRE(out.has_color());
-    // Rounding through 8-bit channels, so a level or two of slack rather than exact equality.
-    for (size_t i = 0; i < out.rgb.size(); ++i)
-        REQUIRE(std::abs(int(out.rgb[i]) - int(src.rgb[i])) <= 2);
-}
-
-TEST_CASE("the adjustment blur radius ramps from zero and stays under its cost cap", "[TextureDisplacement]")
-{
-    CHECK_THAT(adjustment_blur_radius(0.f, 512, 512), Catch::Matchers::WithinAbs(0.f, 1e-6f));
-    // 5% of the short side, as the Smoothing slider uses.
-    CHECK_THAT(adjustment_blur_radius(1.f, 512, 512), Catch::Matchers::WithinAbs(25.6f, 1e-3f));
-    CHECK_THAT(adjustment_blur_radius(0.5f, 512, 512), Catch::Matchers::WithinAbs(12.8f, 1e-3f));
-    // Capped, so a large image at the top of the slider cannot cost without bound.
-    CHECK_THAT(adjustment_blur_radius(1.f, 8192, 8192), Catch::Matchers::WithinAbs(48.f, 1e-3f));
-    // Sized off the short side, not the long one.
-    CHECK_THAT(adjustment_blur_radius(1.f, 4096, 200), Catch::Matchers::WithinAbs(10.f, 1e-3f));
-}
-
-TEST_CASE("downscaling a height texture averages the texels it drops and never upscales",
-          "[TextureDisplacement]")
-{
-    // Averaging, not decimation: a one-texel checkerboard halved must come out uniformly mid-grey. Picking
-    // one texel per block would instead come out all black or all white - detail the adjustment never
-    // produced, shown in the preview.
-    const DecodedHeightTexture small = downscale_height_texture(make_gray_checkerboard(16, 16), 8);
-    CHECK(small.width == 8);
-    CHECK(small.height == 8);
-    CHECK(std::all_of(small.pixels.begin(), small.pixels.end(), [](uint8_t v) { return v == 127; }));
-
-    // Already within the limit: handed back as it is.
-    const DecodedHeightTexture ramp = make_gray_ramp(64, 4);
-    const DecodedHeightTexture same = downscale_height_texture(ramp, 256);
-    CHECK(same.width == ramp.width);
-    CHECK(same.height == ramp.height);
-    CHECK(same.pixels == ramp.pixels);
-
-    // Aspect preserved, and a colour source keeps its colour.
-    const DecodedHeightTexture wide = downscale_height_texture(make_rgb_flat(200, 60, 30, 400, 100), 100);
-    CHECK(wide.width == 100);
-    CHECK(wide.height == 25);
-    CHECK(wide.has_color());
-}
-
-TEST_CASE("a layer's live image adjustment reaches its decode", "[TextureDisplacement]")
-{
-    // This is what makes the image-adjustment panel's sliders move the relief: decode_height_texture()
-    // applies the layer's preview_adjust, so everything downstream of the decode - the displacement, the
-    // colour, the thumbnails, the bake - sees the adjusted image without being told about the panel.
-    TextureDisplacementLayer layer;
-    layer.image_data = make_checkerboard_png(32, 32);
-
-    const DecodedHeightTexture raw = decode_height_texture(layer);
-    REQUIRE_FALSE(raw.empty());
-
-    // An untouched panel, and a closed one, cost nothing and change nothing.
-    layer.preview_adjust = TextureAdjustments{};
-    CHECK(decode_height_texture(layer).pixels == raw.pixels);
-
-    layer.preview_adjust.brightness = 0.5f;
-    const DecodedHeightTexture bright = decode_height_texture(layer);
-    CHECK(bright.pixels != raw.pixels);
-    CHECK(bright.pixels == apply_texture_adjustments(raw, layer.preview_adjust).pixels);
-
-    // Back to identity gives the stored image back, so closing the panel really does revert the layer.
-    layer.preview_adjust = TextureAdjustments{};
-    CHECK(decode_height_texture(layer).pixels == raw.pixels);
-}
-
-TEST_CASE("changing a live adjustment is not served the previous one from cache", "[TextureDisplacement]")
-{
-    // The decode caches by the image_data pointer, which does not change while a slider moves - so the
-    // adjustment has to be part of the key or every slider move past the first would redraw the same
-    // pixels. Same for the smoothed copy, which is computed on top of the adjusted one.
-    TextureDisplacementLayer layer;
-    layer.image_data = make_checkerboard_png(32, 32);
-    const DecodedHeightTexture raw = decode_height_texture(layer);
-    REQUIRE_FALSE(raw.empty());
-
-    layer.preview_adjust.brightness = 0.5f;
-    const std::vector<uint8_t> bright = decode_height_texture(layer).pixels;
-    layer.preview_adjust.brightness   = -0.5f;
-    const std::vector<uint8_t> dark   = decode_height_texture(layer).pixels;
-    CHECK(bright != dark);
-    CHECK(dark == apply_texture_adjustments(raw, layer.preview_adjust).pixels);
-
-    // The same question again with smoothing on, which is cached separately and keyed by both.
-    layer.smoothing                 = 0.5f;
-    layer.preview_adjust.brightness = 0.5f;
-    const std::vector<uint8_t> smooth_bright = decode_height_texture(layer).pixels;
-    layer.preview_adjust.brightness          = -0.5f;
-    const std::vector<uint8_t> smooth_dark   = decode_height_texture(layer).pixels;
-    CHECK(smooth_bright != smooth_dark);
-}
-
 // ---------------------------------------------------------------------------------------------
 // Texture smoothing
 // ---------------------------------------------------------------------------------------------
@@ -1942,321 +1653,6 @@ TEST_CASE("Per-corner LSCM UVs give each triangle its own island's placement", "
     CHECK(differs);
 }
 
-// ---------------------------------------------------------------------------------------------
-// UV orientation: which way up a texture lands on the model.
-//
-// v = 0 is the height map's *first* pixel row, i.e. its top (DecodedHeightTexture::sample(), and
-// the UV editor negates Y on screen for the same reason). So "the image is the right way up" is the
-// statement that the row a point samples gets *lower* as the point moves up the face, and "it is
-// not left-right mirrored" is that the column gets higher as the point moves to the right of a
-// viewer standing outside the model. Both are measured below by sampling a ramp whose value says
-// which row (or column) it came from, which settles the question without having to reason about the
-// uv transform at all.
-
-static constexpr int   RAMP_N      = 64;   // the ramp texture's size, in texels
-static constexpr float RAMP_TILING = 40.f; // mm per tile
-static constexpr float CUBE_HALF   = 5.f;  // half extent of the cube the probes walk over
-// How far a probe steps off a face centre. Short on purpose: the cylindrical and spherical u is an
-// arc length (angle * radius), so a long step also changes the radius, and that term swamps the
-// angular one. It is symmetric about the face centre, so at a short step it cancels between the two
-// readings a check compares.
-static constexpr float RAMP_STEP   = 1.f;
-// What one step's worth of travel is in ramp rows: 2 * RAMP_STEP mm of separation, RAMP_N texels per
-// RAMP_TILING mm. Halved as the margin a check demands, so "flat" cannot pass as either direction.
-static constexpr double RAMP_MARGIN = RAMP_N * RAMP_STEP / RAMP_TILING;
-
-// A height map whose rows (or columns) carry a linear ramp: row r holds 3 + 4r, so the sampled
-// height identifies the row. Built directly rather than through a PNG because these tests are about
-// the projection, not the decoder - decode_height_texture() has its own tests.
-static DecodedHeightTexture ramp_texture(bool by_row)
-{
-    DecodedHeightTexture t;
-    t.width = t.height = RAMP_N;
-    t.pixels.resize(size_t(RAMP_N) * size_t(RAMP_N));
-    for (int y = 0; y < RAMP_N; ++y)
-        for (int x = 0; x < RAMP_N; ++x)
-            t.pixels[size_t(y) * size_t(RAMP_N) + size_t(x)] = uint8_t(3 + 4 * (by_row ? y : x));
-    return t;
-}
-
-// uv 0.5 at the cube's centre, and a tile wide enough that every point the probes visit stays well
-// inside the one tile - so no reading is a wrapped-around neighbour of the one it is compared with.
-static TextureDisplacementLayer ramp_layer(TextureProjectionMethod method)
-{
-    TextureDisplacementLayer layer;
-    layer.projection_method = method;
-    layer.tiling_scale      = RAMP_TILING;
-    layer.offset            = Vec2f(0.5f, 0.5f);
-    layer.depth_mm          = 1.f;
-    return layer;
-}
-
-// Which row (or column) of `ramp` the layer reads at `p`. Fractional, because a point between two
-// texels reads the ramp between them; only the direction it moves in matters here.
-static double ramp_index(const DecodedHeightTexture &ramp, const TextureDisplacementLayer &layer, const Vec3f &p,
-                         const Vec3f &n, const Vec3f &center = Vec3f(Vec3f::Zero()),
-                         const Vec3f &axis = Vec3f(Vec3f::UnitZ()))
-{
-    return (double(sample_layer_height(ramp, layer, p, n, center, axis, nullptr)) * 255.0 - 3.0) / 4.0;
-}
-
-// How a viewer standing outside the model sees a face: their right, and their up. Up is world +Z on
-// the four upright faces; on the top and bottom, where +Z is edge on, it is world +Y.
-static void outside_viewer_frame(const Vec3f &n, Vec3f &right, Vec3f &up)
-{
-    up    = (std::abs(n.z()) < 0.9f) ? Vec3f(0.f, 0.f, 1.f) : Vec3f(0.f, 1.f, 0.f);
-    right = Vec3f((-n).cross(up).normalized());
-}
-
-static const std::array<std::pair<const char *, Vec3f>, 6> CUBE_FACES = { {
-    { "+X", Vec3f(1.f, 0.f, 0.f) },
-    { "-X", Vec3f(-1.f, 0.f, 0.f) },
-    { "+Y", Vec3f(0.f, 1.f, 0.f) },
-    { "-Y", Vec3f(0.f, -1.f, 0.f) },
-    { "+Z", Vec3f(0.f, 0.f, 1.f) },
-    { "-Z", Vec3f(0.f, 0.f, -1.f) },
-} };
-
-TEST_CASE("the box projection lands a texture upright and unmirrored on all six faces of a cube",
-          "[TextureDisplacement]")
-{
-    const DecodedHeightTexture     rows  = ramp_texture(true);
-    const DecodedHeightTexture     cols  = ramp_texture(false);
-    const TextureDisplacementLayer layer = ramp_layer(TextureProjectionMethod::Triplanar);
-
-    for (const auto &[name, n] : CUBE_FACES) {
-        DYNAMIC_SECTION("face " << name)
-        {
-            Vec3f right, up;
-            outside_viewer_frame(n, right, up);
-            const Vec3f centre = n * CUBE_HALF;
-
-            // Upright: the row read near the top of the face is nearer the image's first row.
-            const double row_up   = ramp_index(rows, layer, centre + up * RAMP_STEP, n);
-            const double row_down = ramp_index(rows, layer, centre - up * RAMP_STEP, n);
-            INFO("row at the top of the face " << row_up << ", at the bottom " << row_down);
-            CHECK(row_down - row_up > RAMP_MARGIN);
-
-            // Unmirrored: the column read to the viewer's right is further into the image. Without a
-            // per-side sign this fails on exactly the three faces facing away - -X, +Y and -Z - which
-            // is the mirroring a bare v flip leaves behind.
-            const double col_left  = ramp_index(cols, layer, centre - right * RAMP_STEP, n);
-            const double col_right = ramp_index(cols, layer, centre + right * RAMP_STEP, n);
-            INFO("column at the left of the face " << col_left << ", at the right " << col_right);
-            CHECK(col_right - col_left > RAMP_MARGIN);
-        }
-    }
-}
-
-TEST_CASE("every projection method lands a texture upright on an upright face", "[TextureDisplacement]")
-{
-    const DecodedHeightTexture rows = ramp_texture(true);
-    // ViewProjected is one flat projection from the captured camera rather than a per-face map, so its
-    // "up" is the projector's own (view_project_up), which the default capture puts at +Y.
-    const auto method = GENERATE(TextureProjectionMethod::Triplanar, TextureProjectionMethod::Cylindrical,
-                                 TextureProjectionMethod::Spherical, TextureProjectionMethod::ViewProjected);
-    const TextureDisplacementLayer layer = ramp_layer(method);
-
-    for (const auto &[name, n] : CUBE_FACES) {
-        // Only the four upright faces: on the top and bottom a cylinder's v is constant (they are its
-        // caps) and a sphere's is at an extremum (they are its poles), so neither says anything about
-        // which way up the image is.
-        if (std::abs(n.z()) > 0.9f)
-            continue;
-        DYNAMIC_SECTION("method " << int(method) << ", face " << name)
-        {
-            const Vec3f up = (method == TextureProjectionMethod::ViewProjected) ? layer.view_project_up :
-                                                                                 Vec3f(0.f, 0.f, 1.f);
-            const Vec3f centre = n * CUBE_HALF;
-            const double row_up   = ramp_index(rows, layer, centre + up * RAMP_STEP, n);
-            const double row_down = ramp_index(rows, layer, centre - up * RAMP_STEP, n);
-            INFO("row at the top " << row_up << ", at the bottom " << row_down);
-            CHECK(row_down - row_up > RAMP_MARGIN);
-        }
-    }
-}
-
-TEST_CASE("the cylindrical and spherical wraps run left to right as seen from outside", "[TextureDisplacement]")
-{
-    const DecodedHeightTexture cols = ramp_texture(false);
-    const auto method = GENERATE(TextureProjectionMethod::Cylindrical, TextureProjectionMethod::Spherical);
-    const TextureDisplacementLayer layer = ramp_layer(method);
-
-    for (const auto &[name, n] : CUBE_FACES) {
-        // The caps and poles are out, as above - u is undefined on the axis. So is whichever face the
-        // atan2 branch cut runs through, where u jumps from +pi to -pi: that is a real seam in both
-        // projections, and a reading taken across it compares two opposite sides of the model.
-        if (std::abs(n.z()) > 0.9f)
-            continue;
-        const bool on_the_cut = (method == TextureProjectionMethod::Cylindrical) ? (n.y() < -0.9f) : (n.x() < -0.9f);
-        if (on_the_cut)
-            continue;
-        DYNAMIC_SECTION("method " << int(method) << ", face " << name)
-        {
-            Vec3f right, up;
-            outside_viewer_frame(n, right, up);
-            const Vec3f  centre    = n * CUBE_HALF;
-            const double col_left  = ramp_index(cols, layer, centre - right * RAMP_STEP, n);
-            const double col_right = ramp_index(cols, layer, centre + right * RAMP_STEP, n);
-            INFO("column at the left " << col_left << ", at the right " << col_right);
-            CHECK(col_right - col_left > RAMP_MARGIN);
-        }
-    }
-}
-
-TEST_CASE("an unwrapped cube's flat charts are laid out the right way up", "[TextureDisplacement]")
-{
-    indexed_triangle_set cube = its_make_cube(2. * CUBE_HALF, 2. * CUBE_HALF, 2. * CUBE_HALF);
-    for (Vec3f &v : cube.vertices)
-        v -= Vec3f(CUBE_HALF, CUBE_HALF, CUBE_HALF);
-
-    const PatchUnwrap unwrap = compute_patch_unwrap(cube, LSCM_DEFAULT_SEAM_ANGLE_DEG);
-    REQUIRE_FALSE(unwrap.empty());
-    REQUIRE(unwrap.chart_count == 6); // one flat chart per face, cut at the 90-degree edges
-
-    // Each chart carries one face. The four upright ones span world Z, and their v has to grow
-    // downwards like every other projection's - whatever the packing then did with the island.
-    int upright_charts = 0;
-    for (int c = 0; c < unwrap.chart_count; ++c) {
-        int top = -1, bottom = -1;
-        for (size_t i = 0; i < unwrap.uvs.size(); ++i) {
-            if (unwrap.vertex_chart[i] != c)
-                continue;
-            const float z = cube.vertices[size_t(unwrap.source_vertex[i])].z();
-            if (top < 0 || z > cube.vertices[size_t(unwrap.source_vertex[size_t(top)])].z())
-                top = int(i);
-            if (bottom < 0 || z < cube.vertices[size_t(unwrap.source_vertex[size_t(bottom)])].z())
-                bottom = int(i);
-        }
-        REQUIRE(top >= 0);
-        REQUIRE(bottom >= 0);
-        const float v_top = unwrap.uvs[size_t(top)].y(), v_bottom = unwrap.uvs[size_t(bottom)].y();
-        if (std::abs(v_top - v_bottom) < 1e-3f)
-            continue; // a cap: the whole chart is at one height, so it has no up
-        ++upright_charts;
-        DYNAMIC_SECTION("chart " << c)
-        {
-            INFO("v at the chart's topmost vertex " << v_top << ", at its bottommost " << v_bottom);
-            CHECK(v_bottom - v_top > 1.f);
-        }
-    }
-    CHECK(upright_charts == 4); // the four sides; the top and bottom faces are the caps skipped above
-}
-
-TEST_CASE("project_planar agrees with the box projection's own axes", "[TextureDisplacement]")
-{
-    // The two express the same table in different shapes - one a pair of world axes for the GUI, the
-    // other the closed form the bake's hot path uses - so they are checked against each other here
-    // rather than left to drift apart.
-    const Vec3f p(2.f, -3.f, 7.f);
-    for (const auto &[name, n] : CUBE_FACES) {
-        DYNAMIC_SECTION("face " << name)
-        {
-            Vec3f u_axis, v_axis;
-            box_projection_axes(n, u_axis, v_axis);
-            const Vec2f planar = project_planar(p, n);
-            CHECK_THAT(planar.x(), WithinAbs(p.dot(u_axis), 1e-5f));
-            CHECK_THAT(planar.y(), WithinAbs(p.dot(v_axis), 1e-5f));
-            // Right-handed for a viewer outside the model: u to their right, v down, so u x v points
-            // into the surface. Getting this wrong is exactly what mirrors a face.
-            CHECK_THAT(u_axis.cross(v_axis).dot(n), WithinAbs(-1.f, 1e-5f));
-        }
-    }
-}
-
-// An image with a different value in each quadrant, so one bake says both which way up it landed
-// and whether it came out mirrored. Distinct enough that a wrong quadrant cannot be mistaken for the
-// right one: top-left 255, top-right 170, bottom-left 85, bottom-right 0.
-static std::shared_ptr<std::vector<unsigned char>> make_quadrant_marker_png(size_t w = 32, size_t h = 32)
-{
-    std::vector<uint8_t> pixels(w * h);
-    for (size_t y = 0; y < h; ++y)
-        for (size_t x = 0; x < w; ++x)
-            pixels[y * w + x] = (y < h / 2) ? ((x < w / 2) ? 255 : 170) : ((x < w / 2) ? 85 : 0);
-    const boost::filesystem::path tmp_path = boost::filesystem::temp_directory_path()
-        / boost::filesystem::unique_path("texdisp_test_%%%%%%%%.png");
-    REQUIRE(Slic3r::png::write_gray_to_file(tmp_path.string(), w, h, pixels));
-
-    std::vector<unsigned char> bytes;
-    {
-        std::ifstream ifs(tmp_path.string(), std::ios::binary);
-        bytes.assign(std::istreambuf_iterator<char>(ifs), std::istreambuf_iterator<char>());
-    }
-    boost::system::error_code ec;
-    boost::filesystem::remove(tmp_path, ec);
-
-    REQUIRE_FALSE(bytes.empty());
-    return std::make_shared<std::vector<unsigned char>>(std::move(bytes));
-}
-
-TEST_CASE("baking an asymmetric image puts the top of the image at the top of the model", "[TextureDisplacement]")
-{
-    // An upright wall in the plane y = 0, facing -Y, tessellated so that each of the image's four
-    // quadrants gets a vertex at its centre. A flat sheet rather than a cube because every vertex
-    // normal is then exactly the face normal, which is what makes the expected depth below an exact
-    // number instead of a tri-planar blend of three of them.
-    constexpr int   STEPS = 4;    // cells per side, so 5x5 vertices
-    constexpr float SPAN  = 20.f; // mm, the wall's width and height
-    indexed_triangle_set wall;
-    for (int j = 0; j <= STEPS; ++j)
-        for (int i = 0; i <= STEPS; ++i)
-            wall.vertices.emplace_back(-SPAN / 2.f + SPAN * float(i) / float(STEPS), 0.f,
-                                       SPAN * float(j) / float(STEPS));
-    const auto at = [](int i, int j) { return j * (STEPS + 1) + i; };
-    for (int j = 0; j < STEPS; ++j)
-        for (int i = 0; i < STEPS; ++i) {
-            // Wound so that (+x) x (+z) = -y: the wall faces -Y, away from the origin.
-            wall.indices.emplace_back(at(i, j), at(i + 1, j), at(i + 1, j + 1));
-            wall.indices.emplace_back(at(i, j), at(i + 1, j + 1), at(i, j + 1));
-        }
-
-    TextureDisplacementFacetsData facets{};
-    facets[0] = paint_whole_mesh(wall);
-
-    TextureDisplacementLayer layer;
-    layer.slot              = 0;
-    layer.projection_method = TextureProjectionMethod::Triplanar;
-    layer.image_data        = make_quadrant_marker_png();
-    layer.depth_mm          = 2.f;
-    // The wall is 20 mm across and one tile is 40 mm, so it covers the middle half of the image in
-    // both axes: the quadrant boundaries land on x = 0 and z = 10, and the probed vertices sit a
-    // whole number of texels away from both.
-    layer.tiling_scale      = 40.f;
-    layer.offset            = Vec2f(0.5f, 0.75f);
-    // A single decal rather than a repeat, so that getting the orientation wrong cannot be masked by
-    // the wrap bringing the flipped coordinate back into the image at a plausible-looking row. With
-    // tiling off, uv stays inside [0.25, 0.75] in both axes only while v runs the right way.
-    layer.tile_enabled      = false;
-
-    const indexed_triangle_set result = build_texture_displacement(wall, { layer }, facets, classic_options());
-    REQUIRE(result.vertices.size() == wall.vertices.size());
-
-    // Seen from outside this face the viewer's right is +X and their up is +Z, so the image's
-    // top-left quadrant has to land at low x and high z. Each entry: the vertex, and the image value
-    // whose quadrant it must have read.
-    const std::array<std::tuple<const char *, int, int, int>, 4> expected = { {
-        { "top-left (255)", 1, 3, 255 },
-        { "top-right (170)", 3, 3, 170 },
-        { "bottom-left (85)", 1, 1, 85 },
-        { "bottom-right (0)", 3, 1, 0 },
-    } };
-
-    for (const auto &[name, i, j, value] : expected) {
-        DYNAMIC_SECTION("quadrant " << name)
-        {
-            const size_t vi = size_t(at(i, j));
-            // The whole displacement is along -Y, so this is the relief's height at that vertex.
-            const float raised = wall.vertices[vi].y() - result.vertices[vi].y();
-            INFO("vertex at " << wall.vertices[vi].x() << ", " << wall.vertices[vi].z());
-            CHECK_THAT(raised, WithinAbs(layer.depth_mm * float(value) / 255.f, 1e-3f));
-            // Nothing moved sideways or vertically: a mirrored or rotated basis would still have
-            // displaced along the normal, so this is here to catch the relief leaning instead.
-            CHECK_THAT(result.vertices[vi].x(), WithinAbs(wall.vertices[vi].x(), 1e-4f));
-            CHECK_THAT(result.vertices[vi].z(), WithinAbs(wall.vertices[vi].z(), 1e-4f));
-        }
-    }
-}
-
 TEST_CASE("The Cylindrical/Spherical patch frame is the bake's own, so a preview can share it", "[TextureDisplacement]")
 {
     // The fast preview reconstructs these two projections in the fragment shader and needs the very