Skip to content

Cult of Rig Posts

Season 01 – Episode 40 – Learning and Visualizing Maths

Learning and Visualizing Maths

Over one and half hours focused on tools to visulize maths, developing intuition, and understanding correlations. Vectors, Matrices, Trigonometry and Desmos.

I know the math videos are popular, and I had wanted to do something along these lines for a while, and today it took my fancy to give it a shot.
If you care at all about learning maths then this is certainly worth watching, no matter what level you’re at (it’s more about learning than it is about the specific sub topics).

It also comes with some graphs for you to play with:
Rotational Transform
Angle Between


Season 01 – Episode 39 – Fitting the Leg

Investigating and Fitting Leg Component

This follows very closely from the previous episode.
We had one component left to take care of, the leg, which is also the most complex we have in the rig.

We sorted out the lot in this episode while re-explaining what the various sub-graphs do and making sure all expectations are met.

It’s a good episode to watch if you’ve been following reasonably close to releases and, like me, you need a refresher on what we were doing plus some tips on debugging/investigating while nodelling.


Season 01 – Episode 38 – Fitting the Rig to Geometry, Re-acquisition

Fitting the Rig to Geometry

I announced this episode as a chill stream, but it accidentally came out quite well paced (at least in my opinion.) Always accidentally it’s the last day of the year and the episode ended up being a recap of everything we did during the year, which I also find fitting (no pun intended).

Initially I just wanted to reacquaint myself and the audience with the rig we’d been working on for so long, and I thought that fitting it to some geometry to put it to the test would have been a good way to go about it.
We did do that, in the end, but the outcome is an inspection and a summary of all components as well as a successful fit of the guides lining up everything to the geometry, and the first chunk of work on a scene to be shared done.

Leg Global, Godnode and Foot are all in good shape now, and next stream we should be able to do the leg, call it a wrap on the mehcanics (unless some bug or other rears its ugly head) and finally move on actually binding to the geo.

Whether you’ve been following all along and took a long break with me, or you’re bumping into this while binging on the whole season after it got done weeks or months away from me writing, I think it’s been a worthwhile episode.


Season 01 – Episode 37 – Modular Components, Reassembling the Rig

Modular Components and Rig Assembly

I’ve talked about components being modular before and I’ve shown the I/O process in the past, but this time around we do it for real.

There isn’t anything specific that’s new, but I did kind of like how it went and I would recommend watching it. It will take you through the whole process of componentisation and assembly well enough.

There’s a bit of everything in it, Maya bugs, scripting, tiny amount of nodelling, Q/C, conforming, the actual I/O of the components…
All in all I feel it came out well paced and it covers a good chunk of ground in one hour.

To be a bit more specific: This is where we take all of our components and we push them through the I/O process (to file and from file) both for Q/C (Quality Control) as well as to actually re-assemble a full rig.

In the process I list a couple gotchas with containers, find a non-bug, and we write a trivial renaming script (more for variety than anything). All the work gets done on time, and we fix the last couple dirty bits in our components, which turned out to be bug-free, and only in need of some conforming.

QnA, the last dozen minutes or so, is mostly me rambling about rig standards, instrumenting rigs, and pipelines at scale and not.

As usual the code is available on GitHub in the didactic section but it really isn’t anything much.


Compiling C++ Plugins for Maya with Visual Studio

Compiling C++ Plugins

This is something I had wanted to do for a very, very long time.

A lot of people end up never learning to write C++ because of the difficulty presented by the ecosystem, despite the fact that the base facilities of the language itself are actually pretty straight forward.
In a similar vein I find the language itself, or its use in APIs, is often taught in an overly isolated fashion when it’s actually pretty important to understand how the tool-chain components (project, compiler and linker) actually work together to write and debug such plug-in’s.

My answer to that is a mini-series that isn’t really about C++ (there are many books and videos about that) as much as it’s about knowing how the system goes from source to binary target: We go from nothing to actually assembling and then building an open source node library without using other people’s projects. Every step is explained in both terms of doing it and what goes on under the hood, with further notes on what components participate and how, including possible issues and early troubleshooting of the various steps.

If you want to learn C++, or even if you don’t want to but you would still like to be able to build many of the excellent open source plugins available out there by yourself, this is the playlist for you.

Extra thanks to all the Patrons on Patreon who gave me the motivation to do it and provided feedback on the work as it progressed and was made before its public release.