コード例 #1
0
ファイル: namespacer.py プロジェクト: auqeyjf/glTools
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
コード例 #2
0
	def __init__(self):
		character = self.findSelectedCharacter()
		
		if character == None:
			return
			
		niceName = character.partition('__')[2]
		result = cmds.confirmDialog(title='Delete Character',message='Are you sure you want to delete the character \'' + niceName + '\'?\nCharacter deletion cannot be undone.',button=['Yes','Cancel'],defaultButton='Yes',cancelButton='Cancel',dismissString='Cancel')
		
		if result == 'Cancel':
			return
			
		characterContainer = character + ':character_container'
		
		cmds.lockNode(characterContainer, lock=False, lockUnpublished=False)
		
		cmds.delete(characterContainer)
		
		cmds.namespace(setNamespace=character)
		blueprintNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
		
		for blueprintNamespace in blueprintNamespaces:
			cmds.namespace(setNamespace=':')
			cmds.namespace(setNamespace=blueprintNamespace)
			
			moduleNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
			cmds.namespace(setNamespace=':')
			if moduleNamespaces != None:
				for moduleNamespace in moduleNamespaces:
					cmds.namespace(removeNamespace=moduleNamespace)
					
			cmds.namespace(removeNamespace=blueprintNamespace)
			
		cmds.namespace(removeNamespace=character)
コード例 #3
0
def bdImportGeneric(args):
    basicFilter = "Maya Files (*.ma *.mb);;Maya ASCII (*.ma);;Maya Binary (*.mb)"
    genericFile = cmds.fileDialog2(fileFilter=basicFilter, dialogStyle=0,cap='Import Generic',fm=1)    
    if genericFile:
        print genericFile
        #cmds.file( genericFile[0],  namespace="generic", import = True)
        cmds.file( genericFile[0], i=True,namespace = 'genericchar' )
	#remove namespaces
	sceneNS = cmds.namespaceInfo(lon=True,r=True)
	importNS = []
	for ns in sceneNS:
		if 'genericchar' in ns:
			importNS.append(ns)
	importNS.reverse()
	
	for ns in importNS:
		cmds.namespace(setNamespace=ns)
		parentNS = cmds.namespaceInfo( parent = True)
		nemName = ":" + ns
		cmds.namespace( force = True, moveNamespace = [ nemName, ':' ] )
		cmds.namespace( rm = nemName)        
        

    else:
        print 'No file was selected'
    bipsInScene = cmds.ls('Bip??')
    if len(bipsInScene) == 1:
        target = bipsInScene[0]
        dest = 'Generic|Controllers|World_Anim_grp|Global_Scale_Anim'
        const = cmds.parentConstraint(target,dest)
        cmds.delete(const)
        cmds.setAttr(dest + ".translateZ", 0)
        cmds.setAttr(dest + ".rotateX", 0)
        cmds.setAttr(dest + ".rotateY", 0)	
コード例 #4
0
	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
コード例 #5
0
ファイル: do_playblast.py プロジェクト: Wizard-collab/Wizard
    def list_cam(self, cam_namespace):
        set_name = '{}:{}'.format(cam_namespace, defaults._camrig_export_set_)

        if cmds.objExists(set_name):

            cmds.select(set_name, replace=1)
            shapes_list = cmds.ls(selection=True)
            camera = shapes_list[0]
            camera_shape = cmds.listRelatives(camera, shapes=1)

            return camera_shape[0]

        else:

            if cmds.namespaceInfo(cur=1) != cam_namespace:
                cmds.namespace(set=cam_namespace)
            shapes_list = cmds.namespaceInfo(listNamespace=True)
            cam = None
            for shape in shapes_list:
                if cmds.objectType(shape) == 'camera':
                    cam = shape
                    break
            if cam:
                return cam
            else:
                print('camera or {} not found'.format(set_name))
                return None
コード例 #6
0
ファイル: namespacer.py プロジェクト: lefan2016/glTools
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
コード例 #7
0
def test_import_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.import_taskfile(refobj, tfi)

    # assert namespace is still the same
    assert cmds.namespaceInfo(absoluteName=True) == ":foo"
    ns = cmds.getAttr("%s.namespace" % refobj)
    assert ns == "smurf_1"
    assert not cmds.ls(type="jb_asset")
    assert cmds.getAttr("%s.taskfile_id" % refobj) == tf.pk

    # reference2
    refobj2 = mrefobjinter.create(typ="Asset", identifier=1)
    assettypinter.import_taskfile(refobj2, tfi)

    # assert namespace is still the same
    assert cmds.namespaceInfo(absoluteName=True) == ":foo"
    ns2 = cmds.getAttr("%s.namespace" % refobj2)
    assert ns2 == "smurf_2"
    assert ns2 != ns
    assert not cmds.ls(type="jb_asset")
    assert cmds.getAttr("%s.taskfile_id" % refobj2) == tf.pk

    content = cmds.namespaceInfo(ns, listNamespace=True)
    content2 = cmds.namespaceInfo(ns2, listNamespace=True)
    for n in content + content2:
        assert cmds.referenceQuery(n, isNodeReferenced=True) is False
コード例 #8
0
    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)
コード例 #9
0
    def addCharacter(self, close, *args):
        project = cmds.optionMenu(self.widgets["project"], q=True, value=True)
        selectedCharacter = cmds.textScrollList(self.widgets["characterList"], q=True, si=True)[0]
        rigPath = os.path.join(
            self.mayaToolsDir, "General", "ART", "Projects", project, "AnimRigs", selectedCharacter + ".mb"
        )
        # find existing namespaces in scene
        namespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
        # reference the rig file
        cmds.file(
            rigPath, r=True, type="mayaBinary", loadReferenceDepth="all", namespace=selectedCharacter, options="v=0"
        )
        # clear selection and fit view
        cmds.select(clear=True)
        cmds.viewFit()
        panels = cmds.getPanel(type="modelPanel")
        # turn on smooth shading
        for panel in panels:
            editor = cmds.modelPanel(panel, q=True, modelEditor=True)
            cmds.modelEditor(editor, edit=True, displayAppearance="smoothShaded", displayTextures=True, textures=True)
        # find new namespaces in scene (this is here in case I need to do something later and I need the new name that was created)
        newCharacterName = selectedCharacter
        newNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
        for name in newNamespaces:
            if name not in namespaces:
                newCharacterName = name
        # launch UI
        import ART_animationUI

        reload(ART_animationUI)
        ART_animationUI.AnimationUI()
        if close:
            cmds.deleteUI(self.widgets["window"])
コード例 #10
0
def removeAllNS(deleteContent=False):
    checkingMessage(checkingWhat='REMOVING A LEVEL OF NAMESPACE NOW...',
                    start=True,
                    failed=False)
    ## Now remove all the nameSpaces!! This is to remove any clashes with the core_assemblies later on...
    safeNS = ['UI', 'shared']
    getAllNameSpaces = cmds.namespaceInfo(listOnlyNamespaces=True)
    for eachNS in getAllNameSpaces:
        if eachNS not in safeNS:
            try:
                if deleteContent:
                    cmds.namespace(removeNamespace=eachNS,
                                   deleteNamespaceContent=True)
                else:
                    cmds.namespace(removeNamespace=eachNS,
                                   mergeNamespaceWithRoot=True)
            except RuntimeError:
                pass

    if cmds.namespaceInfo(listOnlyNamespaces=True) != ['UI', 'shared']:
        removeAllNS()
    else:
        checkingMessage(checkingWhat='NAMESPACES REMOVED...',
                        start=False,
                        failed=False)
コード例 #11
0
    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)
コード例 #12
0
    def parse_sub_matrix(self, data):
        """
        """
        import maya.cmds as cmds
        from reveries.lib import DEFAULT_MATRIX
        from reveries.maya.hierarchy import container_from_id_path

        current_NS = cmds.namespaceInfo(currentNamespace=True,
                                        absoluteName=True)
        for container_id, sub_matrix in data["subMatrix"].items():
            container = container_from_id_path(container_id, current_NS)
            full_NS = cmds.getAttr(container + ".namespace")
            nodes = cmds.namespaceInfo(full_NS, listOnlyDependencyNodes=True)
            # Collect hidden nodes' address
            hidden = data.get("hidden", {}).get(container_id, [])

            transform_id_map = self.transform_by_id(nodes)

            for address in sub_matrix:
                is_hidden = False

                if address == "GROUP":
                    name, matrix = sub_matrix[address].popitem()
                    transform = full_NS + ":" + name
                else:
                    transform = transform_id_map.get(address)
                    matrix = sub_matrix[address]

                    if address in hidden and transform is not None:
                        is_hidden = True

                if matrix == "<default>":
                    matrix = DEFAULT_MATRIX

                yield transform, matrix, is_hidden
コード例 #13
0
	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
コード例 #14
0
ファイル: __init__.py プロジェクト: octvision/oct
def rmSelect(_mode):
    if _mode == 0:
        _sel = mc.textScrollList("nameList", q=1, selectItem=1)
    else:
        _sel = mc.textScrollList("nameList", q=1, allItems=1)

    if _sel == None:
        return

    for eachSel in _sel:
        mc.namespace(set=':')
        allName = [eachSel]
        mc.namespace(set=eachSel)
        while mc.namespaceInfo(p=1) != ":":
            allName.append(mc.namespaceInfo(p=1))
            parentName = mc.namespaceInfo(p=1)
            mc.namespace(set=':')
            mc.namespace(set=parentName)

        mc.namespace(set=':')
        for eachName in allName:
            mc.namespace(f=1, mv=(eachName, ":"))
            mc.namespace(rm=eachName)

        if mc.namespace(exists=eachSel) == 0:
            sys.stdout.write(u"已经清除%s..." % eachSel)
            mc.textScrollList("nameList", e=1, removeItem=eachSel)
コード例 #15
0
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
コード例 #16
0
 def retrieveListEmptyNamespaces(self, root):
     del self.listEmptyNamespace[:]
     listNs = cmds.namespaceInfo(root, listOnlyNamespaces=True, recurse = True )
     if listNs != None:
         for namespace in listNs:
             if namespace != "UI" and namespace != "shared":
                 if cmds.namespaceInfo(namespace, listNamespace=True ) == None:
                     self.listEmptyNamespace.append(namespace)
コード例 #17
0
ファイル: OCT_ExchangeProxy_v1.py プロジェクト: octvision/oct
    def cleanUp_Namespace(self, match_NSChar):
        mc.namespace(set=":")
        allNamespaces = mc.namespaceInfo(listOnlyNamespaces=True)
        p = re.compile(match_NSChar)

        idleNamespace = [allNamespaces[i] for i in range(len(allNamespaces)) if len(p.findall(allNamespaces[i])) != 0]
        for eachINS in idleNamespace:
            self.remove_namespace(eachINS)
        return (mc.namespaceInfo(listOnlyNamespaces=True))
コード例 #18
0
def nameSpaceRemover(*args):
    cmds.namespace(setNamespace=':')
    namespaces = cmds.namespaceInfo(':', listOnlyNamespaces=True)
    while len(namespaces) > 2:
        namespaces = cmds.namespaceInfo(':', listOnlyNamespaces=True)
        for d in ('UI', 'shared'):
            if d in namespaces:
                namespaces.remove(d)
        for n in namespaces:
            cmds.namespace(mergeNamespaceWithRoot=True, removeNamespace=n)
            print 'Namespace ' + n + 'removed.'
コード例 #19
0
    def reference(self, refobj, taskfileinfo):
        """Reference the given taskfileinfo into the scene and return the created reference node

        The created reference node will be used on :meth:`RefobjInterface.set_reference` to
        set the reference on a reftrack node.
        Do not call :meth:`RefobjInterface.set_reference` yourself.

        This will also create a group node and group all dagnodes under a appropriate node.

        :param refobj: the reftrack node that will be linked to the reference
        :type refobj: str
        :param taskfileinfo: The taskfileinfo that holds the information for what to reference
        :type taskfileinfo: :class:`jukeboxcore.filesys.TaskFileInfo`
        :returns: the reference node that was created and should set on the appropriate reftrack node
        :rtype: str
        :raises: None
        """
        # work in root namespace
        with common.preserve_namespace(":"):
            jbfile = JB_File(taskfileinfo)
            filepath = jbfile.get_fullpath()
            ns_suggestion = reftrack.get_namespace(taskfileinfo)
            newnodes = cmds.file(filepath,
                                 reference=True,
                                 namespace=ns_suggestion,
                                 returnNewNodes=True)
            # You could also use the filename returned by the file command to query the reference node.
            # Atm there is a but, that if you import the file before, the command fails.
            # So we get all new reference nodes and query the one that is not referenced
            for refnode in cmds.ls(newnodes, type='reference'):
                if not cmds.referenceQuery(refnode, isNodeReferenced=True):
                    node = refnode
                    break
            ns = cmds.referenceQuery(
                node, namespace=True)  # query the actual new namespace
            content = cmds.namespaceInfo(ns,
                                         listOnlyDependencyNodes=True,
                                         dagPath=True)  # get the content
            # connect reftrack with scenenode
            scenenode = self.get_scenenode(content)
            self.get_refobjinter().connect_reftrack_scenenode(
                refobj, scenenode)
            reccontent = cmds.namespaceInfo(
                ns, listOnlyDependencyNodes=True, dagPath=True,
                recurse=True)  # get the content + content of children
            dagcontent = cmds.ls(
                reccontent, ap=True, assemblies=True
            )  # get only the top level dagnodes so we can group them
            if not dagcontent:
                return node  # no need for a top group if there are not dagnodes to group
            # group the dagnodes
            grpname = reftrack.get_groupname(taskfileinfo)
            reftrack.group_content(dagcontent, ns, grpname, "jb_asset")
            return node
コード例 #20
0
def _getNamespace():
    namespaces = mc.namespaceInfo(lon=True)
    _nestedNS = []
    for ns in namespaces:
        nestedNS = mc.namespaceInfo(ns, lon=True)
        print ns, nestedNS
        if nestedNS != None:
            _nestedNS += nestedNS
    namespaces += _nestedNS
    namespaces.remove('UI')
    namespaces.remove('shared')
    return namespaces
コード例 #21
0
    def addCharacter(self, close, *args):
        project = cmds.optionMenu(self.widgets["project"], q=True, value=True)
        selectedCharacter = cmds.textScrollList(self.widgets["characterList"],
                                                q=True,
                                                si=True)[0]
        rigPath = self.mayaToolsDir + "/General/ART/Projects/" + project + "/AnimRigs/" + selectedCharacter + ".mb"

        #find existing namespaces in scene
        namespaces = cmds.namespaceInfo(listOnlyNamespaces=True)

        #reference the rig file
        cmds.file(rigPath,
                  r=True,
                  type="mayaBinary",
                  loadReferenceDepth="all",
                  namespace=selectedCharacter,
                  options="v=0")

        #clear selection and fit view
        cmds.select(clear=True)

        #query autoKeyFrame state
        if not cmds.autoKeyframe(q=True, state=True):
            cmds.viewFit()
        #cmds.viewFit()
        panels = cmds.getPanel(type='modelPanel')

        #turn on smooth shading
        for panel in panels:
            editor = cmds.modelPanel(panel, q=True, modelEditor=True)
            cmds.modelEditor(editor,
                             edit=True,
                             displayAppearance="smoothShaded",
                             displayTextures=True,
                             textures=True)

        #find new namespaces in scene (this is here in case I need to do something later and I need the new name that was created)
        newCharacterName = selectedCharacter
        newNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True)

        for name in newNamespaces:
            if name not in namespaces:
                newCharacterName = name

        #launch UI
        import ART_animationUI
        reload(ART_animationUI)
        ART_animationUI.AnimationUI()

        if close:
            cmds.deleteUI(self.widgets["window"])
コード例 #22
0
	def removeAllNamespaces(self) :
		print('[removeAllNamespaces]')
		cmds.namespace(setNamespace=":")
		spaces = cmds.namespaceInfo(listOnlyNamespaces=True)
		omit = ['shared', 'UI']
		while(len(spaces) > 2) :
			for s in spaces :
				if s in omit :
					continue
				print(s)
				objs = cmds
				cmds.namespace(moveNamespace=[s, ':'], force=True)
				cmds.namespace(removeNamespace=s)
			spaces = cmds.namespaceInfo(listOnlyNamespaces=True)
コード例 #23
0
ファイル: __init__.py プロジェクト: octvision/oct
def removeNS(str):
    eachSel = str
    mc.namespace(set=':')
    allName = [eachSel]
    mc.namespace(set=eachSel)	
    while mc.namespaceInfo(p=1) != ":":
        parentName = mc.namespaceInfo(p=1)
        allName.append(parentName)
        mc.namespace(set=':')
        mc.namespace(set=parentName)	

    mc.namespace(set=':')
    for eachName in allName:
        mc.namespace(f=1,mv=(eachName,":"))
        mc.namespace(rm=eachName)
コード例 #24
0
 def getNamespace(self):
     returnNamespaces = []
     namespaces = cmds.namespaceInfo(lon=True)
     for namespace in namespaces:
         if namespace != 'UI' and namespace != 'shared':
             returnNamespaces.append(namespace)
     return returnNamespaces
コード例 #25
0
ファイル: api.py プロジェクト: BGCX261/zootoolbox-svn-to-git
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 )
コード例 #26
0
ファイル: asset.py プロジェクト: JukeboxPipeline/jukeboxmaya
    def import_taskfile(self, refobj, taskfileinfo):
        """Import the given taskfileinfo and update the refobj

        :param refobj: the refobject
        :type refobj: refobject
        :param taskfileinfo: the taskfileinfo to reference
        :type taskfileinfo: :class:`jukeboxcore.filesys.TaskFileInfo`
        :returns: None
        :rtype: None
        :raises: None
        """
        # work in root namespace
        with common.preserve_namespace(":"):
            jbfile = JB_File(taskfileinfo)
            filepath = jbfile.get_fullpath()
            ns_suggestion = reftrack.get_namespace(taskfileinfo)
            nodes = cmds.file(filepath, i=True, namespace=ns_suggestion, returnNewNodes=True, preserveReferences=True)  # import
            assert nodes, 'Nothing was imported! this is unusual!'
            ns = common.get_top_namespace(nodes[0])  # get the actual namespace
            cmds.setAttr("%s.namespace" % refobj, ns, type="string")
            nscontent = cmds.namespaceInfo(ns, listOnlyDependencyNodes=True, dagPath=True)  # get the content
            scenenode = self.get_scenenode(nscontent)
            self.get_refobjinter().connect_reftrack_scenenode(refobj, scenenode)
            dagcontent = cmds.ls(nodes, ap=True, assemblies=True)  # get only the dagnodes so we can group them
            if not dagcontent:
                return  # no need for a top group if there are not dagnodes to group
            # group the dagnodes in the new namespace
            grpname = reftrack.get_groupname(taskfileinfo)
            reftrack.group_content(dagcontent, ns, grpname, "jb_asset")
            return
コード例 #27
0
def get_node_in_namespace_hierarchy(node, namespace=None, shape=False):
    """Searches a namespace and all nested namespaces for the given node.

    :param node: Name of the node.
    :param namespace: Root namespace
    :param shape: True to get the shape node, False to get the transform.
    :return: The node in the proper namespace.
    """
    if shape and node and cmds.objExists(node):
        node = get_shape(node)

    if node and cmds.objExists(node):
        return node

    if node and namespace:
        # See if it exists in the namespace or any child namespaces
        namespaces = [namespace.replace(":", "")]
        namespaces += cmds.namespaceInfo(namespace, r=True, lon=True) or []
        for namespace in namespaces:
            namespaced_node = "{0}:{1}".format(namespace, node)
            if shape:
                namespaced_node = get_shape(namespaced_node)
            if namespaced_node and cmds.objExists(namespaced_node):
                return namespaced_node
    return None
コード例 #28
0
 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
コード例 #29
0
ファイル: fileMan_lib.py プロジェクト: boochos/work
def cmd_makeRefOfSelection(pathField='', fileField='', nsField='', *args):
    path = cmds.textFieldGrp(pathField, q=True, text=True)
    fyle = cmds.textFieldGrp(fileField, q=True, text=True)
    ns = cmds.textFieldGrp(nsField, q=True, text=True)
    nsList = cmds.namespaceInfo(lon=True)
    sel = cmds.ls(sl=True)
    if sel:
        f = fyle
        if f:
            path = os.path.join(path, f)
        else:
            message('Provide a file name, excluding path.', warning=True)
            return None
        if ns:
            if ns not in nsList:
                try:
                    cmds.file(path, type='mayaAscii', er=True, namespace=ns)
                except:
                    message('Export Failed... In case your object is already a reference, make a duplicate or import it. Then try again.', warning=True)
            else:
                message('Namespace "'  + ns + '" already exists. Choose another!', warning=True)
        else:
            message('Provide a namespace for the reference.', warning=True)
            return None
    else:
        message( 'Select and object', warning=True)
コード例 #30
0
def findNamaSpaces():
    cmds.namespace(setNamespace=":")
    namespaces = cmds.namespaceInfo(listOnlyNamespaces=True)

    for namespace in namespaces:
        if cmds.objExists(namespace + ":*"):
            # create a tab
            widgets[(namespace + "_tab")] = cmds.columnLayout(
                w=400, h=600, parent=widgets["tabLayout"])

            # create attr field grps for translate rotate and scale
            cmds.separator(h=10, style="none")
            widgets[(namespace + "_attrFG_T")] = cmds.attrFieldGrp(
                attribute=(namespace + ":null.translate"))
            widgets[(namespace + "_attrFG_R")] = cmds.attrFieldGrp(
                attribute=(namespace + ":null.rotate"))
            widgets[(namespace + "_attrFG_S")] = cmds.attrFieldGrp(
                attribute=(namespace + ":null.scale"))

            cmds.separator(h=10, style="none")

            widgets[(namespace + "_attrEOM_Vis")] = cmds.attrEnumOptionMenu(
                label="Test", attribute=(namespace + ":null.Test"))

            # edit the tab name
            cmds.tabLayout(widgets["tabLayout"],
                           edit=True,
                           tabLabel=(widgets[(namespace + "_tab")], namespace))
コード例 #31
0
ファイル: hollowRootsOnPath.py プロジェクト: boochos/work
def nsPaths():
    nsList = cmds.namespaceInfo(lon=True)
    nsPathsList = []
    for ns in nsList:
        if 'Path_' in ns:
            nsPathsList.append(ns)
    return nsPathsList
コード例 #32
0
	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')
コード例 #33
0
ファイル: dynInfor.py プロジェクト: chloechan/clothAndHair
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
コード例 #34
0
def get_non_existing_namespace(prefix='dw'):
    i = 0
    namespace = '%s%i' % (prefix, i)
    while namespace in mc.namespaceInfo(listNamespace=True):
        i += 1
        namespace = '%s%i' % (prefix, i)
    return namespace
コード例 #35
0
ファイル: api.py プロジェクト: BGCX261/zootoolbox-svn-to-git
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)
コード例 #36
0
ファイル: bodyIO.py プロジェクト: timm-gitHub/fbRepo
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
コード例 #37
0
def get_scene_namespaces():
	"""
	Return a list of namespaces

	*Arguments:*
		* ``None``

	*Keyword Arguments:*
		* ``None``

	*Returns:*
		* ``None``

	*Author:*
	* randall.hess, [email protected], 11/6/2014 1:36:02 PM
	"""
	try:
		cmds.namespace(setNamespace=":")
	except:
		pass

	ignore_names = ["UI","shared"]
	all_namespaces = cmds.namespaceInfo(listOnlyNamespaces=True, recurse=True)
	namespaces = []
	for namespace in all_namespaces:
		if not any ([x in namespace for x in ignore_names]):
			namespaces.append(namespace)
	return namespaces
コード例 #38
0
 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)
コード例 #39
0
ファイル: blueprintUI.py プロジェクト: jeffhong21/scripts
    def createModuleButtonCommand(self, moduleClassName, *args):

        ##  DEALING WITH NAMESPACES
        moduleName = cmds.textFieldGrp(self.UIwidgets[moduleClassName + "ModuleName"], q=True, text=True)
        if moduleName == "":
            moduleName = moduleClassName

        ##  need to check if name has "_" character in it.  If so we need to remove it.
        ##  if name does not have "_" at the end, add it
        if moduleName.partition("_")[1] == "":
            moduleName = moduleName + "_"
        ##  gather all namespaces
        allNamespaces = cmds.namespaceInfo(listNamespace=True)
        ##  gather the highest number
        index = util.findHighestTrailingNumber(allNamespaces, moduleName)
        ##  check to see if module name is in the list of namespaces.  if so, add 1.  if not leave alone
        if moduleName + str(index) in allNamespaces:
            moduleName = moduleName + str(index + 1)
        else:
            moduleName = moduleName + str(index)

        #  need to find correct module file
        modName = util.findModule(RIGGING_TOOL_ROOT, moduleClassName)
        #  import that module
        mod = __import__(environ.BlueprintModulePath + modName, {}, {}, [modName])
        reload(mod)
        # Get class reference for Blueprint module class, then create user specified instance of Blueprint module class and call it's Constructor and install method.
        #  getAttr returns import reference,
        moduleClass = getattr(mod, mod.ClassName)
        moduleInstance = moduleClass(moduleName)
        moduleInstance.install_joints()
コード例 #40
0
def test_replace(taskfile_with_dagnodes, taskfile_with_dagnodes2, djprj,
                 assettypinter, mrefobjinter):
    cmds.file(new=True, force=True)
    tf = djprj.assettaskfiles[0]
    tfi = TaskFileInfo.create_from_taskfile(tf)
    refobj = mrefobjinter.create(typ="Asset", identifier=0)
    assettypinter.reference(refobj, tfi)
    refnode = cmds.referenceQuery(taskfile_with_dagnodes, referenceNode=True)
    ns = cmds.referenceQuery(refnode, namespace=True)
    ns = cmds.namespaceInfo(ns, fullName=True)
    assert "%s:testdagnode" % ns in cmds.ls(type="transform")
    assert "%s:othertestnode" % ns not in cmds.ls(type="transform")
    tf2 = djprj.assettaskfiles[1]
    tfi2 = TaskFileInfo(task=tf2.task,
                        version=tf2.version,
                        releasetype=tf2.releasetype,
                        descriptor=tf2.descriptor,
                        typ=tf2.typ)
    assettypinter.replace(refobj, refnode, tfi2)
    assert "%s:othertestnode" % ns in cmds.ls(type="transform")
    assert "%s:testdagnode" % ns not in cmds.ls(type="transform")
    assert cmds.getAttr("%s.taskfile_id" % refobj) == tf2.pk

    assert '%s:jb_sceneNode_test' % ns in cmds.listConnections('%s.scenenode' %
                                                               refobj)
    assert cmds.listConnections('%s.taskfile_id' %
                                refobj) == ['%s:jb_sceneNode_test' % ns]

    assettypinter.replace(refobj, refnode, tfi2)
    # this will reference the same file again. it will get a copy number
    # the file command does not return the name with copy number. seems like a bug
    # because the doc sais it will. You have to use the reference node for referenceQuery instead
    # to get the namespace, not the filename that is returned by the file command.
    assettypinter.replace(refobj, refnode, tfi)
コード例 #41
0
def removeAllNS(deleteContent = False):
    ## Now remove all the nameSpaces!! This is to remove any clashes with the core_assemblies later on...
    safeNS = ['UI', 'shared']
    getAllNameSpaces = cmds.namespaceInfo(listOnlyNamespaces = True)
    for eachNS in getAllNameSpaces:
        if eachNS not in safeNS:
            try:
                if deleteContent:
                    cmds.namespace(removeNamespace = eachNS, deleteNamespaceContent = True)
                else:
                    cmds.namespace(removeNamespace = eachNS, mergeNamespaceWithRoot = True)
            except RuntimeError:
                pass

    if cmds.namespaceInfo(listOnlyNamespaces = True) != ['UI', 'shared']:
        removeAllNS()
コード例 #42
0
ファイル: app.py プロジェクト: vipul-rathod/lsapipeline
	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()
コード例 #43
0
ファイル: mayascene.py プロジェクト: tws0002/cross3d
	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
コード例 #44
0
def delete_ns():
    logger.info("Deleting namespaces ----------------------------------")

    try:
        defaults = ['UI', 'shared']

        # Used as a sort key, this will sort namespaces by how many children they have.
        def num_children(ns):
            return ns.count(':')

        namespaces = [
            ns for ns in cmds.namespaceInfo(lon=True, r=True)
            if ns not in defaults
        ]
        # We want to reverse the list, so that namespaces with more children are at the front of the list.
        namespaces.sort(key=num_children, reverse=True)
        for ns in namespaces:
            if namespaces.index(ns) + 1 < len(namespaces):
                parent_ns = namespaces[namespaces.index(ns) + 1]
                cmds.namespace(mv=[ns, parent_ns], f=True)
                cmds.namespace(rm=ns)
            else:
                cmds.namespace(mv=[ns, ":"], f=True)
                cmds.namespace(rm=ns)
    except Exception, err:
        logger.info(err)
        logger.info("Delete namespaces failed")
コード例 #45
0
def remove(name):
    all_namespace = cmds.namespaceInfo(listOnlyNamespaces=1)
    if name not in all_namespace:
        print "%s is not a namespace" % name
        return
    children = cmds.namespaceInfo(name, lon=1)
    if children:
        for child in children:
            remove(child)
    try:
        cmds.namespace(mv=(name, ':'), f=1)
        cmds.namespace(rm=name)
    except:
        print "## Failed:", name
    else:
        print "// Removed:", name
コード例 #46
0
ファイル: mGeneral.py プロジェクト: davidpower/MS_Research
def namespaceList(current= None):
	"""
	"""
	if not current:
		cmds.namespace(set = ':')

	return cmds.namespaceInfo(lon= 1, r= 1, an= 1)
コード例 #47
0
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
コード例 #48
0
def namespaces():	
	namespaces = []
	namespaceInfo = cmds.namespaceInfo(lon=1)
	for i in range(0,len(namespaceInfo)):
		if 	(namespaceInfo[i].count("UI")!=1) and (namespaceInfo[i].count("shared")!=1):
			namespaces.append(namespaceInfo[i])
	return namespaces
コード例 #49
0
	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")
コード例 #50
0
ファイル: ns.py プロジェクト: kthulhu/mrv
	def current( cls ):
		""":return: the currently set absolute namespace """
		# will return namespace relative to the root - thus is absolute in some sense
		nsname = cmds.namespaceInfo( cur = 1 )
		if not nsname.startswith( ':' ):		# assure we return an absoslute namespace
			nsname = ":" + nsname
		return cls( nsname )
コード例 #51
0
def unique_namespace(namespace, format="%02d", prefix="", suffix=""):
    """Return unique namespace

    Similar to :func:`unique_name` but evaluating namespaces
    as opposed to object names.

    Arguments:
        namespace (str): Name of namespace to consider
        format (str, optional): Formatting of the given iteration number
        suffix (str, optional): Only consider namespaces with this suffix.

    """

    iteration = 1
    unique = prefix + (namespace + format % iteration) + suffix

    # The `existing` set does not just contain the namespaces but *all* nodes
    # within "current namespace". We need all because the namespace could
    # also clash with a node name. To be truly unique and valid one needs to
    # check against all.
    existing = set(cmds.namespaceInfo(listNamespace=True))
    while unique in existing:
        iteration += 1
        unique = prefix + (namespace + format % iteration) + suffix

    return unique
コード例 #52
0
ファイル: check_naming_space.py プロジェクト: jonntd/mira
 def remove_namespace(self, namespace_name):
     children = mc.namespaceInfo(namespace_name, listOnlyNamespaces=1)
     if children:
         for child in children:
             self.remove_namespace(child)
     mc.namespace(moveNamespace=(namespace_name, ":"), f=1)
     mc.namespace(removeNamespace=namespace_name)
コード例 #53
0
 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)
コード例 #54
0
ファイル: shortcuts.py プロジェクト: SplineO/cmt
def get_node_in_namespace_hierarchy(node, namespace=None, shape=False):
    """Searches a namespace and all nested namespaces for the given node.

    :param node: Name of the node.
    :param namespace: Root namespace
    :param shape: True to get the shape node, False to get the transform.
    :return: The node in the proper namespace.
    """
    if shape and node and cmds.objExists(node):
        node = get_shape(node)

    if node and cmds.objExists(node):
        return node

    if node and namespace:
        # See if it exists in the namespace or any child namespaces
        namespaces = [namespace.replace(':', ''),]
        namespaces += cmds.namespaceInfo(namespace, r=True, lon=True) or []
        for namespace in namespaces:
            namespaced_node = '{0}:{1}'.format(namespace, node)
            if shape:
                namespaced_node = get_shape(namespaced_node)
            if namespaced_node and cmds.objExists(namespaced_node):
                return namespaced_node
    return None
コード例 #55
0
def stripNamespace(filename):

    try:
        #open the file
        cmds.loadPlugin("fbxmaya.mll")
        string = "FBXImportMode -v \"add\";"
        string += "FBXImport -file \"" + filename + "\""
        string += "FBXImportFillTimeline -v true"
        mel.eval(string)

        #remove the namespace
        cmds.namespace(setNamespace="::")
        currentNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True)

        restricted = ['UI', 'shared']

        for namespace in currentNamespaces:
            if namespace not in restricted:
                cmds.namespace(mv=(':' + namespace, ':'), force=True)
                cmds.namespace(removeNamespace=namespace)

        #re-export the file
        mel.eval("FBXExport -f \"" + filename + "\"")

        #exit
        std.uninitialize()

    except Exception, e:
        sys.stderr.write(str(e))
        sys.exit(-1)
コード例 #56
0
	def isRootTransformInstalled(self):
		cmds.namespace(setNamespace=':')
		namespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
		
		for namespace in namespaces:
			if namespace.find('RootTransform__') == 0:
				return True
		return False
コード例 #57
0
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))