After Effects expressions: a copy-and-paste cheat sheet

Wiggle

wiggle(frequency, amplitude) adds smooth random motion around the property's value: frequency in wiggles per second, amplitude in the property's units.

wiggle(2, 30)

[wiggle(2, 30)[0], value[1]]

[wiggle(2, 30), value]

wiggle(effect("Frequency")("Slider"), effect("Amount")("Slider"))

wiggle(ctrl('Frequency'), ctrl('Amount'))

Loop keyframes: loopOut and loopIn

The expression to repeat keyframes. loopOut() repeats the keyframed animation after the last keyframe; loopIn() does the same before the first. In Premation both loop the whole first-to-last keyframe range: the second argument After Effects accepts (how many keyframes to loop) is ignored.

loopOut()

loopOut("cycle")

loopOut("pingpong")

loopOut("offset")

loopOut("continue")

loopIn("cycle")

Spin and oscillate with time

time is the current time in seconds, so multiplying it gives a constant rate. Math.sin gives a back-and-forth.

time * 360

value + time * 90

value + Math.sin(time * 2 * Math.PI) * 15

50 + Math.sin(time * 4) * 50

Bounce and inertial bounce

An inertial bounce lets a property overshoot and settle after a keyframe, using the speed it arrived with. The classic After Effects version is a short script with variables, so it does not run in Premation; the single-expression version below does the same after the last keyframe and also runs in After Effects.

amp = 0.05; freq = 4; decay = 8;
n = 0;
if (numKeys > 0) {
  n = nearestKey(time).index;
  if (key(n).time > time) n--;
}
if (n == 0) {
  value;
} else {
  t = time - key(n).time;
  v = velocityAtTime(key(n).time - thisComp.frameDuration / 10);
  value + v * amp * Math.sin(freq * t * 2 * Math.PI) / Math.exp(decay * t);
}

numKeys === 0 || time <= key(numKeys).time ? value : value + velocityAtTime(key(numKeys).time - 0.001) * 0.05 * Math.sin((time - key(numKeys).time) * 4 * 2 * Math.PI) / Math.exp((time - key(numKeys).time) * 8)

value + Math.sin(time * 12) * 40 / Math.exp(time * 4)

Delay and follow another layer

A follower that copies a leader's motion a beat late. After Effects users usually chain layers with index - 1; Premation has no index, so name the leader.

thisComp.layer(index - 1).transform.position.valueAtTime(time - 0.1)

[layerAt('Leader', 'x', time - 0.1), layerAt('Leader', 'y', time - 0.1)]

layerAt('Leader', 'rotation', time - 0.1)

thisComp.layer('Leader').position

valueAtTime(time - 0.5)

Stepped motion: posterizeTime

Makes a smooth expression update only a few times a second, for a hand-animated feel. In After Effects posterizeTime(fps) is a statement placed before the expression; in Premation it returns the stepped time, which you pass where the time goes.

posterizeTime(8); wiggle(2, 30)

wiggle(2, 30, 1, 0.5, posterizeTime(8))

valueAtTime(posterizeTime(12))

Clamp and remap: clamp, linear, ease

clamp(value, min, max) keeps a number inside limits. linear(t, tMin, tMax, a, b) maps t from one range onto another; ease(), easeIn() and easeOut() do the same with a curve (Premation's ease() is a smoothstep).

clamp(value, 0, 100)

linear(time, 0, 2, 0, 360)

ease(time, 1, 3, 0, 100)

linear(effect("Progress")("Slider"), 0, 100, 0, 1920)

linear(ctrl('Progress'), 0, 100, 0, 1920)

linear(time, 0, 1, [0, 0], [960, 540])

[linear(time, 0, 1, 0, 960), linear(time, 0, 1, 0, 540)]

Measure a layer: sourceRectAtTime

sourceRectAtTime() returns a layer's own bounds — top, left, width and height — at a time, which is how motion adapts to content instead of typed numbers. Premation measures only the layer the expression is on; there is no thisComp.layer(…).sourceRectAtTime().

[sourceRectAtTime().left + sourceRectAtTime().width / 2, sourceRectAtTime().top + sourceRectAtTime().height / 2]

s = thisComp.layer("Title").sourceRectAtTime(); [s.width + 40, s.height + 20]

Random values: random and seedRandom

random(min, max) returns a new number every frame. seedRandom(seed, true) fixes it, so a layer keeps one random value. In Premation seedRandom returns 0, so it is added in front of random() inside the one expression. Without seedRandom, Premation already seeds each layer and each axis differently.

value + random(-5, 5)

seedRandom(5, true); random(0, 100)

seedRandom(5, true) + random(0, 100)

seedRandom(index, true); random([0, 0], [thisComp.width, thisComp.height])

[seedRandom(5, true) + random(0, thisComp.width), random(0, thisComp.height)]

Which ones work in Premation