So this is annoying. You are trying to paint weights in Maya using Post Normalization and a bunch of your vertices are collapsing to the origin! What’s going on!?

Don’t fret. There is a simple explanation and an easy fix for this. But first, let’s look at what Post skinning is doing:

“What is this Post Normalization skinning all about?”

When using Post Normalization skinning for the first time, it can be a bit tricky to figure out how things are working.

Basically Maya is taking the total of all the weights and then normalizing it to 1.0. With classic interactive skinning this is done while you paint, which means if you paint on Influence A, Maya automatically steals weights away from Influence B and Influence C. If you are subtracting weights, it automatically tries to add weights to other joints. This can be very buggy and throw weights unpredictably.

With Post Normalization, Maya is keeping all the weights you’ve painted and doing this calculation on the fly. It stores the values of your weights without changing any of the others. You can paint all the way up to 1.0 on Influence A, Influence B and Influence C. Maya averages it out and the final effect is 0.333 on all 3 influences, but the weights are still painted to 1.0.

This can be a great way to think of your weights as separate layers. It’s like a bunch of overlapping venn diagrams.

“So what is happening in that ugly image?”

What you are seeing is essentially a divide-by-zero error.

When you first encounter these collapsing vertices, you might think it is a bug and dismiss Post Normalization as garbage or confusing. But it has a simple explanation. Since Maya isn’t automatically changing any weights, if you can paint all the weights to 1, you can also paint them all to 0. Maya is trying to calculate the totals of the weights but when there are no weights to divvy up, it simply can’t make the calculation.

How To Fix It

Luckily there is an easy fix. What I do is create an extra joint called “base_influence” and place it anywhere in the middle of my character or at origin.

Next, flood the entire character geometry with 0.05 weight on “base_influence”. Now you can paint the rest of your joints freely, but this one will always hold a tiny little bit of weight to prevent collapsing.

Lastly, don’t forget to constrain this “base_influence” to your characters root joint or root controller so it follows when you move the character.

“Why use it if it is so confusing?”

It took me a while to get used to, but I use Post Normalization skinning all the time now. You get to think in layers. Smoothing and subtracting weights is bug-free. You just have to get used to the fact that if you are painting Influence A, you have to manually paint away any overlapping influence on Influence B, or you will never reach full influence.

Another Alternative

I haven’t had time to test this tool out yet. If you are interested in advanced skinning techniques and painting in layers, this sounds like a promising tool worth checking out: ngSkin Tools developed by Viktoras Makauskas.

It sounds like Viktoras is developing something which solves a lot of the common frustrations with a Maya skinning workflow. It also uses regular skinning nodes, so it can also be a solution to video game riggers if Post Normalization isn’t an option for your engine.

If you have any skinning tricks and techniques, please let me know in the comments or share your wisdom on Twitter with the #rigtip hashtag.

Here is a tutorial that will demonstrate how to use a Unit Vector to animate the pivot point of a cylinder so that the cylinder will roll on its bottom edge in any direction. I’m using this technique for the feet of my Mini Mammoth rig, but it could also be useful for robot feet, or adapted into different shapes for a variety of uses.

Here is a video of the foot rolling effect we are going to create:

Note: Be aware that my expression syntax may or may not play nicely with WordPress, depending on how you are viewing this post. I have included a Maya 2012 scene file at the bottom of this post so you can download it and follow along. The final expression is included as a text file.

Notes about this tutorial:

• I am using locators as vectors so we can see what is going on. Once we are done prototyping this as an expression we can transform it into node connections that work directly with the attribute data rather than a daisy-chain of connected locators. This tutorial will just show the expression so you can get the idea.
• The order of the lines in your expression matters. Specifically, the foot’s rotation attributes will have to be animated before the pivots are translated in the expression. Otherwise I’ve found that you will sometimes get strange results. If your animation seems to jump or skip, keep this in mind.
• For simplicity, the way I build this ignores rotation in Y. Instead when I go to integrate this into a real rig, I’ll group this entire foot roll rig underneath a parent node and use that to rotate in Y in global space.
• The next step you could take would be to project the vector onto a curve using a closestPoint constraint. Shape the curve to match your character’s foot, and now you can have a foot roll in any shape you want!

So let’s get started

1. Create a cylinder with a radius of 5 and move it up so that it rests at the ground plane.
2. Create a joint at the bottom of the cylinder. Group the joint and call the group “foot_pivot”. The group will be controlled by the expression. Skin the cylinder to the joint.
3. Create a “foot_roll” controller. This can be a locator or a curve icon or whatever. This is the controller that will rotate the foot.

4. Create two locators. Name the first one “vector1″ and the second one “normalized_vector1″.

5. Select the “foot_pivot” group. Go into Edit -> Channel Control and in the Nonkeyable Hidden column make the following visible and keyable:
Rotate Pivot X
Rotate Pivot Y
Rotate Pivot Z
Rotate Pivot Translate X
Rotate Pivot Translate Y
Rotate Pivot Translate Z

6. The first step is to turn the rotation of the “foot_roll” control into XZ translation which we will feed into the pivot point of “foot_pivot”.

vector1.translateX = -foot_pivot.rotateZ;
vector1.translateZ = foot_pivot.rotateX;
// (note the negative value. This may change for you depending on your controllers orientation.)


When you rotate the “foot_roll” now “vector1″ will travel along the ground plane pointing in the direction of the rotation. But the distance from the foot is wrong and it is not in a circular shape. So…

7. We arrive at the meat of this entire tutorial. To get a useful pivot we need to create a Unit Vector or a normalized vector which will always have the same length of 1 no matter which direction it is pointing. If you aren’t familiar with vectors, this would be the same as having a 1-bone IK chain. As you move the effector around, the chain points in the correct direction, but stays the same length. However, if you aren’t familiar with vectors, I highly suggest learning about them. They will open up a new world of ideas for you as a rigger or TD. http://www.rtrowbridge.com/blog/2012/03/442/

We’ll use the built-in unit() vector function in the Expression Editor. Later if you want to rebuild it with nodes, you can get the same functionality with the vectorProduct node and turning “Normalize output” to ON.


vector $norm = unit(<<vector1.translateX,vector1.translateY,vector1.translateZ>>);


8. Now we have a vector, so let’s drive the “normalized_vector” locator so we can see what it is doing. (We don’t need to use the Y-component.)

normalized_vector1.translateX = $norm.x
normalized_vector1.translateZ = $norm.z


9. Ok, but now the problem is that our foot radius is 5 units and the Unit Vector is only 1 unit long. So let’s create a variable to multiply the unit vector which will be easy to edit if we need to use it on different sized cylinders. We add the following to the expression:

float $radius = 5.0;

normalized_vector1.translateX = $norm.x * $radius;
normalized_vector1.translateZ = $norm.z * $radius;


Now the “normalized_vector1″ should be travelling in a circle around our foot as we rotate “foot_roll”.

10. Now this normalized vector is just for visualization or debugging purposes. Let’s connect that straight into the rotatePivotX and rotatePivotZ attributes of the “foot_pivot”. (the group that parents the foot joint.)

foot_pivot.rotatePivotX = $norm.x * $radius;
foot_pivot.rotatePivotZ = $norm.z * $radius;


11. And finally, rotate the “foot_pivot”. (Note that this will go at the top of the expression. Putting it at the bottom caused erratic behaviour for me.)

foot_pivot.rotateX = foot_roll.rotateX;
foot_pivot.rotateY = 0;
foot_pivot.rotateZ = foot_roll.rotateZ;


Bring it all together and this is our final expression:


// Rotate the pivot_rotator to match the controller
foot_pivot.rotateX = foot_roll.rotateX;
foot_pivot.rotateY = 0;
foot_pivot.rotateZ = foot_roll.rotateZ;
float $radius = 5.0;
// Turn the controller rotation into XZ translation
vector1.translateX = -foot_pivot.rotateZ;
vector1.translateZ = foot_pivot.rotateX;
// Normalize the vector
vector $norm = unit(<<vector1.translateX,vector1.translateY,vector1.translateZ>>);
// Use the normalized coordinates to set the position of norm_vector
normalized_vector1.translateX = $norm.x * $radius;
normalized_vector1.translateZ = $norm.z * $radius;
// Animate the pivot_rotator pivot point to match the normalized vector
foot_pivot.rotatePivotX = $norm.x * $radius;
foot_pivot.rotatePivotZ = $norm.z * $radius;


10. (This step is optional or could be done differently.) Another thing I like to do is connect the “foot_roll” translation to the “foot_pivot.rotatePivotTranslate”. Then you can translate the “foot_roll” to create sliding effects in parent space. So even though the foot roll will be rotated, moving forward in Z will slide the foot along the ground all with one control object.

Here is a scene file you can download (Maya 2012) if you’d like to see the finished expression in action. The expression is included as a text file.

Download the finished, animated scene.

Let me know in the comments if you found this helpful or if I can explain anything more clearly. Thanks for reading.

Here is Part 3 of rigging Mini Mammoth. I’ve now got a finished model. This turned into a huge step, because I was learning a ton about modelling and topology in 3D-Coat, which turned into a 2-week long adventure of tutorials and manuals. I made a lot of mistakes as well which I’ll talk a little bit about. All in the spirit of learning!

This is the last post before I get into the actual character rigging.

First, I decided that I liked how the prototype model looked, so instead of starting from scratch, I began editing it. I started by carving out a mouth cavity and lowering the eyes.

The funny thing about this entire process was that after I finished tediously making a change, I found a feature in 3D-Coat that makes it fast and easy!

For example, to change the eye, I filled in the eye sockets, transformed the eye geometry down, and then using the Sphere tool, gouged a new hole for the eye sockets.. After that, I learned that you can create a low-resolution cache, make changes and then propagate those changes back to the high-resolution voxels. This lets you make big changes to the structure of your model without destroying the finer details. (Otherwise, if you just move things around, you’ll tend to get a mushy mess.) I could have done this and used the move tool to lower the eyes very quickly.

In fact, using the low-proxy cache is a good workflow for modelling non-linearly, because even after you have details, you can change proportions and posing. I’ve started doing this now, and it has loosened me up a lot. It is also far faster to edit, because it is lower resolution.

Another example, after I took all these screenshots with different angles, I found out that you can save camera angles. That would have been better for the comparison shots in the topology stages below. It would also be good for making animated gifs of time-lapse progress.

Next, I made a few changes to the nose and ears to make the edges look a bit more hard and defined. I also removed the tail and the eyebrows. (I’ll add those separately later.)

Mesh Retopology

I decided to call it done and moved on to the Retopo tool for creating my polygon topology. This was an exciting stage, because I wasn’t aware until a few months ago that tools like these existed. Modelling used to be a relatively tedious process, and now it feels very artistic in comparison. (I would also like to try ZBrush someday.)

The concept here is that you have your voxel model underneath, and you are adding polygons on top to the surface. So you can use the auto-tools or just draw polygons manually.

I did a few experiments and followed a couple of tutorials, but I was new to this. The best part about this tool is that it is iterative. You create a few “suggestion strokes” and then run the tool and see what you get as a result. If it is very messy, you just delete the polygons and run it again. (Or keep the polygons and stitch them together from various layers.)

Different patterns of suggestion strokes results in different mesh topology. Orange lines are closed loops, and green lines are directional indicators. The dark area indicates where you want more density. Eventually, I rested on the 3rd iteration below:

Now at first glance that might look pretty clean, but there are several 5-sided polys, triangles and a whole bunch of spiral edge-rings. The legs were especially problematic. So with the results as a starting point, there is some clean-up to do.

This is the stage where I wasted the most time!

At this point I wasn’t sure how many polys to use. In hindsight it turns out I was using too many, because it is very easy to sub-divide later. It made editing more cumbersome. I was sliding edges around one-by-one, deleting and merging polys and then hitting “Relax” to smooth out the results. When you hit “Relax”, sometimes things you don’t want to move will shift around and warp. So slowly, my edge-rings around the legs were drifting and getting crooked.

After a long tedious session of these types of edits (which by the way were a JOY compared to the old way I used to model years ago.) I found two powerful features that I had missed:

1. The “Brush” tool. How did I miss this!? It is brilliant. Using the brush tool, you can slide regions of vertices around. The beauty of it is that it stays adhered to the voxel surface below, so you can really get loose and messy. Hold down shift (as with most tools in 3D-Coat) and you can relax and smooth the vertices, again while sticking to the surface. This solved my drifting problem with the Relax tool and made the whole process 40X easier! (give or take a few X’s.)

2. You can delete polygons and use the Strokes tool manually. I thought the Strokes tool was only part of the Auto-Retopo tools. With that in mind, I deleted and rebuilt the eye region, to get a better round edge-loop structure on the face.

So yadda yadda yadda… I kept doing these edits, especially around the mouth and legs and now I have a finished body model with 6892 faces. There is still a weird portion on the inside of the leg where the polys are running a bit diagonally and might cause artifacting, but I am going to test in Maya before I bother spending too much time to fix it. We might never see it. All in all, I’m happy with everything I learned and I know I could model more characters even faster.

The Result:

Next Step: Export to Maya for Rigging

With a nice clean mesh, I think it will be possible to create some great squash-and-stretch cartoony effects. I’ll save the UV unwrapping for later. (This is another easy tool in 3D-Coat.) The next step is to begin doing some rig tests and prototyping. There is a chance I’ll have to make some changes.
- Will the geometry deform properly? (quick skinning tests)
- Should the trunk have been modelled straight? (I might still have to fix this.)
- Prototype a cylindrical auto foot-roll, which can roll in any direction.
- Model small details like tongue, tail, teeth and eyebrows. (and possibly some tufts of fur and other details.)
- Create some nicer, asymmetrical tusks.

Here is a simple skinning trick I like to use, which comes in handy for a lot of different rigging situations.

In the images below, I was rigging a wolf’s tongue with spline IK that needed to be very flexible. (If you count, you’ll notice that there are 12 controllers. 4 main controllers and 8 extra offset controllers to bend and twist the tongue into a variety of shapes.) The skinning was proving to be tedious, because the geometry kept collapsing and self-colliding. So here is what I did:

The Scenario: You have some tongue geometry (or other semi-flat geometry) which needs to be very flexible but the rig has a lot of bones and painting accurate weights is tedious and error-prone!

Look at that unsightly and embarrassing interpenetration!

Solution: Use a poly plane or other simplified geometry as a proxy. Fit it inside the geometry, and skin that instead. When you are done painting, use Copy Skin Weights to copy the weights from the proxy geometry to the full geometry.

The settings I use for Copy Skin Weights are:
Surface Association: Closest point on surface
Influence Association 1: Closest Joint
Influence Association 2: Closest Bone
Influence Association 3: Name (This 3rd entry is usually optional and makes no difference. When copying from the same geometry, like a body to a body, use “One to One” instead.)
Normalize: Not checked

Using a proxy object to skin the 3D geometry

The final result is fast and flexible

This makes it very easy for both sides of the tongue to have the same weighting, without tedious painting, which means it will twist and bend a lot further without self-colliding. When your geometry has a lot of folds and wrinkles it is also a lot easier to get your brush along the flat, uniform geometry of a plane. This technique also works in any 3D package which supports copying weights from one object to another. In XSI you can do the exact same thing using GATOR.

I have also used this technique to copy weights from a stretched sphere to weight complex hair geometry. You could also use it to copy weights from low-res geometry to high-res geometry. You will likely have to do a bit of cleaning up afterwards, but it could be a good way to get 90% of your weight painting done very quickly.

When you are done, you can simply delete the geometry, or tuck it away in a hidden group for later editing.

My next goal with this is to figure out a way to copy weights locally on complex geometry. For example, if the tongue is attached to the body, how would you grab just the tongue weights?

So now we are on to part 2 of the Making Of Mini Mammoth where I am documenting the entire process of designing a cartoony character rig. In this step, I am doing a bunch of sketching from photo references and sculpting a quick prototype 3D model to get even more ideas. We’re almost ready to start the actual modelling, but first…

Sketching Solves Problems

Design-based drawing is ultimately about solving problems, so quality isn’t at all important compared to just looking and observing the world.

Design sketches for Mini Mammoth

Even when I am coding Python tools, I often find it very helpful to draw out my ideas first. I constantly keep a notebook full of notes and doodles beside me.

At this point, I’m just trying to get lots of ideas for shapes, style and proportions. This is one of the most fun steps because anything goes. I even spent some time drawing bears.

Some more design sketches for Mini Mammoth

Design Considerations So Far:

• The mammoth’s trunk is mostly drawn in an interesting S shape, but I want it to be completely flexible and stretchy, including doing a water-passing-through-a-hose effect. So ultimately, I’ll likely model it in a straight line. When making a rig, it is usually easier to bend straight geometry than it is to straighten bent geometry. This is true when modelling any body part that will need to bend a lot, like a trunk, tongue or tail.
• In some of the drawings I noticed that the tusks will overlap with the mouth, and it will be an important part of how the mouth looks. The trunk and tusks will essentially be the upper lips.
• I’ve learned that there are a wide variety of mammoth and elephant ears. I’ll need to decide how floppy and how big they will be.
• The long tusks of a mammoth make a really beautiful curve. This will be an important part to get right.
• I am imagining giving him a thick coat of fur. How will I do it? There a few ways I could do it. Geometry, Maya hair, separate pieces of geometry? A lot to think about.
• Did you know that elephants have a 3rd eyelid membrane that slides sideways as they blink?

Building a Prototype Model in 3D-Coat

My original sketch wasn’t very detailed, and I wasn’t sure if the shapes I was drawing were even possible in 3D! So I started to model a prototype in 3D-Coat.

A digital sculpt in 3D-Coat

I really like how it turned out! At this point, I am just playing with shapes in 3D. This is not a final model. A lot of details like the ears will still change a lot so I am not too worried about following the design so far. Its just a 3D doodle.

Digital voxel sculpting in 3D-Coat is a lot of fun! You are very free to push and pull your model and experiment. It feels as loose as drawing, the tools are very intuitive. You can even build an armature (The ‘Curves’ tool) or drop shapes in (The ‘Primitives’ tool) using spheres, squares and cylinders to build up a model very quickly.

Building an armature in 3D-Coat

Immediately, I began to see some interesting patterns emerge:

• The legs are almost perfect cylinders. I like this a lot. They will bend and stretch, but their default shape will be very simple.
• The trunk makes some really cool undulating waves all the way up to the top of the head.
• The eyebrows need more design work so they don’t look like Groucho Marx. (Though that could be fun too!) Right now he looks angry in a lot of the drawings, but he’ll have a wider range of expressions when I design the facial rigging.
• I like how the foundation of Mini Mammoth is a simple egg shape. But I also started getting some interesting square shapes in the hindquarters. I will hint at real anatomy in the pelvis.

The Lessons

#1. Always use references.

I started out drawing a lot of sketches from my imagination, but the ones I sketched while looking at references of other animals were the ones that solved the most problems and made the design more clear in my mind. As I said earlier; drawing for design is a problem-solving process. At this point, it is not about creating art. The more I drew from references, the more I realized things that I would have to think about during the modelling and rigging stages.

#2. Don’t Limit Your Inspiration

I was looking at one of my drawings and it reminded me of a bear walking. So I studied a few pictures of bears. A bear has a big, lumbering walk with shorter legs than an elephant (just like Mini Mammoth.) So when I go to create a walk cycle, I’ll be largely inspired by bears. Mini Mammoth might look very small but he is going to walk with a big, heavy, camera-shaking gait!

Coming Up Next: I’ll finalize the design, make a couple of polished drawings, and then go back to 3D-Coat to start the actual modelling. After that, I’ll go through the auto re-topology of the model (an amazing feature of 3D-Coat which generates the polygon edge-loops) and create the texture UV’s for preparing the model to export into Maya.

Until then!

Hi everyone. This is the first post in a series where I take this simple doodle of a cartoon mammoth:

…and turn him into a fully animated, super-flexible cartoony character rig in Maya!

I’ll be documenting the entire process from design and modelling to the creation of the entire rig. It won’t be a step-by-step tutorial, but it will show my entire thought process as I rig, mistakes and all. It might get messy, but I know I’ll learn a lot and hopefully you will too.

This isn’t the full “design”. That will come a bit later. Right now it is just a quick 3-inch doodle that I sketched while at work. I am choosing this funny little character for a few reasons, because it will be especially challenging in a few ways:

The Challenge

1. The challenge of small cartoony rigs is that there is lots of overlapping influence between the different body parts. Take a look at this image.

For example, the cavity of the mouth and the shape of the lips is going to overlap all the way down to his knees. So when he opens his mouth his legs are going to move! His head is so big in relation to his body that he is basically a walking face. When rigging a normal-sized human or creature, all the body parts are distinct and separate and it is easier to paint the influence. So I am going to have to very carefully consider how I do everything from the facial rig to the way the limbs bend the body.

2. I am going to design him so that he has a lot of exaggerated squash and stretch. His trunk will stretch, bulge and grab on to things. How will such a short little trunk grab things? We will see!

3. It will just be a lot of fun figuring out how to make this guy move in an appealing and believable way!

The End Result?

The end result will be an animated short, featuring “Mini Mammoth”. I am not sure yet if I am going to texture and render it, but we will see! Stay tuned!