PATCH mode

Press 4. PATCH is where you choose surfaces and decide how they are filled.

A patch is one CAD surface — a sheet in CAD terms, the trimmed surface patch a solid is built from (or a merged union of several). It owns its fill strategy, its density, its guide and its tweaks — all stored parametrically, so re-filling it later reproduces the same result plus your changes.

Select

Gesture	Effect
hover	the patch under the cursor highlights; unbuilt CAD islands highlight too
LMB	select the hovered island — built or not. Clicking empty space clears the selection
Shift+LMB / Ctrl+LMB	add / remove from the selection
LMB drag	box-select whole patches (never a partial face selection)
Shift+G	select every patch of the same CAD surface type as the hovered one (STEP only). Replaces the selection; accumulate with Shift+LMB

Selection is by island id, so unbuilt islands sit in it like built ones ("select several, then build them" is one gesture pair), and it survives operations — F, a strategy change, X, Reset and any rebuild keep the same patches selected. Only clicking empty space or picking something else clears it.

Select Similar reads the CAD type, not the geometry, so "all fillets of this band" is one keystroke. Curved islands are further split into open strips (fillet bands) and wrapping walls (bores, bosses) so a half-cylinder hole does not group with a tube.

Fill

F fills the selection. Unbuilt islands get built, built ones re-fill — so the same key covers "make this" and "make this again after a tweak". With nothing selected it falls back to the hovered island, for a quick single fill.

Clicking never fills. Select, then F.

Fill strategy per patch (tool header, while patches are selected): Auto, Smart fill, Quad, Loft. Auto is the honest default — override when you know better, not as a habit. What each one builds, and what it costs you in control, is on Fill types.

Fill missing (panel) rebuilds every patch detection found but the mesh does not have — a deleted patch, a skipped one, or one whose source appeared after the bootstrap. No selection needed.

Refresh stale (panel) rebuilds every patch that a neighbour's change has marked for a rebuild but that has not caught up yet — the classic case is a flat patch not following the cylinders cut into it after their spans were wheeled. No selection needed; it reports how many it rebuilt, and says so when there is nothing to do. Commit runs the same sweep automatically before applying, so a stale patch can never end up baked into the final mesh.

Cover — one patch over many

Some regions are not worth retopologizing patch by patch: knurling, engraved detail, a cluster of tiny surfaces the CAD author left behind. A cover lays ONE live patch over the whole group — its boundary is the group's outer rim, everything inside is ignored, and the covered surfaces stay untouched underneath, so removing the cover brings them back exactly as they were.

The gesture is the ordinary selection:

1. Select the patches to cover (click / box). While the selection forms a connected group that can be covered, a yellow outline previews the derived perimeter.
2. Alt+F (or the Cover button in the panel). Not F — F is the ordinary fill. A mixed selection covers its largest connected group; the disconnected leftovers are skipped and listed in the report.
3. An island you did not select but that sits fully inside the group is covered automatically — the perimeter is what you choose, not the roster.

A cover behaves like a real patch afterwards: click any covered patch to select it, hover highlights the whole group, the fill strategy switch and the G/R/S/D knobs work, the boundary curves tune with the span wheel, and its seams weld to the neighbours parametrically. X removes it and the covered patches return untouched. Undo works in both directions.

What to expect from the interior: the default fill is Smart fill sourced from the covered surfaces, so over grooves and knurling the interior follows the detail rather than bridging it flat — treat the cover as a decimation gesture, not a smoothing one. A flat bridge over deep detail is planned (silhouette snapping); until then a Quad/Loft strategy on the cover gives the un-snapped, sagging-prone approximation.

Current limits: a cover cannot include an already built patch (reset it first — refused loudly), does not mirror (no symmetry half-loop yet), and its faces carry no CAD id for the normal transfer. Freeze, Inset and Merge refuse a cover; Reset on a cover is simply X.

Smart-fill knobs: G / R / S / D and W

Smart fill only

These knobs exist because smart fill has an interior of its own to move. A structured Quad, Loft or macro grid has none — its interior is a consequence of its boundary — so the operator declines with "works on smart fill (smart / coarse) only". A frozen patch declines too. In CURVE mode they say "use span / contour"; in vertex/edge/face they forward to Blender's own transform. Nothing silently half-applies.

Steer structured fills from their curves instead — see CURVE and Fill types.

G / R / S / D open the on-surface UV manipulator on the selected patch:

G — slide the lattice

move the whole grid across the surface.

R — rotate the flow

spin the grid direction.

S — redistribute

push the same nodes along U/V. Node count is unchanged and everything stays on the CAD surface — this is not Blender's scale.

D — density

the interior node count per axis; re-fills, so topology changes. Each axis also has a terminal: drag decisively past the floor and the axis snaps to loft (the label says so) — zero interior loops in that direction. From loft only an upward drag brings density back; small wobbles never resurrect it by accident. What the loft state builds is described in Fill types.

Grab a handle (U/V arrow, ball, or the corner square for both axes) and drag for a live re-fill; press the key twice (gg, rr, ss, dd) to drive it from the cursor instead. The four axes switch on the fly, committing the current drag.

W — flow guide, smart fill only as well: press LMB, drag, release, and that line becomes the fill's flow direction. It lays no edge itself — it orients the interior. The cursor may leave the patch: the guide goes to the patch you selected whatever you release over. Hold Ctrl at press or release to stick that endpoint to the nearest vertex of the filled mesh on screen, i.e. the vertices you actually see. Draw again to replace, or clear it to return to automatic flow (Flow / its × in the tool header do the same). The guide is the R knob's twin — it only sets the lattice direction, so on a flat patch or a structured fill it changes nothing.

Shift+W — manual rails (also Rails in the tool header): click vertex to vertex across a smart-fill patch to lay up to four lines the interior must follow — a whole station row seats on each one, so both banks become full cells and recombine into quads. The snap is always on, a rail may not cross another, Ctrl+click deletes one, the header's mirror toggle lays them on the X twin too, Clear rails removes them. A rail adds a rule; it never re-aims the lattice (that is R / the flow guide). Structured Quad/Loft patches refuse them, like the guide.

Polish

Relax and soft move are brush strokes — see The brush. A manual F on a brushed patch clears its dabs and re-pours plain; spans and splits survive.

Inset (tool header, beside the strategies) lays a quad perimeter band; adjust Band width in the redo panel (F9) and the band re-tessellates live. Concave or thin patches shrink the band or fall back to the plain fill rather than producing garbage.

Merge joins two or more selected patches into one: the internal joints vanish and the union re-fills as a single even grid. Frozen members block a merge — unfreeze first.

Merge is pulled from the panel for now

The merge workflow has known problems, so its button is off the panel until they are resolved. The operator itself still exists (F3 → HC: Merge Patches), but consider it at-your-own-risk in this build.

Where density comes from

Structured patches take their density from their curves in CURVE; Smart fill from D / S on this patch; a shared curve propagates to both patches and keeps the weld. The wheel here drives many patches at once.

Spans across a multi-selection

Shift+Wheel over a multi-selection bumps the span of every selected patch's transverse curves at once: tube rims, fillet width arcs — the direction that reads as "how many rows across the band". Select the whole run of fillets, wheel once, and the band keeps a consistent count instead of being tuned patch by patch. On a Mac, a smooth Shift-scroll (trackpad / Magic Mouse) drives the same gesture.

Two rules decide what the wheel actually turns, per patch:

• a curve sitting at span 1 is pinned — the wheel never moves it, in either axis;
• when a patch's whole transverse (U) set is pinned, the wheel drives its live V instead — a ribbon's rails, a grid's opposite pair;
• a flat patch is skipped, always — even a flat strip that reads as a band of quads (its "quads" are the triangle fill dissolved into n-gons for viewing). Flat has no transverse direction to trade; the status line counts it as planar and its arcs are still tuned one at a time in CURVE.

So a radial detail mass-tweaks without skips: each patch contributes the axis that actually has segments to trade, and nothing at span 1 drifts. When every curve in the selection is pinned the wheel says so instead of doing nothing silently. To raise a span-1 curve, use the exact-entry fields below — typed numbers bypass the pin on purpose.

Selections up to ~20 patches commit every notch live; above that the gesture accumulates while you scroll and commits one rebuild when the wheel goes idle, so a five-notch turn costs one re-fill and not five.

Afterwards the redo panel (F9) exposes both axes: Spans U is what the wheel drove, Spans V is the complement. A closed tube has no boundary V (its axial rows are interior), so V is reported as not applicable there rather than silently doing nothing.

While patches are selected, each one carries a U/V label in the viewport (yellow / cyan — the same colours as the fields) showing exactly which curve each axis will drive. The panel's U and V fields set either axis to an exact number across the whole selection — type the value, 0 means "leave as is". Don't need the labels? Show UV spans (panel toggle) turns them off.

E — type the spans. The fastest exact entry: press E, type the number (it echoes in the header), Enter. No mouse travel, no field to click. The number follows the same routing as the wheel — each patch's live axis lands on it, span-1 curves stay pinned — and in CURVE the same key sets the selected curves directly. Esc cancels, Backspace edits.

Ctrl+C / Ctrl+V — copy the U/V of the patch under the cursor, paste onto the selected patches. The paste goes through the same routing as the wheel: live U keys take U, live V keys take V, span-1 curves stay pinned. The same keys carry a single curve's span in CURVE; one buffer serves both modes.

Density stays off the wheel deliberately: it re-fills, and re-pouring a dozen patches from a wheel notch is not a gesture anyone wants by accident. To drive density (or any of G/R/S/D) on more than one patch, use the gizmo below — it is built for two or three patches, not for a batch.

G / R / S / D on two or three patches

Select the patches and press the key: the gizmo appears on the active one and the others follow the same drag. The status line says who is coming along — "Density P12 +2 with it" — and how many were skipped.

What each companion gets is the same relative change, applied to its own starting value: D and S are multipliers on that patch's own lattice, G is a slide in its own UV. Two patches of different size therefore stay different — they get denser together, they do not collapse onto one number.

"The same axis" means the same direction in space, not the same slot: each patch's U and V come from its own unwrap, so a companion whose frame runs the other way is matched by direction and driven on the axis that actually lines up with what you are dragging. At 45° the question has no answer and the match is arbitrary — you will see both patches move, and undo is one key away.

Skipped without fuss, with a count in the status line: frozen patches, and structured Quad/Loft fills that have no lattice to move. A cut patch takes D/S/G but refuses R, because each of its regions seeds its own frame.

Sized for hand work

This is built for the 1-3 patches you are actually finishing, not for driving a whole part at once — Hardcraft is per-patch hand work, not automation.

Freeze and Reset

Freeze takes a patch off the parametric path: nothing regenerates it, so hand edits on its mesh are safe. Frozen patches draw tinted. This is the mechanism that lets you finish a stubborn area by hand without losing the rest.

Reset is the escape hatch: unfreeze, delete, purge every override (strategy, guide, transform, relax, inset), return the shared seams to the CAD curve and re-fill. One rule matters at the border: a frozen neighbour's side wins — the re-fill inherits the hand lay it already has, rather than fighting it.

Symmetry and weld preview

Alt+X toggles mirror-X symmetry: work one side, get both. The mirror and the seam weld live in a small Geometry Nodes modifier on the retopo object: it mirrors the flagged faces across local X and merges by distance, restricted to boundary points. Both are evaluated, not baked — which is why the preview is exact and why symmetry costs nothing parametrically. Apply is the commit: it bakes the modifier, closes the seams and strips the Hardcraft metadata.

Auto-sym (panel toggle) applies that flag for you: while it is on, every first-time fill looks for the patch's mirror twin across X=0 and, if it finds a solid one, the patch becomes a Mirror X master on the spot. No twin, and the fill lands plain — silently, with nothing to undo. It never touches patches you already built: the automatic path only ever fires on the fill you just made, and the twin is left alone if it is already filled. Alt+X remains the manual gesture and is unaffected by the toggle.

The twin test is deliberately hard to pass, because a wrong mirror is worse than no mirror: the mirrored patch has to land on its candidate's surface, the candidate has to point back at it, and the two have to match in both area and shape — a near-symmetric model whose two sides are cut into different patches will not pair up. If a patch you consider symmetric stays unflagged, that is the verdict refusing, not a bug; flag it by hand with Alt+X.

Weld preview (panel) makes the edit cage be the evaluated result, so the welded seams are what you see and edit — the retopology overlay keeps drawing, now over the welded mesh. The mirrored ghost's wire stays readable at any distance and does not show through the part. Toggle it off to return to the working view.

Merge Distance on the modifier is the weld tolerance, and it is entirely yours: it starts at the node group's own default and Hardcraft never writes it — not on a fill, not on Alt+X, not on a rebind. Raise it if a seam does not close.

The brush (separate tool)

Soft move and relax live on their own HC Brush tool, not on HC Target's keys — inside the brush LMB is the stroke, which is why HC Target's Shift+LMB can stay add patch to selection.

In HC Brush	Effect
LMB drag	soft move — grab interior verts with falloff; every vertex re-raycasts onto the patch's own surface, so the grab slides on the CAD. Boundary stays pinned.
Shift+LMB drag	relax — one solver step per tick while held; hold still to keep relaxing one spot
Shift+Wheel	brush radius — between strokes; during one, plain Wheel does it too
Ctrl+Wheel (during a stroke)	falloff

Strength lives on the slider in the tool header, not on the wheel. Pen pressure scales it while you draw. The header also carries a Symmetry X toggle: the stroke lands on the mirror patch across local X=0 as well, and those dabs persist there.

Both are recorded as dabs and replayed through the same kernel on regen — so a re-fill does not throw away your stroke.