def import_file(self): """Import component file""" log.info("Importing file: %s" % self.file) temp_namespace = "temp" cmds.file(self.file, i=True, namespace=temp_namespace) # Collect component nodes nodes = self._collect_imported_nodes() for node in nodes: # Check for duplicates if node.count("|"): e = "Duplicate node detected %s in component %s" % (node, self.__class__.__name__) log.error(e) raise RuntimeError(e) # Rename clean_node = ":".join(node.split(":")[1:]) try: cmds.rename(node, clean_node) self.nodes.append(clean_node) except: pass cmds.namespace(removeNamespace=temp_namespace, mergeNamespaceWithRoot=True, force=True)
def getCharacterInfo(): cmds.namespace(set=":") namespaces = cmds.namespaceInfo(lon=True) characterName = [] for name in namespaces: """ TODO: """ """ I need a global check for valid characters in the scene """ characterContainer = (name + ":character_container") setupContainer = name.replace("Character__", "Export__") setupContainer = (setupContainer + ":Setup") if cmds.objExists (characterContainer): fullCharName = name tmpCharName = name.split("__")[1] tmpCharName = tmpCharName[:tmpCharName.rfind("_")] characterName = tmpCharName return (characterName, characterContainer, fullCharName, setupContainer) else: characterContainer = 'Character__tmp_1:character_container' fullCharName = name tmpCharName = name.split("__")[1] tmpCharName = tmpCharName[:tmpCharName.rfind("_")] characterName = tmpCharName return (characterName, characterContainer, fullCharName, setupContainer) # Warn no character in the scene #charConfirm = ("No character exists in this scene") #cmds.confirmDialog(messageAlign="center", title="Create Directory", message= charConfirm) characterName = 'Character__tmp' return characterName
def process( call, *args): # Selection intialSelection = cmds.ls(selection=True, flatten=True) selections = intialSelection[:] # Input Values from UI inputName = ['placeholder'] # needs to be a list fed into it to work inputName[0] = cmds.textField("inputField", q=True, text = True) old = cmds.textField("replaceField", q=True, text = True) new = cmds.textField("withField", q=True, text = True) # Assign the Rename Class D = Rename(selections, inputName ) if old: # if there is data in the replaceField txt box, then run the replacement code for i in range( len (selections) ): findTxt = D.reFunction(D.getAfterNamespace(i), old) replacementName = D.getAfterNamespace(i)[ : findTxt [0][0] ] + new + D.getAfterNamespace(i)[ findTxt [0][1] : ] cmds.rename(selections[i], D.getNamespace(i) + replacementName) else: for i in range( len (selections) ): X = D.processNamespace(i) if X == ':': X = '::' # This prevents the root namespace from getting lost in the cutoff [:-1] use X[:-1] instead of D.processNamespace(i) [:-1] if cmds.namespace(exists = X [:-1] ) != True: # creates new namespace if doesn't already exist print ' creating new namespace' cmds.namespace(addNamespace = X [:-1] ) # create namespace if doesn't already exist cmds.rename( D.selection[i] , ':' + D.processNamespace(i) + D.processRename(i) ) cmds.namespace(set = ':') # set namespace back to root so any new object created is under the root if call == 'NA': cmds.warning('no exit call, window stays open') elif call == 'exit': cmds.warning('exit called, closing rename window') cmds.evalDeferred('cmds.deleteUI("renameUI")') #cmds.deleteUI(window)
def instanceAsset(namespace=""): """Find new namespace""" ns = namespace name = "%s:root" % ns i = 1 while cmds.objExists(name): ns = "%s%d" % (namespace, i) name = "%s:root" % ns i += 1 """Make instance""" cmds.namespace(add=ns) root = cmds.instance("%s:root" % namespace, name=name)[0] """Get model_grp path""" model_grp = "%s:root|%s:master_trs|%s:shot_trs|%s:aux_trs|%s:model_grp" % ( ns, namespace, namespace, namespace, namespace, ) """Lock attributes""" cmds.setAttr("%s.%s" % (root, "asset"), lock=True) cmds.setAttr("%s.%s" % (root, "texturever"), lock=True) cmds.setAttr("%s.inheritsTransform" % model_grp, 0)
def searchCharsName(): """检索当前场景中的所有角色名 Description: 根据绑定文件的命名规范与reference原则,从命名空间中就可获得角色名称 Arguments: 无 Returns: allCharsNameList:所有角色名列表(无重复) """ cmds.namespace(set = ":") allNamespace = cmds.namespaceInfo(listOnlyNamespaces = True) #拿到所有根目录下的命名空间名称 allCharsName = [] for eachNamespace in allNamespace: #拿到带有_Char_的命名空间名称,从中拿到角色名 if eachNamespace.find("_chr_") < 0: print "This Is Not A Char!" else: namesapceWithChar = eachNamespace charName = namesapceWithChar.split("_")[2] #charName存放角色名 allCharsName.append(charName) allCharsNameList = cT.delDupFromList(allCharsName) #调用函数去除list中的重复元素 return allCharsNameList
def doSwapAsset(arg=None): ''' Button: Swap For Reference. Swaps current selection for referenced asset. ''' currentImageLibrary = getImageLibrary() currentAssetLibrary = getAssetLibrary() cmds.namespace(setNamespace=":") directory = getCategoryFolder() if not directory: return directory = directory.replace(currentImageLibrary, currentAssetLibrary) selected = cmds.textField("currentAssetTFD", query=True, text=True) if not selected: sys.stdout.write("Select an asset.\n") return assetDirectory = selected.partition("_")[0] filename = os.path.join(directory, assetDirectory, "%s.ma" % selected) if currentAssetLibrary == ddConstants.CHAR_ASSETLIBRARY: # due to character naming 'CHAR_character', # assetDirectory needs to be more accurate char_patt = re.compile("^([A-Z]{3}_[a-zA-Z]+)\w*$") if char_patt.match(selected): assetDirectory = char_patt.search(selected).groups()[0] filename = os.path.join(directory, assetDirectory, "chesspiece", "published", "%s.ma" % selected) nodes = getSelectionList(topGrps=False) if nodes: ddSwapForReference.do(nodes=nodes, filename=filename)
def installModule(self, module, *arg): basename = 'instance_' cmds.namespace(setNamespace=":") namespaces = cmds.namespaceInfo(listOnlyNamespaces=True) for i in range(len(namespaces)): if namespaces[i].find('__') != -1: namespaces[i] = namespaces[i].partition('__')[2] newSuffix = utils.findHighestTrailingNumber(namespaces, basename) + 1 userSpecName = basename + str(newSuffix) hookObj = self.findHookObjectFromSelection() mod = __import__('Blueprint.'+ module,{},{},[module]) reload(mod) moduleClass = getattr(mod, mod.CLASS_NAME) moduleInstance = moduleClass(userSpecName, hookObj) moduleInstance.install() #this is to make sure move tool is selected by default moduleTransform = mod.CLASS_NAME + '__' + userSpecName + ':module_transform' cmds.select(moduleTransform, replace=True) cmds.setToolTo('moveSuperContext')
def buildScene(self): MayaCmds.file(new=True, force=True) MayaCmds.namespace(addNamespace='foo') MayaCmds.namespace(addNamespace='bar') MayaCmds.createNode('transform', name='foo:a') MayaCmds.createNode('transform', name='bar:a') MayaCmds.createNode('transform', name='a') MayaCmds.polyPlane(sx=1, sy=1, w=1, h=1, ch=0, n='foo:b') MayaCmds.polyPlane(sx=1, sy=1, w=1, h=1, ch=0, n='bar:b') MayaCmds.polyPlane(sx=1, sy=1, w=1, h=1, ch=0, n='b') MayaCmds.parent('foo:b', 'foo:a') MayaCmds.parent('bar:b', 'bar:a') MayaCmds.parent('b', 'a') MayaCmds.select('foo:b.vtx[0:8]') MayaCmds.setKeyframe(t=[1, 4]) MayaCmds.scale(0.1, 0.1, 0.1, r=True) MayaCmds.setKeyframe(t=2) MayaCmds.select('bar:b.vtx[0:8]') MayaCmds.setKeyframe(t=[1, 4]) MayaCmds.scale(2, 2, 2, r=True) MayaCmds.setKeyframe(t=2) MayaCmds.select('b.vtx[0:8]') MayaCmds.setKeyframe(t=[1, 4]) MayaCmds.scale(5, 5, 5, r=True) MayaCmds.setKeyframe(t=2)
def deleteNsContents(self, nameSpace): mc.namespace(set=":") mc.namespace(set=":"+nameSpace) if self.debug: print"current ns: ", mc.namespaceInfo(currentNamespace=True) nsContent = mc.namespaceInfo(ls=True, listOnlyDependencyNodes=True) if not nsContent: return for i in mc.namespaceInfo(ls=True, listOnlyDependencyNodes=True): delStr = i.split(":")[-1] try: print "deleting:", delStr #print mc.nodeType(i) mc.delete(i) self.count += 1 except: if self.debug:print "can not delete: ", i pass if self.debug: print "renaming namespace: ", nameSpace self.setNsCleaned(nameSpace)
def fixDoubleNamespaces(): """Import all elements into existing hierarchy if it already exists. Then delete the namespace and fixReferences()""" namespaces = cmds.namespaceInfo(listOnlyNamespaces=True, recurse=True, fullName=True) namespacesTofix = list(set([i.split(':')[0] for i in namespaces if ':' in i])) # Fix double namespaces for namespace in namespacesTofix: content = cmds.namespaceInfo(namespace, listNamespace=True, dagPath=True) tofixList = [i for i in content if cmds.ls(i.replace(namespace + ':', ''))] # Check if nodes already exists with the same name if we remove the namespace tofix = {} for i in tofixList: # Sort the elements by hierarchy level lenght = len(i.split('|')) try: tofix[lenght].append(i) except KeyError: tofix[lenght] = [i] for keys, values in reversed(sorted(tofix.iteritems())): for node in values: if isGroup(node): childrens = cmds.listRelatives(node, children=True, fullPath=True) or [] for u in childrens: upperGrp = node.replace(namespace + ':', '') cmds.parent(u, upperGrp) # parent each child to the original group cmds.delete(node) # then delete the empty group fixReferences() cmds.namespace(removeNamespace=namespace, mergeNamespaceWithRoot=True) return namespacesTofix
def deleteNS(): sel_namespace = cmds.ls(sl=True)[0] NS = sel_namespace.rsplit(':',1)[0] if not cmds.namespace(ex=NS): raise Exception('Namespace "'+NS+'" does not exist!') cmds.namespace(mv=[NS,':'],f=True) cmds.namespace(rm=NS)
def refreshAnimationModuleList(self, index=1): cmds.textScrollList(self.UIElements["animationModule_textScroll"], edit=True, removeAll=True) cmds.symbolButton(self.UIElements["deleteModuleButton"], edit=True, enable=False) cmds.symbolButton(self.UIElements["duplicateModuleButton"], edit=True, enable=False) selectedBlprnModule = cmds.textScrollList(self.UIElements["blueprintModule_textScroll"], q=True, selectItem=True) self.selectedBlueprintModule = self.blueprintModules[selectedBlprnModule[0]] self.setupActiveModuleControls() cmds.namespace(setNamespace=self.selectedBlueprintModule) controlModuleNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True) cmds.namespace(setNamespace=":") if controlModuleNamespaces != None: for module in controlModuleNamespaces: moduleName = utils.stripAllNamespaces(module)[1] cmds.textScrollList(self.UIElements["animationModule_textScroll"], edit=True, append=moduleName) cmds.textScrollList(self.UIElements["animationModule_textScroll"], edit=True, selectIndexedItem = index) cmds.symbolButton(self.UIElements["deleteModuleButton"], edit=True, enable=True) cmds.symbolButton(self.UIElements["duplicateModuleButton"], edit=True, enable=True) cmds.symbolButton(self.UIElements["zeroModulesButton"], edit=True, enable=True) self.setupModuleSpecificControls() self.previousBlueprintListEntry = selectedBlprnModule
def __init__(self, dpUIinst, langDic, langName, userGuideName, rigType, CLASS_NAME, TITLE, DESCRIPTION, ICON): """ Initialize the module class creating a button in createGuidesLayout in order to be used to start the guide module. """ # defining variables: self.dpUIinst = dpUIinst self.langDic = langDic self.langName = langName self.guideModuleName = CLASS_NAME self.title = TITLE self.description = DESCRIPTION self.icon = ICON self.userGuideName = userGuideName self.rigType = rigType # defining namespace: self.guideNamespace = self.guideModuleName + "__" + self.userGuideName # defining guideNamespace: cmds.namespace(setNamespace=":") self.namespaceExists = cmds.namespace(exists=self.guideNamespace) self.guideName = self.guideNamespace + ":Guide" self.moduleGrp = self.guideName+"_Base" self.radiusCtrl = self.moduleGrp+"_RadiusCtrl" self.annotation = self.moduleGrp+"_Ant" if not self.namespaceExists: cmds.namespace(add=self.guideNamespace) # create GUIDE for this module: self.createGuide() # create the Module layout in the mainUI - modulesLayoutA: self.createModuleLayout() # update module instance info: self.updateModuleInstanceInfo()
def importSkinByRef(ref, file, skip=[], **kwargs): """Import skin for every dag node in reference.""" if not os.path.exists(file): rigUtils.log('Skin file not found - skipping: %s' % file) return rigUtils.log('Reading file: %s' % file) f = open(file, 'r') j = json.loads(f.read()) f.close() cmds.namespace(set=ref) dagnodes = cmds.namespaceInfo(lod=True) cmds.namespace(set=':') skinned = [] for dagnode in dagnodes: if skip: if dagnode in skip: continue if dagnode in j: dict = j[dagnode] try: skindict = dict['skinCluster'] except: continue importSkin(skindict, dagnode, **kwargs) skinned.append(dagnode) return skinned
def _fixTheFuckingCores(self): """ This is used to clean sweep the static scenes and remove the duplicate Namespaces and reconnect the bases to the duplicates """ removedNameSpaces = [] ## Remove duplicate root core namespaces getAllNameSpaces = cmds.namespaceInfo(listOnlyNamespaces = True) for eachNS in getAllNameSpaces: if eachNS.endswith('1'): print 'Removing %s' % eachNS cmds.namespace(removeNamespace = eachNS, mergeNamespaceWithRoot = True) removedNameSpaces.append(eachNS.replace('1', '').replace('_CORE', '')) ## Remove duplicate base cores for each in cmds.ls(type = 'core_archive'): if '1'in each: print 'Cleaned rootCore %s from scene...' % each cmds.delete(each) ## Now find all geo with the core name in it and proceess it for reconnection for eachCore in removedNameSpaces: #print eachCore ## Check child _hrc grps for processing getAllGeo = [eachGeo for eachGeo in cmds.ls('*%s*' % eachCore) if cmds.nodeType(eachGeo) == 'transform'] for eachGeo in getAllGeo: self._reconnectDuplicates(eachGeo, '%s_CORE_Geoshader' % eachCore) coreLib.cleanupDeadCoreArchives()
def deleteModule(self, *args): """ Delete the Guide, ModuleLayout and Namespace. """ # delete mirror preview: try: cmds.delete(self.moduleGrp[:self.moduleGrp.find(":")]+"_MirrorGrp") except: pass # delete the guide module: utils.clearNodeGrp(nodeGrpName=self.moduleGrp, attrFind='guideBase', unparent=True) # clear default 'dpAR_GuideMirror_Grp': utils.clearNodeGrp() # remove the namespaces: allNamespaceList = cmds.namespaceInfo(listOnlyNamespaces=True) if self.guideNamespace in allNamespaceList: cmds.namespace(moveNamespace=(self.guideNamespace, ':'), force=True) cmds.namespace(removeNamespace=self.guideNamespace, force=True) try: # delete the moduleFrameLayout from window UI: cmds.deleteUI(self.moduleFrameLayout) self.clearSelectedModuleLayout() # edit the footer A text: self.currentText = cmds.text("footerAText", query=True, label=True) cmds.text("footerAText", edit=True, label=str(int(self.currentText[:self.currentText.find(" ")]) - 1) +" "+ self.langDic[self.langName]['i005_footerA']) except: pass # clear module from instance list (clean dpUI list): delIndex = self.dpUIinst.moduleInstancesList.index(self) self.dpUIinst.moduleInstancesList.pop(delIndex)
def namespaceList(current= None): """ """ if not current: cmds.namespace(set = ':') return cmds.namespaceInfo(lon= 1, r= 1, an= 1)
def _createNativeModel(self, name='Model', nativeObjects=[], referenced=False): name = 'Model' if not name else name # Create a "model" namespace and add the locator to it # TODO: Make this a context currentNamespace = cmds.namespaceInfo(currentNamespace=True) namespace = cmds.namespace(addNamespace=name) cmds.namespace(setNamespace=namespace) # Create the transform node then the shape node so the transform is properly named parent = cmds.createNode('transform', name='Model') #name = cmds.createNode('locator', name='{}Shape'.format(name), parent=parent) output = cross3d.SceneWrapper._asMOBject(parent) userProps = cross3d.UserProps(output) userProps['model'] = True if referenced: userProps['referenced'] = referenced # Create the Active_Resolution enum if it doesn't exist # cmds.addAttr(name, longName="Active_Resolution", attributeType="enum", enumName="Offloaded:") # userProps['Resolutions'] = OrderedDict(Offloaded='') cmds.namespace(setNamespace=currentNamespace) # Add each of nativeObjects to the model namespace if nativeObjects: for nativeObject in nativeObjects: nativeObject = cross3d.SceneWrapper._getTransformNode(nativeObject) objName = cross3d.SceneWrapper._mObjName(nativeObject) # cmds.parent(objName, cross3d.SceneWrapper._mObjName(nativeParent)) nameInfo = cross3d.SceneWrapper._namespace(nativeObject) newName = '{namespace}:{name}'.format(namespace=namespace, name=nameInfo['name']) cmds.rename(objName, newName) nativeObjects.append(output) return output
def _removeNativeModels(self, models): """ Deletes provided native models. :param models: list of native models :return: <bool> success """ ret = True for model in models: nameInfo = cross3d.SceneWrapper._namespace(model) fullName = cross3d.SceneWrapper._mObjName(model) if cmds.referenceQuery(fullName, isNodeReferenced=True): # The model is referenced and we need to unload it. refNode = cmds.referenceQuery(fullName, referenceNode=True) filename = cmds.referenceQuery(refNode, filename=True) # If all nodes in the namespace are referenced, the namespace will be removed, otherwise # the namespace will still exist and contain all of those unreferenced nodes. cmds.file(filename, removeReference=True) # Remove nodes that were parented to referneced nodes leftovers = self.objects(wildcard='{refNode}fosterParent*'.format(refNode=refNode)) if leftovers: self.removeObjects(leftovers) # Local node processing: check for unreferenced items in the namespace and remove them. namespace = nameInfo['namespace'] if cmds.namespace(exists=namespace): cmds.namespace(removeNamespace=namespace, deleteNamespaceContent=True) if cmds.namespace(exists=namespace): print 'The namespace {ns} still exists the model {model} was not entirely removed.'.format(namespace, model=fullName) ret = False return ret
def do(nodes=None): '''Builds the window. ''' doCloseWindow() cmds.namespace(setNamespace=":") window = cmds.window("textureManagerWIN", title="Texture Manager", sizeable=True, resizeToFitChildren=True, widthHeight=(800, 450)) mainFL = cmds.formLayout("textureManagerFL", numberOfDivisions=100) displayShaderFL = cmds.formLayout("displayShaderFL", numberOfDivisions=100, parent=mainFL) displayShaderSL = cmds.textScrollList("displayShaderSL", allowMultiSelection=True, parent=displayShaderFL, selectCommand=partial(doSelectShaders)) shadersMenu = cmds.popupMenu('displayShadersMenu', parent=displayShaderSL) displayTextureFL = cmds.formLayout("displayTextureFL", numberOfDivisions=100, parent=mainFL) displayTextureSL = cmds.textScrollList("displayTextureSL", allowMultiSelection=True, parent=displayTextureFL) showShadersForSelectionBTN = cmds.button("showShadersForSelectionBTN", label="Show Shaders For Selection", height=30, annotation="Show shaders for selected GEO or GRP", parent=mainFL, backgroundColor=[0.28, 0.337, 0.375], c=partial(doShowShadersForSelection)) openShaderLibraryBTN = cmds.button("openShaderLibraryBTN", label="Open Shader Library", height=30, annotation="Open Shader Library", parent=mainFL, backgroundColor=[0.28, 0.337, 0.375], c=partial(doOpenShaderLibrary)) refreshTexturesBTN = cmds.button("refreshTexturesBTN", label="Refresh", height=30, annotation="Refresh display", parent=mainFL, backgroundColor=[0.28, 0.337, 0.375], c=partial(doRefreshShadersDisplay)) textureManagerHelpBTN = cmds.button("textureManagerHelpBTN", label="Help", height=30, annotation="Show instructions and other information.", parent=mainFL, backgroundColor=[0.28, 0.337, 0.375], c=partial(showTextureManagerHelp)) currentNodesTFD = cmds.textField("currentNodesTFD", text="", visible=False, parent=mainFL) c1 = 25 c2 = 50 c3 = 75 r1 = 50 r2 = 89 cmds.formLayout(mainFL, edit=True, attachPosition=[ (displayShaderFL, "top", 15, 0), (displayShaderFL, "bottom", 4, r1), (displayTextureFL, "top", 4, r1), (displayTextureFL, "bottom", 6, r2), (showShadersForSelectionBTN, "top", 6, r2), (showShadersForSelectionBTN, "bottom", 15, 100), (openShaderLibraryBTN, "top", 6, r2), (openShaderLibraryBTN, "bottom", 15, 100), (refreshTexturesBTN, "top", 6, r2), (refreshTexturesBTN, "bottom", 15, 100), (textureManagerHelpBTN, "top", 6, r2), (textureManagerHelpBTN, "bottom", 15, 100), (displayShaderFL, "left", 12, 0), (displayShaderFL, "right", 12, 100), (displayTextureFL, "left", 12, 0), (displayTextureFL, "right", 12, 100), (showShadersForSelectionBTN, "left", 12, 0), (showShadersForSelectionBTN, "right", 3, c1), (openShaderLibraryBTN, "left", 3, c1), (openShaderLibraryBTN, "right", 3, c2), (refreshTexturesBTN, "left", 3, c2), (refreshTexturesBTN, "right", 3, c3), (textureManagerHelpBTN, "left", 3, c3), (textureManagerHelpBTN, "right", 12, 100) ]) cmds.formLayout(displayShaderFL, edit=True, attachForm = [ (displayShaderSL, "top", 0), (displayShaderSL, "left", 0), (displayShaderSL, "right", 0), (displayShaderSL, "bottom", 0) ]) cmds.formLayout(displayTextureFL, edit=True, attachForm = [ (displayTextureSL, "top", 0), (displayTextureSL, "left", 0), (displayTextureSL, "right", 0), (displayTextureSL, "bottom", 0) ]) window = cmds.window("textureManagerWIN", edit=True, widthHeight=(800, 464)) # Initialize current node list doShowShadersForSelection() # Initialize shading engines list doBuildShadingEnginesList() cmds.showWindow(window)
def iterNamespaces( namespace=':' ): ''' iterates over all namespaces under and including the one given... holy sH1t namespaces suck b4lls in maya ''' if namespace.endswith( ':' ): namespace = namespace[ :-1 ] namespaces = [ namespace ] idx = 0 while True: try: curNS = namespaces[ idx ] except IndexError: break idx += 1 try: cmd.namespace( set=curNS ) except RuntimeError: continue subs = cmd.namespaceInfo( listOnlyNamespaces=True ) if subs is None: continue namespaces += subs return iter( namespaces )
def doReferenceAsset(arg=None): ''' Button: Reference Asset. References the assets using namespaces. ''' currentImageLibrary = getImageLibrary() currentAssetLibrary = getAssetLibrary() cmds.namespace(setNamespace=":") directory = getCategoryFolder() if not directory: return directory = directory.replace(currentImageLibrary, currentAssetLibrary) selected = cmds.textField("currentAssetTFD", query=True, text=True) if not selected: sys.stdout.write("Select an asset.\n") return assetDirectory = selected.partition("_")[0] filename = os.path.join(directory, assetDirectory, "%s.ma" % selected) if currentAssetLibrary == ddConstants.CHAR_ASSETLIBRARY: # due to character naming 'CHAR_character', # assetDirectory needs to be more accurate char_patt = re.compile("^([A-Z]{3}_[a-zA-Z]+)\w*$") if char_patt.match(selected): assetDirectory = char_patt.search(selected).groups()[0] filename = os.path.join(directory, assetDirectory, "chesspiece", "published", "%s.ma" % selected) if os.path.isfile(filename): cmds.file(filename, reference=True, namespace=selected) else: sys.stdout.write("File not found: %s.\n" % filename) return deselectAllAssets()
def testExportWithStripAndMerge(self): mayaFilePath = os.path.abspath('UsdExportStripNamespaces.ma') cmds.file(mayaFilePath, new=True, force=True) cmds.namespace(add=":foo") cmds.namespace(add=":bar") node1 = cmds.polyCube( sx=5, sy=5, sz=5, name="cube1" ) cmds.namespace(set=":foo"); node2 = cmds.polyCube( sx=5, sy=5, sz=5, name="cube2" ) cmds.namespace(set=":bar"); node3 = cmds.polyCube( sx=5, sy=5, sz=5, name="cube3" ) cmds.namespace(set=":"); usdFilePath = os.path.abspath('UsdExportStripNamespaces_EXPORTED.usda') cmds.usdExport(mergeTransformAndShape=True, selection=False, stripNamespaces=True, file=usdFilePath, shadingMode='none') stage = Usd.Stage.Open(usdFilePath) self.assertTrue(stage) expectedPrims = ("/cube1", "/cube2", "/cube3") for primPath in expectedPrims: prim = stage.GetPrimAtPath(primPath) self.assertTrue(prim.IsValid(), "Expect " + primPath)
def renameAllNodeInNamespace( ns='' ) : # Remove every nodes that belong to the given namespace. # Input : Namespace # Output : Empty namespace nodes = mc.ls( '%s:*' % ns , l=True ) mc.namespace( set=':' ) if nodes : # If current namespace contains nodes, # delete them. for node in nodes : if mc.objExists( node ) : lockState = mc.lockNode( node , q=True )[0] if lockState : mc.lockNode( node , l=False ) newName = addElementToName( node.split( ':' )[-1] , ns ) print newName try : mc.rename( node , newName ) except : pass
def rename_module_instance(self, new_name): if new_name == self.user_specified_name: return True if utils.does_blueprint_user_specified_name_exist(new_name): cmds.confirmDialog( title="Name Confilct", message="Name \""+new_name+"\" already exists, aborting rename", button=["Accept"], defaultButton="Accept" ) return False else: new_namespace = self.module_name+"__"+new_name cmds.lockNode(self.container_name, lock=False, lockUnpublished=False) cmds.namespace(setNamespace=":") cmds.namespace(add=new_namespace) cmds.namespace(setNamespace=":") cmds.namespace(moveNamespace=[self.module_namespace, new_namespace]) cmds.namespace(removeNamespace=self.module_namespace) self.module_namespace = new_namespace self.container_name = self.module_namespace+"::module_container" cmds.lockNode(self.container_name, lock=True, lockUnpublished=True) return True
def install_module(self,module,*args): basename = "instance_" cmds.namespace(setNamespace =":") namespaces = cmds.namespaceInfo(listOnlyNamespaces=True) for i in range(len(namespaces)): if namespaces[i].find("__") != -1: namespaces[i] = namespaces[i].partition("__")[2] new_suffix = utils.find_highest_trailing_number(namespaces, basename)+1 user_specified_name = basename+str(new_suffix) hook_obj = self.find_hook_obj_from_selection() mod = __import__("blueprint."+module, {}, {}, [module]) reload(mod) module_class = getattr(mod, mod.CLASS_NAME) module_instance = module_class(user_specified_name, hook_obj) module_instance.install() module_trans = mod.CLASS_NAME+"__"+user_specified_name+":module_transform" cmds.select(module_trans,replace=True) cmds.setToolTo("moveSuperContext")
def removeAllNodeInNamespace( ns='' ) : # Remove every nodes that belong to the given namespace. # Input : namespace # Output : Nonde nodes = mc.ls( '%s:*' % ns ) mc.namespace( set=':' ) if nodes : # If current namespace contains nodes, # delete them. for node in nodes : if mc.objExists( node ) : lockState = mc.lockNode( node , q=True )[0] if lockState : mc.lockNode( node , l=False ) try : newName = mc.rename( node , node.split( ':' )[-1] ) print '%s has been renamed to %s' % ( node , newName ) except : pass mc.lockNode( newName , l=lockState )
def resolveNamespaceClashes(self, tempNamespace): returnNames = [] cmds.namespace(setNamespace=tempNamespace) namespaces = cmds.namespaceInfo(listOnlyNamespaces=True) cmds.namespace(setNamespace=':') existingNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True) for i in range(len(namespaces)): namespaces[i] = namespaces[i].partition(tempNamespace+ ':')[2] for name in namespaces: newName = str(name) oldName = tempNamespace + ':' + name if name in existingNamespaces: highestSuffix = utils.findHighestTrailingNumber(existingNamespaces, name+'_') highestSuffix += 1 newName = str(name) + '_' + str(highestSuffix) returnNames.append([oldName,newName]) self.resolveNameChangeMirrorLinks(returnNames,tempNamespace) self.renameNamespaces(returnNames) return returnNames
def remove(namespaces = 'all'): if namespaces == 'all': namespaces = cmds.namespaceInfo(lon = 1) for namespace in namespaces: cmds.namespace(f=1,mv=(namespace,":")) if namespace.count("UI") <1 and namespace.count("uv") <1 and namespace.count("shared") <1: cmds.namespace(f=1,rm=str(namespace))
def removeNamespaces(self, *args): cmds.namespace(set=':') """ Move objects out of the character namespace """ cmds.namespace(mv=(self.characterPrefix, ':'), f=True) cmds.namespace(rm=self.characterPrefix) cmds.namespace(mv=(self.exportPrefix, ':'), f=True) cmds.namespace(rm=self.exportPrefix)
def testExportWithClashStripping(self): mayaFilePath = os.path.abspath('UsdExportStripNamespaces.ma') cmds.file(mayaFilePath, new=True, force=True) node1 = cmds.polyCube(sx=5, sy=5, sz=5, name="cube1") cmds.namespace(add="foo") cmds.namespace(set="foo") node2 = cmds.polyCube(sx=5, sy=5, sz=5, name="cube1") cmds.namespace(set=":") usdFilePath = os.path.abspath('UsdExportStripNamespaces_EXPORTED.usda') errorRegexp = "Multiple dag nodes map to the same prim path" \ ".+|cube1 - |foo:cube1.*" with self.assertRaisesRegexp(RuntimeError, errorRegexp) as cm: cmds.usdExport(mergeTransformAndShape=True, selection=False, stripNamespaces=True, file=usdFilePath, shadingMode='none') with self.assertRaisesRegexp(RuntimeError, errorRegexp) as cm: cmds.usdExport(mergeTransformAndShape=False, selection=False, stripNamespaces=True, file=usdFilePath, shadingMode='none')
def remove(self, container): """Remove an existing `container` from Maya scene Deprecated; this functionality is replaced by `api.remove()` Arguments: container (avalon-core:container-1.0): Which container to remove from scene. """ from maya import cmds node = container["objectName"] # Assume asset has been referenced members = cmds.sets(node, query=True) reference_node = self._get_reference_node(members) assert reference_node, ("Imported container not supported; " "container must be referenced.") self.log.info("Removing '%s' from Maya.." % container["name"]) namespace = cmds.referenceQuery(reference_node, namespace=True) fname = cmds.referenceQuery(reference_node, filename=True) cmds.file(fname, removeReference=True) try: cmds.delete(node) except ValueError: # Already implicitly deleted by Maya upon removing reference pass try: # If container is not automatically cleaned up by May (issue #118) cmds.namespace(removeNamespace=namespace, deleteNamespaceContent=True) except RuntimeError: pass
def getAllNS(): #set the current naemspace to world curNS = mc.namespaceInfo(cur=True) mc.namespace(set=":") #because maya can only list the child namespaces of the current set namespace, we have to recursively go through setting #and checking child namespaces #start by getting the worlds children namespaces = [] childspaces = mc.namespaceInfo(lon=True) while childspaces: #move the current add spaces into the namespaces list (what we will return) namespaces.extend(childspaces) #create a list from the childspaces so that we can check for their children checkspaces = childspaces #empty the childspaces so all new children can be added to it for the next round childspaces = [] #cycle through the current checkspaces and get their child namespaces for check in checkspaces: mc.namespace(set=(":" + check)) grandchildspaces = mc.namespaceInfo(lon=True) if grandchildspaces: childspaces.extend(grandchildspaces) #remove default namespaces if namespaces.count('UI'): namespaces.remove('UI') if namespaces.count('shared'): namespaces.remove('shared') mc.namespace(set=(":" + curNS)) namespaces.sort() return namespaces
def jobPinGuide(self, ctrlName, *args): """ Pin temporally the guide by scriptJob. """ transformAttrList = ["tx", "ty", "tz", "rx", "ry", "rz", "sx", "sy", "sz", "v"] if cmds.objExists(ctrlName+".pinGuide"): # extracting namespace... need to find an ellegant way using message or stored attribute instead: nameSpaceName = None cmds.namespace(set=":") if ":" in ctrlName: if "|" in ctrlName: nameSpaceName = ctrlName[ctrlName.rfind("|")+1:ctrlName.rfind(":")] else: nameSpaceName = ctrlName[:ctrlName.rfind(":")] pcName = ctrlName+"_PinGuide_PaC" pinValue = cmds.getAttr(ctrlName+".pinGuide") if pinValue: if not cmds.objExists(pcName): if cmds.objExists(self.dpUIinst.tempGrp): if nameSpaceName: cmds.namespace(set=nameSpaceName) cmds.parentConstraint(self.dpUIinst.tempGrp, ctrlName, maintainOffset=True, name=pcName) self.setPinnedGuideColor(ctrlName, True, "red") else: pConstList = cmds.listRelatives(ctrlName, children=True, type="parentConstraint") if pConstList: for pConst in pConstList: if "PinGuide" in pConst: cmds.delete(pConst) self.setPinnedGuideColor(ctrlName, False, "red") for attr in transformAttrList: cmds.setAttr(ctrlName+"."+attr, lock=pinValue) cmds.namespace(set=":")
def installTemplate(self, templateAndPath, *args): cmds.file(templateAndPath, i=True, namespace="TEMPLATE_1") self.resolveNamespaceClashes("TEMPLATE_1") groupContainer = "TEMPLATE_1:Group_container" if cmds.objExists(groupContainer): self.resolveGroupNameClashes("TEMPLATE_1") cmds.lockNode(groupContainer, lock=False, lockUnpublished=False) oldGroupContainer = "Group_container" if cmds.objExists(oldGroupContainer): cmds.lockNode(oldGroupContainer, lock=False, lockUnpublished=False) nodeList = cmds.container(groupContainer, q=True, nodeList=True) utils.addNodeToContainer(oldGroupContainer, nodeList, force=True) cmds.delete(groupContainer) else: cmds.rename(groupContainer, oldGroupContainer) cmds.lockNode("Group_container", lock=True, lockUnpublished=True) cmds.namespace(setNamespace=":") cmds.namespace(moveNamespace=("TEMPLATE_1",":"), force=True) cmds.namespace(removeNamespace="TEMPLATE_1")
def fixDoubleNamespaces(): """Import all elements into existing hierarchy if it already exists. Then delete the namespace and fixReferences()""" namespaces = cmds.namespaceInfo(listOnlyNamespaces=True, recurse=True, fullName=True) namespacesTofix = list( set([i.split(':')[0] for i in namespaces if ':' in i])) # Fix double namespaces for namespace in namespacesTofix: content = cmds.namespaceInfo(namespace, listNamespace=True, dagPath=True) tofixList = [ i for i in content if cmds.ls(i.replace(namespace + ':', '')) ] # Check if nodes already exists with the same name if we remove the namespace tofix = {} for i in tofixList: # Sort the elements by hierarchy level lenght = len(i.split('|')) try: tofix[lenght].append(i) except KeyError: tofix[lenght] = [i] for keys, values in reversed(sorted(tofix.iteritems())): for node in values: if isGroup(node): childrens = cmds.listRelatives( node, children=True, fullPath=True) or [] for u in childrens: upperGrp = node.replace(namespace + ':', '') cmds.parent( u, upperGrp ) # parent each child to the original group cmds.delete(node) # then delete the empty group fixReferences() cmds.namespace(removeNamespace=namespace, mergeNamespaceWithRoot=True) return namespacesTofix
def refreshData(self, *_): self.__select = [] cmds.namespace(set=":") self.shelf.cleanUp() self.motionLibBtnImport.setEnabled(False) self.motionLibCBProject.setCurrentText(config.getProject()) if not self.motionLibCBCharactor.count(): return self.namespace = self.motionLibCBCharactor.currentText().split( "<")[-1].split(">")[0] self.path = config.getConfig('animLibPath') + self.getOrigChar( self.namespace.split(":")[-1]) fileList = self.getFileList(self.path) exp = codecs.decode(self.motionLibLEFilter.text(), 'utf-8') itemList = [] for f in fileList: if self.__match__(f, exp): found = False for ext in ['gif', 'png', 'jpg']: iconPath = self.path + f + ext if os.path.isfile(iconPath): found = True break if not found: iconPath = config.getPath(config.kIcon, "motion.gif") itemList.append({ ui.QShelfView.kName: f, ui.QShelfView.kData: f, ui.QShelfView.kIcon: iconPath, ui.QShelfView.kType: f }) self.shelf.setup(*itemList) sels = os.popen("type \"%s\"\\__config__" % self.path).read() for sel in sels.split('&'): if not sel: continue self.__select.append("%s:%s" % (self.namespace, sel)) if not self.__select: self.__select.append("%s:Main" % self.namespace) cmds.select(self.__select, r=True) self.__config = None
def remove_namespace(self, removeNS): # removeNS = "rp_1" mc.namespace(set=removeNS) objsInNs = mc.namespaceInfo(listNamespace=True) mc.delete(objsInNs) mc.namespace(set=":") mc.namespace(removeNamespace=removeNS)
def test_reference_without_dag(taskfile_without_dagnodes, djprj, assettypinter, mrefobjinter): cmds.file(new=True, force=True) cmds.namespace(add="foo") cmds.namespace(set="foo") assert cmds.namespaceInfo(absoluteName=True) == ":foo" tf = djprj.assettaskfiles[0] tfi = TaskFileInfo.create_from_taskfile(tf) refobj = mrefobjinter.create(typ="Asset", identifier=0) assettypinter.reference(refobj, tfi) # assert namespace is still the same assert cmds.namespaceInfo(absoluteName=True) == ":foo" refnode = cmds.referenceQuery(taskfile_without_dagnodes, referenceNode=True) ns = cmds.referenceQuery(refnode, namespace=True) ns = cmds.namespaceInfo(ns, fullName=True) # assert no group created content = cmds.namespaceInfo(ns, listOnlyDependencyNodes=True) assert not cmds.ls(content, type="jb_asset") assert cmds.getAttr("%s.taskfile_id" % refobj) == tf.pk # reference2 refobj2 = mrefobjinter.create(typ="Asset", identifier=1) assettypinter.reference(refobj2, tfi) # assert namespace is still the same assert cmds.namespaceInfo(absoluteName=True) == ":foo" refnode2 = cmds.referenceQuery(taskfile_without_dagnodes + "{1}", referenceNode=True) ns2 = cmds.referenceQuery(refnode2, namespace=True) ns2 = cmds.namespaceInfo(ns2, fullName=True) assert refnode2 != refnode assert ns2 != ns # assert no group created content = cmds.namespaceInfo(ns, listOnlyDependencyNodes=True) assert not cmds.ls(content, type="jb_asset") assert cmds.getAttr("%s.taskfile_id" % refobj2) == tf.pk
def moveNS(srcNS, dstNS): """ Move all items from the source namespace to the destination namespace. @param srcNS: The source namespace @type srcNS: str @param dstNS: The destination namespace @type dstNS: str """ # Check NS if not cmds.namespace(exists=srcNS): raise Exception('Source namespace "' + srcNS + '" does not exist!') # Check Destination NS if not cmds.namespace(exists=dstNS): # Create newNS dstNS = cmds.namespace(add=dstNS, f=True) # Move namespace cmds.namespace(mv=(srcNS, dstNS), f=True) # Return newNS return newNS
def getCharacterInfo(): cmds.namespace(set=":") namespaces = cmds.namespaceInfo(lon=True) characterName = [] for name in namespaces: characterContainer = (name + ":character_container") setupContainer = name.replace("Character__", "Export__") setupContainer = (setupContainer + ":Setup") if cmds.objExists(characterContainer): fullCharName = name tmpCharName = name.split("__")[1] tmpCharName = tmpCharName[:tmpCharName.rfind("_")] characterName = tmpCharName return (characterName, characterContainer, fullCharName, setupContainer) else: # Warn no character in the scene charConfirm = ("No character exists in this scene") cmds.confirmDialog(messageAlign="center", title="Create Directory", message=charConfirm)
def setLiveNS(namespace): ''' Set the current namespace, this will cause all items created to be in this namespace. @note: this namespace does not need to exist, it will be created otherwise @param namespace: the namespace to create/set @type namespace: str ''' namespace = cleanNS(namespace) # if setting to world if namespace == ":": mc.namespace(set=":") else: addNS(namespace) mc.namespace(set=":%s" % namespace) # confirm it curNS = mc.namespaceInfo(cur=True) if not curNS == namespace: raise NamespacerError('The namespace "%s" was not set, current namespace is "%s"'\ % (namespace, curNS)) return True
def delete( self, move_to_namespace = rootpath, autocreate=True ): """Delete this namespace and move it's obejcts to the given move_to_namespace :param move_to_namespace: if None, the namespace to be deleted must be empty If Namespace, objects in this namespace will be moved there prior to namespace deletion move_to_namespace must exist :param autocreate: if True, move_to_namespace will be created if it does not exist yet :note: can handle sub-namespaces properly :raise RuntimeError: :todo: Implement undo !""" if self == self.rootpath: raise ValueError( "Cannot delete root namespace" ) if not self.exists(): # its already gone - all fine return # assure we have a namespace type if move_to_namespace: move_to_namespace = self.__class__( move_to_namespace ) # assure we do not loose the current namespace - the maya methods could easily fail previousns = Namespace.current( ) cleanup = CallOnDeletion( None ) if previousns != self: # cannot reset future deleted namespace cleanup.callableobj = lambda : previousns.setCurrent() # recurse into children for deletion for childns in self.children( ): childns.delete( move_to_namespace = move_to_namespace ) # make ourselves current self.setCurrent( ) if move_to_namespace: self.moveNodes( move_to_namespace, autocreate=autocreate ) # finally delete the namespace cmds.namespace( rm=self )
def remove_namespaces(empty_first=True, defaults=('UI', 'shared')): """Remove namespaces from the current Maya scene. Args: empty_first: Remove nodes from the namespace before deleting it defaults: Namespaces to keep Returns: None """ namespaces = [ ns for ns in cmds.namespaceInfo(lon=True, r=True) if ns not in defaults ] namespaces.sort(key=lambda ns: ns.count(':'), reverse=True) for ns in namespaces: try: cmds.namespace(rm=ns, mnr=empty_first) LOG.debug('Removed namespace: `{0}`'.format(ns)) except RuntimeError as e: LOG.exception( 'Could not remove namespace, it might not be empty: {}'.format( e))
def initialiseBlueprintModuleList(self): cmds.namespace(setNamespace=self.selectedCharacter) blueprintNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True) cmds.namespace(setNamespace=":") # Dictionary containing full names of blueprint modules self.blueprintModules = {} if len(blueprintNamespaces) > 0: for namespace in blueprintNamespaces: blueprintModule = utils.stripLeadingNamespace(namespace)[1] """ Add in to modify name displayed in module scroll list """ #uSpecNameA = blueprintModule.partition("__")[0] #uSpecNameB = blueprintModule.partition("__")[2] #userSpecifiedName = (uSpecNameA + "_" + uSpecNameB) userSpecifiedName = blueprintModule.partition("__")[2] cmds.textScrollList(self.UIElements["blueprintModule_textScroll"], edit=True, append=userSpecifiedName) self.blueprintModules[userSpecifiedName] = namespace cmds.textScrollList(self.UIElements["blueprintModule_textScroll"], edit=True, selectIndexedItem=1) selectedBlprnModule = cmds.textScrollList(self.UIElements["blueprintModule_textScroll"], q=True, selectItem=True) self.selectedBlueprintModule = self.blueprintModules[selectedBlprnModule[0]]
def delete_asset(): selection = cmds.ls(sl=1, long=1) namespaces_list = [] for sel in selection: namespace = None relatives = cmds.listRelatives(sel, allDescendents=1) for relative in relatives: if cmds.referenceQuery(relative, isNodeReferenced=True): namespace = relative.split(':')[0] refFile = cmds.referenceQuery(relative, filename=True) break if [namespace, refFile] not in namespaces_list: namespaces_list.append([namespace, refFile]) for namespace in namespaces_list: cmds.file(namespace[-1], removeReference=True) locator_name = namespace[0] + '_CTRL' if cmds.objExists(locator_name): cmds.delete(locator_name) if cmds.namespace(exists=namespace[0]): cmds.namespace(rm=namespace[0])
def basicBlock(): blockHeight = cmds.intSliderGrp('blockHeight', q=True, v=True) blockWidth = cmds.intSliderGrp('blockWidth', q=True, v=True) blockDepth = cmds.intSliderGrp('blockDepth', q=True, v=True) rgb = cmds.colorSliderGrp('blockColour', q=True, rgbValue=True) #Creates the temporary namespace global nextBlockId nsTmp = "Block" + str(nextBlockId) nextBlockId = nextBlockId + 1 createNamespace(nsTmp) cubeSizeX = blockWidth * 0.8 cubeSizeZ = blockDepth * 0.8 cubeSizeY = blockHeight * 0.32 cmds.polyCube(h=cubeSizeY, w=cubeSizeX, d=cubeSizeZ) cmds.move((cubeSizeY / 2.0), moveY=True) for i in range(blockWidth): for j in range(blockDepth): cmds.polyCylinder(r=0.25, h=0.20) cmds.move((cubeSizeY + 0.10), moveY=True, a=True) cmds.move(((i * 0.8) - (cubeSizeX / 2.0) + 0.4), moveX=True, a=True) cmds.move(((j * 0.8) - (cubeSizeZ / 2.0) + 0.4), moveZ=True, a=True) myShader = cmds.shadingNode('lambert', asShader=True, name="blckMat") cmds.setAttr(nsTmp + ":blckMat.color", rgb[0], rgb[1], rgb[2], typ='double3') cmds.polyUnite((nsTmp + ":*"), n=nsTmp, ch=False) cmds.delete(ch=True) cmds.hyperShade(assign=(nsTmp + ":blckMat")) cmds.namespace(removeNamespace=":" + nsTmp, mergeNamespaceWithParent=True)
def _find(self): """ :return: Empty namespaces :rtype: generator """ # set namespace to root cmds.namespace(set=":") # get all namespaces namespaces = cmds.namespaceInfo(":", listOnlyNamespaces=True, recurse=True) namespaces.reverse() # loop namespaces for ns in namespaces: if ns in self.ignoreNamespaces: continue # yield empty namespaces if not cmds.namespaceInfo(ns, listOnlyDependencyNodes=True): yield ns
def remove(self, container): from maya import cmds namespace = container["namespace"] container_name = container["objectName"] container_content = cmds.sets(container_name, query=True) nodes = cmds.ls(container_content, long=True) nodes.append(container_name) self.log.info("Removing '%s' from Maya.." % container["name"]) try: cmds.delete(nodes) except ValueError: pass cmds.namespace(removeNamespace=namespace, deleteNamespaceContent=True) return True
def test_create_from_attributes_with_namespace(): """Validate we can create a compound from attributes in a namespace.""" cmds.namespace(addNamespace=":namespace_a") cmds.rename("a", ":namespace_a:a") cmds.rename("b", ":namespace_a:b") cmds.rename("c", ":namespace_a:c") cmds.rename("d", ":namespace_a:d") cmds.rename("e", ":namespace_a:e") compound = from_attributes([":namespace_a:b.translateX"], [":namespace_a:d.translateX"]) assert isinstance(compound, Compound) assert _ls() == { "namespace_a:a", "namespace_a:compound1:inputs", "namespace_a:compound1:b", "namespace_a:compound1:c", "namespace_a:compound1:d", "namespace_a:compound1:outputs", "namespace_a:e", }
def mirrorLyt(self, *args): """ Requires the lyt to be mirrored and added to a namespace. """ asset_info = {} if len(cmds.ls(sl=True)) == 0: return sel = cmds.ls(sl=True)[0] if cmds.nodeType(sel) != 'dagContainer': return assetcontents = cmds.container(sel, q=True, nl=True) print sel print assetcontents # Find the Main_GRP for a in assetcontents: if 'Main_GRP' in a: maingrp = a print maingrp mmain = maingrp.replace('L_', 'R_') print mmain # Determine mirror namespace name tv = maingrp.partition(':')[0] mns = tv.replace('L_', 'R_') cmds.namespace(set=':') cmds.namespace(add=mns) cmds.namespace(set=mns) # Duplicate the Main_GRP nodedupe = cmds.duplicate(maingrp, ic=True, rc=True, un=True) mircon = cmds.container(n='FACE_LYT_01_AST') print mmain try: cmds.container(sel, edit=True, rn=mmain, force=True) except: pass cmds.container(mircon, edit=True, an=mmain, f=True) cmds.namespace(set=':') for n in nodedupe: cmds.container(mircon, edit=True, an=n, f=True) cmds.container(mircon, edit=True, an=n, f=True)
def deleteModule(self, *args): """ Delete the Guide, ModuleLayout and Namespace. """ # delete mirror preview: try: cmds.delete(self.moduleGrp[:self.moduleGrp.find(":")] + "_MirrorGrp") except: pass # delete the guide module: utils.clearNodeGrp(nodeGrpName=self.moduleGrp, attrFind='guideBase', unparent=True) # clear default 'dpAR_GuideMirror_Grp': utils.clearNodeGrp() # remove the namespaces: allNamespaceList = cmds.namespaceInfo(listOnlyNamespaces=True) if self.guideNamespace in allNamespaceList: cmds.namespace(moveNamespace=(self.guideNamespace, ':'), force=True) cmds.namespace(removeNamespace=self.guideNamespace, force=True) try: # delete the moduleFrameLayout from window UI: cmds.deleteUI(self.moduleFrameLayout) self.clearSelectedModuleLayout() # edit the footer A text: self.currentText = cmds.text("footerAText", query=True, label=True) cmds.text( "footerAText", edit=True, label=str( int(self.currentText[:self.currentText.find(" ")]) - 1) + " " + self.langDic[self.langName]['i005_footerA']) except: pass # clear module from instance list (clean dpUI list): delIndex = self.dpUIinst.moduleInstancesList.index(self) self.dpUIinst.moduleInstancesList.pop(delIndex)
def switch(cls, bsnodes, *args): '''切换缓存 bsnodes传入类型为list ''' _input_connect = {} _output_connect = {} _info = {} asset, namespace, node, path = args _texgrp = cls.get_texfile_grp(bsnodes[0]) _abcgrp = cls.get_alembic_grp(bsnodes[0]) for bsnode in bsnodes: # cls.get_connect_info(bsnode,_info) _input_connect = cls.get_blend_input(bsnode) _output_connect = cls.get_blend_output(bsnode) if _abcgrp: _ns = cls.get_alembic_namespace(_abcgrp) cmds.delete(_abcgrp) if _ns: cmds.namespace(rm=_ns, mnr=1) cls.import_alembic(asset, namespace, node, path) cls.connect_attr(_abcgrp, _texgrp) _dis_connect = {} for k, v in _input_connect.items(): cmds.connectAttr(k, v) try: _k_p = k.split(".worldMesh")[0] _k = "{}_rendering.outMesh".format(_k_p) _v = v.split(".inputTargetGroup")[0].replace( "inputTarget", "input") + ".inputGeometry" #print(_k,_v) cmds.connectAttr(k, _v) _dis_connect[k] = _v except: pass if _dis_connect: for k, v in _dis_connect.items(): cmds.disconnectAttr(k, v)
def constructProxy(self): cmds.namespace(set=":") self.destructProxy() dags = cmds.ls(self.__select, dag=True, ap=True) self.grp = cmds.group(name="%s:Proxy" % self.namespace, empty=True) cmds.hide(self.grp) cmds.progressWindow(title=u"创建代理", status=u"生成中...") cmds.progressWindow(e=True, progress=0, max=len(dags)) for dag in dags: cmds.progressWindow(e=True, step=1) if not dag.find("%s:Main" % self.namespace) == -1: continue shape = cmds.listRelatives(dag, shapes=True, fullPath=True) if not shape: continue shapeType = cmds.nodeType(shape[0]) if shapeType == "nurbsCurve" or shapeType == "nurbsSurface": attrs = cmds.listAttr(dag, keyable=True) if not attrs: continue loc = cmds.spaceLocator(name=dag + "___Proxy") for attr in attrs: if attr in [ u'visibility', u'translateX', u'translateY', u'translateZ', u'rotateX', u'rotateY', u'rotateZ', u'scaleX', u'scaleY', u'scaleZ' ]: continue attrType = cmds.getAttr("%s.%s" % (dag, attr), type=True) try: cmds.addAttr(loc, ln=attr, keyable=True, attributeType=attrType) except: continue cmds.parent(loc, self.grp) cmds.progressWindow(endProgress=1)
def do_plant(self, pressPosition): view = omUI.M3dView.active3dView() worldPt = om.MPoint() worldVector = om.MVector() view.viewToWorld(int(pressPosition[0]), int(pressPosition[1]), worldPt, worldVector) mSel = om.MSelectionList() mSel.add(self.lineEdit_2.text()) mDagPath = om.MDagPath() mSel.getDagPath(0, mDagPath) fnMesh = om.MFnMesh(mDagPath) farclip = 1.0 clickPos = om.MFloatPoint(worldPt.x, worldPt.y, worldPt.z) mCamPath = om.MDagPath() view.getCamera(mCamPath) cam_name = mCamPath.fullPathName() ratio_scale = mc.getAttr(cam_name + '.farClipPlane') clickDir = om.MFloatVector(worldVector.x * ratio_scale, worldVector.y * ratio_scale, worldVector.z * ratio_scale) currentHitFP = om.MFloatPoint() hit = fnMesh.closestIntersection(clickPos, clickDir, None, None, True, om.MSpace.kWorld, farclip, True, None, currentHitFP, None, None, None, None, None) if hit: tree_name = self.treeListWidget.currentItem().text() current_namespace = tree_name.split(':')[1].split('_')[1] dup_tree = mc.duplicate(tree_name) mc.move(currentHitFP.x, currentHitFP.y, currentHitFP.z, tree_name) new_namespace = self.get_namespace(current_namespace) mc.namespace(add=new_namespace) for i in dup_tree: mc.rename(i, "%s:%s" % (new_namespace, i))
def create_empty(namespace=COMPOUND_DEFAULT_NAMESPACE): """ Create a compound from nothing. :param str namespace: The desired namespace for the new compound. :return: A ``Component`` instance. :rtype: Compound """ namespace = _utils_namespace.get_unique_namespace(namespace) # Create namespace if necessary if not cmds.namespace(exists=namespace): cmds.namespace(add=namespace) # Create bounds if necessary bound_inn_dagpath = "%s:%s" % (namespace, INPUT_NODE_NAME) bound_out_dagpath = "%s:%s" % (namespace, OUTPUT_NODE_NAME) if not cmds.objExists(bound_inn_dagpath): cmds.createNode("network", name=bound_inn_dagpath) if not cmds.objExists(bound_out_dagpath): cmds.createNode("network", name=bound_out_dagpath) return Compound(namespace)
def importRef(): """ import reference and try to remove namespace """ cleanSharedReferenceNode() refs = mc.ls(type='reference') skipNodes = ['_UNKNOWN_REF_NODE_', 'sharedReferenceNode'] skipNamespaces = ['UI', 'shared'] for each in refs: try: if not each in skipNodes: fileName = mc.referenceQuery(each, filename=True) mc.file(fileName, importReference=True) except Exception as e: print e namespaces = mc.namespaceInfo(listOnlyNamespaces=True) for each in namespaces: if not each in skipNamespaces: mc.namespace(force=True, mv=(':%s' % each, ':')) mc.namespace(removeNamespace=each)
def era_NameSpace(delNameSpace = 0): nameSpaces = list(set(mc.namespaceInfo(lon = True,r = True,sn = True)) - set(['UI','shared']) - set([mc.referenceQuery(r,ns = True,shn = True) for r in mc.ls(rf = True)])) print nameSpaces if nameSpaces: if delNameSpace: num = 0 while(True): ns = list(set(mc.namespaceInfo(lon = True,r = True,sn = True)) - set(['UI','shared']) - set([mc.referenceQuery(r,ns = True,shn = True) for r in mc.ls(rf = True)])) if not ns: break for n in ns: if num > 10000: return '脚本运行错误,请联系技术部人员解决。' try: mc.namespace( f = True,mv=[n,':'] ) mc.namespace( f = True,rm=n ) except RuntimeError: num +=1 continue if num > 10000: return '脚本运行错误,请联系技术部人员解决。' else: return era_SplitFlag().join(nameSpaces)
def install_module(self, module, *args): basename = "instance_" cmds.namespace(setNamespace=":") namespaces = cmds.namespaceInfo(listOnlyNamespaces=True) for i in range(len(namespaces)): if namespaces[i].find("__") != -1: namespaces[i] = namespaces[i].partition("__")[2] new_suffix = utils.find_highest_trailing_number(namespaces, basename) + 1 user_spec_name = basename + str(new_suffix) mod = __import__("Blueprint." + module, {}, {}, [module]) reload(mod) module_class = getattr(mod, mod.CLASS_NAME) module_instance = module_class(user_spec_name) module_instance.install() module_transform = mod.CLASS_NAME + "__" + user_spec_name + ":module_transform" cmds.select(module_transform, replace=True) cmds.setToolTo("moveSuperContext")
def namespace(): """ clear namespace """ NamespaceList = cmds.namespaceInfo(recurse=True, listOnlyNamespaces=True) if NamespaceList: NamespaceList.reverse() for NamespaceName in NamespaceList: if NamespaceName != 'shared' and NamespaceName != 'UI': cmds.namespace(setNamespace=NamespaceName) NamespaceList = cmds.namespaceInfo(recurse=True, listOnlyNamespaces=True) NodeList = cmds.namespaceInfo(listOnlyDependencyNodes=True, dagPath=True) ParentNamespace = cmds.namespaceInfo(parent=True) cmds.namespace(setNamespace=':') if NamespaceList == None: if NodeList == None: try: cmds.namespace(removeNamespace=NamespaceName) except Exception as e: logger.warning(e) else: IsNodeReferenced = False for NodeName in NodeList: if cmds.referenceQuery( NodeName, isNodeReferenced=True) == True: IsNodeReferenced = True break if IsNodeReferenced == False: try: cmds.namespace(force=True, moveNamespace=(NamespaceName, ParentNamespace)) cmds.namespace(removeNamespace=NamespaceName) except Exception as e: logger.warning(e)