def add_to_layer(nodes, layer_name): """ Adds a node to the layer with the given name. If that layer does not exist it will be created with default options. :param nodes: List of nodes (or a single node) :type nodes: pm.nt.Transform or list(pm.nt.Transform, ..) :param layer_name: Name of layer to add to :type layer_name: str :return: None """ # -- If the layer does not exist, we need to create it if not pm.ls(layer_name, type='displayLayer'): pm.createDisplayLayer( name=layer_name, empty=True, ) if not nodes: return # -- If the nodes is a list a single node we should convert # -- that to a list nodes = [nodes] # -- Get the layer layer = pm.PyNode(layer_name) layer.addMembers(nodes)
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 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 setButtonPress(self, *args): """Sets the plane we'll be snapping to from the three selected vertices Called by "set plane" button """ sel = pm.ls(selection=1, flatten=1) if len(sel) ==3: self.cleanUp() pos1 = sel[0].getPosition() pos2 = sel[1].getPosition() pos3 = sel[2].getPosition() vct1 = pos2-pos1 vct2 = pos3-pos1 # ^ is owerwritten to perform a cross product self.normal = vct1 ^ vct2 self.normal.normalize() self.position = pos1 pm.select(sel) layerObj = pm.createDisplayLayer(name=self.layername, empty=1) for i, vtx in enumerate(sel): annotation = pm.annotate(vtx, tx="V%d" % (i+1), p=vtx.getPosition(space="world") ) annotation.setAttr("overrideEnabled", 1) annotation.setAttr("overrideColor", 17) annTrans = annotation.getParent() annTrans.rename("annotateVts%d" % (i+1)) layerObj.addMembers(annTrans) layerObj.addMembers(annotation) layerObj.setAttr("displayType", 1) else: pm.confirmDialog(message="Please select exactly 3 vertices", title="Error", button="OK", defaultButton="OK", dismissString="OK", cancelButton="OK")
def run(): needLayer = pm.ls(sl=True) for x in needLayer: ns = x.name().rpartition(':')[0] pm.select(x) layer = pm.createDisplayLayer(name=ns + '_layer') pm.PyNode(layer).attr('visibility').set(False)
def createDisplayLayer(self): """ Create display layer and set it to wireframe mode """ layer = pm.createDisplayLayer(n=self.displayLayerName) # set display type to wireframe only layer.setAttr('displayType', 1) return layer
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 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 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 selectCmd(*args, **kwargs): ''' add selection model into the display layer ''' exportLayerName = 'kx_cloth_export_layer' if pm.objExists(exportLayerName): exportLayer = pm.PyNode(exportLayerName) else : exportLayer = pm.createDisplayLayer(noRecurse = 1, e = 1, name = 'kx_cloth_export_layer') exportLayer.visibility.set(0) exportLayer.color.set(14) sel = pm.ls(sl=1) exportLayer.addMembers(sel) return exportLayerName
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 putInLayer(objs, layerName): ''' Puts the given objects in a layer of the given name. todo:: There needs to be a fallback if the layer isn't found to verify another dag obj doesn't have the intended name. ''' for layer in ls(type='displayLayer'): if layer.name() == layerName: break else: layer = createDisplayLayer(name=layerName, e=True) layer.addMembers(objs)
def selectCmd(*args, **kwargs): ''' add selection model into the display layer ''' exportLayerName = 'kx_cloth_export_layer' if pm.objExists(exportLayerName): exportLayer = pm.PyNode(exportLayerName) else: exportLayer = pm.createDisplayLayer(noRecurse=1, e=1, name='kx_cloth_export_layer') exportLayer.visibility.set(0) exportLayer.color.set(14) sel = pm.ls(sl=1) exportLayer.addMembers(sel) return exportLayerName
def setPanelLayout(self): cmd = 'setNamedPanelLayout "Single Perspective View";' panel_current = cmds.getPanel(withFocus=1) print 'panel_current', panel_current #lookThroughModelPanel $cams[0] $currentPanel; cmd += 'lookThroughModelPanel ' + self.Cam + ' ' + panel_current + ';' pm.mel.eval(cmd) #modelEditor -e -udm false $currentPanel; #modelEditor -e -allObjects 0 $currentPanel; #modelEditor -e -polymeshes true $currentPanel; cmds.modelEditor(panel_current, e=1, udm=0) cmds.modelEditor(panel_current, e=1, allObjects=0) cmds.modelEditor(panel_current, e=1, polymeshes=1) cmds.modelEditor(panel_current, e=1, cameraName=self.Cam) #select -r `ls -dag -lf -type softModHandle -type clusterHandle` ; #string $layer = `createDisplayLayer -name "softHandle_layer" -number 1 -nr`; #layerEditorLayerButtonVisibilityChange $layer; #remove cluster and softModHandle pm.ls(dag=1, lf=1, type=('softModHandle', 'clusterHandle')) layer = pm.createDisplayLayer(name='softHandle_layer', number=1, mc=1) pm.mel.eval('layerEditorLayerButtonVisibilityChange ' + layer)
def setPanelLayout(self): cmd = 'setNamedPanelLayout "Single Perspective View";' panel_current = cmds.getPanel(withFocus=1) print 'panel_current',panel_current #lookThroughModelPanel $cams[0] $currentPanel; cmd += 'lookThroughModelPanel ' + self.Cam + ' ' + panel_current + ';' pm.mel.eval(cmd) #modelEditor -e -udm false $currentPanel; #modelEditor -e -allObjects 0 $currentPanel; #modelEditor -e -polymeshes true $currentPanel; cmds.modelEditor(panel_current,e=1,udm=0) cmds.modelEditor(panel_current,e=1,allObjects=0) cmds.modelEditor(panel_current,e=1,polymeshes=1) cmds.modelEditor(panel_current,e=1,cameraName=self.Cam) #select -r `ls -dag -lf -type softModHandle -type clusterHandle` ; #string $layer = `createDisplayLayer -name "softHandle_layer" -number 1 -nr`; #layerEditorLayerButtonVisibilityChange $layer; #remove cluster and softModHandle pm.ls(dag=1,lf=1,type=('softModHandle','clusterHandle')) layer = pm.createDisplayLayer(name='softHandle_layer',number=1,mc=1) pm.mel.eval('layerEditorLayerButtonVisibilityChange ' + layer)
def addToLayer(self, allObjects): # create new display layer layer = pm.createDisplayLayer( empty=True, name='Filterrr_layer_' ) for obj in allObjects: pm.editDisplayLayerMembers( layer, obj )
# Looping through all assemblies 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 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 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_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 addObjectToLayer(layer='main', mode=0): ''' assembly references can not be added to display layer, so we add text description to layer attribute mode 0: add object mode 1: delete object mode 2: delete all objects in all layers ''' layer = 'stereo_' + layer if mode==2: for l in ['stereo_main', 'stereo_near', 'stereo_far']: if not pm.objExists(l): continue tmp = pm.PyNode(l) obj_display = pm.listConnections(tmp.attr('drawInfo'), d=True) for o in obj_display: try: tmp.drawInfo // o.drawOverride o.attr('overrideVisibility').set(1) o.attr('overrideEnabled').set(0) except: pass if not pm.hasAttr(tmp, 'stereo_hidden'): continue obj_string = tmp.attr('stereo_hidden').get() if obj_string: obj_string = [o.strip() for o in obj_string.split(';')] for o in obj_string: try: if not pm.objExists(o): continue o.attr('overrideVisibility').set(1) o.attr('overrideEnabled').set(0) except: pass tmp.attr('stereo_hidden').set('') if not pm.objExists(str(layer)): layer = pm.createDisplayLayer(name=str(layer), e=True) else: layer = pm.PyNode(str(layer)) if not pm.hasAttr(layer, 'stereo_hidden'): pm.addAttr(layer, ln='stereo_hidden', dt='string') hidden_obj = [] hidden_string = [] # get original hidden_obj.extend( pm.listConnections(layer.attr('drawInfo'), d=True) ) hidden_string_orig = layer.attr('stereo_hidden').get() if hidden_string_orig: hidden_string.extend( [o.strip() for o in hidden_string_orig.split(';')] ) sel = pm.ls(sl=True) for s in sel: # does it ends with :master or _AR if not s.name().endswith(':master') and not s.name().endswith('_AR'): # is it sit in lay if not s.isChildOf('|assets|lay'): print s.name()+' was not added to hidden layer, because its name does not ends with :master' return if mode==0: # try add to display layer first add_to_display = False if s not in hidden_obj: try: layer.drawInfo >> s.drawOverride add_to_display = True except: add_to_display = False if not add_to_display and s.name() not in hidden_string: hidden_string.append(s.name()) elif mode==1: if s in hidden_obj: try: layer.drawInfo // s.drawOverride s.attr('overrideVisibility').set(1) s.attr('overrideEnabled').set(0) except: pass if s.name() in hidden_string: hidden_string.remove(s.name()) layer.attr('stereo_hidden').set( ';'.join(hidden_string) )
def rigDazFigure( name, path='C:/Users/Darrick/Documents/Maya/projects/_UE4-Chars/scenes'): """Need to load DAZ FBX first""" figure = getFigureName() # File paths mesh_path = '{0}/Mesh/Ref/Mesh_{1}.ma'.format(path, name) rig_path = '{0}/Rig/Ref/Rig_{1}.ma'.format(path, name) skel_path = '{0}/Rig/Ref/Skel_{1}.ma'.format(path, name) anim_path = '{0}/Rig/Ref/AnimRig_{1}.mb'.format(path, name) # Build and save meshes print('Converting DAZ figure geometry:') buildDazMeshes() print('Exporting geometry...') meshes = pm.ls(('*Mesh', '*Morphs'), type='transform', r=True) face_sets = pm.ls('Fac*', recursive=True) pm.select(meshes + face_sets, ne=True) pm.exportSelected(mesh_path, force=True) print('Geometry exported to {}'.format(mesh_path)) # Load and setup AS5 skeleton print('Loading and setting up AS5 skeleton...') as5util.preBuild(figure, load=True) # Edit joint placement, if necessary # Remove shading face sets from namespaces so they don't get deleted for sel_set in pm.ls('Fac*', recursive=True): pm.rename(sel_set, sel_set.name().split(':')[1]) # Delete geometry + namespaces for name_space in 'HeadGeo', 'BodyGeo': pm.namespace(rm=name_space, deleteNamespaceContent=True) # Reference geometry pm.createReference(mesh_path, defaultNamespace=True) # Build AS5 rig print('Building AS5 rig...') pm.mel.eval( 'source "C:/Users/Darrick/Documents/Maya/scripts/AdvancedSkeleton5.mel";' ) pm.mel.eval('asBuildAdvancedSkeleton();') print('Executing post-build script...') as5util.postBuild(figure) pm.mel.eval('asSetBuildPose("");') # Skin mesh and apply blendshapes print('Skinning geometry and applying weight drivers...') applySkins() # Add to layers, cleanup print('Cleaning up...') layer = pm.ls('GeoLayer')[0] if pm.ls( 'GeoLayer') else pm.createDisplayLayer(name='GeoLayer') layer.displayType.set(2) for grp in pm.ls(('Mesh', 'Morphs'), r=True): grp.setParent('Geometry') layer.addMembers(grp) pm.delete('Genesis8*') for grp in 'Geometry', 'DeformationSystem': pm.parent(grp, None) # Export skeleton print('Exporting skeleton to {}'.format(skel_path)) pm.select('DeformationSystem', r=True) pm.exportSelected(skel_path, force=True, channels=False) # Save rig file print('Saving rig file to {}'.format(rig_path)) pm.saveAs(rig_path) print('Saving animRig file to {}'.format(anim_path)) refs = pm.ls(type='reference') for ref in refs: file_ref = pm.FileReference(ref) file_ref.importContents() pm.saveAs(anim_path) pm.openFile(rig_path, force=True) print('Conversion complete.')
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
def build_base_rig(): ##### 2. BUILD THE BASE RIG ##### #TODO: Generate my own generic shapes here. #TODO: Better naming conventions #TODO: If the guide doesn't exist, just build a rig with all controls at 0,0,0. Don't be an ass about it. #nSRT = 'globalsrt' nGlobal = 'world_ctl' nLocal = 'master_C0_ctl' nBody = 'COG_C0_ctl' if not pm.objExists("Rig"): rigGroup = pm.group(em=True, n='Rig') else: rigGroup = pm.PyNode("Rig") if pm.objExists('RigLayer'): pm.delete('RigLayer') if pm.objExists('GeoLayer'): pm.delete('GeoLayer') oLayer = pm.createDisplayLayer('Rig', n='RigLayer', number=1, nr=True) oLayer.color.set(14) oLayer = pm.createDisplayLayer(pm.ls('Geo'), n='GeoLayer', number=1, nr=True) oLayer.color.set(7) # Find or create the guide controls #if pm.objExists(nSRT): # oSRT = pm.PyNode(nSRT) #else: # oSRT = pm.spaceLocator(n='globalsrt') if pm.objExists(nGlobal): oGlobal = pm.PyNode(nGlobal) else: oGlobal = props_icon_lib.create_control_icon('arrowBox', 'world_ctl', [10.0, 1.0, 10.0]) if pm.objExists(nLocal): oLocal = pm.PyNode(nLocal) else: oLocal = props_icon_lib.create_control_icon('square', 'master_C0_ctl', [9.0, 1.0, 9.0]) localBB = oLocal.getBoundingBox() localWidth = localBB.width() - 1.0 localDepth = localBB.depth() - 1.0 oLocal2 = props_icon_lib.create_control_icon( 'square', 'local_C0_ctl', [localWidth, 1.0, localDepth], offset=[0.0, 0.2, 0.0], ) oLocal2.setTranslation(oLocal.getTranslation(space='world'), space='world') if pm.objExists(nBody): oBody = pm.PyNode(nBody) else: oBody = props_icon_lib.create_control_icon('square', 'COG_C0_ctl', [8.0, 1.0, 8.0]) oBody.setTranslation([0.0, 3.0, 0.0]) bodyBB = oBody.getBoundingBox() bodyWidth = bodyBB.width() - 1.0 bodyDepth = bodyBB.depth() - 1.0 oBody2 = props_icon_lib.create_control_icon( 'square', 'COG_C1_ctl', [bodyWidth, 1.0, bodyDepth], offset=[0.0, 0.0, 0.0], ) oBody2.setTranslation(oBody.getTranslation(space='world'), space='world') #chain_parent([rigGroup, oSRT, oGlobal, oLocal, oBody, oBody2]) chain_parent([rigGroup, oGlobal, oLocal, oLocal2, oBody, oBody2]) make_a_root([oGlobal, oLocal, oLocal2, oBody, oBody2]) pm.parentConstraint(oBody2, "Geo", mo=True) pm.scaleConstraint(oBody2, "Geo", mo=True) oGlobal.getShape().overrideEnabled.set(True) oLocal.getShape().overrideEnabled.set(True) oLocal2.getShape().overrideEnabled.set(True) oBody.getShape().overrideEnabled.set(True) oBody2.getShape().overrideEnabled.set(True) oGlobal.getShape().overrideColor.set(13) oLocal.getShape().overrideColor.set(22) oLocal2.getShape().overrideColor.set(22) oBody.getShape().overrideColor.set(24) oBody2.getShape().overrideColor.set(24)
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)