def skeletonizeCharacter(masterNull): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Skeletonizes a character ARGUMENTS: masterNull(string) RETURNS: nothin >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ modules = modules.returnModules(masterNull) orderedModules = modules.returnOrderedModules(modules) #>>> Do the spine first stateCheck = modules.moduleStateCheck(orderedModules[0], ['template']) if stateCheck == 1: spineJoints = skeletonize(orderedModules[0]) else: print('%s%s' % (module, ' has already been skeletonized. Moving on...')) #>>> Do the rest for module in orderedModules[1:]: stateCheck = modules.moduleStateCheck(module, ['template']) if stateCheck == 1: templateNull = modules.returnTemplateNull(module) root = modules.returnInfoNullObjects(module, 'templatePosObjects', types='templateRoot') #>>> See if our item has a non default anchor anchored = storeTemplateRootParent(module) if anchored == True: anchor = attributes.returnMessageObject( root[0], 'skeletonParent') closestJoint = distance.returnClosestObject( anchor, spineJoints) else: closestJoint = distance.returnClosestObject( root[0], spineJoints) limbJoints = skeletonize(module) rootName = rigging.doParentReturnName(limbJoints[0], closestJoint) print rootName else: print('%s%s' % (module, ' has already been skeletonized. Moving on...'))
def copyWeightsByClosestVerticeFromVert(sourceMesh, targetVert): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> New >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ assert mc.objExists(sourceMesh) is True,"'%s' doesn't exist" %sourceMesh assert mc.objExists(targetVert) is True,"'%s' doesn't exist" %targetVert targetMeshBuffer = targetVert.split('.') print targetMeshBuffer targetSkinCluster = querySkinCluster(targetMeshBuffer[0]) print targetSkinCluster influenceData = returnVerticeJointWeightDataToDict(sourceMesh) print influenceData sourceVertexList = (mc.ls ([sourceMesh+'.vtx[*]'],flatten=True)) print sourceVertexList rebuiltVertWeightData = [] """ find the closest vert """ verticeBuffer = [targetVert] closestVert = distance.returnClosestObject(targetVert,sourceVertexList) print ("Copying " + closestVert + " >>>> " + targetVert) """ rebuild our vert weighting data to set""" verticeBuffer.append(influenceData.get(closestVert)) rebuiltVertWeightData.append(verticeBuffer) setSkinWeights(targetSkinCluster,rebuiltVertWeightData) return rebuiltVertWeightData
def attachQSSSkinJointsToRigJoints (qssSkinJoints,qssRigJoints): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Created for N project. It will constrain one skeleton to the other by looking for the closest joint in a qss set of bind joints ARGUMENTS: qssSet(set) - must exist in scene. Set of the rig joints rigStartJoint - the first joint of a unifed deformation skeleton RETURNS: Nothing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ mc.select(cl=True) mc.select(qssSkinJoints) skinnedHeirarchy = mc.ls(sl=True) mc.select(cl=True) mc.select(qssRigJoints) rigHeirarchy = mc.ls(sl=True) constraintsList = [] for obj in rigHeirarchy: print ('On '+obj) attachJoint = distance.returnClosestObject(obj,skinnedHeirarchy) pntConstBuffer = mc.pointConstraint(obj,attachJoint,maintainOffset=True,weight=1) orConstBuffer = mc.orientConstraint(obj,attachJoint,maintainOffset=True,weight=1) pntConst = mc.rename(pntConstBuffer,(obj+('_pntConst'))) orConst = mc.rename(orConstBuffer,(obj+('_orConst'))) constraintsList.append(pntConst) constraintsList.append(orConst) #make our attribute Holder object """ need to make our master scale connector""" dataHolderGrp= ('rigJointsConstraintHolder_grp') if mc.objExists (dataHolderGrp): pass else: mc.group (n= dataHolderGrp, w=True, empty=True) #stores the constraints attributes.storeObjListNameToMessage (constraintsList, dataHolderGrp) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def returnLocalAimDirection(rootObj, aimObj): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Returns a local aim direction ARGUMENTS: rootObj(string) aimObj(string) RETURNS: direction(list) - [0,0,0] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ directionalLocArray = [] locGroups = [] directions = ['+x', '-x', '+y', '-y', '+z', '-z'] returnDirections = [[1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1]] distanceBuffer = distance.returnDistanceBetweenObjects(rootObj, aimObj) #distanceValues = distanceBuffer /2 cnt = 0 for direction in directions: locBuffer = locators.locMeObject(rootObj) locBuffer = mc.rename(locBuffer, (locBuffer + '_' + str(cnt))) locGroups.append(rigging.groupMeObject(locBuffer)) directionBuffer = list(direction) if directionBuffer[0] == '-': mc.setAttr((locBuffer + '.t' + directionBuffer[1]), -1) else: mc.setAttr((locBuffer + '.t' + directionBuffer[1]), 1) directionalLocArray.append(locBuffer) cnt += 1 closestLoc = distance.returnClosestObject(aimObj, directionalLocArray) matchIndex = directionalLocArray.index(closestLoc) for grp in locGroups: mc.delete(grp) return returnDirections[matchIndex]
def HOLDER(moduleNull): #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Connect skin joints to surface joints #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for joint in skinJoints: attachJoint = distance.returnClosestObject(joint, surfaceJoints) pntConstBuffer = mc.pointConstraint(attachJoint, joint, maintainOffset=True, weight=1) orConstBuffer = mc.orientConstraint(attachJoint, joint, maintainOffset=True, weight=1) #scaleConstBuffer = mc.scaleConstraint(attachJoint,joint,maintainOffset=True,weight=1) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Template Save and Removal #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ get rid of the template """
def copyWeightsByClosestVertice(sourceMesh, targetMesh): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Tool to copy weights from one mesh to another by checking for the closest vertice to each vertice ARGUMENTS: sourceMesh(string) targetMesh(string) RETURNS: None >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ assert mc.objExists(sourceMesh) is True,"'%s' doesn't exist" %sourceMesh assert mc.objExists(targetMesh) is True,"'%s' doesn't exist" %targetMesh targetSkinCluster = querySkinCluster(targetMesh) influenceData = returnVerticeJointWeightDataToDict(sourceMesh) targetVertexList = (mc.ls ([targetMesh+'.vtx[*]'],flatten=True)) sourceVertexList = (mc.ls ([sourceMesh+'.vtx[*]'],flatten=True)) rebuiltVertWeightData = [] for v in targetVertexList: verticeBuffer = [v] """ find the closest vert """ closestVert = distance.returnClosestObject(v,sourceVertexList) print ("Copying " + closestVert + " >>>> " + v) """ rebuild our vert weighting data to set""" verticeBuffer.append(influenceData.get(closestVert)) rebuiltVertWeightData.append(verticeBuffer) setSkinWeights(targetSkinCluster,rebuiltVertWeightData) return rebuiltVertWeightData
def constrainToParentModule(self): """ Pass a module class. Constrains template root to parent's closest template object """ log.debug(">>> constrainToParentModule") if not self.isTemplated(): log.error("Must be template state to contrainToParentModule: '%s' "%self.getShortName()) return False if not self.getMessage('moduleParent'): return False else: log.debug("looking for moduleParent info") i_templateNull = self.templateNull #Link i_parent = self.moduleParent #Link parentState = i_parent.getState() if i_parent.isTemplated():#If the parent has been templated, it makes things easy log.debug("Parent has been templated...") parentTemplateObjects = i_parent.templateNull.getMessage('controlObjects') log.debug("parentTemplateObjects: %s"%parentTemplateObjects) closestObj = distance.returnClosestObject(i_templateNull.getMessage('root')[0],parentTemplateObjects) log.debug("closestObj: %s"%closestObj) if parentTemplateObjects.index(closestObj) == 0:#if it's the first object, connect to the root log.info('Use root for parent object') closestObj = i_parent.templateNull.root.mNode #Find the closest object from the parent's template object log.debug("closestObj: %s"%closestObj) l_constraints = cgmMeta.cgmObject(i_templateNull.root.parent).getConstraintsTo() if cgmMeta.cgmObject(i_templateNull.root.parent).isConstrainedBy(closestObj): log.debug("Already constrained!") return True elif l_constraints:mc.delete(l_constraints) return constraints.doConstraintObjectGroup(closestObj,group = i_templateNull.root.parent,constraintTypes=['point']) else: log.debug("Parent has not been templated...") return False
def simpleControlSurfaceSmoothWeights(surface,maxBlend = 3): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Early version of a weight smoother for a ARGUMENTS: surface(string) RETURNS: Nada >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ cvList = (mc.ls ([surface+'.cv[*][*]'],flatten=True)) skinCluster = querySkinCluster (surface) influenceObjects = queryInfluences (skinCluster) #find the closest influence object to the start startObject = (distance.returnClosestObjToCV (cvList[0], influenceObjects)) #find the closest influence object to the end endObject = (distance.returnClosestObjToCV (cvList[-1], influenceObjects)) #getting the last cv list number cvChainLength = ((len(cvList)-1)/2) #Smooth interior weights """ get our interior CVs """ interiorCvList = [] cnt = 1 for i in range(cvChainLength): interiorCvList.append('%s%s%i%s' % (surface,'.cv[0][',cnt,']')) interiorCvList.append('%s%s%i%s' % (surface,'.cv[1][',cnt,']')) cnt += 1 """ overall blend """ for cv in interiorCvList: closestObject = (distance.returnClosestObjToCV (cv, influenceObjects)) closestObjectsDict = distance.returnClosestObjectsFromAim(closestObject,influenceObjects) upObjects = closestObjectsDict.get('up') downObjects = closestObjectsDict.get('dn') objectsToCheck = [] if upObjects != None: objectsToCheck += upObjects if downObjects != None: objectsToCheck += downObjects blendInfluences =[] blendInfluences.append(closestObject) distances = [] cnt = 1 print objectsToCheck while cnt < maxBlend and cnt < len(objectsToCheck): closestSubObj = distance.returnClosestObject(closestObject, objectsToCheck) blendInfluences.append(closestSubObj) objectsToCheck.remove(closestSubObj) cnt+=1 """ get our distances to normalize """ locBuffer = locators.locMeSurfaceCV(cv) for obj in blendInfluences: distances.append(distance.returnDistanceBetweenObjects(locBuffer,obj)) normalizedDistances = cgmMath.normList(distances, normalizeTo=1) cnt = 0 for obj in blendInfluences: mc.skinPercent (skinCluster,cv, tv = [obj,normalizedDistances[cnt]]) cnt +=1 mc.delete(locBuffer) """ Set closest cv's to respective infuences to max """ cvList1 = [] cvList2 = [] for i in range(cvChainLength): cvList1.append('%s%s%i%s' % (surface,'.cv[0][',cnt,']')) cvList2.append('%s%s%i%s' % (surface,'.cv[1][',cnt,']')) cnt += 1 for obj in influenceObjects: closestCV1 = distance.returnClosestCVFromList(obj, cvList1) mc.skinPercent (skinCluster,closestCV1, tv = [obj,1]) closestCV2 = distance.returnClosestCVFromList(obj, cvList2) mc.skinPercent (skinCluster,closestCV2, tv = [obj,1]) #set the skin weights for the top and bottom mc.skinPercent (skinCluster,(surface+'.cv[0:1][0:1]'), tv = [startObject,1]) mc.skinPercent (skinCluster,('%s%s%i%s%i%s' % (surface,'.cv[0:1][',(cvChainLength-1),':',cvChainLength,']')), tv = [endObject,1]) #Blend in the nearest row to the start and end mc.skinPercent (skinCluster,(surface+'.cv[0:1][2]'), tv = [startObject,1]) mc.skinPercent (skinCluster,('%s%s%i%s' % (surface,'.cv[0:1][',(cvChainLength-2),']')), tv = [endObject,1]) mc.skinPercent (skinCluster,(surface+'.cv[0:1][3]'), tv = [startObject,.7]) mc.skinPercent (skinCluster,('%s%s%i%s' % (surface,'.cv[0:1][',(cvChainLength-3),']')), tv = [endObject,.7])
def rigSpine(moduleNull): #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>>Get our info #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partName = NameFactory.returnUniqueGeneratedName(moduleNull, ignore='cgmType') """ template null """ templateNull = modules.returnTemplateNull(moduleNull) templateNullData = attributes.returnUserAttrsToDict(templateNull) jointOrientation = modules.returnSettingsData('jointOrientation') templateRoot = modules.returnInfoNullObjects(moduleNull, 'templatePosObjects', types='templateRoot') """ AutonameStuff """ divider = NameFactory.returnCGMDivider() """ control helper objects """ controlTemplateObjects = modules.returnInfoNullObjects( moduleNull, 'templateControlObjects', types='all') controlTemplateObjects = distance.returnDistanceSortedList( templateRoot, controlTemplateObjects) print 'controlTemplateObjects...' print controlTemplateObjects """size list of template control objects """ controlTemplateObjectsSizes = [] for obj in controlTemplateObjects: controlTemplateObjectsSizes.append( distance.returnAbsoluteSizeCurve(obj)) print 'sizes...' print controlTemplateObjectsSizes """ Skin Joints """ skinJoints = modules.returnInfoNullObjects(moduleNull, 'skinJoints', types='all') skinJoints = distance.returnDistanceSortedList(templateRoot, skinJoints) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Make Controls #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ control options """ fk = templateNullData.get('fk') ik = templateNullData.get('ik') stretch = templateNullData.get('stretch') bend = templateNullData.get('bend') """controls to make """ controlsToMake = [] controlsToMake.append('cog') if fk == True: controlsToMake.append('segmentControls') controlsToMake.append('hips') if ik == True: controlsToMake.append('vectorHandles') controlsToMake.append('spineIKHandle') controlsDict = modules.limbControlMaker(moduleNull, controlsToMake) print controlsDict #>>> Organize em segmentControls = controlsDict.get('segmentControls') spineIKHandle = controlsDict.get('spineIKHandle') cog = controlsDict.get('cog') hips = controlsDict.get('hips') vectorHandles = controlsDict.get('vectorHandles') for handle in vectorHandles[-1:]: mc.delete(handle) vectorHandles.remove(handle) #>>> Parent em rigging.parentListToHeirarchy(segmentControls) mc.parent(spineIKHandle, segmentControls[-1]) mc.parent(segmentControls[0], cog) mc.parent(hips, cog) for obj in segmentControls: rigging.zeroTransformMeObject(obj) mc.makeIdentity(obj, apply=True, translate=True) for obj in vectorHandles: mc.makeIdentity(obj, apply=True, translate=True) """ hips anchor locator """ locBuffer = locators.locMeObject(hips) attributes.storeInfo(locBuffer, 'cgmName', hips) attributes.storeInfo(locBuffer, 'cgmTypeModifier', 'anchor') hipsAnchor = NameFactory.doNameObject(locBuffer) mc.setAttr((hipsAnchor + '.rotateOrder'), 5) pointConstraintBuffer = mc.pointConstraint(hips, hipsAnchor, maintainOffset=False, weight=1) orientConstraintBuffer = mc.orientConstraint(hips, hipsAnchor, maintainOffset=False, skip=['x', 'y'], weight=1) """ hips anchor group constraint """ groupBuffer = rigging.groupMeObject(hipsAnchor) attributes.storeInfo(groupBuffer, 'cgmName', hipsAnchor) attributes.storeInfo(groupBuffer, 'cgmTypeModifier', 'orient') hipsAnchorOrGroup = NameFactory.doNameObject(groupBuffer) orientConstraintBuffer = mc.orientConstraint(segmentControls[0], hipsAnchorOrGroup, maintainOffset=False, weight=1) """ end anchor locator """ locBuffer = locators.locMeObject(segmentControls[-1]) attributes.storeInfo(locBuffer, 'cgmName', segmentControls[-1]) attributes.storeInfo(locBuffer, 'cgmTypeModifier', 'anchor') endAnchor = NameFactory.doNameObject(locBuffer) mc.setAttr((endAnchor + '.rotateOrder'), 5) mc.parent(endAnchor, spineIKHandle) #>>> set up follow chains constraintChain = [] constraintChain.append(hipsAnchor) constraintChain = constraintChain + vectorHandles constraintChain.append(endAnchor) constraintChainReturn = constraints.doSegmentAimPointConstraint( constraintChain) print constraintChainReturn vectorHandlesZeroGroups = [] for obj in vectorHandles: vectorHandlesZeroGroups.append(rigging.zeroTransformMeObject(obj)) """ parent the last group to our IK handle """ #mc.parent(vectorHandlesZeroGroups[-1],spineIKHandle) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Joint Chains #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ surface chain """ dupJointsBuffer = mc.duplicate(skinJoints[:-1], po=True, rc=True) surfaceJoints = [] for joint in dupJointsBuffer: attributes.storeInfo(joint, 'cgmType', 'surfaceJoint') surfaceJoints.append(NameFactory.doNameObject(joint)) """ firm start """ startJointsBuffer = mc.duplicate(skinJoints[0], po=True, rc=True) startJoints = [] for joint in startJointsBuffer: attributes.storeInfo(joint, 'cgmType', 'deformationJoint') startJoints.append(NameFactory.doNameObject(joint)) """ firm end """ endJointsBuffer = mc.duplicate(skinJoints[-2:], po=True, rc=True) endJoints = [] for joint in endJointsBuffer: attributes.storeInfo(joint, 'cgmType', 'deformationJoint') endJoints.append(NameFactory.doNameObject(joint)) mc.parent(endJoints[0], world=True) #>>> Influence chain """ get the root joints from our main chain searching by "cgmName" tags...maybe not the best way Maybe should change to search to closest joints """ influenceJointsBuffer = [] for obj in surfaceJoints: if (search.returnTagInfo(obj, 'cgmName')) != False: influenceJointsBuffer.append(obj) """ make our influence joints """ influenceJoints = [] for joint in influenceJointsBuffer: buffer = mc.duplicate(joint, po=True) closestObject = distance.returnClosestObject(buffer[0], surfaceJoints) attributes.storeInfo(buffer[0], 'cgmName', closestObject) attributes.storeInfo(buffer[0], 'cgmType', 'influenceJoint') rigging.doParentToWorld(buffer[0]) influenceJoints.append(NameFactory.doNameObject(buffer[0])) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Put our deformation joints in the rig #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ############### need better way of doing this for iterative mc.parent(endJoints[0], spineIKHandle) mc.parent(startJoints[0], hips) mc.parent(influenceJoints[0], hipsAnchor) mc.parent(influenceJoints[1], vectorHandles[0]) mc.parent(influenceJoints[2], spineIKHandle) #mc.parent(influenceJoints[3],spineIKHandle) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Control Surface #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ create """ orientationBuffer = list(jointOrientation) outChannel = orientationBuffer[2] upChannel = (orientationBuffer[1] + 'up') print upChannel surfaceBuffer = joints.loftSurfaceFromJointList(surfaceJoints, outChannel) controlSurface = surfaceBuffer[0] attributes.copyUserAttrs(moduleNull, controlSurface, attrsToCopy=['cgmName']) attributes.storeInfo(controlSurface, 'cgmType', 'controlSurface', True) controlSurface = NameFactory.doNameObject(controlSurface) """ connect joints to surface""" surfaceConnectReturn = joints.attachJointChainToSurface( surfaceJoints, controlSurface, jointOrientation, upChannel, 'animCrv') print surfaceConnectReturn """ surface influence joints skinning""" surfaceSkinCluster = mc.skinCluster(influenceJoints, controlSurface, tsb=True, n=(controlSurface + '_skinCluster'), maximumInfluences=3, normalizeWeights=1, dropoffRate=1) #surfaceSkinCluster = mc.skinCluster (influenceJoints,controlSurface,tsb=True, n=(controlSurface+'_skinCluster'),maximumInfluences = 3, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) controlSurfaceSkinCluster = surfaceSkinCluster[0] """ smooth skin weights """ skinning.simpleControlSurfaceSmoothWeights(controlSurface) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Connect skin joints to surface joints #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deformationJoints = [] deformationJoints.append(startJoints[0]) deformationJoints = deformationJoints + surfaceJoints[1:-2] deformationJoints = deformationJoints + endJoints for joint in skinJoints: attachJoint = distance.returnClosestObject(joint, deformationJoints) pntConstBuffer = mc.pointConstraint(attachJoint, joint, maintainOffset=False, weight=1) orConstBuffer = mc.orientConstraint(attachJoint, joint, maintainOffset=False, weight=1) #mc.connectAttr((attachJoint+'.t'),(joint+'.t')) #mc.connectAttr((attachJoint+'.r'),(joint+'.r')) mc.connectAttr((attachJoint + '.s'), (joint + '.s')) pntConstBuffer = mc.pointConstraint(attachJoint, joint, maintainOffset=False, weight=1) orConstBuffer = mc.orientConstraint(attachJoint, joint, maintainOffset=False, weight=1)
def surfRigger(objectNull,anchor,worldScale,mirror,mode,jointsPerChain,deformChains,ctrlChains): """ Get variables""" nullBase = names.stripSuffixObj (objectNull) templateNull = (nullBase + '_templateNull') moverNull = (nullBase + '_mover') templateNullMessageData = [] templateNullMessageData = attributes.returnMessageAttrs (templateNull) templateObjects = [] coreNamesList = [] spineJointNumber = int(mc.getAttr (objectNull+'.rollJoints')) #spineChainList = search.returnChildrenJoints (spineChain) spineChainList = [] spineChainList.append (anchor) jointChains = [] for set in templateNullMessageData: templateObjects.append (set[1]) coreNamesList.append (set[0]) #>>>>>>>>>>>>>>>>>>>>>Store skin joint data """ check for master skin info group """ if mc.objExists ('master_skinJntList_grp'): masterSkinJointList = ('master_skinJntList_grp') else: masterSkinJointList = mc.group (n= ('master_skinJntList_grp'), w=True, empty=True) mc.parent(masterSkinJointList,'rigStuff_grp') """ check for segment skin info group """ if mc.objExists (nullBase+'_skinJntList_grp'): skinJointListGrp = (nullBase+'_skinJntList_grp') else: skinJointListGrp = mc.group (n= (nullBase+'_skinJntList_grp'), w=True, empty=True) attributes.storeObjNameToMessage (skinJointListGrp,masterSkinJointList) mc.parent (skinJointListGrp,masterSkinJointList) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ Rebuild curve - with actual curve in it!""" mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5) mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5) mc.rebuildCurve ((templateObjects[11]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5) """ Reverse the curve """ mc.reverseCurve ((templateObjects[3]),ch=False,rpo=True) mc.reverseCurve ((templateObjects[7]),ch=False,rpo=True) mc.reverseCurve ((templateObjects[11]),ch=False,rpo=True) """ loft our surface to figure out joint positions, then delete it""" controlSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(ctrlChains-mode),ch=1,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True) mc.select (cl=True) jointChains = joints.createJointChainsFromLoftSurface (nullBase,controlSurface[0],2,False) frontChain = jointChains[0] backChain = jointChains[-1] """ Chain - orienting, sizing """ for chain in jointChains: joints.orientJointChain (chain, 'xyz', 'zup') joints.setGoodJointRadius(chain,.5) #IF we have mode 0, gotta make a main ctrl if mode == 0: midChain = [] if (len(jointChains)) > 3: midChain = jointChains[int(len(jointChains)/2)] else: midChain = jointChains[1] jointChains.remove(midChain) if ctrlChains > 2: masterCtrlBuffer = mc.duplicate (midChain[0],parentOnly=True) else: masterCtrlBuffer = midChain[0] mc.delete (midChain[1]) masterCtrl = mc.rename (masterCtrlBuffer,(nullBase+'_master_anim')) position.movePointSnap(masterCtrl,moverNull) """ temp parenting the master control for mirroring purposes """ spineHookJoint = distance.returnClosestObject (masterCtrl, spineChainList) mc.parent (masterCtrl,spineHookJoint) mc.delete (controlSurface[0]) #>>>>>>>>>>>>Parent time """ Get closest joint """ if mode == 0: for chain in jointChains: mc.parent (chain[0],masterCtrl) else: for chain in jointChains: tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) mc.parent (chain[0],tailHookJoint) #>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ctrl Joints to Ctrls cnt = 0 for chain in jointChains: ctrlSize = (distance.returnAverageDistanceBetweenObjects (chain)/2) for jnt in chain[0:-1]: rigging.makeObjCtrl (jnt,ctrlSize) """ adds our Anim tag """ chainBuffer = [] chainBuffer = names.addSuffixList ('anim', chain) jointChains[cnt]= chainBuffer cnt +=1 #>>>>>>>>>>>>>>>>>>>Mirroring while getting chain info """ If mirroring ....""" if mirror == True: # if we have a main control leftSkinChains = [] rightSkinChains = [] masterCtrls = [] if mode == 0: leftChain = [] rightChain = [] finHeirarchy = [] finHeirarchy.append (masterCtrl) children = search.returnChildrenJoints (masterCtrl) finHeirarchy += children leftChain = names.addPrefixList ('left',finHeirarchy) masterCtrl = leftChain [0] rightChainBuffer = mc.mirrorJoint (masterCtrl,mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right']) rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint') rightChain = rightChainJointBuffer leftSkinChains.append(leftChain) rightSkinChains.append(rightChain) masterCtrls.append(leftChain[0]) masterCtrls.append(rightChain[0]) else: for chain in jointChains: leftChain =[] leftChain = names.addPrefixList ('left',chain) rightChainBuffer = (mc.mirrorJoint (leftChain[0],mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right'])) rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint') rightChain = rightChainJointBuffer rightSkinChains.append (rightChainJointBuffer) leftSkinChains.append (leftChain) """ complile our chains to lists of skin joints """ leftSkinJointList=[] rightSkinJointList=[] for chain in leftSkinChains: for jnt in chain: leftSkinJointList.append (jnt) for chain in rightSkinChains: for jnt in chain: rightSkinJointList.append (jnt) """if we're not mirroring, let's return our skin joints for the deformation surface""" else: skinJointList = [] skinChains = [] for chain in jointChains: skinChains.append (chain) for jnt in chain: skinJointList.append (jnt) #>>>>>>>>>>>>>>>>>>>>>>>>>>Time to make the deformation surface stuff """ Rebuild curve - with actual curve in it!""" #mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5) #mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5) """ loft our surface to figure out joint positions, then delete it""" deformSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(deformChains-1),ch=0,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True) if mirror == True: deformSurfaceNameBuffer = deformSurface[0] """we have a surface to mirror...""" surfaceMirrorBuffer = mc.duplicate (deformSurface[0]) mc.setAttr ((surfaceMirrorBuffer[0]+'.sx'),-1) leftBuffer = mc.rename (deformSurface[0],('left_'+deformSurfaceNameBuffer)) rightBuffer = mc.rename (surfaceMirrorBuffer[0],('right_'+deformSurfaceNameBuffer)) deformSurface[0]=leftBuffer deformSurface.append(rightBuffer) leftDeformJointChains = joints.createJointChainsFromLoftSurface (('left_'+nullBase),deformSurface[0],2,False) rightDeformJointChains = joints.createJointChainsFromLoftSurface (('right_'+nullBase),deformSurface[1],2,False) """ Connecting to surface """ for chain in leftDeformJointChains: attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup') tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) """ break the connection so we can parent it""" """first return the original thing to follow""" parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate')) attributes.doBreakConnection (chain[0]+'.translate') #mc.parent (chain[0],tailHookJoint) """ reconstrain it to the driver""" constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True) mc.rename (constraintBuffer[0],(chain[0]+'_pointConst')) """ store the skin joint data """ for jnt in chain: attributes.storeObjNameToMessage (jnt,skinJointListGrp) for chain in rightDeformJointChains: attachSurfaceMirrorReturn = joints.attachJointChainToSurface (chain,deformSurface[1],'xyz','zup') tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) """ break the connection s we can parent it""" """first return the original thing to follow""" parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate')) attributes.doBreakConnection (chain[0]+'.translate') #mc.parent (chain[0],tailHookJoint) """ reconstrain it to the driver""" constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True) mc.rename (constraintBuffer[0],(chain[0]+'_pointConst')) """ store the skin joint data """ for jnt in chain: attributes.storeObjNameToMessage (jnt,skinJointListGrp) """ parent the scale stuff to rig stuff grp""" mc.select (cl=True) for item in attachSurfaceReturn[0]: mc.parent(item,'rigStuff_grp') for item in attachSurfaceMirrorReturn[0]: mc.parent(item,'rigStuff_grp') """ hook up world scale """ mc.connectAttr (worldScale,attachSurfaceReturn[1]) mc.connectAttr (worldScale,attachSurfaceMirrorReturn[1]) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Skin in the control joints """ Time to set skin our surface to our control joints """ mc.skinCluster (leftSkinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) mc.skinCluster (rightSkinJointList,deformSurface[1],tsb=True, n=(deformSurface[1]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) #>>>>>If we,re not mirrored, let's make our deform setup else: deformJointChains = [] deformJointChains = joints.createJointChainsFromLoftSurface (nullBase,deformSurface[0],2,False) """ Connecting to surface """ for chain in deformJointChains: attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup') tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) """ break the connection so we can parent it""" """first return the original thing to follow""" parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate')) attributes.doBreakConnection (chain[0]+'.translate') #mc.parent (chain[0],tailHookJoint) """ reconstrain it to the driver""" constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True) mc.rename (constraintBuffer[0],(chain[0]+'_pointConst')) """ store the skin joint data """ for jnt in chain: attributes.storeObjNameToMessage (jnt,skinJointListGrp) """ hook up world scale """ partScaleBuffer = attachSurfaceReturn[1] mc.connectAttr (worldScale, partScaleBuffer) """ parent the scale stuff to rig stuff grp""" mc.select (cl=True) for item in attachSurfaceReturn[0]: mc.parent(item,'rigStuff_grp') """ Time to set skin our surface to our control joints """ mc.skinCluster (skinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) """ Setting up the joint starts""" if mode == 0: if mirror == True: for ctrl in masterCtrls: rigging.makeObjCtrl (ctrl,(ctrlSize*4)) masterCtrlGrp = rigging.groupMeObject (ctrl,True) """ Get closest joint and connect the Cntrl """ spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList) mc.parent(masterCtrlGrp,spineHookJoint) else: rigging.makeObjCtrl (masterCtrl,(ctrlSize*4)) masterCtrlGrp = rigging.groupMeObject (masterCtrl,True) """ Get closest joint and connect the Cntrl """ spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList) mc.parent(masterCtrlGrp,spineHookJoint) #else we need to connect the individual chains to the spine else: if mirror == True: for chain in leftSkinChains: chainCtrlGrp = rigging.groupMeObject (chain[0],True) spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList) mc.parent(chainCtrlGrp,spineHookJoint) for chain in rightSkinChains: chainCtrlGrp = rigging.groupMeObject (chain[0],True) spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList) mc.parent(chainCtrlGrp,spineHookJoint) else: for chain in skinChains: chainCtrlGrp = rigging.groupMeObject (chain[0],True) spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList) mc.parent(chainCtrlGrp,spineHookJoint)
def makeLimbTemplate (self): #>>>Curve degree finder if self.optionCurveDegree.get() == 0: doCurveDegree = 1 else: if len(corePositionList) <= 3: doCurveDegree = 1 else: doCurveDegree = len(corePositionList) - 1 #Make some storage vehicles self.templatePosObjectsBuffer = BufferFactory(self.infoNulls['templatePosObjects'].get()) self.templatePosObjectsBuffer.purge() LocatorCatcher = ObjectFactory('') LocatorBuffer = BufferFactory(LocatorCatcher.nameLong) LocatorBuffer.purge() returnList = [] self.templHandleList = [] moduleColors = modules.returnModuleColors(self.ModuleNull.nameShort) #>>>Scale stuff moduleParent = self.msgModuleParent.get() if not moduleParent: length = (distance.returnDistanceBetweenPoints (corePositionList[0],corePositionList[-1])) size = length / self.optionHandles.get() else: #>>>>>>>>>>>>>>>>>>>>> NOT TOUCHED YET parentTemplatePosObjectsInfoNull = modules.returnInfoTypeNull(moduleParent,'templatePosObjects') parentTemplatePosObjectsInfoData = attributes.returnUserAttrsToDict (parentTemplatePosObjectsInfoNull) parentTemplateObjects = [] for key in parentTemplatePosObjectsInfoData.keys(): if (mc.attributeQuery (key,node=parentTemplatePosObjectsInfoNull,msg=True)) == True: if search.returnTagInfo((parentTemplatePosObjectsInfoData[key]),'cgmType') != 'templateCurve': parentTemplateObjects.append (parentTemplatePosObjectsInfoData[key]) createBuffer = curves.createControlCurve('sphere',1) pos = corePositionList[0] mc.move (pos[0], pos[1], pos[2], createBuffer, a=True) closestParentObject = distance.returnClosestObject(createBuffer,parentTemplateObjects) boundingBoxSize = distance.returnBoundingBoxSize (closestParentObject) maxSize = max(boundingBoxSize) size = maxSize *.25 mc.delete(createBuffer) if partType == 'clavicle': size = size * .5 elif partType == 'head': size = size * .75 if (search.returnTagInfo(moduleParent,'cgmModuleType')) == 'clavicle': size = size * 2 #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> # Making the template objects #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self.TemplateObject = {} #>>> Template objects for cnt,pos in enumerate(corePositionList): #Size multiplier based on PuppetMode, make it take into account module mode eventually if PuppetInstance.optionPuppetMode.get() == 0: if cnt == 0: sizeMultiplier = 1 elif cnt == len(corePositionList) -1: sizeMultiplier = .8 else: sizeMultiplier = .5 else: sizeMultiplier = 1 #make a sphere and move it createBuffer = curves.createControlCurve('sphere',(size * sizeMultiplier)) self.TemplateObject[cnt] = ObjectFactory(createBuffer) # Instance the control to our module obj = self.TemplateObject[cnt] curves.setCurveColorByName(obj.nameLong,moduleColors[0]) obj.store('cgmName',coreNames[cnt]) obj.getNameTagsFromObject(self.ModuleNull.nameLong,['cgmName','cgmType']) obj.store('cgmType','templateObject') obj.doName() mc.move (pos[0], pos[1], pos[2], [obj.nameLong], a=True) #adds it to the list self.templHandleList.append (obj.nameLong) self.templatePosObjectsBuffer.store(obj.nameLong) #Aim the objects position.aimObjects(self.templHandleList, dictionary.axisDirectionsByString[ self.optionAimAxis.get() ], dictionary.axisDirectionsByString[ self.optionUpAxis.get() ], dictionary.axisDirectionsByString[ PuppetInstance.optionUpAxis.get() ]) #>>> Template curve crvName = mc.curve (d=doCurveDegree, p = corePositionList , os=True, n=('%s_%s' %(partName,(typesDictionary.get('templateCurve'))))) self.afTemplateCurve = AttrFactory(self.infoNulls['templatePosObjects'].get(), 'curve','message', value=crvName)# connect it back to our template objects info null curve = ObjectFactory(crvName) # instance it curve.getNameTagsFromObject(self.ModuleNull.nameLong,['cgmType']) #get name tags from the module attributes.storeInfo(crvName,'cgmType','templateCurve') # store type curves.setCurveColorByName(crvName,moduleColors[1]) # set curve color # Make locators to connect the cv's to for cnt,obj in enumerate(self.templHandleList): pointLoc = locators.locMeObject(obj) # make the loc loc = ObjectFactory(pointLoc) #instance it mc.setAttr ((loc.nameShort+'.visibility'),0) # turn off visibility mc.parentConstraint ([obj],[loc.nameShort],mo=False) # parent constrain mc.connectAttr ( (loc.nameShort+'.translate'), ('%s.controlPoints[%i]' % (crvName, cnt)), f=True ) # connect the cv to the loc self.TemplateObject[cnt].store('loc',loc.nameLong) LocatorBuffer.store(loc.nameLong) #>>> Direction and size Stuff """ # Directional data derived from joints generalDirection = logic.returnHorizontalOrVertical(self.templHandleList) if generalDirection == 'vertical' and 'leg' not in self.afModuleType.get(): worldUpVector = [0,0,-1] elif generalDirection == 'vertical' and 'leg' in self.afModuleType.get(): worldUpVector = [0,0,1] else: worldUpVector = [0,1,0] """ # Create root control templateNull = self.msgTemplateNull.get() handleList = copy.copy(self.templatePosObjectsBuffer.bufferList) rootSize = (distance.returnBoundingBoxSizeToAverage(self.templHandleList[0])*1.5) rootCtrl = ObjectFactory(curves.createControlCurve('cube',rootSize)) rootCtrl.getNameTagsFromObject(self.ModuleNull.nameLong) self.msgTemplateRoot = AttrFactory(self.infoNulls['templatePosObjects'].get(), 'root', 'message', value = rootCtrl.nameLong) curves.setCurveColorByName(rootCtrl.nameLong,moduleColors[0]) # move the root if self.afModuleType.get() == 'clavicle': position.movePointSnap(rootCtrl.nameLong,self.templHandleList[0]) else: position.movePointSnap(rootCtrl.nameLong,self.templHandleList[0]) # aim the root position.aimSnap(rootCtrl.nameShort,self.templHandleList[-1], dictionary.axisDirectionsByString[ self.optionAimAxis.get() ], dictionary.axisDirectionsByString[ self.optionUpAxis.get() ], dictionary.axisDirectionsByString[ PuppetInstance.optionUpAxis.get() ]) rootCtrl.store('cgmType','templateRoot') rootCtrl.doName() #>>> Parent the main objcts rootGroup = rootCtrl.doGroup() rootGroup = rigging.doParentReturnName(rootGroup,templateNull) curve.doParent(templateNull) for obj in LocatorBuffer.bufferList: rigging.doParentReturnName(obj,templateNull) mc.delete(LocatorCatcher.nameShort) # delete the locator buffer obj #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>> Orientation helpers #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> # Make our Orientation Helpers """ orientHelpersReturn = template.addOrientationHelpers(self) masterOrient = orientHelpersReturn[0] orientObjects = orientHelpersReturn[1] return #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>> Control helpers #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> print orientObjects print self.ModuleNull.nameShort print (templateNull+'.visControlHelpers') controlHelpersReturn = addControlHelpers(orientObjects,self.ModuleNull.nameShort,(templateNull+'.visControlHelpers'))""" #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>> Input the saved values if there are any #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> # Orientation Helpers """rotBuffer = coreRotationList[-1] #actualName = mc.spaceLocator (n= wantedName) rotCheck = sum(rotBuffer) if rotCheck != 0: mc.rotate(rotBuffer[0],rotBuffer[1],rotBuffer[2],masterOrient,os=True) cnt = 0 for obj in orientObjects: rotBuffer = coreRotationList[cnt] rotCheck = sum(rotBuffer) if rotCheck != 0: mc.rotate(rotBuffer[0],rotBuffer[1],rotBuffer[2],obj,os=True) cnt +=1 # Control Helpers controlHelpers = controlHelpersReturn[0] cnt = 0 for obj in controlHelpers: posBuffer = controlPositionList[cnt] posCheck = sum(posBuffer) if posCheck != 0: mc.xform(obj,t=[posBuffer[0],posBuffer[1],posBuffer[2]],ws=True) rotBuffer = controlRotationList[cnt] rotCheck = sum(rotBuffer) if rotCheck != 0: mc.rotate(rotBuffer[0],rotBuffer[1],rotBuffer[2],obj,ws=True) scaleBuffer = controlScaleList[cnt] scaleCheck = sum(scaleBuffer) if scaleCheck != 0: mc.scale(scaleBuffer[0],scaleBuffer[1],scaleBuffer[2],obj,absolute=True) cnt +=1 """ #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>> Final stuff #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ returnList.append(templObjNameList) returnList.append(self.templHandleList) returnList.append(rootCtrl)""" return True
def skeletonize(moduleNull, stiffIndex=0): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Basic limb skeletonizer ARGUMENTS: moduleNull(string) stiffIndex(int) - the index of the template objects you want to not have roll joints For example, a value of -1 will let the chest portion of a spine segment be solid instead of having a roll segment. Default is '0' which will put roll joints in every segment RETURNS: limbJoints(list) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>>Get our info #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partName = NameFactory.returnUniqueGeneratedName(moduleNull, ignore='cgmType') """ template null """ templateNull = modules.returnTemplateNull(moduleNull) templateNullData = attributes.returnUserAttrsToDict(templateNull) """ template object nulls """ templatePosObjectsInfoNull = modules.returnInfoTypeNull( moduleNull, 'templatePosObjects') templateControlObjectsNull = modules.returnInfoTypeNull( moduleNull, 'templateControlObjects') templatePosObjectsInfoData = attributes.returnUserAttrsToDict( templatePosObjectsInfoNull) templateControlObjectsData = attributes.returnUserAttrsToDict( templateControlObjectsNull) jointOrientation = modules.returnSettingsData('jointOrientation') moduleRootBuffer = modules.returnInfoNullObjects(moduleNull, 'templatePosObjects', types='templateRoot') moduleRoot = moduleRootBuffer[0] stiffIndex = templateNullData.get('stiffIndex') rollJoints = templateNullData.get('rollJoints') """ AutonameStuff """ divider = NameFactory.returnCGMDivider() skinJointsNull = modules.returnInfoTypeNull(moduleNull, 'skinJoints') templateObjects = [] coreNamesArray = [] #>>>TemplateInfo for key in templatePosObjectsInfoData.keys(): if (mc.attributeQuery(key, node=templatePosObjectsInfoNull, msg=True)) == True: templateObjects.append(templatePosObjectsInfoData[key]) coreNamesArray.append(key) posTemplateObjects = [] """ Get the positional template objects""" for obj in templateObjects: bufferList = obj.split(divider) if (typesDictionary.get('templateObject')) in bufferList: posTemplateObjects.append(obj + divider + typesDictionary.get('locator')) """put objects in order of closeness to root""" posTemplateObjects = distance.returnDistanceSortedList( moduleRoot, posTemplateObjects) curve = (templatePosObjectsInfoData['curve']) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Actually making the skeleton with consideration for roll joints and the stiffIndex! #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if stiffIndex == 0: """ If no roll joints """ limbJoints = joints.createJointsFromCurve(curve, partName, rollJoints) else: rolledJoints = joints.createJointsFromCurve(curve, partName, rollJoints) if rollJoints == 0: limbJoints = rolledJoints else: if stiffIndex < 0: """ Get our to delete number in a rolledJoints[-4:] format""" #searchIndex = (int('%s%s' %('-',(rollJoints+1)))*abs(stiffIndex)-1) searchIndex = (int('%s%s' % ('-', (rollJoints + 1))) * abs(stiffIndex)) toDelete = rolledJoints[searchIndex:] """ delete out the roll joints we don't want""" mc.delete(toDelete[0]) for name in toDelete: rolledJoints.remove(name) """ make our stiff joints """ jointPositions = [] if abs(stiffIndex) == 1: jointPositions.append( distance.returnClosestUPosition( posTemplateObjects[stiffIndex], curve)) else: for obj in posTemplateObjects[stiffIndex:]: jointPositions.append( distance.returnClosestUPosition(obj, curve)) stiffJoints = joints.createJointsFromPosListName( jointPositions, 'partName') """ connect em up """ mc.parent(stiffJoints[0], rolledJoints[-1]) limbJoints = [] for joint in rolledJoints: limbJoints.append(joint) for joint in stiffJoints: limbJoints.append(joint) else: """ if it's not negative, it's positive....""" searchIndex = ((rollJoints + 1) * abs(stiffIndex)) toDelete = rolledJoints[:searchIndex] toKeep = rolledJoints[searchIndex:] """ delete out the roll joints we don't want""" mc.parent(toKeep[0], world=True) mc.delete(toDelete[0]) for name in toDelete: rolledJoints.remove(name) """ make our stiff joints """ jointPositions = [] if abs(stiffIndex) == 1: jointPositions.append( distance.returnClosestUPosition( posTemplateObjects[stiffIndex - 1], curve)) else: for obj in posTemplateObjects[:stiffIndex]: jointPositions.append( distance.returnClosestUPosition(obj, curve)) stiffJoints = joints.createJointsFromPosListName( jointPositions, 'partName') """ connect em up """ mc.parent(rolledJoints[0], stiffJoints[-1]) limbJoints = [] for joint in stiffJoints: limbJoints.append(joint) for joint in rolledJoints: limbJoints.append(joint) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Naming #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ Copy naming information from template objects to the joints closest to them copy over a cgmNameModifier tag from the module first """ attributes.copyUserAttrs(moduleNull, limbJoints[0], attrsToCopy=['cgmNameModifier']) """ First we need to find our matches """ for obj in posTemplateObjects: closestJoint = distance.returnClosestObject(obj, limbJoints) transferObj = attributes.returnMessageObject(obj, 'cgmName') """Then we copy it""" attributes.copyUserAttrs( transferObj, closestJoint, attrsToCopy=['cgmNameModifier', 'cgmDirection', 'cgmName']) limbJointsBuffer = NameFactory.doRenameHeir(limbJoints[0]) limbJoints = [] limbJoints.append(limbJointsBuffer[0]) for joint in limbJointsBuffer[1]: limbJoints.append(joint) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Orientation #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> limbJoints = orientSegment(limbJoints, posTemplateObjects, jointOrientation) #>>> Set its radius and toggle axis visbility on #averageDistance = distance.returnAverageDistanceBetweenObjects (limbJoints) jointSize = ( distance.returnDistanceBetweenObjects(limbJoints[0], limbJoints[-1]) / 6) for jnt in limbJoints: mc.setAttr((jnt + '.radi'), jointSize * .2) #>>>>>>> TEMP joints.toggleJntLocalAxisDisplay(jnt) print 'to orientation' #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #>>> Storing data #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> skinJointsNull = modules.returnInfoTypeNull(moduleNull, 'skinJoints') skinJointsNullData = attributes.returnUserAttrsToList(skinJointsNull) existingSkinJoints = lists.removeMatchedIndexEntries( skinJointsNullData, 'cgm') print existingSkinJoints if len(existingSkinJoints) > 0: for entry in existingSkinJoints: attrBuffer = (skinJointsNull + '.' + entry[0]) print attrBuffer attributes.doDeleteAttr(skinJointsNull, entry[0]) for i in range(len(limbJoints)): buffer = ('%s%s' % ('joint_', i)) attributes.storeInfo(skinJointsNull, buffer, limbJoints[i]) return limbJoints
i_rig = Rig.go(m1,forceNew=False)#call to do general rig m1.templateNull.handles rUtils.createEyeballRig('l_eye_rigHelper',aimTargetObject = 'l_eye_ik_anim', buildIK=True) i_rig.build(i_rig,buildTo = 'controls') i_rig.buildModule.build_rigSkeleton(i_rig) i_rig.buildModule.build_shapes(i_rig) i_rig.buildModule.build_controls(i_rig) i_rig.buildModule.build_FKIK(i_rig) i_rig.buildModule.build_deformation(i_rig) i_rig.buildModule.build_rig(i_rig) i_rig.buildModule.__build__(i_rig) from cgm.lib import distance l_constrainTargetJoints = [u'l_left_index_1_blend_jnt', u'l_left_index_2_blend_jnt', u'l_left_index_3_blend_jnt', u'l_left_index_4_blend_jnt', u'l_left_index_5_blend_jnt'] distance.returnClosestObject('l_left_index_1_rig_jnt',l_constrainTargetJoints) m1.rigNull.getMessage('blendJoints',False) m1.moduleParent.rigNull.rigJoints[-1] i_rig.buildModule.build_matchSystem(i_rig) reload(Rig) from cgm.lib import cgmMath cgmMath.isFloatEquivalent(0.002,0,2) rUtils.matchValue_iterator(drivenAttr='l_left_index_2_ik_jnt.rz',driverAttr='left_index_noFlip_ikH.twist',minIn = -179, maxIn = 179, maxIterations = 5,matchValue=0) cgmMeta.cgmObject('l_ankle_ik_anim').scalePivotY = 0 i_rig._i_deformNull.controlsIK ml_ikJoints = m1.rigNull.ikJoints ml_fkJoints = m1.rigNull.fkJoints ml_blendJoints = m1.rigNull.blendJoints mi_settings = m1.rigNull.settings
def build_rig(goInstance = None): class fncWrap(modUtils.rigStep): def __init__(self,goInstance = None): super(fncWrap, self).__init__(goInstance) self._str_funcName = 'build_rig(%s)'%self.d_kws['goInstance']._strShortName self.__dataBind__() self.l_funcSteps = [{'step':'Build NOT BROKEN UP YET','call':self.build}] #================================================================= def build(self):#================================================================================ try:#>>>Get data orientation = self._go._jointOrientation or modules.returnSettingsData('jointOrientation') mi_moduleParent = False if self._go._mi_module.getMessage('moduleParent'): mi_moduleParent = self._go._mi_module.moduleParent mi_controlIK = self._go._i_rigNull.controlIK ml_controlsFK = self._go._i_rigNull.msgList_get('controlsFK') ml_rigJoints = self._go._i_rigNull.msgList_get('rigJoints') ml_blendJoints = self._go._i_rigNull.msgList_get('blendJoints') mi_settings = self._go._i_rigNull.settings log.info("mi_controlIK: %s"%mi_controlIK.getShortName()) log.info("ml_controlsFK: %s"%[o.getShortName() for o in ml_controlsFK]) log.info("mi_settings: %s"%mi_settings.getShortName()) log.info("ml_rigJoints: %s"%[o.getShortName() for o in ml_rigJoints]) log.info("ml_blendJoints: %s"%[o.getShortName() for o in ml_blendJoints]) ml_segmentHandleChains = self._go._get_segmentHandleChains() ml_segmentChains = self._go._get_segmentChains() ml_influenceChains = self._go._get_influenceChains() aimVector = dictionary.stringToVectorDict.get("%s+"%self._go._jointOrientation[0]) upVector = dictionary.stringToVectorDict.get("%s+"%self._go._jointOrientation[1]) #Build our contrain to pool l_constrainTargetJoints = [] """ for ml_chain in ml_segmentChains: l_constrainTargetJoints.extend([i_jnt.mNode for i_jnt in ml_chain[:-1]]) l_constrainTargetJoints.extend([i_jnt.mNode for i_jnt in ml_blendJoints[-2:]]) """ if not l_constrainTargetJoints: l_constrainTargetJoints = [i_jnt.mNode for i_jnt in ml_blendJoints] for i_jnt in ml_blendJoints: attributes.doSetLockHideKeyableAttr(i_jnt.mNode,lock=True, visible=True, keyable=False) i_jnt.radius = 0#This is how we can hide joints without hiding them since we have children we want to ride along i_jnt.drawStyle = 2 for i_jnt in ml_controlsFK: i_jnt.radius = 0#This is how we can hide joints without hiding them since we have children we want to ride along i_jnt.drawStyle = 2 #Set group lockks for mCtrl in self._go._i_rigNull.msgList_get('controlsAll'): try:mCtrl._setControlGroupLocks() except Exception,error:log.error("%s _setControlGroupLocks failed on object: %s"%(self._str_reportStart,mCtrl.p_nameShort)) except Exception,error: log.error("finger.build_rig>> Gather data fail!") raise Exception,error #Dynamic parent groups #==================================================================================== try:#>>>> IK ml_fingerDynParents = [] #Build our dynamic groups """ 1)wrist 2)fk root 3)... 4)world """ if mi_moduleParent: mi_blendEndJoint = mi_moduleParent.rigNull.msgList_get('blendJoints')[-1] mi_parentRigNull = mi_moduleParent.rigNull if mi_moduleParent: mi_parentRigNull = mi_moduleParent.rigNull buffer = mi_parentRigNull.msgList_get('moduleJoints') if buffer: ml_fingerDynParents.append( buffer[-1]) ml_fingerDynParents.append( ml_controlsFK[0]) mi_spine = self._go._mi_module.modulePuppet.getModuleFromDict(moduleType= ['torso','spine']) if mi_spine: log.info("spine found: %s"%mi_spine) mi_spineRigNull = mi_spine.rigNull ml_fingerDynParents.append( mi_spineRigNull.handleIK ) ml_fingerDynParents.append( mi_spineRigNull.cog ) ml_fingerDynParents.append( mi_spineRigNull.hips ) ml_fingerDynParents.append(self._go._i_masterControl) if mi_controlIK.getMessage('spacePivots'): ml_fingerDynParents.extend(mi_controlIK.msgList_get('spacePivots',asMeta = True)) log.info("%s.build_rig>>> Dynamic parents to add: %s"%(self._go._strShortName,[i_obj.getShortName() for i_obj in ml_fingerDynParents])) #Add our parents i_dynGroup = mi_controlIK.dynParentGroup log.info("Dyn group at setup: %s"%i_dynGroup) i_dynGroup.dynMode = 0 for o in ml_fingerDynParents: i_dynGroup.addDynParent(o) i_dynGroup.rebuild() except Exception,error: log.error("finger.build_rig>> finger ik dynamic parent setup fail!") raise Exception,error self._go.collect_worldDynDrivers()#...collect world dyn drivers #Make some connections #==================================================================================== #Parent and constrain joints #==================================================================================== ml_rigJoints[0].parent = self._go._i_deformNull.mNode#shoulder #ml_rigJoints[-1].parent = self._go._i_deformNull.mNode#wrist #For each of our rig joints, find the closest constraint target joint log.info("targetJoints: %s"%l_constrainTargetJoints) l_rigJoints = [i_jnt.mNode for i_jnt in ml_rigJoints] for i,i_jnt in enumerate(ml_rigJoints): #Don't try scale constraints in here, they're not viable log.info("Checking: '%s'"%i_jnt.getShortName()) attachJoint = distance.returnClosestObject(i_jnt.mNode,l_constrainTargetJoints) log.info("'%s'<< drives <<'%s'"%(i_jnt.getShortName(),cgmMeta.cgmNode(attachJoint).getShortName())) pntConstBuffer = mc.pointConstraint(attachJoint,i_jnt.mNode,maintainOffset=False,weight=1) orConstBuffer = mc.orientConstraint(attachJoint,i_jnt.mNode,maintainOffset=False,weight=1) mc.connectAttr((attachJoint+'.s'),(i_jnt.mNode+'.s')) #Setup finger scaling #==================================================================================== #Parent deform Null to last blend parent if mi_moduleParent: mi_blendEndJoint = mi_moduleParent.rigNull.msgList_get('blendJoints')[-1] mi_parentBlendPlug = cgmMeta.cgmAttr(mi_blendEndJoint,'scale') self._go._i_deformNull.parent = mi_blendEndJoint.mNode #connect blend joint scale to the finger blend joints for i_jnt in ml_blendJoints: mi_parentBlendPlug.doConnectOut("%s.scale"%i_jnt.mNode) #intercept world scale on finger IK and add in the blend wrist scale mPlug_moduleMasterScale = cgmMeta.cgmAttr(self._go._i_rigNull,'masterScale',value = 1.0,defaultValue=1.0) mPlug_globalScale = cgmMeta.cgmAttr(self._go._i_masterControl.mNode,'scaleY') mPlug_globalScale.doConnectOut(mPlug_moduleMasterScale) NodeF.argsToNodes("%s = %s * %s.sy"%(mPlug_moduleMasterScale.p_combinedShortName, mPlug_globalScale.p_combinedShortName, mi_blendEndJoint.p_nameShort)).doBuild() try:#Vis Network, lock and hide #==================================================================================== #Segment handles need to lock for ml_chain in ml_segmentHandleChains: for i_obj in ml_chain: attributes.doSetLockHideKeyableAttr(i_obj.mNode,lock=True, visible=False, keyable=False, channels=['s%s'%orientation[1], 's%s'%orientation[2]]) attributes.doSetLockHideKeyableAttr(mi_settings.mNode,lock=True, visible=False, keyable=False) attributes.doSetLockHideKeyableAttr(ml_blendJoints[0].mNode,lock=True, visible=True, keyable=False) for i,mCtrl in enumerate(ml_controlsFK): l_attrs = ['sx','sy','sz','v'] if i != 0: l_attrs.extend(['tx','ty','tz']) attributes.doSetLockHideKeyableAttr(mCtrl.mNode,channels=l_attrs, lock=True, visible=False, keyable=False) attributes.doSetLockHideKeyableAttr(mi_controlIK.mNode,channels=['sx','sy','sz','v'], lock=True, visible=False, keyable=False) except Exception,error: raise Exception,"Lock and hide fail! | {0}".format(error)