def createIrisPupilSetup(self, s, side, type, codeName, sec, jointLabelNumber, *args): ''' Predefined function to add Iris or Pupil setup. Returns control. ''' # declare cv guides: cvLoc = side+self.userGuideName+"_Guide_"+type.capitalize()+"Loc" # creating joint: mainJnt = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName][codeName]+"_1_Jnt", scaleCompensate=False) cmds.addAttr(mainJnt, longName='dpAR_joint', attributeType='float', keyable=False) utils.setJointLabel(mainJnt, jointLabelNumber, 18, self.userGuideName+"_"+self.langDic[self.langName][codeName]+"_1") # joint position: cmds.delete(cmds.parentConstraint(cvLoc, mainJnt, maintainOffset=False)) # create end joint: endJoint = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName][codeName]+"_JEnd", scaleCompensate=False) cmds.delete(cmds.parentConstraint(mainJnt, endJoint, maintainOffset=False)) cmds.setAttr(endJoint+".translateZ", 1) # creating control: if type == IRIS: ctrlId = "id_012_EyeIris" else: ctrlId = "id_013_EyePupil" ctrl = self.ctrls.cvControl(ctrlId, side+self.userGuideName+"_"+self.langDic[self.langName][codeName]+"_1_Ctrl", r=(self.ctrlRadius*0.3), d=self.curveDegree) utils.originedFrom(objName=ctrl, attrString=self.base+";"+self.guide) cmds.makeIdentity(ctrl, rotate=True, apply=True) # create constraints and arrange hierarchy: ctrlZero = utils.zeroOut([ctrl]) cmds.delete(cmds.parentConstraint(cvLoc, ctrlZero[0], maintainOffset=False)) cmds.parent(ctrlZero[0], self.baseEyeCtrl) # fixing flip mirror: if s == 1: if cmds.getAttr(self.moduleGrp+".flip") == 1: if not "X" == cmds.getAttr(self.moduleGrp+".aimDirectionName"): cmds.setAttr(ctrlZero[0]+".scaleX", -1) else: cmds.setAttr(ctrlZero[0]+".scaleX", 1) if not "Y" == cmds.getAttr(self.moduleGrp+".aimDirectionName"): cmds.setAttr(ctrlZero[0]+".scaleY", -1) else: cmds.setAttr(ctrlZero[0]+".scaleY", 1) if not "Z" == cmds.getAttr(self.moduleGrp+".aimDirectionName"): cmds.setAttr(ctrlZero[0]+".scaleZ", -1) else: cmds.setAttr(ctrlZero[0]+".scaleZ", 1) cmds.parentConstraint(self.fkEyeCtrl, ctrlZero[0], maintainOffset=True, name=ctrlZero[0]+"_ParentConstraint") cmds.scaleConstraint(self.fkEyeCtrl, ctrlZero[0], maintainOffset=True, name=ctrlZero[0]+"_ScaleConstraint") cmds.parent(mainJnt, self.jnt) cmds.parentConstraint(ctrl, mainJnt, maintainOffset=False, name=mainJnt+"_ParentConstraint") cmds.scaleConstraint(ctrl, mainJnt, maintainOffset=True, name=mainJnt+"_ScaleConstraint") return ctrl
def createEyelidJoints(self, side, lid, middle, cvEyelidLoc, jointLabelNumber, *args): ''' Create the eyelid joints to be used in the needed setup. Returns EyelidBaseJxt and EyelidJnt created for rotate and skinning. ''' # declating a concatenated name used for base to compose: baseName = side+self.userGuideName+"_"+self.langDic[self.langName][lid]+"_"+self.langDic[self.langName]['c042_eyelid']+middle # creating joints: eyelidBaseZeroJxt = cmds.joint(name=baseName+"_Base_Zero_Jxt", rotationOrder="yzx", scaleCompensate=False) eyelidBaseJxt = cmds.joint(name=baseName+"_Base_Jxt", rotationOrder="yzx", scaleCompensate=False) eyelidZeroJxt = cmds.joint(name=baseName+"_Zero_Jxt", rotationOrder="yzx", scaleCompensate=False) eyelidJnt = cmds.joint(name=baseName+"_Jnt", rotationOrder="yzx", scaleCompensate=False) cmds.addAttr(eyelidJnt, longName='dpAR_joint', attributeType='float', keyable=False) utils.setJointLabel(eyelidJnt, jointLabelNumber, 18, self.userGuideName+"_"+self.langDic[self.langName][lid]+"_"+self.langDic[self.langName]['c042_eyelid']+middle) cmds.select(eyelidZeroJxt) eyelidSupportJxt = cmds.joint(name=baseName+"_Jxt", rotationOrder="yzx", scaleCompensate=False) cmds.setAttr(eyelidSupportJxt+".translateX", self.ctrlRadius*0.1) # positioning and orienting correctely eyelid joints: cmds.delete(cmds.aimConstraint(cvEyelidLoc, eyelidBaseZeroJxt, aimVector=(0,0,1), worldUpType="objectrotation", worldUpObject=self.eyelidJxt)) cmds.delete(cmds.parentConstraint(cvEyelidLoc, eyelidZeroJxt, mo=False)) cmds.setAttr(eyelidZeroJxt+".rotateX", 0) cmds.setAttr(eyelidZeroJxt+".rotateY", 0) cmds.setAttr(eyelidZeroJxt+".rotateZ", 0) cmds.select(self.eyelidJxt) return eyelidBaseJxt, eyelidJnt
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # declare lists to store names and attributes: self.steeringCtrlList = [] # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [ self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_' ] for s, side in enumerate(sideList): duplicated = cmds.duplicate( self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side + self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename( self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 0: for axis in self.mirrorAxis: gotValue = cmds.getAttr( side + self.userGuideName + "_Guide_Base.translate" + axis) flipedValue = gotValue * (-2) cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.translate' + axis, flipedValue) else: for axis in self.mirrorAxis: cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True) #for Maya2012: self.userGuideName+'_'+self.moduleGrp+"_Grp" # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # run for all sides for s, side in enumerate(sideList): self.base = side + self.userGuideName + '_Guide_Base' cmds.select(clear=True) # declare guide: self.guide = side + self.userGuideName + "_Guide_JointLoc1" self.cvEndJoint = side + self.userGuideName + "_Guide_JointEnd" self.radiusGuide = side + self.userGuideName + "_Guide_Base_RadiusCtrl" # create a joint: self.jnt = cmds.joint(name=side + self.userGuideName + "_1_Jnt", scaleCompensate=False) cmds.addAttr(self.jnt, longName='dpAR_joint', attributeType='float', keyable=False) self.endJoint = cmds.joint(name=side + self.userGuideName + "_JEnd", radius=0.5) # joint labelling: utils.setJointLabel(self.jnt, s + jointLabelAdd, 18, self.userGuideName + "_1") # create a control: self.steeringCtrl = self.ctrls.cvControl( "id_065_SteeringWheel", side + self.userGuideName + "_" + self.langDic[self.langName]['m158_steering'] + "_Ctrl", r=self.ctrlRadius, d=self.curveDegree) self.mainCtrl = self.ctrls.cvControl( "id_066_SteeringMain", side + self.userGuideName + "_" + self.langDic[self.langName]['c058_main'] + "_Ctrl", r=self.ctrlRadius, d=self.curveDegree) utils.originedFrom(objName=self.steeringCtrl, attrString=self.guide) utils.originedFrom(objName=self.mainCtrl, attrString=self.base + ";" + self.cvEndJoint + ";" + self.radiusGuide) self.steeringCtrlList.append(self.steeringCtrl) # position and orientation of joint and control: cmds.delete( cmds.parentConstraint(self.guide, self.jnt, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.guide, self.steeringCtrl, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvEndJoint, self.mainCtrl, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvEndJoint, self.endJoint, maintainOffset=False)) cmds.setAttr(self.endJoint + ".translateY", 1) # zeroOut controls: zeroOutCtrlGrpList = utils.zeroOut( [self.steeringCtrl, self.mainCtrl]) # hide visibility attribute: self.ctrls.setLockHide( [self.steeringCtrl], ['tx', 'ty', 'tz', 'rx', 'ry', 'sx', 'sy', 'sz', 'v']) # fixing flip mirror: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: cmds.setAttr(zeroOutCtrlGrpList[0] + ".scaleX", -1) cmds.setAttr(zeroOutCtrlGrpList[0] + ".scaleY", -1) cmds.setAttr(zeroOutCtrlGrpList[0] + ".scaleZ", -1) cmds.addAttr(self.steeringCtrl, longName='scaleCompensate', attributeType="bool", keyable=False) cmds.setAttr(self.steeringCtrl + ".scaleCompensate", 1, channelBox=True) cmds.connectAttr(self.steeringCtrl + ".scaleCompensate", self.jnt + ".segmentScaleCompensate", force=True) # integrating setup: cmds.addAttr( self.steeringCtrl, longName=self.langDic[self.langName]['c071_limit'], defaultValue=500, attributeType="float", keyable=False) cmds.addAttr( self.steeringCtrl, longName=self.langDic[self.langName]['c049_intensity'], min=0, defaultValue=0.8, attributeType="float", keyable=False) cmds.addAttr( self.steeringCtrl, longName=self.langDic[self.langName]['c070_steering'], attributeType="float", keyable=False) cmds.setAttr(self.steeringCtrl + "." + self.langDic[self.langName]['c071_limit'], 500, channelBox=True) cmds.setAttr(self.steeringCtrl + "." + self.langDic[self.langName]['c049_intensity'], 0.8, channelBox=True) self.steeringUnitMD = cmds.createNode( 'multiplyDivide', name=side + self.userGuideName + "_Unit_MD") self.steeringInvertMD = cmds.createNode( 'multiplyDivide', name=side + self.userGuideName + "_Rotate_MD") self.steeringMD = cmds.createNode('multiplyDivide', name=side + self.userGuideName + "_MD") cmds.setAttr(self.steeringInvertMD + ".input2X", 0.1) cmds.setAttr(self.steeringUnitMD + ".input2X", -1) cmds.transformLimits(self.steeringCtrl, enableRotationZ=(1, 1)) cmds.connectAttr(self.steeringCtrl + "." + self.langDic[self.langName]['c071_limit'], self.steeringUnitMD + ".input1X", force=True) cmds.connectAttr(self.steeringUnitMD + ".outputX", self.steeringCtrl + ".minRotLimit.minRotZLimit", force=True) cmds.connectAttr(self.steeringCtrl + "." + self.langDic[self.langName]['c071_limit'], self.steeringCtrl + ".maxRotLimit.maxRotZLimit", force=True) cmds.connectAttr(self.steeringCtrl + ".rotateZ", self.steeringInvertMD + ".input1X", force=True) cmds.connectAttr(self.steeringInvertMD + ".outputX", self.steeringMD + ".input1X", force=True) cmds.connectAttr(self.steeringCtrl + "." + self.langDic[self.langName]['c049_intensity'], self.steeringMD + ".input2X", force=True) cmds.connectAttr(self.steeringMD + ".outputX", self.steeringCtrl + "." + self.langDic[self.langName]['c070_steering'], force=True) # grouping: cmds.parent(zeroOutCtrlGrpList[0], self.mainCtrl) # create parentConstraint from steeringCtrl to jnt: cmds.parentConstraint(self.steeringCtrl, self.jnt, maintainOffset=False, name=self.jnt + "_PaC") # create scaleConstraint from steeringCtrl to jnt: cmds.scaleConstraint(self.steeringCtrl, self.jnt, maintainOffset=True, name=self.jnt + "_ScC") # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group( zeroOutCtrlGrpList[1], name=side + self.userGuideName + "_Control_Grp") self.toScalableHookGrp = cmds.group( side + self.userGuideName + "_1_Jnt", name=side + self.userGuideName + "_Joint_Grp") self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, name=side + self.userGuideName + "_Grp") # create a locator in order to avoid delete static group loc = cmds.spaceLocator(name=side + self.userGuideName + "_DO_NOT_DELETE_PLEASE_Loc")[0] cmds.parent(loc, self.toStaticHookGrp, absolute=True) cmds.setAttr(loc + ".visibility", 0) self.ctrls.setLockHide([loc], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' ]) # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count) if hideJoints: cmds.setAttr(self.toScalableHookGrp + ".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # declare lists to store names and attributes: self.mainCtrlList, self.wheelCtrlList, self.steeringGrpList, self.ctrlHookGrpList = [], [], [], [] # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [ self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_' ] for s, side in enumerate(sideList): duplicated = cmds.duplicate( self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side + self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename( self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 0: for axis in self.mirrorAxis: gotValue = cmds.getAttr( side + self.userGuideName + "_Guide_Base.translate" + axis) flipedValue = gotValue * (-2) cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.translate' + axis, flipedValue) else: for axis in self.mirrorAxis: cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True) #for Maya2012: self.userGuideName+'_'+self.moduleGrp+"_Grp" # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # run for all sides for s, side in enumerate(sideList): # declare guides: self.base = side + self.userGuideName + '_Guide_Base' self.cvCenterLoc = side + self.userGuideName + "_Guide_CenterLoc" self.cvFrontLoc = side + self.userGuideName + "_Guide_FrontLoc" self.cvInsideLoc = side + self.userGuideName + "_Guide_InsideLoc" self.cvOutsideLoc = side + self.userGuideName + "_Guide_OutsideLoc" # create a joint: cmds.select(clear=True) self.centerJoint = cmds.joint( name=side + self.userGuideName + "_" + self.langDic[self.langName]['m156_wheel'] + "_Jnt", scaleCompensate=False) cmds.addAttr(self.centerJoint, longName='dpAR_joint', attributeType='float', keyable=False) # joint labelling: utils.setJointLabel( self.centerJoint, s + jointLabelAdd, 18, self.userGuideName + "_" + self.langDic[self.langName]['m156_wheel']) # create end joint: self.endJoint = cmds.joint( name=side + self.userGuideName + "_" + self.langDic[self.langName]['m156_wheel'] + "_JEnd") # create controls: self.wheelCtrl = self.ctrls.cvControl( "id_060_WheelCenter", side + self.userGuideName + "_" + self.langDic[self.langName]['m156_wheel'] + "_Ctrl", r=self.ctrlRadius, d=self.curveDegree) self.mainCtrl = self.ctrls.cvControl( "id_061_WheelMain", side + self.userGuideName + "_" + self.langDic[self.langName]['c058_main'] + "_Ctrl", r=self.ctrlRadius * 0.4, d=self.curveDegree) self.insideCtrl = self.ctrls.cvControl( "id_062_WheelPivot", side + self.userGuideName + "_" + self.langDic[self.langName]['c011_RevFoot_B'].capitalize() + "_Ctrl", r=self.ctrlRadius * 0.2, d=self.curveDegree, rot=(0, 90, 0)) self.outsideCtrl = self.ctrls.cvControl( "id_062_WheelPivot", side + self.userGuideName + "_" + self.langDic[self.langName]['c010_RevFoot_A'].capitalize() + "_Ctrl", r=self.ctrlRadius * 0.2, d=self.curveDegree, rot=(0, 90, 0)) self.mainCtrlList.append(self.mainCtrl) self.wheelCtrlList.append(self.wheelCtrl) # origined from attributes: utils.originedFrom(objName=self.mainCtrl, attrString=self.base + ";" + self.cvCenterLoc + ";" + self.cvFrontLoc + ";" + self.cvInsideLoc + ";" + self.cvOutsideLoc) #utils.originedFrom(objName=self.wheelCtrl, attrString=self.cvCenterLoc) # prepare group to receive steering wheel connection: self.toSteeringGrp = cmds.group( self.insideCtrl, name=side + self.userGuideName + "_" + self.langDic[self.langName]['c070_steering'].capitalize() + "_Grp") cmds.addAttr( self.toSteeringGrp, longName=self.langDic[self.langName]['c070_steering'], attributeType='bool', keyable=True) cmds.addAttr( self.toSteeringGrp, longName=self.langDic[self.langName]['c070_steering'] + self.langDic[self.langName]['m151_invert'], attributeType='bool', keyable=True) cmds.setAttr( self.toSteeringGrp + "." + self.langDic[self.langName]['c070_steering'], 1) self.steeringGrpList.append(self.toSteeringGrp) # position and orientation of joint and control: cmds.delete( cmds.parentConstraint(self.cvCenterLoc, self.centerJoint, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvFrontLoc, self.endJoint, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvCenterLoc, self.wheelCtrl, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvCenterLoc, self.mainCtrl, maintainOffset=False)) if s == 1 and cmds.getAttr(self.moduleGrp + ".flip") == 1: cmds.move(self.ctrlRadius, self.mainCtrl, moveY=True, relative=True, objectSpace=True, worldSpaceDistance=True) else: cmds.move(-self.ctrlRadius, self.mainCtrl, moveY=True, relative=True, objectSpace=True, worldSpaceDistance=True) cmds.delete( cmds.parentConstraint(self.cvInsideLoc, self.toSteeringGrp, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvOutsideLoc, self.outsideCtrl, maintainOffset=False)) # zeroOut controls: zeroGrpList = utils.zeroOut([ self.mainCtrl, self.wheelCtrl, self.toSteeringGrp, self.outsideCtrl ]) wheelAutoGrp = utils.zeroOut([self.wheelCtrl]) wheelAutoGrp = cmds.rename( wheelAutoGrp, side + self.userGuideName + "_" + self.langDic[self.langName]['m156_wheel'] + "_Auto_Grp") # fixing flip mirror: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: for zeroOutGrp in zeroGrpList: cmds.setAttr(zeroOutGrp + ".scaleX", -1) cmds.setAttr(zeroOutGrp + ".scaleY", -1) cmds.setAttr(zeroOutGrp + ".scaleZ", -1) cmds.addAttr(self.wheelCtrl, longName='scaleCompensate', attributeType="bool", keyable=False) cmds.setAttr(self.wheelCtrl + ".scaleCompensate", 1, channelBox=True) cmds.connectAttr(self.wheelCtrl + ".scaleCompensate", self.centerJoint + ".segmentScaleCompensate", force=True) # hide visibility attributes: self.ctrls.setLockHide( [self.mainCtrl, self.insideCtrl, self.outsideCtrl], ['v']) self.ctrls.setLockHide( [self.wheelCtrl], ['tx', 'ty', 'tz', 'rx', 'ry', 'sx', 'sy', 'sz', 'v']) # grouping: cmds.parentConstraint(self.wheelCtrl, self.centerJoint, maintainOffset=False, name=self.centerJoint + "_ParentConstraint") cmds.scaleConstraint(self.wheelCtrl, self.centerJoint, maintainOffset=True, name=self.centerJoint + "_ScaleConstraint") cmds.parent(zeroGrpList[1], self.mainCtrl, absolute=True) cmds.parent(zeroGrpList[0], self.outsideCtrl, absolute=True) cmds.parent(zeroGrpList[3], self.insideCtrl, absolute=True) # add attributes: cmds.addAttr( self.wheelCtrl, longName=self.langDic[self.langName]['c047_autoRotate'], attributeType="bool", defaultValue=1, keyable=True) cmds.addAttr( self.wheelCtrl, longName=self.langDic[self.langName]['c068_startFrame'], attributeType="long", defaultValue=1, keyable=False) cmds.addAttr( self.wheelCtrl, longName=self.langDic[self.langName]['c067_radius'], attributeType="float", min=0.01, defaultValue=self.ctrlRadius, keyable=True) cmds.addAttr( self.wheelCtrl, longName=self.langDic[self.langName]['c069_radiusScale'], attributeType="float", defaultValue=1, keyable=False) cmds.addAttr( self.wheelCtrl, longName=self.langDic[self.langName]['c021_showControls'], attributeType="long", min=0, max=1, defaultValue=0, keyable=True) cmds.addAttr( self.wheelCtrl, longName=self.langDic[self.langName]['c070_steering'], attributeType="bool", defaultValue=0, keyable=True) cmds.addAttr( self.wheelCtrl, longName=self.langDic[self.langName]['i037_to'] + self.langDic[self.langName]['c070_steering'].capitalize(), attributeType="float", defaultValue=0, keyable=False) cmds.addAttr( self.wheelCtrl, longName=self.langDic[self.langName]['c070_steering'] + self.langDic[self.langName]['c053_invert'].capitalize(), attributeType="long", min=0, max=1, defaultValue=1, keyable=False) cmds.addAttr( self.wheelCtrl, longName=self.langDic[self.langName]['c093_tryKeepUndo'], attributeType="long", min=0, max=1, defaultValue=1, keyable=False) # get stored values by user: startFrameValue = cmds.getAttr(self.moduleGrp + ".startFrame") steeringValue = cmds.getAttr(self.moduleGrp + ".steering") showControlsValue = cmds.getAttr(self.moduleGrp + ".showControls") cmds.setAttr(self.wheelCtrl + "." + self.langDic[self.langName]['c068_startFrame'], startFrameValue, channelBox=True) cmds.setAttr(self.wheelCtrl + "." + self.langDic[self.langName]['c070_steering'], steeringValue, channelBox=True) cmds.setAttr(self.wheelCtrl + "." + self.langDic[self.langName]['c021_showControls'], showControlsValue, channelBox=True) cmds.setAttr( self.wheelCtrl + "." + self.langDic[self.langName]['c070_steering'] + self.langDic[self.langName]['c053_invert'].capitalize(), 1, channelBox=True) cmds.setAttr(self.wheelCtrl + "." + self.langDic[self.langName]['c093_tryKeepUndo'], 1, channelBox=True) if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: cmds.setAttr( self.wheelCtrl + "." + self.langDic[self.langName]['c070_steering'] + self.langDic[ self.langName]['c053_invert'].capitalize(), 0) # automatic rotation wheel setup: receptSteeringMD = cmds.createNode( 'multiplyDivide', name=side + self.userGuideName + "_" + self.langDic[self.langName]['c070_steering'] + "_MD") inverseSteeringMD = cmds.createNode( 'multiplyDivide', name=side + self.userGuideName + "_" + self.langDic[self.langName]['c070_steering'] + "_Inv_MD") steeringInvCnd = cmds.createNode( 'condition', name=side + self.userGuideName + "_" + self.langDic[self.langName]['c070_steering'] + "_Inv_Cnd") cmds.setAttr(steeringInvCnd + ".colorIfTrueR", 1) cmds.setAttr(steeringInvCnd + ".colorIfFalseR", -1) cmds.connectAttr( self.wheelCtrl + "." + self.langDic[self.langName]['i037_to'] + self.langDic[self.langName]['c070_steering'].capitalize(), receptSteeringMD + ".input1X", force=True) cmds.connectAttr(self.wheelCtrl + "." + self.langDic[self.langName]['c070_steering'], receptSteeringMD + ".input2X", force=True) cmds.connectAttr(receptSteeringMD + ".outputX", inverseSteeringMD + ".input1X", force=True) cmds.connectAttr(steeringInvCnd + ".outColorR", inverseSteeringMD + ".input2X", force=True) cmds.connectAttr( self.wheelCtrl + "." + self.langDic[self.langName]['c070_steering'] + self.langDic[self.langName]['c053_invert'].capitalize(), steeringInvCnd + ".firstTerm", force=True) cmds.connectAttr(inverseSteeringMD + ".outputX", self.toSteeringGrp + ".rotateY", force=True) # create locators (frontLoc to get direction and oldLoc to store wheel old position): self.frontLoc = cmds.spaceLocator( name=side + self.userGuideName + "_" + self.langDic[self.langName]['m156_wheel'] + "_Front_Loc")[0] self.oldLoc = cmds.spaceLocator( name=side + self.userGuideName + "_" + self.langDic[self.langName]['m156_wheel'] + "_Old_Loc")[0] cmds.delete( cmds.parentConstraint(self.cvFrontLoc, self.frontLoc, maintainOffset=False)) cmds.parent(self.frontLoc, self.mainCtrl) cmds.delete( cmds.parentConstraint(self.cvCenterLoc, self.oldLoc, maintainOffset=False)) cmds.setAttr(self.frontLoc + ".visibility", 0, lock=True) cmds.setAttr(self.oldLoc + ".visibility", 0, lock=True) # this wheel auto group locator could be replaced by a decomposeMatrix to get the translation in world space of the Wheel_Auto_Ctrl_Grp instead: self.wheelAutoGrpLoc = cmds.spaceLocator( name=side + self.userGuideName + "_" + self.langDic[self.langName]['m156_wheel'] + "_Auto_Loc")[0] cmds.pointConstraint(wheelAutoGrp, self.wheelAutoGrpLoc, maintainOffset=False, name=self.wheelAutoGrpLoc + "_PointConstraint") cmds.setAttr(self.wheelAutoGrpLoc + ".visibility", 0, lock=True) expString = "if ("+self.wheelCtrl+"."+self.langDic[self.langName]['c047_autoRotate']+" == 1) {"+\ "\nif ("+self.wheelCtrl+"."+self.langDic[self.langName]['c093_tryKeepUndo']+" == 1) { undoInfo -stateWithoutFlush 0; };"+\ "\nfloat $radius = "+self.wheelCtrl+"."+self.langDic[self.langName]['c067_radius']+" * "+self.wheelCtrl+"."+self.langDic[self.langName]['c069_radiusScale']+\ ";\nvector $moveVectorOld = `xform -q -ws -t \""+self.oldLoc+\ "\"`;\nvector $moveVector = << "+self.wheelAutoGrpLoc+".translateX, "+self.wheelAutoGrpLoc+".translateY, "+self.wheelAutoGrpLoc+".translateZ >>;"+\ "\nvector $dirVector = `xform -q -ws -t \""+self.frontLoc+\ "\"`;\nvector $wheelVector = ($dirVector - $moveVector);"+\ "\nvector $motionVector = ($moveVector - $moveVectorOld);"+\ "\nfloat $distance = mag($motionVector);"+\ "\n$dot = dotProduct($motionVector, $wheelVector, 1);\n"+\ wheelAutoGrp+".rotateZ = "+wheelAutoGrp+".rotateZ - 360 / (6.283*$radius) * ($dot*$distance);"+\ "\nxform -t ($moveVector.x) ($moveVector.y) ($moveVector.z) "+self.oldLoc+\ ";\nif (frame == "+self.wheelCtrl+"."+self.langDic[self.langName]['c068_startFrame']+") { "+wheelAutoGrp+".rotateZ = 0; };"+\ "\nif ("+self.wheelCtrl+"."+self.langDic[self.langName]['c093_tryKeepUndo']+" == 1) { undoInfo -stateWithoutFlush 1; };};" # expression: cmds.expression(name=side + self.userGuideName + "_" + self.langDic[self.langName]['m156_wheel'] + "_Exp", object=self.frontLoc, string=expString) self.ctrls.setLockHide([self.frontLoc, self.wheelAutoGrpLoc], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' ]) # deformers: self.loadedGeo = cmds.getAttr(self.moduleGrp + ".geo") # geometry holder: self.geoHolder = cmds.polyCube( name=side + self.userGuideName + "_" + self.langDic[self.langName]['c046_holder'] + "_Geo", constructionHistory=False)[0] cmds.delete( cmds.parentConstraint(self.cvCenterLoc, self.geoHolder, maintainOffset=False)) cmds.setAttr(self.geoHolder + ".visibility", 0, lock=True) # skinning: cmds.skinCluster(self.centerJoint, self.geoHolder, toSelectedBones=True, dropoffRate=4.0, maximumInfluences=3, skinMethod=0, normalizeWeights=1, removeUnusedInfluence=False, name=side + self.userGuideName + "_" + self.langDic[self.langName]['c046_holder'] + "_SC") if self.loadedGeo: if cmds.objExists(self.loadedGeo): baseName = utils.extractSuffix(self.loadedGeo) skinClusterName = baseName + "_SC" if "|" in skinClusterName: skinClusterName = skinClusterName[skinClusterName. rfind("|") + 1:] try: cmds.skinCluster(self.centerJoint, self.loadedGeo, toSelectedBones=True, dropoffRate=4.0, maximumInfluences=3, skinMethod=0, normalizeWeights=1, removeUnusedInfluence=False, name=skinClusterName) except: childList = cmds.listRelatives(self.loadedGeo, children=True, allDescendents=True) if childList: for item in childList: itemType = cmds.objectType(item) if itemType == "mesh" or itemType == "nurbsSurface": try: skinClusterName = utils.extractSuffix( item) + "_SC" cmds.skinCluster( self.centerJoint, item, toSelectedBones=True, dropoffRate=4.0, maximumInfluences=3, skinMethod=0, normalizeWeights=1, removeUnusedInfluence=False, name=skinClusterName) except: pass # lattice: latticeList = cmds.lattice(self.geoHolder, divisions=(6, 6, 6), outsideLattice=2, outsideFalloffDistance=1, position=(0, 0, 0), scale=(self.ctrlRadius * 2, self.ctrlRadius * 2, self.ctrlRadius * 2), name=side + self.userGuideName + "_FFD") #[deformer, lattice, base] cmds.scale(self.ctrlRadius * 2, self.ctrlRadius * 2, self.ctrlRadius * 2, latticeList[2]) # clusters: upperClusterList = cmds.cluster( latticeList[1] + ".pt[0:5][4:5][0:5]", relative=True, name=side + self.userGuideName + "_" + self.langDic[self.langName]['c044_upper'] + "_Cls") #[deform, handle] middleClusterList = cmds.cluster( latticeList[1] + ".pt[0:5][2:3][0:5]", relative=True, name=side + self.userGuideName + "_" + self.langDic[self.langName]['m033_middle'] + "_Cls") #[deform, handle] lowerClusterList = cmds.cluster( latticeList[1] + ".pt[0:5][0:1][0:5]", relative=True, name=side + self.userGuideName + "_" + self.langDic[self.langName]['c045_lower'] + "_Cls") #[deform, handle] clusterGrpList = utils.zeroOut([ upperClusterList[1], middleClusterList[1], lowerClusterList[1] ]) clustersGrp = cmds.group(clusterGrpList, name=side + self.userGuideName + "_Clusters_Grp") # deform controls: upperDefCtrl = self.ctrls.cvControl( "id_063_WheelDeform", side + self.userGuideName + "_" + self.langDic[self.langName]['c044_upper'] + "_Ctrl", r=self.ctrlRadius * 0.5, d=self.curveDegree) middleDefCtrl = self.ctrls.cvControl( "id_064_WheelMiddle", side + self.userGuideName + "_" + self.langDic[self.langName]['m033_middle'] + "_Ctrl", r=self.ctrlRadius * 0.5, d=self.curveDegree) lowerDefCtrl = self.ctrls.cvControl( "id_063_WheelDeform", side + self.userGuideName + "_" + self.langDic[self.langName]['c045_lower'] + "_Ctrl", r=self.ctrlRadius * 0.5, d=self.curveDegree, rot=(0, 0, 180)) defCtrlGrpList = utils.zeroOut( [upperDefCtrl, middleDefCtrl, lowerDefCtrl]) defCtrlGrp = cmds.group(defCtrlGrpList, name=side + self.userGuideName + "_Ctrl_Grp") # positions: cmds.delete( cmds.parentConstraint(upperClusterList[1], defCtrlGrpList[0], maintainOffset=False)) cmds.delete( cmds.parentConstraint(middleClusterList[1], defCtrlGrpList[1], maintainOffset=False)) cmds.delete( cmds.parentConstraint(lowerClusterList[1], defCtrlGrpList[2], maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvCenterLoc, latticeList[1], maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvCenterLoc, latticeList[2], maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvCenterLoc, clustersGrp, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.cvCenterLoc, defCtrlGrp, maintainOffset=False)) outsideDist = cmds.getAttr(self.cvOutsideLoc + ".tz") if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: outsideDist = -outsideDist cmds.move(outsideDist, defCtrlGrp, moveZ=True, relative=True, objectSpace=True, worldSpaceDistance=True) self.ctrls.directConnect(upperDefCtrl, upperClusterList[1]) self.ctrls.directConnect(middleDefCtrl, middleClusterList[1]) self.ctrls.directConnect(lowerDefCtrl, lowerClusterList[1]) # grouping deformers: if self.loadedGeo: if cmds.objExists(self.loadedGeo): cmds.lattice(latticeList[0], edit=True, geometry=self.loadedGeo) defGrp = cmds.group(latticeList[1], latticeList[2], clustersGrp, name=side + self.userGuideName + "_Deform_Grp") cmds.parentConstraint(self.mainCtrl, defGrp, maintainOffset=True, name=defGrp + "_ParentConstraint") cmds.scaleConstraint(self.mainCtrl, defGrp, maintainOffset=True, name=defGrp + "_ScaleConstraint") cmds.parent(defCtrlGrp, self.mainCtrl) cmds.connectAttr( self.wheelCtrl + "." + self.langDic[self.langName]['c021_showControls'], defCtrlGrp + ".visibility", force=True) # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group( zeroGrpList[2], name=side + self.userGuideName + "_Control_Grp") self.toScalableHookGrp = cmds.group( self.centerJoint, defGrp, name=side + self.userGuideName + "_Joint_Grp") self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, self.oldLoc, self.wheelAutoGrpLoc, self.geoHolder, name=side + self.userGuideName + "_Grp") # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count) self.ctrlHookGrpList.append(self.toCtrlHookGrp) if hideJoints: cmds.setAttr(self.toScalableHookGrp + ".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # create lists to be integrated: # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp+".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp+".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [self.mirrorNames[0]+'_', self.mirrorNames[len(self.mirrorNames) - 1]+'_'] for s, side in enumerate(sideList): duplicated = cmds.duplicate(self.moduleGrp, name=side+self.userGuideName+'_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side+self.userGuideName+"_"+item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side+self.userGuideName+'_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename(self.mirrorGrp, side+self.userGuideName+'_'+self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: for axis in self.mirrorAxis: cmds.setAttr(side+self.userGuideName+'_'+self.mirrorGrp+'.scale'+axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName+'_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName+"_"+item) self.mirrorGrp = cmds.group(self.userGuideName+'_Guide_Base', name="Guide_Base_Grp", relative=True) # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName+'_'+self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type")+1 # run for all sides for s, side in enumerate(sideList): # redeclaring variables: self.base = side+self.userGuideName+"_Guide_Base" self.cvFootLoc = side+self.userGuideName+"_Guide_Foot" self.cvRFALoc = side+self.userGuideName+"_Guide_RfA" self.cvRFBLoc = side+self.userGuideName+"_Guide_RfB" self.cvRFCLoc = side+self.userGuideName+"_Guide_RfC" self.cvRFDLoc = side+self.userGuideName+"_Guide_RfD" self.cvRFELoc = side+self.userGuideName+"_Guide_RfE" self.cvEndJoint = side+self.userGuideName+"_Guide_JointEnd" # declaring attributes reading from dictionary: ankleRFAttr = self.langDic[self.langName]['c009_leg_extrem'] middleRFAttr = self.langDic[self.langName]['c017_RevFoot_middle'] outsideRFAttr = self.langDic[self.langName]['c010_RevFoot_A'] insideRFAttr = self.langDic[self.langName]['c011_RevFoot_B'] heelRFAttr = self.langDic[self.langName]['c012_RevFoot_C'] toeRFAttr = self.langDic[self.langName]['c013_RevFoot_D'] ballRFAttr = self.langDic[self.langName]['c014_RevFoot_E'] footRFAttr = self.langDic[self.langName]['c015_RevFoot_F'] sideRFAttr = self.langDic[self.langName]['c016_RevFoot_G'] rfRoll = self.langDic[self.langName]['c018_RevFoot_roll'] rfSpin = self.langDic[self.langName]['c019_RevFoot_spin'] rfTurn = self.langDic[self.langName]['c020_RevFoot_turn'] showCtrlsAttr = self.langDic[self.langName]['c021_showControls'] # creating joints: cmds.select(clear=True) self.footJnt = cmds.joint(name=side+self.userGuideName+"_"+ankleRFAttr.capitalize()+"_Jnt") utils.setJointLabel(self.footJnt, s+jointLabelAdd, 18, self.userGuideName+ "_"+ankleRFAttr.capitalize()) self.middleFootJxt = cmds.joint(name=side+self.userGuideName+"_"+middleRFAttr.capitalize()+"_Jxt") self.endJnt = cmds.joint(name=side+self.userGuideName+"_JEnd") cmds.select(clear=True) self.middleFootJnt = cmds.joint(name=side+self.userGuideName+"_"+middleRFAttr.capitalize()+"_Jnt") utils.setJointLabel(self.middleFootJnt, s+jointLabelAdd, 18, self.userGuideName+"_"+middleRFAttr.capitalize()) self.endBJnt = cmds.joint(name=side+self.userGuideName+"B_JEnd") cmds.parent(self.middleFootJnt, self.middleFootJxt) cmds.addAttr(self.footJnt, longName='dpAR_joint', attributeType='float', keyable=False) cmds.addAttr(self.middleFootJnt, longName='dpAR_joint', attributeType='float', keyable=False) cmds.select(clear=True) ''' Deactivate the segment scale compensate on the bone to prevent scaling problem in maya 2016 It will prevent a double scale problem that will come from the upper parent in the rig ''' if (int(cmds.about(version=True)[:4]) >= 2016): cmds.setAttr(self.footJnt+".segmentScaleCompensate", 0) cmds.setAttr(self.middleFootJxt+".segmentScaleCompensate", 0) cmds.setAttr(self.middleFootJnt+".segmentScaleCompensate", 0) # reverse foot controls: self.RFACtrl = self.ctrls.cvControl("id_018_FootReverse", side+self.userGuideName+"_"+outsideRFAttr.capitalize()+"_Ctrl", r=(self.ctrlRadius*0.1), d=self.curveDegree) self.RFBCtrl = self.ctrls.cvControl("id_018_FootReverse", side+self.userGuideName+"_"+insideRFAttr.capitalize()+"_Ctrl", r=(self.ctrlRadius*0.1), d=self.curveDegree) self.RFCCtrl = self.ctrls.cvControl("id_018_FootReverse", side+self.userGuideName+"_"+heelRFAttr.capitalize()+"_Ctrl", r=(self.ctrlRadius*0.1), d=self.curveDegree, dir="+Y", rot=(0, 90, 0)) self.RFDCtrl = self.ctrls.cvControl("id_018_FootReverse", side+self.userGuideName+"_"+toeRFAttr.capitalize()+"_Ctrl", r=(self.ctrlRadius*0.1), d=self.curveDegree, dir="+Y", rot=(0, 90, 0)) self.RFECtrl = self.ctrls.cvControl("id_019_FootReverseE", side+self.userGuideName+"_"+ballRFAttr.capitalize()+"_Ctrl", r=(self.ctrlRadius*0.1), d=self.curveDegree, rot=(0, 90, 0)) # reverse foot groups: self.RFAGrp = cmds.group(self.RFACtrl, name=self.RFACtrl+"_Grp") self.RFBGrp = cmds.group(self.RFBCtrl, name=self.RFBCtrl+"_Grp") self.RFCGrp = cmds.group(self.RFCCtrl, name=self.RFCCtrl+"_Grp") self.RFDGrp = cmds.group(self.RFDCtrl, name=self.RFDCtrl+"_Grp") self.RFEGrp = cmds.group(self.RFECtrl, name=self.RFECtrl+"_Grp") rfGrpList = [self.RFAGrp, self.RFBGrp, self.RFCGrp, self.RFDGrp, self.RFEGrp] self.ballRFList.append(self.RFEGrp) # putting groups in the correct place: tempToDelA = cmds.parentConstraint(self.cvFootLoc, self.footJnt, maintainOffset=False) tempToDelB = cmds.parentConstraint(self.cvRFELoc, self.middleFootJxt, maintainOffset=False) tempToDelC = cmds.parentConstraint(self.cvEndJoint, self.endJnt, maintainOffset=False) tempToDelD = cmds.parentConstraint(self.cvEndJoint, self.endBJnt, maintainOffset=False) tempToDelE = cmds.parentConstraint(self.cvRFALoc, self.RFAGrp, maintainOffset=False) tempToDelF = cmds.parentConstraint(self.cvRFBLoc, self.RFBGrp, maintainOffset=False) tempToDelG = cmds.parentConstraint(self.cvRFCLoc, self.RFCGrp, maintainOffset=False) tempToDelH = cmds.parentConstraint(self.cvRFDLoc, self.RFDGrp, maintainOffset=False) tempToDelI = cmds.parentConstraint(self.cvRFELoc, self.RFEGrp, maintainOffset=False) cmds.delete(tempToDelA, tempToDelB, tempToDelC, tempToDelD, tempToDelE, tempToDelF, tempToDelG, tempToDelH, tempToDelI) # mounting hierarchy: cmds.parent(self.RFBGrp, self.RFACtrl) cmds.parent(self.RFCGrp, self.RFBCtrl) cmds.parent(self.RFDGrp, self.RFCCtrl) cmds.parent(self.RFEGrp, self.RFDCtrl) # reverse foot zero out groups: self.RFEZero = utils.zeroOut([self.RFEGrp])[0] self.RFDZero = utils.zeroOut([self.RFDGrp])[0] self.RFCZero = utils.zeroOut([self.RFCGrp])[0] self.RFBZero = utils.zeroOut([self.RFBGrp])[0] self.RFAZero = utils.zeroOut([self.RFAGrp])[0] self.RFAZeroExtra = utils.zeroOut([self.RFAZero])[0] rfJointZeroList = [self.RFAZero, self.RFBZero, self.RFCZero, self.RFDZero, self.RFEZero] # fixing side rool rotation order: cmds.setAttr(self.RFBZero+".rotateOrder", 5) # creating ikHandles: ikHandleAnkleList = cmds.ikHandle(name=side+self.userGuideName+"_"+ankleRFAttr.capitalize()+"_IkHandle", startJoint=self.footJnt, endEffector=self.middleFootJxt, solver='ikSCsolver') ikHandleMiddleList = cmds.ikHandle(name=side+self.userGuideName+"_"+middleRFAttr.capitalize()+"_IkHandle", startJoint=self.middleFootJxt, endEffector=self.endJnt, solver='ikSCsolver') cmds.rename(ikHandleAnkleList[1], ikHandleAnkleList[0]+"_Effector") cmds.rename(ikHandleMiddleList[1], ikHandleMiddleList[0]+"_Effector") cmds.setAttr(ikHandleAnkleList[0]+'.visibility', 0) cmds.setAttr(ikHandleMiddleList[0]+'.visibility', 0) # creating Fk controls: self.footCtrl = self.ctrls.cvControl("id_020_FootFk", side+self.userGuideName+"_"+self.langDic[self.langName]['c009_leg_extrem']+"_Ctrl", r=(self.ctrlRadius*0.5), d=self.curveDegree, dir="+Z") self.footCtrlList.append(self.footCtrl) cmds.setAttr(self.footCtrl+".rotateOrder", 1) self.revFootCtrlShapeList.append(cmds.listRelatives(self.footCtrl, children=True, type='nurbsCurve')[0]) self.middleFootCtrl = self.ctrls.cvControl("id_021_FootMiddle", side+self.userGuideName+"_"+self.langDic[self.langName]['c017_RevFoot_middle'].capitalize()+"_Ctrl", r=(self.ctrlRadius*0.5), d=self.curveDegree) cmds.setAttr(self.middleFootCtrl+'.overrideEnabled', 1) cmds.setAttr(self.middleFootCtrl+".rotateOrder", 4) tempToDelA = cmds.parentConstraint(self.cvFootLoc, self.footCtrl, maintainOffset=False) tempToDelB = cmds.parentConstraint(self.cvRFELoc, self.middleFootCtrl, maintainOffset=False) cmds.delete(tempToDelA, tempToDelB) if s == 1: cmds.setAttr(self.middleFootCtrl+".scaleX", -1) cmds.setAttr(self.middleFootCtrl+".scaleY", -1) cmds.setAttr(self.middleFootCtrl+".scaleZ", -1) self.footCtrlZeroList = utils.zeroOut([self.footCtrl, self.middleFootCtrl]) self.middleFootCtrlList.append(self.middleFootCtrl) # mount hierarchy: cmds.parent(self.footCtrlZeroList[1], self.RFDCtrl, absolute=True) cmds.parent(ikHandleMiddleList[0], self.middleFootCtrl, absolute=True) self.toLimbIkHandleGrp = cmds.group(empty=True, name=side+self.userGuideName+"_"+self.langDic[self.langName]['c009_leg_extrem']+"_Grp") self.toLimbIkHandleGrpList.append(self.toLimbIkHandleGrp) cmds.parent(ikHandleAnkleList[0], self.toLimbIkHandleGrp, self.RFECtrl, absolute=True) cmds.makeIdentity(self.toLimbIkHandleGrp, apply=True, translate=True, rotate=True, scale=True) parentConst = cmds.parentConstraint(self.RFECtrl, self.footJnt, maintainOffset=True, name=self.footJnt+"_ParentConstraint")[0] self.parentConstList.append(parentConst) self.footJntList.append(self.footJnt) cmds.parent(self.RFAZeroExtra, self.footCtrl, absolute=True) scaleConst = cmds.scaleConstraint(self.footCtrl, self.footJnt, maintainOffset=True, name=self.footJnt+"_ScaleConstraint") self.scaleConstList.append(scaleConst) cmds.parentConstraint(self.middleFootCtrl, self.middleFootJnt, maintainOffset=True, name=self.middleFootJnt+"_ParentConstraint") cmds.scaleConstraint(self.middleFootCtrl, self.middleFootJnt, maintainOffset=True, name=self.middleFootJnt+"_ScaleConstraint") # add attributes to footCtrl and connect them to reverseFoot groups rotation: rfAttrList = [outsideRFAttr, insideRFAttr, heelRFAttr, toeRFAttr, ballRFAttr] rfTypeAttrList = [rfRoll, rfSpin] for j, rfAttr in enumerate(rfAttrList): for t, rfType in enumerate(rfTypeAttrList): if t == 1 and j == (len(rfAttrList) - 1): # create turn attr to ball cmds.addAttr(self.footCtrl, longName=rfAttr+"_"+rfTurn, attributeType='float', keyable=True) cmds.connectAttr(self.footCtrl+"."+rfAttr+"_"+rfTurn, rfGrpList[j]+".rotateZ", force=True) self.reverseFootAttrList.append(rfAttr+"_"+rfTurn) cmds.addAttr(self.footCtrl, longName=rfAttr+"_"+rfType, attributeType='float', keyable=True) self.reverseFootAttrList.append(rfAttr+"_"+rfType) if t == 0: if j > 1: cmds.connectAttr(self.footCtrl+"."+rfAttr+"_"+rfType, rfGrpList[j]+".rotateX", force=True) else: cmds.connectAttr(self.footCtrl+"."+rfAttr+"_"+rfType, rfGrpList[j]+".rotateZ", force=True) else: cmds.connectAttr(self.footCtrl+"."+rfAttr+"_"+rfType, rfGrpList[j]+".rotateY", force=True) # creating the originedFrom attributes (in order to permit integrated parents in the future): utils.originedFrom(objName=self.footCtrl, attrString=self.base+";"+self.cvFootLoc+";"+self.cvRFALoc+";"+self.cvRFBLoc+";"+self.cvRFCLoc+";"+self.cvRFDLoc) utils.originedFrom(objName=self.middleFootCtrl, attrString=self.cvRFELoc+";"+self.cvEndJoint) # creating pre-defined attributes for footRoll and sideRoll attributes: cmds.addAttr(self.footCtrl, longName=footRFAttr+"_"+rfRoll, attributeType='float', keyable=True) cmds.addAttr(self.footCtrl, longName=sideRFAttr+"_"+rfRoll, attributeType='float', keyable=True) # create clampNodes in order to limit the side rotations: sideClamp = cmds.createNode("clamp", name=side+self.userGuideName+"_Side_Clp") # outside values in R cmds.setAttr(sideClamp+".minR", -360) # inside values in G cmds.setAttr(sideClamp+".maxG", 360) # inverting sideRoll values: sideMD = cmds.createNode("multiplyDivide", name=side+self.userGuideName+"_Side_MD") cmds.setAttr(sideMD+".input2X", -1) # connections: cmds.connectAttr(self.footCtrl+"."+sideRFAttr+"_"+rfRoll, sideMD+".input1X", force=True) cmds.connectAttr(sideMD+".outputX", sideClamp+".inputR", force=True) cmds.connectAttr(sideMD+".outputX", sideClamp+".inputG", force=True) cmds.connectAttr(sideClamp+".outputR", self.RFAZero+".rotateZ", force=True) cmds.connectAttr(sideClamp+".outputG", self.RFBZero+".rotateZ", force=True) # for footRoll: footClamp = cmds.createNode("clamp", name=side+self.userGuideName+"_Foot_Clp") # heel values in R cmds.setAttr(footClamp+".minR", -360) cmds.connectAttr(self.footCtrl+"."+footRFAttr+"_"+rfRoll, footClamp+".inputR", force=True) cmds.connectAttr(footClamp+".outputR", self.RFCZero+".rotateX", force=True) # set driven keys cmds.setDrivenKeyframe(self.RFEZero+".rotateX", currentDriver=self.footCtrl+"."+footRFAttr+"_"+rfRoll, driverValue=0, value=0, inTangentType="flat", outTangentType="flat") cmds.setDrivenKeyframe(self.RFEZero+".rotateX", currentDriver=self.footCtrl+"."+footRFAttr+"_"+rfRoll, driverValue=45, value=45, inTangentType="spline", outTangentType="spline") cmds.setDrivenKeyframe(self.RFEZero+".rotateX", currentDriver=self.footCtrl+"."+footRFAttr+"_"+rfRoll, driverValue=200, value=0, inTangentType="flat", outTangentType="flat") cmds.setDrivenKeyframe(self.RFDZero+".rotateX", currentDriver=self.footCtrl+"."+footRFAttr+"_"+rfRoll, driverValue=30, value=0, inTangentType="flat", outTangentType="flat") cmds.setDrivenKeyframe(self.RFDZero+".rotateX", currentDriver=self.footCtrl+"."+footRFAttr+"_"+rfRoll, driverValue=60, value=30, inTangentType="spline", outTangentType="spline") cmds.setDrivenKeyframe(self.RFDZero+".rotateX", currentDriver=self.footCtrl+"."+footRFAttr+"_"+rfRoll, driverValue=360, value=180, inTangentType="flat", outTangentType="flat") # organizing keyable attributes: self.ctrls.setLockHide([self.middleFootCtrl, self.footCtrl], ['v'], l=False) # show or hide reverseFoot controls: cmds.addAttr(self.footCtrl, longName=showCtrlsAttr, attributeType='long', min=0, max=1, defaultValue=1) cmds.setAttr(self.footCtrl+"."+showCtrlsAttr, keyable=False, channelBox=True) showHideCtrlList = [self.RFACtrl, self.RFBCtrl, self.RFCCtrl, self.RFDCtrl] for rfCtrl in showHideCtrlList: rfCtrlShape = cmds.listRelatives(rfCtrl, children=True, type='nurbsCurve')[0] cmds.connectAttr(self.footCtrl+"."+showCtrlsAttr, rfCtrlShape+".visibility", force=True) # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group(self.footCtrlZeroList[0], name=side+self.userGuideName+"_Control_Grp") self.revFootCtrlGrpFinalList.append(self.toCtrlHookGrp) self.toScalableHookGrp = cmds.createNode("transform", name=side+self.userGuideName+"_Joint_Grp") mWorldFoot = cmds.getAttr(self.footJnt+".worldMatrix") cmds.xform(self.toScalableHookGrp, matrix=mWorldFoot, worldSpace=True) cmds.parent(self.footJnt, self.toScalableHookGrp, absolute=True) #Remove the Joint orient to make sure the bone is at the same orientation than it's parent cmds.setAttr(self.footJnt+".jointOrientX", 0) cmds.setAttr(self.footJnt+".jointOrientY", 0) cmds.setAttr(self.footJnt+".jointOrientZ", 0) self.aScalableGrp.append(self.toScalableHookGrp) self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, name=side+self.userGuideName+"_Grp") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp+".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp+".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp+'.dpAR_count', dpAR_count) # create a locator in order to avoid delete static group loc = cmds.spaceLocator(name=side+self.userGuideName+"_DO_NOT_DELETE")[0] cmds.parent(loc, self.toStaticHookGrp, absolute=True) cmds.setAttr(loc+".visibility", 0) self.ctrls.setLockHide([loc], ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']) # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') if hideJoints: cmds.setAttr(self.toScalableHookGrp+".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side+self.userGuideName+'_'+self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [ self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_' ] for s, side in enumerate(sideList): duplicated = cmds.duplicate( self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side + self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename( self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 0: for axis in self.mirrorAxis: gotValue = cmds.getAttr( side + self.userGuideName + "_Guide_Base.translate" + axis) flipedValue = gotValue * (-2) cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.translate' + axis, flipedValue) else: for axis in self.mirrorAxis: cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True) #for Maya2012: self.userGuideName+'_'+self.moduleGrp+"_Grp" # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # run for all sides for s, side in enumerate(sideList): self.base = side + self.userGuideName + '_Guide_Base' # get the number of joints to be created: self.nJoints = cmds.getAttr(self.base + ".nJoints") for n in range(1, self.nJoints + 1): cmds.select(clear=True) # declare guide: self.guide = side + self.userGuideName + "_Guide_JointLoc" + str( n) # create a joint: self.jnt = cmds.joint(name=side + self.userGuideName + "_" + str(n) + "_Jnt", scaleCompensate=False) cmds.addAttr(self.jnt, longName='dpAR_joint', attributeType='float', keyable=False) # joint labelling: utils.setJointLabel(self.jnt, s + jointLabelAdd, 18, self.userGuideName + "_" + str(n)) # create a control: # self.mainCtrl = cmds.circle(name=side+self.userGuideName+"_"+str(n)+"_Ctrl", degree=1, normal=(0, 0, 1), r=self.ctrlRadius, s=6, ch=False)[0] self.mainCtrl = self.ctrls.cvControl( "id_007_FkLine", side + self.userGuideName + "_" + str(n) + "_Ctrl", r=self.ctrlRadius, d=self.curveDegree) if n == 1: utils.originedFrom(objName=self.mainCtrl, attrString=self.base + ";" + self.guide) else: utils.originedFrom(objName=self.mainCtrl, attrString=self.guide) # position and orientation of joint and control: cmds.delete( cmds.parentConstraint(self.guide, self.jnt, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.guide, self.mainCtrl, maintainOffset=False)) # zeroOut controls: zeroOutCtrlGrp = utils.zeroOut([self.mainCtrl])[0] # hide visibility attribute: cmds.setAttr(self.mainCtrl + '.visibility', keyable=False) # fixing flip mirror: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: cmds.setAttr(zeroOutCtrlGrp + ".scaleX", -1) cmds.setAttr(zeroOutCtrlGrp + ".scaleY", -1) cmds.setAttr(zeroOutCtrlGrp + ".scaleZ", -1) cmds.addAttr(self.mainCtrl, longName='scaleCompensate', attributeType="bool", keyable=False) cmds.setAttr(self.mainCtrl + ".scaleCompensate", 1, channelBox=True) cmds.connectAttr(self.mainCtrl + ".scaleCompensate", self.jnt + ".segmentScaleCompensate", force=True) if n == self.nJoints: # create end joint: cmds.select(self.jnt) self.cvEndJoint = side + self.userGuideName + "_Guide_JointEnd" self.endJoint = cmds.joint( name=side + self.userGuideName + "_JEnd") cmds.delete( cmds.parentConstraint(self.cvEndJoint, self.endJoint, maintainOffset=False)) # grouping: for n in range(1, self.nJoints + 1): self.jnt = side + self.userGuideName + "_" + str( n) + "_Jnt" self.mainCtrl = side + self.userGuideName + "_" + str( n) + "_Ctrl" self.zeroCtrl = side + self.userGuideName + "_" + str( n) + "_Ctrl_Zero_Grp" if n > 1: # parent joints as a simple chain (line) self.fatherJnt = side + self.userGuideName + "_" + str( n - 1) + "_Jnt" cmds.parent(self.jnt, self.fatherJnt, absolute=True) # parent zeroCtrl Group to the before mainCtrl: self.fatherCtrl = side + self.userGuideName + "_" + str( n - 1) + "_Ctrl" cmds.parent(self.zeroCtrl, self.fatherCtrl, absolute=True) # create parentConstraint from mainCtrl to jnt: cmds.parentConstraint(self.mainCtrl, self.jnt, maintainOffset=False, name=self.jnt + "_ParentConstraint") # create scaleConstraint from mainCtrl to jnt: cmds.scaleConstraint(self.mainCtrl, self.jnt, maintainOffset=True, name=self.jnt + "_ScaleConstraint") # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group( side + self.userGuideName + "_1_Ctrl_Zero_Grp", name=side + self.userGuideName + "_Control_Grp") self.toScalableHookGrp = cmds.group( side + self.userGuideName + "_1_Jnt", name=side + self.userGuideName + "_Joint_Grp") self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, name=side + self.userGuideName + "_Grp") # create a locator in order to avoid delete static group loc = cmds.spaceLocator(name=side + self.userGuideName + "_DO_NOT_DELETE")[0] cmds.parent(loc, self.toStaticHookGrp, absolute=True) cmds.setAttr(loc + ".visibility", 0) self.ctrls.setLockHide([loc], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' ]) # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count) if hideJoints: cmds.setAttr(self.toScalableHookGrp + ".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [ self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_' ] for s, side in enumerate(sideList): duplicated = cmds.duplicate( self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side + self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename( self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 0: for axis in self.mirrorAxis: gotValue = cmds.getAttr( side + self.userGuideName + "_Guide_Base.translate" + axis) flipedValue = gotValue * (-2) cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.translate' + axis, flipedValue) else: for axis in self.mirrorAxis: cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True) #for Maya2012: self.userGuideName+'_'+self.moduleGrp+"_Grp" # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # run for all sides for s, side in enumerate(sideList): self.base = side + self.userGuideName + '_Guide_Base' cmds.select(clear=True) # declare guide: self.guide = side + self.userGuideName + "_Guide_JointLoc1" # create a joint: self.jnt = cmds.joint(name=side + self.userGuideName + "_Jnt", scaleCompensate=False) cmds.addAttr(self.jnt, longName='dpAR_joint', attributeType='float', keyable=False) utils.setJointLabel(self.jnt, s + jointLabelAdd, 18, self.userGuideName) # create a control: if not self.getHasIndirectSkin(): if self.curveDegree == 0: self.curveDegree = 1 # work with curve shape and rotation cases: indirectSkinRot = (0, 0, 0) if self.langDic[ self.langName]['c058_main'] in self.userGuideName: ctrlTypeID = "id_054_SingleMain" if len(sideList) > 1: if self.langDic[self.langName][ 'c041_eyebrow'] in self.userGuideName: indirectSkinRot = (0, 0, -90) else: indirectSkinRot = (0, 0, 90) else: ctrlTypeID = "id_029_SingleIndSkin" if self.langDic[ self.langName]['c045_lower'] in self.userGuideName: indirectSkinRot = (0, 0, 180) elif self.langDic[self.langName][ 'c043_corner'] in self.userGuideName: if "00" in self.userGuideName: indirectSkinRot = (0, 0, 90) else: indirectSkinRot = (0, 0, -90) self.singleCtrl = self.ctrls.cvControl( ctrlTypeID, side + self.userGuideName + "_Ctrl", r=self.ctrlRadius, d=self.curveDegree, rot=indirectSkinRot) utils.originedFrom(objName=self.singleCtrl, attrString=self.base + ";" + self.guide) # position and orientation of joint and control: cmds.delete( cmds.parentConstraint(self.guide, self.jnt, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.guide, self.singleCtrl, maintainOffset=False)) # zeroOut controls: zeroOutCtrlGrp = utils.zeroOut([self.singleCtrl], offset=True)[0] # hide visibility attribute: cmds.setAttr(self.singleCtrl + '.visibility', keyable=False) # fixing flip mirror: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: cmds.setAttr(zeroOutCtrlGrp + ".scaleX", -1) cmds.setAttr(zeroOutCtrlGrp + ".scaleY", -1) cmds.setAttr(zeroOutCtrlGrp + ".scaleZ", -1) if not self.getHasIndirectSkin(): cmds.addAttr(self.singleCtrl, longName='scaleCompensate', attributeType="bool", keyable=False) cmds.setAttr(self.singleCtrl + ".scaleCompensate", 1, channelBox=True) cmds.connectAttr(self.singleCtrl + ".scaleCompensate", self.jnt + ".segmentScaleCompensate", force=True) if self.getHasIndirectSkin(): # create a fatherJoint in order to zeroOut the skinning joint: cmds.select(clear=True) jxtName = self.jnt.replace("_Jnt", "_Jxt") self.jxt = cmds.duplicate(self.jnt, name=jxtName)[0] cmds.deleteAttr(self.jxt, attribute="dpAR_joint") cmds.parent(self.jnt, self.jxt) cmds.makeIdentity(self.jnt, apply=True, jointOrient=False) attrList = [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz' ] for attr in attrList: cmds.connectAttr(self.singleCtrl + '.' + attr, self.jnt + '.' + attr) if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: cmds.setAttr(self.jxt + ".scaleX", -1) cmds.setAttr(self.jxt + ".scaleY", -1) cmds.setAttr(self.jxt + ".scaleZ", -1) if self.getHasHolder(): cmds.delete(self.singleCtrl + "Shape", shape=True) self.singleCtrl = cmds.rename( self.singleCtrl, self.singleCtrl + "_" + self.langDic[self.langName]['c046_holder'] + "_Grp") self.ctrls.setLockHide([self.singleCtrl], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz' ]) self.jnt = cmds.rename( self.jnt, self.jnt.replace( "_Jnt", "_" + self.langDic[self.langName]['c046_holder'] + "_Jis")) self.ctrls.setLockHide([self.jnt], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz' ], True, True) else: self.jnt = cmds.rename( self.jnt, self.jnt.replace("_Jnt", "_Jis")) else: # like a fkLine # create parentConstraint from ctrl to jnt: cmds.parentConstraint(self.singleCtrl, self.jnt, maintainOffset=False, name=self.jnt + "_ParentConstraint") # create scaleConstraint from ctrl to jnt: cmds.scaleConstraint(self.singleCtrl, self.jnt, maintainOffset=True, name=self.jnt + "_ScaleConstraint") # create end joint: cmds.select(self.jnt) self.cvEndJoint = side + self.userGuideName + "_Guide_JointEnd" self.endJoint = cmds.joint(name=side + self.userGuideName + "_JEnd") cmds.delete( cmds.parentConstraint(self.cvEndJoint, self.endJoint, maintainOffset=False)) self.mainJisList.append(self.jnt) # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group( side + self.userGuideName + "_Ctrl_Zero_0_Grp", name=side + self.userGuideName + "_Control_Grp") if self.getHasIndirectSkin(): locScale = cmds.spaceLocator(name=side + self.userGuideName + "_Scalable_DO_NOT_DELETE")[0] cmds.setAttr(locScale + ".visibility", 0) self.toScalableHookGrp = cmds.group( locScale, name=side + self.userGuideName + "_IndirectSkin_Grp") jxtGrp = cmds.group(side + self.userGuideName + "_Jxt", name=side + self.userGuideName + "_Joint_Grp") self.toStaticHookGrp = cmds.group( jxtGrp, self.toScalableHookGrp, self.toCtrlHookGrp, name=side + self.userGuideName + "_Grp") else: self.toScalableHookGrp = cmds.group( side + self.userGuideName + "_Jnt", name=side + self.userGuideName + "_Joint_Grp") self.toStaticHookGrp = cmds.group( self.toCtrlHookGrp, self.toScalableHookGrp, name=side + self.userGuideName + "_Grp") # create a locator in order to avoid delete static or scalable group loc = cmds.spaceLocator(name=side + self.userGuideName + "_DO_NOT_DELETE")[0] cmds.parent(loc, self.toStaticHookGrp, absolute=True) cmds.setAttr(loc + ".visibility", 0) self.ctrls.setLockHide([loc], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' ]) # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_type", CLASS_NAME, type="string") self.aStaticGrpList.append(self.toStaticHookGrp) self.aCtrlGrpList.append(self.toCtrlHookGrp) # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count) if hideJoints: cmds.setAttr(self.toScalableHookGrp + ".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp) # check mirror indirectSkin bug in Maya2018: if (int(cmds.about(version=True)[:4]) == 2018): if self.mirrorAxis != 'off': if self.getHasIndirectSkin(): meshList = cmds.ls(selection=False, type="mesh") if meshList: self.detectedBug = True # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # articulation joint: self.addArticJoint = self.getArticulation() # declaring lists to send information for integration: self.scalableGrpList, self.ikCtrlZeroList = [], [] # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp+".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp+".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [self.mirrorNames[0]+'_', self.mirrorNames[len(self.mirrorNames)-1]+'_'] for s, side in enumerate(sideList): duplicated = cmds.duplicate(self.moduleGrp, name=side+self.userGuideName+'_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side+self.userGuideName+"_"+item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side+self.userGuideName+'_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename(self.mirrorGrp, side+self.userGuideName+'_'+self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: for axis in self.mirrorAxis: cmds.setAttr(side+self.userGuideName+'_'+self.mirrorGrp+'.scale'+axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName+'_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName+"_"+item) self.mirrorGrp = cmds.group(self.userGuideName+'_Guide_Base', name="Guide_Base_Grp", relative=True) # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName+'_'+self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type")+1 # run for all sides for s, side in enumerate(sideList): self.skinJointList = [] self.base = side+self.userGuideName+'_Guide_Base' # get the number of joints to be created: self.nJoints = cmds.getAttr(self.base+".nJoints") for n in range(0, self.nJoints+1): cmds.select(clear=True) # declare guide: self.guide = side+self.userGuideName+"_Guide_JointLoc"+str(n) self.cvEndJoint = side+self.userGuideName+"_Guide_JointEnd" self.radiusGuide = side+self.userGuideName+"_Guide_Base_RadiusCtrl" # create a joint: self.jnt = cmds.joint(name=side+self.userGuideName+"_%02d_Jnt"%(n), scaleCompensate=False) self.skinJointList.append(self.jnt) cmds.addAttr(self.jnt, longName='dpAR_joint', attributeType='float', keyable=False) utils.setJointLabel(self.jnt, s+jointLabelAdd, 18, self.userGuideName+"_%02d"%(n)) # create a control: if n == 1: self.fingerCtrl = self.ctrls.cvControl("id_015_FingerMain", ctrlName=side+self.userGuideName+"_%02d_Ctrl"%(n), r=(self.ctrlRadius * 2.0), d=self.curveDegree, rot=(0, 0, -90)) cmds.setAttr(self.fingerCtrl+".rotateOrder", 1) utils.originedFrom(objName=self.fingerCtrl, attrString=self.base+";"+self.guide) # edit the mirror shape to a good direction of controls: if s == 1: if self.mirrorAxis == 'X': cmds.setAttr(self.fingerCtrl+'.rotateZ', 180) elif self.mirrorAxis == 'Y': cmds.setAttr(self.fingerCtrl+'.rotateY', 180) elif self.mirrorAxis == 'Z': cmds.setAttr(self.fingerCtrl+'.rotateZ', 180) elif self.mirrorAxis == 'XY': cmds.setAttr(self.fingerCtrl+'.rotateX', 180) elif self.mirrorAxis == 'XYZ': cmds.setAttr(self.fingerCtrl+'.rotateZ', 180) cmds.makeIdentity(self.fingerCtrl, apply=True, translate=False, rotate=True, scale=False) else: self.fingerCtrl = self.ctrls.cvControl("id_016_FingerFk", ctrlName=side+self.userGuideName+"_%02d_Ctrl"%(n), r=self.ctrlRadius, d=self.curveDegree) cmds.setAttr(self.fingerCtrl+".rotateOrder", 1) if n == self.nJoints: utils.originedFrom(objName=self.fingerCtrl, attrString=self.guide+";"+self.cvEndJoint+";"+self.radiusGuide) else: utils.originedFrom(objName=self.fingerCtrl, attrString=self.guide) if n == 0: if self.nJoints == 2: # problably we are creating the first control to a thumb cmds.scale(2, 2, 2, self.fingerCtrl, relative=True) cmds.makeIdentity(self.fingerCtrl, apply=True) else: # problably we are creating other base controls cmds.scale(2, 0.5, 1, self.fingerCtrl, relative=True) cmds.makeIdentity(self.fingerCtrl, apply=True) # scaleCompensate attribute: #Not needed in Maya 2016 since we need to deactivate scale compensate on all finger bone if (int(cmds.about(version=True)[:4]) < 2016): if n > 0 or self.nJoints == 2: cmds.addAttr(self.fingerCtrl, longName="scaleCompensate", attributeType='bool', keyable=True) scaleCompensateCond = cmds.createNode("condition", name=side+self.userGuideName+"_%02d_ScaleCompensate_Cnd"%(n)) cmds.setAttr(scaleCompensateCond+".secondTerm", 1) cmds.connectAttr(self.fingerCtrl+".scaleCompensate", scaleCompensateCond+".colorIfTrueR", force=True) cmds.connectAttr(scaleCompensateCond+".outColorR", self.jnt+".segmentScaleCompensate", force=True) # hide visibility attribute: cmds.setAttr(self.fingerCtrl+'.visibility', keyable=False) # put another group over the control in order to use this to connect values from mainFingerCtrl: self.sdkGrp = cmds.group(self.fingerCtrl, name=side+self.userGuideName+"_%02d_SDK_Grp"%(n)) if n == 1: # change pivot of this group to control pivot: pivotPos = cmds.xform(self.fingerCtrl, query=True, worldSpace=True, rotatePivot=True) cmds.setAttr(self.sdkGrp+'.rotatePivotX', pivotPos[0]) cmds.setAttr(self.sdkGrp+'.rotatePivotY', pivotPos[1]) cmds.setAttr(self.sdkGrp+'.rotatePivotZ', pivotPos[2]) # position and orientation of joint and control: tempDel = cmds.parentConstraint(self.guide, self.jnt, maintainOffset=False) cmds.delete(tempDel) tempDel = cmds.parentConstraint(self.guide, self.sdkGrp, maintainOffset=False) cmds.delete(tempDel) # zeroOut controls: self.zeroGrp = utils.zeroOut([self.sdkGrp]) # grouping: if n > 0: if n == 1: if not cmds.objExists(self.fingerCtrl+'.ikFkBlend'): cmds.addAttr(self.fingerCtrl, longName="ikFkBlend", attributeType='float', keyable=True, minValue=0.0, maxValue=1.0, defaultValue=1.0) self.ikFkRevNode = cmds.createNode("reverse", name=side+self.userGuideName+"_ikFk_Rev") cmds.connectAttr(self.fingerCtrl+".ikFkBlend", self.ikFkRevNode+".inputX", force=True) if not cmds.objExists(self.fingerCtrl+'.'+self.langDic[self.langName]['c021_showControls']): cmds.addAttr(self.fingerCtrl, longName=self.langDic[self.langName]['c021_showControls'], attributeType='float', keyable=True, minValue=0.0, maxValue=1.0, defaultValue=1.0) self.ctrlShape0 = cmds.listRelatives(side+self.userGuideName+"_00_Ctrl", children=True, type='nurbsCurve')[0] cmds.connectAttr(self.fingerCtrl+"."+self.langDic[self.langName]['c021_showControls'], self.ctrlShape0+".visibility", force=True) cmds.setAttr(self.fingerCtrl+'.'+self.langDic[self.langName]['c021_showControls'], keyable=False, channelBox=True) for j in range(1, self.nJoints+1): cmds.addAttr(self.fingerCtrl, longName=self.langDic[self.langName]['c022_phalange']+str(j), attributeType='float', keyable=True) # parent joints as a simple chain (line) self.fatherJnt = side+self.userGuideName+"_%02d_Jnt"%(n-1) cmds.parent(self.jnt, self.fatherJnt, absolute=True) # parent zeroGrp Group to the before ctrl: self.fatherCtrl = side+self.userGuideName+"_%02d_Ctrl"%(n-1) cmds.parent(self.zeroGrp, self.fatherCtrl, absolute=True) # freeze joints rotation cmds.makeIdentity(self.jnt, apply=True) # create parent and scale constraints from ctrl to jnt: cmds.delete(cmds.parentConstraint(self.fingerCtrl, self.jnt, maintainOffset=False, name=self.jnt+"_PaC")) # add articulationJoint: if n > 0: if self.addArticJoint: artJntList = utils.articulationJoint(self.fatherJnt, self.jnt) #could call to create corrective joints. See parameters to implement it, please. utils.setJointLabel(artJntList[0], s+jointLabelAdd, 18, self.userGuideName+"_%02d_Jar"%(n)) cmds.select(self.jnt) if n == self.nJoints: # create end joint: self.endJoint = cmds.joint(name=side+self.userGuideName+"_JEnd", radius=0.5) cmds.delete(cmds.parentConstraint(self.cvEndJoint, self.endJoint, maintainOffset=False)) # make first phalange be leads from base finger control: cmds.parentConstraint(side+self.userGuideName+"_00_Ctrl", side+self.userGuideName+"_01_SDK_Zero_0_Grp", maintainOffset=True, name=side+self.userGuideName+"_01_SDK_Zero_0_Grp"+"_PaC") cmds.scaleConstraint(side+self.userGuideName+"_00_Ctrl", side+self.userGuideName+"_01_SDK_Zero_0_Grp", maintainOffset=True, name=side+self.userGuideName+"_01_SDK_Zero_0_Grp"+"_ScC") if self.nJoints != 2: cmds.parentConstraint(side+self.userGuideName+"_00_Ctrl", side+self.userGuideName+"_00_Jnt", maintainOffset=True, name=side+self.userGuideName+"_PaC") cmds.scaleConstraint(side+self.userGuideName+"_00_Ctrl", side+self.userGuideName+"_00_Jnt", maintainOffset=True, name=side+self.userGuideName+"_ScC") # connecting the attributes from control 1 to phalanges rotate: for n in range(1, self.nJoints+1): self.fingerCtrl = side+self.userGuideName+"_01_Ctrl" self.sdkGrp = side+self.userGuideName+"_%02d_SDK_Grp"%(n) cmds.connectAttr(self.fingerCtrl+"."+self.langDic[self.langName]['c022_phalange']+str(n), self.sdkGrp+".rotateY", force=True) if n > 1: self.ctrlShape = cmds.listRelatives(side+self.userGuideName+"_%02d_Ctrl"%(n), children=True, type='nurbsCurve')[0] cmds.connectAttr(self.fingerCtrl+"."+self.langDic[self.langName]['c021_showControls'], self.ctrlShape+".visibility", force=True) # ik and Fk setup if self.nJoints == 2: dupIk = cmds.duplicate(self.skinJointList[0])[0] dupFk = cmds.duplicate(self.skinJointList[0])[0] else: dupIk = cmds.duplicate(self.skinJointList[1])[0] dupFk = cmds.duplicate(self.skinJointList[1])[0] # hide ik and fk joints in order to be Rigger friendly while skinning cmds.setAttr(dupIk+".visibility", 0) cmds.setAttr(dupFk+".visibility", 0) # ik setup childrenIkList = cmds.listRelatives(dupIk, children=True, allDescendents=True, fullPath=True) if childrenIkList: for child in childrenIkList: if not cmds.objectType(child) == "joint": cmds.delete(child) if child.endswith("_Jar"): cmds.delete(child) jointIkList = cmds.listRelatives(dupIk, children=True, allDescendents=True, fullPath=True) for jointNode in jointIkList: if "_Jnt" in jointNode[jointNode.rfind("|"):]: cmds.rename(jointNode, jointNode[jointNode.rfind("|")+1:].replace("_Jnt", "_Ik_Jxt")) elif "_JEnd" in jointNode[jointNode.rfind("|"):]: cmds.rename(jointNode, jointNode[jointNode.rfind("|")+1:].replace("_JEnd", "_Ik_JEnd")) ikBaseJoint = cmds.rename(dupIk, dupIk.replace("_Jnt1", "_Ik_Jxt")) ikJointList = cmds.listRelatives(ikBaseJoint, children=True, allDescendents=True) ikJointList.append(ikBaseJoint) # Fk setup childrenFkList = cmds.listRelatives(dupFk, children=True, allDescendents=True, fullPath=True) if childrenFkList: for child in childrenFkList: if not cmds.objectType(child) == "joint": cmds.delete(child) if child.endswith("_Jar"): cmds.delete(child) jointFkList = cmds.listRelatives(dupFk, children=True, allDescendents=True, fullPath=True) for jointNode in jointFkList: if "_Jnt" in jointNode[jointNode.rfind("|"):]: cmds.rename(jointNode, jointNode[jointNode.rfind("|")+1:].replace("_Jnt", "_Fk_Jxt")) elif "_JEnd" in jointNode[jointNode.rfind("|"):]: cmds.rename(jointNode, jointNode[jointNode.rfind("|")+1:].replace("_JEnd", "_Fk_JEnd")) fkBaseJoint = cmds.rename(dupFk, dupFk.replace("_Jnt2", "_Fk_Jxt")) fkJointList = cmds.listRelatives(fkBaseJoint, children=True, allDescendents=True) fkJointList.append(fkBaseJoint) # ik fk blend connnections for i, ikJoint in enumerate(ikJointList): if not "_JEnd" in ikJoint: utils.clearDpArAttr([ikJoint]) fkJoint = ikJoint.replace("_Ik_Jxt", "_Fk_Jxt") skinJoint = ikJoint.replace("_Ik_Jxt", "_Jnt") self.fingerCtrl = side+self.userGuideName+"_01_Ctrl" scaleCompensateCond = ikJoint.replace("_Ik_Jxt", "_ScaleCompensate_Cnd") ikFkParentConst = cmds.parentConstraint(ikJoint, fkJoint, skinJoint, maintainOffset=True, name=skinJoint+"_PaC")[0] ikFkScaleConst = cmds.scaleConstraint(ikJoint, fkJoint, skinJoint, maintainOffset=True, name=skinJoint+"_ScC")[0] cmds.connectAttr(self.fingerCtrl+".ikFkBlend", ikFkParentConst+"."+fkJoint+"W1", force=True) cmds.connectAttr(self.ikFkRevNode+".outputX", ikFkParentConst+"."+ikJoint+"W0", force=True) cmds.connectAttr(self.fingerCtrl+".ikFkBlend", ikFkScaleConst+"."+fkJoint+"W1", force=True) cmds.connectAttr(self.ikFkRevNode+".outputX", ikFkScaleConst+"."+ikJoint+"W0", force=True) cmds.setAttr(ikJoint+".segmentScaleCompensate", 1) #Condition for scale compensate will not exist in maya 2016 since we need to have the compensate #off for almost every joint if (int(cmds.about(version=True)[:4]) < 2016): cmds.connectAttr(self.fingerCtrl+".ikFkBlend", scaleCompensateCond+".firstTerm", force=True) # fk control drives fk joints for i, fkJoint in enumerate(fkJointList): if not "_JEnd" in fkJoint: utils.clearDpArAttr([fkJoint]) fkCtrl = fkJoint.replace("_Fk_Jxt", "_Ctrl") scaleCompensateCond = fkCtrl.replace("_Ctrl", "_ScaleCompensate_Cnd") cmds.parentConstraint(fkCtrl, fkJoint, maintainOffset=True, name=fkJoint+"_PaC") cmds.scaleConstraint(fkCtrl, fkJoint, maintainOffset=True, name=fkJoint+"_ScC") #Not needed in Maya 2016 since we need to deactivate scale compensate on all finger bone if (int(cmds.about(version=True)[:4]) < 2016): cmds.connectAttr(fkCtrl+".scaleCompensate", fkJoint+".segmentScaleCompensate", force=True) else: cmds.setAttr(fkJoint+".segmentScaleCompensate", 0) cmds.setAttr(fkCtrl+".rotateOrder", 1) #Force Scale compensate to prevent scale problem in Maya 2016 for nJnt in self.skinJointList: if (int(cmds.about(version=True)[:4]) >= 2016): cmds.setAttr(nJnt+".segmentScaleCompensate", 0) # ik handle if self.nJoints >= 2: if self.nJoints == 2: ikHandleList = cmds.ikHandle(startJoint=side+self.userGuideName+"_00_Ik_Jxt", endEffector=side+self.userGuideName+"_%02d_Ik_Jxt"%(self.nJoints), solver="ikRPsolver", name=side+self.userGuideName+"_IKH") else: ikHandleList = cmds.ikHandle(startJoint=side+self.userGuideName+"_01_Ik_Jxt", endEffector=side+self.userGuideName+"_%02d_Ik_Jxt"%(self.nJoints), solver="ikRPsolver", name=side+self.userGuideName+"_IKH") cmds.rename(ikHandleList[1], side+self.userGuideName+"_Eff") endIkHandleList = cmds.ikHandle(startJoint=side+self.userGuideName+"_%02d_Ik_Jxt"%(self.nJoints), endEffector=side+self.userGuideName+"_Ik_JEnd", solver="ikSCsolver", name=side+self.userGuideName+"_EndIkHandle") cmds.rename(endIkHandleList[1], side+self.userGuideName+"_End_Eff") self.ikCtrl = self.ctrls.cvControl("id_017_FingerIk", ctrlName=side+self.userGuideName+"_Ik_Ctrl", r=(self.ctrlRadius * 0.3), d=self.curveDegree) cmds.addAttr(self.ikCtrl, longName='twist', attributeType='float', keyable=True) cmds.connectAttr(self.ikCtrl+".twist", ikHandleList[0]+".twist", force=True) cmds.delete(cmds.parentConstraint(side+self.userGuideName+"_Ik_JEnd", self.ikCtrl)) cmds.setAttr(self.ikCtrl+".rotateOrder", 1) self.ikCtrlZero = utils.zeroOut([self.ikCtrl])[0] self.ikCtrlZeroList.append(self.ikCtrlZero) cmds.connectAttr(self.ikFkRevNode+".outputX", self.ikCtrlZero+".visibility", force=True) for q in range(2, self.nJoints+1): cmds.connectAttr(side+self.userGuideName+"_01_Ctrl.ikFkBlend", side+self.userGuideName+"_%02d_Ctrl.visibility"%(q), force=True) cmds.parentConstraint(self.ikCtrl, ikHandleList[0], name=side+self.userGuideName+"_IKH_PaC", maintainOffset=True) cmds.parentConstraint(self.ikCtrl, endIkHandleList[0], name=side+self.userGuideName+"_EndIkHandle_PaC", maintainOffset=True) ikHandleGrp = cmds.group(ikHandleList[0], endIkHandleList[0], name=side+self.userGuideName+"_IKH_Grp") cmds.setAttr(ikHandleGrp+".visibility", 0) self.ctrls.setLockHide([self.ikCtrl], ['sx', 'sy', 'sz', 'v']) if self.nJoints == 2: cmds.parentConstraint(side+self.userGuideName+"_00_Ctrl", side+self.userGuideName+"_00_Ik_Jxt", maintainOffset=True, name=side+self.userGuideName+"_00_Ik_Jxt_PaC") cmds.scaleConstraint(side+self.userGuideName+"_00_Ctrl", side+self.userGuideName+"_00_Ik_Jxt", maintainOffset=True, name=side+self.userGuideName+"_00_Ik_Jxt_ScC") # stretch cmds.addAttr(self.ikCtrl, longName='stretchable', attributeType='float', minValue=0, maxValue=1, defaultValue=0, keyable=True) stretchNormMD = cmds.createNode("multiplyDivide", name=side+self.userGuideName+"_StretchNormalize_MD") cmds.setAttr(stretchNormMD+".operation", 2) distBetweenList = self.ctrls.distanceBet(side+self.userGuideName+"_00_Ctrl", self.ikCtrl, name=side+self.userGuideName+"_DistBet", keep=True) cmds.connectAttr(self.ikFkRevNode+".outputX", distBetweenList[5]+"."+self.ikCtrl+"W0", force=True) cmds.connectAttr(self.fingerCtrl+".ikFkBlend", distBetweenList[5]+"."+distBetweenList[4]+"W1", force=True) cmds.connectAttr(distBetweenList[1]+".distance", stretchNormMD+".input1X", force=True) cmds.setAttr(stretchNormMD+".input2X", distBetweenList[0]) stretchScaleMD = cmds.createNode("multiplyDivide", name=side+self.userGuideName+"_StretchScale_MD") cmds.connectAttr(stretchNormMD+".outputX", stretchScaleMD+".input1X", force=True) cmds.connectAttr(self.ikCtrl+".stretchable", stretchScaleMD+".input2X", force=True) stretchCond = cmds.createNode("condition", name=side+self.userGuideName+"_Stretch_Cnd") cmds.connectAttr(stretchScaleMD+".outputX", stretchCond+".firstTerm", force=True) cmds.setAttr(stretchCond+".secondTerm", 1) cmds.setAttr(stretchCond+".operation", 2) cmds.connectAttr(stretchScaleMD+".outputX", stretchCond+".colorIfTrueR", force=True) for i, ikJoint in enumerate(ikJointList): if not "_JEnd" in ikJoint: if self.nJoints == 2 and i == 0: pass else: cmds.connectAttr(stretchCond+".outColorR", ikJoint+".scaleZ", force=True) # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group(self.ikCtrlZero, side+self.userGuideName+"_00_SDK_Zero_0_Grp", side+self.userGuideName+"_01_SDK_Zero_0_Grp", name=side+self.userGuideName+"_Control_Grp") if self.nJoints == 2: self.toScalableHookGrp = cmds.group(self.skinJointList[0], ikBaseJoint, fkBaseJoint, ikHandleGrp, distBetweenList[2], distBetweenList[3], distBetweenList[4], name=side+self.userGuideName+"_Joint_Grp") else: self.toScalableHookGrp = cmds.group(self.skinJointList[0], ikHandleGrp, distBetweenList[2], distBetweenList[3], distBetweenList[4], name=side+self.userGuideName+"_Joint_Grp") else: self.toCtrlHookGrp = cmds.group(side+self.userGuideName+"_00_SDK_Zero_0_Grp", side+self.userGuideName+"_01_SDK_Zero_0_Grp", name=side+self.userGuideName+"_Control_Grp") self.toScalableHookGrp = cmds.group(side+self.userGuideName+"_00_Jnt", name=side+self.userGuideName+"_Joint_Grp") self.scalableGrpList.append(self.toScalableHookGrp) self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, name=side+self.userGuideName+"_Grp") # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp+".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp+".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp+'.dpAR_count', dpAR_count) # create a locator in order to avoid delete static group loc = cmds.spaceLocator(name=side+self.userGuideName+"_DO_NOT_DELETE_PLEASE_Loc")[0] cmds.parent(loc, self.toStaticHookGrp, absolute=True) cmds.setAttr(loc+".visibility", 0) self.ctrls.setLockHide([loc], ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']) if hideJoints: cmds.setAttr(self.toScalableHookGrp+".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side+self.userGuideName+'_'+self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # declare lists to store names and attributes: self.suspensionBCtrlGrpList, self.fatherBList, self.ctrlHookGrpList = [], [], [] # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [ self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_' ] for s, side in enumerate(sideList): duplicated = cmds.duplicate( self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side + self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename( self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 0: for axis in self.mirrorAxis: gotValue = cmds.getAttr( side + self.userGuideName + "_Guide_Base.translate" + axis) flipedValue = gotValue * (-2) cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.translate' + axis, flipedValue) else: for axis in self.mirrorAxis: cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True) #for Maya2012: self.userGuideName+'_'+self.moduleGrp+"_Grp" # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # run for all sides for s, side in enumerate(sideList): # declare guide: self.base = side + self.userGuideName + '_Guide_Base' self.cvALoc = side + self.userGuideName + "_Guide_JointLocA" self.cvBLoc = side + self.userGuideName + "_Guide_JointLocB" self.radiusGuide = side + self.userGuideName + "_Guide_Base_RadiusCtrl" self.locatorsGrp = cmds.group(name=side + self.userGuideName + "_Loc_Grp", empty=True) # calculate distance between guide and end: self.dist = self.ctrls.distanceBet(self.cvALoc, self.cvBLoc)[0] * 0.2 self.jointList, self.mainCtrlList, self.ctrlZeroList, self.ctrlList, self.aimLocList, self.upLocList = [], [], [], [], [], [] for p, letter in enumerate(["A", "B"]): # create joints: cmds.select(clear=True) jnt = cmds.joint(name=side + self.userGuideName + "_" + letter + "_1_Jnt", scaleCompensate=False) endJoint = cmds.joint(name=side + self.userGuideName + "_" + letter + "_JEnd", scaleCompensate=False, radius=0.5) cmds.addAttr(jnt, longName='dpAR_joint', attributeType='float', keyable=False) cmds.setAttr(endJoint + ".translateZ", self.dist) # joint labelling: utils.setJointLabel(jnt, s + jointLabelAdd, 18, self.userGuideName + "_" + letter) self.jointList.append(jnt) # create a control: mainCtrl = self.ctrls.cvControl( "id_055_SuspensionMain", side + self.userGuideName + "_" + self.langDic[self.langName]["c058_main"] + "_" + letter + "_Ctrl", r=self.ctrlRadius, d=self.curveDegree) ctrl = self.ctrls.cvControl("id_056_SuspensionAB", side + self.userGuideName + "_" + letter + "_Ctrl", r=self.ctrlRadius * 0.5, d=self.curveDegree) upLocCtrl = self.ctrls.cvControl( "id_057_SuspensionUpLoc", side + self.userGuideName + "_" + letter + "_UpLoc_Ctrl", r=self.ctrlRadius * 0.1, d=self.curveDegree) self.ctrls.setLockHide([ctrl], ['tx', 'ty', 'tz', 'v']) self.ctrls.setLockHide( [upLocCtrl], ['rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']) # position and orientation of joint and control: cmds.parent(ctrl, upLocCtrl, mainCtrl) cmds.parentConstraint(ctrl, jnt, maintainOffset=False, name=jnt + "_PaC") cmds.scaleConstraint(ctrl, jnt, maintainOffset=False, name=jnt + "_ScC") self.ctrlList.append(ctrl) # zeroOut controls: zeroOutCtrlGrp = utils.zeroOut([mainCtrl, ctrl, upLocCtrl]) self.mainCtrlList.append(zeroOutCtrlGrp[0]) self.ctrlZeroList.append(zeroOutCtrlGrp[1]) cmds.setAttr(zeroOutCtrlGrp[2] + ".translateX", self.dist) # origined from data: if p == 0: utils.originedFrom(objName=mainCtrl, attrString=self.base + ";" + self.cvALoc + ";" + self.radiusGuide) cmds.delete( cmds.parentConstraint(self.cvALoc, zeroOutCtrlGrp[0], maintainOffset=False)) else: utils.originedFrom(objName=mainCtrl, attrString=self.cvBLoc) cmds.delete( cmds.parentConstraint(self.cvBLoc, zeroOutCtrlGrp[0], maintainOffset=False)) # integrating data: self.suspensionBCtrlGrpList.append(zeroOutCtrlGrp[0]) # hide visibility attribute: cmds.setAttr(mainCtrl + '.visibility', keyable=False) # fixing flip mirror: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: cmds.setAttr(zeroOutCtrlGrp[0] + ".scaleX", -1) cmds.setAttr(zeroOutCtrlGrp[0] + ".scaleY", -1) cmds.setAttr(zeroOutCtrlGrp[0] + ".scaleZ", -1) cmds.addAttr(ctrl, longName='scaleCompensate', attributeType="bool", keyable=False) cmds.setAttr(ctrl + ".scaleCompensate", 1, channelBox=True) cmds.connectAttr(ctrl + ".scaleCompensate", jnt + ".segmentScaleCompensate", force=True) # working with aim setup: cmds.addAttr(ctrl, longName="active", attributeType="bool", defaultValue=1, keyable=True) aimLoc = cmds.spaceLocator(name=side + self.userGuideName + "_" + letter + "_Aim_Loc")[0] upLoc = cmds.spaceLocator(name=side + self.userGuideName + "_" + letter + "_Up_Loc")[0] locGrp = cmds.group(aimLoc, upLoc, name=side + self.userGuideName + "_" + letter + "_Loc_Grp") cmds.parent(locGrp, self.locatorsGrp, relative=True) cmds.delete( cmds.parentConstraint(ctrl, locGrp, maintainOffset=False)) cmds.parentConstraint(upLocCtrl, upLoc, maintainOffset=False, name=upLoc + "_PaC") cmds.parentConstraint(mainCtrl, locGrp, maintainOffset=True, name=locGrp + "_PaC") cmds.setAttr(locGrp + ".visibility", 0) self.aimLocList.append(aimLoc) self.upLocList.append(upLoc) # aim constraints: # B to A: aAimConst = cmds.aimConstraint(self.aimLocList[1], self.ctrlZeroList[0], aimVector=(0, 0, 1), upVector=(1, 0, 0), worldUpType="object", worldUpObject=self.upLocList[0], maintainOffset=True, name=self.ctrlZeroList[0] + "_AiC")[0] cmds.connectAttr(self.ctrlList[0] + ".active", aAimConst + "." + self.aimLocList[1] + "W0", force=True) # A to B: bAimConst = cmds.aimConstraint(self.aimLocList[0], self.ctrlZeroList[1], aimVector=(0, 0, 1), upVector=(1, 0, 0), worldUpType="object", worldUpObject=self.upLocList[1], maintainOffset=True, name=self.ctrlZeroList[0] + "_AiC")[0] cmds.connectAttr(self.ctrlList[1] + ".active", bAimConst + "." + self.aimLocList[0] + "W0", force=True) # integrating data: self.loadedFatherB = cmds.getAttr(self.moduleGrp + ".fatherB") if self.loadedFatherB: self.fatherBList.append(self.loadedFatherB) else: self.fatherBList.append(None) # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group( self.mainCtrlList, name=side + self.userGuideName + "_Control_Grp") self.toScalableHookGrp = cmds.group( self.jointList, name=side + self.userGuideName + "_Joint_Grp") self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, self.locatorsGrp, name=side + self.userGuideName + "_Grp") # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count) self.ctrlHookGrpList.append(self.toCtrlHookGrp) if hideJoints: cmds.setAttr(self.toScalableHookGrp + ".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp+".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp+".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [ self.mirrorNames[0]+'_', self.mirrorNames[len(self.mirrorNames)-1]+'_' ] for s, side in enumerate(sideList): duplicated = cmds.duplicate(self.moduleGrp, name=side+self.userGuideName+'_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side+self.userGuideName+"_"+item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side+self.userGuideName+'_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename(self.mirrorGrp, side+self.userGuideName+'_'+self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: if cmds.getAttr(self.moduleGrp+".flip") == 0: for axis in self.mirrorAxis: gotValue = cmds.getAttr(side+self.userGuideName+"_Guide_Base.translate"+axis) flipedValue = gotValue*(-2) cmds.setAttr(side+self.userGuideName+'_'+self.mirrorGrp+'.translate'+axis, flipedValue) else: for axis in self.mirrorAxis: cmds.setAttr(side+self.userGuideName+'_'+self.mirrorGrp+'.scale'+axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName+'_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName+"_"+item) self.mirrorGrp = cmds.group(self.userGuideName+'_Guide_Base', name="Guide_Base_Grp", relative=True) #for Maya2012: self.userGuideName+'_'+self.moduleGrp+"_Grp" # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName+'_'+self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type: dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # create lists to export: self.eyeScaleGrpList, self.irisCtrlList, self.pupilCtrlList = [], [], [] self.hasIris = False self.hasPupil = False # create the main control: self.eyeCtrl = self.ctrls.cvControl("id_010_EyeLookAtMain", self.userGuideName+"_A_Ctrl", r=(2.25*self.ctrlRadius), d=self.curveDegree) cmds.addAttr(self.eyeCtrl, longName=self.langDic[self.langName]['c032_follow'], attributeType='float', keyable=True, minValue=0, maxValue=1) cmds.setAttr(self.eyeCtrl+"."+self.langDic[self.langName]['c032_follow'], 1) cmds.delete(cmds.parentConstraint(sideList[0]+self.userGuideName+"_Guide_JointEnd", self.eyeCtrl, maintainOffset=False)) if self.mirrorAxis != 'off': cmds.setAttr(self.eyeCtrl+".translate"+self.mirrorAxis, 0) self.eyeGrp = cmds.group(self.eyeCtrl, name=self.userGuideName+"_A_Grp") utils.zeroOut([self.eyeCtrl]) self.upLocGrp = cmds.group(name=self.userGuideName+"_UpLoc_Grp", empty=True) # run for all sides: for s, side in enumerate(sideList): cmds.select(clear=True) self.base = side+self.userGuideName+'_Guide_Base' # declare guide: self.guide = side+self.userGuideName+"_Guide_JointLoc1" self.cvEndJointZero = side+self.userGuideName+"_Guide_JointEnd_Grp" # create a joint: self.jxt = cmds.joint(name=side+self.userGuideName+"_1_Jxt", scaleCompensate=False) self.jnt = cmds.joint(name=side+self.userGuideName+"_1_Jnt", scaleCompensate=False) cmds.addAttr(self.jnt, longName='dpAR_joint', attributeType='float', keyable=False) utils.setJointLabel(self.jnt, s+jointLabelAdd, 18, self.userGuideName+"_1") self.fkEyeCtrl = self.ctrls.cvControl("id_014_EyeFk", side+self.userGuideName+"_Fk_Ctrl", r=self.ctrlRadius, d=self.curveDegree) utils.originedFrom(objName=self.fkEyeCtrl, attrString=self.base+";"+self.guide) self.baseEyeCtrl = self.ctrls.cvControl("id_009_EyeBase", ctrlName=side+self.userGuideName+"_Base_Ctrl", r=self.ctrlRadius, d=self.curveDegree) utils.originedFrom(objName=self.baseEyeCtrl, attrString=self.base+";"+self.guide) # position and orientation of joint and control: cmds.delete(cmds.pointConstraint(self.guide, self.jxt, maintainOffset=False)) cmds.delete(cmds.orientConstraint(self.cvEndJointZero, self.jxt, maintainOffset=False)) cmds.delete(cmds.pointConstraint(self.guide, self.fkEyeCtrl, maintainOffset=False)) cmds.delete(cmds.orientConstraint(self.cvEndJointZero, self.fkEyeCtrl, maintainOffset=False)) cmds.delete(cmds.parentConstraint(self.guide, self.baseEyeCtrl, maintainOffset=False)) # zeroOut controls: eyeZeroList = utils.zeroOut([self.baseEyeCtrl, self.fkEyeCtrl]) # fixing flip mirror: if s == 1: if cmds.getAttr(self.moduleGrp+".flip") == 1: cmds.setAttr(eyeZeroList[0]+".scaleX", -1) cmds.setAttr(eyeZeroList[0]+".scaleY", -1) cmds.setAttr(eyeZeroList[0]+".scaleZ", -1) cmds.parent(eyeZeroList[1], self.baseEyeCtrl) # hide visibility attribute: cmds.setAttr(self.fkEyeCtrl+'.visibility', keyable=False) self.ctrls.setLockHide([self.fkEyeCtrl], ['tx', 'ty', 'tz']) # create end joint: self.cvEndJoint = side+self.userGuideName+"_Guide_JointEnd" self.endJoint = cmds.joint(name=side+self.userGuideName+"_JEnd") cmds.delete(cmds.parentConstraint(self.cvEndJoint, self.endJoint, maintainOffset=False)) cmds.parent(self.endJoint, self.jnt, absolute=True) # create parentConstraint from ctrl to jxt: cmds.parentConstraint(self.fkEyeCtrl, self.jxt, maintainOffset=False, name=self.jnt+"_ParentConstraint") # create scaleConstraint from ctrl to jnt: cmds.scaleConstraint(self.fkEyeCtrl, self.jxt, maintainOffset=True, name=self.jnt+"_ScaleConstraint") # lookAt control: self.lookAtCtrl = self.ctrls.cvControl("id_011_EyeLookAt", side+self.userGuideName+"_LookAt_Ctrl", r=self.ctrlRadius, d=self.curveDegree) cmds.delete(cmds.parentConstraint(self.cvEndJoint, self.lookAtCtrl, maintainOffset=False)) cmds.parent(self.lookAtCtrl, self.eyeCtrl, relative=False) cmds.makeIdentity(self.lookAtCtrl, apply=True) cmds.addAttr(self.lookAtCtrl, longName="active", attributeType="bool", defaultValue=1, keyable=True) # up locator: self.cvUpLocGuide = side+self.userGuideName+"_Guide_JointEnd_UpLoc" self.lUpGrpLoc = cmds.group(name=side+self.userGuideName+"_Up_Loc_Grp", empty=True) cmds.delete(cmds.pointConstraint(self.jnt, self.lUpGrpLoc, maintainOffset=False)) cmds.delete(cmds.orientConstraint(self.cvEndJointZero, self.lUpGrpLoc, maintainOffset=False)) self.lUpLoc = cmds.spaceLocator(name=side+self.userGuideName+"_Up_Loc")[0] cmds.delete(cmds.parentConstraint(self.cvUpLocGuide, self.lUpLoc, maintainOffset=False)) cmds.parent(self.lUpLoc, self.lUpGrpLoc, relative=False) cmds.parent(self.lUpGrpLoc, self.upLocGrp, relative=False) # look at aim constraint: aimConst = cmds.aimConstraint(self.lookAtCtrl, eyeZeroList[1], worldUpType="object", worldUpObject=self.upLocGrp+"|"+self.lUpGrpLoc+"|"+self.lUpLoc, maintainOffset=True, name=self.fkEyeCtrl+"_Zero"+"_AimConstraint")[0] cmds.connectAttr(self.lookAtCtrl+".active", aimConst+"."+self.lookAtCtrl+"W0", force=True) # eye aim rotation cmds.addAttr(self.fkEyeCtrl, longName="aimRotation", attributeType="float", keyable=True) cmds.connectAttr(self.fkEyeCtrl+".aimRotation", self.jnt+".rotateZ", force=True) cmds.pointConstraint(self.baseEyeCtrl, self.lUpGrpLoc, maintainOffset=True, name=self.lUpGrpLoc+"_PointConstraint") # create eyeScale setup: cmds.select(clear=True) self.eyeScaleJnt = cmds.joint(name=side+self.userGuideName+"Scale_1_Jnt", scaleCompensate=False) cmds.addAttr(self.eyeScaleJnt, longName='dpAR_joint', attributeType='float', keyable=False) utils.setJointLabel(self.eyeScaleJnt, s+jointLabelAdd, 18, self.userGuideName+"Scale_1") # jointScale position: cmds.delete(cmds.parentConstraint(self.guide, self.eyeScaleJnt, maintainOffset=False)) # create endScale joint: self.endScaleJoint = cmds.joint(name=side+self.userGuideName+"Scale_JEnd") cmds.delete(cmds.parentConstraint(self.eyeScaleJnt, self.endScaleJoint, maintainOffset=False)) cmds.setAttr(self.endScaleJoint+".translateZ", 1) # create constraints to eyeScale: cmds.pointConstraint(self.jnt, self.eyeScaleJnt, maintainOffset=False, name=self.eyeScaleJnt+"_PointConstraint") cmds.orientConstraint(self.baseEyeCtrl, self.eyeScaleJnt, maintainOffset=False, name=self.eyeScaleJnt+"_OrientConstraint") cmds.scaleConstraint(self.jnt, self.eyeScaleJnt, maintainOffset=True, name=self.eyeScaleJnt+"_ScaleConstraint") self.eyeScaleGrp = cmds.group(self.eyeScaleJnt, name=self.eyeScaleJnt+"_Grp") self.eyeScaleGrpList.append(self.eyeScaleGrp) # create eyelid setup: if self.getModuleAttr(EYELID): # declare eyelid guides: self.cvUpperEyelidLoc = side+self.userGuideName+"_Guide_UpperEyelidLoc" self.cvLowerEyelidLoc = side+self.userGuideName+"_Guide_LowerEyelidLoc" # creating eyelids joints: cmds.select(clear=True) self.eyelidJxt = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName]['c042_eyelid']+"_Jxt", scaleCompensate=False) cmds.delete(cmds.parentConstraint(self.guide, self.eyelidJxt, mo=False)) cmds.parent(self.eyelidJxt, self.eyeScaleJnt) self.upperEyelidBaseJxt, self.upperEyelidJnt = self.createEyelidJoints(side, 'c044_upper', "", self.cvUpperEyelidLoc, s+jointLabelAdd) self.upperEyelidMiddleBaseJxt, self.upperEyelidMiddleJnt = self.createEyelidJoints(side, 'c044_upper', self.langDic[self.langName]['c029_middle'], self.cvUpperEyelidLoc, s+jointLabelAdd) self.lowerEyelidBaseJxt, self.lowerEyelidJnt = self.createEyelidJoints(side, 'c045_lower', "", self.cvLowerEyelidLoc, s+jointLabelAdd) self.lowerEyelidMiddleBaseJxt, self.lowerEyelidMiddleJnt = self.createEyelidJoints(side, 'c045_lower', self.langDic[self.langName]['c029_middle'], self.cvLowerEyelidLoc, s+jointLabelAdd) # creating eyelids controls and setup: self.upperEyelidCtrl, self.upperEyelidCtrlZero = self.createEyelidSetup(side, 'c044_upper', self.upperEyelidJnt, self.upperEyelidBaseJxt, self.upperEyelidMiddleBaseJxt, self.upperEyelidMiddleJnt, 30, (0, 0, 0)) self.lowerEyelidCtrl, self.lowerEyelidCtrlZero = self.createEyelidSetup(side, 'c045_lower', self.lowerEyelidJnt, self.lowerEyelidBaseJxt, self.lowerEyelidMiddleBaseJxt, self.lowerEyelidMiddleJnt, 30, (0, 0, 180)) # fixing mirror behavior for side controls: if s == 0: #left cmds.setAttr(self.upperEyelidCtrl+"."+self.langDic[self.langName]['c053_invert']+"X", 1) cmds.setAttr(self.upperEyelidCtrl+"."+self.langDic[self.langName]['c053_invert']+"Y", 1) cmds.setAttr(self.lowerEyelidCtrl+"."+self.langDic[self.langName]['c053_invert']+"Y", 1) else: #right if cmds.getAttr(self.moduleGrp+".flip") == 0: cmds.setAttr(self.upperEyelidCtrl+"."+self.langDic[self.langName]['c053_invert']+"Y", 1) cmds.setAttr(self.lowerEyelidCtrl+"."+self.langDic[self.langName]['c053_invert']+"X", 1) cmds.setAttr(self.lowerEyelidCtrl+"."+self.langDic[self.langName]['c053_invert']+"Y", 1) cmds.setAttr(self.upperEyelidCtrlZero+".rotateY", 180) cmds.setAttr(self.lowerEyelidCtrlZero+".rotateY", 180) else: cmds.setAttr(self.lowerEyelidCtrl+"."+self.langDic[self.langName]['c053_invert']+"X", 1) # create iris setup: if self.getModuleAttr(IRIS): self.irisCtrl = self.createIrisPupilSetup(s, side, IRIS, 'i080_iris', 12, s+jointLabelAdd) self.irisCtrlList.append(self.irisCtrl) self.hasIris = True # create pupil setup: if self.getModuleAttr(PUPIL): self.pupilCtrl = self.createIrisPupilSetup(s, side, PUPIL, 'i081_pupil', 4, s+jointLabelAdd) self.pupilCtrlList.append(self.pupilCtrl) self.hasPupil = True # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group(eyeZeroList[0], name=side+self.userGuideName+"_Control_Grp") self.toScalableHookGrp = cmds.group(self.jxt, self.eyeScaleGrp, name=side+self.userGuideName+"_Joint_Grp") self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, name=side+self.userGuideName+"_Grp") if s == 0: cmds.parent(self.eyeGrp, self.toCtrlHookGrp) cmds.parent(self.upLocGrp, self.toScalableHookGrp) # create a locator in order to avoid delete static group: loc = cmds.spaceLocator(name=side+self.userGuideName+"_DO_NOT_DELETE")[0] cmds.parent(loc, self.toStaticHookGrp, absolute=True) cmds.setAttr(loc+".visibility", 0) self.ctrls.setLockHide([loc], ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']) # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp+".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp+".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp+'.dpAR_count', dpAR_count) if hideJoints: cmds.setAttr(self.toScalableHookGrp+".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side+self.userGuideName+'_'+self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()