top of page
  • Writer's pictureJoe McDowall

Custom Character Rig Breakdown Part 1 - Introduction


Introduction

There was a time quite recently that I really didn't enjoy rigging. I would live with a simple but frustrating rig, or I would use Rigify but never feel I fully understood how to use it well. However, my perspective changed when I spent some time learning how to build custom rigs from scratch. This unlocked a new set of eyes that could appreciate the tools blender provides for rigging and how flexible a solution like Rigify is and how one might extend it.


So when I was thinking the other week of creating a new character I thought it might be a great opportunity to reinforce what I’ve learnt and create its rig from scratch. The character I had in mind had some unique properties that deviate from the usual human rigs that I thought some might find useful.


I would like to share some of the key learnings and challenges I encountered throughout this project, providing insight for those who may not have ventured into it yet and are curious about rigging. My aim is to offer you an overview of custom rigging and demonstrate how you can leverage these tools to address your own rigging challenges in the future.


The Goal

Before we look into the rig let's start by talking about the goal of the project. My 3D model is a stylized humanoid character based on some drawings I made for this website.






As I mentioned before, I created this model to have a character ready for a Unity game idea I plan to work on later.




The model, designed to be very cartoonish, intentionally lacks some anatomical details that a more realistic model would have, such as defined muscle groups. Additionally, I aimed to keep the eye and mouth details simple and create a rig reminiscent of those used in Aardman productions or movies like Coraline. Instead of sculpting eye sockets and a mouth, I wanted to attach them as physical pieces, similar to a potato head. This feature is not commonly found in a general rig, but I will discuss it further in the article.



The tools

In this first part of the series I would love to cover some of the basic components of Rigging. I think it might be a good idea to ensure that everyone has some understanding of the tools Blender provides for creating rigs as I make heavy reference of them later in the series. I will give a brief overview of each tool, but please note that these can be in-depth topics that will benefit from further research on your own. If you are already familiar with these tools feel free to skip this part, however it might be a nice refresher.


Bones

In the real world, bones provide the structure that allows fleshy creatures to move. Without them, we would be reduced to blobs of organs on the ground. The same concept applies to our digital puppets in Blender. We place bones inside our models, and with the help of software, we specify which parts of the models are influenced by the bones. This way, when we move a bone, the corresponding part of the model also moves. Bones that directly affect the polygons on our models are called Deformation Bones. It's important to note that not all bones have to deform the model. We can disable deformation for some bones and use them for other purposes, which will be explained in later sections. For now, remember that bones are like Lego blocks for rigging and are crucial for bringing our 3D characters to life.





Armature

In Blender, bones that are related to a single subject are part of an object called an Armature. This term is borrowed from clay modelling, where an armature refers to a structure, typically made of wire, that provides a foundation for the clay to take shape, similar to a skeleton. In Blender, we attach our models to armatures using the armature modifier. This guide does not provide detailed instructions on creating the initial armature, as its focus is on rigging aspects. However, there are excellent resources available if you need assistance with this, I will provide a few links at the end of the article.



Weight Painting

Okay so we know we can attach a model (or models) to our deformation bones through the armature modifier which allows us to move our model. But how does Blender know which part of the model should be affected by the movement of a particular bone? Enter weight painting.





Weight painting allows us to paint at a vertex level how much influence a bone has over our model. In weight painting mode we paint values from 0 to 1 on each vertex for every bone in our Armature. Blender offers some tools to apply these values to our mesh in weight painting mode.





My personal favourite is the Gradient tool which allows you to create a nice fade of weighting linearly or radially across the mesh.





This is especially powerful when combined with vertex/paint selection masks.


Vertex Groups

If we look at the Data tab of our mesh properties window there we can find a section called Vertex Groups.





Now depending on how you parented your mesh to your armature this list might be extensive or it might empty. As we weight paint parts of our mesh(s) to the bones in the armature you will begin to see vertex groups appear in this list with the same name as our bones. This is how Blender stores the data around what vertices are manipulated by each bone. If I took one of the vertex groups and deleted it, that bone would no longer influence our mesh at all.


  • Tip: When you parent your mesh to an armature Blender gives you a number of options con shortcut Ctrl+P. If you just select armature deform, you wont see any vertex groups appear. Selecting Automatic weights will instruct Blender to try to guess based on proximity what weights each bone should have over the mesh and you’ll see a vertex group generated for each bone. Be mindful of which option will be most useful to you, if you are attaching multiple meshes to your armature it may not need to have vertex groups for every bone.





Other Bone “types”

So far, we have only discussed Deformation Bones. However, in Blender, there is an option to disable the deformation feature by toggling off the "deform" option. These non-deform bones can be added to the armature to provide auxiliary features for our rig.


  • It's important to note that these bone "types" are completely fabricated and conceptual and may be called something else by different artists. While I initially used the same terminology as Rigify, I have also added a few different bone types that make sense to me. Therefore, feel free to interpret and name them in a way that helps your understanding, as there is no strict rule for naming these bone “types”.


Deformation Bones (DEF)

As mentioned before, these are the core bones that control the movement of the model. It is important to note that when exporting to a game engine like Unity, usually only these bones are required, and all other bones can be discarded. However, there may be a few exceptions to this depending on your specific needs in the game.


Control Bones (CON)

Control bones are non-deformation bones that serve as an interface for operating or controlling deformation bones. They act as an abstraction layer placed by the rigger over other bones, with the purpose of enhancing movement operations or simplifying the animation process.


For example, consider a control for curling the fingers. Typically, a finger consists of three bones, and manually rotating each bone to curl or straighten them every frame can be tedious. Moreover, except for the bone connecting the finger to the hand, the other bones in the finger should ideally only bend along a single axis. The ability to rotate each bone along different axes actually complicates and increases the likelihood of errors when manipulating these bones. A better approach is to introduce a single control that, when interacted with, causes all three bones to curl in the expected way along a single axis.

The ultimate goal here is to make the animator's life as easy as possible. By abstracting complex controls and presenting a simple interface, we can streamline the animation process.


Deformation Bones As Controls (DEFCON)

Sometimes it’s just more convenient to treat a deformation bone as a control rather than create a control to govern it if it’s simple enough. In these occasions I name it such as put it in both the Deform and Control bone groups.


Could also name these Lazy bones....


Position Bones (POS)

These bones do not have any inherent functionality themselves; they serve as reference points for other bones or objects to attach to. For instance, I created a position bone for eyewear, allowing my character's glasses to align with that bone and sit properly on the face. I also have a similar bone for headwear, such as hats. This feature is beneficial as it enables me to animate how a hat or glasses might move during motion and, in a game engine, use that bone to switch between different hats and glasses.


Pole Bones (PLE)

Pole bones are used with IK Rigs to provide the modifier some extra information it can use to calculate the rotation of joints.


Guide Bones (GDE)

Guide bones are primarily used to provide contextual information to the animator on how to operate the rig. In my rig, I use them to add extra information that helps inform the operator about the various eye options they can select.


Bone naming

I believe it is important to form a naming convention when creating bones in Blender. This helps instruct animators what each bone in the hierarchy is used for and reduces the risk of error or misuse in the rig. In fact Blender also expects conformity to one of its own naming conventions when you have symmetrical bones you want to keep aligned. Blender expects symmetrical bones to end in either L for left side and R for right side.


This is the convention I use which I borrow heavily from Rigify:


Asymmetrical bones: [BONE_TYPE]-[BONE_NAME]

Symmetrical bones: [BONE_TYPE]-[BONE_NAME]_[L/R]


For example here are a few common bones you can find in my rigs:


DEF-head

DEF-hand_L

CON-wrist-rotation-y_R

POS-eyewear


The intention of a good naming convention is to provide anyone using your rigged model with guidance and consistency so they can understand at a glance what each bone might do.




Bone constraints

Constraints apply restrictions on bones that allow us to control and restrict them in interesting ways. These are fundamental to rigging and allow us to design interactions.


We can place Limit Constraints on to a bone to control how far it can move, or rotate or be scaled. This can be useful in preventing a wrist from being able to bend in unnatural ways for example.





There are a lot of constraints to cover and this series won't go in to them all so I will leave it up to the reader to research what each of them do. The ones we will be making use of are the Copy and Limit Transforms, Armature and IK constraints. Let's elaborate on those further as they come up in the series.



Drivers

Drivers are my favourite things! They allow us to drive properties using expressions! In the series we will definitely be covering examples of drivers. They allow us to attach so many rich behaviours on to our rig that would be impossible otherwise.




Drivers can get access to properties of other objects as Input variables and make use of them in their expressions.


An expression is basically just a piece of code that executes and returns a value. Properties in Blender have different data types like Booleans, floats and integers. A driver attached to a property must return the same data type. We can add any valid code to our expression just so long as it returns that expected value type.


In using data from other objects in the rig we can make some really complex controls that will really help animators pose their characters quickly.


Custom Bone Shapes

Assign custom shapes to your bones is not only a great idea to visually make them distinct but it’s also a brilliant opportunity to use a consistent set of shapes that infer how the bone should be controlled. It is important that when you communicate an action through shapes that you keep it consistent so that anyone operating the rig isn’t suddenly surprised when two bones that look the same operate differently.


You can find the Custom Shape properties on the Bone Properties tab. Here you can select any object to become the custom shape. A good idea is to collect all shapes in a custom shapes collection, it could be something you import on future rigging projects. Here you can also manipulate the transform of the shape so that it aligns perfectly on you model.





Below are a few shapes I commonly use on the rig, some were made up, some were inspired by Rigify.


Shape Name: Twist

Purpose: Rotation Y Axis




Shape Name: Spool

Purpose: Rotation X / Z Axis





Shape Name: Move

Purpose: Translate X / Z Axis





Shape Name: Pull

Purpose: Many, but commonly used for finger curling





Bone Color

Another great feature for customising bones is the ability to choose colours. In the Bone properties tab under Viewport Display we can give our bones a colour set.


This can help bones stand out easier. You can also give different bones different colours if you wanted to help differentiate between them. In UI design it is best practice not to rely on colours to convey information however as for some people may not be able to distinguish by colour if they have certain visual disabilities. It is a good idea to use shape to convey intent when it comes to bones and use colour as supplementary language.


If you want to add your own colour sets you can add your own in Blender preferences:


Bone Collections

A Blender 4.0 feature that allows us to sort our bones into groups. This comes in handy for hiding and showing different types of bone.



You can have as many bone collections as you need. It replaces the old bone layer feature.


I tend to group my bones by type but you can do anything here. If you prefer grouping your bones by body part, you can! That would allow you to just isolate the bones in one area.


FK & IK

You may hear animators talk about FK and IK when referring to rigs. If you haven't heard of these terms let me explain with use of the arm.


With FK or Forward Kinematics we angle joints individually one by one from the root in order to position our model in the required pose. Think trying the orient an arm so that your character places their hand on a cup. Depending on the position of the overall body you might have to start by animating the shoulder, then the elbow and finally the wrist in order to position the hand in the right location. If you did it in the reverse order it would be very difficult to guess each part in turn.


With IK or Inverse Kinematics we don't really think about how the bones orient themselves to achieve the same pose. We position the final bone in the chain based on a target and the IK solver calculates all the joint angles required to make the pose if it can. This can result in a much quicker rig to animate at the cost of some control.


In this series we will look at adding both FK and IK controls on our rig and a mechanism to switch between them.





Rigging

A rig is an abstraction layer placed on top of an armature to simplify or enhance control over the armature. You could say that rigging is providing an animator with an interface in which they can operate a puppet. If you are familiar with programming then a lot of these concepts will feel familiar.

You might be wondering how do the concepts of abstraction and interfaces have anything to do with rigging and animation? Well consider the operation of a simple plane, if you had to run around the aircraft and manually operate all the physical mechanical flaps in order to turn and fly it you would quickly find yourself overwhelmed. Instead, Aeronautical Engineers provide controls in the cockpit that simplify operation of the vehicle. A control column is provided that allows for controlling the aircrafts pitch and yaw and a throttle that allows the pilot to adjust the thrust. The pilot doesn’t need to know about the inner workings of how these controls translate into motion they just need to understand how to operate the interface. In a similar fashion animators are mostly concerned with moving characters between poses and if we can provide them with a simple interface to do so then we have succeeded in our rigging goal.


Rigging Principles

In rigging my character I decided to set out some ground rules or tenants to follow by in hopes of ending up with a consistent, easy to use and extendable rig. As Barbossa said in Pirates of the Caribbean: "The code is more what you’d call ‘guidelines’ than actual rules".


KISS (Keep It Simple Stupid)

Following this principle our rig will allow us to do only what we need from it and no more. Rigs can become complicated very quickly and if we waste a lot of time building controls for things we don’t immediately see a need for then we can quickly find that our rig becomes difficult to operate.


Follow the naming convention

For our own benefit and those of the animators using our rigs its a good idea to stick to a naming convention so the purpose of a bone can be easily understood at a glance. See the earlier section on bone naming if you need help deciding on a convention.


Expose controls and abstract details

We should make use of Blender 4.0 bone collections and hide away from our users bones not directly required to operate our rig. This clears the screen of clutter and instead lets people focus on what they need to use and not distract them with unnecessary details.


Controls should be clear and consistent

Bone shapes should be used to communicate the purpose of a control and that shape should remain consistent across all other controls of a similar operation. If we construct a shape language in our controls then operators of our rig can quickly learn how to use them and transfer that knowledge to new controls as they find them.


Single Responsibility (where applicable)

Where possible I prefer applying a Single Responsibility principle to controls so they do one thing and that makes it easier for me to understand and operate them however it isn’t always practical to follow that rule religiously so I tend to follow it as a loose guideline.


Constrain Controls but not Deform Bones

Where possible we should leave deform bones as close to their default state as we can. This allows animators some degree of freedom if our controls don’t allow the exact behaviour they need in their animation. If the deform bones remain unrestricted they can enable them and tweak their transforms to override our control behaviour if necessary.


An example of this might be that we restrict rotations on fingers so they operate like a human hand does but actually an animator needs to break this rule to literally break the fingers in an accident. If we leave the underlying bones as pure as possible then the animator can tweak these bones without having to unravel our rig to do so.


If you know of any other best practices in rigging I would love to hear them!


Wrapping Up

In this part of the series we went over the basic components of building and organising rigs. In part 2 we will start to look at the rig and how some of the features were implemented. Starting with the face/head.


Resources

If you are interested in a more step by step guide on building up the whole armature there are excellent series on YouTube, here are a couple of good ones:


Dikko


Ryan King Art





12 views0 comments

Recent Posts

See All

Comments


bottom of page