[Filip Vandueren]

Tim, I specifically did the Ball on a separate shape and let it calculate its own position on the sine wave (it’s actually a cosine wave, that made it easier to place the vertices on peaks an valleys), so the ball has an X-value you can manipulate.

You could also use pointOnPath() to get a position that’s a certain % along the way of the wave-path, but if you do this, then the X-position could change if the wave changes shape, 13% along the course of the path isn’t necessarily at the same X-coördinate for different phases/amplitudes/wavelengths…

[Filip Vandueren]

Perhaps it’s handier to do something to your time variable.

for example:

t=time%10;
t<5 ? linear(t,0,5,100,200) : linear (t,5,10,200,100);

because t is now looping, you don’t need more linear()s

[Filip Vandueren]

Hey Tim, doing it from a wave warp would take some guess work, and the result isn’t as crisp
so I would personally do it with a shapelayer.

Here is a project that does a reasonable approximation of a sinewave with a rather minimal amount of points using expressions:

https://imgur.com/a/IDkvv3o

https://we.tl/t-blJaNBDZri

View post on imgur.com

[Filip Vandueren]

Let me know if you run into any issues…

[Filip Vandueren]

Hey Kira,

the method is looking at the “source” of the footage at a certain time.

But the current time of the composition (which is default if you don’t give a number to .sourceRectAtTime() ) is not necessarily the current time of the source of a layer.

So you are seeing values for sourceRect that are out of sync: the method asks what is the sourceRect of this layer at its own 1:07 time (the current time-value of the comp), and that is what’s returned, even though that is not the currently displayed frame of this textlayer.

It’s confusing and unintuitive because for shape, solid, stills and text layers we’re not as aware of the actual inpoint and internal time of those layers as we are with a video or precomp.

Here is the fix:

l=thisComp.layer(index-1);
sr=l.sourceRectAtTime(l.sourceTime(time));

Now sr holds the sourceRect of the layer as we now see it. The l.sourceTime(time) method has figured out what time of the layer’s source is currently being displayed for us.

[Filip Vandueren]

Yes Scott, you would straighten out the lens distortion, then do the tracking and patchwork, and finally re-introduce the original distortion.

If the distortion seems to be changing, then perhaps the footage was cropped or digitally stabilised ? That’s a final step that can only occur after the lens correction and tracking.

After Effects has a basic lens correction plug-in “Optics Compensation”, Red Giant has one that’s supposedly better, included in VFX plugin suite: https://www.maxon.net/en/red-giant/vfx-suite/lens-distortion-matcher

If it’s a reasonably short shot, perhaps you can even correct the lens distortion in photoshop as an image sequence.

[Filip Vandueren]

Hey Dan,

I tried it, and for me this does the characters one by one like a square selector instead of with an overlapping delay.

The only way I can get a delay in an expression selector to work with custom keyframes/timings is to have the actual keyframes somewhere else (in another deactivated animator, or in a point control, on a Null…), because once a property is already keyframed down to 0, no amount between -100 and 100 is going to change it to be anything else.

My approach with Position expressions Selectors is to give the property a fixed value of 10,000;10,000 and then use the amount expression to use percentages to turn those into pixel positions. (It’s unfortunate that all selectors are limited form -100% to 100%)

I’d love to hear your thoughts on this technique, maybe there’s another approach with expression selectors?

https://imgur.com/a/RJzXzab

Animation Delay

[Filip Vandueren]

Try something like this:

[Filip Vandueren]

Hey Mario,

in that case, one way to handle the changes is this:

• set the Paragraph setting of both text to Left aligned
• The control-layers have an expression on their X-positon -> disable these expressions
• The BG-layers should get expressions for their anchorpoint:
  [effect(“SubtitleWidth”)(“Slider”)/-2, 0]
• and for their position:
  value – [effect(“SubtitleMargin”)(“Slider”)/2,0];

[Filip Vandueren]

To automate that all the ranges (which you duplicate yourself) are sequential:

Range, based on Characters index, from 0 to 1, offset has this expression:

thisProperty.propertyGroup(3).propertyIndex-1;

The first Animator has its properties keyframed (position in your example), the following ranges’ properties have this expression:

delay = thisComp.frameDuration*2; // 
thisProperty
	.propertyGroup(3)(
		thisProperty.propertyGroup(2).propertyIndex-1
	)
	("Properties")
		(thisProperty.propertyIndex)
		.valueAtTime(time-delay)

You’ll notice that the propertyGroup counts are not intuitive if you try to count up by eyeballing the levels of properties you see in the timeline, because there are some hidden levels: An Animator has a hidden propertyGroup of “Selectors” and a hidden PropertyGroup of “Properties”, and also the animators themselves are inside a propertyGroup “Animators”, all these levels are not represented by a twirly > in the timelines structures.

So, counting up from a property Position to the Pool of animators it is a child of takes 3 steps:

comp
   layer
      ("Text")
         ("Animators")
            ("Animator 1")
               ("Properties")
                  ("Position")