anim.mcl

Identity rate function: animation progress equals time progress.

Use this when a motion should have constant speed or when another helper already encodes easing.

let linear = |t| t

play rate{linear} Lerp(1, [&dot])

Default ease-in/ease-out rate for most animations.

A monotone fifth-order smoothstep-style curve, symmetric around the midpoint.

let smooth = |t| {
    let s = 1 - t
    return t * t * t * (10 * s * s + 5 * s * t + t * t)
}

play Lerp(1, [&dot], smooth)

Rate that starts slowly and accelerates.

let smooth_in = |t| 2 * smooth(0.5 * t)

play rate{smooth_in} Lerp(1, [&item])

Rate that starts quickly and settles slowly.

let smooth_out = |t| 2 * smooth(0.5 * (t + 1)) - 1

play rate{smooth_out} Lerp(1, [&item])

Fifth-order smoothstep rate.

let smoother = |t| t * t * t * (t * (t * 6 - 15) + 10)

Cosine ease-in/ease-out rate.

let cosine = |t| ...

Power ease-in rate; larger p makes the start slower and the end sharper.

let ease_in = |t, p = 3| ...

Power ease-out rate; larger p makes the start sharper and the end slower.

let ease_out = |t, p = 3| ...

Symmetric power ease-in/ease-out rate.

let ease_in_out = |t, p = 3| {
    if (t < 0.5) { return ease_in(2 * t, p) / 2 }
    return 1 - ease_in(2 * (1 - t), p) / 2
}

Exponential ease-out rate.

let exponential = |t| ...

Bounce-out rate with decaying rebounds near the end.

let bounce = |t| ...

Elastic-out rate that overshoots and rings into place.

Because it overshoots, it can produce values outside [0, 1]; use with geometry that tolerates extrapolation.

let elastic = |t| ...

Low-level primitive animation wrapper used by higher-level animations.

embed can normalize follower/leader values into interpolation endpoints plus state; lerp can then use that state at every frame. Most scene code should use Lerp, Trans, Write, Grow, Fade, or CameraLerp instead.

let PrimitiveAnim = |time = 1, &vars = [], embed = nil, lerp = nil, rate = smooth| ...

Reveal newly introduced mesh content by growing it outward from its center.

Grow compares the current follower with the destination leader. Meshes introduced by the leader start collapsed at their centroid and expand into place; meshes deleted from the leader shrink back to their centroid. Best for appearing objects; use Fade for opacity-only entrances.

let Grow = |time = 1, &meshes = [], rate = smooth| ...

background = [0.035, 0.045, 0.060, 1]
mesh ring = stroke{CYAN, 3} Circle(1)
slide "grow"
play Grow(0.8, [&ring])
ring = []
play Grow(0.6, [&ring])

Morph line-based geometry by carrying local edge rotations through the path.

Bend is best for curves, polylines, and stroke-like shapes whose local direction should rotate smoothly. Unlike Trans, it does not run the full topology matcher; use Trans for unrelated filled shapes and Bend when the path structure itself is meaningful.

let Bend = |time = 1, &meshes = [], rate = smooth| ...

background = [0.035, 0.045, 0.060, 1]
mesh path = stroke{color: CYAN, stroke_width: 4} Polyline([1.4l, 0.4l + 0.7u, 0.4r + 0.4d, 1.4r])
slide "bend"
play Set()
path = stroke{color: ORANGE, stroke_width: 4} Polyline([1.4l, 0.8l + 0.6d, 0.7r + 0.7u, 1.4r])
play Bend(1.2)

Bend morph that pairs tagged subparts before matching geometry.

Use this for tagged stroke/path content when each tagged piece should bend independently.

let TagBend = |time = 1, &meshes = [], rate = smooth| ...

play TagBend(1, [&paths])

Temporarily change a mesh leader to a highlight color and then restore it.

Highlight is a progressor: it mutates the referenced leader to the highlighted value and then back to the original value.

let Highlight = |&value, color, time = 1, rate = smooth| anim ...

play Highlight(&equation, YELLOW)

Sweep a moving write-window over a mesh and then restore it.

Flash uses two phase functions: the leading edge and trailing edge of the visible window. By default the window opens, sweeps over the stroke/text contours, and closes.

let Flash = |&value, time = 1, lead = nil, trail = nil| ...

play Flash(&equation, 0.8)

Move all mesh content from one leader into another and clear the source.

This is a state-changing helper, not a visual morph by itself; it snaps both leaders with Set.

let Transfer = |&from, &into| anim {
    into = [into, from]
    from = []
    play Set([&from, &into])
}

play Transfer(&old_group, &new_group)

Move only the tagged subset matching a filter into another leader.

The filter receives the full tag list. Non-matching content stays in from.

let TransferSubset = |&from, &into, filter = nil| anim ...

play TransferSubset(&source, &sink, |tags| 2 in tags)

Copy the tagged subset matching a filter into another leader.

Matching content is appended to into; from is left unchanged.

let CopySubset = |&from, &into, filter = nil| anim ...

Copy all mesh content from one leader into another without clearing the source.

Snaps only the destination follower after appending the source content.

let Copy = |&from, &into| anim {
    into = [into, from]
    play Set([&into])
}

Move a tagged subset into an auxiliary target, morph it, then transfer it into another leader.

This is the workhorse for equation/proof animations: select tagged source pieces, morph them into matching destination geometry, then append them into into.

let TransSubsetTo = |&from, filter, target, &into, time = 1, tagged = 0, path_arc = 0, rate = smooth, similar_topo_hint = 0| anim {
    mesh aux = []
    play TransferSubset(&from, &aux, filter)

    aux = target
    if (tagged) {
        play TagTrans(time, &aux, path_arc, rate, similar_topo_hint)
    } else {
        play Trans(time, &aux, path_arc, rate, similar_topo_hint)
    }

    play Transfer(&aux, &into)
}

play TransSubsetTo(&labels, |tags| 2 in tags, tag_filter{|tags| 2 in tags} formula, &formula, 1, 1)

Copy a tagged subset into an auxiliary target, morph it, then transfer it into another leader.

Same as TransSubsetTo, but leaves the source content in place.

let TransSubsetCopy = |&from, filter, target, &into, time = 1, tagged = 0, path_arc = 0, rate = smooth, similar_topo_hint = 0| anim {
    mesh aux = []
    play CopySubset(&from, &aux, filter)

    aux = target
    if (tagged) {
        play TagTrans(time, &aux, path_arc, rate, similar_topo_hint)
    } else {
        play Trans(time, &aux, path_arc, rate, similar_topo_hint)
    }

    play Transfer(&aux, &into)
}

Run a list of animations with staggered offsets.

Starts each animation after an offset distributed by unit_map, then waits for all branches to finish. Good for cascaded Grow, Write, or per-item progressors.

let LaggedMap = |anims, average_offset = 0.1, unit_map = smooth| ...

play LaggedMap(map(dots, |&d| Grow(0.4, [&d])), 0.08)

Slow an animation by a multiplicative factor.

slow{2} doubles the target duration.

let slow = operator |target, factor = 2| ...

play slow{2} Write(1, [&path])

Speed an animation up by a multiplicative factor.

fast{2} halves the target duration.

let fast = operator |target, factor = 2| ...

Delay an animation block by playing Wait before it.

Useful inside parallel play [...] lists when one branch should start later.

let delay = operator |target, time = 1| [target, anim {
    play Wait(time)
    play target
}]

play [Write(1, [&a]), delay{0.2} Write(1, [&b])]