std::shaders::motion

Stability: Tentative — motion shaders: loops and settling moves around an entity’s pose, and paths between two poses.

Two kinds of motion:

Local motions for Entity::local_motion return a LocalMotion. They move the entity around its pose for drawing only: the loops repeat forever, the settling moves hold still at their end.
Transitional motions for Entity::travel return a TransitionalMotion: a path from the entity’s pose to the pose given to travel, over a duration. .ease(…) and .delay(…) adjust it.

Distances are pixels and angles turn clockwise. Every function is const fn, not builtin.

Overview

Function	Kind	Motion
`bob(height, period)`	local, loop	rises and comes back
`sway(angle, period)`	local, loop	rocks around the anchor
`pulse(scale, period)`	local, loop	grows and shrinks
`spin(period)`	local, loop	turns around the anchor
`orbit(radius, period)`	local, loop	circles through the pose
`decaying_quake(horizontal, vertical, duration)`	local, settling	a shake that fades out
`sine_integral(amplitude, rate, settle)`	local, settling	an overshooting approach
`arc(height, duration)`	transitional	a parabolic arc
`bounce(overshoot, duration)`	transitional	an overshooting arrival
`spiral(turns, duration)`	transitional	a spiral into the end

The loops use the behaviour Periodic { after: ZERO, period }: they start at once and repeat every period. Changing a loop’s arguments with a tween keeps its clock, so a bob can grow from bob(0.0, p) to bob(20.0, p) without a jump.

Bob

Rises by height pixels and comes back once per period, forever, easing in and out: y − height·(0.5 − 0.5·cos(2π·t/period)).

Sway

Rocks around the anchor by angle either way once per period, forever: rotation + angle·sin(2π·t/period).

Pulse

Grows to scale times its size and back once per period, forever, around the anchor.

Spin

Turns clockwise around the anchor once per period, forever.

Orbit

Circles clockwise on a circle of radius pixels that passes through the pose, once per period, forever. The entity starts at its pose and comes back to it every round.

Decaying quake

A shake that fades out (TyranoScript [quake2]): moves by horizontal and vertical pixels, alternating direction every frame at 60 fps, with the amplitude falling off quadratically to 0 over duration; then holds still at the pose. The behaviour is Stall { after: duration }.

Sine integral

An overshooting approach, and an example of a motion defined by a differential equation. The entity moves by amplitude · (2/π) · Si(rate · t), the solution of dx/dt = amplitude · (2/π) · sin(rate · t) / t from x = 0: it overshoots amplitude and settles at it in ringing swings. rate is in radians per second. The behaviour is Stall { after: settle }, so the motion holds where it is at settle.

Si has no closed form; the shader integrates it numerically from 0 to t every frame, since a shader keeps nothing between frames. The motion only changes how the entity is drawn: the entity’s logical position stays where it was, displaced by amplitude on screen once it settles.

Arc

Moves along a parabola that peaks height pixels above the straight line halfway, over duration: mix(start, end, p) − (0, height · 4p(1 − p)) for progress p. Scale and rotation change linearly.

Bounce

An overshooting arrival (animate.css bounceIn*): moves straight, overshoots the end by overshoot pixels, comes back past it by less, overshoots once more by less still, and settles, over duration. Scale and rotation change linearly. When the start and end positions are the same, the position does not bounce.

Spiral

Spirals into the end, turning turns times clockwise around it while the distance shrinks linearly, over duration. Scale and rotation change linearly.