précédent   suivant   sommaire  

11. Les modules de manipulation du temps de SMIL 2.0

Rédacteurs :
Patrick Schmitz (cogit@ludicrum.org), (Microsoft)

Table des matières

11.1 Introduction

Ce module introduit de nouveaux attributs pour la manipulation avancée du comportement du temps, comme le contrôle de la vitesse ou le régime du temps pour un élément. Ces manipulations du temps sont particulièrement adaptées aux médias d'animation et aux médias non linéraires, ou médias discrets. Les types de média continus ne géreront pas tous totalement les manipulations de temps. Par exemple, un flux vidéo MPEG 1 ne gérera pas, en général, une lecture en arrière. Un mécanisme de repli est décrit pour ces types de média.

Quatre nouveaux attributs ajoutent une gestion des manipulations du temps aux modules de de temporisation de SMIL, incluant le contrôle sur la vitesse d'un élément et la gestion de l'accélération et de la décélération. L'impact global sur la temporisation et la synchronisation est décrit. Une définition des mécanismes de repli raisonnables est fournie pour les lecteurs de média qui ne gèrent pas les manipulations de temps.

Une condition d'accessibilité pour le contrôle de la vitesse de relecture est liée au contrôle de la vitesse, mais elle peut aussi être controlée au travers d'autres mécanismes comme les interfaces DOM.

11.1.1 Arrière-plan

Cette section est informative.

Une application commune de temporisation gère l'animation. L'intégration récente de la temporisation de SMIL dans SVG est un bon exemple de l'intérêt dans ce domaine. L'animation, au sens le plus général, inclut la manipulation basée sur le temps des transformations de base, appliquées à une présentation. Certains des effets gérés incluent le mouvement, la mise à l'échelle, la rotation, la manipulation des couleurs tout comme un grand nombre de manipulations de présentation au sein d'un cadre de style comme CSS.

L'animation est souvent utilisée pour modeler les mécanismes de base. De nombreux cas d'utilisation avec des animations sont difficiles ou pratiquement impossibles à décrire sans un moyen simple de contrôler l'allure et d'appliquer des effets simples qui émulent des phénomènes mécaniques communs. Bien qu'il soit possible de construire ces mécanismes dans les comportements d'animation eux-mêmes, cela requiert que chaque extension d'animation duplique cette gestion. Cela rend l'environnement plus difficile à étendre et à personnaliser. De plus, un modèle décentralisé permet à tout comportement d'animation d'introduire une syntaxe et une sémantique individuelles pour ces mécanismes. Les inconsistances que cela introduirait feraient que le modèle d'édition serait plus dur à apprendre et compliquerait aussi le travail du concepteur d'un outil de développement. Enfin, un modèle par élément ad hoc exclut l'utilisation de tels mécanismes sur des animations structurées (i.e., appliquer des manipulations de temps à un conteneur de temps avec des comportements d'animation synchronisés).

Un modèle beaucoup plus simple, pour fournir la gestion demandée, centralise la fonctionnalité nécessaire dans l'environnement de temporisation. Cela permet à tous les éléments temporisés de gérer cette fonctionnalité et fournit un modèle cohérent aux auteurs et aux concepteurs d'outils de développement. La façon la plus directe de généraliser le contrôle de l'allure et la fonctionnalité associée est de transformer l'allure du temps pour un élément donné. Ceci est une extension du cadre général pour le temps de l'élément (qu'on appelle parfois « temps local ») et de la gestion de la conversion du temps d'un élément dans le temps d'un autre élément. Ainsi, pour contrôler l'allure de l'animation d'un mouvement, une transformation temporelle est appliquée qui ajuste l'allure du temps (i.e., le taux de progression) pour l'élément en mouvement. Si le temps est gradué pour avancer plus vite que le temps normal de la présentation , le mouvement semblera aller plus vite. De façon similaire, si l'allure du temps est ajusté dynamiquement, les effets d'accélération et de décélération sont obtenus facilement.

Les manipulations de temps sont basées sur un modèle de temps de cascade. Ainsi, chaque élément définit son temps actif et son temps simple comme des transformations du temps simple du parent. Ceci se répète du conteneur de temps racine jusqu'à chaque « nœud terminal » du graphe temporel. Si un conteneur de temps a une manipulation de temps définie, cela sera reflété dans tous les enfants du conteneur de temps, étant donné que ceux-ci définissent leur temps à partir du conteneur de temps parent. Dans l'exemple suivant, un conteneur de temps séquentiel est défini pour aller deux fois plus vite que la normale (i.e., deux fois plus vite que son propre conteneur de temps).

<seq speed="2.0">
   <video src="movie1.mpg" dur="10s" />
   <video src="movie2.mpg" dur="10s" />
   <img src="img1.jpg" begin="2s" dur="10s">
      <animateMotion from="-100,0" to="0,0" dur="10s" />
   </img>
   <video src="movie4.mpg" dur="10s" />
</seq>

Le contenu entier de la séquence sera joué deux fois plus vite. Chaque vidéo sera jouée à régime deux fois supérieure à la normale, et ne durera donc que 5 secondes. L'enfant image aura un délai d'une seconde (la moitié du décalage de début spécifié). L'enfant animation de l'image « héritera » aussi de la manipulation de la vitesse du conteneur de temps séquentiel et jouera donc son contenu deux fois plus vite que la normale, laissant l'image dans la position finale après seulement 5 secondes. La durée simple et la durée active de la séquence seront de 21 secondes (42 secondes divisées par 2).

11.1.2 Aperçu de la gestion

Cette section est informative.

Trois manipulations de temps générales sont définies :

accelerate, decelerate
Ces deux attributs fournissent un raccourci simple pour contrôler le taux de progression du temps simple de l'élément en vue de simuler un mouvement mécanique commun. Un modèle simple est présenté pour permettre une accélération à partir de la halte du début de la durée simple et/ou une décélération jusqu'à la halte de la fin de la durée simple. Ce modèle a l'avantage de préserver la durée simple. Ce modèle est parfois présenté aux auteurs comme « entrée en douceur, sortie en douceur ».
autoReverse
Quand il est mis à "true", la durée simple est jouée une fois en avant puis une fois en arrière. Cela double la durée simple, qu'elle soit déclarée ou implicite. La gestion de autoReverse est souvent présentée aux auteurs comme « lecture avant, puis arrière ».
speed
Contrôle l'allure (ou la vitesse) du temps actif de l'élément. La vitesse réduit effectivement le taux de progression de la durée active de l'élément, relativement au taux de progression du conteneur de temps parent.

Cette section est normative

Quand la vitesse du temps est filtrée par une quelconque manipulation du temps, cela affecte la façon dont le temps d'un document est converti dans le temps simple d'un élément. Pour comprendre cela, pensez aux contenus d'un élément comme progressant à un taux donné. Une valeur de temps en entrée non modifiée est convertie en une progression accumulée pour les contenus de l'élément. La progression d'un élément est exprimée en temps filtré. Cela permet à l'effet de n'importe quel régime (y compris l'accélération et la décélération) de se propager en cascade à tous les enfants temporisés. Si la progression de l'élément avance à un régime constant (i.e., avec une valeur de vitesse de 2), le calcul du temps filtré correspond simplement au temps en entrée multiplié par le régime. Si le régime change, le temps filtré est traité comme une intégrale du régime changeant. Les équations utilisées, pour calculer le temps filtré pour un temps en entrée donné, sont présentées dans « La conversion du temps d'un document dans celui d'un élément ».

Les caractéristiques de accelerate et decelerate sont appliquées localement sur la durée simple et n'ont pas d'effet sur la longueur de la durée simple ou de la durée active de l'élément. Quand ils sont appliqués à un conteneur de temps, les attributs accelerate et decelerate s'appliquent à la durée simple du conteneur de temps et à tous les temps de ses enfants, en affectant la durée observée des enfants temporisés.

La caractéristique de autoReverse est appliquée directement à la durée simple et double une durée simple implicite ou déclarée. Ainsi, si la durée simple est définie (selon la sémantique de temporisation normale) à 5 secondes, le paramétrage de autoReverse à "true" fera que la durée simple sera de 10 secondes. Ainsi, si la durée active est définie en fonction de la durée simple (par exemple, en spécifiant un attribut repeatCount), alors l'attribut autoReverse doublera aussi la durée active. Cependant, si la durée active est définie indépendamment de la durée simple (par exemple, en spécifiant une durée répétée, une valeur de fin et/ou des valeurs min et max), alors l'attribut autoReverse n'affectera pas la durée active. La durée active est calculée selon la sémantique du modèle de temporisation et de synchronisation ; le seul changement est l'utilisation de la valeur de durée simple modifiée (doublée).

L'attribut speed réduit la progression du temps de l'élément pour l'élément. Quand il est appliqué à un conteneur de temps, les contenus du conteneur de temps jouent de façon collective à la vitesse réduite. Si un élément joue deux fois plus vite que la normale, la durée simple observée sera moitié moins longue que la normale. Cela peut, ou non, affecter la durée active, selon la manière dont il est défini pour l'élément. Les attributs repeatDur, min et max sont tous mesurés dans le temps simple de l'élément, et donc les valeurs associées seront réduites par la vitesse de l'élément. De façon similaire, un élément défini avec un attribut repeatCount sera aussi réduit, étant donnée que la durée simple est réduite. Cependant, si un élément spécifie un attribut end, la valeur de fin n'est pas affectée par la vitesse de l'élément. Les valeurs de décalage d'un attribut end sont mesurées dans le temps simple du parent, et sont donc exclues des effets de la vitesse de l'élément. D'autres valeurs (incluant les valeurs d'arc de synchronisation, les valeurs d'événement, etc.) doivent être converties dans le temps simple du parent, et sont donc aussi non affectées par la vitesse de l'élément.

Notez qu'un attribut speed sur un élément n'affecte pas le temps de début d'un élément. Les valeurs de décalage pour l'attribut begin sont mesurées dans le temps simple du parent, et ne sont donc pas affectées par la vitesse de l'élément. (Le temps de début est affecté par toute manipulation sur le parent ou les autres conteneurs de temps ascendants).

Quand ces manipulations de temps sont appliquées à un conteneur de temps, elles affectent la façon dont le contenu entier de ce conteneur de temps est traité, i.e., elles affectent tous les descendants du conteneur de temps. Comme un temps global est converti en temps simple, les manipulations de temps pour chaque ancêtre sont appliquées, en commençant par la racine du graphe de temps et en descendant jusqu'au conteneur de temps de l'élément. Ainsi le temps simple et le temps actif pour un élément donné sont traités finalement comme une fonction des manipulations de temps de tous les conteneurs de temps ascendants, tout comme les éventuelles manipulations de temps définies sur l'élément lui-même. Ceci est décrit plus en détail dans « Le détail de l'arithmétique du modèle de temporisation ».

La vitesse de cascade nette d'un élément est une fonction des éventuelles manipulations de temps sur l'élément et de tous ses conteneurs de temps ascendants. Bien que cela puisse être calculé directement à partir des valeurs décrites, la vitesse peut aussi être pensée comme étant la dérivée du régime du temps (i.e., le taux de progression) en tout point.

Cette section est informative.

Ce modèle se prête bien à une implémentation basée sur l'« échantillonnage » d'un graphe temporel, avec un média non-linéaire (aussi appelé média d'« accès aléatoire »). Le modèle de manipulations de temps est basé sur un modèle utilisé couramment dans le graphisme et l'animation, dans lequel un graphe d'animation est « échantillonné » pour calculer les valeurs courantes de l'animation, et ensuite le graphisme associé est rendu. Certains lecteurs de média linéaires peuvent ne pas bien fonctionner avec les manipulations de temps (i.e., les lecteurs qui peuvent seulement jouer à une vitesse de lecture normale). Un mécanisme de repli est décrit, dans lequel le graphe temporel et les temps des valeurs de base de synchronisation sont calculés en utilisant la mathématique propre du modèle de manipulation de temps, les éléments de médias individuels jouant simplement à la vitesse normale ou alors affichant une image figée.

Certains des exemples ci-dessous incluent des éléments d'animation comme animate et animateMotion. Ces éléments sont définis dans la section traitant de l'animation de SMIL 2.0. Des éléments additionnels et des attributs liés à la temporisation et la synchronisation sont décrits dans la section traitant de la temporisation de SMIL 2.0.

11.1.3 La syntaxe des attributs

Cette section est normative.

Les attributs accelerate et decelerate

Ces attributs définissent une accélération et une décélération simple du temps de l'élément, dans la durée simple. Les valeurs sont exprimées comme une proportion de la durée simple (i.e., entre 0 et 1) et sont définis de sorte que la longueur de la durée simple ne soit pas changée par l'utilisation de ces attributs. La vitesse de lecture normale dans la durée simple est accrue pour compenser les périodes d'accélération et de décélération (c'est comme cela que la durée simple est préservée). La vitesse modifiée est appelée le régime d'exécution. Quand la durée simple progresse (i.e., est jouée), l'accélération fait que le taux de progression augmente d'un régime de 0 jusqu'au régime d'exécution. La progression continue au au régime d'exécution jusqu'à la phase de décélération, quand la progression ralentie par rapport au régime d'exécution jusqu'à un régime de 0. Ceci est illustré dans la Figure 1, ci-dessous :

Diagram relating input time to element progress

<animation dur="10s" accelerate="0.3" decelerate="0.3" .../>

Figure 1: Effet de l'accélération et de la décélération sur le taux de progression.

Ces attributs s'appliquent à la durée simple ; si ces attributs sont combinés avec un comportement répétitif, l'accélération et/ou la décélération se produisent dans chaque itération de la répétition.

accelerate = "nombre"
Définit une accélération simple du temps pour l'élément. Le temps de l'élément va s'accélérer à partir d'un régime de 0 au début jusqu'à un régime d'exécution, sur la course de la proportion spécifiée de la durée simple.
La valeur par défaut est 0 (pas d'accélération).
Les valeurs autorisées sont des valeurs décimales entre 0 et 1 (inclus).
decelerate = "nombre"
Définit une décélération simple du temps pour l'élément. Le temps de l'élément va décélérer à partir du régime d'exécution jusqu'à 0, à la fin de la durée simple, sur la course de la proportion spécifiée de la durée simple.
La valeur par défaut est 0 (pas de décélération).
Les valeurs autorisées sont des valeurs décimales entre 0 et 1 (inclus).

La somme des valeurs de accelerate et de decelerate ne doit pas excéder 1. Si les valeurs individuelles des attributs accelerate et decelerate sont entre 0 et 1 et que leur somme est supérieure à 1, alors les attributs accelerate et decelerate seront ignorés et l'élément temporisé se comportera comme si aucun des deux attributs n'avait été spécifié.

Si la durée élémentaire de l'élément n'est pas résolue ou si elle est résolue comme étant indéfinie, alors les attributs accelerate et decelerate sont ignorés.

Pour des détails sur le calcul du régime d'exécution et sur la conversion du temps simple du parent vers le temps simple de l'élément quand accelerate et/ou decelerate sont spécifiés, voir « Le calcul du régime d'exécution de l'élément » et « La conversion du temps d'un document dans celui d'un élément ».

Exemples

Dans cet exemple, un tracé de mouvement va s'accélérer à partir d'un arrêt pendant les 2 premières secondes, s'exécuter à un régime plus grand que la normale pendant 4 secondes, et ensuite décélérer doucement jusqu'à un arrêt durant les 2 dernières secondes. Cela fait que l'animation du mouvement est plus réaliste.

<img ...>
    <animateMotion dur="8s" accelerate=".25" decelerate=".25" .../>
</img>

Dans l'exemple suivant, l'image va « traverser » à partir de la gauche hors écran, et ensuite décélérer durant la dernière seconde pour une « entrée en douceur » à sa place. Cela suppose un modèle de disposition qui gère le positionnement (par exemple, le positionnement CSS ou la position d'une region dans la disposition de SMIL).

<img ...>
    <animate attributeName="left" dur="4s" decelerate=".25"
	     from="-1000" to="0" additive="sum" />
</img>

L'attribut autoReverse

Un autre phénomène mécanique commun est celui d'un processus qui avance et qui fait marche arrière. Des exemples peuvent en être :

Parce que tant de cas d'utilisation communs appliquent une répétition au temps local modifié (comme dans les exemples ci-dessus), cette fonction est modélisée comme modifiant la durée simple. En tant que tel, l'attribut autoReverse double la durée simple implicite ou déclarée. Quand il est combiné avec un comportement répétitif, chaque itération de la répétition va se jouer une fois en avant, et ensuite une fois en arrière.

autoReverse = " true | false "
Contrôle le mode de lecture autoReverse.
Les valeurs des arguments sont des booléens.
La valeur par défaut est "false" (i.e., lecture normale).

Quand celui-ci est appliqué à un conteneur de temps, cela va jouer le conteneur de temps en avant et ensuite en arrière. La sémantique de lecture d'un conteneur de temps en arrière est détaillée dans « Les implications des manipulations du temps sur les conteneurs de temps ».

La manipulation du temps autoReverse ne requiert pas initialement une durée simple résolue, bien qu'elle ne commencera pas la lecture en arrière tant que la durée simple n'est pas résolue ni achevée. Cela peut arriver quand la durée simple est définie par une durée simple implicite non résolue (telle la durée intrinsèque d'un média). Dans ce cas, l'élément va continuer la lecture avant jusqu'à ce que la durée simple implicite soit résolue (ou jusqu'à ce que la durée active, ou le conteneur de temps parent, écourte la durée simple, comme décrit dans la section traitant de la temporisation de SMIL 2.0). Si la durée simple implicite devient résolue avant la fin de la durée active, alors la durée simple sera résolue à 2 fois cette durée implicite, et la durée simple implicite sera jouée en arrière.

À chaque fois que l'élément sera joué en arrière, y compris la seconde partie de la manipulation autoReverse, la durée simple doit être résolue. Voir aussi « L'attribut speed ».

Dans cet exemple, un tracé de mouvement va s'animer normalement pour 5 secondes, déplaçant l'élément 20 pixels à droite, et ensuite le faire aller en arrière pendant 5 secondes (des 20 pixels à droite vers la position originale). Le comportement de répétition entraîne sa répétition 2 fois de plus, laissant finalement l'élément à sa place d'origine. La durée simple calculée de l'animation est de 10 secondes et la durée active est de 30 secondes.

<img ...>
    <animateMotion by="20, 0" dur="5s" autoReverse="true" repeatCount="3"/>
</img>

Dans l'exemple suivant, le tracé de mouvement se comportera comme au-dessus, mais se finira à la seconde 15 ou quand l'utilisateur clique sur l'image. Si l'élément se finit à la seconde 15 (si l'utilisateur ne clique pas), le tracé de mouvement laissera l'élément à la fin du tracé défini, 20 pixels à droite. Comme la durée active est définie par les attributs repeatDur et end, la durée active n'est pas affectée par l'attribut autoReverse dans ce cas. La sémantique de l'attribut fill n'est pas modifiée par les manipulations de temps : l'état du média à la fin de la durée active est utilisé durant une éventuelle période fill. La fin de la durée active peut tomber soit pendant un intervalle de lecture avant, soit pendant un intervalle de lecture arrière.

<img ...>
    <animateMotion  by="20, 0" dur="5s" autoReverse="true"
	 repeatDur="15" end="click" fill="freeze"/>
</img>

Les attributs accelerate et decelerate peuvent être combinés avec autoReverse et ils sont appliqués à la durée simple non modifiée. Par exemple :

<img ...>
    <animateMotion by="20, 0" dur="4s" autoReverse="true"
       accelerate=".25" decelerate=".25" />
</img>

Cela va produire une sorte de mouvement élastique avec le tracé accélérant pendant 1 seconde à partir de la position originale alors qu'il se déplace sur la droite, se déplaçant légèrement plus vite que la normale pendant 2 secondes, puis décélérant pendant 1 seconde alors qu'il approche le point 20 pixels à droite. Il accélère ensuite jusqu'à la position originale et décélère à la fin du tracé de mouvement inverse, à la position originale.

L'exemple suivant d'une rotation (basée sur l'élément animateTransform de SVG) illustre également une combinaison des attributs accelerate, decelerate et autoReverse. Cela va produire un balancement pendulaire sur la cible (si la cible a une forme pendulaire, avec l'origine de la transformation en haut) :

<animateTransform type="rotate" from="20" to="-20" dur="1s" repeatCount="indefinite"
	accelerate=".5" decelerate=".5" autoReverse="true" ... />

Le pendule se balance sur un arc en une seconde, et revient ensuite en une seconde. L'accélération et la décélération sont appliquées à la durée simple non modifiée et l'attribut autoReverse joue cette durée simple modifiée en avant puis en arrière. L'effet est d'accélérer tout le long du balancement descendant, puis de décélérer tout le long du balancement montant. La caractéristique autoReverse fait alors jouer la même animation (i.e., la durée simple) à l'envers et le pendule se balance pour revenir à la position de départ. La totalité de la durée simple modifiée se répète, produisant une animation continue d'avant en arrière. Cela produit une animation réaliste d'un mouvement pendulaire du monde réel.

L'attribut speed

L'attribut speed contrôle la vitesse de lecture locale d'un élément, pour accélérer ou ralentir le régime effectif de lecture relativement au conteneur de temps parent. L'attribut speed est géré sur tous les éléments temporisés. La valeur de l'argument ne spécifie pas une vitesse de lecture absolue, mais est plutôt relatif à la vitesse de lecture du conteneur de temps parent. La valeur spécifiée se transmet en cascade sur tous les dépendants temporels. Ainsi, si un élément par et l'un de ses enfants spécifient tous les deux une valeur speed de 50%, l'enfant jouera à 25% de la vitesse de lecture normale.

speed = " nombre "
Définit la vitesse de lecture du temps de l'élément.
Les valeurs légales sont des valeurs décimales signées. Une valeur de 0 n'est pas autorisée (et sera ignorée)
La valeur par défaut est "1.0" (pas de modification de vitesse).

Des valeurs de moins de 0 sont autorisées et entraîne la lecture de l'élément à l'envers. Un élément peut seulement être joué en arrière s'il y a suffisamment d'information concernant les durées active et simple. Spécifiquement :

Si la valeur de vitesse de cascade de l'élément est négative et si l'une ou l'autre des deux conditions ci-dessus n'est pas rencontrée, l'élément commencera et se finira immédiatement (i.e., il se comportera comme s'il avait une durée active spécifiée de 0). S'il y a un attribut min spécifié, le conteneur de temps sera simplement gelé à l'état initial pour la durée spécifiée minimum.

Le détail des effets de l'élément speed sur les calculs de temporisation sont décrits dans « Le détail de l'arithmétique du modèle de temporisation ».

Exemples

L'animation de mouvement suivante bougera la cible deux fois plus vite que la normale :

<animateMotion dur="10s" repeatCount="2" speed="2.0" path= ... />

La cible se déplacera le long du tracé en 5 secondes (dur/speed simples = 10s / 2.0 = 5s), et ensuite répétera ce mouvement (car repeatCount est mis à 2). La durée active est donc de 10 secondes.

Quand l'attribut speed est appliqué à un conteneur de temps, il règle le taux de progression tout au long du plan de montage chronologique du conteneur de temps. Cet effet se transmet en cascade. Quand des descendants spécifient aussi une valeur pour speed, les vitesses du parent et de l'enfant sont multipliées pour donner le résultat. Par exemple :

<par speed=2.0>
   <animate begin="2s" dur="9s" speed=0.75 .../>
</par>

Le régime de lecture observé de l'élément animate est 1.5 fois la vitesse normale de lecture (2.0 * 0.75 = 1.5). L'élément commence 1 seconde après que le par a commencé ( le décalage de begin est réduite seulement par l'attribut speed du parent), et finit 6 secondes plus tard (dur/speed = 9 / 1.5 = 6). 

L'exemple suivant montre comment un attribut end basé sur un événement se combine avec les manipulations de temps :

<par speed=2.0>
   <animate begin="2s" dur="9s" speed=0.75
	repeatCount="4" end="click" .../>
</par>

Le comportement est comme dans le premier exemple, mais l'élément animate se répète 4 fois pour un temps observé de 24 secondes (vitesse dur/cascade = 9s / (2.0 * 0.75) = 6s, et 6s * 4 répétitions = 24s). Si un événement click se produit avant cela, l'élément se termine au moment du clic. Une variante illustre une temporisation avec base de synchronisation :

<par speed=2.0>
   <img id="foo" dur="30s" .../>
   <animate dur="9s" speed=0.75
	repeatCount="4" end="click; foo.end" .../>
</par>

L'image sera affichée pendant 15 secondes. L'élément animate joue à un régime observé de 1.5 fois la vitesse de lecture (2.0 * 0.75), mais il se termine après 15 secondes, quand l'image se termine. La durée simple observée sera de 6 secondes (9 secondes divisées par la vitesse de cascade de 1.5). L'animation se répétera 2.5 fois pendant la durée active. Notez que, bien que l'animation ait une valeur pour speed, cela n'a pas d'impact sur la sémantique de la temporisation avec base de synchronisation. Quand le temps d'une base de synchronisation, d'un événement, d'une horloge de temps réel ou d'un marqueur de média va survenir, celui-ci sera appliqué partout où il est utilisé au temps effectif (bien que des conversions soient appliquées de façon interne, par exemple, à partir du temps actif de l'élément de base de synchronisation vers le temps simple du parent - voir aussi « La conversion du temps d'un document dans celui d'un élément »).

Notez que dans les exemples ci-dessus, la durée par défaut du conteneur de temps par est définie selon endsync="last". Ce comportement n'est pas affecté par les modifications de vitesse, dans le sens que la fin observée des éléments produira la durée simple correcte sur le conteneur de temps du parent.

Les exemples suivants illustrent un effet important de la réduction du temps d'un décalage :

<par speed=2.0>
   <img id="foo" dur="30s" .../>
   <animate begin="2s" dur="9s" speed=0.75
	repeatCount="4" end="foo.end+6s" .../>
</par>

L'image sera affichée pendant 15 secondes, comme précédemment. L'élément animate commence au bout d'une seconde, étant donné que le décalage de début est réduit par la vitesse du conteneur de temps du parent, mais pas par la vitesse de l'élément. L'élément animate finira au bout de 18 secondes (15 secondes plus 6 secondes divisées par la vitesse du conteneur de temps de 2.0). Le décalage de "6s" ajouté à "foo.end" est réduit par la vitesse du conteneur de temps parent, mais pas par la vitesse de l'élément.

11.1.4 Le détail de l'arithmétique du modèle de temporisation

Cette section est normative.

La temporisation et le temps des horloges réelles

Quand les attributs de manipulation de temps sont utilisés pour ajuster la vitesse et/ou l'allure au sein de la durée simple, la sémantique peut être assimilée au changement de l'allure du temps dans l'intervalle donné. Un modèle équivalent est que ces attributs changent simplement l'allure à laquelle la présentation progresse au cours de l'intervalle donné. Les deux interprétations sont mathématiquement équivalantes et le point significatif est que la notion de « temps », comme définie pour la durée simple de l'élément, ne devrait pas être interprétée comme un temps d'horloge de temps réel. Pour les besoins de la manipulation du temps de SMIL (comme pour la temporisation et la synchronisation de SMIL), le « temps » peut se comporter de façon assez différente de celui des horloges de temps réelle.

Les définitions communes

Dans la discussion suivante, plusieurs symboles sont utilisés comme raccourcis :

Soit a la valeur de l'attribut accelerate, et b la valeur de l'attribut decelerate. Les deux prennent des valeurs ( décimales) entre 0 et 1 et leur somme ne fait pas plus de 1.

Soit dur la valeur de la durée simple, comme définie dans le modèle de temporisation et de synchronisation. C'est la durée simple effective et pas simplement l'attribut dur. Cette valeur ne tient pas compte de l'effet d'éventuelles manipulation de temps.

Soit dacc la durée de la phase d'accélération, et ddec celle de la phase de décélération. Ces valeurs sont traitées comme une fonction de la durée simple non modifiée. Notez qu'avec le modèle décrit pour l'accélération et la décélération, la durée observée durant laquelle le temps accélère et/ou décélère peut être plus grande que dacc et ddec respectivement.

dacc = dur * a

ddec = dur * d

Le calcul du régime d'exécution de l'élément

Dans le but de préserver la durée simple, la vitesse au cours de la durée simple doit être augmentée pour pour tenir compte de l'accélération et de la décélération. Pour calculer le régime d'exécution dans le cours de la durée simple, la formule suivante est utilisée. Le régime d'exécution r est donc :

r = 1 / ( 1 - a/2 - b/2 )

Ainsi, par exemple, si la valeur de l'attribut accelerate est 1 (i.e., une accélération pendant toute la durée simple), le régime d'exécution est 2 (deux fois la vitesse normale de lecture).

La valeur r(t) est la variation de vitesse due à l'accélération et à la décélération, à tout instant t au sein de la durée simple. Le paramètre de temps t ne doit pas déjà être modifié pour tenir compte de l'accélération et de la décélération. Pour la discussion ci-dessous, dans « La conversion du temps d'un document dans celui d'un élément », le paramètre de temps t est dans l'espace tsu'. La variation de vitesse est définie comme une fonction du régime d'exécution r, comme suit :

Dans l'intervalle d'accélération, où ( 0 <= t < dacc )
r(t) = r * ( t / dacc )

Dans l'intervalle de régime d'exécution, où ( dacc <= t <= ( dur - ddec ) )

r(t) = r

Dans l'intervalle de décélération, où ( ( dur - ddec ) < t <= dur )

r(t) = r * ( dur - t ) / ( ddec )

Le régime d'exécution décrit seulement la variation appliquée pour tenir compte des accélérations et décélérations éventuelles. Cela se combine avec une éventuelle vitesse d'élément, ainsi qu'avec la vitesse héritée du conteneur de temps parent. La vitesse combinée, ou vitesse « nette », est définie dans la section « Le calcul de la vitesse de cascade nette pour un élément ».

La conversion du temps d'un document dans celui d'un élément

Pour convertir le temps d'un document dans celui d'un élément, le temps original est converti dans le temps simple de chaque conteneur de temps, à partir du conteneur de temps racine en descendant jusqu'au conteneur de temps parent pour l'élément. Cet algorithme récursif permet un modèle simple de la conversion du temps simple du parent dans le temps actif et le temps simple de l'élément. La première étape calcule le temps actif de l'élément et la seconde calcule le temps simple de l'élément.

Ces étapes sont basées sur un modèle général plus simple pour la conversion de temps, qui s'applique au modèle de temporisation indépendamment des fonctionnalités des manipulations du temps (voir aussi la section traitant de la temporisation de SMIL 2.0). Les étapes ci-dessous décrivent l'arithmétique modifiée pour convertir les temps, en prenant en compte la sémantique des manipulations du temps.

Les étapes ci-dessous supposent que les temps associés sont résolus et non indéfinis. Si un temps requis n'est pas résolu ou est indéfini, alors la conversion est non définie et ne peut être effectuée.

Le calcul du temps actif filtré

Pour refléter la sémantique de la vitesse de l'élément, le temps actif de l'élément doit être ajusté. Le temps ajusté est appelé le temps actif filtré, qui est utilisé par l'élément là où la sémantique de temporisation se réfère comme au « temps actif de l'élément ». Les attributs autoReverse  et accelerate/decelerate affectent seulement le calcul du temps simple filtré, et donc ne rentrent pas en compte dans cette étape.

Le temps en entrée est exprimé dans le temps simple du parent. Ceci est normalisé dans la durée active de l'élément, en ajustant le décalage de synchronisation accumulée (décrit dans « Le décalage de synchronisation accumulée »).

Soit tps un temps exprimé dans le temps simple du parent et B le temps de début, et O le décalage de synchronisation accumulée pour un élément, mesuré dans le temps simple du parent.

Le temps actif non filtré tau pour tout élément enfant est :

tau = tps - B - O

Étant donné un temps tau actif non filtré, le temps actif filtré taf est seulement une fonction de la vitesse pour l'élément (c'est la valeur spécifiée dans l'attribut speed, ou la valeur par défaut, et non pas la vitesse de cascade nette) :

Si ( speed > 0 )  i.e., si la vitesse locale est vers l'avant
taf = tau * vitesse

Sinon    i.e. si la vitesse locale est vers l'arrière

taf = AD - tau * ABS( vitesse )

Comme attendu, si la valeur de l'attribut speed est 1 (par défaut), c'est une fonction identité, et donc taf = tau. Quand la vitesse est inférieure à 0 (dans la direction arrière), la durée active procède à partir de la fin de la durée active en allant vers 0.

Le calcul du temps simple filtré

Pour refléter la sémantique des attributs autoReverse et accelerate/decelerate, le temps simple d'un élément doit être ajusté. Le temps ajusté est appelé le temps simple filtré. Le temps simple filtré est défini comme une fonction du temps actif filtré, qui reflète donc toutes les manipulations du temps sur un élément.

Le temps simple d'un élément est le temps utilisé pour établir la synchronisation à l'exécution pour un élément média, ou pour calculer la valeur d'entrée d'une fonction d'animation ou un temps d'échantillon. Si l'élément est un conteneur de temps, c'est aussi le temps qui est vu par tous les enfants du conteneur de temps (comme le temps simple de l'élément conteneur de temps).

Le temps en entrée est un temps actif filtré taf.

Soit dur' la durée simple modifiée qui tient compte de l'effet de l'attribut autoReverse. Il est calculé comme suit :
Si autoReverse a une valeur "false" :

dur' = dur

Sinon (si autoReverse a une valeur "true") :

dur' = dur * 2

Les étapes pour calculer le temps simple filtré sont décrites ci-dessous.

  1. Calculer le temps simple non filtré tsu, en tenant compte d'un éventuel comportement répétitif.

    S'il n'y a pas de comportement répétitif :

    tsu = taf

    Sinon, si la durée simple modifiée dur' est fixée et ne varie pas (cas idéal) :

    tsu = REMAINDER( taf, dur' )

    REMAINDER( t, d ) est défini comme (t - d*floor(t/d)).

    Sinon, si la durée simple modifiée dur' varie d'une itération de répétition à une autre, ou si elle est inconnue, alors le temps simple non filtré est juste calculé à partir du temps du début de la plus récente itération - appelons la tlast-repeat. Un autre mécanisme (tels qu'une logique de fin de synchronisation ou bien un lecteur de média) doit noter quand la durée simple se termine et réinitialiser la valeur de tlast-repeat. Si l'élément ne s'est pas encore répété, une valeur de 0 est utilisée pour tlast-repeat.

    tsu = taf - tlast-repeat
  2. Tenir compte du comportement de l'attribut autoReverse. Si autoReverse a une valeur de "false", tsu' = tsu.

    Sinon, si autoReverse a une valeur de "true" (notez que les étapes suivantes utilisent la durée non modifiée dur, et non pas dur') :

    Si tsu < dur
    tsu' = tsu

    Sinon ( tsu >= dur )

    tsu' = dur - ( tsu - dur ) = 2*dur - tsu
  3. Tenir compte du comportement d'accélération et/ou de décélération. Cela prend en entrée tsu' (le résultat des étapes 1 et 2).
Le temps simple filtré tsf est calculé comme une fonction du temps d'entrée tsu' et des régimes d'exécution effectifs sur l'intervalle de 0 à tsu'. Le temps simple filtré est la progression accumulée jusqu'au temps en entrée et se cacule comme l'intégrale des taux d'accélération, du régime d'exécution et du taux de décélération. Étant donné que les taux d'accélération et de décélération sont constants, l'intégrale se simplifie en une fonction du taux de progression moyen pour chacun des trois intervalles définis par les valeurs d'accélération et de décélération. Les étapes ci-dessous calculent le temps filtré en multipliant le temps en entrée et les taux de progression moyens. Dans l'intervalle d'accélération, comme l'accélération est constante et que le régime change de 0 à r, le taux moyen est juste 1/2 du taux instantanée r(t) défini ci-dessus :
taux moyen = (r(t) + r(0) ) / 2) = r(t)/2

Dans l'intervalle de décélération, le taux moyen est calculé de façon similaire. Dans l'intervalle du régime d'exécution, le taux est constant, et donc le taux moyen est égal au régime d'exécution.

Dans l'intervalle d'accélération, où ( 0 <= tsu' < dacc ), le temps simple filtré est le temps en entrée multiplié par le régime d'exécution moyen durant l'intervalle d'accélération :

tsf = tsu' * r(tsu') / 2

Dans l'intervalle de régime d'exécution, où ( dacc <= tsu' <= ( dur - ddec ) ), le temps simple filtré est calculé à partir du temps d'entrée et des taux dans les intervalles du régime d'exécution et d'accélération. Cela ajoute la progression accumulée dans l'intervalle d'accélération à la progression dans l'intervalle du régime d'exécution :

tsf = dacc * r / 2  + ( tsu' - dacc ) * r

    = r * ( dacc / 2  + ( tsu' - dacc ))

    = r * (  tsu' - dacc / 2 )

Dans l'intervalle de décélération, où ( ( dur - ddec ) < tsu' <= dur ), le temps simple filtré est calculé à partir du temps en entrée et des taux dans les trois intervalles. Cela fait la somme des progressions totales dans les intervalles d'accélération, de régime d'exécution et de décélération.

Pour simplifier ces expressions, nous définissons tdec, le temps écoulé dans l'intervalle de décélération :

tdec =  tsu' - ( dur - ddec )

Nous définissons aussi la durée proportionnelle dans l'intervalle de décélération comme :

pd =  tdec / ddec

Le temps filtré dans l'intervalle de décélération est donc :

tsf = dacc * r / 2  
          + ( dur - dacc - ddec ) * r  
          + tdec * (( r + r*(1 - pd )) / 2 ))
     = r * ( dur - dacc / 2 - ddec 
             + tdec * ( 2 - pd ) / 2 )

La conversion du temps d'un élément dans celui d'un document

Pour convertir de l'espace de temps d'un élément à un autre, le temps pour le premier élément te1 doit tout d'abord être converti dans le temps simple du conteneur de temps ascendant le plus proche qui contient les deux éléments. La conversion du temps d'un élément dans le temps du parent est le processus inverse de celui décrit ci-dessus. Encore une fois, il s'agit d'une opération récursive, ainsi les conversions sont décrites génériquement à partir du temps simple de l'élément vers le temps actif de l'élément, puis du temps actif de l'élément vers le temps simple du parent.

La conversion du temps simple de l'élément vers le temps actif de l'élément requiert le temps du début de la plus récente itération, tlast-repeat. Si l'élément ne se répète pas ou n'a pas encore été répété, une valeur de 0 est utilisée pour tlast-repeat.

ta = ts + tlast-repeat

La conversion du temps actif de l'élément vers le temps simple du parent utilise le début associé de l'élément et le décalage de synchronisation accumulé.

tps = ta + B + O

Notez que les conversions pures ne prennent pas en compte l'écrêtage des durées actives, pas plus que les effets de remplissage (où le temps est gelé). Les conversions temps global vers temps local, utilisées pour la traduction entre espaces temporels, doivent ignorer ces questions, et ainsi peuvent produire un temps dans l'espace temporel local de destination qui est bien avant ou bien après la durée simple de l'élément.

Une forme alternative de la conversion est utilisée pour l'échantillonnage effectif du graphe temporel. Un conteneur de temps est seulement échantillonné s'il est actif ou gelé, et donc aucun temps ne sera produit qui ne soit avant qu'un conteneur de temps n'ait commencé. Si la conversion du temps global vers le temps local pour un conteneur de temps produit un temps lors duquel le conteneur de temps est gelé, le temps est fixé à la valeur de la fin active.

Le calcul de la vitesse de cascade nette pour un élément

La vitesse de cascade nette d'un élément donné à un point donné dans le temps peut être utilisée pour régler le régime de lecture correcte pour un élément média. Elle n'est sinon pas utilisée directement dans le modèle de manipulation du temps.

Pour calculer la vitesse de cascade nette speednc(t) pour un élément à un point donné dans le temps, nous combinons la vitesse de cascade nette du parent au point dans le temps speednc-parent(t) avec la valeur de la vitesse de l'élément speed et le régime d'exécution instantané r(t) calculé à partir des éventuelles accélération et décélération. Si l'élément n'a pas de parent temporisé, utilisez 1 pour speednc-parent(t).

Notez que la vitesse de cascade nette du parent sera calculée dans le temps simple du parent, et donc le temps simple de l'élément devra être converti dans le temps simple du parent. Ceci est décrit ci-dessus dans « La conversion du temps d'un élément dans celui d'un document ».

La valeur du paramètre de temps doit être dans la portée de la durée simple. La valeur du temps ne doit pas déjà être modifiée pour pour tenir compte de l'accélération et de la décélération. Dans la discussion ci-dessus, dans « La conversion du temps d'un document dans celui d'un élément », le paramètre de temps est dans l'espace tsu'.

La vitesse de cascade nette speednc(t) pour un temps simple non filtré donné tsu' est alors :

speednc(tsu') =  speednc-parent(tsu') * speed * r(tsu')

La définition est récursive, en montant jusqu'à la racine de la hiérarchie des conteneurs de temps, et ainsi tient compte des réglages de vitesse sur le parent et sur tous les autres conteneurs de temps ascendants.

11.1.5 La sémantique du média de repli

Cette section est informative.

Un modèle théorique peut être décrit qui suppose que tous les plans de montage chronologiques locaux des éléments (incluant d'éventuels éléments médias) soient entièrement non linéaires et aient des ballistiques libres (i.e., ils peuvent être échantillonnés en tout point à tout instant et peuvent ajuster le régime de lecture observée instantanément). Ce modèle idéal peut correspondre à de multiples applications, y compris des rendus de graphiques purs, du texte, etc. Néanmoins, de nombreuses applications communes comprennent aussi des médias ayant un comportement linéaire et d'autres limitations en lecture. Quand le graphe temporel inclut des éléments médias qui ont un comportement linéaire, le modèle de manipulation du temps doit tenir compte de ces limitations du monde réel.

Alors que le modèle gère les graphes temporels mélangeant des comportements linéaires et non linéaires et définit des sémantiques spécifiques pour les éléments médias qui ne peuvent pas gérer le modèle non linéaire idéal, ce n'est pas le but que de fournir une présentation alternative idéale pour tous les graphes temporels possibles avec un tel mélange. Les auteurs et les outils de développement sont libres d'appliquer les manipulations de temps dans les situations appropriées. Cette section décrit à la fois le modèle idéal et la sémantique associée aux éléments médias linéaires.

Le modèle idéal

Cette section est informative.

Dans le modèle idéal, l'allure ou la vitesse du temps local peuvent être manipulées arbitrairement. Le graphe avance (ou est échantillonné, selon votre point de vue) à mesure que le temps de la présentation avance. Un conteneur de temps échantillonne chacun de ses enfants à son tour, ainsi une traversée du graphe est exécutée pour chaque temps de rendu. Les éléments qui ne sont ni actifs ni gelés peuvent être élagués à partir de cette traversée pour optimisation. Comme la traversée descend le graphe (à partir des conteneurs de temps jusqu'aux enfants), chaque plan de montage chronologique local transforme simplement le temps courant de l'espace temporel du parent dans l'espace temporel local, puis échantillonne le plan de montage chronologique local selon le temps courant transformé. Notez que la vitesse et les effets des filtres de temps descendent en cascade le graphe temporel, étant donné que chaque élément transforme le temps de l'élément et la vitesse de l'élément pour soi-même et pour tous ses descendants.

C'est le modèle décrit par le modèle arithmétique dans « Le détail de l'arithmétique du modèle de temporisation ».

Quand des médias linéaires sont ajoutés à ce modèle et que la traversée (ou échantillon) du « temps courant » rencontre un élément média, on dit effectivement à l'élément média « d'échantillonner » à une position particulière et à un régime particulier. Étant donné que ces médias linéaires ne peuvent pas échantillonner arbitrairement (i.e., ils ne peuvent pas chercher immédiatement et afficher une image ou un échantillon arbitraires), le lecteur de l'élément média peut être incapable de correspondre au modèle idéal.

De nombreux éléments médias ne peuvent pas jouer hors la vitesse (i.e., à une autre vitesse que la normale) et ainsi doivent ignorer la vitesse qui est requise. Au fur et à mesure que l'élément est joué, il va se trouver désynchronisé par rapport à la relation de synchronisation définie dans la syntaxe de temporisation. Dans les limites définies par l'attribut syncTolerance de SMIL, une divergence par rapport au plan de montage chronologique théorique pourra être ignorée. Cependant, pour les divergences ultérieures en-dehors de cette tolérance, l'élément sera considéré comme désynchronisé ; si l'élément est défini avec syncBehavior="locked", le moteur de lecture essaiera de respecter les sémantiques de synchronisation d'éxécution (et cela ne produira probablement pas une lecture de la présentation attrayante). Les auteurs appliquant des manipulations de temps, aux médias linéaires ou aux conteneurs de temps qui incluent des médias linéaires, souhaiteront vraisemblablement spécifier l'attribut syncBehavior pour le média linéaire avec une valeur "canSlip".

Les replis pour les filtres de temps sur un élément média

Cette section est normative.

La sémantique de repli dépend de ce dont le lecteur de média est capable. Certains lecteurs pour certains médias peuvent jouer en avant et en arrière mais seulement à la vitesse normale de lecture, d'autres peuvent seulement gérer une vitesse de lecture avant normale.

Si la vitesse d'un élément (i.e., la valeur de cascade) n'est pas gérée par l'élément média, le média devrait jouer à la vitesse gérée la plus proche (« au mieux »). Si l'élément ne peut pas jouer plus lentement ou plus rapidement que la vitesse de lecture normale, la vitesse gérée la plus proche sera la vitesse de lecture normale.

Dans tous les cas, la durée simple calculée, comme modifiée par les filtres de temps, est respectée.

La sémantique des attributs clipBegin et clipEnd n'est pas affectée par les manipulations de temps. La sémantique de clipBegin et clipEnd est toujours interprétée en fonction de la vitesse de lecture avant normale. Ceux-ci sont évalués avant que les effets d'éventuels filtres de temps aient été appliqués sur le modèle temporel. Ceci est cohérent avec le modèle selon lequel ils peuvent être évalués par le gestionnaire de l'élément média, indépendamment du modèle temporel.

Les considérations à l'édition pour la sémantique de repli

Cette section est informative.

Dans ce modèle de repli, certains éléments médias peuvent ne pas être capables de jouer à la vitesse calculée définie par le graphe temporel. La sémantique de repli peut faire en sorte que l'élément média tombe en dehors de la synchronisation visuelle tout en respectant le reste du graphe temporel. Par exemple, si un élément image est défini pour commencer 10 secondes après qu'un élément vidéo a commencé et qu'ensuite une vitesse de 2.0 est appliquée au conteneur de temps pour ces deux éléments, l'élément image commencera à 5 secondes (10s/2.0). Si la vidéo ne peut pas être jouée à deux fois la vitesse normale, cela ne fera pas 10 secondes quand l'image réapparaitra, et ainsi la présentation pourrait apparaître désynchronisée.

Quand des manipulations de temps sont utilisées avec un média linéaire, les auteurs peuvent utiliser des valeurs de marqueur de média pour définir les relations de synchronisation. Cela peut aider à maintenir une synchronisation « visuelle » indépendamment du comportement de repli. Étant donné que les valeurs de marqueur de média sont définies pour se produire quand un point particulier du média est joué, cette temporisation va respecter le comportement effectif du média, plutôt que le comportement de la vitesse calculée.

Les implications des manipulations du temps sur les conteneurs de temps

Cette section est normative.

Les manipulations de temps peuvent s'appliquer à n'importe quel élément, incluant les conteneurs de temps. Ceci entraîne deux implications principales pour le modèle temporel :

  1. Le régime (relativement à la vitesse de lecture normale) auquel le temps s'écoule dans le parent peut affecter les temps de début et de fin observés pour les enfants du conteneur de temps. Dans le processus de conversion de temps, à partir de l'espace temporel d'un élément dans le graphe vers l'espace temporel d'un autre élément, toutes les manipulations de temps sur des conteneurs de temps ascendants doivent être respectées. Ainsi, par exemple, si un conteneur de temps a une accélération définie, les enfants, qui sont définis pour commencer avec des conditions de décalage simples, seront observés (en temps réel) commencer plus tard (que le décalage spécifié), étant donné que le temps s'écoule plus lentement au début de la durée simple du parent. Voir aussi « Le détail de l'arithmétique du modèle de temporisation » ;
  2. Quand un conteneur de temps est défini pour être joué en en arrière, les temps de début et de fin des enfants doivent être calculés avec un algorithme modifié (décrit immédiatement ci-dessous). Ceci n'est pas (seulement) défini par rapport aux attributs speed ou autoReverse du conteneur de temps. Plutôt, quand la vitesse de cascade nette du conteneur de temps est inférieure à zéro, la sémantique modifiées est appliquée. Voir aussi « Le calcul de la vitesse de cascade nette pour un élément ».
La gestion des vitesses négatives sur les conteneurs de temps

La discussion suivante est basée sur la sémantique des listes d'instance de début et de fin et sur l'interprétation des listes des temps de début et de fin décrites dans la section traitant de la temporisation de SMIL 2.0.

Si le conteneur de temps peut jouer en arrière (selon les contraintes générales de lecture arrière pour les durées simples et actives), alors les enfants doivent jouer les intervalles définis en ordre inverse. Ceci est obtenu avec le cycle de vie modifié suivant pour des éléments enfants. Dans la description suivante, les termes les termes « début » et « fin » pour les intervalles s'entendent relativement à la direction de lecture normale. Quand ils sont utilisés comme un verbe (« l'intervalle débute »), les termes début et fin se réfèrent à l'intervalle courant devenant actif et inactif, respectivement. Les intervalles sont décrits comme débutant à partir de la fin de l'intervalle jusqu'au début, et donc ils commencent à la fin de l'intervalle, et ils finissent à début de l'intervalle.

  1. Trouver le premier intervalle de lecture : L'élément enfant calculera le premier intervalle à jouer, qui est en fait le dernier intervalle défini par les temps d'instance. Ceci est est réalisé en considérant les listes des temps d'instance dans l'ordre normal du premier au dernier, en calculant le dernier intervalle qui débute avant la fin de la durée simple du conteneur de temps. On utilise pour cela la même approche de base que celle utilisée pour déterminer le premier intervalle dans une lecture normale, qui tient compte des sémantiques de redémarrage en fonction des temps connus dans les listes d'instances. On peut voir cela, en tenant compte de l'élément enfant, comme le temps simple du parent qui est avancé de 0 jusqu'à la fin de la durée simple, le dernier intervalle trouvé étant celui à utiliser. Aucun intervalle n'est créé dans ce processus, jusqu'à ce que les temps corrects soient trouvés, alors un intervalle courant est défini, avec les mêmes effets secondaires que pour une lecture normale : tous les dépendants temporels sont avisés et créeront de nouveaux temps d'instance associés à cet intervalle courant ;
  2. Attendre avant de jouer l'intervalle : Au fur et à mesure que le temps s'écoule, à partir de la fin de la durée simple du conteneur de temps jusqu'à 0, l'intervalle courant peut attendre avant d'être actif. L'intervalle courant deviendra actif quand le temps simple du conteneur de temps atteindra le temps de fin défini de l'intervalle courant. Pendant la période où l'intervalle courant attend avant de débuter, l'effet éventuel d'un remplissage devra être appliqué. Ceci est défini de la même façon que pour la lecture avant normale, en utilisant l'état de l'élément à la fin définie de l'intervalle courant ;
  3. La lecture effective : Quand l'intervalle courant devient actif, un événement beginEvent est déclenché. L'événement est déclenché pour indiquer que l'élément est devenu actif, même s'il était devenu actif à la fin de l'intervalle. L'intervalle courant restera actif jusqu'à ce que le temps simple du parent atteigne le temps de début de l'intervalle courant. Une fois que l'intervalle courant est devenu actif, aucun changement de temps d'instance n'aura plus impact sur l'intervalle courant. Cela est légèrement différent du mécanisme normal, mais simplifie significativement le modèle sans perte significative de fonctionnalité. Notez que cette sémantique est seulement appliquée quand le conteneur de temps parent d'un élément est joué en arrière ;
  4. Terminé - trouver le prochain intervalle : Quand l'intervalle courant devient inactif, un événement endEvent est déclenché. L'événement est déclenché pour indiquer que l'élément est devenu inactif, même s'il était devenu inactif au début de l'intervalle courant. À ce stade, l'élément considère la liste des temps d'instances et il calcule le prochain intervalle (s'il y en a un). La même approche que dans la phase 1 ci-dessus est utilisée, excepté que le prochain intervalle doit débuter avant que l'intervalle courant ( celui qui finit) ne commence. De plus, la fin du prochain intervalle est contrainte, selon la sémantique de redémarrage, de finir pas plus tard que le début de l'intervalle courant (celui qui finit). Ainsi, le prochain intervalle (s'il y en a un) débutera avant le début de l'intervalle courant et finira pas plus tard que le début de l'intervalle courant. Il est possible que cet intervalle ait été défini avant que le parent n'ait débuté ;
  5. Plus aucun intervalle : Une fois que tous les intervalles définis entre la fin et le début de la durée simple du parent ont été joués, le cycle de vie courant pour l'élément enfant est achevé.

Quand un conteneur de temps est défini pour être joué à l'envers, un élément enfant peut définir des manipulations de temps additionnelles qui affectent la vitesse, ou même le sens de la lecture. De telles manipulations de temps additionnelles sur l'élément enfant n'ont pas d'impact sur le modèle décrit ci-dessus.

Le cycle de vie est recommencé chaque fois que le conteneur de temps parent (ou n'importe quel ascendant) se répète ou redémarre, comme pour un sens de lecture normal.

À cause de l'évaluation inversée des intervalles, des dépendances temporelles cycliques qui se propageraient correctement en avant, quand elles sont jouées normalement, ne se propageront pas correctement quand elles seront jouées à l'envers. Les règles pour évaluer et arrêter les cycles dans les graphes temporels ne sont pas changées par la sémantique des manipulations du temps.

 


précédent   suivant   sommaire