Posted Apr 29

Introducing Codex: one rig to rule them all

by Rikki Knight Trembath
Introducing Codex: one rig to rule them all by Rikki Knight Trembath

Rigging is an essential component of any animation workflow and a fast rig allows not only a more efficient pipeline but also enable better animation work through more interactivity and visibility in context.

Most of the time, puppets are not performant enough, presenting a challenge when animators need real-time feedback to author animation. It can also be quite an expense if you want to author a full rig in multiple applications.

Wouldn't it be nice to rig a fast creature where the creature doesn't suffer these low playback speeds? To only spend time rigging it once and then have the same rig in other applications? That would make animation transfer so much more comfortable where instead of moving around baked keys, you can use sparse keyframes that keep your breakdowns.

Enter Codex, a propriety creature authoring Digital Content Creation App (DCC). Independent of business logic (MPC, MR. X, The Mill, Mikros), creating rigs agnostic from off the shelf applications (Maya, Houdini, Unreal etc.).

Yes, yes, all good, but what does it do?

Codex sets up a framework that allows artists to generate components, arms, legs, etc., that come together to form a creature. This might seem familiar; a lot of rigging systems do this. Our framework differs because we communicate with other DCC's while keeping the data centralised and agnostic. Should a DCC crash, the user can reconnect to our server and recover where they last left off from Codex. This decentralises rigging from typical applications like Maya, opening up multiple reflections.

These components that Codex generates are data-oriented. This allows us to take control and achieve efficient use of memory and I/O.

They are also functional, meaning they have strictly typed inputs and outputs and should be free of side effects. Providing static boundaries for the components to exchange and pass data.

Codex allows us to move away from traditional management and scripting of components often tied to the DCC. Thus, freeing the artists to rig a creature once and recreate this representation in other DCC's (Maya/Unreal, for example).

Codex's structure allows easy export of multiple rigs into different evaluation resolutions. This provides different levels of complexity of a rig to various departments – for example, layout, previs, animation, fx etc. As it's the same rig with increasing evaluation levels, this allows motion to pass seamlessly down the pipeline.

Component data objects are programmatic functions agnostic from the host (Maya, Houdini etc.). They have access specifiers such as private, protected, and public that aid in developing the rig (Public is for downstream users like animators, protected and private to design the rig and initialisation). The component is provided parameters from riggers and inputs from animation, which returns a set of outputs. This approach results in users approaching the components' design to be more like a function, a piece of software. By treating components like software instead of looking at rigs as assets, the user can start versioning and tracking components throughout production, much like software. It can be easy to scan shows to see what might be out of date with the central library. Furthermore, with components being a data object, we can now differentiate them for the rigger, allowing them to see the potential differences before they bump the version for their show.

But what's the artist's interface like? Do they need to relearn a new package?

The rig authoring can be done in a familiar environment, which helps the adoption of the product.

We use a validator in Maya to run small unit tests on the asset; this allows the riggers to rig with confidence that they are working to the guidelines Codex sets out. Once it passes the component, the user can abstract it into a data object. When a test fails, we offer a conform step to make sure the user has minimal interruptions. This allows us to fix the rig automatically, saving the user time.

Once a library of components is built, this presents an easy workflow for assembling creatures. While this might be familiar to artists, Codex helps decrease rig authoring times by offering a more drag-and-drop interface. This simplifies a creature's construction, moving away from traditional build scripts. The components can be imported, duplicated, or sections copied and pasted, allowing the merging of components if needed like an fk chain and ik spline. Artists can work with a component in isolation within Maya while keeping the entire creature loaded in Codex. If an artist needs to adjust an enormous asset, the edits can be kept quick and snappy in Maya without needing the creature as a whole. Furthermore, with Codex owning the data, we can help reduce build times when injecting and creating the rig in Maya.

Codex sets out to work with the DCC by augmenting and helping the artist's workflow, rather than inject a different engine. This allows the rigs to take advantage of the DCC features, where custom engines can make this more challenging.

One augmentation we have applied is enhancing Maya's node editor. Graph layouts can easily be lost in Maya if you're not careful. To make it a lot easier to work with, part of this augmentation is making sure the artist can graph the component in isolation. Normally graphing results in the entire graph from start to end, which is not too helpful if you're working on a component and wanting to see it in isolation.

Also, adding auto-saving to graph layouts ensures they are persistent between abstraction and different Maya sessions. This eliminates the issue of losing work when organising the readability of a graph.

Another addition we added was a new catalogue search pop-up. It improves on the node editor by displaying a consistent font rather than the native one which if the name becomes too long is too small to read. We add a node history and explore menu, which isn't new in itself as far as these pop-ups go but was lacking from the native node editor. And finally, we introduced a query language, allowing us to search not only by name but also by input/output types and even by tags.

In conclusion, with the guidelines and nodes Codex has provided so far for Maya, we have seen complicated creatures perform up to 90fps+, providing real-time creatures for elaborate set-ups.

Codex presents a new future in rigging: while delivering performant rigs, we also allow rigs and their evaluation description to be agnostic from the application without the need for custom engines. Equipping artists with the tools to set up a character once before replicating it in multiple applications with the option of varying evaluation resolutions. –

Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.