def applyInitNodeConnections(self):
for key in self.filterGroupNodeDic['inputPlacement'].keys():
sourceNode = key.replace("motion_input",
"init").replace("input_placement", "init")
util.transformChannelBinding(sourceNode, key)
for key in self.filterGroupNodeDic['outputPlacement'].keys():
sourceNode = key.replace("motion_output",
"init").replace("output_placement",
"init")
sourceLocal = util.fullPathName2Local(sourceNode)
matchNodes = {}
util.getChildrenNodes(self.modulePathDic['init'], sourceLocal[1],
matchNodes, 1)
sourceNode = matchNodes.keys()[0]
util.transformChannelBinding(sourceNode, key)
for key in self.filterGroupNodeDic['controlPlacement'].keys():
sourceNode = key.replace("motion_control",
"init").replace("control_placement",
"init")
sourceLocal = util.fullPathName2Local(sourceNode)
matchNodes = {}
util.getChildrenNodes(self.modulePathDic['init'], sourceLocal[1],
matchNodes, 1)
sourceNode = matchNodes.keys()[0]
util.transformChannelBinding(sourceNode, key)
def setConnectionInfo(self):
parentSocketNodes = {}
childPlugNodes = {}
for socketNode in self.filterGroupNodeDic['outputParentSocket'].keys():
socketLocalNode = util.fullPathName2Local(socketNode)
parentSocketNodes[socketLocalNode[1]] = socketNode
if self.filterGroupNodeDic['controlChildPlug'] != None:
for plugNode in self.filterGroupNodeDic['controlChildPlug'].keys():
plugLocalNode = util.fullPathName2Local(plugNode)
childPlugNodes[plugLocalNode[1]] = plugNode
return parentSocketNodes, childPlugNodes
def updateInitByFit(self, liveConnection=False):
snapOps = []
initNodeFullName = cmds.ls(self.modulePathDic['init'], l=True)[0]
for match in self.fitNodeInfo.iterkeys():
for node, parentInfo in self.filterGroupNodeDic['init'].iteritems(
):
nodeLocal = util.fullPathName2Local(node)
if nodeLocal[1] == match + '_init':
parentInit = parentInfo['parent']
matrixOps = util.localMatrixOp(self.moduleNameSpace,
match + '_init')
snapOps += matrixOps
cmds.connectAttr(parentInit + '.worldInverseMatrix',
matrixOps[0] + '.matrixIn[1]',
f=True)
cmds.connectAttr(self.fitNodeInfo[match] + '.worldMatrix',
matrixOps[0] + '.matrixIn[0]',
f=True)
util.decompChannelBinding(matrixOps[1],
self.fitMatchDic[match])
liveConnection = self.params[0]['value']
if liveConnection != True:
if snapOps != None:
cmds.delete(snapOps)
return None
else:
return snapOps
def createMatchDic(self, fitNodeInfo, initNodes):
fitMatchDic = {}
for match in fitNodeInfo.iterkeys():
for initNode in initNodes.keys():
initNodeLocal = util.fullPathName2Local(initNode)
if initNodeLocal[1].replace('_init', '') == match:
fitMatchDic[match] = initNode
return fitMatchDic
def alignFootOffsetChild(self):
for node in self.filterGroupNodeDic['inputChildPlug'].iterkeys():
nodeLocal = util.fullPathName2Local(node)
if nodeLocal[1].rfind('foot_offset') != -1:
footOffsetPlug = node
parentNodes = cmds.listRelatives(footOffsetPlug, p=True, f=True, typ='transform')
footOffsetPlugNew = cmds.parent(footOffsetPlug, w=True)
cmds.setAttr(footOffsetPlugNew[0]+'.rotateX', 0)
cmds.setAttr(footOffsetPlugNew[0]+'.rotateZ', 0)
cmds.parent(footOffsetPlugNew[0], parentNodes[0], absolute=True, relative=False)
def setConnectionInfo(self):
parentSocketNodes = {}
childPlugNodes = {}
useConnectionConNodes = {}
if self.filterGroupNodeDic['outputParentSocket'] != None:
for socketNode in self.filterGroupNodeDic[
'outputParentSocket'].keys():
socketLocalNode = util.fullPathName2Local(socketNode)
parentSocketNodes[socketLocalNode[1]] = socketNode
if self.filterGroupNodeDic['inputChildPlug'] != None:
for plugNode in self.filterGroupNodeDic['inputChildPlug'].keys():
plugLocalNode = util.fullPathName2Local(plugNode)
childPlugNodes[plugLocalNode[1]] = plugNode
if self.filterGroupNodeDic['controlFkCon'] != None:
for plugNode in self.filterGroupNodeDic['controlFkCon'].keys():
plugLocalNode = util.fullPathName2Local(plugNode)
customAttributes = cmds.listAttr(plugNode, ud=True)
if customAttributes != None:
for customAttr in customAttributes:
if customAttr == 'useConnection':
useConnectionConNodes[plugLocalNode[1]] = plugNode
return parentSocketNodes, childPlugNodes, useConnectionConNodes
def applyMotionNodeConnections(self):
bodyNode = None
bodyFkCons = {}
for fkConNode in self.filterGroupNodeDic['controlFkCon']:
fkConLocalNode = util.fullPathName2Local(fkConNode)
if fkConLocalNode[1].rfind('space') == -1:
if fkConLocalNode[1].rfind('body') != -1 and fkConLocalNode[
1].rfind('upbody') == -1:
if fkConLocalNode[1].rfind('piv') != -1:
bodyFkCons['piv'] = fkConNode
else:
bodyFkCons['con'] = fkConNode
fkLocalNodeStr = fkConLocalNode[1].replace('fk_Con', 'node')
for motionOutputNode in self.filterGroupNodeDic['outputNode']:
motionOutputLocalNode = util.fullPathName2Local(
motionOutputNode)
if motionOutputLocalNode[1].rfind(
'body') != -1 and motionOutputLocalNode[1].rfind(
'upbody') == -1:
bodyNode = motionOutputNode
if motionOutputLocalNode[1] == fkLocalNodeStr:
util.transformChannelBinding(fkConNode,
motionOutputNode)
cmds.connectAttr(bodyFkCons['piv'] + '.translate',
bodyFkCons['con'] + '.rotatePivot',
f=True)
cmds.connectAttr(bodyFkCons['piv'] + '.translate',
bodyNode + '.rotatePivot',
f=True)
upbody_hip_blend_socket_node = None
for socketNode in self.filterGroupNodeDic['outputParentSocket']:
if socketNode.rfind('upbody') != -1 and socketNode.rfind(
'hip') != -1:
upbody_hip_blend_socket_node = socketNode
targetNodes = []
for motionOutputNode in self.filterGroupNodeDic['outputNode']:
motionOutputLocalNode = util.fullPathName2Local(motionOutputNode)
if motionOutputLocalNode[1].rfind(
'upbody') != -1 or motionOutputLocalNode[1].rfind(
'hip') != -1 and motionOutputLocalNode[1].rfind(
'placement') == -1:
targetNodes.append(motionOutputNode)
upbody_hip_blend_ori = cmds.orientConstraint(
targetNodes[0], targetNodes[1], upbody_hip_blend_socket_node)
upbody_hip_blend_pos = cmds.pointConstraint(
targetNodes[0], targetNodes[1], upbody_hip_blend_socket_node)
hipFkCon = None
headFkCon = None
for fkConNode in self.filterGroupNodeDic['controlFkCon']:
fkConLocalNode = util.fullPathName2Local(fkConNode)
if fkConLocalNode[1].rfind(
'hip') != -1 and fkConLocalNode[1].rfind('space') == -1:
hipFkCon = fkConNode
elif fkConLocalNode[1].rfind('head') != -1 and fkConLocalNode[
1].rfind('space') == -1 and fkConLocalNode[1].rfind(
'comp') == -1:
headFkCon = fkConNode
else:
continue
check = cmds.attributeQuery('hip_nodeW0',
node=upbody_hip_blend_pos[0],
ex=True)
attr = ''
if check:
attr = 'hip_nodeW0'
else:
attr = 'hip_nodeW1'
cmds.connectAttr(hipFkCon + '.hipPosWeight',
upbody_hip_blend_pos[0] + '.' + attr,
f=True)
check = cmds.attributeQuery('hip_nodeW0',
node=upbody_hip_blend_ori[0],
ex=True)
attr = ''
if check:
attr = 'hip_nodeW0'
else:
attr = 'hip_nodeW1'
cmds.connectAttr(hipFkCon + '.hipOriWeight',
upbody_hip_blend_ori[0] + '.' + attr,
f=True)
headCompSpaceOp = util.createOpNode(
self.moduleNameSpace, 'choice',
self.filterStrList[3] + '_compSpace_selector')
spaceRefNodeList = self.filterGroupNodeDic['controlRef'].keys()
for i in range(len(spaceRefNodeList)):
cmds.connectAttr(spaceRefNodeList[i] + '.worldMatrix',
headCompSpaceOp + '.input[' + str(i) + ']',
f=True)
cmds.connectAttr(headFkCon + '.headCompSpace',
headCompSpaceOp + '.selector',
f=True)
headConPlacementNode = None
for controlPNode in self.filterGroupNodeDic[
'controlPlacement'].iterkeys():
controlPNodeLocal = util.fullPathName2Local(controlPNode)
if controlPNodeLocal[1].rfind(self.filterStrList[3]) != -1:
headConPlacementNode = controlPNode
matrixOps = util.localMatrixOp(
self.moduleNameSpace, self.filterStrList[3] + '_compSpace_cal')
cmds.connectAttr(headCompSpaceOp + '.output',
matrixOps[0] + '.matrixIn[0]',
f=True)
cmds.connectAttr(headConPlacementNode + '.worldInverseMatrix',
matrixOps[0] + '.matrixIn[1]',
f=True)
headCompWeightApplyOp = util.createOpNode(
self.moduleNameSpace, 'multiplyDivide',
self.filterStrList[3] + '_compWeight_apply')
cmds.connectAttr(matrixOps[1] + '.outputRotate',
headCompWeightApplyOp + '.input1',
f=True)
cmds.connectAttr(headFkCon + '.headCompWeight',
headCompWeightApplyOp + '.input2X',
f=True)
cmds.connectAttr(headFkCon + '.headCompWeight',
headCompWeightApplyOp + '.input2Y',
f=True)
cmds.connectAttr(headFkCon + '.headCompWeight',
headCompWeightApplyOp + '.input2Z',
f=True)
cmds.setAttr(headCompWeightApplyOp + '.operation', 1)
headConCompSpaceNode = None
for controlSpaceNode in self.filterGroupNodeDic[
'controlSpace'].iterkeys():
controlSpaceLocalNode = util.fullPathName2Local(controlSpaceNode)
if controlSpaceLocalNode[1].rfind(
'head_fk') != -1 and controlSpaceLocalNode[1].rfind(
'comp') != -1:
headConCompSpaceNode = controlSpaceNode
cmds.connectAttr(headCompWeightApplyOp + '.output',
headConCompSpaceNode + '.rotate',
f=True)
headOutputSpaceNode = None
for motionOutputSpaceNode in self.filterGroupNodeDic[
'outputSpace'].iterkeys():
motionOutputSpaceLocalNode = util.fullPathName2Local(
motionOutputSpaceNode)
if motionOutputSpaceLocalNode[1].rfind('head') != -1:
headOutputSpaceNode = motionOutputSpaceNode
cmds.connectAttr(headConCompSpaceNode + '.rotate',
headOutputSpaceNode + '.rotate',
f=True)
def applyInitNodeConnections(self):
rootNode = None
controlNode = None
outputPlacementNode = None
initNodeLocal = None
filterStr = 'root'
for initNode in self.filterGroupNodeDic['init'].iterkeys():
initNodeLocal = util.fullPathName2Local(initNode)
if initNodeLocal[1].rfind(filterStr) != -1:
rootNode = initNode
for outPNode in self.filterGroupNodeDic['outputPlacement'].iterkeys():
outPNodeLocal = util.fullPathName2Local(outPNode)
if outPNodeLocal[1].rfind(
filterStr
) != -1: #and initNodeLocal[1].rfind('upbody') == -1:
outputPlacementNode = outPNode
for controlPNode in self.filterGroupNodeDic[
'controlPlacement'].iterkeys():
controlPNodeLocal = util.fullPathName2Local(controlPNode)
if controlPNodeLocal[1].rfind(filterStr) != -1:
controlNode = controlPNode
util.transformChannelBinding(rootNode, controlNode)
util.transformChannelBinding(rootNode, outputPlacementNode)
filterStr = 'body'
matrixOp = []
bodyInitNode = None
bodySocketNode = None
for outPNode in self.filterGroupNodeDic['outputPlacement'].iterkeys():
outPNodeLocal = util.fullPathName2Local(outPNode)
if outPNodeLocal[1].rfind(filterStr) != -1 and outPNodeLocal[
1].rfind('upbody') == -1:
outputPlacementNode = outPNode
for controlPNode in self.filterGroupNodeDic[
'controlPlacement'].iterkeys():
controlPNodeLocal = util.fullPathName2Local(controlPNode)
if controlPNodeLocal[1].rfind(filterStr) != -1:
controlNode = controlPNode
for initNode in self.filterGroupNodeDic['init'].iterkeys():
initNodeLocal = util.fullPathName2Local(initNode)
if initNodeLocal[1].rfind(filterStr) != -1 and initNodeLocal[
1].rfind('upbody') == -1:
bodyInitNode = initNode
matrixOps = util.localMatrixOp(self.moduleNameSpace,
filterStr + '_init')
cmds.connectAttr(rootNode + '.worldInverseMatrix',
matrixOps[0] + '.matrixIn[1]',
f=True)
cmds.connectAttr(bodyInitNode + '.worldMatrix',
matrixOps[0] + '.matrixIn[0]',
f=True)
util.decompChannelBinding(matrixOps[1], controlNode)
util.decompChannelBinding(matrixOps[1], outputPlacementNode)
for socketNode in self.filterGroupNodeDic['outputParentSocket']:
socketLocalNode = util.fullPathName2Local(socketNode)
if socketLocalNode[1].rfind(filterStr) != -1 and socketLocalNode[
1].rfind('upbody') == -1:
bodySocketNode = socketNode
bodyNegYOp = util.createOpNode(self.moduleNameSpace, 'multiplyDivide',
filterStr + '_space_neg_y')
cmds.setAttr(bodyNegYOp + '.input2Y', -1)
cmds.connectAttr(outputPlacementNode + '.translate',
bodyNegYOp + '.input1',
f=True)
cmds.connectAttr(bodyNegYOp + '.outputY',
bodySocketNode + '.translateY',
f=True)
upbodyInitNode = None
chestInitNode = None
hipInitNode = None
headInitNode = None
for initNode in self.filterGroupNodeDic['init'].iterkeys():
initNodeLocal = util.fullPathName2Local(initNode)
if initNodeLocal[1].rfind(self.filterStrList[0]) != -1:
upbodyInitNode = initNode
elif initNodeLocal[1].rfind(self.filterStrList[1]) != -1:
chestInitNode = initNode
elif initNodeLocal[1].rfind(self.filterStrList[2]) != -1:
hipInitNode = initNode
elif initNodeLocal[1].rfind(self.filterStrList[3]) != -1:
headInitNode = initNode
else:
continue
upbodyOutputNodes = []
chestOutputNodes = []
hipOutputNodes = []
headOutputNodes = []
for outPNode in self.filterGroupNodeDic['outputPlacement'].iterkeys():
outPNodeLocal = util.fullPathName2Local(outPNode)
if outPNodeLocal[1].rfind(self.filterStrList[0]) != -1:
upbodyOutputNodes.append(outPNode)
elif outPNodeLocal[1].rfind(self.filterStrList[1]) != -1:
chestOutputNodes.append(outPNode)
elif outPNodeLocal[1].rfind(self.filterStrList[2]) != -1:
hipOutputNodes.append(outPNode)
elif outPNodeLocal[1].rfind(self.filterStrList[3]) != -1:
headOutputNodes.append(outPNode)
else:
continue
upbodyControlNodes = []
chestControlNodes = []
hipControlNodes = []
headControlNodes = []
for controlPNode in self.filterGroupNodeDic[
'controlPlacement'].iterkeys():
controlPNodeLocal = util.fullPathName2Local(controlPNode)
if controlPNodeLocal[1].rfind(self.filterStrList[0]) != -1:
upbodyControlNodes.append(controlPNode)
elif controlPNodeLocal[1].rfind(self.filterStrList[1]) != -1:
chestControlNodes.append(controlPNode)
elif controlPNodeLocal[1].rfind(self.filterStrList[2]) != -1:
hipControlNodes.append(controlPNode)
elif controlPNodeLocal[1].rfind(self.filterStrList[3]) != -1:
headControlNodes.append(controlPNode)
else:
continue
upbodyConnections = upbodyOutputNodes + upbodyControlNodes
for upbodyConnection in upbodyConnections:
util.transformChannelBinding(upbodyInitNode, upbodyConnection)
matrixOps = util.localMatrixOp(self.moduleNameSpace,
self.filterStrList[1] + '_init')
cmds.connectAttr(upbodyInitNode + '.worldInverseMatrix',
matrixOps[0] + '.matrixIn[1]',
f=True)
cmds.connectAttr(chestInitNode + '.worldMatrix',
matrixOps[0] + '.matrixIn[0]',
f=True)
util.decompChannelBinding(matrixOps[1], chestControlNodes[0])
util.decompChannelBinding(matrixOps[1], chestOutputNodes[0])
util.transformChannelBinding(hipInitNode, hipOutputNodes[0])
util.transformChannelBinding(hipInitNode, hipControlNodes[0])
matrixOps = util.localMatrixOp(self.moduleNameSpace,
self.filterStrList[3] + '_init')
cmds.connectAttr(chestInitNode + '.worldInverseMatrix',
matrixOps[0] + '.matrixIn[1]',
f=True)
cmds.connectAttr(headInitNode + '.worldMatrix',
matrixOps[0] + '.matrixIn[0]',
f=True)
util.decompChannelBinding(matrixOps[1], headControlNodes[0])
util.decompChannelBinding(matrixOps[1], headOutputNodes[0])
def applyMotionNodeConnections(self):
for key in self.filterGroupNodeDic['outputChildPlug'].keys():
sourceNode = key.replace("motion_output", "motion_input").replace(
"output", "input")
util.transformChannelBinding(sourceNode, key)
for key in self.filterGroupNodeDic['controlChildPlug'].keys():
sourceNode = key.replace("motion_control", "motion_input").replace(
"control", "input")
util.transformChannelBinding(sourceNode, key)
addFkConNode = cmds.listRelatives(
self.filterGroupNodeDic['controlAddFkConSpace'].keys()[0],
c=1,
s=0,
f=1,
typ='transform')[0]
for key in self.filterGroupNodeDic['controlFkConSpace'].keys():
localKey = util.fullPathName2Local(key)
baseName = localKey[1]
part = baseName.split('_')[0]
for initNode in self.filterGroupNodeDic['init']:
localName = util.fullPathName2Local(initNode)
if localName[1].rfind(part) != -1:
addOpNode = util.createOpNode(self.moduleNameSpace,
'plusMinusAverage',
'add_fk_op_' + part)
if part != 'meta':
cmds.connectAttr(initNode + '.rotate',
addOpNode + '.input3D[0]',
f=True)
cmds.connectAttr(addFkConNode + '.curl',
addOpNode + '.input3D[1]',
f=True)
if part == "meta":
multOpNode = util.createOpNode(
self.moduleNameSpace, 'multiplyDivide',
'add_fk_mult_op_' + part)
cmds.setAttr(multOpNode + '.operation', 1)
cmds.setAttr(multOpNode + '.input2X',
self._params[2]['value'])
cmds.setAttr(multOpNode + '.input2Y',
self._params[2]['value'])
cmds.setAttr(multOpNode + '.input2Z',
self._params[2]['value'])
cmds.connectAttr(addOpNode + '.output3D',
multOpNode + '.input1',
f=True)
cmds.connectAttr(multOpNode + '.output',
key + '.rotate',
f=True)
else:
util.transformChannelBinding(initNode, key, 2)
util.transformChannelBinding(initNode, key, 4)
cmds.connectAttr(addOpNode + '.output3D',
key + '.rotate',
f=True)
fkConNodes = []
for key in self.filterGroupNodeDic['controlFkConSpace'].keys():
child = cmds.listRelatives(key, c=1, s=0, f=1, typ='transform')[0]
fkConNodes.append(child)
for fkConNode in fkConNodes:
localKey = util.fullPathName2Local(fkConNode)
baseName = localKey[1]
if baseName == 'fk_Con':
for node in self.filterGroupNodeDic['outputNode']:
localNode = util.fullPathName2Local(node)
baseName2 = localNode[1]
part = baseName2.split('_')[0]
part2 = baseName2.split('_')[-1]
if part == 'meta' and part2 != 'space':
util.transformChannelBinding(fkConNode, node)
else:
for node in self.filterGroupNodeDic['outputNode']:
localNode = util.fullPathName2Local(node)
baseName2 = localNode[1]
part = baseName2.split('_')[0]
localFkCon = util.fullPathName2Local(fkConNode)
if part in localFkCon[1]:
if baseName2.rfind('space') != -1:
continue
matrixOp = util.localMatrixOp(self.moduleNameSpace,
part)
spaceNode = self.filterGroupNodeDic['outputNode'][
node]['parent']
cmds.connectAttr(fkConNode + '.worldMatrix',
matrixOp[0] + '.matrixIn[0]',
f=True)
cmds.connectAttr(spaceNode + '.worldInverseMatrix',
matrixOp[0] + '.matrixIn[1]',
f=True)
cmds.connectAttr(matrixOp[1] + '.outputTranslate',
node + '.translate',
f=True)
cmds.connectAttr(matrixOp[1] + '.outputRotate',
node + '.rotate',
f=True)
cmds.connectAttr(matrixOp[1] + '.outputScale',
node + '.scale',
f=True)
cmds.connectAttr(matrixOp[1] + '.outputShear',
node + '.shear',
f=True)
def applyMotionNodeConnections(self):
for key in self.filterGroupNodeDic['outputChildPlug'].keys():
sourceNode = key.replace("motion_output", "motion_input").replace(
"output", "input")
util.transformChannelBinding(sourceNode, key)
for key in self.filterGroupNodeDic['controlChildPlug'].keys():
sourceNode = key.replace("motion_control", "motion_input").replace(
"control", "input")
util.transformChannelBinding(sourceNode, key)
for key in self.filterGroupNodeDic['controlFkCon'].keys():
keyLocal = util.fullPathName2Local(key)
if keyLocal[1].rfind('space') == -1:
outputNodes = {}
nodeStrLocal = keyLocal[1].replace("fk_Con", "node")
util.getChildrenNodes(self.modulePathDic['output'],
nodeStrLocal, outputNodes, 1)
for node in outputNodes:
if node.split('|')[-1].rfind('space') != -1 or node.split(
'|')[-1].rfind('socket') != -1:
continue
else:
if keyLocal[1].rfind('hand_roll') != -1:
util.transformChannelBinding(key, node, 3)
else:
util.transformChannelBinding(key, node)
hand_piv_con_op = util.createOpNode(self.moduleNameSpace,
'plusMinusAverage',
'hand_piv_con_add_op')
for key in self.filterGroupNodeDic['controlPlacement']:
keyLocal = util.fullPathName2Local(key)
if keyLocal[1].rfind('piv') != -1:
cmds.connectAttr(key + '.translate',
hand_piv_con_op + '.input3D[0]',
f=True)
for key in self.filterGroupNodeDic['controlFkCon']:
keyLocal = util.fullPathName2Local(key)
if keyLocal[1].rfind('piv') != -1 and keyLocal[1].rfind(
'space') == -1:
cmds.connectAttr(key + '.translate',
hand_piv_con_op + '.input3D[1]',
f=True)
rollFkConNode = ''
for key in self.filterGroupNodeDic['controlFkCon']:
keyLocal = util.fullPathName2Local(key)
if keyLocal[1].rfind('roll') != -1 and keyLocal[1].rfind(
'space') == -1:
rollFkConNode = key
cmds.connectAttr(hand_piv_con_op + '.output3D',
key + '.rotatePivot',
f=True)
hand_piv_node_op = util.createOpNode(self.moduleNameSpace,
'plusMinusAverage',
'hand_piv_node_add_op')
for key in self.filterGroupNodeDic['outputPlacement']:
keyLocal = util.fullPathName2Local(key)
if keyLocal[1].rfind('piv') != -1:
cmds.connectAttr(key + '.translate',
hand_piv_node_op + '.input3D[0]',
f=True)
for key in self.filterGroupNodeDic['outputNode']:
keyLocal = util.fullPathName2Local(key)
if keyLocal[1].rfind('piv') != -1:
cmds.connectAttr(key + '.translate',
hand_piv_node_op + '.input3D[1]',
f=True)
for key in self.filterGroupNodeDic['outputNode']:
keyLocal = util.fullPathName2Local(key)
if keyLocal[1].rfind('roll') != -1 and keyLocal[1].rfind(
'space') == -1 and keyLocal[1].rfind('socket') == -1:
cmds.connectAttr(hand_piv_node_op + '.output3D',
key + '.rotatePivot',
f=True)
elif keyLocal[1].rfind('roll') != -1 and keyLocal[1].rfind(
'space') != -1:
cmds.connectAttr(rollFkConNode + '.translate',
key + '.translate',
f=True)
def applyMotionNodeConnections(self):
spaceListGroup = [self.filterGroupNodeDic['fkSpace'], self.filterGroupNodeDic['ikSpace'], self.filterGroupNodeDic['outputSpace'], self.filterGroupNodeDic['controlFkSpace'], self.filterGroupNodeDic['controlIkSpace']]
for node in self.filterGroupNodeDic['inputChildPlug'].iterkeys():
nodeLocal = util.fullPathName2Local(node)
if nodeLocal[1].rfind('upleg') != -1:
for spaceList in spaceListGroup:
for spaceNode in spaceList:
spaceNodeLocal = util.fullPathName2Local(spaceNode)
if spaceNodeLocal[1].rfind('upleg') != -1:
util.transformChannelBinding(node, spaceNode)
elif nodeLocal[1].rfind('ball_twist') != -1:
for controlIkSpace in self.filterGroupNodeDic['controlIkSpace']:
controlIkSpaceLocal = util.fullPathName2Local(controlIkSpace)
if controlIkSpaceLocal[1].rfind('Pole_Rot') != -1:
cmds.orientConstraint(node, controlIkSpace)
elif nodeLocal[1].rfind('foot_offset') != -1:
footOffsetPlug = node
ballJntOffsetPlug = ''
tipJntOffsetPlug = ''
uplegIkSpace = ''
footIkSpace = ''
ballIkSpaceLocal = ''
tipIkSpaceLocal = ''
controlIKSpaceLocalNodes = []
for controlIkSpace in self.filterGroupNodeDic['controlIkSpace']:
controlIkSpaceLocal = util.fullPathName2Local(controlIkSpace)
if controlIkSpaceLocal[1].rfind('space_local') != -1:
controlIKSpaceLocalNodes.append(controlIkSpace)
for spaceLocalNode in controlIKSpaceLocalNodes:
spaceLocalNodeBaseStr = util.fullPathName2Local(spaceLocalNode)
if spaceLocalNodeBaseStr[1].rfind('ball') != -1:
ballIkSpaceLocal = spaceLocalNode
elif spaceLocalNodeBaseStr[1].rfind('tip') != -1:
tipIkSpaceLocal = spaceLocalNode
for plugNode in self.filterGroupNodeDic['inputChildPlug'].iterkeys():
plugNodeLocal = util.fullPathName2Local(plugNode)
if plugNodeLocal[1].rfind('ball_jnt') != -1:
ballJntOffsetPlug = plugNode
elif plugNodeLocal[1].rfind('tip_jnt') != -1:
tipJntOffsetPlug = plugNode
for controlIkSpace in self.filterGroupNodeDic['controlIkSpace']:
controlIkSpaceLocalStr = util.fullPathName2Local(controlIkSpace)
if controlIkSpaceLocalStr[1].rfind('upleg_con_ik') != -1:
uplegIkSpace = controlIkSpace
elif controlIkSpaceLocalStr[1].rfind('foot_con_ik') != -1 and controlIkSpaceLocalStr[1].rfind('local') == -1:
footIkSpace = controlIkSpace
matrixOps = util.localMatrixOp(self.moduleNameSpace, 'foot_Ik_Con_space')
cmds.connectAttr(uplegIkSpace+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(footOffsetPlug+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], footIkSpace)
matrixOps = util.localMatrixOp(self.moduleNameSpace, 'ball_ik_Con_space')
cmds.connectAttr(footOffsetPlug+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(ballJntOffsetPlug+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], ballIkSpaceLocal)
matrixOps = util.localMatrixOp(self.moduleNameSpace, 'tip_Ik_Con_space')
cmds.connectAttr(footOffsetPlug+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(tipJntOffsetPlug+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], tipIkSpaceLocal)
for controlFkCon in self.filterGroupNodeDic['controlFkCon']:
controlFkConLocal = util.fullPathName2Local(controlFkCon)
matchStr = controlFkConLocal[1].replace('_fk_Con', 'Jnt_fk')
for fkJntNode in self.filterGroupNodeDic['fkJnt']:
fkJntNodeLocal = util.fullPathName2Local(fkJntNode)
if fkJntNodeLocal[1] == matchStr:
cmds.connectAttr(controlFkCon+'.rotate', fkJntNode+'.rotate', f=True)
filterDic = {'foot':'ball', 'ball':'tip'}
sourceNode = ''
targetNode = ''
targetUpNode = ''
for key, value in filterDic.iteritems():
for ikJnt in self.filterGroupNodeDic['ikJnt']:
ikJntLocal = util.fullPathName2Local(ikJnt)
if ikJntLocal[1].rfind(key) != -1:
sourceNode = ikJnt
for controlRef in self.filterGroupNodeDic['controlRef']:
controlRefLocal = util.fullPathName2Local(controlRef)
if controlRefLocal[1].rfind(value) != -1:
if controlRefLocal[1].rfind('Handle') != -1:
targetNode = controlRef
elif controlRefLocal[1].rfind('Pole') != -1:
targetUpNode = controlRef
cmds.aimConstraint(targetNode, sourceNode, aim = [1,0,0], u= [0,1,0], wut='object', wuo=targetUpNode)
for spaceIkNode in self.filterGroupNodeDic['ikSpace']:
spaceIkNodeLocal = util.fullPathName2Local(spaceIkNode)
if spaceIkNodeLocal[1].rfind('soft') != -1:
sourceNode = spaceIkNode
for controlIkNode in self.filterGroupNodeDic['controlIkCon']:
controlIkNodeLocal = util.fullPathName2Local(controlIkNode)
if controlIkNodeLocal[1].rfind('foot') != -1 and controlIkNodeLocal[1].rfind('local') != -1:
targetNode = controlIkNode
elif controlIkNodeLocal[1].rfind('leg') != -1 and controlIkNodeLocal[1].rfind('Pole') != -1:
targetUpNode = controlIkNode
cmds.aimConstraint(targetNode, sourceNode, aim = [1,0,0], u= [0,1,0], wut='object', wuo=targetUpNode)
for blendNode in self.filterGroupNodeDic['outputBlend']:
blendNodeLocal = util.fullPathName2Local(blendNode)
blendNodeLocalPrefix = blendNodeLocal[1].split('_')[0]
blendNodeOp = util.createOpNode(self.moduleNameSpace, 'blendColors', blendNodeLocalPrefix+'_blend_op')
cmds.connectAttr(self.filterGroupNodeDic['fk2ikCon'].keys()[0]+'.fk2ik', blendNodeOp+'.blender', f=True)
for ikJntNode in self.filterGroupNodeDic['ikJnt']:
ikJntNodeLocal = util.fullPathName2Local(ikJntNode)
if blendNodeLocalPrefix+'_ik' == ikJntNodeLocal[1]:
cmds.connectAttr(ikJntNode+'.rotate', blendNodeOp+'.color1', f=True)
for fkJntNode in self.filterGroupNodeDic['fkJnt']:
fkJntNodeLocal = util.fullPathName2Local(fkJntNode)
if blendNodeLocalPrefix+'_fk' == fkJntNodeLocal[1]:
cmds.connectAttr(fkJntNode+'.rotate', blendNodeOp+'.color2', f=True)
cmds.connectAttr(blendNodeOp+'.output', blendNode+'.rotate', f=True)
ikConDisplayOp = util.createOpNode(self.moduleNameSpace, 'condition', 'ik_con_display_op')
cmds.setAttr(ikConDisplayOp+'.operation', 0)
cmds.setAttr(ikConDisplayOp+'.secondTerm', 1)
cmds.setAttr(ikConDisplayOp+'.colorIfTrueR', 1)
cmds.setAttr(ikConDisplayOp+'.colorIfFalseR', 0)
fkConDisplayOp = util.createOpNode(self.moduleNameSpace, 'condition', 'fk_con_display_op')
cmds.setAttr(fkConDisplayOp+'.operation', 0)
cmds.setAttr(fkConDisplayOp+'.secondTerm', 0)
cmds.setAttr(fkConDisplayOp+'.colorIfTrueR', 1)
cmds.setAttr(fkConDisplayOp+'.colorIfFalseR', 0)
cmds.connectAttr(self.filterGroupNodeDic['fk2ikCon'].keys()[0]+'.controlDisplay', ikConDisplayOp+'.firstTerm', f=True)
cmds.connectAttr(self.filterGroupNodeDic['fk2ikCon'].keys()[0]+'.controlDisplay', fkConDisplayOp+'.firstTerm', f=True)
for blendNode in self.filterGroupNodeDic['outputBlend']:
blendNodeLocal = util.fullPathName2Local(blendNode)
if blendNodeLocal[1].rfind('upleg') != -1:
cmds.connectAttr(blendNode+'.rotate', self.filterGroupNodeDic['fk2ikSpace'].keys()[0]+'.rotate', f=True)
placementList = ['Fk', 'Ik']
for typeStr in placementList:
for placementNode in self.filterGroupNodeDic['control'+typeStr+'Placement'].iterkeys():
placementNodeLocal = util.fullPathName2Local(placementNode)
if placementNodeLocal[1].rfind('upleg') != -1 and placementNodeLocal[1].rfind('fk2ik') == -1:
if typeStr == placementList[0]:
cmds.connectAttr(fkConDisplayOp+'.outColorR', placementNode+'.visibility', f=True)
else:
cmds.connectAttr(ikConDisplayOp+'.outColorR', placementNode+'.visibility', f=True)
legPoleAutoAssetPath = self.pathInfo.assetDirPath + 'poleVectorPosAutoOpAsset' + '.' + self.file_extenstion_str
legPoleAutoOpNode = ''
legPoleAutoOpNodeNew = ''
fileCheck = cmds.file( legPoleAutoAssetPath, query=True, exists=True )
if fileCheck:
cmds.file( legPoleAutoAssetPath, i=True, mergeNamespacesOnClash=True )
containerNodes = cmds.ls(type='container', l=True)
if containerNodes != None:
for containerNode in containerNodes:
localStr = containerNode.split(':')[-1]
if localStr == 'poleVectorPosAutoOp':
legPoleAutoOpNode = containerNode
if cmds.objExists(legPoleAutoOpNode):
legPoleAutoOpNodeNew = cmds.rename(legPoleAutoOpNode, legPoleAutoOpNode + '_' + self.component_val)
uplegIkMotion = ''
legPoleAuto = ''
legPoleSideAuto = ''
legPoleFntAuto = ''
footIkConLocal = ''
uplegIkMotionStr = ''
legPoleAutoStr = ''
legPoleSideAutoStr = ''
legPoleFntAutoStr = ''
footIkConLocalStr = ''
for conPoleAutoNode in self.filterGroupNodeDic['controlPoleAuto']:
conPoleAutoNodeLocal = util.fullPathName2Local(conPoleAutoNode)
if conPoleAutoNodeLocal[1].rfind('Pole_Auto') != -1:
legPoleAuto = conPoleAutoNode
legPoleAutoStr = conPoleAutoNodeLocal[1]
elif conPoleAutoNodeLocal[1].rfind('Side') != -1:
legPoleSideAuto = conPoleAutoNode
legPoleSideAutoStr = conPoleAutoNodeLocal[1]
elif conPoleAutoNodeLocal[1].rfind('Fnt') != -1:
legPoleFntAuto = conPoleAutoNode
legPoleFntAutoStr = conPoleAutoNodeLocal[1]
for motinoIkSpaceNode in self.filterGroupNodeDic['ikSpace']:
motinoIkSpaceNodeLocal = util.fullPathName2Local(motinoIkSpaceNode)
if motinoIkSpaceNodeLocal[1].rfind('upleg') != -1:
uplegIkMotion = motinoIkSpaceNode
uplegIkMotionStr = motinoIkSpaceNodeLocal[1]
for conIkNode in self.filterGroupNodeDic['controlIkCon']:
conIkNodeLocal = util.fullPathName2Local(conIkNode)
if conIkNodeLocal[1] == 'foot_ik_Con_local':
footIkConLocal = conIkNode
footIkConLocalStr = conIkNodeLocal[1]
uplegIkMotionDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', uplegIkMotionStr+'_decomp')
footIkConLocalDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', footIkConLocalStr+'_decomp')
legPoleSideAutoDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', legPoleSideAutoStr+'_decomp')
cmds.connectAttr(uplegIkMotion+'.worldMatrix', uplegIkMotionDecompOp +'.inputMatrix', f=True)
cmds.connectAttr(footIkConLocal+'.worldMatrix', footIkConLocalDecompOp +'.inputMatrix', f=True)
cmds.connectAttr(legPoleSideAuto+'.worldMatrix', legPoleSideAutoDecompOp +'.inputMatrix', f=True)
cmds.connectAttr(uplegIkMotionDecompOp+'.outputTranslate', legPoleAutoOpNodeNew +'.Input_ikSpaceWorldPos', f=True)
cmds.connectAttr(footIkConLocalDecompOp+'.outputTranslate', legPoleAutoOpNodeNew +'.Input_conSpaceWorldPos', f=True)
cmds.connectAttr(legPoleSideAutoDecompOp+'.outputTranslate', legPoleAutoOpNodeNew +'.Input_ikSideWorldPos', f=True)
legPoleSideAutoCompOp = util.createOpNode(self.moduleNameSpace, 'composeMatrix', legPoleSideAutoStr+'_comp')
cmds.connectAttr(legPoleAutoOpNodeNew+'.Output_poleVectorWorldPos', legPoleSideAutoCompOp +'.inputTranslate', f=True)
matrixOps = util.localMatrixOp(self.moduleNameSpace, legPoleSideAutoStr+'_comp')
cmds.connectAttr(legPoleAuto+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(legPoleSideAutoCompOp +'.outputMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], legPoleFntAuto, option=2)
for conIkSpaceNode in self.filterGroupNodeDic['controlIkSpace']:
conIkSpaceNodeLocal = util.fullPathName2Local(conIkSpaceNode)
if conIkSpaceNodeLocal[1].rfind('Pole_Pos') != -1:
cmds.pointConstraint(legPoleFntAuto, conIkSpaceNode)
legFk2IkConNode = self.filterGroupNodeDic['fk2ikCon'].keys()[0]
if self._side == 'L':
legFk2IkConShapeNode = cmds.listRelatives(legFk2IkConNode, shapes=True, f=True)[0]
spanNums = cmds.getAttr(legFk2IkConShapeNode+'.spans')
spanNums = spanNums + 1
for i in range(0, spanNums):
originalPos = cmds.getAttr(legFk2IkConShapeNode+".controlPoints["+ str(i)+"].zValue")
cmds.setAttr(legFk2IkConShapeNode+".controlPoints["+ str(i)+"].zValue", originalPos * -1)
def applyInitNodeConnections(self):
initNodeFullName = cmds.ls(self.modulePathDic['init'], l=True)[0]
initNodeParents = []
placementNodesList = [self.filterGroupNodeDic['inputPlacement'], self.filterGroupNodeDic['fkPlacement'], self.filterGroupNodeDic['ikPlacement'], self.filterGroupNodeDic['outputPlacement'], self.filterGroupNodeDic['controlPlacement']]
uplegInitFull = ''
for initNode, parentNode in self.filterGroupNodeDic['init'].iteritems():
initLocalNode = util.fullPathName2Local(initNode)
matchStr = initLocalNode[1].replace('init', '')
for placementNodes in placementNodesList:
for placementNode in placementNodes:
placementLocalNode = util.fullPathName2Local(placementNode)
if placementLocalNode[1].rfind(matchStr) != -1:
util.transformChannelBinding(initNode, placementNode)
uplegInitFull = ''
lolegInitFull = ''
footInitFull = ''
ballInitFull = ''
tipInitFull = ''
spaceInitFull = ''
controlInitFull = ''
for initNode, parentNode in self.filterGroupNodeDic['init'].iteritems():
initLocalNode = util.fullPathName2Local(initNode)
partStr = initLocalNode[1].replace('_init', '')
if initLocalNode[1].rfind('upleg') != -1:
uplegInitFull = initNode
elif initLocalNode[1].rfind('loleg') != -1:
lolegInitFull = initNode
elif initLocalNode[1].rfind('foot') != -1:
footInitFull = initNode
elif initLocalNode[1].rfind('ball') != -1:
ballInitFull = initNode
elif initLocalNode[1].rfind('tip') != -1:
tipInitFull = initNode
elif initLocalNode[1].rfind('space') != -1:
spaceInitFull = initNode
elif initLocalNode[1].rfind('control') != -1:
controlInitFull = initNode
jointListGroup = [self.filterGroupNodeDic['fkJnt'], self.filterGroupNodeDic['ikJnt'], self.filterGroupNodeDic['outputBlend']]
for initNode, parentNode in self.filterGroupNodeDic['init'].iteritems():
initLocalNode = util.fullPathName2Local(initNode)
partStr = initLocalNode[1].replace('_init', '')
if initLocalNode[1].rfind('loleg') != -1:
for controlFkSpace in self.filterGroupNodeDic['controlFkSpace']:
controlLocalFkSpace = util.fullPathName2Local(controlFkSpace)
if controlLocalFkSpace[1].rfind('loleg') != -1:
matrixOps = util.localMatrixOp(self.moduleNameSpace, 'loleg_init')
cmds.connectAttr(uplegInitFull+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(initNode+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], controlFkSpace)
for jointList in jointListGroup:
for jnt in jointList:
jntLocal = util.fullPathName2Local(jnt)
if jntLocal[1].rfind('loleg') != -1:
cmds.connectAttr(matrixOps[1]+'.outputTranslate', jnt+'.translate')
cmds.connectAttr(matrixOps[1]+'.outputRotate', jnt+'.jointOrient')
elif initLocalNode[1].rfind('foot') != -1:
for controlFkSpace in self.filterGroupNodeDic['controlFkSpace']:
controlLocalFkSpace = util.fullPathName2Local(controlFkSpace)
if controlLocalFkSpace[1].rfind('foot') != -1:
matrixOps = util.localMatrixOp(self.moduleNameSpace, 'foot_init')
cmds.connectAttr(lolegInitFull+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(initNode+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], controlFkSpace)
for jointList in jointListGroup:
for jnt in jointList:
jntLocal = util.fullPathName2Local(jnt)
if jntLocal[1].rfind('foot') != -1:
cmds.connectAttr(matrixOps[1]+'.outputTranslate', jnt+'.translate')
cmds.connectAttr(matrixOps[1]+'.outputRotate', jnt+'.jointOrient')
elif initLocalNode[1].rfind('ball') != -1:
for controlFkSpace in self.filterGroupNodeDic['controlFkSpace']:
controlLocalFkSpace = util.fullPathName2Local(controlFkSpace)
if controlLocalFkSpace[1].rfind('ball') != -1:
matrixOps = util.localMatrixOp(self.moduleNameSpace, 'ball_init')
cmds.connectAttr(footInitFull+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(initNode+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], controlFkSpace)
for jointList in jointListGroup:
for jnt in jointList:
jntLocal = util.fullPathName2Local(jnt)
if jntLocal[1].rfind('ball') != -1:
cmds.connectAttr(matrixOps[1]+'.outputTranslate', jnt+'.translate')
cmds.connectAttr(matrixOps[1]+'.outputRotate', jnt+'.jointOrient')
elif initLocalNode[1].rfind('tip') != -1:
for controlFkSpace in self.filterGroupNodeDic['controlFkSpace']:
controlLocalFkSpace = util.fullPathName2Local(controlFkSpace)
if controlLocalFkSpace[1].rfind('tip') != -1:
matrixOps = util.localMatrixOp(self.moduleNameSpace, 'ball_init')
cmds.connectAttr(ballInitFull+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(initNode+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], controlFkSpace)
for jointList in jointListGroup:
for jnt in jointList:
jntLocal = util.fullPathName2Local(jnt)
if jntLocal[1].rfind('tip') != -1:
cmds.connectAttr(matrixOps[1]+'.outputTranslate', jnt+'.translate')
cmds.connectAttr(matrixOps[1]+'.outputRotate', jnt+'.jointOrient')
for fkSpaceNode in self.filterGroupNodeDic['fkSpace']:
fkSpaceLocalNode = util.fullPathName2Local(fkSpaceNode)
if fkSpaceLocalNode[1].rfind('foot') != -1:
matrixOps = util.localMatrixOp(self.moduleNameSpace, 'foot_init')
cmds.connectAttr(lolegInitFull+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(footInitFull+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], fkSpaceNode)
# soft IK OP
upleg2lolegDistanceOp = util.createOpNode(self.moduleNameSpace, 'distanceBetween', 'upleg2loleg_distasnce')
loleg2footDistanceOp = util.createOpNode(self.moduleNameSpace, 'distanceBetween', 'loleg2foot_distasnce')
legDistanceOp = util.createOpNode(self.moduleNameSpace, 'plusMinusAverage', 'leg_distance_sum')
cmds.connectAttr(uplegInitFull+'.worldMatrix', upleg2lolegDistanceOp+'.inMatrix1', f=True)
cmds.connectAttr(lolegInitFull+'.worldMatrix', upleg2lolegDistanceOp+'.inMatrix2', f=True)
cmds.connectAttr(lolegInitFull+'.worldMatrix', loleg2footDistanceOp+'.inMatrix1', f=True)
cmds.connectAttr(footInitFull+'.worldMatrix', loleg2footDistanceOp+'.inMatrix2', f=True)
cmds.connectAttr(upleg2lolegDistanceOp+'.distance', legDistanceOp+'.input1D[0]', f=True)
cmds.connectAttr(loleg2footDistanceOp+'.distance', legDistanceOp+'.input1D[1]', f=True)
softIkAssetPath = self.pathInfo.assetDirPath + 'softIkOpAsset' + '.' + self.file_extenstion_str
softIkOpNode = ''
softIkOpNodeNew = ''
fileCheck = cmds.file( softIkAssetPath, query=True, exists=True )
if fileCheck:
cmds.file( softIkAssetPath, i=True, mergeNamespacesOnClash=True )
containerNodes = cmds.ls(type='container', l=True)
if containerNodes != None:
for containerNode in containerNodes:
localStr = containerNode.split(':')[-1]
if localStr == 'softIKOp':
softIkOpNode = containerNode
if cmds.objExists(softIkOpNode):
softIkOpNodeNew = cmds.rename(softIkOpNode, softIkOpNode + '_' + self.component_val)
cmds.connectAttr(legDistanceOp+'.output1D', softIkOpNodeNew+'.In_initLength', f=True)
softIkNode = ''
for ikSoftNode in self.filterGroupNodeDic['ikSoft']:
ikSoftNodeLocal = util.fullPathName2Local(ikSoftNode)
if ikSoftNodeLocal[1].rfind('space') == -1:
softIkNode = ikSoftNode
cmds.connectAttr(softIkOpNodeNew+'.Out_softDistance', softIkNode +'.translateX', f=True)
legIkSpaceNode = ''
for ikSpaceNode in self.filterGroupNodeDic['ikSpace']:
ikSpaceLocalNode = util.fullPathName2Local(ikSpaceNode)
if ikSpaceLocalNode[1].rfind('leg') != -1 and ikSpaceLocalNode[1].rfind('soft') == -1:
legIkSpaceNode = ikSpaceNode
footikConLocalNode = ''
footikConNode = ''
for ikConNode in self.filterGroupNodeDic['controlIkCon']:
ikConLocalNode = util.fullPathName2Local(ikConNode)
if ikConLocalNode[1].rfind('foot') != -1:
if ikConLocalNode[1].rfind('local') != -1:
footikConLocalNode = ikConNode
else:
footikConNode = ikConNode
ikControlDistanceOp = util.createOpNode(self.moduleNameSpace, 'distanceBetween', 'ik_control_distasnce')
cmds.connectAttr(legIkSpaceNode+'.worldMatrix', ikControlDistanceOp+'.inMatrix1', f=True)
cmds.connectAttr(footikConLocalNode+'.worldMatrix', ikControlDistanceOp+'.inMatrix2', f=True)
cmds.connectAttr(ikControlDistanceOp+'.distance', softIkOpNodeNew+'.In_motionLength', f=True)
cmds.connectAttr(footikConNode+'.softIK', softIkOpNodeNew+'.In_softWeight', f=True)
for initNode, parentNode in self.filterGroupNodeDic['init'].iteritems():
initNodeLocal = util.fullPathName2Local(initNode)
partStr = initNodeLocal[1].replace('_init', '')
if partStr in ['foot', 'ball', 'tip']:
for ikSpace in self.filterGroupNodeDic['ikSpace']:
ikLocalSpace = util.fullPathName2Local(ikSpace)
if ikLocalSpace[1].rfind(partStr) != -1:
matrixOps = util.localMatrixOp(self.moduleNameSpace, partStr+'_init')
cmds.connectAttr(uplegInitFull+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(initNode+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
util.decompChannelBinding(matrixOps[1], ikSpace)
uplegInitDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', 'upleg_init_decomp')
cmds.connectAttr(uplegInitFull+'.worldMatrix', uplegInitDecompOp+'.inputMatrix')
lolegInitDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', 'loleg_init_decomp')
cmds.connectAttr(lolegInitFull+'.worldMatrix', lolegInitDecompOp+'.inputMatrix')
footInitDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', 'foot_init_decomp')
cmds.connectAttr(footInitFull+'.worldMatrix', footInitDecompOp+'.inputMatrix')
footVecOp = util.createOpNode(self.moduleNameSpace, 'plusMinusAverage', 'footVec')
cmds.setAttr(footVecOp+'.operation',2)
cmds.connectAttr(uplegInitDecompOp+'.outputTranslate', footVecOp+'.input3D[0]')
cmds.connectAttr(footInitDecompOp+'.outputTranslate', footVecOp+'.input3D[1]')
#cmds.connectAttr(footInitDecompOp+'.outputTranslate', +'.translate')
footVecMagOp = util.createOpNode(self.moduleNameSpace, 'distanceBetween', 'footVecMag')
cmds.connectAttr(uplegInitDecompOp+'.outputTranslate', footVecMagOp+'.point1')
cmds.connectAttr(footInitDecompOp+'.outputTranslate', footVecMagOp+'.point2')
footVecUnitOp = util.createOpNode(self.moduleNameSpace, 'multiplyDivide', 'footVecUnit')
cmds.setAttr(footVecUnitOp+'.operation',2)
cmds.connectAttr(footVecOp+'.output3D', footVecUnitOp+'.input1')
cmds.connectAttr(footVecMagOp+'.distance', footVecUnitOp+'.input2X')
cmds.connectAttr(footVecMagOp+'.distance', footVecUnitOp+'.input2Y')
cmds.connectAttr(footVecMagOp+'.distance', footVecUnitOp+'.input2Z')
lolegVecOp = util.createOpNode(self.moduleNameSpace, 'plusMinusAverage', 'lolegVec')
cmds.setAttr(lolegVecOp+'.operation',2)
cmds.connectAttr(lolegInitDecompOp+'.outputTranslate', lolegVecOp+'.input3D[0]')
cmds.connectAttr(footInitDecompOp+'.outputTranslate', lolegVecOp+'.input3D[1]')
lolegVecMagOp = util.createOpNode(self.moduleNameSpace, 'distanceBetween', 'lolegVecMag')
cmds.connectAttr(lolegInitDecompOp+'.outputTranslate', lolegVecMagOp+'.point1')
cmds.connectAttr(footInitDecompOp+'.outputTranslate', lolegVecMagOp+'.point2')
lolegVecUnitOp = util.createOpNode(self.moduleNameSpace, 'multiplyDivide', 'lolegVecUnit')
cmds.setAttr(lolegVecUnitOp+'.operation',2)
cmds.connectAttr(lolegVecOp+'.output3D', lolegVecUnitOp+'.input1')
cmds.connectAttr(lolegVecMagOp+'.distance', lolegVecUnitOp+'.input2X')
cmds.connectAttr(lolegVecMagOp+'.distance', lolegVecUnitOp+'.input2Y')
cmds.connectAttr(lolegVecMagOp+'.distance', lolegVecUnitOp+'.input2Z')
poleSideVecOp = util.createOpNode(self.moduleNameSpace, 'vectorProduct', 'poleSideVec')
cmds.setAttr(poleSideVecOp+'.normalizeOutput', 1)
cmds.setAttr(poleSideVecOp+'.operation',2)
cmds.connectAttr(footVecUnitOp+'.output', poleSideVecOp+'.input1')
cmds.connectAttr(lolegVecUnitOp+'.output', poleSideVecOp+'.input2')
poleFntVecOp = util.createOpNode(self.moduleNameSpace, 'vectorProduct', 'poleFntVec')
cmds.setAttr(poleFntVecOp+'.normalizeOutput', 1)
cmds.setAttr(poleFntVecOp+'.operation',2)
cmds.connectAttr(poleSideVecOp+'.output', poleFntVecOp+'.input1')
cmds.connectAttr(footVecUnitOp+'.output', poleFntVecOp+'.input2')
poleMatOp = util.createOpNode(self.moduleNameSpace, 'fourByFourMatrix', 'poleMat')
# X axis
cmds.connectAttr(poleSideVecOp+'.outputX', poleMatOp+'.in00')
cmds.connectAttr(poleSideVecOp+'.outputY', poleMatOp+'.in01')
cmds.connectAttr(poleSideVecOp+'.outputZ', poleMatOp+'.in02')
# Y axis
cmds.connectAttr(footVecUnitOp+'.outputX', poleMatOp+'.in10')
cmds.connectAttr(footVecUnitOp+'.outputY', poleMatOp+'.in11')
cmds.connectAttr(footVecUnitOp+'.outputZ', poleMatOp+'.in12')
# Z axis
cmds.connectAttr(poleFntVecOp+'.outputX', poleMatOp+'.in20')
cmds.connectAttr(poleFntVecOp+'.outputY', poleMatOp+'.in21')
cmds.connectAttr(poleFntVecOp+'.outputZ', poleMatOp+'.in22')
# translate
cmds.connectAttr(footInitDecompOp+'.outputTranslateX', poleMatOp+'.in30')
cmds.connectAttr(footInitDecompOp+'.outputTranslateY', poleMatOp+'.in31')
cmds.connectAttr(footInitDecompOp+'.outputTranslateZ', poleMatOp+'.in32')
# decomp
poleMatDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', 'poleMat_decomp')
cmds.connectAttr(poleMatOp+'.output', poleMatDecompOp+'.inputMatrix')
cmds.connectAttr(poleMatDecompOp+'.outputTranslate', spaceInitFull+'.translate')
cmds.connectAttr(poleMatDecompOp+'.outputRotate', spaceInitFull+'.rotate')
matrixOps = util.localMatrixOp(self.moduleNameSpace, 'space_init')
cmds.connectAttr(controlInitFull+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True)
cmds.connectAttr(spaceInitFull+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True)
for controlPoleNode in self.filterGroupNodeDic['controlPoleAuto']:
controlPoleNodeLocal = util.fullPathName2Local(controlPoleNode)
if controlPoleNodeLocal[1].rfind('Pole_Auto') != -1:
util.decompChannelBinding(matrixOps[1], controlPoleNode)
return
