def bendyJoints(sj, mj, ej, moduleType, module): """ Create a bendy joints setup (mainly for arms & legs). [Args]: sj (string) - The name of the start joint mj (string) - The name of the middle joint ej (string) - The name of the end joint moduleType (string) - The type of body part ('arm', 'leg') module (class) - The class of the body part module """ moduleName = utils.setupBodyPartName(module.extraName, module.side) extraName = module.extraName mechGrp = utils.newNode('group', name='{}BendyMech'.format(extraName), side=module.side, skipNum=True, parent='{}{}Mech{}'.format(moduleName, moduleType, suffix['group'])) mechGrp.setAttr('it', 0) midBendCtrl = ribbonJoints(sj, mj, 'Upper', module, extraName=extraName, moduleType=moduleType, par=mechGrp.name, endCtrl=True) ribbonJoints(mj, ej, 'Lower', module, extraName=extraName, moduleType=moduleType, par=mechGrp.name, basePar=midBendCtrl.ctrlEnd)
def __init__(self, name, scaleOffset=1, debug=False): cmds.file(force=1, new=1) # fileFn.loadPlugin('mjSoftIK', python=True) # fileFn.loadPlugin('mjStretchArray') # fileFn.loadPlugin('mjRivet') fileFn.loadAllPlugins() fileFn.setAssetName(name) self.scaleOffset = scaleOffset self.grp = utils.newNode('group', name='RIG_', skipNum=True, side='') self.worldLoc = utils.newNode('locator', name='world', parent=self.grp.name, skipNum=True) cmds.setAttr('{}.v'.format(self.worldLoc.name), 0) self.worldLoc.lockAttr() self.geoGrp = utils.newNode('group', name='geometry', parent=self.grp.name, skipNum=True) cmds.setAttr('{}.overrideEnabled'.format(self.geoGrp.name), 1) self.globalCtrl = ctrlFn.ctrl(name='global', parent=self.grp.name, skipNum=True, scaleOffset=self.scaleOffset) self.rigNode, self.ctrlsAttr, self.skinJntsAttr = createRigNode(self.globalCtrl.ctrl) self.globalCtrl.modifyShape(color=30, shape='global') self.ctrlsGrp = utils.newNode('group', name='controls', parent=self.globalCtrl.ctrlEnd, skipNum=True) cmds.setAttr('{}.overrideEnabled'.format(self.ctrlsGrp.name), 1) self.settingCtrlsGrp = utils.newNode('group', name='settingCtrls', parent=self.ctrlsGrp.name, skipNum=True) self.skelGrp = utils.newNode('group', name='skeleton', parent=self.globalCtrl.ctrlEnd, skipNum=True) cmds.setAttr('{}.overrideEnabled'.format(self.skelGrp.name), 1) self.mechGrp = utils.newNode('group', name='mechanics', parent=self.globalCtrl.ctrlEnd, skipNum=True) cmds.setAttr('{}.overrideEnabled'.format(self.mechGrp.name), 1) cmds.setAttr('{}.v'.format(self.mechGrp.name), 0) self.scaleAttr = '{}.sy'.format(self.globalCtrl.ctrl.name) globalCtrlAttrs = [ ('visSep', '___ Visibilities', ['___'], 0, '', ''), ('visGeo', 'Geometry', ['Hide', 'Show'], 1, '{}.v'.format(self.geoGrp.name)), ('visCtrls', 'Controls', ['Hide', 'Show'], 1, '{}.v'.format(self.ctrlsGrp.name)), ('visSkel', 'Skeleton', ['Hide', 'Show'], 0 if not debug else 1, '{}.v'.format(self.skelGrp.name)), ('visMech', 'Mechanics', ['Hide', 'Show'], 0, '{}.v'.format(self.mechGrp.name)), ('mdSep', '___ Display Mode', ['___'], 0, '', ''), ('mdGeo', 'Geometry', ['Normal', 'Template', 'Reference'], 2 if not debug else 0, '{}.overrideDisplayType'.format(self.geoGrp.name)), ('mdSkel', 'Skeleton', ['Normal', 'Template', 'Reference'], 2 if not debug else 0, '{}.overrideDisplayType'.format(self.skelGrp.name)), ('sep1', '___ ', ['___'], 0, '', ''), ('credits', 'Rig by Matt Jenkins', ['___'], 0, '', '') ] for each in globalCtrlAttrs: self.globalCtrl.addAttr(each[0], each[1], typ='enum', defaultVal=each[3], enumOptions=each[2]) if each[4]: exec('cmds.connectAttr(self.globalCtrl.ctrl.{}, each[4])'.format(each[0]))
def createCtrlOffsetGrps(self, num, name, guide=None, skipNum=False): self.rootGrp = utils.newNode('group', name=name, suffixOverride='controlRootGrp', side=self.side, skipNum=skipNum) utils.setOutlinerColor(self.rootGrp.name, color=(0.48, 0.48, 0.44)) if guide: utils.matchTransforms([self.rootGrp.name], guide) self.offsetGrps = [] par = self.rootGrp.name for i in range(num): self.offsetGrps.append( utils.newNode('group', name=name, suffixOverride='controlOffset', side=self.side, skipNum=skipNum)) utils.setOutlinerColor(self.offsetGrps[-1].name, color=(0.6, 0.6, 0.55)) self.offsetGrps[-1].parent(par, relative=True) par = self.offsetGrps[-1].name
def createSplineIK(self, crv=None, autoCrvSpans=0, rootOnCrv=True, parent=None): ## ik creation if crv: ik = cmds.ikHandle(sj=self.sj, ee=self.ej, sol='ikSplineSolver', c=crv, ccv=False) self.crv = crv else: if autoCrvSpans: scv = True else: scv = False ik = cmds.ikHandle(sj=self.sj, ee=self.ej, sol='ikSplineSolver', ccv=True, scv=scv, ns=autoCrvSpans) self.crv = cmds.rename( ik[2], utils.setupName(self.name, obj='nurbsCrv', side=self.side)) self.hdl = cmds.rename( ik[0], utils.setupName(self.name, obj='ikHandle', side=self.side)) self.eff = cmds.rename( ik[1], utils.setupName(self.name, obj='ikEffector', side=self.side)) self.grp = utils.newNode('group', name=self.name, side=self.side, parent=parent).name cmds.parent(self.hdl, self.crv, self.grp) cmds.setAttr('{}.it'.format(self.crv), 0) grpCP = cmds.xform(self.hdl, q=1, t=1, ws=1) cmds.xform(self.grp, piv=grpCP, ws=1) ## set effected joints self.jnts = utils.getChildrenBetweenObjs(self.sj, self.ej)
def createIK(self, solver='ikRPsolver', parent=None): ## ik creation ik = cmds.ikHandle(sj=self.sj, ee=self.ej, sol=solver) self.hdl = cmds.rename( ik[0], utils.setupName(self.name, obj='ikHandle', side=self.side)) self.eff = cmds.rename( ik[1], utils.setupName(self.name, obj='ikEffector', side=self.side)) hdlGrp = utils.newNode('group', name=self.name, side=self.side) hdlGrp.matchTransforms(self.hdl) cmds.parent(self.hdl, hdlGrp.name) self.grp = hdlGrp.name # self.grp = cmds.group(self.hdl, name=utils.setupName(self.name, obj='group', # side=self.side)) if parent: cmds.parent(self.grp, parent) grpCP = cmds.xform(self.hdl, q=1, t=1, ws=1) cmds.xform(self.grp, piv=grpCP, ws=1) ## set effected joints self.jnts = utils.getChildrenBetweenObjs(self.sj, self.ej) cmds.select(cl=1)
def addStretch(self, operation='greater', customStretchNode=False, globalScaleAttr=None, mode='distance', sjPar=None): if customStretchNode: if operation == 'greater': op = 1 elif operation == 'lesser': op = 2 else: op = 0 loadedPlugins = cmds.pluginInfo(query=1, listPlugins=1) if 'mjStretchArray' not in loadedPlugins: customStretchNode = False else: stretchNd = utils.newNode('mjStretchArray', name='{}Stretch'.format(self.name), side=self.side) jntsWithStretch = utils.getChildrenBetweenObjs( self.sj, self.ej)[1:] if self.rig: stretchNd.connect('gs', self.rig.scaleAttr, 'to') jntLengths = [] for i, each in enumerate(jntsWithStretch): eachTx = cmds.getAttr('{}.tx'.format(each)) jntLengths.append(eachTx) cmds.setAttr('{}.ojd[{}]'.format(stretchNd.name, i), eachTx) stretchNd.connect('od[{}]'.format(i), '{}.tx'.format(each), 'from') origD = abs(sum(jntLengths)) print origD cmds.setAttr('{}.origD'.format(stretchNd.name), origD) startLoc = utils.newNode('locator', name='{}Start'.format(self.name), side=self.side, parent=cmds.listRelatives(self.sj, p=1)) startLoc.matchTransforms(self.sj) endLoc = utils.newNode('locator', name='{}End'.format(self.name), side=self.side, parent=self.grp) endLoc.matchTransforms(self.ej) stretchNd.connect('sm', '{}.wm'.format(startLoc.name), 'to') stretchNd.connect('em', '{}.wm'.format(endLoc.name), 'to') print "### ADD A TOGGLE ATTR TO THE mjStretchArray NODE!" self.stretchToggleAttr = '{}.gs'.format(stretchNd.name) if not customStretchNode: if operation == 'greater': op = 2 elif operation == 'lesser': op = 4 else: op = 1 if mode == 'distance': ## locators startLoc = utils.newNode('locator', name='{}Start'.format(self.name), side=self.side) cmds.delete(cmds.parentConstraint(self.sj, startLoc.name)) if not sjPar: sjPar = cmds.listRelatives(self.jnts[0], p=1) cmds.parent(startLoc.name, sjPar) endLoc = utils.newNode('locator', name='{}End'.format(self.name), side=self.side) cmds.delete(cmds.parentConstraint(self.ej, endLoc.name)) cmds.parent(endLoc.name, self.grp) ## distance between locs distNd = utils.newNode('distanceBetween', name=self.name, side=self.side) cmds.connectAttr('{}.wp'.format(startLoc.name), '{}.point1'.format(distNd.name)) cmds.connectAttr('{}.wp'.format(endLoc.name), '{}.point2'.format(distNd.name)) distanceAttr = '{}.distance'.format(distNd.name) elif mode == 'length': ## crv info crvInfo = utils.newNode('curveInfo', name=self.crv, side=self.side) cmds.connectAttr('{}.ws'.format(self.crv), '{}.inputCurve'.format(crvInfo.name)) distanceAttr = '{}.arcLength'.format(crvInfo.name) ## global scale mult gsMult = utils.newNode('multDoubleLinear', name='{}GlobalScale'.format(self.name), side=self.side) if globalScaleAttr: cmds.connectAttr(globalScaleAttr, '{}.input2'.format(gsMult.name)) else: cmds.setAttr('{}.input2'.format(gsMult.name), 1) chainLength = 0 for jnt in self.jnts[1:]: length = cmds.getAttr('{}.translateX'.format(jnt)) chainLength += length cmds.setAttr('{}.input1'.format(gsMult.name), abs(chainLength)) ## distance / globalScaleMult divNd = utils.newNode('multiplyDivide', name='{}Dist'.format(self.name), suffixOverride='multiplyDivide_div', operation=2, side=self.side) cmds.connectAttr(distanceAttr, '{}.input1X'.format(divNd.name)) cmds.connectAttr('{}.output'.format(gsMult.name), '{}.input2X'.format(divNd.name)) ## condition; distance -> first, globalScaleMult -> second, div -> colorIfTrue condNd = utils.newNode('condition', name='{}Stretch'.format(self.name), operation=op, side=self.side) cmds.connectAttr(distanceAttr, '{}.firstTerm'.format(condNd.name)) cmds.connectAttr('{}.output'.format(gsMult.name), '{}.secondTerm'.format(condNd.name)) cmds.connectAttr('{}.output'.format(divNd.name), '{}.colorIfTrue'.format(condNd.name)) ## toggle (with power node) disablePowNode = utils.newNode('multiplyDivide', side=self.side, name='{}StretchToggle'.format( self.name), suffixOverride='multiplyDivide_pow', operation=3) disablePowNode.connect('input1X', '{}.outColorR'.format(condNd.name), mode='to') self.stretchToggleAttr = '{}.input2X'.format(disablePowNode.name) ## mult for each joint for jnt in self.jnts[1:]: transMult = utils.newNode('multDoubleLinear', name='{}{}'.format(self.name, jnt), side=self.side) cmds.setAttr('{}.input1'.format(transMult.name), cmds.getAttr('{}.tx'.format(jnt))) cmds.connectAttr('{}.outputX'.format(disablePowNode.name), '{}.input2'.format(transMult.name)) cmds.connectAttr('{}.output'.format(transMult.name), '{}.tx'.format(jnt))
def spaceSwitching(self, parents, niceNames=None, constraint='parent', dv=0, skip={}): target = self.offsetGrps[0].name if not niceNames: niceNames = [] for each in parents: splitParent = each.partition('_')[-1].rpartition('_')[0] if splitParent == 'global': splitParent = 'World' niceNames.append(splitParent.capitalize()) if niceNames <= 1: attrNiceName = niceNames[0] else: attrNiceName = '' for i, each in enumerate(niceNames): if i < len(niceNames) - 1: attrNiceName += '{} / '.format(each) else: attrNiceName += '{}'.format(each) # add seperator self.addAttr('spSwSep', '___ Space Switching', typ='enum', enumOptions=['___']) # add attribute spSwAttr = self.addAttr('spaceSwitch', '{} Switch'.format(attrNiceName), typ='enum', defaultVal=dv, enumOptions=niceNames) # constraint skipArgs = '' if 'rot' in skip.keys(): if constraint == 'orient': s = 'k' else: s = 'r' skipArgs = '{}, s{}={}'.format(skipArgs, s, skip['rot']) if 'trans' in skip.keys(): if constraint == 'point': s = 'k' else: s = 't' skipArgs = '{}, s{}={}'.format(skipArgs, s, skip['trans']) exec('constr = cmds.{}Constraint(parents, target, mo=1{})[0]'.format( constraint, skipArgs)) # connect attrs for i, each in enumerate(parents): # create condition node condNd = utils.newNode('condition', name='{}SpSwitch'.format(each), side=self.side, operation=0) # set cond vals cmds.setAttr('{}.secondTerm'.format(condNd.name), i) cmds.setAttr('{}.colorIfTrueR'.format(condNd.name), 1) cmds.setAttr('{}.colorIfFalseR'.format(condNd.name), 0) # connect condNd.connect('firstTerm', self.ctrl.spaceSwitch, mode='to') condNd.connect('outColorR', '{}.{}W{}'.format(constr, each, i), mode='from')
def __init__(self, name='control', gimbal=False, offsetGrpNum=1, guide=None, rig=None, deleteGuide=False, side='C', skipNum=False, parent=None, scaleOffset=1.0, constrainGuide=False): """ Create the control, offset groups, root group and const group. [Args]: name (string) - The name of the control gimbal (bool) - Toggles creating a gimbal control offsetGrpNum (int) - The amount of offset groups to create guide (string) - The guide to match transforms to rig (class) - The rig class to link the control to deleteGuide (bool) - Toggles deleting the guide side (string) - The side of the control skipNum (bool) - Toggles skipping the number in the control name if possible parent (string) - The parent of the control scaleOffset (float) - The scale offset of the control shape """ self.side = side self.gimbal = gimbal self.scaleOffset = scaleOffset if not guide: deleteGuide = True guideLoc = utils.newNode('locator', name='controlGuide') guide = guideLoc.name self.guide = False if deleteGuide else guide self.ctrl = utils.newNode('control', name=name, side=self.side, skipNum=skipNum) if self.gimbal: self.gimbalCtrl = utils.newNode('gimbalCtrl', name=name, side=self.side, skipNum=skipNum, parent=self.ctrl.name) scriptsPath = fileFn.getScriptDir() path = '{}/Jenks/scripts/controlShapes'.format(scriptsPath) loadShapeData(self.gimbalCtrl.name, 'sphere', path) self.gimbalCtrl.lockAttr(['t', 's']) self.ctrl.addAttr(name='gimbal', nn='Gimbal Visibility', typ='enum', enumOptions=['Hide', 'Show']) for each in cmds.listRelatives(self.gimbalCtrl.name, s=1): self.ctrl.connect('gimbal', '{}.v'.format(each), 'from') constGrpPar = self.gimbalCtrl.name else: constGrpPar = self.ctrl.name if offsetGrpNum > 0: self.createCtrlOffsetGrps(offsetGrpNum, name, guide, skipNum) self.ctrl.parent(self.offsetGrps[-1].name, relative=True) self.constGrp = utils.newNode('group', name=name, suffixOverride='controlConst', side=side, skipNum=skipNum) utils.setOutlinerColor(self.constGrp.name, color=(0.6, 0.6, 0.58)) self.constGrp.parent(parent=constGrpPar, relative=True) self.ctrlRoot = self.rootGrp.name self.ctrlEnd = self.constGrp.name else: self.ctrlRoot = self.ctrl self.ctrlEnd = self.ctrl if deleteGuide: cmds.delete(guide) if parent: cmds.parent(self.ctrlRoot, parent) self.ctrl.rigConnection = utils.addAttr(self.ctrl.name, name='rigConnection', nn='Rig Connection', typ='message') if constrainGuide and guide: self.constrain(guide, typ=constrainGuide) if rig: utils.addJntToSkinJnt(guide, rig) if rig: cmds.connectAttr(rig.ctrlsAttr, self.ctrl.rigConnection) cmds.select(cl=1)
def poleVector(pvGuide, jnt, module, extraName, limbType, moduleName, limbIK, arrow=False, parent=None): """ Create a polevector control for an ik handle. [Args]: pvGuide (string) - The name of the poleVector guide locator jnt (string) - The name of the joint to aim at module (class) - The limb module class extraName (string) - The extra name of the module limbType (string) - The name of the limb type moduleName (string) - The module name limbIK (class) - The ik class arrow (bool) - Toggles creating an arrow from the start of the joint chain instead """ col = utils.getColors(module.side) cmds.delete(cmds.aimConstraint(jnt, pvGuide)) if not arrow: module.pvCtrl = ctrlFn.ctrl(name='{}{}PV'.format(extraName, limbType), side=module.side, guide=pvGuide, skipNum=True, deleteGuide=True, parent=module.ikCtrlGrp.name, scaleOffset=module.rig.scaleOffset, rig=module.rig) module.pvCtrl.modifyShape(shape='3dArrow', color=col['col1'], rotation=(0, 180, 0), scale=(0.4, 0.4, 0.4)) module.pvCtrl.lockAttr(['r', 's']) module.pvCtrl.constrain(limbIK.hdl, typ='poleVector') module.pvCtrl.spaceSwitching( [module.rig.globalCtrl.ctrlEnd, module.ikCtrl.ctrlEnd]) pvCrv = cmds.curve(d=1, p=[ cmds.xform(module.pvCtrl.ctrl.name, q=1, ws=1, t=1), cmds.xform(jnt, q=1, ws=1, t=1) ]) cmds.setAttr('{}.it'.format(pvCrv), 0) cmds.parent(pvCrv, module.pvCtrl.offsetGrps[0].name, r=1) pvCrv = cmds.rename( pvCrv, '{}{}PVLine{}'.format(moduleName, limbType, suffix['nurbsCrv'])) cmds.setAttr('{}Shape.overrideEnabled'.format(pvCrv), 1) cmds.setAttr('{}Shape.overrideDisplayType'.format(pvCrv), 1) cmds.select(cl=1) cmds.select('{}.cv[1]'.format(pvCrv)) pvJntCluHdl = utils.newNode('cluster', name='{}{}PVJnt'.format( extraName, limbType), side=module.side, parent=jnt) cmds.select('{}.cv[0]'.format(pvCrv)) pvCtrlCluHdl = utils.newNode('cluster', name='{}{}PVCtrl'.format( extraName, limbType), side=module.side, parent=module.pvCtrl.ctrlEnd) utils.setColor(pvJntCluHdl.name, color=None) utils.setColor(pvCtrlCluHdl.name, color=None) else: ikStartJnt = cmds.listRelatives(jnt, p=1)[0] module.pvCtrl = ctrlFn.ctrl(name='{}{}PV'.format(extraName, limbType), side=module.side, guide=ikStartJnt, skipNum=True, parent=module.ikCtrlGrp.name, scaleOffset=module.rig.scaleOffset, rig=module.rig) module.pvCtrl.modifyShape(shape='pvArrow', color=col['col2'], scale=(0.4, 0.4, 0.4)) module.pvCtrl.lockAttr(['t', 's', 'rx']) cmds.delete(cmds.aimConstraint(pvGuide, module.pvCtrl.rootGrp.name)) if parent: cmds.parentConstraint(parent, module.pvCtrl.rootGrp.name, mo=1) cmds.parent(pvGuide, module.pvCtrl.ctrlEnd) cmds.poleVectorConstraint(pvGuide, limbIK.hdl) utils.setShapeColor(pvGuide, color=None)
def createRivet(rivName, extraName='', module=None, nrb=None, side='C', loftComponents=None, pv=0.5, pu=0.5, parent=None, rivJntPar=None, jnt=True): """ Create a rivet. [Args]: rivName (string) - The name of the rivet extraName (string) - The extra name of the rivet module (class) - The class of the body part module nrb (string) - The nurbs plane to create the rivet on pv (float) - The V position for the rivet pu (float) - The U position for the rivet parent (string) - The name of the mechanics parent rivJntPar (string) - The name of the joint parent [Returns]: rivJnt.name (string) - The name of the rivet joint """ if extraName: extraName += '_' if not nrb and loftComponents: nrbName = utils.setupName('{}{}Riv'.format(extraName, rivName), obj='nurbsSurface', side=module.side if module else side, skipNumber=False) nrb = cmds.loft(loftComponents, ch=1, u=1, d=3, ss=1, rn=0, po=0, n=nrbName)[0] if parent: cmds.parent(nrb, parent) rivLoc = utils.newNode('locator', name='{}{}Riv'.format(extraName, rivName), side=module.side if module else side, parent=parent) if jnt: rivJnt = utils.newNode('joint', name='{}{}Riv'.format(extraName, rivName), side=module.side if module else side, parent=rivJntPar) if module: utils.addJntToSkinJnt(rivJnt.name, rig=module.rig) cmds.setAttr('{}.jointOrient'.format(rivJnt.name), 0, 0, 0) cmds.parentConstraint(rivLoc.name, rivJnt.name) rivNd = utils.newNode('mjRivet', name='{}{}Riv'.format(extraName, rivName), side=module.side if module else side) rivNd.connect('is', '{}.ws'.format(nrb), 'to') rivNd.connect('ot', '{}.t'.format(rivLoc.name), 'from') rivNd.connect('or', '{}.r'.format(rivLoc.name), 'from') cmds.setAttr('{}.pv'.format(rivNd.name), pv) cmds.setAttr('{}.pu'.format(rivNd.name), pu) return rivJnt.name if jnt else rivLoc.name
def createLayeredSplineIK(jnts, name, rig=None, side='C', extraName='', parent=None, dyn=False): """ Create a layered spline IK. [Args]: jnts (list)(string) - The names of the joints to create the IK with name (string) - The name of the IK rig (class) - The rig class to use side (string) - The side of the IK extraName (string) - The extra name of the IK parent (string) - The name of the parent dyn (bool) - Toggles dynamics on the spline IK """ moduleName = utils.setupBodyPartName(extraName, side) col = utils.getColors(side) ## create base layer jnts tmpCrv = utils.createCrvFromObjs(jnts, crvName='tmpCrv') ctrlGrp = utils.newNode('group', name='{}{}Ctrls'.format(extraName, name), side=side, parent=rig.ctrlsGrp.name if rig else None, skipNum=True) mechGrp = utils.newNode('group', name='{}{}Mech'.format(extraName, name), side=side, parent=rig.mechGrp.name if rig else None, skipNum=True) baseJnts = utils.createJntsFromCrv(tmpCrv, numOfJnts=4, side=side, name='{}{}_baseLayer'.format( extraName, name)) if rig: cmds.parent(jnts[0], rig.skelGrp.name) cmds.parent(baseJnts[0], mechGrp.name) ## parent locs to base jnts ## base layer ctrls baseLayerLocs = [] baseLayerCtrls = [] baseCtrlParent = ctrlGrp.name for each in baseJnts: baseLoc = utils.newNode('locator', name='{}{}_baseLayer'.format(extraName, name), side=side) baseLoc.parent(each, relative=True) utils.setShapeColor(baseLoc.name, color=None) baseLayerLocs.append(baseLoc) baseCtrl = ctrlFn.ctrl(name='{}{}_baseLayer'.format(extraName, name), guide=each, side=side, parent=baseCtrlParent, rig=rig, scaleOffset=rig.scaleOffset) baseCtrl.constrain(each) baseCtrl.modifyShape(shape='cube', color=col['col2'], scale=(1, 1, 1)) baseLayerCtrls.append(baseCtrl) baseCtrlParent = baseCtrl.ctrlEnd baseSpaces = [rig.globalCtrl.ctrlEnd] if parent: baseSpaces.insert(0, parent) baseLayerCtrls[0].spaceSwitching(parents=baseSpaces, niceNames=None, constraint='parent', dv=0) ## mid layer crv FROM BASE JNTS midCrv = utils.createCrvFromObjs(baseJnts, crvName='{}_midLayer'.format(name), side=side, extraName=extraName) ## create mid jnts midJnts = utils.createJntsFromCrv(tmpCrv, numOfJnts=7, side=side, name='{}{}_midLayer'.format( extraName, name)) cmds.parent(midJnts[0], mechGrp.name) cmds.delete(tmpCrv) ## parent locs to mid jnts ## create mid ctrls - parent constrain root grp to mid jnts midLayerLocs = [] midLayerCtrls = [] midCtrlParent = ctrlGrp.name for each in midJnts: midCtrl = ctrlFn.ctrl(name='{}{}_midLayer'.format(extraName, name), guide=each, side=side, parent=midCtrlParent, rig=rig, scaleOffset=rig.scaleOffset) cmds.parentConstraint(each, midCtrl.rootGrp.name, mo=1) midCtrl.modifyShape(shape='sphere', color=col['col1'], scale=(0.4, 0.4, 0.4)) midLayerCtrls.append(midCtrl) midLoc = utils.newNode('locator', name='{}{}_midLayer'.format(extraName, name), side=side) utils.setShapeColor(midLoc.name, color=None) midLoc.parent(midCtrl.ctrlEnd, relative=True) midLayerLocs.append(midLoc) midCtrlParent = midCtrl.ctrlEnd ## ik spline mid crv to mid jnts midIKSpline = ikFn.ik(sj=midJnts[0], ej=midJnts[-1], name='{}{}_midLayerIK'.format(extraName, name), side=side) midIKSpline.createSplineIK(crv=midCrv, parent=mechGrp.name) midIKSpline.addStretch(operation='both', mode='length', globalScaleAttr=rig.scaleAttr if rig else None) midIKSpline.advancedTwist(baseLayerCtrls[0].ctrlEnd, endObj=baseLayerCtrls[-1].ctrlEnd, wuType=4) ## connect mid crv cvs to base locators for i, each in enumerate(baseLayerLocs): cmds.connectAttr('{}.wp'.format(each.name), '{}Shape.cv[{}]'.format(midCrv, i)) ## create skin crv FROM MID JNTS skinCrvIn = utils.createCrvFromObjs(midJnts, side=side, extraName=extraName, crvName='{}_skinLayer{}'.format( name, 'DynIn' if dyn else '')) skinCrvInShape = cmds.listRelatives(skinCrvIn, s=1)[0] if dyn: dynMechGrp = utils.newNode('group', name='{}Dynamics'.format(name), side=side, parent=mechGrp.name, skipNum=True) cmds.parent(skinCrvIn, dynMechGrp.name) skinCrv = utils.createCrvFromObjs(midJnts, crvName='{}_skinLayer'.format(name), side=side, extraName=extraName) ## create output curve dynOutCrv = utils.createCrvFromObjs( midJnts, side=side, extraName=extraName, crvName='{}_skinLayerDynOut'.format(name)) cmds.parent(dynOutCrv, dynMechGrp.name) dynOutCrvShape = cmds.listRelatives(dynOutCrv, s=1)[0] ## create follicle fol = utils.newNode('follicle', name='{}_skinLayerDyn'.format(name), side=side, parent=dynMechGrp.name) cmds.setAttr('{}.restPose'.format(fol.name), 1) cmds.setAttr('{}.startDirection'.format(fol.name), 1) cmds.setAttr('{}.degree'.format(fol.name), 3) ## create hair system hs = utils.newNode('hairSystem', name='{}_skinLayerDyn'.format(name), side=side, parent=dynMechGrp.name) ## create nucleus nuc = utils.newNode('nucleus', name='{}_skinLayerDyn'.format(name), side=side, parent=dynMechGrp.name) ## connect shit fol.connect('startPosition', '{}.local'.format(skinCrvInShape), mode='to') fol.connect('startPositionMatrix', '{}.wm'.format(skinCrvIn), mode='to') fol.connect('currentPosition', '{}.outputHair[0]'.format(hs.name), mode='to') fol.connect('outCurve', '{}.create'.format(dynOutCrvShape), mode='from') fol.connect('outHair', '{}.inputHair[0]'.format(hs.name), mode='from') hs.connect('currentState', '{}.inputActive[0]'.format(nuc.name), mode='from') hs.connect('startState', '{}.inputActiveStart[0]'.format(nuc.name), mode='from') hs.connect('nextState', '{}.outputObjects[0]'.format(nuc.name), mode='to') hs.connect('startFrame', '{}.startFrame'.format(nuc.name), mode='to') hs.connect('currentTime', 'time1.outTime', mode='to') nuc.connect('currentTime', 'time1.outTime', mode='to') ## blend shape curves blendNode = cmds.blendShape(skinCrvIn, dynOutCrv, skinCrv, n='{}_{}Dynamics{}'.format( side, name, suffix['blend']))[0] ## connect blend shape to attribute ##- create dyn control dynCtrl = ctrlFn.ctrl(name='{}Settings'.format(name), guide='{}_{}SettingsGuide{}'.format( side, name, suffix['locator']), rig=rig, deleteGuide=True, side=side, skipNum=True, parent=rig.settingCtrlsGrp.name) dynCtrl.makeSettingCtrl(ikfk=False, parent=jnts[0]) dynCtrl.addAttr('dynSwitch', nn='Dynamics Switch', minVal=0, maxVal=1, defaultVal=1) dynSwitchRev = utils.newNode('reverse', name='{}DynamicsSwitch'.format(name), side=side) cmds.connectAttr(dynCtrl.ctrl.dynSwitch, '{}.{}'.format(blendNode, dynOutCrv)) dynSwitchRev.connect('inputX', dynCtrl.ctrl.dynSwitch, mode='to') dynSwitchRev.connect('outputX', '{}.{}'.format(blendNode, skinCrvIn), mode='from') else: skinCrv = skinCrvIn ## ik spline skin crv to skin jnts skinIKSpline = ikFn.ik(sj=jnts[0], ej=jnts[-1], name='{}{}_skinLayerIK'.format(extraName, name), side=side) skinIKSpline.createSplineIK(crv=skinCrv, parent=mechGrp.name) skinIKSpline.addStretch(operation='both', mode='length', globalScaleAttr=rig.scaleAttr if rig else None) skinIKSpline.advancedTwist(midLayerCtrls[0].ctrlEnd, endObj=midLayerCtrls[-1].ctrlEnd, wuType=4) ## connect skin crv cvs to mid locators for i, each in enumerate(midLayerLocs): cmds.connectAttr('{}.wp'.format(each.name), '{}Shape.cv[{}]'.format(skinCrvIn, i))
def ribbonJoints(sj, ej, bendyName, module, extraName='', moduleType=None, par=None, endCtrl=False, basePar=None): """ Create a ribbon setup. [Args]: sj (string) - ej (string) - bendyName (string) - The name of the ribbon setup module (class) - The class of the body part module extraName (string) - The extra name of the ribbon setup moduleType (string) - The type of module par (string) - The name of the mechanics parent endCtrl (bool) - Toggles creating an end control basePar (string) - The name of the joints parent [Returns]: bendyEndCtrl (class) - The end control class or False """ if not basePar: basePar = sj moduleName = utils.setupBodyPartName(module.extraName, module.side) bendyName = '{}{}'.format(moduleType, bendyName) col = utils.getColors(module.side) distance = cmds.getAttr('{}.tx'.format(ej)) nPlane = cmds.nurbsPlane(p=(distance / 2, 0, 0), lr=0.1, w=distance, axis=[0, 1, 0], u=3, d=3) nPlane = cmds.rename( nPlane[0], '{}{}Bendy{}'.format(moduleName, bendyName, suffix['nurbsSurface'])) if par: cmds.parent(nPlane, par) utils.matchTransforms(nPlane, sj) ## ctrl if not cmds.objExists('{}{}Ctrls{}'.format(moduleName, moduleType, suffix['group'])): ctrlGrp = cmds.group( n='{}{}Ctrls{}'.format(moduleName, moduleType, suffix['group'])) cmds.parent(ctrlGrp, module.rig.ctrlsGrp.name) bendyCtrl = ctrlFn.ctrl(name='{}{}Bendy'.format(extraName, bendyName), side=module.side, offsetGrpNum=2, skipNum=True, rig=module.rig, scaleOffset=module.rig.scaleOffset, parent='{}{}Ctrls{}'.format( moduleName, moduleType, suffix['group'])) bendyCtrl.modifyShape(color=col['col3'], shape='starFour', scale=(0.3, 0.3, 0.3)) cmds.pointConstraint(sj, ej, bendyCtrl.offsetGrps[0].name) cmds.orientConstraint(sj, bendyCtrl.offsetGrps[0].name, sk='x') orientConstr = cmds.orientConstraint(basePar, ej, bendyCtrl.offsetGrps[1].name, sk=['y', 'z'], mo=1) cmds.setAttr('{}.interpType'.format(orientConstr[0]), 2) ## clusters cmds.select('{}.cv[0:1][0:3]'.format(nPlane)) baseClu = utils.newNode('cluster', name='{}{}BendyBase'.format(extraName, bendyName), side=module.side, parent=par) cmds.select('{}.cv[2:3][0:3]'.format(nPlane)) midClu = utils.newNode('cluster', name='{}{}BendyMid'.format(extraName, bendyName), side=module.side, parent=par) bendyCtrl.constrain(midClu.name) bendyCtrl.constrain(midClu.name, typ='scale') endCluGrpTrans = utils.newNode('group', name='{}{}BendyEndCluTrans'.format( extraName, bendyName), side=module.side, parent=par) utils.matchTransforms(endCluGrpTrans.name, ej) endCluGrpOrientYZ = utils.newNode('group', name='{}{}BendyEndCluOrient'.format( extraName, bendyName), side=module.side, parent=endCluGrpTrans.name) utils.matchTransforms(endCluGrpOrientYZ.name, endCluGrpTrans.name) endCluGrpOrientX = utils.newNode('group', name='{}{}BendyEndCluOrientX'.format( extraName, bendyName), side=module.side, parent=endCluGrpOrientYZ.name) utils.matchTransforms(endCluGrpOrientX.name, endCluGrpOrientYZ.name) cmds.select('{}.cv[4:5][0:3]'.format(nPlane)) endClu = utils.newNode('cluster', name='{}{}BendyEnd'.format(extraName, bendyName), side=module.side, parent=endCluGrpOrientX.name) cmds.parentConstraint(basePar, baseClu.name, mo=1) cmds.scaleConstraint(basePar, baseClu.name, mo=1) if not endCtrl: cmds.pointConstraint(ej, endCluGrpTrans.name, mo=1) cmds.orientConstraint(ej, endCluGrpOrientX.name, mo=1, sk=['y', 'z']) cmds.orientConstraint(sj, endCluGrpOrientYZ.name, mo=1, sk='x') bendyEndCtrl = False else: bendyEndCtrl = ctrlFn.ctrl( name='{}{}BendyEnd'.format(extraName, bendyName), side=module.side, skipNum=True, rig=module.rig, scaleOffset=module.rig.scaleOffset, parent='{}{}Ctrls{}'.format(moduleName, moduleType, suffix['group'])) bendyEndCtrl.modifyShape(color=col['col3'], shape='starFour', scale=(0.3, 0.3, 0.3)) cmds.parentConstraint(ej, bendyEndCtrl.offsetGrps[0].name) bendyEndCtrl.constrain(endCluGrpTrans.name) bendyEndCtrl.constrain(endCluGrpTrans.name, typ='scale') ## rivets rivJntPar = sj for i in [0.1, 0.3, 0.5, 0.7, 0.9]: rivJnt = createRivet('{}Bendy'.format(bendyName), extraName, module, nPlane, pv=0.5, pu=i, parent=par, rivJntPar=rivJntPar) rivJntPar = rivJnt return bendyEndCtrl
def create(self, jnts, nrb, parent=None, numOfJnts=10, skipSkinning=False, mode='pu'): """ Create the strap. [Args]: jnts (list)(string) - The names of the joints to bind to the nurbs plane nrb (string) - The name of the nurbs plane parent (string) - The name of the parent numOfJnts (int) - The amount of skinning joints to create """ extraName = '{}_'.format(self.extraName) if self.extraName else '' col = utils.getColors(self.side) self.ctrls = [] self.strapMechGrp = utils.newNode('group', name='{}{}Mech'.format( extraName, self.name), side=self.side, parent=self.rig.mechGrp.name, skipNum=True) cmds.setAttr('{}.it'.format(self.strapMechGrp.name), 0) cmds.parent(nrb, self.strapMechGrp.name) self.strapCtrlsGrp = utils.newNode('group', name='{}{}Ctrls'.format( extraName, self.name), side=self.side, parent=self.rig.ctrlsGrp.name, skipNum=True) if parent: cmds.parentConstraint(parent, self.strapCtrlsGrp.name, mo=1) if not skipSkinning: prevJnt = None for each in jnts: if prevJnt: try: cmds.parent(each, prevJnt) except RuntimeError: pass prevJnt = each utils.orientJoints(jnts, aimAxis=(1 if not self.side == 'R' else -1, 0, 0), upAxis=(0, 1, 0)) for each in jnts: cmds.parent(each, self.strapMechGrp.name) ## create control ctrl = ctrlFn.ctrl(name='{}{}'.format(extraName, self.name), side=self.side, guide=each, rig=self.rig, parent=self.strapCtrlsGrp.name, scaleOffset=self.rig.scaleOffset * 0.4) ctrl.modifyShape(shape='sphere', color=col['col3']) self.ctrls.append(ctrl) ctrl.constrain(each) ctrl.constrain(each, typ='scale') if not skipSkinning: ## skin jnts to nrb / clusters skin = cmds.skinCluster(jnts, nrb, parent)[0] ## rivet locators + jnts if self.rig: rivJntPar = self.rig.skelGrp.name else: rivJntPar = None for i in range(numOfJnts): if mode == 'pu': createRivet(self.name, extraName, self, nrb, parent=self.strapMechGrp.name, pv=0.5, pu=(1.0 / (numOfJnts - 1.0)) * i, rivJntPar=rivJntPar) else: createRivet(self.name, extraName, self, nrb, parent=self.strapMechGrp.name, pv=(1.0 / (numOfJnts - 1.0)) * i, pu=0.5, rivJntPar=rivJntPar)
def reverseFoot(module, extraName, legMechGrp, footJnts, legIK): col = utils.getColors(module.side) footMechGrp = utils.newNode('group', name='{}footMech'.format(extraName), side=module.side, parent=legMechGrp.name) ##- iks footBallIK = ikFn.ik(footJnts[0], footJnts[1], side=module.side, name='{}footBallIK'.format(extraName)) footBallIK.createIK(parent=footMechGrp.name) footToesIK = ikFn.ik(footJnts[1], footJnts[2], side=module.side, name='{}footToesIK'.format(extraName)) footToesIK.createIK(parent=footMechGrp.name) ##- rf joints rfMechGrp = utils.newNode('group', name='{}RFMech'.format(extraName), side=module.side, parent=footMechGrp.name) rfJntGuides = [ '{}footHeelGuide{}'.format(module.moduleName, suffix['locator']), '{}footToesGuide{}'.format(module.moduleName, suffix['locator']), footJnts[1], footJnts[0], ] rfJntNames = [ 'footHeel', 'footToes', 'footBall', 'ankle', ] rfJnts = utils.createJntChainFromObjs(rfJntGuides, 'RF', side=module.side, extraName=extraName, jntNames=rfJntNames, parent=rfMechGrp.name) ##- rf iks rfToesIK = ikFn.ik(rfJnts[0], rfJnts[1], side=module.side, name='{}RF_footToesIK'.format(extraName)) rfToesIK.createIK(parent=rfMechGrp.name) rfBallIK = ikFn.ik(rfJnts[1], rfJnts[2], side=module.side, name='{}RF_footBallIK'.format(extraName)) rfBallIK.createIK(parent=rfMechGrp.name) rfAnkleIK = ikFn.ik(rfJnts[2], rfJnts[3], side=module.side, name='{}RF_ankleIK'.format(extraName)) rfAnkleIK.createIK(parent=rfMechGrp.name) ##- foot side pivots module.ikCtrl.addAttr('footRollsSep', nn='___ Foot Rolls', typ='enum', enumOptions=['___']) innerPivGrp = utils.newNode('group', name='{}footInnerPivot'.format(extraName), parent=module.ikCtrl.ctrlEnd, side=module.side, skipNum=True) innerPivGrp.matchTransforms('{}footInnerGuide{}'.format( module.moduleName, suffix['locator'])) outerPivGrp = utils.newNode('group', name='{}footOuterPivot'.format(extraName), parent=innerPivGrp.name, side=module.side, skipNum=True) outerPivGrp.matchTransforms('{}footOuterGuide{}'.format( module.moduleName, suffix['locator'])) module.ikCtrl.addAttr('sidePiv', nn='Side Pivot') sidePivNeg = utils.newNode('condition', name='{}footSidePivNeg'.format(extraName), side=module.side, operation=3) sidePivNeg.connect('firstTerm', module.ikCtrl.ctrl.sidePiv, mode='to') if module.side == 'R': negFootPivAttr = utils.newNode( 'reverse', name='{}footSidePivNeg'.format(extraName), side=module.side) negFootPivAttr.connect('inputX', module.ikCtrl.ctrl.sidePiv, mode='to') negFootPivAttr = '{}.outputX'.format(negFootPivAttr.name) else: negFootPivAttr = module.ikCtrl.ctrl.sidePiv sidePivNeg.connect('colorIfTrueR', negFootPivAttr, mode='to') sidePivNeg.connect('outColorR', '{}.rz'.format(innerPivGrp.name), mode='from') sidePivPos = utils.newNode('condition', name='{}footSidePivPos'.format(extraName), side=module.side, operation=4) sidePivPos.connect('firstTerm', module.ikCtrl.ctrl.sidePiv, mode='to') sidePivPos.connect('colorIfTrueR', module.ikCtrl.ctrl.sidePiv, mode='to') sidePivPos.connect('outColorR', '{}.rz'.format(outerPivGrp.name), mode='from') ##- controls module.footHeelIKCtrl = ctrlFn.ctrl(name='{}footHeelIK'.format(extraName), side=module.side, guide=rfJntGuides[0], skipNum=True, parent=outerPivGrp.name, scaleOffset=module.rig.scaleOffset, rig=module.rig, offsetGrpNum=2) module.footHeelIKCtrl.modifyShape(color=col['col2'], shape='pringle', mirror=True, scale=(0.7, 0.7, 0.7), rotation=(-45, 0, 0)) module.footHeelIKCtrl.lockAttr(attr=['t', 's']) module.footHeelIKCtrl.constrain(rfJnts[0]) module.footToesFKCtrl = ctrlFn.ctrl(name='{}footToesFK'.format(extraName), side=module.side, guide=footJnts[1], skipNum=True, parent=module.footHeelIKCtrl.ctrlEnd, scaleOffset=module.rig.scaleOffset, rig=module.rig) module.footToesFKCtrl.modifyShape(color=col['col3'], shape='arc', mirror=True, scale=(0.2, 0.2, 0.2), translation=(3, 1, 0), rotation=(90, 0, 0)) module.footToesFKCtrl.constrain(footToesIK.grp) module.footToesFKCtrl.lockAttr(['t', 's']) module.footToesIKCtrl = ctrlFn.ctrl(name='{}footToesIK'.format(extraName), side=module.side, guide=rfJntGuides[1], skipNum=True, parent=module.footHeelIKCtrl.ctrlEnd, scaleOffset=module.rig.scaleOffset, rig=module.rig, offsetGrpNum=2) module.footToesIKCtrl.modifyShape(color=col['col2'], shape='pringle', mirror=True, scale=(0.7, 0.7, 0.7), rotation=(90, 0, 0), translation=(0, -1, 0)) module.footToesIKCtrl.lockAttr(attr=['t', 's']) module.footToesIKCtrl.constrain(rfBallIK.grp) module.footBallIKCtrl = ctrlFn.ctrl(name='{}footBallIK'.format(extraName), side=module.side, guide=rfJntGuides[2], skipNum=True, parent=module.footToesIKCtrl.ctrlEnd, scaleOffset=module.rig.scaleOffset, rig=module.rig, offsetGrpNum=2) module.footBallIKCtrl.modifyShape(color=col['col2'], shape='pringle', mirror=True, scale=(0.7, 0.7, 0.7), translation=(0, 1.5, 0)) module.footBallIKCtrl.lockAttr(attr=['t', 's']) cmds.xform(module.footBallIKCtrl.offsetGrps[0].name, ro=(-90, 0, 90)) module.footBallIKCtrl.constrain(rfAnkleIK.grp) ##-- control attributes module.ikCtrl.addAttr('footCtrlTog', nn='Fine Foot Controls', typ='enum', defaultVal=1, enumOptions=['Hide', 'Show']) cmds.connectAttr(module.ikCtrl.ctrl.footCtrlTog, '{}.v'.format(module.footHeelIKCtrl.rootGrp.name)) module.ikCtrl.addAttr('heelRoll', nn='Heel Roll') cmds.connectAttr(module.ikCtrl.ctrl.heelRoll, '{}.rx'.format(module.footHeelIKCtrl.offsetGrps[1].name)) module.ikCtrl.addAttr('heelTwist', nn='Heel Twist') cmds.connectAttr(module.ikCtrl.ctrl.heelTwist, '{}.ry'.format(module.footHeelIKCtrl.offsetGrps[1].name)) module.ikCtrl.addAttr('ballRoll', nn='Ball Roll') cmds.connectAttr(module.ikCtrl.ctrl.ballRoll, '{}.rx'.format(module.footBallIKCtrl.offsetGrps[1].name)) module.ikCtrl.addAttr('toeRoll', nn='Toe Roll') cmds.connectAttr(module.ikCtrl.ctrl.toeRoll, '{}.rx'.format(module.footToesIKCtrl.offsetGrps[1].name)) module.ikCtrl.addAttr('toeTwist', nn='Toe Twist') cmds.connectAttr(module.ikCtrl.ctrl.toeTwist, '{}.ry'.format(module.footToesIKCtrl.offsetGrps[1].name)) ##- constraints # cmds.parentConstraint(rfJnts[1], footToesIK.grp, mo=1) cmds.parentConstraint(module.footHeelIKCtrl.ctrlEnd, rfToesIK.grp, mo=1) cmds.parentConstraint(rfJnts[1], module.footToesFKCtrl.offsetGrps[0].name, mo=1) cmds.parentConstraint(rfJnts[2], footBallIK.grp, mo=1) cmds.parentConstraint(rfJnts[3], legIK.grp, mo=1) if cmds.objExists('{}footGuides{}'.format(module.moduleName, suffix['group'])): cmds.delete('{}footGuides{}'.format(module.moduleName, suffix['group']))
def ikfkMechanics(module, extraName, jnts, mechSkelGrp, ctrlGrp, moduleType, rig): """ Create the mechanics for a IK/FK setup. [Args]: module (class) - The class of the body part module extraName (string) - The extra name for the setup jnts (list)(string) - A list of jnts to create the mechanics on mechSkelGrp (string) - The name of the mechanics skeleton group ctrlGrp (string) - The name of the control group moduleType (string) - The type of module ('arm', 'leg', etc) rig (class) - The rig class to use [Returns]: ikJnts (list)(string) - The names of the IK joints fkJnts (list)(string) - The names of the FK joints jnts (list)(string) - The names of the result joints ikCtrlGrp (string) - The name of the IK controls group fkCtrlGrp (string) - The name of the FK controls group """ jntSuffix = suffix['joint'] newJntChains = [] ## create duplicate chains for chain in ['IK', 'FK']: newJnts = utils.duplicateJntChain(chain, jnts, parent=mechSkelGrp.name) newJntChains.append(newJnts) ikJnts = newJntChains[0] fkJnts = newJntChains[1] for i, each in enumerate(jnts): newName = '{}_result{}'.format(each.rsplit('_', 1)[0], jntSuffix) jnts[i] = cmds.rename(each, newName) # utils.addJntToSkinJnt(jnts[i], rig=rig) ## settings control module.settingCtrl = ctrlFn.ctrl( name='{}{}Settings'.format(extraName, moduleType), guide='{}{}Settings{}'.format(module.moduleName, moduleType, suffix['locator']), deleteGuide=True, side=module.side, skipNum=True, parent=module.rig.settingCtrlsGrp.name, scaleOffset=rig.scaleOffset, rig=rig) if moduleType == 'arm': settingJnt = jnts[3] else: settingJnt = jnts[2] module.settingCtrl.makeSettingCtrl(ikfk=True, parent=settingJnt) ## parent constraints for jnt, ikJnt, fkJnt in zip(jnts, ikJnts, fkJnts): parConstr = cmds.parentConstraint(ikJnt, fkJnt, jnt) cmds.connectAttr(module.settingCtrl.ctrl.ikfkSwitch, '{}.{}W1'.format(parConstr[0], fkJnt)) swRev = utils.newNode('reverse', name='{}{}IKFKSw'.format(extraName, moduleType), side=module.side) swRev.connect('inputX', module.settingCtrl.ctrl.ikfkSwitch, mode='to') swRev.connect('outputX', '{}.{}W0'.format(parConstr[0], ikJnt), mode='from') ## control vis groups ikCtrlGrp = utils.newNode('group', name='{}{}IKCtrls'.format(extraName, moduleType), side=module.side, parent=ctrlGrp.name, skipNum=True) fkCtrlGrp = utils.newNode('group', name='{}{}FKCtrls'.format(extraName, moduleType), side=module.side, parent=ctrlGrp.name, skipNum=True) cmds.setDrivenKeyframe(ikCtrlGrp.name, at='visibility', cd=module.settingCtrl.ctrl.ikfkSwitch, dv=0.999, v=1) cmds.setDrivenKeyframe(ikCtrlGrp.name, at='visibility', cd=module.settingCtrl.ctrl.ikfkSwitch, dv=1, v=0) cmds.setDrivenKeyframe(fkCtrlGrp.name, at='visibility', cd=module.settingCtrl.ctrl.ikfkSwitch, dv=0.001, v=1) cmds.setDrivenKeyframe(fkCtrlGrp.name, at='visibility', cd=module.settingCtrl.ctrl.ikfkSwitch, dv=0, v=0) return ikJnts, fkJnts, jnts, ikCtrlGrp, fkCtrlGrp
def basicFace(self, jntPar=None, tongue=False): """ Create a basic face setup. [Args]: jntPar (string) - The name of the joint parent tongue (bool) - Toggles creating the tongue """ extraName = '{}_'.format(self.extraName) if self.extraName else '' faceCtrlsGrp = utils.newNode('group', name='{}faceCtrls'.format(extraName), side=self.side, skipNum=True, parent=self.rig.ctrlsGrp.name) if jntPar: cmds.parentConstraint(jntPar, faceCtrlsGrp.name, mo=1) ## jaw jawJnt = 'C_{}jawLower{}'.format(extraName, suffix['joint']) utils.addJntToSkinJnt(jawJnt, self.rig) utils.addJntToSkinJnt( 'C_{}jawUpper{}'.format(extraName, suffix['joint']), self.rig) jawCtrl = ctrlFn.ctrl(name='{}lowerJaw'.format(extraName), side='C', guide=jawJnt, rig=self.rig, parent=faceCtrlsGrp.name, scaleOffset=self.rig.scaleOffset) jawCtrl.modifyShape(shape='cube', color=27, scale=(0.3, 0.3, 0.3)) jawCtrl.constrain(jawJnt) if jntPar: cmds.parent(jawJnt, jntPar) cmds.parent('C_{}jawUpper{}'.format(extraName, suffix['joint']), jntPar) ## eyes for s in 'LR': eyeJnt = '{}_{}eye{}'.format(s, extraName, suffix['joint']) utils.addJntToSkinJnt(eyeJnt, self.rig) eyeCtrl = ctrlFn.ctrl(name='{}eye'.format(extraName), side=s, guide=eyeJnt, rig=self.rig, parent=faceCtrlsGrp.name, scaleOffset=self.rig.scaleOffset) eyeCtrl.constrain(eyeJnt) eyeCtrl.modifyShape(shape='sphere', scale=(0.1, 0.1, 0.1), color=27) if jntPar: cmds.parent(eyeJnt, jntPar) ## do aim controls print '## Do eye aim controls.' ## eyelids upperEyelidJnt = '{}_{}eyelidUpper{}'.format( s, extraName, suffix['joint']) if jntPar: cmds.parent(upperEyelidJnt, jntPar) utils.addJntToSkinJnt(upperEyelidJnt, self.rig) upperEyelidCtrl = ctrlFn.ctrl( name='{}eyelidUpper'.format(extraName), side=s, guide=upperEyelidJnt, rig=self.rig, parent=faceCtrlsGrp.name, scaleOffset=self.rig.scaleOffset) upperEyelidCtrl.constrain(upperEyelidJnt) upperEyelidCtrl.constrain(upperEyelidJnt, typ='scale') upperEyelidCtrl.modifyShape(shape='arc', scale=(0.1, 0.1, 0.1), rotation=(0, 0, 90), mirror=True, color=27) lowerEyelidJnt = '{}_{}eyelidLower{}'.format( s, extraName, suffix['joint']) if jntPar: cmds.parent(lowerEyelidJnt, jntPar) utils.addJntToSkinJnt(lowerEyelidJnt, self.rig) lowerEyelidCtrl = ctrlFn.ctrl( name='{}eyelidLower'.format(extraName), side=s, guide=lowerEyelidJnt, rig=self.rig, parent=faceCtrlsGrp.name, scaleOffset=self.rig.scaleOffset) lowerEyelidCtrl.constrain(lowerEyelidJnt) lowerEyelidCtrl.constrain(lowerEyelidJnt, typ='scale') lowerEyelidCtrl.modifyShape(shape='arc', scale=(0.1, 0.1, 0.1), rotation=(0, 0, 90), mirror=True, color=27) ## tongue if tongue: tongueSj = 'C_{}tongue_base_JNT'.format(extraName) tongueEj = 'C_{}tongue_tip_JNT'.format(extraName) tongueJnts = utils.getChildrenBetweenObjs(tongueSj, tongueEj) cmds.parent(tongueSj, jntPar) tongueCtrlPar = jawCtrl.ctrlEnd for each in tongueJnts[:-1]: ctrl = ctrlFn.ctrl(name='tongue', side='C', guide=each, rig=self.rig, parent=tongueCtrlPar, scaleOffset=self.rig.scaleOffset) tongueCtrlPar = ctrl.ctrlEnd ctrl.modifyShape(shape='circle', color=27, scale=(0.1, 0.1, 0.1)) ctrl.constrain(each) ## lips ## cheeks ## eyebrows ## nose jntList = [ ('lipLower', 'C'), ('lipUpper', 'C'), ('mouthCorner', 'L'), ('mouthCorner', 'R'), ('noseCorner', 'L'), ('noseCorner', 'R'), ('eyebrowInner', 'L'), ('eyebrowMid', 'L'), ('eyebrowOuter', 'L'), ('eyebrowInner', 'R'), ('eyebrowMid', 'R'), ('eyebrowOuter', 'R'), ('cheek', 'L'), ('cheek', 'R'), ] for x in jntList: name = x[0] side = x[1] ## create control jnt = '{}_{}{}{}'.format(side, extraName, name, suffix['joint']) utils.addJntToSkinJnt(jnt, self.rig) if jntPar: cmds.parent(jnt, jntPar) childsOfJaw = ['lipLower', 'mouthCorner'] if name in childsOfJaw: par = jawCtrl.ctrlEnd else: par = faceCtrlsGrp.name ctrl = ctrlFn.ctrl(name='{}{}'.format(extraName, name), guide=jnt, rig=self.rig, side=side, parent=par, scaleOffset=self.rig.scaleOffset) if name == 'mouthCorner': constr = cmds.parentConstraint(jawCtrl.ctrlEnd, faceCtrlsGrp.name, ctrl.offsetGrps[0].name, mo=1)[0] cmds.setAttr('{}.interpType'.format(constr), 2) ctrl.modifyShape(shape='pin', scale=(0.2, 0.2, 0.2), rotation=(-90, 0, 0), mirror=True, color=11) ## constrain ctrl.constrain(jnt) ctrl.constrain(jnt, typ='scale') cmds.delete('{}_{}faceJnts{}'.format(self.side, extraName, suffix['group']))
def createNewShader(bump=False, sss=False, disp=True): """ Create a new aiStandardSurface shader with colour corrects and aiImage nodes for each important input. [Args]: bump (bool) - Toggles creating the bump map nodes sss (bool) - Toggles creating the sss map nodes disp (bool) - Toggles creating the displacement map nodes [Returns]: True """ name = fileFn.textAssetNamePrompt() if not name: return False shad = utils.newNode('aiStandardSurface', name=name, side='ai', skipNum=True, shaderNode='shader') sg = utils.newNode('shadingEngine', name=name, side='ai', skipNum=True) sg.connect('surfaceShader', '{}.outColor'.format(shad.name), 'to') nodesToMake = [ ('diffuse', 'outColor', 'baseColor'), ('spc', 'outColorR', 'specular'), ('spcRough', 'outColorR', 'specularRoughness'), ] if sss: nodesToMake.append(('sss', 'outColor', 'subsurfaceColor')) for extraName, fromAttr, destAttr in nodesToMake: ccNd = utils.newNode('aiColorCorrect', name='{}_{}'.format(name, extraName), side='ai', skipNum=True, shaderNode='utility') ccNd.connect(fromAttr, '{}.{}'.format(shad.name, destAttr), 'from') imgNd = utils.newNode('aiImage', name='{}_{}'.format(name, extraName), side='ai', skipNum=True, shaderNode='texture') imgNd.connect('outColor', '{}.input'.format(ccNd.name), 'from') if bump: bumpNd = utils.newNode('bump2d', name=name, side='ai', skipNum=True, shaderNode='utility') bumpNd.connect('outNormal', '{}.normalCamera'.format(shad.name)) bumpImg = utils.newNode('aiImage', name='{}_bump'.format(name), side='ai', skipNum=True, shaderNode='texture') bumpImg.connect('outColorR', '{}.bumpValue'.format(bumpNd.name)) if disp: displacementNd = utils.newNode('displacementShader', name=name, side='ai', skipNum=True, shaderNode='shader') displacementNd.connect('displacement', '{}.displacementShader'.format(sg.name)) displacementImgNd = utils.newNode('aiImage', name='{}_disp'.format(name), side='ai', skipNum=True, shaderNode='texture') displacementImgNd.connect( 'outColorR', '{}.displacement'.format(displacementNd.name)) return True
def create(self, geo, worldSpace=False): meshes = cmds.listRelatives(geo, f=1, ni=1, s=1, type='mesh') if not meshes: cmds.warning('No Geometry Selected. Skipping.') return False nucleus = mel.eval('getActiveNucleusNode(false, true);') self.clothNodes = [] for mesh in meshes: conns = cmds.listConnections(mesh, sh=1, type='nBase') if not conns: meshTforms = mel.eval('listTransforms("{}")'.format(mesh)) tform = meshTforms[0] nCloth = utils.newNode('nCloth', name=self.name, side=self.side) mel.eval('hideParticleAttrs("{}")'.format(nCloth.name)) self.clothNodes.append(nCloth) nCloth.connect('currentTime', 'time1.outTime', mode='to') wrapPlugs = cmds.listConnections('{}.worldMesh'.format(mesh), d=1, p=1, sh=1, type='wrap') nCloth.connect('inputMesh', '{}.worldMesh'.format(mesh), mode='to') oldMeshName = mesh.rsplit('|')[-1] # newMeshName = '{}_{}InputMesh_{}'.format(mesh.split('_', 1)[0], self.name, # mesh.rsplit('_', 1)[-1]) newMeshName = utils.setupName('{}InputMesh'.format(self.name), suffix='_{}'.format( oldMeshName.rsplit('_')[-1]), side=oldMeshName.split('_')[0]) print newMeshName mesh = cmds.rename(mesh, newMeshName) outMesh = utils.newNode('mesh', name='{}OutputMesh'.format(self.name), side=self.side) outMesh.renameNode(oldMeshName) if not worldSpace: cmds.parent(outMesh.name, tform, s=1, r=1) cmds.delete(outMesh.transform) nCloth.setAttr('localSpaceOutput', True) shadCons = cmds.listConnections( '{}.instObjGroups[0]'.format(mesh), d=1, sh=1, type='shadingEngine') # if len(shadCons) > 0: if shadCons: cmds.hyperShade(outMesh.name, assign=shadCons[0]) else: cmds.sets(outMesh.name, add='initialShadingGroup') outMesh.setAttr('quadSplit', 0) nCloth.connect('outputMesh', '{}.inMesh'.format(outMesh.name), mode='from') mel.eval('addActiveToNSystem("{}", "{}")'.format( nCloth.name, nucleus)) nCloth.connect('startFrame', '{}.startFrame'.format(nucleus), mode='to') cmds.setAttr('{}.intermediateObject'.format(mesh), 1) clothTforms = mel.eval('listTransforms "{}"'.format( nCloth.name)) cmds.setAttr('{}.translate'.format(clothTforms[0]), l=True) cmds.setAttr('{}.rotate'.format(clothTforms[0]), l=True) cmds.setAttr('{}.scale'.format(clothTforms[0]), l=True) ## todo: add shit about thickness for collisions if wrapPlugs: mel.eval( 'if( !`exists transferWrapConns` ){ source "removeNCloth.mel"; } transferWrapConns( "' + wrapPlugs + '", "' + outMesh.name + '" );') return True