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

Advertisements

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.

dragonRender

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

Rigging for Education: Jaguar

I spent a bit of this Summer creating some rigs for Cogswell for use of their animation classes. The first one I worked on is this Jaguar, which was a good oppurtunity to try some approaches I recently came across. For the hind legs, I used a ikSpringSolver, similar to Morgan Loomis’ setup. For the spine I added an extra layer of control that allows the animator to fine tune each section to work along with the spline IK controls.

curlproxy

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 = ''
    CREATION_PARAM_JSON_ATTRNAME = 'creationParams'
    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)
            else:
                if mainControl:
                    self.parent = mainControl

        self.verifyParams()
        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')
        self.mainColorAttr.showInChannelBox(True)

        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)
        self.updateSelectionSets()

        self.layer.addMembers(self._rigControls.values())

        self.containedNodes.append(self.transform)
        self.containedNodes.extend(self._rigControls.values())
        self.container.addNode(self.containedNodes)
        self.containerPublish(self.container)

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

    @property
    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

Driven

I first came to Cogswell Polytechnical Institute as a substitute teacher for their advanced rigging class. I really enjoyed it from the start and it didn’t take long before I was introduced to their animation students’ project film, Driven. I was hired on as a freelance to develop the pipeline for facial rigging. Despite being a student project, Driven was an exciting opportunity as I haven’t done many production facial rigs up to this point and I was eager to try some techniques I studied in the latest edition of Stop Staring. More info, plus the full movie after the jump Continue reading

Mothhead

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()
    else:
        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!