Guides pratiques › Créer des animations

Guides pratiques

Animations

Une animation est une image animée pour une diapositive, écrite dans le modèle. Elle est dessinée par l'un des modèles d'animation d'Arche, et son contenu peut faire référence au modèle : parts, constantes, machine à états, scénario. Quand la conception change, l'image change avec elle. Les histoires d'Arche fonctionnent de la même façon : elles pointent vers le modèle au lieu d'en montrer une capture d'écran.

Une première animation#

Un message qui va d'un capteur au cloud, en passant par une passerelle :

const HOPS: int32 = 4

component Node

system Net {
  part sensor:  Node
  part gateway: Node
  part cloud:   Node
}

animation v-path "From the sensor to the cloud" from flow {
  stops [Net.sensor, Net.gateway, Net.cloud]   // each stop shows the part's name
  speed HOPS * 55                              // a formula: worked out on the slide
  height 160
  group "Stories"
  duration 4s
}
Diagramme : Net
Ce qu’archec dessine depuis ce code : Net
Essayer

from flow nomme le modèle d'animation. stops et speed sont les données qu'il lit. height, group et duration sont les propriétés propres du visuel.

Prévisualisez-la dans un navigateur, sans Arche :

archec animation preview main.arche v-path -o path.html --open
✓ v-path → path.html

Ou construisez le projet Arche :

archec build main.arche -o proj
✓ 10 files → proj (net.yaml, models.yaml, templates.yaml, variables.yaml, simulation.yaml, menu.yaml, visuals/v-path.html, visuals/v-path.yaml, visuals.yaml, layout.yaml)

archec build écrit les mêmes fichiers que l'éditeur d'animations d'Arche : l'application ouvre donc l'animation comme l'une des siennes.

Fichier Contenu
visuals/v-path.html Le dessin : le code du modèle d'animation, inchangé.
visuals/v-path.yaml Le contenu qu'il dessine. Le dessin le lit sous la forme arche.data.
visuals.yaml Son entrée : nom, hauteur, groupe, durée, paramètres qui lui sont transmis.

visuals/v-path.yaml contient les noms des parts et la formule :

stops:
  - label: sensor
    x: 80
  - label: gateway
    x: 320
  - label: cloud
    x: 560
speed: ${HOPS * 55}

Modèles d'animation#

Les modèles d'animation sont ceux d'Arche : 72, répartis en 14 catégories. Les catégories sont : bases, flux (un message le long d'un chemin, des pipelines, des séquences, un producteur et un consommateur autour d'un tampon, des nouvelles tentatives), temporel (chronologies, formes d'onde, budgets de latence, plannings), machines à états (un parcours, un cycle de vie, des vérifications qui passent et qui échouent, un basculement), signaux, données, interfaces, FPGA, matériel, géométrie, mission, naval, antenne et communications.

archec animation list               # the gallery, by category
archec animation list Timing        # one category
archec animation show flow          # what it draws, the data it reads, a starter block
archec animation new sequence v-boot --into app/visuals.arche

archec animation show flow affiche :

flow — Message along a path (Flow)
A dot travelling between boxes — "who sends what to whom", in one line.

Data it reads
  stops  a list of { label, x } — The boxes the message crosses, left to right.
  speed  a number — px per second (sample: 220)

Starter
animation v-flow "Message along a path" from flow {
  // The boxes the message crosses, left to right.
  stops [{ label: Terminal, x: 80 }, { label: PS, x: 320 }, { label: PL, x: 560 }]
  // px per second
  speed 220
}
  • show liste chaque donnée que le modèle d'animation lit, sa forme, et ce qu'en dit l'exemple fourni avec le modèle.
  • new écrit un bloc de départ. Ses données sont celles de l'exemple, écrites dans le langage. Il se construit tel quel, et dessine la même chose que l'image du modèle dans la galerie, jusqu'à ce que vous le modifiiez.

Le modèle d'animation est nommé dans l'en-tête (from flow) ou par une propriété (template flow). archec embarque la bibliothèque de modèles d'Arche (vendor/animations.js). Un modèle ajouté à l'application est vérifié ici dès qu'archec est reconstruit à côté.

Le contenu, et le modèle#

Les propriétés propres du visuel sont height, group, comment, duration, fps, params, tags, variants et data-file. (data-file indique où le contenu est écrit, quand ce n'est pas visuals/<id>.yaml.) Toute autre propriété est du contenu pour le modèle d'animation. Elle s'écrit comme le langage écrit les valeurs :

Écrit Écrit pour le dessin
step 1.4, ok true, title "Gain per channel" tel quel
stages Parse, Compute, Write une liste (comme [Parse, Compute, Write])
{ label: PS, x: 320 } un enregistrement
Net.gateway : un composant, un système, une exigence… son nom, tel que l'application l'affiche
HOPS : une constante ou un paramètre ${HOPS} : l'application lit le projet sur la diapositive
HOPS * 8 ${HOPS * 8}, calculé de la même façon
un mot seul qui ne nomme rien le mot

Ainsi, une diapositive suit la conception. Renommez la part, et l'arrêt affiche le nouveau nom. Modifiez HOPS, et le point va plus vite. Un chemin pointé qui ne nomme rien donne un avertissement : c'est plus probablement une faute de frappe qu'une légende.

Une liste de noms là où le modèle attend des enregistrements. flow lit stops: [{ label, x }], mais stops [Net.sensor, Net.gateway, Net.cloud] suffit.

  • Chaque nom devient le label de l'enregistrement.
  • Les autres champs viennent de l'exemple du modèle.
  • Une position que l'exemple répartit (80, 320, 560) est répartie de la même façon, quel que soit le nombre d'éléments.
  • Tout autre nombre est pris dans l'élément de l'exemple situé à la même place.

Une machine à états. machine <part> remplit ce que lit un modèle d'animation de machine à états :

  • states. Dans le modèle states, ils sont dans l'ordre où ils sont atteints. Dans lifecycle, chaque état est placé dans une colonne selon le nombre de transitions qui le séparent de l'état initial.
  • edges : les transitions et leurs déclencheurs. Un arc est courbé quand deux états vont l'un vers l'autre dans les deux sens.
  • walk : toutes les transitions, chacune empruntée une fois là où c'est possible.
animation v-life "Life cycle" from lifecycle { machine Home.door; step 1.5 }

Un scénario. scenario <id> (ou scenario <id>.<sequence>) remplit le modèle sequence. Les participants deviennent les lignes de vie (actors). Ses étapes deviennent les flèches (messages), chacune étiquetée avec son message.

animation v-boot "Boot" from sequence { scenario boot }

Ce qui est écrit dans l'animation l'emporte sur ce que donne le modèle.

Un dessin personnalisé#

code "visuals/beam.html" est une animation dessinée par votre propre HTML. Le chemin est relatif au fichier dans lequel il est écrit.

  • Elle s'exécute dans le même cadre isolé qu'un modèle d'animation, et reçoit ses données de la même façon.
  • Elle est copiée dans le projet à côté des autres.
  • params liste les paramètres qui lui sont transmis, sous la forme arche.params. Un dessin qui lit un paramètre qui ne lui est pas transmis (arche.params.ELEMENTS) donne un avertissement, car la valeur arriverait indéfinie.
  • Avec un template en plus, le modèle indique quelles données le code lit.

Ce qui est vérifié#

Code
animation-template le modèle d'animation n'existe pas (avec le plus proche), ou il n'y a ni modèle ni code
animation-data une donnée que le modèle ne lit pas ; une valeur de la mauvaise forme (un mot là où un nombre est attendu, un champ qu'un enregistrement n'a pas) ; un chemin qui ne nomme rien ; une formule sur des noms qui ne sont ni des constantes ni des paramètres
animation-binding machine ou scenario ne nomme rien, ou le modèle n'en dessine rien
animation-param params nomme quelque chose qui n'est ni une constante ni un paramètre ; le dessin en lit un qui ne lui est pas transmis
animation-visual une étape d'histoire animate quelque chose qui n'est ni un visuel ni une animation
animation-code le fichier code n'existe pas

Dans une histoire#

story tour "The tour" {
  step s1 "The door" { text "The door opens and closes."; animate v-life; dwell 8s }
}
  • animate fournit les visuals de l'étape. Ils sont vérifiés par rapport aux visuels et aux animations du projet.
  • dwell est la durée pendant laquelle l'étape reste affichée quand l'histoire se joue toute seule.

En voir une sans Arche#

archec animation preview main.arche v-boot --open   # a page that plays it
archec animation render main.arche v-boot -o boot.gif
archec story export main.arche tour --lang en -o tour.html
  • preview écrit une page qui joue l'animation dans un cadre isolé, exactement comme une diapositive. Ses ${…} sont calculés à partir des constantes et des paramètres. La page fonctionne en thème clair ou sombre. Sans identifiant, elle prévisualise toutes les animations.

  • render enregistre un GIF, comme le fait l'export .pptx d'Arche : le dessin peint ses propres images. Il faut Chrome ou Chromium sans interface (--chrome, ou $CHROME). Il enregistre un cycle de la duration (3 s s'il n'y en a pas), à son fps (10 s'il n'y en a pas).

  • story export écrit toute l'histoire dans un seul fichier, pour quelqu'un qui n'a pas Arche. Il contient :

    • les étapes, dans la langue demandée ;
    • les animations, en mouvement ;
    • les images, et le schéma de blocs d'une étape qui porte sur un système ;
    • les notes (touche n).

    Appuyez sur p (ou ajoutez #play à l'adresse) pour la jouer toute seule, chaque étape pendant son dwell. Rien n'est chargé depuis le réseau.

Dans VS Code#

  • La vue Animations liste les animations du projet (cliquez sur l'une d'elles pour la prévisualiser) et les modèles par catégorie (cliquez sur l'un d'eux pour insérer un bloc de départ au curseur).
  • ▶ Preview au-dessus de chaque animation ouvre l'aperçu à côté de l'éditeur. Il suit le modèle : modifiez les données, et l'image change.
  • Après from, la complétion propose les modèles d'animation.
  • En début de ligne dans une animation, la complétion propose les données que son modèle lit et qui n'ont pas encore été fournies, chacune avec sa valeur d'exemple.
  • Le survol explique à quoi sert une donnée.

Limites#

  • Les modèles d'animation sont ceux d'Arche. archec ne connaît que ceux qui étaient embarqués lors de sa construction : un modèle ajouté à l'application exige de reconstruire archec à côté.
  • archec animation render nécessite Chrome ou Chromium sans interface.