Ressorts (étape du cours 08)
Les easings bon marché passent de A à B sur une courbe fixe. Un mouvement avec masse accélère, dépasse légèrement et s'installe. Les
ressorts dans lib/motion.js sont des réponses en forme fermée, donc ils restent une fonction pure du temps : l'image 812 se rend
sans simuler les images 0 à 811, et seek(t) reste déterministe.
Importez depuis lib/motion.js du projet de film (chemins relatifs au fichier : ../lib/motion.js depuis film/film.js,
../../lib/motion.js depuis film/scenes/*.js). Les numéros de préréglages complets se trouvent dans
${CLAUDE_SKILL_DIR}/references/presets.md (references/presets.md).
1. API
| Fonction | Retourne | Notes |
|---|---|---|
sp(t, preset = 'default') | 0 à 1 | l'appel quotidien ; t est le temps depuis le déclenchement (lt - 0.2), 0 avant le déclenchement |
spring(t, k, d, m = 1) / springVel(...) / springPV(...) | x / v / [x, v] | forme brute k/d ; exact sous-, critique- et sur-amorti |
SPRINGS | { snappy, default, heavy, playful } | paires {k, d}, voir le tableau ci-dessous |
resolveSpring(p) | {k, d} | accepte un nom de préréglage, {k, d} ou {duration, bounce} partout où un ressort est attendu |
springFromFeel({ duration, bounce }) / feelFromSpring({k, d}) | {k, d} / {duration, bounce} | paramètres adaptés aux designers (convention Apple) |
track(t, keys, spring = 'default') / trackVel(...) | valeur / vélocité | keys = [[time, value], ...] trié ; un ressort par changement, additionné ; un troisième élément optionnel remplace le ressort pour ce changement ([2.4, 420, 'heavy']) |
loopTrack(t, keys, dur, spring = 'default', cycles = null) | valeur | boucles sans couture. Les temps des clés sont dans un cycle, 0..dur, et ne sont pas enroulés (en dehors, une erreur est levée). La dernière valeur doit être égale à la première. Une clé exactement à dur est le changement à la jointure |
indicator(t, stops, { width = 120, lead = 'snappy', trail = {k: 140, d: 22} }) | { left, right } | indicateur d'onglet qui s'étire : les bords sur des ressorts différents |
swapAlpha(t, tIn, tOut, { inDelay = 0.08, inDur = 0.12, outLead = 0.1, outDur = 0.1 }) | 0 à 1 | texte dans une boîte en morphing : entrée après le début du morph, sortie avant le suivant |
stagger(i, step = 0.03) | secondes | délai pour l'élément i |
stepTime(t, rate = 12) | t par paliers | "sur les deux" uniquement pour les dessins, jamais pour la caméra ou les fondus globaux. Passez c.frameLt (ou c.frameT), le temps de l'image de sortie, pour une coupe franche entre les paliers ; c.t / lt sont des temps sous-image et mélangent les deux paliers sur les images où un palier change |
loopT(t, dur) | t enroulé dans [0, dur) | enroulement temporel ; pas suffisant seul pour les ressorts (utilisez loopTrack) |
settleTime(spring, eps = 0.01) / overshoot(spring) | secondes / fraction | planifiez les arrêts et les points de coupe |
easeOutCubic, easeInOutCubic | 0 à 1 | uniquement pour les fondus non physiques (opacité) ; jamais pour les choses qui bougent |
2. Préréglages
| Préréglage | k / d | Rapport d'amortissement | Dépassement | Stabilisation (1%) | Utilisation |
|---|---|---|---|---|---|
snappy | 320 / 30 | 0.839 | 0.79% | 0.24 s | boutons, interrupteurs, bords d'attaque, curseur |
default | 170 / 26 | 0.997 | 0 | 0.51 s | cartes, conteneurs, caméra |
heavy | 90 / 20 | 1.054 | 0 | 0.78 s | grands caractères, objets 3D, logos |
playful | 220 / 14 | 0.472 | 18.6% | 0.59 s | mascottes, autocollants |
Règle maison : tout petit dépassement sur l'UI (snappy), aucun sur le texte (default ou heavy pour l'échelle et la position du texte héroïque),
playful uniquement là où le dépassement est la blague. Nombres complets, conversions de sensation et formules :
references/presets.md.
3. Recettes
À l'intérieur d'une scène draw(g, lt, c) : lt est le temps depuis le début de la scène, c.t le temps du film, c.L la mise en page,
c.brand les jetons de marque, c.grid la grille de beats, c.film.dur la durée du film (c.dur est la durée de la scène). Avec
le flou de mouvement activé, c.t et lt sont le temps sous-image en cours de rendu (le flou de mouvement se fait tout seul) ; c.frameT / c.frameLt
sont le temps de l'image de sortie et c.frame son index, identiques pour chaque sous-image. Les extraits supposent
const { t, L } = c; et les imports depuis lib/motion.js, lib/draw.js et lib/rng.js.
Entrée unique (déclenchement 0.15 s dans la scène) :
const s = sp(lt - 0.15, 'snappy');
withTransform(g, { x: L.cx, y: lerp(L.cy + 80 * L.u, L.cy, s), s: lerp(0.92, 1, s) }, () => { /* dessiner */ });
Celui-ci commence visible : la position et l'échelle sont à leurs valeurs de départ pendant que le ressort est à 0, donc l'image 0 n'est pas vide.
Elle serait vide si s pilotait la seule chose à l'écran via l'opacité ou un cache. Pour une scène qui est à l'écran à l'image
0 (l'accroche), ouvrez en pleine action en déclenchant le ressort AVANT la scène : sp(lt + 0.3, 'snappy'), ou
kinetic(g, 'FAIS-LE BOUGER.', x, y, lt + 0.3, { ... }), ou kinetic(..., { delay: -0.3 }). À lt = 0, le texte est alors à 0.3 s
dans son ascension au lieu de ne pas être dessiné (kinetic ignore chaque glyphe dont le ressort est encore à 0). La critique signale une image 0
vide comme une P0 (l'image 0 est presque vide).
Une valeur avec plusieurs cibles (ne redémarrez jamais un ressort ; ajoutez-en un par changement) :
// curseur x en px logique : repose à 200, bouge à 1.0 s et 2.4 s, revient à 3.6 s
const cx = track(t, [[0, 200 * L.u], [1.0, 640 * L.u], [2.4, 420 * L.u], [3.6, 200 * L.u]], 'snappy');
Le temps de la première clé est ignoré : sa valeur est la valeur de repos depuis le début. Chaque changement après cela démarre son propre ressort à son propre moment, et la somme reste continue en position et vélocité même lorsqu'une nouvelle cible arrive avant que la dernière ne se soit stabilisée.
Morphing d'une seule forme (le conteneur ne coupe jamais ; chaque propriété est une piste sur les mêmes temps de clés) :
const K = [0, 1, 2, 3].map((n) => c.grid.bar(n)); // changements d'état sur les temps forts, depuis la grille
const w = track(t, [[K[0], 320], [K[1], 120], [K[2], 760], [K[3], 320]].map(([k, v]) => [k, v * L.u]));
const h = track(t, [[K[0], 96], [K[1], 120], [K[2], 480], [K[3], 96]].map(([k, v]) => [k, v * L.u]));
const r = track(t, [[K[0], 48], [K[1], 60], [K[2], 32], [K[3], 48]].map(([k, v]) => [k, v * L.u]));
fillRoundRect(g, L.cx - w / 2, L.cy - h / 2, w, h, Math.max(0, r), c.brand.colors.fg);
withAlpha(g, swapAlpha(t, K[1], K[2]), () => ring(g, L.cx, L.cy, 36 * L.u, sp(t - K[1] - 0.1), { color: c.brand.colors.accent }));
Couleurs : ressortez une progression de 0 à 1 et mélangez avec mixColor(a, b, p) depuis lib/draw.js (elle sature p), ou, pour une couleur
avec plusieurs cibles, pistez chaque canal et saturez à 0 à 255. Le rayon et les tailles qui peuvent dépasser en dessous de zéro nécessitent
Math.max(0, ...).
Indicateur d'onglet qui s'étire entre les arrêts :
const { left, right } = indicator(t, [[0, x0], [1.5, x1], [3.0, x2]], { width: 140 * L.u });
fillRoundRect(g, left, y, right - left, 6 * L.u, 3 * L.u, c.brand.colors.accent);
Boucle sans couture (la valeur et sa vélocité correspondent à travers la jointure) :
// boucle de 6 s : a au repos, b à 1.5 s, c2 à 3 s, retour à a à 4.5 s
const x = loopTrack(t, [[0, a], [1.5, b], [3, c2], [4.5, a]], c.film.dur, 'default');
// la même boucle avec le retour comme changement à la jointure : la dernière clé se trouve exactement à dur
const y = loopTrack(t, [[0, a], [1.5, b], [3, c2], [c.film.dur, a]], c.film.dur, 'default');
Règles de loopTrack (vérifiées par rapport à lib/motion.js) :
| Règle | Détail |
|---|---|
les temps des clés restent dans 0..dur | ils sont relatifs au cycle et jamais enroulés ; un temps en dehors lève loopTrack: la clé <i> au temps <t> est en dehors de 0..<dur> (un tout petit peu après dur suite à l'arithmétique de la grille est toléré) |
| la première clé est la valeur de repos | son temps est ignoré (elle doit quand même être dans 0..dur) ; la valeur est celle à partir de laquelle le premier changement commence |
| la dernière valeur est égale à la première | sinon elle lève la dernière valeur (...) doit être égale à la première (...) |
une clé à dur est le changement à la jointure | le ressort commence à t = 0 du cycle suivant : l'image 0 (= image dur) montre la valeur avant la jointure et ease vers la première valeur. Cela équivaut à écrire [[0, pre], [0, post], ...]. Écrivez le changement à la jointure une fois, à 0 ou à dur |
un changement juste avant dur peut encore bouger à l'image 0 | la somme est exactement périodique, donc la position et la vélocité correspondent à travers la jointure quelle que soit la synchronisation. Pour ouvrir sur une image fixe, gardez le dernier changement au moins settleTime(preset) avant dur (0.51 s pour default) |
| cycles | le nombre de cycles précédents additionnés suit le temps de stabilisation et la dernière clé, donc les clés tardives sont sûres ; cycles le remplace |
Un simple loopT plus track saute à la jointure car les ressorts déclenchés vers la fin bougent encore à t = 0.
loopTrack additionne aussi les ressorts des cycles précédents (assez pour se stabiliser) et donne, avec les clés
[[0, 0], [2, 100], [4, 40], [6, 0]] et dur 6, les valeurs 0.001 / 99.997 / 40.002 à t = 1 / 3 / 5. Vérifiez la jointure
dans out/review/<fmt>/loop.png après npm run critique : |last - first| devrait ressembler à un pas normal et
|end - first| (l'état final non enroulé) devrait être noir.
Apparitions échelonnées (graines par élément, jamais un flux partagé) :
for (let i = 0; i < n; i++) {
const r = rngFor('tile', i);
const s = sp(lt - stagger(i, 0.035) - range(r, 0, 0.06), 'playful');
// dessiner la tuile i mise à l'échelle par s
}
Texte cinétique : kinetic(g, str, x, y, lt, { size, family, weight, color, spring: 'snappy', stagger: 0.035, rise: 0.6, by: 'char' | 'word', mask, delay, alpha, align, baseline, style, tracking }). family par défaut à brand.fonts.display et weight au poids le plus proche
que la famille a enregistré, donc laissez les deux de côté sauf si le design nécessite une autre police. mask: true coupe la course à sa
boîte de ligne pour que les glyphes s'élèvent depuis derrière un bord au lieu de fondre ; delay décale toute la course (négatif ouvre en pleine action).
Pour le texte héroïque, passez spring: 'default' ou 'heavy' lorsque l'ascension est assez grande pour que le dépassement de 0.8% se voie.
Copie multi-lignes : wrapText(g, text, maxW, font(size, family)) renvoie les lignes (ne coupe jamais à l'intérieur d'une syllabe Hangul) ;
dessinez-les avec y + i * 1.2 * size ou plus et donnez à chaque ligne son propre delay.
Dessins sur les deux (aspect dessiné à la main) : const td = stepTime(c.frameLt, 12) pour l'animation propre du dessin (le temps de l'image de
sortie, donc chaque palier est une coupe franche même avec le flou de mouvement activé) ; gardez les mouvements de caméra, les fondus et l'UI
sur lt continu, ou les panoramiques font un pas 12 fois par seconde et sont perçus comme un décalage.
4. Refactoriser un film complet
Utilisez le modèle d'invite dans le projet : lisez prompts/refactor-springs.txt et suivez-le (ou collez-le comme tâche). Il
remplace chaque interpolation linéaire et easing standard qui déplace quelque chose par des préréglages, track(), loopTrack(),
indicator() et swapAlpha(), garde le timing, et rapporte chaque changement. Ensuite :
npm run lint(doit être propre).npm run stillsetnode tools/critique.mjs --strip-at <t>au moment le plus chargé :strip.pngmontre 12 images consécutives, ce qui expose les pops, les redémarrages et les glissements qu'une planche contact cache.- Enregistrez le changement dans le prochain tour de critique (
/motion-studio:critique-loop).
5. Erreurs à attraper
| Erreur | À quoi ça ressemble | Correction |
|---|---|---|
redémarrer un ressort à chaque cible (sp(t - tNew) depuis l'ancienne valeur) | la vélocité saute à 0, un coude visible | track() avec toutes les cibles |
| sommes artisanales de ressorts avec leurs propres valeurs de départ | sauts quand deux changements se chevauchent | un track() par valeur ; les préréglages par changement vont dans le troisième élément de la clé |
loopT seul sur une valeur de ressort | saut à la jointure | loopTrack() avec des clés dans 0..dur et dernière valeur == première |
| dépassement sur du texte | le texte vacille, semble bon marché | default / heavy pour le texte |
playful sur le chrome de l'UI | interface de jouet | snappy pour l'UI |
| ressort uniquement sur l'opacité alors que la position est linéaire | les fondus sont beaux, les glissements sont bon marché | ressortez la position ; l'opacité peut suivre easeOutCubic |
| tout sur le même préréglage et le même délai | mécanique, pas de hiérarchie | commencez par snappy, suivez avec default, stagger() le reste |
Suite : /motion-studio:conception-sonore pour verrouiller le mouvement sur le beat, puis /motion-studio:boucle-de-critique.