Class Description:
“Since the formal introduction of Python into Maya, it has been rapidly gaining ground as the scripting language of choice among technical artists and tools developers. Its host of built-in features and its support for programming with the Maya API allow Python developers to interact with Maya in many exciting ways. In this MasterClass, Adam and Ryan discuss different scenarios that may appear during production and for which Python is ideally suited to provide a quick and flexible solution. Using two example projects, Adam and Ryan will demonstrate practical applications of threading as well as Maya plug-in development.”

http://area.autodesk.com/gdc/class2

Last but not least Uncharted 2 received five awards at the 10th annual Game Developers Choice Awards including the Game of The Year award. More info here:

http://www.gamasutra.com/view/news/27649/GDC_Uncharted_2_Wins_Big_At_10th_Annual_Game_Developers_Choice_Awards.php

Cheers,
Ryan

http://evolve3d.net/feature-speaker-ryan-trowbridge/

Cheers,
Ryan

Type in and execute the following code into your script editor in a Maya Python tab:

print __name__

Which will print:

__main__

When you print __name__ in a module it will give you the namespace of the module itself. So why did printing __name__ work inside of the Script Editor? Now write a quick function and execute it in the Script Editor:

def test():
    """this function is a test"""
    print "test"

Next type and execute the following line:

help(test)

#Result:
Help on function test in module __main__:

test()
    testing

Ok so your thinking its just calling it module __main__ its not really a real module is it? Try executing the following:

import __main__
dir(__main__)
# Result: ['__builtins__', '__doc__', '__main__', '__name__', '__package__', 'test'] #

You can see that by calling dir on the __main__ module that test has been defined inside of the __main__ module. So Python is adding functions that we write and variables on the fly to this __main__ module. If you import a module it will also go into this list.

import math
dir(__main__)
# Result: ['__builtins__', '__doc__', '__main__', '__name__', '__package__', 'math', 'test'] #

Every Python program starts with a __main__ module. If we were to make a Python program outside of Maya the first module loaded and executed would become the __main__ module. Some people write a line that states:

if __name__ == "__main__":
    print "do special stuff if your the main module"

Python docs state:

http://docs.python.org/library/__main__.html

“This module represents the (otherwise anonymous) scope in which the interpreter’s main program executes — commands read either from standard input, from a script file, or from an interactive prompt. It is this environment in which the idiomatic “conditional script” stanza causes a script to run:”

In the end the __main__ module is not an actual file though, but you could call it the main module.

Have fun,
Ryan

This post has nothing to do with Python or anything to do with character rigging. With that warning given I thought I would post something I had made to remember Uncharted 2: Among Thieves. My last project was by far the best project I have ever worked on. So far we have won more awards than we can count. Last time I looked there were 98 major magazine or online publications that had given us the Game of the Year award for 2009. So to celebrate this I decided to make something to remember the game by.

I had a poster we had on hand signed by all my colleges at ND, then I had a plaque engraved with Uncharted 2:Among Thieves Game of the Year 2009. I had all of these framed in a shadow box style frame. The boarders use the black, red, and white Naughty Dog colors. The shadow box style frame let me put the game cd, box, and plaque to the side of the poster. The frame shop did a great job.

I look forward to shipping our next game,
Ryan

A good way to setup your UI is to encapsulate the UI in a class including the functions you will use with the UI. You dont need all of your functions inside of the class. If you need to work with a function that is external to the class, you can use a partial function. When you set a button command to use a function it is best not to give it a string like you would in MEL. You should pass the functions directly to the command. You should not pass the functions as if you called them however like function() but by just giving it the name. If you need to pass an argument you need to use a partial function so the function does not get called until the user presses the UI item. You should note the UI button command happens to always pass one argument even if you dont pass anything to the function. If you pass your function one argument it will receive two, or if you pass two it will receive three. This is easily remedied by adding an extra unused argument.

I have several personal projects taking up my time right now so I am going to be brief on the how to and what does what part. The following example should help you get started. You can execute it from the script editor and start playing around with it.

import maya.cmds as cmds
from functools import partial

def myfunc(inst=None, thing=None, arg=None):
    print 'arg: ', arg
    print 'inst: ', inst
    print 'thing: ', thing
    data = cmds.button(inst.btnA, query=True, label=True)
    print data

class ui():
    def __init__(self, winName="winTheWindow"):
        self.winTitle = "The Window"
        self.winName = winName

    def create(self):
        if cmds.window(self.winName, exists=True):
            cmds.deleteUI(self.winName)

        cmds.window(self.winName, title=self.winTitle)
        self.mainCol = cmds.columnLayout( adjustableColumn=True )
        self.btnA = cmds.button( label='Press Me - External Func', c=partial(myfunc, self, 'say...') )
        self.btnB = cmds.button( label='Press Me - Internal Func', c=partial(self.a, 'something...') )
        self.btnC = cmds.button( label='Press Me - Internal Func No Args', c=self.b)
        cmds.showWindow( self.winName )
        cmds.window(self.winName, edit=True, widthHeight=[250,75])

    def a(self, myarg=None, arg=None):
        print 'myarg: ', myarg

    def b(self, arg=None):
        print 'buttons require an argument'
        print 'the argument passed in will always be the last argument'

# create the window
inst = ui()
inst.create()

Have fun,
Ryan

Uncharted 2 Trailers -
E3 Trailer
Level Walkthrough
Dont Quite Cinematic

Awards -

Game Critics Awards
http://www.gogaminggiant.com/2009/06/my-e3-game-of-the-show/

• Game of the Show

“The storyline of the game, the writing and the characters also all look top-notch, like something out of a Hollywood movie.”

PlatformNation
http://www.platformnation.com/2009/06/06/uncharted-2-among-thieves-2009-game-of-e3/

• Best Game of E3

“…it is the best looking video game this generation.”

G4
http://g4tv.com/videos/39019/Best-of-E3-09-Best-of-Show/
http://g4tv.com/videos/39016/Best-of-E3-09-PlayStation-3-Game/

• Best of Show
• Best PS3 Game

“It is a summer blockbuster in a nutshell.”

Game Focus
http://www.gamefocus.ca/?nav=article&did=429

• Best of Show
• Best Action/Adventure
• Best PS3 Game

“It was a tough call once again bug overall, Uncharted 2 had the most things to show at E3.”

1up
http://www.1up.com/do/feature?cId=3174543

• Best of Show
• Best PS3 Game

“Nathan Drake’s new adventure looks prettier, scarier, and more intense than ever.”

Gameblog
http://www.gameblog.fr/news_9729_e3-09-les-gameblog-awards-de-l-e3-2009

• Best of Show
• Best Action / Adventure game
• Best Graphics
• Best Sound

Futureshop
http://www.futureshopforums.ca/t5/Tech-Blog/E3-09-Uncharted-2-was-a-Show-Stealer/ba-p/155082#A234

• Game of the show

“For those of you who have seen the recent E3 trailer (if you haven’t, see below) you’ll probably agree that this game looks absolutely stunning.”

The Totaly Rad Show
http://revision3.com/trs/fundane?hp

• game of the show

“Uncharted 2 game of show. It is so awesome, Thee best graphics, thee most exciting gameplay, fun, smart, funny, great story, it is going to be a phenominal game.”

IGN Australia
http://xbox360.ign.com/articles/993/993782p2.html

• best game of E3 2009

“Uncharted: Among Thieves is the best game of E3 2009, without question. It is a title of unsurpassed beauty, combining wonderful programming with technical beauty. Uncharted: Among Thieves is so refined on all fronts – single player, multiplayer, cinematically, thematically – that it shames every other game in the action-shooter category.”

Gamespy
http://www.gamespy.com/articles/993/993100p1.html

• PS3 Game of Show

“Uncharted 2’s thieving protagonist Drake climbed monolithic structures as a camera panned to show miles and miles of dangerously lush skylines, all before collapsing and sending him into a chaotic series of duck-and-cover firefights. Yet somehow, through all the madness, he was able to keep his cool. It’s that balance of cockiness and confidence that exudes from every detail of Uncharted 2. The final product is shaping up to be not just a must-have for PS3 owners, but a defining icon of gaming for this generation.”

Crispygamer
http://www.crispygamer.com/features/2009-06-11/the-crispy-awards-e3-2009-edition.aspx

• PS3 Game of Show

“It should have been Kratos’ show. (We picture the old bald-headed bastard somewhere in a hotel room, pulling the wings off flies.) Instead, it’s Nathan Drake’s this-freaking-building-is-falling-down-around-meeeee demo that’s indelibly etched into our admittedly soft brains.”

IGN
http://ps3.ign.com/articles/992/992656p1.html

• PS3 Best Game of Show
• PS3 Best Action Game
• PS3 Best Graphics
• PS3 Best Multiplayer
• Ps3 Best Tech

“The way the characters react to this with the newly-enhanced physics and animation systems makes the game look absolutely incredible, more like a summer blockbuster than your everyday videogame. We cannot wait until this fall to get our hands on it.”

Game Trailers
http://www.gametrailers.com/video/best-graphics-best-of-e3/51488

• Best Graphics of E3
• Best Third Person Shooter

Game Spot
http://www.gamespot.com/special_feature/e3-2009-editors-choice/

• Best PS3 Game
• Best Graphics

“The folks at Naughty Dog brought it all to E3 2009. For starters, they showcased a live demo during the Sony press conference that combined an impressive array of gameplay variety, stunning visuals, and mind-bending destruction.”

Gamepro
http://www.gamepro.com/article/features/210658/best-of-e3-the-27-best-games/

• E3 gold award

“In the trailer, the graphics are so damn good you might not be able to tell the difference between real gameplay and the cut scenes.”

I think they liked it,
Ryan

I thought this was an interesting challege that the Python API could handle since it can access the M3dView class which lets you test points in the Maya 3d space and get what pixel they are at in the viewport. Here is the finished script, also posted in my downloads section:

rtRenderSelectedMeshesRegion.zip

Cheers,
Ryan

So I was given this example and asked what the u charter was for in front of each string name returned in the list.

aList = cmds.ls(selection=True)
print aList

>>[u'pSphere1', u'pSphere2', u'pSphere3', u'pSphere4']

The long and the short of it is Unicode allows more characters than ASCII. ASCII can hold 256 values and Unicode can hold 65,536 values. This allows computers to support complex languages with many characters. If you want a more complex explanation go here:

http://www.amk.ca/python/howto/unicode

Getting back to the example. So the aList returns a list of string names using Python Unicode. Thats what the u stands for. It shouldnt bother you though nor affect anything.

So if you have two spheres in your scene and you run this in the script editor it will return u’pSphere2′ and u’pSphere1′ like this:

import maya.cmds as cmds

getlist = cmds.ls(sl=True)
print getlist
>>[u'pSphere2', u'pSphere1']

You should not need to worry about this because Maya automatically converts back to regular strings when you get the items out of the list:

for node in getlist:
    print node
>>pSphere2
>>pSphere1

Notice maya converts the string to a normal string when you print each item in the list. Or if you print just one item like this:

print getlist[0]
>>pSphere2

You could do this though, even though you shouldn’t need to do this, unless linux or apple computers work differently. I am not sure.

import maya.cmds as cmds

getlist = cmds.ls(sl=True)
print len(getlist)

for i in range( 0, len(getlist) ):
    getlist[i] = getlist[i].encode("ascii","ignore")

print getlist
>>['pSphere1', 'pSphere2']

As for the second question:

“Is there a way to fit arguments into the command?”

def fooB (var = 1.0):
cmds.button(command=fooB(var = 9.5) )       	# won't work
cmds.button(command=fooB)                 	# but this will work?

The reason the first method wont work is that the button command is getting confused as to what arguments are being passed to it. The second works but the command thinks it is a string not a function. You can make the first work by passing the command a string containing what you are passing it. To further that thought you can pass it other variables as well.

#Example 1

# this works because it is inside of a string so the command
# clearly understands what is passed to it
def fooB (var = 1.0)
cmds.button(command='fooB(var = 9.5)' )

#Example 2

# this works as long as the functions doesnt expect an argument,
# since you are using keyword like var = 1.0 you dont have to pass
# anything to the function
def fooB (var = 1.0)
cmds.button(command='fooB()') 

#Example 3

# this also works but gets much harder to read whats going on
fooA = 9.5
def fooB (var = 1.0)
cmds.button(command=('fooB(var = ' + fooA + ')'), label='something' )

In example 3 I surround the multiple strings with brackets ( and ) so that it is clear to the command what is to be passed to it. Think of it like brackets in MEL you are defining a clump of data to be passed to the command. Last thing to note is only strings can be passed to a command so you need to type str(fooA) to cast the 9.5 into a string like this “9.5″ so it can be added to the ‘fooB(var = ‘ and ‘)’ string. Now this is getting more complex to read.

If you get to the point you want to do this, you probably need to start reading data from your UI.
For example you could create a floatField like this:

import maya.cmds as cmds

window = cmds.window()
cmds.columnLayout()
cmds.floatField('myFloatFieldA', minValue=-10, maxValue=10, value=5 )
cmds.showWindow( window )

Since I defined the float field with a name ‘myFloatFieldA’ you can ask the UI what the value is in your script editor or a function.

cmds.floatField('myFloatFieldA', query=True, value=True )

Then instead of using:

fooA = 9.5
def fooB (var = 1.0)
cmds.button(command=('fooB(var = ' + fooA + ')'), label='something' )

You can do this:

import maya.cmds as cmds

def fooB ():
	myFloatValue = cmds.floatField('myFloatFieldA', query=True, value=True )
	print myFloatValue

window = cmds.window()
cmds.columnLayout()
cmds.floatField('myFloatFieldA', minValue=-10, maxValue=10, value=5 )
cmds.button(command='fooB()', label='something' )
cmds.showWindow( window )

If you press the button it will print the value in the float field.

Cheers,
Ryan

http://www.rtrowbridge.com/blog/downloads/

It was originally written by Michael B. Comet so the concept was created by him and he deserves the credit. I converted his C++ code into a Maya Python API plug-in. Hopefully with no bugs, but there very well could be some still lurking. If you find any feel free to tell me and I will look into fixing them. I think this was a good exercise in converting a plug-in. It helped me with understanding better how to read C++ into Python. Not that I will be doing that often but it is still a good learning experience.

This changes the poseReader from being a plug-in that must be compiled for every version of Maya to a plug-in that will work on any platform and for any version of Maya using Python. That’s pretty cool I think.

Feel free to pick it apart and learn from it.

Cheers,
RyanT

import maya.OpenMaya as OpenMaya
import maya.OpenMayaMPx as OpenMayaMPx

kcompUtilNodeTypeName = "compoundExampleNode"
kcompUtilNodeClassify = "utility/general"
kcompUtilNodeId = OpenMaya.MTypeId(0x87325)

# define a new matrixUtilNode class derived from the MPxNode class
class rtcompUtilNode(OpenMayaMPx.MPxNode):

	# class variables
	compIn = OpenMaya.MObject()
	compOut = OpenMaya.MObject()
	input = OpenMaya.MObject()
	output = OpenMaya.MObject()

	def __init__(self):
		OpenMayaMPx.MPxNode.__init__(self)

	# arguments ( self, MPlug, MDataBlock)
	def compute(self, plug, dataBlock):

		# if these attributes are requested, recompute their values
		if plug == rtcompUtilNode.compOut or plug.parent() == rtcompUtilNode.compOut:

			# get MDataHandle's to attributes
			#
			try:
				input_dataHandle = dataBlock.inputValue( rtcompUtilNode.input )
			except:
				sys.stderr.write( "Failed to get MDataHandle inputValue input" )
				raise
			try:
				output_dataHandle = dataBlock.outputValue( rtcompUtilNode.output )
			except:
				sys.stderr.write( "Failed to get MDataHandle outputValue output" )
				raise

			# get values from dataHandle
			#
			input_value = input_dataHandle.asFloat()

			# set the output
			output_dataHandle.setFloat(input_value)

			# set the plug clean so maya knows it can update
			dataBlock.setClean(plug)

		else:
			return OpenMaya.kUnknownParameter

		return OpenMaya.MStatus.kSuccess

def nodeCreator():

	return OpenMayaMPx.asMPxPtr( rtcompUtilNode() )

# create and initialize the attributes to the node
def nodeInitializer():

	nAttr = OpenMaya.MFnNumericAttribute()
	cAttr = OpenMaya.MFnCompoundAttribute()

	# create input attributes
	#
	rtcompUtilNode.input = nAttr.create("input", "i", OpenMaya.MFnNumericData.kFloat, 0.0)
	nAttr.setWritable(True)
	nAttr.setStorable(True)
	nAttr.setReadable(True)
	nAttr.setKeyable(True)

	rtcompUtilNode.output = nAttr.create("output", "o", OpenMaya.MFnNumericData.kFloat, 0.0)
	nAttr.setWritable(False)
	nAttr.setStorable(False)
	nAttr.setReadable(True)

	# create compound attribute
	#
	rtcompUtilNode.compIn = cAttr.create( "compIn", "ci" )
	cAttr.addChild( rtcompUtilNode.input )

	rtcompUtilNode.compOut = cAttr.create( "compOut", "co" )
	cAttr.addChild( rtcompUtilNode.output )

	# add attribues
	#
	rtcompUtilNode.addAttribute( rtcompUtilNode.compIn )
	rtcompUtilNode.addAttribute( rtcompUtilNode.compOut )

	# Setup which attributes affect each other
	rtcompUtilNode.attributeAffects ( rtcompUtilNode.compIn,  rtcompUtilNode.compOut )

# initialize the script plug-in
def initializePlugin(mobject):
	mplugin = OpenMayaMPx.MFnPlugin(mobject, "Autodesk", "1.0", "Any")
	try:
		mplugin.registerNode( kcompUtilNodeTypeName, kcompUtilNodeId, nodeCreator, nodeInitializer, OpenMayaMPx.MPxNode.kDependNode, kcompUtilNodeClassify)
	except:
		sys.stderr.write( "Failed to register node: %s" % kcompUtilNodeTypeName )
		raise

# uninitialize the script plug-in
def uninitializePlugin(mobject):
	mplugin = OpenMayaMPx.MFnPlugin(mobject)
	try:
		mplugin.deregisterNode( kcompUtilNodeId )
	except:
		sys.stderr.write( "Failed to deregister node: %s" % kcompUtilNodeTypeName )
		raise

First lets get it working before I talk about how the script works. Save this script as a file somewhere on your computer with a .py extension. In maya select the menu Window/Settings and Preferences/Plug-in Manager. Click the browse button in the plug-in manager and select the file that you saved the script as. This will a plug-in called compountAttrExample to the “OtherRegisteredPlugins” section of the manager. If you click on the “i” icon to the right of it, the plug-in shows the Dependency nodes of that plug-in. This lets you see what the plug-in has created. Now lets create the new node we added.

Open the script editor, and in a python tab run these lines of script:

import maya.cmds as cmds

cmdAttrNode = cmds.createNode(’compoundExampleNode’)
sphere = cmds.polySphere()
cmds.connectAttr( (sphere[1] + ‘.radius’), (cmdAttrNode + ‘.input’), force=True)
cmds.getAttr( cmdAttrNode + ‘.output’)

This creates a new compoundExampleNode and a poly sphere. The poly sphere has its radius attribute connected to the input attribute of the compoundExampleNode. Finally we get the attribute value of the output from the compoundExampleNode. If the sphere’s radius changes it will automatically change the output.

Now lets break down the script.

import maya.OpenMaya as OpenMaya
import maya.OpenMayaMPx as OpenMayaMPx

kcompUtilNodeTypeName = "compoundExampleNode"
kcompUtilNodeClassify = "utility/general"
kcompUtilNodeId = OpenMaya.MTypeId(0×87325)

First we must import maya.OpenMaya nd maya.OpenMayaMPx. These give us access to the Maya api classes we need for creating the plug-in. Most maya.OpenMaya classes can be used in the script editor in in a general Python script, but maya.OpenMayaMPx classes are specifically used for creating nodes which you must create a plug-in to use.

Next the kcompUtilNodeTypeName defines the name of the plugin node. This is just a variable placed at the top of the script so it is easy to change. The kcompUtilNodeClassify variable allows you to classify your node. If a node is in the utility/general class it will show up in the hypershade under general utilities. You can get the class of any specific Maya node by using

cmds.getClassification( ‘nodeName’ )

The last variable defines the node id number. Maya needs this to understand which node is which. If your class id is the same as another node it will conflict and your node will not work.

Moving on to the next part we define the nodes class and figure out what we derive from:

class rtcompUtilNode(OpenMayaMPx.MPxNode):
...

First we define the class rtcompUtilNode which derives from the class OpenMayaMPx.MPxNode Maya defines what is needed for a non dag node inside of the MPxNode class. If you want to create a node that has a transform you need to derive from another class like MPxLocatorNode for instance.

Next we define the variables of that class.

# class variables
compIn = OpenMaya.MObject()
compOut = OpenMaya.MObject()
input = OpenMaya.MObject()
output = OpenMaya.MObject()

You can have general variables you need for doing whatever it is you want to do, but these variables are special. They define OpenMaya.MObject() attributes which is what you will use to create input / output attributes on your node.

Next we move onto compute:

def compute(self, plug, dataBlock):

	# if these attributes are requested, recompute their values
	if plug == rtcompUtilNode.compOut or plug.parent() == rtcompUtilNode.compOut:

This function is run anytime an attribute on the node changes. The if plug statement changes to see if the compOut attribute has been requested. Then you know you have the attribute that you want to update.

The last part of the class looks like this:

try:
	input_dataHandle = dataBlock.inputValue( rtcompUtilNode.input )
except:
	sys.stderr.write( "Failed to get MDataHandle inputValue input" )
	raise
try:
	output_dataHandle = dataBlock.outputValue( rtcompUtilNode.output )
except:
	sys.stderr.write( "Failed to get MDataHandle outputValue output" )
	raise

# get values from dataHandle
#
input_value = input_dataHandle.asFloat()

# set the output
output_dataHandle.setFloat(input_value)

# set the plug clean so maya knows it can update
dataBlock.setClean(plug)

Here we get the input and output attributes as MDataHandle objects. The MDataHandle class lets you get and set data on a attribute.

input_dataHandle = dataBlock.inputValue( rtcompUtilNode.input )
output_dataHandle = dataBlock.outputValue( rtcompUtilNode.output )

Once we have the MDataHandle object we can query the value on the input attribute like this. The MDataHandle class has several ways of querying data. You must use the correct function to work with the type of data you have stored. asFloat() does not work for int’s ect. You would use asInt() for an int. See the documentation on the class for more details.

input_value = input_dataHandle.asFloat()

And our last step is to set the output attribute. First we set the attribute again with a specific function for setting floats that the MDataHandle class has. Then we use setClean(plug) to tell Maya that we updated the attribute and the node is ready.

output_dataHandle.setFloat(input_value)
dataBlock.setClean(plug)

Every node needs nodeCreator() function. This simply returns the node that you have setup.

def nodeCreator()

The nodeInitializer function is what sets up the nodes attributes. First we start off by defining the types of attributes we want to create.

nAttr = OpenMaya.MFnNumericAttribute()
cAttr = OpenMaya.MFnCompoundAttribute()

Next we create some numeric attributes.

rtcompUtilNode.input = nAttr.create("input", "i", OpenMaya.MFnNumericData.kFloat, 0.0)
nAttr.setWritable(True)
nAttr.setStorable(True)
nAttr.setReadable(True)
nAttr.setKeyable(True)

rtcompUtilNode.output = nAttr.create("output", "o", OpenMaya.MFnNumericData.kFloat, 0.0)
nAttr.setWritable(False)
nAttr.setStorable(False)
nAttr.setReadable(True)

Then we create two compound attributes. Note we create the compound attribute and then add the attribute that we want to be a child of that compound attribute. Once we add a attribute to a compound attribute we do not add it again.

rtcompUtilNode.compIn = cAttr.create( "compIn", "ci" )
cAttr.addChild( rtcompUtilNode.input )

rtcompUtilNode.compOut = cAttr.create( "compOut", "co" )
cAttr.addChild( rtcompUtilNode.output )

Now we add the compound attributes.

rtcompUtilNode.addAttribute( rtcompUtilNode.compIn )
rtcompUtilNode.addAttribute( rtcompUtilNode.compOut )

Our last step is we tell Maya that we want the input compound attribute to affect the output. If the input changes it will tell the node to call the compute function. Any attribute inside of the compound attribute will cause compute to be called. Also note it is ok to have many attributes that affect many attributes. You can save yourself some trouble though by creating fewer compound attributes to group attributes that are similar.

rtcompUtilNode.attributeAffects ( rtcompUtilNode.compIn, rtcompUtilNode.compOut )

Almost done!

Now we need to make it so Maya knows how to create the node and uncreate the node. This is what the node id and name and all the above that we created comes together as a package.

When you call the command createNode Maya calls teh initializePlugin function of this node. This attempts to register this node with the name, id, nodeCreator function, nodeInitializer function, type of maya node, and the class we defined it as. The node

def initializePlugin(mobject):
	mplugin = OpenMayaMPx.MFnPlugin(mobject, "Autodesk", "1.0", "Any")
	try:
		mplugin.registerNode( kcompUtilNodeTypeName, kcompUtilNodeId, nodeCreator, nodeInitializer, OpenMayaMPx.MPxNode.kDependNode, kcompUtilNodeClassify)
	except:
		sys.stderr.write( "Failed to register node: %s" % kcompUtilNodeTypeName )
		raise

This just does the opposite and removes the node when you delete it from Maya using the node id that it has.

def uninitializePlugin(mobject):
	mplugin = OpenMayaMPx.MFnPlugin(mobject)
	try:
		mplugin.deregisterNode( kcompUtilNodeId )
	except:
		sys.stderr.write( "Failed to deregister node: %s" % kcompUtilNodeTypeName )
		raise

Wow that takes a bit to describe but I hope it helps.
-RyanT