def remove_from_all_layer(self, target): target = pm.PyNode(target) target_list = [] target_list.append(target) target_list.append(target.getShapes()) for item in target_list: pm.editDisplayLayerMembers('defaultLayer', item)
def saveReferenceName(pReferenceObject, *pArgs): newLayer = pm.createDisplayLayer(name='Scan') if (newLayer == 'Scan1'): pm.delete('Scan1') pm.editDisplayLayerMembers('Scan', pReferenceObject) myDescription = pm.textField("referenceDescription", query=True, text=True) pm.rename('%s' % (pReferenceObject), 'Scan_%s' % (myDescription)) pm.deleteUI('referenceID')
def moveToLayer(layerName, objectList=[]): """This function takes a set of objects and puts them onto a designated layer. If the layer does not yet exist, it is created. """ if pm.objExists(layerName) == False: # the layer does not exist pm.select(objectList) pm.createDisplayLayer(name=layerName) else: # the layer already exists pm.editDisplayLayerMembers(layerName, objectList)
def moveToLayer(layerName, objectList=[]): """This function takes a set of objects and puts them onto a designated layer. If the layer does not yet exist, it is created. """ if pm.objExists(layerName) == False: # the layer does not exist pm.select(objectList) pm.createDisplayLayer(name=layerName) else: # the layer already exists pm.editDisplayLayerMembers( layerName, objectList )
def run(self): layer = pm.ls(self.name) if len(layer) and isinstance(layer[0], pm.nt.DisplayLayer): pm.editDisplayLayerMembers(layer[0], self.objects) layer = layer[0] else: layer = pm.createDisplayLayer(self.objects, n=self.name) layer.visibility.set(self.visible) layer.displayType.set(self.displayType) layer.shading.set(self.shading) layer.texturing.set(self.texturing) layer.playback.set(self.playback)
def reference_layer(object, **kwargs): """ Creates reference layer "Ref_Layer" if not already made or no new name is provided Adds object to new layer Returns new reference layer """ layer = kwargs.setdefault('name', 'Ref_Layer') if py.objExists(layer) is False: py.createDisplayLayer(empty=True, n=layer) py.setAttr(layer+".dt", 2) py.editDisplayLayerMembers(layer, object) return layer
def flipAll(self, args): layer = self.getAnim('Foxo_Controls') controls = pm.editDisplayLayerMembers(layer, q=True) toFlipControls = [] for control in controls: if '_r_' not in str(control): toFlipControls.append(control) for control in toFlipControls: self.flipAnim(control)
def mirrorAllRL(self, args): layer = self.getAnim('Foxo_Controls') controls = pm.editDisplayLayerMembers(layer, q=True) leftControls = [] for control in controls: if '_r_' in str(control): leftControls.append(control) for control in leftControls: self.mirrorAnim(control)
def importCallback(*Args): loadPopup = pm.confirmDialog(title='Import', message='Choose Gender: ', button=['Female', 'Male', 'Cancel'], dismissString='Cancel') global globalGender localGender = '' if loadPopup == 'Cancel': return else: cmds.NewScene() globalNameKey[:] = [] globalVertexKey[:] = [] if loadPopup == 'Female': pm.mel.FBXImport(f="assets\EqualReality\NudeFemale.fbx") localGender = 'Female' pm.move('persp', [0, 156, 89]) if loadPopup == 'Male': pm.mel.FBXImport(f="assets\EqualReality\NudeMale.fbx") localGender = 'Male' pm.move('persp', [0, 169, 89]) pm.rotate('persp', [-8, 0, 0]) myScene = ['Eyes', 'Eyelashes', 'Body_%s' % (localGender)] pm.createDisplayLayer(name='Game_Model', number=1) for item in myScene: pm.editDisplayLayerMembers('Game_Model', item) #pm.hide('mixamorig:Hips') pm.hide('Eyes') global OnStart OnStart = 1 pm.modelEditor('modelPanel4', edit=True, displayTextures=True) rolloutParameters(names=[None], edit=True) createUI('Poly Morph')
def deleteLayers(): """ delete selected display layers :return: """ type = getLayerDisplayType() if type != "Display": pm.warning("Unsupported layer type. Works on display layers.") return [] selectedLayers = getLayerSelection() for layer in selectedLayers: objs = pm.editDisplayLayerMembers(layer, query=True, fullNames=True) pm.delete(layer) if objs: for obj in objs: pm.setAttr(obj + ".overrideEnabled", 0)
def postbuild(self): # Group everything all_anms = libPymel.ls_root_anms() if not isinstance(self.grp_anms, CtrlRoot): self.grp_anms = CtrlRoot() self.grp_anms.build() self.grp_anms.rename('anm_root') all_anms.setParent(self.grp_anms) all_rigs = libPymel.ls_root_rigs() self.grp_rigs = RigNode(name='rigs', _create=True) all_rigs.setParent(self.grp_rigs) # note: self.grp_jnts is now handled in prebuild #all_jnts = libPymel.ls_root_jnts() #self.grp_jnts = pymel.createNode('joint', name='jnts') #all_jnts.setParent(self.grp_jnts) # Ensure self.grp_jnts is constraint to self.grp_anms # We use parentConstraint instead of connections in the the animator change self.grp_anms parent pymel.delete([child for child in self.grp_jnts.getChildren() if isinstance(child, pymel.nodetypes.Constraint)]) pymel.parentConstraint(self.grp_anms, self.grp_jnts) all_geos = libPymel.ls_root_geos() self.grp_geos = RigNode(name='geos', _create=True) all_geos.setParent(self.grp_geos) # Setup displayLayers self.layer_anm = pymel.createDisplayLayer(name='layer_anm', number=1, empty=True) pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anms, noRecurse=True) self.layer_anm.color.set(17) # Yellow self.layer_rig = pymel.createDisplayLayer(name='layer_rig', number=1, empty=True) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_rigs, noRecurse=True) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_jnts, noRecurse=True) self.layer_rig.color.set(13) # Red #oLayerRig.visibility.set(0) # Hidden self.layer_rig.displayType.set(2) # Frozen self.layer_geo = pymel.createDisplayLayer(name='layer_geo', number=1, empty=True) pymel.editDisplayLayerMembers(self.layer_geo, self.grp_geos, noRecurse=True) self.layer_geo.color.set(12) # Green? self.layer_geo.displayType.set(2) # Frozen
def pre_build(self, create_master_grp=False, create_grp_jnt=True, create_grp_anm=True, create_grp_rig=True, create_grp_geo=True, create_display_layers=True, create_grp_backup=False): # Hack: Invalidate any cache before building anything. # This ensure we always have fresh data. try: del self._cache except AttributeError: pass # Look for a root joint if create_grp_jnt: # For now, we will determine the root jnt by it's name used in each rig. Not the best solution, # but currently the safer since we want to support multiple deformation layer if not libPymel.is_valid_PyNode(self.grp_jnt): # self.grp_jnt = next(iter(libPymel.ls_root(type='joint')), None) if cmds.objExists(self.nomenclature.root_jnt_name): self.grp_jnt = pymel.PyNode(self.nomenclature.root_jnt_name) else: self.warning("Could not find any root joint, master ctrl will not drive anything") # self.grp_jnt = pymel.createNode('joint', name=self.nomenclature.root_jnt_name) # Ensure all joints have segmentScaleComprensate deactivated. # This allow us to scale adequately and support video game rigs. # If for any mean stretch and squash are necessary, implement # them on a new joint chains parented to the skeletton. # TODO: Move elsewere? all_jnts = libPymel.ls(type='joint') for jnt in all_jnts: jnt.segmentScaleCompensate.set(False) # Create the master grp if create_master_grp: self.grp_master = self.build_grp(RigGrp, self.grp_master, self.name + '_' + self.nomenclature.type_rig) # Create grp_anm if create_grp_anm: grp_anim_size = CtrlRoot._get_recommended_radius(self) self.grp_anm = self.build_grp(CtrlRoot, self.grp_anm, self.nomenclature.root_anm_name, size=grp_anim_size) # Create grp_rig if create_grp_rig: self.grp_rig = self.build_grp(RigGrp, self.grp_rig, self.nomenclature.root_rig_name) # Create grp_geo if create_grp_geo: all_geos = libPymel.ls_root_geos() self.grp_geo = self.build_grp(RigGrp, self.grp_geo, self.nomenclature.root_geo_name) #if all_geos: # all_geos.setParent(self.grp_geo) if create_grp_backup: self.grp_backup = self.build_grp(RigGrp, self.grp_backup, self.nomenclature.root_backup_name) #Parent all grp on the master grp if self.grp_master: if self.grp_jnt: self.grp_jnt.setParent(self.grp_master.node) if self.grp_anm: self.grp_anm.setParent(self.grp_master.node) if self.grp_rig: self.grp_rig.setParent(self.grp_master.node) if self.grp_geo: self.grp_geo.setParent(self.grp_master.node) if self.grp_backup: self.grp_backup.setParent(self.grp_master.node) # Setup displayLayers if create_display_layers: if not pymel.objExists(self.nomenclature.layer_anm_name): self.layer_anm = pymel.createDisplayLayer(name=self.nomenclature.layer_anm_name, number=1, empty=True) self.layer_anm.color.set(17) # Yellow else: self.layer_anm = pymel.PyNode(self.nomenclature.layer_anm_name) pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anm, noRecurse=True) if not pymel.objExists(self.nomenclature.layer_rig_name): self.layer_rig = pymel.createDisplayLayer(name=self.nomenclature.layer_rig_name, number=1, empty=True) self.layer_rig.color.set(13) # Red # self.layer_rig.visibility.set(0) # Hidden self.layer_rig.displayType.set(2) # Frozen else: self.layer_rig = pymel.PyNode(self.nomenclature.layer_rig_name) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_rig, noRecurse=True) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_jnt, noRecurse=True) if not pymel.objExists(self.nomenclature.layer_geo_name): self.layer_geo = pymel.createDisplayLayer(name=self.nomenclature.layer_geo_name, number=1, empty=True) self.layer_geo.color.set(12) # Green? self.layer_geo.displayType.set(2) # Frozen else: self.layer_geo = pymel.PyNode(self.nomenclature.layer_geo_name) pymel.editDisplayLayerMembers(self.layer_geo, self.grp_geo, noRecurse=True)
def addToLayer(self, allObjects): # create new display layer layer = pm.createDisplayLayer( empty=True, name='Filterrr_layer_' ) for obj in allObjects: pm.editDisplayLayerMembers( layer, obj )
def ph_mainCode(extraHeight, particleRate, getInitialInfo, minSlope, minSlopeVariance, setBoundingBox, maxTilt, objectScale, objectScaleVariance, objectHeightVariance): displayWindow = True windowError = py.window(title="Notice", mxb=False, s=False) errorLayout = py.rowColumnLayout(numberOfColumns=3, parent=windowError) #initialise varibables originalTime = py.currentTime(query=True) deleteCount = 0 decimalPoints = 2 #file validation storeSelection = py.ls(selection=True) try: validFile = True myfile = open('storedobjects.txt') objectList = myfile.readlines() myfile.close() py.select(clear=True) for i in range(len(objectList)): py.select(objectList[i], add=True) 1 / len(objectList) except: validFile = False #get original selection py.select(clear=True) for i in range(len(storeSelection)): py.select(storeSelection[i], add=True) #deselect non polygons if type(storeSelection[i]) != py.nodetypes.Transform: py.select(storeSelection[i], deselect=True) #deselect objects in the text file if getInitialInfo == False: for j in range(len(objectList)): selectionEdit = storeSelection[i] + objectList[j][ -2] + objectList[j][-1] if objectList[j] == selectionEdit: py.select(storeSelection[i], deselect=True) storeSelection = py.ls(selection=True) startTime = time() listOfPoints = [] totalNum = 0 if len(storeSelection) == 0: displayMessage = "Nothing is selected. Please select an object and try again." ph_displayWindow(displayWindow, displayMessage) elif getInitialInfo == True: #write to file selection = py.ls(selection=True) myfile = open('storedobjects.txt', 'w') for i in range(len(selection)): myfile.write("" + selection[i] + "\r\n") myfile.close() if len(selection) > 0: print str(len(selection)) + " object(s) successfully stored." if displayWindow == True: py.text(label=" ") py.text(label=" ") py.text(label=" ") py.text(label=" ") py.text(label=str(len(selection)) + " object(s) successfully stored.", align="center") py.text(label=" ") py.text(label=" ") py.text(label=" ") py.text(label=" ") py.showWindow() else: displayMessage = "Please select the objects you wish to store." ph_displayWindow(displayWindow, displayMessage) for i in range(len(storeSelection)): py.select(storeSelection[i], add=True) elif validFile == False: displayMessage = "Error with stored list. Please choose new object(s) to duplicate." ph_displayWindow(displayWindow, displayMessage) elif len(objectList) == 0: displayMessage = "No objects stored. Please choose new object(s) to duplicate." ph_displayWindow(displayWindow, displayMessage) else: for loops in range(len(storeSelection)): particleID = [] particleLoc = [] particleVelocity = [] #get information about selected object py.select(storeSelection[loops], r=True) originalObj = py.ls(selection=True) originalObjLoc = originalObj[0].getTranslation() originalObjX = originalObjLoc.x originalObjY = originalObjLoc.y originalObjZ = originalObjLoc.z #duplicate object to work on tempObj = py.instance(originalObj) #make emitter particleEmitter = py.emitter(n='tempEmitter', type='surface', r=particleRate * 24, sro=0, speed=0.0001) particles = py.particle(n='emittedParticles') py.connectDynamic('emittedParticles', em='tempEmitter') py.setAttr(particles[1] + '.seed[0]', rd.randint(0, sys.maxint)) #get list from file myfile = open('storedobjects.txt') objectList = myfile.readlines() objectListCopy = [] myfile.close() for i in range(len(objectList)): copyObj = py.duplicate(objectList[i]) objectListCopy.append(copyObj) #fixes the seed always being 0 py.currentTime(originalTime + 1, edit=True, update=True) py.currentTime(originalTime, edit=True, update=True) py.currentTime(originalTime + 1, edit=True, update=True) numOfParticles = particles[1].num() for i in range(numOfParticles): #get particle info particleInfo = particles[1].Point('emittedParticles', i) particleID.append(particleInfo) particleLoc.append(particleInfo.position) particleVelocity.append(particleInfo.velocity) for i in range(len(particleID)): #place objects randomNum = rd.randint(0, len(objectListCopy) - 1) instanceObj = objectListCopy[randomNum] dupObj = py.instance(instanceObj) yDir = particleVelocity[i][1] * 10000 #get height of object py.select(instanceObj, r=True) py.scale(1, 1, 1) height = py.ls(selection=True)[0].getBoundingBox().height() #reselect instance py.select(dupObj[0], r=True) py.move(dupObj[0], particleLoc[i][0], particleLoc[i][1] + extraHeight, particleLoc[i][2]) py.rotate(dupObj[0], rd.uniform(-maxTilt, maxTilt), rd.randint(0, 360), rd.uniform(-maxTilt, maxTilt), os=True) scaleX = rd.uniform(objectScale - objectScaleVariance, objectScale + objectScaleVariance) scaleY = rd.uniform(objectScale - (objectHeightVariance / 2), objectScale + objectHeightVariance) scaleZ = rd.uniform(objectScale - objectScaleVariance, objectScale + objectScaleVariance) py.scale(dupObj[0], scaleX, scaleY, scaleZ) if yDir <= rd.uniform(minSlope - minSlopeVariance, minSlope + minSlopeVariance): py.delete(dupObj) deleteCount = deleteCount + 1 else: listOfPoints.append(dupObj) #display percent completed maxValue = int(pow(len(particleID), 0.5)) if float(i / maxValue) == float(i) / maxValue: print str( int((float(i) * 100 / len(particleID)) * 100.0) / 100.0) + "% completed" totalNum = totalNum + numOfParticles #delete temp objects py.select(tempObj, 'tempEmitter', 'emittedParticles') py.delete() py.currentTime(originalTime, edit=True, update=True) for i in range(len(objectListCopy)): py.delete(objectListCopy[i][0]) #place objects in display layer py.select(clear=True) if len(listOfPoints) > 0: if setBoundingBox == True: displayLayerName = 'duplicatedObjectsBB' else: displayLayerName = 'duplicatedObjectsMesh' #add to display layer try: for i in range(len(listOfPoints)): py.editDisplayLayerMembers(displayLayerName, listOfPoints[i]) #create display layer first except: py.createDisplayLayer(noRecurse=True, name=displayLayerName) for i in range(len(listOfPoints)): py.editDisplayLayerMembers(displayLayerName, listOfPoints[i]) #display objects as bounding box if setBoundingBox == True: py.setAttr(displayLayerName + '.levelOfDetail', 1) py.setAttr(displayLayerName + '.color', 17) #add to group for i in range(len(listOfPoints)): py.select(listOfPoints[i][0], add=True) py.group(n='duplicatedObjectsGroup') #output time taken endTime = time() ph_timeOutput(startTime, endTime, decimalPoints) secondsDecimal, sec = ph_timeOutput(startTime, endTime, decimalPoints) displayMessage = str(totalNum - deleteCount) + " objects created in " + str( secondsDecimal) + str(sec) ph_displayWindow(displayWindow, displayMessage) #select original selection py.select(clear=True) for i in range(len(storeSelection)): py.select(storeSelection[i], add=True)
def pre_build(self, create_grp_jnt=True, create_grp_anm=True, create_grp_rig=True, create_grp_geo=True, create_display_layers=True): # Ensure we got a root joint # If needed, parent orphan joints to this one if create_grp_jnt: if not libPymel.is_valid_PyNode(self.grp_jnt): self.grp_jnt = next(iter(libPymel.ls_root(type='joint')), None) ''' if cmds.objExists(self.nomenclature.root_jnt_name): self.grp_jnt = pymel.PyNode(self.nomenclature.root_jnt_name) else: self.grp_jnt = pymel.createNode('joint', name=self.nomenclature.root_jnt_name) ''' #all_root_jnts.setParent(self.grp_jnt) # Ensure all joinst have segmentScaleComprensate deactivated. # This allow us to scale adequately and support video game rigs. # If for any mean stretch and squash are necessary, implement them on a new joint chains parented to the skeletton. # TODO: Move elsewere? all_jnts = libPymel.ls(type='joint') for jnt in all_jnts: jnt.segmentScaleCompensate.set(False) # Create grp_anm if create_grp_anm: if not isinstance(self.grp_anm, CtrlRoot): self.grp_anm = CtrlRoot() if not self.grp_anm.is_built(): grp_anm_size = CtrlRoot._get_recommended_radius(self) self.grp_anm.build(self, size=grp_anm_size) self.grp_anm.rename(self.nomenclature.root_anm_name) # Create grp_rig if create_grp_rig: if not isinstance(self.grp_rig, Node): self.grp_rig = Node() if not self.grp_rig.is_built(): self.grp_rig.build(self) self.grp_rig.rename(self.nomenclature.root_rig_name) # Create grp_geo if create_grp_geo: all_geos = libPymel.ls_root_geos() if not isinstance(self.grp_geo, Node): self.grp_geo = Node() if not self.grp_geo.is_built(): self.grp_geo.build(self) self.grp_geo.rename(self.nomenclature.root_geo_name) #if all_geos: # all_geos.setParent(self.grp_geo) # Setup displayLayers if create_display_layers: if not pymel.objExists(self.nomenclature.layer_anm_name): self.layer_anm = pymel.createDisplayLayer(name=self.nomenclature.layer_anm_name, number=1, empty=True) pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anm, noRecurse=True) self.layer_anm.color.set(17) # Yellow if not pymel.objExists(self.nomenclature.layer_rig_name): self.layer_rig = pymel.createDisplayLayer(name=self.nomenclature.layer_rig_name, number=1, empty=True) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_rig, noRecurse=True) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_jnt, noRecurse=True) self.layer_rig.color.set(13) # Red #self.layer_rig.visibility.set(0) # Hidden self.layer_rig.displayType.set(2) # Frozen if not pymel.objExists(self.nomenclature.layer_geo_name): self.layer_geo = pymel.createDisplayLayer(name=self.nomenclature.layer_geo_name, number=1, empty=True) pymel.editDisplayLayerMembers(self.layer_geo, self.grp_geo, noRecurse=True) self.layer_geo.color.set(12) # Green? self.layer_geo.displayType.set(2) # Frozen
for each in assemblies: # Checking whether each item is not in exclude list. if avaliable it will be ignored if each not in excludeType: # Adding each item from list if not avaliable in exclude list finalAssemblies.append(each) # Getting the list of catagories with out duplicates. # empty list to store catagories catagory = [] # Looping through final assemblies for each in finalAssemblies: # Splitting the name based on "_" typ, col = each.split('_') # Adding the typ variable to the list catagory.append(typ) # Removing the duplicates from generated list and assigning as a new variable. finalCatagory = list(set(catagory)) # Looping through catagory for eachCatagory in finalCatagory: # Creating a new display layer with the each catagory name. pm.createDisplayLayer(name=eachCatagory, empty=True) # Looping through all final assemblies for eachAssembly in finalAssemblies: # Checking whether each assembly is starting with catagory name. if eachAssembly.startswith(eachCatagory): # Adding the assembly to the catagory display layer. pm.editDisplayLayerMembers(eachCatagory, eachAssembly)
def selectAll(self, args): layer = self.getAnim('Foxo_Controls') pm.select(pm.editDisplayLayerMembers(layer, q=True))
def resetAll(self, args): layer = self.getAnim('Foxo_Controls') controls = pm.editDisplayLayerMembers(layer, q=True) for anim in controls: self.resetAnim(anim)
def keyAll(self, args): layer = self.getAnim('Foxo_Controls') controls = pm.editDisplayLayerMembers(layer, q=True) for control in controls: pm.setKeyframe(control)
def pre_build(self, create_master_grp=False, create_grp_jnt=True, create_grp_anm=True, create_grp_rig=True, create_grp_geo=True, create_display_layers=True, create_grp_backup=False, create_layer_jnt=False): # Hack: Invalidate any cache before building anything. # This ensure we always have fresh data. self._clear_cache() # Look for a root joint if create_grp_jnt: # For now, we will determine the root jnt by it's name used in each rig. Not the best solution, # but currently the safer since we want to support multiple deformation layer if not libPymel.is_valid_PyNode(self.grp_jnt): # self.grp_jnt = next(iter(libPymel.ls_root(type='joint')), None) if cmds.objExists(self.nomenclature.root_jnt_name): self.grp_jnt = pymel.PyNode(self.nomenclature.root_jnt_name) else: self.warning("Could not find any root joint, master ctrl will not drive anything") # self.grp_jnt = pymel.createNode('joint', name=self.nomenclature.root_jnt_name) # Create the master grp if create_master_grp: self.grp_master = self.build_grp(RigGrp, self.grp_master, self.name + '_' + self.nomenclature.type_rig) # Create grp_anm if create_grp_anm: grp_anim_size = CtrlRoot._get_recommended_radius(self) self.grp_anm = self.build_grp(CtrlRoot, self.grp_anm, self.nomenclature.root_anm_name, size=grp_anim_size) # Create grp_rig if create_grp_rig: self.grp_rig = self.build_grp(RigGrp, self.grp_rig, self.nomenclature.root_rig_name) # Create grp_geo if create_grp_geo: all_geos = libPymel.ls_root_geos() self.grp_geo = self.build_grp(RigGrp, self.grp_geo, self.nomenclature.root_geo_name) # if all_geos: # all_geos.setParent(self.grp_geo) if create_grp_backup: self.grp_backup = self.build_grp(RigGrp, self.grp_backup, self.nomenclature.root_backup_name) # Parent all grp on the master grp if self.grp_master: if self.grp_jnt: self.grp_jnt.setParent(self.grp_master.node) if self.grp_anm: self.grp_anm.setParent(self.grp_master.node) if self.grp_rig: self.grp_rig.setParent(self.grp_master.node) if self.grp_geo: self.grp_geo.setParent(self.grp_master.node) if self.grp_backup: self.grp_backup.setParent(self.grp_master.node) # Setup displayLayers if create_display_layers: if not pymel.objExists(self.nomenclature.layer_anm_name): self.layer_anm = pymel.createDisplayLayer(name=self.nomenclature.layer_anm_name, number=1, empty=True) self.layer_anm.color.set(17) # Yellow else: self.layer_anm = pymel.PyNode(self.nomenclature.layer_anm_name) pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anm, noRecurse=True) if not pymel.objExists(self.nomenclature.layer_rig_name): self.layer_rig = pymel.createDisplayLayer(name=self.nomenclature.layer_rig_name, number=1, empty=True) self.layer_rig.color.set(13) # Red # self.layer_rig.visibility.set(0) # Hidden self.layer_rig.displayType.set(2) # Frozen else: self.layer_rig = pymel.PyNode(self.nomenclature.layer_rig_name) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_rig, noRecurse=True) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_jnt, noRecurse=True) if not pymel.objExists(self.nomenclature.layer_geo_name): self.layer_geo = pymel.createDisplayLayer(name=self.nomenclature.layer_geo_name, number=1, empty=True) self.layer_geo.color.set(12) # Green? self.layer_geo.displayType.set(2) # Frozen else: self.layer_geo = pymel.PyNode(self.nomenclature.layer_geo_name) pymel.editDisplayLayerMembers(self.layer_geo, self.grp_geo, noRecurse=True) if create_layer_jnt: if not pymel.objExists(self.nomenclature.layer_jnt_name): self.layer_jnt = pymel.createDisplayLayer(name=self.nomenclature.layer_jnt_name, number=1, empty=True) self.layer_jnt.color.set(1) # Black? self.layer_jnt.visibility.set(0) # Hidden self.layer_jnt.displayType.set(2) # Frozen else: self.layer_jnt = pymel.PyNode(self.nomenclature.layer_jnt_name) pymel.editDisplayLayerMembers(self.layer_jnt, self.grp_jnt, noRecurse=True)
def getObjectsInDisplayLayer(layer): return pm.ls(pm.editDisplayLayerMembers(layer, query=True))
def pre_build(self, create_grp_anm=True, create_display_layers=True, **kwargs): super(RigSqueeze, self).pre_build(create_grp_anm=create_grp_anm, create_master_grp=False, create_display_layers=create_display_layers, **kwargs) if create_grp_anm: grp_anim_size = CtrlMaster._get_recommended_radius(self) self.grp_anm_master = self.build_grp( CtrlMaster, self.grp_anm_master, self.nomenclature.root_anm_master_name, size=grp_anim_size ) if create_display_layers: pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anm_master, noRecurse=True) # # Create specific group related to squeeze rig convention # all_geos = libPymel.ls_root_geos() # Build All_Grp self.grp_master = self.build_grp(classRig.RigGrp, self.grp_master, self.nomenclature.root_all_name) self.grp_model = self.build_grp(classRig.RigGrp, self.grp_model, self.nomenclature.root_model_name) self.grp_proxy = self.build_grp(classRig.RigGrp, self.grp_proxy, self.nomenclature.root_proxy_name) self.grp_fx = self.build_grp(classRig.RigGrp, self.grp_fx, self.nomenclature.root_fx_name) # Parent all groups in the main grp_master pymel.parent(self.grp_anm_master, self.grp_master) pymel.parent(self.grp_anm, self.grp_anm_master) # grp_anm is not a Node, but a Ctrl self.grp_rig.setParent(self.grp_master) self.grp_fx.setParent(self.grp_master) self.grp_model.setParent(self.grp_master) self.grp_proxy.setParent(self.grp_master) self.grp_geo.setParent(self.grp_master) ''' if self.grp_jnt.getParent() is None: self.grp_jnt.setParent(self.grp_master) ''' # Lock and hide all attributes we don't want the animator to play with libAttr.lock_hide_trs(self.grp_master) libAttr.lock_hide_trs(self.grp_rig) libAttr.lock_hide_trs(self.grp_fx) libAttr.lock_hide_trs(self.grp_model) libAttr.lock_hide_trs(self.grp_proxy) libAttr.lock_hide_trs(self.grp_geo) libAttr.hide_scale(self.grp_anm) # Hide some group # self.grp_jnt.visibility.set(False) self.grp_rig.visibility.set(False) self.grp_fx.visibility.set(False) self.grp_model.visibility.set(False) # # Add root ctrl attributes specific to squeeze while preserving existing connections. # if not self.grp_anm.hasAttr(self.GROUP_NAME_DISPLAY, checkShape=False): libAttr.addAttr_separator(self.grp_anm, self.GROUP_NAME_DISPLAY) attr_display_mesh_output_attrs = {self.grp_geo.visibility} attr_display_proxy_output_attrs = {self.grp_proxy.visibility} # attr_display_ctrl_output_attrs = set( # [children.visibility for children in self.grp_anm.getChildren(type='transform')] # ) # In the past, the displayMesh attribute was a boolean and the displayProxy was also a boolean. # Now we use an enum. This mean that we need to remap. if self.grp_anm.hasAttr(self.ATTR_NAME_DISPLAY_MESH): attr_display_mesh = self.grp_anm.attr(self.ATTR_NAME_DISPLAY_MESH) if attr_display_mesh.type() == 'short': for attr_dst in attr_display_mesh.outputs(plugs=True): attr_display_mesh_output_attrs.add(attr_dst) pymel.disconnectAttr(attr_display_mesh, attr_dst) if self.grp_anm.hasAttr(self.ATTR_NAME_DISPLAY_PROXY): attr_display_proxy = self.grp_anm.attr(self.ATTR_NAME_DISPLAY_PROXY) for attr_dst in attr_display_proxy.outputs(plugs=True): attr_display_proxy_output_attrs.add(attr_dst) pymel.disconnectAttr(attr_display_proxy, attr_dst) attr_display_proxy.delete() # Create DisplayMesh attribute attr_display_mesh = self._init_attr_display_mesh() # Create DisplayCtrl attribute attr_display_ctrl = self._init_attr_display_ctrl() # Connect DisplayMesh attribute for attr_dst in attr_display_mesh_output_attrs: if not libAttr.is_connected_to(attr_display_mesh, attr_dst, max_depth=3): self.debug("Connecting {} to {}".format(attr_display_mesh, attr_dst)) attr_proxy_display_inn = libRigging.create_utility_node( 'condition', firstTerm=attr_display_mesh, secondTerm=0, colorIfTrueR=True, colorIfFalseR=False ).outColorR pymel.connectAttr(attr_proxy_display_inn, attr_dst, force=True) for attr_dst in attr_display_proxy_output_attrs: if not libAttr.is_connected_to(attr_display_mesh, attr_dst, max_depth=3): self.debug("Connecting {} to {}".format(attr_display_mesh, attr_dst)) # attr_proxy_display_inn = libRigging.create_utility_node( # 'condition', # firstTerm=attr_display_mesh, # secondTerm=0, # colorIfTrueR=True, # colorIfFalseR=False # ).outColorR pymel.connectAttr(attr_display_mesh, attr_dst, force=True)
def pre_build(self, create_master_grp=False, create_grp_jnt=True, create_grp_anm=True, create_grp_rig=True, create_grp_geo=True, create_display_layers=True, create_grp_backup=False): # Hack: Invalidate any cache before building anything. # This ensure we always have fresh data. try: del self._cache except AttributeError: pass # Look for a root joint if create_grp_jnt: # For now, we will determine the root jnt by it's name used in each rig. Not the best solution, # but currently the safer since we want to support multiple deformation layer if not libPymel.is_valid_PyNode(self.grp_jnt): # self.grp_jnt = next(iter(libPymel.ls_root(type='joint')), None) if cmds.objExists(self.nomenclature.root_jnt_name): self.grp_jnt = pymel.PyNode( self.nomenclature.root_jnt_name) else: self.warning( "Could not find any root joint, master ctrl will not drive anything" ) # self.grp_jnt = pymel.createNode('joint', name=self.nomenclature.root_jnt_name) # Ensure all joints have segmentScaleComprensate deactivated. # This allow us to scale adequately and support video game rigs. # If for any mean stretch and squash are necessary, implement # them on a new joint chains parented to the skeletton. # TODO: Move elsewere? all_jnts = libPymel.ls(type='joint') for jnt in all_jnts: jnt.segmentScaleCompensate.set(False) # Create the master grp if create_master_grp: self.grp_master = self.build_grp( RigGrp, self.grp_master, self.name + '_' + self.nomenclature.type_rig) # Create grp_anm if create_grp_anm: grp_anim_size = CtrlRoot._get_recommended_radius(self) self.grp_anm = self.build_grp(CtrlRoot, self.grp_anm, self.nomenclature.root_anm_name, size=grp_anim_size) # Create grp_rig if create_grp_rig: self.grp_rig = self.build_grp(RigGrp, self.grp_rig, self.nomenclature.root_rig_name) # Create grp_geo if create_grp_geo: all_geos = libPymel.ls_root_geos() self.grp_geo = self.build_grp(RigGrp, self.grp_geo, self.nomenclature.root_geo_name) #if all_geos: # all_geos.setParent(self.grp_geo) if create_grp_backup: self.grp_backup = self.build_grp( RigGrp, self.grp_backup, self.nomenclature.root_backup_name) #Parent all grp on the master grp if self.grp_master: if self.grp_jnt: self.grp_jnt.setParent(self.grp_master.node) if self.grp_anm: self.grp_anm.setParent(self.grp_master.node) if self.grp_rig: self.grp_rig.setParent(self.grp_master.node) if self.grp_geo: self.grp_geo.setParent(self.grp_master.node) if self.grp_backup: self.grp_backup.setParent(self.grp_master.node) # Setup displayLayers if create_display_layers: if not pymel.objExists(self.nomenclature.layer_anm_name): self.layer_anm = pymel.createDisplayLayer( name=self.nomenclature.layer_anm_name, number=1, empty=True) self.layer_anm.color.set(17) # Yellow else: self.layer_anm = pymel.PyNode(self.nomenclature.layer_anm_name) pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anm, noRecurse=True) if not pymel.objExists(self.nomenclature.layer_rig_name): self.layer_rig = pymel.createDisplayLayer( name=self.nomenclature.layer_rig_name, number=1, empty=True) self.layer_rig.color.set(13) # Red # self.layer_rig.visibility.set(0) # Hidden self.layer_rig.displayType.set(2) # Frozen else: self.layer_rig = pymel.PyNode(self.nomenclature.layer_rig_name) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_rig, noRecurse=True) pymel.editDisplayLayerMembers(self.layer_rig, self.grp_jnt, noRecurse=True) if not pymel.objExists(self.nomenclature.layer_geo_name): self.layer_geo = pymel.createDisplayLayer( name=self.nomenclature.layer_geo_name, number=1, empty=True) self.layer_geo.color.set(12) # Green? self.layer_geo.displayType.set(2) # Frozen else: self.layer_geo = pymel.PyNode(self.nomenclature.layer_geo_name) pymel.editDisplayLayerMembers(self.layer_geo, self.grp_geo, noRecurse=True)