def fromList(self,posList = [],orientList = [],autoOrient = 1): for i in range(len(posList)): tempName = nameUtils.getUniqueName(self.side,self.baseName,self.type) if i == len(posList) - 1: tempName = nameUtils.getUniqueName(self.side,self.baseName,self.type) pm.select(cl = 1) if autoOrient == 1: tempJnt = pm.joint(n = tempName,position = posList[i]) else : tempJnt = pm.joint(n = tempName,position = posList[i],orientation = orientList[i]) self.chain.append(tempJnt) self.__parentJoints() if autoOrient == 1: #pm.joint(self.chain[0].name(),e = 1,oj = 'yzx',secondaryAxisOrient = 'zup',ch = 1) pm.joint(self.chain[0].name(),e = 1,oj = 'xyz',secondaryAxisOrient = 'zdown',ch = 1) #xzy -secondaryAxisOrient ydown -ch -zso; self.__zeroOrientJoint(self.chain[-1])
def buildGuides(self): #group self.fkGuides = [] #build curve self.guideCc = pm.curve(d = 3,p = [[0,9.040668,0.0623416],[0,10.507795,0.181759],[0,11.991982,0.164699], [0,13.322632,-0.108255],[0,14.397388,-0.0570757]],k = [0,0,0,1,2,2,2], n = nameUtils.getUniqueName(self.side,self.baseName + '_cc','gud')) curveInfo = pm.createNode('curveInfo',n = nameUtils.getUniqueName(self.side,self.baseName + '_cc','cvINFO')) self.guideCc.getShape().worldSpace.connect(curveInfo.inputCurve) self.length = curveInfo.arcLength.get() control.lockAndHideAttr(self.guideCc,['tx','ty','tz','rx','ry','rz','sx','sy','sz','v'])
def blendTwoChains(chain1,chain2,resChain,attrHolder,attrName,baseName,side): blnTArray = [] blnRArray = [] blnSArray = [] data = {'blendTranslate':blnTArray, 'blendRotate':blnRArray, 'blendScale':blnSArray } if attrHolder.hasAttr(attrName) == 0: attrHolder.addAttr(attrName,at = 'float',min = 0,max = 1,dv = 0,k = 1) for i,b in enumerate(resChain): blnT = nameUtils.getUniqueName(side,baseName + 'Tra','BCN') blnR = nameUtils.getUniqueName(side,baseName + 'Rot','BCN') blnS = nameUtils.getUniqueName(side,baseName + 'Sca','BCN') if not blnT or not blnR or not blnS: return blnNodeT = pm.createNode('blendColors', n = blnT) blnNodeR = pm.createNode('blendColors', n = blnR) blnNodeS = pm.createNode('blendColors', n = blnS) chain1[i].t.connect(blnNodeT.color2) chain2[i].t.connect(blnNodeT.color1) chain1[i].r.connect(blnNodeR.color2) chain2[i].r.connect(blnNodeR.color1) chain1[i].s.connect(blnNodeS.color2) chain2[i].s.connect(blnNodeS.color1) blnNodeT.output.connect(b.t) blnNodeS.output.connect(b.s) blnNodeR.output.connect(b.r) blnTArray.append(blnNodeT) blnRArray.append(blnNodeR) blnSArray.append(blnNodeS) attrHolder.attr(attrName).connect(blnNodeT.blender) attrHolder.attr(attrName).connect(blnNodeR.blender) attrHolder.attr(attrName).connect(blnNodeS.blender) return data
def __finalizeFkChainShape(self): reversedList = list(self.controlsArray) reversedList.reverse() #parent shape for num,ctrl in enumerate(self.controlsArray): # for shape in ctrl.control.getShapes(): # pm.parent(shape,self.chain[num],r=1,s=1) pm.parent(ctrl.control.getShape(),self.chain[num],r=1,s=1) #stretch #Add attr pm.addAttr(self.chain[num],ln = 'stretch',at = 'double',dv = 0) pm.setAttr(self.chain[num] + '.stretch',e = 1,k = 1) #create node fkStrectchPMANodeName = nameUtils.getUniqueName(self.side,'fkStrectch','MDN') fkStrectchPMANode = pm.createNode('plusMinusAverage',n = fkStrectchPMANodeName) #connect oriTx = self.chain[num].tx.get() fkStrectchPMANode.input3D[0].input3Dx.set(oriTx) self.chain[num].stretch.connect(fkStrectchPMANode.input3D[1].input3Dx) fkStrectchPMANode.operation.set(1) fkStrectchPMANode.output3Dx.connect(self.chain[num].tx) #lock and hide control.lockAndHideAttr(self.chain[num],["tx","ty","tz","sy","sz","sx"]) #delete grp for i in range(len(reversedList)): pm.delete(reversedList[i].controlGrp)
def build(self): #build Trv self.guideTrv = pm.joint(p = [0,0,0],n = nameUtils.getUniqueName(self.side,self.baseName,'trv')) moPathName = nameUtils.getUniqueName(self.side,self.baseName,'MOP') moPathNode = pm.pathAnimation(self.guideCc,self.guideTrv,fractionMode = 1,follow = 1,followAxis = 'x',upAxis = 'y',worldUpType = 'vector', worldUpVector = [0,1,0],inverseUp = 0,inverseFront = 0,bank = 0,startTimeU = 1,endTimeU = 24,n = moPathName) pm.delete(moPathNode + '.uValue') # pm.disconnectAttr(moPathNode + '_uValue.output',moPathNode + '.uValue') #set Trv Loc: self.trvPosList = [] for num in range(0,self.segment): trvDis = num * (1 / float(self.segment-1)) pm.setAttr(moPathNode + '.uValue',trvDis) trvPos = self.guideTrv.getTranslation(space = 'world') self.trvPosList.append(trvPos) #set loc #set loc grp for i,p in enumerate(self.trvPosList): trvName = nameUtils.getUniqueName(self.side,self.baseName + 'Fk','gud') loc = pm.spaceLocator(n = trvName) loc.t.set(p) self.fkGuides.append(loc) loc.setParent(self.guideGrp) tempGuides = list(self.fkGuides) tempGuides.reverse() #set loc grp for i in range(len(tempGuides)): if i != (len(tempGuides) - 1): pm.parent(tempGuides[i],tempGuides[i + 1]) name = nameUtils.getUniqueName(self.side,self.baseName + '_Gud','grp') self.guideGrp = pm.group(em = 1,n = name) self.guideCc.setParent(self.guideGrp) self.fkGuides[0].setParent(self.guideGrp) self.guideTrv.setParent(self.guideGrp) self.guideGrp.v.set(0) self.__bodyCtrl() self.__fkJj() self.__ikJj() self.__squashStretch() self.__combine()
def __measure(self,*arg): sizeOneCtrl = control.Control('m','measureSizeOne',1,'y') sizeOneCtrl.circleCtrl() sizeFiveCtrl = control.Control('m','measureSizeFive',5,'y') sizeFiveCtrl.circleCtrl() sizeTenCtrl = control.Control('m','measureSizeTen',10,'y') sizeTenCtrl.circleCtrl() sizeTwentyCtrl = control.Control('m','measureSizeTwenty',20,'y') sizeTwentyCtrl.circleCtrl() tempGrp = pm.group(empty = 1,n = nameUtils.getUniqueName('m','measure','grp')) sizeOneCtrl.controlGrp.setParent(tempGrp) sizeFiveCtrl.controlGrp.setParent(tempGrp) sizeTenCtrl.controlGrp.setParent(tempGrp) sizeTwentyCtrl.controlGrp.setParent(tempGrp)
def __combine(self): #spine cc hip = self.spineCc[0].getParent() mid = self.spineCc[1].getParent() chest = self.spineCc[2].getParent() chest.setParent(self.spineFkRevBlendChain.chain[-1]) hip.setParent(self.spineFkRevBlendChain.chain[0]) mid.setParent(self.spineFkRevBlendChain.chain[(self.segment - 1) / 2]) hipPos = self.spineCc[0].getTranslation(space = 'world') pm.move(hipPos[0],hipPos[1],hipPos[2],self.bodyCtrl.control + '.rotatePivot') pm.move(hipPos[0],hipPos[1],hipPos[2],self.bodyCtrl.control + '.scalePivot') #create chestGRP self.chestGrp = pm.group(em = 1,n = nameUtils.getUniqueName('m','chest','grp')) self.chestGrp.setParent(self.spineFkRevBlendChain.chain[-1]) pm.parentConstraint(self.spineCc[2],self.chestGrp, mo = True)
def __squashStretch(self): #perpare Name startLocName = nameUtils.getUniqueName(self.side,self.baseName + '_StretchStart','loc') endLocName = nameUtils.getUniqueName(self.side,self.baseName + '_StretchEnd','loc') distanceBetweenNodeName = nameUtils.getUniqueName(self.side,self.baseName + '_Stretch','dist') multipleNodeName = nameUtils.getUniqueName(self.side,self.baseName + '_Stretch','MDN') conditionNodeName = nameUtils.getUniqueName(self.side,self.baseName + '_Stretch','COND') colorRedRemapValueName = nameUtils.getUniqueName(self.side,self.baseName + 'Red','RV') colorGreenRemapValueName = nameUtils.getUniqueName(self.side,self.baseName + 'Green','RV') # expressionNodeName = nameUtils.getUniqueName(self.side,self.baseName + '_Stretch','EXP') stretchSwitchNodeName = nameUtils.getUniqueName(self.side,self.baseName + '_Stretch','BCN') #remap Node for ikJj scale remapNodeRed = pm.createNode('remapValue',n = colorRedRemapValueName) remapNodeGreen = pm.createNode('remapValue',n = colorGreenRemapValueName) remapNodeNum = ((self.segment - 1) / 2) + 1 remapList = [] for num in range(0,remapNodeNum): remapNodeName = nameUtils.getUniqueName(self.side,self.baseName + '_Stretch','RV') remapNode = pm.createNode('remapValue',n = remapNodeName) remapList.append(remapNode) #createNode distBetweenNode = pm.createNode('distanceBetween',n = distanceBetweenNodeName) multipleNode = pm.createNode('multiplyDivide',n = multipleNodeName) conditionNode = pm.createNode('condition',n = conditionNodeName) stretchSwitchNode = pm.createNode('blendColors',n = conditionNodeName) #set command self.stretchStartLoc = pm.spaceLocator(n = startLocName) self.stretchStartLoc.v.set(0) self.stretchEndLoc = pm.spaceLocator(n = endLocName) self.stretchEndLoc.v.set(0) #align loc startPos = self.ribbonJc[0].worldMatrix.get() endPos = self.ribbonJc[-1].worldMatrix.get() pm.xform(self.stretchStartLoc,matrix = startPos) pm.xform(self.stretchEndLoc,matrix = endPos) self.stretchStartLoc.setParent(self.spineCc[0]) self.stretchEndLoc.setParent(self.spineCc[-1]) #connect #stretch self.stretchStartLoc.worldPosition[0].connect(distBetweenNode.point1) self.stretchEndLoc.worldPosition[0].connect(distBetweenNode.point2) self.stretchLength = distBetweenNode.distance.get() self.bodyCtrl.control.volume.connect(stretchSwitchNode.blender) stretchSwitchNode.color1R.set(1) multipleNode.outputX.connect(stretchSwitchNode.color2R) #multiple distBetweenNode.distance.connect(multipleNode.input1X) multipleNode.input2X.set(self.stretchLength) multipleNode.operation.set(2) #remap for num,remapNode in enumerate(remapList): stretchSwitchNode.outputR.connect(remapNode.inputValue) remapNode.inputMax.set(2) remapNode.outputMin.set(3) remapNode.outputMax.set(-1) if (self.segment - num - 1) != num: remapNode.outValue.connect(self.spineIkBlendJoint[num].sx) remapNode.outValue.connect(self.spineIkBlendJoint[num].sz) remapNode.outValue.connect(self.spineIkBlendJoint[self.segment - num - 1].sx) remapNode.outValue.connect(self.spineIkBlendJoint[self.segment - num - 1].sz) else: remapNode.outValue.connect(self.spineIkBlendJoint[num].sx) remapNode.outValue.connect(self.spineIkBlendJoint[num].sz) remapNode.value[0].value_FloatValue.set(num * float(1 / float(self.segment - 1))) remapNode.value[0].value_Position.set(0) remapNode.value[1].value_FloatValue.set(float(1 - (num * float(1 / float(self.segment - 1))))) remapNode.value[1].value_Position.set(1) remapNode.value[2].value_FloatValue.set(0.5) remapNode.value[2].value_Position.set(0.5) remapNode.value[2].value_Interp.set(1) #create shader materials = pm.shadingNode('blinn',asShader = 1,n = nameUtils.getUniqueName(self.side,self.baseName + 'Stretch','MAT')) shadingGroup = pm.sets(renderable = 1,noSurfaceShader = 1,empty = 1,name = nameUtils.getUniqueName(self.side,self.baseName + 'Stretch','SG')) materials.outColor.connect(shadingGroup.surfaceShader) #condition node multipleNode.outputX.connect(conditionNode.firstTerm) conditionNode.secondTerm.set(1) conditionNode.operation.set(2) conditionNode.colorIfTrueR.set(0) conditionNode.colorIfFalseR.set(0) conditionNode.colorIfTrueG.set(0) conditionNode.colorIfFalseG.set(0) conditionNode.colorIfTrueB.set(0) conditionNode.colorIfFalseB.set(0) #bug spotted!!! ''' color cannot change interactively ''' stretchSwitchNode.outputR.connect(remapNodeRed.inputValue) stretchSwitchNode.outputR.connect(remapNodeGreen.inputValue) remapNodeRed.inputMin.set(1) remapNodeRed.inputMax.set(2) remapNodeRed.outputMin.set(0) remapNodeRed.outputMax.set(1) remapNodeGreen.inputMin.set(0) remapNodeGreen.inputMax.set(1) remapNodeGreen.outputMin.set(1) remapNodeGreen.outputMax.set(0) remapNodeRed.outValue.connect(conditionNode.colorIfTrueR) remapNodeGreen.outValue.connect(conditionNode.colorIfFalseG) # print materials + '.incandescenceR = ' + conditionNode + '.outColorR' # print materials + '.incandescenceG = ' + conditionNode + '.outColorG' # print materials + '.incandescenceB = ' + conditionNode + '.outColorB' conditionNode.outColor.outColorR.connect(materials.incandescence.incandescenceR) conditionNode.outColor.outColorG.connect(materials.incandescence.incandescenceG) conditionNode.outColor.outColorB.connect(materials.incandescence.incandescenceB)
def __ikJj(self): self.ikJj = [] #create IKRibbonSpine #ribbon spine info: curveInfo = [0,(self.segment - 1) / 4,(self.segment - 1) / 2, ((self.segment - 1) / 2 + (self.segment - 1)) / 2, (self.segment - 1)] ribbonCurve = [] self.folList = [] #create curve for jjInfo in curveInfo: ribonJjPos = self.spineFkBlendChain.chain[jjInfo].getTranslation(space = 'world') ribbonCurve.append(ribonJjPos) #set ribbon offset offset = float(self.length * 0.05) #set ribbon cur ribbonCurveL = pm.curve(d = 3,p = [ribbonCurve[0],ribbonCurve[1],ribbonCurve[2],ribbonCurve[3],ribbonCurve[4]], k = [0,0,0,1,2,2,2],n = nameUtils.getUniqueName(self.side,self.baseName + '_ribbonL','gud')) pm.move(offset,0,0,ribbonCurveL) ribbonCurveR = pm.curve(d = 3,p = [ribbonCurve[0],ribbonCurve[1],ribbonCurve[2],ribbonCurve[3],ribbonCurve[4]], k = [0,0,0,1,2,2,2],n = nameUtils.getUniqueName(self.side,self.baseName + '_ribbonR','gud')) pm.move(-offset,0,0,ribbonCurveR) ribbonCurveR.setParent(self.guideGrp) ribbonCurveL.setParent(self.guideGrp) #create ribbon surf ribbonGeo = pm.loft(ribbonCurveR,ribbonCurveL,ch = 0,u = 1,c = 0,ar = 1,d = 3,ss = 1, rn = 0,po = 0,rsn = 1, n = nameUtils.getUniqueName(self.side,self.baseName + '_ribbon','surf')) ribbonClusList = [] self.ribbonJc = [] self.spineCc = [] #get loc pos for num,loc in enumerate(self.fkGuides): startLoc = self.fkGuides[0] midLoc = self.fkGuides[(len(self.fkGuides) - 1) / 2] endLoc = self.fkGuides[-1] startLocPos = pm.xform(startLoc,ws = 1,t = 1,q = 1)[1] midLocPos = pm.xform(midLoc,ws = 1,t = 1,q = 1)[1] endLocPos = pm.xform(endLoc,ws = 1,t = 1,q = 1)[1] #get Jc pos for num in [0,2,4]: pos = pm.select(ribbonGeo[0] + '.cv[' + str(num) + '][0:3]',r = 1) clus = pm.cluster() pm.rename(clus[1],nameUtils.getUniqueName(self.side,self.baseName + '_ribbon','cls')) ribbonClusList.append(clus) pm.select(cl = 1) #set cvpos for vert in [1,3]: for row in range(0,4): cvNum = pm.select(ribbonGeo[0] + '.cv[' + str(vert) + '][' + str(row) + ']',r = 1) oriPos = pm.xform(cvNum,ws = 1,t = 1,q = 1) if vert == 1: pm.xform(cvNum,ws = 1,t = (oriPos[0],(startLocPos + midLocPos) / 2,oriPos[2])) elif vert == 3: pm.xform(cvNum,ws = 1,t = (oriPos[0],(endLocPos + midLocPos) / 2,oriPos[2])) #set Jc and Jc ctrl for num,x in enumerate(ribbonClusList): jc = pm.joint(p = x[1].getRotatePivot(), n = nameUtils.getUniqueName(self.side,self.baseName + self.nameList[num],'jc'), radius = self.length / 3) self.ribbonJc.append(jc) pm.select(cl = 1) pm.delete(ribbonClusList[num]) pm.select(cl = 1) cc = control.Control(self.side,self.baseName + self.nameList[num],size = self.ikSize,aimAxis = self.ctrlAxis) cc.circleCtrl() pm.makeIdentity(cc.control,apply = True,t=0,r=1,s=0,n=0,pn=1) # self.bodyCtrl.control.ik_vis.connect(cc.controlGrp.v) self.bodyCtrl.control.ik_vis.connect(cc.control.getShape().v) self.spineCc.append(cc.control) control.lockAndHideAttr(cc.control,['sx','sy','sz','v']) pm.xform(cc.controlGrp,ws = 1,matrix = jc.worldMatrix.get()) #skin Jc for num,jc in enumerate(self.ribbonJc): jc.setParent(self.spineCc[num]) ribbonSkin = pm.skinCluster(self.ribbonJc[0],self.ribbonJc[1],self.ribbonJc[2],ribbonGeo[0], tsb = 1,ih = 1,mi = 3,dr = 4,rui = 1,n = nameUtils.getSkinName()) #skin pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[0][0:3]', transformValue=[(self.ribbonJc[0],1)]) pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[1][0:3]', transformValue=[(self.ribbonJc[1],0.5),(self.ribbonJc[0],0.5)]) pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[2][0:3]', transformValue=[(self.ribbonJc[1],1)]) pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[3][0:3]', transformValue=[(self.ribbonJc[1],0.5),(self.ribbonJc[2],0.5)]) pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[4][0:3]', transformValue=[(self.ribbonJc[2],1)]) #set fol #create / rename fol self.folGrp = pm.group(em = 1,n = nameUtils.getUniqueName(self.side,self.baseName + 'Fol','grp')) for fol in range(0,self.segment): #createNodeName follicleTransName = nameUtils.getUniqueName(self.side,self.baseName,'fol') follicleShapeName = nameUtils.getUniqueName(self.side,self.baseName,'folShape') #createNode follicleShape = pm.createNode('follicle',n = follicleShapeName) follicleTrans = pm.listRelatives(follicleShape, parent=True)[0] follicleTrans = pm.rename(follicleTrans, follicleTransName) # connect the surface to the follicle if ribbonGeo[0].getShape().nodeType() == 'nurbsSurface': pm.connectAttr((ribbonGeo[0] + '.local'), (follicleShape + '.inputSurface')) #Connect the worldMatrix of the surface into the follicleShape pm.connectAttr((ribbonGeo[0].getShape() + '.worldMatrix[0]'), (follicleShape + '.inputWorldMatrix')) #Connect the follicleShape to it's transform pm.connectAttr((follicleShape + '.outRotate'), (follicleTrans + '.rotate')) pm.connectAttr((follicleShape + '.outTranslate'), (follicleTrans + '.translate')) #Set the uValue and vValue for the current follicle pm.setAttr((follicleShape + '.parameterV'), 0.5) pm.setAttr((follicleShape + '.parameterU'), float(1.0 / float(self.segment - 1)) * fol) #Lock the translate/rotate of the follicle pm.setAttr((follicleTrans + '.translate'), lock=True) pm.setAttr((follicleTrans + '.rotate'), lock=True) pm.setAttr((follicleShape + '.degree'),1) #parent self.folList.append(follicleTrans) follicleTrans.setParent(self.folGrp) #rebuild fol pos self.spineIkBlendJoint = [] self.stretchCube = [] for num,fol in enumerate(self.folList): jj = pm.joint(p = (0,0,0),n = nameUtils.getUniqueName(self.side,self.baseName,'jj'), radius = self.length / 5) self.spineIkBlendJoint.append(jj) jj.setParent(fol) tempCube = pm.polyCube(ch = 1,o = 1,w = float(self.length / 5),h = float(self.length / 10), d = float(self.length / 5),cuv = 4,n = nameUtils.getUniqueName(self.side,self.baseName,'cube')) tempCube[0].setParent(jj) tempCube[0].v.set(0) self.stretchCube.append(tempCube[0]) jj.translateX.set(0) jj.translateY.set(0) jj.translateZ.set(0) self.ikJj.append(jj) #create spine grp self.spineIkGrp = pm.group(self.spineCc[0].getParent(),self.spineCc[1].getParent(),self.spineCc[2].getParent(),self.folGrp,ribbonGeo[0], n = nameUtils.getUniqueName(self.side,self.baseName + 'Ik','grp')) ribbonGeo[0].inheritsTransform.set(0) self.folGrp.inheritsTransform.set(0) #clean self.spineIkGrp.setParent(self.bodyCtrl.control) #temp self.spineIkGrp.v.set(1) '''put chest ctrl under chest cc''' '''put leg under hip cc'''
def __fkJj(self): #create fk jj self.spineFkRevBlendChain = [] self.guideSpineFkPos = [x.getTranslation(space = 'world') for x in self.fkGuides] self.guideSpineFkRot = [x.getRotation(space = 'world') for x in self.fkGuides] self.spineFkBlendChain = boneChain.BoneChain(self.baseName,self.side,type = 'fk') self.spineFkBlendChain.fromList(self.guideSpineFkPos,self.guideSpineFkRot,autoOrient = 1) #create revFk MDN node fkMultipleNodeList = [] fkPlusMinusAverageList = [] for num,fkJj in enumerate(self.spineFkBlendChain.chain): fkMultipleNodeName = nameUtils.getUniqueName(self.side,self.baseName + 'Fk','MDN') fkMultipleNode = pm.createNode('multiplyDivide',n = fkMultipleNodeName) fkMultipleNodeList.append(fkMultipleNode) fkPlusMinusAverageNodeName = nameUtils.getUniqueName(self.side,self.baseName + 'Fk','PMA') fkPlusMinusAverageNode = pm.createNode('plusMinusAverage',n = fkPlusMinusAverageNodeName) fkPlusMinusAverageNode.operation.set(1) fkPlusMinusAverageList.append(fkPlusMinusAverageNode) fkJj.rx.connect(fkMultipleNode.input1X) fkJj.ry.connect(fkMultipleNode.input1Y) fkJj.rz.connect(fkMultipleNode.input1Z) fkMultipleNode.input2X.set(-1) fkMultipleNode.input2Y.set(-1) fkMultipleNode.input2Z.set(-1) fkMultipleNode.outputX.connect(fkPlusMinusAverageNode.input3D[0].input3Dx) fkMultipleNode.outputY.connect(fkPlusMinusAverageNode.input3D[0].input3Dy) fkMultipleNode.outputZ.connect(fkPlusMinusAverageNode.input3D[0].input3Dz) #clean up self.spineFkGrp = pm.group(self.spineFkBlendChain.chain[0], n = nameUtils.getUniqueName(self.side,self.baseName + 'Fk','grp')) self.spineFkGrp.setParent(self.bodyCtrl.control) #create revFk self.guideSpineRevFkPos = [x.getTranslation(space = 'world') for x in self.fkGuides] self.guideSpineRevFkRot = [x.getRotation(space = 'world') for x in self.fkGuides] self.spineFkRevBlendChain = boneChain.BoneChain(self.baseName + 'Rev',self.side,type = 'fk') self.spineFkRevBlendChain.fromList(self.guideSpineRevFkPos,self.guideSpineRevFkRot,autoOrient = 1) #reroot skl pm.select(self.spineFkRevBlendChain.chain[-1]) pm.runtime.RerootSkeleton() self.spineFkRevBlendChain.chain[-1].setParent(self.spineFkBlendChain.chain[-1]) #set Rotate #nodename multiplefkBendNodeName = nameUtils.getUniqueName(self.side,self.baseName + 'FkBend','MDN') multiplefkRevBendNodeName = nameUtils.getUniqueName(self.side,self.baseName + 'FkRevBend','MDN') multiplefkTwistNodeName = nameUtils.getUniqueName(self.side,self.baseName + 'FkTwist','MDN') multiplefkRevTwistNodeName = nameUtils.getUniqueName(self.side,self.baseName + 'FkRevTwist','MDN') multiplefkSideNodeName = nameUtils.getUniqueName(self.side,self.baseName + 'FkSide','MDN') multiplefkRevSideNodeName = nameUtils.getUniqueName(self.side,self.baseName + 'FkRevSide','MDN') #nodecreate multiplefkBendNode = pm.createNode('multiplyDivide',n = multiplefkBendNodeName) multiplefkRevBendNode = pm.createNode('multiplyDivide',n = multiplefkRevBendNodeName) multiplefkTwistNode = pm.createNode('multiplyDivide',n = multiplefkTwistNodeName) multiplefkRevTwistNode = pm.createNode('multiplyDivide',n = multiplefkRevTwistNodeName) multiplefkSideNode = pm.createNode('multiplyDivide',n = multiplefkSideNodeName) multiplefkRevSideNode = pm.createNode('multiplyDivide',n = multiplefkRevSideNodeName) #connect #bend self.bodyCtrl.control.bend_lo.connect(multiplefkBendNode.input1X) self.bodyCtrl.control.bend_mid.connect(multiplefkBendNode.input1Y) self.bodyCtrl.control.bend_up.connect(multiplefkBendNode.input1Z) self.bodyCtrl.control.bend_lo_rev.connect(multiplefkRevBendNode.input1X) self.bodyCtrl.control.bend_mid_rev.connect(multiplefkRevBendNode.input1Y) self.bodyCtrl.control.bend_up_rev.connect(multiplefkRevBendNode.input1Z) multiplefkBendNode.input2X.set(-1) multiplefkBendNode.input2Y.set(-1) multiplefkBendNode.input2Z.set(-1) multiplefkBendNode.operation.set(1) multiplefkRevBendNode.input2X.set(-1) multiplefkRevBendNode.input2Y.set(-1) multiplefkRevBendNode.input2Z.set(-1) multiplefkRevBendNode.operation.set(1) #twist self.bodyCtrl.control.twist_lo.connect(multiplefkTwistNode.input1X) self.bodyCtrl.control.twist_mid.connect(multiplefkTwistNode.input1Y) self.bodyCtrl.control.twist_up.connect(multiplefkTwistNode.input1Z) self.bodyCtrl.control.twist_lo_rev.connect(multiplefkRevTwistNode.input1X) self.bodyCtrl.control.twist_mid_rev.connect(multiplefkRevTwistNode.input1Y) self.bodyCtrl.control.twist_up_rev.connect(multiplefkRevTwistNode.input1Z) multiplefkTwistNode.input2X.set(-1) multiplefkTwistNode.input2Y.set(-1) multiplefkTwistNode.input2Z.set(-1) multiplefkTwistNode.operation.set(1) multiplefkRevTwistNode.input2X.set(-1) multiplefkRevTwistNode.input2Y.set(-1) multiplefkRevTwistNode.input2Z.set(-1) multiplefkRevTwistNode.operation.set(1) #side self.bodyCtrl.control.side_lo.connect(multiplefkSideNode.input1X) self.bodyCtrl.control.side_mid.connect(multiplefkSideNode.input1Y) self.bodyCtrl.control.side_up.connect(multiplefkSideNode.input1Z) self.bodyCtrl.control.side_lo_rev.connect(multiplefkRevSideNode.input1X) self.bodyCtrl.control.side_mid_rev.connect(multiplefkRevSideNode.input1Y) self.bodyCtrl.control.side_up_rev.connect(multiplefkRevSideNode.input1Z) multiplefkSideNode.input2X.set(-1) multiplefkSideNode.input2Y.set(-1) multiplefkSideNode.input2Z.set(-1) multiplefkSideNode.operation.set(1) multiplefkRevSideNode.input2X.set(-1) multiplefkRevSideNode.input2Y.set(-1) multiplefkRevSideNode.input2Z.set(-1) multiplefkRevSideNode.operation.set(1) #fk for num,chain in enumerate(self.spineFkBlendChain.chain): #lo if 1 <= num <= (self.segment / 3): multiplefkBendNode.outputX.connect(chain.rz) multiplefkSideNode.outputX.connect(chain.ry) multiplefkTwistNode.outputX.connect(chain.rx) #mid elif (self.segment / 3) < num < ((self.segment / 3) * 2): multiplefkBendNode.outputY.connect(chain.rz) multiplefkSideNode.outputY.connect(chain.ry) multiplefkTwistNode.outputY.connect(chain.rx) #up elif ((self.segment / 3) * 2) <= num < (self.segment - 1): multiplefkBendNode.outputZ.connect(chain.rz) multiplefkSideNode.outputZ.connect(chain.ry) multiplefkTwistNode.outputZ.connect(chain.rx) #revFk # self.spineFkRevBlendChain.chain.reverse() for num,chain in enumerate(self.spineFkRevBlendChain.chain): #lo if 1 <= num <= (self.segment / 3 - 1): multiplefkRevBendNode.outputX.connect(fkPlusMinusAverageList[num].input3D[1].input3Dz) multiplefkRevSideNode.outputX.connect(fkPlusMinusAverageList[num].input3D[1].input3Dy) multiplefkRevTwistNode.outputX.connect(fkPlusMinusAverageList[num].input3D[1].input3Dx) fkPlusMinusAverageList[num].output3D.output3Dz.connect(chain.rz) fkPlusMinusAverageList[num].output3D.output3Dy.connect(chain.ry) fkPlusMinusAverageList[num].output3D.output3Dx.connect(chain.rx) #mid elif (self.segment / 3 - 1) < num < ((self.segment / 3) * 2): multiplefkRevBendNode.outputY.connect(fkPlusMinusAverageList[num].input3D[1].input3Dz) multiplefkRevSideNode.outputY.connect(fkPlusMinusAverageList[num].input3D[1].input3Dy) multiplefkRevTwistNode.outputY.connect(fkPlusMinusAverageList[num].input3D[1].input3Dx) fkPlusMinusAverageList[num].output3D.output3Dz.connect(chain.rz) fkPlusMinusAverageList[num].output3D.output3Dy.connect(chain.ry) fkPlusMinusAverageList[num].output3D.output3Dx.connect(chain.rx) #up elif ((self.segment / 3) * 2) <= num < (self.segment - 1): multiplefkRevBendNode.outputZ.connect(fkPlusMinusAverageList[num].input3D[1].input3Dz) multiplefkRevSideNode.outputZ.connect(fkPlusMinusAverageList[num].input3D[1].input3Dy) multiplefkRevTwistNode.outputZ.connect(fkPlusMinusAverageList[num].input3D[1].input3Dx) fkPlusMinusAverageList[num].output3D.output3Dz.connect(chain.rz) fkPlusMinusAverageList[num].output3D.output3Dy.connect(chain.ry) fkPlusMinusAverageList[num].output3D.output3Dx.connect(chain.rx)