As anyone can guess the last 3 years were quite challenging: i was lucky enough to travel and work in Canada, Spain and Scotland.
I didn’t manage to update this blog in the meantime, but todays post will but related to maya development .
Last week Chris Evans wrote a post on skin-weights saving/loading in Maya, I will try to talk here about the part I find relevant and lastly elements we can improve.
Downloadable files and tool:
After a review of this task and additional information you will be able see some benchmark using different methods and tool.
The one i wrote for this occasion can be grab on my git hub account:
State of the art and current configuration:
Saving and loading weights is a common task any character TD will face at some point.
Usually in the rigging pipeline :
- This update can be motivated when a character model has changed.
- A rig module has changed or animation department request a special feature.
Those updates will mean our rig need to be rebuilt.
Back in the day changing skeleton layout requires people to detach their skin deformer but is no longer needed.
Another observation is that we usually are interested to updated a whole character skincluster or build it from scratch:
- loading weight on selected points is quite rare ( but easy to do ).
Practical interaction and scripting access:
On a scripting point of view this task can be done with the commands skinPercent and skinCluster.
#lets try this code in the python script Editor
vertexToWrite = ['bodySuit.vtx[0]',
'bodySuit.vtx[1]',
'bodySuit.vtx[2]']
#when you want to write some point weights
maya.cmds.skinPercent(vertexToWrite,
'bodySuitSkinCluster1',
transformValue = ('spine1',0.5),
('spine2', 0.5)])
#We can see you can specify as argument the component you wish to act upon
This example can illustrate some of maya strong points : its nodal nature, openness and scripting capacity .
A very interesting design choice was made by the maya architects:
- letting user having free access to attributes .
This freedom let you read/write data at will and connect compatible element together and this process can be done without having to select their parent node
In contrast in 3dsmax the skinOps command is only accessible from the command panel after a skin modifier have been selected, unfrtunately :
- Some exposed function are broken or doesn’t support undo…
Skincluster node study:
To continue the 3dsmax analogy an operator which act on set of points is called a deformer.
- its a specialized node which only update point attributes (so normals /position are quite common, but usually not the topology nor the uvs)
In our case a skincluster purpose is to attach a set of points to a joint and then define a smooth falloff between regions.
( above the equation in academic papers: not very useful and readable isn’t it?)
In common terms each influence will move all points rigidly ( as if the whole shape was parented to it ) and then bone vertex weights will be used to define how we mix things together.
Without any surprise the main input attribute used to define this behavior is the matrix attribute.
Each influences worldMatrix will feed this list and tell the deformer when to update our shape point positions.
In order to parent the shape to a joint we need to convert points into this joint space:
- at bind Time Maya will store your joint worldInverseMatrix into the correct bindPrematrix attribute.
Technically weight data are stored into a compound attribute:
- each vertex will have a sparse array of float/double related to the joints influencing them
- One other fun fact is that you can connect this attribute ( maya being a nodal application remember?) to have animatable weights ( it will slow down your rig in a tremendous manner on complex character though).
This choice was mostly driven for it flexibity:
- when you paint weights or colors on a set of points having a sparse array attribute save space and memory.
Its interesting to see that this attribute is inherited from weightGeometryFilter parent class and as such is shared between all kind of deformer in maya ( very useful example of class design and inheritance).
Saving weights from the grounds up:
Now that we have a rough idea on how maya skincluster is implemented we can start looking on how this task was done through the year:
1 – Skinpercent vertex iteration:
Back in mel days we where using a combination of fopen / fclose / fflush to write line by lines the influences index and weights list of each vertex component.
The most easy way to do that was to use a simple line separator like space.
Nowadays we can do it easily with python:
#skinData mix joint index / weights: 65 0.2 12 0.56 5 0.24
with open ('targetskinFile.txt', 'w') as targetskinFile:
targetskinFile.write(skinData)
Python context is a really powerful tool and concept: here it will automatically close your file once it goes out of scope.
Lets see now how to actually extract some usefull data.
pointCount = maya.cmds.polyEvaluate(meshTransform, v=True)
skinCommand = 'findRelatedSkinCluster {}'.format(meshTransform)
skinDeformer = maya.mel.eval(skinCommand)
jointArray = maya.cmds.skinCluster(skinDeformer,
q=True,
inf=True)
for pointIndex in xrange(pointCount):
component = '{meshTransform}.vtx[{vertexIndex}]'
component = component.format(meshTransform=meshTransform,
vertexIndex=pointIndex)
weightData = maya.cmds.skinPercent(component,
skinDeformer,
q=True,
value=True,
ignoreBelow=0.000001)
influenceData = maya.cmds.skinPercent(component,
skinDeformer,
q=True,
transform=True,
ignoreBelow=0.000001)
influenceIndices = [jointArray.index(joint) for joint in jointArray]
skinData = zip(influenceIndices, weightData)
Above you can see how to gather the weights for the provided component(most of the time vertex mesh ):
- The first lines gather the skinCluster node from the mesh history
- determines how many points are deformed ( a more robust method involves getting the skincluster set but 90 percent of time user use all shape points.
- And lastly gather the influence list
The main part of the code is then put under a loop and act on each point:
- the first skinpercent command gather weights which are above the provided threshold (ignoreBellow=0.000001)
- the second call will return an array of joint names hence the list comprehension at the end of the loop uesd to collect their index )
( In the next update of skinIO module on git hub you will be able to look at the pointWeight class example: it will mostly be used to benchmark and compare methods)
2 – Low level attribute parsing:
e
3 – MFnSkinCluster influence iteration:
At some point, the natural evolution of a skinweights IO tool will involve acting on components:
- It can be useful to swap sides or mirror elements.
- Sort elements and prepare data in for weight transfer ( here we can only do a one to one assigment ).
At this point most people start to look at a higher degree of abstraction to actually save/read data to/from disk.
The most popular choice in game industry is to use Xml ( because of 3dsmax and through dotnet).
it was also choosed by maya developper to save deformer weights ( skincluster is still done through UV and texture maps… ).
Years ago when i was testing the different options to save weight faster I start by saving them as well into an xml file.I was having correct result with python cElementTree, but on my data set Json proved to be actually faster.
One thing that stroke me is that people are still trying to export skin weights in xml on a per Vertex basis.
At some point i tried to reverse my way of thinking and to save the data from a joint point of view:
- each influence will carry a list of vertex index and matching list of weights.
Lets take a look at this task by using the API (as skinPercent -q -transform “jointToRead” average values instead of giving the list of weigts of the provided component…).
import maya.OpenMaya
import maya.OpenMayaAnim
import maya.cmds
def get_mobject(node):
#sample code from chad vernon
selectionList = maya.OpenMaya.MSelectionList()
selectionList.add(node)
oNode = maya.OpenMaya.MObject()
selectionList.getDependNode(0, oNode)
return oNode
skinCommand = 'findRelatedSkinCluster {}'.format(meshTransform)
skinDeformer = maya.mel.eval(skinCommand)
#Gather some data relative to influences
jointArray = maya.cmds.skinCluster(skinDeformer,
q=True,
inf=True)
influenceCount = len(jointArray)
#go from command to Api world
skinClusterApiObject = get_mobject(skinDeformer)
shapeApiObj = get_mobject(shape)
shapePath = OpenMaya.MDagPath()
maya.OpenMaya.MDagPath().getAPathTo(shapeApiObj, shapePath)
#Now we can request skin data with the API by using MFnSkinCluster
skinFunctionUtils = maya.OpenMayaAnim.MFnSkinCluster(skinClusterApiObject)
influenceObjectPaths = maya.OpenMaya.MDagPathArray()
skinFunctionUtils.influenceObjects(influenceObjectPaths)
componentFunctionUtils = OpenMaya.MFnSingleIndexedComponent()
vertexElements = OpenMaya.MIntArray()
vertexIndexSelectionList = maya.OpenMaya.MSelectionList()
vertexWeights = maya.OpenMaya.MFloatArray()
for jointIndex in xrange(influenceCount):
vertexComponents = OpenMaya.MObject()
skinFunctionUtils.getPointsAffectedByInfluence(influenceObjectPaths[jointIndex],
vertexIndexSelectionList,
vertexWeights)
if vertexIndexSelectionList.length() < 1:
continue
vertexIndexSelectionList.getDagPath(0, shapePath, vertexComponents)
componentFunctionUtils.setObject(vertexComponents)
componentFunctionUtils.getElements(vertexElements)
skinData = zip(vertexElements, vertexWeights)
4 – MFnSkinCluster and python Api tricks:
As seen previously,using the python API show great improvement in speed but in the end the correct answer in my case was to dump the whole shape at once:
- instead of filtering point weights below a certain threshold the APImethod will expose all values( even zero one ) for all influences .
Above sven rig strip down to only its influence object and geometries ( from autodesk open source project : https://github.com/cedricB/skinIO/blob/master/sven.skin001.zip)
One interesting side effect is that for a mesh with 12000 vertices ( 36000 tris ) and 170 joint you will have a 2 million float list ( and no need for influence index ). As such its best to use other method if one as to process very dense mesh.
Lets see how we can do it with actual code:
e
In python it makes more sense to save this kind of data set as a whole in a binary format:
weightLength=’d’*exposedSkinData.length()
binWeights=struct.pack(weightLength,*exposedSkinData)
with open(binFile ,’wb’) as weightData:
weightData.write(binWeights)
The final product can package every asset files into a zip archive.
(above : it made more sense to me to bundle several skincluster present into a file as a skin asset instead of having one file per element)
(above a sample of json dictionnary: each skincluster will have the same structure and point to a binary file ( either alembic or bin file))
6 – Maya ascii/binary injection:
Another alternative, opened to mel scripter and maya native user, is to take advantage of maya nature and leverage is strong points.
It is kind of sad to see nowadays softimage user bashing mel, and trying to promote pymel as the only correct way to interact with maya.(sorry but Ice and visual programming is not cool nor new to any nodal application user ).
Unfortunately pymel design which enforce object programming:
- cuts maya user from its architecture,
- uses and expose api element to beginners( messing with MObject will have terrible consequence in your UI or scripts… ( look at motionbuilder instability if you want to see one concrete example of this potential disaster)
- slower than both mel and and maya command
- carry subtle bugs
- pollutes maya namespace and scripted plugin at import times.
end of the rant…
Benchmarking and final toughts:
So the funny trick to save and load weight is to actually let maya do all the work:
- exporting a selected skincluster node in either binary or ascii format (you need to unsure no connection ,history other other accessory elements are included at save time ).
Lets call it maya ascii/binary injection.( there is a really intersting section in the API documention on mayaAscii filter with similar concepts).
(The following test can be carried out on your side if you dowmload and use script from :
https://github.com/cedricB/skinIO
On my laptop using Chris script ( after correcting the missing import statements )
sven Export weight methods will produce this result in the script editor:
Exported skinWeights for 22 meshes in 1.80200004578 seconds.
The binary extraction methods from the script I will share on github:
———————————————————————-
Processings took 0.82452176412 seconds
The ascii extraction methods
———————————————————————-
Processings took 2.28121973499 seconds
(slower but still reasonable with retrospective to the amount of work involved… )
The last methods will take advantage of alembic cache node:
Saving 22 elements took 0.473954696144 seconds
Export to D:/SuitSkinCluster1.abc was successful
Geometry SuitShape
Number of vertex 18148
Number of influences 216
Number of weights Samples 3919968
———————————————————————-
Processings took 0.313700978128 seconds
(SKIPPING 21 other elements)
———————————————————————-
Processings took 0.516421672774 seconds
Thats it for today, I hope you had a good read.
The first part of the scene optimization problem was solved:
