Expresiones

Inertial Bounce

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);
amp = .05;
freq = 4.0;
decay = 8.0;
value + v*amp*Math.sin(freq*t*2*Math.PI)/Math.exp(decay*t);
}else{
value;
}
Drop o Bounce Back

e = .7;
g = 5000;
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
Inertia Position

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){v = velocityAtTime(key(n).time - thisComp.frameDuration/10);

amp = 3;

freq = 2.0;

decay = 3.0;

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

Inertia Rotation

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){v = velocityAtTime(key(n).time - thisComp.frameDuration/10);

amp = 8;

freq = 1.0;

decay = 1.0;

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

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){v = velocityAtTime(key(n).time - thisComp.frameDuration/10);

amp = 8;

freq = 2.0;

decay = 3.0;

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

var p = 0.8; // period for elastic

var a = 50; // amplitude for elastic

var s = 1.70158; // overshoot amount for "back"

function outBounce(t, b, c, d, a, p) {

if ((t/=d) < (1/2.75)) {

return c*(7.5625*t*t) + b;

} else if (t < (2/2.75)) {

return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;

} else if (t < (2.5/2.75)) {

return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;

} else {

return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;

function easeAndWizz() {

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;

// determine how many dimensions the keyframes need

var dim = 1; // It's gotta have at least ONE 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 = outBounce(t, sX, eX, d, a, p, s);

switch (dim) {

case 1:

return val1;

break;

case 2:

val2 = outBounce(t, sY, eY, d, a, p, s);

return [val1, val2];

break;

case 3:

val2 = outBounce(t, sY, eY, d, a, p, s);

val3 = outBounce(t, sZ, eZ, d, a, p, s);

return [val1, val2, val3];

break;

default:

return null;

(easeAndWizz() || value);
Elastic Potition:

// some defaults

var p = 0.6; // period for elastic

var a = 140; // amplitude for elastic

var s = 1.70158; // overshoot amount for "back"

function outElastic(t, b, c, d, a, p) {

if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3;

if (!a || a < Math.abs(c)) { a=c; var s=p/4; }

else var s = p/(2*Math.PI) * Math.asin (c/a);

return (a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b);

function easeAndWizz() {

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;

}
// determine how many dimensions the keyframes need

var dim = 1; // It's gotta have at least ONE 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 = outElastic(t, sX, eX, d, a, p, s);

switch (dim) {
 case 1:

return val1;

break;

case 2:

val2 = outElastic(t, sY, eY, d, a, p, s);

return [val1, val2];

break;

case 3:

val2 = outElastic(t, sY, eY, d, a, p, s);

val3 = outElastic(t, sZ, eZ, d, a, p, s);

return [val1, val2, val3];

break;

default:

return null;

(easeAndWizz() || value);
Back Potition:

// Ease and Wizz 2.0.1 : outBack : All keyframes

// Ian Haigh (http://ianhaigh.com/easeandwizz/)

// Last built: 2010-10-09T13:35:40+11:00

// some defaults

var p = 0.8; // period for elastic

var a = 50; // amplitude for elastic

var s = 1.70158; // overshoot amount for "back"

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 easeAndWizz() {

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;

// determine how many dimensions the keyframes need

var dim = 1; // It's gotta have at least ONE 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;

}
 }

(easeAndWizz() || value);

Squach and Stretch Scale

freq = 2;

amplitude = 40;

decay = 1.0;

t = time - inPoint;

x = scale[0] + amplitude*Math.sin(freq*t*2*Math.PI)/Math.exp(decay*t);

y = (1/x)*10000;

[x,y]

Ondulación: (posicion y rotacion para la ondulación, más de un objeto cambiar los

valores).

Posición:

xAmp = 40; //height of undulations (pixels)

xFreq = .3; //undulations per second

xSpeed = 150; //speed of wave (pixels per second)

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]
Rotacion:

xFreq = .3; //undulations per second

xSpeed = 150; //speed of wave (pixels per second)

damping = 15; //undulation damping factor

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;

Jumpy Wiggle (posicion)

fps=5; //frequency

amount=25; //amplitude

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

Grid:

columns = 10; //number of columns in grid

tHold= .2; //hold time (must be less than tmin)

tMin = .5; //minimum cycle time (can't be zero)

tMax = 1; //maximum cycle time

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

Wiggle Text ( en evolución del efecto Turbulence Displacement )

f = 8;
a = 1400;
posterizeTime(f);
wiggle(f, a);
Mascara

Ping pong:

if (numKeys >1 && time > key(numKeys).time){

t1 = key(1).time;

t2 = key(numKeys).time;

span = t2 - t1;

delta = time - t2;

t = delta%span;

valueAtTime(t1 + t)

}else

value

Cycle:

d = key(numKeys).time - key(1).time;

valueAtTime(time%d)

Pre Composicion

layer = thisComp.layer(“Null 1”)

layer.toComp([0,0,0])
Motion Trail (trazos)
delay = 5; //number of frames to delay

d = delay*thisComp.frameDuration*(index - 1);

thisComp.layer(1).position.valueAtTime(time - d)

autofade
transition = 20; // transition time in frames

if (marker.numKeys<2){

tSecs = transition / ( 1 / thisComp.frameDuration); // convert to seconds

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)

}
Zoom in out (en texto).
//Snap zoom in and out: apply to scale

snapScale = 300; //percent of scale to zoom

trans = 4; // transition time in frames

trans = trans * thisComp.frameDuration;

inTrans = easeOut(time, inPoint, inPoint + trans, [snapScale,snapScale], [0,0]);

outTrans = easeIn(time, outPoint, outPoint - trans, [0,0], [snapScale, snapScale]);

value+ inTrans + outTrans

If you prefer to use Z space position instead of scale, try this one:

zoom = 5000; //distance to zoom

trans = 4; // transition time in frames

trans = trans * thisComp.frameDuration;

inTrans = easeIn(time, inPoint, inPoint + trans, [0,0,zoom], [0,0,0]);

outTrans = easeOut(time, outPoint, outPoint - trans*2, [0,0,0], [0,0,zoom]);

value+ inTrans - outTrans