diff --git a/TEXTURE_DISPLACEMENT.md b/TEXTURE_DISPLACEMENT.md index c30592de77..b557bad8db 100644 --- a/TEXTURE_DISPLACEMENT.md +++ b/TEXTURE_DISPLACEMENT.md @@ -1,9 +1,7 @@ # Texture Displacement - Technical Notes -Branch: `feature/texture_displacement`. This document is a knowledge dump of the whole feature as -it stands: architecture, file map, algorithms, known bugs found and fixed (with root causes worth -remembering), and what's still deferred. Written so a fresh session (or a fresh pair of eyes) can -pick this up without re-deriving everything from scratch. +Branch: `feature/texture_displacement`. Reference for the feature as it stands: what it does, how the +algorithms work, and where the code lives. ## What it does @@ -14,24 +12,67 @@ A paint-style gizmo (`GLGizmoTextureDisplacement`) that lets you: (saved into `/textures/displacement/`, kept separate so app updates can't clobber it). - Combine overlapping layers with image-editor-style blend modes (Add/Subtract/Multiply/Divide). - Preview the true displaced result live, before baking (background job, not on the UI thread). -- Optionally preview via a fast GPU bump-map shader instead (no real geometry movement, just - shading) for a lighter-weight alternative. +- Preview via a fast GPU shader instead (no real geometry movement) for a lighter-weight alternative. - Bake into real mesh geometry on demand, restricted to the painted area only. -- Subdivide a low-poly model first so there are enough vertices to show fine detail. +- Remesh and subdivide so a low-poly model has enough vertices to show fine detail. - Unwrap a painted patch with a real CGAL LSCM parameterization and view it in a dedicated, dockable 2D "UV Editor" pane. +## Standard vs Pro mode + +A two-position slider in the panel header, right of the Dock/Undock button. + +**Pro** shows every mesh-preparation control; Remesh, Subdivide and Bake are run separately by the user, +in whatever order they like. + +**Standard** hides all of it and folds one fixed recipe into the Bake button, because a height map only +ever *moves vertices that already exist* - painting onto an imported 12-triangle box and pressing Bake +would otherwise do nothing visible. Standard's Bake is: + +1. `plan_remesh()` + `replace_mesh_keep_all_paint()` - isotropic remesh to 1 mm, sharp edges above 40 + degrees protected. Gives the subdivider an even starting density whatever the input looked like. +2. `plan_adaptive_subdivision()` + `apply_adaptive_subdivision()` - feature-adaptive refinement, max + edge 20 mm, detail 0.02 mm, min edge 0.02 mm. +3. `bake()` - the ordinary background displacement job. + +Both preparation stages are *planned* before the undo snapshot and *applied* after it, so a stage with +nothing to do is skipped without leaving an empty undo step. The standalone Pro buttons share the same +plan/apply split. + +**All three stages sit under one undo step.** `Plater::take_snapshot()` records the state *before* the +change, so a single snapshot taken at the top of `bake_standard()` means one Undo returns the mesh to +exactly what was imported. `TextureDisplacementBakeInput::take_snapshot` lets the caller say who owns +the undo step - true for the Pro-mode button, false for the pipeline, whose background job commits long +after that snapshot's scope has closed. + +The presets live in one place (`STD_*` constants) and `apply_standard_mode_presets()` pins the hidden +controls to them every frame while Standard is active, so the live preview cannot disagree with what +Bake will do. Switching to Standard also closes the subdivision preview, whose controls have just gone. + +One control survives into Standard: **"Added triangles (k)"**, the subdivision budget. It is deliberately +*not* pinned - pinning would fight the user's own slider every frame - because unlike the rest of the +recipe its right value depends on the part rather than on the method (a big model, or a fine texture, +simply needs more triangles). Default 1500. The widget is one lambda shared by both layouts. + +Standard remeshes *after* painting, so the remesh has to preserve paint: `ModelVolume::restore_painting()` +only remaps the four standard channels, so `replace_mesh_keep_all_paint()` additionally runs +`TriangleSelector::remap_painting()` over the eight texture-displacement masks. The Pro Remesh button +goes through the same helper. If the remap comes back empty the pipeline stops with a message rather +than baking a flat mesh. + ## Architecture ### Data model (per `ModelVolume`) Each of up to `TEXTURE_DISPLACEMENT_MAX_LAYERS` (8) layers gets its **own independent -`FacetsAnnotation`** paint mask - the exact same `TriangleSelector`/`FacetsAnnotation` machinery -every other paint gizmo (FdmSupports, Seam, MMU, FuzzySkin) already uses, just one full instance -per layer slot instead of one per volume. This is what makes "layered/blended" painting work for -free: the same triangle can be `ENFORCER` in layer 2's mask and layer 5's mask simultaneously, and -at bake/preview time each layer displaces the surface left by the previous one (image-editor-layer -semantics). +`FacetsAnnotation`** paint mask - the same `TriangleSelector`/`FacetsAnnotation` machinery every other +paint gizmo (FdmSupports, Seam, MMU, FuzzySkin) already uses, just one full instance per layer slot +instead of one per volume. This is what makes layered/blended painting work for free: the same triangle +can be `ENFORCER` in layer 2's mask and layer 5's mask simultaneously, and at bake/preview time each +layer displaces the surface left by the previous one (image-editor-layer semantics). + +Whole-stack settings (border handling, post-process smoothing) live beside the layers in +`texture_displacement_options` (`TextureDisplacementOptions`), since they belong to no single layer. ### Bake algorithm (`libslic3r/TextureDisplacement.cpp`) @@ -42,13 +83,13 @@ same order - only the positions of displaced vertices differ. 1. `its_compactify_vertices()` on a copy of the input. In practice a no-op (it only drops *unreferenced* vertices, and preserves the order and indices of the rest). It is there to guarantee the index alignment step 3 depends on. -2. Area-weighted vertex normals of the **undisplaced** mesh, computed once. Every layer both - projects and displaces along these, so a vertex covered by several layers moves along one single - well-defined direction. Where the paint does *not* cover every triangle around a vertex, the normal - is recomputed from the painted triangles alone (the union over all layers, so it stays one direction - per vertex). On the rim of a fully painted top face the whole-mesh normal is the 45 degrees bisector - it shares with the side wall, and displacing along that flares the rim outwards instead of raising - it. Interior vertices are unaffected - all their triangles are painted, so the two coincide. Paint +2. Area-weighted vertex normals of the **undisplaced** mesh, computed once. Every layer both projects + and displaces along these, so a vertex covered by several layers moves along one single well-defined + direction. Where the paint does *not* cover every triangle around a vertex, the normal is recomputed + from the painted triangles alone (the union over all layers, so it stays one direction per vertex): + on the rim of a fully painted top face the whole-mesh normal is the 45-degree bisector it shares with + the side wall, and displacing along that flares the rim outwards instead of raising it. Interior + vertices are unaffected - all their triangles are painted, so the two normals coincide. Paint coverage per original triangle comes straight off `TriangleSplittingData::triangles_to_split`. 3. For each layer in slot order: deserialize its stored paint mask into a `TriangleSelector` against the **base mesh** (never against a previous layer's output), then @@ -61,36 +102,33 @@ same order - only the positions of displaced vertices differ. brush stroke split a triangle are appended after them), and `get_facets_strict()` emits the referenced ones in order. Combined with step 1, **selector vertex index `i` is our vertex `i`**. Split vertices live past the end of our array and are simply skipped - they sit on the paint - boundary anyway (splitting only happens at partial coverage), so they would be pinned regardless. + boundary anyway (splitting only happens at partial coverage). 4. A vertex used by at least one **unpainted** triangle is a border vertex. Whether it moves is - `TextureDisplacementOptions::displace_border`, and it **does by default**. The original design - pinned it, justified as stopping the patch tearing away from the surrounding surface - which stopped - being true the moment the bake became topology-preserving. There is no seam to tear: a border vertex - is *one* vertex shared by both regions, and moving it simply tilts the unpainted triangles that use - it. What pinning actually does is clamp the outermost ring of relief to zero, so on a fully painted - face the pattern collapses into a ring of steep ramps right at the edge - the reported "it doesn't - extrude at the border" artifact. Pinning is kept as an option for the case where the relief must not - spill past the paint at all. Either way the border still drives the `edge_smoothing` falloff. + `TextureDisplacementOptions::displace_border`, and it does by default. Nothing can tear: the bake is + topology-preserving, so a border vertex is *one* vertex shared by both regions and moving it simply + tilts the unpainted triangles that use it. Pinning it instead clamps the outermost ring of relief to + zero, which on a fully painted face collapses the pattern into a ring of steep ramps at the edge; it + is kept as an option for when the relief must not spill past the paint at all. Either way the border + drives the `edge_smoothing` falloff. 5. Per interior vertex: sample the height texture (`sample_layer_height()`, see Projection methods) and fold `height * depth_mm * (invert ? -1 : 1)` into that vertex's running total via the layer's `TextureBlendMode` (see Blend modes). A `visited` set makes each layer fold in exactly **once** per vertex, no matter how many of the patch's triangles share it - otherwise a Multiply/Subtract layer would apply two or three times over depending on local triangle fan-out. -6. Finally, move each touched vertex along its (step 2) normal by its accumulated total. +6. Move each touched vertex along its (step 2) normal by its accumulated total. 7. Optionally (`TextureDisplacementOptions::smooth_*`) relax the result - see Post-process smoothing. ### Post-process smoothing -`smooth_mesh_vertices(mesh, movable, strength, iterations)` - plain Laplacian relaxation, run after all -layers have been folded in, restricted to the vertices flagged in `movable`. Each pass moves a movable -vertex a `strength` fraction of the way to the average of its one-ring, read from a **snapshot** of the -previous pass so the result does not depend on vertex order (a Gauss-Seidel sweep would smooth several -times as hard at the end of the array as at the start). Neighbours come from a CSR-style adjacency built -once per call. +`smooth_mesh_vertices(mesh, movable, strength, iterations)` - Laplacian relaxation, run after all layers +have been folded in, restricted to the vertices flagged in `movable`. Each pass moves a movable vertex a +`strength` fraction of the way to the average of its one-ring, read from a **snapshot** of the previous +pass so the result does not depend on vertex order (a Gauss-Seidel sweep would smooth several times as +hard at the end of the array as at the start). Neighbours come from a CSR-style adjacency built once per +call. Topology-preserving, like the bake. -Its job is to round off the hard steps a bitmap height map leaves behind, which is a different knob from -`TextureDisplacementLayer::smoothing` - that blurs the *height map* before it is ever sampled, this -relaxes the *geometry* afterwards. Topology-preserving, like the bake. +Its job is to round off the hard steps a bitmap height map leaves behind - a different knob from +`TextureDisplacementLayer::smoothing`, which blurs the *height map* before it is ever sampled. Two ways in, sharing one set of settings on the volume: - The **"Smooth result"** checkbox + "Smoothing (%)" / "Passes" ride along with Preview and Bake. @@ -103,14 +141,13 @@ Two ways in, sharing one set of settings on the volume: operation in the gizmo that keeps **every** paint channel verbatim - it saves and restores the eight texture-displacement masks around `set_mesh()` rather than remapping or dropping them. -**"Ignore outer ring"** (`smooth_skip_border`, **on by default**) drops the patch's own outermost ring of +**"Ignore outer ring"** (`smooth_skip_border`, on by default) drops the patch's own outermost ring of vertices from `movable`. That ring's neighbours *outside* the paint never move, so relaxing it drags the -rim of the relief back down toward the flat surface and the pattern comes out half-melted exactly where -it meets the edge - crisp everywhere else, which is what makes it look like a bug rather than a setting. -Held out, the border keeps the full depth the texture asked for and only the interior relaxes. Turning it -off softens the outer edge deliberately (a blunter version of the per-layer edge-smoothing falloff). -Note this is the *smoothing* rim, a separate question from whether that rim is displaced at all -(`displace_border`, step 4 above) - the two are independent and both default to "keep the border sharp". +rim of the relief down toward the flat surface and the pattern comes out half-melted where it meets the +edge. Held out, the border keeps the full depth the texture asked for and only the interior relaxes. +Turning it off softens the outer edge deliberately (a blunter version of the per-layer edge-smoothing +falloff). This is the *smoothing* rim, independent of whether that rim is displaced at all +(`displace_border`, step 4 above); both default to keeping the border sharp. ### Blend modes @@ -122,50 +159,46 @@ Add/Subtract are self-explanatory. Multiply/Divide are *scaling* operations and convention: they treat the layer's own value as a **factor relative to 1 mm**. That makes `depth_mm` a gain, and - the property that makes a Multiply layer usable as a mask - a layer with depth 1 mm sampling a white (1.0) texel multiplies by exactly 1, i.e. leaves the layers below unchanged. -Divide floors its divisor's magnitude at 0.05 - a black texel samples to *exactly* zero, so the -divisor really does hit zero in ordinary use, and an unbounded `1/0` would fling vertices thousands -of mm away and poison the mesh's bounding box (and every plate/print-volume check downstream). The -floor doubles as a cap on how far Divide can amplify the relief beneath it: at most 20×. +Divide floors its divisor's magnitude at 0.05: a black texel samples to *exactly* zero, so the divisor +really does hit zero in ordinary use, and an unbounded `1/0` would fling vertices thousands of mm away +and poison the mesh's bounding box (and every plate/print-volume check downstream). The floor doubles as +a cap on how far Divide can amplify the relief beneath it: at most 20×. The **lowest painted layer ignores its blend mode**: it has nothing beneath it, and Multiply/Divide -against an implicit zero base would annihilate (or blow up) it. Enforced in `build_texture_ -displacement()` (the first layer to reach a given vertex always folds in additively) and surfaced in -the UI, which labels that layer "Base layer" instead of offering a control that silently does nothing. +against an implicit zero base would annihilate (or blow up) it. Enforced in +`build_texture_displacement()` (the first layer to reach a given vertex always folds in additively) and +surfaced in the UI, which labels that layer "Base layer" instead of offering a control that does nothing. ### Projection methods -Four choices per layer (`TextureProjectionMethod`), all funneling through `apply_uv_transform()` +Five choices per layer (`TextureProjectionMethod`), all funneling through `apply_uv_transform()` (scale by `1/tiling_scale`, rotate by `rotation_deg`, add `offset`). They are dispatched by `sample_layer_height()`, which returns a **height**, not a UV - because Triplanar takes three texture samples per vertex and so has no single UV that represents it. - **Triplanar** (default) - samples the texture on all three world planes (`(y,z)`, `(x,z)`, `(x,y)`) - and blends the three by the vertex's own normal raised to `TRIPLANAR_BLEND_SHARPNESS` (4). - This is the fix for a real, user-reported bug. The previous version *hard-picked* the single axis - most aligned with the normal, which is discontinuous wherever that dominant axis flips: on a +X - face the planar coordinate is `(y, z)`, on a −Y face it is `(x, z)`, so at the shared edge `u` - jumps from `y_edge` to `x_edge`. On a box centred near the origin those two happen to **agree** at - the (+,+) and (−,−) corners and **differ by the full corner width** at the (+,−) and (−,+) corners - - which is exactly the "two bad corners, two good ones" symmetry that was observed. A weighted - blend is continuous across the transition by construction, since the weight of the axis being left - behind falls smoothly to zero. (Note this removes the hard *seam*; some cross-fade blurring in the - band right at a 90° edge is inherent to triplanar mapping. A genuinely seam-free wrap around a box - needs a real unwrap - that is what the LSCM mode is for.) + and blends the three by the vertex's own normal raised to `TRIPLANAR_BLEND_SHARPNESS` (4). Hard-picking + the single axis most aligned with the normal instead is discontinuous wherever that dominant axis + flips: on a +X face the planar coordinate is `(y, z)`, on a −Y face it is `(x, z)`, so at the shared + edge `u` jumps. A weighted blend is continuous across the transition by construction, since the weight + of the axis being left behind falls smoothly to zero. This removes the hard *seam*; some cross-fade + blurring in the band right at a 90° edge is inherent to triplanar mapping. A genuinely seam-free wrap + around a box needs a real unwrap - that is what the LSCM mode is for. - **Cylindrical** - wraps around an axis through the patch centroid, axis auto-picked as the world axis *least* aligned with the average normal (perpendicular to the outward radial normal, as a cylinder's own axis would be). `u = angle * local_radius` (arc length in mm), `v = distance along - axis`. Approximation, not an exact fit for arbitrary geometry. + axis`. An approximation, not an exact fit for arbitrary geometry, and the axis/centre are not + user-overridable. - **Spherical** - longitude/latitude around the centroid, scaled by local radius. Same caveat. - **LSCM** - real UV unwrap via `MeshBoolean::cgal::parameterize_lscm()` (CGAL's `Surface_mesh_parameterization` package, LSCM algorithm). Computed **once per patch** (not per-vertex like the others - it's a single global least-squares solve), then each vertex looks up its precomputed UV. Requires the patch to be a single topological disk (one connected component, - one boundary loop) - `compute_lscm_uvs()` returns empty and the layer silently falls back to - Triplanar if not (e.g. multiple disconnected painted islands, or a fully closed patch). - CGAL's parameterizer needs a mesh with no isolated/unreferenced vertices, but `get_facets_strict()` - returns the *whole* mesh's vertex array - so there's a compaction step - (`compact_patch_with_map()`) that builds a clean sub-mesh + an index map back to the original - (uncompacted) vertex numbering, purely local to this file. + one boundary loop) - `compute_lscm_uvs()` returns empty and the layer falls back to Triplanar if not + (e.g. multiple disconnected painted islands, or a fully closed patch). CGAL's parameterizer needs a + mesh with no isolated/unreferenced vertices, but `get_facets_strict()` returns the *whole* mesh's + vertex array - so `compact_patch_with_map()` builds a clean sub-mesh plus an index map back to the + original vertex numbering, purely local to this file. - **ViewProjected** ("From view") - a flat projection along a fixed direction captured from the 3D camera, like a slide projector. `capture_view_projection()` takes the camera's right/up axes, transforms them into the volume's *local* frame (so the projection rides along if the part is later @@ -174,7 +207,7 @@ texture samples per vertex and so has no single UV that represents it. projects `Vec2f(dot(pos, right), dot(pos, up))`. Single-valued per point, so - like LSCM but unlike blended Triplanar - the fast preview and UV-check overlay precompute it per vertex (`compute_layer_vertex_uvs()`) and drive the shader's `use_vertex_uv` path. Faces angled away from - the projector smear; that is inherent to view projection, not a bug. + the projector smear; that is inherent to view projection. Two companions to this mode: - **Projection frame overlay** (`TextureProjectorFrame`, see below) - a semi-transparent window @@ -202,35 +235,34 @@ untouched) still forces a re-solve. Like the paint masks, seams are mesh-index-s any topology change. Two ways to write to it: -- **Mark seam (manual, #9)** - a "Mark seams" click mode (`m_seam_edit_mode`) that suppresses - painting. A click raycasts the volume (`m_c->raycaster()->raycasters()[idx]->unproject_on_mesh()`, - `idx` = the volume's slot among model-part volumes), finds the facet's edge nearest the hit point, - and toggles it. Marked edges render as a red overlay (`render_seam_overlay()`), pulled toward the - camera so they read on top. This is the Blender mark-seam workflow. -- **Cut island (auto, #17)** - `cut_island()` takes the selected chart's triangles (back-mapped from - the unwrap via `source_vertex`), finds their 3D bounding box, and marks every edge that straddles - the mid-plane perpendicular to the longest axis. The re-unwrap then splits the chart across its - narrow waist - the "islands might be very long" case. Exposed as the UV pane's **Cut** button. +- **Mark seam (manual)** - a "Mark seams" click mode (`m_seam_edit_mode`) that suppresses painting. A + click raycasts the volume (`m_c->raycaster()->raycasters()[idx]->unproject_on_mesh()`, `idx` = the + volume's slot among model-part volumes), finds the facet's edge nearest the hit point, and toggles it. + Marked edges render as a red overlay (`render_seam_overlay()`), pulled toward the camera so they read + on top. This is the Blender mark-seam workflow. +- **Cut island (auto)** - `cut_island()` takes the selected chart's triangles (back-mapped from the + unwrap via `source_vertex`), finds their 3D bounding box, and marks every edge that straddles the + mid-plane perpendicular to the longest axis. The re-unwrap then splits the chart across its narrow + waist. Exposed as the UV pane's **Cut** button. ### UV-check overlays (checker / distortion) `resources/shaders/{110,140}/texture_displacement_uvcheck.{vs,fs}`, one shader with a `mode` uniform, drawn over the painted patch (`rebuild_uvcheck_mesh()`/`render_uvcheck_mesh()`, P3N3T2: `normal.x` = -distortion, `tex_coord` = uv), pulled forward with a polygon offset. **Checker** (#13) samples a -procedural checkerboard at the layer's uv (per-vertex for LSCM/ViewProjected, in-shader triplanar -otherwise) - squares that stay square mean low distortion. **Distortion** (#14) colours each triangle -blue→green→red by `log2(uv_area / surface_area)` centred on the patch's *median* stretch (so a -globally-scaled unwrap reads as uniformly ideal and only relative stretch shows), averaged to -vertices. A separate **Show mesh wireframe** toggle (#8) draws the whole volume's triangle edges, -rebuilt only when the vertex count changes (not per stroke). +distortion, `tex_coord` = uv), pulled forward with a polygon offset. **Checker** samples a procedural +checkerboard at the layer's uv (per-vertex for LSCM/ViewProjected, in-shader triplanar otherwise) - +squares that stay square mean low distortion. **Distortion** colours each triangle blue→green→red by +`log2(uv_area / surface_area)` centred on the patch's *median* stretch (so a globally-scaled unwrap +reads as uniformly ideal and only relative stretch shows), averaged to vertices. A separate **Show mesh +wireframe** toggle draws the whole volume's triangle edges, rebuilt only when the vertex count changes +(not per stroke). ### Tiling `DecodedHeightTexture::sample(uv, tile_enabled, tile_method)`. Two tile methods when enabled (Repeat, MirroredRepeat). **When `tile_enabled` is false, sampling outside `[0,1)` returns `0` -directly** - clamping the *coordinate* into range (what an earlier version did) instead smears the -border row/column of pixels outward to infinity in every direction, which is a real bug that was -reported and fixed (visually: streaky lines radiating out from the painted patch). +directly** rather than clamping the *coordinate* into range, which would smear the border row/column of +pixels outward to infinity in every direction (streaky lines radiating out from the painted patch). ### Subdivision — two modes @@ -242,16 +274,15 @@ no subdivision), Apply snaps back to 0. Drops texture-displacement paint (no rem `save_painting()`/`set_mesh()`/`restore_painting()` dance; the other four channels are remapped. **Adaptive (`subdivide_mesh_adaptive()`)** — refine **only the painted area**, by **Rivara longest-edge -bisection**. This is the algorithm that was "scoped out" originally for fear of the T-junction/crack -problem; it is safe because it is *conformal by construction*. Only **terminal** edges are ever bisected -- an edge that is the longest edge of *every* triangle sharing it - which splits both those triangles -along one shared midpoint at once, so a hanging node is never created. The edge to split for a triangle -that wants refining is found by **longest-edge propagation (LEPP)**: walk to the longest edge of -ever-longer-edged neighbours until a terminal one is reached, and bisect that. Edge length strictly -increases along the path (ties broken by mesh-vertex key, which both sides of an edge compute -identically), so the walk cannot cycle, and Rivara's result is that repeating it refines the original -triangle in a bounded number of bisections. The transition triangles it pulls in just outside the -painted patch are the graded band that makes the size change conformal. +bisection**, which is *conformal by construction*. Only **terminal** edges are ever bisected - an edge +that is the longest edge of *every* triangle sharing it - which splits both those triangles along one +shared midpoint at once, so a hanging node is never created. The edge to split for a triangle that wants +refining is found by **longest-edge propagation (LEPP)**: walk to the longest edge of ever-longer-edged +neighbours until a terminal one is reached, and bisect that. Edge length strictly increases along the +path (ties broken by mesh-vertex key, which both sides of an edge compute identically), so the walk +cannot cycle, and Rivara's result is that repeating it refines the original triangle in a bounded number +of bisections. The transition triangles it pulls in just outside the painted patch are the graded band +that makes the size change conformal. The win: a small decal on a big model no longer quadruples the *whole* model's triangle count. @@ -260,16 +291,11 @@ of sweeps: it holds every triangle that is over its criteria in a max-heap keyed it is, pops the worst, walks its LEPP, bisects, and re-scores. Edge adjacency (`nb[e]`, the triangle across each edge) is built **once** and maintained incrementally through each bisection, so the cost scales with the refined region rather than with the whole model. `max_triangles` is the only bound; -stopping on it leaves a perfectly valid, still-conformal mesh that spent its budget on the largest errors. +stopping on it leaves a perfectly valid, still-conformal mesh that spent its budget on the largest +errors. A fixed sweep count instead spends itself grading the *coarse surroundings* - whose edges are +the longest, so they win every terminal-edge contest - and never reaches the painted patch. -This shape replaced a first version that ran a fixed 12 sweeps, each rebuilding a whole-mesh edge map and -bisecting one terminal edge per active triangle. Two failure modes came out of that, and they are worth -remembering because they look like separate bugs and are not: the sweeps were consumed grading the -*coarse surroundings* (whose edges are the longest, so they win every terminal-edge contest), which both -**stopped refinement of the painted patch far short** of the requested detail and left the band outside -it looking wildly over-refined relative to the patch itself. - -**It carries the paint forward**, which is what makes it usable (uniform/remesh both drop paint). Because +**It carries the paint forward**, which is what makes it usable (uniform subdivide drops paint). Because the refinement is *driven by* the paint, the remap is trivial: `subdivide_mesh_adaptive()` fills an `out_source[new_tri] = input_tri` map (children inherit their parent), and the gizmo rebuilds each layer's mask on the new mesh - a new triangle is painted iff its source was fully painted in that @@ -277,32 +303,30 @@ layer. `collect_paint_region()` derives both: - the union refine-region: **exactly** the original triangles the brush touched, read straight off `TriangleSplittingData::triangles_to_split` (`serialize()` records an entry per original triangle that is either split - i.e. partially painted, the patch boundary - or carries a non-default state). No - dilation. An earlier version marked every triangle sharing a *vertex* with the patch, which drags in a - whole fan of huge unpainted neighbours and then refines *those* down to the resolution floor, since the - height field the detail test samples is not restricted to the painted area. The conformal closure - already grades the size change outward on its own; it does not need help. + dilation: marking every triangle that shares a *vertex* with the patch drags in a whole fan of huge + unpainted neighbours and refines *those* down to the resolution floor, since the height field the + detail test samples is not restricted to the painted area. The conformal closure already grades the + size change outward on its own. - the per-layer fully-painted-triangle sets (a `get_facets_strict(ENFORCER)` sub-triangle with all three *original* vertex indices == a whole, fully-painted original triangle; a partial stroke's sub-triangles always carry a split vertex). -The other four channels still ride the normal `restore_painting()` remap. Covered by a conformality unit -test (`every_edge_used_twice` on a partially-refined cube - an exact crack detector for a closed mesh), -plus tests that the target edge length is actually *reached* and that the budget caps the result without -opening a crack. +The other four channels ride the normal `restore_painting()` remap. -Both share the gizmo's Preview/Apply/Done flow; the **"Only painted area (adaptive)"** checkbox picks -the mode, and the adaptive preview follows the paint live (`rebuild_preview()` refreshes the wireframe -while the subdivide preview is open in adaptive mode). The panel shows the previewed triangle count. +Both modes share the gizmo's Preview/Apply/Done flow; the **"Only painted area (adaptive)"** checkbox +picks the mode, and the adaptive preview follows the paint live (`rebuild_preview()` refreshes the +wireframe while the subdivide preview is open in adaptive mode). The panel shows the previewed triangle +count. **Feature-adaptive (follow texture detail).** A sub-mode of adaptive (the **"Follow texture detail"** -checkbox) that puts triangles where the *displaced surface actually bends*, not evenly. The insight: -a flat region or a linear **ramp** needs no extra vertices (linear interpolation is exact for a ramp); -what needs them is **curvature** - the *second* derivative, not the gradient. So the extra predicate is a -**chord-error** test: sample the combined displacement at the triangle's three edge midpoints *and its -centroid* (sampling the interior is what catches a bump sitting inside a triangle, the blind spot of an -edge-only test) and take the largest departure from the flat triangle's barycentric interpolation. Refine -while that exceeds `chord_tolerance_mm` ("Detail (mm)"). Zero chord error on a ramp ⇒ untouched; high on -a bump/ridge/noise ⇒ refined until captured. Same conformal machinery, so still crack-free. The +checkbox) that puts triangles where the *displaced surface actually bends*, not evenly. A flat region or +a linear **ramp** needs no extra vertices (linear interpolation is exact for a ramp); what needs them is +**curvature** - the *second* derivative, not the gradient. So the extra predicate is a **chord-error** +test: sample the combined displacement at the triangle's three edge midpoints *and its centroid* +(sampling the interior is what catches a bump sitting inside a triangle, the blind spot of an edge-only +test) and take the largest departure from the flat triangle's barycentric interpolation. Refine while +that exceeds `chord_tolerance_mm` ("Detail (mm)"). Zero chord error on a ramp ⇒ untouched; high on a +bump/ridge/noise ⇒ refined until captured. Same conformal machinery, so still crack-free. The per-triangle error is cached and recomputed only for the children of a split. Four knobs bracket it, and all four matter: @@ -320,33 +344,40 @@ The height field is `make_combined_displacement_sampler()` - it mirrors `build_t per-layer setup (decode, patch centroid, cylinder axis, blend order, "lowest layer folds additively") but evaluated per point. Two deliberate simplifications, both erring toward *more* detail (safe - over-refinement is never a crack): every sampleable layer is sampled at every point (no per-point paint -test), and edge-smoothing falloff is ignored. Note the first one is *why* the refine region must not be -dilated - outside the paint the sampler still reports full relief. **LSCM layers are skipped** (no -per-point UV); a purely LSCM stack yields a null sampler and the code falls back to the length baseline -alone. Per-vertex heights are sampled lazily, so a small patch on a huge model never pays for the rest of -it. Covered by unit tests: a Gaussian bump refines densely at its center and leaves flat corners coarse, -a linear ramp produces *zero* extra triangles (the case a gradient criterion would over-refine), and a -flat field still honours the max-edge baseline. +test), and edge-smoothing falloff is ignored. The first is *why* the refine region must not be dilated - +outside the paint the sampler still reports full relief. **LSCM layers are skipped** (no per-point UV); a +purely LSCM stack yields a null sampler and the code falls back to the length baseline alone. Per-vertex +heights are sampled lazily, so a small patch on a huge model never pays for the rest of it. -### Fast bump preview (GPU-only, no CPU meshing) +### Fast preview (GPU-only, no CPU meshing) `resources/shaders/{110,140}/texture_displacement_bump.{vs,fs}`, registered as -`"texture_displacement_bump"`. Perturbs the *shading* normal from the height texture's local -gradient instead of moving geometry - active-layer-only, toggled via a "Fast preview (normal map)" -checkbox. Vertex format is `GLModel::Geometry::EVertexLayout::P3N3T2`: `normal.x` carries the -per-vertex paint weight (0/1) and `tex_coord` carries a precomputed texture UV, so it can use -`GLModel` normally instead of needing a hand-rolled VBO/VAO manager. Weight buffer is -rebuilt at the same cadence as the true-displacement preview (stroke-end/slider-release), using the -**live** `TriangleSelector` state (not the flushed model facets), so it doesn't lag by a full model -round-trip. +`"texture_displacement_bump"`. Shades the *displaced* surface without moving geometry - active-layer +only, selected from the View row, and the default when the gizmo opens (`m_use_bump_preview = true`). +Vertex format is `GLModel::Geometry::EVertexLayout::P3N3T2`: `normal.x` carries the per-vertex paint +weight (0/1), `normal.y` flags the UV island currently being dragged, and `tex_coord` carries a +precomputed texture UV, so it can use `GLModel` normally instead of a hand-rolled VBO/VAO manager. + +The mesh is **flat** (vertices not shared between triangles): every corner of a painted triangle gets +weight 1, every corner of an unpainted one weight 0. A coarse mesh needs that - one painted face of a raw +cube has no strictly-interior vertex, so per-vertex weighting would either bleed onto the neighbours or +vanish outright. Duplicating vertices costs no shading quality here because the shader takes its surface +normal from screen-space derivatives of position, not from a per-vertex normal. + +**Both preview meshes work in the patch's vertex space, not the mesh's.** Those agree only until a +*brush* stroke splits a triangle: `get_facets_strict()` then appends the split vertices, so the patch +array is longer. `rebuild_bump_preview_mesh()` and `rebuild_uvcheck_mesh()` therefore index +`patch.vertices` throughout. The weight buffer is rebuilt at the same cadence as the true-displacement +preview (stroke-end/slider-release) but from the **live** `TriangleSelector` state, not the flushed model +facets, so it does not lag by a full model round-trip. The perturbed normal is the analytic one for a height field `H = ±depth_mm · h(uv)` displaced along `N` over any orthonormal surface tangent pair `T`/`B`: N' = normalize(N − (dH/da)·T − (dH/db)·B), a = dot(p,T), b = dot(p,B) -The two slopes have to be genuine **mm-per-mm** derivatives for the preview's apparent depth to -match the bake's - see bug #13. +The two slopes have to be genuine **mm-per-mm** derivatives for the preview's apparent depth to match +the bake's. **Two projection paths (`use_vertex_uv` uniform):** - **Triplanar (`use_vertex_uv = 0`)** - `uv` and the `T`/`B` axes are both derived in-shader from @@ -354,32 +385,58 @@ match the bake's - see bug #13. formed analytically. `T`/`B` are the projection's axis-aligned pair, exact only when the face is axis-aligned; the shader drops the along-normal component to keep the gradient in the surface. Here one `uv` unit is exactly `tiling_scale` mm, so the `1/tiling_scale` gradient factor is right. -- **Precomputed UV (`use_vertex_uv = 1`, used for LSCM)** - `uv` comes per-vertex from the CPU - (`compute_lscm_uvs(patch, layer)`, so island placement + tiling/rotation/offset are already folded +- **Precomputed UV (`use_vertex_uv = 1`, used for LSCM and ViewProjected)** - `uv` comes per-vertex from + the CPU (`compute_layer_vertex_uvs()`, so island placement + tiling/rotation/offset are already folded in), and the perturbed normal is built with **Mikkelsen's method** ("Bump Mapping Unparametrized Surfaces on the GPU"): the surface gradient taken directly from the screen-space derivatives of the - *sampled height* and position. **This makes no uv→mm scale assumption**, which is essential - - the first cut used the same global `1/tiling_scale` factor as triplanar and the depth came out - visibly wrong, because an LSCM map is **conformal, not isometric**: it is globally area-scaled but - the *local* mm-per-uv varies across the chart. `dFdx(h)` captures the true on-screen rate of change - however the chart is stretched. **This path is also what makes the fast preview follow the UV - editor: move an island and its uv - hence its bump - moves with it** (the bump mesh rebuilds on - drag-end, since `on_island_edited(finished)` → `rebuild_preview()` → `rebuild_bump_preview_mesh()`). - The branch is uniform (`use_vertex_uv` is a uniform) and the paint weight gates by multiply, so the + *sampled height* and position. **This makes no uv→mm scale assumption**, which is essential, because an + LSCM map is **conformal, not isometric**: it is globally area-scaled but the *local* mm-per-uv varies + across the chart, so a single global `1/tiling_scale` factor gets the apparent depth wrong. `dFdx(h)` + captures the true on-screen rate of change however the chart is stretched. This path is also what makes + the fast preview follow the UV editor: move an island and its uv - hence its shading - moves with it + (the mesh rebuilds on drag-end, `on_island_edited(finished)` → `rebuild_preview()` → + `rebuild_bump_preview_mesh()`). The branch is uniform and the paint weight gates by multiply, so the texture derivatives stay well defined. A triangle straddling a seam has a discontinuous uv → the `det≈0` guard skips it (a localised preview-only artifact, never in the bake). -Remaining deliberate approximation: the GPU sampler's wrap mode stands in for -`tile_enabled`/`tile_method`, so with tiling *off* the GPU repeats where the CPU returns 0 outside +**Parallax (triplanar path).** Perturbing the shading normal alone welds the pattern to the base surface: +it does not slide as the camera orbits, and does not get deeper as `depth_mm` grows. The triplanar path +therefore shades at the point the *displaced* surface would show at this pixel, found by **ray marching** +(parallax occlusion mapping). A point at ray parameter `s`, i.e. `P + V·s` (`P` the base point, `V` the +unit direction to the eye), sits at height `s·dot(V,n)` above the undisplaced surface. The displaced +surface lives in a shell between the extreme values of `amp·(h − midlevel)` - taken from both ends of +`h ∈ [0,1]`, so it holds for an inverted layer and a raised midlevel too, where the surface sits *below* +the undisplaced one. The march starts at the top of that shell, where the ray is outside the surface by +construction, and steps inward until the ray height drops below the sampled height. That crossing *is* +the visible point. + +Solving `Q = P + V·(H(Q)/dot(V,n))` by fixed-point iteration instead is geometrically exact but the +divisor goes to zero edge-on; the sample then lands a large fraction of a tile away and the iteration +oscillates, which reads as a second, flat copy of the pattern ghosted over the real one. Clamping the +step to one tile does not help - a tile-sized shift lands on the neighbouring tile, the same pattern +again. Offset limiting (stepping along the tangential part of `V`) is stable but understates parallax +enough that the relief still flattens as soon as the camera tilts. Marching has neither problem. + +The hit is interpolated between the last two samples, which keeps `PARALLAX_STEPS` (24) affordable, and +the whole march is skipped when sweeping the shell would move the sample point less than half a texel - +the head-on case, so the common view pays almost nothing. The 140 variant samples with +`textureLod(…, 0.0)` inside the loop, since implicit derivatives are undefined in non-uniform control +flow. Two uniforms exist for this: `midlevel` (parallax needs the real height, not just its derivative) +and `eye_model_pos` (the camera in the volume's local frame). + +Parallax cannot change the model's silhouette or cast shadows; the View row's Normal mode is one click +away for that. The LSCM path stays plain Mikkelsen bump - it has no closed-form uv, so there is no cheap +way to re-project a marched position. One further approximation: the GPU sampler's wrap mode stands in +for `tile_enabled`/`tile_method`, so with tiling *off* the GPU repeats where the CPU returns 0 outside `[0,1)`. ### On-canvas "Adjust Texture" gizmo -A per-active-layer toggle ("Adjust placement (drag on model)") that disables painting and shows a -flat pan panel (free 2D drag on both axes) plus two arrows along the patch's own U/V axes -(constrained single-axis drag). Anchored to the painted patch's centroid/average-normal -(`compute_layer_paint_anchor()`). Hit-testing is screen-space distance/point-to-segment (not real -3D ray intersection against the handle geometry) - simple and good enough at this handle size. +A per-active-layer toggle ("Adjust placement") that disables painting and shows a flat pan panel (free +2D drag on both axes) plus two arrows along the patch's own U/V axes (constrained single-axis drag). +Anchored to the painted patch's centroid/average-normal (`compute_layer_paint_anchor()`). Hit-testing is +screen-space distance/point-to-segment, not real 3D ray intersection against the handle geometry - simple +and good enough at this handle size. ### Projection frame overlay (ViewProjected) @@ -393,14 +450,14 @@ position and size *are* the placement, read on demand at Apply - which is also w visible-facet raycast runs. So dragging it is free and nothing recomputes until asked. Plain 2D (`wxPaintDC`), not a `wxGLCanvas`: a second GL canvas would have to share the app's one real -`wxGLContext`, the cause of bugs #10 and #14 below. It only ever draws a bitmap and a border. +`wxGLContext`. It only ever draws a bitmap and a border. -**The projective mapping (`apply_projection_frame()`)**. The frame defines a -**screen-space** rectangle, but the bake samples from a **local-space** position, so the two have to be -reconciled. `view_project_right/up` can only express an *affine* projection - exact under an -orthographic camera, but wrong under perspective, where the near end of a part projects larger than the -far end and no pair of axes reproduces that. So the layer instead stores a full projective map -(`view_project_matrix`, row-major 3×4, `uv = (row0·p̃/row2·p̃, row1·p̃/row2·p̃)`), built like this: +**The projective mapping (`apply_projection_frame()`)**. The frame defines a **screen-space** rectangle, +but the bake samples from a **local-space** position, so the two have to be reconciled. +`view_project_right/up` can only express an *affine* projection - exact under an orthographic camera, but +wrong under perspective, where the near end of a part projects larger than the far end and no pair of +axes reproduces that. So the layer instead stores a full projective map (`view_project_matrix`, row-major +3×4, `uv = (row0·p̃/row2·p̃, row1·p̃/row2·p̃)`), built like this: - `K = projection · view · (instance · volume)`, i.e. local → clip, the same product the renderer uses. Note `Camera::get_projection_matrix()` is typed `Transform3d` (nominally affine) but its perspective @@ -433,7 +490,7 @@ reopening keeps it where it was left. `UVEditorCanvas` (`src/slic3r/GUI/UVEditorCanvas.hpp/.cpp`) - a standalone `wxGLCanvas` rendering the flattened LSCM islands (per-island wireframe + outline + fill) over the height texture (background quad tiled across the whole unwrap), with mouse pan/zoom. It is wrapped in a **`UVEditorPanel`** -(same file) that adds a button row (Frame / Snap / Average scale) and a status line +(same file) that adds a button row (Frame / Snap / Avg scale / Cut / Join / Unjoin) and a status line along the bottom naming the current gesture and the shortcuts in play. The *panel* is what is registered as a `wxAuiPaneInfo` pane on `Plater`'s `m_aui_mgr`; `Plater::show_uv_editor(bool)` shows/hides it (deferred via `CallAfter`, since the gizmo calls it mid-3D-frame), and @@ -445,51 +502,24 @@ same call `View3D`/`Preview`/`AssembleView` make) rather than creating an indepe `"flat"`/`"flat_texture"` shaders and `GLModel` as-is, instead of needing its own shader compilation/VBO management. -**Geometry is uploaded once, in the unwrap's own (raw, mm) coordinates**, one `GLModel` set per -island; each island is then drawn through its own 2x3 affine (`island_transform_matrix()` composed -with the layer's tiling/rotation/offset) passed as the `flat` shader's `view_model_matrix`. A -drag updates one matrix per island and touches no vertex -buffer - `on_island_edited(!finished)` calls only `set_island_transforms()`, and the full -`set_islands()` rebuild happens solely when the unwrap itself changes (`unwrap_changed` in -`update_uv_editor()`). +**Geometry is uploaded once, in the unwrap's own (raw, mm) coordinates**, one `GLModel` set per island; +each island is then drawn through its own 2x3 affine (`island_transform_matrix()` composed with the +layer's tiling/rotation/offset) passed as the `flat` shader's `view_model_matrix`. A drag updates one +matrix per island and touches no vertex buffer - `on_island_edited(!finished)` calls only +`set_island_transforms()`, and the full `set_islands()` rebuild happens solely when the unwrap itself +changes (`unwrap_changed` in `update_uv_editor()`). **Gestures** (canvas-owned, reported to the gizmo as incremental deltas via `IslandEditFn`): left-drag = move, right-drag or **R** = rotate (hold **Shift** to snap to 15° steps - quantised on the *cumulative* rotation, not each delta, so it doesn't judder, and accumulated incrementally so it survives crossing ±180°), **S** = scale (R/S modal, click/Enter to confirm, Esc to cancel), wheel = zoom about the cursor, middle-drag = pan, **Home**/**F** = frame all. Scale writes -`TextureIsland::scale`; "Average scale" (`average_island_scales()`) sets every island to the mean, so +`TextureIsland::scale`; "Avg scale" (`average_island_scales()`) sets every island to the mean, so one island scaled by hand can be matched back to its neighbours' texel density. **Snap** (canvas-owned `m_snap_enabled`, toggled from the toolbar) sticks a dragged island's nearest boundary vertex onto a neighbouring island's at drag-*end* only - a magnet that re-applies mid-drag is very hard to pull out -of. Toolbar commands the canvas can't service itself (Average scale) are forwarded to the gizmo via -`CommandFn`; view-only ones (Frame, Snap) it handles directly. - -## Known limitations / deferred work - -- **No `.3mf` serialization** for texture-displacement paint data or texture assets. A background - agent attempted this in an earlier session, hit its own usage limit mid-edit, and left - `bbs_3mf.cpp` with an undefined forward-declared function; that partial edit was reverted rather - than shipped broken. Practical impact: **baked** geometry round-trips fine (it's just an ordinary - part of the mesh via the existing mesh serialization path) - what does *not* survive a project - save/reload is any *unbaked* paint stroke and texture layer definition. -- **No remap-across-topology-change** for texture-displacement paint (`ModelObject::split()`, mesh - boolean ops, Simplify, uniform subdivide, and remesh all drop it via `reset_extra_facets()`). The - other four paint channels (supported/seam/mmu/fuzzy) do get remapped in these cases. The lone - exception is **adaptive subdivide**, which carries texture-displacement paint forward itself via its - source map (see the Subdivision section) - a targeted remap that only works because the operation is - driven by the paint. -- **Cylindrical/Spherical axis/center are auto-picked heuristically**, not user-controllable - no - UI to override the auto-detected wrap axis if it picks the "wrong" one for an odd shape. -- **Fast preview covers the active layer only** — and is now the **default** view when the gizmo - opens (`m_use_bump_preview = true`): it is the instant, no-CPU-meshing preview, so it is the better - first impression while painting. The exact true-displacement view is one click away in the View row. -- **Displacement resolution is capped by the mesh's own vertex density.** Baking only ever *moves* - existing vertices (it never inserts any), so a coarse patch cannot show fine texture detail no - matter how high-resolution the height map is - that is what the subdivision controls are for - (uniform, adaptive, or feature-adaptive; see the Subdivision section). Since the rewrite the bake is - topology-preserving, so this is now a hard, explicit property rather than something partly papered - over by the old per-layer re-meshing. +of. Toolbar commands the canvas can't service itself (Avg scale, Cut, Join, Unjoin) are forwarded to the +gizmo via `CommandFn`; view-only ones (Frame, Snap) it handles directly. ## File map @@ -498,23 +528,18 @@ of. Toolbar commands the canvas can't service itself (Average scale) are forward tiling, subdivision (uniform + adaptive longest-edge bisection), post-process smoothing (`smooth_mesh_vertices()`), and `TextureDisplacementOptions` (the whole-stack settings). See doc comments throughout, they're kept accurate and up to date. -- `src/libslic3r/MeshBoolean.hpp/.cpp` - added `parameterize_lscm()` and `remesh_isotropic()` - in the `cgal` sub-namespace, - reusing the existing `CGALMesh`/`_EpicMesh`/conversion-helper infrastructure already there for - mesh boolean ops. New CGAL includes: `Polygon_mesh_processing/border.h`, +- `src/libslic3r/MeshBoolean.hpp/.cpp` - `parameterize_lscm()` and `remesh_isotropic()` in the `cgal` + sub-namespace, reusing the existing `CGALMesh`/`_EpicMesh`/conversion-helper infrastructure already + there for mesh boolean ops. CGAL includes: `Polygon_mesh_processing/border.h`, `Polygon_mesh_processing/connected_components.h`, `Surface_mesh_parameterization/{Error_code, - LSCM_parameterizer_3, parameterize}.h`. No new dependency - CGAL 5.6.3 is already vendored and - the `Surface_mesh_parameterization` package headers were already present, just unused before now. + LSCM_parameterizer_3, parameterize}.h`. No new dependency - CGAL 5.6.3 is already vendored and the + `Surface_mesh_parameterization` package headers were already present. - `src/libslic3r/Model.hpp/.cpp` - the 8 named `FacetsAnnotation` fields + accessor, `texture_displacement_layers`, `texture_displacement_options`, and all the mirrored touch points (see Data model above). **GUI:** -- `src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp/.cpp` - the gizmo. Panel controls: dock/ - undock toggle, brush/face/connected-area selection mode + "select whole model" button, per-layer - texture picker + depth/tiling/rotation/invert/tile-mode/projection-mode/blend-mode controls, - "Adjust placement" toggle (on-canvas gizmo), "Fast preview (normal map)" toggle, "Subdivide model" - button, Add layer/Erase all/Bake. +- `src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp/.cpp` - the gizmo and its whole panel. - `src/slic3r/GUI/TextureLibrary.hpp/.cpp` - scans the shipped + user texture folders, imports an arbitrary image into the user folder (converting it to the 8-bit grayscale PNG libslic3r decodes), and loads a library file's bytes for a layer. The image→grayscale-PNG conversion lives here, on the @@ -534,18 +559,23 @@ of. Toolbar commands the canvas can't service itself (Average scale) are forward - `src/slic3r/GUI/Plater.hpp/.cpp` - `uv_editor_canvas` member, AUI pane registration, `get_uv_editor_canvas()`/`show_uv_editor()`. - `src/slic3r/GUI/GLShadersManager.cpp` - registers `"texture_displacement_bump"`. -- `resources/shaders/{110,140}/texture_displacement_bump.{vs,fs}` - the bump-preview shader. +- `resources/shaders/{110,140}/texture_displacement_bump.{vs,fs}` - the fast-preview shader. - `src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp` - `PainterGizmoType::TEXTURE_DISPLACEMENT`. - `src/slic3r/GUI/Gizmos/GLGizmosManager.hpp/.cpp` - `EType::TextureDisplacement` registration. -- `src/slic3r/GUI/ImGuiWrapper.cpp` - the light-mode checkmark-color fix -**Tests:** `tests/libslic3r/test_texture_displacement.cpp` - **run and passing** (7 cases, 116 -assertions). Covers `decode_height_texture` round-trip, empty-layer no-op, full-cube uniform -displacement, boundary-vertex pinning on a hand-built fan mesh, and - added with the bake rewrite - -a regression test that a **second layer over the same area actually contributes**, -a table-driven check of all four blend modes, and that the lowest layer ignores its -blend mode. `BUILD_TESTS` is `OFF` in the checked-in build cache; flip it on to run them: +## Tests + +`tests/libslic3r/test_texture_displacement.cpp`. Covers `decode_height_texture` round-trip, empty-layer +no-op, full-cube uniform displacement, a second layer over the same area contributing, all four blend +modes (table-driven), the lowest layer ignoring its blend mode, border displace/pin, post-process +smoothing and its mask guarantees, and adaptive subdivision: conformality (`every_edge_used_twice` on a +partially-refined cube - an exact crack detector for a closed mesh), the target edge length actually +being reached, the triangle budget capping the result without opening a crack, curvature-driven +refinement (a Gaussian bump refines at its centre, a linear ramp adds nothing), and the max-edge +baseline. + +`BUILD_TESTS` is `OFF` in the checked-in build cache; flip it on to run them: cmake -S . -B build -DBUILD_TESTS=ON cmake --build build --config Release --target libslic3r_tests -- -m - ./build/tests/libslic3r/Release/libslic3r_tests.exe "[TextureDisplacement]" --order rand \ No newline at end of file + ./build/tests/libslic3r/Release/libslic3r_tests.exe "[TextureDisplacement]" --order rand diff --git a/resources/shaders/110/texture_displacement_bump.fs b/resources/shaders/110/texture_displacement_bump.fs index 75a2baa290..d569b42d0c 100644 --- a/resources/shaders/110/texture_displacement_bump.fs +++ b/resources/shaders/110/texture_displacement_bump.fs @@ -5,6 +5,9 @@ #define INTENSITY_CORRECTION 0.6 +#define PARALLAX_STEPS 24 +#define H_AT(uv) texture2D(height_tex, uv).r + const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929); #define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION) #define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION) @@ -30,6 +33,8 @@ uniform float tiling_scale; uniform float rotation_rad; uniform vec2 uv_offset; uniform bool invert; +uniform float midlevel; // the height that means "don't move"; needed by the parallax step +uniform vec3 eye_model_pos; // camera position in this volume's local space, for the view ray uniform bool use_vertex_uv; // 2x3 affine (lin = (m00, m01, m10, m11), tr = (m02, m12)) applied to the dragged island's uv; see the // 140 variant. Identity when nothing is dragged. @@ -96,10 +101,50 @@ void main() if (abs(det) > 1e-12) triangle_normal = normalize(triangle_normal - (dHdx * R1 + dHdy * R2) / det); } else if (weight > 0.0) { - vec2 uv = project_uv(model_pos.xyz, triangle_normal); vec3 t, b; projection_axes(triangle_normal, t, b); + // Parallax occlusion mapping: march the view ray through the height shell and shade at the + // first point where it drops below the displaced surface (see header). + float amp = (invert ? -1.0 : 1.0) * depth_mm * clamp(weight, 0.0, 1.0); + vec3 view_dir = normalize(eye_model_pos - model_pos.xyz); + float v_dot_n = dot(view_dir, triangle_normal); + vec2 uv = project_uv(model_pos.xyz, triangle_normal); + + // The shell the displaced surface lives inside, as signed heights along the normal. Taken from + // both ends of h in [0, 1] so it stays correct for an inverted layer or a raised midlevel, + // where the surface sits *below* the undisplaced one. + float h_end_a = amp * (0.0 - midlevel); + float h_end_b = amp * (1.0 - midlevel); + float h_hi = max(h_end_a, h_end_b); + float h_lo = min(h_end_a, h_end_b); + // How far, in mm, sweeping the ray across the shell slides the sample point sideways. Below half + // a texel there is no parallax to find and the march would be pure cost - which is the common + // case of looking straight down at a surface. + float sweep = length(view_dir - triangle_normal * v_dot_n) * (h_hi - h_lo) / max(v_dot_n, 1e-4); + if (v_dot_n > 0.05 && sweep > 0.5 * tiling_scale * height_tex_texel.x) { + // A point at ray parameter s (model_pos + view_dir * s) sits at height s * v_dot_n above the + // undisplaced surface. Start at the top of the shell, where the ray is outside the surface + // by construction, and step inward; the crossing is what this pixel actually sees. + float s = h_hi / v_dot_n; + float ds = (h_hi - h_lo) / (v_dot_n * float(PARALLAX_STEPS)); + vec2 prev_uv = project_uv(model_pos.xyz + view_dir * s, triangle_normal); + float prev_gap = h_hi - amp * (H_AT(prev_uv) - midlevel); // >= 0 by construction + for (int i = 0; i < PARALLAX_STEPS; ++i) { + s -= ds; + vec2 cur_uv = project_uv(model_pos.xyz + view_dir * s, triangle_normal); + float gap = s * v_dot_n - amp * (H_AT(cur_uv) - midlevel); + if (gap <= 0.0) { + // Crossed between the last two samples - interpolating the hit is what stops it + // quantising to the step size, and so what keeps the step count affordable. + uv = mix(prev_uv, cur_uv, clamp(prev_gap / max(prev_gap - gap, 1e-6), 0.0, 1.0)); + break; + } + prev_uv = cur_uv; + prev_gap = gap; + } + } + float hL = texture2D(height_tex, uv - vec2(height_tex_texel.x, 0.0)).r; float hR = texture2D(height_tex, uv + vec2(height_tex_texel.x, 0.0)).r; float hD = texture2D(height_tex, uv - vec2(0.0, height_tex_texel.y)).r; diff --git a/resources/shaders/140/texture_displacement_bump.fs b/resources/shaders/140/texture_displacement_bump.fs index 58f79722aa..17b550d5e6 100644 --- a/resources/shaders/140/texture_displacement_bump.fs +++ b/resources/shaders/140/texture_displacement_bump.fs @@ -19,7 +19,36 @@ // Two projection paths: // * Triplanar (use_vertex_uv = 0): uv and the tangent axes are derived in-shader from the dominant // normal axis, mirroring libslic3r's project_planar()/apply_uv_transform(), and the slope is -// formed analytically (there is a closed-form uv, so 1 uv unit is exactly tiling_scale mm). +// formed analytically (there is a closed-form uv, so 1 uv unit is exactly tiling_scale mm). This +// path also runs a parallax step before shading, see below. +// +// Parallax. A pure bump map perturbs shading only, so the pattern is welded to the base surface: it +// does not shift as the camera orbits and it does not get any deeper as depth_mm grows, which is +// exactly when the preview stops reading as real geometry. The triplanar path therefore shades at the +// point the *displaced* surface would show at this pixel rather than at the pixel's own base position. +// +// Two cheaper formulations were tried first and both are wrong here, which is worth recording: +// * Solving Q = P + V * (H(Q) / dot(V, n)) by fixed-point iteration. Geometrically exact, but the +// divisor goes to zero edge-on, and an unbounded step is not a small error - the sample lands a +// large fraction of a tile away and the iteration oscillates instead of converging. It reads as a +// *second, flat copy* of the pattern ghosted over the real one. Clamping the step to one tile does +// not help either: a tile-sized shift lands on the neighbouring tile, which is the same pattern. +// * Offset limiting (Welsh): step along the tangential part of V, whose length caps the shift at one +// depth. Stable and cheap, but it understates parallax by exactly the factor that matters - the +// relief still flattens as soon as the camera tilts, which is the complaint it was meant to fix. +// +// So this ray-marches instead (parallax occlusion mapping). A point at ray parameter s, i.e. P + V * s, +// sits at height s * dot(V, n) above the undisplaced surface. The displaced surface lives in a shell +// between the extreme values of amp * (h - midlevel); the march starts at the top of that shell, where +// the ray is outside the surface by construction, and steps inward until the ray height falls below the +// sampled height. That crossing *is* the visible point - no divergence, no ghosting, and parallax stays +// correct at any angle. The hit is interpolated between the last two samples, which is what keeps +// PARALLAX_STEPS low enough to afford. The march is skipped when sweeping the shell would move the +// sample point less than half a texel (the head-on case), so the common view pays almost nothing. +// +// The gradient/shading below is evaluated at the resulting uv, so the relief both slides correctly +// under camera motion and visibly deepens with depth_mm. What it still cannot do is change the +// model's silhouette or cast shadows; for that, switch the View row to Normal. // * Precomputed uv (use_vertex_uv = 1, used for LSCM): uv comes per-vertex from the CPU (the LSCM // unwrap with island placement + tiling/rotation/offset already folded in), and the perturbed // normal is built with Mikkelsen's method -- the surface gradient taken straight from the @@ -31,6 +60,11 @@ #define INTENSITY_CORRECTION 0.6 +#define PARALLAX_STEPS 24 +// Explicit LOD: the march samples inside non-uniform control flow, where implicit +// derivatives are undefined. +#define H_AT(uv) textureLod(height_tex, uv, 0.0).r + // normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31) const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929); #define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION) @@ -58,6 +92,8 @@ uniform float tiling_scale; uniform float rotation_rad; uniform vec2 uv_offset; uniform bool invert; +uniform float midlevel; // the height that means "don't move"; needed by the parallax step +uniform vec3 eye_model_pos; // camera position in this volume's local space, for the view ray uniform bool use_vertex_uv; // true: sample at vertex_uv with a derived tangent frame (LSCM) // A 2x3 affine (columns packed as lin = (m00, m01, m10, m11), tr = (m02, m12)) applied to the uv of // the island currently being dragged in the UV editor (island_active > 0.5). Identity when nothing is @@ -144,10 +180,50 @@ void main() // Triplanar path: uv and the tangent axes are reconstructed in-shader from the dominant // normal component (see header). The gradient is expressed analytically because there is a // closed-form uv here, unlike the LSCM case. - vec2 uv = project_uv(model_pos.xyz, triangle_normal); vec3 t, b; projection_axes(triangle_normal, t, b); + // Parallax occlusion mapping: march the view ray through the height shell and shade at the + // first point where it drops below the displaced surface (see header). + float amp = (invert ? -1.0 : 1.0) * depth_mm * clamp(weight, 0.0, 1.0); + vec3 view_dir = normalize(eye_model_pos - model_pos.xyz); + float v_dot_n = dot(view_dir, triangle_normal); + vec2 uv = project_uv(model_pos.xyz, triangle_normal); + + // The shell the displaced surface lives inside, as signed heights along the normal. Taken from + // both ends of h in [0, 1] so it stays correct for an inverted layer or a raised midlevel, + // where the surface sits *below* the undisplaced one. + float h_end_a = amp * (0.0 - midlevel); + float h_end_b = amp * (1.0 - midlevel); + float h_hi = max(h_end_a, h_end_b); + float h_lo = min(h_end_a, h_end_b); + // How far, in mm, sweeping the ray across the shell slides the sample point sideways. Below half + // a texel there is no parallax to find and the march would be pure cost - which is the common + // case of looking straight down at a surface. + float sweep = length(view_dir - triangle_normal * v_dot_n) * (h_hi - h_lo) / max(v_dot_n, 1e-4); + if (v_dot_n > 0.05 && sweep > 0.5 * tiling_scale * height_tex_texel.x) { + // A point at ray parameter s (model_pos + view_dir * s) sits at height s * v_dot_n above the + // undisplaced surface. Start at the top of the shell, where the ray is outside the surface + // by construction, and step inward; the crossing is what this pixel actually sees. + float s = h_hi / v_dot_n; + float ds = (h_hi - h_lo) / (v_dot_n * float(PARALLAX_STEPS)); + vec2 prev_uv = project_uv(model_pos.xyz + view_dir * s, triangle_normal); + float prev_gap = h_hi - amp * (H_AT(prev_uv) - midlevel); // >= 0 by construction + for (int i = 0; i < PARALLAX_STEPS; ++i) { + s -= ds; + vec2 cur_uv = project_uv(model_pos.xyz + view_dir * s, triangle_normal); + float gap = s * v_dot_n - amp * (H_AT(cur_uv) - midlevel); + if (gap <= 0.0) { + // Crossed between the last two samples - interpolating the hit is what stops it + // quantising to the step size, and so what keeps the step count affordable. + uv = mix(prev_uv, cur_uv, clamp(prev_gap / max(prev_gap - gap, 1e-6), 0.0, 1.0)); + break; + } + prev_uv = cur_uv; + prev_gap = gap; + } + } + float hL = texture(height_tex, uv - vec2(height_tex_texel.x, 0.0)).r; float hR = texture(height_tex, uv + vec2(height_tex_texel.x, 0.0)).r; float hD = texture(height_tex, uv - vec2(0.0, height_tex_texel.y)).r; diff --git a/src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.cpp b/src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.cpp index 78886f6be8..579d9a5792 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.cpp @@ -747,9 +747,13 @@ void GLGizmoTextureDisplacement::rebuild_bump_preview_mesh() if (patch.indices.empty()) return; - const indexed_triangle_set &base = mv->mesh().its; - if (base.vertices.size() != patch.vertices.size()) - return; // shouldn't happen: get_facets_strict() always returns the full vertex array + // No "patch.vertices.size() == mesh vertex count" check here, and that is the point: a *brush* + // stroke splits triangles, so the selector appends split vertices and the patch array is longer + // than the mesh's. An earlier version bailed out on that as "shouldn't happen", which meant the + // bump model was never built while brushing and render_painter_gizmo() silently fell back to the + // Normal (true-displacement) preview - Fast looked broken for brush and fine for Face/Connected + // area, because only the brush splits. Everything below indexes the patch's own vertex array, so + // the extra vertices are simply carried through. // Unpainted triangles, so the surrounding surface still renders (the render path hides the real // model in bump mode). get_facets_strict() returns the same vertex array whatever state is asked. @@ -762,7 +766,7 @@ void GLGizmoTextureDisplacement::rebuild_bump_preview_mesh() // mesh rebuilds (on drag end) with them. The other projections keep projecting in-shader. const TextureDisplacementLayer *active = active_layer(); std::vector vertex_uv = active != nullptr ? compute_layer_vertex_uvs(patch, *active) : std::vector{}; - m_bump_preview_uses_vertex_uv = vertex_uv.size() == base.vertices.size(); + m_bump_preview_uses_vertex_uv = vertex_uv.size() == patch.vertices.size(); if (!m_bump_preview_uses_vertex_uv) vertex_uv.clear(); @@ -945,6 +949,13 @@ void GLGizmoTextureDisplacement::render_bump_preview_mesh() shader->set_uniform("rotation_rad", layer->rotation_deg * float(M_PI) / 180.f); shader->set_uniform("uv_offset", layer->offset); shader->set_uniform("invert", layer->invert); + // The parallax step in the triplanar path needs the real height, not just its gradient, so it + // needs the midlevel the bake subtracts - and the camera position in the volume's own local space, + // to build the view ray it walks along. Without the parallax the pattern is welded to the base + // surface: it does not slide as the camera orbits and does not deepen with depth_mm, which is + // exactly when the fast preview stops looking like geometry. + shader->set_uniform("midlevel", layer->midlevel); + shader->set_uniform("eye_model_pos", Vec3f((trafo_matrix.inverse() * camera.get_position()).cast())); // When set, the shader samples at the per-vertex uv baked into the mesh (LSCM) rather than // projecting; see rebuild_bump_preview_mesh(). shader->set_uniform("use_vertex_uv", m_bump_preview_uses_vertex_uv); @@ -970,9 +981,11 @@ void GLGizmoTextureDisplacement::rebuild_uvcheck_mesh() const indexed_triangle_set patch = m_triangle_selectors[0]->get_facets_strict(EnforcerBlockerType::ENFORCER); if (patch.indices.empty()) return; - const indexed_triangle_set &base = mv->mesh().its; - if (base.vertices.size() != patch.vertices.size()) - return; + // Everything below works in the *patch's* vertex space, not the mesh's. Those agree only until a + // brush stroke splits a triangle, after which the patch array is longer - and since patch triangle + // indices are used to index it, reading the mesh's array instead would run off the end. An earlier + // version guarded that by bailing out, which quietly disabled the Checker and Distortion overlays + // for anything painted with the brush. const TextureDisplacementLayer *layer = active_layer(); if (layer == nullptr) return; @@ -980,16 +993,16 @@ void GLGizmoTextureDisplacement::rebuild_uvcheck_mesh() // The checker samples wherever the projection puts it; the projections the shader can't // reconstruct (LSCM, ViewProjected) get a precomputed per-vertex uv, the rest project in-shader. std::vector uv = compute_layer_vertex_uvs(patch, *layer); - const bool have_uvs = uv.size() == base.vertices.size(); + const bool have_uvs = uv.size() == patch.vertices.size(); m_uvcheck_uses_vertex_uv = have_uvs; // Per-vertex area distortion in [0,1] (0.5 == ideal), only when both requested and possible. - std::vector distortion(base.vertices.size(), 0.5f); + std::vector distortion(patch.vertices.size(), 0.5f); if (m_uv_check_mode == UVCheckMode::Distortion && have_uvs) { std::vector tri_log(patch.indices.size(), 0.f); for (size_t f = 0; f < patch.indices.size(); ++f) { const stl_triangle_vertex_indices &t = patch.indices[f]; - const float a3 = 0.5f * (base.vertices[t[1]] - base.vertices[t[0]]).cross(base.vertices[t[2]] - base.vertices[t[0]]).norm(); + const float a3 = 0.5f * (patch.vertices[t[1]] - patch.vertices[t[0]]).cross(patch.vertices[t[2]] - patch.vertices[t[0]]).norm(); const Vec2f e0 = uv[t[1]] - uv[t[0]]; const Vec2f e1 = uv[t[2]] - uv[t[0]]; const float a2 = 0.5f * std::abs(e0.x() * e1.y() - e0.y() * e1.x()); @@ -1003,8 +1016,8 @@ void GLGizmoTextureDisplacement::rebuild_uvcheck_mesh() std::nth_element(sorted.begin(), sorted.begin() + sorted.size() / 2, sorted.end()); median = sorted[sorted.size() / 2]; } - std::vector sum(base.vertices.size(), 0.f); - std::vector cnt(base.vertices.size(), 0); + std::vector sum(patch.vertices.size(), 0.f); + std::vector cnt(patch.vertices.size(), 0); for (size_t f = 0; f < patch.indices.size(); ++f) { // +/- 2 stops (4x stretch either way) spans the full blue->red range. const float d = std::clamp(0.5f + (tri_log[f] - median) / 4.f, 0.f, 1.f); @@ -1020,10 +1033,10 @@ void GLGizmoTextureDisplacement::rebuild_uvcheck_mesh() GLModel::Geometry init_data; init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3T2 }; - init_data.reserve_vertices(base.vertices.size()); + init_data.reserve_vertices(patch.vertices.size()); init_data.reserve_indices(patch.indices.size() * 3); - for (size_t vi = 0; vi < base.vertices.size(); ++vi) - init_data.add_vertex(base.vertices[vi], Vec3f(distortion[vi], 0.f, 0.f), + for (size_t vi = 0; vi < patch.vertices.size(); ++vi) + init_data.add_vertex(patch.vertices[vi], Vec3f(distortion[vi], 0.f, 0.f), have_uvs ? uv[vi] : Vec2f::Zero()); for (const stl_triangle_vertex_indices &tri : patch.indices) init_data.add_triangle(unsigned(tri[0]), unsigned(tri[1]), unsigned(tri[2])); @@ -2753,51 +2766,82 @@ bool GLGizmoTextureDisplacement::collect_paint_region( return any_paint; } -void GLGizmoTextureDisplacement::subdivide_model_adaptive() +bool GLGizmoTextureDisplacement::plan_adaptive_subdivision(const ModelVolume &mv, SubdivisionPlan &out) const { - ModelVolume *mv = texture_volume(); - ModelObject *mo = m_c->selection_info()->model_object(); - if (mv == nullptr || mo == nullptr || m_subdivide_target_mm <= 0.f) - return; + if (m_subdivide_target_mm <= 0.f) + return false; - update_model_object(); // flush any in-progress stroke into the committed masks first - - std::vector region; - std::array, TEXTURE_DISPLACEMENT_MAX_LAYERS> painted_tri; - if (!collect_paint_region(region, &painted_tri)) { - show_error(nullptr, _u8L("Paint the area you want to subdivide first - adaptive subdivision only " - "refines where you have painted.")); - return; - } + std::vector region; + if (!collect_paint_region(region, &out.painted_tri)) + return false; // Feature-adaptive: sample the combined displacement so refinement follows texture curvature. A - // null sampler (only LSCM layers, or nothing decodable) falls back to the uniform target below. + // null sampler (only LSCM layers, or nothing decodable) falls back to the length baseline alone. HeightFieldSampler sampler; if (m_subdivide_feature) { TextureDisplacementFacetsData facets{}; for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i) - facets[size_t(i)] = mv->texture_displacement_facet(i).get_data(); - sampler = make_combined_displacement_sampler(mv->mesh().its, mv->texture_displacement_layers, facets); + facets[size_t(i)] = mv.texture_displacement_facet(i).get_data(); + sampler = make_combined_displacement_sampler(mv.mesh().its, mv.texture_displacement_layers, facets); } - // Do the (potentially slow) refinement before taking the snapshot, so a no-op leaves no empty - // undo step - mirrors remesh_model(). // "Min edge" is a feature-mode control (it is the floor the curvature test refines down to); in // plain adaptive mode the target edge length is the only criterion, so the floor must not be // allowed to silently override a target the user set below it. const float tol = m_subdivide_feature ? m_subdivide_detail_mm : 0.f; const float floor = m_subdivide_feature ? m_subdivide_min_edge_mm : 0.f; - std::vector source; - indexed_triangle_set refined; { wxBusyCursor wait; // The budget slider is "triangles the refinement may *add*", so the model's own count is the // baseline - otherwise the control would be meaningless (or a dead end) on a dense model. - refined = subdivide_mesh_adaptive(mv->mesh().its, region, m_subdivide_target_mm, - int(mv->mesh().its.indices.size()) + m_subdivide_budget_k * 1000, - &source, sampler, tol, floor); + out.refined = subdivide_mesh_adaptive(mv.mesh().its, region, m_subdivide_target_mm, + int(mv.mesh().its.indices.size()) + m_subdivide_budget_k * 1000, + &out.source, sampler, tol, floor); } - if (refined.indices.size() == mv->mesh().its.indices.size()) { + return out.refined.indices.size() != mv.mesh().its.indices.size(); +} + +void GLGizmoTextureDisplacement::apply_adaptive_subdivision(ModelVolume &mv, SubdivisionPlan &&plan) +{ + // Other paint channels ride across via the standard remap; texture-displacement paint is rebuilt + // below from the plan's source map, which is the whole point of driving this by the paint. + std::optional saved_painting = mv.save_painting(); + mv.set_mesh(TriangleMesh(std::move(plan.refined))); + mv.set_new_unique_id(); + mv.calculate_convex_hull(); + mv.restore_painting(saved_painting); // resets extra facets (incl. texture-displacement) + remaps the rest + + // Carry each layer's paint onto the new mesh: a new triangle is painted iff its source triangle + // was fully painted in that layer. Children inherit their parent's source, so this is exact. + for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) { + if (plan.painted_tri[size_t(slot)].empty()) + continue; + TriangleSelector sel(mv.mesh()); + for (size_t i = 0; i < plan.source.size(); ++i) + if (plan.painted_tri[size_t(slot)][size_t(plan.source[i])]) + sel.set_facet(int(i), EnforcerBlockerType::ENFORCER); + mv.texture_displacement_facet(slot).set(sel); + } +} + +void GLGizmoTextureDisplacement::subdivide_model_adaptive() +{ + ModelVolume *mv = texture_volume(); + ModelObject *mo = m_c->selection_info()->model_object(); + if (mv == nullptr || mo == nullptr) + return; + + update_model_object(); // flush any in-progress stroke into the committed masks first + + if (!mv->is_texture_displacement_painted()) { + show_error(nullptr, _u8L("Paint the area you want to subdivide first - adaptive subdivision only " + "refines where you have painted.")); + return; + } + + // Plan before the snapshot, so a no-op leaves no empty undo step - mirrors remesh_model(). + SubdivisionPlan plan; + if (!plan_adaptive_subdivision(*mv, plan)) { show_error(nullptr, _u8L("Nothing to subdivide - the painted area already meets the target edge " "length and detail tolerance, or the triangle budget is already used up.")); return; @@ -2805,26 +2849,7 @@ void GLGizmoTextureDisplacement::subdivide_model_adaptive() Plater *plater = wxGetApp().plater(); Plater::TakeSnapshot snapshot(plater, _u8L("Adaptive subdivide for texture displacement"), UndoRedo::SnapshotType::GizmoAction); - - // Other paint channels ride across via the standard remap; texture-displacement paint is rebuilt - // by hand below from the source map, which is the whole point of driving this by the paint. - std::optional saved_painting = mv->save_painting(); - mv->set_mesh(TriangleMesh(std::move(refined))); // refined is not needed past here; source carries the paint map - mv->set_new_unique_id(); - mv->calculate_convex_hull(); - mv->restore_painting(saved_painting); // resets extra facets (incl. texture-displacement) + remaps the rest - - // Carry each layer's paint onto the new mesh: a new triangle is painted iff its source triangle - // was fully painted in that layer. Children inherit their parent's source, so this is exact. - for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) { - if (painted_tri[slot].empty()) - continue; - TriangleSelector sel(mv->mesh()); - for (size_t i = 0; i < source.size(); ++i) - if (painted_tri[slot][source[i]]) - sel.set_facet(int(i), EnforcerBlockerType::ENFORCER); - mv->texture_displacement_facet(slot).set(sel); - } + apply_adaptive_subdivision(*mv, std::move(plan)); if (ObjectList *obj_list = wxGetApp().obj_list()) { const ModelObjectPtrs &objs = plater->model().objects; @@ -2921,6 +2946,62 @@ void GLGizmoTextureDisplacement::smooth_model() m_parent.set_as_dirty(); } +void GLGizmoTextureDisplacement::replace_mesh_keep_all_paint(ModelVolume &mv, TriangleMesh &&new_mesh) +{ + const indexed_triangle_set old_its = mv.mesh().its; + std::array saved_texture; + for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i) + saved_texture[size_t(i)] = mv.texture_displacement_facet(i).get_data(); + std::optional saved_painting = mv.save_painting(); + + mv.set_mesh(std::move(new_mesh)); + mv.set_new_unique_id(); + mv.calculate_convex_hull(); + mv.restore_painting(saved_painting); // clears the extra facets, then remaps the four standard channels + + // ... and the same spatial remap for the texture-displacement masks, which restore_painting() knows + // nothing about. Without this a remesh would wipe the texture paint, which is fine for a standalone + // "Remesh" click but fatal for Standard mode's pipeline: it remeshes *after* the user has painted, + // and the subdivision and displacement that follow are both driven by that paint. + const Transform3d to_source = Slic3r::Geometry::translation_transform(mv.mesh().get_init_shift()); + for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i) { + if (saved_texture[size_t(i)].bitstream.empty()) + continue; + TriangleSelector::TriangleSplittingData remapped = + TriangleSelector::remap_painting(old_its, saved_texture[size_t(i)], mv.mesh().its, to_source, + {}); // no existing paint to merge with: set_mesh() just cleared it + if (!remapped.bitstream.empty()) + mv.texture_displacement_facet(i).set_data(std::move(remapped)); + } +} + +bool GLGizmoTextureDisplacement::plan_remesh(const ModelVolume &mv, float target_edge_mm, float sharp_angle_deg, + TriangleMesh &out) +{ + if (target_edge_mm <= 0.f) + return false; + + // CGAL isotropic remeshing can be slow on a big mesh, which is why this is separated from applying + // it: the caller runs it before taking the snapshot so a failure leaves no empty undo step. + const indexed_triangle_set &src = mv.mesh().its; + indexed_triangle_set remeshed; + { + wxBusyCursor wait; + remeshed = MeshBoolean::cgal::remesh_isotropic(src, double(target_edge_mm), 3, double(sharp_angle_deg)); + } + // remesh_isotropic() signals failure by handing the input straight back, so compare against it + // structurally. Vertex count alone is not enough: a remesh that only redistributes triangles at + // roughly the current density legitimately lands on the same count, and treating that as failure + // meant a perfectly good result got thrown away with an error message. + if (remeshed.indices.empty() || + (remeshed.vertices.size() == src.vertices.size() && remeshed.indices.size() == src.indices.size() && + remeshed.indices == src.indices)) + return false; + + out = TriangleMesh(std::move(remeshed)); + return true; +} + void GLGizmoTextureDisplacement::remesh_model() { ModelVolume *mv = texture_volume(); @@ -2928,39 +3009,18 @@ void GLGizmoTextureDisplacement::remesh_model() if (mv == nullptr || mo == nullptr || m_remesh_target_edge_mm <= 0.f) return; - Plater *plater = wxGetApp().plater(); - - // CGAL isotropic remeshing can be slow on a big mesh; do it before taking the snapshot so a failure - // (it returns the input unchanged) doesn't leave an empty undo step. - const indexed_triangle_set &src = mv->mesh().its; - indexed_triangle_set remeshed; - { - wxBusyCursor wait; - remeshed = MeshBoolean::cgal::remesh_isotropic(mv->mesh().its, double(m_remesh_target_edge_mm), 3, - m_remesh_keep_sharp_edges ? double(m_remesh_sharp_angle_deg) : 0.0); - } - // remesh_isotropic() signals failure by handing the input straight back, so compare against it - // structurally. Vertex count alone is not enough: a remesh that only redistributes triangles at - // roughly the current density legitimately lands on the same count, and treating that as failure - // meant a perfectly good result got thrown away with an error message. - const bool unchanged = remeshed.indices.empty() || - (remeshed.vertices.size() == src.vertices.size() && remeshed.indices.size() == src.indices.size() && - remeshed.indices == src.indices); - if (unchanged) { + TriangleMesh remeshed; + if (!plan_remesh(*mv, m_remesh_target_edge_mm, m_remesh_keep_sharp_edges ? m_remesh_sharp_angle_deg : 0.f, + remeshed)) { show_error(nullptr, _u8L("Remeshing did not change the model. It may be non-manifold (open edges or " "edges shared by more than two triangles), or the target edge length may " "already be met.")); return; } + Plater *plater = wxGetApp().plater(); Plater::TakeSnapshot snapshot(plater, _u8L("Remesh model for texture displacement"), UndoRedo::SnapshotType::GizmoAction); - // Same save/replace/restore-painting dance as subdivide: texture-displacement paint has no remap - // across a topology change, so it is dropped rather than left pointing at triangles that moved. - std::optional saved_painting = mv->save_painting(); - mv->set_mesh(TriangleMesh(std::move(remeshed))); - mv->set_new_unique_id(); - mv->calculate_convex_hull(); - mv->restore_painting(saved_painting); + replace_mesh_keep_all_paint(*mv, std::move(remeshed)); if (ObjectList *obj_list = wxGetApp().obj_list()) { const ModelObjectPtrs &objs = plater->model().objects; @@ -3075,7 +3135,7 @@ GLTexture *GLGizmoTextureDisplacement::get_layer_thumbnail(const TextureDisplace return m_thumbnails[slot].get(); } -void GLGizmoTextureDisplacement::bake() +void GLGizmoTextureDisplacement::bake(bool own_snapshot) { ModelVolume *mv = texture_volume(); if (!mv || m_bake_in_progress) @@ -3101,7 +3161,112 @@ void GLGizmoTextureDisplacement::bake() if (m_state == On && m_c->selection_info() && m_c->selection_info()->model_object()) update_from_model_object(false); m_parent.set_as_dirty(); - }); + }, own_snapshot); +} + +// Standard mode's fixed recipe. These are both the values the hidden controls are pinned to and what +// bake_standard() drives its remesh and subdivision with - one set of numbers, so the preview cannot +// disagree with the bake. Chosen to be safe on an arbitrary imported part rather than optimal on any +// particular one: a 1 mm isotropic remesh gives the subdivider an even starting density whatever the +// input looked like, and the subdivision then spends up to 1.5 M triangles chasing texture curvature +// down to a 0.02 mm floor, which is finer than any FDM nozzle will resolve. The triangle budget is not +// here: it is the one control Standard mode still shows, so it belongs to the user (its default is +// m_subdivide_budget_k's initialiser). +static constexpr float STD_REMESH_EDGE_MM = 1.0f; +static constexpr float STD_REMESH_SHARP_DEG = 40.f; +static constexpr float STD_SUBDIV_MAX_EDGE_MM = 20.f; +static constexpr float STD_SUBDIV_DETAIL_MM = 0.02f; +static constexpr float STD_SUBDIV_MIN_EDGE_MM = 0.02f; + +bool GLGizmoTextureDisplacement::apply_standard_mode_presets(ModelVolume *mv) +{ + bool changed = false; + const auto pin = [&changed](auto &field, auto value) { + if (field != value) { + field = value; + changed = true; + } + }; + + if (mv != nullptr) { + pin(mv->texture_displacement_options.displace_border, true); + pin(mv->texture_displacement_options.smooth_enabled, false); + } + pin(m_subdivide_adaptive, true); + pin(m_subdivide_feature, true); + pin(m_subdivide_target_mm, STD_SUBDIV_MAX_EDGE_MM); + pin(m_subdivide_detail_mm, STD_SUBDIV_DETAIL_MM); + pin(m_subdivide_min_edge_mm, STD_SUBDIV_MIN_EDGE_MM); + // Deliberately *not* pinned: the triangle budget stays visible and editable in Standard mode, so + // pinning it would fight the user's own slider every frame. + pin(m_remesh_target_edge_mm, STD_REMESH_EDGE_MM); + pin(m_remesh_keep_sharp_edges, true); + pin(m_remesh_sharp_angle_deg, STD_REMESH_SHARP_DEG); + return changed; +} + +void GLGizmoTextureDisplacement::bake_standard() +{ + ModelVolume *mv = texture_volume(); + ModelObject *mo = m_c->selection_info()->model_object(); + if (mv == nullptr || mo == nullptr || m_bake_in_progress) + return; + + update_model_object(); // flush the active layer's in-progress strokes before anything reads them + if (!mv->is_texture_displacement_painted()) { + show_error(nullptr, _u8L("Nothing is painted, there is nothing to bake.")); + return; + } + apply_standard_mode_presets(mv); // belt and braces: never bake with values the panel is not showing + + // Both stages are planned before the snapshot so a stage that has nothing to do is simply skipped. + // Skipping is normal, not a failure: a mesh that is already even needs no remesh, and one that is + // already fine enough for the texture needs no subdivision. + TriangleMesh remeshed; + const bool do_remesh = plan_remesh(*mv, STD_REMESH_EDGE_MM, STD_REMESH_SHARP_DEG, remeshed); + + Plater *plater = wxGetApp().plater(); + { + // ONE undo step for the whole pipeline. take_snapshot() records the state *before* the change, + // so a single Undo goes all the way back to the untouched mesh - which is the only thing "undo + // the bake" can sensibly mean when the bake is also what prepared the geometry. The background + // displacement job is told not to add its own (see queue_texture_displacement_bake's + // take_snapshot), because an undo step landing between the subdivision and the displacement + // leaves a mesh with 1.5 M extra triangles and no relief on it - and baking again from there + // subdivides that mesh a second time. + Plater::TakeSnapshot snapshot(plater, _u8L("Bake texture displacement"), + UndoRedo::SnapshotType::GizmoAction); + if (do_remesh) + replace_mesh_keep_all_paint(*mv, std::move(remeshed)); + + // The remesh carries the paint across spatially, but if that remap came back empty the rest of + // the pipeline has nothing to work from - stop here rather than silently baking a flat mesh. + if (!mv->is_texture_displacement_painted()) { + show_error(nullptr, _u8L("The painted area could not be transferred onto the remeshed model. Undo, " + "then switch to Pro mode to prepare the mesh before painting.")); + return; + } + + // Planning the subdivision has to happen inside the snapshot because it reads the mesh the + // remesh just produced. It is the expensive step, but by here we are committed anyway. + SubdivisionPlan plan; + if (plan_adaptive_subdivision(*mv, plan)) + apply_adaptive_subdivision(*mv, std::move(plan)); + } + + if (ObjectList *obj_list = wxGetApp().obj_list()) { + const ModelObjectPtrs &objs = plater->model().objects; + auto it = std::find(objs.begin(), objs.end(), mo); + if (it != objs.end()) + obj_list->update_info_items(size_t(it - objs.begin())); + } + plater->changed_object(*mo); + update_from_model_object(false); // reload selectors against the prepared mesh + carried paint + m_parent.set_as_dirty(); + + // ... and finally the displacement itself, in the background exactly as the Pro-mode button does - + // except that it commits into the snapshot taken above instead of pushing another one. + bake(/* own_snapshot */ false); } void GLGizmoTextureDisplacement::render_paint_cursor_hint() @@ -3237,6 +3402,42 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float m_imgui->tooltip(_u8L("Detach this panel so it can be dragged anywhere over the 3D view, or dock it " "back beside the toolbar."), m_imgui->scaled(20.f)); + + // Standard / Pro, right-aligned on the header row. A two-position slider rather than a checkbox + // because it is a mode, not an option: Standard hides every mesh-preparation control and folds the + // whole recipe into Bake, Pro shows all of it and hands the ordering to the user. + { + const float mode_w = m_imgui->scaled(6.2f); + ImGui::SameLine(std::max(ImGui::GetCursorPosX(), ImGui::GetWindowContentRegionMax().x - mode_w)); + ImGui::PushItemWidth(mode_w); + // The format string carries no conversion, so ImGui prints it verbatim as the slider's label - + // which is how a two-position slider gets word labels instead of "0" and "1". + const std::string mode_label = pro_mode() ? _u8L("Pro") : _u8L("Standard"); + if (ImGui::SliderInt("##panel_mode", &m_panel_mode, 0, 1, mode_label.c_str())) { + m_panel_mode = std::clamp(m_panel_mode, 0, 1); + if (!pro_mode()) { + // Leaving the subdivision preview open would strand a wireframe whose controls just + // disappeared, so close it as part of the switch. + m_subdivide_editing = false; + m_subdivide_preview_tris = -1; + m_subdivide_preview_glmodel.reset(); + if (apply_standard_mode_presets(mv)) + m_preview_params_dirty = true; + } + m_parent.set_as_dirty(); + } + ImGui::PopItemWidth(); + if (ImGui::IsItemHovered()) + m_imgui->tooltip(_u8L("Standard - paint, then press Bake: the mesh is remeshed, refined where the " + "texture bends, and displaced in one step.\n\nPro - every mesh-preparation " + "control is shown and you run Remesh, Subdivide and Bake yourself, in the " + "order you want."), + m_imgui->scaled(20.f)); + } + // Pinned every frame while Standard is active, so what Preview shows is always what Bake will do. + if (!pro_mode() && apply_standard_mode_presets(mv)) + m_preview_params_dirty = true; + ImGui::Separator(); // Selection mode: which of TriangleSelector's existing click/brush mechanisms drives painting. @@ -3854,8 +4055,9 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float } // (The "Add layer" button now lives next to the "Texture layers" heading, as an icon.) - // Settings for the whole stack rather than one layer, so they sit outside the layer list. - if (mv != nullptr) { + // Settings for the whole stack rather than one layer, so they sit outside the layer list. Standard + // mode pins them (see apply_standard_mode_presets()) instead of showing them. + if (pro_mode() && mv != nullptr) { TextureDisplacementOptions &opts = mv->texture_displacement_options; ImGui::Separator(); @@ -3912,7 +4114,34 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float } ImGui::Separator(); - m_imgui->text(_u8L("Not enough vertices for fine detail?")); + m_imgui->text(_u8L("Subdivision")); + + // The triangle budget is the one subdivision control Standard mode keeps: its right value depends + // on the part rather than on the recipe (a big model, or a fine texture, simply needs more of them), + // and raising or lowering it is safe without understanding anything else in this section. Shared + // with the Pro layout below so there is one definition of the widget. + const auto budget_slider = [this]() { + ImGui::PushItemWidth(m_imgui->scaled(8.4f)); + if (ImGui::SliderInt((_u8L("Added triangles (k)") + "##subdivbudget").c_str(), &m_subdivide_budget_k, 10, 2000)) { + m_subdivide_budget_k = std::clamp(m_subdivide_budget_k, 10, 2000); + if (m_subdivide_editing) + rebuild_subdivide_preview(); + m_parent.set_as_dirty(); + } + ImGui::PopItemWidth(); + if (ImGui::IsItemHovered()) + m_imgui->tooltip(_u8L("How many thousand triangles the refinement may add. It always splits the " + "worst-fitting triangle first, so a run that uses the whole budget has still spent " + "it where it shows most - raise this if the result still looks too coarse."), + m_imgui->scaled(20.f)); + }; + + // Everything else from here to the Bake row is mesh preparation, which is exactly what Standard + // mode takes over: it pins those to one recipe and runs them from the Bake button (see + // bake_standard()), so showing them would only invite changing numbers that get overwritten. + if (!pro_mode()) + budget_slider(); + if (pro_mode()) { if (ImGui::Checkbox(_u8L("Only painted area (adaptive)").c_str(), &m_subdivide_adaptive)) { if (m_subdivide_editing) @@ -3996,18 +4225,8 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float m_imgui->scaled(20.f)); } - // The budget. Refinement is worst-error-first, so a run that hits it has still spent its - // triangles on the biggest deviations - raising it buys detail, it does not redistribute it. - if (ImGui::SliderInt((_u8L("Added triangles (k)") + "##subdivbudget").c_str(), &m_subdivide_budget_k, 10, 2000)) { - m_subdivide_budget_k = std::clamp(m_subdivide_budget_k, 10, 2000); - preview_live(); - } - if (ImGui::IsItemHovered()) - m_imgui->tooltip(_u8L("How many thousand triangles the refinement may add. It always splits the " - "worst-fitting triangle first, so a run that uses the whole budget has still spent " - "it where it shows most - raise this if the preview still looks too coarse."), - m_imgui->scaled(20.f)); ImGui::PopItemWidth(); + budget_slider(); if (m_subdivide_editing && m_subdivide_preview_tris > 0) m_imgui->text(Slic3r::format(_u8L("Preview: %1% triangles"), m_subdivide_preview_tris)); @@ -4074,7 +4293,7 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float // Remesh: even out uneven triangle sizes (CGAL isotropic remeshing). GPU Delaunay isn't practical // here, but this delivers the same goal - a consistent triangle size across the whole model. - m_imgui->text(_u8L("Uneven triangle sizes?")); + m_imgui->text(_u8L("Remeshing")); if (m_remesh_target_edge_mm <= 0.f && mv != nullptr) { // Seed the target with the model's current mean edge length, so the default is a sensible // "make everything about the size it already averages". @@ -4114,9 +4333,12 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float if (ImGui::IsItemHovered()) m_imgui->tooltip(_u8L("Rebuilds the whole model with triangles close to this edge length - splitting the big " "ones and merging the small ones - so displacement has an even density to work with. " - "Replaces the geometry and clears any not-yet-baked paint (already-baked bumps are kept)."), + "Replaces the geometry; your paint is carried onto the new triangles spatially, so it " + "survives (already-baked bumps are kept too)."), m_imgui->scaled(20.f)); + } // pro_mode() + ImGui::Separator(); m_imgui->disabled_begin(mv == nullptr || !mv->is_texture_displacement_painted()); @@ -4136,9 +4358,23 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float ImGui::SameLine(); m_imgui->disabled_begin(m_bake_in_progress || mv == nullptr || !mv->is_texture_displacement_painted()); - if (m_imgui->button(m_bake_in_progress ? _L("Baking...") : m_desc.at("bake"))) - bake(); + if (m_imgui->button(m_bake_in_progress ? _L("Baking...") : m_desc.at("bake"))) { + // Standard mode's Bake is the whole pipeline (remesh -> refine -> displace); Pro's is only the + // displacement, because there the user has already prepared the mesh with the controls above. + if (pro_mode()) + bake(); + else + bake_standard(); + } m_imgui->disabled_end(); + if (ImGui::IsItemHovered()) + m_imgui->tooltip(pro_mode() ? + _u8L("Turn the painted height maps into real geometry, by moving the vertices that are " + "already there. Use Subdivide first if the mesh is too coarse to show the detail.") : + _u8L("Turn the painted height maps into real geometry. The mesh is remeshed to an even " + "density and refined where the texture bends first, so the detail has vertices to " + "land on - all in one step."), + m_imgui->scaled(20.f)); ImGui::Separator(); if (m_imgui->button(_L("Close"))) diff --git a/src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp b/src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp index 1f3c6bcc73..29fc28a114 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp @@ -67,7 +67,51 @@ private: void add_texture_layer(); void remove_texture_layer(int slot); void set_active_layer(int slot); // flushes the previous layer's edits, then reloads selectors - void bake(); + // `own_snapshot` false when the caller has already taken an undo step that is meant to cover the + // displacement too - see bake_standard(). + void bake(bool own_snapshot = true); + + // Standard (0) vs Pro (1), driven by the two-position slider in the panel header. + // + // Pro is the panel as it has always been: every geometry-preparation control is visible and the + // user drives Remesh, Subdivide and Bake themselves, in whatever order they like. Standard hides + // all of that, pins it to one fixed recipe, and folds it into the Bake button - paint, press Bake, + // done - so the common case does not require knowing that a height map can only move vertices that + // already exist. Nothing about Pro changed when Standard was added. + int m_panel_mode = 0; + bool pro_mode() const { return m_panel_mode != 0; } + // Pins every control Standard mode hides to its preset value. Idempotent, called each frame while + // Standard is active so what Preview shows is always what Bake will do. Returns true if it actually + // changed something, so the caller can invalidate the preview. + bool apply_standard_mode_presets(ModelVolume *mv); + // Standard mode's Bake: remesh to an even density, refine where the texture bends, then displace. + // The order matters and is the whole reason this is one button - a height map can only move + // existing vertices, so the mesh has to be prepared first, and remeshing after painting would drop + // the paint if it were not remapped across (see replace_mesh_keep_all_paint()). + void bake_standard(); + + // Replaces `mv`'s mesh and carries *every* paint channel onto it, texture displacement included - + // the four standard channels via ModelVolume::restore_painting(), the eight texture-displacement + // masks via the same TriangleSelector::remap_painting() spatial remap, which restore_painting() + // does not cover. Shared by Remesh and by Standard mode's pipeline. + static void replace_mesh_keep_all_paint(ModelVolume &mv, TriangleMesh &&new_mesh); + // Remesh and adaptive Subdivide are each split into a *plan* (the heavy geometry work, touching + // nothing) and an *apply* (pure mutation). That split is what lets both the standalone buttons and + // Standard mode's one-button pipeline run the expensive part **before** taking the undo snapshot, + // so a run that turns out to be a no-op does not leave an empty undo step behind - and it keeps + // snapshot ownership with the caller, which matters because the buttons want one snapshot per click + // while the pipeline wants a single one around remesh + subdivide together. + struct SubdivisionPlan + { + indexed_triangle_set refined; + std::vector source; // new tri -> input tri + std::array, TEXTURE_DISPLACEMENT_MAX_LAYERS> painted_tri; // per layer, per input tri + }; + // False means "nothing to refine" and `out` must not be used. + bool plan_adaptive_subdivision(const ModelVolume &mv, SubdivisionPlan &out) const; + static void apply_adaptive_subdivision(ModelVolume &mv, SubdivisionPlan &&plan); + // False means the remesh failed or changed nothing (CGAL signals failure by handing the input back). + static bool plan_remesh(const ModelVolume &mv, float target_edge_mm, float sharp_angle_deg, TriangleMesh &out); // Marks every facet of every model-part volume as painted for the currently active layer - // "whole model" as an alternative to brushing/clicking every triangle by hand. @@ -327,7 +371,7 @@ private: // dense model). Refinement is worst-error-first, so hitting the budget still yields the best mesh // that many triangles can buy - and it is what keeps a fine "Detail" over a noisy texture from // turning into an out-of-memory, or an unrenderable preview wireframe. - int m_subdivide_budget_k = 200; + int m_subdivide_budget_k = 1500; void subdivide_model_adaptive(); // Fills `region` (per current-mesh triangle, 1 = refine) from the union of every layer's painted // area. If `painted_tri` is non-null, also fills, per layer, the fully-painted triangles to carry @@ -345,7 +389,9 @@ private: // Isotropic remeshing (CGAL) to even out wildly varying triangle sizes so displacement has a // consistent density to work with. Target edge length in mm; 0 means "not yet initialised", filled // with the mesh's mean edge length the first time the control is shown. Like subdivide, it replaces - // the geometry and drops not-yet-baked paint (no remap across a topology change). + // the geometry, but unlike subdivide it keeps every paint channel: replace_mesh_keep_all_paint() + // remaps the texture-displacement masks spatially, which is also what lets Standard mode remesh + // *after* the user has painted. float m_remesh_target_edge_mm = 0.f; // Dihedral angle above which an edge counts as a hard feature and is held fixed by the remesher. // Off by default would round every sharp edge off, so this is on; 0 disables the protection. diff --git a/src/slic3r/GUI/Jobs/TextureDisplacementBakeJob.cpp b/src/slic3r/GUI/Jobs/TextureDisplacementBakeJob.cpp index ae7e4dc3dd..7d6119ce30 100644 --- a/src/slic3r/GUI/Jobs/TextureDisplacementBakeJob.cpp +++ b/src/slic3r/GUI/Jobs/TextureDisplacementBakeJob.cpp @@ -41,41 +41,55 @@ void TextureDisplacementBakeJob::finalize(bool canceled, std::exception_ptr &ept Plater *plater = wxGetApp().plater(); - Plater::TakeSnapshot snapshot(plater, _u8L("Bake texture displacement"), UndoRedo::SnapshotType::GizmoAction); + const auto commit = [this, plater]() { + ModelVolume *volume = get_model_volume(m_input.volume_id, plater->model().objects); + if (volume == nullptr) + return; - ModelVolume *volume = get_model_volume(m_input.volume_id, plater->model().objects); - if (volume == nullptr) - return; + volume->set_mesh(std::move(m_result)); + volume->set_new_unique_id(); + volume->calculate_convex_hull(); - volume->set_mesh(std::move(m_result)); - volume->set_new_unique_id(); - volume->calculate_convex_hull(); + // Clear the paint mask of every layer that was actually baked so a repeat bake (or the paint + // overlay) doesn't act on triangles that no longer represent the same unbaked surface. The + // texture layer definitions themselves (and paint outside the baked area, if any) are left + // untouched so the user can keep sculpting with the same textures. + for (const TextureDisplacementLayer &layer : m_input.layers) + if (!layer.empty() && layer.slot >= 0 && layer.slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS)) + volume->texture_displacement_facet(layer.slot).reset(); - // Clear the paint mask of every layer that was actually baked so a repeat bake (or the paint - // overlay) doesn't act on triangles that no longer represent the same unbaked surface. The - // texture layer definitions themselves (and paint outside the baked area, if any) are left - // untouched so the user can keep sculpting with the same textures. - for (const TextureDisplacementLayer &layer : m_input.layers) - if (!layer.empty() && layer.slot >= 0 && layer.slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS)) - volume->texture_displacement_facet(layer.slot).reset(); + ModelObject *object = volume->get_object(); + if (object == nullptr) + return; - ModelObject *object = volume->get_object(); - if (object == nullptr) - return; + if (ObjectList *obj_list = wxGetApp().obj_list()) { + const ModelObjectPtrs &objs = plater->model().objects; + auto it = std::find(objs.begin(), objs.end(), object); + if (it != objs.end()) + obj_list->update_info_items(size_t(it - objs.begin())); + } - if (ObjectList *obj_list = wxGetApp().obj_list()) { - const ModelObjectPtrs &objs = plater->model().objects; - auto it = std::find(objs.begin(), objs.end(), object); - if (it != objs.end()) - obj_list->update_info_items(size_t(it - objs.begin())); + plater->changed_object(*object); + }; + + // Standard mode's Bake is remesh -> subdivide -> displace under a single snapshot, and this job runs + // long after that snapshot's scope has closed. Adding one here would put an undo step *between* the + // subdivision and the displacement: the first Undo would land on a mesh carrying every added + // triangle and no relief at all, and pressing Bake again from there would subdivide that mesh a + // second time. So the caller says who owns the undo step. + if (m_input.take_snapshot) { + Plater::TakeSnapshot snapshot(plater, _u8L("Bake texture displacement"), UndoRedo::SnapshotType::GizmoAction); + commit(); + } else { + commit(); } - - plater->changed_object(*object); } -void queue_texture_displacement_bake(const ModelVolume &volume, std::function on_finished) +void queue_texture_displacement_bake(const ModelVolume &volume, std::function on_finished, + bool take_snapshot) { TextureDisplacementBakeInput input; + input.take_snapshot = take_snapshot; input.volume_id = volume.id(); input.base_mesh = volume.mesh().its; input.layers = volume.texture_displacement_layers; diff --git a/src/slic3r/GUI/Jobs/TextureDisplacementBakeJob.hpp b/src/slic3r/GUI/Jobs/TextureDisplacementBakeJob.hpp index 6fca093897..bf0fcaa8bd 100644 --- a/src/slic3r/GUI/Jobs/TextureDisplacementBakeJob.hpp +++ b/src/slic3r/GUI/Jobs/TextureDisplacementBakeJob.hpp @@ -22,6 +22,10 @@ struct TextureDisplacementBakeInput std::vector layers; TextureDisplacementFacetsData facets_data; TextureDisplacementOptions options; + // Whether this job pushes its own undo step when it commits. False when the caller has already + // taken one that is meant to cover the displacement as well - Standard mode's Bake, which remeshes + // and subdivides first and has to undo as a single action. + bool take_snapshot = true; }; // Bakes a volume's painted texture-displacement layers into real mesh geometry in the background, @@ -45,7 +49,8 @@ private: // the app's UI job worker. `on_finished` is always called once the job settles (success, failure, // or cancellation), so the caller can clear its own "bake in progress" UI state. Must be called // from the main thread. -void queue_texture_displacement_bake(const ModelVolume &volume, std::function on_finished); +void queue_texture_displacement_bake(const ModelVolume &volume, std::function on_finished, + bool take_snapshot = true); } // namespace Slic3r::GUI