Fix texture projection UV orientation

An image laid onto a model came out upside down under the ordinary box
(tri-planar) projection, and on three of a cube's six faces it was also
mirrored left to right, which reads as a 180 degree rotation.

DecodedHeightTexture::sample() defines v = 0 as the height map's first
pixel row, i.e. its top. Every projection built v from world +Z, so v
grew upward and the image landed bottom row up. The one path that was
already right is the projective "project from view" matrix, which
measures window y downward.

Both halves of the box basis were wrong:

- v is now negated on all three world planes, so the top of an image
  sits at the top of the model.
- u now carries a sign for the side of the plane the face is on, chosen
  so that u x v == -normal. Without it the two faces sharing a plane get
  one u and one of them is mirrored. The sign flips exactly where that
  plane's blend weight (the fourth power of a normal component) reaches
  zero, so the blended tri-planar sum stays continuous and the hard axis
  switch the old code removed does not come back.

The same v convention was missing from the other mapping modes:
cylindrical (which also had a left handed frame, right x up rather than
up x right, so its wrap ran mirrored), spherical, the affine branch of
view projection, and the flat chart fallback of the LSCM unwrap, which
now reuses the box basis so a cube face unwraps to the orientation
tri-planar would have given it.

The basis table is exported as box_projection_axes() and the gizmo's
adjust_tangent_basis() calls it instead of restating it, so the
placement ring and offset handle cannot drift from the bake. All four
preview shaders get the matching change, including projection_axes(),
whose tangent and bitangent have to flip with the coordinate or the
relief shading inverts.

Re-baking an existing project now places its texture upright, so it will
differ from how it looked before. Geometry already baked into a 3mf is
untouched, so nothing changes until the user re-bakes.

Verified by measuring the sampled texture row and column against world
position for every mapping mode on all six faces of a cube, and by a
full bake of a quadrant coded image, which lands each quadrant within
1e-3 mm of its expected depth.

resources/shaders/110/texture_displacement_shaded.fs

@@ -72,17 +72,21 @@ 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 - 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.
+// 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.
 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(right, up));
+    fwd   = normalize(cross(up, right));
 }
 
+// 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.
@@ -94,7 +98,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;
@@ -102,10 +106,18 @@ 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;
     }
-    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);
+    // 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);
 }
 
 // The two surface directions projection_raw()'s u and v run along at `p`, plus how many raw units one
@@ -124,7 +136,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 along the axis
+        b = -up;                                                  // v is the distance *against* the axis
         return;
     }
     if (projection_mode == 2) {
@@ -133,20 +145,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);                                        // increasing latitude, unit length
+        b = -cross(dir, t);                                       // v grows away from the pole, unit length
         units_per_mm = vec2(1.0 / max(c, 1e-3), 1.0);
         return;
     }
-    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);
+    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);
     }
 }
 

resources/shaders/110/texture_displacement_uvcheck.fs

@@ -36,14 +36,20 @@ 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(right, up));
+    fwd   = normalize(cross(up, right));
 }
 
+// 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)
 {
@@ -53,7 +59,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;
@@ -61,10 +67,16 @@ 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);
-    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
+    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);
 }
 
 vec2 project_uv(vec3 p, vec3 n)

resources/shaders/140/texture_displacement_shaded.fs

@@ -138,17 +138,21 @@ in vec2  vertex_uv;
 
 out vec4 out_color;
 
-// 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.
+// 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.
 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(right, up));
+    fwd   = normalize(cross(up, right));
 }
 
+// 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.
@@ -160,7 +164,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;
@@ -168,10 +172,18 @@ 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;
     }
-    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);
+    // 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);
 }
 
 // The two surface directions projection_raw()'s u and v run along at `p`, plus how many raw units one
@@ -190,7 +202,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 along the axis
+        b = -up;                                                  // v is the distance *against* the axis
         return;
     }
     if (projection_mode == 2) {
@@ -199,20 +211,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);                                        // increasing latitude, unit length
+        b = -cross(dir, t);                                       // v grows away from the pole, unit length
         units_per_mm = vec2(1.0 / max(c, 1e-3), 1.0);
         return;
     }
-    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);
+    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);
     }
 }
 

resources/shaders/140/texture_displacement_uvcheck.fs

@@ -47,14 +47,20 @@ 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(right, up));
+    fwd   = normalize(cross(up, right));
 }
 
+// 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)
 {
@@ -64,7 +70,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;
@@ -72,10 +78,16 @@ 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);
-    return (an.x >= an.y && an.x >= an.z) ? p.yz : ((an.y >= an.x && an.y >= an.z) ? p.xz : p.xy);
+    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);
 }
 
 vec2 project_uv(vec3 p, vec3 n)

src/libslic3r/TextureDisplacement.cpp

@@ -491,6 +491,57 @@ 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
@@ -501,23 +552,26 @@ 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 Vec2f(position.y(), position.z());
+        return box_plane_yz(position, normal.x());
     if (n.y() >= n.x() && n.y() >= n.z())
-        return Vec2f(position.x(), position.z());
-    return Vec2f(position.x(), position.y());
+        return box_plane_xz(position, normal.y());
+    return box_plane_xy(position, normal.z());
 }
 
 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 signed distance along the axis - a reasonable approximation
-// for roughly cylindrical selections, not an exact fit for arbitrary geometry.
+// 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.
 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());
-    const Vec3f fwd       = Vec3f(right.cross(up).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 rel        = position - patch_center;
     const float along_axis = rel.dot(up);
@@ -526,7 +580,9 @@ 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);
 
-    return Vec2f(angle * radius, along_axis);
+    // 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);
 }
 
 // Longitude/latitude around patch_center. u/v are scaled by this point's own distance from the
@@ -542,7 +598,9 @@ 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));
-    return Vec2f(longitude, latitude) * radius;
+    // 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;
 }
 
 // CGAL's LSCM parameterizer expects a clean mesh with no isolated (unreferenced) vertices - but
@@ -837,9 +895,26 @@ 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)
 {
-    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());
+    // 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());
 
     std::vector<Vec2f> uvs(chart.vertices.size());
     for (size_t i = 0; i < chart.vertices.size(); ++i)
@@ -1814,8 +1889,10 @@ 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.
-        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. 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)));
     case TextureProjectionMethod::LSCM: // no usable unwrap for this patch - fall back to Triplanar
     case TextureProjectionMethod::Triplanar:
     default: break;
@@ -1830,14 +1907,15 @@ 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(Vec2f(position.x(), position.y()));
+        return sample_at(box_plane_xy(position, normal.z()));
     w /= w_sum;
 
-    // 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()));
+    // 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()));
 }
 
 bool sample_layer_color(const DecodedHeightTexture &texture, const TextureDisplacementLayer &layer,
@@ -1899,7 +1977,8 @@ bool sample_layer_color(const DecodedHeightTexture &texture, const TextureDispla
             out = texture.sample_color(uv, layer.tile_enabled, layer.tile_method);
             return true;
         } else {
-            const Vec2f p(position.dot(layer.view_project_right), position.dot(layer.view_project_up));
+            // Negated up, exactly as sample_layer_height() does it.
+            const Vec2f p(position.dot(layer.view_project_right), -position.dot(layer.view_project_up));
             if (!covered(p))
                 return false;
             out = sample_at(p);
@@ -1915,7 +1994,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(position.x(), position.y());
+        const Vec2f p = box_plane_xy(position, normal.z());
         if (!covered(p))
             return false;
         out = sample_at(p);
@@ -1926,8 +2005,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 = { Vec2f(position.y(), position.z()), Vec2f(position.x(), position.z()),
-                                          Vec2f(position.x(), position.y()) };
+    const std::array<Vec2f, 3> planes = { box_plane_yz(position, normal.x()), box_plane_xz(position, normal.y()),
+                                          box_plane_xy(position, normal.z()) };
     Vec3f acc     = Vec3f::Zero();
     float acc_w   = 0.f;
     for (int i = 0; i < 3; ++i)

src/libslic3r/TextureDisplacement.hpp

@@ -524,11 +524,24 @@ 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`. 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`. 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.
 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/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.cpp

@@ -494,17 +494,7 @@ bool GLGizmoTextureDisplacement::on_init()
         {ctrl + _L("Mouse wheel"), m_desc["gap_area"]},
         toggle_wireframe_shortcut
     };
-
-    // Both ways into the same input box on any slider in the panel: ImGui turns a slider into one when
-    // it is Ctrl+clicked or when it is given the keyboard focus, which is what the edit icon asks for.
-    m_desc["type_value"] = _L("Type an exact value into a slider");
-    m_shortcuts_sliders  = {
-        {ctrl + _L("Left mouse button"), m_desc["type_value"]},
-        {_L("Edit icon at a slider's right end"), m_desc["type_value"]},
-    };
-    for (std::vector<std::pair<wxString, wxString>> *list : {&m_shortcuts_brush, &m_shortcuts_bucket_fill, &m_shortcuts_gap_fill})
-        list->insert(list->end(), m_shortcuts_sliders.begin(), m_shortcuts_sliders.end());
-
+ 
     return true;
 }
 
@@ -1262,8 +1252,9 @@ 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;
@@ -3302,19 +3293,10 @@ Vec3f GLGizmoTextureDisplacement::adjust_handle_center(const TextureDisplacement
 
 void GLGizmoTextureDisplacement::adjust_tangent_basis(Vec3f &u_axis, Vec3f &v_axis) const
 {
-    // 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();
-    }
+    // 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);
 }
 
 void GLGizmoTextureDisplacement::render_adjust_texture_gizmo()
@@ -3690,8 +3672,6 @@ void GLGizmoTextureDisplacement::ensure_panel_icons()
         "texture_displacement_adjust.svg", "canvas_drag.svg", "texture_displacement_move_up.svg",
         "texture_displacement_move_down.svg", "texture_displacement_drag.svg",
         "texture_displacement_select_all.svg", "texture_displacement_erase_all.svg",
-        // The "type a value instead" icon at the right end of every slider.
-        "edit.svg",
     };
     std::vector<std::string> paths;
     paths.reserve(names.size());
@@ -5931,8 +5911,8 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
         }
         return s + "...";
     };
-    // Label column + a slider filling the rest of the row, value printed inside the track.
-    // `right_inset` keeps a layer card's inner padding.
+    // Label column + a slider filling the rest of the row, value printed inside the track. Ctrl+click on
+    // any of these types a value in. `right_inset` keeps a layer card's inner padding.
     const auto slider_label = [&](const wxString &label) {
         const float x0 = ImGui::GetCursorPosX();
         ImGui::AlignTextToFramePadding();
@@ -5940,107 +5920,17 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
         ImGui::SameLine();
         ImGui::SetCursorPosX(std::max(ImGui::GetCursorPosX(), x0 + label_w));
     };
-
-    // ---- Typed values on sliders ----
-    // Every slider in the panel goes through typed_slider(), so all of them take a number the same
-    // two ways: Ctrl+click on the track, or the edit icon at the right end for the same box without
-    // the modifier. Both end up in ImGui's own "temp input" mode - the icon only asks ImGui to focus
-    // the slider, which is what turns it into an input box (see SliderScalar) - so the parsing,
-    // the clamping and the Enter/click-away behaviour are ImGui's, not a second implementation.
-
-    // Retires a click whose row is no longer being drawn - the panel changed mode in between - so that
-    // it cannot fire later when that row comes back. Before any row is drawn, so a live one still wins.
-    if (!m_slider_type_request.empty() && ImGui::GetFrameCount() > m_slider_type_request_frame + 1)
-        m_slider_type_request.clear();
-
-    // Exactly as tall as the slider it sits beside, so it lines up with the track without the row
-    // having to be re-centred around it; icon_button() pads the glyph itself down to about 0.7 of this.
-    const float edit_icon_w = frame_h;
-    // What the slider's own width has to give up for the icon beside it.
-    const float edit_icon_room = edit_icon_w + gap_s;
-
-    // One end of a range, through the slider's own format, so the bounds in the tooltip read exactly
-    // like the value in the track. A parenthesised note in the format - "(auto)" - is dropped: it
-    // describes the current state, not the bound.
-    const auto fmt_bound = [](const char *format, auto v) {
-        char buf[64];
-        std::snprintf(buf, sizeof(buf), format, v);
-        std::string out(buf);
-        const size_t paren = out.find('(');
-        if (paren != std::string::npos)
-            out.erase(paren);
-        while (!out.empty() && out.back() == ' ')
-            out.pop_back();
-        return out;
-    };
-    const auto range_text = [](const std::string &lo, const std::string &hi) {
-        return Slic3r::format(_u8L("Range: %1% to %2%"), lo, hi);
-    };
-    const auto edit_icon_tip = [&](const std::string &range) {
-        return _u8L("Type a value instead of dragging. Ctrl+click on the slider does the same.") + "\n\n" + range;
-    };
-
-    // Draws `slider` at `item_w` (SetNextItemWidth's convention: negative measures back from the right
-    // edge, and the caller has already left edit_icon_room in it), then the edit icon. `tip` and the
-    // range go on both. Returns whatever the slider returned.
-    const auto typed_row = [&](const char *id, float item_w, const wxString &tip, const std::string &range,
-                               const std::function<bool()> &slider) -> bool {
-        // Deferred from the click a frame ago: SetKeyboardFocusHere() is a request for the *next*
-        // frame, so it has to be issued before the slider it names, not from the icon beside it.
-        if (m_slider_type_request == id) {
-            ImGui::SetKeyboardFocusHere();
-            m_slider_type_request.clear();
-            m_parent.set_as_dirty(); // the focus only lands on a frame that actually gets drawn
-        }
-        ImGui::SetNextItemWidth(item_w);
-        const bool changed = slider();
-        // AllowWhenDisabled: several of these rows are drawn inside disabled_begin(), and a greyed
-        // slider is exactly when the user needs to be told what it is and why it is not moving.
-        if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
-            wxString full = tip;
-            if (!full.IsEmpty())
-                full += "\n\n";
-            m_imgui->tooltip(full + from_u8(range), wrap_w);
-        }
-        // SameLine() puts the cursor back at the slider's own top (ItemSize records the Y the item was
-        // drawn at), so an icon of the same height lands on the track wherever the row placed it.
-        ImGui::SameLine(0.f, gap_s);
-        if (icon_button(int(ImGui::GetID(id)), "edit.svg", edit_icon_w, _L("Edit"), from_u8(edit_icon_tip(range)))) {
-            m_slider_type_request       = id;
-            m_slider_type_request_frame = ImGui::GetFrameCount();
-            m_parent.set_as_dirty(); // the next frame is where the request above is turned into focus
-        }
-        return changed;
-    };
-
-    // The two forms every slider in the panel is one of. They derive the range from the bounds they are
-    // already given, so no row states its bounds or its format twice and the tooltip cannot drift from
-    // the track. `item_w` is as typed_row() takes it.
-    const auto typed_slider = [&](const char *id, float item_w, float *v, float v_min, float v_max, const char *format,
-                                  bool log, const wxString &tip) -> bool {
-        return typed_row(id, item_w, tip, range_text(fmt_bound(format, v_min), fmt_bound(format, v_max)), [&] {
-            return ImGui::SliderFloat(id, v, v_min, v_max, format,
-                                      ImGuiSliderFlags_AlwaysClamp | (log ? ImGuiSliderFlags_Logarithmic : 0));
-        });
-    };
-    const auto typed_slider_int = [&](const char *id, float item_w, int *v, int v_min, int v_max, const char *format,
-                                      bool log, const wxString &tip) -> bool {
-        return typed_row(id, item_w, tip, range_text(fmt_bound(format, v_min), fmt_bound(format, v_max)), [&] {
-            return ImGui::SliderInt(id, v, v_min, v_max, format,
-                                    ImGuiSliderFlags_AlwaysClamp | (log ? ImGuiSliderFlags_Logarithmic : 0));
-        });
-    };
-
-    // Label column + the slider filling the rest of the row.
     const auto float_row = [&](const char *id, const wxString &label, float *v, float v_min, float v_max, const char *format,
-                               bool log, float right_inset, const wxString &tip) -> bool {
+                               bool log, float right_inset) -> bool {
         slider_label(label);
-        return typed_slider(id, -(std::max(right_inset, 1.f) + edit_icon_room), v, v_min, v_max, format, log, tip);
+        ImGui::SetNextItemWidth(-std::max(right_inset, 1.f));
+        return ImGui::SliderFloat(id, v, v_min, v_max, format, ImGuiSliderFlags_AlwaysClamp | (log ? ImGuiSliderFlags_Logarithmic : 0));
     };
     const auto int_row = [&](const char *id, const wxString &label, int *v, int v_min, int v_max, const char *format,
-                             float right_inset, const wxString &tip) -> bool {
+                             float right_inset) -> bool {
         slider_label(label);
-        return typed_slider_int(id, -(std::max(right_inset, 1.f) + edit_icon_room), v, v_min, v_max, format, false, tip);
+        ImGui::SetNextItemWidth(-std::max(right_inset, 1.f));
+        return ImGui::SliderInt(id, v, v_min, v_max, format, ImGuiSliderFlags_AlwaysClamp);
     };
     const auto layer_name = [](const TextureDisplacementLayer &l) {
         return l.name.empty() ? Slic3r::format(_u8L("Layer %1%"), l.slot + 1) : l.name;
@@ -6262,10 +6152,11 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
         const auto  centre_on_row = [&](float h) { ImGui::SetCursorPosY(row_y + std::round((icon_md - h) * 0.5f)); };
         vsep(icon_md);
         if (is_brush_mode) {
+            ImGui::SetNextItemWidth(std::max(1.f, row_end - ImGui::GetCursorPosX() - (3.f * gap_s + 1.f + 2.f * icon_sm)));
             centre_on_row(frame_h);
-            typed_slider("##cursor_radius",
-                         std::max(1.f, row_end - ImGui::GetCursorPosX() - (3.f * gap_s + 1.f + 2.f * icon_sm) - edit_icon_room),
-                         &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f mm", false, m_desc.at("cursor_size"));
+            ImGui::SliderFloat("##cursor_radius", &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f mm",
+                               ImGuiSliderFlags_AlwaysClamp);
+            hover_tip(m_desc.at("cursor_size"));
             vsep(icon_sm);
             const bool is_circle = m_cursor_type == TriangleSelector::CursorType::CIRCLE;
             centre_on_row(icon_sm);
@@ -6278,10 +6169,11 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                             _L("Sphere - paints only within a ball around the point under the cursor")))
                 m_cursor_type = TriangleSelector::CursorType::SPHERE;
         } else if (is_area_mode) {
+            ImGui::SetNextItemWidth(std::max(1.f, row_end - ImGui::GetCursorPosX()));
             centre_on_row(frame_h);
-            typed_slider("##smart_fill_angle", std::max(1.f, row_end - ImGui::GetCursorPosX() - edit_icon_room),
-                         &m_smart_fill_angle, SmartFillAngleMin, SmartFillAngleMax, "%.0f°", false,
-                         _L("Angle threshold - the fill stops at edges sharper than this"));
+            ImGui::SliderFloat("##smart_fill_angle", &m_smart_fill_angle, SmartFillAngleMin, SmartFillAngleMax, "%.0f°",
+                               ImGuiSliderFlags_AlwaysClamp);
+            hover_tip(_u8L("Angle threshold - the fill stops at edges sharper than this"));
         } else {
             centre_on_row(frame_h);
             ImGui::AlignTextToFramePadding();
@@ -6551,16 +6443,16 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
 
             // The three controls nearly every layer needs; everything else waits behind "More settings".
             // Depth and tile size are logarithmic, so both ends of their wide ranges stay usable.
-            m_preview_params_dirty |= float_row("##depth", _L("Depth"), &layer.depth_mm, 0.01f, 10.f, "%.3f mm", true, card_pad,
-                                                _L("Height of the relief: how far white in the texture lifts the surface, in "
-                                                   "millimetres. Black does not move it at all, unless Midlevel says otherwise."));
-            m_preview_params_dirty |= float_row("##tile_size", _L("Tile size"), &layer.tiling_scale, 0.2f, 200.f, "%.2f mm", true, card_pad,
-                                                _L("How wide one copy of the texture is on the model. Smaller repeats the pattern "
-                                                   "more often and makes its detail finer; with Tile off, this is the size of the "
-                                                   "single copy."));
-            m_preview_params_dirty |= float_row("##rotation", _L("Rotation"), &layer.rotation_deg, 0.f, 360.f, "%.0f°", false, card_pad,
-                                                _L("Turns the texture on the surface, in degrees - for lining a pattern up with an "
-                                                   "edge of the model."));
+            m_preview_params_dirty |= float_row("##depth", _L("Depth"), &layer.depth_mm, 0.01f, 10.f, "%.3f mm", true, card_pad);
+            hover_tip(_u8L("Height of the relief: how far white in the texture lifts the surface, in "
+                           "millimetres. Black does not move it at all, unless Midlevel says otherwise."));
+            m_preview_params_dirty |= float_row("##tile_size", _L("Tile size"), &layer.tiling_scale, 0.2f, 200.f, "%.2f mm", true, card_pad);
+            hover_tip(_u8L("How wide one copy of the texture is on the model. Smaller repeats the pattern "
+                           "more often and makes its detail finer; with Tile off, this is the size of the "
+                           "single copy."));
+            m_preview_params_dirty |= float_row("##rotation", _L("Rotation"), &layer.rotation_deg, 0.f, 360.f, "%.0f°", false, card_pad);
+            hover_tip(_u8L("Turns the texture on the surface, in degrees - for lining a pattern up with an "
+                           "edge of the model."));
 
             if (m_layer_expanded[size_t(layer.slot)]) {
                 {
@@ -6575,22 +6467,22 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
 
                 // Midlevel: the height that means "don't move". At 0 the surface only ever bulges outwards;
                 // at 0.5 mid-grey is neutral and darker texels cut inwards.
-                m_preview_params_dirty |= float_row("##midlevel", _L("Midlevel"), &layer.midlevel, 0.f, 10.f, "%.2f", false, card_pad,
-                                                    _L("Which gray stays where the surface already is. At 0 the texture only pushes "
-                                                       "outwards; at 0.5 mid-gray stays put, so darker grays cut in and lighter ones "
-                                                       "still push out - one image both embosses and engraves.\n\n"
-                                                       "What cuts in has to fit: inside a sharp corner or through a thin wall, a deep "
-                                                       "cut can pass through the other side."));
+                m_preview_params_dirty |= float_row("##midlevel", _L("Midlevel"), &layer.midlevel, 0.f, 10.f, "%.2f", false, card_pad);
+                hover_tip(_u8L("Which gray stays where the surface already is. At 0 the texture only pushes "
+                               "outwards; at 0.5 mid-gray stays put, so darker grays cut in and lighter ones "
+                               "still push out - one image both embosses and engraves.\n\n"
+                               "What cuts in has to fit: inside a sharp corner or through a thin wall, a deep "
+                               "cut can pass through the other side."));
                 if (layer.midlevel > 0.f && layer.depth_mm > 1.f) {
                     ImGui::PushTextWrapPos(content_rx - card_pad);
                     m_imgui->warning_text(_L("Deep inward displacement may self-intersect."));
                     ImGui::PopTextWrapPos();
                 }
 
-                m_preview_params_dirty |= float_row("##smoothing", _L("Smoothing"), &layer.smoothing, 0.f, 1.f, "%.2f", false, card_pad,
-                                                    _L("Blurs the image before it is used, which rounds off hard steps and removes "
-                                                       "speckle from a noisy photo. Raise it if the relief looks harsh or grainy; it "
-                                                       "costs fine detail."));
+                m_preview_params_dirty |= float_row("##smoothing", _L("Smoothing"), &layer.smoothing, 0.f, 1.f, "%.2f", false, card_pad);
+                hover_tip(_u8L("Blurs the image before it is used, which rounds off hard steps and removes "
+                               "speckle from a noisy photo. Raise it if the relief looks harsh or grainy; it "
+                               "costs fine detail."));
 
                 // Edge fade: the relief flattens toward the boundary of the painted area.
                 m_preview_params_dirty |= m_imgui->bbl_checkbox(_L("Edge fade") + "##edge_smoothing", layer.edge_smoothing);
@@ -6598,11 +6490,12 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                                "blends into the bare surface instead of stopping at a step."));
                 ImGui::SameLine();
                 m_imgui->disabled_begin(!layer.edge_smoothing);
-                m_preview_params_dirty |= typed_slider("##edge_amount", -(card_pad + edit_icon_room),
-                                                       &layer.edge_smoothing_amount, 0.02f, 1.f, "%.2f", false,
-                                                       _L("How far in the fade reaches, as a share of the painted area. Small "
-                                                          "values soften a narrow band at the edge; 1 flattens almost all of it."));
+                ImGui::SetNextItemWidth(-card_pad);
+                m_preview_params_dirty |= ImGui::SliderFloat("##edge_amount", &layer.edge_smoothing_amount, 0.02f, 1.f, "%.2f",
+                                                             ImGuiSliderFlags_AlwaysClamp);
                 m_imgui->disabled_end();
+                hover_tip(_u8L("How far in the fade reaches, as a share of the painted area. Small values "
+                               "soften a narrow band at the edge; 1 flattens almost all of it."));
 
                 // Invert and Colours share a row.
                 {
@@ -6647,19 +6540,19 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                             // Every mix can become a filament slot, and there are only so many beside the
                             // physical filaments.
                             const int max_mixes = std::max(1, int(EnforcerBlockerType::ExtruderMax) - int(m_palette_filaments.size()));
-                            if (int_row("##color_mix_count", _L("Mixed colors"), &opts.color_mix_count, 1, max_mixes, "%d", card_pad,
-                                        _L("The most mixed filaments a bake may add. They are picked from the "
-                                           "texture's colors, and only the ones the bake actually uses are created.")))
+                            if (int_row("##color_mix_count", _L("Mixed colors"), &opts.color_mix_count, 1, max_mixes, "%d", card_pad))
                                 m_preview_params_dirty = true;
+                            hover_tip(_u8L("The most mixed filaments a bake may add. They are picked from the "
+                                           "texture's colors, and only the ones the bake actually uses are created."));
                             // After the slider, so a change shows in the same frame.
                             ImGui::TextDisabled("%s", Slic3r::format(_u8L("%1% printable colors from %2% filaments"),
                                                                      int(cached_palette().size()), int(m_palette_filaments.size())).c_str());
                         }
-                        if (int_row("##color_despeckle", _L("Denoise"), &opts.color_despeckle, 0, 6, "%d", card_pad,
-                                    _L("Cleans up single stray triangles of the wrong color, which detail finer "
-                                       "than the mesh leaves behind. Raise it if the result looks speckled, "
-                                       "lower it if small features are being swallowed.")))
+                        if (int_row("##color_despeckle", _L("Denoise"), &opts.color_despeckle, 0, 6, "%d", card_pad))
                             m_preview_params_dirty = true;
+                        hover_tip(_u8L("Cleans up single stray triangles of the wrong color, which detail finer "
+                                       "than the mesh leaves behind. Raise it if the result looks speckled, "
+                                       "lower it if small features are being swallowed."));
                     }
                 }
 
@@ -6764,10 +6657,10 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                                     "gets the texture, and its border becomes the edge of the projection."));
 
                     if (projector_open) {
-                        if (int_row("##projector_opacity", _L("Opacity"), &m_projector_opacity, 20, 255, "%d", card_pad,
-                                    _L("How solid the frame window looks while you place it. Lower to see the "
-                                       "model through it; it does not affect the result.")))
+                        if (int_row("##projector_opacity", _L("Opacity"), &m_projector_opacity, 20, 255, "%d", card_pad))
                             m_projector_frame->set_opacity(m_projector_opacity);
+                        hover_tip(_u8L("How solid the frame window looks while you place it. Lower to see the "
+                                       "model through it; it does not affect the result."));
 
                         if (m_imgui->button(_u8L("Apply projection frame"))) {
                             const int painted_count = apply_projection_frame();
@@ -7068,57 +6961,57 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
             // pattern can sample four points that all happen to land at similar heights, report no error,
             // and stall before refinement ever starts.
             if (float_row("##subdiv_target", m_subdivide_feature ? _L("Max edge") : _L("Target edge"), &m_subdivide_target_mm,
-                          0.001f, 20.f, "%.3f mm", true, 0.f,
-                          m_subdivide_feature ?
-                              _L("No triangle in the painted area stays larger than this, even where the texture "
-                                 "is flat. Keep it near the size of the smallest feature you want to come out.") :
-                              _L("Triangles in the painted area are split until none is larger than this. Smaller "
-                                 "means finer detail and, fast, a lot more triangles.")))
+                          0.001f, 20.f, "%.3f mm", true, 0.f))
                 preview_live();
+            hover_tip(m_subdivide_feature ?
+                          _u8L("No triangle in the painted area stays larger than this, even where the texture "
+                               "is flat. Keep it near the size of the smallest feature you want to come out.") :
+                          _u8L("Triangles in the painted area are split until none is larger than this. Smaller "
+                               "means finer detail and, fast, a lot more triangles."));
 
             if (m_subdivide_feature) {
-                if (float_row("##subdiv_detail", _L("Detail"), &m_subdivide_detail_mm, 0.001f, 1.f, "%.3f mm", true, 0.f,
-                              _L("How far the mesh may sit from the shape the texture describes, in millimetres. "
-                                 "Smaller follows fine detail and costs triangles; larger only chases the big "
-                                 "features.")))
+                if (float_row("##subdiv_detail", _L("Detail"), &m_subdivide_detail_mm, 0.001f, 1.f, "%.3f mm", true, 0.f))
                     preview_live();
-                if (float_row("##subdiv_min", _L("Min edge"), &m_subdivide_min_edge_mm, 0.001f, 20.f, "%.3f mm", true, 0.f,
-                              _L("A floor on triangle size, so a sharp step in the texture cannot be chased "
-                                 "forever. Lower it for finer relief, raise it if the count runs away at hard "
-                                 "edges.")))
+                hover_tip(_u8L("How far the mesh may sit from the shape the texture describes, in millimetres. "
+                               "Smaller follows fine detail and costs triangles; larger only chases the big "
+                               "features."));
+                if (float_row("##subdiv_min", _L("Min edge"), &m_subdivide_min_edge_mm, 0.001f, 20.f, "%.3f mm", true, 0.f))
                     preview_live();
+                hover_tip(_u8L("A floor on triangle size, so a sharp step in the texture cannot be chased "
+                               "forever. Lower it for finer relief, raise it if the count runs away at hard "
+                               "edges."));
             }
 
             // Applies in both adaptive sub-modes: it is about the step the bake puts at the paint's edge, which
             // exists whether or not "Follow texture detail" is on. 0 turns the band off.
-            if (float_row("##subdiv_border", _L("Edge detail"), &m_subdivide_border_mm, 0.f, 5.f, "%.3f mm", false, 0.f,
-                          _L("Triangle size along the outline of the painted area, where the relief drops back to the "
-                             "bare surface. Lower it if that rim looks jagged; it only costs triangles along the "
-                             "outline. 0 turns it off.")))
+            if (float_row("##subdiv_border", _L("Edge detail"), &m_subdivide_border_mm, 0.f, 5.f, "%.3f mm", false, 0.f))
                 preview_live();
+            hover_tip(_u8L("Triangle size along the outline of the painted area, where the relief drops back to the "
+                            "bare surface. Lower it if that rim looks jagged; it only costs triangles along the "
+                            "outline. 0 turns it off."));
 
             // Only worth showing when a layer is actually colouring: with no colour there is no boundary for it
             // to refine and the control would do nothing whatever it is set to.
             if (mv != nullptr && any_layer_colors(*mv)) {
-                if (float_row("##subdiv_color", _L("Color detail"), &m_subdivide_color_mm, 0.f, 5.f, "%.3f mm", false, 0.f,
-                              _L("Triangle size where two colors meet. Each triangle prints in one filament, so a "
-                                 "color edge can only be as sharp as the triangles along it - and nothing else "
-                                 "refines there, since the surface is flat across a change of color. 0 turns it off.")))
+                if (float_row("##subdiv_color", _L("Color detail"), &m_subdivide_color_mm, 0.f, 5.f, "%.3f mm", false, 0.f))
                     preview_live();
+                hover_tip(_u8L("Triangle size where two colors meet. Each triangle prints in one filament, so a "
+                                "color edge can only be as sharp as the triangles along it - and nothing else "
+                                "refines there, since the surface is flat across a change of color. 0 turns it off."));
             }
 
             ImGui::TextDisabled("%s", _u8L("Triangle budget: set with Triangles, below.").c_str());
             if (m_subdivide_editing && m_subdivide_preview_tris > 0)
                 m_imgui->text(Slic3r::format(_u8L("Preview: %1% triangles"), m_subdivide_preview_tris));
         } else {
-            if (int_row("##subdiv_steps", _L("Steps"), &m_subdivide_count, 0, 5, "%d", 0.f,
-                        _L("Splits every triangle of the model into four, this many times over. Each step "
-                           "quadruples the count - 3 turns 100 k triangles into 6.4 M - so prefer refining "
-                           "only the painted area unless you need the whole model finer."))) {
+            if (int_row("##subdiv_steps", _L("Steps"), &m_subdivide_count, 0, 5, "%d", 0.f)) {
                 if (m_subdivide_editing)
                     rebuild_subdivide_preview(); // a count of 0 clears the preview, it doesn't compute one
                 m_parent.set_as_dirty();
             }
+            hover_tip(_u8L("Splits every triangle of the model into four, this many times over. Each step "
+                           "quadruples the count - 3 turns 100 k triangles into 6.4 M - so prefer refining "
+                           "only the painted area unless you need the whole model finer."));
         }
 
         {
@@ -7180,9 +7073,9 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                 }
             m_remesh_target_edge_mm = cnt > 0 ? std::clamp(float(sum / double(cnt)), 0.1f, 20.f) : 1.f;
         }
-        float_row("##remesh_edge", _L("Target edge"), &m_remesh_target_edge_mm, 0.1f, 20.f, "%.2f mm", true, 0.f,
-                  _L("Triangle size the whole model is rebuilt with, in millimetres. Displacement works best on an "
-                     "even mesh; this is what makes one out of an uneven import."));
+        float_row("##remesh_edge", _L("Target edge"), &m_remesh_target_edge_mm, 0.1f, 20.f, "%.2f mm", true, 0.f);
+        hover_tip(_u8L("Triangle size the whole model is rebuilt with, in millimetres. Displacement works best on an "
+                        "even mesh; this is what makes one out of an uneven import."));
 
         m_imgui->bbl_checkbox(_L("Keep sharp edges") + "##remesh_sharp", m_remesh_keep_sharp_edges);
         hover_tip(_u8L("Holds hard edges and open borders in place while the rest is remeshed. Without it "
@@ -7190,10 +7083,11 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                        "a cube comes back with wobbly edges."));
         ImGui::SameLine();
         m_imgui->disabled_begin(!m_remesh_keep_sharp_edges);
-        typed_slider("##remesh_sharp_angle", -(1.f + edit_icon_room), &m_remesh_sharp_angle_deg, 5.f, 90.f, "%.0f°", false,
-                     _L("How sharp a fold has to be, in degrees, before the remesher treats it as an edge worth "
-                        "keeping. Lower protects more of the model's shape; higher rebuilds more of it evenly."));
+        ImGui::SetNextItemWidth(-1.f);
+        ImGui::SliderFloat("##remesh_sharp_angle", &m_remesh_sharp_angle_deg, 5.f, 90.f, "%.0f°", ImGuiSliderFlags_AlwaysClamp);
         m_imgui->disabled_end();
+        hover_tip(_u8L("How sharp a fold has to be, in degrees, before the remesher treats it as an edge worth "
+                        "keeping. Lower protects more of the model's shape; higher rebuilds more of it evenly."));
 
         m_imgui->disabled_begin(mv == nullptr || busy);
         if (ImGui::Button(_u8L("Remesh").c_str()))
@@ -7221,16 +7115,16 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                             "on a layer is a different thing: it blurs the image before it is used."));
             if (opts.smooth_enabled) {
                 float percent = opts.smooth_strength * 100.f;
-                if (float_row("##dispsmooth", _L_CONTEXT("Strength", "Texture Displacement"), &percent, 1.f, 100.f, "%.0f %%", false, 0.f,
-                              _L("How far each pass pulls a vertex towards its neighbours. High values round the "
-                                 "relief off quickly; low values need more passes but keep more of the detail."))) {
+                if (float_row("##dispsmooth", _L_CONTEXT("Strength", "Texture Displacement"), &percent, 1.f, 100.f, "%.0f %%", false, 0.f)) {
                     opts.smooth_strength   = std::clamp(percent / 100.f, 0.01f, 1.f);
                     m_preview_params_dirty = true;
                 }
-                if (int_row("##dispsmoothit", _L("Passes"), &opts.smooth_iterations, 1, 10, "%d", 0.f,
-                            _L("How many smoothing passes to run. More passes spread the smoothing further across "
-                               "the surface; Strength decides how much each one moves.")))
+                hover_tip(_u8L("How far each pass pulls a vertex towards its neighbours. High values round the "
+                               "relief off quickly; low values need more passes but keep more of the detail."));
+                if (int_row("##dispsmoothit", _L("Passes"), &opts.smooth_iterations, 1, 10, "%d", 0.f))
                     m_preview_params_dirty = true;
+                hover_tip(_u8L("How many smoothing passes to run. More passes spread the smoothing further across "
+                                "the surface; Strength decides how much each one moves."));
 
                 m_preview_params_dirty |= m_imgui->bbl_checkbox(_L("Ignore outer ring"), opts.smooth_skip_border);
                 hover_tip(_u8L("Keeps the outer ring of the painted area out of the smoothing. Its neighbours "
@@ -7273,16 +7167,16 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
             int        shown_k     = auto_budget ? v2_recommendation(*mv).budget_k : opts.v2_max_triangles_k;
             m_imgui->disabled_begin(auto_budget);
             // TRN Slider value: %d is the triangle budget in thousands
-            if (int_row("##v2budget", _L("Budget"), &shown_k, 0, 4000, auto_budget ? _u8L("%d k (auto)").c_str() : "%d k", 0.f,
-                        _L("How many thousand triangles this bake may spend on the area you painted. "
-                           "Relief already baked into the rest of the model is kept on top of it, so a "
-                           "second bake somewhere else gets the same budget as the first. Raise it if the "
-                           "warning below Resolution says the detail will not fit; 0 keeps every triangle "
-                           "the refinement produced, however many that is."))) {
+            if (int_row("##v2budget", _L("Budget"), &shown_k, 0, 4000, auto_budget ? _u8L("%d k (auto)").c_str() : "%d k", 0.f)) {
                 opts.v2_max_triangles_k = shown_k;
                 m_preview_params_dirty  = true;
             }
             m_imgui->disabled_end();
+            hover_tip(_u8L("How many thousand triangles this bake may spend on the area you painted. "
+                           "Relief already baked into the rest of the model is kept on top of it, so a "
+                           "second bake somewhere else gets the same budget as the first. Raise it if the "
+                           "warning below Resolution says the detail will not fit; 0 keeps every triangle "
+                           "the refinement produced, however many that is."));
         }
         if (SHOW_PIPELINE_DEV_CONTROLS && opts.pipeline_v2) {
             // Keeping the relief above the plate is not a checkbox: it is unconditional, in both pipelines
@@ -7389,28 +7283,26 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                            "default. Untick to set both yourself - worth doing for a texture much finer or "
                            "much coarser than the part it sits on."));
             ImGui::SameLine();
+            ImGui::SetNextItemWidth(x0 + panel_w - ImGui::GetCursorPosX());
             float shown = auto_res ? rec.edge_mm : opts.v2_refine_mm;
-            // Held in a local: the format outlives the call that reads it, and the slider and the
-            // range in its tooltip are then formatted the same way.
-            const std::string v2edge_format = auto_res ? _u8L("%.2f mm (auto)") : std::string("%.2f mm");
-            const wxString    v2edge_tip =
-                auto_res && rec.edge_mm > 0.f ?
-                    from_u8(Slic3r::format(_u8L("Chosen from the size of the model: %1$.2f mm triangles, "
-                                                "budget %2% k. Untick Auto to set them yourself."),
-                                           rec.edge_mm, rec.budget_k)) :
-                    _L("How fine the mesh is made under the paint, in millimetres. It has to be "
-                       "smaller than the detail you want out of the texture - a 0.5 mm groove needs "
-                       "triangles well under 0.5 mm. Smaller costs triangles fast: halving it needs "
-                       "four times as many, and once they no longer fit the budget the bake simplifies "
-                       "back down and the detail goes with it.");
             m_imgui->disabled_begin(busy || auto_res);
-            if (typed_slider("##v2edge", x0 + panel_w - ImGui::GetCursorPosX() - edit_icon_room, &shown, 0.02f, 2.f,
-                             v2edge_format.c_str(), true, v2edge_tip)) {
+            if (ImGui::SliderFloat("##v2edge", &shown, 0.02f, 2.f, auto_res ? _u8L("%.2f mm (auto)").c_str() : "%.2f mm",
+                                   ImGuiSliderFlags_AlwaysClamp | ImGuiSliderFlags_Logarithmic)) {
                 opts.v2_refine_mm      = shown;
                 m_preview_params_dirty = true;
                 m_parent.set_as_dirty();
             }
             m_imgui->disabled_end();
+            if (auto_res && rec.edge_mm > 0.f)
+                hover_tip(Slic3r::format(_u8L("Chosen from the size of the model: %1$.2f mm triangles, "
+                                              "budget %2% k. Untick Auto to set them yourself."),
+                                          rec.edge_mm, rec.budget_k));
+            else
+                hover_tip(_u8L("How fine the mesh is made under the paint, in millimetres. It has to be "
+                               "smaller than the detail you want out of the texture - a 0.5 mm groove needs "
+                               "triangles well under 0.5 mm. Smaller costs triangles fast: halving it needs "
+                               "four times as many, and once they no longer fit the budget the bake simplifies "
+                               "back down and the detail goes with it."));
 
             // What this resolution costs over what is painted, against what the budget allows. Refining
             // past the budget is not an error - the bake simplifies back down to it - but the result
@@ -7442,17 +7334,18 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
             m_imgui->text(_L("Triangles"));
             ImGui::SameLine();
             ImGui::SetCursorPosX(std::max(ImGui::GetCursorPosX(), x0 + label_w));
+            ImGui::SetNextItemWidth(x0 + panel_w - ImGui::GetCursorPosX());
             m_imgui->disabled_begin(busy);
-            if (typed_slider_int("##subdivbudget", x0 + panel_w - ImGui::GetCursorPosX() - edit_icon_room,
-                                 &m_subdivide_budget_k, 10, 2000, "+%d k", true,
-                                 _L("How many thousand triangles the refinement may add to the model. The triangle "
-                                    "that fits worst is always split first, so even a run that spends the lot has "
-                                    "spent it where it shows most. Raise it if the relief still looks coarse."))) {
+            if (ImGui::SliderInt("##subdivbudget", &m_subdivide_budget_k, 10, 2000, "+%d k",
+                                 ImGuiSliderFlags_AlwaysClamp | ImGuiSliderFlags_Logarithmic)) {
                 if (m_subdivide_editing)
                     rebuild_subdivide_preview();
                 m_parent.set_as_dirty();
             }
             m_imgui->disabled_end();
+            hover_tip(_u8L("How many thousand triangles the refinement may add to the model. The triangle "
+                           "that fits worst is always split first, so even a run that spends the lot has "
+                           "spent it where it shows most. Raise it if the relief still looks coarse."));
         }
 
         const float button_h = std::round(frame_h * 1.25f);
@@ -7471,7 +7364,7 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
             : m_tool_type == ToolType::SMART_FILL  ? m_shortcuts_bucket_fill 
             : m_tool_type == ToolType::BRUSH       ? m_shortcuts_brush 
             : m_tool_type == ToolType::GAP_FILL    ? m_shortcuts_gap_fill 
-            : m_shortcuts_sliders; // the sliders are there whether or not a painting tool is
+            : std::vector<std::pair<wxString, wxString>>{};
 
         ImGui::SetCursorPosY(row_y + (row_h - icon_h) * .5f); // center vertically
         ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(int(m_imgui->scaled(.5f)), style.ItemSpacing.y));

src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp

@@ -404,12 +404,6 @@ private:
     // Per slot: whether the layer's card shows every setting or only Depth, Tile size and Rotation.
     // Panel state only, not saved with the project.
     std::array<bool, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_layer_expanded{};
-    // The slider whose edit icon was just clicked, as its ImGui id, and the frame it was clicked on.
-    // The row acts on it on the next frame - ImGui's keyboard-focus request only takes effect a frame
-    // later - and clears it; the frame number is what retires a request whose row has gone off screen
-    // in the meantime. Panel state only, not saved with the project.
-    std::string m_slider_type_request;
-    int         m_slider_type_request_frame = 0;
 
     // "Adjust Texture" mode: instead of painting, dragging an on-canvas handle changes the active
     // layer's offset. The handle is a flat panel lying in the paint patch's own tangent plane
@@ -429,8 +423,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, matching project_planar()'s
-    // dominant-axis convention so dragging on-canvas maps consistently onto offset.
+    // 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.
     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.
@@ -1022,9 +1016,6 @@ private:
     std::vector<std::pair<wxString, wxString>> m_shortcuts_bucket_fill;
     // Contains all shortcuts in the format of {shortcut, description}, e.g. {alt + _L("Left mouse button"), _L("Part_selection")}
     std::vector<std::pair<wxString, wxString>> m_shortcuts_gap_fill;
-    // The two ways every slider in the panel takes a typed value. They hold whatever tool is selected,
-    // so they are tacked onto each of the lists above and stand on their own when no tool is active.
-    std::vector<std::pair<wxString, wxString>> m_shortcuts_sliders;
 
     // Icons for the panel's icon buttons (tools, views, mapping, tiling, layer actions). Loaded through IconManager with
     // the same colour/monochrome variants the main toolbar uses, so an inactive button shows the icon in

tests/libslic3r/test_texture_displacement.cpp

@@ -2174,3 +2174,318 @@ TEST_CASE("whether a layer's texture has colour agrees with its decode", "[Textu
 
     CHECK_FALSE(height_texture_has_color(TextureDisplacementLayer{}));
 }
+
+// ---------------------------------------------------------------------------------------------
+// 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));
+        }
+    }
+}