اللمس والحركة

How a glass surface answers a finger, bundled as one descriptor.

Touch response is not one effect. Apple's own description of Liquid Glass is that a control can "lift, flex, and energize" the moment you touch it — a deformation and a light, two separate things that fire on the same gesture. This is the group that holds them, so a surface's whole feel travels as a single value the way its whole look travels as a LiquidGlassStyle.

Today it carries flex. null means the surface does not respond at all — no gesture listener, no ticker, nothing added to the tree.

Touch-driven soft-body deformation for a lens that does not move.

Press a lens and it compresses under your finger; drag and it elongates along the pull, pinches in the cross axis, and leans after your finger — then springs back with a wobble when you let go.

The model: four independent edges

Unlike a scale transform — which can only grow symmetrically around one anchor — this moves the lens's left, right, top and bottom edges independently. That is what makes it read as soft: the half of the shape nearest your finger deforms more than the far half.

The grab point drives that split. Grab near the right edge and pull right: the right edge shoots out while the left barely follows. Grab dead centre and the same pull elongates both sides evenly. grip controls how localized this is (0 = fully symmetric, 1 = fully local).

Volume is preserved, not gained

Whatever the along-axis edges gain, the cross-axis edges give back: (w + g)·(h - loss) = w·h. Elongate horizontally and it genuinely gets thinner. squeeze scales that give-back (1 = full preservation, 0 = none).

Hold and tap are separate responses

holdScale resizes the lens for as long as the finger stays down — the swell of a control being held. tapScale is a one-shot pop fired the moment a tap completes, so a quick click still reads as a click even though nothing was held long enough for the hold to arrive. Both are signed: positive swells, negative yields inward.

A press also deepens the optics (LiquidGlassFlexAdvanced.refractionBoost), which is what makes the surface read as glass being compressed rather than as a rubber button popping.

Only nine knobs

Everything you would reach for while dialling in a feel is a direct parameter. The five that are set once and forgotten — content follow, optical boost, and the three spring constants — live in LiquidGlassFlexAdvanced behind advanced, so they stay out of the way without being out of reach.

One resolved frame of LiquidGlassFlex deformation.

The four edge values are how far each edge has moved outward from rest, in logical pixels; negative means the edge has moved inward.

The knobs of LiquidGlassFlex that are set once and then left alone — grouped so they stay out of the main constructor.

Reach for them when the feel is right but something else is off: the content is fighting the glass (childFollow), the optics are too shallow (refractionBoost), or the settle is too tight or too loose (the three spring constants).

How much of the stretched-outline behaviour is active. Debug only.

Exists so the fix can be judged against what it replaced on a running device -- a rim is one logical pixel wide, and the difference is not something a screenshot settles.

The sliding thumb's whole thumb effect as one isolated, reusable component: the two-state morph (contracted ↔ expanded glass), the acceleration squash / stretch (LiquidGlassLensMotion), and the driven-lens rendering — so the same living glass pill can ride a slider track, a bottom nav bar, or anything else that moves it.

Division of labour

The HOST owns position and gesture: where the pill's centre is each frame (drags, glide springs, rubber bands — whatever its own model produces) and when the pill is grabbed. This widget owns everything the thumb itself did:

• Morph. While active, the pill spring-grows from restSize to activeSize (0.4 s, ζ 0.6 — overshoot included); on deactivation it contracts on the softer spring (0.6 s, ζ 0.7). The optional cover (e.g. the slider's white rest pill) fades out as the glass arrives, so the two read as one crossfade.
• Squash/stretch. While active, center is sampled every frame into the acceleration model; the resulting deviation scales the pill oppositely on the two axes. Tracking starts on activation and resets instantly when the contract-back begins.
• Rendering. The deformation is not a rebuilt capsule: the lens renders at its REST (morph) size and the size change rides the shader's u_shapeScale + matching clip scale via LiquidGlassLens, so the end caps go elliptical instead of the shape being re-rounded at each new size — with the refraction band counter-scaled so it keeps its authored width at stretched caps.

Embedding

The widget fills whatever box the host gives it and positions the (overflowing) pill at center in that box's coordinates — place it as the child of a LiquidGlassView, or anywhere a LiquidGlassLens can render. The host just rebuilds with the new center; this widget's own ticker does the sampling.

The running simulation behind LiquidGlassLensMotionSpec. One instance per moving body; see the library doc for the calling contract.

The acceleration→deformation physics of a moving glass body, extracted from the stretch slider's thumb into a component-agnostic class.

Feed it the mover's position once per frame — a slider thumb's centre, a nav-bar pill's centre, anything that travels — and read back a signed scale deviation:

scaleX = 1 + deviation scaleY = 1 − deviation

Accelerating into a drag stretches the body wide and flat; braking (or arriving from a glide) squashes it narrow and tall; constant speed leaves it undeformed — force, not speed, is what deforms it.

This class is physics only: the caller owns the Ticker, calls start when the effect goes live (the thumb lifts, the pill starts moving), track every frame with the current position, and stop the moment the effect ends (an instant reset, masked by whatever animation runs over it). How the deviation maps to pixels is each component's business.

Positions are 2-D on purpose: the two axes combine as avgX − avgY, since a vertical acceleration deforms the opposite way (Y-stretch is a negative deviation). A horizontal mover passes Offset(x, 0) and gets the collapsed one-axis behaviour.

Wraps child so a pan gesture drags it, with the same smoothness as the built-in drag — and without baking drag into the lens itself.

The drag offset lives in an internal ValueNotifier, and only a Transform.translate rebuilds on each pan; child stays a stable subtree, so a wrapped LiquidGlassLens (or any glass) re-runs its shader/capture pipeline once, not every frame. The lens keeps sampling the backdrop correctly at its dragged position because the renderer resolves its screen rect through the full layer transform.