Skip to content

Tag: stream

Season 01 – Episode 20 – Leg Guide pt2

Finishing the Guide, Notes on Constraints

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,

Intro and Constraints

Episode 20

Season 01 – Episode 19 – Leg Guide pt1

Guiding the Leg Proper

Part one of I’m not entirely sure how many episodes where we will finish the guide and set up for the leg component proper.

There isn’t anything specific about the episode I feel needs outlining. We have some work ahead of us to make the full rig configurable by guide and finished, and this is one of those sessions of honest work to get there.
I wouldn’t call it boring, I actually quite enjoyed streaming it and am looking forward to the next one or two we’ll need to finish this, but it’s one largely about keeping the graph in check while nodelling new parts on.

Enjoy,

Season 01 – Episode 18 – Refactoring Components

Refactoring Components

In this episode we do a pretty extensive refactoring (strict) of the leg and leg global components.

I’m not gonna lie, I’m actually quite happy with how it turned out.

Refactoring, in programming, is often done poorly and when people say “I have to refactor this for the future” they often mean “I’ll rewrite it according to my understanding of the problem space and destroy every interface in the process”.

We remained strict about it instead, moved a bunch of functionality across components and suppressed some unnecessary parts of the graph, both across and inside components, with the public interfaces left entirely unscathed.
The fact it was done methodically and entirely by just reasoning about the graph’s topology and our expectations is the part that I believe was successful. Worth a watch, even if I say so myself.

Enjoy,

Season 01 – Episode 17 – Planning a Refactoring, Maya Profiler

Planning a Refactor and Maya Profiler

This is an atypical episode: for the most part we don’t modify anything in the rig.
In a way that’s not atypical in software development; some times you need to stop for a moment, take stock of what you did and why, and refactor some of the work before you can proceed to the next Milestone.

This is what happened in episode 17. I took a long hard (thoroughly commented) look at what I wanted to do next and what I had done insofar to plan my next steps.
It’s not a bad episode di per se’, I have re-done a couple of those in the past and would have re-done this had I thought it was useless, but it’s not an eventful or entertaining one.

There is one exception though contents wise which is a bit more exciting: Towards the very end someone asked a question about the Maya Profiler, a very useful but often overlooked and under explained feature.

If you don’t care for the slower paced episodes I still recommend you watch the video, but definitely pick it up from minute 53 when I start talking about the profiler. If you don’t mind the lack of climactic events and you have been following the stream sequentially then it’s not a bad one to have on your second monitor while drinking a beer.

Because of the peculiar nature of it, and the above note about the profiler, I felt I had to preface it with an intro video, but the intro video simply explains what you’ve read here. I’m embedding it for completeness but if you’re on this page and read it it will be unnecessary.

Enjoy,

Season 01 – Episode 16 – Maya Attributes Primer, FKoverIK set up

Attributes Primer, FKoverIK

We provide a quick primer on Maya attributes and how to form compound attributes, which will be very important for our guide clean up process, and then show how to do an FKoverIK set up which we’ll use to simplify the guide.

A very simple script is used during the stream. As usual it’s provided in this post, and I will eventually add it to the GitHub repository.

All new episode now free of low frequency hum in the audio!
Enjoy,

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from maya.api import OpenMaya as om2
sel = om2.MGlobal.getActiveSelectionList()
mob = sel.getDependNode(0)
 
fn_cAttr = om2.MFnCompoundAttribute()
fn_mAttr = om2.MFnMessageAttribute()
 
c_attr = fn_cAttr.create("toSwap", "toSwap")
fn_cAttr.array = True
 
m_attr1 = fn_mAttr.create("originalConnection", "originalConnection")
m_attr2 = fn_mAttr.create("guidedConnection", "guidedConnection")
 
fn_cAttr.addChild(m_attr1)
fn_cAttr.addChild(m_attr2)
 
fn_dep = om2.MFnDependencyNode(mob)
fn_dep.addAttribute(c_attr)