The Magic of Cavalry

Cavalry brings a lot of innovation to the way animators can work. This post explores a few of the ideas central to these innovations.

The Cavalry Interface

Cavalry has lots of standard animation features, such as keyframes, curves, and a fully fledged graph editor along with an enormously powerful Project Window (more on those another day), but the first thing to get out the way is that Cavalry has a predictive user experience, meaning we infer and automate a lot of the boring stuff (this makes Cavalry really easy to use) while managing to maintain complete artistic freedom — as this article will hopefully make clear.

Example 1, A Simple Circle:

Here we create a circle, add a Noise Behaviour to the scene, and connect them.

Make a circle, add Noise, connect them. Play.

There are two things to notice here, firstly, we made the connection by dragging from a Connection Anchor on one object and dropping the connection onto another object. This is how you connect things in Cavalry.

The second thing to notice is that menu that appeared when we released the mouse. Here’s a screenshot:

Those options are all okay to choose. This means that the same Noise that can deform a shape, can connect to its position, or radius, or colour and so on. It can even power several things on several objects all at once, just by dragging those connections (there’s an even faster way to do this, but I’ll show you that later). That’s a core foundational concept of Cavalry. Anything can connect to anything — within reason anyway. This was the thought that started the whole Cavalry adventure, and which enables so many magical workflows.

Example 2, A Grid of Polygons:

Making a simple grid is trivial.

Okay that was easy, but let’s say we want each polygon to have a random number of sides.

Add a Random Behaviour to the number of sides on the Polygon.

You may have spotted that I right-clicked on an attribute and added a Random Behaviour from a menu (that’s the quick way to add Behaviours that I mentioned above).

The amazing thing to note here is that each time the Duplicator went to build a polygon, it asked the Random Behaviour for a different random number. This is the most simple example of a technique that can take you to amazing places, in very little time.

So let’s take a look at another example in a similar vein.

Example 3, Outlines:

Let’s start with our circle again. This time we’ll create an Outline for it. Then we’ll pop that into a Duplicator and make lots of copies of it.

Then instead of Noise or Random, let’s use a Stagger Behaviour this time, and let’s use it on the Basic Shape’s Radius attribute. Stagger will just give us some values ‘staggered’ between a minimum and maximum.

Making outlines.

That was cool.

Okay, so now let’s put a Random on the length of that Outline.

Adding a Random Behaviour to the Length of the Outlines.

Yes, it’s that easy.

Okay, now let’s make the Outline travel around the shape. For that we can use a Frame Behaviour.

Add a Frame Behaviour, and then randomise the direction and speed.

Notice I added a Random Behaviour to the Frame’s Value attribute, which means some outlines travel faster than others, and some even go backwards.

Remember this is procedural! Let’s change the number of Outlines.

Now let’s colour the outlines in using a gradient.

Okay you get the idea. In a few clicks you can create something truly complex which also remains fully editable, and you can just keep layering effects on top of each other until you’re done.

Back to the beginning, adding Noise as a deformer.

And there you have it; an introduction to the magic of Cavalry. One thing to note is that I’ve barely scratched the surface of what you can do, but hopefully you’ve enjoyed this brief introduction. Finally, be sure to checkout the Cavalry Instagram page below.