comp(name)

Type de valeur renvoyé : Comp. (composition)

Type d’argument : nom est une chaîne de caractères.

Récupère une autre composition par son nom.

footage(name)

Type de valeur renvoyé : Footage (métrage).

Type d’argument : nom est une chaîne de caractères.

Récupère un métrage par son nom.

thisComp

Type de valeur renvoyé : Comp. (composition)

Représente la composition contenant l’expression.

thisLayer

Type de valeur renvoyé : Layer (calque), Light (lumière) ou Camera (caméra).

Représente le calque contenant l’expression. thisLayer étant l’objet par défaut, son utilisation est facultative. Par exemple, vous pouvez débuter une expression par thisLayer.width ou width et obtenir le même résultat.

thisProperty

Type de valeur renvoyé : Property (propriété).

Représente la propriété contenant l’expression. Par exemple, si vous rédigez une expression sur la propriété Rotation, vous pouvez la commencer par thisProperty pour faire référence à la propriété Rotation.

time

Type de valeur renvoyé : Number (nombre).

Représente l’instant de la composition (en secondes) auquel l’expression est évaluée.

colorDepth

Type de valeur renvoyé : Number (nombre).

Renvoie la valeur de codage des couleurs du projet. Par exemple, l’élément colorDepth renvoie la valeur 16 si le projet utilise un codage (ou une profondeur) des couleurs de 16 bits par couche.

posterizeTime(framesPerSecond)

Type de valeur renvoyé : Number (nombre).

Type d’argument : framesPerSecond est un nombre.

La valeur framesPerSecond est ensuite utilisée comme cadence d’images pour le reste de l’expression. Cette expression vous permet de définir la cadence d’une propriété afin qu’elle soit inférieure à la cadence de la composition. Par exemple, l’expression suivante remplace la valeur de la propriété par une valeur aléatoire toutes les secondes :

  posterizeTime(1); 
  random()

value

Type de valeur renvoyé : Number (nombre), Array (ensemble) ou String (chaîne).

Représente la valeur à l’instant courant de la propriété contenant l’expression.

timeToFrames(t = time + thisComp.displayStartTime, fps = 1.0 / thisComp.frameDuration, isDuration = false)

Type de valeur renvoyé : Number (nombre).

Type d’argument : t et fps sont des nombres (Number) ; isDuration est un booléen (Boolean).

Convertit la valeur de t, qui prend par défaut la valeur de l’instant courant de la composition, en un nombre entier d’images. Le nombre d’images par seconde est défini dans l’argument fps, qui prend par défaut la valeur de la cadence de la composition actuelle (1.0 / thisComp.frameDuration). L’argument isDuration, qui prend par défaut la valeur « false », doit être positionné sur true si la valeur t représente un écart entre deux instants et non un instant absolu. Les instants absolus sont arrondis (au chiffre inférieur) vers l’infini négatif ; les durées sont arrondies par éloignement par rapport à zéro (au chiffre supérieur pour les valeurs positives).

framesToTime(frames, fps = 1.0 / thisComp.frameDuration)

Type de valeur renvoyé : Number (nombre).

Type d’argument : frames et fps sont des nombres (Number).

Il s’agit de l’inverse de timeToFrames. Renvoie l’instant correspondant à l’argument frames, qui est requis. Il ne s’agit pas nécessairement d’un entier. Voir timeToFrames pour obtenir des explications sur l’argument fps.

timeToTimecode(t = time + thisComp.displayStartTime, timecodeBase = 30, isDuration = false)

Type de valeur renvoyé : String (chaîne).

Type d ’argument : t et timecodeBase sont des nombres (Number) ; isDuration est un booléen (Boolean).

Convertit la valeur de t en une chaîne (String) représentant le code temporel. Voir timeToFrames pour obtenir des explications sur les arguments t et isDuration. timecodeBase, qui prend par défaut la valeur 30, définit le nombre d’images par seconde.

timeToNTSCTimecode(t = time + thisComp.displayStartTime, ntscDropFrame = false, isDuration = false)

Type de valeur renvoyé : String (chaîne).

Type d’argument : t est un nombre (Number), ntscDropFrame et isDuration sont des booléens (Boolean).

Convertit t en une chaîne (String) représentant le code temporel NTSC. Voir timeToFrames pour obtenir des explications sur les arguments t et isDuration. Si ntscDropFrame est défini sur « false » (valeur par défaut), la chaîne (String) obtenue représente un code temporel NTSC (Image non compensée). Si ntscDropFrame est défini sur « true », la chaîne (String) obtenue représente un code temporel NTSC (Image compensée).

timeToFeetAndFrames(t = time + thisComp.displayStartTime, fps = 1.0 / thisComp.frameDuration, framesPerFoot = 16, isDuration = false)

Type de valeur renvoyé : String (chaîne).

Type d’argument : t, fps et framesPerFoot sont des nombres (Number) ; isDuration est un booléen (Boolean).

Convertit la valeur de t en une chaîne (String) représentant du film et des images (en pieds). Voir timeToFrames pour obtenir des explications sur les arguments t, fps et isDuration. L’argument framesPerFoot définit le nombre d’images sur un pied de film. Il prend par défaut la valeur 16, qui représente la cadence la plus fréquente pour les métrages 35 mm.

timeToCurrentFormat(t = time + thisComp.displayStartTime, fps = 1.0 / thisComp.frameDuration, isDuration = false)

Type de valeur renvoyé : String (chaîne).

Type d’argument : t et fps sont des nombres (Number) ; isDuration est un booléen (Boolean).

Convertit la valeur de t en une chaîne (String) représentant le temps au format d’affichage actuel sélectionné dans la boîte de dialogue Paramètres du projet. Voir timeToFrames pour obtenir une définition de tous les arguments.

Un argument ntscDropFrame facultatif a été ajouté à la fonction timeToCurrentFormat() dans After Effects CS5.5 et versions ultérieures. Valeur par défaut : ntscDropFrame = thisComp.ntscDropFrame.

Si vous souhaitez un plus grand contrôle sur l’aspect du code temporel dans le métrage, utilisez la méthode timeToCurrentFormat ou d’autres méthodes timeTo pour générer le code temporel au lieu d’utiliser l’effet Code temporel ou Nombres. Créez un calque de texte, ajoutez une expression à la propriété Texte source et entrez timeToCurrentFormat() dans le champ de l’expression. Avec cette méthode, vous pouvez formater et animer le texte de code temporel. Le code temporel utilise par ailleurs le même style d’affichage que celui défini par les paramètres actuels du projet.

Les fonctions de calcul vectoriel sont des méthodes globales qui effectuent des opérations sur des ensembles, en les traitant comme des vecteurs mathématiques. Contrairement aux méthodes JavaScript (comme Math.sin), il est inutile d’utiliser le préfixe Math avec ces méthodes. Sauf indication contraire, les méthodes de calcul vectoriel sont modérées en ce qui concerne les dimensions et renvoient une valeur correspondant à la dimension de l’objet d’ensemble d’entrée le plus important et remplissent les éléments manquants avec des zéros. Par exemple, l’expression add([10, 20]+[1, 2, 3]) renvoie[11, 22, 3].

Sur le site Web de JJ Gifford, vous apprendrez comment associer la géométrie et la trigonométrie simples aux expressions grâce à des explications illustrées par des exemples.

Dans un article sur le site Web ProVideo Coalition, Chris et Trish Meyer proposent des informations complémentaires sur les méthodes mathématiques vectorielles et sur les ensembles.

add(vec1, vec2)

Type de valeur renvoyé : Array (ensemble).

Type d’argument : vec1 et vec2 sont des ensembles (Array).

Ajoute deux vecteurs.

sub(vec1, vec2)

Type de valeur renvoyé : Array (ensemble).

Type d’argument : vec1 et vec2 sont des ensembles (Array).

Soustrait deux vecteurs.

mul(vec, amount)

Type de valeur renvoyé : Array (ensemble).

Type d’argument : vec est un ensemble (Array), amount est un nombre (Number).

Multiplie chaque élément du vecteur par la valeur amount.

div(vec, amount)

Type de valeur renvoyé : Array (ensemble).

Type d’argument : vec est un ensemble (Array), amount est un nombre (Number).

Divise chaque élément du vecteur par la valeur amount.

clamp(value, limit1, limit2)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : value, limit1 et limit2 sont des nombres (Number) ou des ensembles (Array).

La valeur de chaque composant de value doit être comprise entre les valeurs correspondantes de limit1 et limit2.

Dans un article sur le site Web ProVideo Coalition, Chris et Trish Meyer proposent des informations complémentaires sur la méthode clamp (verrouillage).

dot(vec1, vec2)

Type de valeur renvoyé : Number (nombre).

Type d’argument : vec1 et vec2 sont des ensembles (Array).

Renvoie le produit (interne) des arguments vectoriels.

cross(vec1, vec2)

Type de valeur renvoyé : Array (ensemble) [2 ou 3].

Type d’argument : vec1 et vec2 sont des ensembles (Array) [2 ou 3].

Renvoie le produit croisé de vec1 et vec2. Pour plus de détails, reportez-vous à un manuel de mathématiques ou à un manuel JavaScript.

normalize(vec)

Type de valeur renvoyé : Array (ensemble).

Type d’argument : vec est un ensemble (Array).

Normalise le vecteur afin que sa longueur soit de 1,0. L’utilisation de la méthode normalize constitue un raccourci pour exécuter l’opération div(vec, length(vec)).

length(vec)

Type de valeur renvoyé : Number (nombre).

Type d’argument : vec est un ensemble (Array).

Renvoie la longueur du vecteur vec.

length(point1, point2)

Type de valeur renvoyé : Number (nombre).

Type d’argument : point1 et point2 sont des ensembles (Array).

Renvoie la distance entre deux points. L’argument point2 est facultatif. Par exemple, length(point1, point2) est identique à length(sub(point1, point2)).

Vous pouvez, par exemple, ajouter cette expression à la propriété Distance de mise au point d’une caméra pour verrouiller le plan focal sur le point ciblé de la caméra, de telle sorte que la mise au point soit effectuée sur celui-ci :

  length(position, pointOfInterest)

lookAt(fromPoint, atPoint)

Type de valeur renvoyé : Array (ensemble) [3].

Type d’argument : fromPoint et atPoint sont des ensembles (Array) [3].

L’argument fromPoint représente la position dans l’espace univers du calque à orienter. L’argument atPoint représente le point de l’espace univers vers lequel orienter le calque. La valeur renvoyée peut être utilisée comme expression pour la propriété Orientation afin de pointer l’axe z du calque sur atPoint. Cette méthode est particulièrement utile pour les caméras et les lumières. En cas d’utilisation de cette expression avec une caméra, veillez à désactiver l’orientation automatique. Par exemple, cette expression sur la propriété Orientation d’un projecteur positionne le point lumineux sur le point d’ancrage du calque numéro 1 de la même composition : lookAt(position, thisComp.layer(1).position)

seedRandom(offset, timeless=false)

Type de valeur renvoyé : aucun.

Type d’argument : offset est un nombre (Number), timeless est un booléen (Boolean).

Les méthodes random et gaussRandom utilisent une valeur de générateur qui contrôle la séquence de nombres. Par défaut, la valeur est calculée en tant que fonction d’un identifiant de calque unique, de la propriété à l’intérieur du calque, de l’instant courant et d’une valeur de décalage de 0. Appelez seedRandom pour définir le décalage sur une valeur différente de 0 et créer une séquence aléatoire différente.

Utilisez true pour l’argument timeless afin de ne pas utiliser l’instant courant comme générateur aléatoire. L’utilisation de true pour l’argument timeless vous permet de générer un nombre aléatoire ne variant pas en fonction du moment d’évaluation.

La valeur offset, contrairement à la valeur timeless, permet également de contrôler la valeur initiale de la fonction wiggle (tremblement).

Par exemple, cette expression attribue à la propriété Opacité une valeur aléatoire sans variation temporelle :

  seedRandom(123456, true); 
  random()*100

La multiplication par 100 dans cet exemple convertit la valeur entre 0 et 1 renvoyée par la méthode random en un nombre compris entre 0 et 100. Cette plage est plus généralement utilisée pour la propriété Opacité dont la valeur est comprise entre 0 % et 100 %.

random()

Type de valeur renvoyé : Number (nombre).

Renvoie un nombre aléatoire dans la plage 0 à 1.

Dans After Effects CS6, le comportement de l’expression random() a été modifié afin d’accentuer le caractère aléatoire lorsque les ID de calque sont proches les uns des autres. L’expression wiggle() n’est pas concernée.

random(maxValOrArray)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : maxValOrArray est un nombre (Number) ou un ensemble (Array).

Si maxValOrArray est un nombre, cette méthode renvoie un nombre compris entre 0 et maxValOrArray. Si maxValOrArray est un ensemble (Array), cette méthode renvoie un ensemble de même dimension que maxValOrArray, dont chaque composant se situe entre 0 et le composant correspondant de maxValOrArray.

random(minValOrArray, maxValOrArray)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : minValOrArray et maxValOrArray sont des nombres (Number) ou des ensembles (Array).

Si minValOrArray et maxValOrArray sont des nombres, cette méthode renvoie un nombre compris entre minValOrArray et maxValOrArray. Si les arguments sont des ensembles, cette méthode renvoie un ensemble ayant la même dimension que l’argument doté de la plus grande dimension, chaque composant dans la plage du composant correspondant de minValOrArray au composant correspondant de maxValOrArray. Par exemple, l’expression random([100, 200], [300, 400]) renvoie un ensemble dont la première valeur se situe dans la plage 100 à 300 et dont la deuxième valeur est dans la page 200 à 400. Si les dimensions des deux ensembles d’entrée ne correspondent pas, les valeurs de dimension supérieure de l’ensemble le plus court sont complétées par des zéros.

gaussRandom()

Type de valeur renvoyé : Number (nombre).

Renvoie un nombre aléatoire. Les résultats ont une distribution gaussienne. Environ 90 % des résultats se situent entre 0 et 12, et les 10 % restant se situent hors de cette plage.

gaussRandom(maxValOrArray)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : maxValOrArray est un nombre (Number) ou un ensemble (Array).

Lorsque maxValOrArray est un nombre (Number), cette méthode renvoie un nombre aléatoire. Environ 90 % des résultats se situent entre 0 et maxValOrArray, et les 10 % restant se situent hors de cette plage. Lorsque maxValOrArray est un ensemble (Array), cette méthode renvoie un ensemble de valeurs aléatoires, de même dimension que maxValOrArray. 90 % des valeurs se situent entre 0 et maxValOrArray, et les 10 % restant se situent hors de cette plage. Les résultats ont une distribution gaussienne.

gaussRandom(minValOrArray, maxValOrArray)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : minValOrArray et maxValOrArray sont des nombres (Number) ou des ensembles (Array).

Si minValOrArray et maxValOrArray sont des nombres (Number), cette méthode renvoie un nombre aléatoire. Environ 90 % des résultats se situent entre minValOrArray et maxValOrArray, et les 10 % restant se situent hors de cette plage. Si les arguments sont des ensembles, cette méthode renvoie un ensemble de nombres aléatoires de même dimension que l’argument de dimension maximale. Pour chaque composant, environ 90% des résultats se situent dans la plage entre le composant correspondant de minValOrArray et le composant correspondant de maxValOrArray, et les 10 % restant se situent hors de cette plage. Les résultats ont une distribution gaussienne.

noise(valOrArray)

Type de valeur renvoyé : Number (nombre).

Type d’argument : valOrArray est un nombre (Number) ou un ensemble (Array) [2 ou 3].

Renvoie un nombre dans la plage -1 à 1. Le bruit n’est pas véritablement aléatoire : il s’appuie sur le bruit Perlin qui signifie que les valeurs renvoyées de deux valeurs d’entrée proches seront également généralement proches l’une de l’autre. Ce type de bruit est utile lorsque vous souhaitez obtenir une séquence de nombres apparemment aléatoires à faible variation comme c’est généralement le cas pour l’animation d’un mouvement naturel apparemment aléatoire. Par exemple, rotation + 360*noise(time)

Pour toutes les méthodes d’interpolation, l’argument t est souvent le temps ou la valeur, mais il peut aussi représenter d’autres valeurs. Si t représente le temps, l’interpolation entre les valeurs se produit sur une durée. Si t représente la valeur, l’expression fait correspondre une plage de valeurs à une nouvelle plage de valeurs.

Pour plus d’explications et d’exemples sur les méthodes d’interpolation, visitez le site Web de JJ Gifford.

Chris et Trish Meyer proposent des informations et des exemples complémentaires sur ces méthodes dans un article sur le site Web ProVideo Coalition.

Ian Haigh propose, sur le site Web After Effects Scripts, un script permettant d’appliquer aisément des expressions de méthode d’interpolation évoluées, telles que les rebonds, aux propriétés.

Andrew Devis propose sur le site Web de Creative COW deux didacticiels vidéo qui détaillent l’utilisation de la méthode d’expression linéaire en conjonction avec l’option Convertir les données audio en images clés.

linear(t, tMin, tMax, value1, value2)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t, tMin et tMax sont des nombres (Number) ; value1 et value2 sont des nombres (Number) ou des ensembles (Array).

Renvoie value1 si t <= tMin. Renvoie value2 si t >= tMax. Renvoie une interpolation linéaire entre value1 et value2 si tMin < t < tMax.

Par exemple, si cette expression est rédigée sur la propriété Opacité, on obtient un dégradé linéaire des valeurs d’opacité de 20 % à 80 % entre 0 seconde et 6 secondes :

  linear(time, 0, 6, 20, 80)

Cette méthode, comme toutes les méthodes d’interpolation, peut également être utilisée pour effectuer une conversion d’une plage de données à une autre. Par exemple, cette expression sur la propriété Opacité convertit les valeurs d’opacité de la plage 0 %-100 % à la plage 20 %-80 % :

  linear(value, 0, 100, 20, 80)

linear(t, value1, value2)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t est un nombre (Number) ; value1 et value2 sont des nombres (Number) ou des ensembles (Array).

Renvoie une valeur qui représente l’interpolation linéaire entre value1 et value2 si t est compris entre 0 et 1. Renvoie value1 si t <= 0. Renvoie value2 si t >= 1.

ease(t, value1, value2)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t est un nombre (Number) ; value1 et value2 sont des nombres (Number) ou des ensembles (Array).

Identique à linear avec les mêmes arguments, si ce n’est que l’interpolation définit une vitesse d’ajustement intérieur et extérieur de 0 aux points de départ et d’arrivée. Cette méthode permet de réaliser des animations parfaitement lissées.

ease(t, tMin, tMax, value1, value2)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t, tMin et tMax sont des nombres (Number) ; value1 et value2 sont des nombres (Number) ou des ensembles (Array).

Identique à linear avec les mêmes arguments, si ce n’est que l’interpolation définit une vitesse d’ajustement intérieur et extérieur de 0 aux points de départ et d’arrivée. Cette méthode permet de réaliser des animations parfaitement lissées.

easeIn(t, value1, value2)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t est un nombre (Number) ; value1 et value2 sont des nombres (Number) ou des ensembles (Array).

Identique à ease, mais avec une tangente de 0 sur le côté value1 seulement et une interpolation linéaire sur le côté value2.

easeIn(t, tMin, tMax, value1, value2)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t, tMin et tMax sont des nombres (Number) ; value1 et value2 sont des nombres (Number) ou des ensembles (Array).

Identique à ease, mais avec une tangente de 0 sur le côté tMin seulement et une interpolation linéaire sur le côté tMax.

easeOut(t, value1, value2)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t est un nombre (Number) ; value1 et value2 sont des nombres (Number) ou des ensembles (Array).

Identique à ease, mais avec une tangente de 0 sur le côté value2 seulement et une interpolation linéaire sur le côté value1.

easeOut(t, tMin, tMax, value1, value2)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t, tMin et tMax sont des nombres (Number) ; value1 et value2 sont des nombres (Number) ou des ensembles (Array).

Identique à ease, mais avec une tangente de 0 sur le côté tMax seulement et une interpolation linéaire sur le côté tMin.

Sur son site Web graymachine, Harry Frank propose un didacticiel vidéo décrivant l’utilisation de ces méthodes de conversion chromatique pour changer la couleur des ondes produites par l’effet Ondes radio.

rgbToHsl(rgbaArray)

Type de valeur renvoyé : Array (ensemble) [4].

Type d’argument : rgbaArray est un ensemble (Array) [4].

Convertit une couleur RVBA en couleur TSLA. L’entrée est un ensemble de valeurs normalisées comprises entre 0.0 et 1.0 pour les couches rouge, verte, bleue et alpha. La valeur résultante est un ensemble de valeurs (également comprises entre 0.0 et 1.0) pour la teinte, la saturation, la luminosité et la couche alpha. Exemple :

  rgbToHsl.effect("Change Color")("Color To Change")

hslToRgb(hslaArray)

Type de valeur renvoyé : Array (ensemble) [4].

Type d’argument : hslaArray est un ensemble (Array) [4].

Convertit une couleur TSLA en couleur RVBA. Cette conversion est l’opposé de la conversion effectuée par la méthode rgbToHsl.

Dans un article sur le site Web ProVideo Coalition, Chris et Trish Meyer proposent des informations complémentaires sur ces méthodes.

degreesToRadians(degrees)

Type de valeur renvoyé : Number (nombre).

Type d’argument : degrees est un nombre (Number).

Convertit les degrés en radians.

radiansToDegrees(radians)

Type de valeur renvoyé : Number (nombre).

Type d’argument : radians est un nombre (Number).

Convertit les radians en degrés.

layer(index)

Type de valeur renvoyé : Layer (calque), Light (lumière) ou Camera (caméra).

Type d’argument : index est un nombre (Number).

Récupère un calque en fonction de son numéro (dans l’ordre du panneau Montage). Par exemple, thisComp.layer(3).

layer(name)

Type de valeur renvoyé : Layer (calque), Light (lumière) ou Camera (caméra).

Type d’argument : nom est une chaîne de caractères.

Récupère un calque en fonction de son nom. Les correspondances sont évaluées par nom de calque ou par nom source en l’absence de nom de calque. S’il existe des doublons, le premier calque (situé en haut) du panneau Montage sera retenu. Exemple :

  thisComp.layer("Solid 1")

layer(otherLayer, relIndex)

Type de valeur renvoyé : Layer (calque), Light (lumière) ou Camera (caméra).

Type d’argument : otherLayer est un objet Layer et relIndex est un nombre (Number).

Récupère le calque situé relIndex niveaux de calques au-dessus ou en dessous de otherLayer. Par exemple, thisComp.layer(thisLayer, 1).active renvoie la valeur « true » si le calque suivant du panneau Montage est actif.

marker

Type de valeur renvoyé : MarkerProperty.

Important : le numéro de repère ne permet pas d’accéder à un repère de composition. Si vous avez créé un projet dans une version antérieure d’After Effects qui utilise les numéros de repères de composition dans les expressions, vous devez remplacer ces noms par marker.key(name). Le nom par défaut d’un repère de composition étant un numéro, la conversion de la référence pour utiliser le nom revient généralement à placer le numéro entre guillemets.

marker.key(index)

Type de valeur renvoyé : MarkerKey (clé de repère).

Type d’argument : index est un nombre (Number).

Renvoie l’objet MarkerKey du repère avec l’index spécifié. L’index fait référence à l’ordre du repère dans la composition (et non pas à son nom). Par exemple, cette expression renvoie l’instant du premier repère de composition :

  thisComp.marker.key(1).time

marker.key(name)

Type de valeur renvoyé : MarkerKey (clé de repère).

Type d’argument : nom est une chaîne de caractères.

Renvoie l’objet MarkerKey du repère avec le nom spécifié. La valeur name est le nom du repère, tel qu’il a été entré dans le champ Commentaires de la boîte de dialogue Repère, par exemple, marker.key("1"). Le nom par défaut d’un repère de composition est un nombre. Si plusieurs repères d’une composition portent le même nom, cette méthode renvoie le repère qui apparaît en premier dans le temps de la composition. La valeur d’une clé de repère est une chaîne de caractères (String), et non un nombre (Number). Par exemple, cette expression renvoie l’instant du repère de composition portant le nom « 0 » :

  thisComp.marker.key("0").time

marker.nearestKey(t)

Type de valeur renvoyé : MarkerKey (clé de repère).

Type d’argument : t est un nombre (Number).

Renvoie le repère le plus proche de t dans le temps. Par exemple, cette expression renvoie l’instant du repère de composition le plus proche de l’instant 1 seconde :

  thisComp.marker.nearestKey(1).time

Cette expression renvoie l’instant du repère de composition le plus proche de l’instant courant :

  thisComp.marker.nearestKey(time).time

marker.numKeys

Type de valeur renvoyé : Number (nombre).

Renvoie le nombre total de repères de la composition.

numLayers

Type de valeur renvoyé : Number (nombre).

Renvoie le nombre de calques de la composition.

activeCamera

Type de valeur renvoyé : Camera.

Renvoie l’objet Camera à travers lequel s’effectue le rendu de la composition pour l’image actuelle. Cette caméra n’est pas nécessairement la caméra par laquelle vous regardez dans le panneau Composition.

width

Type de valeur renvoyé : Number (nombre).

Renvoie la largeur en pixels de la composition.

Appliquez l’expression suivante à la propriété Position d’un calque pour centrer celui-ci dans la composition :

  [thisComp.width/2, thisComp.height/2]

height

Type de valeur renvoyé : Number (nombre).

Renvoie la hauteur en pixels de la composition.

duration

Type de valeur renvoyé : Number (nombre).

Renvoie la durée en secondes de la composition.

ntscDropFrame

Type de valeur renvoyé : Boolean (booléen).

Renvoie la valeur « true » si le code temporel est au format compensé (After Effects CS5.5 et versions ultérieures.)

displayStartTime

Type de valeur renvoyé : Number (nombre).

Renvoie l’instant de départ de la composition, en secondes.

frameDuration

Type de valeur renvoyé : Number (nombre).

Renvoie la durée en secondes de l’image.

shutterAngle

Type de valeur renvoyé : Number (nombre).

Renvoie la valeur en degrés de l’angle d’obturateur de la composition.

shutterPhase

Type de valeur renvoyé : Number (nombre).

Renvoie la valeur en degrés de la phase d’obturateur de la composition.

bgColor

Type de valeur renvoyé : Array (ensemble) [4].

Renvoie la couleur de fond de la composition.

pixelAspect

Type de valeur renvoyé : Number (nombre).

Renvoie le format des pixels de la composition.

name

Type de valeur renvoyé : String (chaîne).

Renvoie le nom de la composition.

Pour utiliser un métrage du panneau Projet en tant qu’objet d’une expression, utilisez la méthode footage globale (comme dans footage("nom_fichier")). Vous pouvez également accéder à un objet de métrage en utilisant l’attribut source d’un calque dont la source est un métrage.

width

Type de valeur renvoyé : Number (nombre).

Renvoie la largeur du métrage en pixels.

height

Type de valeur renvoyé : Number (nombre).

Renvoie la hauteur du métrage en pixels.

duration

Type de valeur renvoyé : Number (nombre).

Renvoie la durée du métrage en secondes.

frameDuration

Type de valeur renvoyé : Number (nombre).

Renvoie la durée d’une image du métrage en secondes.

ntscDropFrame

Type de valeur renvoyé : Boolean (booléen).

Renvoie la valeur « true » si le code temporel est au format compensé (After Effects CS5.5 et versions ultérieures.)

pixelAspect

Type de valeur renvoyé : Number (nombre).

Renvoie le format des pixels du métrage.

name

Type de valeur renvoyé : String (chaîne).

Renvoie le nom du métrage tel qu’il apparaît dans le panneau Projet.

source

Type de valeur renvoyée : Comp ou Footage.

Renvoie l’objet Comp ou Footage source du calque. Le temps par défaut est ajusté sur le temps source. Par exemple, source.layer(1).position.

sourceTime(t = time)

Type de valeur renvoyé : Number (nombre).

Renvoie la source des calques correspondant au temps t (After Effects CS5.5 et versions ultérieures.)

effect(name)

Type de valeur renvoyée : Effect.

Type d’argument : nom est une chaîne de caractères.

L’effet est récupéré selon son nom dans le panneau Effets. Le nom peut être le nom par défaut ou celui choisi par l’utilisateur. Si plusieurs effets portent le même nom, l’effet le plus proche du haut du panneau Effets est utilisé. Exemple :

  effect("Fast Blur")("Blurriness")

effect(index)

Type de valeur renvoyée : Effect.

Type d’argument : index est un nombre (Number).

L’effet est récupéré selon son indexation dans le panneau Effets (de 1 en partant du haut).

mask(name)

Type de valeur renvoyée : Mask.

Type d’argument : nom est une chaîne de caractères.

Le nom peut être le nom par défaut ou celui choisi par l’utilisateur. Si plusieurs masques portent le même nom, le premier masque (le plus haut) est employé. Exemple :

  mask("Mask 1")

mask(index)

Type de valeur renvoyée : Mask.

Type d’argument : index est un nombre (Number).

Le masque est retrouvé en fonction de son index dans le panneau Montage (1 en haut).

width

Type de valeur renvoyé : Number (nombre).

Renvoie la largeur en pixels du calque. Identique à source.width.

height

Type de valeur renvoyé : Number (nombre).

Renvoie la hauteur en pixels du calque. Identique à source.height.

index

Type de valeur renvoyé : Number (nombre).

Renvoie le numéro du calque (index) dans la composition.

parent

Type de valeur renvoyé : Layer (calque), Light (lumière) ou Camera (caméra).

Renvoie l’objet Layer parent du calque (s’il en existe un). Par exemple, position[0] + parent.width.

hasParent

Type de valeur renvoyé : Boolean (booléen).

Renvoie la valeur « true » si le calque a un parent et « false » dans le cas contraire.

L’attribut hasParent permet de déterminer si le calque possède un parent. Vous pouvez utiliser cet attribut même si le calque n’a pas de calque parent pour le moment. L’expression ci-dessous, par exemple, indique que le calque sur lequel vous l’appliquez tremble en fonction de la position du calque parent. Si le calque n’a pas de parent, il tremble en fonction de sa propre position. Si le calque obtient un parent ultérieurement, son comportement change en conséquence :

  idx = index; 
  if (hasParent) { 
    idx = parent.index; 
  } 
  thisComp.layer(idx).position.wiggle(5,20)

inPoint

Type de valeur renvoyé : Number (nombre).

Renvoie l’instant en secondes du point d’entrée du calque.

Remarque : en général, la valeur de outPoint est supérieure à celle de inPoint. Cependant, si un calque est inversé dans le temps, la valeur de inPoint est supérieure à celle de outPoint. De même, la valeur de startTime peut être supérieure à celle de inPoint.

outPoint

Type de valeur renvoyé : Number (nombre).

Renvoie l’instant en secondes du point de sortie du calque.

startTime

Type de valeur renvoyé : Number (nombre).

Renvoie l’instant de départ du calque en secondes.

hasVideo

Type de valeur renvoyé : Boolean (booléen).

Renvoie la valeur « true » si le calque est vidéo et « false » dans le cas contraire.

hasAudio

Type de valeur renvoyé : Boolean (booléen).

Renvoie la valeur « true » si le calque est audio et « false » dans le cas contraire.

active

Type de valeur renvoyé : Boolean (booléen).

Renvoie true (vrai) si le bouton d’option Vidéo  est activé pour le calque et que l’instant courant se trouve dans la plage comprise entre le point d’entrée du calque et le point de sortie du calque ; false (faux) dans les autres cas.

enabled

Type de valeur renvoyé : Boolean (booléen).

Renvoie true (vrai) si le bouton d’option Vidéo  est activé pour le calque ; false (faux) dans les autres cas.

audioActive

Type de valeur renvoyé : Boolean (booléen).

Renvoie true (vrai) si le bouton d’option Audio  est activé pour le calque et que l’instant courant se trouve dans la plage comprise entre le point d’entrée du calque et le point de sortie du calque ; false (faux) dans les autres cas.

sampleImage(point, radius = [.5, .5], postEffect=true, t=time)

Type de valeur renvoyé : Array (ensemble) [4].

Type d’argument : point est un ensemble (Array) [2], radius est un ensemble (Array) [2], postEffect est un booléen (Boolean) et t est un nombre (Number).

Echantillonne les valeurs chromatiques et de couche alpha d’un calque et renvoie la moyenne pondérée de la valeur alpha des pixels à une distance spécifiée du point, en tant qu’ensemble : [rouge, vert, bleu, alpha]. Si postEffect est défini sur « true », les valeurs échantillonnées sont destinées au calque après le rendu des masques et des effets sur ce calque ; si postEffect est défini sur « false », les valeurs échantillonnées sont destinées au calque avant le rendu des masques et des effets. La valeur d’entrée point se situe dans l’espace calque ; le point [0,0] est le centre du pixel en haut à gauche du calque. La valeur d’entrée radius définit la distance (verticale et horizontale) entre le centre de l’échantillon et les bords du rectangle échantillonné. La valeur par défaut échantillonne un pixel.

Remarque : le paramètre postEffect fait référence aux effets appliqués directement au calque, et non aux effets appliqués indirectement comme avec un calque de réglage.

Dans cet exemple, un rectangle de 4 pixels de large sur 3 pixels de haut, centré sur un point situé 100 pixels plus bas, à droite du coin supérieur gauche du calque, est échantillonné :

  thisComp.layer(1).sampleImage([100, 100], [2, 1.5])

Dan Ebberts propose un exemple d’utilisation de la méthode sampleImage sur son site Web Motionscript.

Vous trouverez, sur le forum AE Enhancers, une expression qui utilise la méthode sampleImage pour mesurer un calque de texte ou un calque de forme et déterminer son cadre de sélection réel.

Todd Kopriva, pour sa part, explique comment utiliser la méthode sampleImage et l’effet Paramètre point d’effet pour un point donné au cours d’une correction colorimétrique. Pour en savoir plus, rendez-vous sans attendre sur son blog After Effects Region of Interest.

Lorsque vous ajoutez des masques, des effets, de la peinture ou du texte à un calque, After Effects ajoute de nouvelles propriétés dans le panneau Montage. Ces propriétés sont trop nombreuses pour être énumérées ici ; utilisez l’icône de sélection pour en apprendre la syntaxe et y faire référence dans vos expressions.

anchorPoint

Type de valeur renvoyé : Property (propriété) [2 ou 3].

Renvoie la valeur du point d’ancrage du calque dans le système de coordonnées du calque (espace calque).

position

Type de valeur renvoyé : Property (propriété) [2 ou 3].

Renvoie la valeur de position du calque, en espace univers si le calque n’a pas de parent. Si le calque a un parent, renvoie la valeur de position du calque dans le système de coordonnées du calque parent (dans l’espace calque du calque parent).

scale

Type de valeur renvoyé : Property (propriété) [2 ou 3].

Renvoie la valeur de l’échelle du calque, en pourcentage.

rotation

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur de rotation du calque, en degrés. Pour un calque 3D, la valeur en degrés de rotation de l’axe Z.

opacity

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur d’opacité du calque, en pourcentage.

audioLevels

Type de valeur renvoyé : Property [2].

Renvoie la valeur de la propriété Niveaux audio du calque, en décibels. Il s’agit d’une valeur 2D ; la première indique le niveau du canal de gauche et la seconde de celui de droite. La valeur n’est pas l’amplitude de la piste audio du matériel source. Il s’agit plutôt de la propriété Niveaux audio, qui peut être affectée par des images clés.

timeRemap

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur en secondes de la propriété Remappage temporel (si elle est activée).

marker.key(index)

Type de valeur renvoyé : MarkerKey (clé de repère).

Type d’argument : index est un nombre (Number).

Renvoie l’objet MarkerKey du repère de calque avec l’index spécifié.

marker.key(name)

Type de valeur renvoyé : MarkerKey (clé de repère).

Type d’argument : nom est une chaîne de caractères.

Renvoie l’objet MarkerKey du repère de calque avec le nom spécifié. name est le nom du repère, tel qu’il a été entré dans le champ Commentaires de la boîte de dialogue Repère, par exemple, marker.key("ch1"). Si plusieurs repères du calque portent le même nom, cette méthode renvoie le repère qui apparaît en premier dans le temps (du calque). La valeur d’une clé de repère est une chaîne de caractères (String), et non un nombre (Number).

Cette expression inscrite dans une propriété entraîne un dégradé de la valeur de la propriété de 0 à 100 entre deux repères identifiés par leurs noms :

  m1 = marker.key("Start").time; 
  m2 = marker.key("End").time;  
  linear(time, m1, m2, 0, 100);

marker.nearestKey(t)

Type de valeur renvoyé : MarkerKey (clé de repère).

Type d’argument : t est un nombre (Number).

Renvoie le repère de calque le plus proche de t dans le temps. Par exemple, cette expression renvoie l’instant du repère du calque le plus proche de l’instant 1 seconde :

  marker.nearestKey(1).time

Cette expression renvoie l’instant du repère du calque le plus proche de l’instant courant :

  marker.nearestKey(time).time

marker.numKeys

Type de valeur renvoyé : Number (nombre).

Renvoie le nombre total de repères du calque.

name

Type de valeur renvoyé : String (chaîne).

Renvoie le nom du calque.

orientation

Type de valeur renvoyé : Property [3].

Renvoie la valeur en degrés de l’orientation 3D d’un calque 3D.

rotationX

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur de rotation de l’axe x d’un calque 3D, en degrés.

rotationY

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur de rotation de l’axe y d’un calque 3D, en degrés.

rotationZ

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur de rotation de l’axe z d’un calque 3D, en degrés.

lightTransmission

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur de la propriété Transmission de la lumière d’un calque 3D.

castsShadows

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur 1,0 si le calque projette des ombres.

acceptsShadows

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur 1,0 si le calque accepte les ombres.

acceptsLights

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur 1,0 si le calque accepte les lumières.

ambient

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur en pourcentage de la composante ambiante.

diffuse

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur en pourcentage de la composante diffuse.

specular

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur en pourcentage de la composante spéculaire.

shininess

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur en pourcentage de la composante brillance.

metal

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur en pourcentage de la composante métal.

Les méthodes de conversion de l’espace calque permettent de convertir les valeurs d’un espace à un autre, par exemple de l’espace du calque à l’espace univers. Les méthodes « from » convertissent les valeurs de l’espace calque dans l’espace nommé (composition ou univers). Les méthodes « to » convertissent les valeurs de l’espace nommé (composition ou univers) dans l’espace calque. Chacune de ces méthodes utilise un argument optionnel pour déterminer l’instant auquel la transformation est calculée. Cependant, il est pratiquement toujours possible d’utiliser l’instant courant (par défaut).

Utilisez les méthodes de conversion vectorielles (« vec ») pour convertir un vecteur directionnel (différence entre deux valeurs de position, par exemple). Utilisez les méthodes non vectorielles pour convertir un point (une position, par exemple). Les espaces composition et univers sont identiques pour les calques 2D. Pour les calques 3D, l’espace composition est relatif à la caméra active, alors que l’espace univers en est indépendant.

Dans un article sur le site Web ProVideo Coalition, Chris et Trish Meyer proposent des informations complémentaires sur ces méthodes.

toComp(point, t=time)

Type de valeur renvoyé : Array (ensemble) [2 ou 3].

Type d’argument : point est un ensemble (Array) [2 ou 3] et t est un nombre (Number).

Convertit un point de l’espace calque dans l’espace composition.

fromComp(point, t=time)

Type de valeur renvoyé : Array (ensemble) [2 ou 3].

Type d’argument : point est un ensemble (Array) [2 ou 3] et t est un nombre (Number).

Convertit un point de l’espace composition dans l’espace calque. Le point résultant dans un calque 3D peut avoir une valeur différente de zéro, même s’il se situe dans l’espace calque. Exemple : fromComp(thisComp.layer(2).position)

toWorld(point, t=time)

Type de valeur renvoyé : Array (ensemble) [2 ou 3].

Type d’argument : point est un ensemble (Array) [2 ou 3] et t est un nombre (Number).

Convertit un point de l’espace calque dans l’espace univers (indépendant de la vue). Exemple :

  toWorld.effect("Bulge")("Bulge Center")

Dan Ebberts propose, sur son site Web MotionScript, une expression qui utilise la méthode toWorld pour orienter automatiquement un calque le long d’un seul axe. Cela se révèle particulièrement utile, par exemple, pour retourner des caractères latéralement afin de suivre le mouvement de la caméra, tout en les laissant verticaux.

Carl Larsen propose, sur le site Web de Creative COW, un didacticiel vidéo en deux parties dans lequel il décrit les principes de la parenté, puis utilise une expression contenant la méthode toWorld pour suivre la trajectoire d’un calque enfant animé :

• Partie 1

• Partie 2

Sur son site Web AE Portal, Rich Young propose un ensemble d’expressions qui utilisent la méthode toWorld pour lier une caméra et la lumière à un calque avec l’effet CC Sphere.

fromWorld(point, t=time)

Type de valeur renvoyé : Array (ensemble) [2 ou 3].

Type d’argument : point est un ensemble (Array) [2 ou 3] et t est un nombre (Number).

Convertit un point de l’espace univers dans l’espace calque. Par exemple : fromWorld(thisComp.layer(2).position).

Pour obtenir un exemple d’utilisation possible de cette méthode, reportez-vous à la section Exemple d’expression : création d’un renflement entre deux calques.

toCompVec(vec, t=time)

Type de valeur renvoyé : Array (ensemble) [2 ou 3].

Type d’argument : vec est un ensemble (Array) [2 ou 3] et t est un nombre (Number).

Convertit un vecteur de l’espace calque dans l’espace composition. Par exemple : toCompVec([1,0])

fromCompVec(vec, t=time)

Type de valeur renvoyé : Array (ensemble) [2 ou 3].

Type d’argument : vec est un ensemble (Array) [2 ou 3] et t est un nombre (Number).

Convertit un vecteur de l’espace composition dans l’espace calque. Par exemple (calque 2D) :

  dir=sub(position, thisComp.layer(2).position); 
  fromCompVec(dir)

toWorldVec(vec, t=time)

Type de valeur renvoyé : Array (ensemble) [2 ou 3].

Type d’argument : vec est un ensemble (Array) [2 ou 3] et t est un nombre (Number).

Convertit un vecteur de l’espace calque dans l’espace univers. Exemple :

  p1 = effect("Eye Bulge 1")("Bulge Center");  
  p2 = effect("Eye Bulge 2")("Bulge Center");   
  toWorld(sub(p1, p2))

fromWorldVec(vec, t=time)

Type de valeur renvoyé : Array (ensemble) [2 ou 3].

Type d’argument : vec est un ensemble (Array) [2 ou 3] et t est un nombre (Number).

Convertit un vecteur de l’espace univers dans l’espace calque. Par exemple : fromWorld(thisComp.layer(2).position).

fromCompToSurface(point, t=time)

Type de valeur renvoyé : Array (ensemble) [2].

Type d’argument : point est un ensemble (Array) [2 ou 3] et t est un nombre (Number).

Projette un point de l’espace composition à la surface du calque (valeur z à zéro) à l’endroit où il apparaît vu par la caméra active. Cette méthode est utile pour positionner des points de contrôle des effets. A n’utiliser qu’avec des calques 3D.

Les objets Camera ont les mêmes attributs et suivent les mêmes méthodes que les objets Layer à l’exception de source, effect, mask, width, height, anchorPoint, scale, opacity, audioLevels, timeRemap et de toutes les propriétés de surface.

pointOfInterest

Type de valeur renvoyé : Property [3].

Renvoie les valeurs de points ciblés d’une caméra dans l’espace univers.

zoom

Type de valeur renvoyé : Property (propriété).

Renvoie les valeurs de zoom d’une caméra en pixels.

Voici une expression pour la propriété Echelle d’un calque qui conserve la taille relative du calque dans l’image tout en modifiant la position z du calque (profondeur) ou la valeur de zoom de la caméra :

  cam = thisComp.activeCamera;  
  distance = length(sub(position, cam.position));  
  scale * distance / cam.zoom;

depthOfField

Type de valeur renvoyé : Property (propriété).

Renvoie 1 si la propriété Profondeur de champ d’une caméra est activée, ou renvoie 0 si la propriété Profondeur de champ est désactivée.

focusDistance

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur de distance de mise au point d’une caméra en pixels.

aperture

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur d’ouverture d’une caméra en pixels.

blurLevel

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur de niveau de flou d’une caméra sous forme de pourcentage.

active

Type de valeur renvoyé : Boolean (booléen).

Renvoie true (vrai) si la caméra est la caméra active pour la composition à l’instant courant : le bouton d’option Vidéo  est activé pour le calque de caméra, l’instant courant est dans la plage située entre le point d’entrée et le point de sortie du calque de caméra, et c’est le premier (le plus haut) de ces calques de caméra figurant dans le panneau Montage. Renvoie la valeur « false » dans tous les autres cas.

Les objets Light ont les mêmes attributs et suivent les mêmes méthodes que les objets Layer à l’exception de source, effect, mask, width, height, anchorPoint, scale, opacity, audioLevels, timeRemap et de toutes les propriétés de surface.

pointOfInterest

Type de valeur renvoyé : Property [3].

Renvoie les valeurs de points ciblés d’une lumière dans l’espace univers.

intensity

Type de valeur renvoyé : Property (propriété).

Renvoie les valeurs d’intensité d’une lumière sous forme de pourcentage.

color

Type de valeur renvoyé : Property [4].

Renvoie la valeur de couleur d’une lumière.

coneAngle

Type de valeur renvoyé : Property (propriété).

Renvoie l’angle du cône d’une lumière, en degrés.

coneFeather

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur du contour du cône d’une lumière sous forme de pourcentage.

shadowDarkness

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur d’obscurité de l’ombre d’une lumière sous forme de pourcentage.

shadowDiffusion

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur de diffusion de l’ombre d’une lumière en pixels.

Sur son blog omino pixel, David Van Brink a posté un article pédagogique et un projet-type qui expliquent comment utiliser les expressions avec les éclairages.

active

Type de valeur renvoyé : Boolean (booléen).

Renvoie la valeur true (vrai) si l’effet est activé (l’option Effet  est sélectionnée).

param(name)

Type de valeur renvoyé : Property (propriété).

Type d’argument : nom est une chaîne de caractères.

Renvoie une propriété d’un effet. Les points de contrôle des effets se situent toujours dans l’espace calque. Exemple :

  effect("Bulge").param("Bulge Height") 

param(index)

Type de valeur renvoyé : Property (propriété).

Type d’argument : index est un nombre (Number).

Renvoie une propriété d’un effet. Les points de contrôle des effets se situent toujours dans l’espace calque. Par exemple, effect("Bulge").param(4) renvoie la propriété de hauteur du renflement.

MaskOpacity

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur d’opacité d’un masque sous forme de pourcentage.

MaskFeather

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur de contour d’un masque, en pixels.

MaskExpansion

Type de valeur renvoyé : Property (propriété).

Renvoie la valeur d’expansion d’un masque, en pixels.

invert

Type de valeur renvoyé : Boolean (booléen).

Renvoie la valeur « true » si le masque est inversé et la valeur « false » dans le cas contraire.

value

Type de valeur renvoyé : Number (nombre), Array (ensemble) ou String (chaîne).

Renvoie la valeur d’une propriété à l’instant courant.

valueAtTime(t)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t est un nombre (Number).

Renvoie la valeur d’une propriété à l’instant indiqué, en secondes.

Par exemple, pour que la valeur de la propriété de chaque image soit choisie de manière aléatoire parmi quatre valeurs, définissez vos quatre valeurs comme des images clés à 0, 1, 2 et 3 secondes, puis appliquez l’expression suivante à la propriété :

  valueAtTime(random(4))

Remarque : Sur son site Web MotionScript, Dan Ebberts fournit d’autres exemples et techniques d’utilisation des méthodes valueAtTime et velocityAtTime.

velocity

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Renvoie la valeur de la vitesse temporelle à l’instant courant. Pour les propriétés spatiales, comme Position, il renvoie la valeur du vecteur tangent. Le résultat est de même dimension que la propriété.

velocityAtTime(t)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : t est un nombre (Number).

Renvoie la valeur de la vitesse temporelle à l’instant indiqué.

speed

Type de valeur renvoyé : Number (nombre).

Renvoie une valeur de vitesse (1D et positive) égale à la vitesse à laquelle la propriété change à l’instant par défaut. Cet élément ne peut être utilisé que pour les propriétés spatiales.

speedAtTime(t)

Type de valeur renvoyé : Number (nombre).

Type d’argument : t est un nombre (Number).

Renvoie la valeur de la vitesse spatiale à l’instant indiqué.

wiggle(freq, amp, octaves=1, amp_mult=.5, t=time)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : freq, amp, octaves, amp_mult et t sont des nombres (Number).

Applique un tremblement aléatoire (secousses) à la valeur de la propriété.

La valeur freq est la fréquence en tremblements par seconde.

La valeur amp est l’amplitude en unités de la propriété à laquelle elle est appliquée.

La valeur octaves est le nombre d’octaves de bruit à cumuler. Cette valeur permet de contrôler le niveau de détail dans le tremblement. Choisissez une valeur supérieure à 1 (par défaut) pour inclure des fréquences plus élevées, ou inférieure pour inclure des harmoniques d’amplitude dans le tremblement.

amp_mult est la valeur par laquelle amp est multiplié pour chaque octave. Cette valeur permet de contrôler la vitesse de filtrage des harmoniques. La valeur par défaut est 0,5 ; une valeur plus proche de 1 permet d’ajouter des harmoniques de même amplitude que la fréquence de base, alors qu’une valeur plus proche de 0 permet d’ajouter moins de détails.

t représente l’instant de départ de base. Cette valeur est établie par défaut à l’instant courant. Utilisez ce paramètre si vous souhaitez obtenir un tremblement de la valeur de la propriété échantillonnée à un instant différent.

Exemple : position.wiggle(5, 20, 3, .5) génère environ 5 tremblements par seconde avec une taille moyenne de 20 pixels. En plus du tremblement principal, il est possible de produire deux niveaux supplémentaires de tremblements détaillés à une fréquence de 10 et 20 tremblements par seconde, et des tailles respectives de 10 et 5 pixels.

Dans cet exemple, qui porte sur une propriété à deux dimensions telle que Echelle, les deux dimensions tremblent avec la même intensité :

  v = wiggle(5, 10); 
  [v[0], v[0]]

Cet exemple, sur une propriété à deux dimensions, tremble uniquement le long de l’axe y :

  freq = 3; 
  amp = 50; 
  w = wiggle(freq,amp); 
  [value[0],w[1]];

Sur le forum AE Enhancers, Paul Tuersley propose un script qui ajoute automatiquement les expressions wiggle, smooth et loop à une sélection de propriétés.

Dan Ebberts propose, sur son site Web MotionScript, un exemple d’expression, assorti d’une explication détaillée, qui illustre l’utilisation du paramètre temporel de la méthode de tremblement pour créer une animation en boucle.

Kert Gartner propose sur le site Web VFX Haiku un didacticiel vidéo qui explique comment ajouter un mouvement organique aux images à l’aide de la méthode d’expression tremblement sur les coins Marionnette.

temporalWiggle(freq, amp, octaves=1, amp_mult=.5, t=time)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : freq, amp, octaves, amp_mult et t sont des nombres (Number).

Echantillonne la propriété à l’instant de tremblement. La valeur freq mesure la fréquence en tremblements par seconde ; amp mesure l’amplitude en unités de la propriété à laquelle il s’applique ; octaves est le nombre d’octaves à cumuler ; amp_mult est le multiplicateur de amp pour chaque octave et t est l’instant de départ de base. Pour que cette fonction soit significative, la propriété qu’elle échantillonne doit être animée puisqu’elle n’altère que le moment de l’échantillonnage et non sa valeur. Par exemple : scale.temporalWiggle(5, .2).

smooth(width=.2, samples=5, t=time)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Type d’argument : width, samples et t sont des nombres (Number).

Lisse la valeur de la propriété dans le temps, en convertissant les variations importantes et brèves de la valeur en variations plus petites et réparties de manière uniforme. Ce lissage s’effectue en appliquant à la valeur de la propriété un filtre « Box » à l’instant indiqué. width est la plage de temps (en secondes) sur laquelle la moyenne du filtre est évaluée. La valeur samples est égale au nombre d’échantillons discrets, répartis uniformément dans le temps. Une valeur plus élevée permet d’obtenir un meilleur lissage (mais une performance moindre). Il est préférable que samples soit impair afin que la valeur à l’instant courant soit incluse dans la moyenne. Par exemple : position.smooth(.1, 5).

loopIn(type="cycle", numKeyframes=0)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Lit en boucle, vers l’avant, un segment de durée mesuré à partir de la première image clé du calque jusqu’au point de sortie du calque. La boucle est lue à partir du point d’entrée du calque. La valeur numKeyframes définit le segment qui est lu en boucle : ce segment correspond à la partie du calque qui va de la première image clé à l’image clé numKeyframes+1. Par exemple, loopIn("cycle", 3) lit en boucle le segment délimité par la première et la quatrième image clé. La valeur par défaut, 0, indique que toutes les images clés seront lues en boucle.

Les méthodes de lecture en boucle des images clés permettent de répéter une série d’images clés. Vous pouvez utiliser ces méthodes sur la plupart des propriétés. Sont exclues les propriétés qu’il est impossible d’exprimer par des valeurs numériques simples dans le panneau Montage, notamment la propriété Texte source, les propriétés de tracés de formes et la propriété Histogramme de l’effet Niveaux. Si elles sont trop grandes, les valeurs d’images clés ou de durées indiquées sont ramenées à la valeur maximale autorisée. De trop petites valeurs produisent une boucle constante.

Type de boucle	Résultat
cycle	(par défaut) Répète le segment spécifié.
pingpong	Répète le segment spécifié en alternant les répétitions vers l’avant et vers l’arrière.
offset	Répète le segment spécifié tout en décalant chaque cycle selon la différence de la valeur de la propriété au début et à la fin du segment, multipliée par le nombre de lectures en boucle du segment.
continue	Ne répète pas le segment spécifié, mais continue à animer une propriété en fonction de la rapidité de la première ou de la dernière image clé. Par exemple, si la dernière image clé de la propriété Echelle d’un calque indique 100 %, le calque continue sa mise à l’échelle, à partir de la valeur 100 % jusqu’au point de sortie au lieu de retourner directement au point de sortie. Ce type n’accepte pas les arguments images clés ou de durée.

Todd Kopriva propose, sur son blog, un exemple de projet illustrant l’utilisation des méthodes loopIn et loopOut, ainsi que de l’ensemble des types de boucle.

Sur le forum AE Enhancers, Paul Tuersley propose un script qui ajoute automatiquement les expressions wiggle, smooth et loop à une sélection de propriétés.

loopOut(type="cycle", numKeyframes=0)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Lit en boucle, vers l’arrière, un segment de durée mesuré à partir de la dernière image clé du calque jusqu’au point d’entrée du calque. La boucle est lue jusqu’au point de sortie du calque. Le segment à lire en boucle est déterminé par le nombre d’images clés spécifié. La valeur numKeyframes indique le nombre de segments d’images clés à lire en boucle ; la plage spécifiée est mesurée à partir de la dernière image clé. Par exemple, loopOut("cycle", 1) lit en boucle le segment délimité par la dernière image clé et l’avant-dernière image clé. La valeur par défaut, 0, indique que toutes les images clés seront lues en boucle. Consultez l’entrée loopIn pour plus de détails.

Sur son blog omino pixel, David Van Brink met à disposition un article pédagogique et un projet-type qui expliquent comment utiliser les effets Echo et Laboratoire de particules, ainsi que la méthode loopOut, pour animer un nid grouillant de bactéries stylisées.

loopInDuration(type="cycle", duration=0)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Lit en boucle, vers l’avant, un segment de durée mesuré à partir de la première image clé du calque jusqu’au point de sortie du calque. La boucle est lue à partir du point d’entrée du calque. Le segment à lire en boucle est déterminé par la durée spécifiée. La valeur Duration indique le nombre de secondes de la composition à lire en boucle dans le segment ; la plage spécifiée est mesurée à partir de la première image clé. Par exemple, loopInDuration("cycle", 1) lit en boucle la première seconde de la totalité de l’animation. La valeur par défaut, 0, indique que le segment à lire en boucle doit commencer au point de sortie du calque. Consultez l’entrée loopIn pour plus de détails.

loopOutDuration(type="cycle", duration=0)

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Lit en boucle, vers l’arrière, un segment de durée mesuré à partir de la dernière image clé du calque jusqu’au point d’entrée du calque. La boucle est lue jusqu’au point de sortie du calque. Le segment à lire en boucle est déterminé par la durée spécifiée. La valeur Duration indique le nombre de secondes de la composition à lire en boucle dans le segment ; la plage spécifiée est mesurée à partir de la dernière image clé. Par exemple, loopOutDuration("cycle", 1) lit en boucle la dernière seconde de la totalité de l’animation. La valeur par défaut, 0, indique que le segment à lire en boucle doit commencer au point d’entrée du calque. Consultez l’entrée loopIn pour plus de détails.

key(index)

Type de valeur renvoyé : Key ou MarkerKey.

Type d’argument : index est un nombre (Number).

Renvoie l’objet Key ou MarkerKey en fonction de son numéro. Par exemple, key(1) renvoie la première image clé.

key(markerName)

Type de valeur renvoyé : MarkerKey (clé de repère).

Type d’argument : markerName est une chaîne de caractères (String).

Renvoie l’objet MarkerKey portant ce nom. A n’utiliser qu’avec les propriétés de repère.

nearestKey(t)

Type de valeur renvoyé : Key ou MarkerKey.

Renvoie l’objet Key ou MarkerKey le plus proche de l’instant spécifié.

numKeys

Type de valeur renvoyé : Number (nombre).

Renvoie le nombre d’images clés d’une propriété. Renvoie le nombre de repères d’une propriété de repère.

Remarque : si vous utilisez la commande Séparer les dimensions pour séparer les dimensions de la propriété Position afin d’obtenir des composants individuels, le nombre d’images clés change et la valeur renvoyée par cette méthode est alors modifiée.

propertyGroup(countUp = 1)

Type de valeur renvoyé : Group.

Renvoie un groupe de propriétés lié à la propriété sur laquelle l’expression est écrite. Si, par exemple, vous ajoutez l’expression propertyGroup(1) à la propriété Rotation d’un tracé, l’expression prend comme cible le groupe de propriétés Transformer qui contient la propriété Rotation. Si, en revanche, vous ajoutez propertyGroup(2), l’expression prend comme cible le groupe de propriétés Pinceau. Cette méthode vous permet d’établir des relations entre des propriétés, indépendamment de leur nom. Cette méthode s’avère particulièrement utile lors de la duplication de propriétés contenant des expressions.

La méthode numProperties pour propertyGroup renvoie le nombre de propriétés dans le groupe de propriétés.

L’exemple suivant renvoie le nombre de propriétés du groupe contenant la propriété sur laquelle l’expression est rédigée :

  thisProperty.propertyGroup(1).numProperties

propertyIndex

Type de valeur renvoyé : Number (nombre).

Renvoie l’index d’une propriété par rapport à d’autres propriétés de son groupe de propriétés, y compris les groupes de propriétés contenus dans les masques, effets, animations de texte, sélecteurs, formes, suivis et points de suivi.

name

Type de valeur renvoyé : String (chaîne).

Renvoie le nom de la propriété ou du groupe de propriétés.

Exemple : réalisation d’une animation à l’aide de la méthode propertyGroup et de l’attribut propertyIndex

Valeurs de propertyGroup relatives à la propriété Position du tracé d’un pinceau

A.

propertyGroup(4)

B.

propertyGroup(3)

C.

propertyGroup(2)

D.

propertyGroup(1)

E.

La valeur propertyIndex de la propriété Position est 2 ; la valeur propertyIndex de la propriété Rotation est 4.

Dans cet exemple, la méthode propertyGroup de chaque tracé prend comme cible le groupe de propriétés Pinceau car ce groupe se trouve deux groupes de propriétés plus haut que la propriété Rotation. L’attribut propertyIndex de chaque tracé renvoie alors une valeur unique pour chaque tracé. La valeur obtenue est alors multipliée par l’instant et par 200 ; elle est ensuite appliquée à chacune des valeurs de rotation, ce qui fait pivoter chaque tracé selon un angle unique et crée des tracés de peinture tourbillonnants :

  propertyGroup(2).propertyIndex * time * 200

Animation d’un tracé à l’aide d’une expression

Lorsque vous accédez à un objet Key, vous pouvez obtenir les propriétés time, index et value. L’expression suivante, par exemple, vous indique la valeur de la troisième image clé Position : position.key(3).value.

  d = Math.abs(time - nearestKey(time).time); 
  easeOut(d, 0, .1, 100, 0)

value

Type de valeur renvoyé : Number (nombre) ou Array (ensemble).

Renvoie la valeur de l’image clé.

time

Type de valeur renvoyé : Number (nombre).

Renvoie l’instant de l’image clé.

index

Type de valeur renvoyé : Number (nombre).

Renvoie l’index de l’image clé.

Vous pouvez utiliser les mêmes méthodes pour accéder aux valeurs des repères de composition et de calque. Utilisez l’objet thisLayer.marker pour accéder aux repères de calque et l’objet thisComp.marker pour accéder aux repères de composition.

Dans le cas d’expressions, les repères consistent en un type spécial d’objet Key. Vous pouvez donc accéder aux repères à l’aide de méthodes de type nearestKey(time). Les repères ont également des attributs time et index. L’attribut index n’est pas le numéro (nom) du repère, mais le numéro d’index de l’image clé. Il représente la place du repère sur l’échelle de temps.

Les expressions ont accès à toutes les valeurs d’un repère définies dans la boîte de dialogue Repère de composition ou Repère de calque. Cette expression inscrite dans la propriété Texte source d’un calque de texte affiche différentes données (instant, durée, index, commentaire (nom), chapitre, URL, image cible et nom du signal de départ du repère de calque le plus proche de l’instant courant) et indique si le repère est destiné à un signal de départ d’événement :

  m = thisLayer.marker.nearestKey(time);  
  s = "time:" + timeToCurrentFormat(m.time) + "\r" +  
      "duration: " + m.duration + "\r" +  
      "key index: " + m.index + "\r" +  
      "comment:" + m.comment + "\r" +  
      "chapter:" + m.chapter + "\r" +  
      "URL:" + m.url + "\r" +  
      "frame target: " + m.frameTarget + "\r" +  
      "cue point name: " + m.cuePointName + "\r" +  
      "Event cue point? " + m.eventCuePoint + "\r";  
  for (param in m.parameters){  
       s += "parameter: " + param + " value: " + m.parameters[param] + "\r";  
  } 
  s

Etant donné que les métadonnées XMP d’un élément de métrage peuvent être converties en repères de calque sur la base de cet élément, les expressions peuvent interagir avec des métadonnées XMP. Pour plus d’informations, reportez-vous à la section Métadonnées XMP dans After Effects.

Dan Ebberts propose, dans la section After Effects Developer Center du site Web d’Adobe, un didacticiel illustrant l’utilisation de métadonnées XMP avec des expressions.

duration

Type de valeur renvoyé : Number (nombre).

Durée des repères (en secondes).

comment

Type de valeur renvoyé : String (chaîne).

Contenu du champ Commentaires de la boîte de dialogue Repère.

chapter

Type de valeur renvoyé : String (chaîne).

Contenu du champ Chapitre de la boîte de dialogue Repère.

url

Type de valeur renvoyé : String (chaîne).

Contenu du champ URL de la boîte de dialogue Repère.

frameTarget

Type de valeur renvoyé : String (chaîne).

Contenu du champ Image cible de la boîte de dialogue Repère.

eventCuePoint

Type de valeur renvoyé : Boolean (booléen).

Type de signal de départ paramétré dans la boîte de dialogue Repère. « True » pour Evénement ; « false » pour Navigation.

cuePointName

Type de valeur renvoyé : String (chaîne).

Contenu du champ Nom du signal de départ de la boîte de dialogue Repère.

parameters

Type de valeur renvoyé : ensemble associatif (Array) de valeurs de chaîne (String).

Contenu des champs Nom du paramètre et Valeur du paramètre de la boîte de dialogue Repère.

Par exemple, s’il existe un paramètre appelé « background color » (couleur d’arrière-plan), vous pouvez utiliser l’expression suivante pour accéder à sa valeur au repère le plus proche :

  thisComp.marker.nearestKey(time).parameters["background color"]