Rigging for Education: Caroline and Henry

Caroline and Henry are now available for download at Cogswell’s website

After completing the Jaguar and Dragon, the rigging project continued to grow at Cogswell and has since been named Project Avatarah. I continued my work in developing more character rigs and after working on a couple of simpler bipeds that were styled more along the lines of popular characters such as Norman and Hogan, we went into designing the next set of bipeds with a higher-level design geared towards detailed acting and subtlety in motions. Caroline is the first rig we developed with this mindset and includes features such as bendy limbs, proportion adjusters, IKFK spine, breathing controls, and a toony facial rig capable of squash deformations.

Continue reading

Rigging Dojo Apprenticeship Experience

After being on the waiting list for a few months, I finally had a chance to experience the Rigging Dojo Apprenticeship last Fall.

With my background in the game industry, the mentor that I was matched up was Todd Widup, and simply put, he is awesome! All of our sessions were done over Skype and overall went very smooth. After brief introductions, we jumped right into it. Todd started by asked questions to get a feel on the topics that peaked my curiosity.

Continue reading

Rigging for Education: Dragon

If you like to check out the dragon rig, it’s now available on Cogswell’s website here.

This is continuation from the project I started on last summer with making rigs for the animation classes at Cogswell College.


After finishing up the Jaguar, I shifted my work onto the dragon named Cogswell (to loosely tie the character to the college’s mascot), which was modeled and textured by Robert Garcia. With the dragon’s design being pretty close to a quadruped I was able re-use most of the rig techniques from Toothy: IK/FK legs, FK tail, and a IK neck.

Things became more interesting when approaching the unique aspect of Cogswell: the wings.

Continue reading

Zombie Playground’s Character Pipeline: Designing a Modular Rig Solution

With a greater number of potential characters than Mothhead, our previous Unity project; I went into Zombie Playground’s pre-production with my mind already set on creating an automated rigging solution. I took some inspiration from a Modular Rigging course I followed on 3dBuzz and begun to break down my rigging process into object-oriented code in suite I named Automato.

class BaseSubstruct(object):
    Abstract class to derive new rig modules from
    NAME = 'abstractobject'
    NICE_NAME = ''
    DESCRIPTION = 'generic abstract description'
    MIN_JOINTS = 1  # number of joints needed to create substruct
    REQUIRES_SKELETON_CHAIN = True  # if true, subsruct requires a skeletal chain for creation

    def __init__(self, basename, joints, parent, mainControl):
        Builds rig in maya and creates an asset node to contain relevant nodes
        self.container = None
        self.layer = None
        self.containedNodes = list()
        self._rigControls = dict()
        self.lockAttrs = list()
        self.basename = basename  # unique name to identify nodes created by this substruct
        self.parent = parent  # parent to attach top-most rig node
        self.joints = joints  # base skeleton joints to attach
        self.mainControl = mainControl

        self.mainColorAttr = None

        if self.parent is None:
            self.parent = self.joints[0].firstParent2()
            if self.parent:
                self.parent = pm.PyNode(self.parent)
                if mainControl:
                    self.parent = mainControl

        self.container = pm.container(name='_'.join([Prefix.CONTAINER, basename, self.NAME]))

        ## Parameter dictionary for storing settings for assets
        ## Children classes can further expand this dictionary with parameters of their own
        self.paramDict = {'classname': self.NAME,
                          'basename': self.basename,
                          'joints': [str(i) for i in self.joints],
                          'parent': str(self.parent),
                          'mainControl': str(self.mainControl),
                          'container': str(self.container)}

        pm.addAttr(self.container, dataType='string', ln=self.CREATION_PARAM_JSON_ATTRNAME)
        pm.addAttr(self.container, at=int, ln='color', min=0, max=31, defaultValue=0, keyable=False, hidden=False)

        self.mainColorAttr = self.container.attr('color')

        if self.layer is None:
            self.layer = Layers.getLayer(Layers.ANIMATION_CONTROLS)

        self.transform = self.install()
        utils.lockAndHide(self.lockAttrs, True)
        connectControlColors(self.rigControls, self.mainColorAttr)



        pm.parent(self.transform, self.mainControl)

    def rigControls(self):
        return self._rigControls.values()

    def verifyParams(self):
        if self.REQUIRES_SKELETON_CHAIN and not checkJointsAreHierarchy(self.joints):
            raise SkeletonError('The specified joints must be from the same skeletal chain')

        if len(self.joints) < self.MIN_JOINTS:
            raise SkeletonError('Only works with {0} joints!!'.format(self.MIN_JOINTS))

    def install(self):
        Main juice function
        Basic rig framework is created
        Return the top-most group node for __init__ method to utilize
        raise NotImplementedError("Derive me please")

This is a small snippet of the base class I designed all the rig components (known as “Substructs” in my code) to derive from. The BaseSubstruct class contains a set of parameters stored as members that most, or all, of my rigging structures (leg, arm, etc.) share. Using a OOP approach to creating the rig makes for a very scaleable solution for our pipeline. As new creatures are designed and implemented; I can plan out the automation right away, simply making a new class with most of the ground work derived from the original base class. Continue reading


Mothhead – Behind The Scenes

Mothhead is an interactive art demo for Unity we did at Massive Black.  The characters are inspired from sculptures created by Pete König during his time at studio that I originally rigged as part of an art test. In the past during company downtime, we revisited Mothhead often to experiment with different directions to possibly take the IP; such as the renders seen in the Massive Black Vol 1 art book. Unity stood out as fresh opportunity; we had experience with it from previous projects with Emotiv and the editor is user-friendly enough for artists to prototype ideas.

Continue reading

A Look at the Beginnings of Zombie Playground’s Character Pipeline

Zombie Playground is an exciting project I’ve been working on in recent months. Even though this was the second project where we are using Unity3d (the first being Mothhead); this is a completely brand new IP for us, that isn’t tied down to maintaining legacy assets. As such, Zombie Playground offers us a lot of freedom in planning out an efficient pipeline so we can better concentrate on the vision of the game, and less on tedious tasks. I’m responsible for wrangling our said pipeline, documentation, character rigging, and developing tools to assist our small team. We’re still in the early stages of development, and there’s a lot of aspects of the project in WIP-phase, but I want to describe some tools I’ve developed for ZPG that have been coming along nicely.

Continue reading

Playblast completeFilename flag in 2012…

I’ve been working on updating our animation library tool at work for use in Maya 2012 and noticed an issue with properly generating thumbnails. After scouring the internet for awhile, I found out I wasn’t the only one experiencing an issue with the playblast command. When using the completeFilename flag (to save an image without zero-padding), the image won’t save, and Maya raises no warnings or errors about it.
Fortunately, I came across a post from Nathan Horne, showing how to generate thumbnails using the Maya API commands. I added some additional checks to the original snippet:

def writeThumbnailFromView(filename, compression, modelPanel=None):
    #Import api modules
    import maya.OpenMaya as api
    import maya.OpenMayaUI as apiUI

    #Grab the last active 3d viewport
    view = None
    if modelPanel is None:
        view = apiUI.M3dView.active3dView()
        view = apiUI.M3dView()
        apiUI.M3dView.getM3dViewFromModelEditor(modelPanel, view)

    #read the color buffer from the view, and save the MImage to disk
    image = api.MImage()
    view.readColorBuffer(image, True)
    image.writeToFile(filename, compression)

So far it seems more efficient for my needs than the playblast command, as my tool is now able to avoid capturing the wrong viewport, and I can control the image without messing with render settings.

Time Lapse – Bat Skinning

[vimeo 34571923 w=640&h=385]

Skinning pass, at mega-speed, made to a bat rig.

I worked on this guy about 2 years ago. Originally planned to use this footage as a skinning tutorial but i never got off the ground fully. With all this footage I decided to try speeding the entire process and see how interesting it looks.

Modeled by Shon Mitchell.

For more information about the rig, and to see it in action, check my previous post!

Kinect Disneyland Adventures

Kinect Disneyland Adventures came out in November 2011. We brought on a freelance Character TD to help share the load and I was responsible for his work as well as my own rigs All the characters were implemented using Character Studio to client’s specification.

James Bond 007: Blood Stone

James Bond Blood Stone 007 came out in November 2010. The project was mostly animated in MotionBuilder but Maya was used to build the character skeletons and setup secondary movement for clothing. I helped setup various NPCs and enemy characters for this project.