Tutorial 191: Grid Generation

Joe Clay | Aug 30, 2019

I've experimented a ton with the effect in this tutorial, but I think this might be the most perfect version of it. And because of that, there's a bit more that can be done with it since it relies on a lot less processing power.

We start by building tiles to replace our sources with. Sources are our gradient maps and tiles are our final output. We're basing our system on a 20 x 20px grid, but you don't even have to use a grid if you don't want to. And if you don't, you might want to add some slight noise to your sources because that can have interesting effects when the tiles are mapped to the source.

The basic idea is that we're using an intermediate comp—Piece—to take our source maps and our tiles and composite them together. With some input from our main comp, like piece number and total number of pieces, we drive an extract effect to crop our source to a range of luminance that will fit that piece, and when we combine all of the pieces with different tiles, we get this effect.

I haven't messed around with this particular idea, but you can also add a Master Property in the Piece comp to change what channel the extract effect looks at. It can't be added directly to a Master Property, but you can put a slider on your controller that the Channel parameter looks at. And then you can add that slider to your Master Properties. 0 and 1 are both Luminance. Red is 2. And so on.

Using this idea, you could add tiles according to certain colors which makes your source maps way more powerful. So, as always, there's a lot to be explored. Have fun experimenting and tweet us @workbench_tv if you make anything with this!

For more information, please see the following tutorials. Some are made somewhat obsolete by this technique, but you might be able to glean other interesting information from them.

• Tutorial 65: ASCII & Text Generation
• Tutorial 67: Glitch Mapping
• Tutorial 120: One Comp to Rule Them All
• Tutorial 122: After Effects Multi-shader
• Tutorial 129: 8-bit Glitches
• Tutorial 131: Generative Elements
• Tutorial 152: Procedural Circuitry
• Tutorial 160: Mechanical Text
• Tutorial 165: Generative Art
• Tutorial 190: Cicada

Expression Code

These expressions are applied to the Extract effect parameters. This one is for black point.

n = thisComp.layer("Controller").effect("Piece")("Slider");
t = thisComp.layer("Controller").effect("Total")("Slider");
(n - 1) * (255/t);

This one goes on white point. It's nearly identical.

n = thisComp.layer("Controller").effect("Piece")("Slider");
t = thisComp.layer("Controller").effect("Total")("Slider");
n * (255/t);

And this last one goes in your Sources/Tiles comp in the opacity for each Source/Tile. Just swap the names to fit which one it is.

if(thisComp.layer("Controller").effect("Source")("Slider") == index) {
    100;
} else {
    0;
}

Then just make sure everything is linked up in your Master Properties and you're all set.

Tutorial 190: Cicada

Joe Clay | Aug 23, 2019

I was working on some other ideas for this week's After Effects tutorial, and I wasn't really getting anywhere. So I took some time to do other things and just take a break. Wednesday morning, I was rowing and while I row, I watch videos on YouTube. Great Big Story just published an excellent documentary series on Cicada 3301, so I was watching the last two episodes and I thought their graphic treatment was interesting.

I've been a fan of Cicada 3301 and puzzles like that in general. When I was a lot younger, I discovered notpron and spent a while going through it. I never finished it because I didn't have the time, though I should probably go back to it. But ciphers, steganography, etc. have always been really intriguing to me.

So, combining that with my love of Albert Omoss' work on the FITC Tokyo 2015 titles I quickly thought of a way to build a stupidly simple L-system-ish expression to make generative lines. We randomly choose directions and lengths, and draw points at 90 degree angles. So we end up with interesting paths, almost like a 2D version of the old pipes screensaver!

Taking those paths and combining them with shape modifiers we can make all sorts of things—lines, boxes, paths for movement, etc. You could even take these and use other modifiers like twist to get really odd looks and movement. This technique renders pretty quickly too. Our example is a little slow, but it has camera blurs, grading, and more so keep that in mind!

Have fun experimenting with this. I'm sure there's a lot more that can be done with this if you take the time to explore! Tweet us @workbench_tv if you make anything with this! And grab the Cicada drawing from aniszewskas here if you want to use it.

Expression Code

Make sure to add all of the slider controls necessary and rename them. We need Random Seed, Steps, Max Length, Stroke, Offset, and Completion sliders. The expression below should be applied to a path in a shape layer. Stroke, Offset, and Completion sliders are basically just pickwhipped to Stroke Width, an Offset modifier, and the End property of a Trim Paths modifier.

s = thisComp.layer("Controller").effect("Random Seed")("Slider");
n = thisComp.layer("Controller").effect("Steps")("Slider");
l = thisComp.layer("Controller").effect("Max Length")("Slider");

seedRandom(s, true);
var pts = [];
var x = y = 0;
pts.push([x,y]);

for(i = 0; i < n; i++) {
    var d = Math.floor(random(l));
    var r = Math.floor(random(4));
    switch(r) {
        case 0:
            x += d;
            break;
        case 1:
            y += d;
            break;
        case 2:
            x -= d;
            break;
        case 3:
            y -= d;
            break;
    }
    pts.push([x,y]);
}

createPath(pts, [], [], false);

Tutorial 189: Real Glitches

Severo Ojea | Aug 16, 2019

In this week's Cinema 4D tutorial, we're going to exploit OpenGL rendering errors in order to make some glitches that we can use in After Effects later on, or even as 2D/3D animations in their own right.

Since OpenGL can have clipping issues with geometry at certain distances to the camera—especially if polys are close together—we're able to make use of those errors to produce actual rendering glitches.

Have fun with this one and make sure to experiment! Joe and I were sitting down to figure out something else and a glitch that we would normally ignore had an interesting pattern, so we continued down that rabbit hole and here we are.

Tutorial 188: Isopush

Joe Clay | Aug 9, 2019

You know what's really not fun to do inside of After Effects? Moving things at angles that aren't multiples of 90° is a pain. There's not really any guides for isometric projection. It's not even easy to draw in Illustrator. Isometric art has been popular for quite a long time—ever heard of M.C. Escher or seen architectural drawings—so it's kind of annoying that it's difficult to work with isometric art inside of AE.

Well, I can help to make it a tiny bit easier to work with. Without sacrificing our ability to move layers anywhere on screen, we're going to build three sliders that will let us move our layers in angles corresponding to our isometric projection. This tutorial builds upon what we built in Tutorial 87: Angular Controls. If you need more explanation on the math behind this, check that one out.

This one is pretty simple, but it will save you a ton of time. I had to build some boards with a lot of isometric art in it last week, and it probably saved me hours already. And that's why I built this! I hope it saves you time too.

Expression Code

If you have Pseudo Effect Maker and you want to build your own preset you'll need to modify this code. Otherwise, you just make three sliders, name them X, Y, and Z, and add this expression to position. Note: if you're a Journeyman patron or above, a preset for this will be in your download this month.

//ISOPUSH
function getPoint(angle, magnitude) {
    return [Math.cos(degreesToRadians(angle)) * magnitude, Math.sin(degreesToRadians(angle)) * magnitude];
}

x = effect("X")("Slider"); //30
y = effect("Y")("Slider"); //0
z = effect("Z")("Slider");//-30

x = getPoint(30, x);
y = getPoint(90, y);
z = getPoint(-30, z);

value + x + y + z;

Tutorial 187: Triggering Animation in Cinema 4D

Severo Ojea | Aug 2, 2019

In this week's tutorial, we use objects in Cinema 4D to trigger the animation of other objects—without keyframing. This technique is pretty versatile, as it relies on blending objects inside of a cloner. While you can use effectors' falloff to achieve some of this, using fields exponentially increases our limits because of how much can be controlled using fields and because of what can be used as a field. We also use dynamics and collisions to trigger animation. So there's a ton that can be done if you explore!

Tutorial 186: Behaviors

Joe Clay | Jul 26, 2019

In this week's After Effects tutorial, we explore building a Cinema 4D-like effector by setting up behaviors based on positioning of layers. In our first example of a very wildly inaccurate Apollo mission example, we use distance to illustrate a burn of the Command Module. I also mentioned that this was inspired by the 50th anniversary of the moon landing an the new Apollo 11 (2019) documentary. There's some amazing footage in there that was recovered, and I believe it's a lot of never-before-seen footage. It was painstakingly put together, and the result is excellent.

Anyway, we continue on to make objects scale as another object approaches and finally we make a space ship capable of matter rejection. What's that you ask? It's the ability to force objects to stay outside of a predefined perimeter. There's not asteroid that can touch our ship.

There are a ton of things that can be done with this technique. You're really only limited by your imagination and ability to code. We've already covered distance and angle, so you have a good base to start from!

Expression Code

This is the more basic code from the tutorial. It covers distance only.

d = length(thisLayer.position, thisComp.layer('Moon').position);
s = ease(d, 100, 300, 80, 30);
[s, s];

This is the more complex code from the tutorial. It covers distance as well as angle.

r = effect("CC Sphere")("Radius") + thisComp.layer("Controller").effect("Shield Radius")("Slider");
ptA = thisLayer.position;
ptB = thisComp.layer('Zeus Orb').position;
d = length(ptA, ptB);
if(d < r) {
    x = ptA[0] - ptB[0];
    y = ptA[1] - ptB[1];
    a = Math.atan2(y, x);
    x = Math.cos(a);
    y = Math.sin(a);
    r = r - d;
    value + [x*r, y*r];
} else {
    value;
}

Tutorial 185: Digital Countdown

Severo Ojea | Jul 19, 2019

In this week's tutorial, we create a grid of splines and deform them with a MoText Object. This setup is simple but the base can be used and deformed in a matter of ways to create anything from FUI elements to Backgrounds.

Tutorial 184: CSV-Based Graphs

Joe Clay | Jul 12, 2019

This week, we're exploring using a CSV file to generate graphs in After Effects. Building a CSV allows for a lot of interesting things, one of which is the ability to use data to drive animation. In our case, a cool side effect of using a CSV is that you can change the data outside of After Effects and it can automatically change your animation.

Data driven animation also makes it really easy to version things. Basically, if you can put something into a spreadsheet, you can use it in After Effects. Graphs and data aren't the only things you can use CSVs for. You can even use them to offer different translations for a script so you can switch your project over to output another language with minimal effort. Perhaps we'll take a look at that exact use case in the future.

If you need any additional information on how to use CSVs in After Effects, check out Sergei's excellent introductory lesson over at Ukramedia—Tip 071: How to Create & Use a CSV File in After Effects.

And as always, make sure to experiment.

Expression Code

Before adding these expressions, be sure to add three sliders to a layer named Controller. One should be named Start Row, one should be End Row, and the final should be Tangent Radius

This generates the months from a CSV file that has dates in the format YYYY-MM. Apply this to a text layer's Source Text property.

start = thisComp.layer("Controller").effect("Start Row")("Slider");
end = thisComp.layer("Controller").effect("End Row")("Slider");
str = '';
options = {
    month: 'short',
    year: '2-digit'
};

for(i = start; i < end; i++) {
    d = new Date(footage("WBsubs.csv").dataValue([0,i]) + '-1');
    str += d.toLocaleDateString('en-US', options) + "\t\t";
}
str;

This generates the line graph itself. Apply it to a path inside of a shape layer.

start = thisComp.layer("Controller").effect("Start Row")("Slider");
end = thisComp.layer("Controller").effect("End Row")("Slider");
tanR = thisComp.layer("Controller").effect("Tangent Radius")("Slider");
x = 296 - 960;
y = 766 - 540;
pts = new Array();
inTan = new Array();
outTan = new Array();

for(i = start; i < end; i++) {
    ptX = x + ((i-start) * 147.7);
    ptY = y - (linear(footage("WBsubs.csv").dataValue([1,i]), 0, 3000, 0, 452));
    pts.push([ptX,ptY]);
    inTan.push([-tanR, 0]);
    outTan.push([tanR, 0]);
}
createPath(pts,inTan,outTan,false);

Tutorial 183: Outbreak

Severo Ojea | Jul 3, 2019

In this week's tutorial we use Cinema 4D's Fields along with Redshift to make a growing viral look.

Tutorial 182: Compression Glitches

Joe Clay | Jun 28, 2019

This week, we're looking at how to achieve a compressed jiffpeg look using a procedural stack of effects. If you're curious, Big Black is built from Bashcorpo textures—number 8 on this list, though I have a copy numbered 10. Also, the eagle-eyed of you might notice there's a Base composition in the Base 2 comp. There's just text in there. I made base contain all of that in case I went a little crazier in the Base 2 comp! And finally, if you're wondering what the hell JSplacement is, go check out our tools post. That's it. Now go out and experiment!