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]
