Add motion-design skills from iart-ai/motion-design-skills

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013TAaJBzbmePTECuv62BXYX

.agents/skills/after-effects/references/expressions.md

@@ -0,0 +1,134 @@
+# Expressions, Rigging & MOGRT
+
+After Effects is GUI software, so this delivers knowledge: ready-to-paste JavaScript expressions, rigging setups that make motion controllable, and template/export pipelines. Expressions read on the property they are pasted on; `value` is that property's keyframed/static value, `time` is the composition time in seconds, and `index`, `thisLayer`, `thisComp` are in scope.
+
+For a deeper cookbook (tuned inertial bounce, every loop variant, advanced per-axis wiggle, `valueAtTime` echoes, `seedRandom` grids, full rigging walkthrough, Essential Graphics → MOGRT steps, Lottie/Bodymovin + Media Encoder presets), see `expression-library.md`.
+
+## Core expressions
+
+### Inertial bounce (overshoot after the last keyframe)
+
+Paste on a Position, Scale, or Rotation property. It continues the velocity at the final keyframe into a damped sine — the classic "settle" motion.
+
+```js
+amp = 0.08;   // overshoot amount
+freq = 2.5;   // oscillations per second
+decay = 6.0;  // how fast it settles
+n = 0;
+if (numKeys > 0) {
+  n = nearestKey(time).index;
+  if (key(n).time > time) n--;
+}
+if (n > 0) {
+  t = time - key(n).time;
+  v = velocityAtTime(key(n).time - 0.001);
+  value + v * (amp * Math.sin(freq * t * 2 * Math.PI) / Math.exp(decay * t));
+} else {
+  value;
+}
+```
+
+### Looping
+
+```js
+loopOut("cycle");        // repeat keyframed range forever
+loopOut("pingpong");     // bounce back and forth
+loopOut("offset");       // continue, accumulating (e.g. continuous travel)
+loopOut("continue");     // extend final velocity linearly
+loopOut("cycle", 2);     // loop only the last 2 keyframes
+loopIn("cycle");         // mirror, before the first keyframe
+```
+
+### Wiggle and stable randomness
+
+```js
+wiggle(2, 30);              // 2 wiggles/sec, amplitude 30 (units match the property)
+seedRandom(index, true);   // unique-but-stable per layer; timeless=true
+random(0, 100);            // stable after seedRandom
+wiggle(freq, amp, octaves=1, amp_mult=0.5, t=time);  // full signature
+```
+
+`seedRandom(index, true)` before `random()` or `wiggle()` makes each layer differ but stay constant across renders — essential for grids of layers that must not flicker.
+
+### Time remap & value-at-time
+
+```js
+// Sample another property/layer at a shifted time (echo/trailing motion)
+delay = 0.2 * index;
+thisComp.layer("Lead").transform.position.valueAtTime(time - delay);
+
+// Speed up a precomp via time remap
+linear(time, 0, thisComp.duration, 0, 6);  // 6s source mapped over comp duration
+```
+
+## Rigging
+
+Make motion controllable instead of hand-keyed:
+
+1. Add a null/control layer (often a "Controls" layer). Add **Slider Control**, **Checkbox Control**, **Color Control**, **Angle Control**, or **Point Control** effects to it.
+2. Reference them with the pick-whip or by path:
+
+```js
+ctrl = thisComp.layer("Controls");
+amt  = ctrl.effect("Intensity")("Slider");      // Slider Control → ADBE Slider Control-0001
+on   = ctrl.effect("Enable")("Checkbox");       // Checkbox: 1 or 0
+col  = ctrl.effect("Tint")("Color");
+
+if (on == 1) value * amt else value;
+```
+
+3. Parent transforms to a null so one move drives many layers. Use `toComp`/`fromComp` to convert coordinate spaces when layers are parented or in different comps.
+
+```js
+// Stagger N layers off one master slider
+master = thisComp.layer("Controls").effect("Reveal")("Slider");
+delay  = 4 * index;     // 4 frames per layer
+master.valueAtTime(time - framesToTime(delay));
+```
+
+## Essential Graphics / MOGRT
+
+1. Open **Window → Essential Graphics**, pick the comp as the Master.
+2. Drag the Slider/Checkbox/Color/Text source properties into the panel to expose them.
+3. Group, rename, and set comment fields for editors.
+4. **Export Motion Graphics Template** → a `.mogrt` usable in Premiere Pro / AE. Keep driving expressions referencing the exposed controls so editors change only the exposed params.
+
+Set "Allow fonts to substitute" off and embed/package fonts where possible so the template renders consistently elsewhere.
+
+## Export from expressions/template work
+
+### To Lottie (Bodymovin / `@lottiefiles/bodymovin`)
+
+- Stick to Lottie-supported features: shape layers, transforms, masks, track mattes, basic expressions converted to keyframes.
+- Avoid blur-heavy effects, blend modes, 3D layers, and most native effects — they don't translate.
+- Bake expressions to keyframes if the renderer is strict, or use the `expressions` flag in Bodymovin and test on the target player (web/iOS/Android renderers differ).
+- Run **Bodymovin → Render** to produce `data.json` (+ optional images). Verify in a Lottie preview before handoff.
+
+### To video (Media Encoder)
+
+- **File → Export → Add to Adobe Media Encoder Queue** (or render queue for AE-native).
+- Delivery: **H.264** (MP4), bitrate ~10–20 Mbps for 1080p, VBR 2-pass.
+- Master/intermediate: **ProRes 422 HQ** (or ProRes 4444 when alpha is needed).
+- Transparency: ProRes 4444 or PNG/QuickTime with an alpha channel; H.264 cannot carry alpha. (See `export-recipes.md` for the full codec/alpha/bitrate matrix.)
+
+## Quick reference
+
+| Goal | Expression |
+|---|---|
+| Loop keyframes | `loopOut("cycle")` |
+| Continuous travel | `loopOut("offset")` |
+| Subtle life | `wiggle(2, 20)` |
+| Stable per-layer random | `seedRandom(index,true); random(...)` |
+| Settle/overshoot | inertial bounce (above) |
+| Echo another layer | `valueAtTime(time - delay)` |
+| Read a slider | `effect("Name")("Slider")` |
+| Frames ↔ seconds | `framesToTime(n)` / `timeToFrames(t)` |
+
+## Gotchas
+
+- An expression overrides keyframes on that property unless it incorporates `value`; start most expressions from `value`.
+- `index` is the layer's stacking number — it changes if layers are reordered; prefer named lookups for stable rigs.
+- Expression errors disable the expression and show a yellow banner; check the property's path names (effect names must match exactly, including duplicates' suffixes).
+- Pre-compose for reuse; name layers; use shy/lock and guide layers for safe areas before handoff.
+</content>
+</invoke>