Maya Station

Crash when loading scenes with displayPoints or type in mayapy

We have seen issues from customers who are attempting to load their scenes which contain type in mayapy that end up crashing.  These particular crashes seem to focus around the newer displayPoints node that are used in Maya.

A displayPoint node in Maya is a Utility Draw Node that is mainly used to display the Type pivot points in the .  Ultimately this crash tends to occur when the type tool is used as there is a UI draw call.

head over to our learning page for more details and workarounds.

 

 

Selection behaviour for set nodes

When a set node is selected, the default behaviour is for Maya to expand the selection to include all the items in that set.

If you want Maya to simply select the node and ignore its contents, use the -noExpand flag.

Around the Corner: a new M&E developer blog

There is a new blog in town!  Around the Corner, is a blog dedicated to
plug-in developers working with Maya, MotionBuilder, FBX and any other
technology that strikes our fancy at the moment of blogging.

This blog is authored by Cyrille Fauvel and me (Kristine Middlemiss, I am
sad to say I am departing this blog :()

To tell you a little about our selves we are 2/6’s of the Media & Entertainment worldwide team of API gurus providing technical services through the Autodesk Developer Network.

When either of us comes across some information on programming for Autodesk
technologies that we think you’ll be interested in, then you can expect it to
be posted here. That will be technical (how-to) solutions derived from
answering questions from ADN partners and from Autodesk forum users, sample
projects, white papers screencasts, conference presentation material, and other
information derived from our work. This blog is a vehicle to put lots of up to
date information in one place so you can easily find what you need to solve
your programming problems.

Enjoy!

Kristine

Python MDataHandle.asString() does not return the string content

When writing a custom node using Python and trying to retrieve an attribute string with the compute method, the MDataHandle.asString() method does not return the attribute string content, but a string referencing the internal Maya MString:

def compute( self, plug, data ):
  if plug != myTestNode.outputAttr:
   return maya.OpenMaya.MStatus.kUnknownParameter
  inputHandle = data.inputValue( myTestNode.myStringAttr )

  # returns something like "_18691109_p_MString"
  simpleAttrValue = inputHandle.asString()  

To retrieve the real string content th MDataHandle::asString() returns a reference to an internal Maya MString object. Because it is a reference, if the user changes the contents of the string that is immediately reflected in the datablock without having to call set(). There is no way to provide equivalent functionality in Python because, among other things, Python strings are immutable: any changes create a new string and the MString class that is available in C++ is not available in Python because it has its own string implementation which makes our not needed.

However, there is a simple workaround. If you add this code you will get the string content rather than the reference to the internal string.

stringData =inputHandle.data()
stringFn = maya.OpenMaya.MFnStringData(stringData)
stringValue = stringFn.string()
print "real stringValue:", stringValue

Working with Internal Data Using setInternalValueInContext

When writing an MPxNode which stores data internally using setInternalValueInContext that is connect to another node. Everything will work well until you save the scene and re-load the scene. It seems you have to force an update of the attribute of your node with a refresh, such as displaying the Attribute Editor.

The reason for this is the value that is maintain for an internal attribute is only used when the attribute does not have an incoming connection. If the attribute has an incoming connection then the connection determines the value of the attribute and your node has no say in the matter. To handle this, use MPxNode::connectionMade() and MPxNode::connectionBroke() to maintain a flag telling you whether the attribute is currently connected.

In Python, that would look something like this:

class myNode(maya.OpenMayaMPx.MPxNode):
         myNode.myAttr = maya.OpenMaya.MObject()

         def __init__(self):
                 self.myValue = 0.0
                 self.myAttrIsConnected = False

         def connectionMade(self, myPlug, theirPlug, iAmSrc):
                 if not iAmSrc and myPlug == myNode.myAttr:
                          self.myAttrIsConnected = True
                 return ompx.MPxNode.connectionMade(self, myPlug, theirPlug, iAmSrc)

         def connectionBroken(self, myPlug, theirPlug, iAmSrc):
                 if not iAmSrc and myPlug == myNode.myAttr:
                          self.myAttrIsConnected = False
                 return ompx.MPxNode.connectionBroken(self, myPlug, theirPlug, iAmSrc)

In the compute(), check the flag. If it's true then update the internal value from the datablock before using it:

         def compute(self, plug, block):
                 if plug == myNode.someOutputAttr:
                          if self.myAttrIsConnected:
                                   self.myValue = block.inputValue(myNode.myAttr).asFloat()

If you need the internal value outside the compute() then write yourself a helper method which gets the value from a plug when the flag is set and call that method as needed:

         def get_myValue(self):
                 if self.myAttrIsConnected:
                          plug = maya.OpenMaya.MPlug(thisMObject(), myNode.myAttr)
                          self.myValue = plug.asFloat()
                 return self.myValue

How to get Tkinter to run in Maya 2012 with Linux

Tkinter is a Python GUI package which operates on top of Tcl/Tk.  The Tkinter .so is included with Maya’s packaged Python folder. For users on Linux running distributions like Redhat Enterprise 6 or Fedora 14 you will notice that the default version of Tcl and Tk are 8.5.  Running any Tkinter call within Maya’s ui will automatically prompt an error:

from Tkinter import *
root = Tk()

# Error: TclError: Can't find a usable init.tcl in the following directories:
/usr/share/tcl8.4 /usr/aw/maya2011-x64/lib/tcl8.4 /usr/aw/lib/tcl8.4 /usr/aw/maya2011-x64/library /usr/aw/library /usr/aw/tcl8.4.13/library /usr/tcl8.4.13/library /usr/share/tcl8.4

You will notice Maya is pointing to a version Tcl which is not installed and looking for directories which are not on the system.

The reason this occurs is because we compile Maya on the lowest possible setup for compliance.  Maya 2012 is based on Redhat Enterprise 5.  This simply means that the default Tcl and Tk version on this distribution are 8.4.  Unfortunately, this information is hardcoded into the _tkinter.so file included in the Maya python "lib-dynload" folder. This cannot be changed. So your only option at this point is to install the 8.4 version of the app.

There is no need to remove your current Tcl or Tk versions and the 8.4 version can be installed without any issues.  You will need to source these based on your distribution and get the rpm’s installed and Maya will than grab the proper directories in /usr/lib.

Let’s now focus on some actual work.  Below is a sample script which will build a GUI window with a button to build a sphere.  You will notice I added some threading commands.  The reason for this is to make sure that the Maya UI is still available and updated without having to wait for the python UI to close before updating the viewport.

import maya.utils
import maya.cmds as mc
import Tkinter as tk
import threading

def makeSphere( radius ):
     print "WOW that Sphere is great!"
     mc.sphere( radius=radius )

def makeMySphere():
     maya.utils.executeInMainThreadWithResult( makeSphere, 5 )

def UI():
    app = tk.Tk()
    btnCube = tk.Button(app, text="Make a special Sphere", command=makeMySphere )
    btnCube.pack()
    app.mainloop()

class MyThread ( threading.Thread ):
     def run ( self ):
          UI()

MyThread().start()

I hope this is helpful for anyone using Tkinter on Linux.  Please remember this was only tested on Linux so I am not sure what the behaviour is like on Windows.

There are also other options for building python GUI’s.  We have details in the Maya devkit for pyQt and I have also seen folks use wxPython.

Cheers!

Nelson

Free Autodesk Media & Entertainment API/SDK Webcast Trainings

Free Autodesk API/SDK Webcast Trainings

The Autodesk Developer Network (ADN) is offering free Maya API, 3ds Max SDK, MotionBuilder SDK and FBX SDK webcast trainings. This unique opportunity allows you to dive into the inner workings of our software, and come out with a strong fundamental knowledge of the architecture. You will see and understand how you can utilize and benefit from the API’s/SDK’s of these powerful software’s.

1. Maya API (Python)
2. MotionBuilder API (Python)
3. 3ds Max
4. FBX (C++)

To register and view the course schedule, please look here:

http://www.adskconsulting.com/adn/cs/api_course_sched.php

For specific course agenda’s go here:

http://usa.autodesk.com/adsk/servlet/index?siteID=123112&id=785271

Okay, I loaded my Plug-in, now what?

I got this great question the other day, it may seem simple however that is what is so great about the question.

Everyone thinks it's so simple that no one ever writes about it!

What do you do in Maya once you use the Plug-in Manager or the MEL command loadPlugin to load your plug-in.

Once you have loaded your plug-in, shhh, this is the part no one tells you, you still have to create your node in the scene!

To do this you can use the MEL command ‘createNode {nodename}’ so for example to create any Maya default node you could do this:

 createNode Transform;

Here we are creating a standard node that comes with Maya (there are hundreds), the name of the node matches the node name in the documentation under Nodes and Attribute Reference, which you can access from the standard help documentation that comes with Maya:

But you can also use this createNode for custom nodes that you creating using the Maya API. Let’s say you have compiled the Devkit sample ‘pnTrianglesNode’, you would do this after loading the plug-in:

 createNode pnTriangles;

One you run this command, the node is now actually in your Maya scene, and will be saved there on scene save. From here you just need to connect other nodes to this node in your scene.

Also, the other way to create nodes in the API is to use the class MDGModifier, there is a method there called createNode.

~Kristine

Exporting Hair Geometry

If you are writing an exporter plug-in and want to add support for exporting hair geometry data (much like the mayatomr functionality). At first glance there does not seem to be any API functionality for hair other than collision solving via MHairSystem, which does not give access to the hair data. To access the hair geometry scalar data (per-hair and per-vertex data) use MFnPfxGeometry::getLineData() and then use MRenderLineArray and MRenderLine to get at the per-vertex data. For other data, you’ll have to access the attrs on hairSystem or pfxHair node directly.

To elaborate the actual hair geometry is represented in the pfxHair node (which is connected to the hairSystem node when paint effects output is used). This derives from the base class pfxGeometry which is also used for stroke and pfxToon nodes.  To get the hair geometry one can use the call  MFnPfxGeomtry::getLineData for the pfxHair node. (Note that if one used curve output instead of pfx output on the hair system, then one could simply access the set of output nurbs curves on the hair system, but as this is rather obvious I’m assuming they want the pfxHair data)

One thing worth noting is that your exporter would also potentially work (to some degree) for paint effects strokes and Maya toon lines, in addition to hair, because they all share the same base class.

~Kristine

Viewport 2.0 and API Introduction

One of the most important and the biggest changes of the last release (Maya 2012) was Viewport 2.0.  I want to take this opportunity to provide you some additional information on the new Viewport 2.0 API. Previously in Maya if you had several high polygon models and you were trying to manipulate those models, Maya sometimes could behave slowly.

Viewport 2.0 is a brand new rendering system it is based on an internal technology by Autodesk. By using this new architecture, we are trying to replace all the old rendering system. As you can see this is a fundamental architecture change. The purpose of the change is to have high performance when rendering large complicated scenes. Viewport 2.0 is much faster compared to the old viewport. Keep in mind when importing this new technology, we have dramatically changed the way shading and rendering works in Maya.

Viewport 2.0 provides a programmable shader system allowing you more flexibility with customization. You can customize a shape, a shader, or a rendering process; it’s all possible with this new system. This new rendering system includes a new viewport 2.0, but also includes a batch version called Hardwar Renderer 2.0. In Maya 2012 there are a lot of new classes in the API. Since some of the new classes have the same name as the old classes, the new classes are in a new namespace called MHWRender.

~Kristine