Kickstand x Kidrobot x Kozik

Kickstand got to collaborate with Kidrobot on a new short film featuring Frank Kozik’s foul mouthed and eternally grumpy Labbit.  More of these to come…

Posted in Featured Content | Leave a comment

In the works: SteamPipe

We’ve been busy working on a new standalone web-based asset manager called SteamPipe.  The system, focused on animation and visual effects pipelines, aims to be simple, yet powerful and flexible.  From our extensive pipeline experience, we set out to make a general tool which we hope will soon become a standard in the CG industry.

SteamPipe Screenshot

SteamPipe Screenshot

Features:

Flexibility and Customization:

We know everyone works in different ways, so SteamPipe lets the end user customize everything.  Being built on dynamic languages like Python and javascript, the end user gains limitless freedom to display assets in different ways, extend from 3rd party libraries, and define how you want the asset manager to work.

Simplicity:

We want our users to be able to jump into SteamPipe and immediately understand the basics.  Many studios rely on freelancers who are hired for short period and need to begin work as soon as they arrive.  The studio’s pipeline needs to be simple to use, otherwise too much time is invested teaching the pipeline.  We used Web 2.0 type interfaces to create an advanced modern user interface which would be familiar to users of sites such as Google, Facebook, etc.

Search:

It’s common to reuse assets, but unfortunately, it’s also common to lose them.  Being able to search in many ways will greatly assist in finding any asset your studio has created.

SteamPipe Search

SteamPipe Search

Foundation:

The backend uses a postgres database and a fastcgi application written in python and the frontend is in javascript using jQuery.

SteamPipe will be available as a custom installation during Beta, contact us for more information.

Posted in SteamPipe | Leave a comment

Don’t Feed the Creatures…

Director: Kickstand
Producers: Rob O’Neill, Daniel Dawson, Greg Elshoff

Modeling: George Smaragdis, Bryan Eck
Rigging: George Smaragdis, StretchMesh
Animation: George Smaragdis, Jonathan Lee, Bryan Eck
Lighting and Compositing: Jonathan Lee
Sound Design: George Smaragdis and Paris Smaragdis
Special Thanks: NYFrequency.

Shot on RED, produced at Kickstand, Brooklyn, NY in 2009.

Shot breakdown on our reel:
vimeo.com/8089163

Posted in Featured Content | Leave a comment

Maya Python UI

A lot of people ask me how to deal with UI’s in Maya, especially how to lay things out properly. The example below shows a simple way to construct a ui in Python. One thing that’s nice about using Python for ELF UI’s is how UI names can be easily unique and accessible. In MEL, I got used to making UI names as specific as possible, and often times concatenating strings together to represent things like this:

string $mybutton = `button -label "test" ("myButton_" + $name)`;

Then if you want to access it, you need to know $name and call this:

button -q ... ("myButton_" + $name);

This is completely fine and manageable, but now with Python, it’s more clear to do something like this:

self.myButton = cmds.button(label='test')

Then anytime you want to access it in Python, you can just call:

cmds.button(self.myButton, q=True, ...)

The other thing that can be great is to store UI elements in lists in Python. So if you want to create a layout that has a textField and two buttons for every object that’s selected, you could iterate through your selection, appending a new layout to your list for each object.

For example:

def createMyLayout( obj, parent ):
    cmds.setParent(parent)
    c = cmds.columnLayout()
    text = cmds.textField(text=obj)
    button1 = cmds.button(label="one")
    button2 = cmds.button(label="two")
   
    return c

myLayouts = []
w = cmds.window("example", title="Example")
c = cmds.columnLayout()
for selectedObject in cmds.ls(sl=True):
    myLayouts.append(createMyLayout(selectedObject, c))
cmds.showWindow(w)

So this example could be even better if you defined a class, but already, it’s great that there’s a function that generates the layout for each object and then stores it so you could access it later without worrying what Maya actually names it.

Also in this example, I define my function to accept the parameter: ‘parent’. I started this after seeing many of the UI MEL scripts in Maya are setup like that. It also seems to make things more clear in the code, instead of calling “setParent ..” all the time, you’re explicitly telling it which layout to put new things under.

My last example tries to put things together into a Python class. It shows how to access UI elements which are stored as members of the class and how to handle UI control callbacks as well as how to use the formLayout. The formLayout has been my secret to controlling how UI’s are displayed. The great thing about it is you can specify where controls get placed on the layout and how other controls get place around it. It’s also the most consistent way of making controls expand / contract when the window is resized. So if you want a button to be attached to the left / right side of the window, you can just use the formLayout’s attachForm option.

You can actually run this, but copy pasting into your Python Script Editor, then you can just type something like:

m = myUI()

This will immediately create the UI because the UI was defined / created in the class’ __init__ method.

The other thing you can do is access members of myUI from the instance: m like this:

cmds.button(m.rename, q=True, label=True)

This will query the label of the rename button that was defined in __init__:

self.rename = cmds.button(label='Rename', w=100, c=self.rename)

Here’s the generic UI code as example:

import maya.cmds as cmds

class myUI:
    def __init__(self):
        self.name = "myUI"
        self.title = "My UI"

        # Begin creating the UI
        if (cmds.window(self.name, q=1, exists=1)): cmds.deleteUI(self.name)
        self.window = cmds.window(self.name, title=self.title)

        self.form = cmds.formLayout()
        self.fromText = cmds.textFieldButtonGrp(label='From: ', buttonLabel='...', bc=self.fromTextLoad)
        self.toText = cmds.textFieldButtonGrp(label='To: ', buttonLabel='...', bc=self.toTextLoad)
        self.rename = cmds.button(label='Rename', w=100, c=self.rename)

        # Attach elements to form
        cmds.formLayout( self.form,
            edit=True,
            attachForm=[
                (self.fromText, 'top', 2),
                (self.fromText, 'left', 2),
                (self.fromText, 'right', 2),
                (self.toText, 'left', 2),
                (self.toText, 'right', 2),
                (self.rename, 'left', 2)
                ],
            attachControl=[
                (self.toText, 'top', 2, self.fromText),
                (self.rename, 'top', 2, self.toText)
            ]
        )

        cmds.window(self.window, e=1, w=430, h=103)
        cmds.showWindow(self.window)

    def fromTextLoad(self, *args):
        print args
        sel = cmds.ls(sl=True)
        if len(sel):
            # Load first selected
            cmds.textFieldButtonGrp(self.fromText, e=True, text=sel[0])
       
    def toTextLoad(self, *args):
        sel = cmds.ls(sl=True)
        if len(sel):
            # Load first selected
            cmds.textFieldButtonGrp(self.toText, e=True, text=sel[0])
       
    def rename(self, *args):
        fromText = cmds.textFieldButtonGrp(self.fromText, q=True, tx=True)
        toText = cmds.textFieldButtonGrp(self.toText, q=True, tx=True)
        print "Rename from: %s to: %s" % (fromText, toText)
Posted in Maya | 1 Comment

A Couple of User-Created OpenPipeline Video Tutorials Posted!

A few of the students over at Animation Mentor posted tutorials about how they use OpenPipeline in production. Thanks to Paul Borawski Jr. and Peter Ruschel for making the effort and for supporting OpenPipeline.

Posted in OpenPipeline | Tagged , | Leave a comment

OpenPipeline on openSourceVFX.org

The open source animation pipeline OpenPipeline has been added to openSourceVFX.org. The site is an amazing collection of production-proven tools for visual effects and animation that have been made open source. The site has three goals:

1. Present the best open-source projects.
2. Provide an up-to-date directory with relevant links.
3. Aggregate news for those projects.

Opensourcevfx.org is headed up by folks from Sony Imageworks (who have made recent strides to release some internal tools open source) and we thank Rob Bredow and Philippe Leprince for connecting us to the site. Kickstand is a strong supporter of making tools open source whenever possible. The lessons learned through these tools help to raise the quality of work in the industry and can benefit everyone from students to studios. We have a number of tools, scripts, and code snippets coming up that we plan to be releasing open source to contribute to the conversation of animation and vfx development.

Posted in OpenPipeline, Tools | Tagged , , | 1 Comment

Welcome to the Kickstand Den!

Take a look around– we’re adding all sorts of new things to our website to make it easier for us to interact with you.

On our new blog, the Kickstand team will be posting weekly about new work, events, and ideas for the future, plus updates from around our studio in Brooklyn, NY.

We are also integrating a new forum area where we invite you to participate in the development of new projects with your feedback, suggestions, and thoughts.

As always, information about Kickstand, our creative team, services and tools, are available at kickstand.tv.

We hope to hear from you soon!

Posted in Featured Content, Uncategorized | Leave a comment

Rob O’Neill discusses OpenPipeline in CGWorld

Animation students face many challenges as they prepare to enter the workforce– one of the most obvious is the lack of experience working in a studio production pipeline. For studios juggling tight deadlines and even tighter budgets, this issue can oftentimes be a deal breaker when it comes to landing the job … [OpenPipeline], an underground, open-source project, which began in 2006 and has been consistently gaining momentum over the years, is providing students with the tools they need to work in a production pipeline long before they ever set foot in the studio.

Posted in Press, Team Work | Tagged , | Leave a comment