Mayanomicon:Toggle state array

Today I will show some re-factoring done on my old toggle node .

Pruning rig dependencies :

This node purpose was to simplify a graph network by enabling user to toggle the state of a large number of elements.

Its usually used for common space switching setup :

• An enum attribute defines which parent is active
• All other element are then disabled

As usual on such simple node the core functionality can be written in two lines:

(notice how coding style and pep8 was not my priority nor concern)

def updateToggleStates(self):
    for item in self.currentDataHandleArray:
        item.setBool(False)

    self.currentDataHandleArray[self.currentActiveIndexValue].setBool(True)

def compute(self,
            currentPlug,
            dataBlockInput):
    self.collectOutputhandle(dataBlockInput)

    self.prepareBuilder()

    self.resize(dataBlockInput)

    self.updateToggleStates()

    self.writeOutput()

On the updated code the node will resize the output attribute array  with and array data builder and then write the correct value from the selected currentActiveIndexValue.

Tool design :

To help people have the least amount of preparation the primary mode of this tool will be focused on driving a parent constraint .

item can be reorder in the list with dra and drop and the text edited after a double click

Launching the tool can be done with Mayanomicon/run/openToggleParentWeightsTool.py

Final product and parting words:

Source code and tool are now available in my Mayanomicon repository

The download section will be updated accordingly and expose how module installation works.

 

Advertisements

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.

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