Menu

Tutorial 171: Glitch Paths

Joe Clay | Apr 12, 2019

In this week's After Effects tutorial, we're actually back in After Effects. I was talking to Mikey Borup about messing with paths using expressions, and while he was working on something, I had an idea for something else. So we're going to explore glitching paths. The basic idea is to take paths and screw them up with code.

Mikey had done something cool with messing with path resolution, using pointOnPath(). So I built glitchy text by rebuilding paths with different points. Then I started to move those points around, and ultimately I started adding in my own blocky glitches.

Since we're just using paths, we can actually use any shape, so this isn't just limited to text. So experiment with different things. You can even add in path operations like the ones I mentioned from the Mo Better Blobs tutorial—and make sure to read the text for an update.

Now, here's some code for you to examine.

Expression Code

Note that all of these require slider controls. You can see which ones you need to make assigned to variables in the following expressions.

All of these are set to glitch randomly, so sometimes the original paths are shown. In the first one, we build an array of points at a specified resolution, and then we randomly select points from that array and move them before passing them back into createPath().

var origPath = thisProperty;
var freq = effect("Glitch Frequency")("Slider")/100;

if(random() < freq){
    var res = effect("Resolution")("Slider");
    var amp = effect("Amplitude")("Slider");
    var amt = effect("Glitch Amount")("Slider");
    var seed = effect("Seed")("Slider");
    var pts = new Array;
    var skip = 1/res;
    seedRandom(seed);

    for(var i = 0; i < res; i++){
        pts.push(origPath.pointOnPath(i*skip));

    }

    for(var i = 0; i < amt; i++){
        var j = Math.floor(random(res));
        var offset = [random(-amp,amp),random(-amp,amp)];
        pts[j] += offset;
        if(j < res - 1) {
            j++;
            pts[j] += offset;
        }
    }
    createPath(pts);
} else {
    origPath;
}

In this version, we've changed out glitches to happen randomly, and we're also using the timeless argument to seedRandom() so that our random numbers will only change every 2-3 frames. This allows out glitches to hold for a frame or two longer so it's less crazy but more distinctive—like animating on twos. We've also change our random movements to push out in x only, effectively pushing out boxes from our paths. Even though I pressed on, I think I actually prefer this one.

var origPath = thisProperty;
var freq = effect("Glitch Frequency")("Slider")/100;
var seed = effect("Seed")("Slider");
seed = seed + Math.floor(time*15);
seedRandom(seed, true);

if(random() < freq){
    var res = effect("Resolution")("Slider");
    var amp = effect("Amplitude")("Slider");
    var amt = effect("Glitch Amount")("Slider");
    var pts = new Array;
    var skip = 1/res;

    for(var i = 0; i < res; i++){
        pts.push(origPath.pointOnPath(i*skip));=
    }

    for(var i = 0; i < amt; i++){
        var j = Math.floor(random(1,res-2));
        var x = random(-amp,amp);
        pts[j] = [pts[j][0] + x, pts[j-1][1]];
        pts[j+1] = [pts[j+1][0] + x, pts[j+2][1]];
    }
    createPath(pts);
} else {
    origPath;
}

In this one, we've added in a function called buildBlock() so that we can bump out a block whenever we want. So we grab all of our points, and when we're done with that, we add in boxes up to the number specified in the amount slider. Those are concatenated to the end of the original points. So they're drawn in order after the original points, so that they'll intersect the existing geometry.

function buildBlock(a, b) {
    var x = random(-amp, amp);
    var block = new Array;
    block.push(a);
    block.push([a[0] + x, a[1]]);
    block.push([b[0] + x, b[1]]);
    block.push(b);
    return block;
}

var origPath = thisProperty;
var freq = effect("Glitch Frequency")("Slider")/100;
var seed = effect("Seed")("Slider");
seedRandom(seed);

if(random() < freq){
    var res = effect("Resolution")("Slider");
    var amp = effect("Amplitude")("Slider");
    var amt = effect("Glitch Amount")("Slider");
    var pts = origPath.points();
    var inTangents = origPath.inTangents();
    var outTangents = origPath.outTangents();
    var skip = 1/res;

    for(var i = 0; i < amt; i++) {
        var pt = random();
        var a = origPath.pointOnPath(pt - .01);
        var b = origPath.pointOnPath(pt + .01);
        pts = pts.concat(buildBlock(a, b));
        for(var j = 0; j < 4; j++) {
            inTangents.push([0,0]);
            outTangents.push([0,0]);
        }
    }
    createPath(pts, inTangents, outTangents);
} else {
    origPath;
}

This is the final expression. To save time and also make cleaner paths, we test to see if we should add a glitch and then we add it instead of the point we were going to add so that it occurs where it should along the path. This makes it less crazy. Earlier versions didn't have a the Glitch Spread slider and the spread variable. This allows you to force the glitches to occur less frequently, so that instead of showing up all at the top of the paths, they spread out. This is because if they will glitch points 80% of the time, most of the glitches will be used earlier in the process of building the paths leaving none for the rest. So adding in that slider allows you to fine tune it.

function buildBlock(a, b, glitches) {
    var x = random(-amp, amp);
    var block = new Array;
    block.push(a);
    block.push([a[0] + x, a[1]]);
    block.push([b[0] + x, b[1]]);
    block.push(b);
    return block;
}

var origPath = thisProperty;
var freq = effect("Glitch Frequency")("Slider")/100;
var seed = effect("Seed")("Slider");

seed += Math.floor(time*15);
seedRandom(seed, true);

if(random() < freq){
    var res = effect("Resolution")("Slider");
    var amp = effect("Amplitude")("Slider");
    var amt = effect("Glitch Amount")("Slider");
    var size = effect("Glitch Size")("Slider") * .01;
    var pts = new Array;
    var inTangents = new Array;
    var outTangents = new Array;
    var skip = 1/res;
    var glitches = 0;

    for(var i = 0; i < res; i++) {
        if(random() > .5 && glitches < amt) {
            var a = origPath.pointOnPath(i * skip - size);
            var b = origPath.pointOnPath(i * skip + size);
            pts = pts.concat(buildBlock(a, b));
            for(var j = 0; j < 4; j++) {
                inTangents.push([0,0]);
                outTangents.push([0,0]);
            }
            glitches ++;
        } else {
            pts.push(origPath.pointOnPath(i * skip));
            tangent = origPath.tangentOnPath(i * skip)*10;
            inTangents.push(mul(tangent, -1));
            outTangents.push(tangent);
        }
    }
    createPath(pts, inTangents, outTangents);
} else {
    origPath;
}

And that's it. I hope this helps you, or at least gets you thinking of the power that we finally have to control the destiny of our paths.

Grab the Project Files

Get the project file through our Gumroad Store. This project file contains all of the setups shown in the tutorial as well as some other graphic elements used in the final design. It also includes all of the expressions used during the research and development of this tutorial. I've also included an older version that should open in AE CC 2018+. Versions prior to 2018 cannot access path points.

If you're buying project files, consider becoming a Patron. At the $5/mo. tier, you get access to project files as they come out and some tutorials also come with additional BTS content showing more of the builds.

Get the project on Gumroad

Become a Patron

If you'd like to help support Workbench, check out our Patreon page. Thank you for even considering clicking this link to support what we're doing. We appreciate it. Patrons get all sorts of benefits, from additional files to early product releases depending upon the tier.

Check out our Patreon Today