Guida utente Annulla

Esempi di espressioni

Scaricare il progetto di esempio

Scarica

Deformazione casuale

L’espressione di deformazione è una delle espressioni più comuni in After Effects. Muove un oggetto attraverso valori casuali. Questa espressione può essere utilizzata per rendere la scena più naturale. Aggiungi questa espressione alla proprietà Posizione del livello.

  1. Seleziona un livello nella composizione.

  2. Premi P per mostrare la proprietà Posizione nel pannello della Timeline.

  3. Tieni premuto Alt (Windows) o Opzione (macOS) e clicca sul cronometro a sinistra del nome della proprietà.

  4. Immetti quanto segue nel campo dell’espressione:

    deformazione(2,30)
    deformazione(2,30)
    deformazione(2,30)

    In questo esempio, deformazione (frequenza, quantità) dove il primo numero è il numero di deformazioni al secondo e il secondo numero è il valore della deformazione. Quindi, la deformazione (2,30) farà muovere il livello 2 volte al secondo fino a 30 pixel in qualsiasi direzione.

Controlla una deformazione con i controlli del cursore

Le espressioni possono essere inserite in un fotogramma chiave sostituendo i valori con i collegamenti ai controlli delle espressioni, come un controllo del cursore. Sostituendo il secondo argomento all’espressione deformazione() con un collegamento a un controllo del cursore, è possibile avviare e interrompere il comportamento in un fotogramma chiave in momenti specifici.

  1. Aggiungi un effetto al controllo del cursore a qualsiasi livello e nominalo Quantità di deformazione.

  2. Applica la seguente espressione alla proprietà Posizione dello stesso livello:

    // Usa la frusta per creare il collegamento “effect(...)” al cursore
    var wiggleAmount = effect(“Wiggle Amount”)(“Slider”);
    // Si muove 4 volte al secondo rispetto alla quantità impostata dal cursore
    deformazione( 4, wiggleAmount );
    // Usa la frusta per creare il collegamento “effect(...)” al cursore var wiggleAmount = effect(“Wiggle Amount”)(“Slider”); // Si muove 4 volte al secondo rispetto alla quantità impostata dal cursore deformazione( 4, wiggleAmount );
    // Usa la frusta per creare il collegamento “effect(...)” al cursore 
    var wiggleAmount = effect(“Wiggle Amount”)(“Slider”); 
     
    // Si muove 4 volte al secondo rispetto alla quantità impostata dal cursore 
    deformazione( 4, wiggleAmount );

Lo strato ruota in un cerchio

Puoi creare un’espressione senza usare le proprietà di altri livelli. Ad esempio, è possibile far ruotare un livello attorno al centro della composizione.

  1. Seleziona un livello nella composizione.

  2. Premi P per mostrare la proprietà Posizione nel pannello della Timeline.

  3. Tieni premuto Alt (Windows) o Opzione (macOS) e clicca sul cronometro a sinistra del nome della proprietà.

  4. Immetti quanto segue nel campo dell’espressione:

    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;

Overshoot

Comunemente nota come rimbalzo inerziale, questa espressione utilizza l’animazione dei fotogrammi chiave di un livello per creare un superamento naturale. Crea un movimento di rimbalzo di qualsiasi parametro da un fotogramma chiave al successivo, in base alla sua velocità. Il rimbalzo avviene in qualunque direzione l’oggetto stia viaggiando. Per ottenere questa animazione:

  1. Crea o importa i tuoi elementi grafici in After Effects.

  2. Aggiungi fotogrammi chiave alla proprietà Posizione del livello che desideri animare.

  3.  Aggiungi la seguente espressione alla proprietà Posizione del livello:

    // Imposta i valori per controllare l’overshoot.
    // Collegali ai controlli dell’espressione Cursore per visualizzare rapidamente in anteprima diverse impostazioni.
    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;
    // Se l’ora attuale è successiva a un fotogramma chiave, calcola l’overshoot.
    // In caso contrario, usa il valore originale.
    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;
    }
    // Imposta i valori per controllare l’overshoot. // Collegali ai controlli dell’espressione Cursore per visualizzare rapidamente in anteprima diverse impostazioni. 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; // Se l’ora attuale è successiva a un fotogramma chiave, calcola l’overshoot. // In caso contrario, usa il valore originale. 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; }
    // Imposta i valori per controllare l’overshoot.  
    // Collegali ai controlli dell’espressione Cursore per visualizzare rapidamente in anteprima diverse impostazioni. 
    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; 
     
    // Se l’ora attuale è successiva a un fotogramma chiave, calcola l’overshoot. 
    // In caso contrario, usa il valore originale.
    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; 
    }

Ruota con il tempo

Puoi usare il selettore per collegare i valori di rotazione tra livelli per animare gli oggetti. In modo analogo a un orologio, considera questi tre cerchi come tre lancette: la lancetta delle ore si sposta di ora in ora, la lancetta dei minuti ruota lungo l’intera circonferenza del quadrante.

  1. Importa o crea tre livelli di cerchi in tinta unita. Supponiamo che uno di loro funzioni come una lancetta delle ore, l’altro come lancetta dei minuti e il terzo come lancetta dei secondi.

  2. Imposta i punti di ancoraggio alla fine dei livelli.

  3. Sposta i livelli in modo che i punti di ancoraggio siano al centro della composizione.

  4. Imposta i fotogrammi chiave di Rotazione per la lancetta delle ore. Seleziona la proprietà Rotazione come lancetta dei minuti e scegli Animazione > Aggiungi espressione.

  5. Trascina il selettore sulla proprietà Rotazione per il cerchio più grande. Viene visualizzata la seguente espressione: 

    thisCompayer(“circle”)otation
    thisCompayer(“circle”)otation
     thisCompayer(“circle”)otation
  6. Per far ruotare il secondo cerchio 12 volte più velocemente del primo, aggiungi *12 alla fine dell’espressione come segue:

    thisCompayer(“circle”)otation*12
    thisCompayer(“circle”)otation*12
    thisCompayer(“circle”)otation*12
  7. Ripeti la stessa operazione con il terzo cerchio e aggiungi *24 alla fine dell’espressione:

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

Ciclo

Le espressioni possono essere utilizzate per eseguire in ciclo ed estendere l’animazione senza aggiungere altri fotogrammi chiave, ad esempio più forme possono essere fatte girare fino al termine di una composizione. A tale scopo, aggiungi un fotogramma chiave alla proprietà Rotazione per la rotazione iniziale e poi un altro per la rotazione finale. Applicando il metodo loopOut() alla proprietà Rotazione dei fotogrammi chiave, il livello continuerà a girare dopo l’ultimo fotogramma chiave.

Gli argomenti utilizzati nell’esempio di loopOut() riportato di seguito impostano il tipo di ciclo e il numero di fotogrammi chiave da includere nel ciclo.

//loopOut è impostato per scorrere tutti i fotogrammi chiave
loopOut(“cycle”, 0);
//loopOut è impostato per scorrere tutti i fotogrammi chiave loopOut(“cycle”, 0);
//loopOut è impostato per scorrere tutti i fotogrammi chiave 
loopOut(“cycle”, 0);

Il primo argomento è “ciclo”, una delle quattro modalità di ciclo disponibili per il metodo di loopOut. Gli altri tre sono “continua”, “scostamento” e “ping-pong”“ciclo” inizia ad eseguire in ciclo dall’ultimo fotogramma chiave, ripartendo dai valori del primo fotogramma chiave nell’intervallo definito dal secondo argomento.

Il secondo argomento è il numero di fotogrammi chiave da includere nel ciclo, contati all’indietro rispetto all’ultimo fotogramma chiave. Se il secondo argomento non è specificato o è impostato su 0, l’animazione di tutti i fotogrammi chiave sulla proprietà viene eseguita in ciclo continuo dopo l’ultimo fotogramma chiave. Se l’argomento è 1, l’animazione tra l’ultimo fotogramma chiave e quello precedente avverrà con ciclo continuo. Se l'argomento è 2, l’animazione con ciclo continuo si troverà tra l’ultimo fotogramma chiave e i due fotogrammi chiave precedenti ad esso, e così via.

Ottienere la vera posizione di un livello dipendente

Quando un livello è dipendente, il valore mostrato nella sua proprietà Posizione non è la posizione “reale” nella composizione, ma è invece relativo alla posizione del livello principale. Per trovare la posizione reale del livello dipendente, è necessario utilizzare un’espressione per convertire lo spazio delle coordinate del livello principale nello spazio delle coordinate della composizione. Applica la seguente espressione alla Posizione di un livello non dipendente per collegarlo alla posizione del livello dipendente:

// Definisce il livello dipendente
var targetLayer = thisComp.layer(“Parented Layer”);
// Trova il punto di ancoraggio del livello dipendente nella Composizione
targetLayer.toComp( targetLayer.anchorPoint );
// Definisce il livello dipendente var targetLayer = thisComp.layer(“Parented Layer”); // Trova il punto di ancoraggio del livello dipendente nella Composizione targetLayer.toComp( targetLayer.anchorPoint );
// Definisce il livello dipendente 
var targetLayer = thisComp.layer(“Parented Layer”); 
 
// Trova il punto di ancoraggio del livello dipendente nella Composizione 
targetLayer.toComp( targetLayer.anchorPoint );

Ritardare la posizione di un livello dal livello principale

Il ritardo e lo scostamento sono delle ottime modalità per rendere l’animazione più dinamica e naturale. È possibile creare e controllare questi tipi di scostamento associando più livelli a un livello principale e poi applicando un’espressione alla Posizione di ciascun livello dipendente per ritardare il movimento ereditato dal livello principale.

Nota: funziona solo con i livelli dipendenti.

// Imposta una quantità di ritardo in fotogrammi
var delay = 5;
// Compensa la posizione del livello nel tempo in base al ritardo
parent.fromComp( toComp( anchorPoint, time - framesToTime( delay ) ) );
// Imposta una quantità di ritardo in fotogrammi var delay = 5; // Compensa la posizione del livello nel tempo in base al ritardo parent.fromComp( toComp( anchorPoint, time - framesToTime( delay ) ) );
// Imposta una quantità di ritardo in fotogrammi 
var delay = 5; 
 
// Compensa la posizione del livello nel tempo in base al ritardo 
parent.fromComp( toComp( anchorPoint, time - framesToTime( delay ) ) );

Puoi anche guidare la quantità di ritardo in base all’indice del livello inferiore rispetto al livello superiore. Ciò consente di riordinare facilmente l’animazione dei livelli dipendenti nella Timeline sotto il livello principale (o sopra se si preferisce che la loro animazione avvenga prima del livello principale):

// Imposta una quantità di ritardo in fotogrammi
var delay = 5;
// Moltiplica il ritardo in base all’indice di questo livello rispetto al suo livello principale
var multiplyDelay = delay * ( index - parent.index )
// Compensa la posizione del livello nel tempo in base al ritardo
parent.fromComp( toComp( anchorPoint, time - framesToTime( multiplyDelay ) ) );
// Imposta una quantità di ritardo in fotogrammi var delay = 5; // Moltiplica il ritardo in base all’indice di questo livello rispetto al suo livello principale var multiplyDelay = delay * ( index - parent.index ) // Compensa la posizione del livello nel tempo in base al ritardo parent.fromComp( toComp( anchorPoint, time - framesToTime( multiplyDelay ) ) );
// Imposta una quantità di ritardo in fotogrammi 
var delay = 5; 
 
// Moltiplica il ritardo in base all’indice di questo livello rispetto al suo livello principale 
var multiplyDelay = delay * ( index - parent.index ) 
 
// Compensa la posizione del livello nel tempo in base al ritardo 
parent.fromComp( toComp( anchorPoint, time - framesToTime( multiplyDelay ) ) );

Esempio di espressione: iniziare o interrompere la deformazione in un tempo specifico

Aggiungi la seguente espressione alla proprietà Posizione di un elemento per avviare un effetto deformazione a partire da 2 secondi nell’animazione:

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; 
}

Aggiungi la seguente espressione alla proprietà Posizione di un elemento per avviare un effetto deformazione all’inizio dell’animazione e per interromperla dopo 4 secondi:

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 ); 
}

Aggiungi la seguente espressione alla proprietà Posizione di un elemento per avviare un effetto deformazione che inizia dopo 2 secondi dall’animazione e termina dopo 4 secondi:

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;
}

Esempio di espressione: posizionare un livello tra altri due livelli

Questo esempio di espressione posiziona e mantiene un livello a una distanza proporzionata tra altri due livelli.

  1. Inizia con creare tre livelli.

  2. Anima le posizioni dei primi due livelli nel pannello Timeline.

    Suggerimento:

    Scopri come utilizzare i Tracciati animati.

  3. Seleziona il terzo livello. Premi P per visualizzare la proprietà Posizione. Tieni premuto Alt (Windows) o Opzione (macOS) e fai clic sul pulsante cronometro a sinistra del nome della proprietà.

  4. Immetti quanto segue nel campo dell’espressione:
    ( 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

Creare una scia di immagini

Questo esempio di espressione ordina a un livello di essere nella stessa posizione del livello immediatamente superiore nel pannello Timeline, ma con un ritardo pari all’intervallo di tempo indicato (in questo caso: 0,5 secondi). Puoi impostare espressioni simili per le altre proprietà geometriche.

  1. Inizia con un livello di forma ridimensionato a circa il 30% della dimensione della composizione.

  2. Apri la proprietà Posizione e aggiungi fotogrammi chiave. Seleziona il livello. Premi P per visualizzare la proprietà Posizione. Tieni premuto Alt (Windows) o Opzione (macOS) e fai clic sul pulsante cronometro a sinistra del nome della proprietà.

  3. Immetti quanto segue nel campo dell’espressione:

    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. Duplica l’ultimo livello cinque volte selezionandolo e premendo Ctrl+D (Windows) o Command+D (macOS) cinque volte. Tutti i livelli seguono lo stesso percorso, con un ritardo di 0,5 secondi l’uno dall’altro.

Esempio di espressione: creare un rigonfiamento tra due livelli

Questo esempio di espressione sincronizza l’argomento Rigonfiamento centrale dell’effetto Rigonfiamento in un livello con la posizione di un altro livello. Ad esempio, potete creare un effetto simile a una lente di ingrandimento spostandovi sopra un livello, con il contenuto sotto la lente di ingrandimento che si gonfia non appena la lente (vale a dire il livello soprastante) si sposta. Quest'espressione utilizza il metodo fromWorld, che fa funzionare correttamente l’espressione indipendentemente dal fatto che spostiate il livello lente di ingrandimento o il livello sottostante. Potete ruotare o ridimensionare il livello sottostante, ma l’espressione rimane intatta.

Con questa espressione, puoi utilizzare anche altri effetti, ad esempio Increspatura.

  1. Inizia con la creazione di re due livelli. Rendi un livello una lente di ingrandimento o un oggetto simile con un foro al centro e nominalo Lente di ingrandimento.

  2. Anima la posizione del livello lente di ingrandimento.

  3. Applica l’effetto Rigonfiamento all’altro livello.

  4. Seleziona la proprietà Rigonfiamento centrale dell’effetto Rigonfiamento nel pannello Linea temporale. scegli Animazione > Aggiungi espressione o tieni premuto Alt (Windows) o Opzione (macOS) e fai clic sul pulsante cronometro per la proprietà.

  5. Seleziona il testo dell’espressione predefinito e digita quanto segue:
    fromWorld(thisCompayer(“Magnifier”)osition)
    fromWorld(thisCompayer(“Magnifier”)osition)
    fromWorld(thisCompayer(“Magnifier”)osition)

Esempio di espressione: dissolvere l’opacità di un livello 3D in base alla distanza dalla videocamera

Applica la seguente espressione alla proprietà Opacità di un livello 3D:

var startFade = 500; // Inizio dissolvenza 500 pixels dalla videocamera.
var endFade = 1500; // Fine dissolvenza 1500 pixels dalla videocamera.
prova {
// Controlla che ci sia una videocamera
var C = thisComp.activeCamera.toWorld([0,0,0]);
} catch ( err ) {
// Nessuna videocamera, presupponi 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; // Inizio dissolvenza 500 pixels dalla videocamera. var endFade = 1500; // Fine dissolvenza 1500 pixels dalla videocamera. prova { // Controlla che ci sia una videocamera var C = thisComp.activeCamera.toWorld([0,0,0]); } catch ( err ) { // Nessuna videocamera, presupponi 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; // Inizio dissolvenza 500 pixels dalla videocamera.
var  endFade = 1500;  // Fine dissolvenza 1500 pixels dalla videocamera.  

prova {
 // Controlla che ci sia una videocamera
 var C = thisComp.activeCamera.toWorld([0,0,0]);
} catch ( err ) {
 // Nessuna videocamera, presupponi 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 );

La dissolvenza inizia a una distanza di 500 pixel dalla videocamera ed è completa a 1500 pixel dalla videocamera. Il metodo di interpolazione lineare è usato per mappare i valori della distanza sui valori dell’opacità.

Esempio di espressione: rendere invisibile un livello 3D se rivolto in direzione contraria alla videocamera

Applica la seguente espressione alla proprietà Opacità di un livello 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; 
}

Esempio di espressione: capovolgere un livello in orizzontale se rivolto in direzione contraria alla videocamera

Applica la seguente espressione alla proprietà Scala di un livello 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] ];
}

Esempio di espressione: animare la scala su ogni marcatore livello

Applica la seguente espressione a una proprietà Scala perché un livello si deformi ad ogni marcatore:

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];
Nota:

Per aggiungere un marcatore, seleziona Livello > Marcatori > Nuovo Marcatore.

Puoi usare qualsiasi espressione al posto dell’espressione deformazione usata qui, per iniziare e terminare l’influenza di qualsiasi espressione in un tempo specifico.

Esempio di espressione: effettuare la corrispondenza del piano focale della videocamera con un altro livello

Applica la seguente espressione alla proprietà Distanza focale di un livello della videocamera perché la sua distanza focale corrisponda a quella fino al punto di ancoraggio di un livello denominato “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 

Ulteriori risorse sulle espressioni

Una volta compresi alcuni dei concetti base delle espressioni, visita la community, dove puoi trovare alcuni esempi concreti e condividere il tuo lavoro.

Ottieni supporto in modo più facile e veloce

Nuovo utente?