def connectCtrls(): ctrls = pm.ls(sl=1) masterGrp = groupTools.makeGroup(name='wingCtrlsConnect') coordsList = [] midDrvLocs = [] holdDrvLocs = [] mdCtrlsCoord = vtxWalk.bbox(ctrls)['globalPvt'] middle = controlTools.cntrlCrv(name='wingCtrlsConnect_mid_loc', coords=(mdCtrlsCoord, (0, 0, 0), (1, 1, 1)), cntrlSulfix='', parent=masterGrp, icone='null') tempConstraint = pm.pointConstraint(ctrls[0], ctrls[1], middle, mo=0) pm.delete(tempConstraint) pm.parentConstraint(ctrls[0].getParent().getParent(), ctrls[1].getParent().getParent(), middle, mo=1, sr=['x', 'y', 'z']) pm.aimConstraint(ctrls[0].getParent().getParent(), middle, wut='scene', mo=0) orientMiddle = pm.xform(middle, q=1, ro=1, ws=1) for ctrl in ctrls: coord = vtxWalk.bbox(ctrl)['globalPvt'] coordsList.append(coordsList) midLoc = controlTools.cntrlCrv(name=ctrl + '_mid_drv_loc', coords=(coord, (0, 0, 0), (1, 1, 1)), cntrlSulfix='', parent=middle, icone='null') midDrvLocs.append(midLoc) holdLoc = controlTools.cntrlCrv(name=ctrl + '_hold_drv_loc', coords=(coord, orientMiddle, (1, 1, 1)), cntrlSulfix='', parent=masterGrp, icone='null') holdDrvLocs.append(holdLoc) pm.parentConstraint(ctrl.getParent().getParent(), holdLoc, mo=1) pm.addAttr(ctrl, ln='autoConnect', dv=0.8, min=0, max=1, k=1) drvPointConstraint = pm.pointConstraint(midLoc, holdLoc, ctrl.getParent(), mo=1) #drvOrientConstraint = pm.orientConstraint(middle, holdLoc, ctrl.getParent(), mo=1) revNode = pm.createNode('reverse', n='wingCtrlsConnect_rev') ctrl.autoConnect >> revNode.inputX pm.connectAttr(ctrl.autoConnect, drvPointConstraint + '.' + midLoc + 'W0') pm.connectAttr(revNode.outputX, drvPointConstraint + '.' + holdLoc + 'W1')
def doGuide(self, **kwargs): self.__dict__.update(kwargs) # apaga se existir displaySetup = self.moveallGuideSetup.copy() cntrlName = displaySetup['nameTempl'] + self.guideSulfix if pm.objExists(cntrlName): pm.delete(cntrlName) self.guideMoveall = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, cntrlSulfix='', hasHandle=True, **displaySetup) if not pm.objExists('GUIDES'): pm.group(self.guideMoveall, n='GUIDES') else: pm.parent(self.guideMoveall, 'GUIDES') displaySetup = self.startGuideSetup.copy() cntrlName = displaySetup['nameTempl'] + self.guideSulfix self.startGuide = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, cntrlSulfix='', hasHandle=True, **displaySetup) displaySetup = self.endGuideSetup.copy() cntrlName = displaySetup['nameTempl'] + self.guideSulfix self.endGuide = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, cntrlSulfix='', hasHandle=True, **displaySetup) pm.parent(self.startGuide, self.endGuide, self.guideMoveall) self.setCntrl(self.endGuide, 'end', space='object') self.setCntrl(self.startGuide, 'start', space='object') self.setCntrl(self.guideMoveall, 'moveall', space='world') pm.addAttr(self.guideMoveall, ln='neckDict', dt='string') self.guideMoveall.neckDict.set(json.dumps(self.exportDict()))
def doGuide(self, **kwargs): self.__dict__.update(kwargs) displaySetup = self.moveallGuideSetup.copy() cntrlName = displaySetup['nameTempl'] + self.guideSulfix if pm.objExists(cntrlName): pm.delete(cntrlName) self.guideMoveall = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, cntrlSulfix='', **displaySetup) if not pm.objExists('GUIDES'): pm.group(self.guideMoveall, n='GUIDES') else: pm.parent(self.guideMoveall, 'GUIDES') self.startGuide = self.createCntrl('startGuide') self.midGuide = self.createCntrl('midGuide') self.endGuide = self.createCntrl('endGuide') pm.parent(self.startGuide, self.midGuide, self.endGuide, self.guideMoveall) if self.lastJoint: self.lastGuide = self.createCntrl('lastGuide') pm.parent(self.lastGuide, self.endGuide) self.setCntrl(self.lastGuide, 'last', space='object') self.setCntrl(self.startGuide, 'start', space='object') self.setCntrl(self.midGuide, 'mid', space='object') self.setCntrl(self.endGuide, 'end', space='object') arrow = controlTools.cntrlCrv(obj=self.startGuide, name=self.name + 'PlaneDir', icone='seta', size=.35, color=(0, 1, 1)) arrow.template.set(1) arrow.getParent().setParent(self.startGuide) pm.aimConstraint(self.endGuide, arrow, weight=1, aimVector=(1, 0, 0), upVector=(0, 0, -1), worldUpObject=self.midGuide, worldUpType='object') self.setCntrl(self.guideMoveall, 'moveall', space='world') pm.addAttr(self.guideMoveall, ln='limbDict', dt='string') # todo implementar funcao de exportar o dict self.guideMoveall.limbDict.set(json.dumps(self.exportDict()))
def doRig(self): sufix_skin = 'jxt' sufix = 'end' if not self.guideMoveall: self.doGuide() self.guideMoveall.visibility.set(0) if pm.objExists(self.name + "_constrained_grp"): pm.delete(self.name + "_constrained_grp") if pm.objExists(self.name + 'Sys_grp'): pm.delete(self.name + 'Sys_grp') self.sysGrp = pm.group(em=True, n=self.name + 'Sys_grp') self.sysGrp.visibility.set(0) self.constrainedGrp = pm.group(em=True, n=self.name + '_constrained_grp') if pm.objExists('head_contrained'): constrained_grp = 'head_contrained' else: constrained_grp = pm.group(n='head_contrained', em=True) L_eyeTranslate = pm.xform(self.L_eyeSocketGuide, q=True, ws=True, t=True) L_eyeRotate = pm.xform(self.L_eyeSocketGuide, q=True, ws=True, ro=True) R_eyeTranslate = pm.xform(self.R_eyeSocketGuide, q=True, ws=True, t=True) R_eyeRotate = pm.xform(self.R_eyeSocketGuide, q=True, ws=True, ro=True) pm.select(cl=True) L_eyeJntZero = pm.joint(p=L_eyeTranslate, n='L_eyeSocket_zero') L_eyeJntSkin = pm.joint(p=L_eyeTranslate, n='L_eyeSocket_' + sufix_skin) pm.xform(L_eyeJntZero, ws=True, ro=L_eyeRotate) pm.select(cl=True) R_eyeJntZero = pm.joint(p=R_eyeTranslate, n='R_eyeSocket_zero') R_eyeJntSkin = pm.joint(p=R_eyeTranslate, n='R_eyeSocket_' + sufix_skin) pm.xform(R_eyeJntZero, ws=True, ro=R_eyeRotate) self.LsocketCtrl = controlTools.cntrlCrv(name='L_eyeSocket_ctrl', obj=L_eyeJntSkin, align='posRot', connType='connection', size=1, icone='circuloZ') self.RsocketCtrl = controlTools.cntrlCrv(name='R_eyeSocket_ctrl', obj=R_eyeJntSkin, align='posRot', connType='connection', size=1, icone='circuloZ') pm.parent(R_eyeJntZero, L_eyeJntZero, self.sysGrp) pm.parent(self.LsocketCtrl.getParent(), self.RsocketCtrl.getParent(), self.constrainedGrp) pm.parent(self.constrainedGrp, constrained_grp)
def connectCtrls(self, ctrls, parent): masterCtrl = ctrls[0] drvCtrlList = ctrls[1] bendCtrlList = ctrls[2] paramList = self.returnClosestPointOnCurve(objList=self.ikhDrvList, curve=self.curve) locDrvGrp = groupTools.makeGroup(name=self.name + '_loc_drv', parent=parent) locDrvGrp.v.set(0) curveMinMaxValue = self.curve.getShape().minMaxValue.get() curveSize = curveMinMaxValue[1] - curveMinMaxValue[0] locDrvList = [] for i, each in enumerate(paramList): locDrv = controlTools.cntrlCrv( icone='null', name=self.name + '_drv_' + str(i + 1) + '_loc', hasZeroGrp=0, parent=locDrvGrp, cntrlSulfix='', coords=(self.ikhCoordList[i], (0, 0, 0), (1, 1, 1))) locDrvList.append(locDrv) self.createMotionPath(locDrv, self.curve, each) pm.pointConstraint(locDrv, self.ikhNodeList[i], mo=0) # construir o reader para extrair rotacao da curva self.orientJoint(i, locDrv, parent) # bends: blendValue = each / curveSize self.connectToBendCtrl(i, bendCtrlList, blendValue)
def doGuide(self, **kwargs): self.__dict__.update(kwargs) displaySetup = self.moveallGuideSetup.copy() cntrlName = displaySetup['nameTempl'] + self.guideSulfix if pm.objExists(cntrlName): pm.delete(cntrlName) self.guideMoveall = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, cntrlSulfix='', hasHandle=True, **displaySetup) if not pm.objExists('GUIDES'): pm.group(self.guideMoveall, n='GUIDES') else: pm.parent(self.guideMoveall, 'GUIDES') for eye in self.eyes: guideDict = {'moveall': self.guideDict[eye]} self.eyeInstances[eye].doGuide(name=eye, guideDict=guideDict) pm.parent(self.eyeInstances[eye].guideMoveall, self.guideMoveall) self.eyeInstances[self.eyes[-1]].mirrorConnectGuide( self.eyeInstances[self.eyes[0]]) pm.parent(self.eyeInstances[self.eyes[-1]].mirrorGuide, self.guideMoveall) self.setCntrl(self.guideMoveall, 'moveall', space='world')
def createCntrl(self, cntrlName, hasZeroGrp=False): displaySetup = self.__dict__[cntrlName+'Setup'].copy() cntrlName = displaySetup['nameTempl'] + self.guideSulfix if pm.objExists(cntrlName): pm.delete(cntrlName) guide = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=hasZeroGrp, cntrlSulfix='', hasHandle=True, **displaySetup) return guide
def doGuide(self, **kwargs): self.__dict__.update(kwargs) # apaga se existir self.guideMoveall = self.createCntrl('moveallGuide') if not pm.objExists('GUIDES'): pm.group(self.guideMoveall, n='GUIDES') else: pm.parent(self.guideMoveall, 'GUIDES') self.setCntrl(self.guideMoveall, 'moveall', space='world') self.guideList = [] for i in range(len(self.guideDict.keys()) - 1): displaySetup = self.guideSetup.copy() cntrlName = displaySetup['nameTempl'] + str(i + 1) + self.guideSulfix guide = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, cntrlSulfix='', hasHandle=True, **displaySetup) self.guideList.append(guide) pm.parent(guide, self.guideMoveall) if i == 0: self.setCntrl(guide, 'guide' + str(i + 1), space='object') else: self.setCntrl(guide, 'guide' + str(i + 1), space='object') pm.addAttr(self.guideMoveall, ln='chainDict', dt='string') # todo implantar funcao pra exportar dict self.guideMoveall.chainDict.set(json.dumps(self.exportDict()))
def doRig(self): if not self.guideMoveall: self.doGuide() if pm.objExists(self.name + 'Moveall'): pm.delete(self.name + 'Moveall') self.drvGrp = pm.group(em=True, n=self.name + 'Sys_grp') self.drvGrp.visibility.set(False) self.cntrlGrp = pm.group(em=True, n=self.name + 'Ctrls_grp') self.moveall = pm.group(self.cntrlGrp, n=self.name + 'Constrained') self.cntrlList = [] for i in range(self.num): pm.select(cl=True) jnt = pm.joint(n=self.name + str(i + 1) + self.jntPrefix) pos = pm.xform(self.guideList[i], q=True, ws=True, t=True) pm.xform(jnt, ws=True, t=pos) drvName = self.drvSetup['nameTempl'] + str(i + 1) + '_drv' drv = controlTools.cntrlCrv(name=drvName, obj=jnt, connType='parent', **self.drvSetup) cntrlName = self.ctrlSetup['nameTempl'] + str(i + 1) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=drv, connType='connection', offsets=1, **self.ctrlSetup) if self.hasMulti: mlt = pm.createNode('multiplyDivide') mlt.input2.set([-1, -1, -1]) cntrl.translate >> mlt.input1 mlt.output >> cntrl.getParent().translate self.cntrlList.append(cntrl) cntrl.getParent(2).setParent(self.cntrlGrp) drv.getParent().setParent(self.drvGrp)
def doGuide(self, **kwargs): self.__dict__.update(kwargs) displaySetup = self.moveallGuideSetup.copy() cntrlName = displaySetup['nameTempl'] + self.guideSulfix if pm.objExists(cntrlName): pm.delete(cntrlName) self.guideMoveall = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, cntrlSulfix='', **displaySetup) # self.guideMoveall=pm.group (n=guideName, em=True) # self.guideMoveall=pm.circle (n=guideName , c=(0,0,0),nr=(1,0,0), sw=360,r=1 ,d=3,ut=0,ch=0)[0] if not pm.objExists('GUIDES'): pm.group(self.guideMoveall, n='GUIDES') else: pm.parent(self.guideMoveall, 'GUIDES') self.startGuide = self.createCntrl('startGuide') self.midGuide = self.createCntrl('midGuide') self.endGuide = self.createCntrl('endGuide') midGuideGrp = pm.group(em=True, n=self.name + 'midGuide_grp') pm.pointConstraint(self.startGuide, self.endGuide, midGuideGrp, mo=False) self.midGuide.setParent(midGuideGrp) self.endTipGuide = self.createCntrl('endTipGuide') self.endTipGuide.setParent(self.endGuide) self.startTipGuide = self.createCntrl('startTipGuide') self.startTipGuide.setParent(self.startGuide) pm.parent(self.startGuide, midGuideGrp, self.endGuide, self.guideMoveall) self.setCntrl(self.startGuide, 'start', space='object') self.setCntrl(self.endGuide, 'end', space='object') self.setCntrl(self.midGuide, 'mid', space='object') self.setCntrl(self.endTipGuide, 'endTip', space='object') self.setCntrl(self.startTipGuide, 'startTip', space='object') self.setCntrl(self.guideMoveall, 'moveall', space='world') pm.addAttr(self.guideMoveall, ln='spineDict', dt='string') self.guideMoveall.spineDict.set(json.dumps(self.exportDict()))
def doRig(self): # se nao tiver guide faz um padrao if not self.guideMoveall: self.doGuide() displaySetup = self.lookAtCntrlSetup.copy() cntrlName = self.lookAtCntrlSetup['nameTempl'] if pm.objExists(cntrlName + '_grp'): pm.delete(cntrlName + '_grp') self.lookAt = controlTools.cntrlCrv(name=cntrlName, obj=self.guideMoveall, **displaySetup)
def createCntrl(self, setupName='ctrl', nameTempl=None, posRot=None): displaySetup = self.__dict__[setupName + 'Setup'].copy() if nameTempl: cntrlName = nameTempl else: cntrlName = displaySetup['nameTempl'] + self.guideSulfix if pm.objExists(cntrlName): pm.delete(cntrlName) guide = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, posRot=posRot, cntrlSulfix='', hasHandle=True, **displaySetup) return guide
def doGuide(self, **kwargs): self.__dict__.update(kwargs) displaySetup = self.moveallGuideSetup.copy() def createEachCtrlGuide(ctrlName, guideRunning, setUp): if pm.objExists(ctrlName): pm.delete(ctrlName) guideRunning = controlTools.cntrlCrv(name=ctrlName, **setUp) self.setCntrl(pm.PyNode(ctrlName), displaySetup, 'spaceSet', 'world') ctrlName = displaySetup['nameTempl'] + self.guideSulfix createEachCtrlGuide(ctrlName, self.guideMoveall, self.moveallGuideSetup) ''' self.guideMoveall = rigFunctions.cntrlCrv( name = ctrlName, hasZeroGrp=False, cntrlSulfix='', hasHandle=True, **self.moveallGuideSetup) self.setCntrl(pm.PyNode(ctrlName), displaySetup, 'spaceSet', 'world') ''' for guide in range(self.num): displaySetup = self.chainGuideSetup.copy() guideName = displaySetup['nameTempl'] + str(guide) + self.guideSulfix guideIcon = displaySetup['icone'] if pm.objExists(guideName): pm.delete(guideName) runningGuide = controlTools.cntrlCrv(name=guideName, hasZeroGrp=False, cntrlSulfix='', hasHandle=True, **self.chainGuideSetup) self.setCntrl(pm.PyNode(guideName), self.guideDict, guide, 'world') self.guideSys.append(runningGuide) print (self.guideSys) # lista de todos os controles de guide a serem construidos if not pm.objExists('GUIDES'): pm.group(self.guideMoveall, n='GUIDES') else: pm.parent(self.guideMoveall, 'GUIDES')
def doGuide(self, **kwargs): self.__dict__.update(kwargs) # self.guideMoveall=pm.group(n=guideName, em=True) # self.guideMoveall=pm.circle (n=guideName , c=(0,0,0),nr=(1,0,0), sw=360,r=1 ,d=3,ut=0,ch=0)[0] displaySetup = self.moveallGuideSetup.copy() cntrlName = displaySetup['nameTempl'] + self.guideSulfix if pm.objExists(cntrlName): pm.delete(cntrlName) self.guideMoveall = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, cntrlSulfix='', **displaySetup) if pm.objExists('GUIDES'): self.guideGrp = pm.PyNode('GUIDES') else: self.guideGrp = pm.group(em=True, n='GUIDES') self.setCntrl(self.guideMoveall, 'moveall', space='world') pm.parent(self.guideMoveall, self.guideGrp) pm.addAttr(self.guideMoveall, ln='moveallDict', dt='string') self.guideMoveall.moveallDict.set(json.dumps(self.exportDict()))
def doGuide(self, **kwargs): self.__dict__.update(kwargs) displaySetup = self.moveallGuideSetup.copy() cntrlName = displaySetup['nameTempl'] + self.guideSulfix if pm.objExists(cntrlName): pm.delete(cntrlName) self.guideMoveall = controlTools.cntrlCrv(name=cntrlName, hasZeroGrp=False, cntrlSulfix='', hasHandle=True, **displaySetup) if not pm.objExists('GUIDES'): pm.group(self.guideMoveall, n='GUIDES') else: pm.parent(self.guideMoveall, 'GUIDES') # cria guides segundo os nomes dos controles e nas posicoes definidas no dicionario footGuideDict self.centerGuide = self.createCntrl('centerGuide') guideName = self.centerGuideSetup['nameTempl'] + self.grpSulfix self.centerGuideGrp = pm.group(self.centerGuide, n=guideName) self.tipGuide = self.createCntrl('tipGuide') self.heelGuide = self.createCntrl('heelGuide') self.ankleGuide = self.createCntrl('ankleGuide') self.ballGuide = self.createCntrl('ballGuide') self.inGuide = self.createCntrl('inGuide') self.outGuide = self.createCntrl('outGuide') for finger in self.fingers: f = self.fingerInstances[finger] f.doGuide(guideDict=self.fingers[finger]['guideDict']) pm.parent(f.guideMoveall, self.tipGuide) # pm.parent (self.fingerGrp, self.tipGuide) pm.parent(self.ballGuide, self.inGuide, self.outGuide, self.tipGuide) self.ankleGuide.setParent(self.centerGuide) pm.parent(self.centerGuideGrp, self.tipGuide, self.heelGuide, self.guideMoveall) self.setCntrl(self.tipGuide, 'tip', space='object') self.setCntrl(self.heelGuide, 'heel', space='object') self.setCntrl(self.ankleGuide, 'ankle', space='object') self.setCntrl(self.ballGuide, 'ball', space='object') self.setCntrl(self.inGuide, 'in', space='object') self.setCntrl(self.outGuide, 'out', space='object') pm.pointConstraint(self.tipGuide, self.heelGuide, self.centerGuideGrp) pm.pointConstraint(self.tipGuide, self.centerGuideGrp, e=True, w=0.25) pm.pointConstraint(self.heelGuide, self.centerGuideGrp, e=True, w=0.75) pm.aimConstraint(self.heelGuide, self.tipGuide, weight=1, aimVector=(-1, 0, 0), upVector=(0, 1, 0), worldUpVector=(0, 1, 0), worldUpType='objectrotation', worldUpObject=self.guideMoveall) pm.aimConstraint(self.tipGuide, self.centerGuide, weight=1, aimVector=(1, 0, 0), upVector=(0, 1, 0), worldUpVector=(0, 1, 0), worldUpType='objectrotation', worldUpObject=self.guideMoveall) self.setCntrl(self.guideMoveall, 'moveall', space='world') pm.addAttr(self.guideMoveall, ln='footDict', dt='string') #todo implementar funcao pra exportar dict self.guideMoveall.footDict.set(json.dumps(self.exportDict())) guideShape = self.guideMoveall.getShape() guideShape.template.set(1)
def createEachCtrlGuide(ctrlName, guideRunning, setUp): if pm.objExists(ctrlName): pm.delete(ctrlName) guideRunning = controlTools.cntrlCrv(name=ctrlName, **setUp) self.setCntrl(pm.PyNode(ctrlName), displaySetup, 'spaceSet', 'world')
def doRig(self): sufix_skin = 'jxt' sufix = 'pivot' if not self.guideMoveall: self.doGuide() if pm.objExists(self.name + '_sys'): pm.delete(self.name + '_sys') if pm.objExists(self.name + '_constrained'): pm.delete(self.name + '_constrained') if pm.objExists('head_contrained'): head_constrained_grp = 'head_contrained' else: head_constrained_grp = pm.group(n='head_contrained', em=True) moveall = pm.group(n=self.name + '_sys', em=True) constrained_grp = pm.group(n=self.name + '_constrained', em=True) pm.parent(constrained_grp, head_constrained_grp) pm.select(cl=True) pivot = pm.xform(self.pivotGuide, q=True, ws=True, t=True) jawZero = pm.joint(p=pivot, n='jaw_zero') jawJnt = pm.joint(p=pivot, n='jaw_' + sufix) jaw = pm.xform(self.jawGuide, q=True, ws=True, t=True) pm.joint(p=jaw, n='jaw_' + sufix_skin) pm.select(cl=True) L_cornerJnt = pm.joint(p=pivot, n='L_corner_' + sufix) L_corner = pm.xform(self.L_cornerGuide, q=True, ws=True, t=True) L_cornerTipJnt = pm.joint(p=L_corner, n='L_corner_' + sufix_skin) L_ikh = pm.ikHandle(L_cornerJnt, L_cornerTipJnt, sol='ikRPsolver', n=L_cornerJnt + '_ikh') pm.select(cl=True) L_constraint = pm.parentConstraint(jawZero, jawJnt, L_ikh[0], mo=True) pm.select(cl=True) R_cornerJnt = pm.joint(p=pivot, n='R_corner_' + sufix) R_corner = pm.xform(self.R_cornerGuide, q=True, ws=True, t=True) R_cornerTipJnt = pm.joint(p=R_corner, n='R_corner_' + sufix_skin) R_ikh = pm.ikHandle(R_cornerJnt, R_cornerTipJnt, sol='ikRPsolver', n=R_cornerJnt + '_ikh') R_constraint = pm.parentConstraint(jawZero, jawJnt, R_ikh[0], mo=True) pm.select(cl=True) upperLipJnt = pm.joint(p=pivot, n='upperLip_' + sufix) upperLip = pm.xform(self.upperLipGuide, q=True, ws=True, t=True) pm.joint(p=upperLip, n='upperLip_' + sufix_skin) pm.select(cl=True) tongueJnts = [] previousJnt = None for i in range(1, 6): print i guide = self.__dict__['tongue' + str(i) + 'Guide'] jnt = jointTools.makeJoint(name='tongue' + str(i), jntSulfix='_jxt', connectToLast=True, obj=guide) if previousJnt: pm.joint(previousJnt, e=True, zso=True, oj='xyz', sao='yup') previousJnt = jnt print jnt tongueJnts.append(jnt) tongueJnts[-1].jointOrientX.set(0) tongueJnts[-1].jointOrientY.set(0) tongueJnts[-1].jointOrientZ.set(0) jointTools.zeroJoints(tongueJnts) pm.parent(tongueJnts[0].getParent(), jawJnt) previousCtrl = None tongueFirstCtrl = None print tongueJnts for i, jnt in enumerate(tongueJnts): print i print jnt tongueCtrl = controlTools.cntrlCrv(name='tongue' + str(i), obj=jnt, connType='connection', size=.2, icone='cubo') if previousCtrl: pm.parent(tongueCtrl.getParent(), previousCtrl) else: tongueFirstCtrl = tongueCtrl previousCtrl = tongueCtrl print tongueFirstCtrl jawCntrl = controlTools.cntrlCrv(name='jaw_ctrl', obj=jawJnt, connType='connection', size=.5, icone='jaw') jawCntrl.addAttr('L_cornerFollow', at='float', dv=0.5, k=1) jawCntrl.addAttr('R_cornerFollow', at='float', dv=0.5, k=1) b = jaw a = pivot shape = jawCntrl.getShape() pm.move(b[0] - a[0], (b[1] - a[1]) - .3, (b[2] - a[2]) + .4, shape.cv, r=True) L_reverse = pm.createNode('reverse') jawCntrl.L_cornerFollow >> L_reverse.input.inputX jawCntrl.L_cornerFollow >> L_constraint.attr(jawZero.name() + 'W0') L_reverse.output.outputX >> L_constraint.attr(jawJnt.name() + 'W1') jawCntrl.R_cornerFollow >> L_reverse.input.inputY jawCntrl.R_cornerFollow >> R_constraint.attr(jawZero.name() + 'W0') L_reverse.output.outputY >> R_constraint.attr(jawJnt.name() + 'W1') ## cond = pm.createNode('condition') multiUpLip = pm.createNode('multDoubleLinear') jawJnt.rotateX >> cond.firstTerm cond.secondTerm.set(0) cond.operation.set(4) cond.colorIfFalseR.set(0) multiUpLip.input2.set(.3) jawJnt.rotateX >> multiUpLip.input1 multiUpLip.output >> cond.colorIfTrue.colorIfTrueR cond.outColor.outColorR >> upperLipJnt.rotateX self.guideMoveall.visibility.set(False) moveall.visibility.set(False) #DENTES pm.select(cl=True) upperTeeth = pm.xform(self.upperTeethGuide, q=True, ws=True, t=True) upperTeethJnt = pm.joint(p=upperTeeth, n='upperTeeth_zero') upperTeethJxt = pm.joint(n='upperTeeth_' + sufix_skin) pm.select(cl=True) lowerTeeth = pm.xform(self.lowerTeethGuide, q=True, ws=True, t=True) lowerTeethJnt = pm.joint(p=lowerTeeth, n='lowerTeeth_zero') lowerTeethJxt = pm.joint(n='lowerTeeth_' + sufix_skin) teethUpCtrl = controlTools.cntrlCrv(name='teeth_up_ctrl', obj=upperTeethJxt, connType='connection', size=.5, icone='upTeeth') teethDwCtrl = controlTools.cntrlCrv(name='teeth_dw_ctrl', obj=lowerTeethJxt, connType='connection', size=.5, icone='dwTeeth') pm.parent(upperTeethJnt, upperLipJnt) pm.parent(lowerTeethJnt, jawJnt) pm.parent(L_cornerJnt, R_cornerJnt, jawZero, upperLipJnt, L_ikh[0], R_ikh[0], moveall) pm.parent(jawCntrl.getParent(), tongueFirstCtrl.getParent(), teethUpCtrl.getParent(), teethDwCtrl.getParent(), constrained_grp)
def doRig(self): # se nao tiver guide, faz if not self.guideMoveall: self.doGuide() # se ja existir rig, apaga cntrlName = self.moveallSetup['nameTempl'] if pm.objExists(cntrlName): pm.delete(cntrlName) # cria o moveall da espinha self.moveall = pm.group(n=cntrlName, em=True) pos = pm.xform(self.guideMoveall, q=True, ws=True, t=True) pm.xform(self.moveall, ws=True, t=pos) if not pm.objExists('MOVEALL'): pm.group(self.moveall, n='MOVEALL') else: pm.parent(self.moveall, 'MOVEALL') spineRibbon = None # cria controles fk com nomes e setagem de display vindas do spineDict displaySetup = self.hipCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.cogCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.startGuide, **displaySetup) displaySetup = self.spineFkCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.spineFkCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.startGuide, **displaySetup) self.spineFkCntrl.getParent().setParent(self.cogCntrl) displaySetup = self.startFkCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.startFkCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.startGuide, **displaySetup) self.startFkCntrl.getParent().setParent(self.cogCntrl) displaySetup = self.midFkCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.midFkCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.midGuide, **displaySetup) displaySetup = self.midFkOffsetCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.midFkOffsetCntrl = controlTools.cntrlCrv( name=cntrlName, obj=self.midGuide, **displaySetup ) # esse controle faz o offset do ribbon e permanece orientado corretamente self.midFkOffsetCntrl.getParent().setParent(self.midFkCntrl) self.midFkCntrl.getParent().setParent(self.spineFkCntrl) displaySetup = self.endFkCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.endFkCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.endGuide, **displaySetup) self.endFkCntrl.getParent().setParent(self.midFkCntrl) # cria controles ik com nomes e setagem de display vindas do spineDict displaySetup = self.startIkCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.startIkCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.startGuide, **displaySetup) self.startIkCntrl.getParent().setParent(self.cogCntrl) displaySetup = self.midIkCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.midIkCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.midGuide, **displaySetup) displaySetup = self.endIkCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.endIkCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.endGuide, **displaySetup) self.endIkCntrl.getParent().setParent(self.cogCntrl) # Cria os joints orientados em X down start = pm.xform(self.startGuide, q=True, t=True, ws=True) startTip = pm.xform(self.startTipGuide, q=True, t=True, ws=True) pm.select(cl=True) jntName = self.startJntSetup['nameTempl'] + self.zeroJxtSulfix self.startZeroJnt = pm.joint(p=(0, 0, 0), n=jntName) pm.select(cl=True) jntName = self.startJntSetup['nameTempl'] + self.jntSulfix self.startJnt = pm.joint(p=(0, 0, 0), n=jntName) self.skinJoints.append(self.startJnt) pm.select(cl=True) jntName = self.startJntSetup['nameTempl'] + self.tipJxtSulfix self.startTipJnt = pm.joint(p=(0, 0, 0), n=jntName) A = om.MVector(start) B = om.MVector(startTip) Z = om.MVector(0, 0, 1) AB = B - A dot = Z.normal() * AB.normal( ) # se o eixo Z, usado como secundario, for quase paralelo ao vetor do Bone, troca pra eixo Y como secundario # vai acontecer qnd usarem a guide horizontal if abs(dot) > .95: Z = om.MVector(0, 1, 0) n = AB ^ Z m = matrixTools.orientMatrix(mvector=AB, normal=n, pos=A, axis=self.axis) pm.xform(self.startZeroJnt, m=m, ws=True) pm.xform(self.startJnt, m=m, ws=True) pm.xform(self.startTipJnt, m=m, ws=True) pm.xform(self.startTipJnt, t=B, ws=True) pm.parent(self.startJnt, self.startZeroJnt) pm.parent(self.startTipJnt, self.startJnt) end = pm.xform(self.endGuide, q=True, t=True, ws=True) endTip = pm.xform(self.endTipGuide, q=True, t=True, ws=True) pm.select(cl=True) jntName = self.endJntSetup['nameTempl'] + self.zeroJxtSulfix self.endZeroJnt = pm.joint(p=(0, 0, 0), n=jntName) pm.select(cl=True) jntName = self.endJntSetup['nameTempl'] + self.jntSulfix self.endJnt = pm.joint(p=(0, 0, 0), n=jntName) self.skinJoints.append(self.endJnt) pm.select(cl=True) jntName = self.endJntSetup['nameTempl'] + self.tipJxtSulfix self.endTipJnt = pm.joint(p=(0, 0, 0), n=jntName) A = om.MVector(end) B = om.MVector(endTip) Z = om.MVector(0, 0, 1) AB = B - A dot = Z.normal() * AB.normal( ) # se o eixo Z, usado como secundario, for quase paralelo ao vetor do Bone, troca pra eixo Y como secundario if abs(dot) > .95: Z = om.MVector(0, 1, 0) n = AB ^ Z m = matrixTools.orientMatrix(mvector=AB, normal=n, pos=A, axis=self.axis) pm.xform(self.endZeroJnt, m=m, ws=True) pm.xform(self.endJnt, m=m, ws=True) pm.xform(self.endTipJnt, m=m, ws=True) pm.xform(self.endTipJnt, t=B, ws=True) pm.parent(self.endJnt, self.endZeroJnt) pm.parent(self.endTipJnt, self.endJnt) # cria os extratores de twist dos joints inicial e final # IMPLEMENTAR: twist do controle do meio twistExtractor1 = twistExtractor.twistExtractor(self.startJnt, flipAxis=True, name=self.name + 'TwistExtractor1') twistExtractor2 = twistExtractor.twistExtractor(self.endJnt, name=self.name + 'TwistExtractor2') twistExtractor1.extractorGrp.visibility.set(False) twistExtractor2.extractorGrp.visibility.set(False) # ribbon # calcular a distancia entre os guides pra fazer ribbon do tamanho certo A = om.MVector(start) B = om.MVector(end) Z = om.MVector(0, 0, -1) AB = B - A dot = Z.normal() * AB.normal( ) # se o eixo Z, usado como secundario, for quase paralelo ao vetor do Bone, troca pra eixo Y como secundario if abs(dot) > .95: Z = om.MVector(0, -1, 0) spineRibbon = ribbonBezierSimple.RibbonBezierSimple( name=self.name + 'Ribbon_', size=AB.length(), offsetStart=0.05, offsetEnd=0.05, numJnts=self.ribbonJntNum) spineRibbon.doRig() self.skinJoints += spineRibbon.skinJoints # cria o sistema que vai orientar o controle do meio por calculo vetorial aimTwist = aimTwistDivider.AimTwistDivider(name=self.name + 'TwistDivider') aimTwist.start.setParent(spineRibbon.startCntrl, r=True) aimTwist.end.setParent(spineRibbon.endCntrl, r=True) aimTwist.mid.setParent(spineRibbon.moveall, r=True) # calculo para determinar a rotacao do ribbon # hardcoded orientacao X down do ribbon para funcionar com o extractor n = AB ^ Z x = n.normal() ^ AB.normal() t = x.normal() ^ n.normal() list = [ t.x, t.y, t.z, 0, n.normal().x, n.normal().y, n.normal().z, 0, x.x * -1, x.y * -1, x.z * -1, 0, A.x, A.y, A.z, 1 ] m = om.MMatrix(list) pm.xform(spineRibbon.moveall, m=m, ws=True) ##Liga os controles do meio do ik e do meioOffset fk no aimTwist # eles trabalharam somente por translacao pm.pointConstraint(self.startIkCntrl, self.endIkCntrl, self.midIkCntrl.getParent(), mo=True) pm.orientConstraint(aimTwist.mid, self.midIkCntrl, mo=True) self.midIkCntrl.rotate.lock() self.midIkCntrl.rotate.setKeyable(0) pm.orientConstraint(aimTwist.mid, self.midFkOffsetCntrl, mo=True) self.midFkOffsetCntrl.rotate.lock() self.midFkOffsetCntrl.rotate.setKeyable(0) self.midIkCntrl.addAttr('twist', at='float', dv=0, k=1) self.midIkCntrl.twist >> spineRibbon.midCntrl.twist # faz os constraints do ribbon nos controles ik e fk pra fazer blend cns1 = pm.parentConstraint(self.startFkCntrl, self.startIkCntrl, spineRibbon.startCntrl, mo=True) mid = pm.xform(self.midGuide, q=True, t=True, ws=True) pm.xform(spineRibbon.midCntrl.getParent(), t=mid, ws=True) cns2 = pm.parentConstraint(self.midFkOffsetCntrl, self.midIkCntrl, spineRibbon.midCntrl, mo=True) cns3 = pm.parentConstraint(self.endFkCntrl, self.endIkCntrl, spineRibbon.endCntrl, mo=True) # parenteia os joints das pontas nos controles do ribbon self.startZeroJnt.setParent(spineRibbon.startCntrl.getParent()) self.endZeroJnt.setParent(spineRibbon.endCntrl.getParent()) # e cria os constraints point no start joint zero e orient no start joint # o joint zero eh necessario para o twist extractor pm.pointConstraint(spineRibbon.startCntrl, self.startZeroJnt, mo=True) pm.orientConstraint(spineRibbon.startCntrl, self.startJnt, mo=True) pm.pointConstraint(spineRibbon.endCntrl, self.endZeroJnt, mo=True) pm.orientConstraint(spineRibbon.endCntrl, self.endJnt, mo=True) # e parenteia todo mundo pm.parent(twistExtractor1.extractorGrp, twistExtractor2.extractorGrp, spineRibbon.moveall, self.cogCntrl) pm.parent(self.midIkCntrl.getParent(), self.cogCntrl.getParent(), self.moveall) # conecta os twist extractors nos twists do ribbon twistExtractor1.extractor.extractTwist >> spineRibbon.startCntrl.twist twistExtractor2.extractor.extractTwist >> spineRibbon.endCntrl.twist # cria o node tree do blend ikfk self.moveall.addAttr('ikfk', at='float', max=1, min=0, dv=1, k=1) ikfkRev = pm.createNode('reverse', n=self.name + 'IffkReverse') ikfkCond1 = pm.createNode('condition', n=self.name + 'IffkCond1') ikfkCond2 = pm.createNode('condition', n=self.name + 'IffkCond2') self.moveall.ikfk >> ikfkCond1.firstTerm self.moveall.ikfk >> ikfkCond2.firstTerm self.moveall.ikfk >> ikfkRev.inputX # visibilidade ik fk ikfkCond1.secondTerm.set(0) ikfkCond1.operation.set(2) ikfkCond1.colorIfTrueR.set(1) ikfkCond1.colorIfFalseR.set(0) ikfkCond1.outColorR >> self.startIkCntrl.getParent().visibility ikfkCond1.outColorR >> self.midIkCntrl.getParent().visibility ikfkCond1.outColorR >> self.endIkCntrl.getParent().visibility ikfkCond2.secondTerm.set(1) ikfkCond2.operation.set(4) ikfkCond2.colorIfTrueR.set(1) ikfkCond2.colorIfFalseR.set(0) ikfkCond2.outColorR >> self.startFkCntrl.getParent().visibility ikfkCond2.outColorR >> self.spineFkCntrl.getParent().visibility # blend dos constraints weightAttr = cns1.target.connections( p=True, t='parentConstraint') # descobre parametros self.moveall.ikfk >> weightAttr[1] ikfkRev.outputX >> weightAttr[0] weightAttr = cns2.target.connections( p=True, t='parentConstraint') # descobre parametros self.moveall.ikfk >> weightAttr[1] ikfkRev.outputX >> weightAttr[0] weightAttr = cns3.target.connections( p=True, t='parentConstraint') # descobre parametros self.moveall.ikfk >> weightAttr[1] ikfkRev.outputX >> weightAttr[0]
def doRig(self, upVectorObj=None): sufix_skin = 'jxt' sufix = 'end' if not self.guideMoveall: self.doGuide() self.guideMoveall.visibility.set(0) if pm.objExists(self.name + "Ctrl_grp"): pm.delete(self.name + "Ctrl_grp") if pm.objExists(self.name + 'Sys_grp'): pm.delete(self.name + 'Sys_grp') self.moveall = pm.group(em=True, n=self.name + 'Sys_grp') self.moveall.visibility.set(0) if pm.objExists('head_contrained'): constrained_grp = 'head_contrained' else: constrained_grp = pm.group(n='head_contrained', em=True) L_eyeTranslate = pm.xform(self.L_eyeLookAtGuide, q=True, ws=True, t=True) L_eyeRotate = pm.xform(self.L_eyeLookAtGuide, q=True, ws=True, ro=True) R_eyeTranslate = pm.xform(self.R_eyeLookAtGuide, q=True, ws=True, t=True) R_eyeRotate = pm.xform(self.R_eyeLookAtGuide, q=True, ws=True, ro=True) pm.select(cl=True) L_eyeJntZero = pm.joint(p=L_eyeTranslate, n='L_eye_zero') L_eyeJntSkin = pm.joint(p=L_eyeTranslate, n='L_eye_' + sufix_skin) pm.xform(L_eyeJntZero, ws=True, ro=L_eyeRotate) pm.select(cl=True) R_eyeJntZero = pm.joint(p=R_eyeTranslate, n='R_eye_zero') R_eyeJntSkin = pm.joint(p=R_eyeTranslate, n='R_eye_' + sufix_skin) pm.xform(R_eyeJntZero, ws=True, ro=R_eyeRotate) self.L_eye_loc1 = pm.spaceLocator(n=L_eyeJntSkin + '1_loc', ) self.R_eye_loc1 = pm.spaceLocator(n=R_eyeJntSkin + '1_loc', ) self.L_eye_loc1.translate.set(L_eyeTranslate) self.R_eye_loc1.translate.set(R_eyeTranslate) self.L_eye_loc1.visibility.set(0) self.R_eye_loc1.visibility.set(0) self.L_eye_loc2 = pm.spaceLocator(n=L_eyeJntSkin + '2_loc', ) self.R_eye_loc2 = pm.spaceLocator(n=R_eyeJntSkin + '2_loc', ) self.L_eye_loc2.translate.set(L_eyeTranslate) self.R_eye_loc2.translate.set(R_eyeTranslate) self.L_eye_loc2.visibility.set(0) self.R_eye_loc2.visibility.set(0) ctrlGrp = pm.group(em=True, n=self.name+'Ctrl_grp') pm.addAttr(ctrlGrp, ln='ikFk', k=True, dv=0, max=1, min=0) Lbld = pm.createNode('blendColors', n='L_eyeDirIkfkBlend') Rbld = pm.createNode('blendColors', n='R_eyeDirIkfkBlend') self.L_eye_loc1.rotate >> Lbld.color1 self.R_eye_loc1.rotate >> Rbld.color1 self.L_eye_loc2.rotate >> Lbld.color2 self.R_eye_loc2.rotate >> Rbld.color2 ctrlGrp.ikFk >> Lbld.blender ctrlGrp.ikFk >> Rbld.blender Lbld.output >> L_eyeJntSkin.rotate Rbld.output >> R_eyeJntSkin.rotate self.L_lookAt_ctrl = controlTools.cntrlCrv(name='L_lookAt_ctrl', obj=self.L_lookAtGuide, align='posRot', connType=None, size=.3, icone='circuloZ') self.R_lookAt_ctrl = controlTools.cntrlCrv(name='R_lookAt_ctrl', obj=self.R_lookAtGuide, align='posRot', connType=None, size=.3, icone='circuloZ') self.L_rotate_ctrl = controlTools.cntrlCrv(name='L_Rotate_ctrl', obj=self.L_eye_loc2, align='posRot', connType='connectionR', size=.6, icone='ponteiroReto_Z') self.R_rotate_ctrl = controlTools.cntrlCrv(name='R_Rotate_ctrl', obj=self.R_eye_loc2, align='posRot', connType='connectionR', size=.6, icone='ponteiroReto_Z') self.lookAt_ctrl = controlTools.cntrlCrv(name='lookAt_ctrl', obj=None, connType=None, size=1, icone='circuloZ') rev = pm.createNode('reverse', n='eyeDirIkFkVizRev') ctrlGrp.ikFk >> rev.input.inputX ctrlGrp.ikFk >> self.lookAt_ctrl.getParent().visibility rev.output.outputX >> self.L_rotate_ctrl.getParent().visibility rev.output.outputX >> self.R_rotate_ctrl.getParent().visibility pm.delete(pm.parentConstraint(self.L_lookAt_ctrl, self.R_lookAt_ctrl, self.lookAt_ctrl.getParent(), mo=False)) pm.addAttr(self.lookAt_ctrl, ln='followHead', k=True) pm.move(0, -.6, 0, self.lookAt_ctrl + '.cv[1]', r=1, os=1, wd=1) pm.move(-.2, 0, 0, self.lookAt_ctrl + '.cv[3]', r=1, os=1, wd=1) pm.move(0, .5, 0, self.lookAt_ctrl + '.cv[5]', r=1, os=1, wd=1) pm.move(.2, 0, 0, self.lookAt_ctrl + '.cv[7]', r=1, os=1, wd=1) for ctrl in [self.L_rotate_ctrl, self.R_rotate_ctrl]: ctrl.translateZ.lock() ctrl.scale.lock() ctrl.visibility.lock() ctrl.translateX.setKeyable(0) ctrl.translateY.setKeyable(0) ctrl.translateZ.setKeyable(0) ctrl.scaleX.setKeyable(0) ctrl.scaleY.setKeyable(0) ctrl.scaleZ.setKeyable(0) ctrl.visibility.setKeyable(0) for ctrl in [self.L_lookAt_ctrl, self.R_lookAt_ctrl, self.L_lookAt_ctrl]: ctrl.translateZ.lock() ctrl.rotate.lock() ctrl.scale.lock() ctrl.visibility.lock() ctrl.translateZ.setKeyable(0) ctrl.rotateX.setKeyable(0) ctrl.rotateY.setKeyable(0) ctrl.rotateZ.setKeyable(0) ctrl.scaleX.setKeyable(0) ctrl.scaleY.setKeyable(0) ctrl.scaleZ.setKeyable(0) ctrl.visibility.setKeyable(0) if not upVectorObj: pm.aimConstraint(self.L_lookAt_ctrl, self.L_eye_loc1, offset=(0, 0, 0), weight=1, aimVector=[0, 0, 1], upVector=[0, 1, 0], worldUpType="objectrotation", worldUpObject=self.lookAt_ctrl) pm.aimConstraint(self.R_lookAt_ctrl, self.R_eye_loc1, offset=(0, 0, 0), weight=1, aimVector=[0, 0, 1], upVector=[0, 1, 0], worldUpType="objectrotation", worldUpObject=self.lookAt_ctrl) else: pm.aimConstraint(self.L_lookAt_ctrl, self.L_eye_loc1, offset=(0, 0, 0), weight=1, aimVector=[0, 0, 1], upVector=[0, 1, 0], worldUpType="objectrotation", worldUpObject=upVectorObj, worldUpVector=[1, 0, 0]) pm.aimConstraint(self.R_lookAt_ctrl, self.R_eye_loc1, offset=(0, 0, 0), weight=1, aimVector=[0, 0, 1], upVector=[0, 1, 0], worldUpType="objectrotation", worldUpObject=upVectorObj, worldUpVector=[1, 0, 0]) pm.parent(L_eyeJntZero, R_eyeJntZero, self.moveall) pm.parent(self.L_lookAt_ctrl.getParent(), self.R_lookAt_ctrl.getParent(), self.lookAt_ctrl) pm.parent(self.L_rotate_ctrl.getParent(), self.R_rotate_ctrl.getParent(), self.L_eye_loc1, self.R_eye_loc1, self.L_eye_loc2, self.R_eye_loc2, self.lookAt_ctrl.getParent(), ctrlGrp) pm.parent(ctrlGrp, constrained_grp)
def doGuide(self, eyeball=None, edgeLoop=None, autoExtremes=True, **kwargs): self.__dict__.update(kwargs) if pm.objExists(self.name + 'Crv_grp'): pm.delete(self.name + 'Crv_grp') self.guideMoveall = self.createCntrl('moveallGuide') self.eyeCenter = self.createCntrl(setupName='eyeCenterGuide', nameTempl=self.name + 'EyeCenter' + self.guideSulfix) self.inCorner = self.createCntrl(setupName='cornersGuide', nameTempl=self.name + 'InCorner' + self.guideSulfix) self.outCorner = self.createCntrl(setupName='cornersGuide', nameTempl=self.name + 'OutCorner' + self.guideSulfix) self.upCorner = self.createCntrl(setupName='cornersGuide', nameTempl=self.name + 'UpCorner' + self.guideSulfix) self.lowCorner = self.createCntrl(setupName='cornersGuide', nameTempl=self.name + 'LowCorner' + self.guideSulfix) pm.parent(self.eyeCenter, self.inCorner, self.outCorner, self.upCorner, self.lowCorner, self.guideMoveall) crvGrp = pm.group(n=self.name + 'Crv_grp', em=True) clsGuideGrp = pm.group(em=True, n=self.name + 'crvCtrlGuideClusters', p=crvGrp) clsGuideGrp.visibility.set(False) ctrlGuideGrp = pm.group(em=True, n=self.name + 'crvCtrlsGuide', p=self.guideMoveall) if eyeball: bbox = eyeball.getBoundingBox(space='world') pos = bbox.center() self.guideDict['moveall'][0] = (pos[0], pos[1], pos[2]) else: logger.debug('no eyeball passed') if edgeLoop: self.edgeLoop = edgeLoop self.meshName = self.edgeLoop[0].name().split('.')[0] self.mesh = pm.PyNode(self.meshName) else: logger.debug('no edgeloop passed') #self.mesh = None self.edgeLoop = None if autoExtremes: try: pts = getEdgeLoopExtremesPoints(self.edgeLoop) inPos = pm.xform(pts[0], q=True, ws=True, t=True) outPos = pm.xform(pts[1], q=True, ws=True, t=True) upPos = pm.xform(pts[2], q=True, ws=True, t=True) lowPos = pm.xform(pts[3], q=True, ws=True, t=True) self.guideDict['inCorner'] = [inPos, (0, 0, 0)] self.guideDict['outCorner'] = [outPos, (0, 0, 0)] self.guideDict['upCorner'] = [upPos, (0, 0, 0)] self.guideDict['lowCorner'] = [lowPos, (0, 0, 0)] except: logger.debug('not possible autoextremes') self.setCntrl(self.guideMoveall, 'moveall', space='world') self.setCntrl(self.eyeCenter, 'eyeCenter', space='object') self.setCntrl(self.inCorner, 'inCorner', space='world') self.setCntrl(self.outCorner, 'outCorner', space='world') self.setCntrl(self.upCorner, 'upCorner', space='world') self.setCntrl(self.lowCorner, 'lowCorner', space='world') try: upEdgeLoop = selectLoopByLocators(mesh=self.mesh, loc1=self.inCorner, loc2=self.outCorner, loc3=self.upCorner) pm.select(cl=True) pm.select(upEdgeLoop) upCrv = pm.polyToCurve(form=2, degree=3, n=self.name + 'UpperCrv', ch=False)[0] if not atStart(loc=self.inCorner, crvName=upCrv): pm.reverseCurve(upCrv, ch=False, replaceOriginal=True) lowEdgeLoop = selectLoopByLocators(mesh=self.mesh, loc1=self.inCorner, loc2=self.outCorner, loc3=self.lowCorner) pm.select(cl=True) pm.select(lowEdgeLoop) lowCrv = pm.polyToCurve(form=2, degree=3, n=self.name + 'LowerCrv', ch=False)[0] if not atStart(loc=self.inCorner, crvName=lowCrv): pm.reverseCurve(lowCrv, ch=False, replaceOriginal=True) self.upCtrlCrv = pm.rebuildCurve(upCrv, s=2, rt=0, rpo=False, ch=False, n=self.name + 'upCtrl')[0] self.lowCtrlCrv = pm.rebuildCurve(lowCrv, s=2, rt=0, rpo=False, ch=False, n=self.name + 'lowCtrl')[0] pm.delete(upCrv, lowCrv) except: logger.debug( 'Found no edgeloop by locators. Using coordinates to draw') self.upCtrlCrv = pm.curve(n=self.name + 'upCrv_guide', d=3, p=self.guideDict['upCtrlGrp']) self.setCntrl(self.upCtrlCrv, 'moveall', space='world') self.lowCtrlCrv = pm.curve(n=self.name + 'lowCrv_guide', d=3, p=self.guideDict['lowCtrlGrp']) self.setCntrl(self.lowCtrlCrv, 'moveall', space='world') self.crvGuideCtrls = {'upCtrlCrv': [], 'lowCtrlCrv': []} for crvName in ['upCtrlCrv', 'lowCtrlCrv']: crv = self.__dict__[crvName] for i in range(5): cls = pm.cluster(crv.cv[i])[1] pm.parent(cls, clsGuideGrp) ctrl = controlTools.cntrlCrv(name=self.name + crvName + str(i), align='pivot', obj=cls, connType='pointConstraint', hasZeroGrp=True, cntrlSulfix='_ctrl', icone='bola', size=.05) pm.parent(ctrl.getParent(), ctrlGuideGrp) self.crvGuideCtrls[crvName].append(ctrl) for crvName in ['upCtrlCrv', 'lowCtrlCrv']: for i in range(5): self.crvGuideCtrls[crvName][i].setTranslation( self.guideDict[crvName][i], space='object') pm.parent(self.upCtrlCrv, self.lowCtrlCrv, crvGrp, r=True) try: facialGrp = pm.PyNode('facial_guides_grp') pm.parent(self.guideMoveall, crvGrp, facialGrp) except: pass pm.addAttr(self.guideMoveall, ln='eyeLidDict', dt='string') self.guideMoveall.eyeLidDict.set(json.dumps(self.exportDict()))
def doRig(self): cnstrGrp = pm.group(em=True, n=self.name + 'EyeLid_constrained_grp') sysGrp = pm.group(em=True, n=self.name + 'EyeLidSys_grp') crvsGrp = pm.group(em=True, n=self.name + 'Curves_grp') clsGrp = pm.group(em=True, n=self.name + 'Clusters_grp') jntGrp = pm.group(em=True, n=self.name + 'Joints_grp') locGrp = pm.group(em=True, n=self.name + 'Locators_grp') if pm.objExists('head_contrained'): constrained_grp = 'head_contrained' else: constrained_grp = pm.group(n='head_contrained', em=True) pm.parent(crvsGrp, clsGrp, jntGrp, locGrp, sysGrp) sysGrp.visibility.set(False) pm.delete(self.upCtrlCrv, self.lowCtrlCrv, ch=True) self.upEdgeLoop = selectLoopByLocators(mesh=self.mesh, loc1=self.inCorner, loc2=self.outCorner, loc3=self.upCorner) pm.select(self.upEdgeLoop) upCrv = pm.polyToCurve(form=2, degree=1, n=self.name + 'UpperCrv', ch=False)[0] self.upCrv = pm.rebuildCurve(upCrv, rt=3, rpo=True, d=3, end=1, kr=0, kcp=1, kep=0, kt=0, s=25, tol=0.01, ch=False)[0] if not atStart(loc=self.inCorner, crvName=self.upCrv): pm.reverseCurve(self.upCrv, ch=False, replaceOriginal=True) self.lowEdgeLoop = selectLoopByLocators(mesh=self.mesh, loc1=self.inCorner, loc2=self.outCorner, loc3=self.lowCorner) pm.select(self.lowEdgeLoop) lowCrv = pm.polyToCurve(form=2, degree=1, n=self.name + 'LowerCrv', ch=False)[0] self.lowCrv = pm.rebuildCurve(lowCrv, rt=3, rpo=True, d=3, end=1, kr=0, kcp=1, kep=0, kt=0, s=25, tol=0.01, ch=False)[0] if not atStart(loc=self.inCorner, crvName=self.lowCrv): pm.reverseCurve(self.lowCrv, ch=False, replaceOriginal=True) upBlink = pm.rebuildCurve(self.upCrv, s=20, rt=0, rpo=False, ch=False, n=self.name + 'upBlink')[0] lowBlink = pm.rebuildCurve(self.lowCrv, s=20, rt=0, rpo=False, ch=False, n=self.name + 'lowBlink')[0] upTarget = pm.rebuildCurve(self.upCrv, s=20, rt=0, rpo=False, ch=False, n=self.name + 'upTarget')[0] lowTarget = pm.rebuildCurve(self.lowCrv, s=20, rt=0, rpo=False, ch=False, n=self.name + 'lowTarget')[0] midTarget = pm.rebuildCurve(self.lowCrv, s=20, rt=0, rpo=False, ch=False, n=self.name + 'midTarget')[0] pm.parent(upTarget, lowTarget, midTarget, lowBlink, upBlink, self.upCtrlCrv, self.lowCtrlCrv, self.upCrv, self.lowCrv, crvsGrp) w1 = pm.wire(self.upCrv, w=upBlink)[0] w2 = pm.wire(self.lowCrv, w=lowBlink)[0] w3 = pm.wire(upTarget, w=self.upCtrlCrv)[0] w4 = pm.wire(lowTarget, w=self.lowCtrlCrv)[0] bs_upBlink = pm.blendShape(upTarget, midTarget, upBlink, n=self.name + "blendShapeUpBlink") bs_lowBlink = pm.blendShape(lowTarget, midTarget, lowBlink, n=self.name + "blendShapeLowBlink") bs_mid = pm.blendShape(lowTarget, upTarget, midTarget, n=self.name + "blendShapeLowBlink") # setting blendshape reverse connections rev_node = pm.createNode("reverse") pm.connectAttr(bs_upBlink[0].attr(midTarget.name()), rev_node + ".inputX") pm.connectAttr(rev_node + ".outputX", bs_upBlink[0].attr(upTarget.name())) rev_node = pm.createNode("reverse") pm.connectAttr(bs_lowBlink[0].attr(midTarget.name()), rev_node + ".inputX") pm.connectAttr(rev_node + ".outputX", bs_lowBlink[0].attr(lowTarget.name())) rev_node = pm.createNode("reverse") pm.connectAttr(bs_mid[0].attr(upTarget.name()), rev_node + ".inputX") pm.connectAttr(rev_node + ".outputX", bs_mid[0].attr(lowTarget.name())) # setting default values bs_mid[0].attr(upTarget.name()).set(.3) cvsUp = self.upCtrlCrv.getCVs(space="world") cvsLow = self.lowCtrlCrv.getCVs(space="world") upCtrls = [] lowCtrls = [] cornerCtrls = [] for i in range(1, 4): pos = cvsUp[i] clsUp = pm.cluster(self.upCtrlCrv.cv[i], n=self.name + 'ClsUp' + str(i))[1] pm.group() rp = pm.xform(clsUp, q=True, rp=True, ws=True) grp = pm.group(em=True, n=clsUp.name() + 'off1_grp') pm.xform(grp, t=rp, ws=True) grp1 = pm.duplicate(grp, n=clsUp.name() + 'off2_grp')[0] pm.parent(grp, grp1) pm.parent(clsUp.getParent(), grp) pm.parent(grp1, clsGrp) ctrlUp = controlTools.cntrlCrv(name=self.name + 'EyeLidUp' + str(i), obj=clsUp, connType='connection', hasZeroGrp=True, cntrlSulfix='_ctrl', icone='circuloZ', size=.1, offsets=1) ctrlUp.getParent().translate >> grp.translate ctrlUp.getParent().rotate >> grp.rotate ctrlUp.getParent().scale >> grp.scale pm.xform(ctrlUp.getParent(2), ws=True, t=pos) pm.parent(ctrlUp.getParent(2), cnstrGrp) upCtrls.append(ctrlUp) pos = cvsLow[i] clsLow = pm.cluster(self.lowCtrlCrv.cv[i], n=self.name + 'ClsLow' + str(i))[1] pm.group() rp = pm.xform(clsLow, q=True, rp=True, ws=True) grp = pm.group(em=True, n=clsLow.name() + 'off1_grp') pm.xform(grp, t=rp, ws=True) grp1 = pm.duplicate(grp, n=clsLow.name() + 'off2_grp')[0] pm.parent(grp, grp1) pm.parent(clsLow.getParent(), grp) pm.parent(grp1, clsGrp) ctrlLow = controlTools.cntrlCrv(name=self.name + 'EyeLidLow' + str(i), obj=clsLow, connType='connection', hasZeroGrp=True, cntrlSulfix='_ctrl', icone='circuloZ', size=.1, offsets=1) ctrlLow.getParent().translate >> grp.translate ctrlLow.getParent().rotate >> grp.rotate ctrlLow.getParent().scale >> grp.scale pm.xform(ctrlLow.getParent(2), ws=True, t=pos) pm.parent(ctrlLow.getParent(2), cnstrGrp) lowCtrls.append(ctrlLow) for i in [0, 4]: pos = cvsUp[i] clsCorner = pm.cluster(self.upCtrlCrv.cv[i], self.lowCtrlCrv.cv[i], n=self.name + 'ClsCorner' + str(i))[1] pm.group() rp = pm.xform(clsCorner, q=True, rp=True, ws=True) grp = pm.group(em=True, n=clsCorner.name() + 'off1_grp') pm.xform(grp, t=rp, ws=True) grp1 = pm.duplicate(grp, n=clsCorner.name() + 'off2_grp')[0] pm.parent(grp, grp1) pm.parent(clsCorner.getParent(), grp) pm.parent(grp1, clsGrp) ctrlCorner = controlTools.cntrlCrv(name=self.name + 'EyeLidCorner' + str(i), obj=clsCorner, connType='connection', hasZeroGrp=True, cntrlSulfix='_ctrl', icone='circuloZ', size=.1, offsets=1) pm.xform(ctrlCorner.getParent(2), ws=True, t=pos) pm.parent(ctrlCorner.getParent(2), cnstrGrp) cornerCtrls.append(ctrlCorner) upCrvNode = pm.PyNode(self.upCrv) lowCrvNode = pm.PyNode(self.lowCrv) centerPos = pm.xform(self.eyeCenter, q=True, ws=True, t=True) cvs = upCrvNode.getCVs(space="world") aimLocs = [] for i, pos in enumerate(cvs): pm.select(cl=True) jntBase = pm.joint(p=centerPos, n=self.name + 'EyelidUp_' + str(i) + '_zero') jnt = pm.joint(p=pos, n=self.name + 'EyelidUp_' + str(i) + '_jnt') self.skinJoints.append(jnt.name()) pm.joint(jntBase, e=True, zso=True, oj='xyz', sao='yup') pm.parent(jntBase, jntGrp) loc = pm.spaceLocator(p=[0, 0, 0], n=jnt.name() + 'UpAim_loc') loc.translate.set(pos) loc.localScale.set(.01, .01, .01) pm.aimConstraint(loc, jntBase, aim=(1, 0, 0), u=(0, 1, 0), wut='vector', wu=(0, 1, 0)) pm.parent(loc, locGrp) aimLocs.append(loc) pm.select(aimLocs, self.upCrv) attachTools.hookOnCurve(tangent=False) cvs = lowCrvNode.getCVs(space="world") aimLocs = [] for i, pos in enumerate(cvs): pm.select(cl=True) jntBase = pm.joint(p=centerPos, n=self.name + 'EyelidLw_' + str(i) + '_zero') jnt = pm.joint(p=pos, n=self.name + 'EyelidLw_' + str(i) + '_jnt') self.skinJoints.append(jnt.name()) pm.joint(jntBase, e=True, zso=True, oj='xyz', sao='yup') pm.parent(jntBase, jntGrp) loc = pm.spaceLocator(p=[0, 0, 0], n=jnt.name() + 'LwAim_loc') loc.translate.set(pos) loc.localScale.set(.01, .01, .01) pm.aimConstraint(loc, jntBase, aim=(1, 0, 0), u=(0, 1, 0), wut='vector', wu=(0, 1, 0)) pm.parent(loc, locGrp) aimLocs.append(loc) pm.select(aimLocs, self.lowCrv) attachTools.hookOnCurve(tangent=False) pm.parentConstraint(upCtrls[1], cornerCtrls[0], upCtrls[0].getParent(), mo=1) pm.parentConstraint(upCtrls[1], cornerCtrls[1], upCtrls[2].getParent(), mo=1) pm.parentConstraint(lowCtrls[1], cornerCtrls[0], lowCtrls[0].getParent(), mo=1) pm.parentConstraint(lowCtrls[1], cornerCtrls[1], lowCtrls[2].getParent(), mo=1) up_ctl = upCtrls[1] pm.addAttr(up_ctl, ln="blink", at="float", dv=0, minValue=0, maxValue=1, k=True) pm.addAttr(up_ctl, ln="blinkMult", at="float", dv=1, minValue=1, maxValue=2, k=True) pm.addAttr(up_ctl, ln="blinkHeight", at="float", dv=0.3, minValue=0, maxValue=1, k=True) pm.addAttr(up_ctl, ln="fleshyEye", at="float", dv=0.5, minValue=0, maxValue=1, k=True) fleshyEye_loc = pm.spaceLocator(n=self.name + 'FleshyEye_loc') fleshyEye_loc.visibility.set(0) pm.parent(fleshyEye_loc, cnstrGrp) pm.xform(fleshyEye_loc, t=centerPos, ws=True) pm.parentConstraint(fleshyEye_loc, upCtrls[1].getParent(), mo=1) pm.parentConstraint(fleshyEye_loc, lowCtrls[1].getParent(), mo=1) fleshyEyeMulti = pm.createNode('multiplyDivide', name=self.name + 'multiFleshy') fleshyEyeMulti.output.outputX >> fleshyEye_loc.rotate.rotateX fleshyEyeMulti.output.outputY >> fleshyEye_loc.rotate.rotateY fleshyEyeMulti.output.outputZ >> fleshyEye_loc.rotate.rotateZ up_ctl.fleshyEye >> fleshyEyeMulti.input2.input2X up_ctl.fleshyEye >> fleshyEyeMulti.input2.input2Y up_ctl.fleshyEye >> fleshyEyeMulti.input2.input2Z mult_node = pm.createNode('multDoubleLinear', name=self.name + 'multBlink') up_ctl.blink >> mult_node.input1 up_ctl.blinkMult >> mult_node.input2 mult_node.output >> bs_upBlink[0].attr(midTarget.name()) mult_node.output >> bs_lowBlink[0].attr(midTarget.name()) up_ctl.blinkHeight >> bs_mid[0].attr(upTarget.name()) reverse_node = pm.createNode('reverse', name=self.name + 'blinkReverse') up_ctl.blink >> reverse_node.inputX reverse_node.outputX >> w1.scale[0] reverse_node.outputX >> w2.scale[0] reverse_node.outputX >> w3.scale[0] reverse_node.outputX >> w4.scale[0] self.guideMoveall.visibility.set(0) pm.parent(cnstrGrp, constrained_grp)
def ctrlButtonClicked(self, button): last = None color = None offsets = 0 sel = pm.ls(sl=True) if not sel: logger.warn('Selecione objetos q serao controlados!!') return createOffsets = self.ui.offsetGroups_chk.isChecked() offsetNumber = self.ui.offsetsNumber_spin.value() autoColor = self.ui.autoColor_chk.isChecked() autoParent = self.ui.parentSelectOrder_chk.isChecked() controlShape = button.whatsThis() connectionType = self.ui.connectionType_comboBox.currentText() globalSize = self.ui.globalScale_spin.value() if connectionType == 'change Shape': logger.warn('Change Shape!') return if createOffsets: offsets = offsetNumber pm.undoInfo(openChunk=True) try: for obj in sel: ctrlName = obj.name().replace('_jnt', '_ctrl').replace('_jxt', '_ctrl').replace('_zero', '_ctrl').replace('_grp', '_ctrl').replace('_geo', '_ctrl').replace('_ikh', '_ctrl').replace('_ik', '_ctrl') if autoColor: if ctrlName.startswith('L_'): color = 6 elif ctrlName.startswith('R_'): color = 13 ctrl = controlTools.cntrlCrv(name=ctrlName, obj=obj, connType=connectionType, icone=controlShape, align='pivot', offsets=offsets, cntrlSize=globalSize, hasZeroGrp=True, cntrlSulfix='_ctrl', hasHandle=False, posRot=None, color=color, rotateOrder=0, localAxis=False, template=False, hideShape=False, lockChannels=[], returnParent=False, coords=None, parent=None) if autoParent: if createOffsets: pm.parent(ctrl.getParent(1+offsetNumber), last) else: pm.parent(ctrl.getParent(), last) last = ctrl finally: pm.undoInfo(closeChunk=True)
def featherSys(self, base, moduleSysGrp): sysGrp = groupTools.makeGroup(name=base + '_sys', suffix='', parent=moduleSysGrp) sysGrp.v.set(0) objToDeform = pm.listConnections(pm.listConnections( pm.listConnections(base.getShape())), t='mesh')[0] end = base + '_end' baseCoord = pm.xform(base, q=1, rp=1, ws=1) self.baseCoordList.append(baseCoord) endCoord = pm.xform(end, q=1, rp=1, ws=1) featherParentGrp = groupTools.makeGroup(name=base + '_parent_grp', parent=sysGrp, suffix='', coords=(baseCoord, (0, 0, 0), (1, 1, 1))) self.featherParentGrp.append(featherParentGrp) jointChain = self.createJointChain(base, [baseCoord, endCoord], parent=featherParentGrp) jntBase = jointChain[0] jntEnd = jointChain[1] ikh = pm.ikHandle(n=base + '_ikh', sj=jntBase, ee=jntEnd)[0] self.ikhNodeList.append(ikh) ikh.poleVectorX.set(0) ikh.poleVectorY.set(0) ikh.poleVectorZ.set(0) objOrient = pm.xform(jointChain[0], q=1, ro=1, ws=1) self.baseOrientList.append(objOrient) twkGrp = groupTools.makeGroup(name=base + '_twk', parent=moduleSysGrp, coords=(baseCoord, objOrient, (1, 1, 1))) twkJointChain = self.createJointChain(base + '_twk', [baseCoord, endCoord], parent=twkGrp) twkJntBase = twkJointChain[0] twkJntBase.v.set(0) twkJntEnd = twkJointChain[1] twkCtrl = controlTools.cntrlCrv(name=base + '_twk', icone='dropY', lockChannels=['v'], parent=twkGrp, coords=(baseCoord, objOrient, (1, 1, 1)), size=5) twkCtrl.translate >> twkJntBase.translate twkCtrl.rotate >> twkJntBase.rotate twkCtrl.scale >> twkJntBase.scale pm.parentConstraint(jntBase, twkGrp, mo=1) pm.scaleConstraint(jntBase, twkGrp, mo=1) ikhZero = groupTools.makeGroup(name=base + '_ikh_zero', coords=(baseCoord, objOrient, (1, 1, 1)), parent=sysGrp, suffix='') ikhGrp = groupTools.makeGroup(name=base + '_ikh_grp', coords=(baseCoord, objOrient, (1, 1, 1)), parent=ikhZero, suffix='') self.ikhDrvList.append(ikhGrp) pm.xform(ikhZero, t=(self.distance, 0, 0), os=1, r=1) ikhPosition = pm.xform(ikhZero, q=1, rp=1, ws=1) self.ikhCoordList.append(ikhPosition) ikh.setParent(ikhGrp) # criando bends: nonlinearGrp = groupTools.makeGroup(name=base + '_bend_grp', parent=sysGrp) # bend1 bendX = self.createBend(objToDeform, [baseCoord, objOrient, (1, 1, 1)], nonlinearGrp) # bend2 bendY = self.createBend(objToDeform, [baseCoord, objOrient, (1, 1, 1)], nonlinearGrp) pm.xform(bendY, ro=(0, 90, 0), os=1, r=1) self.bendList.append([bendX, bendY]) pm.skinCluster(twkJntBase, objToDeform)
def doRig(self, bsDict=None): if not self.guideMoveall: self.doGuide() self.guideMoveall.visibility.set(0) if pm.objExists(self.name + 'Moveall'): pm.delete(self.name + 'Moveall') self.moveall = pm.group(em=True, n=self.name + 'Moveall') if pm.objExists('head_contrained'): constrained_grp = 'head_contrained' else: constrained_grp = pm.group(n='head_contrained', em=True) if bsDict: self.bsDict = bsDict size=0.8 pm.select(cl=True) self.lcornerCntrl = controlTools.cntrlCrv(name='L_mouthCorner', obj=self.lcornerGuide, icone='trianguloMinusZ', size=.5) pm.addAttr (self.lcornerCntrl, ln="up", at="double") pm.addAttr (self.lcornerCntrl, ln="down", at="double") pm.addAttr (self.lcornerCntrl, ln="wide", at="double") pm.addAttr (self.lcornerCntrl, ln="narrow", at="double") pm.addAttr (self.lcornerCntrl, ln="upWide", at="double") pm.addAttr (self.lcornerCntrl, ln="upNarrow", at="double") pm.addAttr (self.lcornerCntrl, ln="downWide", at="double") pm.addAttr (self.lcornerCntrl, ln="downNarrow", at="double") attr = {self.lcornerCntrl: ["tz", "rx", "ry", "rz", "sx", "sy", "sz", "v"]} key = attr.keys () for k in key: for item in attr[k]: pm.setAttr(k + "." + item, k=False, l=True) lClampX = pm.createNode("clamp", n="l_mouthX_clamp") lClampX.maxR.set(100) lClampX.minG.set(-100) lClampY = pm.createNode("clamp", n="l_mouthY_clamp") lClampY.maxR.set(100) lClampY.minG.set(-100) lMultX = pm.createNode("multiplyDivide", n="l_mouthX_md") lMultX.input2Y.set(-1) lMultY = pm.createNode("multiplyDivide", n="l_mouthY_md") lMultY.input2Y.set(-1) self.lcornerCntrl.translateX >> lClampX.inputR self.lcornerCntrl.translateX >> lClampX.inputG lClampX.outputR >> lMultX.input1X lClampX.outputG >> lMultX.input1Y self.lcornerCntrl.translateY >> lClampY.inputR self.lcornerCntrl.translateY >> lClampY.inputG lClampY.outputR >> lMultY.input1X lClampY.outputG >> lMultY.input1Y lMultX.outputX >> self.lcornerCntrl.wide lMultX.outputY >> self.lcornerCntrl.narrow lMultY.outputX >> self.lcornerCntrl.up lMultY.outputY >> self.lcornerCntrl.down multiUpWide = pm.createNode("multiplyDivide", n="MD_l_combo_up_wide") multiUpNarrow = pm.createNode("multiplyDivide", n="MD_l_combo_up_narrow") multiDownWide = pm.createNode("multiplyDivide", n="MD_l_combo_down_wide") multiDownNarrow = pm.createNode("multiplyDivide", n="MD_l_combo_down_narrow") self.lcornerCntrl.up >> multiUpWide.input1X self.lcornerCntrl.wide >> multiUpWide.input2X multiUpWide.outputX >> self.lcornerCntrl.upWide self.lcornerCntrl.up >> multiUpNarrow.input1X self.lcornerCntrl.narrow >> multiUpNarrow.input2X multiUpNarrow.outputX >> self.lcornerCntrl.upNarrow self.lcornerCntrl.down >> multiDownWide.input1X self.lcornerCntrl.wide >> multiDownWide.input2X multiDownWide.outputX >> self.lcornerCntrl.downWide self.lcornerCntrl.down >> multiDownNarrow.input1X self.lcornerCntrl.narrow >> multiDownNarrow.input2X multiDownNarrow.outputX >> self.lcornerCntrl.downNarrow self.rcornerCntrl = controlTools.cntrlCrv(name='R_mouthCorner', obj=self.rcornerGuide, icone='trianguloMinusZ', size=.5) self.rcornerCntrl.getParent().rotateY.set(180) pm.addAttr (self.rcornerCntrl, ln="up", at="double") pm.addAttr (self.rcornerCntrl, ln="down", at="double") pm.addAttr (self.rcornerCntrl, ln="wide", at="double") pm.addAttr (self.rcornerCntrl, ln="narrow", at="double") pm.addAttr (self.rcornerCntrl, ln="upWide", at="double") pm.addAttr (self.rcornerCntrl, ln="upNarrow", at="double") pm.addAttr (self.rcornerCntrl, ln="downWide", at="double") pm.addAttr (self.rcornerCntrl, ln="downNarrow", at="double") attrR = {self.rcornerCntrl: ["tz", "rx", "ry", "rz", "sx", "sy", "sz", "v"]} keyR = attrR.keys () for kk in keyR: for cadaItem in attrR[kk]: pm.setAttr (kk + "." + cadaItem, k=False, l=True) rClampX = pm.createNode("clamp", n="l_mouthX_clamp") rClampX.maxR.set(100) rClampX.minG.set(-100) rClampY = pm.createNode("clamp", n="l_mouthY_clamp") rClampY.maxR.set(100) rClampY.minG.set(-100) rMultX = pm.createNode("multiplyDivide", n="r_mouthX_md") rMultX.input2Y.set(-1) rMultXNeg = pm.createNode("multiplyDivide", n="r_mouthX_md_neg") rMultY = pm.createNode("multiplyDivide", n="r_mouthY_md") rMultY.input2Y.set(-1) self.rcornerCntrl.translateX >> rClampX.inputR self.rcornerCntrl.translateX >> rClampX.inputG rClampX.outputR >> rMultX.input1X rClampX.outputG >> rMultX.input1Y rMultX.outputY >> rMultXNeg.input1X rMultX.outputX >> rMultXNeg.input1Y self.rcornerCntrl.translateY >> rClampY.inputR self.rcornerCntrl.translateY >> rClampY.inputG rClampY.outputR >> rMultY.input1X rClampY.outputG >> rMultY.input1Y rMultXNeg.outputY >> self.rcornerCntrl.wide rMultXNeg.outputX >> self.rcornerCntrl.narrow rMultY.outputX >> self.rcornerCntrl.up rMultY.outputY >> self.rcornerCntrl.down rMultiUpWide = pm.createNode("multiplyDivide", n="MD_r_combo_up_wide") rMultiUpNarrow = pm.createNode("multiplyDivide", n="MD_r_combo_up_narrow") rMultiDownWide = pm.createNode("multiplyDivide", n="MD_r_combo_down_wide") rMultiDwonWide = pm.createNode ("multiplyDivide", n="MD_r_combo_down_narrow") self.rcornerCntrl.up >> rMultiUpWide.input1X self.rcornerCntrl.wide >> rMultiUpWide.input2X rMultiUpWide.outputX >> self.rcornerCntrl.upWide self.rcornerCntrl.up >> rMultiUpNarrow.input1X self.rcornerCntrl.narrow >> rMultiUpNarrow.input2X rMultiUpNarrow.outputX >> self.rcornerCntrl.upNarrow self.rcornerCntrl.down >> rMultiDownWide.input1X self.rcornerCntrl.wide >> rMultiDownWide.input2X rMultiDownWide.outputX >> self.rcornerCntrl.downWide self.rcornerCntrl.down >> rMultiDwonWide.input1X self.rcornerCntrl.narrow >> rMultiDwonWide.input2X rMultiDwonWide.outputX >> self.rcornerCntrl.downNarrow pm.parent(self.lcornerCntrl.getParent(), self.rcornerCntrl.getParent(), self.moveall) pm.parent(self.moveall, constrained_grp)
def createPoseReader(self, index, parent, featherParent): baseCoord = self.baseCoordList[index] baseOrient = self.baseOrientList[index] aimCoord = self.ikhCoordList[index] name = self.featherNameList[index] ikh = self.ikhNodeList[index] ikhDrv = self.ikhDrvList[index] readerGrpName = name + '_reader' readerBaseLocName = name + '_reader_base_loc' readerAimUpLocName = name + '_reader_aim_up_loc' readerAimWorldLocName = name + '_reader_aim world_loc' readerUpLocName = name + '_reader_upVect_loc' readerAimLocName = name + '_reader_target_loc' readerMultNegName = name + '_reader_multNeg_md' readerGrp = groupTools.makeGroup(name=readerGrpName, parent=parent, coords=(aimCoord, baseOrient, (1, 1, 1))) readerGrp.v.set(0) readerBaseLoc = controlTools.cntrlCrv(icone='null', name=readerBaseLocName, cntrlSulfix='', parent=readerGrp, coords=(aimCoord, baseOrient, (1, 1, 1))) readerAimUpLoc = controlTools.cntrlCrv(icone='null', name=readerAimUpLocName, cntrlSulfix='', hasZeroGrp=0, parent=readerBaseLoc, coords=(aimCoord, baseOrient, (1, 1, 1))) readerAimWorldLoc = controlTools.cntrlCrv(icone='null', name=readerAimWorldLocName, cntrlSulfix='', hasZeroGrp=0, parent=readerAimUpLoc, coords=(aimCoord, baseOrient, (1, 1, 1))) readerUpLoc = controlTools.cntrlCrv(icone='null', name=readerUpLocName, cntrlSulfix='', parent=readerBaseLoc, coords=(aimCoord, baseOrient, (1, 1, 1))) readerTargetLoc = controlTools.cntrlCrv(icone='null', name=readerAimLocName, cntrlSulfix='', parent=readerGrp, coords=(baseCoord, baseOrient, (1, 1, 1))) pm.xform(readerUpLoc.getParent(), t=(0, 10, 0), r=1, os=1) pm.aimConstraint(readerTargetLoc, readerAimUpLoc, wuo=readerUpLoc, wut='object', u=(0, 1, 0), aim=(-1, 0, 0), mo=0) pm.aimConstraint(readerTargetLoc, readerAimWorldLoc, wut='scene', u=(0, 1, 0), aim=(-1, 0, 0), mo=0) pm.parentConstraint(featherParent, readerTargetLoc, mo=1) pm.scaleConstraint(featherParent, readerTargetLoc, mo=1) foll = attatchTools.hookOnMesh(inputs=[readerGrp, self.aimRbbn], mode=3) foll.v.set(0) readerMultNeg = pm.createNode('multDoubleLinear', n=readerMultNegName) readerAimWorldLoc.rotateX >> readerMultNeg.input1 readerMultNeg.input2.set(-1) readerMultNeg.output >> ikh.twist return self
def ctrlCurve(self, parent=None): self.curve = pm.curve(n=self.name + '_curve', d=1, p=self.ikhCoordList) if parent: self.curve.setParent(parent) pm.rebuildCurve(self.curve, s=3, d=3) # criando cluster a cada dois cvs clusterDrivers = [] # clusters curveCtrls = [] # ctrls cvsToCluster = [] poleCoords = [] drvPtvList = [] # coords de pvt dos tres drivers drvOrientList = [] # orientacao dos drivers bendCtrlList = [] index = 0 curveDrvGrp = groupTools.makeGroup(name=self.name + '_curveDrv', parent=parent) curveDrvGrp.v.set(0) ctrlGrp = groupTools.makeGroup(name=self.name + '_ctrl', parent=parent) # criando ctrl master e parenteando os outros nele: masterZeroGrp = groupTools.makeGroup(name=self.name + '_master_zero', parent=ctrlGrp) self.masterCtrl = groupTools.makeGroup(name=self.name + '_master_ctrl', suffix='', parent=masterZeroGrp) masterShape = pm.duplicate(self.curve)[0] masterShape.translateZ.set(-25) # criando uma rbbn para orientar os pose readers das penas: rbbnName = self.name + '_aimRbbn' self.aimRbbn = pm.loft(self.curve, masterShape, ch=False, ar=True, d=1, n=rbbnName)[0] self.aimRbbn.setParent(parent) self.aimRbbn.v.set(0) for e, cv in enumerate(self.curve.cv): if e == 0 or e == len(self.curve.cv) - 1: poleCoords.append(vtxWalk.bbox(cv)['globalPvt']) cvsToCluster.append(cv) for eachSpam in range(2): cvsToCluster.append( str(self.aimRbbn.name()) + '.cv[' + str(eachSpam) + '][' + str(e) + ']') index += 1 if index == 2: cluster = pm.cluster(cvsToCluster, n=self.name + '_' + str((e / 2) + 1))[1] cluster.setParent(curveDrvGrp) clusterDrivers.append(cluster) index = 0 cvsToCluster = [] # ajustando pivos dos clusters das extremidades para os extremos pm.xform(clusterDrivers[0], rp=poleCoords[0], ws=1) pm.xform(clusterDrivers[2], rp=poleCoords[1], ws=1) # criando drv ctrls para a curva for e, drv in enumerate(clusterDrivers): currentPvt = pm.xform(clusterDrivers[e], rp=1, q=1, ws=1) ctrl = controlTools.cntrlCrv(name=self.name + '_' + str(e + 1), size=20, coords=(currentPvt, (0, 0, 0), (1, 1, 1)), parent=ctrlGrp, lockChannels=[ 'v', ], color=(.9, .9, 0)) drvPtvList.append(currentPvt) curveCtrls.append(ctrl) # orientando drv ctrls: for i, ctrl in enumerate(curveCtrls): target = ctrl.getParent() if i == 0: source = curveCtrls[1] aim = (1, 0, 0) elif i == 1: source = curveCtrls[2] aim = (1, 0, 0) elif i == 2: source = curveCtrls[1] aim = (-1, 0, 0) tempConstraint = pm.aimConstraint(source, target, wut='scene', aim=aim, mo=0) pm.delete(tempConstraint) drvOrientList.append(pm.xform(ctrl, q=1, ro=1, ws=1)) # contraint do controle para os clusters: pm.parentConstraint(ctrl, clusterDrivers[i], mo=1) pm.scaleConstraint(ctrl, clusterDrivers[i], mo=1) pm.xform(masterZeroGrp, t=drvPtvList[1], ro=drvOrientList[1], ws=1) masterShape.setParent(self.masterCtrl) pm.makeIdentity(masterShape, t=1, r=1, apply=1) pm.parent(masterShape.getShape(), self.masterCtrl, r=1, s=1) pm.delete(masterShape) self.curve.getShape().template.set(1) for ctrl in curveCtrls: ctrl.getParent().setParent(self.masterCtrl) # ctrls de bend: bendCtrl1 = controlTools.cntrlCrv(name=self.name + '_bend1', icone='trianguloZ', size=15, lockChannels=['v'], coords=(drvPtvList[0], drvOrientList[0], (1, 1, 1)), parent=ctrlGrp, color=(0, .1, .5)) pm.xform(bendCtrl1, t=(0, 0, 40), ro=(0, 90, 0), r=1) pm.makeIdentity(bendCtrl1, r=1, apply=1) bendCtrl1.getParent().setParent(curveCtrls[0]) bendCtrlList.append(bendCtrl1) bendCtrl2 = controlTools.cntrlCrv(name=self.name + '_bend2', icone='trianguloZ', size=15, lockChannels=['v'], coords=(drvPtvList[2], drvOrientList[2], (1, 1, 1)), parent=ctrlGrp, color=(0, .1, .5)) pm.xform(bendCtrl2, t=(0, 0, 40), ro=(0, -90, 0), r=1) pm.makeIdentity(bendCtrl2, r=1, apply=1) bendCtrl2.getParent().setParent(curveCtrls[2]) bendCtrlList.append(bendCtrl2) return self.masterCtrl, curveCtrls, bendCtrlList
def doRig(self): if pm.objExists(self.name + 'Constrained_grp'): pm.delete(self.name + 'Constrained_grp') if pm.objExists(self.name + 'tweakSys_grp'): pm.delete(self.name + 'tweakSys_grp') cnstrGrp = pm.group(n=self.name + 'Constrained_grp', em=True) allSliderGrp = pm.group(n=self.name + 'Sliders_grp', em=True) tweakCtrlGrp = pm.group(n=self.name + 'tweakCtrls_grp', em=True) tweakJntGrp = pm.group(n=self.name + 'tweakSys_grp', em=True) pm.parent(tweakCtrlGrp, allSliderGrp, cnstrGrp) tweakJntGrp.visibility.set(False) basePos = pm.xform(self.guideMoveall, t=True, q=True, ws=True) masterSlderGrp = pm.group(em=True, name=self.name + 'global_grp') masterSliderCtrl = pm.circle(nr=(0, 0, 1), r=0.2, n=self.name + 'global_ctrl')[0] pm.parent(masterSliderCtrl, masterSlderGrp) pm.parent(masterSlderGrp, allSliderGrp) p1 = pm.xform(self.tweak4, q=True, ws=True, t=True)[0] p2 = pm.xform(self.tweak3, q=True, ws=True, t=True)[0] pm.xform(masterSlderGrp, t=(p1 + (p1 - p2), basePos[1] + 1, basePos[2] + 1), ws=True) displaySetup = self.tweakCtrlSetup.copy() tweakGuides = [self.tweak1, self.tweak2, self.tweak3, self.tweak4] slidersNames = ['In', 'MidIn', 'MidOut', 'Out'] sliderList = [] sideMove = True for i in range(4): guide = tweakGuides[i] guideXpos = pm.xform(guide, q=True, ws=True, t=True)[0] slider = createSlider(self.name + slidersNames[i], size=0.1, sideMove=sideMove) sliderList.append(slider) pm.xform(slider.getParent(), t=(guideXpos, basePos[1] + 1, basePos[2] + 1), ws=True) pm.parent(slider.getParent(), allSliderGrp) addNode = pm.createNode('addDoubleLinear') clampConn = pm.listConnections(slider.translateY, p=True, d=True) for conn in clampConn: addNode.output >> conn masterSliderCtrl.translateY >> addNode.input1 slider.translateY >> addNode.input2 pm.parent(slider.getParent(), masterSliderCtrl) cntrlName = displaySetup['nameTempl'] + str(i) jntName = self.jntSetup['nameTempl'] + str(i) jnt = jointTools.makeJoint(name=jntName, obj=guide, jntSulfix='_jxt', hasZero=True, connectToLast=False) ctrl = controlTools.cntrlCrv(name=cntrlName, obj=jnt, connType='connection', offsets=1, **displaySetup) pm.parent(jnt.getParent(), tweakJntGrp) pm.parent(ctrl.getParent(2), tweakCtrlGrp) sideMove = False self.guideMoveall.visibility.set(0)
def doRig(self): relaxOps1 = [[], [1], [.2, 1], [.2, .6, 1.0], [0.1, .33, .66, 1.0], [.2, .4, .6, .8, 1.0]] relaxOps2 = [[], [-1], [-1, -.2], [-1.0, -.6, -.2], [-1.0, -.66, -.33, -.1], [-1.0, -.8, -.6, -.4, -.2]] spreadOps = [[], [0], [-1, 1], [-1, -.1, 1], [-1, -.2, .3, 1], [-1, -.4, -.1, .4, 1]] #thumb = [x for x in self.fingers if self.fingers[x]['fingerId'] == 0] thumb = [] relax1 = relaxOps1[len(self.fingers) - len(thumb)] relax2 = relaxOps2[len(self.fingers) - len(thumb)] spread = spreadOps[len(self.fingers) - len(thumb)] if not self.guideMoveall: self.doGuide() cntrlName = self.moveallCntrlSetup['nameTempl'] if pm.objExists(cntrlName): pm.delete(cntrlName) # esqueleto center = pm.xform(self.centerGuide, q=True, ws=True, t=True) tip = pm.xform(self.tipGuide, q=True, ws=True, t=True) ankle = pm.xform(self.ankleGuide, q=True, ws=True, t=True) ball = pm.xform(self.ballGuide, q=True, ws=True, t=True) A = om.MVector(ankle) B = om.MVector(center) C = om.MVector(tip) D = om.MVector(ball) # calcula a normal do sistema no triangulo entre center, ankle e tip. # pode ser q isso de problemas se mal colocados. # IMPLEMENTAR limites dos guides para evitar ma colocacao if self.flipAxis: AB = A - B BC = B - C AD = A - D CD = D - C else: AB = B - A BC = C - B AD = D - A CD = C - D n = AB ^ BC pm.select(cl=True) m = matrixTools.orientMatrix(mvector=AD, normal=n, pos=A, axis=self.axis) jntName = self.ankleJntSetup['nameTempl'] + self.jntSulfix j1 = pm.joint(n=jntName) self.skinJoints.append(j1) pm.xform(j1, m=m, ws=True) pm.makeIdentity(j1, apply=True, r=1, t=0, s=1, n=0, pn=0) # cria os joints m = matrixTools.orientMatrix(mvector=CD, normal=n, pos=D, axis=self.axis) jntName = self.toeJntSetup['nameTempl'] + self.jntSulfix j2 = pm.joint(n=jntName) self.skinJoints.append(j2) pm.xform(j2, m=m, ws=True) pm.makeIdentity(j2, apply=True, r=1, t=0, s=1, n=0, pn=0) jntName = self.toeJntSetup['nameTempl'] + self.tipJxtSulfix j3 = pm.joint(n=jntName) self.skinJoints.append(j3) pm.xform(j3, m=m, ws=True) pm.xform(j3, t=C, ws=True) pm.makeIdentity(j3, apply=True, r=1, t=0, s=1, n=0, pn=0) # e faz os ikhandles ballIkh = pm.ikHandle(n=self.name + 'ballIKHandle', sj=j1, ee=j2, sol="ikRPsolver") tipIkh = pm.ikHandle(n=self.name + 'toeIKHandle', sj=j2, ee=j3, sol="ikRPsolver") self.moveall = pm.group(em=True, n=cntrlName) self.moveall.translate.set(center) if not pm.objExists('MOVEALL'): pm.group(self.moveall, n='MOVEALL') else: pm.parent(self.moveall, 'MOVEALL') # esse controle deve levar o controle ik da ponta do limb para funcionar o pe displaySetup = self.toLimbCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.limbConnectionCntrl = controlTools.cntrlCrv( name=cntrlName, obj=j1, connType='parentConstraint', cntrlSulfix="_null", **displaySetup) # base cntrl displaySetup = self.baseCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.baseCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.centerGuide, **displaySetup) pm.move(.8, 0.225, 0, self.baseCntrl, r=True, os=True) pm.xform(self.baseCntrl, rp=ankle, ws=True) pm.scale(self.baseCntrl, [1, .15, .5], r=True) pm.makeIdentity(self.baseCntrl, apply=True, r=0, t=1, s=1, n=0, pn=0) self.baseCntrl.addAttr('extraRollCntrls', min=0, max=1, dv=0, k=1) # slidePivot displaySetup = self.slideCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] slideCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.centerGuide, **displaySetup) slideCompensateGrp = pm.group(em=True, n=self.name + 'Slide_grp') pm.parent(slideCompensateGrp, slideCntrl, r=True) slideMulti = pm.createNode('multiplyDivide', n=self.name + 'slideMulti') slideCntrl.translate >> slideMulti.input1 slideMulti.input2.set(-1, -1, -1) slideMulti.output >> slideCompensateGrp.translate # bank cntrls displaySetupOut = self.outCntrlSetup.copy() outNameCntrl = displaySetupOut['nameTempl'] outCntrl = controlTools.cntrlCrv(name=outNameCntrl, obj=self.inGuide, **displaySetup) displaySetup = self.inCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] inCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.outGuide, **displaySetup) self.baseCntrl.extraRollCntrls >> inCntrl.getParent().visibility # tip/heel displaySetup = self.tipCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] tipCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.tipGuide, **displaySetup) displaySetup = self.heelCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] heelCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.heelGuide, **displaySetup) # toe displaySetup = self.toeCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] toeCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.ballGuide, **displaySetup) toeCntrl.translate.set(0.5, 0, 0) pm.makeIdentity(toeCntrl, apply=True, r=0, t=1, s=0, n=0, pn=0) pm.xform(toeCntrl, rp=(-0.5, 0, 0), r=True) # ball displaySetup = self.ballCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.ballCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.ballGuide, **displaySetup) # rollCntrl displaySetup = self.rollCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] rollCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.ballGuide, **displaySetup) rollCntrl.getParent().translateBy((0, 1.5, 1)) globalCtrl = pm.curve(n=self.name + 'GlobalFinger_cntrl', d=1, p=[(0, 0.25, 0), (0, 0, 0.25), (0.25, 0, 0), (0, 0.25, 0), (0, 0, -0.25), (0.25, 0, 0), (0, -0.25, 0), (0, 0, -0.25), (-0.25, 0, 0), (0, -0.25, 0), (0, 0, 0.25), (-0.25, 0, 0), (0, 0.25, 0)], k=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) globalCtrl.getShape().overrideEnabled.set(True) globalCtrlGrp = pm.group(n=self.name + 'GlobalFinger_grp') pm.parent(globalCtrlGrp, self.moveall, r=True) globalCtrlGrp.translate.set(.5, .75, 0) globalCtrl.addAttr('curl', k=1, at=float, dv=0) globalCtrl.addAttr('lean', k=1, at=float, dv=0) globalCtrl.addAttr('scrunch', k=1, at=float, dv=0) globalCtrl.addAttr('spread', k=1, at=float, dv=0) globalCtrl.addAttr('twist', k=1, at=float, dv=0) globalCtrl.addAttr('relax', k=1, at=float, dv=0) for finger in self.fingers: i = 0 f = self.fingerInstances[finger] f.flipAxis = self.flipAxis f.doRig() self.skinJoints += f.skinJoints if self.fingers[finger]['isHeelFinger']: pm.parent(f.moveall, j1) else: pm.parent(f.moveall, j2) i = f.fingerId #if f.fingerId != 0: if True: ctrlBase = f.cntrl1 twist_PMA = pm.listConnections(ctrlBase.twist, d=True)[0] globalCtrl.twist >> twist_PMA.input2D[1].input2Dx curl_PMA = pm.listConnections(ctrlBase.curl, d=True, t='plusMinusAverage') relaxMDL1 = pm.createNode('multDoubleLinear', n=self.name + 'relaxMulti1') relaxMDL1.input2.set(relax1[i]) globalCtrl.relax >> relaxMDL1.input1 relaxMDL2 = pm.createNode('multDoubleLinear', n=self.name + 'relaxMulti2') relaxMDL2.input2.set(relax2[i]) globalCtrl.relax >> relaxMDL2.input1 cond = pm.createNode('condition', n=self.name + 'relaxCond') globalCtrl.relax >> cond.firstTerm cond.secondTerm.set(0) cond.operation.set(2) relaxMDL1.output >> cond.colorIfTrue.colorIfTrueR relaxMDL2.output >> cond.colorIfFalse.colorIfFalseR for node in curl_PMA: globalCtrl.curl >> node.input1D[3] cond.outColor.outColorR >> node.input1D[4] lean_PMA = pm.listConnections(ctrlBase.lean, d=True, t='plusMinusAverage') for node in lean_PMA: globalCtrl.lean >> node.input2D[2].input2Dy scrunch_MDL = pm.listConnections( ctrlBase.scrunch, d=True, ) scrunch_PMA = [] multi = [] for node in scrunch_MDL: multi.append(node.input2.get()) scrunch_PMA = scrunch_PMA + pm.listConnections( node, d=True, t='plusMinusAverage') for j, node in enumerate(scrunch_PMA): MDL = pm.createNode('multDoubleLinear', n=self.name + 'scrunchMult') globalCtrl.scrunch >> MDL.input1 MDL.input2.set(multi[j]) MDL.output >> node.input1D[5] spread_PMA = pm.listConnections(ctrlBase.spread, d=True, t='plusMinusAverage')[0] spread_MDL = pm.createNode('multDoubleLinear', n=self.name + 'spreadMult') globalCtrl.spread >> spread_MDL.input1 spread_MDL.input2.set(spread[i]) spread_MDL.output >> spread_PMA.input2D[3].input2Dy # hierarquia pm.parent(self.ballCntrl.getParent(), toeCntrl.getParent(), heelCntrl) heelCntrl.getParent().setParent(tipCntrl) tipCntrl.getParent().setParent(outCntrl) outCntrl.getParent().setParent(inCntrl) inCntrl.getParent().setParent(slideCompensateGrp) rollCntrl.getParent().setParent(slideCompensateGrp) slideCntrl.getParent().setParent(self.baseCntrl) ballIkh[0].setParent(self.ballCntrl) ballIkh[0].visibility.set(0) tipIkh[0].setParent(toeCntrl) tipIkh[0].visibility.set(0) self.limbConnectionCntrl.getParent().setParent(self.ballCntrl) pm.parent(j1, self.baseCntrl.getParent(), self.moveall) # rollCntrl rollCntrl.addAttr('heelLimit', dv=50, k=1, at='float') rollBlend = pm.createNode('blendColors', n=self.name + 'rollBlend') rollCntrl.heelLimit >> rollBlend.color1.color1R # setDrivens do controle do Roll animUU = pm.createNode('animCurveUU', n=self.name + 'RollAnimCrv1') # cria curva multi = pm.createNode('multDoubleLinear', n=self.name + 'RollMulti') multi.input2.set(-1) pm.setKeyframe(animUU, float=float(0), value=float(0), itt='Linear', ott='Linear') pm.setKeyframe(animUU, float=float(1.5), value=float(1), itt='Linear', ott='Linear') pm.setKeyframe(animUU, float=float(3), value=float(0), itt='Linear', ott='Linear') rollCntrl.translateX >> animUU.input animUU.output >> rollBlend.blender rollBlend.outputR >> multi.input1 multi.output >> self.ballCntrl.getParent().rotateZ animUA = pm.createNode('animCurveUA', n=self.name + 'RollAnimCrv2') pm.setKeyframe(animUA, float=float(-3), value=float(75), itt='Linear', ott='Linear') pm.setKeyframe(animUA, float=float(0), value=float(0), itt='Linear', ott='Linear') rollCntrl.translateX >> animUA.input animUA.output >> heelCntrl.getParent().rotateZ animUA = pm.createNode('animCurveUA', n=self.name + 'RollAnimCrv3') pm.setKeyframe(animUA, float=float(1.5), value=float(0), itt='Linear', ott='Linear') pm.setKeyframe(animUA, float=float(7), value=float(-180), itt='Linear', ott='Linear') rollCntrl.translateX >> animUA.input animUA.output >> tipCntrl.getParent().rotateZ animUA = pm.createNode('animCurveUA', n=self.name + 'RollAnimCrv4') pm.setKeyframe(animUA, float=float(0), value=float(0), itt='Linear', ott='Linear') pm.setKeyframe(animUA, float=float(-2.5), value=float(-120), itt='Linear', ott='Linear') rollCntrl.translateZ >> animUA.input # inverte se for mirror pq o controle tem if self.flipAxis: animUA.output >> inCntrl.getParent().rotateX else: animUA.output >> outCntrl.getParent().rotateX animUA = pm.createNode('animCurveUA', n=self.name + 'RollAnimCrv5') pm.setKeyframe(animUA, float=float(0), value=float(0), itt='Linear', ott='Linear') pm.setKeyframe(animUA, float=float(2.5), value=float(120), itt='Linear', ott='Linear') rollCntrl.translateZ >> animUA.input if self.flipAxis: animUA.output >> outCntrl.getParent().rotateX else: animUA.output >> inCntrl.getParent().rotateX # controles fk displaySetup = self.ankleFkCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.ankleFkCntrl = controlTools.cntrlCrv(name=cntrlName, obj=j1, connType='parentConstraint', **displaySetup) displaySetup = self.toeFkCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.toeFkCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.ballGuide, align='parent', connType=None, **displaySetup) if self.flipAxis: pm.xform(self.toeFkCntrl.getParent(), ws=True, ro=[0, 0, 90]) else: pm.xform(self.toeFkCntrl.getParent(), ws=True, ro=[180, 0, -90]) pm.orientConstraint(self.toeFkCntrl, j2, mo=True) self.toeFkCntrl.getParent().setParent(self.ankleFkCntrl) self.ankleFkCntrl.getParent().setParent(self.moveall) # node tree ikfk Blend self.moveall.addAttr('ikfk', at='float', min=0, max=1, dv=1, k=1) ikfkRev = pm.createNode('reverse', n=self.name + 'IkFkReverse') ikfkVisCond1 = pm.createNode('condition', n=self.name + 'IkFkCond1') ikfkVisCond2 = pm.createNode('condition', n=self.name + 'IkFkCond2') # visibilidade ik fk self.moveall.ikfk >> ikfkRev.inputX self.moveall.ikfk >> ballIkh[0].ikBlend self.moveall.ikfk >> tipIkh[0].ikBlend self.moveall.ikfk >> ikfkVisCond1.firstTerm ikfkVisCond1.secondTerm.set(0) ikfkVisCond1.operation.set(2) ikfkVisCond1.colorIfTrueR.set(1) ikfkVisCond1.colorIfFalseR.set(0) ikfkVisCond1.outColorR >> self.baseCntrl.getParent().visibility # blend dos constraints self.moveall.ikfk >> ikfkVisCond2.firstTerm ikfkVisCond2.secondTerm.set(1) ikfkVisCond2.operation.set(4) ikfkVisCond2.colorIfTrueR.set(1) ikfkVisCond2.colorIfFalseR.set(0) ikfkVisCond2.outColorR >> self.ankleFkCntrl.getParent().visibility parCnstr = j1.connections( type='parentConstraint')[0] # descobre constraint weightAttr = parCnstr.target.connections( p=True, t='parentConstraint') # descobre parametros self.moveall.ikfk >> weightAttr[0] ikfkRev.outputX >> weightAttr[1]
def doRig(self): anchorList = [] cntrlList = [] locList = [] dummyCrv = self.ribbonDict['moveallSetup']['nameTempl'] + '_dummy_crv' pm.hide(pm.polyCube(n=dummyCrv)) if pm.objExists(self.ribbonDict['noMoveSetup']['nameTempl']): pm.delete(self.ribbonDict['noMoveSetup']['nameTempl']) if pm.objExists(self.ribbonDict['moveallSetup']['nameTempl']): pm.delete(self.ribbonDict['moveallSetup']['nameTempl']) logger ###Estrutura que nao deve ter transformacao noMoveSpace = pm.group(empty=True, n=self.ribbonDict['noMoveSetup']['nameTempl']) if not pm.objExists('NOMOVE'): pm.group(self.ribbonDict['noMoveSetup']['nameTempl'], n='NOMOVE') else: pm.parent(self.ribbonDict['noMoveSetup']['nameTempl'], 'NOMOVE') pm.parent(self.ribbonDict['moveallSetup']['nameTempl'] + '_dummy_crv', noMoveSpace) noMoveSpace.visibility.set(0) noMoveBend1 = pm.nurbsPlane(p=(self.size * 0.5, 0, 0), ax=(0, 0, 1), w=self.size, lr=0.1, d=3, u=5, v=1) # noMoveCrvJnt = pm.curve ( bezier=True, d=3, p=[(self.size*-0.5,0,0),(self.size*-0.4,0,0),(self.size*-0.1,0,0),(0,0,0),(self.size*0.1,0,0),(self.size*0.4,0,0),(self.size*0.5,0,0)], k=[0,0,0,1,1,1,2,2,2]) noMoveCrvJnt = pm.curve( bezier=True, d=3, p=[(self.size * -0.50, 0, 0), (self.size * -0.499, 0, 0), (self.size * -0.496, 0, 0), (self.size * -0.495, 0, 0), (self.size * -0.395, 0, 0), (self.size * -0.10, 0, 0), (0, 0, 0), (self.size * 0.10, 0, 0), (self.size * 0.395, 0, 0), (self.size * 0.495, 0, 0), (self.size * 0.496, 0, 0), (self.size * 0.499, 0, 0), (self.size * 0.50, 0, 0)], k=[0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10]) noMoveCrvJnt.translate.set(self.size * 0.5, 0, 0) # Deformers das superficies noMove twist1 = pm.nonLinear(noMoveBend1[0], type='twist') # twist das superficies noMove twist1[1].rotateZ.set(90) # IMPLEMENTAR O TWIST DO MEIO twist2 = pm.nonLinear(noMoveBend1[0].name() + '.cv[0:3][0:3]', type='twist') # twist das superficies noMove twist2[1].rotateZ.set(90) twist3 = pm.nonLinear(noMoveBend1[0].name() + '.cv[4:7][0:3]', type='twist') # twist das superficies noMove twist3[1].rotateZ.set(90) wireDef = pm.wire(noMoveBend1[0], w=noMoveCrvJnt, dds=[(0, 50)]) # Wire das superficies noMove wireDef[0].rotation.set(1) # seta rotacao pra acontecer baseWire = [ x for x in wireDef[0].connections() if 'BaseWire' in x.name() ] pm.group(baseWire, noMoveCrvJnt, noMoveBend1[0], p=noMoveSpace, n=self.name + 'Deforms_grp') pm.parent(twist1[1], twist2[1], twist3[1], noMoveSpace) ###Estrutura que pode ser movida cntrlsSpace = pm.group(empty=True, n=self.ribbonDict['moveallSetup']['nameTempl']) bendSurf1 = pm.nurbsPlane(p=(self.size * -0.5, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1) blend1 = pm.blendShape(noMoveBend1[0], bendSurf1[0]) pm.blendShape(blend1, e=True, w=[(0, 1)]) pm.parent(bendSurf1[0], cntrlsSpace) ##Cntrls for i in range(0, 7): anchor = pm.cluster(noMoveCrvJnt.name() + '.cv[' + str(i + 3) + ']') pm.cluster(anchor[1], e=True, g=dummyCrv) clsHandle = anchor[1] anchorGrp = pm.group(em=True, n='clusterGrp' + str(i)) anchorDrn = pm.group(em=True, n='clusterDrn' + str(i), p=anchorGrp) pos = pm.xform(anchor, q=True, ws=True, rp=True) pm.xform(anchorGrp, t=pos, ws=True) pm.parent(anchor[1], anchorDrn) anchorList.append(anchor[1]) if i == 0 or i == 6: displaySetup = self.ribbonDict['cntrlSetup'].copy() cntrlName = displaySetup['nameTempl'] + str(i) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup) elif i == 3: displaySetup = self.ribbonDict['midCntrlSetup'].copy() cntrlName = displaySetup['nameTempl'] + str(i) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup) else: displaySetup = self.ribbonDict['cntrlTangSetup'].copy() cntrlName = displaySetup['nameTempl'] + str(i) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup) # Nao pode fazer conexao na criacao do controle, pois tera conexao direta pm.xform(cntrl.getParent(), t=pos, ws=True) # estrutura de buffers para conexao direta auxLocGrp = pm.group(em=True, n=self.name + 'auxLoc_grp') auxLoc = pm.group(em=True, p=auxLocGrp, n=self.name + 'aux_loc') pm.xform(auxLocGrp, t=pos, ws=True) loc = pm.PyNode(auxLoc) if i == 1 or i == 4: pm.xform(anchorGrp, s=(-1, 1, 1), r=True) pm.xform(cntrl.getParent(), s=(-1, 1, 1), r=True) pm.xform(loc.getParent(), s=(-1, 1, 1), r=True) # Conexoes dos buffers cm os clusters e com os controles pm.parentConstraint(cntrl, loc) loc.translate >> anchorDrn.translate loc.rotate >> anchorDrn.rotate cntrlList.append(cntrl) locList.append(loc) startCls = pm.cluster(noMoveCrvJnt.name() + '.cv[0:2]') endCls = pm.cluster(noMoveCrvJnt.name() + '.cv[10:14]') pm.cluster(startCls[1], e=True, g=dummyCrv) pm.cluster(endCls[1], e=True, g=dummyCrv) pm.parent(startCls, anchorList[0]) pm.parent(endCls, anchorList[6]) cntrlsSpace.addAttr('cntrlsVis', at='double', dv=1, k=True, h=False) cntrlsSpace.addAttr('extraCntrlsVis', at='double', dv=0, k=True, h=False) cntrlList[0].addAttr('twist', at='double', dv=0, k=True) cntrlList[0].addAttr('stretchDist', at='double', dv=0, k=True) cntrlList[0].addAttr('autoVolumStregth', at='double', dv=0, k=True) cntrlList[3].addAttr('twist', at='double', dv=0, k=True) cntrlList[3].addAttr('autoVolume', at='double', dv=0, k=True) cntrlList[6].addAttr('twist', at='double', dv=0, k=True) cntrlList[6].addAttr('stretchDist', at='double', dv=0, k=True) cntrlList[6].addAttr('autoVolumStregth', at='double', dv=0, k=True) cntrlList[0].twist >> twist1[0].endAngle cntrlList[3].twist >> twist2[0].startAngle cntrlList[3].twist >> twist3[0].endAngle cntrlList[6].twist >> twist1[0].startAngle # hierarquia pm.parent(anchorList[1].getParent(2), anchorList[0]) pm.parent(anchorList[5].getParent(2), anchorList[6]) pm.parent(anchorList[2].getParent(2), anchorList[4].getParent(2), anchorList[3]) pm.parent(cntrlList[1].getParent(), cntrlList[0]) pm.parent(cntrlList[5].getParent(), cntrlList[6]) pm.parent(cntrlList[2].getParent(), cntrlList[4].getParent(), cntrlList[3]) pm.parent(cntrlList[3].getParent(), cntrlList[0].getParent(), cntrlList[6].getParent(), cntrlsSpace) pm.parent(locList[1].getParent(), locList[0]) pm.parent(locList[5].getParent(), locList[6]) pm.parent(locList[2].getParent(), locList[4].getParent(), locList[3]) pm.parent(locList[3].getParent(), locList[0].getParent(), locList[6].getParent(), cntrlsSpace) pm.parent(anchorList[3].getParent(2), anchorList[0].getParent(2), anchorList[6].getParent(2), noMoveSpace) # Skin joints do ribbon skinJntsGrp = pm.group(em=True, n=self.name + 'SkinJnts_grp') follGrp = pm.group(em=True, n=self.name + 'Foll_grp') # cria ramps para controlar o perfil de squash e stretch ramp1 = pm.createNode('ramp', n=self.name + 'SquashRamp1') ramp1.attr('type').set(1) # ramp2 = pm.createNode ('ramp') # ramp2.attr('type').set(1) expre1 = "float $dummy = " + ramp1.name( ) + ".outAlpha;float $output[];float $color[];" # expre2 = "float $dummy = "+ramp2.name()+".outAlpha;float $output[];float $color[];" extraCntrlsGrp = pm.group(em=True, r=True, p=cntrlsSpace, n=self.name + 'extraCntrls_grp') # loop pra fazer os colocar o numero escolhido de joints ao longo do ribbon. # cria tmb node tree pro squash/stretch # e controles extras vIncrement = float( (1.0 - (self.offsetStart + self.offsetEnd)) / (self.numJnts - 1)) for i in range(1, self.numJnts + 1): # cria estrutura pra superficie 1 pm.select(cl=True) jntName = self.ribbonDict['jntSetup']['nameTempl'] + str( i) + self.jntSulfix jnt1 = pm.joint(p=(0, 0, 0), n=jntName) self.skinJoints.append(jnt1) displaySetup = self.ribbonDict['cntrlExtraSetup'].copy() cntrlName = displaySetup['nameTempl'] + 'A' + str(i) cntrl1 = controlTools.cntrlCrv(name=cntrlName, obj=jnt1, connType='parentConstraint', **displaySetup) # node tree blend1A = pm.createNode('blendTwoAttr', n=self.name + 'VolumeBlend1A') blend1B = pm.createNode('blendTwoAttr', n=self.name + 'VolumeBlend1B') gammaCorr1 = pm.createNode('gammaCorrect', n=self.name + 'VolumeGamma1') cntrlList[0].attr('autoVolumStregth') >> gammaCorr1.gammaX cntrlList[0].attr('stretchDist') >> gammaCorr1.value.valueX blend1A.input[0].set(1) gammaCorr1.outValueX >> blend1A.input[1] blend1B.input[0].set(1) blend1A.output >> blend1B.input[1] cntrlList[3].attr('autoVolume') >> blend1B.attributesBlender blend1B.output >> cntrl1.getParent().scaleY blend1B.output >> cntrl1.getParent().scaleZ # expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch expre1 = expre1 + "$color = `colorAtPoint -o RGB -u " + str( self.offsetStart + (i - 1) * vIncrement) + " -v 0.5 " + ramp1.name( ) + " `;$output[" + str(i) + "] = $color[0];" + blend1A.name( ) + ".attributesBlender=$output[" + str(i) + "];" # prende joints nas supeficies com follicules foll1 = self.attachObj(cntrl1.getParent(), bendSurf1[0], self.offsetStart + (i - 1) * vIncrement, 0.5, 4) pm.parent(cntrl1.getParent(), extraCntrlsGrp) pm.parent(jnt1, skinJntsGrp) pm.parent(foll1, follGrp) # seta expressoes para so serem avaliadas por demanda pm.expression(s=expre1, ae=False) pm.parent(skinJntsGrp, cntrlsSpace) pm.parent(follGrp, noMoveSpace) # hideCntrls pm.toggle(bendSurf1[0], g=True) bendSurf1[0].visibility.set(0) # skinJntsGrp.visibility.set(0) cntrlsSpace.extraCntrlsVis >> extraCntrlsGrp.visibility cntrlsSpace.cntrlsVis >> cntrlList[0].getParent().visibility cntrlsSpace.cntrlsVis >> cntrlList[3].getParent().visibility cntrlsSpace.cntrlsVis >> cntrlList[6].getParent().visibility # povoa ribbon Dict self.ribbonDict['name'] = 'bezierRibbon' self.ribbonDict['ribbonMoveAll'] = cntrlsSpace for i in range(0, 7): self.ribbonDict['cntrl' + str(i)] = cntrlList[i] self.startCntrl = cntrlList[0] self.midCntrl = cntrlList[3] self.endCntrl = cntrlList[6] self.moveall = cntrlsSpace
def doRig(self): if not self.guideMoveall: self.doGuide() # apagar todos os node ao reconstruir if pm.objExists(self.name + 'Moveall'): pm.delete(self.name + 'Moveall') # Cria o grupo moveAll self.moveall = pm.group(empty=True, n=self.name + 'Moveall') pos = pm.xform(self.guideMoveall, q=True, ws=True, t=True) pm.xform(self.moveall, ws=True, t=pos) if not pm.objExists('MOVEALL'): pm.group(self.moveall, n='MOVEALL') else: pm.parent(self.moveall, 'MOVEALL') self.moveall.addAttr('ikfk', at='float', min=0, max=1, dv=1, k=1) # define pontos do guide como vetores usando api para faciitar os calculos p1 = pm.xform(self.startGuide, q=True, t=True, ws=True) p2 = pm.xform(self.midGuide, q=True, t=True, ws=True) p3 = pm.xform(self.endGuide, q=True, t=True, ws=True) A = om.MVector(p1) B = om.MVector(p2) C = om.MVector(p3) if self.lastJoint: p4 = pm.xform(self.lastGuide, q=True, t=True, ws=True) D = om.MVector(p4) # Calculando a normal do plano definido pelo guide # invertendo inverte a direcao do eixo ao longo do vetor if self.flipAxis: AB = A - B BC = B - C CD = C - D else: AB = B - A BC = C - B CD = D - C n = BC ^ AB self.jointLength = AB.length() + BC.length() m = matrixTools.orientMatrix(mvector=AB, normal=n, pos=A, axis=self.axis) # cria joint1 pm.select(cl=True) jntName = self.startJntSetup['nameTempl'] + self.jntSulfix self.startJnt = pm.joint(n=jntName) self.skinJoints.append(self.startJnt) pm.xform(self.startJnt, m=m, ws=True) pm.makeIdentity(self.startJnt, apply=True, r=1, t=0, s=0, n=0, pn=0) # cria joint2 # criando a matriz do joint conforme a orientacao setada m = matrixTools.orientMatrix(mvector=BC, normal=n, pos=B, axis=self.axis) pm.select(cl=True) jntName = self.midJntSetup['nameTempl'] + self.jntSulfix self.midJnt = pm.joint(n=jntName) self.skinJoints.append(self.midJnt) pm.xform(self.midJnt, m=m, ws=True) pm.makeIdentity(self.midJnt, apply=True, r=1, t=0, s=0, n=0, pn=0) # cria joint3 # aqui so translada o joint, usa a mesma orientacao pm.select(cl=True) jntName = self.endJntSetup['nameTempl'] + self.jntSulfix self.endJnt = pm.joint(n=jntName) self.skinJoints.append(self.endJnt) pm.xform(self.endJnt, m=m, ws=True) pm.xform(self.endJnt, t=C, ws=True) pm.makeIdentity(self.endJnt, apply=True, r=1, t=0, s=0, n=0, pn=0) # hierarquia pm.parent(self.midJnt, self.startJnt) pm.parent(self.endJnt, self.midJnt) self.startJnt.setParent(self.moveall) ##joint4(hand) se estiver setado nas opcoes if self.lastJoint: # joint4 # Faz a orientacao do ultimo bone independente da normal do braco # Se o cotovelo estiver para frente inverte a normal # limitacao: se o limb for criado no eixo Z o calculo nao eh preciso if self.flipAxis: if n.y < 0: Z = om.MVector(0, 0, 1) else: Z = om.MVector(0, 0, -1) else: if n.y > 0: Z = om.MVector(0, 0, -1) else: Z = om.MVector(0, 0, 1) n = CD ^ Z m = matrixTools.orientMatrix(mvector=CD, normal=n, pos=C, axis=self.axis) pm.select(cl=True) jntName = self.lastJntSetup['nameTempl'] + self.jntSulfix self.lastJnt = pm.joint(n=jntName) pm.xform(self.lastJnt, m=m, ws=True) pm.makeIdentity(self.lastJnt, apply=True, r=1, t=0, s=0, n=0, pn=0) # cria joint5 e so move pm.select(cl=True) jntName = self.lastJntSetup['nameTempl'] + self.tipJxtSulfix self.lastTipJnt = pm.joint(n=jntName) pm.xform(self.lastTipJnt, m=m, ws=True) pm.xform(self.lastTipJnt, t=D, ws=True) pm.makeIdentity(self.lastTipJnt, apply=True, r=1, t=0, s=0, n=0, pn=0) # hierarquia pm.parent(self.lastJnt, self.endJnt) pm.parent(self.lastTipJnt, self.lastJnt) ##Estrutura FK if self.axis == 'Y' or self.axis == 'Z' or self.axis == 'X': axisName = self.axis else: axisName = 'X' displaySetup = self.moveAll1CntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.moveAll1Cntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.startJnt, **displaySetup) displaySetup = self.endCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.endCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.startJnt, connType='parentConstraint', **displaySetup) self.endCntrl.addAttr('manualStretch', at='float', min=.1, dv=1, k=1) displaySetup = self.midCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.midCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.midJnt, connType='orientConstraint', **displaySetup) self.midCntrl.addAttr('manualStretch', at='float', min=.1, dv=1, k=1) pm.pointConstraint(self.midJnt, self.midCntrl.getParent(), mo=True) ##Estrutura IK ikH = pm.ikHandle(sj=self.startJnt, ee=self.endJnt, sol="ikRPsolver") displaySetup = self.ikCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.ikCntrl = controlTools.cntrlCrv(name=cntrlName, obj=ikH[0], **displaySetup) # orienta o controle ik de modo a ter aproximadamente a orientacao do eixo global # mas aponta o eixo X para a ponta do ultimo bone mat = pm.xform(self.ikCntrl.getParent(), q=True, m=True, ws=True) matrix = om.MMatrix(mat) Zcomponent = om.MVector(0, 0, -1) Zaxis = matrix * Zcomponent normal = CD ^ Zaxis # CD eh o vetor de direcao do ultimo joint ori = matrixTools.orientMatrix(CD, normal, C, self.axis) pm.xform(self.ikCntrl.getParent(), m=ori, ws=True) ikH[0].setParent(self.ikCntrl) ikH[0].translate.lock() ikH[0].rotate.lock() self.ikCntrl.addAttr('pin', at='float', min=0, max=1, dv=0, k=1) self.ikCntrl.addAttr('bias', at='float', min=-0.9, max=0.9, k=1) self.ikCntrl.addAttr('autoStretch', at='float', min=0, max=1, dv=1, k=1) self.ikCntrl.addAttr('manualStretch', at='float', dv=1, k=1) self.ikCntrl.addAttr('twist', at='float', dv=0, k=1) # pole vector displaySetup = self.poleVecCntrlSetup.copy() cntrlName = displaySetup['nameTempl'] self.poleVec = controlTools.cntrlCrv(name=cntrlName, obj=self.midJnt, **displaySetup) # calcula a direcao q deve ficar o polevector BA = B - A CA = C - A U = BA * CA.normal() dist = CA.length() V = U / dist * dist T = A + V * CA.normal() D = B - T Pole = (D.normal() * 4) + B # test=pm.spaceLocator (p=(0,0,0)) # locator de teste de onde calculou o ponto mais proximo # pm.xform (test, t=T) pm.xform(self.poleVec.getParent(), t=Pole) pm.xform(self.poleVec.getParent(), ro=(0, 0, 0)) poleCnst = pm.poleVectorConstraint(self.poleVec, ikH[0]) pm.parent(self.midCntrl.getParent(), self.endCntrl) pm.parent(self.endCntrl.getParent(), self.moveAll1Cntrl) pm.parent(self.moveAll1Cntrl.getParent(), self.poleVec.getParent(), self.ikCntrl.getParent(), self.moveall) # handCntrls se houver if self.lastJoint: displaySetup = self.startCntrlSetup cntrlName = displaySetup['nameTempl'] self.startCntrl = controlTools.cntrlCrv(name=cntrlName, obj=self.lastJnt, **displaySetup) buf = pm.group(em=True, n='startBuf') matrix = pm.xform(self.lastJnt, q=True, ws=True, m=True) pm.xform(buf, m=matrix, ws=True) pm.parent(buf, self.ikCntrl) handCnst = pm.orientConstraint(buf, self.startCntrl, self.lastJnt, mo=False) handCnstScale = pm.scaleConstraint(buf, self.startCntrl, self.lastJnt, mo=False) self.lastJnt.segmentScaleCompensate.set(False) pm.pointConstraint(self.endJnt, self.startCntrl.getParent(), mo=True) pm.parent(self.startCntrl.getParent(), self.midCntrl) # display ikH[0].visibility.set(0) # grupos de stretch startGrp = pm.group(empty=True, n='startStretch_grp') endGrp = pm.group(empty=True, n='endStretch_grp') pm.parent(endGrp, self.ikCntrl, r=True) pm.xform(startGrp, t=p1, ws=True) pm.parent(startGrp, self.endCntrl) ##NODE TREE####### # cria um blend entre uso de poleVector ou so twist poleBlendColor = pm.createNode('blendColors', n=self.name + 'poleVecBlend') poleAdd = pm.createNode('addDoubleLinear', n=self.name + 'PoleAdd') poleCond = pm.createNode('condition', n=self.name + 'poleCond') poleCnst.constraintTranslate >> poleBlendColor.color1 poleBlendColor.color2.set(0, 0, 0) # poleCnst.constraintTranslateX // ikH[0].poleVectorX # poleCnst.constraintTranslateY // ikH[0].poleVectorY # poleCnst.constraintTranslateZ // ikH[0].poleVectorZ poleBlendColor.outputR >> ikH[0].poleVectorX poleBlendColor.outputG >> ikH[0].poleVectorY poleBlendColor.outputB >> ikH[0].poleVectorZ self.moveall.addAttr('poleVec', at='float', k=1, dv=0, max=1, min=0) self.moveall.poleVec >> poleAdd.input1 self.ikCntrl.pin >> poleAdd.input2 poleAdd.output >> poleCond.firstTerm poleCond.secondTerm.set(0) poleCond.operation.set(2) poleCond.colorIfFalseR.set(0) poleCond.colorIfTrueR.set(1) poleCond.outColorR >> poleBlendColor.blender poleCond.outColorR >> self.poleVec.visibility # Pin p5 = pm.xform(self.poleVec.getParent(), q=True, t=True, ws=True) E = om.MVector(p5) AE = A - E CE = E - C distMax = AB.length() + BC.length() # distancia somada dos bones pinScaleJnt1 = AE.length() / AB.length() pinScaleJnt2 = CE.length() / BC.length() pinDist1 = pm.createNode( 'distanceBetween', n=self.name + 'pinDist1') # distance do pole vector a ponta do joint1 pinDist2 = pm.createNode( 'distanceBetween', n=self.name + 'pinDist2') # distance do pole vector a ponta do joint2 pinNorm1 = pm.createNode( 'multiplyDivide', n=self.name + 'pinNorm1') # normalizador distancia1 para escala pinNorm2 = pm.createNode( 'multiplyDivide', n=self.name + 'pinNorm2') # normalizador distancia2 para escala pinMultiScale1 = pm.createNode( 'multDoubleLinear', n=self.name + 'pinMultiScale1' ) # multiplicador da distancia inicial pela escala Global pinMultiScale2 = pm.createNode( 'multDoubleLinear', n=self.name + 'pinMultiScale2' ) # multiplicador da distancia inicial pela escala Global pinMultiOffset1 = pm.createNode( 'multDoubleLinear', n=self.name + 'pinMultiOffset1' ) # multiplicador escala para chegar ao pole vec pela escala Global pinMultiOffset2 = pm.createNode( 'multDoubleLinear', n=self.name + 'pinMultiOffset2' ) # multiplicador escala para chegar ao pole vec pela escala Global pinMulti1 = pm.createNode('multDoubleLinear', n=self.name + 'pinMulti1') # multiplicador do normalizador pinMulti2 = pm.createNode('multDoubleLinear', n=self.name + 'pinMulti2') # multiplicador do normalizador startGrp.worldMatrix[0] >> pinDist1.inMatrix1 endGrp.worldMatrix[0] >> pinDist2.inMatrix1 self.poleVec.worldMatrix[0] >> pinDist1.inMatrix2 self.poleVec.worldMatrix[0] >> pinDist2.inMatrix2 self.moveall.scaleX >> pinMultiScale1.input1 self.moveall.scaleX >> pinMultiScale2.input1 pinMultiScale1.input2.set(AE.length()) pinMultiScale2.input2.set(CE.length()) pinMultiOffset1.input2.set(pinScaleJnt1) pinMultiOffset2.input2.set(pinScaleJnt2) pinMultiOffset1.input1.set(1) pinMultiOffset2.input1.set(1) pinDist1.distance >> pinNorm1.input1X pinDist2.distance >> pinNorm2.input1X pinMultiScale1.output >> pinNorm1.input2X pinMultiScale2.output >> pinNorm2.input2X pinNorm1.operation.set(2) pinNorm2.operation.set(2) pinNorm1.outputX >> pinMulti1.input1 pinNorm2.outputX >> pinMulti2.input1 pinMultiOffset1.output >> pinMulti1.input2 pinMultiOffset2.output >> pinMulti2.input2 ##Stretch stretchDist = pm.createNode('distanceBetween', n=self.name + 'stretchDist') # distance stretchNorm = pm.createNode('multiplyDivide', n=self.name + 'stretchNorm') # normalizador stretchMultiScale = pm.createNode( 'multDoubleLinear', n=self.name + 'stretchMultiScale' ) # mutiplica valor maximo pela escala do moveAll stretchCond = pm.createNode( 'condition', n=self.name + 'stretchCond' ) # condicao so estica se for maior q distancia maxima ##Manual Stretch stretchManualStretch1 = pm.createNode( 'multDoubleLinear', n=self.name + 'stretchManualStretch1' ) # mutiplica valor maximo pela escala do moveAll stretchManualStretch2 = pm.createNode( 'multDoubleLinear', n=self.name + 'stretchManualStretch2' ) # mutiplica valor maximo pela escala do moveAll stretchManualStretch3 = pm.createNode( 'multDoubleLinear', n=self.name + 'stretchManualStretch3' ) # mutiplica valor maximo pela escala do moveAll startGrp.worldMatrix[0] >> stretchDist.inMatrix1 endGrp.worldMatrix[0] >> stretchDist.inMatrix2 stretchDecompMatrix = pm.createNode('decomposeMatrix', n=self.name + 'StretchDecompose') self.moveall.worldMatrix[0] >> stretchDecompMatrix.inputMatrix stretchDecompMatrix.outputScale.outputScaleX >> stretchMultiScale.input1 stretchMultiScale.input2.set(distMax) stretchMultiScale.output >> stretchManualStretch1.input2 stretchManualStretch1.output >> stretchNorm.input2X stretchNorm.operation.set(2) stretchDist.distance >> stretchNorm.input1X stretchNorm.outputX >> stretchCond.colorIfTrue.colorIfTrueR stretchNorm.outputX >> stretchCond.firstTerm stretchCond.operation.set(2) stretchCond.secondTerm.set(1) stretchCond.colorIfFalseR.set(1) ##AutoStretch switch autoStretchSwitch = pm.createNode('blendTwoAttr', n=self.name + 'autoStretchSwitch') stretchCond.outColor.outColorR >> autoStretchSwitch.input[1] autoStretchSwitch.input[0].set(1) ##Bias biasAdd1 = pm.createNode('plusMinusAverage', n=self.name + 'biasAdd1') biasAdd2 = pm.createNode('plusMinusAverage', n=self.name + 'biasAdd2') biasMulti1 = pm.createNode('multDoubleLinear', n=self.name + 'biasMult1') biasMulti2 = pm.createNode('multDoubleLinear', n=self.name + 'biasMult2') biasAdd1.input1D[1].set(1) biasAdd1.operation.set(1) biasAdd1.output1D >> biasMulti1.input1 autoStretchSwitch.output >> biasMulti1.input2 biasMulti1.output >> stretchManualStretch2.input2 biasAdd2.input1D[0].set(1) biasAdd2.operation.set(2) biasAdd2.output1D >> biasMulti2.input1 autoStretchSwitch.output >> biasMulti2.input2 biasMulti2.output >> stretchManualStretch3.input2 ##Twist offset twistBlend1 = pm.createNode('blendTwoAttr', n=self.name + 'twistBlend') twistBlend1.input[0].set(1) twistBlend1.output >> ikH[0].twist ##Blend stretch e pin stretchPinBlend1 = pm.createNode('blendTwoAttr', n=self.name + 'stretchPinBlend1') stretchPinBlend2 = pm.createNode('blendTwoAttr', n=self.name + 'stretchPinBlend2') stretchManualStretch2.output >> stretchPinBlend1.input[0] stretchManualStretch3.output >> stretchPinBlend2.input[0] pinMulti1.output >> stretchPinBlend1.input[1] pinMulti2.output >> stretchPinBlend2.input[1] ##Blend ikfk ikfkBlend1 = pm.createNode('blendTwoAttr', n=self.name + 'ikfkBlend1') ikfkBlend2 = pm.createNode('blendTwoAttr', n=self.name + 'ikfkBlend2') ikfkReverse = pm.createNode('reverse', n=self.name + 'ikfkReverse') stretchPinBlend1.output >> ikfkBlend1.input[0] stretchPinBlend2.output >> ikfkBlend2.input[0] self.endCntrl.manualStretch >> ikfkBlend1.input[1] self.midCntrl.manualStretch >> ikfkBlend2.input[1] self.moveall.ikfk >> ikfkReverse.inputX ikfkReverse.outputX >> ikfkBlend1.attributesBlender ikfkReverse.outputX >> ikfkBlend2.attributesBlender cnstrConn = self.midCntrl.connections( t='orientConstraint', d=True, s=False)[0] ## arriscando em pegar o primeiro... weightAttr = cnstrConn.target.connections( p=True, t='orientConstraint') ##Descobre o parametro de peso do constraint ikfkReverse.outputX >> weightAttr[0] if self.lastJoint: handTargetAttrs = handCnst.target.connections(p=True, t='orientConstraint') handTargetAttrsScale = handCnstScale.target.connections( p=True, t='scaleConstraint') ikfkReverse.outputX >> handTargetAttrs[1] self.moveall.ikfk >> handTargetAttrs[0] ikfkReverse.outputX >> handTargetAttrsScale[1] self.moveall.ikfk >> handTargetAttrsScale[0] self.moveall.ikfk >> ikH[0].ikBlend ikfkBlend1.output >> self.startJnt.attr('scale' + axisName) ikfkBlend2.output >> self.midJnt.attr('scale' + axisName) ##ikfk visibility ikCntrlVisCond = pm.createNode('condition', n=self.name + 'ikVisCond') fkCntrlVisCond = pm.createNode('condition', n=self.name + 'fkVisCond') self.moveall.ikfk >> ikCntrlVisCond.ft ikCntrlVisCond.secondTerm.set(0) ikCntrlVisCond.operation.set(1) ikCntrlVisCond.colorIfTrueR.set(1) ikCntrlVisCond.colorIfFalseR.set(0) self.moveall.ikfk >> fkCntrlVisCond.ft fkCntrlVisCond.secondTerm.set(1) fkCntrlVisCond.operation.set(1) fkCntrlVisCond.colorIfTrueR.set(1) fkCntrlVisCond.colorIfFalseR.set(0) ikCntrlVisCond.outColor.outColorR >> self.ikCntrl.getParent( ).visibility ikCntrlVisCond.outColor.outColorR >> self.poleVec.getParent( ).visibility fkCntrlVisCond.outColor.outColorR >> self.endCntrl.getParent( ).visibility ##Atributos e conexoes do controle ik self.ikCntrl.bias >> biasAdd2.input1D[1] self.ikCntrl.bias >> biasAdd1.input1D[0] self.ikCntrl.pin >> stretchPinBlend1.attributesBlender self.ikCntrl.pin >> stretchPinBlend2.attributesBlender self.ikCntrl.manualStretch >> stretchManualStretch1.input1 self.ikCntrl.manualStretch >> stretchManualStretch2.input1 self.ikCntrl.manualStretch >> stretchManualStretch3.input1 self.ikCntrl.autoStretch >> autoStretchSwitch.attributesBlender self.ikCntrl.pin >> twistBlend1.attributesBlender self.ikCntrl.twist >> twistBlend1.input[0]