This episode we conclude the presentation of Maya’s evaluation models by going over parallel evaluation.
We explain how it works, what nodes operate in which way, and the fundamentals to make the best of your graph’s layout to ensure you keep all cores of your CPU busy.
I haven’t seen this discussed extensively anywhere else, so there are good chances you’ll find it useful.
Enjoy,
With the scripting saga finally over we take a good look at how Maya’s DG (Dependency Graph) evaluation model works.
We introduce evaluation graphs in general, the concepts of push and pull, data vs evaluation, and then we move into more Maya specific territory.
Maya’s MDataBlock, compute(), Plugs and dirty state and all that goodness.
I do wish I had switched up to our own rig to show a more complex graph somewhere in the last third, but hopefully the simplicity of the example and the discussion will still get the point across even for the more complex scenarios. We will, no doubt, have a chance to revisit the subject again soon enough when we’ll be discussing profiling and performance.
In the end we also introduce some of the peculiarities and fundamentals of how the model behind the new multi-threaded evaluation looks like.
Enjoy,
Like a few episodes ago I feel this episode, while still with a clear main theme of the Guide, needs an introduction.
I have, in the past, redone streams when I thought they weren’t up to par. In this case I decided not to (redo it), because I don’t feel it’s a “bad one”.
The first half is without hitches and we go about our business of analyzing where we stand, recapping, and setting things up.
Somewhere in the second half being indecisive about how to tackle the framing of the knee buffer, I chased my tail around a bit while looking at options, and on some fairly simple mistakes (largely involving the aim constraints).
The episode is still worth watching through, but it feels like I have been hand waving the graph cycle subject for too long so that the second part of the episode might be confusing to a good slice of the audience.
Lastly, at the very end, in the last few minutes before wrapping up, I explain something about containers (assets) in Maya, how they interact with the node editor, and why you might find that opening one of the scenes I share might show you a node editor with no connections despite the rig working fine.
So, with all that in mind I decided to do a special intro to explain how constrain cycles work, why they exist, what other cycles you might encounter and what their consequences are as well as how to solve them.
Thanks for reading, and enjoy the episode,
Not a lot to add here that won’t be obvious from the video itself.
I originally intended to start more from the animation interface, but ended up discussing graphs as a problem solving notion with a fair chunk of actual rigging in Maya first.
We’ll start on an implementation proper and discuss the interface next episode.
Enjoy,
In the interest of building up vocabulary on math fundamentals for the rest of the season we introduce Set and Graph Theory.
Both the video description and a comment under it contain an Errata Corrige I have to make here as well:
While talking about the inverse function of sin, arcsin, I mention the co-domain of the function being -pi to +pi; that is incorrect, as the domain of arcsin spans the half circle, and therefore is -1/2pi to +1/2pi