def addLowerLipCurlsSDKs():
'''
'''
# lower lips
coeffs = pm.group(em=True, n='CT_lowerLipCurls_coeffs')
coeffs.addAttr('leftPinch', k=True)
coeffs.addAttr('leftSneer', k=True)
coeffs.addAttr('leftSide', k=True)
coeffs.addAttr('centerMid', k=True)
coeffs.addAttr('rightSide', k=True)
coeffs.addAttr('rightSneer', k=True)
coeffs.addAttr('rightPinch', k=True)
rt.connectSDK('LT_lowerPinch_lip_ctrl.rx',
coeffs.leftPinch, {-90:-1, 0:0, 90:1})
rt.connectSDK('LT_lowerSneer_lip_ctrl.rx',
coeffs.leftSneer, {-90:-1, 0:0, 90:1})
rt.connectSDK('LT_lowerSide_lip_ctrl.rx',
coeffs.leftSide, {-90:-1, 0:0, 90:1})
rt.connectSDK('CT_lower_lip_ctrl.rx',
coeffs.centerMid, {-90:-1, 0:0, 90:1})
rt.connectSDK('RT_lowerSneer_lip_ctrl.rx',
coeffs.rightSneer, {-90:-1, 0:0, 90:1})
rt.connectSDK('RT_lowerSide_lip_ctrl.rx',
coeffs.rightSide, {-90:-1, 0:0, 90:1})
rt.connectSDK('RT_lowerPinch_lip_ctrl.rx',
coeffs.rightPinch, {-90:-1, 0:0, 90:1})
priCtls = [nt.Transform(u'RT_lowerSneer_lip_pri_ctrl'),
nt.Transform(u'CT_lower_lip_pri_ctrl'),
nt.Transform(u'LT_lowerSneer_lip_pri_ctrl')]
attrs = ['leftPinch',
'leftSneer',
'leftSide',
'centerMid',
'rightSide',
'rightSneer',
'rightPinch']
for pCtl in priCtls:
token = pCtl.split('_')[0]
for attr in attrs:
mod = modulate.addInput(coeffs.attr(attr), 0, token)
rt.connectSDK(pCtl.rx, mod, {-90:-1, 0:0, 90:1})
rt.connectSDK(coeffs.leftPinch,
'blendShapeCt_face_geo.lipCurlIn_lowerPinch_Lf', {0:0, -1:1})
rt.connectSDK(coeffs.leftSneer,
'blendShapeCt_face_geo.lipCurlIn_lowerSneer_Lf', {0:0, -1:1})
rt.connectSDK(coeffs.leftSide,
'blendShapeCt_face_geo.lipCurlIn_lowerSide_Lf', {0:0, -1:1})
rt.connectSDK(coeffs.centerMid,
'blendShapeCt_face_geo.lipCurlIn_lower_Ct', {0:0, -1:1})
rt.connectSDK(coeffs.rightPinch,
'blendShapeCt_face_geo.lipCurlIn_lowerPinch_Rt', {0:0, -1:1})
rt.connectSDK(coeffs.rightSneer,
'blendShapeCt_face_geo.lipCurlIn_lowerSneer_Rt', {0:0, -1:1})
rt.connectSDK(coeffs.rightSide,
'blendShapeCt_face_geo.lipCurlIn_lowerSide_Rt', {0:0, -1:1})
def mirror_eyeCurve_weights():
'''
mirror LT_eye_aimAt_crv_0 to RT_eye_aimAt_crv_0
'''
lf_crv = nt.Transform(u'LT_eye_aimAt_crv_0')
rt_crv = nt.Transform(u'RT_eye_aimAt_crv_0')
lf_skn = pm.PyNode(mel.findRelatedSkinCluster(lf_crv))
rt_skn = pm.PyNode(mel.findRelatedSkinCluster(rt_crv))
def setEyeJointsLabels(joints):
for jnt in joints:
### change the label
label = '_'.join(jnt.name().split('_')[1:3])
#label = '_'.join(jnt.name().split('_')[1:4])
jnt.attr('type').set('Other')
jnt.otherType.set(label)
lf_infs = pm.skinCluster(lf_crv, q=True, inf=True)
setEyeJointsLabels(lf_infs)
rt_infs = pm.skinCluster(rt_crv, q=True, inf=True)
setEyeJointsLabels(rt_infs)
lf_crv.sx.setLocked(False)
lf_crv.sx.set(-1)
pm.copySkinWeights(ss=lf_skn,
ds=rt_skn,
sa='closestPoint',
ia='label',
nm=True)
lf_crv.sx.set(1)
def faceEvaluationSwitch():
'''
find all deformers on geos
when switchAttr = False,
set nodes to HasNoEffect
'''
geos = [nt.Transform(u'FACE:LT_eyelashes_geo'),
nt.Transform(u'FACE:RT_eyelashes_geo'),
nt.Transform(u'FACE:CT_face_geo'),
nt.Transform(u'CT_face_geo_lattice'),
nt.Transform(u'CT_face_geo_latticeWeights')]
# add switch to face ctrl
faceCtl = pm.PyNode('FACE:CT_face_ctrl')
faceCtl.addAttr('disableFace', at='bool', dv=0)
faceCtl.attr('disableFace').showInChannelBox(True)
for geo in geos:
dfmNames = mel.findRelatedDeformer(geo)
for dfmName in dfmNames:
dfm = pm.PyNode(dfmName)
faceCtl.attr('disableFace') >> dfm.nodeState
# also hide inner mouth geo
mouthGeoGrp = pm.PyNode('FACE:CT_mouth_geo_grp')
rt.connectSDK(faceCtl.attr('disableFace'),
mouthGeoGrp.v, {0:1, 1:0})
def build():
'''
'''
mesh = nt.Mesh(u'CT_face_geoShape')
placementGrp = nt.Transform(u'CT_placement_grp')
#---------------------------------------------------------------------- bind
if 'bind' in data.build_actions:
bindGrp = face.createBndsFromPlacement(placementGrp)
else:
bindGrp = nt.Transform(u'CT_bnd_grp')
#--------------------------------------------------------- sec motion system
if 'sec_motion_system' in data.build_actions:
face.buildSecondaryControlSystem(placementGrp, bindGrp, mesh)
#------------------------------------------------------------ pri ctl system first
if 'primary_ctl_system_first' in data.build_actions:
# run a simple first pass
# which can be used to block out mappings
bndsForPriCtls = data.all_bnds_for_priCtls
priCtl.setupPriCtlFirstPass(bindGrp, bndsForPriCtls)
priCtl.driveAttachedPriCtlsRun(bindGrp)
#------------------------------------------------------------ pri ctl system second
if 'primary_ctl_system_second' in data.build_actions:
if data.priCtlMappings:
# if priCtlMappings is set up, use the data
priCtlMappings = data.priCtlMappings
priCtl.setupPriCtlSecondPass(priCtlMappings)
priCtl.driveAttachedPriCtlsRun(bindGrp)
else:
pm.warning('no data for pri ctl system')
#-------------------------------------------------------------- load weights
if 'load_weights' in data.build_actions:
priCtlMappings = data.priCtlMappings
priCtl.setPriCtlFirstPassWeights(priCtlMappings)
#--------------------------------------------------------------------- clean
if 'clean' in data.build_actions:
print 'clean'
face.cleanFaceRig()
#---------------------------------------------------------------------- eyes
if 'eyes' in data.build_actions:
buildEyeRig(placementGrp)
#------------------------------------------------------------------ eyeballs
if 'eyeballs' in data.build_actions:
#------------------------------------------ EYEBALL RIG (SIMPLE AIM CONSTRAINTS)
eye.buildEyeballRig()
eye.addEyeAim(prefix='LT_', distance=25) # BROKEN if there is already a
# node named LT_eyeball_grp!!!
eye.addEyeAim(prefix='RT_', distance=25) # BROKEN
#--------------------------------------------------------------- sticky lips
if 'sticky_lips' in data.build_actions:
pass
def replaceEyelidAimAtCurve():
'''
'''
# transfer pocis from oldcrv to newcrv
oldCrv = nt.Transform(u'LT_eye_aimAt_crv_0')
newCrv = nt.Transform(u'LT_eyelids_aimAt_crv_0')
outPocis = oldCrv.worldSpace.outputs(type='pointOnCurveInfo', p=True)
for poci in outPocis:
newCrv.worldSpace >> poci
def jacketCtlPatch():
'''
previously ctls were driven matrices by joint's matrix
joint were driven by ikSplines driven by vert crvs
ctls will still be driven by matrices,
but will use locator matrices instead
locators will be driven by motionpaths
DONT PATCH THIS FOR MATHILDA
the speed improvement is negligible
possibly because the motion path alignment ends up
using the same amt of computes as iksplines
'''
# set up crvs to calculate lengths
jacketVertCrvsGrp = nt.Transform(u'CT_jacketVertCrvs_grp')
allVertCrvs = [
n for n in jacketVertCrvsGrp.getChildren() if '_crv' in n.name()
]
for crv in allVertCrvs:
addCurveLengthRatioAttr(crv)
addCurveLengthRatioGlobalScale(
crv, pm.PyNode('Mathilda_root_ctrl.masterScale'))
# set up locators to replace joints
jacketCtlGrp = nt.Transform(u'CT_jacket_ctls_grp')
allJacketCths = [
n for n in jacketCtlGrp.getChildren(ad=True) if '_cth' in n.name()
]
newLocs = []
for eachCth in allJacketCths:
cthId = int(eachCth.name().split('_')[1][-1])
# get driver jnt (with same id at the end)
driverJnt = [
jnt for jnt in eachCth.listHistory(type='joint')
if jnt[-1] == str(cthId)
][0]
# remove last two tokens to get curve name
vertCrv = '_'.join(driverJnt.split('_')[:-2])
vertCrv = pm.PyNode(vertCrv)
newLocs.append(addLocToVertCrv(eachCth, vertCrv, driverJnt))
locGrp = pm.group(newLocs, n='CT_jacketVertCrvsLoc_grp')
# replace joint matrix with locator matrix
allVertJntsGrp = pm.PyNode('CT_jacketVertCrvsJoints_grp')
allVertJnts = allVertJntsGrp.getChildren(ad=True, type='joint')
for jnt in allVertJnts:
# find substitute loc
locName = jnt.replace('_jnt_', '_loc_')
if pm.objExists(locName):
loc = pm.PyNode(locName)
substituteJointWithLoc(jnt, loc)
else:
# no loc for this joint
pass
def transferUpperLipRollToSDK():
attr = pm.PyNode('CT_jaw_pri_ctrl.upperLipRoll')
xfos = [
nt.Transform(u'CT_upper_lip_bnd_rollPivot_loc'),
nt.Transform(u'LT_upper_sneer_lip_bnd_rollPivot_loc'),
nt.Transform(u'LT_upper_pinch_lip_bnd_rollPivot_loc'),
nt.Transform(u'RT_upper_pinch_lip_bnd_rollPivot_loc'),
nt.Transform(u'RT_upper_sneer_lip_bnd_rollPivot_loc')
]
for xfo in xfos:
transferAnimToSDK(xfo, attr, .1)
def transferLeftBrowHoriToSDK(mirror=False):
attr = pm.PyNode('LT_mid_brow_pri_ctrl.tx')
xfos = [
nt.Transform(u'LT_in_brow_bnd_browHoriLT_loc'),
nt.Transform(u'LT_mid_brow_bnd_browHoriLT_loc'),
nt.Transform(u'LT_out_brow_bnd_browHoriLT_loc'),
nt.Transform(u'CT_brow_bnd_browHoriLT_loc')
]
if mirror:
xfos = rsym.mirror_PyNodes(xfos)
attr = rsym.mirror_PyNodes(attr)
for xfo in xfos:
transferAnimToSDK(xfo, attr, .1)
def transferLeftSmileLipToSDK(mirror=False):
attr = pm.PyNode('LT_corner_lip_pri_ctrl.ty')
xfos = [
nt.Transform(u'LT_sneer_bnd_smilePivot_loc'),
nt.Transform(u'LT_mid_crease_bnd_smilePivot_loc'),
nt.Transform(u'LT_up_crease_bnd_smilePivot_loc'),
nt.Transform(u'LT_up_cheek_bnd_smilePivot_loc'),
nt.Transform(u'LT_cheek_bnd_smilePivot_loc')
]
if mirror:
xfos = [pm.PyNode(xfo.name().replace('LT_', 'RT_')) for xfo in xfos]
attr = pm.PyNode(attr.name().replace('LT_', 'RT_'))
for xfo in xfos:
transferAnimToSDK(xfo, attr, .1)
def connectBndsToACS():
'''
connect motion system (*_sdk) to acs
set this up once
'''
bndGrp = nt.Transform(u'CT_bnd_grp')
acsNode = nt.Transform(u'CT_face_acs')
allBnds = bndGrp.getChildren(ad=True, type='joint')
allSdks = [bnd.replace('_bnd', '_sdk') for bnd in allBnds]
for sdk in allSdks:
for channel in ['tx', 'ty', 'tz']:
mel.DPK_acs_importOutput(acsNode.name(), sdk + '.' + channel)
def build():
'''
'''
mesh = nt.Mesh(u'CT_hat_simplegeoShape')
placementGrp = nt.Transform(u'CT_placement_grp')
#---------------------------------------------------------------------- bind
if 'bind' in data.build_actions:
bindGrp = face.createBndsFromPlacement(placementGrp)
pm.refresh()
else:
bindGrp = nt.Transform(u'CT_bnd_grp')
#--------------------------------------------------------- sec motion system
if 'sec_motion_system' in data.build_actions:
face.buildSecondaryControlSystem(placementGrp, bindGrp, mesh)
pm.refresh()
#------------------------------------------------------------ pri ctl system first
if 'primary_ctl_system_first' in data.build_actions:
# run a simple first pass
# which can be used to block out mappings
bndsForPriCtls = data.all_bnds_for_priCtls
priCtl.setupPriCtlFirstPass(bindGrp, bndsForPriCtls)
priCtl.driveAttachedPriCtlsRun(bindGrp)
#------------------------------------------------------------ pri ctl system second
if 'primary_ctl_system_second' in data.build_actions:
if data.priCtlMappings:
# if priCtlMappings is set up, use the data
priCtlMappings = data.priCtlMappings
priCtl.setupPriCtlSecondPass(priCtlMappings)
priCtl.driveAttachedPriCtlsRun(bindGrp)
pm.refresh()
else:
pm.warning('no data for pri ctl system')
#-------------------------------------------------------------- load weights
if 'load_weights' in data.build_actions:
priCtlWeights = data.priCtlWeights
priCtl.setPriCtlSecondPassWeights(priCtlWeights)
pm.refresh()
#--------------------------------------------------------------------- clean
if 'clean' in data.build_actions:
print 'clean'
face.cleanFaceRig()
pm.select(cl=True)
pm.refresh()
def initBind():
'''
'''
bndGrp = nt.Transform(u'CT_bnd_grp')
mesh = nt.Transform(u'CT_face_geo')
allBnds = bndGrp.getChildren(type='joint', ad=True)
# initial bind all with closestJoint
pm.select(cl=True)
skn = pm.skinCluster(allBnds, mesh, bindMethod=0,
maximumInfluences=1, omi=False)
mll = layer_weighting.initLayers(bndGrp, mesh)
return mll
def buildEyeShaper():
createLattice(
[nt.Transform(u'LT_eyeball_geo'),
nt.Transform(u'RT_eyeball_geo')], [
nt.Mesh(u'CT_face_geoShape'),
nt.Mesh(u'LT_brow_geoShape'),
nt.Mesh(u'RT_brow_geoShape')
])
# add placement locs
pGrp = nt.Transform(u'CT_eyeLattice_placement_grp')
import rigger.modules.placementGrp as placementGrp
reload(placementGrp)
placementGrp.mirrorAllPlacements(pGrp)
# create bnds
import rigger.modules.face as face
bndGrp = face.createBndsFromPlacement(pGrp)
# motion sys
# mesh is passed in for legacy reasons
face.buildSecondaryControlSystem(pGrp, bndGrp, mesh=None)
priCtlMappings = {
'LT_midUp_eyeShaper_pri_ctrl': {
u'LT_inUp_eyeShaper_bnd': 1,
u'LT_midUp_eyeShaper_bnd': 1,
u'LT_outUp_eyeShaper_bnd': 1
},
'LT_midLow_eyeShaper_pri_ctrl': {
u'LT_inLow_eyeShaper_bnd': 1,
u'LT_midLow_eyeShaper_bnd': 1,
u'LT_outLow_eyeShaper_bnd': 1
},
'RT_midUp_eyeShaper_pri_ctrl': {
u'RT_inUp_eyeShaper_bnd': 1,
u'RT_midUp_eyeShaper_bnd': 1,
u'RT_outUp_eyeShaper_bnd': 1
},
'RT_midLow_eyeShaper_pri_ctrl': {
u'RT_inLow_eyeShaper_bnd': 1,
u'RT_midLow_eyeShaper_bnd': 1,
u'RT_outLow_eyeShaper_bnd': 1
}
}
import rigger.modules.priCtl as priCtl
reload(priCtl)
priCtl.setupPriCtlSecondPass(priCtlMappings)
def addVertJointChains():
'''
'''
crvs = {
nt.Transform(u'LT_jacketVert_crv_0_crv'): 5.64175573477838,
nt.Transform(u'LT_jacketVert_crv_1_crv'): 5.72573491802788,
nt.Transform(u'LT_jacketVert_crv_2_crv'): 6.03354529902427,
nt.Transform(u'LT_jacketVert_crv_3_crv'): 6.32167583466526,
nt.Transform(u'LT_jacketVert_crv_4_crv'): 6.49099392892804,
nt.Transform(u'RT_jacketVert_crv_0_crv'): 5.64175573477838,
nt.Transform(u'RT_jacketVert_crv_1_crv'): 5.72573491802788,
nt.Transform(u'RT_jacketVert_crv_2_crv'): 6.03354529902427,
nt.Transform(u'RT_jacketVert_crv_3_crv'): 6.32167583466526,
nt.Transform(u'RT_jacketVert_crv_4_crv'): 6.49099392892804
}
for crv, endPt in crvs.items():
addJointChainToCurvePoints(crv, endPt, 8)
def transferLeftSneerToSDK(mirror=False):
attr = pm.PyNode('LT_philtrum_ctrl.ty')
xfos = [
nt.Transform(u'LT_in_philtrum_bnd_sneerLT_loc'),
nt.Transform(u'LT_philtrum_bnd_sneerLT_loc'),
nt.Transform(u'LT_nostril_bnd_sneerLT_loc'),
nt.Transform(u'LT_sneer_bnd_sneerLT_loc'),
nt.Transform(u'LT_upper_pinch_lip_bnd_sneerLT_loc'),
nt.Transform(u'LT_lower_pinch_lip_bnd_sneerLT_loc'),
nt.Transform(u'LT_lower_sneer_lip_bnd_sneerLT_loc'),
nt.Transform(u'LT_upper_sneer_lip_bnd_sneerLT_loc'),
nt.Transform(u'CT_upper_lip_bnd_sneerLT_loc'),
nt.Transform(u'CT_lower_lip_bnd_sneerLT_loc')
]
if mirror:
xfos = rsym.mirror_PyNodes(xfos)
attr = rsym.mirror_PyNodes(attr)
for xfo in xfos:
transferAnimToSDK(xfo, attr, .03)
def connectHairFolliclesToMesh():
'''
for each follicle under hairCrvsGrp,
- unparent the child curve to WS (to maintain ws-position)
- find closest uv on mesh
- set uv on follicle
- mesh.worldMatrix >> follicle.inputWorldMatrix
- mesh.outMesh >> follicle.inputMesh
- follicle.outT/R >> follicleDag.t/r
- reparent curve under follicle
'''
mesh = nt.Transform(u'CT_headCollide_geo')
hairCrvsGrp = nt.Transform(u'CT_hairCurves_grp')
allFollicles = hairCrvsGrp.getChildren(ad=True, type='follicle')
for eachFol in allFollicles:
folDag = eachFol.getParent()
# assume only one curve per follicle
crvDag = folDag.getChildren(ad=True, type='transform')[0]
# unparent to maintain WS
crvDag.setParent(None)
# calculate UVs
startPt = crvDag.cv[0].getPosition()
uVal, vVal = mesh.getUVAtPoint(startPt)
uvSet = mesh.getCurrentUVSetName()
eachFol.parameterU.set(uVal)
eachFol.parameterV.set(vVal)
eachFol.startDirection.set(1)
# connect mesh to follicle
mesh.worldMatrix >> eachFol.inputWorldMatrix
mesh.outMesh >> eachFol.inputMesh
# connect follicle t/r
eachFol.outTranslate >> folDag.t
eachFol.outRotate >> folDag.r
# parent curve under follicle
folDag | crvDag
def connectAllJacketLocs():
locGrpParams = {
8: '_back',
6: '_left',
4: '_front',
2: '_right',
7: '_leftBack',
1: '_rightBack',
3: '_rightFront',
5: '_leftFront'
}
for param, grpName in locGrpParams.items():
for i in range(4, 10):
twistCrv = nt.Transform(u'torsoReader_' + str(i))
untwistCrv = nt.Transform(u'torsoReader_%d_untwist' % i)
connectJacketLoc(twistCrv, untwistCrv, param, name=grpName)
# special case for i=3
# also connect to additional readers 1 & 2
twistCrv = nt.Transform(u'torsoReader_3')
untwistCrv = nt.Transform(u'torsoReader_3_untwist')
connectJacketLoc(twistCrv,
untwistCrv,
param,
name=grpName,
addCrvs=[
nt.Transform(u'torsoReader_2'),
nt.Transform(u'torsoReader_1')
])
def disableLipCtlsRotateX():
'''
'''
# disable lip controls rotateX
# use rotateX to drive
def useSurrogateXfo(ctl, blockChannels=[]):
'''
reroute priCtl matrix outputs
assume priCtl only have local matrix outputs
'''
xfo = pm.group(em=True, n=ctl+'_surrXfo')
ctlParent = ctl.getParent()
ctlParent | xfo
xfo.setMatrix(pm.dt.Matrix())
allChannels = ['tx','ty','tz','rx','ry','rz','sx','sy','sz']
for channel in allChannels:
if channel not in blockChannels:
ctl.attr(channel) >> xfo.attr(channel)
# reroute matrix outputs
allMatrixPlugs = ctl.matrix.outputs(p=True)
for plug in allMatrixPlugs:
xfo.matrix >> plug
ctls = [nt.Transform(u'RT_upperSneer_lip_pri_ctrl'),
nt.Transform(u'CT_upper_lip_pri_ctrl'),
nt.Transform(u'LT_upperSneer_lip_pri_ctrl'),
nt.Transform(u'LT_lowerSneer_lip_pri_ctrl'),
nt.Transform(u'CT_lower_lip_pri_ctrl'),
nt.Transform(u'RT_lowerSneer_lip_pri_ctrl')]
for ctl in ctls:
useSurrogateXfo(ctl, ['rx'])
def addEyelashCollideAimLocGo():
'''
'''
eyelidCtl = nt.Transform(u'FACE:LT_eyelid_inner_upper_ctrl')
collideCtl = nt.Transform(u'FACE:LT_in_brow_ctrl')
addEyelashCollideAimLoc(eyelidCtl, collideCtl)
eyelidCtl = nt.Transform(u'FACE:LT_eyelid_upper_ctrl')
collideCtl = nt.Transform(u'FACE:LT_mid_brow_ctrl')
addEyelashCollideAimLoc(eyelidCtl, collideCtl)
eyelidCtl = nt.Transform(u'FACE:LT_eyelid_outer_upper_ctrl')
collideCtl = nt.Transform(u'FACE:LT_out_brow_ctrl')
addEyelashCollideAimLoc(eyelidCtl, collideCtl)
eyelidCtl = nt.Transform(u'FACE:LT_eyelid_outer_ctrl')
collideCtl = nt.Transform(u'FACE:LT_out_brow_ctrl')
addEyelashCollideAimLoc(eyelidCtl, collideCtl)
def modulateFleshyEyesUp():
'''
DONT USE THIS
'''
node = nt.Transform(u'FACE:LT_eyeball_bnd')
node.addAttr('finalVectorAngle', k=True)
# replace outputs
outAttrs = node.vectorAngle.outputs(p=True)
node.vectorAngle >> node.finalVectorAngle
for plug in outAttrs:
node.finalVectorAngle >> plug
# modulate finalVectorAngle
mod = modulate.multiplyInput(node.finalVectorAngle, 1, '_eyeY_mod')
rt.connectSDK('FACE:LT_eyeball_bnd.paramNormalized', mod, {0:0.2, 0.4:1, 0.6:1, 1:0.2})
def showRotateOrderAttrs():
ctls = [
nt.Transform(u'Ori_neck_ctrl'),
nt.Joint(u'Ori_midNeck_ctrl'),
nt.Transform(u'Ori_head_ctrl'),
nt.Transform(u'Ori_spineHigh_ctrl'),
nt.Transform(u'Ori_spineMid_2_ctrl'),
nt.Transform(u'Ori_spineMid_1_ctrl'),
nt.Transform(u'Ori_spineLow_ctrl'),
nt.Transform(u'Ori_cog_ctrl')
]
for ctl in ctls:
ctl.rotateOrder.set(cb=True)
def connectHairToGlobalScale():
'''
import rigger.builds.mathilda.hacks as hacks
reload(hacks)
hacks.connectHairToGlobalScale()
'''
crvGrp = nt.Transform(u'CT_hairStartCurves_grp')
mesh = nt.Transform(u'CT_headHair_geo')
root = nt.Transform(u'Mathilda_root_ctrl')
# connect masterscale to scale curves
root.masterScale >> crvGrp.sx
root.masterScale >> crvGrp.sy
root.masterScale >> crvGrp.sz
# multiply matrix for follicles
mm = pm.createNode('multMatrix', n='CT_hairFolliclesGlobalScale_mm')
mesh.worldMatrix >> mm.matrixIn[0]
crvGrp.worldInverseMatrix >> mm.matrixIn[1]
# get all follicles
allFols = crvGrp.getChildren(ad=True, type='follicle')
# connect worldMatrix
for fol in allFols:
mm.matrixSum >> fol.inputWorldMatrix
# scale hairSystems
attrsToScale = ['backHairSystemShape.clumpWidth',
'backHairSystemShape.hairWidth',
'frontHairSystemShape.clumpWidth',
'frontHairSystemShape.hairWidth']
for attr in attrsToScale:
mod = modulate.multiplyInput(attr, 1, '_gscale')
root.masterScale >> mod
def buildBndVertMap():
'''
'''
bndGrp = nt.Transform(u'CT_bnd_grp')
baseMesh = nt.Mesh(u'CT_face_geoShape')
allBnds = bndGrp.getChildren(ad=True, type='joint')
bndVertMap = {}
for bnd in allBnds:
bndPos = bnd.getTranslation(space='world')
closestVertId = closestVertexOnMesh(baseMesh, bndPos)
bndVertMap[bnd.name()] = closestVertId
return bndVertMap
def getAllPriWeightsByDelta(baseMesh,
targetMesh,
priCtl,
calcChannels=('tx', 'ty', 'tz')):
'''
'''
bndGrp = nt.Transform(u'CT_bnd_grp')
allBnds = bndGrp.getChildren(ad=True, type='joint')
attrWeightsMap = {}
for bnd in allBnds:
d = getPriWeightsByDelta(bnd, priCtl, baseMesh, targetMesh,
calcChannels)
if d:
attrWeightsMap.update(d)
return attrWeightsMap
def connectSmoothGeos():
# connect smoothGeo
mainCtl = pm.PyNode('BODY:Main')
allGeos = [nt.Transform(u'DNTEETH:CT_gumBlockGlobal_geo_0'),
nt.Transform(u'DNTEETH:CT_teethBlockGlobal_geo_0'),
nt.Transform(u'UPTEETH:CT_teethBlockGlobal_geo_0'),
nt.Transform(u'UPTEETH:CT_gumBlockGlobal_geo_0'),
nt.Transform(u'TONGUE:CT_tongueJaw_geo_0'),
nt.Transform(u'GEO:LT_eye_geo_0'),
nt.Transform(u'GEO:RT_eye_geo_0'),
nt.Transform(u'GEO:CT_nose_geo_0'),
nt.Transform(u'GEO:CT_body_geo_0')]
for eachGeo in allGeos:
shapes = eachGeo.getChildren(s=True)
# choose the one that is not intermediate
shapes = [shape for shape in shapes if shape.intermediateObject.get() == 0]
targetShape = shapes[0]
mainCtl.smoothGeo >> targetShape.smoothLevel
targetShape.displaySmoothMesh.set(2)
# also set to reference
targetShape.overrideEnabled.set(1)
targetShape.overrideDisplayType.set(2)
def modulatePushOutLocs():
'''
add a modulate attr for each row of locs
add attrs to loc grp
'''
locGrpNames = [
'_back', '_left', '_front', '_right', '_leftBack', '_rightBack',
'_rightFront', '_leftFront'
]
master = nt.Transform(u'CT_torsoReader_locs_grp')
for grpName in locGrpNames:
for rowId in range(1, 10):
master.addAttr('%s_row%d_mod' % (grpName, rowId), k=True, dv=1)
loc = pm.PyNode('torsoReader_%d%s_loc_pushOutLoc' %
(rowId, grpName))
modAttr = modulate.multiplyInput(loc.tz, 1, '_mod')
master.attr('%s_row%d_mod' % (grpName, rowId)) >> modAttr
def __init__(self, **kwargs):
"""
Merge all shape nodes under a single transform and trash any
left-over (empty) transforms.
"""
shapes = [n for n in self if not isinstance(n, nt.Joint)]
empty_transforms = [s.getParent() for s in shapes if not \
[sib for sib in s.getSiblings() if sib not in self]]
self._transform = nt.Transform()
parent(self, self._transform, relative=True, shape=True)
#if empty_transforms:
# print('empty transforms:', empty_transforms)
# delete(empty_transforms)
select(self)
DeleteHistory()
snap_to = kwargs.pop('st', kwargs.pop('snap_to', None))
if snap_to:
snap(self._transform, snap_to)
def assignAllPriWeightsByDelta(corrMesh,
priCtl,
calcChannels=('tx', 'ty', 'tz'),
avgChannels=('rx', 'ry', 'rz', 'sx', 'sy',
'sz')):
'''
corrMesh = nt.Mesh(u'smile_correctiveShape')
priCtl = nt.Transform(u'LT_corner_lip_pri_ctrl')
assume neutral position before running
'''
bndGrp = nt.Transform(u'CT_bnd_grp')
baseMesh = nt.Mesh(u'CT_base_corrective_bsgShape')
bndVertMap = buildBndVertMap()
allBnds = bndGrp.getChildren(ad=True, type='joint')
for bnd in allBnds:
assignPriWeightsByDelta(bnd, priCtl, baseMesh, corrMesh, bndVertMap,
calcChannels, avgChannels)
def setAllAcsPosByDelta():
'''
import rigger.utils.assignAcsByBlendshape as acs
reload(acs)
acs.setAllAcsPosByDelta()
'''
bndGrp = nt.Transform(u'CT_bnd_grp')
allBnds = bndGrp.getChildren(ad=True, type='joint')
# don't change movers
allBnds = [
bnd for bnd in allBnds if 'Mover' not in bnd.name()
and 'CT__base' not in bnd.name() and 'CT__jaw' not in bnd.name()
]
# bndVertMap = assignPriWeightsByBlendshape.buildBndVertMap()
corrMesh = nt.Mesh(u'LT_allBrowsUp_bsgShape1')
for bnd in allBnds:
try:
setAcsPosByDelta(bnd, corrMesh)
except AttributeError as e:
print 'hello'
print e
def moveClaviclePivot():
'''
'''
# move clavicle pivot
newPos = pm.dt.Vector([-1.06312130585, 91.7071256576, -1.76231053414])
moveNode = nt.Transform(u'Mathilda_rt_clavicleTrans_ctrl_zeroFrzGrp')
jnt = nt.Joint(u'Mathilda_rt_clavicle_jnt')
newPivot = pm.spaceLocator(n='rt_newpivot')
newPivot.t.set(newPos)
incomingCons = set(jnt.inputs(type='constraint'))
outgoingCons = set(jnt.outputs(type='constraint'))
outgoingCons = [con for con in outgoingCons if con not in incomingCons]
wMatDict = {}
# store world matrices for constrainees
for con in outgoingCons:
dag = con.ctx.outputs()[0]
wMat = dag.getMatrix(worldSpace=True)
wMatDict[con] = wMat
mel.moveJointsMode(True)
# assume move node is currently an identity matrix
# so we can just use translate for offset
newPos = newPivot.getTranslation(space='world')
moveNode.setTranslation(newPos, space='world')
# restore world matrices for constainees
for con in outgoingCons:
dag = con.ctx.outputs()[0]
wMat = wMatDict[con]
dag.setMatrix(wMat, worldSpace=True)
pm.parentConstraint(jnt, dag, mo=True, e=True)
mel.moveJointsMode(False)
