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 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 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 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')
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)])
