def referenceRelatives( rfn, onlyLoaded=False, parents=False ):
"""
List all currently loaded references in current scene.
"""
result = []
references = [ rfn ]
if references:
while references:
mcache = []
for i in range( 0, len( references )):
if references[i] not in result and ( onlyLoaded is True and cmds.referenceQuery( references[i], isLoaded=True ) or onlyLoaded is not True ):
result.append( references[i] )
if parents is False:
relatives = cmds.referenceQuery( references[i], child=True, rfn=True )
else:
relatives = cmds.referenceQuery( references[i], parent=True, rfn=True )
if relatives:
relatives = type( relatives ) is not list and [ relatives ] or relatives
for n in range( 0, len( relatives )):
if relatives[n] not in result:
mcache.append( relatives[n] )
if mcache:
references = mcache
else:
break
return result
def get_invalid(instance):
"""Return invalid reference nodes in the instance
Terminology:
reference node: The node that is the actual reference containing
the nodes (type: reference)
referenced nodes: The nodes contained within the reference
(type: any type of nodes)
"""
referenced_nodes = cmds.ls(instance, referencedNodes=True, long=True)
if not referenced_nodes:
return list()
# Get reference nodes from referenced nodes
# (note that reference_nodes != referenced_nodes)
reference_nodes = set()
for node in referenced_nodes:
reference_node = cmds.referenceQuery(node, referenceNode=True)
if reference_node:
reference_nodes.add(reference_node)
# Check for failed edits on each reference node.
invalid = []
for reference_node in reference_nodes:
failed_edits = cmds.referenceQuery(reference_node,
editNodes=True,
failedEdits=True,
successfulEdits=False)
if failed_edits:
invalid.append(reference_node)
return invalid
def getAssetSelection(self):
objs = mc.ls(sl=True)
assets = []
namespaces = []
if objs:
for obj in objs:
if mc.referenceQuery(obj, inr=True):
path = mc.referenceQuery(obj, f=True)
asset = entityInfo.info(path)
if not asset.name() in assets:
assets.append(asset.name())
else:
namespace = obj.split(':')[0]
if not namespace in namespaces:
namespaces.append(namespace)
for namespace in namespaces:
attr = '%s:Geo_Grp.assetName' % namespace
if mc.objExists(attr):
assetName = mc.getAttr(attr)
if not assetName in assets:
assets.append(assetName)
return assets
def doNameObject(obj,sceneUnique = False,fastIterate = True):
"""
Names an object
ARGUMENTS:
obj(string) - the object we'd like to name
sceneUnique(bool)- whether to do a full scene check or just the faster check
RETURNS:
newName(string) on success
"""
### input check
assert mc.objExists(obj) is True, "'%s' doesn't exist" %obj
assert mc.referenceQuery(obj, isNodeReferenced=True) is not True, "'%s' is referenced, can't name!" %obj
name = returnUniqueGeneratedName(obj,sceneUnique, fastIterate)
nameFactory = NameFactory(obj)
if nameFactory.amIMe(name):
guiFactory.warning("'%s' is already named correctly."%nameFactory.nameBase)
return name
else:
objLong = mc.ls(obj,long=True)
renameBuffer = mc.rename(objLong,name)
shapes = mc.listRelatives(renameBuffer,shapes=True,fullPath=True)
if shapes:
for shape in shapes:
if not mc.referenceQuery(shape, isNodeReferenced=True):
name = returnUniqueGeneratedName(shape,sceneUnique, fastIterate)
mc.rename(shape,name)
return renameBuffer
def doTest(successfulEdits, failedEdits, force, expectedNum):
self.setUp()
self.createFailedEdits()
# Should have 3 total, 2 successful, 1 failed
refNode = str(self.sphereRef1.refNode)
getKwargs = {'editStrings':True, 'onReferenceNode':refNode}
getKwargs['successfulEdits'] = False
getKwargs['failedEdits'] = True
self.assertEqual(len(cmds.referenceQuery(refNode, **getKwargs)), 1)
getKwargs['successfulEdits'] = True
getKwargs['failedEdits'] = False
self.assertEqual(len(cmds.referenceQuery(refNode, **getKwargs)), 2)
getKwargs['successfulEdits'] = True
getKwargs['failedEdits'] = True
self.assertEqual(len(cmds.referenceQuery(refNode, **getKwargs)), 3)
kwargs = {}
if successfulEdits is not None:
kwargs['successfulEdits'] = successfulEdits
if failedEdits is not None:
kwargs['failedEdits'] = failedEdits
if force:
kwargs['force'] = True
self.sphereRef1.removeReferenceEdits(**kwargs)
self.assertEqual(len(cmds.referenceQuery(refNode, **getKwargs)),
expectedNum)
def cleanupReference( rfn ):
#Get reference node.
if cmds.nodeType( rfn ) == "reference":
rfn = rfn
elif os.path.isfile( rfn ):
rfn = cmds.referenceQuery( rfn, rfn=True )
else:
print "%s is not reference" % rfn
return None
references = []
pm = cmds.listConnections( rfn, type="proxyManager" )
if pm:
references = cmds.listConnections( "%s.proxyList" % pm[0], type="reference" )
if not references:
references = [ rfn ]
m_words = "|".join( references )
else:
references = [ rfn ]
m_words = rfn
edits = []
if references:
for i in range( 0, len( references )):
strings = cmds.referenceQuery( references[i], failedEdits=True, successfulEdits=True, editStrings=True )
if strings:
for i in range( 0, len( strings )):
if strings[i] not in edits:
if not re.findall( m_words, strings[i] ):
edits.append( strings[i] )
if edits:
removeEdits( rfn, edits )
def getReferences(loadState=False, nodesInRef=False):
"""Returns a dictionary with the namespace as keys
and a list containing the proxyManager if there is one, the refnode, and its load state
"""
result = dict()
proxyManagers = set()
references = cmds.file(query=True, reference=True)
for i in references:
refNode = cmds.referenceQuery(i, referenceNode=True)
connection = cmds.connectionInfo(refNode + '.proxyMsg', sourceFromDestination=True)
if connection:
proxyManagers.update([connection.split('.')[0]])
else:
namespace = cmds.file(i, parentNamespace=True, query=True)[0] + ':' + cmds.file(i, namespace=True, query=True)
namespace = cmds.file(i, namespace=True, query=True)
# namespace = ('' if namespace.startswith(':') else ':') + namespace
result[i] = {'namespace': namespace, 'proxyManager': None, 'refNode': refNode}
for proxy in proxyManagers:
connection = cmds.connectionInfo(proxy + '.activeProxy', destinationFromSource=True)
activeProxy = cmds.listConnections(connection, source=False)[0]
namespace = cmds.referenceQuery(activeProxy, parentNamespace=True)[0]
refNode = cmds.referenceQuery(activeProxy, referenceNode=True)
result[namespace] = {'proxyManager': proxy, 'refNode': refNode}
for ref in result:
if loadState:
isLoaded = cmds.referenceQuery(result[ref]['refNode'], isLoaded=True)
result[ref]['isLoaded'] = isLoaded
if nodesInRef:
nodes = cmds.referenceQuery(result[ref]['refNode'], nodes=True, dagPath=True)
result[ref]['nodesInRef'] = nodes
return result
def unloadReference( rfn ):
#Get reference node.
result = []
if cmds.nodeType( rfn ) == "reference":
rfn = rfn
elif os.path.isfile( rfn ):
rfn = cmds.referenceQuery( rfn, rfn=True )
else:
print "%s is not reference" % rfn
return None
relatives = referenceRelatives( rfn, onlyLoaded=True, parents=False )
if cmds.referenceQuery( rfn, isLoaded=True ):
if relatives:
for i in range( len( relatives )-1, -1, -1 ):
parent = cmds.referenceQuery( relatives[i], parent=True, filename=True )
parent = parent and parent or "untitled"
pm = cmds.listConnections( relatives[i], type="proxyManager" )
if pm:
mcache = cmds.listConnections( "%s.proxyList" % pm[0], type="reference" )
else:
mcache = [ relatives[i] ]
for n in range( 0, len( mcache )):
if mcache[n] not in result:
result.append( mcache[n] )
pcache = cmds.referenceQuery( mcache[n], parent=True, filename=True )
pcache = pcache and pcache or "untitled"
if parent != pcache:
print "//Warning:\n//\treference is not valid:\n//\t{0} has parent {1}\n//\t{2} has parent {3}\n//\tplease check reference nodes connections.\n".format( relatives[i], parent, mcache[n], pcache )
if cmds.referenceQuery( mcache[n], isLoaded=True ):
print "unload reference: %s" % mcache[n]
cmds.file( unloadReference=mcache[n] )
return result
def _modifiedAttrs(self):
""" Returns a dictionary of modifications made to this referenced model.
For referneced models return info describing the modifications made by the referencing
system.
"""
modified = {}
if self.isReferenced():
fullName = self.path()
refNode = cmds.referenceQuery(fullName, referenceNode=True)
# Build the setAttr pattern
pattern = r'setAttr {node}.(?P<attr>[^ ]+)'.format(node = fullName.replace('|', r'\|'))
setAttrRegex = re.compile(pattern)
# TODO: Add patterns for other mel commands like addAttr, etc
for s in cmds.referenceQuery(refNode, editStrings=True):
# Process setAttr
match = setAttrRegex.match(s)
if match:
key = match.groupdict()['attr']
if s.endswith('"'):
# Found a string. Note, this does not include escaped quotes.
openingQuote = s[::-1].find('"', 1)
value = s[-openingQuote:-1]
else:
# its not a string
value = s.split(' ')[-1]
modified.setdefault(key, {}).setdefault('setAttr', {}).update(value=value, command=s)
return modified
def do(self, *args):
try:
sel = mc.ls(sl=1)
sum = 0.0
sum = len(sel)
amount = 0.0
for item in sel:
mc.progressWindow(
title="Removing References", progress=amount, status="Removing: 0%", isInterruptable=True
)
if mc.progressWindow(query=True, isCancelled=True):
break
if mc.progressWindow(query=True, progress=True) >= 100:
break
RN = mc.referenceQuery(item, referenceNode=1)
Nodes = mc.referenceQuery(RN, referenceNode=True, topReference=True)
referenceFile = mc.referenceQuery(Nodes, f=1)
reLoaded = mc.referenceQuery(referenceFile, il=True)
if reLoaded == 1:
mc.file(referenceFile, unloadReference=1)
amount = float((sel.index(item) + 1)) / float(len(sel)) * 100.0
mc.progressWindow(edit=True, progress=amount, status=("Removing: " + ` amount ` + "%"))
# mc.pause( seconds=1 )
mc.progressWindow(endProgress=1)
except:
pass
def listReferenceEdits( rfn ):
"""
List all edits for current reference node.
"""
result = []
successfull = []
if cmds.nodeType( rfn ) == "reference":
rfn = rfn
else:
rfn = cmds.referenceQuery( rfn, rfn=True )
edits = cmds.referenceQuery( rfn, failedEdits=True, successfulEdits=True, editStrings=True )
if edits:
edits = [ "".join( [ m_part for m_part in re.split( "\|:[A-z0-9:]+", edits[i] ) if m_part != "" ] ) for i in range( 0, len( edits )) ]
m_content = cmds.ls( cmds.referenceQuery( rfn, nodes=True, dagPath=True ), long=True )
for c in range( 0, len( m_content )):
m_levels = listReferenceLevels( m_content[c] )
for l in range( 0, len( m_levels )):
m_expr = re.compile( "(\A|\s|\||\")+([A-z0-9_|]+|){0}(\Z|\s|\$|\"|\.)+".format( "(\||)".join( m_levels[l][0].split( "|" ))))
for e in range( 0, len( edits )):
if edits[e] not in successfull:
if m_expr.findall( edits[e] ):
m_temp = [ rfn, m_content[c], m_levels[l][-1], m_levels[l][0], edits[e].split( " " )[0], edits[e] ]
result.append( m_temp )
successfull.append( edits[e] )
for e in range( 0, len( edits )):
if edits[e] not in successfull:
m_temp = [ rfn, "unknown", "unknown", "unknown", edits[e].split( " " )[0], edits[e] ]
result.append( m_temp )
return result
def deformCharacterShapeSel(self, value):
RN = mc.referenceQuery(self.core.skCharacter[int(value)-1], referenceNode=1)
Nodes = mc.referenceQuery(RN, nodes=1)
self.characterdeformShape = []
self.allCharacterRightdeformShape = []
for item in Nodes:
if self.nodeTypeSelf(item) in self.shapeType:
self.characterdeformShape.append(item)
for each in self.characterdeformShape:
itemP = mc.listRelatives(each, p=1)[0]
itemPP = mc.listRelatives(itemP, p=1)
if itemPP != None and mc.getAttr('%s.v'%itemP) != 0 and mc.getAttr('%s.v'%itemPP[0]) != 0:
self.allCharacterRightdeformShape.append(each)
self.allCharacterRightdeformShape.reverse()
for item in self.allCharacterRightdeformShape:
if mc.filterExpand( item, sm=(10,12)) == None:
self.allCharacterRightdeformShape.remove(item)
for item in self.allCharacterRightdeformShape:
if item.endswith('Orig') == True:
self.allCharacterRightdeformShape.remove(item)
for item in self.allCharacterRightdeformShape:
if item.endswith('Orig') == True:
self.allCharacterRightdeformShape.remove(item)
for item in self.allCharacterRightdeformShape:
if item.endswith('Orig') == True:
self.allCharacterRightdeformShape.remove(item)
for item in self.allCharacterRightdeformShape:
if item.endswith('Orig') == True:
self.allCharacterRightdeformShape.remove(item)
for item in self.allCharacterRightdeformShape:
if item.endswith('Orig') == True:
self.allCharacterRightdeformShape.remove(item)
return self.allCharacterRightdeformShape
def exportShaders(self): """export custom shaders from scene, ex: shaders for masks etc...""" lays = rlayer.renderlayers() finalExport = [] for l in lays: if l.name == 'defaultRenderLayer': continue if l.overridedShader: finalExport.append( l.overridedShader ) else: if l.overridesWithConnections[1]: finalExport.extend( l.overridesWithConnections[1] ) if finalExport: shadersToExport = [] for i in finalExport: if mc.referenceQuery( i, inr = True ) or i in shadersToExport: #is a referenced node continue if mc.referenceQuery( i.a.surfaceShader.input, inr = True ): #check if shader is a reference continue if i.a.displacementShader.input: if mc.referenceQuery( i.a.displacementShader.input, inr = True ): #check if displacement is a reference continue shadersToExport.append( i ) mc.select( shadersToExport, r = 1, ne = 1 ) mc.file( self.shaderPath.path, op = "v=0", typ = "mayaAscii", pr = 1, es = 1 )
def defineAsset(self):
self.assetType, self.topGrp, self.astRes = None, None, None
self.refObjs = []
if not mc.referenceQuery(self.refNode,il=1):
utils.msgWin("Warning", "Reference not loaded for %s"%self.refNode, self.silent)
self.refLoaded = False
else:
self.refLoaded = True
self.assetPath = mc.referenceQuery(self.refNode, f = True, wcn = True)
self.assetPathCopyNum = mc.referenceQuery(self.refNode, f = True, wcn = False)
self.namespace = mc.file(self.assetPathCopyNum, q = 1, ns = 1)
if "/char/" in self.assetPath: self.assetType = "char"
if "/prop/" in self.assetPath: self.assetType = "prop"
if "/sets/" in self.assetPath: self.assetType = "sets"
if not self.assetType:
utils.msgWin("Error", "Error identifying asset type from asset path for %s"%self.refNode, self.silent)
self.validAsset = False
if self.refLoaded:
self.refObjs = mc.referenceQuery(self.refNode,n=1)
if not self.refObjs:
utils.msgWin("Error", "Couldn't find any referenced objects", self.silent)
self.validAsset = False
self.topGrp = self.refObjs[0]
if self.assetType == "prop":
topGrpAttrs = mc.listAttr(self.topGrp,ud=1)
if topGrpAttrs:
if ('Elements' in topGrpAttrs):
self.assetType = 'elms'
self.astRes = str(utils.findObjRes(self.topGrp))
def buildScene(cameraFile, envFile, charFile):
'''
Build the final lighting scene file.
:param cameraFile: Camera alembic file to import
:param envFile: Published layout env file to reference
:param charFile: Baked char file to reference
:return:
'''
if isValidFile(envFile):
try:
# Check if env file is already referenced.
cmds.referenceQuery(envFile, filename=True)
except RuntimeError:
cmds.file(envFile, r=True)
if isValidFile(charFile):
try:
# Check if env file is already referenced.
cmds.referenceQuery(charFile, filename=True)
except RuntimeError:
cmds.file(charFile, r=True)
if isValidFile(cameraFile):
# Check if camera exists in scene
cameraNodes = cmds.ls('renderCam')
if len(cameraNodes) == 1:
# Camara exists, delete and re-import alembic
cameraNode = cameraNodes[0]
cmds.delete(cameraNode)
cmds.AbcImport(cameraFile, mode='import')
cmds.file(save=True, type='mayaBinary', force=True)
def clearHeadPart(self, *args):
#find the current character
try:
character = cmds.optionMenu(self.widgets["characterList"], q = True, v = True)
except:
cmds.warning("No valid character selected")
#find any body part references
refs = cmds.ls(type = "reference")
headPartRefs = []
for ref in refs:
namespace = cmds.referenceQuery(ref, namespace = True)
if namespace.find("_headPart") != -1:
headPartRefs.append([ref, namespace])
#find out which, if any, are tied to this character and remove
for ref in headPartRefs:
joint = ref[1] + ":root"
constraint = cmds.listConnections(joint, type = "parentConstraint")[0]
target = cmds.listConnections(constraint + ".target")[0].partition(":")[0]
if target == character:
filename = cmds.referenceQuery(ref[0], filename = True)
cmds.file(filename, rr = True)
#unhide the original geometry
if cmds.objExists(character + ":Geo_Layer"):
cmds.setAttr(character + ":Geo_Layer.v", 1)
def dupReferenceForSelectedObjects(): """ Duplicate reference of the selected objects, only one time, and copy their edits """ allreadyDup = [] for a in mc.ls( sl = True ): ap = mc.referenceQuery( a, referenceNode=True, topReference=True ) if any( ap == r for r in allreadyDup ): print 'skipping',a continue allreadyDup.append( ap ) edits = mc.referenceQuery( ap , editStrings = True ) mc.select( a ) try: mm.eval( 'duplicateReference 0 ""' ) except: print 'maya de mierda' baseOldName = edits[0][edits[0].find( '|' )+1:edits[0].find( ':' )] baseNewName = mc.ls( sl = True )[0].split( ':' )[0] for e in edits: print '"""""""' print e print baseOldName,baseNewName try: mm.eval( e.replace( baseOldName, baseNewName, 1 ) ) except: continue
def addReferences():
cmds.select("dsMetaData")
shotList = cmds.ls(type = "shot")
refList = cmds.ls(rf=True)
for shot in shotList:
""" skips namespaces"""
if re.search(":",shot):
sSplit = shot.split(":")
shot = sSplit[-1]
for ref in refList:
if cmds.referenceQuery(ref,n=True,dp=True) != None:
refNs = cmds.referenceQuery(ref,ns=True,shn=True)
refN = cmds.referenceQuery(ref,f=True,shn=True)
print refNs
print refN
if not cmds.objExists("dsMetaData." + str(shot) + "_" + refNs):
cmds.addAttr(ln= str(shot) + "_" + refNs, at="message", h=False,r=True)
cmds.addAttr(ln= str(shot) + "_" + refNs + "_viz", at='bool', h=False,r=True)
cmds.addAttr(ln= str(shot) + "_" + refNs + "_assetID",at="long",h=False,r=True)
cmds.addAttr(ln= str(shot) + "_" + refNs + "_version",dt="string",h=False,r=True)
connectReferences(str(shot)+ "_" + refNs,refNs,refN)
def fixNode(self, nodeToFix, invert=False):
print ("\n" + nodeToFix)
# gets all attributes that need to be fixed
attrs = cmds.listAttr(nodeToFix, st=["hubElement"])
for attr in attrs:
print ("Found Attribute -> '" + attr + "'")
# check if the attribute is empty and if yes, fixs it
val = cmds.getAttr(nodeToFix + "." + attr)
condition = (not val or val != "neverBirdA")
if invert: condition = (val == "neverBirdA")
if condition:
msg = ("Attribute '" + attr + "' is empty or incorrect.")
if invert: msg = ("Attribute '" + attr + "' is OK.")
print msg
# if the attribute is locked, unlocks it first
isLocked = cmds.getAttr((nodeToFix + "." + attr), lock=True)
if isLocked:
print ("Attribute '" + attr + "' is locked. Unlocking it.")
isReferenced = cmds.referenceQuery((nodeToFix + "." + attr), isNodeReferenced=True)
if isReferenced:
try:
cmds.setAttr((nodeToFix + "." + attr), lock=False)
except:
print ("Attribute '" + attr + "' could not be unlocked, it is referenced.")
else:
cmds.setAttr((nodeToFix + "." + attr), lock=False)
# if the attribute is now unlocked, fixes the value
isLocked = cmds.getAttr((nodeToFix + "." + attr), lock=True)
if not isLocked:
msg = ("Attribute '" + attr + "'. Setting value to 'neverBirdA'")
if invert: msg = ("Attribute '" + attr + "'. Setting value to 'empty string'.")
print msg
newVal = "neverBirdA"
if invert: newVal = ""
print (nodeToFix + "." + attr)
print (cmds.getAttr((nodeToFix + "." + attr), settable=True))
cmds.setAttr((nodeToFix + "." + attr), newVal, type="string")
isReferenced = cmds.referenceQuery((nodeToFix + "." + attr), isNodeReferenced=True)
if not isReferenced:
print ("Attribute '" + attr + "'. Locking again")
cmds.setAttr((nodeToFix + "." + attr), lock=True)
else:
print ("Attribute '" + attr + "'. Is referenced, unable to locl again.")
else:
print ("Attribute '" + attr + "' could not be unlocked.")
else:
msg = ("Attribute '" + attr + "' is OK -> '" + val + "'")
if invert: msg = ("Attribute '" + attr + "' is not OK.")
print msg
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 export_mesh(self, transform, shape, awd_ctr):
try:
mtx = mc.xform(transform, q=True, m=True)
except:
print('skipping invalid %s' % transform)
tf_name = self.get_name(transform)
sh_name = self.get_name(shape)
tf_is_ref = mc.referenceQuery(transform, inr=True)
sh_is_ref = mc.referenceQuery(shape, inr=True)
if (tf_is_ref or sh_is_ref) and self.replace_exrefs:
# This is an external reference, and it should be
# replaced with an empty container in the AWD file
ctr = AWDContainer(name=tf_name, transform=AWDMatrix3x4(mtx))
self.set_attributes(transform, ctr)
self.block_cache.add(transform, ctr)
if awd_ctr is not None:
awd_ctr.add_child(ctr)
else:
self.awd.add_scene_block(ctr)
else:
md = self.block_cache.get(sh_name)
if md is None:
print('Creating mesh data %s' % sh_name)
md = AWDTriGeom(sh_name)
md.bind_matrix = AWDMatrix3x4(mtx)
self.export_mesh_data(md, shape)
self.awd.add_tri_geom(md)
self.block_cache.add(sh_name, md)
inst = AWDMeshInst(md, tf_name, self.mtx_list2awd(mtx))
self.set_attributes(transform, inst)
# Look for materials
if self.include_materials:
self.export_materials(transform, inst)
self.block_cache.add(transform, inst)
if awd_ctr is not None:
awd_ctr.add_child(inst)
else:
self.awd.add_scene_block(inst)
if self.include_skeletons:
history = mc.listHistory(transform)
clusters = mc.ls(history, type='skinCluster')
if len(clusters) > 0:
#TODO: Deal with multiple clusters?
sc = clusters[0]
influences = mc.skinCluster(sc, q=True, inf=True)
if len(influences) > 0:
skel_path = self.get_skeleton_root(influences[0])
if self.block_cache.get(skel_path) is None:
self.export_skeleton(skel_path)
def listCurrentProxy(sel=""):
'''List the current proxy, the selection belongs to'''
if str(sel) == "":
sel = cmds.ls(sl=True, hd=1, type="transform")
if not str(sel) == "":
proxfile = cmds.referenceQuery(sel ,filename=True )
prox = cmds.referenceQuery( proxfile, referenceNode=True )
return prox
def getSelectReferenceFile():
selectObjs = mc.ls(sl = True)
result = []
for obj in selectObjs:
if mc.referenceQuery(obj, isNodeReferenced = True):
if not result.count(mc.referenceQuery(obj, filename = True)):
result.append( mc.referenceQuery(obj, filename = True))
return result
def deformShapeSel(self, value):
RN = mc.referenceQuery(self.core.allPropPath[int(value)-1], referenceNode=1)
Nodes = mc.referenceQuery(RN, nodes=1)
self.propdeformShape = []
for item in Nodes:
if mc.nodeType(item) in self.shapeType:
self.propdeformShape.append(item)
return self.propdeformShape
def deformCharacterShapeSel(self, value):
RN = mc.referenceQuery(self.core.skCharacter[int(value)-1], referenceNode=1)
Nodes = mc.referenceQuery(RN, nodes=1)
self.characterdeformShape = []
for item in Nodes:
if mc.nodeType(item) in self.shapeType:
self.characterdeformShape.append(item)
return self.characterdeformShape
def export(ref_node):
"""
"""
data = {}
data['filename'] = cmds.referenceQuery(ref_node, filename=True)
data['namespace'] = cmds.referenceQuery(ref_node, namespace=True)
data['parents'] = get_parents(data['namespace'])
return data
def process(self, context):
from maya import cmds
self.log.info("Collecting references..")
# Get only valid top level reference nodes
# This makes it easier than using `cmds.ls` since it lists only
# top level references, and skips sharedReferenceNode.
ref_files = cmds.file(q=1, reference=1)
ref_nodes = [cmds.file(x, q=1, referenceNode=True) for x in ref_files]
references = dict()
for reference in ref_nodes:
# Ensure only top-level references
assert cmds.referenceQuery(reference,
referenceNode=True,
topReference=True) == reference
filename = cmds.referenceQuery(
reference,
filename=True,
withoutCopyNumber=True # Exclude suffix {1}
).replace("\\", "/")
if filename in references:
continue
references[filename] = {
"node": reference,
"filename": filename
}
self.log.info("Collecting %s" % references[filename])
for instance in context:
object_set = instance.data['objSetName']
if not cmds.objExists(object_set):
self.log.info("{0} is not a Maya node".format(object_set))
continue
userattrs = dict()
for attr in cmds.listAttr(object_set, userDefined=True):
try:
value = cmds.getAttr(object_set + "." + attr)
except RuntimeError:
continue
userattrs[attr] = value
metadata = instance.data("metadata")
assert metadata
metadata["references"] = references.values()
metadata["userattrs"] = userattrs
def listReferences():
"""Returns a dictionary with the path to the ref, its refNode, the nodes contained in the ref, and if the ref is loaded or not"""
references = cmds.file(query=True, reference=True)
referencesDict = dict()
for ref in references:
refNode = cmds.file(ref, query=True, referenceNode=True)
isLoaded = cmds.referenceQuery(refNode, isLoaded=True)
nodesInRef = cmds.referenceQuery(refNode, nodes=True)
referencesDict[ref] = [refNode, nodesInRef, isLoaded]
return referencesDict
def populateReferenceList():
references = cmds.ls(et='reference')
#del references[len(references)-1]
#print references
for ref in references:
refFileName = cmds.referenceQuery(ref ,filename = True)
print refFileName
if not(cmds.file(rfn=ref,q=True,dr=True)):
bla = cmds.referenceQuery(ref ,n = True)
cmds.textScrollList('ceRefList',e=True,append=[bla[0]])
def removeSelected(): """unload selected reference""" objs = mn.ls( sl = True ) for obj in objs: try: referenceNode = mc.referenceQuery( obj.name, rfn = True ) path = mc.referenceQuery( obj.name, f = True ) mc.file( referenceNode = referenceNode, removeReference = True ) except: continue
def getReferences(selected=False):
''' returns a list of maya references from
scene selection in form of objects '''
selected_references = []
sel = cmds.ls(sl=True) if selected else cmds.ls(type="reference")
for item in sel:
try:
ref_node = cmds.referenceQuery(item, rfn=True)
if ref_node not in selected_references:
selected_references.append(ref_node)
except RuntimeError:
pass
return [MayaReference(r) for r in selected_references]
def get_tagged_node(self, ref):
refNodes = cmds.referenceQuery(unicode(ref), nodes=True)
rootNode = ls(refNodes[0])
if rootNode[0].hasAttr("BYU_Alembic_Export_Flag"):
taggedNode = rootNode[0]
else:
taggedNode = self.get_tagged_children(rootNode[0])
if taggedNode == "":
self.showNoTagFoundDialog(unicode(ref))
return ""
print taggedNode
return taggedNode
def get_invalid(instance):
# Collect all referenced members
references = defaultdict(set)
relationships = instance.data["lookData"]["relationships"]
for relationship in relationships.values():
for member in relationship['members']:
node = member["name"]
if cmds.referenceQuery(node, isNodeReferenced=True):
ref = cmds.referenceQuery(node, referenceNode=True)
references[ref].add(node)
# Validate whether any has changes to 'cbId' attribute
invalid = list()
for ref, nodes in references.items():
edits = cmds.referenceQuery(editAttrs=True,
editNodes=True,
showDagPath=True,
showNamespace=True,
onReferenceNode=ref)
for edit in edits:
# Ensure it is an attribute ending with .cbId
# thus also ignore just node edits (like parenting)
if not edit.endswith(".cbId"):
continue
# Ensure the attribute is 'cbId' (and not a nested attribute)
node, attr = edit.split(".", 1)
if attr != "cbId":
continue
if node in nodes:
invalid.append(node)
return invalid
def create_breakdown(self, shot_name, requiered_nodes):
"""
"""
shot_entity = self.ensure_shot_entity(shot_name)
assets = []
for node in requiered_nodes:
node_type = cmds.nodeType(node)
if node_type == 'reference':
file_path = cmds.referenceQuery(node, filename=True)
namespace = cmds.referenceQuery(node, namespace=True).replace(
':', '')
asset_entity = self.ensure_breakdown_entity(
shot_entity, file_path, namespace)
if asset_entity:
assets.append(asset_entity)
if node_type == 'transform':
# this one gets tricky, but we in theory now that its a gpuCache
# Lets first get the children and verify its indeed a gpuCache
children = cmds.listRelatives(node, children=True)
if children and cmds.nodeType(children[0]) == 'gpuCache':
child = children[0]
file_path = cmds.getAttr("%s.cacheFileName" % child)
asset_entity = self.ensure_breakdown_entity(
shot_entity, file_path, None)
if asset_entity:
assets.append(asset_entity)
# finally just update the assets shot field
data = {'assets': assets}
self.shotgun.update('Shot', shot_entity['id'], data)
def cleanREF_SG():
print('Running %s...' % 'cleanREF_SG')
allRef = mc.ls(references=True)
#remove unloaded reference from the list
for ref in allRef:
if not mc.referenceQuery(ref, isLoaded=1):
allRef.remove(ref)
print('****COULDN\'T FIND: %s' % ref)
print('Found:')
for ref in allRef:
print(' %s' % ref)
#unloading all references
print('\nUnloading references...')
for ref in allRef:
mc.file(unloadReference=ref)
#remove Shading group reference edits
print('Removing Shading Group reference edits...')
for ref in allRef:
sgEdits = [
sge for sge in mc.referenceQuery(ref, editNodes=True)
if 'SG' in sge
]
for sge in sgEdits:
mc.referenceEdit(sge + '.dagSetMembers',
failedEdits=True,
successfulEdits=True,
removeEdits=True)
#reload reference
print('Reloading...')
for ref in allRef:
print(' %s' % ref)
mc.file(loadReference=ref)
print('')
def _maya_find_additional_session_dependencies():
"""
Find additional dependencies from the session
"""
# default implementation looks for references and
# textures (file nodes) and returns any paths that
# match a template defined in the configuration
ref_paths = set()
# first let's look at maya references
ref_nodes = cmds.ls(references=True)
for ref_node in ref_nodes:
# get the path:
ref_path = cmds.referenceQuery(ref_node, filename=True)
# make it platform dependent
# (maya uses C:/style/paths)
ref_path = ref_path.replace("/", os.path.sep)
if ref_path:
ref_paths.add(ref_path)
# now look at file texture nodes
for file_node in cmds.ls(l=True, type="file"):
# ensure this is actually part of this session and not referenced
if cmds.referenceQuery(file_node, isNodeReferenced=True):
# this is embedded in another reference, so don't include it in
# the breakdown
continue
# get path and make it platform dependent
# (maya uses C:/style/paths)
texture_path = cmds.getAttr("%s.fileTextureName" % file_node).replace(
"/", os.path.sep)
if texture_path:
ref_paths.add(texture_path)
return list(ref_paths)
def remove(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.
"""
node = container["objectName"]
# Assume asset has been referenced
reference_node = next((node for node in cmds.sets(node, query=True)
if cmds.nodeType(node) == "reference"), None)
assert reference_node, ("Imported container not supported; "
"container must be referenced.")
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 execute(self, **kwargs):
"""
Main hook entry point
:returns: A list of any items that were found to be published.
Each item in the list should be a dictionary containing
the following keys:
{
type: String
This should match a scene_item_type defined in
one of the outputs in the configuration and is
used to determine the outputs that should be
published for the item
name: String
Name to use for the item in the UI
description: String
Description of the item to use in the UI
selected: Bool
Initial selected state of item in the UI.
Items are selected by default.
required: Bool
Required state of item in the UI. If True then
item will not be deselectable. Items are not
required by default.
other_params: Dictionary
Optional dictionary that will be passed to the
pre-publish and publish hooks
}
"""
items = []
# get the main scene:
scene_name = cmds.file(query=True, sn=True)
if not scene_name:
raise TankError("Please Save your file before Publishing")
scene_path = os.path.abspath(scene_name)
name = os.path.basename(scene_path)
# create the primary item - this will match the primary output 'scene_item_type':
items.append({"type": "work_file", "name": name})
for node in cmds.ls(type="file"):
if not cmds.referenceQuery(node, isNodeReferenced=True):
items.append({"type": "texture_file", "name": node})
return items
def global_repair_func(self):
item = QtWidgets.QTreeWidgetItemIterator(self.rfn_tree)
while item.value():
name_space = item.value().text(0)
filename = item.value().text(1)
temp_matrix = eval(item.value().text(2))
rfn = cmds.file(filename, reference=True, namespace=name_space)
_temp_namespace = cmds.referenceQuery(rfn, namespace=True)
main_curve = "{}:{}".format(_temp_namespace, "Main")
if cmds.objExists(main_curve):
cmds.xform(main_curve, matrix=temp_matrix)
item = item.__iadd__(1)
def setMetaData(node, className, data, undoable=True, replace=False):
"""
Set the meta data for the a meta class type on a node.
The className must be a valid attribute name.
Args:
node (PyNode or str): The node on which to set data
className (str): The data's meta class type name
data (dict): The data to serialize and store on the node
undoable (bool): When True, the operation will be undoable
replace (bool): When True, will replace all data on the node
with the new meta data. This uses setAllMetaData and can
be much faster with large data sets.
"""
if replace:
setAllMetaData(node, {className: data}, undoable)
return
mfnnode = utils.getMFnDependencyNode(node)
plug = _getOrCreateMetaDataPlug(mfnnode, undoable)
_addMetaClassAttr(mfnnode, className, undoable)
# update meta data
refNode = None
if cmds.referenceQuery(str(node), isNodeReferenced=True):
refNode = cmds.referenceQuery(str(node), rfn=True)
fullData = decodeMetaData(plug.asString(), refNode)
fullData[className] = data
newValue = encodeMetaData(fullData)
if undoable:
plugName = _getUniquePlugName(mfnnode, plug)
cmds.setAttr(plugName, newValue, type='string')
else:
plug.setString(newValue)
def get_camera(with_panel=None):
all_cams = [cam for cam in mc.listCameras(p=1) if not mc.referenceQuery(cam, isNodeReferenced=True)]
extra_cams = ['persp', 'left', 'right', 'top', 'side', 'bottom']
if with_panel:
try:
current_cam = pm.PyNode(pm.modelPanel(pm.getPanel(wf=True), q=True, cam=True))
return current_cam
except RuntimeError:
pass
all_cam_transform = [str(cam) for cam in all_cams if str(cam) not in extra_cams]
# print all_cam_transform
if all_cam_transform:
return all_cam_transform
else:
return ["persp"]
def reference_in_scene(scene):
scene_references = cmds.ls(references=True)
for node in scene_references:
reference_file = cmds.referenceQuery(node, filename=True)
if os.path.normpath(scene) == os.path.normpath(reference_file):
print node, 'Already exists in the scene'
return True
return False
def formatAudioNode_to_Path(self):
'''
rename the AudioNode so it ties to the wav name
'''
try:
cmds.rename(
self.audioNode,
r9Core.nodeNameStrip(
os.path.splitext(os.path.basename(self.path))[0]))
except:
if cmds.referenceQuery(self.audioNode, inr=True):
log.info('failed to Rename Referenced Audio Node : %s' %
self.audioNode)
else:
log.info('failed to Rename Audio node : %s' % self.audioNode)
def renameReferenceh_AnimChangeTomc_Anim(self):
ReferenceFiles = self.ChangeReferenceFiles()
for ReferenceFile in ReferenceFiles:
if "_h_msAnim" in ReferenceFile:
referFile = mc.referenceQuery(ReferenceFile,
withoutCopyNumber=True,
shortName=True,
filename=True)
pathFileName = os.path.dirname(ReferenceFile) + "/" + referFile
fileName = pathFileName.replace("_h_msAnim", "_mc_msAnim")
if os.path.isfile(fileName):
referenceNode = mc.file(ReferenceFile,
q=True,
referenceNode=True)
mc.file(fileName, loadReference=referenceNode)
def _filteredReferenceNode():
newRefNodes = []
refNodes = cmds.ls(type="reference")
for refNode in refNodes:
if re.match(refNode, "\w+:sharedReferenceNode"):
continue
if re.match(refNode, "sharedReferenceNode"):
continue
if re.match(refNode, "_UNKNOWN_REF_NODE_"):
continue
newRefNode = cmds.referenceQuery(refNode, referenceNode=True)
newRefNodes.append(newRefNode)
return newRefNodes
def getReferenceNode(node):
'''
Get the reference node associated with the given referenced object
@param refNode: Reference node to query
@type refNode: str
'''
# Check Referenced Node
if not isReferenced(node):
raise Exception('Object "'+node+'" is not a referenced node!')
# Get Reference Node
refNode = mc.referenceQuery(node,referenceNode=True)
# Retrun Result
return refNode
def _get_relevant_objects_from_ref_node(self, src_mtl_mapping, ref_node):
child_nodes = cmds.referenceQuery(ref_node, nodes=True)
relevant_nodes = list()
# we need the object that matches objects from src_mtl_mapping
for child in child_nodes:
ns_stripped_object_name = pm.PyNode(child).stripNamespace()
if ns_stripped_object_name in src_mtl_mapping:
relevant_nodes.append(child)
# if not cmds.listRelatives(child, parent=True):
# return child
return relevant_nodes
def RNfromSelection():
'''This will select every master reference node for selected geometries that has a controller'''
# 1. controllers from selection
ctrls = []
for n in cmds.ls(selection=True, referencedNodes=True):
if not 'ctrl' in n:
pass
else:
ctrls.append(n)
# 2. master reference node from ctrl
rn = []
for ctrl in ctrls:
n = cmds.referenceQuery(ctrl, referenceNode=True, p=True)
rn.append(n)
return rn
def openReference(rfn):
"""
Open current reference node in new maya window.
"""
rfn = type(rfn) is list and rfn or [rfn]
for i in range(0, len(rfn)):
if cmds.nodeType(rfn[i]) == "reference":
node = rfn
elif os.path.isfile(rfn):
node = cmds.referenceQuery(rfn[i], rfn=True)
else:
print "%s is not reference" % rfn[i]
return None
maya = sys.executable
filename = cmds.referenceQuery(node, filename=True)
expression = re.compile(
"^(/Server-3d/Project)|(/mnt/server-3d)|(P:)|(/home/.*/Project)|(D:/Work/Project)|(//Server-3d/Project)",
re.IGNORECASE)
filename = expression.sub("//Server-3d/Project", filename)
if filename:
filename = filename.split("{")[0]
m_command = "python(\"import chekProject; chekProject.setMayaProject({0}); import melnik_setup; melnik_setup.updateScene();import maya.cmds as cmds; cmds.file({0}, force=True, open=True )\")".format(
"'%s'" % filename)
subprocess.Popen([maya, "-command", m_command])
def renameReferenceFileNoTex(self):
self.changeReferenceFiles()
for ReferenceFile in self.allReference:
if "_h_msNoTex" in ReferenceFile:
referFile = mc.referenceQuery(ReferenceFile,
withoutCopyNumber=True,
shortName=True,
filename=True)
pathFileName = os.path.dirname(ReferenceFile) + "/" + referFile
fileName = pathFileName.replace("_h_msNoTex", "_h_msAnim")
if os.path.isfile(fileName):
referenceNode = mc.file(ReferenceFile,
q=True,
referenceNode=True)
mc.file(fileName, loadReference=referenceNode)
def getNodesInReferenceFromFileName(ref_file):
""" """
if not os.path.exists(ref_file):
logging.error(u"file not exists:%s"%ref_file)
return None
if not isFileReferenced(ref_file):
logging.error("File Not referenced:%s"%ref_file)
return None
node_list = cmds.referenceQuery(ref_file, nodes=True)
if not node_list:
logging.warning("reference file has no nodes:%s"%ref_file)
return node_list
def getAllReferencedFileNames():
"""
get all file name
"""
ref_node_list = cmds.ls(type="reference")
if not ref_node_list:
logging.warning("No file referenced in current scene")
return None
ref_file_list = []
for ref_node in ref_node_list:
ref_file = cmds.referenceQuery(ref_node, filename=True)
ref_file_list.append(ref_file)
return ref_file_list
def light():
""" clear light
"""
_lights = cmds.ls(type=cmds.listNodeTypes("light"))
if _lights:
for _light in _lights:
try:
#if cmds.objExists(_light):
if cmds.referenceQuery(_light, isNodeReferenced=True) == False:
par = cmds.listRelatives(_light, p=True)
cmds.delete(par)
except Exception as e:
logger.warning(e)
def remove(self, container):
"""Remove an existing `container` from Maya scene
Arguments:
container (avalon-core:container-1.0): Which container
to remove from scene.
"""
from maya import cmds
node = container["objectName"]
# Get reference node from container members
members = cmds.sets(node, query=True, nodesOnly=True)
reference_node = self._get_reference_node(members)
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
return True
def _get_yeti_attr(nodeType, attrName, ignoreReference=True):
pg_dict = {}
_pgyetinodes = cmds.ls(type="pgYetiMaya")
if _pgyetinodes:
for _i in _pgyetinodes:
if ignoreReference and cmds.referenceQuery(_i, inr=1):
continue
selnodes = cmds.pgYetiGraph(_i, listNodes=1, type=nodeType)
for selnode in selnodes:
attr_v = cmds.pgYetiGraph(_i,
node=selnode,
param=attrName,
getParamValue=1) # 查询param命令lsp = 1
pg_dict["%s/%s" % (_i, selnode)] = attr_v
return pg_dict
def find(output_path=None, write=False):
if not output_path:
output_path = os.path.join(
tempfile.gettempdir(), 'studio_maya_reference_data.txt')
if os.path.isfile(output_path):
try:
os.chmod(output_path, 0777)
except:
pass
try:
os.remove(output_path)
except Exception as error:
print str(error)
references = cmds.file(q=True, r=True)
data = {}
print "\nhttp://www.subins-toolkits.com", '\n', '-' * 41
print '\nReference informations'
for index, reference in enumerate(references):
namespace = cmds.file(reference, q=True, ns=True).encode()
source_path = cmds.referenceQuery(reference, filename=True, wcn=True)
source_path = source_path.replace('\\', '/').encode()
world_node = cmds.referenceQuery(reference, n=1)[0]
current_data = {
'source_path': source_path,
'namespace': namespace,
'top_dag_node': world_node
}
data.setdefault(index + 1, current_data)
print index
print '\tsource_path :', source_path
print '\tnamespace :', namespace
print '\tTop level dag object :', world_node, '\n'
if write:
with (open(output_path, 'w')) as content:
content.write(json.dumps(data, indent=4))
return data, output_path
def _cleanupNamespace():
'''
find the reference, import it,
finds the prefix of the reference and cleans up the namespace
'''
for item in listCtrls():
pre = str(listCtrls()[0])
prefix = pre.rsplit(":")[0]
print 'Cleaning up file : RIG is %s' % prefix
ref = cmds.referenceQuery(item, filename=True)
cmds.file(ref, importReference=True)
cmds.namespace(mv=(prefix, ":"), force=True)
cmds.namespace(rm=prefix)
print "Cleaning up file : namespace deleted and cleaned up"
def validateAnimationCurve(animationCurve):
"""
Check if the parsed animation curve can be reduces. Set driven keyframes
and referenced animation curves will be ignored.
:param str animationCurve:
:return: Validation state of the animation curve
:rtype: bool
"""
if cmds.listConnections("{}.input".format(animationCurve)):
return False
elif cmds.referenceQuery(animationCurve, isNodeReferenced=True):
return False
return True
def getReferenceFile(node,withoutCopyNumber=True):
'''
Get the reference node associated with the given referenced object or reference node
@param refNode: Reference node to query
@type refNode: str
'''
# Check Reference/Referenced Node
if not isReference(node) and not isReferenced(node):
raise Exception('Object "'+node+'" is not a valid reference node or a node from a referenced file!')
# Get Reference details
refFile = mc.referenceQuery(node,filename=True,wcn=withoutCopyNumber)
# Retrun Result
return refFile
def remove_ref():
logger.info("Importing references ---------------------------------")
try:
mel.eval('RNdeleteUnused();')
sorted_references = ns_sort(cmds.ls(type='reference'))
for i in sorted_references:
print i
rFile = cmds.referenceQuery(i, f=True)
cmds.file(rFile, importReference=True, mnr=True, f=True)
except Exception, err:
logger.info(err)
logger.info("Import references failed")
