def EvalDeferred(boundMethod, *args, **kwargs): """ Runs the given method but deferred to the end of the current run loop iteration, as opposed to being executed immediately. Should be used instead of PyMel's 'evalDeferred' method. A typical use would be a UI component that wants to delete itself - where doing so immediately would put the currently executing code in invalid memory. This nasty little piece of hackery is necessary because the Pymel version of evalDeferred is not usable from a object-oriented environment - all you get is a string literal to be executed from within the main module. As such, this is the only way to provided the same functionality for bound methods from within modules and classes (Method adds this module to main, then evaluates bound methods via _MakeDeferredEvaluations). :param boundMethod: bound method to be run deferred; will be passed any provided 'args' and 'kwargs' arguments. """ global __DeferredEvaluationsQueue__ global __ModuleHandle__ global __DeferredEvaluationMethodString__ if not callable(boundMethod): raise TypeError('Non-callable object "%s" passed to EvalDeferred.' % boundMethod) else: if not __DeferredEvaluationsQueue__: importString = ( 'if("%s" not in globals()): globals()["%s"] = ' '__import__("%s", globals(), locals(), ["%s"], -1)' % (__ModuleHandle__, __ModuleHandle__, __name__, __name__) ) pm.evalDeferred(importString) pm.evalDeferred(__DeferredEvaluationMethodString__) __DeferredEvaluationsQueue__.append((boundMethod, args, kwargs))
def _kill_scriptjobs(self): """Removes this widget's current scriptjobs.""" for i in self._scriptjobs: pmc.evalDeferred( "if pmc.scriptJob(ex={0}):" " pmc.scriptJob(kill={0}, force=True)".format(i) )
def exportSelectionAsABC(): # check for AbcExport command if not 'AbcExport' in dir(pm): pm.error('AbcExport: command not found.') return # retrieve all selected node paths selection = pm.ls(sl=True, recursive=True, dagObjects=True) if not selection: return nodePathtoExport = [] for n in selection: if n.type() != 'transform': nodePathtoExport.append(n.getParent().fullPath()) # get out file path from user outfile = pm.fileDialog2(fileMode=0) if not outfile: return # ensure we use a '*.abc' file extension outfile = os.path.splitext(outfile[0])[0]+'.abc' # build the AbcExport command exportCmd = '-worldSpace -attr mvg_imageSourcePath -attr mvg_intrinsicParams -file %s -uvWrite'%outfile for p in nodePathtoExport: exportCmd += ' -root %s'%p exportCmd = ''' import pymel.core as pm pm.AbcExport(j="%s")'''%exportCmd pm.evalDeferred(exportCmd)
def registerRenderer(self): log.debug("registerRenderer") self.unRegisterRenderer() self.registerNodeExtensions() self.registerAETemplateCallbacks() pm.renderer(self.rendererName, rendererUIName=self.rendererName) pm.renderer(self.rendererName, edit=True, renderProcedure=self.makeMelProcFromPythonCmd(self.renderProcedure, [('int', 'width'), ('int', 'height'), ('int', 'doShadows'), ('int', 'doGlow'), ('string', 'camera'), ('string', 'options')])) pm.renderer(self.rendererName, edit=True, batchRenderProcedure=self.makeMelProcFromPythonCmd(self.batchRenderProcedure, [('string', 'options')])) pm.renderer(self.rendererName, edit=True, commandRenderProcedure=self.makeMelProcFromPythonCmd(self.batchRenderProcedure, [('string', 'options')])) # pm.renderer(self.rendererName, edit=True, batchRenderProcedure=self.renderCallback("batchRenderProcedure")) # pm.renderer(self.rendererName, edit=True, commandRenderProcedure=self.renderCallback("commandRenderProcedure")) pm.renderer(self.rendererName, edit=True, batchRenderOptionsProcedure=self.renderCallback("batchRenderOptionsProcedure")) pm.renderer(self.rendererName, edit=True, batchRenderOptionsStringProcedure=self.renderCallback("batchRenderOptionsStringProcedure")) pm.renderer(self.rendererName, edit=True, addGlobalsNode="defaultRenderGlobals") pm.renderer(self.rendererName, edit=True, addGlobalsNode="defaultResolution") pm.renderer(self.rendererName, edit=True, addGlobalsNode=self.renderGlobalsNodeName) pm.renderer(self.rendererName, edit=True, startIprRenderProcedure=self.makeMelProcFromPythonCmd(self.startIprRenderProcedure, [('string', 'editor'), ('int', 'resolutionX'), ('int', 'resolutionY'), ('string', 'camera')])) pm.renderer(self.rendererName, edit=True, stopIprRenderProcedure=self.makeMelProcFromPythonCmd(self.stopIprRenderProcedure, [])) pm.renderer(self.rendererName, edit=True, pauseIprRenderProcedure=self.makeMelProcFromPythonCmd(self.pauseIprRenderProcedure, [('string', 'editor'), ('int', 'pause')])) pm.renderer(self.rendererName, edit=True, changeIprRegionProcedure=self.renderCallback("changeIprRegionProcedure")) pm.renderer(self.rendererName, edit=True, iprOptionsProcedure=self.renderCallback("iprOptionsProcedure")) pm.renderer(self.rendererName, edit=True, iprOptionsMenuLabel=self.renderCallback("iprOptionsMenuLabel")) pm.renderer(self.rendererName, edit=True, iprRenderProcedure=self.renderCallback("iprRenderProcedure")) pm.renderer(self.rendererName, edit=True, iprRenderSubMenuProcedure=self.renderCallback("iprRenderSubMenuProcedure")) pm.renderer(self.rendererName, edit=True, isRunningIprProcedure=self.renderCallback("isRunningIprProcedure")) pm.renderer(self.rendererName, edit=True, refreshIprRenderProcedure=self.renderCallback("refreshIprRenderProcedure")) #pm.renderer(self.rendererName, edit=True, logoCallbackProcedure=self.renderCallback("logoCallbackProcedure")) pm.renderer(self.rendererName, edit=True, logoImageName=self.rendererName + ".png") pm.renderer(self.rendererName, edit=True, renderDiagnosticsProcedure=self.renderCallback("renderDiagnosticsProcedure")) pm.renderer(self.rendererName, edit=True, renderOptionsProcedure=self.renderCallback("renderOptionsProcedure")) pm.renderer(self.rendererName, edit=True, cancelBatchRenderProcedure=self.renderCallback("cancelBatchRenderProcedure")) pm.renderer(self.rendererName, edit=True, showBatchRenderProcedure=self.renderCallback("showBatchRenderProcedure")) pm.renderer(self.rendererName, edit=True, showRenderLogProcedure=self.renderCallback("showRenderLogProcedure")) pm.renderer(self.rendererName, edit=True, showBatchRenderLogProcedure=self.renderCallback("showBatchRenderLogProcedure")) pm.renderer(self.rendererName, edit=True, textureBakingProcedure=self.renderCallback("textureBakingProcedure")) #pm.renderer(self.rendererName, edit=True, renderingEditorsSubMenuProcedure=self.renderCallback("renderingEditorsSubMenuProcedure")) pm.renderer(self.rendererName, edit=True, renderRegionProcedure="mayaRenderRegion") scriptDir = path.path(__file__).dirname().parent #os.environ['MAYA_SCRIPT_PATH'] = "{0};{1}".format(scriptDir, os.environ['MAYA_SCRIPT_PATH']) pm.mel.source('createMayaSoftwareCommonGlobalsTab') pm.mel.source("unifiedRenderGlobalsWindow") self.defineCommonMelProcedures() pm.evalDeferred(self.addTabs) log.debug("RegisterRenderer done")
def evalDeferred_playblast(self,fileName,width,height,fp): try: pm.evalDeferred( 'pm.playblast(format="iff",sequenceTime=0,clearCache=1,viewer=0,\ showOrnaments=1,fp='+str(fp)+',percent=100,compression="jpg",\ widthHeight=('+str(width)+','+str(height)+'),\ forceOverwrite=1,quality=100,filename=\"' + fileName + '\")' ) except: self.Log.error('evalDeferred_playblast error') self.Log.error(traceback.format_exc())
def open(): # pm.mel.eval('renderThumbnailUpdate 0') # pm.mel.eval('EnableAll') # pm.currentUnit(l='centimeter',time='film') loadPluginCmd = ['from cgmaya.general import plugin'] loadPluginCmd.append('plugin.loadPlugin("AbcImport")') loadPluginCmd.append('plugin.loadPlugin("mtoa")') pm.evalDeferred(';'.join(loadPluginCmd))
def wrapper(*args, **kwargs): # NOTE 加载 turtle 插件 if not pm.pluginInfo("Turtle", q=1, loaded=1): pm.loadPlugin("Turtle") # pm.mel.unifiedRenderGlobalsWindow() defaultRenderGlobals = pm.PyNode("defaultRenderGlobals") defaultRenderGlobals.currentRenderer.set("turtle") defaultRenderGlobals.imageFormat.set(32) pm.evalDeferred(lambda: set_option(func), lp=1)
def entryCallback(self, *args): ''' the public callback function ''' if not self._updating: #print pm.api.MFileIO.isOpeningFile(), pm.api.MFileIO.isReadingFile() if not pm.api.MFileIO.isOpeningFile(): self._updating = True #print self, "evalDeferred" pm.evalDeferred(self.deferredCallback)
def primChanged(self, prim): '''Slot that receives a signal that a refresh is required to update''' if self._refreshScheduled: return def refreshViewport(): self._refreshScheduled = False pm.refresh() pm.evalDeferred(refreshViewport)
def node_created_callback(cls, m_obj, _): """ Catches all network nodes that are created. Defer evaluates network node with metanode_created_callback so that network nodes have time to be inited as metas. :param m_obj: MObject for created network node. :param _: Extra argument passed from create event. :return: """ cls.created_m_objs.append(m_obj) pm.evalDeferred('meta.manager.MetanodeManager._check_created_node()')
def arnoldAOVEditor(*args): if pm.window(UI_NAME, exists=True): pm.deleteUI(UI_NAME) win = pm.window(UI_NAME, title='AOV setup', width=640, height=300) import time s = time.time() ed = ArnoldAOVEditor() print time.time() - s win.show() pm.evalDeferred(ed.fixOptionMenus) return ed
def evalDeferred_playblast(self, fileName, width, height, fp): try: pm.evalDeferred( 'pm.playblast(format="iff",sequenceTime=0,clearCache=1,viewer=0,\ showOrnaments=1,fp=' + str(fp) + ',percent=100,compression="jpg",\ widthHeight=(' + str(width) + ',' + str(height) + '),\ forceOverwrite=1,quality=100,filename=\"' + fileName + '\")') except: self.Log.error('evalDeferred_playblast error') self.Log.error(traceback.format_exc())
def batchExport(file_path): # NOTE 导入 reference ref = pm.createReference(hik_rig, r=1, namespace="jnt") ref.importContents(True) # org_namespace = "Darius_rig_:" # NOTE 约束武器 org_wp = "*:wp_jnt_ctrl" pm.parentConstraint(pm.ls(org_wp), "wp_jnt_skin", mo=0) pm.evalDeferred(lambda: exportFBX(file_path))
def createArnoldAOVTab(): parentForm = cmds.setParent(query=True) aovNode = aovs.AOVInterface() pm.columnLayout('enableAOVs', adjustableColumn=True) pm.setUITemplate('attributeEditorTemplate', pushTemplate=True) pm.attrControlGrp(attribute=aovNode.node.aovMode, label='Mode') # the tab gets recreated from scratch each time rather than updated and each # time the AOVOptionMenuGrp adds itself to the AOVChanged callback list. # we must remove it or we'll leave behind invalid copies global _aovDisplayCtrl if _aovDisplayCtrl is not None: aovs.removeAOVChangedCallback(_aovDisplayCtrl.update) _aovDisplayCtrl = shaderTemplate.AOVOptionMenuGrp('aiOptions', 'displayAOV', label='Render View AOV', allowCreation=False, includeBeauty=True, allowEmpty=False, allowDisable=False) _aovDisplayCtrl._setToChildMode() _aovDisplayCtrl._doSetup(aovNode.node.name() + '.displayAOV') pm.setParent(parentForm) cmds.scrollLayout('arnoldAOVsScrollLayout', horizontalScrollBarThickness=0) cmds.columnLayout('arnoldTabColumn', adjustableColumn=True) ed = ArnoldAOVEditor(aovNode) cmds.formLayout(parentForm, edit=True, af=[('enableAOVs', "top", 5), ('enableAOVs', "left", 0), ('enableAOVs', "right", 0), ('arnoldAOVsScrollLayout', "bottom", 0), ('arnoldAOVsScrollLayout', "left", 0), ('arnoldAOVsScrollLayout', "right", 0)], an=[('enableAOVs', "bottom")], ac=[('arnoldAOVsScrollLayout', "top", 5, 'enableAOVs')]) pm.setUITemplate('attributeEditorTemplate', popTemplate=True) cmds.setParent(parentForm) pm.evalDeferred(ed.fixOptionMenus) ed.setEnabledState() pm.scriptJob(attributeChange=(aovNode.node.aovMode, ed.setEnabledState), parent=ed.mainCol)
def createArnoldAOVTab(): parentForm = cmds.setParent(query=True) aovNode = aovs.AOVInterface() pm.columnLayout('enableAOVs', adjustableColumn=True) pm.setUITemplate('attributeEditorTemplate', pushTemplate=True) pm.attrControlGrp(attribute=aovNode.node.aovMode, label='Mode') # the tab gets recreated from scratch each time rather than updated and each # time the AOVOptionMenuGrp adds itself to the AOVChanged callback list. # we must remove it or we'll leave behind invalid copies global _aovDisplayCtrl if _aovDisplayCtrl is not None: aovs.removeAOVChangedCallback(_aovDisplayCtrl.update) _aovDisplayCtrl = shaderTemplate.AOVOptionMenuGrp('aiOptions', 'displayAOV', label='Render View AOV', allowCreation=False, includeBeauty=True, allowEmpty=False, allowDisable=False) _aovDisplayCtrl._setToChildMode() _aovDisplayCtrl._doSetup(aovNode.node.name() + '.displayAOV') pm.setParent(parentForm) cmds.scrollLayout('arnoldAOVsScrollLayout', horizontalScrollBarThickness=0) cmds.columnLayout('arnoldTabColumn', adjustableColumn=True) ed = ArnoldAOVEditor(aovNode) cmds.formLayout(parentForm, edit=True, af=[('enableAOVs',"top", 5), ('enableAOVs', "left", 0), ('enableAOVs', "right", 0), ('arnoldAOVsScrollLayout', "bottom", 0), ('arnoldAOVsScrollLayout', "left", 0), ('arnoldAOVsScrollLayout', "right", 0)], an=[('enableAOVs', "bottom")], ac=[('arnoldAOVsScrollLayout', "top", 5, 'enableAOVs')]) pm.setUITemplate('attributeEditorTemplate', popTemplate=True) cmds.setParent(parentForm) pm.evalDeferred(ed.fixOptionMenus) ed.setEnabledState() pm.scriptJob(attributeChange = (aovNode.node.aovMode, ed.setEnabledState), parent=ed.mainCol)
def hyperShadeSelectedIndex(self, indexes): pm.select(cl = True) for index in list(set(indexes)): # Allow selection of entire rows but prevent duplicate items currentItem = self.layeredTextureTreeModel.itemFromIndex(index) if type(currentItem) in (TextureSet, Texture): try: pm.select(currentItem.node, add = True) pm.select(currentItem.nodeList, add = True) except: pass pm.mel.eval('HypershadeWindow;') pm.evalDeferred('pm.mel.eval(\'hyperShadePanelGraphCommand("hyperShadePanel1", "showUpAndDownstream");\')')
def reloadUI(sUiModuleName, bRelaunchUI, **kwargs): sReloadCmd = "import {0}; reload({0}); " reloadModule(sUiModuleName) if bRelaunchUI: strKwargs = ", ".join( str(k) + "='" + str(v) + "'" for k, v in kwargs.items()) if strKwargs: pm.evalDeferred((sReloadCmd + '{0}.launch({1})').format( sUiModuleName, strKwargs)) else: pm.evalDeferred( (sReloadCmd + '{0}.launch()').format(sUiModuleName))
def registerArnoldRenderer(): try: alreadyRegistered = pm.renderer('arnold', exists=True) if not alreadyRegistered: pm.evalDeferred(_register) # AE Templates # the following must occur even in batch mode because they contain calls to registerDefaultTranslator pm.evalDeferred(aeUtils.loadAETemplates) import rendererCallbacks rendererCallbacks.registerCallbacks() import mtoa.ui.ae.customShapeAttributes import mtoa.ui.ae.customShaderTemplates if not pm.about(batch=True): # Reload the AE Window if it has already been opened pm.evalDeferred(aeUtils.rebuildAE) # create the Arnold menu createArnoldMenu() # version specific overrides or additions _overridePythonScripts() _overrideMelScripts() # Add option box for file translator utils.pyToMelProc(exportass.arnoldAssOpts, [('string', 'parent'), ('string', 'action'), ('string', 'initialSettings'), ('string', 'resultCallback')], useName=True) # callbacks import mtoa.core as core core.installCallbacks() core.MTOA_GLOBALS['COMMAND_PORT'] = None import maya.cmds as cmds if not pm.about(batch=True): commandPortBase = 4700 try: commandPortBase = int(os.environ['MTOA_COMMAND_PORT']) except: commandPortBase = 4700 # opening a command port for different tools and maya batch progress messages for port in range(commandPortBase, commandPortBase + 100): commandPortName = ':%i' % port try: cmds.commandPort(name=commandPortName) core.MTOA_GLOBALS['COMMAND_PORT'] = port break except: pass if not pm.about(batch=True): pm.evalDeferred(arnoldShelf.createArnoldShelf) except: import traceback traceback.print_exc(file=sys.__stderr__) raise
def registerRenderer(self): self.unRegisterRenderer() self.registerNodeExtensions() self.registerAETemplateCallbacks() pm.renderer(self.rendererName, rendererUIName=self.rendererName) pm.renderer(self.rendererName, edit=True, renderProcedure=self.makeMelProcFromPythonCmd(self.renderProcedure, [('int', 'width'), ('int', 'height'), ('int', 'doShadows'), ('int', 'doGlow'), ('string', 'camera'), ('string', 'options')])) pm.renderer(self.rendererName, edit=True, batchRenderProcedure=self.makeMelProcFromPythonCmd(self.batchRenderProcedure, [('string', 'options')])) pm.renderer(self.rendererName, edit=True, commandRenderProcedure=self.makeMelProcFromPythonCmd(self.batchRenderProcedure, [('string', 'options')])) pm.renderer(self.rendererName, edit=True, batchRenderOptionsProcedure=self.renderCallback("batchRenderOptionsProcedure")) pm.renderer(self.rendererName, edit=True, batchRenderOptionsStringProcedure=self.renderCallback("batchRenderOptionsStringProcedure")) pm.renderer(self.rendererName, edit=True, addGlobalsNode="defaultRenderGlobals") pm.renderer(self.rendererName, edit=True, addGlobalsNode="defaultResolution") pm.renderer(self.rendererName, edit=True, addGlobalsNode=self.renderGlobalsNodeName) pm.renderer(self.rendererName, edit=True, startIprRenderProcedure=self.makeMelProcFromPythonCmd(self.startIprRenderProcedure, [('string', 'editor'), ('int', 'resolutionX'), ('int', 'resolutionY'), ('string', 'camera')])) pm.renderer(self.rendererName, edit=True, stopIprRenderProcedure=self.makeMelProcFromPythonCmd(self.stopIprRenderProcedure, [])) pm.renderer(self.rendererName, edit=True, pauseIprRenderProcedure=self.makeMelProcFromPythonCmd(self.pauseIprRenderProcedure, [('string', 'editor'), ('int', 'pause')])) pm.renderer(self.rendererName, edit=True, changeIprRegionProcedure=self.makeMelProcFromPythonCmd(self.changeIprRegionProcedure, [('string', 'editor')])) pm.renderer(self.rendererName, edit=True, iprRenderProcedure=self.renderCallback("iprRenderProcedure")) pm.renderer(self.rendererName, edit=True, isRunningIprProcedure=self.renderCallback("isRunningIprProcedure")) pm.renderer(self.rendererName, edit=True, refreshIprRenderProcedure=self.renderCallback("refreshIprRenderProcedure")) pm.renderer(self.rendererName, edit=True, logoImageName=self.rendererName + ".png") pm.renderer(self.rendererName, edit=True, renderDiagnosticsProcedure=self.renderCallback("renderDiagnosticsProcedure")) pm.renderer(self.rendererName, edit=True, renderOptionsProcedure=self.renderCallback("renderOptionsProcedure")) pm.renderer(self.rendererName, edit=True, cancelBatchRenderProcedure=self.renderCallback("cancelBatchRenderProcedure")) pm.renderer(self.rendererName, edit=True, showBatchRenderProcedure=self.renderCallback("showBatchRenderProcedure")) pm.renderer(self.rendererName, edit=True, showRenderLogProcedure=self.renderCallback("showRenderLogProcedure")) pm.renderer(self.rendererName, edit=True, showBatchRenderLogProcedure=self.renderCallback("showBatchRenderLogProcedure")) pm.renderer(self.rendererName, edit=True, textureBakingProcedure=self.renderCallback("textureBakingProcedure")) pm.renderer(self.rendererName, edit=True, renderRegionProcedure="mayaRenderRegion") scriptDir = path.path(__file__).dirname().parent pm.mel.eval('global string $gImageFormatData[]; $gImageFormatData = {};') pm.mel.eval('global string $gPLEImageFormatData[]; $gPLEImageFormatData = {};') pm.mel.eval('global string $gPLEImageFormatData_Mental[]; $gPLEImageFormatData_Mental = {};') pm.mel.source('createMayaSoftwareCommonGlobalsTab') pm.mel.source("unifiedRenderGlobalsWindow") self.defineCommonMelProcedures() pm.evalDeferred(self.addTabs)
def repshp(*args, **kwargs): print "args:", args inmesh = False if not kwargs.has_key("inmesh") else kwargs["inmesh"] rename = True if not kwargs.has_key("rename") else kwargs["rename"] lssl = None if not args: lssl = pm.selected() else: lssl = pm.ls(*args) print " Selection:", lssl if len(lssl) % 2: print " <!> Given objects are not even, select by pairs", return pairs = [(lssl[x], lssl[x + 1]) for x in range(0, len(lssl) - 1, 2)] for pair in pairs: src, trg = pair if rename: trg.rename(src.name(stripNamespace=1)) src_shps = src.getShapes(ni=1) trg_shps = trg.getShapes(ni=1) tshps_sz = len(trg_shps) if inmesh: inm = ".ws" outm = "cr" if src_shp.type() == "mesh": inm = "i" outm = "o" else: pm.delete(trg_shps) for s, src_shp in enumerate(src_shps): if s == tshps_sz: break if inmesh: trg_shp = trg_shps[s] if not (src_shp.attr(outm).isConnectedTo(trg_shp.attr(inm))): pm.evalDeferred(pm.Callback( src_shp.attr(outm).connect, trg_shp.attr(inm)), en=1) pm.evalDeferred(pm.Callback( src_shp.attr(outm).disconnect, trg_shp.attr(inm)), low=1) else: dup = pm.duplicate(src_shp, addShape=1) dup[0].setParent(trg, r=1, s=1)
def set_option(func): if not pm.objExists("TurtleDefaultBakeLayer"): pm.evalDeferred(lambda: set_option(func), lp=1) return TurtleRenderOptions = pm.PyNode("TurtleRenderOptions") TurtleRenderOptions.renderer.set(1) TurtleDefaultBakeLayer = pm.PyNode("TurtleDefaultBakeLayer") TurtleDefaultBakeLayer.tbResX.set(1000) TurtleDefaultBakeLayer.tbResY.set(1000) TurtleDefaultBakeLayer.tbDirectory.set("turtle/bakedTextures/") TurtleDefaultBakeLayer.tbFileName.set("dilation.png") TurtleDefaultBakeLayer.renderType.set(1) TurtleDefaultBakeLayer.renderSelection.set(1) TurtleDefaultBakeLayer.fullShading.set(0) TurtleDefaultBakeLayer.tbBilinearFilter.set(0) TurtleDefaultBakeLayer.tbEdgeDilation.set(0) TurtleDefaultBakeLayer.normals.set(1) TurtleDefaultBakeLayer.tbImageFormat.set(9) func()
def dock_window(dialog_class): try: pm.deleteUI(dialog_class.CONTROL_NAME) except: pass main_control = pm.workspaceControl(dialog_class.CONTROL_NAME, iw=300, ttc=["AttributeEditor", -1], li=False, mw=True, wp='preferred', label=dialog_class.LABEL_NAME) control_widget = OpenMayaUI.MQtUtil.findControl(dialog_class.CONTROL_NAME) control_wrap = wrapInstance(long(control_widget), QtWidgets.QWidget) control_wrap.setStyleSheet("background-color:#505050;") control_wrap.setAttribute(QtCore.Qt.WA_DeleteOnClose) win = dialog_class(control_wrap) pm.evalDeferred(lambda *args: pm.workspaceControl(main_control, e=True, rs=True)) return win.run()
def addCallback(self): """ Create UI and parent any editors. """ # delete window if pm.window(self.winName, ex=True): pm.deleteUI(self.winName) self._win = None self.applyMetrics() p = pm.currentParent() self.deleteViews() with pm.window(title=self.title) as self._win: self._mainLayout = pm.verticalLayout() pm.verticalLayout(self._mainLayout, e=True, p=p) self._win = self._mainLayout self.mainControl = self._mainLayout self.showDefaultView() pm.evalDeferred(self.refreshScriptJobs)
def maya_workspace_docker(qt_widget, window_title): """ qt maya docker """ label = getattr(qt_widget, "label", window_title) try: pm.deleteUI(window_title) except RuntimeError: pass workspace_control = pm.workspaceControl( window_title, tabToControl=["AttributeEditor", -1], label=label) workspace_pointer = omui.MQtUtil.findControl(workspace_control) wrap_widget = wrapInstance(long(workspace_pointer), QtWidgets.QWidget) wrap_widget.setAttribute(QtCore.Qt.WA_DeleteOnClose) # wrap_widget.destroyed.connect(close) child = qt_widget(wrap_widget) wrap_widget.layout().addWidget(child) pm.evalDeferred(lambda *args: pm.workspaceControl( workspace_control, edit=True, restore=True))
def init(): pm.evalDeferred("ftrack_init.resolution_init()", lowestPriority=True) pm.evalDeferred("ftrack_init.render_range_init()", lowestPriority=True) # Disabling debug logging, cause of FTrack constant stream of print outs. mc.evalDeferred("ftrack_init.disable_debug()", lowestPriority=True) # pyblish-qml settings try: __import__("pyblish_qml") except ImportError as e: print("pyblish-bumpybox: Could not load pyblish-qml: %s " % e) else: from pyblish_qml import settings session = ftrack_api.Session() task = session.get("Task", os.environ["FTRACK_TASKID"]) ftrack_path = "" for item in task["link"]: ftrack_path += session.get(item["type"], item["id"])["name"] ftrack_path += " / " settings.WindowTitle = ftrack_path[:-3]
def bootstrap_strack(): # get login_info strack_info_str = os.getenv("strack_info") if not strack_info_str: log.warning("could not get strack info") return strack_info = json.loads(strack_info_str) login_info = strack_info.get("login_info") # set engine info StrackGlobals.engine = "maya" # init st StrackGlobals.st = strack.Strack(base_url=login_info.get('base_url'), login=login_info.get('login'), password=login_info.get('password')) log.info("Strack initialized, get strack api object StrackGlobals.st") StrackGlobals.current_project = strack_info.get("current_project") StrackGlobals.current_entity = strack_info.get("entity_info") if StrackGlobals.current_entity.get("type") == "task": StrackGlobals.selected_task = strack_info.get("entity_info") # setup strack menu project_info = strack_info.get("current_project") entity_info = strack_info.get("entity_info") pm.evalDeferred("StrackMenu(%s, %s)" % (project_info, entity_info))
def duplicate_original_mesh(source_object, default_shader=True): """Duplicate object without any deformer input. :arg source_object: PyNode object needs to be duplicated. :type source_object: pm.PyNode :key default_shader: Assign initialShadingGroup to duplicated object or not, default is True. :type default_shader: bool :return: Duplicated object, None if source object doesnt have shapes. :rtype: pm.PyNode or None """ if not source_object.getShapes(): return shapes_list = pm.ls(source_object.getShapes(), intermediateObjects=True) shape_orig = None for shape in shapes_list: if not shape.inMesh.isDestination() and ( shape.outMesh.isSource() or shape.worldMesh[0].isSource()): shape_orig = shape if not shape_orig: return duplicate_name = '{}_new'.format( shape_orig.getParent().nodeName(stripNamespace=True)) duplicated_object = pm.createNode('mesh', skipSelect=True) # rename its transform node duplicated_object.getParent().rename(duplicate_name) # copy the mesh data shape_orig.outMesh.connect(duplicated_object.inMesh) # done copying, break the connection pm.evalDeferred(duplicated_object.inMesh.disconnect) if default_shader: pm.sets('initialShadingGroup', edit=True, forceElement=duplicated_object.getParent()) return duplicated_object
def checkShelfColors(self): """Update the DilloTools shelf button colors, since Maya always forgets them.""" pm.evalDeferred(pm.Callback(shelf.checkShelfColors, self._tools))
def createMenu(self): """Create the Dillo Tools menu""" pm.evalDeferred(pm.Callback(menu.createMenu, self._tools))
def AddScriptNodesIfNecessary(moduleReference, sceneSetupMethod, frameUpdateMethod, sceneCloseMethod): """ Adds auto-generated script nodes to the Maya scene if they don't already exist. Adds nodes to: - run a method when when Maya scene opens (e.g. to restore PySwarm state from a previous save file). - run a method when the frame changes the Maya scene (e.g. during playback, to read & then update the scene). - run a method when the Maya scene is closed (e.g. to save PySwarm state to a file). :param moduleReference: module object containing the given methods (i.e. needs to be imported to run them). :param sceneSetupMethod: should be a bound method (within 'moduleReference') to be run when Maya scene opens. :param frameUpdateMethod: bound method to run when Maya frame updates within the scene. :param sceneCloseMethod: bound method to run when the Maya scene closes. """ swarmControllerModuleName = moduleReference.__name__ modulePath = os.path.dirname(os.path.dirname(moduleReference.__file__)) moduleHandle = "__%s_IMPORT_FOR_SCRIPTNODE_UPDATES__" % pi.PackageName().upper() headerPadding = "#" * len(pi.PackageName()) scriptHeaderString = ( "####################%s########################\n" "# Auto-generated by %s, please do not edit!! #\n" "####################%s########################\n\n" % (headerPadding, pi.PackageName(), headerPadding) ) if not _ScriptNodeExists("pySwarmOnSceneOpen", True): pathString = 'import sys\nif("%s" not in sys.path): sys.path.append("%s")' % (modulePath, modulePath) importString = ( 'if("%s" not in globals()): globals()["%s"] = ' '__import__("%s", globals(), locals(), ["%s"], -1)' % (moduleHandle, moduleHandle, swarmControllerModuleName, swarmControllerModuleName) ) sceneOpenNode = pm.scriptNode( name="pySwarmOnSceneOpen", beforeScript=( "%s%s\n%s\n%s.%s()" % (scriptHeaderString, pathString, importString, moduleHandle, sceneSetupMethod.__name__) ), scriptType=2, sourceType="python", ) pm.evalDeferred(importString) LogDebug('Added scene-open script node "%s" to Maya scene.' % sceneOpenNode) if not _ScriptNodeExists("pySwarmOnFrameUpdate", True): frameUpdateNode = pm.scriptNode( name="pySwarmOnFrameUpdate", beforeScript=("%s%s.%s()" % (scriptHeaderString, moduleHandle, frameUpdateMethod.__name__)), scriptType=7, sourceType="python", ) LogDebug('Added frame-update script node "%s" to Maya scene.' % frameUpdateNode) if not _ScriptNodeExists("pySwarmOnSceneClose", False): sceneCloseNode = pm.scriptNode( name="pySwarmOnSceneClose", afterScript=("%s%s.%s()" % (scriptHeaderString, moduleHandle, sceneCloseMethod.__name__)), scriptType=2, sourceType="python", ) LogDebug('Added scene-close script node "%s" to Maya scene.' % sceneCloseNode)
import display import dynamics import modeling import materials import modify import poses import rigging import scene import menu import skinning import config from pymel.core import about, evalDeferred, mel try: _initialized except: _initialized = False if not _initialized: _initialized = True mel.python( 'import kinetifex' ) if not about( batch=True ): evalDeferred( display._initHudElements )
def checkShelfColors(self): """Update the DilloTools shelf button colors, since Maya always forgets them.""" pm.evalDeferred( pm.Callback(shelf.checkShelfColors, self._tools) )
_setup_complete = False if not _setup_complete: import pymel.core as pm import hyperdrive pm.evalDeferred(hyperdrive.utils.mayautil.add_hyperdrive_menu) _setup_complete = True
# NOTE 约束武器 org_wp = "*:wp_jnt_ctrl" pm.parentConstraint(pm.ls(org_wp), "wp_jnt_skin", mo=0) pm.evalDeferred(lambda: exportFBX(file_path)) def loadFile(file_path, open_file=True): # NOTE 打开文件 if open_file: pm.openFile(file_path, f=1) batchExport(file_path) mel.eval("ToggleCharacterControls;") for i, file_name in enumerate(os.listdir(animation_path)): if not file_name.endswith(".mb") and not file_name.endswith(".ma"): continue print("file_name", file_name) file_path = os.path.join(animation_path, file_name) pm.evalDeferred(partial(loadFile, file_path), lowestPriority=1) # if i > 3: # break # NOTE 单个文件处理 # file_path = pm.sceneName() # pm.evalDeferred( partial (loadFile,file_path,False) ,lowestPriority=1)
import os import sys import pymel.core as pm import maya.cmds as cmds sys.path.append(os.environ['Art Tools']) startup = pm.evalDeferred("import Maya.Startup")
pm.runtime.SavePreferences() # Change the default camera to Alexa try: persp = pm.PyNode("persp") perspShape = persp.getShape() perspShape.horizontalFilmAperture.set(23.76/25.4) perspShape.verticalFilmAperture.set(13.365/25.4) except pm.MayaNodeError: pass # create environment variables for each Repository db.setup() if not pm.general.about(batch=1): # load shelves shelves_path = '../../../../shelves' shelf_names = ['kks_Tools', 'kks_Animation'] for shelf_name in shelf_names: shelf_path = os.path.normpath( os.path.join(here, shelves_path, 'shelf_%s.mel' % shelf_name) ).replace('\\', '/') pm.evalDeferred('auxiliary.delete_shelf_tab("%s", confirm=False)' % shelf_name) pm.evalDeferred('auxiliary.load_shelf_tab("%s")' % shelf_path) print('shelf_path: %s' % shelf_path)
def registerRenderer(self): log.debug("registerRenderer") self.unRegisterRenderer() self.registerNodeExtensions() self.registerAETemplateCallbacks() pm.renderer(self.rendererName, rendererUIName=self.rendererName) pm.renderer(self.rendererName, edit=True, renderProcedure=self.makeMelProcFromPythonCmd(self.renderProcedure, [('int', 'width'), ('int', 'height'), ('int', 'doShadows'), ('int', 'doGlow'), ('string', 'camera'), ('string', 'options')])) pm.renderer(self.rendererName, edit=True, batchRenderProcedure=self.makeMelProcFromPythonCmd(self.batchRenderProcedure, [('string', 'options')])) pm.renderer(self.rendererName, edit=True, commandRenderProcedure=self.makeMelProcFromPythonCmd(self.batchRenderProcedure, [('string', 'options')])) # pm.renderer(self.rendererName, edit=True, batchRenderProcedure=self.renderCallback("batchRenderProcedure")) # pm.renderer(self.rendererName, edit=True, commandRenderProcedure=self.renderCallback("commandRenderProcedure")) pm.renderer(self.rendererName, edit=True, batchRenderOptionsProcedure=self.renderCallback("batchRenderOptionsProcedure")) pm.renderer(self.rendererName, edit=True, batchRenderOptionsStringProcedure=self.renderCallback("batchRenderOptionsStringProcedure")) pm.renderer(self.rendererName, edit=True, addGlobalsNode="defaultRenderGlobals") pm.renderer(self.rendererName, edit=True, addGlobalsNode="defaultResolution") pm.renderer(self.rendererName, edit=True, addGlobalsNode=self.renderGlobalsNodeName) pm.renderer(self.rendererName, edit=True, startIprRenderProcedure=self.makeMelProcFromPythonCmd(self.startIprRenderProcedure, [('string', 'editor'), ('int', 'resolutionX'), ('int', 'resolutionY'), ('string', 'camera')])) pm.renderer(self.rendererName, edit=True, stopIprRenderProcedure=self.makeMelProcFromPythonCmd(self.stopIprRenderProcedure, [])) pm.renderer(self.rendererName, edit=True, pauseIprRenderProcedure=self.makeMelProcFromPythonCmd(self.pauseIprRenderProcedure, [('string', 'editor'), ('int', 'pause')])) pm.renderer(self.rendererName, edit=True, changeIprRegionProcedure=self.renderCallback("changeIprRegionProcedure")) pm.renderer(self.rendererName, edit=True, iprOptionsProcedure=self.renderCallback("iprOptionsProcedure")) pm.renderer(self.rendererName, edit=True, iprOptionsMenuLabel=self.renderCallback("iprOptionsMenuLabel")) pm.renderer(self.rendererName, edit=True, iprRenderProcedure=self.renderCallback("iprRenderProcedure")) pm.renderer(self.rendererName, edit=True, iprRenderSubMenuProcedure=self.renderCallback("iprRenderSubMenuProcedure")) pm.renderer(self.rendererName, edit=True, isRunningIprProcedure=self.renderCallback("isRunningIprProcedure")) pm.renderer(self.rendererName, edit=True, refreshIprRenderProcedure=self.renderCallback("refreshIprRenderProcedure")) pm.renderer(self.rendererName, edit=True, logoCallbackProcedure=self.renderCallback("logoCallbackProcedure")) pm.renderer(self.rendererName, edit=True, logoImageName=self.rendererName + ".png") pm.renderer(self.rendererName, edit=True, renderDiagnosticsProcedure=self.renderCallback("renderDiagnosticsProcedure")) pm.renderer(self.rendererName, edit=True, renderOptionsProcedure=self.renderCallback("renderOptionsProcedure")) pm.renderer(self.rendererName, edit=True, cancelBatchRenderProcedure=self.renderCallback("cancelBatchRenderProcedure")) pm.renderer(self.rendererName, edit=True, showBatchRenderProcedure=self.renderCallback("showBatchRenderProcedure")) pm.renderer(self.rendererName, edit=True, showRenderLogProcedure=self.renderCallback("showRenderLogProcedure")) pm.renderer(self.rendererName, edit=True, showBatchRenderLogProcedure=self.renderCallback("showBatchRenderLogProcedure")) pm.renderer(self.rendererName, edit=True, textureBakingProcedure=self.renderCallback("textureBakingProcedure")) pm.renderer(self.rendererName, edit=True, renderingEditorsSubMenuProcedure=self.renderCallback("renderingEditorsSubMenuProcedure")) pm.renderer(self.rendererName, edit=True, renderRegionProcedure="mayaRenderRegion") # In the maya system files we have to hardcode some renderers if we want to use our own CommonGlobals Tab # The modified scripts are located in the module scritps directory. Unfortunatly the scripts directory is loaded # after mayas own scripts directory so the modified scripts with the same name will never be loaded. To fix this # behaviour I place the module script path at the very first position. scriptDir = path.path(__file__).dirname().parent os.environ['MAYA_SCRIPT_PATH'] = "{0};{1}".format(scriptDir, os.environ['MAYA_SCRIPT_PATH']) pm.mel.eval("source createMayaSoftwareCommonGlobalsTab") pm.mel.eval("source unifiedRenderGlobalsWindow") pm.evalDeferred(self.addTabs) log.debug("RegisterRenderer done")
def customLightFiltersChanged(self, userChangeCB=None): if userChangeCB: pm.evalDeferred(userChangeCB)
shelves_paths = \ os.environ[custom_shelves_env_var_name].split(os.path.pathsep) for shelves_path in shelves_paths: logprint('current shelves_path: %s' % shelves_path) import glob shelf_paths = glob.glob('%s/shelf_*.mel' % shelves_path) logprint('shelf_paths: %s' % shelf_paths) for shelf_path in shelf_paths: shelf_path = shelf_path.replace('\\', '/') logprint('loading shelf: %s' % shelf_path) shelf_name = \ os.path.splitext(os.path.basename(shelf_path))[0][6:] pm.evalDeferred( 'auxiliary.delete_shelf_tab("%s", confirm=False)' % shelf_name) pm.evalDeferred('auxiliary.load_shelf_tab("%s")' % shelf_path) else: logprint('no **%s** env var for shelves' % custom_shelves_env_var_name) if 'ANIMA_TEST_SETUP' not in os.environ.keys(): def load_arnold(): try: __plugin_loader('mtoa') # patch auto-tx option in arnold for Maya 2017 if pymel.versions.current() >= 201700: from anima.env.mayaEnv.config import arnold_patches from mtoa.ui.globals import settings
bld = True, sm = True, p = 'outlinerPanel1Popup') pm.menuItem('setMenuItemA', l = 'Add Selection to Set', c = pm.Callback(Scenes.addRemoveSetMembers,'add'), p = setMenu) pm.menuItem('setMenuItemB', l = 'Remove Members from Set', c = pm.Callback(Scenes.addRemoveSetMembers,'remove'), p = setMenu) except: pm.displayWarning('[arutils]: Could not create outliner menu') def about(): arutils.ui.generalUI.Generic.windowCheck('arUtilsAboutWin') aboutWin = pm.window('arUtilsAboutWin', t = 'arUtils', s = False, mxb = False, mnb = False) winLayout = pm.rowColumnLayout(nc = 2) text = '\n' + \ ' arUtils 0.1.3\n\n' + \ '\n' \ '\n Author: Rico Koschmitzky & Arvid Schneider' + \ '\n Mail: [email protected]' + \ '\n Acknowledgements: Justin Israel, Philipp Oeser' + \ '\n\n' pm.text(al = 'left', l = text, p = winLayout) pm.image(p = winLayout, i = os.path.join(ICON_LOCATION, 'arUtilsSmallWhite.png')) aboutWin.show() pm.evalDeferred('arMayaMenuUnique01()')
def doIt(shpsA=None, shpsB=None, flp=None, brk=False): """ using transform groups flp = default(0, 0, 0) - xBase, yBase, zBase - if zero no flipping brk = clr rig after mirror """ tg = None tgs = [] mat = [ 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, ] M = dt.Array(mat, shape=(4, 4)) # miirror matrix if not flp: flp = (0, 0, 0) for i, j in enumerate(flp): M[i, i] = M[i][i] + (-1 * (j * 2)) print M.formated() # check shps lssl = pm.ls(shpsA, shpsB) if not lssl: lssl = pm.ls(sl=1) else: lssl = [ x.getShapes(ni=1) if "transform" in x.type(i=1) else [x] for x in lssl ] if lssl.__len__() != 2: print " <!> Select two transforms" return shpsA, shpsB = lssl if not (shpsA and shpsB): return print "shapes A:", shpsA init_lssl = pm.selected() for i, shp in enumerate(shpsA): typ = shp.type() if i < shpsB.__len__(): print "shp type: " + typ trg_shp = shpsB[i] iplg = "cr" oplg = "ws" if typ == "mesh": iplg = "i" oplg = "o" print trg_shp ls_tg = trg_shp.attr(iplg).inputs(type="transformGeometry") if ls_tg: tg = ls_tg[0] else: tg = pm.createNode("transformGeometry", n=("tg_" + trg_shp)) tg.txf.set(M.ravel(), type="matrix") print M.ravel() if not shp.attr(oplg).isConnectedTo(tg.ig): print " // connecting to transformGeometry" shp.attr(oplg) >> tg.ig if not tg.og.isConnectedTo(trg_shp.attr(iplg)): print " // connecting to target" tg.og >> trg_shp.attr(iplg) if brk: print " // breaking" pm.evalDeferred("pm.disconnectAttr(\"{:}\", \"{:}\")".format( shp.ws, tg.ig)) pm.evalDeferred("pm.disconnectAttr(\"{:}\", \"{:}\")".format( tg.og, trg_shp.attr(iplg))) pm.evalDeferred("pm.delete(\"{:}\")".format(tg)) else: tgs.append(tg) tg.fn.set(1) pm.select(init_lssl) return tgs
import pymel.core as pm from maya.utils import executeDeferred # State the directory to the root folder of the pipeline system code repository # This will be error checked pipelineSysDir = "D:/PipelineSystem/" if pm.os.path.isdir(pipelineSysDir): pm.os.sys.path.append("D:/PipelineSystem/") else: pathNotExistErrMsg = "Pipeline System folder, {}, does not exist or " \ "currently unavailable".format(pipelineSysDir) pm.confirmDialog(message=pathNotExistErrMsg) raise OSError(pathNotExistErrMsg) # Next import the Maya modules from the pipeline system, run tests if chosen import ps_maya buttonFlags = { "title": 'Run tests', "message": "Run tests?", "button": ['Yes','No'], "defaultButton": 'Yes', "cancelButton": 'No', "dismissString": 'No' } if pm.confirmDialog(**buttonFlags) == "Yes": pm.evalDeferred(ps_maya.runUnitTests) # Then initialize the pipeline system for Maya pm.evalDeferred(ps_maya.initialize) # ------------------------- END ----------------------------------------------
def createMenu(self): """Create the Dillo Tools menu""" pm.evalDeferred( pm.Callback(menu.createMenu, self._tools) )
import os import sys import pymel.core as pm import maya.cmds as cmds sys.path.append(os.environ['GTOOLS']) startup = pm.evalDeferred('import startup')
def createMenu(items, *args): mi = cmds.window('MayaWindow', ma=True, q=True) for m in mi: if m == 'UserScripts': cmds.deleteUI('UserScripts', m=True) cmds.menu('UserScripts', label='UserScripts', to=True, p="MayaWindow") for item in items: cmds.menuItem(label=item, c=partial(runScript, item)) # Define the path to the scripts Script_Path = (os.environ['GTOOLS'] + '/scripts') allScriptFiles = [] pyFiles = fileUtils.findAllFiles(Script_Path, '.py') for script in pyFiles: allScriptFiles.append(script) melFiles = fileUtils.findAllFiles(Script_Path, '.mel') for script in melFiles: allScriptFiles.append(script) createMenu(allScriptFiles) print "Done Loading User Scripts" # Load Setting print "Trying to load settings" startup = pm.evalDeferred('import RG_Parts.Parts_Maya.settings')
"particles", "renderData", "sceneAssembly", "scripts", "shaders", "sound", "sourceImages", "teClipExports", "templates", "timeEditor", "translatorData" ] for item in rules: pm.Workspace.fileRules[item] = "workspace" # Scene is needs to be directly in the project folder, # so people can open old versions and save as new versions. pm.Workspace.fileRules["scene"] = "" pm.system.Workspace.save() pm.evalDeferred("pyblish_bumpybox_set_workspace()") # Pyblish callbacks for presisting instance states to the scene. def toggle_instance(instance, new_value, old_value): node = instance[0] families = instance.data.get("families", []) if "cache" in families or "scene" in families: attrs = [] for attr in node.listAttr(userDefined=True): attrs.append(attr.name(includeNode=False)) attr_list = list(set(attrs) & set(families))
print( '**%s**: %s' % ( custom_shelves_env_var_name, os.environ[custom_shelves_env_var_name] ) ) shelves_paths = \ os.environ[custom_shelves_env_var_name].split(os.path.pathsep) for shelves_path in shelves_paths: print('current shelves_path: %s' % shelves_path) import glob shelf_paths = glob.glob('%s/shelf_*.mel' % shelves_path) print('shelf_paths: %s' % shelf_paths) for shelf_path in shelf_paths: shelf_path = shelf_path.replace('\\', '/') print('loading shelf: %s' % shelf_path) shelf_name = os.path.splitext(os.path.basename(shelf_path))[0][6:] pm.evalDeferred('auxiliary.delete_shelf_tab("%s", confirm=False)' % shelf_name) pm.evalDeferred('auxiliary.load_shelf_tab("%s")' % shelf_path) else: print('no **%s** env var for shelves' % custom_shelves_env_var_name) # patch auto-tx option in arnold for Maya 2017 if pymel.versions.current() >= 201700: from anima.env.mayaEnv.config import arnold_patches from mtoa.ui.globals import settings settings.createArnoldTextureSettings = \ arnold_patches.createArnoldTextureSettings
import os import sys import datetime import thread import re import __main__ import maya.cmds as cmds import maya.mel as mel import pymel.core as pm import pymel.core.nodetypes as nt import pymel.core.datatypes as dt import maya.OpenMaya as om from pprint import pprint import logging log = logging.getLogger(__name__) # Setup Menus using evalDeffered so that the UI exists def addMenus(): ''' Loading Custom Tools menu ''' import tasMenu tasMenu.createMenus() pm.evalDeferred(addMenus) print "Hello Tom"
def removeComponentCallBack(self, *args): itemMData = self.parentWidget.item ns = self.name.split(':')[0] database.removeComponent(itemMData, ns) pm.evalDeferred('pm.deleteUI("' + self.widgetName + '")') self.parentWidget.itemList.remove(self)
def copyStateCallback(self, newPanel): """ Copy the state of one panel to another """ if newPanel: pm.evalDeferred(Callback(self._copyStateDeferred, newPanel))
def removeCallback(self): """ Unparent any editors and save state if required. """ self.winClosed() # delete this panel pm.evalDeferred(self._removeDeferred)
def __init__(self, aovNode=None): self.waitingToRefresh = False self.aovControls = [] self.optionMenus = [] self.aovRows = {} self.renderOptions = aovs.AOVInterface() if aovNode is None else aovNode self.mainCol = pm.cmds.columnLayout('arnoldAOVMainColumn') # global drivers pm.cmds.frameLayout('arnoldDisplayDriverFrame', label='Default Drivers', width=WIDTH, collapsable=True, collapse=True) pm.cmds.columnLayout(adj=True) for attr in self.renderOptions.node.drivers: driver = attr.inputs() if driver: pm.cmds.rowLayout(nc=2, columnAttach2=['both', 'right'], adjustableColumn=1, rowAttach=[2, 'top', 5]) pm.cmds.columnLayout(adj=True) templates.createTranslatorMenu(driver[0], label=utils.prettify(driver[0].name()), nodeType='aiAOVDriver') pm.cmds.setParent('..') pm.cmds.symbolButton(image="navButtonConnected.png", command=Callback(pm.select, driver)) pm.cmds.setParent('..') pm.setParent(self.mainCol) pm.cmds.frameLayout('arnoldAOVBrowserFrame', label='AOV Browser', width=WIDTH, collapsable=True, collapse=False, height=200) self.browser = AOVBrowser(self.renderOptions) pm.setParent(self.mainCol) pm.cmds.frameLayout('arnoldAOVPrimaryFrame', label='AOVs', width=WIDTH, collapsable=True, collapse=False) self.aovCol = pm.cmds.columnLayout('arnoldAOVListColumn', adj=True) pm.cmds.rowLayout('arnoldAOVButtonRow', nc=3, columnWidth3=[140, 100, 100], columnAttach3=['right', 'both', 'both']) pm.cmds.text(label='') pm.cmds.button(label='Add Custom', c=lambda *args: shaderTemplate.newAOVPrompt()) pm.cmds.button(label='Delete All', c=lambda *args: (self.renderOptions.removeAOVs(self.aovRows.keys()), \ hooks.setupDefaultAOVs(self.renderOptions))) pm.setParent('..') # rowLayout pm.cmds.separator(style='in') pm.rowLayout(nc=4, columnWidth4=[130, 66, 80, 40], columnAttach4=['both', 'both', 'both', 'both']) pm.cmds.text(label='name') pm.cmds.text(label='data') pm.cmds.text(label='driver') pm.cmds.text(label='filter') pm.cmds.setParent('..') # rowLayout pm.cmds.separator(style='in') # pm.text(_uiName('prefixLbl'), align='center', label='Prefix', parent=form) # pm.textField(_uiName('prefixFld'), enable=False, text='', parent=form, changeCommand=Callback(setAOVPrefix, aovnode)) self.browser.populate() # add all control rows self.addRows() aovs.addAOVChangedCallback(self.refresh, 'aoveditor') # update AOV imageFormat of all rows when the default imageFormat changes. a scriptJob will suffice here pm.scriptJob(parent=self.aovCol, attributeChange=[self.renderOptions.node.imageFormat.name(), lambda *args: pm.evalDeferred(self.refresh)])