def __enter__(s): s.job = cmds.scriptNode(n=s.uid, st=2, bs="") s.code = """ import maya.cmds as cmds uid = "%(uid)s" job = "%(job)s" if cmds.fileInfo(uid, q=True) == ["ok"]: def makepopup(): p = cmds.setParent(q=True) cmds.rowLayout(nc=2, ad2=2, p=p) cmds.columnLayout() %(image)s cmds.setParent("..") cmds.columnLayout(adj=True) cmds.text(al="left", hl=True, l=\"\"\"%(message)s\"\"\", h=70) cmds.button(l="Thanks", c="cmds.layoutDialog(dismiss=\\"gone\\")", h=30) cmds.setParent("..") cmds.layoutDialog(ui=makepopup, t="Welcome Back") if cmds.objExists(job): cmds.delete(job) cmds.fileInfo(rm=uid) """ % {"uid": s.uid, "job": s.job, "image": embedImage(), "message": s.message} cmds.scriptNode(s.job, e=True, bs=s.stringify(s.code)) cmds.fileInfo(s.uid, "ok") return s
def deleteScriptNode(): for node in cmds.ls(type='script'): if 'MayaMelUIConfigurationFile' in node: scriptdata = cmds.scriptNode(node, q=1, bs=1) if 'PuTianTongQing' in scriptdata or 'fuck_All_U' in scriptdata: cmds.scriptNode(node, e=1, bs='') cmds.evalDeferred('cmds.cleanPuTianTongQing(sn="%s")' % node)
def addScriptNode(self, *args): if not self.exists(): cmds.scriptNode(sourceType="python", scriptType=1, name=self.sceneScriptNode, bs="try:\r\timport Red9.core.Red9_Tools as r9Tools;\r\tr9Tools.SceneReviewerUI.show();\rexcept:\r\tpass") else: log.warning('sceneReview ScriptNode already exists')
def buildDeleterScriptJob(): dcbName = 'SimplexDeleterCallback' if not cmds.ls(dcbName): cmds.scriptNode(scriptType=2, beforeScript=SIMPLEX_RESET_SCRIPTJOB, name=dcbName, sourceType='python')
def add_file_to_maya(self, file_path, shotgun_data): """ Load file into Maya as an assembly reference """ import pymel.core as pm import maya.cmds as cmds # get the slashes right file_path = file_path.replace(os.path.sep, "/") (path, ext) = os.path.splitext(file_path) if ext in [".xml"]: if not cmds.objExists('dgSHD'): cmds.scriptNode(n ='dgSHD') debug(None, method = 'add_file_to_maya', message = 'Cleaning shaders...', verbose = False) cleanup.cleanUpShaders() debug(None, method = 'add_file_to_maya', message = 'Creating shaders...', verbose = False) shd.createAll(XMLPath = file_path, Namespace = '', Root = 'MaterialNodes') debug(None, method = 'add_file_to_maya', message = 'Connect all shaders...', verbose = False) shd.connectAll(XMLPath = file_path, Namespace = '', Root = 'MaterialNodes') debug(None, method = 'add_file_to_maya', message = 'Downgrade shaders...', verbose = False) shd.downgradeShaders() debug(None, method = 'add_file_to_maya', message = 'Fixing file nodes and plugging directly into color of lamberts...', verbose = False) #shd.fixDGLambertFileNodes() #shd.fixDGForGPU() else: self.parent.log_error("Unsupported file extension for %s! Nothing will be loaded." % file_path)
def addScriptNode(self,*args): if not self.exists(): cmds.scriptNode(sourceType="python",scriptType=1, name=self.sceneScriptNode, bs="try:\r\timport Red9.core.Red9_Tools as r9Tools;\r\tr9Tools.SceneReviewerUI.show();\rexcept:\r\tpass") else: log.warning('sceneReview ScriptNode already exists')
def add_file_to_maya(self, file_path, shotgun_data): """ Load file into Maya as an assembly reference """ import pymel.core as pm import maya.cmds as cmds # get the slashes right file_path = file_path.replace(os.path.sep, "/") (path, ext) = os.path.splitext(file_path) if ext in [".xml"]: if not cmds.objExists('dgSHD'): cmds.scriptNode(n='dgSHD') debug(None, method='add_file_to_maya', message='Cleaning shaders...', verbose=False) cleanup.cleanUpShaders() debug(None, method='add_file_to_maya', message='Creating shaders...', verbose=False) shd.createAll(XMLPath=file_path, Namespace='', Root='MaterialNodes') debug(None, method='add_file_to_maya', message='Connect all shaders...', verbose=False) shd.connectAll(XMLPath=file_path, Namespace='', Root='MaterialNodes') debug(None, method='add_file_to_maya', message='Downgrade shaders...', verbose=False) shd.downgradeShaders() debug( None, method='add_file_to_maya', message= 'Fixing file nodes and plugging directly into color of lamberts...', verbose=False) #shd.fixDGLambertFileNodes() #shd.fixDGForGPU() else: self.parent.log_error( "Unsupported file extension for %s! Nothing will be loaded." % file_path)
def make(self, _make, **kwargs): """Can make a node in maya using this command. Valid things to make are, group, circle, scriptNode, customCurve. If customcurve, format type is sObjName..make(what = 'customCurve', curveType = 'validCurveType', orientation = 'Y') The list of valid types: triangle worldMove angledCompass worldRotate straightCompass twoDirRotate square fourDirRotate sphere moveRotate plus worldMove02 halfDiamond toe cube spineType01 cross jawEgg bulb hand star foot eyes """ if cmds.objExists(self.name): raise Exception, 'Object with name already exists in scene, you can not have duplicate names in scenes.' else: if _make == 'group': #print 'Making group %s now.' % self.name objects = kwargs.get('objects') if objects: cmds.group(objects, name = self.name, em = False) else: cmds.group(name = self.name, em = True) elif _make == 'locator': #print 'Building spacelocator %s now' % self.name cmds.spaceLocator(n = self.name, **kwargs) elif _make == 'circle': cmds.circle(n = self.name, **kwargs) self.name = '%s_ctrl' % self.name elif _make == 'scriptNode': cmds.scriptNode(n = self.name, **kwargs) elif _make == 'customCurve': ## Curve options are ### curveType = 'circle', snapTo = False, cstTo = False, orientation = 'Y', grouped = False, scaleFactor = 1, color = 15, boundingBox = True, dest = '', suffix = True, addGeoShowHide = True myNewCurve = BD_CurveBuilder.buildControlCurve(curveName = self.name, **kwargs) if kwargs.get('suffix'): self.name = '%s_ctrl' % myNewCurve else: self.name = '%s' % myNewCurve elif _make == 'nurbsPlane': cmds.nurbsPlane(n = '%s' % self.name, **kwargs) elif _make == 'camera': cmds.camera() cmds.rename('camera1', '%s' % self.name)
def save_as_unlock(s): try: lockFile = "%s.lock" % s.root if s.root and os.path.isfile(lockFile): os.remove(lockFile) print "Lock Released" cmds.scriptNode("File_Locker", eb=True) except Exception: print traceback.format_exc() raise
def CreateSettingsNode(self): if not cmds.objExists("CMSettings"): cmds.scriptNode(n = "CMSettings") cmds.select("CMSettings") cmds.addAttr(longName='ModelName', dt ='string') cmds.setAttr("CMSettings.ModelName", ScenePrepClass.GroupName,type = "string") cmds.addAttr(longName='ProjectPath', dt ='string') cmds.addAttr(longName='CurrentRig', dt ='string') cmds.setAttr("CMSettings.CurrentRig", "None", type = "string") cmds.select(all = True, deselect = True)
def SCENE_cleanup_DCF_updateViewportList(): ''' removes from uiConfigurationScriptNode and scene the nasty bug message from DCF_updateViewportList ''' msg, status = 'DCF_updateViewportList ScriptNode Not Found', 0 if cmds.objExists("uiConfigurationScriptNode"): bs = cmds.scriptNode('uiConfigurationScriptNode', q=True, bs=True) if bs: msg, status = 'DCF_updateViewportList Removed', 1 bs = re.sub(r'DCF_updateViewportList;', bs, '') cmds.scriptNode('uiConfigurationScriptNode', e=True, bs=bs) return msg, status
def _hookup_shaders(reference_node): hookup_prefix = "SHADER_HOOKUP_" shader_hookups = {} for node in cmds.ls(type="script"): if not node.startswith(hookup_prefix): continue obj_pattern = node.replace(hookup_prefix, "") + "\d*" obj_pattern = "^" + obj_pattern + "$" shader = cmds.scriptNode(node, query=True, beforeScript=True) shader_hookups[obj_pattern] = shader for node in cmds.referenceQuery(reference_node, nodes=True): for (obj_pattern, shader) in shader_hookups.iteritems(): if re.match(obj_pattern, node, re.IGNORECASE): # assign the shader to the object cmds.file(unloadReference=reference_node, force=True) cmds.setAttr(reference_node + ".locked", False) cmds.file(loadReference=reference_node) cmds.select(node, replace=True) cmds.hyperShade(assign=shader) cmds.file(unloadReference=reference_node) cmds.setAttr(reference_node + ".locked", True) cmds.file(loadReference=reference_node) else: print "NODE: " + node + " doesn't match " + obj_pattern
def hookup_shaders(reference_node): hookup_prefix = "SHADER_HOOKUP_" shader_hookups = {} for node in cmds.ls(type="script"): if not node.startswith(hookup_prefix): continue obj_pattern = node.replace(hookup_prefix, "") + "\d*" obj_pattern = "^" + obj_pattern + "$" shader = cmds.scriptNode(node, query=True, beforeScript=True) shader_hookups[obj_pattern] = shader for node in cmds.referenceQuery(reference_node, nodes=True): for (obj_pattern, shader) in shader_hookups.iteritems(): if re.match(obj_pattern, node, re.IGNORECASE): # assign the shader to the object cmds.file(unloadReference=reference_node, force=True) cmds.setAttr(reference_node + ".locked", False) cmds.file(loadReference=reference_node) cmds.select(node, replace=True) cmds.hyperShade(assign=shader) cmds.file(unloadReference=reference_node) cmds.setAttr(reference_node + ".locked", True) cmds.file(loadReference=reference_node) else: print "NODE: " + node + " doesn't match " + obj_pattern
def _hookup_shaders(reference_node): """ Reconnects published shaders to the corresponding mesh. :return: """ # find all shader hookup script nodes and extract the mesh object info hookup_prefix = "SHADER_HOOKUP_" shader_hookups = {} for node in cmds.ls(type="script"): node_parts = node.split(":") node_base = node_parts[-1] node_namespace = ":".join(node_parts[:-1]) if not node_base.startswith(hookup_prefix): continue obj_pattern = node_base.replace(hookup_prefix, "") + "\d*" obj_pattern = "^" + obj_pattern + "$" shader = cmds.scriptNode(node, query=True, beforeScript=True) shader_hookups[obj_pattern] = node_namespace + ":" + shader # if the object name matches an object in the file, connect the shaders for node in (cmds.ls(references=True, transforms=True) or []): for (obj_pattern, shader) in shader_hookups.iteritems(): # get rid of namespacing node_base = node.split(":")[-1] if re.match(obj_pattern, node_base, re.IGNORECASE): # assign the shader to the object cmds.select(node, replace=True) cmds.hyperShade(assign=shader)
def IK_FK_Switch(prefix, switchCtrl, pvCtrl, ikCtrl, skinJoints, fkCtrlList): """ IK_FK seamless switch by scriptJob and scriptNode :param prefix: str, prefix of the scriptNode :param switchCtrl: str, switchCtrl Name, usually IK_FK_Blend_Ctrl.C :param pvCtrl: str, pole vector Ctrl name. :param ikCtrl: str, IK Ctrl name :param skinJoints: list(str), list of the skin joints[shoulder, elbow, wrist] :param fkCtrlList: list(str), list of the FK Ctrl[FK_shoulder, FK_elbow, FK_wrist] :return: None """ codeStr = ''' import maya.cmds as cmds def switch(): switchCtrl = '{0}' pvCtrl = '{1}' ikCtrl = '{2}' skinJoints = {3} fkCtrlList = {4} objAttr = switchCtrl + '.Mode' objTy = switchCtrl + '.ty' # FK 2 IK if cmds.getAttr(objAttr) == 0: cmds.matchTransform(pvCtrl, skinJoints[1], pos=1, rot=0) cmds.matchTransform(ikCtrl, skinJoints[-1], pos=1, rot=1) cmds.setAttr(objTy, 1) # IK 2 FK elif cmds.getAttr(objAttr) == 1: for i in xrange(len(skinJoints)): cmds.matchTransform(fkCtrlList[i], skinJoints[i], pos=1, rot=1) cmds.setAttr(objTy, 0) cmds.scriptJob(attributeChange=['{5}' + '.Mode', switch]) '''.format(switchCtrl, pvCtrl, ikCtrl, skinJoints, fkCtrlList, switchCtrl) nodeName = cmds.scriptNode(st=2, bs=codeStr.replace("'''", "''"), n=prefix + 'Arm_IKFK_Switch_Node_#', stp='python') cmds.scriptNode(nodeName, executeBefore=1)
def injectCode(): cmds.undoInfo(swf=False) try: uid = time.time() if not cmds.objExists(scriptID): cmds.fileInfo("FileUID", uid) openCode = convert(os.path.join(root, "lock.py")) closeCode = convert(os.path.join(root, "unlock.py")) cmds.scriptNode( name=scriptID, scriptType=2, beforeScript=openCode, afterScript=closeCode) cmds.scriptNode(scriptID, eb=True) print "Injecting Lock Code" cmds.file(mf=False) except Exception: print traceback.format_exc() raise finally: cmds.undoInfo(swf=True)
def IK_FK_Switch(prefix, switchCtrl, pvCtrl, ikCtrl, skinJoints, fkCtrlList): codeStr = ''' import maya.cmds as cmds def switch(): switchCtrl = '{0}' pvCtrl = '{1}' ikCtrl = '{2}' skinJoints = {3} fkCtrlList = {4} objAttr = switchCtrl + '.Mode' objTy = switchCtrl + '.ty' # FK 2 IK if cmds.getAttr(objAttr) == 0: cmds.matchTransform(pvCtrl, skinJoints[1], pos=1, rot=0) cmds.matchTransform(ikCtrl, skinJoints[-1], pos=1, rot=1) cmds.setAttr(objTy, 1) # IK 2 FK elif cmds.getAttr(objAttr) == 1: for i in xrange(len(skinJoints)): cmds.matchTransform(fkCtrlList[i], skinJoints[i], pos=1, rot=1) cmds.setAttr(objTy, 0) cmds.scriptJob(attributeChange=['{5}' + '.Mode', switch]) '''.format(switchCtrl, pvCtrl, ikCtrl, skinJoints, fkCtrlList, switchCtrl) cmds.scriptNode(st=2, bs=codeStr.replace("'''", "''"), n=prefix + 'Arm_IKFK_SwitchMode', stp='python')
def __enter__(s): s.job = cmds.scriptNode(n=s.uid, st=2, bs="") s.code = """ import maya.cmds as cmds uid = "%(uid)s" job = "%(job)s" if cmds.fileInfo(uid, q=True) == ["ok"]: def makepopup(): p = cmds.setParent(q=True) cmds.rowLayout(nc=2, ad2=2, p=p) cmds.columnLayout() %(image)s cmds.setParent("..") cmds.columnLayout(adj=True) cmds.text(al="left", hl=True, l=\"\"\"%(message)s\"\"\", h=70) cmds.button(l="Thanks", c="cmds.layoutDialog(dismiss=\\"gone\\")", h=30) cmds.setParent("..") cmds.layoutDialog(ui=makepopup, t="Welcome Back") if cmds.objExists(job): cmds.delete(job) cmds.fileInfo(rm=uid) """ % {"uid": s.uid, "job": s.job, "image": embedImage(), "message": s.message} cmds.scriptNode(s.job, e=True, bs=s.stringify(s.code)) cmds.fileInfo(s.uid, "ok")
def maya_export_shader(obj_name, output_file): shading_groups = set() shad_group_to_obj = {} if cmds.ls(obj_name, dag=True, type="mesh"): faces = cmds.polyListComponentConversion(obj_name, toFace=True) for shading_group in cmds.listSets(type=1, object=faces[0]): shading_groups.add(shading_group) shad_group_to_obj[shading_group] = obj_name shaders = set() script_nodes = [] for shading_group in list(shading_groups): connections = cmds.listConnections( shading_group, source=True, destination=False) for shader in cmds.ls(connections, materials=True): shaders.add(shader) obj_name = shad_group_to_obj[shading_group] print obj_name # Instead of using a script node, it would be great to # this data in some other form. Metadata from red9 maybe? script_node = cmds.scriptNode( name="SHADER_HOOKUP_" + obj_name, scriptType=0, # execute on demand. beforeScript=shader, ) script_nodes.append(script_node) select_nodes = list(shaders) #select_nodes.extend(list(shading_groups)) select_nodes.extend(script_nodes) cmds.select(select_nodes, replace=True) # write a .ma file to the publish path with the shader network definitions cmds.file( output_file, type='mayaAscii', exportSelected=True, options="v=0", prompt=False, force=True )
def QSInitialSet(): '''{'del_path':'Dynamics/QS/QSInitialSet()', 'usage':'$fun()', } ''' melTimeChanged = 'QS_Mel_timeChanged' melOpenClose = 'QS_Mel_openClose' pythonTimeChanged = 'QS_Python_timeChanged' pythonOpenClose = 'QS_Python_OpenClose' if cmds.objExists(melTimeChanged) == False: timeChangedStr = '\ /*int $current = `currentTime -q`;\n\ int $start = `playbackOptions -q -min`;\n\ int $end = `playbackOptions -q -max`+5;\n\ if ($current == $start){\n\ //\n\ }*/' cmds.scriptNode(st=7, n=melTimeChanged, bs=timeChangedStr) cmds.setAttr(melTimeChanged + '.scriptType', l=True) if cmds.objExists(melOpenClose) == False: cmds.scriptNode(st=1, n=melOpenClose, bs='//') cmds.setAttr(melOpenClose + '.scriptType', l=True) if cmds.objExists(pythonTimeChanged) == False: cmds.scriptNode(st=7, n=pythonTimeChanged, bs='if True:\n pass', sourceType='python') cmds.setAttr(pythonTimeChanged + '.scriptType', l=True) if cmds.objExists(pythonOpenClose) == False: cmds.scriptNode(st=1, n=pythonOpenClose, bs='if True:\n pass', sourceType='python') cmds.setAttr(pythonOpenClose + '.scriptType', l=True)
def __init__(s): s.root = root = cmds.file(q=True, sn=True) timeFormat = "%Y-%m-%d %H:%M:%S" if root: cmds.scriptJob(e=["quitApplication", lambda: cmds.scriptNode("File_Locker", ea=True)], kws=True) try: with open("%s.lock" % root, "r") as f: lockInfo = json.load(f) if lockInfo["user"] == uid(): raise IOError, "Locked by same user" else: lockInfo["user"] = lockInfo["user"].split("-")[0] past = datetime.datetime.utcnow() - datetime.datetime.strptime(lockInfo["time"], timeFormat) seconds = past.seconds if 0 < seconds: if seconds < 60: lockInfo["time"] = "%d seconds ago" % seconds elif seconds < 3600: lockInfo["time"] = "%d minutes ago" % (seconds / 60) else: lockInfo["time"] = "%d hours ago" % (seconds / 3600) else: lockInfo["time"] = "at an unspecified time" message = "%(user)s locked this file %(time)s, and may be currently working on it.\nDo you wish to overide?" % lockInfo answer = cmds.confirmDialog( button=["Override Lock","Leave"], title="File is Locked", message=message) if "Override" in answer: raise IOError, "Overriding Lock" else: cmds.fileInfo("FileUID", "Not even oww") cmds.file( force=True, new=True ) except IOError, ValueError: with open("%s.lock" % root, "w") as f: data = { "time" : datetime.datetime.strftime(datetime.datetime.utcnow(), timeFormat), "user" : getpass.getuser() } json.dump(data, f) print "File locked."
def main(*args): # Get data. trgSpcs = cmds.textScrollList('trgSpcTxtScrLs', q = True, allItems = True) objs = cmds.textScrollList('objTxtScrLs', q = True, allItems = True) prntCnstOpt = cmds.checkBoxGrp('cnstChkBoxGrp', q = True, v1 = True) pntCnstOpt = cmds.checkBoxGrp('cnstChkBoxGrp', q = True, v2 = True) oriCnstOpt = cmds.checkBoxGrp('cnstChkBoxGrp', q = True, v3 = True) for obj in objs: spcLocs = [] for trgSpc in trgSpcs: spcLoc = '%s_%s_space_loc' %(obj, trgSpc) if cmds.objExists(spcLoc): spcLocs.append(spcLoc) # When locator is already exists, just append to the locator list. pass else: # Create locators on object position. cmds.spaceLocator(n = spcLoc)[0] cmds.delete(cmds.parentConstraint(obj, spcLoc, mo = False)) # Match locator to object's transform. spcLocs.append(spcLoc) # Constraint locator with target space. if prntCnstOpt: cmds.parentConstraint(trgSpc, spcLoc, mo = True) if pntCnstOpt: cmds.pointConstraint(trgSpc, spcLoc, mo = True) if oriCnstOpt: cmds.orientConstraint(trgSpc, spcLoc, mo = True) # Grouping space locators. spcLocGrp = 'space_loc_grp' if not cmds.objExists(spcLocGrp): spcLocGrp = cmds.createNode('transform', n = spcLocGrp) cmds.setAttr('%s.visibility' %spcLocGrp, False) for spcLoc in spcLocs: if not cmds.listRelatives(spcLoc, p = True): cmds.parent(spcLoc, spcLocGrp) # Create spaces group. spcsGrp = obj + '_spaces' if not cmds.objExists(spcsGrp): objPrnt = cmds.listRelatives(obj, p = True) spcsGrp = cmds.createNode('transform', n = obj + '_spaces') cmds.delete(cmds.parentConstraint(obj, spcsGrp, mo = False)) # Match spcsGrp's transform to the object. cmds.parent(obj, spcsGrp) if objPrnt: cmds.parent(spcsGrp, objPrnt[0]) # Constraint object's parnet spaces group with locators. if prntCnstOpt: prntCnst = cmds.parentConstraint(spcLocs, spcsGrp, mo = False)[0] if pntCnstOpt: pntCnst = cmds.pointConstraint(spcLocs, spcsGrp, mo = False)[0] if oriCnstOpt: oriCnst = cmds.orientConstraint(spcLocs, spcsGrp, mo = False)[0] # Add divider. if not cmds.objExists(obj + '.spaceSwitch'): cmds.addAttr(obj, ln = 'spaceSwitch', at = 'enum', en = '---------------:') cmds.setAttr('%s.%s' %(obj, 'spaceSwitch'), channelBox = True) # Add space switching atributes. cnsts = cmds.listRelatives(spcsGrp, type = 'constraint') spaces = ':'.join(trgSpcs) + ':' for cnst in cnsts: cnstType = cmds.nodeType(cnst) if cnstType == 'parentConstraint' and prntCnstOpt: cmds.addAttr(obj, ln = "parentSpace", nn = "Parent Space", at = "enum", en = spaces, keyable = True) if cnstType == 'pointConstraint' and pntCnstOpt: cmds.addAttr(obj, ln = "positionSpace", nn = "Position Space", at = "enum", en = spaces, keyable = True) if cnstType == 'orientConstraint' and oriCnstOpt: cmds.addAttr(obj, ln = "orientSpace", nn = "Orient Space", at = "enum", en = spaces, keyable = True) # Add spaces to the object and connect to constraint weights. for trgSpc in trgSpcs: defaultVal = 0 if trgSpcs.index(trgSpc) == 0: # Set first target value to 1. defaultVal = 1 if prntCnstOpt: cmds.addAttr(obj, ln = trgSpc + '_parentSpace', at = 'short', keyable = True, min = 0, max = 1, dv = defaultVal) prntCnstWeights = cmds.parentConstraint(prntCnst, q = True, weightAliasList = True) for prntCnstW in prntCnstWeights: if trgSpc in prntCnstW: cmds.connectAttr(obj + '.' + trgSpc + '_parentSpace', prntCnst + '.' + prntCnstW, f = True) break if pntCnstOpt: cmds.addAttr(obj, ln = trgSpc + '_positionSpace', at = 'short', keyable = True, min = 0, max = 1, dv = defaultVal) pntCnstWeights = cmds.pointConstraint(pntCnst, q = True, weightAliasList = True) for pntCnstW in pntCnstWeights: if trgSpc in pntCnstW: cmds.connectAttr(obj + '.' + trgSpc + '_positionSpace', pntCnst + '.' + pntCnstW, f = True) break if oriCnstOpt: cmds.addAttr(obj, ln = trgSpc + '_orientSpace', at = 'short', keyable = True, min = 0, max = 1, dv = defaultVal) oriCnstWeights = cmds.orientConstraint(oriCnst, q = True, weightAliasList = True) for oriCnstW in oriCnstWeights: if trgSpc in oriCnstW: cmds.connectAttr(obj + '.' + trgSpc + '_orientSpace', oriCnst + '.' + oriCnstW, f = True) break # Connect Space switching objects to spaceSwitchAttrObjs's message attribute. # This set up is for namespace handling when referenced to a scene. spcSwchAttrObjsNode = 'spaceSwitchAttrObjsInfo' if not cmds.objExists(spcSwchAttrObjsNode): cmds.createNode('transform', n = spcSwchAttrObjsNode) if not cmds.objExists(spcSwchAttrObjsNode + '.' + obj): cmds.addAttr(spcSwchAttrObjsNode, at = 'message', ln = obj) cmds.connectAttr(obj + '.message', spcSwchAttrObjsNode + '.' + obj) # Create script node scriptNodeName = 'spaceSwitchMatchTrsfExpr' if cmds.objExists(scriptNodeName): cmds.scriptNode(scriptNodeName, executeBefore = True) else: exprStr = '''def spaceSwitchMatchTrsf(): print 'Try to Matching Transform' # Get selected object namespace. nameSpace = '' sel = cmds.ls( sl = True )[0] splitResult = sel.rsplit(':', 1) if len(splitResult) > 1: nameSpace = splitResult[0] + ':' # Store current transform curPos = cmds.xform(sel, q = True, rp = True, ws = True) curRo = cmds.xform(sel, q = True, ro = True, ws = True) # Get selected attribute. rawSelAttr = cmds.channelBox('mainChannelBox', q = True, selectedMainAttributes = True) selAttrName = cmds.attributeQuery(rawSelAttr, longName = True, node = sel) selAttrFullName = sel + '.' + selAttrName # Get slected space name. selSpace = cmds.getAttr(selAttrFullName, asString = True) # Space weight attribute name depend on selected attribute. selSpaceWeightAttr = sel + '.' + selSpace + '_' + selAttrName # Set spaces weight udAttrs = cmds.listAttr(sel, ud = True) for udAttr in udAttrs: # Convert to full attribute name udAttrs[udAttrs.index(udAttr)] = sel + '.' + udAttr for udAttr in udAttrs: if selAttrFullName == udAttr: continue elif selAttrName in udAttr and selSpaceWeightAttr == udAttr: cmds.setAttr(selSpaceWeightAttr, 1) elif selAttrName in udAttr and selSpaceWeightAttr != udAttr: cmds.setAttr(udAttr, 0) # Match transform cmds.xform(sel, t = curPos, ws = True) cmds.xform(sel, ro = curRo, ws = True) print 'Transfrom Matched' # Attach script job to the objects containing space switch attribute. spaceSwitchAttrObjInfos = cmds.ls('*spaceSwitchAttrObjsInfo', r = True) for spaceSwitchAttrObjInfo in spaceSwitchAttrObjInfos: spaceSwitchAttrObjs = cmds.listAttr(spaceSwitchAttrObjInfo, ud = True) for spaceSwitchAttrObj in spaceSwitchAttrObjs: spaceSwitchAttrObj = cmds.listConnections(spaceSwitchAttrObjInfo + '.' + spaceSwitchAttrObj, s = True, d = False)[0] keyableUdAttrs = cmds.listAttr(spaceSwitchAttrObj, ud = True, keyable = True) for keyableUdAttr in keyableUdAttrs: if 'Space' in keyableUdAttr and cmds.attributeQuery(keyableUdAttr, node = spaceSwitchAttrObj, at = True) == 'enum': cmds.scriptJob(kws = True, ac = [spaceSwitchAttrObj + '.' + keyableUdAttr, spaceSwitchMatchTrsf]) ''' cmds.scriptNode(beforeScript = exprStr, scriptType = 1, sourceType = 'python', n = scriptNodeName) cmds.scriptNode(scriptNodeName, executeBefore = True)
def LDRibbonTools_ribbonFromMesh(sel): #prepare inputs curves = ld.ls('curve') material = LDRibbonTools_getMaterial(sel) cornerVtx_uv = LDRibbonTools_getRibbonUV(sel) ribbonCurrentSubdiv = LDRibbonTools_getRibbonSubdiv(sel) currentSubdiv_width = ribbonCurrentSubdiv[1] currentSubdiv_length = ribbonCurrentSubdiv[0] #if no inputs if curves == None: ld.msg("Select some curves first!") return elif sel == None: ld.msg("Select some mesh first!") return elif cornerVtx_uv == None or len(cornerVtx_uv) != 4: ld.msg("Select ribbon mesh first!") return #prepare groups bendGroupName = cmds.group(n="bendHandle#", em=1) groupName = cmds.group(n="ribbonMeshGroup#", em=1) cmds.hide(bendGroupName) createdMesh = [] for i in curves: polyCreateName = cmds.polyPlane(sx=currentSubdiv_width, sy=currentSubdiv_length) cmds.hyperShade(assign=material) polyName = polyCreateName[0] polyPlaneName = polyCreateName[1] cmds.setAttr(polyName + '.rz', -90) ld.freeze(polyName) bendCreateName = cmds.nonLinear(polyName, type='bend', lowBound=-1, highBound=1, curvature=0) bendName = bendCreateName[0] bendHandleName = bendCreateName[1] curveLength = cmds.arclen(i) curveWarpName = cmds.createCurveWarp(polyName, i) # default value for polyPlane cmds.setAttr(curveWarpName + '.alignmentMode', 4) #align z cmds.setAttr(polyPlaneName + '.height', curveLength) #max length sliderList = LDRibbonTools_getSliderList() attrAddList = sliderList['attrName'] minValue = sliderList['minValue'] maxValue = sliderList['maxValue'] softMinValue = sliderList['softMinValue'] softMaxValue = sliderList['softMaxValue'] precision = sliderList['precision'] defaultValue = sliderList['value'] for index in range(len(sliderList['attrName'])): attributeType = 'long' if precision[index] == 0 else 'double' cmds.addAttr(polyName, ln=attrAddList[index], min=minValue[index], smn=softMinValue[index], max=maxValue[index], smx=softMaxValue[index], at=attributeType, dv=defaultValue[index], k=1) cmds.addAttr(polyName, ln="twistReverse", min=0, max=1, at="long", dv=0, k=1) cmds.addAttr(polyName, ln="curvature", min=-180, max=180, at="long", dv=0, k=1) polyTwistReverse = polyName + '.twistReverse' cmds.scriptJob(ro=0, ac=[ polyTwistReverse, 'LDRibbonTools_ribbon_updateTwistReverse("' + polyName + '","' + curveWarpName + '")' ]) LDRibbonTools_scriptJob_twistReverse = 'cmds.scriptJob(ro=0, ac=["' + polyTwistReverse + '", \'LDRibbonTools_ribbon_updateTwistReverse("' + polyName + '","' + curveWarpName + '")\'])' cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_twistReverse, n="ldCurveWarpScriptNode#", stp="python") cmds.connectAttr(polyName + '.flip', curveWarpName + '.flipAxis') cmds.expression(s=curveWarpName + ".maxScale" + '=' + polyName + ".widthScale*2") cmds.expression(s=curveWarpName + ".lengthScale" + '=' + polyName + ".lengthScale/100") cmds.expression(s=curveWarpName + ".offset" + '=' + polyName + ".offset/100") cmds.connectAttr(polyName + '.rotation', curveWarpName + '.rotation') cmds.connectAttr(polyName + '.curvature', bendName + '.curvature') polyTwistRotation = polyName + '.twistRotation' cmds.scriptJob(ro=0, ac=[ polyTwistRotation, 'LDRibbonTools_ribbon_updateTwistRotation("' + polyName + '","' + curveWarpName + '")' ]) LDRibbonTools_scriptJob_twistRotation = 'cmds.scriptJob(ro=0, ac=["' + polyTwistRotation + '", \'LDRibbonTools_ribbon_updateTwistRotation("' + polyName + '","' + curveWarpName + '")\'])' cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_twistRotation, n="ldCurveWarpScriptNode#", stp="python") cmds.setAttr(curveWarpName + '.twistCurve[0].twistCurve_Value', 0.001) cmds.setAttr(curveWarpName + '.twistCurve[3].twistCurve_Value', 0.999) polySubdivLength = polyName + '.subdivLength' polySubdivWidth = polyName + '.subdivWidth' polyPlaneSubdivLength = polyPlaneName + '.subdivisionsHeight' polyPlaneSubdivWidth = polyPlaneName + '.subdivisionsWidth' cmds.scriptJob(ro=0, ac=[ polySubdivLength, 'LDRibbonTools_ribbon_updateSubdiv("' + polyName + '","' + polyPlaneName + '")' ]) cmds.scriptJob(ro=0, ac=[ polySubdivWidth, 'LDRibbonTools_ribbon_updateSubdiv("' + polyName + '","' + polyPlaneName + '")' ]) LDRibbonTools_scriptJob_subdivLength = 'cmds.scriptJob(ro=0, ac=["' + polySubdivLength + '", \'LDRibbonTools_ribbon_updateSubdiv("' + polyName + '","' + polyPlaneName + '")\'])' LDRibbonTools_scriptJob_subdivWidth = 'cmds.scriptJob(ro=0, ac=["' + polySubdivWidth + '", \'LDRibbonTools_ribbon_updateSubdiv("' + polyName + '","' + polyPlaneName + '")\'])' cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_subdivLength, n="ldCurveWarpScriptNode#", stp="python") cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_subdivWidth, n="ldCurveWarpScriptNode#", stp="python") polyTwistStartPos = polyName + '.twistStartPos' polyTwistStartValue = polyName + '.twistStartValue' curveTwistStartPos1 = curveWarpName + '.twistCurve[1].twistCurve_Position' curveTwistStartPos2 = curveWarpName + '.twistCurve[2].twistCurve_Position' curveTwistStartValue1 = curveWarpName + '.twistCurve[1].twistCurve_Value' curveTwistStartValue2 = curveWarpName + '.twistCurve[2].twistCurve_Value' cmds.scriptJob(ro=0, ac=[ polyTwistStartPos, 'LDRibbonTools_setAttr("' + curveTwistStartPos1 + '","' + polyTwistStartPos + '",0.01)' ]) cmds.scriptJob(ro=0, ac=[ polyTwistStartPos, 'LDRibbonTools_setAttr("' + curveTwistStartPos2 + '","' + polyTwistStartPos + '",0.01)' ]) cmds.scriptJob(ro=0, ac=[ polyTwistStartValue, 'LDRibbonTools_setAttr("' + curveTwistStartValue1 + '","' + polyTwistStartValue + '",0.01)' ]) cmds.scriptJob(ro=0, ac=[ polyTwistStartValue, 'LDRibbonTools_setAttr("' + curveTwistStartValue2 + '","' + polyTwistStartValue + '",0.01)' ]) LDRibbonTools_scriptJob_twistStartPos1 = 'cmds.scriptJob(ro=0, ac=["' + polyTwistStartPos + '", \'LDRibbonTools_setAttr("' + curveTwistStartPos1 + '","' + polyTwistStartPos + '",0.01)\'])' LDRibbonTools_scriptJob_twistStartPos2 = 'cmds.scriptJob(ro=0, ac=["' + polyTwistStartPos + '", \'LDRibbonTools_setAttr("' + curveTwistStartPos2 + '","' + polyTwistStartPos + '",0.01)\'])' LDRibbonTools_scriptJob_twistStartValue1 = 'cmds.scriptJob(ro=0, ac=["' + polyTwistStartValue + '", \'LDRibbonTools_setAttr("' + curveTwistStartValue1 + '","' + polyTwistStartValue + '",0.01)\'])' LDRibbonTools_scriptJob_twistStartValue2 = 'cmds.scriptJob(ro=0, ac=["' + polyTwistStartValue + '", \'LDRibbonTools_setAttr("' + curveTwistStartValue2 + '","' + polyTwistStartValue + '",0.01)\'])' cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_twistStartPos1, n="ldCurveWarpScriptNode#", stp="python") cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_twistStartPos2, n="ldCurveWarpScriptNode#", stp="python") cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_twistStartValue1, n="ldCurveWarpScriptNode#", stp="python") cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_twistStartValue2, n="ldCurveWarpScriptNode#", stp="python") polyScaleRoot = polyName + '.scaleRoot' polyScaleTip = polyName + '.scaleTip' curveScaleRoot = curveWarpName + '.scaleCurve[0].scaleCurve_Value' curveScaleTip = curveWarpName + '.scaleCurve[3].scaleCurve_Value' cmds.scriptJob(ro=0, ac=[ polyScaleRoot, 'LDRibbonTools_setAttr("' + curveScaleRoot + '","' + polyScaleRoot + '",0.01)' ]) cmds.scriptJob(ro=0, ac=[ polyScaleTip, 'LDRibbonTools_setAttr("' + curveScaleTip + '","' + polyScaleTip + '",0.01)' ]) LDRibbonTools_scriptJob_scaleRoot = 'cmds.scriptJob(ro=0, ac=["' + polyScaleRoot + '", \'LDRibbonTools_setAttr("' + curveScaleRoot + '","' + polyScaleRoot + '",0.01)\'])' LDRibbonTools_scriptJob_scaleTip = 'cmds.scriptJob(ro=0, ac=["' + polyScaleTip + '", \'LDRibbonTools_setAttr("' + curveScaleTip + '","' + polyScaleTip + '",0.01)\'])' cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_scaleRoot, n="ldCurveWarpScriptNode#", stp="python") cmds.scriptNode(st=2, bs=LDRibbonTools_scriptJob_scaleTip, n="ldCurveWarpScriptNode#", stp="python") # edit uv LDRibbonTools_ribbon_recoverUV(polyName, cornerVtx_uv, currentSubdiv_width, currentSubdiv_length) # group closure LDRibbonTools_movePivotToCurve0() cmds.parent(polyName, groupName) cmds.parent(bendHandleName, bendGroupName) createdMesh.append(polyName) cmds.select(createdMesh, r=1)
def publish(self, settings, item): """ Executes the publish logic for the given item and settings. Any raised exceptions will indicate that the publish pass has failed and the publisher will stop execution. :param dict settings: The keys are strings, matching the keys returned in the :data:`settings` property. The values are :class:`~.processing.Setting` instances. :param item: The :class:`~.processing.Item` instance to validate. """ publisher = self.parent # self.logger.debug("ppcontext:----%s----" % item.context) # self.logger.debug("pptask:----%s----" % item.context.task) # get the path to create and publish publish_path = item.properties["path"] # ensure the publish folder exists: publish_folder = os.path.dirname(publish_path) publisher.ensure_folder_exists(publish_folder) mesh_object = item.properties["object"] # now just export shaders for this item to the publish path. there's # probably a better way to do this. shading_groups = set() shad_group_to_obj = {} def_shader = "initialShadingGroup" # print "mesh:",mesh_object if cmds.ls(mesh_object, dag=True, type="mesh"): faces = cmds.polyListComponentConversion(mesh_object, toFace=True) for face in faces: _groups = cmds.listSets(type=1, object=face) if not _groups: current_object = face.split(".")[0] cmds.select(current_object, r=True) cmds.hyperShade(assign=def_shader) _groups = [def_shader] for shading_group in _groups: shading_groups.add(shading_group) element = cmds.listAttr("%s.dagSetMembers" % (shading_group), m=True) # dagSetMembers[0],dagSetMembers[1] for ele in element: connection_obj = cmds.listConnections("%s.%s" % (shading_group, ele)) if not connection_obj: continue for obj in connection_obj: long_name = cmds.ls(obj, l=True)[0] shad_group_to_obj.setdefault(shading_group, set()).add(long_name) # print "group:",shad_group_to_obj shaders = set() script_nodes = [] for shading_group in list(shading_groups): connections = cmds.listConnections( shading_group, source=True, destination=False ) for shader in cmds.ls(connections, materials=True): # print "shader:", shader shaders.add(shader) objects = list(shad_group_to_obj[shading_group]) for obj in objects: # get rid of namespacing if obj.startswith("|"): obj = obj[1:] # get real name name = [] sp_name_space = obj.split("|") for ns in sp_name_space: name.append(ns.split(":")[-1]) obj_parts = '|'.join(name) script_node_name = "SHADER_HOOKUP_" + obj_parts#[-1] script_node = cmds.scriptNode( name=script_node_name, scriptType=0, # execute on demand. beforeScript=shader, ) # print "script_node:",script_node script_nodes.append(script_node) if not shaders: self.logger.debug("No shader network found to export and publish.") return select_nodes = list(shaders) select_nodes.extend(script_nodes) cmds.select(select_nodes, replace=True) self.logger.debug("shader_node:%s"%select_nodes) # write .ma file to the publish path with the shader network definitions cmds.file( publish_path, type='mayaAscii', exportSelected=True, options="v=0", prompt=False, force=True ) # clean up shader hookup nodes. they should exist in publish file only _clean_shader_hookup_script_nodes() # set the publish type in the item's properties. the base plugin will # use this when registering the file with Shotgun item.properties["publish_type"] = "Maya Shader Network" # Now that the path has been generated, hand it off to the base publish # plugin to do all the work to register the file with SG super(MayaShaderPublishPlugin, self).publish(settings, item)
def add_file_to_maya(self, file_path, shotgun_data): """ Load file into Maya. This implementation creates a standard maya reference file for any item. """ import pymel.core as pm import maya.cmds as cmds # get the slashes right file_path = file_path.replace(os.path.sep, "/") debug(app = None, method = 'add_file_to_maya', message = 'file_path: %s' % file_path, verbose = False) #file_path: I:/lsapipeline/episodes/eptst/eptst_sh2000/Anm/publish/maya/eptstsh2000.v002.mb file_version = int(file_path.split('.')[1].split('v')[-1]) debug(app = None, method = 'add_file_to_maya', message = 'file_version: %s' % file_version, verbose = False) (path, ext) = os.path.splitext(file_path) if ext in [".ma", ".mb"]: ## Open the blocking file cmds.file(file_path, o = True, f = True) ## Cleanup unknown nodes to make sure we can save from mb back to ma for each in cmds.ls(): if cmds.nodeType(each) == 'unknown': cmds.delete(each) ## Build the script node for the FX app.py to use as the current version number of the oceanPreset if not cmds.objExists('fxNugget'): cmds.scriptNode(n ='fxNugget') cmds.addAttr('fxNugget', ln = 'animVersion', at = 'long') cmds.setAttr('fxNugget.animVersion', file_version) ## Save the animation file as the next working file in the FX folder tk = sgtk.sgtk_from_path("T:/software/bubblebathbay") getEntity = shotgun_data['entity'] shotName = getEntity['name'] work_template = tk.templates['shot_work_area_maya'] pathToWorking = r'%s' % tk.paths_from_template(work_template, {"Shot" : shotName, "Step":'FX'})[0] pathToWorking.replace('\\\\', '\\') debug(app = None, method = 'add_file_to_maya', message = 'pathToWorking: %s' % pathToWorking, verbose = False) ## Scan the folder and find the highest version number fileShotName = "".join(shotName.split('_')) padding = '' versionNumber = '' if os.path.exists(pathToWorking): getfiles = os.listdir(pathToWorking) ## Remove the stupid Keyboard folder if it exists.. thx autodesk.. not if 'Keyboard' in getfiles: getfiles.remove('Keyboard') ## Process a clean list now.. trying to remove from the current list is giving me grief and I'm too fn tired to care... finalFiles = [] for each in getfiles: if each.split('.')[0] == fileShotName: finalFiles.append(each) else: pass if finalFiles: highestVersFile = max(finalFiles) versionNumber = int(highestVersFile.split('.')[1].split('v')[1]) + 1 else: versionNumber = 1 ## Now pad the version number if versionNumber < 10: padding = '00' elif versionNumber < 100: padding = '0' else: padding = '' ## Rename the file #print 'FinalFilePath: %s\%s.v%s%s' % (pathToWorking, fileShotName, padding, versionNumber) renameTo = '%s\%s.v%s%s' % (pathToWorking, fileShotName, padding, versionNumber) ## Now rename the file cmds.file(rename = renameTo) ## Now save this as a working version in the animation working folder cmds.file(save = True, force = True, type = 'mayaAscii') cmds.workspace(pathToWorking, openWorkspace = True) cleanup.turnOnModelEditors() else: self.parent.log_error("Unsupported file extension for %s! Nothing will be loaded." % file_path)
def publish(self, settings, item): """ Executes the publish logic for the given item and settings. Any raised exceptions will indicate that the publish pass has failed and the publisher will stop execution. :param dict settings: The keys are strings, matching the keys returned in the :data:`settings` property. The values are :class:`~.processing.Setting` instances. :param item: The :class:`~.processing.Item` instance to validate. """ publisher = self.parent # get the path to create and publish publish_path = item.properties["path"] # ensure the publish folder exists: publish_folder = os.path.dirname(publish_path) publisher.ensure_folder_exists(publish_folder) mesh_objects = item.properties["object"] select_nodes = [] for mesh_object in mesh_objects: # now just export shaders for this item to the publish path. there's # probably a better way to do this. try: shading_groups = set() shad_group_to_obj = {} if cmds.ls(mesh_object, dag=True, type="mesh"): faces = cmds.polyListComponentConversion(mesh_object, toFace=True) for shading_group in cmds.listSets(type=1, object=faces[0]): shading_groups.add(shading_group) shad_group_to_obj[shading_group] = mesh_object shaders = set() script_nodes = [] for shading_group in list(shading_groups): connections = cmds.listConnections(shading_group, source=True, destination=False) for shader in cmds.ls(connections, materials=True): shaders.add(shader) obj_name = shad_group_to_obj[shading_group] # get rid of namespacing obj_parts = obj_name.split(":") # can't seem to store arbitrary data in maya in any # reasonable way. would love to know a better way to # do this. for now, just create a script node that # we can easily find and deduce an object name and # shader name. Yes, this is hacky. script_node_name = "SHADER_HOOKUP_" + obj_parts[-1] script_node = cmds.scriptNode( name=script_node_name, scriptType=0, # execute on demand. beforeScript=shader, ) script_nodes.append(script_node) if not shaders: pass #self.logger.debug("No shader network found to export and publish.") select_nodes.extend(shaders) select_nodes.extend(script_nodes) except: print("Error") cmds.select(clear=True) for seln in select_nodes: cmds.select(seln, add=True) # write .ma file to the publish path with the shader network definitions cmds.file(publish_path, type='mayaBinary', exportSelected=True, options="v=0", prompt=False, force=True) # clean up shader hookup nodes. they should exist in publish file only _clean_shader_hookup_script_nodes() # set the publish type in the item's properties. the base plugin will # use this when registering the file with Shotgun item.properties["publish_type"] = "Maya Shader Network" # Now that the path has been generated, hand it off to the base publish # plugin to do all the work to register the file with SG super(MayaShaderPublishPlugin, self).publish(settings, item)
(indent3 + 'setAttr ' + ikCN + '.rotateZ ' + '$ikLocRotateZ;') + '\n' + (indent3 + 'setAttr ' + ikCN + '.visibility' + ' 1;') + '\n' + (indent3 + 'setAttr ' + pvNN + '.visibility' + ' 1;') + '\n' + (indent3 + 'setAttr ' + jL[2] + '_ctl.visibility' + ' 0;') + '\n' + (indent3 + 'setAttr ' + jL[1] + '_ctl.visibility' + ' 0;') + '\n' + (indent3 + 'setAttr ' + jL[0] + '_ctl.visibility' + ' 0;') + '\n' + (indent3 + 'setAttr ' + (sA[3] + '.constraints') + ' 1;') + '\n' + (indent2 + '}') + '\n' +('}')) #thats the end of this string #the connecting expression eN3 = (locPre + '_ik_fk_switch') fkIkES = ( 'int $index = ` scriptJob - attributeChange "' + sAttr1 + '" "' + sN + '" `;') #end of this string #then lets make them #well go in order the strings were made above cmds.expression(s = constraintsES, n = eN1) cmds.scriptNode(bs = globalProcES, n = eN2, stp ='mel') cmds.expression(s = fkIkES, n = eN3) ## ##THIS MIGHT BE DONE NOW THATS LEFT IS TO TEST IT OUT AND DEBUGG ##
def __publish_maya_shader_network(self, item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb): """ Publish shader networks for the asset and register with Shotgun. :param item: The item to publish :param output: The output definition to publish with :param work_template: The work template for the current scene :param primary_publish_path: The path to the primary published file :param sg_task: The Shotgun task we are publishing for :param comment: The publish comment/description :param thumbnail_path: The path to the publish thumbnail :param progress_cb: A callback that can be used to report progress """ # determine the publish info to use # progress_cb(10, "Determining publish details") # get the current scene path and extract fields from it # using the work template: scene_path = os.path.abspath(cmds.file(query=True, sn=True)) fields = work_template.get_fields(scene_path) publish_version = fields["version"] tank_type = output["tank_type"] obj_name = item['name'] fields['obj_name'] = obj_name fields['name'] = re.sub(r'[\W_]+', '', obj_name) # create the publish path by applying the fields # with the publish template: publish_template = output["publish_template"] publish_path = publish_template.apply_fields(fields) # ensure the publish folder exists: publish_folder = os.path.dirname(publish_path) self.parent.ensure_folder_exists(publish_folder) # determine the publish name: publish_name = fields.get("obj_name") if not publish_name: publish_name = os.path.basename(publish_path) # Find additional info from the scene: # progress_cb(10, "Analysing scene") # clean up any hookup nodes that existed before _clean_shader_hookup_script_nodes() # there's probably a better way to do this. i am jon snow (i know # nothing) shading_groups = set() shad_group_to_obj = {} if cmds.ls(obj_name, dag=True, type="mesh"): faces = cmds.polyListComponentConversion(obj_name, toFace=True) for shading_group in cmds.listSets(type=1, object=faces[0]): shading_groups.add(shading_group) shad_group_to_obj[shading_group] = obj_name shaders = set() script_nodes = [] for shading_group in list(shading_groups): connections = cmds.listConnections( shading_group, source=True, destination=False) for shader in cmds.ls(connections, materials=True): shaders.add(shader) obj_name = shad_group_to_obj[shading_group] # can't seem to store arbitrary data in maya in any # reasonable way. would love to know a better way to # do this. for now, just create a script node that # we can easily find and deduce an object name and # shader name. Yes, this is hacky. script_node = cmds.scriptNode( name="SHADER_HOOKUP_" + obj_name, scriptType=0, # execute on demand. beforeScript=shader, ) script_nodes.append(script_node) if not shaders: progress_cb(100, "No shader networks to export.") return select_nodes = list(shaders) #select_nodes.extend(list(shading_groups)) select_nodes.extend(script_nodes) cmds.select(select_nodes, replace=True) # write a .ma file to the publish path with the shader network definitions progress_cb(25, "Exporting the shader network.") cmds.file( publish_path, type='mayaAscii', exportSelected=True, options="v=0", prompt=False, force=True ) # clean up shader hookup nodes. they should exist in the publish file # only. _clean_shader_hookup_script_nodes() # register the publish: progress_cb(75, "Registering the publish") args = { "tk": self.parent.tank, "context": self.parent.context, "comment": comment, "path": publish_path, "name": publish_name, "version_number": publish_version, "thumbnail_path": thumbnail_path, "task": sg_task, "dependency_paths": [primary_publish_path], "published_file_type":tank_type } tank.util.register_publish(**args)
def dynamicParent(): sel = cmds.ls(sl=1) locatorList = [] for i in xrange(len(sel)-1): locator = cmds.spaceLocator(n=sel[i] + '_Loc') cmds.delete(cmds.parentConstraint(sel[i], locator, mo=0)) cmds.parent(locator, sel[i]) locatorList.append(locator) DPGroup = cmds.group(n=sel[-1] + '_DPGrp', empty=1) cmds.delete(cmds.parentConstraint(sel[-1], DPGroup, mo=0)) pcGroup = cmds.group(n=sel[-1] + '_pcDPGrp', empty=1) cmds.delete(cmds.parentConstraint(sel[-1], pcGroup, mo=0)) cmds.parent(pcGroup, DPGroup) cmds.parent(sel[-1], pcGroup) newList = [] for i in locatorList: newList.append(i[0]) newList.insert(0, DPGroup) cmds.select(cl=1) for i in xrange(len(newList)): cmds.parentConstraint(newList[i], pcGroup, mo=0) parentConstraint = cmds.listRelatives(pcGroup, s=0, c=1, p=0, type='parentConstraint')[0] enumStr = ':'.join(newList) # add Attr cmds.addAttr(sel[-1], ln='Parent', at='enum', en=enumStr, k=1) for i in xrange(len(newList)): cmds.setAttr(parentConstraint + '.' + newList[i] + 'W' + str(i), 0) codeStr = '''import maya.cmds as cmds def dynamicParentSwitch(): constraintObj = '{0}' parentConstraint = '{1}' newList = {2} index = cmds.getAttr(constraintObj + '.Parent') wst = cmds.xform(constraintObj, q=1, ws=1, t=1) wsr = cmds.xform(constraintObj, q=1, ws=1, ro=1) cmds.setAttr(parentConstraint + '.' + newList[index] + 'W' + str(index), 1) for i in xrange(len(newList)): if i == index: continue else: cmds.setAttr(parentConstraint + '.' + newList[i] + 'W' + str(i), 0) cmds.xform(constraintObj, ws=1, t=wst) cmds.xform(constraintObj, ws=1, ro=wsr) cmds.scriptJob(attributeChange=['{3}' + '.Parent', dynamicParentSwitch]) '''.format(sel[-1], parentConstraint, newList, sel[-1]) nodeName = cmds.scriptNode(st=2, bs=codeStr.replace("'''", "''"), n='DynamicParent_#', stp='python') cmds.scriptNode(nodeName, executeBefore=1)
def addDriverByParForWrapedTFNode(tfGrp): '''{'del_path':'TfCtrl/Add/Group/addDriverByParForWrapedTFNode(cmds.ls(sl=True)[0])', 'usage':'$fun(cmds.ls(sl=True)[0])', } ''' #get tfNodeGrp cmds.lockNode(tfGrp, l=False) if cmds.attributeQuery('shellPoly', n=tfGrp, exists=True) == False: raise IOError('This is not tfGrp object') else: shellPoly = cmds.getAttr('%s.shellPoly' % (tfGrp)) if cmds.attributeQuery('nParShapeNode', n=tfGrp, exists=True) == False: cmds.addAttr(tfGrp, ln="nParShapeNode", dt="string") else: raise IOError('%s object has a nParShapeNode to control it') tfNodeGrp = tfGrp #print '%s, %s'%(shellPoly, tfNodeGrp) tfNodeGrpVarStr = tfNodeGrp.replace('|', '__') objects = cmds.listRelatives(tfNodeGrp, type='transform', f=True) cmds.lockNode([shellPoly, tfNodeGrp], l=False) ####################create and set nParticle etc.###################################### #create nParticle nPar = cmds.nParticle(n='%s_nPar' % (tfNodeGrp)) cmds.setAttr(nPar[0] + '.t', l=True) cmds.setAttr(nPar[0] + '.r', l=True) cmds.setAttr(nPar[0] + '.s', l=True) cmds.lockNode(nPar[0], l=True) nParShape = nPar[1] #setAttr to get_tfGrpNode cmds.setAttr(tfNodeGrp + '.nParShapeNode', nParShape, type='string', l=True) cmds.lockNode([shellPoly, tfNodeGrp], l=True) cmds.setAttr('%s.computeRotation' % (nParShape), 1) cmds.goal(nParShape, g=shellPoly, w=.99) #set attributes cmds.setAttr(nParShape + '.goalSmoothness', .01) cmds.setAttr(nParShape + '.radius', .01) #add attributes cmds.addAttr(nParShape, ln="cus_toObjPos", dt='doubleArray') cmds.addAttr(nParShape, ln="cus_toObjPos0", dt='doubleArray') #Add particles and set attributes(goalU, goalV, cus_bbsiRadius) initialize states posLi, radiusLi, atULi, atVLi = [], [], [], [] for tfNode in objects: objPos = cmds.objectCenter(tfNode) bbsize = cmds.getAttr(tfNode + '.bbsi')[0] radius = vectorLen(bbsize) / 2 atU = cmds.getAttr(tfNode + '.atU') atV = cmds.getAttr(tfNode + '.atV') posLi.append(objPos) radiusLi.append(radius) atULi.append(atU) atVLi.append(atV) qsEmit(object = nParShape, position=posLi, attributes=( ('cus_radiusPP', 'floatValue', radiusLi), ('goalU', 'floatValue', atULi),\ ('goalV', 'floatValue', atVLi) )\ ) ##creation expression #parCExpStr = cmds.dynExpression(nParShape, q=True,s=True, c=True) parCExpStr = '\n\n\ /*string $tfNode = $%s[int(particleId)];\n\ goalU = `getAttr ($tfNode+".atU")`;\n\ goalV = `getAttr ($tfNode+".atV")`;\n\ cus_toObjPos = 0;*/' % (tfNodeGrpVarStr) cmds.dynExpression(nParShape, s=parCExpStr, c=True) ##runtime after dynamics expression #parRADExpStr = cmds.dynExpression(nParShape, q=True, s=True, rad=True) parRADExpStr = '\n\n\ /*string $tfNode = $%s[int(particleId)];\n\n\ \ if (cus_toObjPos == 1){\n\ float $pos[] = position;\n\ vector $rotate = rotationPP;\n\ setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\ setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\ }\n\n\ \ \ if (goalPP==0 && cus_toObjPos==0){\n\ cus_toObjPos = 1;\n\ float $pos[] = `getAttr ($tfNode+".translate")`;\n\ position = <<$pos[0], $pos[1], $pos[2]>>;\n\ vector $rotate = rotationPP;\n\ setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\ setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\ setAttr ($tfNode+".pBWeight") 1;\n\ setAttr ($tfNode+".follicleNodeState") 2;\n\ }*/' % (tfNodeGrpVarStr) cmds.dynExpression(nParShape, s=parRADExpStr, rad=True) ######################################create script nodes######################################## ####openCloseMel script node Execute On:Open/close openCloseMelStr = '\n\n\ ///////////for TFNode by Particles/////////////////////\n\ global string $%s[];\n\ $%s = `listRelatives -f "%s"`;\n' % (tfNodeGrpVarStr, tfNodeGrpVarStr, tfNodeGrp) mel.eval(openCloseMelStr) if cmds.objExists("QS_VFX_M_OC"): existsStr = cmds.scriptNode('QS_VFX_M_OC', q=True, bs=True) openCloseMelStr += existsStr cmds.scriptNode('QS_VFX_M_OC', e=True, bs=openCloseMelStr) else: cmds.scriptNode(n='QS_VFX_M_OC', scriptType=1, bs=openCloseMelStr, sourceType='mel') cmds.setAttr('QS_VFX_M_OC.scriptType', l=True) ####timeChangedMel script Node Execute on: Time changed timeChangedMelStr = '\n\n\ ///////////for TFNode by Particles/////////////////////\n\ int $current = `currentTime -q`;\n\ int $start = `playbackOptions -q -min`;\n\ if ($current == $start){\n\ //%s is a global variable, Declare in QS_VFX_M_QC script node.\n\ $%s = `listRelatives -type "transform" "%s"`; \n\ for ($tfNode in $%s){\n\ setAttr($tfNode+".follicleNodeState") 0;\n\ setAttr($tfNode+".pBWeight") 0;\n\ }\n\ }' % (tfNodeGrpVarStr, tfNodeGrpVarStr, tfNodeGrp, tfNodeGrpVarStr) mel.eval(timeChangedMelStr) if cmds.objExists("QS_VFX_M_TC"): existsStr = cmds.scriptNode('QS_VFX_M_TC', q=True, bs=True) timeChangedMelStr += existsStr cmds.scriptNode('QS_VFX_M_TC', e=True, bs=timeChangedMelStr) else: cmds.scriptNode(n='QS_VFX_M_TC', scriptType=7, bs=timeChangedMelStr, sourceType='mel') cmds.setAttr('QS_VFX_M_TC.scriptType', l=True)
def addParByTFSet(tfSet=cmds.ls(sl=True, exactType='objectSet')): '''{'del_path':'TfCtrl/Add/Set/addParByTFSet( tfSet = cmds.ls(sl=True, exactType="objectSet") )', 'usage':'$fun( tfSet = cmds.ls(sl=True, exactType="objectSet") )', } ''' #tfSet = cmds.ls(sl=True, type='objectSet')[0] if isinstance(tfSet, list): tfSet = tfSet[0] cmds.lockNode(tfSet, l=False) objects = cmds.listConnections(tfSet + '.dagSetMembers', d=False) createNewPar = True if cmds.attributeQuery( 'setType', n=tfSet, exists=True) and cmds.getAttr(tfSet + '.setType') == 1: raise IOError('This set type is three particle controls!') if cmds.attributeQuery( 'setType', n=tfSet, exists=True) and cmds.attributeQuery( 'posPar', n=tfSet, exists=True) and cmds.objExists( cmds.getAttr(tfSet + '.posPar')): createNewPar = False if createNewPar: for attr in ['posPar', 'aimPar', 'upPar']: if cmds.attributeQuery(attr, n=tfSet, exists=True) and cmds.objExists( cmds.getAttr('%s.%s' % (attr))): cmds.delete(cmds.getAttr('%s.%s' % (attr))) delAttr(tfSet, ['setType', 'posPar', 'aimPar', 'upPar']) cmds.addAttr(tfSet, ln="setType", at="enum", en="singlePar:threePar:", k=False, r=False) cmds.setAttr(tfSet + '.setType', 0, l=True) cmds.addAttr(tfSet, ln="posPar", dt="string") nPar = cmds.nParticle(n='%s_nPar' % (tfSet)) cmds.setAttr(nPar[0] + '.t', l=True) cmds.setAttr(nPar[0] + '.r', l=True) cmds.setAttr(nPar[0] + '.s', l=True) nParShape = nPar[1] cmds.setAttr(tfSet + '.posPar', nParShape, type='string', l=True) cmds.setAttr("%s.computeRotation" % (nParShape), 1) cmds.addAttr(nParShape, ln="cus_toObjPos", dt='doubleArray') cmds.addAttr(nParShape, ln="cus_toObjPos0", dt='doubleArray') else: nParShape = cmds.getAttr(tfSet + '.posPar') cmds.lockNode(nParShape, l=False) #Add particles and set attributes(goalU, goalV, cus_bbsiRadius) initialize states posLi, radiusLi, atULi, atVLi = [], [], [], [] for tfNode in objects: objPos = cmds.objectCenter(tfNode) bbsize = cmds.getAttr(tfNode + '.bbsi')[0] radius = newom.MVector(bbsize).length() / 2 atU = cmds.getAttr(tfNode + '.atU') atV = cmds.getAttr(tfNode + '.atV') posLi.append(objPos) radiusLi.append(radius) atULi.append(atU) atVLi.append(atV) qsEmit(object = nParShape, position=posLi, attributes=( ('cus_radiusPP', 'floatValue', radiusLi), ('goalU', 'floatValue', atULi),\ ('goalV', 'floatValue', atVLi) )\ ) cmds.lockNode(tfSet, l=True) if createNewPar: ##creation expression #parCExpStr = cmds.dynExpression(nParShape, q=True,s=True, c=True) parCExpStr = '\n\n\ /*string $tfNode = $%s[int(particleId)];\n\ goalU = `getAttr ($tfNode+".atU")`;\n\ goalV = `getAttr ($tfNode+".atV")`;\n\ cus_toObjPos = 0;*/' % (tfSet) cmds.dynExpression(nParShape, s=parCExpStr, c=True) ##runtime after dynamics expression #parRADExpStr = cmds.dynExpression(nParShape, q=True, s=True, rad=True) parRADExpStr = '\n\n\ /*string $tfNode = $%s[int(particleId)];\n\n\ \ if (cus_toObjPos == 1){\n\ float $pos[] = position;\n\ vector $rotate = rotationPP;\n\ setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\ setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\ }\n\n\ \ \ if (goalPP==0 && cus_toObjPos==0){\n\ cus_toObjPos = 1;\n\ float $pos[] = `getAttr ($tfNode+".translate")`;\n\ position = <<$pos[0], $pos[1], $pos[2]>>;\n\ vector $rotate = rotationPP;\n\ setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\ setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\ setAttr ($tfNode+".pBWeight") 1;\n\ setAttr ($tfNode+".follicleNodeState") 2;\n\ }*/' % (tfSet) cmds.dynExpression(nParShape, s=parRADExpStr, rad=True) ######################################create script nodes######################################## ####openCloseMel script node Execute On:Open/close openCloseMelStr = '\n\n\ ///////////for TFNode by Particles/////////////////////\n\ global string $%s[];\n\ $%s = `listConnections -d off "%s.dagSetMembers"`;\n' % (tfSet, tfSet, tfSet) mel.eval(openCloseMelStr) if cmds.objExists("QS_VFX_M_OC"): existsStr = cmds.scriptNode('QS_VFX_M_OC', q=True, bs=True) openCloseMelStr += existsStr cmds.scriptNode('QS_VFX_M_OC', e=True, bs=openCloseMelStr) else: cmds.scriptNode(n='QS_VFX_M_OC', scriptType=1, bs=openCloseMelStr, sourceType='mel') cmds.setAttr('QS_VFX_M_OC.scriptType', l=True) ####timeChangedMel script Node Execute on: Time changed timeChangedMelStr = '\n\n\ ///////////for TFNode by Particles/////////////////////\n\ int $current = `currentTime -q`;\n\ int $start = `playbackOptions -q -min`;\n\ if ($current == $start){\n\ //%s is a global variable, Declare in QS_VFX_M_QC script node.\n\ $%s = `listConnections -d off "%s.dagSetMembers"`; \n\ for ($tfNode in $%s){\n\ setAttr($tfNode+".follicleNodeState") 0;\n\ setAttr($tfNode+".pBWeight") 0;\n\ }\n\ }' % (tfSet, tfSet, tfSet, tfSet) mel.eval(timeChangedMelStr) if cmds.objExists("QS_VFX_M_TC"): existsStr = cmds.scriptNode('QS_VFX_M_TC', q=True, bs=True) timeChangedMelStr += existsStr cmds.scriptNode('QS_VFX_M_TC', e=True, bs=timeChangedMelStr) else: cmds.scriptNode(n='QS_VFX_M_TC', scriptType=7, bs=timeChangedMelStr, sourceType='mel') cmds.setAttr('QS_VFX_M_TC.scriptType', l=True)
""" scriptJob and scriptNode example """ import maya.cmds as cmds codeStr = ''' def colorChange(): objAttr = 'pSphere1.Color' if cmds.getAttr(objAttr) == 0: cmds.polyColorPerVertex(r=0.0, g=1.0, b=0.0, a=1.0, cdo=1) elif cmds.getAttr(objAttr) == 1: cmds.polyColorPerVertex(r=0.0, g=0.0, b=1.0, a=1.0, cdo=1) elif cmds.getAttr(objAttr) == 2: cmds.polyColorPerVertex(r=1.0, g=0.0, b=0.0, a=1.0, cdo=1) cmds.scriptJob(attributeChange=['pSphere1.Color', colorChange]) ''' cmds.scriptNode(st=2, bs=codeStr.replace("'''", "''"), n='sphere_ColorChange', stp='python')
def createMDscriptNode(): dsMetaDataScriptNode = cmds.scriptNode( st=1, bs='import dsCommon.dsMetaDataTools as dsMDT;reload(dsMDT);dsMDT.sceneCheck()', n='dsMetaData', stp='python') dsMDCreate() # creates sequence level attr's createShotAttrs() updatedsMD()