def cornerCtrl(self,matchPosOne, matchPosTwo, prefix, scale, side):
cornerCtrl = ct.Control(matchPos=matchPosOne, matchPosTwo=matchPosTwo,
prefix=prefix,
shape=ct.CIRCLEPLUS, groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.3,
ctrlColor='blue', lockChannels=['v', 's'], side=side)
# check position
pos = mc.xform(cornerCtrl.control, ws=1, q=1, t=1)[0]
# flipping the controller
if pos < 0:
mc.setAttr(cornerCtrl.parentControl[0] + '.scaleX', -1)
self.control = cornerCtrl.control
self.parentControlZro = cornerCtrl.parentControl[0]
self.parentControlOffset = cornerCtrl.parentControl[1]
return cornerCtrl.control, cornerCtrl.parentControl[0]
def __init__(
self,
ctrlGrp,
neckJnt,
headJnt,
headUpJnt,
headLowJnt,
jawJnt,
noseJnt,
upperTeethJnt,
lowerTeethJnt,
tongue01Jnt,
tongue02Jnt,
tongue03Jnt,
tongue04Jnt,
objectFolMesh,
noseTipJnt,
chinJnt,
throatJnt,
scale,
eyeballJntLFT,
eyeballJntRGT,
prefixEyeballAim,
positionEyeAimCtrl,
):
# CREATE CONTROLLER
neckCtrl = ac.Control(matchPos=neckJnt,
prefix=neckJnt,
shape=ac.CIRCLEPLUS,
groupsCtrl=[''],
ctrlSize=scale * 15.0,
gimbal=True,
ctrlColor='yellow',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
headCtrl = ac.Control(matchPos=headJnt,
prefix=headJnt,
shape=ac.CUBE,
groupsCtrl=['', 'Global', "Local"],
ctrlSize=scale * 10.0,
gimbal=True,
ctrlColor='blue',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
# ADD ATTRIBUTE
headUpCtrl = ac.Control(matchPos=headUpJnt,
prefix=headUpJnt,
shape=ac.CIRCLEHALF,
groupsCtrl=[''],
ctrlSize=scale * 10.0,
ctrlColor='red',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
headLowCtrl = ac.Control(matchPos=headLowJnt,
prefix=headLowJnt,
shape=ac.CIRCLEHALF,
groupsCtrl=[''],
ctrlSize=scale * 10.0,
ctrlColor='red',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
jawCtrl = ac.Control(matchPos=jawJnt,
prefix=jawJnt,
shape=ac.SQUAREPLUS,
groupsCtrl=[''],
ctrlSize=scale * 10.0,
ctrlColor='yellow',
lockChannels=['v', 's'],
connect=['parentCons', 'scaleCons'])
noseTipCtrl = ac.Control(matchPos=noseTipJnt,
prefix=noseTipJnt,
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 1.0,
ctrlColor='yellow',
lockChannels=['v'])
chinCtrl = ac.Control(matchPos=chinJnt,
prefix=chinJnt,
shape=ac.JOINT,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='yellow',
lockChannels=['v'])
throatCtrl = ac.Control(matchPos=throatJnt,
prefix=throatJnt,
shape=ac.JOINT,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='yellow',
lockChannels=['v'])
upperTeeth = ac.Control(matchPos=upperTeethJnt,
prefix=upperTeethJnt,
shape=ac.CUBE,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='blue',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
lowerTeeth = ac.Control(matchPos=lowerTeethJnt,
prefix=lowerTeethJnt,
shape=ac.CUBE,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='blue',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
tongue01 = ac.Control(matchPos=tongue01Jnt,
prefix=tongue01Jnt,
shape=ac.SQUAREPLUS,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='turquoiseBlue',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
tongue02 = ac.Control(matchPos=tongue02Jnt,
prefix=tongue02Jnt,
shape=ac.SQUAREPLUS,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='turquoiseBlue',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
tongue03 = ac.Control(matchPos=tongue03Jnt,
prefix=tongue03Jnt,
shape=ac.SQUAREPLUS,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='turquoiseBlue',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
tongue04 = ac.Control(matchPos=tongue04Jnt,
prefix=tongue04Jnt,
shape=ac.SQUAREPLUS,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='turquoiseBlue',
lockChannels=['v'],
connect=['parentCons', 'scaleCons'])
# ==================================================================================================================
# ASSIGNING THE INSTANCE NAME
# ==================================================================================================================
self.neckCtrl = neckCtrl.control
self.neckCtrlGimbal = neckCtrl.controlGimbal
self.neckCtrlGrp = neckCtrl.parentControl[0]
self.headCtrl = headCtrl.control
self.headCtrlGimbal = headCtrl.controlGimbal
self.headCtrlGrp = headCtrl.parentControl[0]
self.headCtrlGlobal = headCtrl.parentControl[1]
self.headCtrlLocal = headCtrl.parentControl[2]
self.headUpCtrl = headUpCtrl.control
self.headUpCtrlGrp = headUpCtrl.parentControl[0]
self.headLowCtrl = headLowCtrl.control
self.headLowCtrlGrp = headLowCtrl.parentControl[0]
self.jawCtrl = jawCtrl.control
self.jawCtrlGrp = jawCtrl.parentControl[0]
self.noseTipCtrl = noseTipCtrl.control
self.noseTipCtrlGrp = noseTipCtrl.parentControl[0]
self.noseTipCtrlOffset = noseTipCtrl.parentControl[1]
self.chinCtrl = chinCtrl.control
self.chinCtrlGrp = chinCtrl.parentControl[0]
self.throatCtrl = throatCtrl.control
self.throatCtrlGrp = throatCtrl.parentControl[0]
self.upperTeethCtrl = upperTeeth.control
self.upperTeethCtrlGrp = upperTeeth.parentControl[0]
self.lowerTeethCtrl = lowerTeeth.control
self.lowerTeethCtrlGrp = lowerTeeth.parentControl[0]
self.tongue01Ctrl = tongue01.control
self.tongue01CtrlGrp = tongue01.parentControl[0]
self.tongue02Ctrl = tongue02.control
self.tongue02CtrlGrp = tongue02.parentControl[0]
self.tongue03Ctrl = tongue03.control
self.tongue03CtrlGrp = tongue03.parentControl[0]
self.tongue04Ctrl = tongue04.control
self.tongue04CtrlGrp = tongue04.parentControl[0]
# LOCAL WORLD HEAD
self.localWorld(objectName='head',
objectCtrl=self.headCtrl,
objectParentGrp=self.headCtrlGrp,
objectParentGlobal=self.headCtrlGlobal,
objectParentLocal=self.headCtrlLocal,
localBase=self.neckCtrlGimbal,
worldBase=ctrlGrp,
eyeAim=False)
# CREATE GROUP CORESPONDENT THE JOINTS
au.createParentTransform(listparent=[''],
object=noseTipJnt,
matchPos=noseTipJnt,
prefix='noseTip',
suffix='_jnt')
au.createParentTransform(listparent=[''],
object=chinJnt,
matchPos=chinJnt,
prefix='chin',
suffix='_jnt')
au.createParentTransform(listparent=[''],
object=throatJnt,
matchPos=throatJnt,
prefix='throat',
suffix='_jnt')
au.connectAttrObject(self.noseTipCtrl, noseTipJnt)
au.connectAttrObject(self.chinCtrl, chinJnt)
au.connectAttrObject(self.throatCtrl, throatJnt)
# SCALE CONSTRAINT
mc.scaleConstraint(self.headCtrl, noseJnt)
# ==================================================================================================================
# CONTROLLER CORRESPONDING TO FOLLICLE
# ==================================================================================================================
# group to follicle
object = [self.noseTipCtrlGrp, self.chinCtrlGrp, self.throatCtrlGrp]
self.follicleTransformAll = []
for i in object:
follicleTransform = au.createFollicleSel(
objSel=i,
objMesh=objectFolMesh,
connectFol=['transConn', 'rotateConn'])[0]
mc.parent(i, follicleTransform)
self.follicleTransformAll.append(follicleTransform)
mc.scaleConstraint(self.headCtrl, self.follicleTransformAll[0])
mc.scaleConstraint(self.jawCtrl, self.follicleTransformAll[1])
mc.scaleConstraint(self.jawCtrl, self.follicleTransformAll[2])
# ==================================================================================================================
# CREATE AIM FOR EYEBALL
# ==================================================================================================================
eyeballAimMainCtrl = ac.Control(matchPos=eyeballJntLFT,
matchPosTwo=eyeballJntRGT,
prefix=prefixEyeballAim,
shape=ac.LOCATOR,
groupsCtrl=['', 'Global', 'Local'],
ctrlSize=scale * 0.4,
ctrlColor='blue',
lockChannels=['v', 'r', 's'])
self.eyeballAimMainCtrl = eyeballAimMainCtrl.control
self.eyeballAimMainCtrlGrp = eyeballAimMainCtrl.parentControl[0]
self.eyeballAimMainCtrlGlobal = eyeballAimMainCtrl.parentControl[1]
self.eyeballAimMainCtrlLocal = eyeballAimMainCtrl.parentControl[2]
getAttribute = mc.getAttr(eyeballAimMainCtrl.parentControl[0] +
'.translateZ')
mc.setAttr(eyeballAimMainCtrl.parentControl[0] + '.translateZ',
getAttribute + (positionEyeAimCtrl * scale))
# LOCAL WORLD AIM EYEBALL
self.localWorld(objectName='eyeballAim',
objectCtrl=self.eyeballAimMainCtrl,
objectParentGrp=self.eyeballAimMainCtrlGrp,
objectParentGlobal=self.eyeballAimMainCtrlGlobal,
objectParentLocal=self.eyeballAimMainCtrlLocal,
localBase=self.headUpCtrl,
worldBase=ctrlGrp,
eyeAim=True)
# PARENT TONGUE HIERARCHY
mc.parent(self.tongue04CtrlGrp, self.tongue03Ctrl)
mc.parent(self.tongue03CtrlGrp, self.tongue02Ctrl)
mc.parent(self.tongue02CtrlGrp, self.tongue01Ctrl)
mc.parent(self.tongue01CtrlGrp, self.lowerTeethCtrlGrp, self.jawCtrl)
mc.parent(self.upperTeethCtrlGrp, self.headLowCtrl)
# PARENTING GRP
mc.parent(self.jawCtrlGrp, self.headLowCtrl)
mc.parent(self.eyeballAimMainCtrlGrp, self.headUpCtrl)
mc.parent(self.headLowCtrlGrp, self.headUpCtrlGrp, self.headCtrlGimbal)
mc.parent(self.headCtrlGrp, self.neckCtrlGimbal)
def __init__(self, objectFolMesh, lipUpJnt01, lipUpJnt02, lipDownJnt01,
lipDownJnt02, lipCornerJnt, directionLipCorner,
directionLip01, directionLip02, headLowCtrl, jawCtrl, scale,
sideRGT, sideLFT, side):
self.pos = mc.xform(lipCornerJnt, q=1, ws=1, t=1)[0]
# corner
self.rotation(object=lipCornerJnt, directionLip=directionLipCorner)
self.rotation(object=lipUpJnt01, directionLip=directionLip01)
self.rotation(object=lipUpJnt02, directionLip=directionLip02)
self.rotation(object=lipDownJnt01, directionLip=directionLip01)
self.rotation(object=lipDownJnt02, directionLip=directionLip02)
mc.makeIdentity(lipCornerJnt, apply=True, t=1, r=1, s=1, n=2)
mc.makeIdentity(lipUpJnt01, apply=True, t=1, r=1, s=1, n=2)
mc.makeIdentity(lipUpJnt02, apply=True, t=1, r=1, s=1, n=2)
mc.makeIdentity(lipDownJnt01, apply=True, t=1, r=1, s=1, n=2)
mc.makeIdentity(lipDownJnt02, apply=True, t=1, r=1, s=1, n=2)
# controller
self.corner = ct.Control(matchPos=lipCornerJnt,
prefix='lipCorner',
shape=ct.JOINT,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
self.cornerParentCtrl = self.corner.parentControl[0]
self.upLip01 = ct.Control(matchPos=lipUpJnt01,
prefix='lipUp01',
shape=ct.JOINT,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
self.upLip01ParentCtrl = self.upLip01.parentControl[0]
self.upLip02 = ct.Control(matchPos=lipUpJnt02,
prefix='lipUp02',
shape=ct.JOINT,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
self.upLip02ParentCtrl = self.upLip02.parentControl[0]
self.downLip01 = ct.Control(matchPos=lipDownJnt01,
prefix='lipDown01',
shape=ct.JOINT,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
self.downLip01ParentCtrl = self.downLip01.parentControl[0]
self.downLip02 = ct.Control(matchPos=lipDownJnt02,
prefix='lipDown02',
shape=ct.JOINT,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
self.downLip02ParentCtrl = self.downLip02.parentControl[0]
cornerGrpJnt = au.createParentTransform(listparent=[''],
object=lipCornerJnt,
matchPos=lipCornerJnt,
prefix='lipCorner',
suffix='_jnt',
side=side)
au.createParentTransform(listparent=[''],
object=lipUpJnt01,
matchPos=lipUpJnt01,
prefix='lipUp01',
suffix='_jnt',
side=side)
au.createParentTransform(listparent=[''],
object=lipUpJnt02,
matchPos=lipUpJnt02,
prefix='lipUp02',
suffix='_jnt',
side=side)
au.createParentTransform(listparent=[''],
object=lipDownJnt01,
matchPos=lipDownJnt01,
prefix='lipDown01',
suffix='_jnt',
side=side)
au.createParentTransform(listparent=[''],
object=lipDownJnt02,
matchPos=lipDownJnt02,
prefix='lipDown02',
suffix='_jnt',
side=side)
# flipping controller
self.flippingCtrl(sideRGT,
sideLFT,
self.corner,
downlip=False,
side=side,
jointTgt=lipCornerJnt)
self.flippingCtrl(sideRGT,
sideLFT,
self.upLip01,
downlip=False,
side=side,
jointTgt=lipUpJnt01)
self.flippingCtrl(sideRGT,
sideLFT,
self.upLip02,
downlip=False,
side=side,
jointTgt=lipUpJnt02)
self.flippingCtrl(sideRGT,
sideLFT,
self.downLip01,
downlip=True,
side=side,
jointTgt=lipDownJnt01)
self.flippingCtrl(sideRGT,
sideLFT,
self.downLip02,
downlip=True,
side=side,
jointTgt=lipDownJnt02)
au.connectAttrScale(self.corner.control, lipCornerJnt)
au.connectAttrScale(self.upLip01.control, lipUpJnt01)
au.connectAttrScale(self.upLip02.control, lipUpJnt02)
au.connectAttrScale(self.downLip01.control, lipDownJnt01)
au.connectAttrScale(self.downLip02.control, lipDownJnt02)
object = [
self.cornerParentCtrl, self.upLip01ParentCtrl,
self.upLip02ParentCtrl, self.downLip01ParentCtrl,
self.downLip02ParentCtrl
]
self.follicleTransformAll = []
for i in object:
follicle = au.createFollicleSel(objSel=i,
objMesh=objectFolMesh,
connectFol=['transConn'])[0]
mc.parent(i, follicle)
mc.scaleConstraint(headLowCtrl, follicle)
self.follicleTransformAll.append(follicle)
mc.orientConstraint(jawCtrl, self.follicleTransformAll[0], mo=1)
mc.orientConstraint(jawCtrl, self.follicleTransformAll[3], mo=1)
mc.orientConstraint(jawCtrl, self.follicleTransformAll[4], mo=1)
mc.orientConstraint(headLowCtrl, self.follicleTransformAll[1], mo=1)
mc.orientConstraint(headLowCtrl, self.follicleTransformAll[2], mo=1)
# CONSTRAINT CORNER JNT GRP
mc.parentConstraint(headLowCtrl, jawCtrl, cornerGrpJnt, mo=1)
def __init__(self, nostrilJnt, earJnt, cheekUpJnt, cheekUpOutJnt,
cheekDownJnt, eyebrowInJnt, eyebrowMidJnt, eyebrowOutJnt,
browInUpJnt, browMidUpJnt, browOutUpJnt, eyelidPinchInJnt,
browInDownJnt, browMidDownJnt, browOutDownJnt,
eyelidPinchOutJnt, scale, objectFolMesh, sideRGT, sideLFT,
side, headCtrl, headUpCtrl, headLowCtrl, directionBrowIn,
directionBrowMid, directionBrowOut, directionBrowPinchIn,
directionBrowPinchOut):
# check position
pos = mc.xform(nostrilJnt, ws=1, q=1, t=1)[0]
nostrilCtrl = ac.Control(matchPos=nostrilJnt,
prefix='nostril',
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 0.5,
ctrlColor='yellow',
lockChannels=['v'],
side=side)
cheekUpCtrl = ac.Control(matchPos=cheekUpJnt,
prefix='cheekUp',
shape=ac.JOINT,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='yellow',
lockChannels=['v'],
side=side)
cheekUpOutCtrl = ac.Control(matchPos=cheekUpOutJnt,
prefix='cheekUpOut',
shape=ac.JOINT,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='yellow',
lockChannels=['v'],
side=side)
cheekDownCtrl = ac.Control(matchPos=cheekDownJnt,
prefix='cheekDown',
shape=ac.JOINT,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='yellow',
lockChannels=['v'],
side=side)
eyebrowInCtrl = ac.Control(matchPos=eyebrowInJnt,
prefix='eyebrowIn',
shape=ac.CUBE,
groupsCtrl=[''],
ctrlSize=scale * 0.5,
ctrlColor='blue',
lockChannels=['v'],
side=side)
eyebrowMidCtrl = ac.Control(matchPos=eyebrowMidJnt,
prefix='eyebrowMid',
shape=ac.CUBE,
groupsCtrl=[''],
ctrlSize=scale * 0.5,
ctrlColor='blue',
lockChannels=['v'],
side=side)
eyebrowOutCtrl = ac.Control(matchPos=eyebrowOutJnt,
prefix='eyebrowOut',
shape=ac.CUBE,
groupsCtrl=[''],
ctrlSize=scale * 0.5,
ctrlColor='blue',
lockChannels=['v'],
side=side)
eyebrowCtrl = ac.Control(matchPos=eyebrowInJnt,
matchPosTwo=eyebrowOutJnt,
prefix='eyebrows',
shape=ac.SQUAREPLUS,
groupsCtrl=[''],
ctrlSize=scale * 3.0,
ctrlColor='yellow',
lockChannels=['v'],
side=side)
browInUpCtrl = ac.Control(matchPos=browInUpJnt,
prefix='browInUp',
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
browMidUpCtrl = ac.Control(matchPos=browMidUpJnt,
prefix='browMidUp',
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
browOutUpCtrl = ac.Control(matchPos=browOutUpJnt,
prefix='browOutUp',
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
eyelidPinchInCtrl = ac.Control(matchPos=eyelidPinchInJnt,
prefix='eyelidPinchIn',
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 1.0,
ctrlColor='blue',
lockChannels=['v'],
side=side)
browInDownCtrl = ac.Control(matchPos=browInDownJnt,
prefix='browInDown',
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
browMidDownCtrl = ac.Control(matchPos=browMidDownJnt,
prefix='browMidDown',
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
browOutDownCtrl = ac.Control(matchPos=browOutDownJnt,
prefix='browOutDown',
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'],
side=side)
eyelidPinchOutCtrl = ac.Control(matchPos=eyelidPinchOutJnt,
prefix='eyelidPinchOut',
shape=ac.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 1.0,
ctrlColor='blue',
lockChannels=['v'],
side=side)
earCtrl = ac.Control(matchPos=earJnt,
prefix='ear',
shape=ac.CUBE,
groupsCtrl=[''],
ctrlSize=scale * 1.0,
ctrlColor='blue',
lockChannels=['v'],
side=side)
# ==================================================================================================================
# ASSIGNING THE INSTANCE NAME
# ==================================================================================================================
self.nostrilCtrl = nostrilCtrl.control
self.nostrilCtrlGrp = nostrilCtrl.parentControl[0]
self.nostrilCtrlOffset = nostrilCtrl.parentControl[1]
self.cheekUpCtrl = cheekUpCtrl.control
self.cheekUpCtrlGrp = cheekUpCtrl.parentControl[0]
self.cheekUpOutCtrl = cheekUpOutCtrl.control
self.cheekUpOutCtrlGrp = cheekUpOutCtrl.parentControl[0]
self.cheekDownCtrl = cheekDownCtrl.control
self.cheekDownCtrlGrp = cheekDownCtrl.parentControl[0]
self.eyebrowInCtrl = eyebrowInCtrl.control
self.eyebrowInCtrlGrp = eyebrowInCtrl.parentControl[0]
self.eyebrowMidCtrl = eyebrowMidCtrl.control
self.eyebrowMidCtrlGrp = eyebrowMidCtrl.parentControl[0]
self.eyebrowOutCtrl = eyebrowOutCtrl.control
self.eyebrowOutCtrlGrp = eyebrowOutCtrl.parentControl[0]
self.eyebrowCtrl = eyebrowCtrl.control
self.eyebrowCtrlGrp = eyebrowCtrl.parentControl[0]
self.browInUpCtrl = browInUpCtrl.control
self.browInUpCtrlGrp = browInUpCtrl.parentControl[0]
self.browMidUpCtrl = browMidUpCtrl.control
self.browMidUpCtrlGrp = browMidUpCtrl.parentControl[0]
self.browOutUpCtrl = browOutUpCtrl.control
self.browOutUpCtrlGrp = browOutUpCtrl.parentControl[0]
self.eyelidPinchInCtrl = eyelidPinchInCtrl.control
self.eyelidPinchInCtrlGrp = eyelidPinchInCtrl.parentControl[0]
self.browInDownCtrl = browInDownCtrl.control
self.browInDownCtrlGrp = browInDownCtrl.parentControl[0]
self.browMidDownCtrl = browMidDownCtrl.control
self.browMidDownCtrlGrp = browMidDownCtrl.parentControl[0]
self.browOutDownCtrl = browOutDownCtrl.control
self.browOutDownCtrlGrp = browOutDownCtrl.parentControl[0]
self.eyelidPinchOutCtrl = eyelidPinchOutCtrl.control
self.eyelidPinchOutCtrlGrp = eyelidPinchOutCtrl.parentControl[0]
self.earCtrl = earCtrl.control
self.earCtrlGrp = earCtrl.parentControl[0]
# ==================================================================================================================
# EYEBROW CONTROLLER SETUP
# ==================================================================================================================
mc.parent(self.eyebrowInCtrlGrp, self.eyebrowMidCtrlGrp,
self.eyebrowOutCtrlGrp, self.eyebrowCtrl)
# GROUPING FOR OFFSET
mc.select(cl=1)
self.ctrlGrpEyebrowInCenter = mc.group(em=1,
n='eyebrowInCtrlCenter' + side +
'_grp')
self.ctrlOffsetGrpEyebrowInCenter = mc.group(
em=1, n='eyebrowInCtrlOffsetCenter' + side + '_grp')
mc.parent(self.ctrlOffsetGrpEyebrowInCenter,
self.ctrlGrpEyebrowInCenter)
mc.select(cl=1)
self.ctrlGrpEyebrowMidCenter = mc.group(em=1,
n='eyebrowMidCtrlCenter' +
side + '_grp')
self.ctrlOffsetGrpEyebrowMidCenter = mc.group(
em=1, n='eyebrowMidCtrlOffsetCenter' + side + '_grp')
mc.parent(self.ctrlOffsetGrpEyebrowMidCenter,
self.ctrlGrpEyebrowMidCenter)
mc.select(cl=1)
self.ctrlGrpEyebrowOutCenter = mc.group(em=1,
n='eyebrowOutCtrlCenter' +
side + '_grp')
self.ctrlOffsetGrpEyebrowOutCenter = mc.group(
em=1, n='eyebrowOutCtrlOffsetCenter' + side + '_grp')
mc.parent(self.ctrlOffsetGrpEyebrowOutCenter,
self.ctrlGrpEyebrowOutCenter)
# CREATE GROUP CORESPONDENT THE JOINTS
au.createParentTransform(listparent=['', 'Offset'],
object=nostrilJnt,
matchPos=nostrilJnt,
prefix='nostril',
suffix='_jnt',
side=side)
au.createParentTransform(listparent=[''],
object=cheekUpJnt,
matchPos=cheekUpJnt,
prefix='cheekUp',
suffix='_jnt',
side=side)
au.createParentTransform(listparent=[''],
object=cheekUpOutJnt,
matchPos=cheekUpOutJnt,
prefix='cheekUpOut',
suffix='_jnt',
side=side)
self.cheekDownJntGrp = au.createParentTransform(listparent=[''],
object=cheekDownJnt,
matchPos=cheekDownJnt,
prefix='cheekDown',
suffix='_jnt',
side=side)
eyebrowInGrp = au.createParentTransform(listparent=['', 'Offset'],
object=eyebrowInJnt,
matchPos=eyebrowInJnt,
prefix='eyebrowIn',
suffix='_jnt',
side=side)
eyebrowMidGrp = au.createParentTransform(listparent=['', 'Offset'],
object=eyebrowMidJnt,
matchPos=eyebrowMidJnt,
prefix='eyebrowMid',
suffix='_jnt',
side=side)
eyebrowOutGrp = au.createParentTransform(listparent=['', 'Offset'],
object=eyebrowOutJnt,
matchPos=eyebrowOutJnt,
prefix='eyebrowOut',
suffix='_jnt',
side=side)
browInUpGrp = au.createParentTransform(listparent=['', 'Offset'],
object=browInUpJnt,
matchPos=browInUpJnt,
prefix='browInUp',
suffix='_jnt',
side=side)
browMidUpGrp = au.createParentTransform(listparent=['', 'Offset'],
object=browMidUpJnt,
matchPos=browMidUpJnt,
prefix='browMidUp',
suffix='_jnt',
side=side)
browOutUpGrp = au.createParentTransform(listparent=['', 'Offset'],
object=browOutUpJnt,
matchPos=browOutUpJnt,
prefix='browOutUp',
suffix='_jnt',
side=side)
eyelidPinchInGrp = au.createParentTransform(listparent=['', 'Offset'],
object=eyelidPinchInJnt,
matchPos=eyelidPinchInJnt,
prefix='eyelidPinchIn',
suffix='_jnt',
side=side)
browInDownGrp = au.createParentTransform(listparent=['', 'Offset'],
object=browInDownJnt,
matchPos=browInDownJnt,
prefix='browInDown',
suffix='_jnt',
side=side)
browMidDownGrp = au.createParentTransform(listparent=['', 'Offset'],
object=browMidDownJnt,
matchPos=browMidDownJnt,
prefix='browMidDown',
suffix='_jnt',
side=side)
browOutDownGrp = au.createParentTransform(listparent=['', 'Offset'],
object=browOutDownJnt,
matchPos=browOutDownJnt,
prefix='browOutDown',
suffix='_jnt',
side=side)
eyelidPinchOutGrp = au.createParentTransform(
listparent=['', 'Offset'],
object=eyelidPinchOutJnt,
matchPos=eyelidPinchOutJnt,
prefix='eyelidPinchOut',
suffix='_jnt',
side=side)
# EYBROW MAIN OFFSET GRP JOINT TRANSFORM
eyebrowInMain = self.mainGroupBindConnection(
name='eyebrowIn', side=side, objectParent=eyebrowInGrp[0])
eyebrowMidMain = self.mainGroupBindConnection(
name='eyebrowMid', side=side, objectParent=eyebrowMidGrp[0])
eyebrowOutMain = self.mainGroupBindConnection(
name='eyebrowOut', side=side, objectParent=eyebrowOutGrp[0])
# SHIFTING PARENT JOINT TO MAIN OFFSET GRP EYEBROW
mc.parent(eyebrowInGrp[1], eyebrowInMain)
mc.parent(eyebrowMidGrp[1], eyebrowMidMain)
mc.parent(eyebrowOutGrp[1], eyebrowOutMain)
# CONTROLLER ACCORDING THE FOLLICLE
object = [
self.nostrilCtrlGrp, self.cheekDownCtrlGrp, self.cheekUpCtrlGrp,
self.eyebrowInCtrlGrp, self.eyebrowMidCtrlGrp,
self.eyebrowOutCtrlGrp, self.browInUpCtrlGrp,
self.browMidUpCtrlGrp, self.browOutUpCtrlGrp,
self.browInDownCtrlGrp, self.browMidDownCtrlGrp,
self.browOutDownCtrlGrp, self.eyelidPinchInCtrlGrp,
self.eyelidPinchOutCtrlGrp, self.cheekUpOutCtrlGrp
]
self.follicleTransformAll = []
for i in object:
follicleTransform = au.createFollicleSel(
objSel=i,
objMesh=objectFolMesh,
connectFol=['transConn', 'rotateConn'])[0]
mc.parent(i, follicleTransform)
self.follicleTransformAll.append(follicleTransform)
# SCALE CONSTRAINT
mc.scaleConstraint(headCtrl, self.follicleTransformAll[0])
mc.scaleConstraint(headLowCtrl, self.follicleTransformAll[1])
for b in self.follicleTransformAll[2:]:
mc.scaleConstraint(headUpCtrl, b)
# FLIPPING THE CONTROLLER
if pos < 0:
mc.setAttr(self.nostrilCtrlGrp + '.scaleX', -1)
mc.setAttr(self.cheekUpCtrlGrp + '.scaleX', -1)
mc.setAttr(self.cheekUpOutCtrlGrp + '.scaleX', -1)
mc.setAttr(self.cheekDownCtrlGrp + '.scaleX', -1)
mc.setAttr(self.eyebrowInCtrlGrp + '.scaleX', -1)
mc.setAttr(self.eyebrowMidCtrlGrp + '.scaleX', -1)
mc.setAttr(self.eyebrowOutCtrlGrp + '.scaleX', -1)
mc.setAttr(self.browInUpCtrlGrp + '.scaleX', -1)
mc.setAttr(self.browMidUpCtrlGrp + '.scaleX', -1)
mc.setAttr(self.browOutUpCtrlGrp + '.scaleX', -1)
mc.setAttr(self.eyelidPinchInCtrlGrp + '.scaleX', -1)
mc.setAttr(self.browInDownCtrlGrp + '.scaleX', -1)
mc.setAttr(self.browMidDownCtrlGrp + '.scaleX', -1)
mc.setAttr(self.browOutDownCtrlGrp + '.scaleX', -1)
mc.setAttr(self.eyelidPinchOutCtrlGrp + '.scaleX', -1)
mc.setAttr(self.browInDownCtrlGrp + '.scaleY', -1)
mc.setAttr(self.browMidDownCtrlGrp + '.scaleY', -1)
mc.setAttr(self.browOutDownCtrlGrp + '.scaleY', -1)
# mc.setAttr(self.eyelidPinchOutCtrlGrp + '.scaleY', -1)
mc.setAttr(self.ctrlGrpEyebrowInCenter + '.scaleX', -1)
mc.setAttr(self.ctrlGrpEyebrowMidCenter + '.scaleX', -1)
mc.setAttr(self.ctrlGrpEyebrowOutCenter + '.scaleX', -1)
mc.setAttr(self.earCtrlGrp + '.scaleX', -1)
mc.setAttr(self.eyebrowCtrlGrp + '.scaleX', -1)
self.reverseNode(self.nostrilCtrl, nostrilJnt, sideRGT, sideLFT,
side)
self.reverseNode(self.cheekUpCtrl, cheekUpJnt, sideRGT, sideLFT,
side)
self.reverseNode(self.cheekUpOutCtrl, cheekUpOutJnt, sideRGT,
sideLFT, side)
self.reverseNode(self.cheekDownCtrl, cheekDownJnt, sideRGT,
sideLFT, side)
self.reverseNode(self.eyebrowInCtrl, eyebrowInJnt, sideRGT,
sideLFT, side)
self.reverseNode(self.eyebrowMidCtrl, eyebrowMidJnt, sideRGT,
sideLFT, side)
self.reverseNode(self.eyebrowOutCtrl, eyebrowOutJnt, sideRGT,
sideLFT, side)
self.reverseNode(self.browInUpCtrl, browInUpJnt, sideRGT, sideLFT,
side)
self.reverseNode(self.browMidUpCtrl, browMidUpJnt, sideRGT,
sideLFT, side)
self.reverseNode(self.browOutUpCtrl, browOutUpJnt, sideRGT,
sideLFT, side)
self.reverseNode(self.eyelidPinchInCtrl, eyelidPinchInJnt, sideRGT,
sideLFT, side)
self.reverseNode(self.browInDownCtrl,
browInDownJnt,
sideRGT,
sideLFT,
side,
inputTrans2Y=-1,
inputRot2X=-1,
inputRot2Z=1)
self.reverseNode(self.browMidDownCtrl,
browMidDownJnt,
sideRGT,
sideLFT,
side,
inputTrans2Y=-1,
inputRot2X=-1,
inputRot2Z=1)
self.reverseNode(self.browOutDownCtrl,
browOutDownJnt,
sideRGT,
sideLFT,
side,
inputTrans2Y=-1,
inputRot2X=-1,
inputRot2Z=1)
self.reverseNode(self.eyelidPinchOutCtrl, eyelidPinchOutJnt,
sideRGT, sideLFT, side)
# self.reverseNode(self.eyelidPinchOutCtrl, eyelidPinchOutJnt, sideRGT, sideLFT, side, inputTrans2X=1, inputRot2Y=1, inputRot2Z=1)
self.reverseNode(self.eyebrowCtrl, eyebrowInMain, sideRGT, sideLFT,
side)
self.reverseNode(self.eyebrowCtrl, eyebrowMidMain, sideRGT,
sideLFT, side)
self.reverseNode(self.eyebrowCtrl, eyebrowOutMain, sideRGT,
sideLFT, side)
au.connectAttrScale(self.nostrilCtrl, nostrilJnt)
au.connectAttrScale(self.cheekUpCtrl, cheekUpJnt)
au.connectAttrScale(self.cheekUpOutCtrl, cheekUpOutJnt)
au.connectAttrScale(self.cheekDownCtrl, cheekDownJnt)
au.connectAttrScale(self.eyebrowInCtrl, eyebrowInJnt)
au.connectAttrScale(self.eyebrowMidCtrl, eyebrowMidJnt)
au.connectAttrScale(self.eyebrowOutCtrl, eyebrowOutJnt)
au.connectAttrScale(self.browInUpCtrl, browInUpJnt)
au.connectAttrScale(self.browMidUpCtrl, browMidUpJnt)
au.connectAttrScale(self.browOutUpCtrl, browOutUpJnt)
au.connectAttrScale(self.eyelidPinchInCtrl, eyelidPinchInJnt)
au.connectAttrScale(self.browInDownCtrl, browInDownJnt)
au.connectAttrScale(self.browMidDownCtrl, browMidDownJnt)
au.connectAttrScale(self.browOutDownCtrl, browOutDownJnt)
au.connectAttrScale(self.eyelidPinchOutCtrl, eyelidPinchOutJnt)
au.connectAttrScale(self.eyebrowCtrl, eyebrowInMain)
au.connectAttrScale(self.eyebrowCtrl, eyebrowMidMain)
au.connectAttrScale(self.eyebrowCtrl, eyebrowOutMain)
else:
au.connectAttrObject(self.nostrilCtrl, nostrilJnt)
au.connectAttrObject(self.cheekUpCtrl, cheekUpJnt)
au.connectAttrObject(self.cheekUpOutCtrl, cheekUpOutJnt)
au.connectAttrObject(self.cheekDownCtrl, cheekDownJnt)
au.connectAttrObject(self.eyebrowInCtrl, eyebrowInJnt)
au.connectAttrObject(self.eyebrowMidCtrl, eyebrowMidJnt)
au.connectAttrObject(self.eyebrowOutCtrl, eyebrowOutJnt)
au.connectAttrObject(self.browInUpCtrl, browInUpJnt)
au.connectAttrObject(self.browMidUpCtrl, browMidUpJnt)
au.connectAttrObject(self.browOutUpCtrl, browOutUpJnt)
au.connectAttrObject(self.eyelidPinchInCtrl, eyelidPinchInJnt)
au.connectAttrObject(self.eyelidPinchOutCtrl, eyelidPinchOutJnt)
au.connectAttrObject(self.eyebrowCtrl, eyebrowInMain)
au.connectAttrObject(self.eyebrowCtrl, eyebrowMidMain)
au.connectAttrObject(self.eyebrowCtrl, eyebrowOutMain)
mc.setAttr(self.browInDownCtrlGrp + '.scaleY', -1)
mc.setAttr(self.browMidDownCtrlGrp + '.scaleY', -1)
mc.setAttr(self.browOutDownCtrlGrp + '.scaleY', -1)
# mc.setAttr(self.eyelidPinchOutCtrlGrp + '.scaleX', -1)
self.reverseNode(self.browInDownCtrl,
browInDownJnt,
sideRGT,
sideLFT,
side,
inputTrans2X=1,
inputTrans2Y=-1,
inputRot2X=-1,
inputRot2Y=1)
self.reverseNode(self.browMidDownCtrl,
browMidDownJnt,
sideRGT,
sideLFT,
side,
inputTrans2X=1,
inputTrans2Y=-1,
inputRot2X=-1,
inputRot2Y=1)
self.reverseNode(self.browOutDownCtrl,
browOutDownJnt,
sideRGT,
sideLFT,
side,
inputTrans2X=1,
inputTrans2Y=-1,
inputRot2X=-1,
inputRot2Y=1)
# self.reverseNode(self.eyelidPinchOutCtrl, eyelidPinchOutJnt, sideRGT, sideLFT, side)
# ROTATE THE DIRECTION
mc.setAttr(browInUpGrp[1] + '.rotateY', directionBrowIn)
mc.setAttr(browMidUpGrp[1] + '.rotateY', directionBrowMid)
mc.setAttr(browOutUpGrp[1] + '.rotateY', directionBrowOut)
mc.setAttr(eyelidPinchInGrp[1] + '.rotateY', directionBrowPinchIn)
mc.setAttr(browInDownGrp[1] + '.rotateY', directionBrowIn)
mc.setAttr(browMidDownGrp[1] + '.rotateY', directionBrowMid)
mc.setAttr(browOutDownGrp[1] + '.rotateY', directionBrowOut)
mc.setAttr(eyelidPinchOutGrp[1] + '.rotateY', directionBrowPinchOut)
mc.setAttr(browInUpCtrl.parentControl[1] + '.rotateY', directionBrowIn)
mc.setAttr(browMidUpCtrl.parentControl[1] + '.rotateY',
directionBrowMid)
mc.setAttr(browOutUpCtrl.parentControl[1] + '.rotateY',
directionBrowOut)
mc.setAttr(eyelidPinchInCtrl.parentControl[1] + '.rotateY',
directionBrowPinchIn)
mc.setAttr(browInDownCtrl.parentControl[1] + '.rotateY',
directionBrowIn)
mc.setAttr(browMidDownCtrl.parentControl[1] + '.rotateY',
directionBrowMid)
mc.setAttr(browOutDownCtrl.parentControl[1] + '.rotateY',
directionBrowOut)
mc.setAttr(eyelidPinchOutCtrl.parentControl[1] + '.rotateY',
directionBrowPinchOut)
# CONSTRAINT EARS
mc.parentConstraint(self.earCtrl, earJnt, mo=1)
mc.scaleConstraint(self.earCtrl, earJnt, mo=1)
# EYEBROW EXCEPTION PARENTING CTRL
mc.delete(
mc.pointConstraint(self.eyebrowCtrl, self.ctrlGrpEyebrowInCenter))
mc.delete(
mc.pointConstraint(self.eyebrowCtrl, self.ctrlGrpEyebrowMidCenter))
mc.delete(
mc.pointConstraint(self.eyebrowCtrl, self.ctrlGrpEyebrowOutCenter))
# grouping to follicle
mc.parent(self.ctrlGrpEyebrowInCenter, self.follicleTransformAll[3])
mc.parent(self.ctrlGrpEyebrowMidCenter, self.follicleTransformAll[4])
mc.parent(self.ctrlGrpEyebrowOutCenter, self.follicleTransformAll[5])
# regrouping to offset grp
mc.parent(self.eyebrowInCtrlGrp, self.ctrlOffsetGrpEyebrowInCenter)
mc.parent(self.eyebrowMidCtrlGrp, self.ctrlOffsetGrpEyebrowMidCenter)
mc.parent(self.eyebrowOutCtrlGrp, self.ctrlOffsetGrpEyebrowOutCenter)
# connect attr
au.connectAttrObject(self.eyebrowCtrl,
self.ctrlOffsetGrpEyebrowInCenter)
au.connectAttrObject(self.eyebrowCtrl,
self.ctrlOffsetGrpEyebrowMidCenter)
au.connectAttrObject(self.eyebrowCtrl,
self.ctrlOffsetGrpEyebrowOutCenter)
def blinkSetup(self, sideRGT, sideLFT, eyeballJnt, prefixEyeball,
prefixEyeballAim, crvUp, crvDown, scale, side, eyelidUp,
eyelidDown, positionEyeAimCtrl, worldUpAimObject,
eyeballAimMainCtrl, controllerBind03OffsetCtrlUp,
controllerBind03OffsetCtrlDown, jointBind03GrpAllUp,
jointBind03GrpAllDown, jointBind03GrpOffsetDown,
jointBind03GrpOffsetUp):
# ==============================================================================================================
# EYEBALL CONTROLLER
# ==============================================================================================================
eyballGrp = au.createParentTransform(listparent=['Zro', 'Offset'],
object=eyeballJnt,
matchPos=eyeballJnt,
prefix='eyeball',
suffix='_jnt',
side=side)
self.eyeballCtrl = ct.Control(matchPos=eyeballJnt,
prefix=prefixEyeball,
shape=ct.JOINTPLUS,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 2,
ctrlColor='blue',
lockChannels=['v', 's'],
side=side,
connect=['connectMatrixAll'])
self.eyeballController = self.eyeballCtrl.control
# ADD ATTRIBUTE
au.addAttribute(objects=[self.eyeballCtrl.control],
longName=['eyelidDegree'],
niceName=[' '],
at="enum",
en='Eyelid Degree',
cb=True)
self.eyelidPos = au.addAttribute(objects=[self.eyeballCtrl.control],
longName=['eyelidPos'],
attributeType="float",
min=0,
max=1,
dv=0.5,
k=True)
self.eyelidFollow = au.addAttribute(objects=[self.eyeballCtrl.control],
longName=['eyelidFollow'],
attributeType="float",
min=0,
max=2,
dv=1,
k=True)
# ==============================================================================================================
# EYEBALL AIM
# ==============================================================================================================
if mc.xform(eyeballJnt, q=1, ws=1, t=1)[0] > 0:
ctrlColor = 'red'
else:
ctrlColor = 'yellow'
self.eyeballAimCtrl = ct.Control(matchPos=eyeballJnt,
prefix=prefixEyeballAim,
shape=ct.LOCATOR,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.2,
ctrlColor=ctrlColor,
lockChannels=['v', 'r', 's'],
side=side)
eyeballAimCtrl = self.eyeballAimCtrl.control
getAttribute = mc.getAttr(self.eyeballAimCtrl.parentControl[0] +
'.translateZ')
mc.setAttr(self.eyeballAimCtrl.parentControl[0] + '.translateZ',
getAttribute + (positionEyeAimCtrl * scale))
mc.aimConstraint(self.eyeballAimCtrl.control,
eyballGrp[1],
mo=1,
weight=1,
aimVector=(0, 0, 1),
upVector=(0, 1, 0),
worldUpType="object",
worldUpObject=worldUpAimObject)
# PARENT EYE AIM TO EYEBALL AIM MAIN CTRL
mc.parent(self.eyeballAimCtrl.parentControl[0], eyeballAimMainCtrl)
# EXPRESSION UP AND DOWN FOLLOW EYELID CTRL
expressionEyelidCtrl= "$range = {5}.{1}; " \
"$a = 20 /$range; " \
"$b = 30 /$range; " \
"$c = 80 /$range;" \
"{2}.translateX = {3}.translateX /$c + {0}.translateX /$c;" \
"{2}.translateY = {3}.translateY /$a + {0}.translateY /$a;" \
"{4}.translateX = {3}.translateX /$c + {0}.translateX /$c;" \
"{4}.translateY = -{3}.translateY /$b - {0}.translateY /$b;"\
\
.format(eyeballAimCtrl, # 0
self.eyelidFollow, # 1
controllerBind03OffsetCtrlUp, # 2
eyeballAimMainCtrl,# 3
controllerBind03OffsetCtrlDown,
self.eyeballCtrl.control
)
mc.expression(s=expressionEyelidCtrl,
n="%s%s%s" % ('eyelidCtrl', side, '_expr'),
ae=0)
# EXPRESSION UP AND DOWN FOLLOW EYELID BIND
expressionEyelidBind = "$range = {7}.{1}; " \
"$a = 30 /$range; " \
"$b = 8 /$range; " \
"$d = 12 /$range; " \
"$c = 60 /$range;" \
"if ({0}.translateY >= 0) " \
"{8} " \
"{2}.translateY = {0}.translateY /$b; " \
"{3}.translateY = {0}.translateY /$b;" \
"{9} " \
"else if ({0}.translateY < 0)" \
"{8}" \
"{2}.translateY = {0}.translateY /$d; " \
"{3}.translateY = {0}.translateY /$a;" \
"{9} " \
"{2}.translateX = {0}.translateX /$c; " \
"{3}.translateX = {0}.translateX /$c; " \
"if ({6}.translateY >= 0) " \
"{8}" \
"{4}.translateY = {6}.translateY /$b; " \
"{5}.translateY = {6}.translateY /$b;" \
"{9} " \
"else if ({6}.translateY < 0) " \
"{8}" \
"{4}.translateY = {6}.translateY /$d; " \
"{5}.translateY = {6}.translateY /$a;" \
"{9} " \
"{4}.translateX = {6}.translateX /$c; " \
"{5}.translateX = {6}.translateX /$c;" \
\
.format(eyeballAimCtrl,
self.eyelidFollow,
jointBind03GrpAllUp,
jointBind03GrpAllDown,
jointBind03GrpOffsetUp,
jointBind03GrpOffsetDown,
eyeballAimMainCtrl,
self.eyeballCtrl.control,
"{",
"}")
mc.expression(s=expressionEyelidBind,
n="%s%s%s" % ('eyelidBind', side, '_expr'),
ae=0)
# ==============================================================================================================
# BLINK
# ==============================================================================================================
# CREATE CURVE MID BLINK
curveBlinkBindMidOld = mc.curve(d=3,
ep=[(self.eyelidUp.xformJnt01),
(self.eyelidUp.xformJnt05)])
curveBlinkBindMidReb = mc.rebuildCurve(curveBlinkBindMidOld,
ch=0,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=8,
d=3,
tol=0.01)
curveBlinkBindMid = mc.rename(curveBlinkBindMidReb,
('eyelidBlink' + side + '_crv'))
curveBlinkUp = mc.duplicate(crvUp,
n='eyelidBlinkUp' + side + '_crv')[0]
curveBlinkDown = mc.duplicate(crvDown,
n='eyelidBlinkDown' + side + '_crv')[0]
blinkBsn = mc.blendShape(eyelidUp.deformCrv,
eyelidDown.deformCrv,
curveBlinkBindMid,
n=('eyelidBlink' + side + '_bsn'),
weight=[(0, 1), (1, 0)])[0]
mc.select(cl=1)
if sideRGT in crvUp:
crvUpNewName = crvUp.replace(sideRGT, '')
elif sideLFT in crvUp:
crvUpNewName = crvUp.replace(sideLFT, '')
else:
crvUpNewName = crvUp
# wire deform up on mid curves
stickyMidwireDefUp = mc.wire(curveBlinkUp,
dds=(0, 100 * scale),
wire=curveBlinkBindMid)
stickyMidwireDefUp[0] = mc.rename(
stickyMidwireDefUp[0],
(au.prefixName(crvUpNewName) + 'Blink' + side + '_wireNode'))
# SET TO DOWN CURVE
mc.setAttr(blinkBsn + '.%s' % eyelidUp.deformCrv, 0)
mc.setAttr(blinkBsn + '.%s' % eyelidDown.deformCrv, 1)
mc.select(cl=1)
if sideRGT in crvDown:
crvDownNewName = crvDown.replace(sideRGT, '')
elif sideLFT in crvDown:
crvDownNewName = crvDown.replace(sideLFT, '')
else:
crvDownNewName = crvDown
# wire deform down on mid curves
stickyMidwireDefDown = mc.wire(curveBlinkDown,
dds=(0, 100 * scale),
wire=curveBlinkBindMid)
stickyMidwireDefDown[0] = mc.rename(
stickyMidwireDefDown[0],
(au.prefixName(crvDownNewName) + 'Blink' + side + '_wireNode'))
# SET KEYFRAME
mc.setDrivenKeyframe(blinkBsn + '.%s' % eyelidUp.deformCrv,
cd='%s.%s' %
(self.eyeballCtrl.control, self.eyelidPos),
dv=0,
v=1,
itt='linear',
ott='linear')
mc.setDrivenKeyframe(blinkBsn + '.%s' % eyelidUp.deformCrv,
cd='%s.%s' %
(self.eyeballCtrl.control, self.eyelidPos),
dv=1,
v=0,
itt='linear',
ott='linear')
mc.setDrivenKeyframe(blinkBsn + '.%s' % eyelidDown.deformCrv,
cd='%s.%s' %
(self.eyeballCtrl.control, self.eyelidPos),
dv=0,
v=0,
itt='linear',
ott='linear')
mc.setDrivenKeyframe(blinkBsn + '.%s' % eyelidDown.deformCrv,
cd='%s.%s' %
(self.eyeballCtrl.control, self.eyelidPos),
dv=1,
v=1,
itt='linear',
ott='linear')
# CONNECT TO BLENDSHAPE BIND CURVE
eyelidUpBsn = mc.blendShape(curveBlinkUp,
crvUp,
n=('eyelidBlinkUp' + side + '_bsn'),
weight=[(0, 1)])[0]
mc.connectAttr(
eyelidUp.controllerBind03Ctrl + '.%s' % eyelidUp.closeEyelid,
eyelidUpBsn + '.%s' % curveBlinkUp)
eyelidDownBsn = mc.blendShape(curveBlinkDown,
crvDown,
n=('eyelidBlinkDown' + side + '_bsn'),
weight=[(0, 1)])[0]
mc.connectAttr(
eyelidDown.controllerBind03Ctrl + '.%s' % eyelidDown.closeEyelid,
eyelidDownBsn + '.%s' % curveBlinkDown)
# CREATE GROUP FOR EYELID STUFF
eyelidGrp = mc.group(em=1, n='eyelid' + side + '_grp')
return eyelidGrp
def controllerLid(self, sideRGT, sideLFT, scale, side, crv,
controllerLidDown, ctrlColor):
if sideRGT in crv:
newName = crv.replace(sideRGT, '')
elif sideLFT in crv:
newName = crv.replace(sideLFT, '')
else:
newName = crv
# controller 03
self.controllerBind03 = ct.Control(matchPos=self.jnt03,
prefix=au.prefixName(newName) +
'03',
shape=ct.CIRCLEPLUS,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v', 's'],
side=side)
# ADD ATTRIBUTE
au.addAttribute(objects=[self.controllerBind03.control],
longName=['eyelid'],
niceName=[' '],
at="enum",
en='Eyelid',
cb=True)
self.closeEyelid = au.addAttribute(
objects=[self.controllerBind03.control],
longName=['closeEyelid'],
attributeType="float",
min=0,
max=1,
dv=0,
k=True)
self.controllerBind03Ctrl = self.controllerBind03.control
self.controllerBind03OffsetCtrl = self.controllerBind03.parentControl[
1]
# controller 01
self.controllerBind01 = ct.Control(matchPos=self.jnt01,
prefix=au.prefixName(newName) +
'01',
shape=ct.CIRCLEPLUS,
groupsCtrl=['Zro', 'Offset', 'All'],
ctrlSize=scale * 0.15,
ctrlColor=ctrlColor,
lockChannels=['v', 's'],
side=side)
self.controllerBindGrpZro01 = self.controllerBind01.parentControl[0]
# controller 02
self.controllerBind02 = ct.Control(matchPos=self.jnt02,
prefix=au.prefixName(newName) +
'02',
shape=ct.CIRCLEPLUS,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.2,
ctrlColor=ctrlColor,
lockChannels=['v', 's'],
side=side)
# controller 05
self.controllerBind05 = ct.Control(matchPos=self.jnt05,
prefix=au.prefixName(newName) +
'05',
shape=ct.CIRCLEPLUS,
groupsCtrl=['Zro', 'Offset', 'All'],
ctrlSize=scale * 0.15,
ctrlColor=ctrlColor,
lockChannels=['v', 's'],
side=side)
self.controllerBindGrpZro05 = self.controllerBind05.parentControl[0]
# controller 04
self.controllerBind04 = ct.Control(matchPos=self.jnt04,
prefix=au.prefixName(newName) +
'04',
shape=ct.CIRCLEPLUS,
groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.2,
ctrlColor=ctrlColor,
lockChannels=['v', 's'],
side=side)
# create grp controller and parent into it
self.grpDrvCtrl = mc.createNode('transform',
n=au.prefixName(newName) + 'Ctrl' +
side + '_grp')
mc.parent(self.controllerBind03.parentControl[0],
self.controllerBind01.parentControl[0],
self.controllerBind02.parentControl[0],
self.controllerBind05.parentControl[0],
self.controllerBind04.parentControl[0], self.grpDrvCtrl)
# # connect group parent bind joint 01 and 02 to the controller grp parent 01 and 02
# au.connectAttrTransRot(self.jointBind02Grp[0], self.controllerBind02.parentControl[0])
# au.connectAttrTransRot(self.jointBind04Grp[0], self.controllerBind04.parentControl[0])
# flipping controller
if controllerLidDown:
if self.pos > 0:
mc.setAttr(self.controllerBind01.parentControl[0] + '.scaleX',
-1)
mc.setAttr(self.controllerBind02.parentControl[0] + '.scaleX',
-1)
mc.setAttr(self.controllerBind04.parentControl[0] + '.scaleX',
1)
mc.setAttr(self.controllerBind05.parentControl[0] + '.scaleX',
1)
# connect translate controller to joint
# right side 01 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind01.control,
input2X=-1,
input2Y=-1,
input2Z=1,
jointBindTarget=self.jnt01)
# right side 02 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind02.control,
input2X=-1,
input2Y=-1,
input2Z=1,
jointBindTarget=self.jnt02)
# left side 02 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind04.control,
input2X=1,
input2Y=-1,
input2Z=1,
jointBindTarget=self.jnt04)
# left side 01 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind05.control,
input2X=1,
input2Y=-1,
input2Z=1,
jointBindTarget=self.jnt05)
else:
mc.setAttr(self.controllerBind01.parentControl[0] + '.scaleX',
1)
mc.setAttr(self.controllerBind02.parentControl[0] + '.scaleX',
1)
mc.setAttr(self.controllerBind04.parentControl[0] + '.scaleX',
-1)
mc.setAttr(self.controllerBind05.parentControl[0] + '.scaleX',
-1)
# connect translate controller to joint
# right side 01 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind01.control,
input2X=1,
input2Y=-1,
input2Z=1,
jointBindTarget=self.jnt01)
# right side 02 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind02.control,
input2X=1,
input2Y=-1,
input2Z=1,
jointBindTarget=self.jnt02)
# left side 02 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind04.control,
input2X=-1,
input2Y=-1,
input2Z=1,
jointBindTarget=self.jnt04)
# left side 01 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind05.control,
input2X=-1,
input2Y=-1,
input2Z=1,
jointBindTarget=self.jnt05)
mc.setAttr(self.controllerBind01.parentControl[0] + '.scaleY', -1)
mc.setAttr(self.controllerBind02.parentControl[0] + '.scaleY', -1)
mc.setAttr(self.controllerBind05.parentControl[0] + '.scaleY', -1)
mc.setAttr(self.controllerBind04.parentControl[0] + '.scaleY', -1)
mc.setAttr(self.controllerBind03.parentControl[0] + '.scaleY', -1)
au.connectAttrRot(self.controllerBind01.control, self.jnt01)
au.connectAttrRot(self.controllerBind02.control, self.jnt02)
# mid translate and rotate
self.bindTranslateReverse(control=self.controllerBind03.control,
input2X=1,
input2Y=-1,
input2Z=1,
jointBindTarget=self.jnt03)
au.connectAttrRot(self.controllerBind03.control, self.jnt03)
au.connectAttrRot(self.controllerBind04.control, self.jnt04)
au.connectAttrRot(self.controllerBind05.control, self.jnt05)
else:
if self.pos > 0:
mc.setAttr(self.controllerBind01.parentControl[0] + '.scaleX',
-1)
mc.setAttr(self.controllerBind02.parentControl[0] + '.scaleX',
-1)
mc.setAttr(self.controllerBind04.parentControl[0] + '.scaleX',
1)
mc.setAttr(self.controllerBind05.parentControl[0] + '.scaleX',
1)
# right side 01 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind01.control,
input2X=-1,
input2Y=1,
input2Z=1,
jointBindTarget=self.jnt01)
# right side 02 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind02.control,
input2X=-1,
input2Y=1,
input2Z=1,
jointBindTarget=self.jnt02)
# left side 02 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind04.control,
input2X=1,
input2Y=1,
input2Z=1,
jointBindTarget=self.jnt04)
# left side 01 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind05.control,
input2X=1,
input2Y=1,
input2Z=1,
jointBindTarget=self.jnt05)
else:
mc.setAttr(self.controllerBind01.parentControl[0] + '.scaleX',
1)
mc.setAttr(self.controllerBind02.parentControl[0] + '.scaleX',
1)
mc.setAttr(self.controllerBind04.parentControl[0] + '.scaleX',
-1)
mc.setAttr(self.controllerBind05.parentControl[0] + '.scaleX',
-1)
# right side 01 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind01.control,
input2X=1,
input2Y=1,
input2Z=1,
jointBindTarget=self.jnt01)
# right side 02 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind02.control,
input2X=1,
input2Y=1,
input2Z=1,
jointBindTarget=self.jnt02)
# left side 02 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind04.control,
input2X=-1,
input2Y=1,
input2Z=1,
jointBindTarget=self.jnt04)
# left side 01 translate and rotate
self.bindTranslateReverse(
control=self.controllerBind05.control,
input2X=-1,
input2Y=1,
input2Z=1,
jointBindTarget=self.jnt05)
au.connectAttrRot(self.controllerBind02.control, self.jnt02)
au.connectAttrRot(self.controllerBind01.control, self.jnt01)
# left side 02 translate and rotate
au.connectAttrRot(self.controllerBind04.control, self.jnt04)
# left side 01 translate and rotate
au.connectAttrRot(self.controllerBind05.control, self.jnt05)
# mid translate and rotate
au.connectAttrTransRot(self.controllerBind03.control, self.jnt03)
def blinkSetup(self, sideRGT, sideLFT, eyeballJnt, prefixEyeball, prefixEyeballAim, crvUp, crvDown, scale,
side, eyelidUp, eyelidDown, positionEyeAimCtrl, worldUpAimObject, eyeballAimMainCtrl,
controllerBind03OffsetCtrlUp, controllerBind03OffsetCtrlDown, jointBind03GrpAllUp, jointBind03GrpAllDown,
jointBind03GrpOffsetDown, jointBind03GrpOffsetUp, pupilJnt, irisJnt, prefixPupil, prefixIris,
eyeballSpecJnt, prefixEyeballSpec, ctrlGrp, headUpCtrl, faceCtrlGrp,
eyeballSpecTipJnt, mainJointGrp):
# ==============================================================================================================
# EYEBALL CONTROLLER
# ==============================================================================================================
# # create group eye spec
# eyeSpecDirectionGrp = mc.group(em=1, n=au.prefixName(eyeballSpecJnt) + 'Direction'+ side+'_grp')
# eyeSpecDirectionOffsetGrp = mc.group(em=1, n=au.prefixName(eyeballSpecJnt) + 'DirectionOffset'+ side+'_grp', p=eyeSpecDirectionGrp)
# self.eyeSpecDirectionOffsetGrp = eyeSpecDirectionOffsetGrp
#
#
# mc.select(cl=1)
# mc.delete(mc.parentConstraint(eyeballSpecJnt, eyeSpecDirectionGrp))
eyeballGrp = au.createParentTransform(listparent=['Zro', 'Offset'], object=eyeballJnt, matchPos=eyeballJnt,
prefix='eyeball',
suffix='_jnt', side=side)
irisGrp = au.createParentTransform(listparent=['Zro'], object=irisJnt, matchPos=irisJnt,
prefix='iris',
suffix='_jnt', side=side)
pupilGrp = au.createParentTransform(listparent=['Zro'], object=pupilJnt, matchPos=pupilJnt,
prefix='pupil',
suffix='_jnt', side=side)
eyeballSpecGrp = au.createParentTransform(listparent=['Zro'], object=eyeballSpecJnt, matchPos=eyeballSpecJnt,
prefix='eyeballSpec',
suffix='_jnt', side=side)
eyeballSpecTipGrp = au.createParentTransform(listparent=['Zro'], object=eyeballSpecTipJnt, matchPos=eyeballSpecTipJnt,
prefix='eyeballSpecTip',
suffix='_jnt', side=side)
self.eyeballCtrl = ct.Control(matchPos=eyeballJnt,
prefix=prefixEyeball,
shape=ct.JOINTPLUS, groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 2,
ctrlColor='blue', lockChannels=['v'], side=side,
connect=['connectMatrixAll'])
self.irisCtrl = ct.Control(matchPos=irisJnt,
prefix=prefixIris,
shape=ct.CIRCLEPLUS, groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 2,
ctrlColor='red', lockChannels=['v'], side=side,
connect=['connectMatrixAll'])
self.pupilCtrl = ct.Control(matchPos=pupilJnt,
prefix=prefixPupil,
shape=ct.CIRCLEPLUS, groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 2,
ctrlColor='yellow', lockChannels=['v'], side=side,
connect=['connectMatrixAll'])
eyeballSpecCtrl = ct.Control(matchPos=eyeballSpecJnt,
prefix=prefixEyeballSpec,
shape=ct.CIRCLEPLUS, groupsCtrl=['', 'Global', 'Local'],
ctrlSize=scale * 2,
ctrlColor='yellow', lockChannels=['v', 's'], side=side,
connect=['parentCons','scaleCons'])
# ADD ATTRIBUTE EYEBALL SPEC
self.offsetEyeballSpec = au.addAttribute(objects=[eyeballSpecCtrl.control], longName=['Offset'],
attributeType="float", min=0, dv=0, k=True)
self.sizeEyeballSpec = au.addAttribute(objects=[eyeballSpecCtrl.control], longName=['size'],
attributeType="float", min=0, dv=1, k=True)
self.eyeballController = self.eyeballCtrl.control
self.eyeballSpecCtrl = eyeballSpecCtrl.control
self.eyeballSpecCtrlGrp = eyeballSpecCtrl.parentControl[0]
self.eyeballSpecCtrlGlobal = eyeballSpecCtrl.parentControl[1]
self.eyeballSpecCtrlLocal= eyeballSpecCtrl.parentControl[2]
# PARENT EYE SPEC DIRECTION TO EYEBALL GRP
# mc.parent(eyeSpecDirectionGrp, eyeballGrp[1])
mc.parent(self.pupilCtrl.parentControl[0], self.irisCtrl.control)
mc.parent(self.irisCtrl.parentControl[0], self.eyeballController)
mc.parent(eyeballSpecGrp[0], mainJointGrp)
mc.parent(self.eyeballSpecCtrlGrp, faceCtrlGrp)
# ADD ATTRIBUTE
au.addAttribute(objects=[self.eyeballCtrl.control], longName=['eyelidDegree'], niceName=[' '], at="enum",
en='Eyelid Degree', cb=True)
self.eyelidPos = au.addAttribute(objects=[self.eyeballCtrl.control], longName=['eyelidPos'],
attributeType="float", min=0, max=1, dv=0.6, k=True)
self.eyelidFollow = au.addAttribute(objects=[self.eyeballCtrl.control], longName=['eyelidFollow'],
attributeType="float", min=0.001, dv=1, k=True)
# LOCAL WORLD EYEBALL SPEC
self.localWorld(objectName='eyeballSpec', objectCtrl=self.eyeballSpecCtrl,
objectParentGrp=self.eyeballSpecCtrlGrp,
objectParentGlobal=self.eyeballSpecCtrlGlobal,
objectParentLocal=self.eyeballSpecCtrlLocal,
localBase=headUpCtrl, worldBase=ctrlGrp, eyeAim=False, side=side)
# CONNECT ATTRIBUTE EYEBALL SPEC
mc.connectAttr(self.eyeballSpecCtrl+'.%s' % self.offsetEyeballSpec, eyeballSpecTipJnt+'.translateZ')
mc.connectAttr(self.eyeballSpecCtrl+'.%s' % self.sizeEyeballSpec,eyeballSpecTipJnt+'.scaleX')
mc.connectAttr(self.eyeballSpecCtrl+'.%s' % self.sizeEyeballSpec,eyeballSpecTipJnt+'.scaleY')
mc.connectAttr(self.eyeballSpecCtrl+'.%s' % self.sizeEyeballSpec,eyeballSpecTipJnt+'.scaleZ')
# SCALE CONSTRAINT
mc.scaleConstraint(headUpCtrl, eyeballSpecCtrl.parentControl[1], mo=1)
# # jaw reverse trans
# self.eyeSpecReverseNode(prefixObject=prefixEyeballSpec, nodeName='ReverseTrans', eyeSpecController=self.eyeballSpecCtrl,
# eyeSpecOffsetGrpCtrl=self.eyeballSpecCtrlOffset, connection='translate', side=side)
#
# self.eyeSpecReverseNode(prefixObject=prefixEyeballSpec, nodeName='ReverseRot', eyeSpecController=self.eyeballSpecCtrl,
# eyeSpecOffsetGrpCtrl=self.eyeballSpecCtrlOffset, connection='rotate', side=side)
#
# au.connectAttrRot(self.eyeballSpecCtrl, eyeballSpecJnt)
# au.connectAttrTrans(self.eyeballSpecCtrl, eyeballSpecTipJnt)
# # connect to base joint
# self.eyeSpecCtrlGimbalDriverJnt(prefixObject=prefixEyeballSpec, nodeName='AddTrans', eyeSpecController=head.jawCtrl.control,
# jawControllerGimbal=head.jawCtrl.controlGimbal, jawTarget=jawJoint,
# attribute='translate')
#
# self.eyeSpecCtrlGimbalDriverJnt(prefixObject=prefixEyeballSpec, nodeName='AddRot', eyeSpecController=head.jawCtrl.control,
# jawControllerGimbal=head.jawCtrl.controlGimbal, jawTarget=jawJoint,
# attribute='rotate')
#
# # connect to jaw direction offset
# self.eyeSpecCtrlGimbalDriverJnt(prefixObject=prefixEyeballSpec, nodeName='AddTransDir', eyeSpecController=head.jawCtrl.control,
# jawControllerGimbal=head.jawCtrl.controlGimbal, jawTarget=head.jawDirectionOffsetGrp,
# attribute='translate')
#
# self.eyeSpecCtrlGimbalDriverJnt(prefixObject=prefixEyeballSpec, nodeName='AddRotDir', eyeSpecController=head.jawCtrl.control,
# jawControllerGimbal=head.jawCtrl.controlGimbal, jawTarget=head.jawDirectionOffsetGrp,
# attribute='rotate')
# mc.delete(mc.parentConstraint(ctrlGrp, self.eyeballSpecCtrlOffsetMtx))
# # connect the tip joint to parent ctrl jaw
# dMtxEyeSpec = mc.createNode('decomposeMatrix', n=prefixEyeballSpec + side+ '_dmtx')
# mc.connectAttr(eyeballSpecTipJnt + '.worldMatrix[0]', dMtxEyeSpec + '.inputMatrix')
#
# mc.connectAttr(dMtxEyeSpec + '.outputTranslate', self.eyeballSpecCtrlMtx + '.translate')
# mc.connectAttr(dMtxEyeSpec + '.outputRotate', self.eyeballSpecCtrlMtx + '.rotate')
# mc.connectAttr(dMtxEyeSpec + '.outputScale', self.eyeballSpecCtrlMtx + '.scale')
# ==============================================================================================================
# EYEBALL AIM
# ==============================================================================================================
if mc.xform(eyeballJnt, q=1, ws=1, t=1)[0] > 0:
ctrlColor ='red'
else:
ctrlColor='yellow'
self.eyeballAimCtrl = ct.Control(matchPos=eyeballJnt,
prefix=prefixEyeballAim,
shape=ct.LOCATOR, groupsCtrl=['Zro', 'Offset'],
ctrlSize=scale * 0.2,
ctrlColor=ctrlColor, lockChannels=['v','r','s'], side=side)
eyeballAimCtrl = self.eyeballAimCtrl.control
getAttribute = mc.getAttr(self.eyeballAimCtrl.parentControl[0]+'.translateZ')
mc.setAttr(self.eyeballAimCtrl.parentControl[0]+'.translateZ', getAttribute+(positionEyeAimCtrl*scale))
mc.aimConstraint(self.eyeballAimCtrl.control, eyeballGrp[1], mo=1, weight=1, aimVector=(0, 0, 1), upVector=(0, 1, 0),
worldUpType="object", worldUpObject=worldUpAimObject)
# PARENT EYE AIM TO EYEBALL AIM MAIN CTRL
mc.parent(self.eyeballAimCtrl.parentControl[0], eyeballAimMainCtrl)
# EXPRESSION UP AND DOWN FOLLOW EYELID CTRL
expressionEyelidCtrl= "$range = {5}.{1}; " \
"$a = 20 /$range; " \
"$b = 30 /$range; " \
"$c = 80 /$range;" \
"{2}.translateX = {3}.translateX /$c + {0}.translateX /$c;" \
"{2}.translateY = {3}.translateY /$a + {0}.translateY /$a;" \
"{4}.translateX = {3}.translateX /$c + {0}.translateX /$c;" \
"{4}.translateY = -{3}.translateY /$b - {0}.translateY /$b;"\
\
.format(eyeballAimCtrl, # 0
self.eyelidFollow, # 1
controllerBind03OffsetCtrlUp, # 2
eyeballAimMainCtrl,# 3
controllerBind03OffsetCtrlDown,
self.eyeballCtrl.control
)
mc.expression(s=expressionEyelidCtrl, n="%s%s%s" % ('eyelidCtrl', side, '_expr'), ae=0)
# $range = eyeballLFT_ctrl.eyelidFollow;
# $a = 30 /$range;
# $b = 8 /$range;
# $d = 12 /$range;
# $c = 60 /$range;
# $e = 50 /$range;
# $f = 60 /$range;
# $g = 60 /$range;
# $h = 25 /$range;
#
# if (eyeballAimLFT_ctrl.translateY >= 0)
# {eyelidUpBindAll03LFT_grp.translateY = eyeballAimLFT_ctrl.translateY /$g;
# eyelidDownBindAll03LFT_grp.translateY = eyeballAimLFT_ctrl.translateY /$h;}
#
# else if (eyeballAimLFT_ctrl.translateY < 0)
# {eyelidUpBindAll03LFT_grp.translateY = eyeballAimLFT_ctrl.translateY /$d;
# eyelidDownBindAll03LFT_grp.translateY = eyeballAimLFT_ctrl.translateY /$f;}
# eyelidUpBindAll03LFT_grp.translateX = eyeballAimLFT_ctrl.translateX /$c;
# eyelidDownBindAll03LFT_grp.translateX = eyeballAimLFT_ctrl.translateX /$c;
#
# if (eyeballAim_ctrl.translateY >= 0)
# {eyelidDownBindOffset03LFT_grp.translateY = eyeballAim_ctrl.translateY /$h;
# eyelidUpBindOffset03LFT_grp.translateY = eyeballAim_ctrl.translateY /$g;}
#
# else if
# (eyeballAim_ctrl.translateY < 0)
# {eyelidDownBindOffset03LFT_grp.translateY = eyeballAim_ctrl.translateY /$e;
# eyelidUpBindOffset03LFT_grp.translateY = eyeballAim_ctrl.translateY /$a;}
# eyelidDownBindOffset03LFT_grp.translateX = eyeballAim_ctrl.translateX /$c;
# eyelidUpBindOffset03LFT_grp.translateX = eyeballAim_ctrl.translateX /$c;
# EXPRESSION UP AND DOWN FOLLOW EYELID BIND
expressionEyelidBind = "$range = {7}.{1}; " \
"$a = 30 /$range; " \
"$d = 12 /$range; " \
"$c = 60 /$range;" \
"$e = 50 /$range; " \
"$b = 25 /$range; " \
"if ({0}.translateY >= 0) " \
"{8} " \
"{2}.translateY = {0}.translateY /$c; " \
"{3}.translateY = {0}.translateY /$b;" \
"{9} " \
"else if ({0}.translateY < 0)" \
"{8}" \
"{2}.translateY = {0}.translateY /$d; " \
"{3}.translateY = {0}.translateY /$c;" \
"{9} " \
"{2}.translateX = {0}.translateX /$c; " \
"{3}.translateX = {0}.translateX /$c; " \
"if ({6}.translateY >= 0) " \
"{8}" \
"{4}.translateY = {6}.translateY /$b; " \
"{5}.translateY = {6}.translateY /$c;" \
"{9} " \
"else if ({6}.translateY < 0) " \
"{8}" \
"{4}.translateY = {6}.translateY /$e; " \
"{5}.translateY = {6}.translateY /$a;" \
"{9} " \
"{4}.translateX = {6}.translateX /$c; " \
"{5}.translateX = {6}.translateX /$c;" \
\
.format(eyeballAimCtrl,
self.eyelidFollow,
jointBind03GrpAllUp,
jointBind03GrpAllDown,
jointBind03GrpOffsetUp,
jointBind03GrpOffsetDown,
eyeballAimMainCtrl,
self.eyeballCtrl.control,
"{",
"}")
mc.expression(s=expressionEyelidBind, n="%s%s%s" % ('eyelidBind', side, '_expr'), ae=0)
# ==============================================================================================================
# BLINK
# ==============================================================================================================
# CREATE CURVE MID BLINK
curveBlinkBindMidOld = mc.curve(d=3, ep=[(self.eyelidUp.xformJnt01), (self.eyelidUp.xformJnt05)])
curveBlinkBindMidReb = mc.rebuildCurve(curveBlinkBindMidOld, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0,
kep=1, kt=0, s=8, d=3, tol=0.01)
curveBlinkBindMid = mc.rename(curveBlinkBindMidReb, ('eyelidBlink' + side + '_crv'))
curveBlinkUp = mc.duplicate(crvUp, n='eyelidBlinkUp'+side+'_crv')[0]
curveBlinkDown = mc.duplicate(crvDown, n='eyelidBlinkDown'+side+'_crv')[0]
blinkBsn = mc.blendShape(eyelidUp.deformCrv, eyelidDown.deformCrv, curveBlinkBindMid, n=('eyelidBlink' +side+ '_bsn'),
weight=[(0, 1), (1, 0)])[0]
mc.select(cl=1)
if sideRGT in crvUp:
crvUpNewName = crvUp.replace(sideRGT, '')
elif sideLFT in crvUp:
crvUpNewName = crvUp.replace(sideLFT, '')
else:
crvUpNewName = crvUp
# wire deform up on mid curves
stickyMidwireDefUp = mc.wire(curveBlinkUp, dds=(0, 100 * scale), wire=curveBlinkBindMid)
stickyMidwireDefUp[0] = mc.rename(stickyMidwireDefUp[0], (au.prefixName(crvUpNewName) + 'Blink' +side+ '_wireNode'))
# SET TO DOWN CURVE
mc.setAttr(blinkBsn+'.%s' % eyelidUp.deformCrv, 0)
mc.setAttr(blinkBsn+'.%s'% eyelidDown.deformCrv, 1)
mc.select(cl=1)
if sideRGT in crvDown:
crvDownNewName = crvDown.replace(sideRGT, '')
elif sideLFT in crvDown:
crvDownNewName = crvDown.replace(sideLFT, '')
else:
crvDownNewName = crvDown
# wire deform down on mid curves
stickyMidwireDefDown = mc.wire(curveBlinkDown, dds=(0, 100 * scale), wire=curveBlinkBindMid)
stickyMidwireDefDown[0] = mc.rename(stickyMidwireDefDown[0], (au.prefixName(crvDownNewName) + 'Blink' + side+ '_wireNode'))
# SET SCALE WIRE 0
mc.setAttr(stickyMidwireDefUp[0]+'.scale[0]', 0)
mc.setAttr(stickyMidwireDefDown[0]+'.scale[0]', 0)
# SET KEYFRAME
mc.setDrivenKeyframe(blinkBsn +'.%s' % eyelidUp.deformCrv,
cd='%s.%s' % (self.eyeballCtrl.control, self.eyelidPos),
dv=0, v=1, itt='linear', ott='linear')
mc.setDrivenKeyframe(blinkBsn +'.%s' % eyelidUp.deformCrv,
cd='%s.%s' % (self.eyeballCtrl.control, self.eyelidPos),
dv=1, v=0, itt='linear', ott='linear')
mc.setDrivenKeyframe(blinkBsn + '.%s' % eyelidDown.deformCrv,
cd='%s.%s' % (self.eyeballCtrl.control, self.eyelidPos),
dv=0, v=0, itt='linear', ott='linear')
mc.setDrivenKeyframe(blinkBsn + '.%s' % eyelidDown.deformCrv,
cd='%s.%s' % (self.eyeballCtrl.control, self.eyelidPos),
dv=1, v=1, itt='linear', ott='linear')
# CONNECT TO BLENDSHAPE BIND CURVE
eyelidUpBsn = mc.blendShape(curveBlinkUp, crvUp, n=('eyelidBlinkUp' +side+ '_bsn'),
weight=[(0, 1)])[0]
mc.connectAttr(eyelidUp.controllerBind03Ctrl+'.%s' % eyelidUp.closeEyelid, eyelidUpBsn+'.%s'% curveBlinkUp)
eyelidDownBsn = mc.blendShape(curveBlinkDown, crvDown, n=('eyelidBlinkDown' +side+ '_bsn'),
weight=[(0, 1)])[0]
mc.connectAttr(eyelidDown.controllerBind03Ctrl+'.%s' % eyelidDown.closeEyelid, eyelidDownBsn+'.%s'% curveBlinkDown)
# CREATE GROUP FOR EYELID STUFF
eyelidGrp = mc.group(em=1, n='eyelid' + side + '_grp')
return eyelidGrp
def __init__(self, objectFolMesh, lipMidUpJnt, lipUpLFTJnt01,
lipMidDownJnt, lipDownLFTJnt02, lipDownLFTJnt01,
lipUpLFTJnt02, lipCornerLFTJnt, lipUpRGTJnt01, lipUpRGTJnt02,
lipDownRGTJnt01, lipDownRGTJnt02, lipCornerRGTJnt, jawCtrl,
scale, headLowCtrl, directionLipCorner, directionLip01,
directionLip02, sideLFT, sideRGT):
lipGroup = mc.group(em=1, n='lipCtrl_grp')
lipLFT = lp.Build(objectFolMesh=objectFolMesh,
lipUpJnt01=lipUpLFTJnt01,
lipUpJnt02=lipUpLFTJnt02,
lipDownJnt01=lipDownLFTJnt01,
lipDownJnt02=lipDownLFTJnt02,
lipCornerJnt=lipCornerLFTJnt,
scale=scale,
headLowCtrl=headLowCtrl,
jawCtrl=jawCtrl,
directionLipCorner=directionLipCorner,
directionLip01=directionLip01,
directionLip02=directionLip02,
sideRGT=sideRGT,
sideLFT=sideLFT,
side=sideLFT)
lipRGT = lp.Build(objectFolMesh=objectFolMesh,
lipUpJnt01=lipUpRGTJnt01,
lipUpJnt02=lipUpRGTJnt02,
lipDownJnt01=lipDownRGTJnt01,
lipDownJnt02=lipDownRGTJnt02,
lipCornerJnt=lipCornerRGTJnt,
scale=scale,
headLowCtrl=headLowCtrl,
jawCtrl=jawCtrl,
directionLipCorner=directionLipCorner,
directionLip01=directionLip01,
directionLip02=directionLip02,
sideRGT=sideRGT,
sideLFT=sideLFT,
side=sideRGT)
self.lipMidUp = ct.Control(matchPos=lipMidUpJnt,
prefix=au.prefixName(lipMidUpJnt),
shape=ct.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=[
'v',
])
self.lipMidDown = ct.Control(matchPos=lipMidDownJnt,
prefix=au.prefixName(lipMidDownJnt),
shape=ct.JOINT,
groupsCtrl=['', 'Offset'],
ctrlSize=scale * 0.4,
ctrlColor='red',
lockChannels=['v'])
self.lipMidUpParentCtrl = self.lipMidUp.parentControl[0]
self.lipMidDownParentCtrl = self.lipMidDown.parentControl[0]
au.createParentTransform(listparent=[''],
object=lipMidUpJnt,
matchPos=lipMidUpJnt,
prefix='lipMidUp',
suffix='_jnt')
au.createParentTransform(listparent=[''],
object=lipMidDownJnt,
matchPos=lipMidDownJnt,
prefix='lipMidDown',
suffix='_jnt')
# lip mid up setup
au.connectAttrObject(self.lipMidUp.control, lipMidUpJnt)
# lip mid down setup
mc.setAttr(self.lipMidDown.parentControl[0] + '.scaleY', -1)
transMult = mc.createNode('multiplyDivide',
n=au.prefixName(self.lipMidDown.control) +
'Trans' + '_mdn')
rotMult = mc.createNode('multiplyDivide',
n=au.prefixName(self.lipMidDown.control) +
'Rot' + '_mdn')
mc.setAttr(transMult + '.input2Y', -1)
mc.setAttr(rotMult + '.input2Z', -1)
mc.setAttr(rotMult + '.input2X', -1)
mc.connectAttr(self.lipMidDown.control + '.translate',
transMult + '.input1')
mc.connectAttr(self.lipMidDown.control + '.rotate',
rotMult + '.input1')
mc.connectAttr(transMult + '.output', lipMidDownJnt + '.translate')
mc.connectAttr(rotMult + '.output', lipMidDownJnt + '.rotate')
# au.connectAttrObject(self.lipMidDown.control, lipMidDownJnt)
# constraint lip mid
# mc.parentConstraint(self.lipMidUp.control, lipMidUpJnt, mo=1)
# mc.parentConstraint(self.lipMidDown.control, lipMidDownJnt, mo=1)
#
# mc.scaleConstraint(self.lipMidUp.control, lipMidUpJnt, mo=1)
# mc.scaleConstraint(self.lipMidDown.control, lipMidDownJnt, mo=1)
object = [self.lipMidUpParentCtrl, self.lipMidDownParentCtrl]
follTransMid = []
for i in object:
follicle = au.createFollicleSel(objSel=i,
objMesh=objectFolMesh,
connectFol=['transConn'])[0]
mc.parent(i, follicle)
mc.scaleConstraint(headLowCtrl, follicle)
follTransMid.append(follicle)
mc.orientConstraint(jawCtrl, follTransMid[1], mo=1)
mc.orientConstraint(headLowCtrl, follTransMid[0], mo=1)
mc.parent(follTransMid, lipLFT.follicleTransformAll,
lipRGT.follicleTransformAll, lipGroup)
self.lipGroup = lipGroup