Guide d'utilisation Annuler

Exemples d’expressions

Télécharger un exemple de projet

Telechargement

Tremblement aléatoire

L’expression « tremblement » est l’une des expressions les plus courantes d’After Effects. Il fait basculer un objet sur des valeurs aléatoires. Vous pouvez utiliser cette expression pour rendre votre scène plus naturelle. Vous ajoutez cette expression à la propriété Position du calque.

  1. Sélectionnez un calque dans votre composition.

  2. Appuyez sur la touche P pour afficher la propriété Position dans le panneau Montage.

  3. Cliquez sur Alt (Windows) ou Option (macOS) sur le chronomètre à gauche du nom de la propriété.

  4. Entrez l’extrait de code suivant dans le champ d’expression :

    tremblement (2,30)
    tremblement (2,30)
    tremblement (2,30)

    Par exemple, tremblement (fréquence, quantité) où le premier nombre correspond au nombre de tremblements par seconde et le second à la valeur du tremblement. Ainsi, l’utilisation de tremblement(2,30) fera trembler le calque 2 fois par seconde jusqu’à 30 pixels dans n’importe quelle direction.

Contrôler un tremblement avec les commandes Curseur

Les expressions peuvent être encadrées par des images-clés en remplaçant les valeurs par des liens vers des contrôles d’expression, comme un contrôle du curseur. En remplaçant le deuxième argument de l’expression wiggle() par un lien vers un contrôle du curseur, vous pouvez créer une image-clé du comportement pour qu’il démarre et s’arrête à des moments spécifiques.

  1. Ajoutez un effet Contrôle du curseur à n’importe quel calque et nommez-le Nombre de tremblements.

  2. Appliquez l’expression suivante à la propriété Position du même calque :

    // Utilise l’icône de sélection pour créer le lien « effect(...) » vers le Curseur
    var wiggleAmount = effect(« Wiggle Amount »)(« Slider ») ;
    // Tremble 4 fois par seconde par la quantité définie par le Curseur
    wiggle( 4, wiggleAmount ) ;
    // Utilise l’icône de sélection pour créer le lien « effect(...) » vers le Curseur var wiggleAmount = effect(« Wiggle Amount »)(« Slider ») ; // Tremble 4 fois par seconde par la quantité définie par le Curseur wiggle( 4, wiggleAmount ) ;
    // Utilise l’icône de sélection pour créer le lien « effect(...) » vers le Curseur
    var wiggleAmount = effect(« Wiggle Amount »)(« Slider ») ;
    
     // Tremble 4 fois par seconde par la quantité définie par le Curseur
     wiggle( 4, wiggleAmount ) ;
    

Le calque tourne en cercle

Vous pouvez également créer des expressions ne faisant pas appel aux propriétés d’autres calques. Par exemple, vous pouvez faire tourner un calque autour du centre de la composition.

  1. Sélectionnez un calque dans votre composition.

  2. Appuyez sur la touche P pour afficher la propriété Position dans le panneau Montage.

  3. Cliquez sur Alt (Windows) ou Option (macOS) sur le chronomètre à gauche du nom de la propriété.

  4. Entrez l’extrait de code suivant dans le champ d’expression :

    var centerOfComp = [ ( thisComp.width / 2 ), ( thisComp.height / 2) ] ;
    var circleOverTime = [ Math.sin( time ) * 50, -Math.cos( time ) * 50 ] ;
    centerOfComp + circleOverTime ;
    var centerOfComp = [ ( thisComp.width / 2 ), ( thisComp.height / 2) ] ; var circleOverTime = [ Math.sin( time ) * 50, -Math.cos( time ) * 50 ] ; centerOfComp + circleOverTime ;
    var centerOfComp = [ ( thisComp.width / 2 ), ( thisComp.height / 2) ] ;
    var circleOverTime = [ Math.sin( time ) * 50, -Math.cos( time ) * 50 ] ;
    centerOfComp + circleOverTime ;

Dépassement

Communément appelée rebond inertiel, cette expression utilise l’animation des propres images-clés d’un calque pour créer un dépassement naturel. Elle crée un mouvement de rebond de n’importe quel paramètre d’une image clé à l’autre, en fonction de sa vitesse. Le rebond se produit dans n’importe quelle direction où l’objet se déplace. Pour obtenir cette animation : 

  1. Créez ou importez vos objets graphiques dans After Effects.

  2. Ajoutez des images-clés à la propriété Position du calque que vous voulez animer.

  3.  Ajoutez l’expression suivante à la propriété Position du calque :

    // Définit des valeurs pour contrôler le dépassement.
    // Liez-les aux contrôles d’expression Curseur pour prévisualiser rapidement différents paramètres.
    var amp = 40;
    var freq = 30;
    var decay = 50;
    // Finds the most recent keyframe
    var nK = nearestKey(time);
    var n = (nK.time <= time) ? nK.index : --nK.index;
    var t = (n === 0) ? 0 : time - key(n).time;
    // Si l’heure actuelle est postérieure à une image-clé, calculez le dépassement.
    // Si ce n’est pas le cas, utilisez la valeur d’origine.
    if ( n > 0 && t < 1 ) {
    var v = velocityAtTime( key( n ).time - thisComp.frameDuration /10 );
    value + v * amp * .001 * Math.sin(freq * .1 * t * 2 * Math.PI) / Math.exp(decay * .1 * t);
    } else {
    value;
    }
    // Définit des valeurs pour contrôler le dépassement. // Liez-les aux contrôles d’expression Curseur pour prévisualiser rapidement différents paramètres. var amp = 40; var freq = 30; var decay = 50; // Finds the most recent keyframe var nK = nearestKey(time); var n = (nK.time <= time) ? nK.index : --nK.index; var t = (n === 0) ? 0 : time - key(n).time; // Si l’heure actuelle est postérieure à une image-clé, calculez le dépassement. // Si ce n’est pas le cas, utilisez la valeur d’origine. if ( n > 0 && t < 1 ) { var v = velocityAtTime( key( n ).time - thisComp.frameDuration /10 ); value + v * amp * .001 * Math.sin(freq * .1 * t * 2 * Math.PI) / Math.exp(decay * .1 * t); } else { value; }
    // Définit des valeurs pour contrôler le dépassement.
    // Liez-les aux contrôles d’expression Curseur pour prévisualiser rapidement différents paramètres. 
    var amp = 40; 
    var freq = 30; 
    var decay = 50; 
     
    // Finds the most recent keyframe 
    var nK = nearestKey(time); 
    var n = (nK.time <= time) ? nK.index : --nK.index; 
    var t = (n === 0) ? 0 : time - key(n).time; 
     
    // Si l’heure actuelle est postérieure à une image-clé, calculez le dépassement.
    // Si ce n’est pas le cas, utilisez la valeur d’origine. 
    if ( n > 0 && t < 1 ) { 
        var v = velocityAtTime( key( n ).time - thisComp.frameDuration /10 );  
        value + v * amp * .001 * Math.sin(freq * .1 * t * 2 * Math.PI) / Math.exp(decay * .1 * t); 
    } else { 
          value; 
    }

Rotation avec le temps

Vous pouvez utiliser lʼicône de sélection pour lier les valeurs de rotation entre plusieurs calques afin dʼanimer les objets. Façon dont tourne une horloge. Considérez ces trois cercles comme les trois aiguilles de lʼhorloge, avec un écoulement du temps identique : lʼaiguille des heures se déplace dʼheure en heure et lʼaiguille des minutes effectue un tour complet du cadran.

  1. Importez ou créez trois calques de couleur unie en forme de cercles. Supposons que lʼun dʼeux fonctionne comme lʼaiguille des heures, lʼautre comme lʼaiguille des minutes et le troisième comme lʼaiguille des secondes.

  2. Définissez les points dʼancrage aux extrémités des calques.

  3. Déplacez les calques de façon à placer les points dʼancrage au centre de la composition.

  4. Positionnez les images clés de rotation de lʼaiguille des heures. Sélectionnez la propriété Rotation pour le calque de lʼaiguille des minutes et choisissez Animation > Ajouter lʼexpression.

  5. Faites glisser lʼicône de sélection sur la propriété Rotation pour le plus grand cercle. L’expression suivante est proposée :

    thisCompayer(“circle”)otation
    thisCompayer(“circle”)otation
     thisCompayer(“circle”)otation
  6. Pour faire en sorte que le deuxième cercle tourne douze fois plus vite que le premier, ajoutez *12 à la fin de lʼexpression comme suit :

    thisCompayer(“circle”)otation*12
    thisCompayer(“circle”)otation*12
    thisCompayer(“circle”)otation*12
  7. Procédez à lʼidentique pour le troisième cercle et ajoutez *24 à la fin de lʼexpression :

    thisCompayer(“circle”)otation*24
    thisCompayer(“circle”)otation*24
    thisCompayer(“circle”)otation*24

Boucle

Les expressions permettent d’exécuter une animation en boucle et de l’étendre sans ajouter d’images-clés supplémentaires. Par exemple, plusieurs formes peuvent tourner jusqu’à la fin d’une composition. Pour ce faire, ajoutez une image-clé à la propriété Rotation pour la rotation de départ, puis une autre avec la rotation de fin. Appliquer la méthode oopOut() à la propriété Rotation des images-clés, permettra ensuite au calque de continuer à tourner après la dernière image-clé.

Les arguments utilisés dans l’exemple loopOut() ci-dessous définissent le type de boucle et le nombre d’images-clés à inclure dans la boucle.

//loopOut set to cycle all keyframes
loopOut(“cycle”, 0
//loopOut set to cycle all keyframes loopOut(“cycle”, 0
//loopOut set to cycle all keyframes
loopOut(“cycle”, 0

Le premier argument est le « Cycle », l’un des quatre modes de boucle disponibles pour la méthode loopOut. Les trois autres sont « continuer », « décalage », et « ping-pong ». L’argument « cycle » commence la boucle à la dernière image-clé, en commençant à nouveau par les valeurs de la première image-clé dans la plage définie par le deuxième argument.

Le deuxième argument est le nombre d’images-clés à inclure dans la boucle, compté à rebours par rapport à la dernière image-clé. Si le deuxième argument n’est pas donné ou est défini sur 0, toutes les animations d’images-clés de la propriété seront lues en boucle après la dernière image-clé. Si l’argument est 1, l’animation se trouve entre la dernière image-clé et celle qui la précède avant d’être lue en boucle. Si l’argument est 2, l’animation en boucle se trouve entre la dernière image-clé et les deux images-clés qui la précèdent, et ainsi de suite.

Obtenir la vraie position d’un calque avec parent

Lorsqu’un calque a un parent, la valeur affichée dans sa propriété Position n’est pas son « vrai » emplacement dans la composition, mais est plutôt relative à l’emplacement de son calque parent. Pour trouver l’emplacement réel du calque avec parent, une expression doit être utilisée pour convertir l’espace de coordonnées du calque parent en espace de coordonnées de la composition. Appliquez l’expression suivante à la position d’un calque sans parent pour le lier à l’emplacement du calque avec parent :

// Définit le calque avec parent
var targetLayer = thisCompayer(“Parented Layer”
/ // Recherche le point d’ancrage du calque avec parent dans la composition
targetLayeroComp( targetLayernchorPoint
// Définit le calque avec parent var targetLayer = thisCompayer(“Parented Layer” / // Recherche le point d’ancrage du calque avec parent dans la composition targetLayeroComp( targetLayernchorPoint
// Définit le calque avec parent
var targetLayer = thisCompayer(“Parented Layer” 
 
/ // Recherche le point d’ancrage du calque avec parent dans la composition
targetLayeroComp( targetLayernchorPoint 

Retarder la position d’un calque à partir de son parent

Le retard et le décalage constituent d’excellents moyens de rendre l’animation plus dynamique et naturelle. Vous pouvez créer et contrôler ces types de décalages en associant plusieurs calques à un calque parent, puis en appliquant une expression à la position de chaque enfant pour retarder le mouvement hérité du parent.

Remarque : cela ne fonctionnera qu’avec les calques avec parents.

// Définit une durée de retard dans les images
var delay = 5;
// Décale la position du calque dans le temps en fonction retard
parent.fromComp( toComp( anchorPoint, time - framesToTime( delay ) ) );
// Définit une durée de retard dans les images var delay = 5; // Décale la position du calque dans le temps en fonction retard parent.fromComp( toComp( anchorPoint, time - framesToTime( delay ) ) );
// Définit une durée de retard dans les images
var delay = 5; 
 
// Décale la position du calque dans le temps en fonction retard
parent.fromComp( toComp( anchorPoint, time - framesToTime( delay ) ) );

Vous pouvez également déterminer la durée du retard en fonction de l’index du calque enfant par rapport au calque parent. Cela vous permet de réorganiser facilement l’animation des calques enfants en les réorganisant dans le montage sous le parent (ou au-dessus si vous souhaitez que leur animation se produise avant le parent) :

// Définit une durée de retard dans les images
var delay = 5;
// Multiplie le retard en fonction de l’index de ce calque par rapport à son parent{n}}var multiplyDelay = delay * ( index - parent.index )
// Décale la position du calque dans le temps en fonction du retard
parent.fromComp( toComp( anchorPoint, time - framesToTime( multiplyDelay ) ) );
// Définit une durée de retard dans les images var delay = 5; // Multiplie le retard en fonction de l’index de ce calque par rapport à son parent{n}}var multiplyDelay = delay * ( index - parent.index ) // Décale la position du calque dans le temps en fonction du retard parent.fromComp( toComp( anchorPoint, time - framesToTime( multiplyDelay ) ) );
// Définit une durée de retard dans les images
var delay = 5; 
// Multiplie le retard en fonction de l’index de ce calque par rapport à son parent{n}}var multiplyDelay = delay * ( index - parent.index ) 
 
// Décale la position du calque dans le temps en fonction du retard
parent.fromComp( toComp( anchorPoint, time - framesToTime( multiplyDelay ) ) );

Exemple d’expression : lancer ou arrêter le tremblement à un moment déterminé

Ajoutez l’expression suivante à la propriété Position d’un élément pour déclencher un effet de tremblement commençant 2 secondes après le début de l’animation :

var timeToStart = 2;
if (time > timeToStart) {
wiggle(3,25);
} else {
value;
}
var timeToStart = 2; if (time > timeToStart) { wiggle(3,25); } else { value; }
var timeToStart = 2; 
 
if (time > timeToStart) { 
  wiggle(3,25); 
} else { 
  value; 
}

Ajoutez l’expression suivante à la propriété Position d’un élément pour déclencher un effet de tremblement au début de l’animation et l’arrêter après 4 secondes :

var timeToStop = 4;
if ( time > timeToStop ) {
value;
} else {
wiggle( 3, 25 );
}
var timeToStop = 4; if ( time > timeToStop ) { value; } else { wiggle( 3, 25 ); }
var timeToStop = 4; 
 
if ( time > timeToStop ) { 
  value; 
} else { 
  wiggle( 3, 25 ); 
}

Ajoutez l’expression suivante à la propriété Position d’un élément pour déclencher un effet de tremblement au début après 2 secondes d’animation et l’arrêter après 4 secondes :

var timeToStart = 2;
var timeToStop = 4;
if ( ( time > timeToStart ) && ( time < timeToStop ) ) {
wiggle(3,25);
} else {
value;
}
var timeToStart = 2; var timeToStop = 4; if ( ( time > timeToStart ) && ( time < timeToStop ) ) { wiggle(3,25); } else { value; }
var timeToStart = 2; 
var timeToStop = 4; 
 
if ( ( time > timeToStart ) && ( time < timeToStop ) ) { 
  wiggle(3,25); 
} else { 
  value; 
}

Exemple d’expression : placer un calque entre deux autres

Cet exemple d’expression positionne et maintient un calque à une distance équivalente de deux autres calques.

  1. Commencez par créer trois calques.

  2. Animez les positions des deux premiers calques dans le panneau Montage.

    Conseil :

    Découvrez comment utiliser les trajectoires de mouvement.

  3. Sélectionnez le troisième calque. Appuyez sur P pour faire apparaître la propriété Position. Cliquez sur Alt (Windows) ou sur Option (macOS) sur le bouton du chronomètre à gauche du nom de la propriété.

  4. Entrez ce qui suit dans le champ d’expression :
    ( thisComp.layer(1).position + thisComp.layer(2).position ) / 2
    ( thisComp.layer(1).position + thisComp.layer(2).position ) / 2
    ( thisComp.layer(1).position + thisComp.layer(2).position ) / 2

Créer une piste d’images

Cet exemple d’expression indique qu’un calque doit rejoindre la position du calque de niveau supérieur dans le panneau Montage après un certain délai (dans ce cas, 0,5 seconde). Des expressions similaires peuvent être conçues pour d’autres propriétés géométriques.

  1. Commencez par un calque de forme mis à l’échelle à environ 30 % de la taille de la composition.

  2. Ouvrez la propriété Position et ajoutez des images-clés. Sélectionnez le calque. Appuyez sur P pour faire apparaître la propriété Position. Cliquez sur Alt (Windows) ou sur Option (macOS) sur le bouton du chronomètre à gauche du nom de la propriété.

  3. Entrez ce qui suit dans le champ d’expression :

    thisComp.layer(thisLayer, -1).position.valueAtTime(time - .5)
    thisComp.layer(thisLayer, -1).position.valueAtTime(time - .5)
    thisComp.layer(thisLayer, -1).position.valueAtTime(time - .5)
  4. Dupliquez le dernier calque cinq fois en le sélectionnant et en appuyant cinq fois sur Ctrl+D (Windows) ou Commande+D (macOS). Tous les calques suivent la même trajectoire avec un décalage de 0,5 seconde par rapport au précédent.

Exemple d’expression : créer un renflement entre deux calques

Cet exemple d’expression synchronise l’argument de centre de renflement d’un effet de renflement dans un calque avec la position d’un autre calque. Vous pouvez par exemple créer l’effet d’une loupe qui se déplace sur un calque, la portion de l’image située en dessous grossissant, par effet de renflement, au fur et à mesure que la loupe (c’est-à-dire le calque situé au-dessus) se déplace. Cette expression utilise la méthode fromWorld qui garantit un bon fonctionnement de l’expression, quels que soient les déplacements du calque loupe (ou du calque situé en dessous). L’expression restera intacte, même si vous effectuez une rotation ou un changement d’échelle sur le calque sous-jacent.

Vous pouvez utiliser d’autres effets, comme l’ondulation, avec cette expression.

  1. Commencez par créer deux calques dont l’un pour la loupe (ou objet similaire comportant un trou central) nommé « Magnifier ».

  2. Animez la position du calque Loupe.

  3. Appliquez l’effet de renflement à l’autre calque.

  4. Sélectionnez la propriété Centre de renflement de l’effet Renflement dans le panneau Montage. Choisissez Animation > Ajouter une expression, ou cliquez en maintenant enfoncée la touche Alt (Windows) ou Option (macOS) sur le bouton du chronomètre pour la propriété.

  5. Sélectionnez le texte de l’expression par défaut et entrez :
    fromWorld(thisCompayer(“Magnifier”)osition)
    fromWorld(thisCompayer(“Magnifier”)osition)
    fromWorld(thisCompayer(“Magnifier”)osition)

Exemple d’expression : atténuer l’opacité d’un calque 3D en fonction de la distance de la caméra

Appliquez l’expression suivante à la propriété Opacité d’un calque 3D :

var startFade = 500; // Commencer le fondu à 500 pixels de la caméra.
var endFade = 1500; // Terminer le fondu à 1 500 pixels de la caméra.
try {
// Vérifier s’il y a une caméra
var C = thisComp.activeCamera.toWorld([0,0,0]);
} catch ( err ) {
// Pas de caméra, supposer donc 50 mm
var w = thisComp.width * thisComp.pixelAspect;
var z = (w/2)/Math.tan(degreesToRadians(19.799));
var C = [0,0,-z];
}
var P = toWorld( anchorPoint );
var d = length( C, P );
linear( d, startFade, endFade, 100, 0 );
var startFade = 500; // Commencer le fondu à 500 pixels de la caméra. var endFade = 1500; // Terminer le fondu à 1 500 pixels de la caméra. try { // Vérifier s’il y a une caméra var C = thisComp.activeCamera.toWorld([0,0,0]); } catch ( err ) { // Pas de caméra, supposer donc 50 mm var w = thisComp.width * thisComp.pixelAspect; var z = (w/2)/Math.tan(degreesToRadians(19.799)); var C = [0,0,-z]; } var P = toWorld( anchorPoint ); var d = length( C, P ); linear( d, startFade, endFade, 100, 0 );
var  startFade = 500; // Commencer le fondu à 500 pixels de la caméra.
var  endFade = 1500; // Terminer le fondu à 1 500 pixels de la caméra.

try {
// Vérifier s’il y a une caméra
var C = thisComp.activeCamera.toWorld([0,0,0]);
} catch ( err ) {
// Pas de caméra, supposer donc 50 mm
var w = thisComp.width * thisComp.pixelAspect;
var z = (w/2)/Math.tan(degreesToRadians(19.799));
var C = [0,0,-z];
}

var P = toWorld( anchorPoint );
var d = length( C, P );

linear( d, startFade, endFade, 100, 0 );

L’ atténuation commence à une distance de 500 pixels de la caméra et se termine à 1 500 pixels de la caméra. La méthode d’interpolation linéaire sert à mapper les valeurs de distance aux valeurs d’opacité.

Exemple d’expression : obtenir un calque 3D invisible si dos à la caméra

Appliquez l’expression suivante à la propriété Opacité d’un calque 3D :

if ( toCompVec([0, 0, 1])[2] > 0 ) {
value;
} else {
0;
}
if ( toCompVec([0, 0, 1])[2] > 0 ) { value; } else { 0; }
if ( toCompVec([0, 0, 1])[2] > 0 ) {  
    value; 
} else {  
    0; 
}

Exemple d’expression : faire basculer le calque à l’horizontale si dos à la caméra

Appliquez l’expression suivante à la propriété Échelle d’un calque 3D :

if ( toCompVec([0, 0, 1])[2] > 0 ) {
value;
} else {
[ -value[0], value[1], value[2] ];
}
if ( toCompVec([0, 0, 1])[2] > 0 ) { value; } else { [ -value[0], value[1], value[2] ]; }
if ( toCompVec([0, 0, 1])[2] > 0 ) {
value;
} else {
[ -value[0], value[1], value[2] ];
}

Exemple d’expression : animer l’échelle à chaque marque de calque

Appliquez l’expression suivante à la propriété Échelle pour faire osciller un calque à chaque repère :

var n = 0;
var t = 0;
if (marker.numKeys > 0){
n = marker.nearestKey(time).index;
if (marker.key(n).time > time) n--;
}
if (n > 0) t = time - marker.key(n).time;
var amp = 15;
var freq = 5;
var decay = 3.0;
var angle = freq * 2 * Math.PI * t;
var scaleFact = (100 + amp * Math.sin(angle) / Math.exp(decay * t)) / 100;
[value[0] * scaleFact, value[1] / scaleFact];
var n = 0; var t = 0; if (marker.numKeys > 0){ n = marker.nearestKey(time).index; if (marker.key(n).time > time) n--; } if (n > 0) t = time - marker.key(n).time; var amp = 15; var freq = 5; var decay = 3.0; var angle = freq * 2 * Math.PI * t; var scaleFact = (100 + amp * Math.sin(angle) / Math.exp(decay * t)) / 100; [value[0] * scaleFact, value[1] / scaleFact];
var n = 0;
var t = 0;

if (marker.numKeys > 0){
n = marker.nearestKey(time).index;
if (marker.key(n).time > time) n--;
}
if (n > 0) t = time - marker.key(n).time;

var amp = 15;
var freq = 5;
var decay = 3.0;

var angle = freq * 2 * Math.PI * t;
var scaleFact = (100 + amp * Math.sin(angle) / Math.exp(decay * t)) / 100;

[value[0] * scaleFact, value[1] / scaleFact];
Remarque :

Pour ajouter un repère, sélectionnez Calque > Repères > Nouveau repère.

Vous pouvez utiliser n’importe quelle expression à la place de l’expression tremblement employée ici, pour lancer et arrêter l’influence d’une expression à un moment déterminé.

Exemple d’expression : mettre en correspondance le plan focal de la caméra avec un autre calque

Appliquez l’expression suivante à la propriété Distance de mise au point d’un calque de caméra pour que sa distance de mise au point corresponde à la distance jusqu’au point d’ancrage d’un calque appelé « Target » :

var target = thisCompayer(“target”
var V1 = targetoWorld( targetnchorPoint ) - toWorld( [ 0, 0, 0 ]
var V2 = toWorldVec( [ 0, 0, 1 ]
dot( V1, V2
var target = thisCompayer(“target” var V1 = targetoWorld( targetnchorPoint ) - toWorld( [ 0, 0, 0 ] var V2 = toWorldVec( [ 0, 0, 1 ] dot( V1, V2
var target = thisCompayer(“target”
var V1 = targetoWorld( targetnchorPoint ) - toWorld( [ 0, 0, 0 ] 
var V2 = toWorldVec( [ 0, 0, 1 ] 

dot( V1, V2 

En savoir plus sur les ressources dʼexpression

Maintenant que vous avez assimilé certains concepts sous-jacents aux expressions, rejoignez la communauté pour découvrir des exemples concrets et partager votre travail.

Recevez de l’aide plus rapidement et plus facilement

Nouvel utilisateur ?