Presenta

35
After Effects

Expresiones
Imprescindibles
Txetxu de la Portilla
After Effects - 35 Expresiones Imprescindibles
1. Animación Aleatoria - Wiggle.......................................................................................pg.1
2. Animación Aleatoria en una Dimensión - Wiggle.................................................pg.1
3. Escala Uniforme - Wiggle.................................................................................................pg.2
4. Bucle Animación Aleatoria - Wiggle..........................................................................pg.2
5. Animación Aleatoria - Wiggle Entrecortado..........................................................pg.2
6. Péndulo...................................................................................................................................pg.3
7. Péndulo 2...............................................................................................................................pg.3
8. Animación Aleatoria 2....................................................................................................pg.4
9. Mantener Animación Aleatoria - Wiggle.................................................................pg.5
10. Ondulaciones......................................................................................................................pg.6
11. Girar........................................................................................................................................pg.6
12. Lanzar....................................................................................................................................pg.7
13. Time........................................................................................................................................pg.7
14. Rebote Inercial...................................................................................................................pg.8
15. Rebote.................................................................................................................................pg.10
16. Rebote 2.............................................................................................................................pg.11
17. Bucles..................................................................................................................................pg.12
18. Espiral..................................................................................................................................pg.12
19. Encoger y Estirar.............................................................................................................pg.13
20. Números Binarios Aleatorios......................................................................................pg.13
21. Movimiento Aleatorio de Capas................................................................................pg.14
22. Movimiento Aleatorio de Líneas...............................................................................pg.15
23. Animación Básica con Audio....................................................................................pg.15
24. Aparecen Capas con el Audio..................................................................................pg.16
25. Empezar Movimiento con Audio...........................................................................pg.17
26. Transición Automática.................................................................................................pg.18
27. Rastro de Movimiento................................................................................................pg.18
28. Conexión Elástica...........................................................................................................pg.19
29. Remapeo de Tiempo Controlado por Audio......................................................pg.20
30. Remapeo de Tiempo Entrecortado.........................................................................pg.20
31. Panorámica y Exploración Aleatoria.......................................................................pg.21
32. Esconder Capa Cuando la Cámara no Mira......................................................pg.23
33. Orientar Automáticamente al Eje Y.......................................................................pg.23
34. Cronómetro......................................................................................................................pg.24
35. Contador Universal.......................................................................................................pg.25
 1.Animación Aleatoria - wiggle

Para conseguir una animación aleatoria de cualquier parámetro y que esta tenga
una “esencia orgánica” utilizamos la expresión wiggle(x,y);

Copiar y pegar a Posición, Escala, Rotación, etc...

x=1; //Cuantas veces por segundo, Frecuencia

y=200; //Por cuanto se genera un numero aleatoria, Amplitud
wiggle(x,y);

2. Animación Aleatoria en una dimensión - wiggle

Digamos que queremos tener una animación aleatoria pero solo en la posición vertical, y
y dejar la posición horizontal como esta.

Copiar y pegar a parametros de 2 dimensiones. La primera dimensión “x” obtendrá

valores aleatorios mientras que la segunda dimensión “y” mantiene el valor establecido

x=1; //Cuantas veces por segundo, Frecuencia

y=200; //Por cuanto se genera un numero aleatoria, Amplitud
w = wiggle(x,y);
[w[0],value[1]] // Puedes cambiar el orden, para cambiar cual dimensión afecta

Copiar y pegar al parametro de Posición con la capa en 3D. Las dimensiones que tengan
la “w” se verán afectadas por la expresión de wiggle, mientras que las que tengan “value”
se quedan como están.

x=1; //Cuantas veces por segundo, Frecuencia

y=200; //Por cuanto se genera un numero aleatoria, Amplitud
w = wiggle(x,y);
[value[0],w[1],value[2]]

1
3. Escala Uniforme - wiggle

Cuando aplicamos wiggle a la escala de una capa, esta nos da una escala que no es uniforme.
Para conseguir una escala uniforme copi y pega esta expresión.

Copiar y pegar a Escala

x=2; //Cuantas veces por segundo, Frecuencia

y=50; //Por cuanto se genera un numero aleatoria, Amplitud
w= wiggle(x,y);
[w[0],w[0]];

4. Bucle de Animación Aleatoria - wiggle

Para conseguir un bucle de una animación aleatoria utilizando la expresión wiggle(x,y);

Copiar y pegar a Posición, Escala, Rotación, etc...

x= 1; //Cuantas veces por segundo, Frecuencia

y = 110; // Por cuanto se genera un numero aleatorio, Amplitud
bucle = 3; // De cuantos segundos será el bucle

t = time % bucle;

wiggle1 = wiggle(x, y, 1, 0.5, t);

wiggle2 = wiggle(x, y, 1, 0.5, t - bucle);
linear(t, 0, bucle, wiggle1, wiggle2)

5. Animación Aleatoria - wiggle entrecortado

Cuando queremos que la animación aleatoria parezca entrecortada.

Copiar y pegar a Posición, Escala, Rotación, etc...

// Wiggle Entrecortado (movimiento definido por FPS)

fps=5; //frecuencia
amount=50; //amplitud
wiggle(fps,amount,octaves = 1, amp_mult = 0.5,(Math.round(time*fps))/fps);

2
6. Péndulo

Recuerda cambiar la posición del punto de anclaje.

Copiar y pegar a Rotación:

veloc = 7;
amplitud = 80;
decay = .7;

amplitud*Math.sin(veloc*time)/Math.exp(decay*time)

7. Péndulo 2 - Muñeco de Caja de Sorpresas

Lo mismo que el péndulo pero preparado para la escala en el parametro vertical. De nuevo
la posición del punto de anclaje es vital para que el efecto funcione.

Copiar y pegar a Escala (o otros parámetros de 2 dimensiones). En este caso se aplica

al valor vertical:

veloc = 35;
amplitud = 30;
decay = 1.0;

y = amplitud*Math.cos(veloc*time)/Math.exp(decay*time);
value + [0,y]

Copiar y pegar a Escala (o otros parámetros de 2 dimensiones). En este caso se aplica

al valor horizontal:

veloc = 35;
amplitud = 30;
decay = 1.0;

y = amplitud*Math.cos(veloc*time)/Math.exp(decay*time);
value + [y,1]

3
8. Animación Aleatoria 2

Esta animación aleatoria es más compleja que la expresión wiggle, pero nos da mucho más
control sobre los valores que proporciona.

Copiar y pegar a Posición (mueve la capa por toda la composición):

tMin = .25; //duración mínima del segmento

tMax = 1.0; //duración máxima del segmento

minVal = [0.1*thisComp.width, 0.1*thisComp.height];

maxVal = [0.9*thisComp.width, 0.9*thisComp.height];

end = 0;
j = 0;
while (time >= end){
j ++;
seedRandom(j,true);
start = end;
end += random(tMin,tMax);
}
endVal = random(minVal,maxVal);
seedRandom(j-1,true);
dummy = random(); //valor desechable
startVal = random(minVal,maxVal);
ease(time,start,end,startVal,endVal)

Copiar y pegar a Rotación (rota la capa 360º aleatoriamente):

tMin = .25; //duración mínima del segmento

tMax = 1.0; //duración máxima del segmento

minVal = 0; //Valor mínimo de rotación

maxVal = 720; // Valor máximo de rotación

end = 0;
j = 0;
while ( time >= end){
j ++;
seedRandom(j,true);
start = end;
end += random(tMin,tMax);
}
endVal = random(minVal,maxVal);
seedRandom(j - 1,true);
dummy = random(); //valor desechable
startVal = random(minVal,maxVal);
ease(time,start,end,startVal,endVal)

4
Copiar y pegar a Escala:

tMin = .25; //duración mínima del segmento

tMax = 1.0; //duración máxima del segmento

minVal = 75; //Escala mínima

maxVal = 150; // Escala máxima

end = 0;
j = 0;
while (time >= end){
j ++;
seedRandom(j,true);
start = end;
end += random(tMin,tMax);
}
s = random(minVal,maxVal);
endVal = [s,s];
seedRandom(j-1,true);
dummy = random(); //valor desechable
s = random(minVal,maxVal);
startVal = [s,s]
ease(time,start,end,startVal,endVal)

9. Mantener Animación Aleatoria

A veces cuando cambiamos el orden de una capa, la animación que teníamos de un wiggle
cambia. Si preferimos tener la animación original pero tenemos que cambiar el orden de la
capa, podemos mantener dicha animación con seedRandom(); De esta manera nuestra
animación aleatoria siempre será la misma. Incluso la podemos copiar a mas capas.

Copiar y pegar a Posición, Rotación, Escala, etc... :

seedRandom(1);

x=1; //Cuantas veces por segundo, Frecuencia

y=200; //Por cuanto se genera un numero aleatoria, Amplitud
wiggle(x,y);

5
10. Ondulaciónes

Ideal para la animación de algo que flota, por ejemplo barcos.

Copiar y pegar a Posición:

xAmp = 3; //altura de ondulación (pixels)

xFreq = .3; //ondulaciones por segundo
xSpeed = 150; //velocidad de la ola (pixels por segundo)

wl = xSpeed/xFreq; //wavelength (pixels)

phaseOffset = ((position[0]%wl)/wl)*2*Math.PI;
y = xAmp*Math.sin(2*Math.PI*xFreq*time + phaseOffset);
value + [0,y]

Copiar y pegar a Rotación:

xFreq = .3; //ondulaciones por segundo

xSpeed = 150; //velocidad de ondulación (pixels por segundo)
damping = 15; //disminuir factor de ondulación

wl = xSpeed/xFreq; //wavelength (pixels)

phaseOffset = ((position[0]%wl)/wl)*2*Math.PI;
theta = Math.atan(Math.cos(2*Math.PI*xFreq*time + phaseOffset));
radiansToDegrees(theta)/damping;

11. Girar
Animar sin fotogramas clave a velocidad constante.

Copiar y pegar a Rotación:

// Gira una capa a una velocidad constante sin fotogramas

veloc = 360; //rotational velocity (degrees per second)

r = rotation + (time - inPoint) *veloc;
[r]

6
12. Lanzar
Animar sin fotogramas clavea velocidad constante.

Copiar y pegar a Posición:

// Lanzar en el eje x (mover a velocidad constante sin fotogramas clave)

veloc = -100; //velocidad horizontal (pixels per second)
x = position[0] + (time - inPoint) *veloc;
y = position[1];
[x,y]

// Lanzar en el eje y (mover a velocidad constante sin fotogramas clave)

veloc = -100; //velocidad horizontal (pixels per second)
x = position[0];
y = position[1] + (time - inPoint) *veloc;
[x,y]

// Lanzar en el eje x e y (mover a velocidad constante sin fotogramas clave)

veloc = -100; //velocidad horizontal (pixels per second)
x = position[0] + (time - inPoint) *veloc;
y = position[1] + (time - inPoint) *veloc;
[x,y]

13. Time
Utilizamos esta expresión para obtener el valor del tiempo en el parámetro que hemos
seleccionado. Podemos multiplicar por un número para que obtengamos mayor velocidad.
Ideal para tener una animación constante sin fotogramas.

Copiar y pegar a Posición, Rotación, etc...:

//Te da valores que van incrementando con el tiempo.

time

//Te da valores que van incrementando con el tiempo y los multiplica por 10.
time*10

7
14. Rebote Inercial

Precioso “rebote” para nuestras animaciones, Necesita de dos fotogramas clave con el
valor inicial y el valor final.

Copiar y pegar a Posición, Escala:

// Rebote Inercial (Se mueve a posición final después de haber rebotado un poco)

amp = .1; //Amplitud

freq = 2.0; // Frecuencia
decay = 2.0; //Cuanto tarda en terminar de rebotar

n = 0;
if (numKeys > 0){
n = nearestKey(time).index;
if (key(n).time > time){
n--;
}}
if (n == 0){ t = 0;
}else{
t = time - key(n).time;
}
if (n > 0 && t < 1){
v = velocityAtTime(key(n).time - thisComp.frameDuration/10);

value + v*amp*Math.sin(freq*t*2*Math.PI)/Math.exp(decay*t);
}else{value}

8
Copiar y pegar a Rotación:

// Rebote Inercial (Modificado para mejorar el resultado de la rotación)

amp = 10; //Amplitud

freq = 2.0; // Frecuencia
decay = 3.0; //Cuanto tarda en terminar de rebotar

n = 0;
if (numKeys > 0){
n = nearestKey(time).index;
if (key(n).time > time){
n--;
}}
if (n == 0){ t = 0;
}else{
t = time - key(n).time;
}
if (n > 0 && t < 1){
v = velocityAtTime(key(n).time - thisComp.frameDuration/10);

value + (v/100)*amp*Math.sin(freq*t*2*Math.PI)/Math.exp(decay*t);
}else{value}

9
15. Rebote
Con esta expresión conseguiremos un efecto “rebote” de nuestra animación la cual ya tiene
fotogramas clave.

Copiar y pegar a cualquier animación que tenga fotogramas clave:

e = .7; // Elasticidad
g = 5000; // Gravedad

nMax = 9;
n = 0;
if (numKeys > 0){
n = nearestKey(time).index;
if (key(n).time > time) n--;
}
if (n > 0){
t = time - key(n).time;
v = -velocityAtTime(key(n).time - .001)*e;
vl = length(v);
if (value instanceof Array){
vu = (vl > 0) ? normalize(v) : [0,0,0];
}else{
vu = (v < 0) ? -1 : 1;
}
tCur = 0;
segDur = 2*vl/g;
tNext = segDur; nb = 1 // number of bounces
while (tNext < t && nb <= nMax){
vl *= e;
segDur *= e;
tCur = tNext;
tNext += segDur;
nb++
}
if(nb <= nMax){
delta = t - tCur;
value + vu*delta*(vl - g*delta/2);
}else{
value
}
}else
value

10
16. Rebote 2 Otra animación de Rebote, un poco más natural.
Copiar y pegar a Parametro de al menos una dimensión (Posición, Rotación,

var p = 3; // elasticidad
var a = 100; // amplitud elastica
var s = 3; // cuanto de rebote
function outBack(t, b, c, d, a, p) {
if (s == null) s = 1.70158;
return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
}
function rebote2() {
var n = 0;
if (numKeys > 0) {
n = nearestKey(time).index;
if (key(n).time > time) { n-- }
}
try {
var key1 = key(n);
var key2 = key(n+1);
} catch(e) {
return null;
}
// Cuantas dimensiones se necesitan
var dim = 1; // tiene que tener al menos una dimension
try {
key(1)[1];
dim = 2;
key(1)[2];
dim = 3;
} catch(e) {}
t = time - key1.time;
d = key2.time - key1.time;
sX = key1[0];
eX = key2[0] - key1[0];
if (dim >= 2) {
sY = key1[1];
eY = key2[1] - key1[1];
if (dim >= 3) {
sZ = key1[2];
eZ = key2[2] - key1[2];
}
}
if ((time < key1.time) || (time > key2.time)) {
return value;
} else {
val1 = outBack(t, sX, eX, d, a, p, s);
switch (dim) {
case 1:
return val1;
break;
case 2:
val2 = outBack(t, sY, eY, d, a, p, s);
return [val1, val2];
break;
case 3:
val2 = outBack(t, sY, eY, d, a, p, s);
val3 = outBack(t, sZ, eZ, d, a, p, s);
return [val1, val2, val3];
break;
default:
return null;
}
}
}
(rebote2() || value); 11
 17. Bucle
Utiliza esta expresión para obtener un bucle de la animación que hayas creado con tus
fotogramas clave.

Copiar y pegar a cualquier animación )el resultado es un bucle clásico:

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

Copiar y pegar a cualquier animación (el resultado es un efecto ping pong, la animación
llega hasta el final y después va marcha atrás::

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

18. Espiral
Movimiento en espiral.

Copiar y pegar a Posición:

center=[thisComp.width/2,thisComp.height/2]; //Centro de la espiral (centro de comp)

rMax = 240; //radio máximo
decay = 0.3; //decaer
freq = 6; //frecuencia
aStart = 0; //ángulo de inicio
aRate = 220; //ritmo de rotación
offsetFactor = 100; //suavizado

r = rMax/Math.exp(time*decay);
a = degreesToRadians(aStart + aRate*time);
offset = (r/offsetFactor)*Math.sin(freq*time*Math.PI*2);
center + [Math.cos(a),Math.sin(a)]*(r + offset);

12
19. Encoger y Estirar

Clásico efecto de dibujos animados para antes y después de una acción.

Copiar y pegar a Escala:

maxDev = 13; // máxima desviación en pixels

spd = 30; //velocidad de oscilación
decay = 1.0; //cuanto tarda en pararse

t = time - inPoint;
x = scale[0] + maxDev*Math.sin(spd*t)/Math.exp(decay*t);
y = scale[0]*scale[1]/x;
[x,y]

20. Números Binarios Aleatorios

Crea una capa de texto y conviértela en un cronómetro.

Copiar y pegar al parámetro Texto de Origen:

rows = 8; //Número de filas

cols = 16; // Número de columnas
freq = 5; // Velocidad de animación

posterizeTime(freq);
randMin = Math.pow(2,cols);
randMax = randMin*2;
s = "";

for(i =0; i < rows; i++){

s += random(randMin,randMax).toString(2).substr(1) + "\r";
}
s

13
21. Movimiento Aleatorio de Capas
Recrea un movimiento aleatorio de las capas que tengan esta expresión.

Copiar y pegar a Posición, duplicar la capa cuantas veces se desee:

columns = 10; //numero de columnas

tHold= .2; //retener tiempo (debe ser menor que tmin)
tMin = .5; //tiempo mínimo de ciclo (no puede ser cero)
tMax = 1; //tiempo máximo de ciclo

gap = this_comp.width/columns;
origin = [gap,gap];
xGrid = columns - 1;
yGrid = Math.floor(this_comp.height/gap) - 1;

start = 0;
end = 0;
j = 1;

while (time >= end){

j += 1;
seedRandom(j,true);
start = end;
end += random(tMin,tMax);
}
targetX = Math.floor(random(0,xGrid));
targetY = Math.floor(random(0,yGrid));
seedRandom(j-1,true);
x = random(); //this is a throw-away value
oldX = Math.floor(random(0,xGrid));
oldY = Math.floor(random(0,yGrid));

if(targetX == oldX && targetY == oldY){

origin + [oldX,oldY]*gap;
}else if (time - start < tHold){
origin + [oldX,oldY]*gap;
}else{
deltaX = Math.abs(targetX - oldX);
deltaY = Math.abs(targetY - oldY);
xTime = (end - start - tHold)*(deltaX/(deltaX + deltaY));
yTime = (end - start - tHold)*(deltaY/(deltaX + deltaY));
if (time < start + tHold + xTime){
startPos = origin + [oldX,oldY]*gap;
targetPos = origin + [targetX,oldY]*gap;
easeOut((time - start - tHold)/xTime, startPos, targetPos);
}else{
startPos = origin + [targetX,oldY]*gap;
targetPos = origin + [targetX,targetY]*gap
easeIn((time - start - tHold - xTime)/yTime, startPos, targetPos); }
}

14
 22. Movimiento Aleatorio de Líneas
Recrea un movimiento aleatorio líneas moviendose en el eje x.

Copiar y pegar a Posición, duplicar la capa cuantas veces se desee:

tMin = .5; //duración mínima del segmento

tMax = 2; //duración máxima del segmento

end = 0;
j = 0;
while (time >= end){
j++;
seedRandom(j,true);
start = end;
end += random(tMin,tMax);
}
endVal = random(thisComp.width);
seedRandom(j - 1,true);
x = random(); //this is a throw-away value
startVal = random()*this_comp.width;
x = ease(time,start,end,startVal,endVal);
[x,value[1]]

23. Animación Básica con Audio

Recordad, se tiene que analizar la pista de audio antes de aplicar esta expresión a la
capa que queramos se vea afectada por la amplitud de onda del archivo de audio.
Copiar y pegar a Escala:

minAudio = 0; // Amplitud Mímina del Audio

maxAudio = 15; // Cambiar este valor a la Amplitud Máxima del Audio

maxStretch = 2.0;
audioLev = thisComp.layer("Audio Amplitude").effect("Both Channels")("Slider");
stretch = linear(audioLev, minAudio, maxAudio, 1.0, maxStretch);
value * stretch

15
24. Aparecen Capas con el Audio

Aparte de Analizar el Audio hay que crear un Controlador de Expresión. Mirar vídeo para
entender mejor los pasos.

Copiar y pegar a la Opacidad de cada Capa:

n = 6; // Número de Capas

slider = thisComp.layer("control").effect("Slider Control")("Slider");

if (slider > (n - index)) 100 else 0

Copiar y pegar al Controlador de Expresión:

threshold = 10.0; // A partir de este valor aparecerán las capas

audioLev = thisComp.layer("Audio Amplitude").effect("Both Channels")("Slider");

above = false; frame = Math.round(time / thisComp.frameDuration);
n = 0;
while (frame >= 0){
t = frame * thisComp.frameDuration;
if (above){
if (audioLev.valueAtTime(t) < threshold){
above = false;
}
}else if (audioLev.valueAtTime(t) >= threshold){
above = true;
n++;
}
frame--
}
n

16
25. Empezar Movimiento con Audio
Recordad, se tiene que analizar la pista de audio antes de aplicar esta expresión a la
capa que queramos se vea afectada por la amplitud de onda del archivo de audio.

Copiar y pegar a Escala:

threshold = 20.0; //A partir de este valor se pone en marcha la expresión

audioLev = thisComp.layer("Audio Amplitude").effect("Both Channels")("Slider");

above = false;
frame = Math.round(time / thisComp.frameDuration);
while (true){
t = frame * thisComp.frameDuration;
if (above){
if (audioLev.valueAtTime(t) < threshold){
frame++;
break;
}
}else if (audioLev.valueAtTime(t) >= threshold){
above = true;
}
if (frame == 0){
break;
}
frame--
}
if (! above){
t = 0;
}else{
t = time - frame * thisComp.frameDuration;
}
amp = 25;
freq = 5;
decay = 4.0;
angle = freq * 2 * Math.PI * t;
wobble = 1 + amp * Math.sin(angle) / Math.exp(decay * t) / 100;

[value[0] * wobble, value[1] / wobble]

17
 26. Tranisición Automática
Haz que una capa “aparezca” y “desaparezca” al principio y final de la composición sin
fotogramas clave.

Copiar y pegar a Opacidad:

transition = 20; // Numero de Frames que dura la transición

if (marker.numKeys<2){
tSecs = transition / ( 1 / thisComp.frameDuration);
linear(time, inPoint, inPoint + tSecs, 0, 100)
- linear(time, outPoint - tSecs, outPoint, 0, 100)
}else{
linear(time, inPoint, marker.key(1).time, 0, 100)
- linear(time, marker.key(2).time, outPoint, 0, 100)
}

27. Rastro de Movimiento

Haz que una o varias capas sigan a la primera capa de la composición, creando el efecto de
un rastro de movimiento..

Copiar y pegar a Posición:

delay = 5; //number of frames to delay

d = delay*thisComp.frameDuration*(index - 1);
thisComp.layer(1).position.valueAtTime(time - d)

Copiar y pegar a Opacidad:

opacityFactor = .75;
Math.pow(opacityFactor,index - 1)*100

18
 28. Conexión Elástica
Esta expresión nos permite crear una cnoexión elástica entre dos capas. Básicamente la capa
a la que se aplica esta expresión seguirá a la capa “leader” pero con un efecto elástico.

Copiar y pegar al parametro de Posición. La capa “maestra debe llamarse leader”:

restLength = 20;
damp = .95;
leader = thisComp.layer("leader");

fDur = thisComp.frameDuration;
currFrame = Math.round(time / fDur);

p2 = position.valueAtTime(0);
v2 = 0;
for (f = 0; f <= currFrame; f++){
t = f*fDur;
p1 = leader.transform.position.valueAtTime(t);
delta = p2 - p1; nDelta = normalize(delta);
a = 2 * nDelta * (length(delta) - restLength) * fDur;
v2 = (v2 - a) * damp;
p2 += v2;
}
p2

19
29. Remapeo de Tiempo controlado por Audio

Haz que el ritmo de tu capa de Audio controle la velocidad del vídeo. Acuérdate de pasar
el Audio a fotogramas clave.

Copiar y pegar al Remapeo de Tiempo de la capa de Vídeo:

spd = thisComp.layer("Audio Amplitude").effect("Both Channels")("Slider");

mult = .5;
n = spd.numKeys;
if (n > 0 && spd.key(1).time < time){
accum = spd.key(1).value*(spd.key(1).time - inPoint);
for (i = 2; i <= n; i++){
if (spd.key(i).time > time) break;
k1 = spd.key(i-1);
k2 = spd.key(i);
accum += (k1.value + k2.value)*(k2.time - k1.time)/2;
}
accum += (spd.value + spd.key(i-1).value)*(time - spd.key(i-1).time)/2;
}else{
accum = spd.value*(time - inPoint);
}
value + accum*mult

30. Remapeo de Tiempo Entrecortado

Elíge un trozo de tu vídeo para que esta expresión te haga un efecto de entrecortado,

Copiar y pegar al Remapeo de Tiempo de la capa de Vídeo:

start = 1.0; //cuando empieza el efecto

end = 1.5; //cuanto dura este efecto

if(time >= start && time <= end) random(start,end) else time

20
31. Panorámica y Exploración Aleatoria
Con esta expresión te creará un efecto de cámara aleatoria a una imágen mas grande que
la composición. Debes crear un Punto de Control para la capa (mirar vídeo)

Copiar y pegar al Punto de Control de Capa (efecto):

scaleTime = 1;
holdTime = .5;
maxScale = 50;

minScale = Math.max(thisComp.width/width,thisComp.height/height)*100;
totalTime = scaleTime + holdTime
seed =Math.floor(time/totalTime) + 2;
seedRandom(seed,true);
newScale = random(minScale,maxScale);
seedRandom(seed - 1,true);
oldScale = random(minScale,maxScale);
[oldScale,newScale];

Copiar y pegar a la Posición:

scaleTime = 1;
holdTime = .5;

pixFactor = source.pixelAspect/thisComp.pixelAspect;
totalTime = scaleTime + holdTime;
segTime = time%totalTime;
oldScale = effect("Point Control").param("Point")[0];
newScale = effect("Point Control").param("Point")[1];
seed = Math.floor(time/totalTime) + 133;
seedRandom(seed,true);
maxX = (width/2)*(newScale/100)*pixFactor;
minX = thisComp.width - (width/2)*(newScale/100)*pixFactor;
maxY = (height/2)*(newScale/100);
minY = thisComp.height - (height/2)*(newScale/100);
newPos = random([minX,minY],[maxX,maxY]);
seedRandom(seed - 1,true);
maxX = (width/2)*(oldScale/100)*pixFactor;
minX = thisComp.width-(width/2)*(oldScale/100)*pixFactor;
maxY = (height/2)*(oldScale/100);
minY = thisComp.height - (height/2)*(oldScale/100);
oldPos = random([minX,minY],[maxX,maxY]);
if(segTime > scaleTime){
newPos
}else{
percent = segTime/scaleTime;
ease(percent,oldPos,newPos)
}

21
Copiar y pegar a la Escala:

scaleTime = 1;
holdTime = .5;

totalTime =scaleTime+holdTime;
segTime = time%totalTime;
oldScale = effect("Point Control").param("Point")[0];
newScale = effect("Point Control").param("Point")[1];
if(segTime > scaleTime){
[newScale,newScale]
}else{
percent = segTime/scaleTime;
ease(percent,[oldScale,oldScale],[newScale,newScale])
}

22
32. Esconder capa cuando la cámara no mira (3D)

Hace desaparecer una capa cuando la cámara no mira a esa cara. Mirar vídeo para explicación.
Hace falta una cámara para que funcione y que las capas sean 3D.

Copiar y pegar a la Opacidad de la Capa:

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

33. Orientar Automáticamente Eje Y (3D)

Cuando utilizamos la orientación automática a cámara, a veces los objetos pierden el

contacto con el suelo. Utlizando esta expresión arreglamos ese problema.

Copiar y pegar a rotación Y de la capa 3D:

delta = toWorld(anchorPoint) - thisComp.activeCamera.toWorld([0,0,0]);

radiansToDegrees(Math.atan2(delta[0],delta[2]))

23
34. Cronómetro

Crea una capa de texto y conviértela en un cronómetro.

Copiar y pegar al parámetro Texto de Origen:

rate = 1; // Velocidad y marcha del cronómetro

clockStart = 0; // Con qué valor empieza el cronómetro

function padZero(n){
if (n < 10) return "0" + n else return "" + n
}
clockTime = clockStart + rate*(time - inPoint);
if (clockTime < 0){
sign = "-";
clockTime = -clockTime;
}else{
sign = "";
}
t = Math.floor(clockTime);
hr = Math.floor(t/3600);
min = Math.floor((t%3600)/60);
sec = Math.floor(t%60);
ms = clockTime.toFixed(2).substr(-2);
sign + padZero(hr) + ":" + padZero(min) + ":" + padZero(sec) + "." + ms

24
35. Contador Universal

Crea una capa de texto y conviértela en un cronómetro.

Copiar y pegar al parámetro Texto de Origen:

numDecimals = 2; //Número de decimales

commas = true; // Si hay o no comas
dollarSign = true; // Si quiere el símbolo del dollar
beginCount = -1999; // Empieza a contar desde
endCount = 1999; // Termina de contar en
dur = 4; // Cuanto dura la animación en segundos

t = time - inPoint;
s = linear (t, 0, dur, beginCount, endCount).toFixed(numDecimals);

prefix = "";
if (s[0] == "-"){
prefix = "-";
s = s.substr(1);
}
if(dollarSign) prefix += "$"; // Cambia el signo de moneda aqui

if (commas){
decimals = "";
if (numDecimals > 0){
decimals = s.substr(-(numDecimals + 1));
s = s.substr(0,s.length - (numDecimals + 1));
}
outStr = s.substr(-s.length, (s.length-1)%3 +1);
for (i = Math.floor((s.length-1)/3); i > 0; i--){
outStr += "," + s.substr(-i*3,3);
}
prefix + outStr + decimals;
}else{
prefix + s;
}

25