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)