Mayanomicon:MultiLine text display

On this second node introspection I will expand on one common concept one can need when doing scene management / rig diagnostic:

• On screen value debugging.

NumToStringNode:

Expanding on my previous post “Hacking maya annotationShape Node”  this node was simply formatting text with a simple numeric input attribute.

Coding wise that was pretty rudimentary project but fulfilled its mission properly.

Drawing on screen paragraph:

While using the factory annotionShape locator, I notice line break and tabulation were not supported. Hence me writing a custom node to fill this needs.

The reportLocator node displays dynamic text , computed by the report node

( technically you can also use a locator’s compute method  but I wanted clear separation of task ). Both viewport type are supported ( which means for this plugin to use python 2.0 API)

The most interesting part of the node will convert the node position into screen coordinates.

This was covered numerous time by the maya community over the years:

• From rob bredow’s mel script
• on highend3d’s forum

import maya.OpenMaya as om

def pointWorldToCam(cameraName, point, res):
    sel = om.MSelectionList()
    dag = om.MDagPath()

    sel.add(cameraName)
    sel.getDagPath(0,dag)

    cam = om.MFnCamera(dag)
    floatMat = cam.projectionMatrix()
    projMat = om.MMatrix(floatMat.matrix)
    floatMat = cam.postProjectionMatrix()
    postProjMat = om.MMatrix(floatMat.matrix)
    transMat = dag.inclusiveMatrix()

    #long form ensures compatibility with MPoint and any iterable
    point = om.MPoint(point[0],point[1],point[2]) 

    fullMat =  transMat.inverse() * projMat * postProjMat
    nuPoint = point * fullMat
    return [(nuPoint[0]/nuPoint[3]/2+0.5)*res[0],
            (1-(nuPoint[1]/nuPoint[3]/2+0.5))*res[1]]

#test
print pointWorldToCam('persp', (0,0,0), (640,480))

• Or  from koichitamura’s blog

import maya.OpenMaya as OpenMaya

def floatMMatrixToMMatrix_(fm):
    mat = OpenMaya.MMatrix()
    OpenMaya.MScriptUtil.createMatrixFromList ([
        fm(0,0),fm(0, 1),fm(0, 2),fm(0, 3),
        fm(1,0),fm(1, 1),fm(1, 2),fm(1, 3),
        fm(2,0),fm(2, 1),fm(2, 2),fm(2, 3),
        fm(3,0),fm(3, 1),fm(3, 2),fm(3, 3)], mat)
    return mat

def WorldPositionToImageCoordinate(cameraName, imageXRes, imageYRes, worldX, worldY, worldZ):
    p = OpenMaya.MPoint(worldX, worldY, worldZ)
    sl = OpenMaya.MSelectionList()
    sl.add(cameraName)
    dpathCameraShape=OpenMaya.MDagPath()
    sl.getDagPath(0, dpathCameraShape)
    dpathCameraShape.extendToShape()
    fnc = OpenMaya.MFnCamera(dpathCameraShape.node())
    mmatProjection = floatMMatrixToMMatrix_(fnc.projectionMatrix())
    mmatInvCamera = dpathCameraShape.inclusiveMatrix().inverse();
    projected = p * mmatInvCamera * mmatProjection
    imageX = (projected.x/projected.w / 2.0 + 0.5) * imageXRes
    imageY = (projected.y/projected.w / 2.0 + 0.5) * imageYRes
    return imageX, imageY

#print WorldPositionToImageCoordinate('persp', 720, 486, -0.543, 3.926, 7.532)

 

Multiline text offset:

Inside a locator we can access directly the incoming M3Dview instance provided to us.

    def getPointOffset(self,
                       view,
                       path,
                       pointCount):
        self.nodeMatrix = path.inclusiveMatrix()

        self.worldPoint.x = self.nodeMatrix[12]
        self.worldPoint.y = self.nodeMatrix[13]
        self.worldPoint.z = self.nodeMatrix[14]

        isClipped = False
        self.xPosPointer, self.yPosPointer, isClipped = view.worldToView(self.worldPoint)

        offsetX = int(self.xPosPointer)
        offsetY = int(self.yPosPointer)

        return (self.computeViewOffset(view,
                                       offsetX,
                                       offsetY,
                                       path.inclusiveMatrixInverse(),
                                       index)
                for index in xrange(pointCount))

So the code above will extract the 3d world position and use worldToView method to return screen coordinates. after that a simple list comprehension will consider each text line as a separate draw call and offset by 20 pixels on Y direction.

Viewport 2.0 was interesting as well:

    def getPointInScreenCoordinates(self,
                                    objectMDagPath,
                                    frameContext):
        self.nodeMatrix = objectMDagPath.inclusiveMatrix()

        self.worldPoint.x = self.nodeMatrix[12]
        self.worldPoint.y = self.nodeMatrix[13]
        self.worldPoint.z = self.nodeMatrix[14]

        viewPoint = self.worldPoint*frameContext.getMatrix(frameContext.kViewProjMtx)
        basePointX = 0.0
        basePointY = 0.0
        if viewPoint.z != 0.0:
            basePointX = (viewPoint.x/viewPoint.z)*0.5
            basePointY = (viewPoint.y/viewPoint.z)*0.5
        basePointX += 0.5
        basePointY += 0.5

        originX, originY, width, height = frameContext.getViewportDimensions()
        viewPoint.x = basePointX*width
        viewPoint.y = basePointY*height
        viewPoint.z = 0.0

        return viewPoint

Its the MFrameContext which will provide additional information like matrix data.

Final product and parting words:

Source code will be available shortly in my Mayanomicon repository

and simple tool will follows soon.

For now a sample file can be studied inside Mayanomicon/sample/reportSample01.ma.

Let me know if you have questions and as usual have fun hacking maya.

Advertisements

Mayanomicon: Exposing shape components

For this first node introspection I will talk about a component I needed  for on face controls and tweakers.

Vertex constraint :

All of started started with a node I was able to study outside the API documentation :

• an open source conversion done by Alex V. U Strarup (original author Chad Robert Morgan).

It was easy to read and proved to be generous gift for the Maya community.

Core concepts:

Basically this type of node expose the point position of mesh shape.

To do so we can derive our own custom node from the base MPxNode class.

Each node have a category and defined purpose:

• dependency node  computes
• deformer deforms ( what a surprise..)
• locator draws etc.

Those class are registered to maya’s plugin framework through the use of MFnPlugin function set:

def initializePlugin(mobject):
    mplugin = OpenMayaMPx.MFnPlugin(mobject)

def uninitializePlugin(mobject):
    mplugin = OpenMayaMPx.MFnPlugin(mobject)

The most important one are IO operations used to load / unload your library

/export:initializePlugin /export:uninitializePlugin %(AdditionalOptions)

hence the export flag required in visual studio project files.

Compute virtual method:

Dependency nodes are literally black boxes operator: they compute a result from their input attributes and write them to some output attributes.

IO is handled through the communication with the node datablock. a handle will let you read and write as you need your required attributes.

vert = OpenMaya.MFnMesh(mesh)

pos = OpenMaya.MPoint()
vert.getPoint(index, pos, OpenMaya.MSpace.kWorld)

On this code snippet from vertexConstraint.py we can see the only action the node will do each time the output position need to be refreshed:

• get from the datablock the mesh attribute and attach it to a function set ( MFn stands for maya function set)
• request with the MFnMesh getPoint method the  nth point position.

What about sampling point/edge  or face centers?

in the github repository you will find my variation on this subject:

• the meshComponentInfo node

Just for cosmetic consideration some common value and data are package under the class as constant properties(for example look at PLUGIN_VERSION).

def initializePlugin(mobject):
    mplugin = OpenMayaMPx.MFnPlugin(mobject,
                                    meshComponentInfo.AUTHOR,
                                    meshComponentInfo.PLUGIN_VERSION,
                                    "Any")
    try:
        mplugin.registerNode(meshComponentInfo.PLUGIN_NODE_NAME,
                             meshComponentInfo.PLUGIN_NODE_ID,
                             meshComponentInfo._createNode,
                             meshComponentInfo._addAttributes,
                             OpenMayaMPx.MPxNode.kDependNode)

    except:
        raise Exception(meshComponentInfo.REGISTER_FAILLURE_MESSAGE)

def uninitializePlugin(mobject):
    mplugin = OpenMayaMPx.MFnPlugin(mobject)

    try:
        mplugin.deregisterNode(meshComponentInfo.PLUGIN_NODE_ID)

    except:
        raise Exception(meshComponentInfo.DEREGISTER_FAILLURE_MESSAGE)

We still can see initialize/uninitialize functions

 

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

    @staticmethod
    def _createNode():
        return OpenMayaMPx.asMPxPtr(meshComponentInfo())

    @staticmethod
    def _addAttributes(....):
        ....

        meshComponentInfo.attributeAffects(meshComponentInfo.input,
                                           meshComponentInfo.output)

After a node is created its attributes will be attach to it and their relationship defined.

 

class meshComponentInfo(OpenMayaMPx.MPxNode):
    def getVertexPosition(self,
                          componentIndex):
        self.meshUtils.getPoint(componentIndex,
                                self.pointValue,
                                OpenMaya.MSpace.kWorld)

    def getPoint(self,
                 dataBlockInput):
        componentIndex = self.getComponentIndex(dataBlockInput)

        if self.componentTypeValue == self.VERTEX_TYPE:
            self.getVertexPosition(componentIndex)

        ....

    def compute(self,
                currentPlug,
                dataBlockInput):
        if not self.needUpdate(currentPlug,
                               dataBlockInput):
            return

        self.getPoint(dataBlockInput)

        self.writeOutput(dataBlockInput)

In my version users can choose vertex/edge/face as component type

The componentIndex will be the index to use to read the correct value in the the corresponding array. This value is clamped in order to prevent reading  outside the legal  the list range.

 

class meshComponentInfo(OpenMayaMPx.MPxNode):
    def getFaceCenter(self,
                      componentIndex):
        self.faceUtils.setIndex(componentIndex,
                                self.createIntPointer())

        self.pointValue = self.faceUtils.center(OpenMaya.MSpace.kWorld)

    def getEdgeCenter(self,
                      componentIndex):
        self.edgeUtils.setIndex(componentIndex,
                                self.createIntPointer())

        self.pointValue = self.edgeUtils.center(OpenMaya.MSpace.kWorld)

    def getPoint(self,
                 dataBlockInput):
        componentIndex = self.getComponentIndex(dataBlockInput)

        if self.componentTypeValue == self.VERTEX_TYPE:
            self.getVertexPosition(componentIndex)

        elif self.componentTypeValue == self.EDGE_TYPE:
            self.getEdgeCenter(componentIndex)

        elif self.componentTypeValue == self.FACE_TYPE:
            self.getFaceCenter(componentIndex)

Final product and parting words:

In python take advantage of shape in world coordinates .

and connect the output attribute to a translate type attribute.

Project and files can be downloaded from  https://github.com/cedricB/Mayanomicon

 

Thats it for today,  let me know if you have questions and i hope you will be able to recombine it to your liking and learn form it

Mayanomicon: custom nodes to encapsulate complex concepts

Throughout the years I was lucky enough to work on interesting projects. The tool i was feeling the most comfortable with was Maya:

• for compositing work my mind was really inclined around After Effect’s layer and composition mechanism. Combustion or Nuke node based work flow was never convenient in my line of work.

But for the very same reason i felt at home in Maya for rigging work. Mel was a scripting language solely defined to interact with your application. It will fell  obsolete and cumbersome to some people by today’s standard but it was a stepping stone to study and grow along side Maya improvement.

The general architecture and the API design was everything i could wish for to combine element the way i needed them.

Its sadly shun over by the young generation or the python zealot who sometime forget that before writing something it might be worth trying to use your tool to its fullest potential .

Node writing obsession:

I think since 2009/2010 i start to study and learn the API on my own.
Back in the days the the only available resources were :

• http://www.comet-cartoons.com/3ddocs/mayaAPI/ : from michael comet
• http://nccastaff.bournemouth.ac.uk/jmacey/RobTheBloke/www/mayaapi.html : An in depth introduction to the maya API by Rob Bateman ,
• http://www.davidgould.com/Books/index.html : Complete Maya Programming I & II
• http://web.archive.org/web/20050308105432/http://www.ewertb.com/maya/api/ : a web cache of Bryan Ewert How-To’s and Tutorials .

So the learning curve the first years was quite steep but at some point i stop counting the number of custom nodes I wrote when i pass over the 300 count.

Node network and visual programming:

I was always reluctant about visual programming paradigm: it feels like people spend more time connecting boxes and organizing the space layout than working on the actual core logic of the task they are trying to accomplish.

Quick prototype are fine and its refreshing sometimes to fiddle around and test an idea quickly switching between expression(which use mel [sorry for the softimage audience]), factory nodes and custom ones.

Code feel more efficient at some-point as even the most simple of operation will expand a graph exponentially .

The real power of the hypergraph lies into the heat propagation mechanism and the visual illustration of the internal dgTimer of your nodes.

click to open in a new window

When you are designing your rig and animation system,or tweaking your asset architecture it will gives far more interesting feedback than the profiler which only give you raw data metric in a lifeless manner without any meaningfully representation.This can sometimes lead to incorrect assumption and diagnostic.

click to open in a new window

But it can prove invaluable as part of a programmer toolkit ( which is different from what a rigger can afford to learn or is allowed to use).

[Above you can see in the image that a skin cluster node take 70 percent of the frame to evaluate: sometime the mesh resolution can slow down the output but most of the time the rig design and small cycle design flaw will be responsible for the evaluation delay]

The magical power of words:

(magic is the bloodstream of the universe…)

It always come to mind when i think of rigging, animation system and software development the riddle asked by the high Aldwin in the movie willow:

• “The power to control the world is in which finger?”

As an old classic the answer was likely to be your own ( each candidate choose one of the wizard finger and failed).

I start to see it easier to teach programming to a look dev artist, modeller or rigger than to teach art to a software engineer . I had rather have a strong collaboration with them asking for a low level api or another task using their full potential and leverage their expertise.

Scripting complex rig and managing their interface through connection and metadata was a useful skill to learn and an obvious answer the network complexity.

The next step for me was to assert that this scripting phase could be though as node prototype:

• once the initial idea was layout we would then start to write a python node and start to study the the graph organization and improvement.
• Ultimately this node will become a first class citizen and be translated as a C++ operator.

I tried during those years:

• to study factory nodes
• combine some of them
• use inheritance to support variation
• mix different element and have a look at hybridization
• play with permutation of parameters and attribute layout.

I had a lot of fun and  wasn’t too attach to coding style,  not any other cosmetic considerations

Parting words:

After this long introduction  i will try to share and publish in the Mayanomicon category my experimentations and code base.

Stay tune for the first plug-in example