figma-storyboard-animation

Storyboard Figma → conception de mouvement de scène

Un storyboard est une série de trames statiques 1920×1080. Votre travail consiste à produire une scène dont la chronologie se déplace entre elles. La majeure partie du mouvement est déjà dans le design — récupérez-le plutôt que de l'inventer.

Vous ne pouvez pas exécuter de code ? Partout où cette recette dit "créez un script de génération", construisez la scène via picsart_scene_patch à la place et fixez les mêmes invariants avec picsart_scene_query_layout après chaque modification (voir Commandes ci-dessous). La méthode est identique — seule la surface d'exécution diffère.

Le flux

1. Lisez l'arborescence une fois — si l'utilisateur a partagé le storyboard via son connecteur Figma, lisez l'arborescence des trames de la page une fois : elle renvoie chaque trame, calque, nom et boîte. Tout ce qui suit en est dérivé. Ne parcourez pas le board trame par trame pour explorer.
2. Planifiez les beats — écrivez la table des beats avant de créer (ci-dessous).
3. Extrayez chaque élément comme son propre calque du design partagé par l'utilisateur : construisez une géométrie de forme modifiable à partir de ses mesures source et utilisez picsart_scene_import_figma_paint pour la peinture CSS de remplissage, d'ombre ou de dégradé sur un calque existant. Gardez le texte vivant. La conversion automatique de nœuds de forme n'est pas exposée ici. Utilisez une image uniquement pour un traitement non pris en charge ou une source véritablement non superposée ; voir extraction.
4. Construisez la scène à partir de la géométrie, et fixez chaque règle. Là où vous pouvez exécuter du code, créez un script de génération (pas du JSON écrit à la main) pour que chaque règle devienne une assert ; là où vous ne pouvez pas, construisez-la via picsart_scene_patch et fixez les mêmes invariants avec picsart_scene_query_layout. La géométrie provient des métadonnées, jamais d'une estimation visuelle.
5. Vérifiez numériquement, puis exportez.

Les étapes 3 à 5 s'exécutent une fois par scène, dans l'ordre — cette boucle est la méthode.

Une trame statique

Lorsque la demande est une seule trame (une image fixe, une image de boutique, une carte), il n'y a pas de storyboard. Sautez les beats et construisez cette trame comme une scène figée :

1. Lisez la trame sélectionnée via le connecteur Figma partagé par l'utilisateur. Sa taille est composition.width et height, son remplissage est composition.background, et une duration courte (1) suffit.
2. Un calque par enfant, dans l'ordre de peinture (le premier enfant de l'arborescence en bas). La position d'un calque est le CENTRE de sa boîte dans la trame, [x + width/2, y + height/2] : un calque tourne et se met à l'échelle autour de son centre. Vérifiez un enfant imbriqué par rapport à la trame : certains groupes stockent les enfants par rapport au groupe (references/figma-extraction.md).
3. Chaque enfant dans le médium qui le garde modifiable : créez la géométrie de la forme, puis appliquez sa peinture CSS via picsart_scene_import_figma_paint, le texte en tant que texte vivant, et chaque remplissage IMAGE comme un calque média sur son bitmap d'origine — jamais l'export du nœud, qui aplatit la transparence sur l'arrière-plan de la trame — par son scaleMode (FILL→cover, FIT→contain, CROP→cover + crop, TILE→non exprimable ; le tableau et les calculs de recadrage sont dans references/figma-extraction.md, "Remplissages d'images"). Téléchargez chaque image d'abord ; une URL d'actif Figma expire.
4. Un groupe local qui se masque ou s'estompe comme un seul est généralement un calque de composition en ligne. Utilisez une référence de scène lorsqu'il s'agit intentionnellement d'un composant réutilisable, appartenant séparément.
5. Vérifiez avec des nombres, puis une image complète. picsart_scene_query_layout à 0 : chaque box à un pixel près de sa boîte Figma. Une image de premier niveau sans crop porte drawn : sa boîte et sourceCrop tels que le design les montre. Une image à l'intérieur d'un groupe lit clippedBox, la partie que son groupe laisse visible. Ensuite, un picsart_scene_contact_sheet avec des times explicites et une resolution égale aux dimensions de la composition : une vignette supprime les lignes de 2 px et le petit texte.

Calques, pas écrans

La scène est un composite de calques mobiles, jamais un montage d'écrans plats. Un design se présente sous forme de calques ; gardez-les séparables pour que chacun puisse bouger indépendamment — c'est toute la raison de construire une scène plutôt que de fondre des captures d'écran.

• Reconstruisez, ne pixellisez pas. Construisez une géométrie de shape modifiable à partir du design partagé par l'utilisateur. Appliquez la peinture CSS à ce calque existant avec picsart_scene_import_figma_paint. L'importation complète de nœuds de design Figma n'est pas prise en charge ici. Gardez les coins, les chemins et le placement modifiables et le texte vivant. Aplatir ceux-ci en PNG ou SVG empêche l'animation indépendante de leurs parties.
• Lorsque vous prenez des actifs d'un design partagé via le connecteur Figma de l'utilisateur, ne prenez jamais une trame parent à la place de ses enfants. Les enfants sont ce qui bouge.
• L'aplatissement en image est la solution de repli uniquement — pour une source véritablement non superposée (un actif pixellisé, pas d'accès aux calques). Lorsque vous reculez, dites-le clairement.
• L'habitude "exporter un nœud pour une apparence fidèle" dans references/figma-extraction.md concerne la fidélité d'un seul élément que vous avez déjà choisi d'importer en entier. Ne généralisez pas cela en "pixelliser tout".

Construire scène par scène, dans l'ordre

Ceci est plus important que toute règle individuelle ci-dessous. Ne créez pas toute la chronologie et ne la présentez pas. Ne prototypz pas non plus un beat intermédiaire frappant en premier : le mouvement conçu au milieu n'a rien à quoi se joindre, donc il est jeté.

Commencez par la première trame et avancez. Par scène :

1. Divisez par unités de mouvement sémantiques, pas seulement par calques modifiables. Un contrôle, son étiquette et son icône partagent normalement un seul propriétaire de placement. Ajoutez un mouvement local enfant uniquement pour un changement d'état délibéré. L'immobilité est une hiérarchie utile et un temps de lecture, pas un défaut. Pour le regroupement, la croissance des panneaux et le réécoulement, utilisez linked-element-motion (récupérez avec picsart_scene_recipe, nom linked-element-motion).
2. Créez son mouvement en ajoutant à ce qui est déjà construit — en annexant au générateur là où vous pouvez exécuter du code, en corrigeant la même scène là où vous ne pouvez pas. Ne recommencez jamais : les constantes et les vérifications de chaque beat précédent restent, donc un nouveau beat ne peut pas en casser silencieusement un autre.
3. Rendez ce beat et montrez-le en vidéo sur sa propre fenêtre. Le mouvement ne peut pas être examiné dans une image fixe ou une planche contact.
4. Prenez les directives et re-rendez. Attendez-vous à plusieurs passages sur un beat. Les directives arrivent sous forme de qualités, pas de nombres — "plus vif", "découpler les tuiles", "cet élément fait du bruit, supprimez-le" — et chacune correspond au timing, à l'échelonnage ou à l'inventaire des éléments, pas à un nouveau design.
5. Ensuite, concevez la jonction vers la scène suivante comme une étape explicite distincte. Une scène n'est pas terminée quand elle a l'air correcte ; elle est terminée lorsque sa sortie et l'entrée de la scène suivante sont convenues. La jonction est la partie que le storyboard ne contient pas, donc c'est là que les directives sont les plus spécifiques ("zoom arrière, puis la scène suivante arrive de la caméra, pas zoomée") et où deviner est le plus coûteux.

Lorsque l'itération autonome est autorisée, utilisez-les comme des portes de vérification internes et montrez des jalons significatifs plutôt que de demander une approbation pour chaque beat. Pour les grandes chronologies, utilisez large-scene-assembly (récupérez avec picsart_scene_recipe, nom large-scene-assembly) pour garder les composants modifiables indépendamment.

Passez ensuite à l'étape suivante. Tenez la table des beats à jour au fur et à mesure — c'est l'enregistrement de ce qui a été convenu, et la chronologie est longue avant la fin de la construction.

Lire le storyboard

• L'ordre x du canevas est l'ordre temporel. Les trames sont disposées de gauche à droite ; triez par x, pas par nom.
• Les noms de trames mentent ; l'ordre non. Les noms en double sont courants (un designer duplique une trame et oublie de renuméroter). Comptez les trames par rapport aux nombres avant de conclure qu'il en manque une.
• Les trames portant le même nom sont généralement des poses A→B d'un seul beat. Différenciez leurs ensembles de calques : mêmes enfants, transformations différentes signifie que le designer a encodé le mouvement comme un delta. Ce mouvement est mesurable, pas une décision de conception que vous devez prendre.
• Lorsque le design arrive via le connecteur Figma de l'utilisateur, capturez les trames une par une : un board entier capturé en une fois est beaucoup plus large que haut et se réduit à une fine bande.

Ce qui est vraiment à vous de concevoir : la pause, l'assouplissement, et les jonctions entre trames non appariées.

Pour chaque jonction non appariée, utilisez motion-scene-continuity (récupérez avec picsart_scene_recipe, nom motion-scene-continuity) pour nommer la relation sémantique et choisir un calque persistant, une transition de catalogue, un cut sec, un fondu enchaîné, ou une transition personnalisée avant d'écrire les mécanismes. Ce flux de travail de storyboard possède encore la récupération du mouvement impliqué par les trames de conception appariées ; la continuité possède uniquement la relation et la représentation à leurs limites.

Résoudre les transformations, ne pas les choisir

Une échelle uniforme s autour d'un pivot inconnu C mappe p → C + s(p − C). Donc une paire de coordonnées correspondante épingle le pivot :

C = (p2 − s·p1) / (1 − s)

Prenez s du rapport de taille de n'importe quel élément entre les deux trames, résolvez C, puis vérifiez-le contre un deuxième élément indépendant. Un accord à une fraction de pixel signifie que vous avez la transformation réelle du designer ; un désaccord signifie que l'élément a bougé tout seul et nécessite son propre traitement.

Écrivez la table des beats — deltas mesurés, pivot résolu, allocation de temps. Neuf beats de chorégraphie avec des nombres ne survivront pas au défilement arrière, et vous voudrez les comparer aux rendus.

Règles de mouvement

Détails complets et chiffres travaillés : references/motion-rules.md. Les règles qui décident si un beat se lit correctement :

• Rigide vs indépendant. Échelonnez la position/l'échelle uniquement pour des objets véritablement indépendants (tuiles de grille, autocollants). Une carte, un verrouillage, ou tout objet avec des parties doit partager une horloge de géométrie, ou ses parties dérivent hors de registre en plein vol. Mettez plutôt l'échelonnage sur le fondu.
• Un fondu doit être co-terminal avec son mouvement pour se lire comme un seul geste. Si le fondu se termine avant le déplacement, l'œil voit deux événements. Faites correspondre aussi les courbes d'assouplissement.
• Sur un rendu de trame plat, un zoom avant est sûr ; une translation ne l'est pas. Le zoom avant n'expose jamais un bord ; la translation expose le bord arrière de l'image elle-même.
• Trajet d'entrée de taille pour que la partie de tête commence juste en dehors du canevas — trajet ≥ canvas − leftmost_x. Trop peu et elle commence à l'écran ; beaucoup trop, c'est du temps mort.
• Les sorties accélèrent (ease_in). Donnez à deux objets des durées différentes pour une accélération différentielle.
• Le chrome de sélection est exclusif — jamais deux marqueurs à la fois, et il ne doit pas survivre à son beat. Si les étapes d'éléments chevauchent leurs durées, un élément perd sa sélection en pleine manipulation.

Faits de rendu qui changent la création

• L'opacité se compose en lumière linéaire. Elle ne met pas à l'échelle la valeur sRGB encodée. Pour atteindre une luminosité mesurée, convertissez via gamma : opacity = linear(cible) / linear(source).
• L'opacité n'est qu'un contrôle d'obscurité sur un fond noir. Sur un fond clair, elle rend un sujet sombre plus clair à mesure que le fond transparaît. Un véritable assombrissement nécessite un cache sombre par-dessus, pas l'opacité sur le sujet.
• anchor donne un pivot non centré (pixels locaux du calque à partir du coin supérieur gauche du calque). Utilisez-le pour une mise à l'échelle pivotée sur un coin — par exemple, une mise à l'échelle autour du coin supérieur gauche d'une boîte de sélection pour qu'elle se lise comme un glissement de la poignée inférieure droite. Ne simulez pas les pivots avec des images clés de position.
• L'animation de texte par caractère est intégrée. Le content.animations[] d'un calque de texte est un animateur After Effects + sélecteur de plage : basedOn: "character", plus randomizeOrder/randomizeSeed pour le scintillement. Empilez les entrées sur différentes graines pour qu'elles ne battent pas à l'unisson. La plage active est [start + offset, end + offset] : une fenêtre étroite gare son bord éloigné à la fin du texte à offset: 1 − end, ou efface chaque glyphe à offset: 1 − start (1 − w / 1 uniquement lorsque start est 0 — ne les utilisez pas autrement). Une fenêtre COMPLÈTE (start:0, end:1) avec une forme de rampe est plutôt une rampe exactement aussi large que le texte : balayez offset −1 → 1 et chaque glyphe s'assouplit sur la moitié du balayage, échelonné par position plutôt que de basculer tous en même temps — voir textAnimationAuthoring.rawSelector dans picsart_scene_capabilities pour les chiffres travaillés.
• Le SVG en ligne doit être encodé en URL avec # encodé en pourcentage. Un # brut commence un fragment d'URI et tronque le SVG à sa première couleur hexadécimale.
• Mesurez l'assouplissement, ne faites pas confiance aux noms prédéfinis. Échantillonnez la valeur à 25 %/75 % d'une fenêtre d'image clé et confirmez que la courbe est celle que vous souhaitiez.

Vérifier numériquement

L'examen visuel d'une planche contact réduite produira des fausses alarmes — elle signale régulièrement des erreurs de position que la mesure réfute. Comparez les trames en pleine résolution, ou mesurez.

• picsart_scene_validate vérifie uniquement la structure. Elle réussit sur une scène dont les calques ne rendent rien.
• picsart_scene_query_layout résout les boîtes sans rendu — utilisez-la pour confirmer la géométrie par rapport aux nombres Figma avant de dépenser un rendu. Elle est uniquement géométrique : une boîte résolue ne dit rien sur la manière dont le contenu se décode.
• Pour trouver les lacunes où rien n'est sur le canevas, regardez les temps suspects avec picsart_scene_contact_sheet avec times: [t1, t2, …] et resolution définie sur composition.width et composition.height de la scène. Une trame ne contenant qu'un petit logo peut sembler vide à première vue — vérifiez-la avant de l'appeler une lacune.
• Là où vous pouvez exécuter du code, mettez les invariants dans le générateur comme des assertions (pivots résolus concordants, trajet assez long, une sélection à la fois, limites saines). Elles détectent les régressions qu'une trame figée cache.

Commandes

Là où vous pouvez exécuter du code, maintenez le même générateur et les mêmes auto-vérifications. Sinon, utilisez des modifications picsart_scene_patch limitées. Validez avec picsart_scene_validate, interrogez la géométrie des événements avec picsart_scene_query_layout, et inspectez les images fixes en pleine résolution en utilisant picsart_scene_contact_sheet avec times: [t1, t2] (au plus 8 fois par appel) et resolution définie sur composition.width et composition.height de la scène. Inspectez la vidéo exportée en continu pour les affirmations de mouvement.

Sans le générateur...