def _buildSkeletonData(self, rootJnt):
'''
:param rootNode: root of the skeleton to process
'''
self.skeletonDict = {}
if not rootJnt:
log.info('skeleton rootJnt joint was not found')
return
fn = r9Core.FilterNode(rootJnt)
fn.settings.nodeTypes = 'joint'
fn.settings.incRoots = False
skeleton = fn.ProcessFilter()
for jnt in skeleton:
key = r9Core.nodeNameStrip(jnt)
self.skeletonDict[key] = {}
self.skeletonDict[key]['attrs'] = {}
for attr in [
'translateX', 'translateY', 'translateZ', 'rotateX',
'rotateY', 'rotateZ'
]:
try:
self.skeletonDict[key]['attrs'][attr] = cmds.getAttr(
'%s.%s' % (jnt, attr))
except:
log.debug('%s : attr is invalid in this instance' % attr)
def matchInternalPoseObjects(self, nodes=None, fromFilter=True):
'''
This is a throw-away and only used in the UI to select for debugging!
from a given poseFile return or select the internal stored objects
'''
InternalNodes = []
if not fromFilter:
#no filter, we just pass in the longName thats stored
for key in self.poseDict.keys():
if cmds.objExists(self.poseDict[key]['longName']):
InternalNodes.append(self.poseDict[key]['longName'])
elif cmds.objExists(key):
InternalNodes.append(key)
elif cmds.objExists(r9Core.nodeNameStrip(key)):
InternalNodes.append(r9Core.nodeNameStrip(key))
else:
#use the internal Poses filter and then Match against scene nodes
if self.settings.filterIsActive():
filterData = r9Core.FilterNode(nodes,
self.settings).ProcessFilter()
matchedPairs = self._matchNodesToPoseData(filterData)
if matchedPairs:
InternalNodes = [node for _, node in matchedPairs]
if not InternalNodes:
raise StandardError('No Matching Nodes found!!')
return InternalNodes
def getNodes(self, nodes):
'''
get the nodes to process
This is designed to allow for specific hooks to be used from user
code stored in the pose folder itself.
'''
if not type(nodes) == list:
nodes = [nodes]
if self.useFilter:
log.debug('getNodes - useFilter=True : no custom poseHandler')
if self.settings.filterIsActive():
return r9Core.FilterNode(
nodes, self.settings).ProcessFilter() # main node filter
else:
log.debug('getNodes - useFilter=False : no custom poseHandler')
return nodes
def buildOffsetCloud(self, rootReference=None, raw=False):
'''
Build a point cloud up for each node in nodes
:param nodes: list of objects to be in the cloud
:param rootReference: the node used for the initial pivot location
:param raw: build the cloud but DON'T snap the nodes into place - an optimisation for the PoseLoad sequence
'''
self.posePointRoot = cmds.ls(cmds.spaceLocator(name='posePointCloud'),
l=True)[0]
ppcShape = cmds.listRelatives(self.posePointRoot, type='shape')[0]
cmds.setAttr("%s.localScaleZ" % ppcShape, 30)
cmds.setAttr("%s.localScaleX" % ppcShape, 30)
cmds.setAttr("%s.localScaleY" % ppcShape, 30)
if self.settings:
if self.prioritySnapOnly:
self.settings.searchPattern = self.settings.filterPriority
self.inputNodes = r9Core.FilterNode(self.inputNodes,
self.settings).ProcessFilter()
if self.inputNodes:
self.inputNodes.reverse() # for the snapping operations
if self.mayaUpAxis == 'y':
cmds.setAttr('%s.rotateOrder' % self.posePointRoot, 2)
if rootReference: # and not mesh:
r9Anim.AnimFunctions.snap([rootReference, self.posePointRoot])
for node in self.inputNodes:
pnt = cmds.spaceLocator(name='pp_%s' %
r9Core.nodeNameStrip(node))[0]
if not raw:
r9Anim.AnimFunctions.snap([node, pnt])
cmds.parent(pnt, self.posePointRoot)
self.posePointCloudNodes.append((pnt, node))
cmds.select(self.posePointRoot)
if self.mesh:
self.shapeSwapMesh()
return self.posePointCloudNodes
