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
}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
}
showliste 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
labelde 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èlestates, ils sont dans l'ordre où ils sont atteints. Danslifecycle, 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.
paramsliste les paramètres qui lui sont transmis, sous la formearche.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
templateen 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 }
}
animatefournit lesvisualsde l'étape. Ils sont vérifiés par rapport aux visuels et aux animations du projet.dwellest 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 laduration(3 s s'il n'y en a pas), à sonfps(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 sondwell. 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
animationouvre 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 rendernécessite Chrome ou Chromium sans interface.