AE 回弹表达式

  1. nearestKeyIndex = 0;
  3. if (numKeys > 0){
  4.   nearestKeyIndex = nearestKey(time).index;
  5.   if (key(nearestKeyIndex).time > time){
  6.     nearestKeyIndex--;
  7.   }
  8. }
  10. if (nearestKeyIndex == 0) {
  11.   currentTime = 0;
  12. } else {
  13.   currentTime = time - key(nearestKeyIndex).time;
  14. }
  16. if (nearestKeyIndex > 0 && currentTime < 1) {
  17.   calculatedVelocity = velocityAtTime(key(nearestKeyIndex).time - thisComp.frameDuration / 10);
  18.   amplitude = 0.04;// 反弹的力度&距离,值越大 反弹越强烈
  19.   frequency = 2.0;// 频率，每秒反弹次数
  20.   decay = 6.0;// 衰减，数值越大，越快停止
  21.   value + calculatedVelocity * amplitude * Math.sin(frequency * currentTime * 2 * Math.PI) / Math.exp(decay * currentTime);
  22. } else {
  23.   value;
  24. }

路径循环表达式

在做路径动画时，直接添加 loop 循环表达式会报错，如何让路径循环？
可以循环路径的表达式来了

  1. try{
  2. timeStart = thisProperty.key(1).time;
  3. duration = thisProperty.key(thisProperty.numKeys).time-timeStart;
  4. pingPong = false; //change to true value if you want to loop animationn back & forth
  5. quant=Math.floor((time-timeStart)/duration);
  6. if(quant<0) quant = 0
  7. if(quant%2 == 1 && pingPong == true){ t = 2*timeStart+ (quant+1)*duration - time;
  8. }
  9. else{
  10. t = time-quant*duration;
  11. }
  12. }
  13. catch(err){
  14. t = time;
  15. }
  16. thisProperty.valueAtTime(t)

注意：第四行是设置改动画是否需要 往复运动(pingpong)，默认是 false ,就是不需要往复运动，就是正常的循环 跟 Loop 循环表达式的(cycle) 一样。
如果需要往复运动 第四 行的 false 改为 ture 即可。

抖动循环表达式

在前面我们学过 wiggle 表达式
wiggle(freq, amp) 摆动函数，第一个参数freq指的是摆动的频率，频率数值越大，晃动越激烈，第二个参数amp指的是摆动的幅度，幅度数值越大，晃动范围越广。
在循环动画中，单纯的使用这个抖动表达式，是达不到循环的效果。
So，今天给大家分享一个 抖动循环表达式。

  1. freq = 1;
  2. amp = 110;
  3. loopTime = 3;
  4. t = time % loopTime;
  5. wiggle1 = wiggle(freq, amp, 1, 0.5, t);
  6. wiggle2 = wiggle(freq, amp, 1, 0.5, t - loopTime);
  7. linear(t, 0, loopTime, wiggle1, wiggle2)

很好理解，Frep 是频率、amp 是幅度、loopTime 是循环的时间(单位是秒)
这三个值可以根据应用场景修改的。

循环

  1. loopOut(type = "pingPong", numKeyframes = 0)

循坏旋转

  1. cycle=360;  //循环周期
  2. n=1;  //转速(需为整数)
  3. cycle*n/thisComp.duration*time

弹性

  1. mp = .1; //振幅
  2. freq = 2.0; //频率
  3. decay = 2.0; //阻力
  4. n = 0;
  5. if (numKeys > 0){
  6.  n = nearestKey(time).index;
  7.  if (key(n).time > time){n--;}
  8.   }
  9. if (n == 0){ t = 0;}
  10. else{t = time - key(n).time;}
  11. if (n > 0){
  12.  v = velocityAtTime(key(n).time - thisComp.frameDuration/10);
  13.  value + v*amp*Math.sin(freq*t*2*Math.PI)/Math.exp(decay*t);
  14.    }
  15. else{value}

回弹

  1. e =0.7;//弹力
  2. g =1000;//重力
  3. nMax = 9;//最大弹跳次数
  4. n = 0;
  5. if (numKeys > 0){
  6. n = nearestKey(time).index;
  7. if (key(n).time > time) n--;
  8. }
  9. if (n > 0){
  10. t = time - key(n).time;
  11. v = -velocityAtTime(key(n).time - .001)*e;
  12. vl = length(v);
  13. if (value instanceof Array){
  14. vu = (vl > 0) ? normalize(v) : [0,0,0];
  15. }else{
  16. vu = (v < 0) ? -1 : 1;
  17. }
  18. tCur = 0;
  19. segDur = 2*vl/g;
  20. tNext = segDur;
  21. nb = 1; // number of bounces
  22. while (tNext < t && nb <= nMax){
  23. vl *= e;
  24. segDur *= e;
  25. tCur = tNext;
  26. tNext += segDur;
  27. nb++
  28. }
  29. if(nb <= nMax){
  30. delta = t - tCur;
  31. value +  vu*delta*(vl - g*delta/2);
  32. }else{
  33. value
  34. }
  35. }else  
  36. value

3D坐标转2D坐标

  1. thisComp.layer('三维层名字').toComp([0,0,0])