But for the inky trees

Left: my first attempt at inks, 2014 Right: my most recent attempt at inks, 2016
Left: my first attempt at inks, 2014.  Right: 2016 (ref. by Scott McDaniel)

I always loved to draw. During a recent trip to my childhood home, my mother unearthed a collection of my earliest works, the central themes revolving around dinosaurs riding helicopters and insanely impractical Goldberg-esque devices, the main purpose of which, according to my cryptic captions, seemed to be processing cranberries.

While I loved to draw, I was never particularly good at it, mainly due to a crippling and persistent fear of failure. While a common theme in many of my short-lived endeavors, it was most apparent in drawing. Through the media I devoured over my formative years (the intricately detailed brutality of MacFarlane, the doe-eyed caricatures of Kricfalusi, the expansive worlds of Hergé, and the pure unmatched genius of Watterson), I was simultaneously inspired and disheartened. The chasm was great, and well-intentioned sketchbooks remained untouched. I pored over my library of Ed Emberley (whose delightful how-to drawing books for children used basic geometry to construct complex objects step-by-step), looking for the secret. I quickly mastered the three-triangle, two circle fox; the massive pirate ship on the last page, somehow made of all the same constituent parts, confounded me.

I found little solace in Emberley’s cheerful reassurance:

If you found some of the things in this book difficult to draw, that is because some of the things in this book are difficult to draw!

Paper and pencil fell by the wayside as I gravitated towards computers in the late 90s. Later, when my college degree required a fairly significant fine arts component, I (short-sightedly) managed to slide through the painting and figure drawing classes with minimal experimentation or risk. I didn’t need this; I was going to be learning Maya, dammit.

I didn’t revisit analog media until I arrived at DreamWorks Animation. Artistic development there was taken very seriously, and the studio provided a wide selection of classes, such as figure drawing or sculpture, that could be taken during lunchtime or at the end of the day. These classes were available to everyone, so even an engineer like myself could attend. For some reason I was surprised to see the storyboard and concept artists present each week. Why? They were already amazing, why would they bother with…

Oh.

This revelation continued to become clearer as time passed. I got to know some of the artists personally, and I began to notice the small Moleskines they always carried and doodled in. I noticed the many, many sketches they tossed aside. They practiced. Constantly. One artist in my department, upon hearing I didn’t draw that evening, said in a dose of his curt, Parisian honesty, “Don’t be so lazy.”

Somehow the very logical (and obvious) solution of discipline, persistence, and embracing failure managed to escape me.

After this revelation, the context surrounding the work of the masters became apparent, and the chasm began to shrink. Now, when I looked at original panels in the Cartoon Art Museum, I noticed the Wite-Out touchups and X-Actoed fixes not visible in flawless final prints. I came across the published sketchbooks of Chris Ware (author of the masterpiece Jimmy Corrigan, The Smartest Kid on Earth), which contained hundreds of his sketches made in the ten years prior to the book’s publication in 2000. In the sketchbooks, themes and characters in Corrigan iterated and developed over the course of a decade. Notes interspersed throughout the crowded pages read “Awful!”, “You’re forcing ideas!!” and “Why is it so hard to get started?”

The work that inspired me didn’t just spontaneously burst into perfect, fully-formed existence. It came into being over time, the margins filled with discarded thumbnail sketches, edits, and self-doubt. Ideas were shelved, reassessed, and trashed. Concepts failed, but their creators persisted. And this is what I neglected to see when I stared hopelessly at the final product.

Ink is unforgiving, and the past two years have left many pages packed full of failure in their wake. It’s easy to get stuck on some particularly difficult anatomical structure or perspective that just doesn’t look correct. But as I have to be reminded time and time again, the important thing is that the sketchbooks are finally getting used. Every once in a while something emerges that I am proud of. And it’s always worthwhile to take a step back and see the forest.

 

If you are looking for some inspiration, these are some of the artists I looked to during my time at DreamWorks.

Pickled Points in Python

A wonderful feature of the Python language is its built-in method of serialization and de-serialization, called pickling. Pickles can be used to easily store (dump) data as efficient byte streams for storage, transfer, and retrieval. This is a great way to save state or pass complex objects around.

Many types of things can be pickled right out of the box; unfortunately, this powerful feature runs into issues when working with the OpenMaya API. Since these classes are wrapped by SWIG, you will get an error when trying to pickle one of these objects:

my_point = om.MPoint(1.0, 2.0, 3.0)  
pickle.dumps(my_point)
# Error: can't pickle SwigPyObject objects

A solution that I particularly like is to define a __reduce__ function, which allows you to tell Python how to serialize the object. Subclass the object in Maya you want to pickle, and in __reduce__, return a tuple of the class and the attributes you would give to the constructor to create the OpenMaya object.  So, in the case of MPoint:

class PickledPoint(om.MPoint):
    def __reduce__(self):
        return(self.__class__, (self.x, self.y, self.z, 
          self.w))

Now, create a point using your subclass and pickle away!

my_point = PickledPoint(1.0, 2.0, 3.0)     
unpickled_point = pickle.loads(pickle.dumps(my_point))
my_point == unpickled_point
# Result: True #

Neat!

You can extend this solution for working with function sets (like meshes and NURBS) in OpenMaya. In addition to adding the __reduce__ function in your subclass, define __init__ to take the name of the object in the scene you are pickling. In the constructor, you can use the name to retrieve the DAG MObject, which is passed along to the parent class:

class PickledMesh(om.MFnMesh):
    def __init__(self, name):
        selection_list = om.MSelectionList()
        shape = selection_list.add(name)
        dag_path = om.MDagPath()
        selection_list.getDagPath(0, dag_path)
        dag_node = dag_path.node()

        super(PickledMesh, self).__init__(dag_node)

    def __reduce__(self):
        return(self.__class__, (self.name(),))

Now, create your MObject with your new subclass, and…

my_mesh = PickledMesh('pSphereShape1')
my_mesh.numVertices()
# Result: 382 # 

pickled_mesh = pickle.loads(pickle.dumps(my_mesh))
pickled_mesh.numVertices()
# Result: 382 #

…voilà!

And the end credits roll…

goodbye
Crew photo by Carlos Puertolas, 2015

Last Friday, the skeleton crew at Pacific Data Images turned off the lights for the last time, finally arriving at the end of the long, protracted closure of DreamWorks Animation’s Northern California studio. Jeffrey Katzenberg solemnly announced the closure to stunned silence in January, and as production subsequently ramped down, the following months were akin to seeing a loved one slowly fade; each week the cafeteria was a little quieter, a little emptier.

My stint as an employee was relatively short, but I had already felt at home there; PDI was a close family of insanely talented artists and technologists, some who had been there since the beginning, prior to the acquisition by DreamWorks fifteen years ago.  Carl, Richard, and Glenn, armed with a DEC PDP containing little more than 128 kilobytes of memory and a C compiler in the early 80s, transformed the small production house into a mainstay in the field of computer graphics. While the studio was primarily involved in feature animation, it is not widely known that the studio contributed to television and live action film over the course of its history, from Michael Jackson’s iconic Black or White music video to The Simpsons to Minority Report.  Upon entering the industry after school, I have met someone at every single gig who was somehow associated with the Redwood City shop. After the announcement of the closure, our feeds began to fill with pictures sent by PDI alums now in Emeryville, the Presidio, Vancouver, flashing gear emblazoned with the familiar golden figure, film camera hoisted high.

It was a moving reminder, not only of how small, but of how close this industry truly is.

My first day
My first day at Pacific Data Images

One quickly realized how special this place was upon arrival; a first-day Polaroid joined those of the other employees on a wall near the cafeteria. There it was, with other first-day pictures of men and women whose names I recognized from textbooks and papers, who made the animated films I grew up watching.  Even more poignant was watching these pictures slowly disappear from the wall, one by one.

You saw its importance in the moving epitaphs written by coworkers and the press, and when past employees returned from far and wide for one last crew photo.  As yet another historic institution closed its doors (an event that is all too familiar to anyone who has spent any significant amount of time in animation or visual effects), everyone mourned together.

I owe a great deal to this studio. Godspeed, everybody.  It was an honor and a privilege. Thank you for letting me be a part of it.

gvim makes you strong

After moving to an all-Linux workplace, I quickly learned to love the gvim text editor for its extensibility and ubiquity.  These are some of the tweaks I’ve found most useful.

This one is easy, but using bang to call shell commands is a nice time saver so you don’t have to switch windows:

:!ls .

You can use the % operator to refer to the currently open file:

:!ls -l %

If it is a long command string that you use frequently, you define functions in vimscript within ~/.vim/plugin:

fu! Cmd()
    let file = expand('%')
    execute '!ls -l '.file
endfu

fu! CmdWithArgs(arg1, arg2)
    echo a:arg1.' '.a:arg2
endfu

command Cmd call Cmd()
command -nargs=* CmdWithArgs call CmdWithArgs(<f-args>)

You can then call these functions via:

:Cmd
:CmdWithArgs one two

I use this all the time for commits, pushes, and pulls in git.  This is also handy when using <cfile>, which grabs the path currently under the cursor and can be used to quickly view images or other formats using command line tools.  For text files, this functionality is available out of the box; typing gf (goto file) with the cursor over a filepath will open the file in the same window, and <ctrl>-w gf will open it in a tab (gt to toggle between them).

You can inline python in vimscript:

python << EOF

import sys

EOF

You can also move a visual block of text (defined with <ctrl>-v) from one file to another:

:w>> path | '[,']d

I’m bad about keeping code to 80 characters a line, so this suggestion for some subtle highlighting in ~/.vimrc for when I run over is a nice reminder:

highlight OverLength ctermbg=#1F0A0A ctermfg=white guibg=#1F0A0A
match OverLength /\%79v.\+/

Other .vimrc additions that I always use are highlighting all search results:

set hlsearch
hi Search guibg=LightGreen ctermbg=LightGreen

and changing statusbar colors based on normal or insert mode:

set laststatus=2
au InsertEnter * hi StatusLine ctermbg=LightRed guibg=LightRed
au InsertLeave * hi StatusLine ctermbg=Black guibg=Black

I really like Todd Werth’s ir_black color scheme with taglist (for providing a list of function definitions) and pyflakes (a useful passive syntax checker for python).

For further reading, check out Andrew Scala’s Five Minute Vimscript or Steve Losh’s comprehensive Learn Vimscript the Hard Way.

Hello World

As I sit on the precipice of another shift in my career, I once again find myself taking inventory of what I have learned and where I want to go next.  While the latter is yet to be determined, the former is rich with knowledge gleaned from working side by side world-class engineers and artists.

With each successive gig, I find the collection of these lessons learned more and more unwieldy.  I am starting this blog to (finally) index and re-share the tidbits I have found particularly useful, since I find myself frequently searching for (and usually reinventing) solutions that have long been misplaced.  In addition, I have wanted to take a more serious ownership of my own work, and with this site I hope to do so: discussing influences, cataloging progress and failure, and presenting it in the hopes that it will inspire as I have been inspired.

So here it goes.  Hold on to your butts…