Skip to content

艺术动画skill:35种艺术风格、9种解说语法,用代码让画动起来。

9.2 KB
Raw Blame
// 动效时间库 MO:缓动、弹簧、步进、错开、拍号。全部是「时间 → 数值」的纯函数,不读时钟,确定性。
// 来源:YouTube 解说动画语法 8 支示范片(references/09-视频动画语法.md)。约定:p 是 0..1 的进度,t/lt 是秒。
//   选缓动的一句话:讲解(3b1b/白板)用 smooth/sineInOut 两端都停稳;发布会用 appleOut/弹簧;动态文字用 expoOut+弹簧;
//   拼贴(Vox)相机用 sineInOut 或长尾 longTail,纸片按 12fps 步进;Kurzgesagt 动作用 k75,循环用 easyEase。
(() => {
const { clamp, lerp } = U;
const MO = window.MO = {};

// 画布尺寸 U.setStage / U.onStage 在 util.js(比本文件先加载的 paint/brush/render/post 也要登记)。

// ---------- 时间片 ----------
MO.seg = (t, a, b) => clamp((t - a) / (b - a));                          // [a,b] → 0..1
MO.at = (t, t0, dur) => clamp((t - t0) / dur);                           // [t0, t0+dur] → 0..1
MO.anim = (lt, start, dur, ease = MO.smooth) => ease(clamp((lt - start) / dur));
// 步进时间:把连续时间量化成 fps 步。拼贴纸片/打字/荧光笔「一拍二」= 12fps;故事型角色 24fps;相机仍按 60fps 平滑。
MO.step = (t, fps = 12) => Math.floor(t * fps + 1e-6) / fps;

// ---------- manim 缓动(3b1b/manim rate_functions.py) ----------
// smooth = 6t⁵−15t⁴+10t³:两端速度、加速度都为 0。讲解类片子的默认缓动。
MO.smooth = t => { t = clamp(t); return t * t * t * (10 - 15 * t + 6 * t * t); };
const sig = x => 1 / (1 + Math.exp(-x));
MO.smoothCE = (t, inflection = 10) => { const e = sig(-inflection / 2); return clamp((sig(inflection * (t - 0.5)) - e) / (1 - 2 * e)); };   // ManimCE 版
MO.thereAndBack = t => MO.smooth(t < 0.5 ? 2 * t : 2 * (1 - t));          // Indicate 用:去了又回
MO.rushInto = t => 2 * MO.smooth(t / 2);                                  // 慢起、冲进终点
MO.rushFrom = t => 2 * MO.smooth(t / 2 + 0.5) - 1;                        // 冲出、慢收
MO.doubleSmooth = t => t < 0.5 ? 0.5 * MO.smooth(2 * t) : 0.5 * (1 + MO.smooth(2 * t - 1));
MO.wiggle = (t, wiggles = 2) => MO.thereAndBack(t) * Math.sin(wiggles * Math.PI * t);
// manim LaggedStart(lag_ratio=r):n 个子动画里第 i 个在总进度 p 下的局部进度。总长 = 1+(n-1)·r 个单位,第 i 个占 [i·r, i·r+1]。
MO.lagged = (i, n, p, r = 0.05) => clamp(p * (1 + (n - 1) * r) - i * r);

// ---------- 常用解析缓动(AE / CSS 名字) ----------
MO.linear = p => p;
MO.sineInOut = p => -(Math.cos(Math.PI * p) - 1) / 2;
MO.cubicIn = p => p * p * p;
MO.cubicOut = p => 1 - Math.pow(1 - p, 3);
MO.cubicInOut = p => p < .5 ? 4 * p * p * p : 1 - Math.pow(-2 * p + 2, 3) / 2;
MO.quartOut = p => 1 - Math.pow(1 - p, 4);
MO.quintOut = p => 1 - Math.pow(1 - p, 5);
MO.quintInOut = p => p < .5 ? 16 * p ** 5 : 1 - Math.pow(-2 * p + 2, 5) / 2;
MO.expoIn = p => p <= 0 ? 0 : Math.pow(2, 10 * p - 10);
MO.expoOut = p => p >= 1 ? 1 : 1 - Math.pow(2, -10 * p);                // 动效设计最常用的「快出慢停」
MO.expoInOut = p => p <= 0 ? 0 : p >= 1 ? 1 : p < .5 ? Math.pow(2, 20 * p - 10) / 2 : (2 - Math.pow(2, -20 * p + 10)) / 2;
// backOut 过冲:s=1.70158 约 10%;2.2 约 13%;2.6 约 17%;3.5 约 23%
MO.backOut = (p, s = 1.70158) => { const q = p - 1; return 1 + (s + 1) * q * q * q + s * q * q; };
// 弹性落定:overshoot 一次再回(贴纸「啪」地落下)
MO.elasticOut = p => p <= 0 ? 0 : p >= 1 ? 1 : Math.pow(2, -10 * p) * Math.sin((p * 10 - 0.75) * (2 * Math.PI / 3)) + 1;

// ---------- CSS cubic-bezier(x1,y1,x2,y2):牛顿法由 x 求参数,再取 y ----------
MO.bezier = (x1, y1, x2, y2) => {
  const cx = 3 * x1, bx = 3 * (x2 - x1) - cx, ax = 1 - cx - bx;
  const cy = 3 * y1, by = 3 * (y2 - y1) - cy, ay = 1 - cy - by;
  const X = s => ((ax * s + bx) * s + cx) * s, Y = s => ((ay * s + by) * s + cy) * s, dX = s => (3 * ax * s + 2 * bx) * s + cx;
  return p => {
    if (p <= 0) return 0; if (p >= 1) return 1;
    let s = p; for (let k = 0; k < 8; k++) { const e = X(s) - p, d = dX(s); if (Math.abs(e) < 1e-6 || Math.abs(d) < 1e-6) break; s -= e / d; }
    s = clamp(s); return Y(s);
  };
};
MO.appleOut = MO.bezier(0.25, 0.1, 0.25, 1);        // CSS `ease`:苹果官网/发布会过渡
MO.emphasized = MO.bezier(0.2, 0, 0, 1);            // Material 3 emphasized:长尾减速
MO.k75 = MO.bezier(0.75, 0, 0.25, 1);               // Kurzgesagt「其他动作用 75% influence」(y1 调研 §6.2)
MO.easyEase = MO.bezier(0.333, 0, 0.667, 1);        // AE Easy Ease:循环动作
MO.longTail = MO.bezier(0.33, 0, 0.2, 1);           // Vox「沿线追过去」「拉出揭示」:起步快、长尾落定(y2 调研)

// ---------- 弹簧 ----------
// SwiftUI 参数化(WWDC23 Animate with springs):stiffness=(2π/duration)²,damping=4π(1-bounce)/duration → ζ=1-bounce,ω=2π/duration。
// 返回 0→1 的位移(可 >1 = 过冲)。t 单位秒。发布会 UI 用它:.smooth(bounce 0) / .snappy(0.15) / .bouncy(0.3)。
MO.spring = (t, { duration = 0.5, bounce = 0, v0 = 0 } = {}) => {
  if (t <= 0) return 0;
  const w = 2 * Math.PI / duration, z = 1 - bounce;
  let x;                                                                 // x = 剩余位移(1→0)
  if (Math.abs(z - 1) < 1e-4) x = Math.exp(-w * t) * (1 + (w - v0) * t);
  else if (z < 1) { const wd = w * Math.sqrt(1 - z * z); x = Math.exp(-z * w * t) * (Math.cos(wd * t) + ((z * w - v0) / wd) * Math.sin(wd * t)); }
  else { const r = Math.sqrt(z * z - 1), a = -w * (z - r), b = -w * (z + r); const A = (-v0 - b) / (a - b); x = A * Math.exp(a * t) + (1 - A) * Math.exp(b * t); }
  return 1 - x;
};
MO.smoothSpring = t => MO.spring(t, { duration: 0.5, bounce: 0 });
MO.snappy = t => MO.spring(t, { duration: 0.5, bounce: 0.15 });
MO.bouncy = t => MO.spring(t, { duration: 0.5, bounce: 0.3 });
// 频率/衰减参数化的欠阻尼弹簧阶跃响应(动态文字用):freq Hz、decay 1/s。
//   freq 3 / decay 6 第一次过冲 ≈37%(砸进来的大字);2.5 / 9 ≈16%(常规弹入);2.2 / 10 ≈8%(主词落定)
MO.springHz = (t, freq = 2.5, decay = 9) => t <= 0 ? 0 : 1 - Math.exp(-decay * t) * Math.cos(2 * Math.PI * freq * t);
// 到位后的余振(Dan Ebberts 惯性回弹):amp·sin(2πft)/e^(decay·t)。换姿势的身体挤压、屏幕震动都用它。
MO.settle = (t, amp, freq = 3, decay = 5) => t <= 0 ? 0 : amp * Math.sin(2 * Math.PI * freq * t) / Math.exp(decay * t);

// ---------- 镜头动作时长(什么时候用哪一种,见 references/镜头语言.md) ----------
// 两类:过渡(缓推 push、找下一件 glide、拉远 pull,0.6–1.5s 缓入缓出)是默认;重音(快推 punch、快移 pan、砸入 slam)留给揭晓、数字、反转。
// 过渡的数取自参考片实测:Vox 推进 1.0–1.5s、找卡 0.5–0.9s、拉出约 1s;3b1b 推镜约 1s。
// 重音的数:一支「每镜匀速推近 7.5%」被判像 PPT 的片子,改成停住→0.28s 快推→停住后被认可;但 2026-10-12 诺奖短片每 2 秒一次快推,被判「太多、太快、不 smooth」。
// 时长常量集中在这里,CAM.track / MD / 各片段都读它;要改节奏改这里,别在片段里另写一套。
MO.PULSE = { punch: 0.28, pan: 0.30, slam: 0.17, k: 0.25, kMin: 0.18, kMax: 0.32, push: 0.9, glide: 0.7, pull: 1.1 };
// 砸入曲线:k = 0..1(砸入进度)→ 缩放。1.55 → 0.94(前 60%,3 帧砸下)→ 1.0(后 40%,2 帧回弹)。k≤0 返回 1.55(还没落下)。
MO.slamK = (k, from = 1.55, under = 0.94) => k <= 0 ? from : k < 0.6 ? from - (from - under) * (k / 0.6) : k < 1 ? under + (1 - under) * ((k - 0.6) / 0.4) : 1;
// 某个元素在 at 这一帧砸进来:返回它此刻的缩放(at 之前 = 0,元素还不该画)。o: {dur=0.17, from=1.55, under=0.94}
MO.slam = (t, at, o = {}) => t < at ? 0 : MO.slamK((t - at) / (o.dur || MO.PULSE.slam), o.from, o.under);
// 动作进度:at 起 dur 秒内按 ease 从 0 走到 1,之后停在 1(默认快推的时长和曲线;缓推写 MO.pulse(t, at, MO.PULSE.push, MO.sineInOut))
MO.pulse = (t, at, dur = MO.PULSE.punch, ease = MO.cubicInOut) => ease(clamp((t - at) / dur));

// ---------- 持续微动 ----------
// 只给环境层(星闪、粒子、远景云)和艺术风格画面用。解说片的主体、标签、卡片落定后停住,不加浮动、呼吸。
// 漂浮:两频正弦叠加。周期避开 5s 左右(HIG:~0.2Hz 的持续摆动让人不适)
MO.float = (t, amp = 6, period = 4, ph = 0) => amp * (0.75 * Math.sin(2 * Math.PI * t / period + ph) + 0.25 * Math.sin(2 * Math.PI * t / (period * 0.53) + ph * 1.7));

// ---------- 反查与拍号 ----------
// 缓动的反函数(二分):「线头/计数在什么时刻到达 y」。例:折线按 smooth 画,求画到某个 x 的时刻(t3 镜 2 的事件标注)。
MO.invert = (ease, y, iters = 30) => { let a = 0, b = 1; for (let i = 0; i < iters; i++) { const m = (a + b) / 2; if (ease(m) < y) a = m; else b = m; } return (a + b) / 2; };
// 拍 → 秒
MO.beat = (n, bpm = 120) => n * 60 / bpm;
// 揭开那一帧落在拍上:段起点 = 小节线 − 揭开点 × 转场时长(y5:zoom 揭开点 .55、色带 .6、push 到 90% 位移在 .58)
MO.onBeat = (barTime, revealP, trDur) => barTime - revealP * trDur;
})();