Tutorial 201: Ugly Sweater

Joe Clay | Dec 13, 2019

In this After Effects tutorial, we take a look at how to build an ugly sweater. We start off by drawing a single stitch, and then repeat that into a full grid. Vertically, we skip every other row because we're coloring these using a source comp that has Mosaic applied to it. However, our Mosaic covers those skipped sections. If we only had one layer of fabric, we'd see the edges.

So instead, we skip rows and then use another copy of our source comp with another Mosaic on it. It needs to match up with the alternated threads, so we move it up with an effect like Motion Tile or Offset so that we don't lose the edges of our source, then we apply Mosaic, and then we shift it back into place. Mosaic doesn't have a setting to shift its effect, so we shift the layer instead.

After that we continue to build our effect procedurally, using adjustment layers to build the background of the fabric from the foreground. We rough it up, and add some fuzz to it to make it more realistic. And then we call it a day.

Many people have created this effect, so look around and experiment to make your own. It's a fun exercise to recreate real-world objects and I'm glad I could share my process with you!

Tutorial 200: Slice

Severo Ojea | Nov 15, 2019

This week, we took some inspiration from Damien Hirst and magnetic resonance imaging (MRI) in order to develop a slicing technique inside of Cinema 4D. We made use of Voronoi Fracture Objects in an unconventional way. Instead of using the default setup, we used a spline with evenly spaced vertices along with Plain Effectors to slice up a 3D model of a RED Epic Dragon from GrabCAD.

We rendered a few different different pieces using some different techniques with basically the same setup. One of the more interesting renders involved using the x-ray technique from Tutorial 192: Scan. Then we brought it all into After Effects to composite.

Using my renders, Joe changed colors, added glows, and retimed some elements. He also took the renders and matted them using time-shifted versions of the same layer to get other slices inside of AE to dress up the edges as the Epic reveals. And then he graded it.

Working together to build this tutorial is indicative of the new direction that we're heading in. Currently, we rarely work on tutorials together other than maybe for a thumbnail. We want to build more things together, instead of always working independently. And that's going to be a big part of this channel moving forward.

Catch you on the next one!

Tutorial 199: Bit Growth

Joe Clay | Nov 4, 2019

My apologies to Josh Yeo. Go check out his channel! If you're interested in filming and you like what we do, I think you'd like him. Plus he's entertaining, and he's got a great shirt.

So in this week's After Effects tutorial, we take a look at a simple bit growth effect. It basically takes a greyscale map, uses Extract to animate it in, and then the look is achieved with Mosaic and Find Edges. You could also use CC Image Wipe to animate. Block Dissolve also works wonders for that as it makes the growth more labored and mechanical. Or you could even combine them using blend modes and then run Mosaic and Find Edges—or CC Kernel—in an adjustment layer.

There's a lot of flexibility in this technique, but what helps to sell it most is to set Find Edges to blend with the original, instead of using it at 100% intensity. That gives this look a depth it wouldn't normally have.

I also mentioned our Procedural Circuitry Tutorial so go check that out! It might give you ideas for other uses of this technique.

Expression Code

For the square mosaic, add this code to the vertical blocks setting. I don't remember why I made the variable f in the original, but I've changed it to w here and in the project file for width, since that's what it is.

w = 1920/effect("Mosaic")("Horizontal Blocks");
1080/w;

Tutorial 198: Faking Waves

Severo Ojea | Oct 28, 2019

Creating water effects in Cinema 4D Does not always have to involve laborious simulations. Using simple tools you can easily create a dynamic toon-shaded wave animation. To see an excellent version of this technique, which we referenced for this tutorial, check out everfresh on twitter. There's some killer no-particle no-simulation work on that feed.

By displacing a plane using fields we'll build a wave. And then we'll add foam to the top of the wave by running two splines through the same setup and projecting them onto our wave surface using Magic Projector from Nitro 4D. We'll then clone spheres onto those splines, and then mesh the two together with VDB Mesher. With a simple material built using the Sketch and Toon cel shader in the luminance channel, we'll texture our foam. Then we'll finish it off by texturing the water using a simple noise setup—also in luminance.

And that's it. As you can see on everfresh's twitter, there's a lot of things that can be built using similar setups.

Tutorial 197: Lockdown

Joe Clay | Oct 18, 2019

If you happened to see Lockdown from Chris Vranos, the creator of Composite Brush, making the rounds lately, you might have been amazed. And then, if you're like me, the first question you had was, "yeah, but how good is it really?"

So to find out, I got a review copy of Lockdown from Chris and started to experiment. I did one initial test to figure out the process. And I discovered that Lockdown is pretty direct and clear for the most part, especially for a brand new plugin. Then I started working on this tutorial video. So you're basically learning along with me.

I made one recording at the outset, and then decided to run the track again. It was already pretty good but I wanted to see how I could improve it. At the time, I didn't know how to properly go back once I had locked down my track, so I restarted my recording. After talking with Chris, he pointed me to where he covers that in his tutorial.

So, final impressions? This thing is killer. It tracked nearly all black areas where the difference between most of the track points was a few points in RGB levels. With a properly lit object it tracks beautifully. In our second track—perhaps a little too lit—I demonstrate this. While that track had some tougher areas due to how much I moved my shirt, I still got a pretty decent track without much effort as you can see in the Supreme Burrito example below. As long as the spots you're tracking don't fold past each other, you should be good for most situations.

Chris has also told me that he's working on an update that should improve this already amazing tracker, the tracking filter—and the workflow including the filter. Judging by how improvements to Composite Brush have gone, I can't wait to see what comes next.

Glitchify from Cinema Spice was also used in this tutorial. Thanks Mikey!

Tutorial 196: Better Forklift

Joe Clay | Oct 11, 2019

Before watching this one, make sure you've seen Part 1! Again, Master Properties in After Effects enable us to make complex rigs. This week, instead of building our forklift in Affinity, we built a model in C4D. I built the initial model and lighting setup, and Sev set it up with Redshift lights for a clay render, and built puzzle mattes so that we could color our objects. By rendering a greyscale version, we can use the overlay blend mode to add both highlights and shadows. So essentially, we've separated our lighting from our colors so we can tweak colors pretty heavily in AE, as you have probably seen by the thumbnail.

In this particular setup, we'll take a look at adding in renders that contain motion—our wheels and tires in this case—as well as adding in keyframed shape animation that we tie to sliders for hydraulic lines on our forklift and shadows for the cab and forks. The fork shadow is pretty cool as it gets softer and then disappears as the forks are raised.

At the end, we also go over a bug I found in master properties. Although I can't figure out how to reproduce it. The gist of it is that sometimes if you add new controls—and I think it's especially likely if you reorder them as this has happened to me before—sometimes After Effects will bug out and the controls may stop working entirely, or one control will actually change another control in your setup. But there will also not be any feedback that it's changed something else. So they can invisibly affect each other. So keep an eye out for that. To fix it, you basically have to start a new comp and add properties to a new Essential Graphics Template.

So this will probably conclude our rigging tutorials for now, but I wouldn't close the book on it just yet.

Expression Code

Make sure to add all of the controls as necessary!

Retime an image sequence to an angle control

f = thisComp.layer("Controller").effect("Wheel Rotation")("Angle") % 60;
if(f < 0) {
    f += 60;
}
f /= 2;
f * thisComp.frameDuration;

Note: we used a 30 frame sequence to make up 60 degrees of travel. So instead of 1 degree per frame—which is what we'd normally render—we did 2 degrees of movement per frame.

Animate a keyframed path from 0-1 second to match a slider

lift = thisComp.layer("Controller").effect("Lift")("Slider")/100;
thisProperty.valueAtTime(lift);

Our slider is intended to go from 0-100 so mapping it from 0-1 second is easy. While AE can interpolate pretty well, you might need to extend that. Just keep in mind value at time is in seconds.

Animate a keyframed path from 0-4 seconds to match a slider

lift = thisComp.layer("Controller").effect("Lift")("Slider");
t = linear(lift, 0, 900, 0, 4);
thisProperty.valueAtTime(t);

The other expressions shown are variations of the above, and are going to change depending upon what you're building. And that's it for now!

Tutorial 195: Forklift

Joe Clay | Oct 3, 2019

Master Properties in After Effects enable us to make more complex rigs than we could previously. And because of that, we're going to talk about techniques to rig objects. We start with a simple cube that has some pretty cool behaviors. It can flatten into the ground, which means it comes with its own transition built-in. It can also be scaled without scaling its strokes.

Then we take a look at a rigged forklift. All of the colors have been linked to control layers so you can change the colors of the forklift if you desire. There's an Angle Control that lets us pick between the 4 isometric angles that the forklift can face, even though only two angles were ever illustrated. This is accomplished by scaling our shape layers horizontally to make up the other two angles. While that would normally change our lighting, we've built and rigged luminosity layers—using grey tones and the overlay blend mode—that can swap the lighting back so that the lighting direction doesn't ever change. The forks of the forklift are also rigged so that the main section moves up, and then the rest of the lift sections extend fully.

In short, there's a lot built into this tutorial, and a lot of the techniques are designed to be applicable to all sorts of rigs. For example, one of the expressions shows you how you can build a checkbox that can switch between two keyframes for a property. We use it to change the lighting of the luminosity layers, but you could use to to switch between keyframes on a path, or intensities of an effect. There's a lot of versatility here.

And the best part is that this is only part one. There will at least be a second tutorial, if not a third. The next one will focus on more efficient ways to build this sort of model if you were going to make a whole bunch of different rigs. We're going to show how to take an actual 3D model, render out a minimal amount of frames and yield even more complex animation, versatility, and speed. And there's also something interesting that I want to try, but haven't had a chance to build yet. So please, stay tuned! And if you didn't see Tutorial 188: Isopush, check it out! It's helpful for moving layers in isometric directions.

Expression Code

Make sure to add all of the controls as necessary! If you absolutely want to limit things like the transition slider we used, you can use linear() or clamp(). If you use it directly on the slider itself, you can force it to not pass 0 or 100, or whatever arbitrary number you'd like. For example, our Forklift goes up 800 pixels. Instead of building it for percentage, you could build it for pixel values so that you can more easily match other layers to the forklift. You can use an expression like clamp(value, 0, 800) on the slider to get a slider that only goes from 0-800. There are a lot of possibilities when it comes to rigging with expression controls! Use the expressions below as starting points to build your own rigs!

Scale an object but maintain the stroke width

value/(thisComp.layer("Controller").effect("Scale")("Slider")/100);

Add vertical movement to an object based on percentage

y = thisComp.layer("Controller").effect("Transition")("Slider") * 1.085;
value + [0, y];

Add vertical movement to an object based on percentage after a threshold

y = thisComp.layer("Controller").effect("Lift")("Slider");
y = ease(y, 30, 100, 0, 300);
value - [0, y];

Posterize an Angle Control

a = thisComp.layer("Controller").effect("Angle")("Angle") % 360;
if(a < 0) {
    a += 360;
}
a /= 360;
Math.floor(a * 4);

Even Checkbox

if(thisComp.layer("Controller").effect("Side")("Slider") % 2) { 0; } else { 1; }

Upper/Lower Checkbox

i = thisComp.layer("Controller").effect("Side")("Slider");
if(i == 0 || i == 3) { 1; } else { 0; }

Control visibility with a checkbox

thisComp.layer("Controller").effect("Upper")("Checkbox") * 100;

Control visibility with a checkbox (inverted)

(1-thisComp.layer("Controller").effect("Upper")("Checkbox"))*100;

Alternate between keyframes using a checkbox

check = thisComp.layer("Controller").effect("Even")("Checkbox");
thisProperty.valueAtTime(check);

Alternate between keyframes using a checkbox (inverted)

check = Math.abs(1-thisComp.layer("Controller").effect("Even")("Checkbox"));
thisProperty.valueAtTime(check);

And that's it for now! And don't forget to check out part two!

Tutorial 194: Simple Rig

Severo Ojea | Sep 27, 2019

Rigs are not only for 3D characters. They can be used in a multitude of situations—from simplifying animation to automating repetitive tasks. Rigs make animating objects easier. Rather than dealing with a ton of keyframes, or complex elements, you can break complex motions down to a single control. It also makes it so that there's less potential for error. So we're going to create a text-based rig so that we can quickly and easily animate text on and change each letter out individually.

Tutorial 193: Sierpinski

Joe Clay | Sep 13, 2019

In building something for a client last week, I came up with an interesting movement using our generative paths from Tutorial 190: Cicada. At the same time I was doing more experiments with L-systems and so I coded a sort of Logo or Turtle graphics interpreter expression inside of After Effects. So this is the result of that.

The base premise is that we take the total number of points and fit them into a Trim Paths operation—or a pointOnPath() expression—by fitting the total number of points into 100. So we divide 100 by our total number of points, and set keys to move the end of our trim by that tiny increment. Then using loopOut('offset'), we have that tiny path move down the whole path. Setting our trim's start to be just a tiny bit away from the end effectively lets us use strokes that extend past the end like round or projecting caps to make circular or square dots.

There's a lot of additional things that can be done. After recording, I even built a system to put layers at specific positions matching the points of these generated paths so that anything could follow the paths in this mechanical fashion. By adding multiple points together, you could even make interesting animated shapes with these, which we'll probably do for Patron files this month. Also, that position setup found it's way into the project files if you want to buy them below.

Have fun experimenting with this! It's a rabbit hole.

Expression Code

Make sure to add all of the slider controls necessary as well as an angle control and rename them. We need Iterations, Distance, and the angle control is called Angle. The expression below should be applied to a path in a shape layer.

cmd would be the axiom or start. And the rules go in the map object. And the replace method within the first for loop. This first one makes the Dragon curve.

pts = [];
var x = y = 0;
var a = -90;
var cmd = 'FX';
var iterations = thisComp.layer("Controller").effect("Iterations")("Slider");
var d = thisComp.layer("Controller").effect("Distance")("Slider");
var angle = thisComp.layer("Controller").effect("Angle")("Angle");
var map = { X:"X+YF+", Y:"-FX-Y"};
for(var i = 0; i < iterations; i++) {
    cmd = cmd.replace(/X|Y/g, function(matched) {
        return map[matched];
    })
}
pts.push([x,y]);
for(var i = 0; i < cmd.length; i++) {
    switch(cmd.charAt(i)) {
        case 'F':
            x += Math.cos(degreesToRadians(a)) * d;
            y += Math.sin(degreesToRadians(a)) * d;
            pts.push([x,y]);
            break;
        case '+':
            a += angle;
            break;
        case '-':
            a -= angle;
            break;
    }
}
createPath(pts, [], [], false);

This one creates the Sierpinski curve.

pts = [];
var x = y = 0;
var a = -60;
var cmd = 'A';
var iterations = thisComp.layer("Controller").effect("Iterations")("Slider");
var d = thisComp.layer("Controller").effect("Distance")("Slider");
var angle = thisComp.layer("Controller").effect("Angle")("Angle");
var map = { A:"B-A-B", B:"A+B+A"};
for(var i = 0; i < iterations; i++) {
    cmd = cmd.replace(/A|B/gi, function(matched) {
        return map[matched];
    })
}
pts.push([x,y]);
for(var i = 0; i < cmd.length; i++) {
    switch(cmd.charAt(i)) {
        case 'B':
        case 'A':
            x += Math.cos(degreesToRadians(a)) * d;
            y += Math.sin(degreesToRadians(a)) * d;
            pts.push([x,y]);
            break;
        case '+':
            a += angle;
            break;
        case '-':
            a -= angle;
            break;
    }
}
createPath(pts, [], [], false);

And this one makes my...uh...Cauliflower curve. Good luck with it.

pts = [];
var x = y = bufferX = bufferY = 0;
var a = bufferA = -60;
var cmd = 'X';
var iterations = thisComp.layer("Controller").effect("Iterations")("Slider");
var d = thisComp.layer("Controller").effect("Distance")("Slider");
var angle = thisComp.layer("Controller").effect("Angle")("Angle");
var map = { X:"F+[[X]-X]-F[-FX]+X", F:"FF"};
for(var i = 0; i < iterations; i++) {
    cmd = cmd.replace(/X|F/gi, function(matched) {
        return map[matched];
    })
}
pts.push([x,y]);
for(var i = 0; i < cmd.length; i++) {
    switch(cmd.charAt(i)) {
        case 'F':
            x += Math.cos(degreesToRadians(a)) * d;
            y += Math.sin(degreesToRadians(a)) * d;
            pts.push([x,y]);
            break;
        case '+':
            a += angle;
            break;
        case '-':
            a -= angle;
            break;
        case '[':
            bufferX = x;
            bufferY = y;
            bufferA = a;
            break;
        case ']':
            x = bufferX;
            y = bufferY;
            a = bufferA;
            break;
    }
}
createPath(pts, [], [], false);

Tutorial 192: Scan

Severo Ojea | Sep 6, 2019

In this Cinema 4D tutorial, we use Redshift's incandescent shader to make a scan rig to use on any 3D object. Once you've built the rig, you can use it on pretty much anything. This technique would work well for futuristic user interfaces/FUI, HUDs, screens etc. It could probably also be applied to medical animations, but you might want to stay away from red.

For more information on the Voronoi Fracture check out Tutorial 157: Particle City. Get free CAD Models at GrabCAD.