def _applied_display_options(options):
"""Context manager for setting background color display options."""
options = dict(DisplayOptions, **(options or {}))
colors = ['background', 'backgroundTop', 'backgroundBottom']
preferences = ['displayGradient']
# Store current settings
original = {}
for color in colors:
original[color] = cmds.displayRGBColor(color, query=True) or []
for preference in preferences:
original[preference] = cmds.displayPref(query=True,
**{preference: True})
# Apply settings
for color in colors:
value = options[color]
cmds.displayRGBColor(color, *value)
for preference in preferences:
value = options[preference]
cmds.displayPref(**{preference: value})
try:
yield
finally:
# Restore original settings
for color in colors:
cmds.displayRGBColor(color, *original[color])
for preference in preferences:
cmds.displayPref(**{preference: original[preference]})
def _applied_display_options(options):
"""Context manager for setting background color display options."""
from maya import cmds
options = options or DisplayOptions()
colors = ['background', 'backgroundTop', 'backgroundBottom']
prefs = ['displayGradient']
# store current settings
original = {}
for clr in colors:
original[clr] = cmds.displayRGBColor(clr, query=True)
for pref in prefs:
original[pref] = cmds.displayPref(query=True, **{pref: True})
# apply settings of options
for clr in colors:
value = getattr(options, clr)
cmds.displayRGBColor(clr, *value)
for pref in prefs:
value = getattr(options, pref)
cmds.displayPref(**{pref: value})
yield
# restore original settings
for clr in colors:
cmds.displayRGBColor(clr, *original[clr])
for pref in prefs:
cmds.displayPref(**{pref: original[pref]})
def load():
'''loads animation environment'''
print "loading animation environment presets..."
#set autoKey
cmds.autoKeyframe( state=True )
#set 24fps and playback on all viewports
cmds.playbackOptions(ps=1.0, v='all')
#set unlimited undo's
cmds.undoInfo( state=True, infinity=True )
#set manipulator sizes
if lib.checkAboveVersion(2014):
cmds.manipOptions( r=False, hs=55, ls=4, sph=1 )
else:
cmds.manipOptions( r=False, hs=55, ls=4 )
#set framerate visibility
mel.eval("setFrameRateVisibility(1);")
#gimbal rotation
cmds.manipRotateContext('Rotate', e=True, mode=2)
#world translation
cmds.manipMoveContext('Move', e=True, mode=2)
#time slider height
aPlayBackSliderPython = mel.eval('$tmpVar=$gPlayBackSlider')
cmds.timeControl(aPlayBackSliderPython, h=45, e=True);
#special tick color
cmds.displayRGBColor("timeSliderTickDrawSpecial", 1,0.5,0)
#check if hotkeys have been set
if (cmds.hotkey( 't', ctl=True, query=True, name = True)== 'CharacterAnimationEditorNameCommand'):
print "Hotkeys have been previously loaded"
else:
setHotkeys('default')
print "ENVIRONMENT SET\n", #the comma forces output on the status line
def apply_view(panel, **options):
"""Apply options to panel"""
camera = cmds.modelPanel(panel, camera=True, query=True)
# Display options
display_options = options.get('display_options', {})
for key, value in display_options.items():
if key in _DisplayOptionsRGB:
cmds.displayRGBColor(key, *value)
else:
cmds.displayPref(**{key: value})
# Camera options
camera_options = options.get('camera_options', {})
for key, value in camera_options.items():
cmds.setAttr(f'{camera}.{key}', value)
# Viewport options
viewport_options = options.get('viewport_options', {})
for key, value in viewport_options.items():
cmds.modelEditor(panel, edit=True, **{key: value})
viewport2_options = options.get('viewport2_options', {})
for key, value in viewport2_options.items():
attr = f'hardwareRenderingGlobals.{key}'
cmds.setAttr(attr, value)
def setDefaultConfig(self):
#STATIC PREFS
# tumble config
#cmds.tumbleCtx( 'tumbleContext', edit=True, alternateContext=True, tumbleScale=1.0, localTumble=0, autoOrthoConstrain=False, orthoLock=False)
cmds.tumbleCtx('tumbleContext',
edit=True,
alternateContext=True,
tumbleScale=1.0,
localTumble=0)
cmds.dollyCtx('dollyContext',
edit=True,
alternateContext=True,
scale=1.0,
localDolly=True,
centerOfInterestDolly=False)
#timeline ticks display
G.playBackSliderPython = G.playBackSliderPython or mel.eval(
'$aTools_playBackSliderPython=$gPlayBackSlider')
cmds.timeControl(G.playBackSliderPython,
edit=True,
showKeys="mainChannelBox",
showKeysCombined=True,
animLayerFilterOptions="active")
#tickDrawSpecial Color
cmds.displayRGBColor('timeSliderTickDrawSpecial', 1, 1, .4)
#CUSTOMIZABLE PREFS
for loopPref in PREFS:
name = loopPref["name"]
self.setPref(name, True)
def setCustomColors():
"""
set the custom maya environment color scheme
"""
# outliner
cmds.displayRGBColor('outlinerInvisibleColor', 0.943999, 0.233173, 0.233173)
"""
# background
cmds.displayRGBColor('background', 0.6, 0.6, 0.6)
cmds.displayRGBColor('backgroundBottom', 0.3, 0.3, 0.3)
cmds.displayRGBColor('backgroundTop', 0.025, 0.025, 0.025)
# meshes
cmds.displayRGBColor('lead', 0.4, 0.4, 0.4, create=True)
cmds.displayColor('hilite', 2, active=True)
cmds.displayColor('hiliteComponent', 1, active=True)
cmds.displayColor('lead', 3, active=True)
cmds.displayColor('polymesh', 3, active=True)
cmds.displayColor('polymesh', 2, dormant=True)
"""
# default background
cmds.displayRGBColor('background', 0.63099998235702515, 0.63099998235702515, 0.63099998235702515)
cmds.displayRGBColor('backgroundBottom', 0.052000001072883606, 0.052000001072883606, 0.052000001072883606)
cmds.displayRGBColor('backgroundTop', 0.5350000262260437, 0.61699998378753662, 0.70200002193450928)
# default meshes
cmds.displayRGBColor('lead', 0.4, 0.4, 0.4, create=True)
cmds.displayColor('hilite', 18, active=True)
cmds.displayColor('hiliteComponent', 9, active=True)
cmds.displayColor('lead', 19, active=True)
cmds.displayColor('polymesh', 16, active=True)
cmds.displayColor('polymesh', 5, dormant=True)
def apply_view(panel, **options):
"""Apply options to panel"""
camera = cmds.modelPanel(panel, camera=True, query=True)
# Display options
display_options = options.get("display_options", {})
for key, value in display_options.iteritems():
if key in _DisplayOptionsRGB:
cmds.displayRGBColor(key, *value)
else:
cmds.displayPref(**{key: value})
# Camera options
camera_options = options.get("camera_options", {})
for key, value in camera_options.iteritems():
cmds.setAttr("{0}.{1}".format(camera, key), value)
# Viewport options
viewport_options = options.get("viewport_options", {})
for key, value in viewport_options.iteritems():
cmds.modelEditor(panel, edit=True, **{key: value})
viewport2_options = options.get("viewport2_options", {})
for key, value in viewport2_options.iteritems():
attr = "hardwareRenderingGlobals.{0}".format(key)
cmds.setAttr(attr, value)
def _applied_display_options(options):
"""Context manager for setting background color display options."""
options = options or DisplayOptions()
colors = ['background', 'backgroundTop', 'backgroundBottom']
preferences = ['displayGradient']
# Store current settings
original = {}
for color in colors:
original[color] = cmds.displayRGBColor(color, query=True) or []
for preference in preferences:
original[preference] = cmds.displayPref(query=True, **{preference: True})
# Apply settings
for color in colors:
value = getattr(options, color)
cmds.displayRGBColor(color, *value)
for preference in preferences:
value = getattr(options, preference)
cmds.displayPref(**{preference: value})
try:
yield
finally:
# Restore original settings
for color in colors:
cmds.displayRGBColor(color, *original[color])
for preference in preferences:
cmds.displayPref(**{preference: original[preference]})
def silhouetteIt():
global background_color, silhouette_flag, object_sgs
print silhouette_flag
print object_sgs
print background_color
shapes = cmds.ls(g=True, v=True)
filtered_shapes = filter(lambda o: (cmds.nodeType(o) == "mesh"), shapes)
for s in filtered_shapes:
if (silhouette_flag):
shape_sg = object_sgs[s]
connectSGToObj(shape_sg, s)
else:
obj_sg = cmds.listConnections(s, type="shadingEngine")[0]
object_sgs[s] = obj_sg
if (not shaderNodeExists("silhouetteShader")):
createSurfaceShader("silhouetteShader", "silhouetteShaderSG")
connectSGToObj("silhouetteShaderSG", s)
if (silhouette_flag):
cmds.displayRGBColor("background", background_color[0],
background_color[1], background_color[2])
silhouette_flag = False
else:
background_color = cmds.displayRGBColor("background", q=True)
cmds.displayRGBColor("background", 1, 1, 1)
silhouette_flag = True
print silhouette_flag
def parse_active_view():
"""Parse active view for settings"""
panel = cmds.getPanel(withFocus=True)
assert "model" in panel, "No active viewport"
camera = cmds.modelPanel(panel, query=True, camera=True)
camera_shape = cmds.listRelatives(camera, shapes=True)[0]
return {
"camera": camera,
"width": cmds.getAttr("defaultResolution.width"),
"height": cmds.getAttr("defaultResolution.height"),
"camera_options": type("CameraOptions", (object, CameraOptions,), {
"displayFilmGate": cmds.getAttr(camera_shape + ".displayFilmGate"),
"displayResolution": cmds.getAttr(camera_shape + ".displayResolution"),
"displaySafeAction": cmds.getAttr(camera_shape + ".displaySafeAction"),
}),
"viewport_options": type("ViewportOptions", (object, ViewportOptions,), {
"useDefaultMaterial": cmds.modelEditor(panel, query=True, useDefaultMaterial=True),
"wireframeOnShaded": cmds.modelEditor(panel, query=True, wireframeOnShaded=True),
"displayAppearance": cmds.modelEditor(panel, query=True, displayAppearance=True),
"displayTextures": cmds.modelEditor(panel, query=True, displayTextures=True),
"displayLights": cmds.modelEditor(panel, query=True, displayLights=True),
"shadows": cmds.modelEditor(panel, query=True, shadows=True),
"xray": cmds.modelEditor(panel, query=True, xray=True),
}),
"display_options": type("DisplayOptions", (object, DisplayOptions,), {
"background": cmds.displayRGBColor('background', q=True),
"backgroundTop": cmds.displayRGBColor('backgroundTop', q=True),
"backgroundBottom": cmds.displayRGBColor('backgroundBottom', q=True),
'displayGradient': cmds.displayPref(dgr=True, q=True),
}),
}
def apply_view(panel, **options):
"""Apply options to panel"""
camera = cmds.modelPanel(panel, camera=True, query=True)
# Display options
display_options = options.get("display_options", {})
for key, value in display_options.iteritems():
if key in _DisplayOptionsRGB:
cmds.displayRGBColor(key, *value)
else:
cmds.displayPref(**{key: value})
# Camera options
camera_options = options.get("camera_options", {})
for key, value in camera_options.iteritems():
cmds.setAttr("{0}.{1}".format(camera, key), value)
# Viewport options
viewport_options = options.get("viewport_options", {})
for key, value in viewport_options.iteritems():
cmds.modelEditor(panel, edit=True, **{key: value})
viewport2_options = options.get("viewport2_options", {})
for key, value in viewport2_options.iteritems():
attr = "hardwareRenderingGlobals.{0}".format(key)
cmds.setAttr(attr, value)
def restoreSettings(self):
'''
restore all UI settings
'''
cmds.autoKeyframe(state=self.dataStore['autoKey'])
# timeline management
cmds.currentTime(self.dataStore['currentTime'])
cmds.playbackOptions(min=self.dataStore['minTime'])
cmds.playbackOptions(max=self.dataStore['maxTime'])
cmds.playbackOptions(ast=self.dataStore['startTime'])
cmds.playbackOptions(aet=self.dataStore['endTime'])
cmds.playbackOptions(ps=self.dataStore['playSpeed'])
cmds.playbackOptions(loop=self.dataStore['playLoop'])
# unit management
cmds.currentUnit(time=self.dataStore['timeUnit'])
cmds.currentUnit(linear=self.dataStore['sceneUnits'])
if not cmds.upAxis(axis=True, q=True) == self.dataStore['upAxis']:
cmds.upAxis(axis=self.dataStore['upAxis'])
log.debug('Restored PlayBack / Timeline setup')
# viewport colors
cmds.displayPref(displayGradient=self.dataStore['displayGradient'])
cmds.displayRGBColor(resetToSaved=True)
# objects colors
cmds.displayColor("curve", self.dataStore['curvecolor'], dormant=True)
# panel management
for panel, data in self.dataStore['panelStore'].items():
try:
cmdString = data['settings'].replace('$editorName', panel)
mel.eval(cmdString)
log.debug("Restored Panel Settings Data >> %s" % panel)
mel.eval('lookThroughModelPanel("%s","%s")' % (data['activeCam'], panel))
log.debug("Restored Panel Active Camera Data >> %s >> cam : %s" % (panel, data['activeCam']))
except:
log.debug("Failed to fully Restore ActiveCamera Data >> %s >> cam : %s" % (panel, data['activeCam']))
# camera management
for cam, settings in self.dataStore['cameraTransforms'].items():
try:
cmds.setAttr('%s.translate' % cam, settings[0][0][0], settings[0][0][1], settings[0][0][2])
cmds.setAttr('%s.rotate' % cam, settings[1][0][0], settings[1][0][1], settings[1][0][2])
cmds.setAttr('%s.scale' % cam, settings[2][0][0], settings[2][0][1], settings[2][0][2])
log.debug('Restored Default Camera Transform Data : % s' % cam)
except:
log.debug("Failed to fully Restore Default Camera Transform Data : % s" % cam)
# sound management
if self.dataStore['displaySound']:
cmds.timeControl(self.gPlayBackSlider, e=True, ds=1, sound=self.dataStore['activeSound'])
log.debug('Restored Audio setup')
else:
cmds.timeControl(self.gPlayBackSlider, e=True, ds=0)
log.debug('Scene Restored fully')
return True
def restoreSettings(self):
'''
restore all UI settings
'''
cmds.autoKeyframe(state=self.dataStore['autoKey'])
# timeline management
cmds.currentTime(self.dataStore['currentTime'])
cmds.playbackOptions(min=self.dataStore['minTime'])
cmds.playbackOptions(max=self.dataStore['maxTime'])
cmds.playbackOptions(ast=self.dataStore['startTime'])
cmds.playbackOptions(aet=self.dataStore['endTime'])
cmds.playbackOptions(ps=self.dataStore['playSpeed'])
cmds.playbackOptions(loop=self.dataStore['playLoop'])
# unit management
cmds.currentUnit(time=self.dataStore['timeUnit'])
cmds.currentUnit(linear=self.dataStore['sceneUnits'])
if not cmds.upAxis(axis=True, q=True) == self.dataStore['upAxis']:
cmds.upAxis(axis=self.dataStore['upAxis'])
log.debug('Restored PlayBack / Timeline setup')
# viewport colors
cmds.displayPref(displayGradient=self.dataStore['displayGradient'])
cmds.displayRGBColor(resetToSaved=True)
# objects colors
cmds.displayColor("curve", self.dataStore['curvecolor'], dormant=True)
# panel management
for panel, data in self.dataStore['panelStore'].items():
try:
cmdString = data['settings'].replace('$editorName', panel)
mel.eval(cmdString)
log.debug("Restored Panel Settings Data >> %s" % panel)
mel.eval('lookThroughModelPanel("%s","%s")' % (data['activeCam'], panel))
log.debug("Restored Panel Active Camera Data >> %s >> cam : %s" % (panel, data['activeCam']))
except:
log.debug("Failed to fully Restore ActiveCamera Data >> %s >> cam : %s" % (panel, data['activeCam']))
# camera management
for cam, settings in self.dataStore['cameraTransforms'].items():
try:
cmds.setAttr('%s.translate' % cam, settings[0][0][0], settings[0][0][1], settings[0][0][2])
cmds.setAttr('%s.rotate' % cam, settings[1][0][0], settings[1][0][1], settings[1][0][2])
cmds.setAttr('%s.scale' % cam, settings[2][0][0], settings[2][0][1], settings[2][0][2])
log.debug('Restored Default Camera Transform Data : % s' % cam)
except:
log.debug("Failed to fully Restore Default Camera Transform Data : % s" % cam)
# sound management
if self.dataStore['displaySound']:
cmds.timeControl(self.gPlayBackSlider, e=True, ds=1, sound=self.dataStore['activeSound'])
log.debug('Restored Audio setup')
else:
cmds.timeControl(self.gPlayBackSlider, e=True, ds=0)
log.debug('Scene Restored fully')
return True
def mhUpdateUserColor(udColorIndex):
rgbValue = cmds.colorSliderButtonGrp('mhCustomColorButtonGrp%d' %
udColorIndex,
query=True,
rgb=True)
cmds.displayRGBColor('userDefined%d' % udColorIndex, rgbValue[0],
rgbValue[1], rgbValue[2])
def assignDefaultShader():
global switch
activeModel = cmds.getPanel(wf=True)
cmds.modelEditor(activeModel, e=True, udm=0)
cmds.displayRGBColor( 'background', 0.61, 0.61, 0.61 )
cmds.setAttr('lambert1.color', 0.5, 0.5, 0.5, type="double3")
cmds.setAttr('lambert1.diffuse', 0.5)
for node in cmds.ls(sl=True):
cmds.color() # assign default wireframes
switch = 1
def active_view_snapshot(*args):
capture.snap(clipboard=True,
display_options={
"displayGradient":
cmds.displayPref(query=True, displayGradient=True),
"background":
cmds.displayRGBColor("background", query=True),
"backgroundTop":
cmds.displayRGBColor("backgroundTop", query=True),
"backgroundBottom":
cmds.displayRGBColor("backgroundBottom", query=True),
})
def assignBlackShader():
global switch
activeModel = cmds.getPanel(wf=True)
cmds.modelEditor(activeModel, e=True, udm=1)
cmds.displayRGBColor( 'background', 0, 0, 0 )
cmds.setAttr('lambert1.color', 0, 0, 0, type="double3")
cmds.setAttr('lambert1.diffuse', 0)
cmds.displayRGBColor('userDefined1', 1 ,1 ,1 )
for node in cmds.ls(sl = True):
cmds.color(ud = 1) # assign white wireframes
switch = 1
def getUserDefinedColors(inType=1):
"""
@param inType: Int. 1 is RGB. 2 is HSV.
@return: List. User defined colors 1-8.
"""
tempList = []
for color in xrange(1, 9):
userString = "userDefined{0}".format(color)
if inType == 1:
colorSetting = cmds.displayRGBColor(userString, query=True)
elif inType == 2:
colorSetting = cmds.displayRGBColor(userString, query=True, hueSaturationValue=True)
tempList.append(colorSetting)
return tempList
def parse_view(panel):
"""Parse the scene, panel and camera for their current settings
Example:
>>> parse_view("modelPanel1")
Arguments:
panel (str): Name of modelPanel
"""
camera = cmds.modelPanel(panel, query=True, camera=True)
# Display options
display_options = {}
for key in DisplayOptions:
if key in _DisplayOptionsRGB:
display_options[key] = cmds.displayRGBColor(key, query=True)
else:
display_options[key] = cmds.displayPref(query=True, **{key: True})
# Camera options
camera_options = {}
for key in CameraOptions:
camera_options[key] = cmds.getAttr("{0}.{1}".format(camera, key))
# Viewport options
viewport_options = {}
# capture plugin display filters first to ensure we never override
# built-in arguments if ever possible a plugin has similarly named
# plugin display filters (which it shouldn't!)
plugins = cmds.pluginDisplayFilter(query=True, listFilters=True)
for plugin in plugins:
plugin = str(plugin) # unicode->str for simplicity of the dict
state = cmds.modelEditor(panel, query=True, queryPluginObjects=plugin)
viewport_options[plugin] = state
for key in ViewportOptions:
viewport_options[key] = cmds.modelEditor(panel,
query=True,
**{key: True})
viewport2_options = {}
for key in Viewport2Options.keys():
attr = "hardwareRenderingGlobals.{0}".format(key)
try:
viewport2_options[key] = cmds.getAttr(attr)
except ValueError:
continue
return {
"camera": camera,
"display_options": display_options,
"camera_options": camera_options,
"viewport_options": viewport_options,
"viewport2_options": viewport2_options
}
def parse_view(panel):
"""Parse the scene, panel and camera for their current settings
Example:
>>> parse_view("modelPanel1")
Arguments:
panel (str): Name of modelPanel
"""
camera = cmds.modelPanel(panel, query=True, camera=True)
# Display options
display_options = {}
for key in DisplayOptions:
if key in _DisplayOptionsRGB:
display_options[key] = cmds.displayRGBColor(key, query=True)
else:
display_options[key] = cmds.displayPref(query=True, **{key: True})
# Camera options
camera_options = {}
for key in CameraOptions:
camera_options[key] = cmds.getAttr("{0}.{1}".format(camera, key))
# Viewport options
viewport_options = {}
# capture plugin display filters first to ensure we never override
# built-in arguments if ever possible a plugin has similarly named
# plugin display filters (which it shouldn't!)
plugins = cmds.pluginDisplayFilter(query=True, listFilters=True)
for plugin in plugins:
plugin = str(plugin) # unicode->str for simplicity of the dict
state = cmds.modelEditor(panel, query=True, queryPluginObjects=plugin)
viewport_options[plugin] = state
for key in ViewportOptions:
viewport_options[key] = cmds.modelEditor(
panel, query=True, **{key: True})
viewport2_options = {}
for key in Viewport2Options.keys():
attr = "hardwareRenderingGlobals.{0}".format(key)
try:
viewport2_options[key] = cmds.getAttr(attr)
except ValueError:
continue
return {
"camera": camera,
"display_options": display_options,
"camera_options": camera_options,
"viewport_options": viewport_options,
"viewport2_options": viewport2_options
}
def setDefaultConfig(self):
#STATIC PREFS
# tumble config
#cmds.tumbleCtx( 'tumbleContext', edit=True, alternateContext=True, tumbleScale=1.0, localTumble=0, autoOrthoConstrain=False, orthoLock=False)
cmds.tumbleCtx( 'tumbleContext', edit=True, alternateContext=True, tumbleScale=1.0, localTumble=0)
cmds.dollyCtx( 'dollyContext', edit=True, alternateContext=True, scale=1.0, localDolly=True, centerOfInterestDolly=False)
#timeline ticks display
G.playBackSliderPython = G.playBackSliderPython or mel.eval('$aTools_playBackSliderPython=$gPlayBackSlider')
cmds.timeControl(G.playBackSliderPython, edit=True, showKeys="mainChannelBox", showKeysCombined=True, animLayerFilterOptions="active")
#tickDrawSpecial Color
cmds.displayRGBColor('timeSliderTickDrawSpecial',1,1,.4)
#CUSTOMIZABLE PREFS
for loopPref in PREFS:
name = loopPref["name"]
self.setPref(name, True)
def setViewportQuality():
global modelEditors
global backgroundColors
backgroundColors.append(cmds.displayRGBColor('background',q=True))
backgroundColors.append(cmds.displayRGBColor('backgroundTop',q=True))
backgroundColors.append(cmds.displayRGBColor('backgroundBottom',q=True))
cmds.displayRGBColor('background', 1, 1, 1)
cmds.displayRGBColor('backgroundTop', 0.762112, 0.87892, 1)
cmds.displayRGBColor('backgroundBottom', 1, 1, 1)
for i in cmds.lsUI(panels=True):
if cmds.modelEditor(i, query=True, exists=True):
sts = cmds.modelEditor(i, query=True, stateString=True)
sts = sts.replace("$editorName", i)
modelEditors.append(sts)
cmds.modelEditor(i, edit=True, displayAppearance="smoothShaded", lineWidth=2)
def mhCreateRGBSlider(udColorIndex, parentLayout):
rgbValue = cmds.displayRGBColor('userDefined%d' % udColorIndex, query=True)
cmds.colorSliderButtonGrp(
'mhCustomColorButtonGrp%d' % udColorIndex,
parent=parentLayout,
label='userColor %d' % udColorIndex,
buttonCommand='mhSetCustomColor(%d)' % udColorIndex,
buttonLabel='assign',
rgb=rgbValue,
symbolButtonDisplay=False,
changeCommand='mhUpdateCustomColor(%d)' % udColorIndex)
def createIcon():
frameNumber = mc.currentTime (q=1)
mc.setAttr("defaultHardwareRenderGlobals.startFrame",l=False)
mc.setAttr("defaultHardwareRenderGlobals.endFrame",l=False)
mc.setAttr("defaultHardwareRenderGlobals.byFrame",l=False)
mc.setAttr("defaultHardwareRenderGlobals.startFrame",frameNumber)
mc.setAttr("defaultHardwareRenderGlobals.endFrame" ,frameNumber)
mc.setAttr("defaultHardwareRenderGlobals.extension",1)
mc.setAttr("defaultHardwareRenderGlobals.backgroundColor", 0.75 ,0.75 ,0.75,type='double3')
mc.setAttr("defaultHardwareRenderGlobals.imageFormat",20)
poseLibCaptureCameraBGColor = ( 0.75,0.75,0.75 )
poseLibIconsSize = ( 104, 82 )
poseLibIconsBGColor = (.4, .4, .5)
currentBGColor = mc.displayRGBColor('background',q=1)
mc.displayRGBColor('background',poseLibCaptureCameraBGColor[0],poseLibCaptureCameraBGColor[1],poseLibCaptureCameraBGColor[2])
# Here we set the default hardware render globals resolution and aspect ratio.
mc.setAttr('defaultHardwareRenderGlobals.filename',"iconTmp",type="string")
mc.setAttr('defaultHardwareRenderGlobals.resolution','104x82 104 82 0',type="string")
# Do the render.
# Here we resize the gl frame to match the correct render resolution.
mc.frameLayout('glRenderFrame',e=1,m=1,width=(poseLibIconsSize[0]+2),height=(poseLibIconsSize[1]+2))
#mc.rowLayout(iconCaptureRL,e=1,cw=[2,106])
# Look through the poseLib camera we just created.
mc.glRenderEditor('hardwareRenderViewBis',e=1,lt='poseLibCaptureCamera')
# Warning: This crashes Maya in certain scenes: 2600/4, or 1402/25, or 702/68.
#mc.glRender(e=1,cf=frameNumber,accumBufferPasses=4,transformIcons= 0,edgeSmoothness=1.0,aam="gaussian")
mc.glRender(rs='hardwareRenderViewBis')
# Put back the background color the way it was.
mc.displayRGBColor ("background",currentBGColor[0],currentBGColor[1],currentBGColor[2])
print 'Icon Creation Done...'
def setup_bgColor(mode = 'gray', reverse = False):
if mode == 'resetAll':
mc.displayRGBColor(rf=True)
return
d_color = d_bg_presets.get(mode)
if not d_color:
raise ValueError,"Invalid mode: {0}".format(mode)
if reverse:
_top = d_color['bottom']
_bottom = d_color['top']
else:
_top = d_color['top']
_bottom = d_color['bottom']
mc.displayRGBColor( 'backgroundTop', _top[0],_top[1],_top[2] )
mc.displayRGBColor( 'backgroundBottom', _bottom[0],_bottom[1],_bottom[2] )
def setViewportQuality():
global modelEditors
global backgroundColors
backgroundColors.append(cmds.displayRGBColor('background', q=True))
backgroundColors.append(cmds.displayRGBColor('backgroundTop', q=True))
backgroundColors.append(cmds.displayRGBColor('backgroundBottom', q=True))
cmds.displayRGBColor('background', 1, 1, 1)
cmds.displayRGBColor('backgroundTop', 0.762112, 0.87892, 1)
cmds.displayRGBColor('backgroundBottom', 1, 1, 1)
for i in cmds.lsUI(panels=True):
if cmds.modelEditor(i, query=True, exists=True):
sts = cmds.modelEditor(i, query=True, stateString=True)
sts = sts.replace("$editorName", i)
modelEditors.append(sts)
cmds.modelEditor(i,
edit=True,
displayAppearance="smoothShaded",
lineWidth=2)
def get_outputs(self):
outputs = {}
if self.override.isChecked():
outputs["displayGradient"] = self.display_gradient()
for label, widget in self._colors.items():
outputs[label] = widget.color
else:
# Parse active color settings
outputs["displayGradient"] = cmds.displayPref(query=True,
displayGradient=True)
for key in COLORS.keys():
color = cmds.displayRGBColor(key, query=True)
outputs[key] = color
return {"display_options": outputs}
def parse_view(panel):
"""Parse the scene, panel and camera for their current settings
Example:
>>> parse_view("modelPanel1")
Arguments:
panel (str): Name of modelPanel
"""
camera = cmds.modelPanel(panel, query=True, camera=True)
# Display options
display_options = {}
for key in DisplayOptions:
if key in _DisplayOptionsRGB:
display_options[key] = cmds.displayRGBColor(key, query=True)
else:
display_options[key] = cmds.displayPref(query=True, **{key: True})
# Camera options
camera_options = {}
for key in CameraOptions:
camera_options[key] = cmds.getAttr("{0}.{1}".format(camera, key))
# Viewport options
viewport_options = {}
for key in ViewportOptions:
viewport_options[key] = cmds.modelEditor(panel,
query=True,
**{key: True})
viewport2_options = {}
for key in Viewport2Options.keys():
attr = "hardwareRenderingGlobals.{0}".format(key)
try:
viewport2_options[key] = cmds.getAttr(attr)
except ValueError:
continue
return {
"camera": camera,
"display_options": display_options,
"camera_options": camera_options,
"viewport_options": viewport_options,
"viewport2_options": viewport2_options
}
def restoreViewportQuality():
global modelEditors
global backgroundColors
bc = backgroundColors
cmds.displayRGBColor('background', bc[0][0], bc[0][1], bc[0][2])
cmds.displayRGBColor('backgroundTop', bc[1][0], bc[1][1], bc[1][2])
cmds.displayRGBColor('backgroundBottom', bc[2][0], bc[2][1], bc[2][2])
for e in modelEditors:
mel.eval(e)
def restoreViewportQuality():
global modelEditors
global backgroundColors
bc = backgroundColors
cmds.displayRGBColor('background', bc[0][0], bc[0][1], bc[0][2])
cmds.displayRGBColor('backgroundTop', bc[1][0], bc[1][1], bc[1][2])
cmds.displayRGBColor('backgroundBottom', bc[2][0], bc[2][1], bc[2][2])
for e in modelEditors:
mel.eval(e)
def parse_view(panel):
"""Parse the scene, panel and camera for their current settings
Example:
>>> parse_view("modelPanel1")
Arguments:
panel (str): Name of modelPanel
"""
camera = cmds.modelPanel(panel, query=True, camera=True)
# Display options
display_options = {}
for key in DisplayOptions:
if key in _DisplayOptionsRGB:
display_options[key] = cmds.displayRGBColor(key, query=True)
else:
display_options[key] = cmds.displayPref(query=True, **{key: True})
# Camera options
camera_options = {}
for key in CameraOptions:
camera_options[key] = cmds.getAttr("{0}.{1}".format(camera, key))
# Viewport options
viewport_options = {}
for key in ViewportOptions:
viewport_options[key] = cmds.modelEditor(
panel, query=True, **{key: True})
viewport2_options = {}
for key in Viewport2Options.keys():
attr = "hardwareRenderingGlobals.{0}".format(key)
try:
viewport2_options[key] = cmds.getAttr(attr)
except ValueError:
continue
return {
"camera": camera,
"display_options": display_options,
"camera_options": camera_options,
"viewport_options": viewport_options,
"viewport2_options": viewport2_options
}
def saveScreenshot(name, directory=TexturesDir):
# 图片保存路径
cmds.displayRGBColor('backgroundTop', 1, 1, 1)
cmds.displayRGBColor('backgroundBottom', 1, 1, 1)
cmds.displayRGBColor('background', 1, 1, 1)
cmds.setAttr("perspShape.focalLength", 50)
path = os.path.join(directory, '%s.jpg' % name)
cmds.setAttr('hardwareRenderingGlobals.multiSampleEnable', 1)
cmds.viewFit(f=1) # 聚焦物体
cmds.setAttr('defaultRenderGlobals.imageFormat', 8) # 设置默认渲染器图片格式 8位jpg
# 使用playblast 的方式保存截图
cmds.playblast(completeFilename=path,
forceOverwrite=True,
format='image',
width=2048,
height=2048,
showOrnaments=False,
startTime=1,
endTime=1,
viewer=False)
cmds.displayRGBColor(rs=True)
return path
def get_outputs(self):
"""Get the plugin outputs that matches `capture.capture` arguments
Returns:
dict: Plugin outputs
"""
outputs = {}
if self.override.isChecked():
outputs["displayGradient"] = self.display_gradient()
for label, widget in self._colors.items():
outputs[label] = widget.color
else:
# Parse active color settings
outputs["displayGradient"] = cmds.displayPref(query=True,
displayGradient=True)
for key in COLORS.keys():
color = cmds.displayRGBColor(key, query=True)
outputs[key] = color
return {"display_options": outputs}
def viewportColor(BG):
if BG == 'gradGrey':
cmds.displayPref(dgr=True)
elif BG == 'Grey':
cmds.displayPref(dgr=False)
cmds.displayRGBColor('background', .631, .631, .631)
elif BG == 'Green':
cmds.displayPref(dgr=False)
cmds.displayRGBColor('background', 0, 1, 0)
elif BG == 'Blue':
cmds.displayPref(dgr=False)
cmds.displayRGBColor('background', 0, 0, 1)
elif BG == 'Red':
cmds.displayPref(dgr=False)
cmds.displayRGBColor('background', 1, 0, 0)
elif BG == 'White':
cmds.displayPref(dgr=False)
cmds.displayRGBColor('background', 1, 1, 1)
elif BG == 'Black':
cmds.displayPref(dgr=False)
cmds.displayRGBColor('background', 0, 0, 0)
else:
print 'Error: There was a problem with setting the camera viewport background color'
def setDefaultColors():
"""
set the default maya environment color scheme
"""
# script editor
cmds.displayRGBColor('syntaxKeywords', 0.0, 1.0, 0.0)
cmds.displayRGBColor('syntaxText', 0.78431373834609985, 0.78431373834609985, 0.78431373834609985)
cmds.displayRGBColor('syntaxStrings', 1.0, 1.0, 0.0)
cmds.displayRGBColor('syntaxComments', 1.0, 0.0, 0.0)
cmds.displayRGBColor('syntaxCommands', 0.0, 1.0, 1.0)
cmds.displayRGBColor('syntaxBackground', 0.16470588743686676, 0.16470588743686676, 0.16470588743686676)
# background
cmds.displayRGBColor('background', 0.63099998235702515, 0.63099998235702515, 0.63099998235702515)
cmds.displayRGBColor('backgroundBottom', 0.052000001072883606, 0.052000001072883606, 0.052000001072883606)
cmds.displayRGBColor('backgroundTop', 0.5350000262260437, 0.61699998378753662, 0.70200002193450928)
# meshes
cmds.displayRGBColor('lead', 0.40000000596046448, 0.40000000596046448, 0.40000000596046448, create=True)
cmds.displayColor('hilite', 18, active=True)
cmds.displayColor('hiliteComponent', 9, active=True)
cmds.displayColor('lead', 19, active=True)
cmds.displayColor('polymesh', 16, active=True)
cmds.displayColor('polymesh', 5, dormant=True)
import maya.cmds as cmds
import datetime
i = datetime.datetime.now()
currentTime = i.strftime('%Y-%m-%d')
# increment and save
# cmds.file(force=True, save=True, options="v=0");
# get scene file name to name the playblast
pbFileName = cmds.file(q=True, sn=True, shn=True)
# set bg color
cmds.displayRGBColor('background', 0, 1, 0)
# render playblast
cmds.playblast(format="qt",
filename="movies/" + currentTime + "/" + pbFileName[:-3],
clearCache=True,
viewer=True,
showOrnaments=False,
fp=4,
percent=100,
compression="H.264",
quality=75,
widthHeight=[1280, 720])
# set bg color back
cmds.displayRGBColor('background', rs=True)
def setCustomColors():
"""
set custom maya environment color scheme
"""
# script editor
cmds.displayRGBColor('syntaxKeywords', 0.14, 0.9, 0.14)
cmds.displayRGBColor('syntaxText', 0.84, 0.84, 0.84)
cmds.displayRGBColor('syntaxStrings', 0.09, 0.4, 0.1)
cmds.displayRGBColor('syntaxComments', 0.45, 0.45, 0.45)
cmds.displayRGBColor('syntaxCommands', 0.75, 0.75, 0.27)
cmds.displayRGBColor('syntaxBackground', 0.15, 0.15, 0.15)
# background
cmds.displayRGBColor('background', 0.6, 0.6, 0.6)
cmds.displayRGBColor('backgroundBottom', 0.3, 0.3, 0.3)
cmds.displayRGBColor('backgroundTop', 0.025, 0.025, 0.025)
# meshes
cmds.displayRGBColor('lead', 0.4, 0.4, 0.4, create=True)
cmds.displayColor('hilite', 2, active=True)
cmds.displayColor('hiliteComponent', 1, active=True)
cmds.displayColor('lead', 3, active=True)
cmds.displayColor('polymesh', 3, active=True)
cmds.displayColor('polymesh', 2, dormant=True)
def setViewportOptions(self, *args):
'''
'''
cmds.select(self._IScontextTool._mVoroObject)
mel.eval("viewFit")
# List all unselected objects
self._IScontextTool._mObjectsToHide = mel.eval('listUnselected')
# Display hard edge color change
bHardEdge = False
displayColors = cmds.displayRGBColor(list = True)
for d in displayColors:
d = d.split()[0]
if d == 'hardedge':
bHardEdge = True
break
if bHardEdge:
if int(cmds.about(version = True).split()[0]) > 2015:
cmds.displayRGBColor('hardedge', .2, .2, .2)
else:
cmds.displayRGBColor('hardedge', .15, .15, .15)
# Switch to Persp/Outliner Panel and look through modelPanel4 (perspective)
mel.eval('setNamedPanelLayout "Persp/Outliner"')
mel.eval('lookThroughModelPanel persp modelPanel4')
# Switch to Viewport 2.0
if cmds.modelEditor('modelPanel4', q = True, rnm = True) != 'vp2Renderer':
mel.eval('setRendererInModelPanel "ogsRenderer" modelPanel4')
# Disable HeadsUpDisplay to display current viewport Renderer
if (cmds.optionVar(exists = 'viewportRendererVisibility')):
mel.eval("setViewportRendererVisibility 0")
# Enable InViewMessages
if (cmds.optionVar(exists = 'inViewMessageEnable')):
cmds.optionVar(iv = ('inViewMessageEnable', 1))
self._IScontextTool._mInViewMessage = True
# Enable AA for Viewport 2.0
if cmds.objExists('hardwareRenderingGlobals'):
if (cmds.attributeQuery('lineAAEnable', node = 'hardwareRenderingGlobals', exists = True)):
cmds.setAttr("hardwareRenderingGlobals.lineAAEnable", True)
if (cmds.attributeQuery('multiSampleEnable', node = 'hardwareRenderingGlobals', exists = True)):
cmds.setAttr("hardwareRenderingGlobals.multiSampleEnable", True)
# Turns HUD on, wireframeOnShaded on for all versions
cmds.modelEditor('modelPanel4', e = True, hud = True)
cmds.modelEditor('modelPanel4', e = True, wos = True)
cmds.modelEditor('modelPanel4', e = True, xray = False)
# Turns Gamma Viewport correction on if Maya version is equal or greater than 2016
if int(cmds.about(version = True).split()[0]) > 2015:
cmds.modelEditor('modelPanel4', e = True, cmEnabled = True)
self._IScontextTool._mGammaCorrect = True
# Turns the ground plane display off in all windows
cmds.modelEditor('modelPanel4', edit = True, grid = False)
# Disable Mesh Drawing for FractureFX
fxWorld = cmds.ls(type = 'fxWorld')
if fxWorld:
for w in fxWorld:
cmds.setAttr(w + '.drawMesh', False)
def ScreenCapture(filename,resolution, color = 0.361):
cmds.undoInfo(stateWithoutFlush = False)
try:
oldFormat = cmds.getAttr("defaultRenderGlobals.imageFormat")
cmds.setAttr("defaultRenderGlobals.imageFormat", 32)
#Store the current display colors
colors = [cmds.displayRGBColor("background", query = True),
cmds.displayRGBColor("backgroundTop", query = True),
cmds.displayRGBColor("backgroundBottom", query = True)]
#To make the UI prettier
cmds.displayRGBColor("background", color, color, color)
cmds.displayRGBColor("backgroundTop", color, color, color)
cmds.displayRGBColor("backgroundBottom", color, color, color)
#Take a snap for the UI
cmds.playblast(frame=0,fmt="image",viewer=0,fp=4,orn=0,p=100,wh=resolution,ifz=0,fo=1,offScreen=1,cf=filename)
#Revert to the old colors
cmds.displayRGBColor("background", colors[0][0], colors[0][1], colors[0][2])
cmds.displayRGBColor("backgroundTop", colors[1][0], colors[1][1], colors[1][2])
cmds.displayRGBColor("backgroundBottom", colors[2][0], colors[2][1], colors[2][2])
cmds.setAttr("defaultRenderGlobals.imageFormat", oldFormat)
except:
pass
cmds.undoInfo(stateWithoutFlush = True)
def _publish_fx_renders_for_item(self, item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb):
"""
Render the FX Splashes (any nParticles) with Hardware Render Buffer (HWB)
"""
## Do the regular Shotgun processing now
group_name = item['name'] # spriteSpray_nParticle_T_RShape
debug(app = None, method = '_publish_fx_renders_for_item', message = 'group_name: %s' % group_name, verbose = False)
tank_type = 'Rendered Image' # Alembic Cache
debug(app = None, method = '_publish_fx_renders_for_item', message = 'tank_type: %s' % tank_type, verbose = False)
publish_template = output["publish_template"] # <Sgtk TemplatePath maya_shot_fxRenderFinal: episodes/{Sequence}/{Shot}//FxLayers/R{version}>
debug(app = None, method = '_publish_fx_renders_for_item', message = 'publish_template: %s' % publish_template, verbose = False)
# Get the current scene path and extract fields from it
# Using the work template:
scene_path = os.path.abspath(cmds.file(query=True, sn= True)) # I:\bubblebathbay\episodes\ep106\ep106_sh030\FX\work\maya\ep106sh030.v025.ma
debug(app = None, method = '_publish_fx_renders_for_item', message = 'scene_path: %s' % scene_path, verbose = False)
fields = work_template.get_fields(scene_path) # {'Shot': u'ep106_sh030', 'name': u'ep106sh030', 'Sequence': u'ep106', 'Step': u'FX', 'version': 25, 'group_name': u'spriteSpray_nParticle_T_RShape'}
publish_version = fields["version"]
## Update fields with the group_name
fields["group_name"] = group_name
## Get episode and shot name from field directly
epShotName = fields["name"]
## create the publish path by applying the fields
## with the publish template:
publish_path = publish_template.apply_fields(fields) # K:\bubblebathbay\episodes\ep106\ep106_sh030\FxLayers\R025
## Make the publish directory for images rendering to be placed
if not os.path.isdir(publish_path):
os.mkdir(publish_path)
# ## Hardware Render Buffer settings (LEGACY FOR NOW)
# ## Get shotCam
# shotCam = []
# for cam in cmds.ls(cameras = 1):
# if not cmds.camera(cam, query = 1, startupCamera = 1):
# transform = cmds.listRelatives(cam, parent = True, fullPath = True)[0]
# if cmds.objExists('%s.type' % transform):
# if cmds.getAttr('%s.type' % transform) == 'shotCam':
# shotCam.append(transform)
#
# if shotCam:
# debug(app = None, method = '_publish_fx_renders_for_item', message = 'shotCam for Hardware Render Buffer: %s' % shotCam[0], verbose = False)
#
# ## Set the necessary correct settings for the HWB
# mel.eval('glRenderWin;')
# cmds.setAttr('defaultHardwareRenderGlobals.filename', epShotName, type = 'string')
# cmds.setAttr('defaultHardwareRenderGlobals.extension', 4)
# cmds.setAttr('defaultHardwareRenderGlobals.startFrame', cmds.playbackOptions(q = True, min = True))
# cmds.setAttr('defaultHardwareRenderGlobals.endFrame', cmds.playbackOptions(q = True, max = True))
# cmds.setAttr('defaultHardwareRenderGlobals.byFrame', 1)
# cmds.setAttr('defaultHardwareRenderGlobals.imageFormat', 19) # TARGA
# cmds.setAttr('defaultHardwareRenderGlobals.resolution', 'HD_720 1280 720 1.777', type = 'string')
# cmds.setAttr('defaultHardwareRenderGlobals.alphaSource', 0)
# cmds.setAttr('defaultHardwareRenderGlobals.writeZDepth', 0)
# cmds.setAttr('defaultHardwareRenderGlobals.lightingMode', 0)
# cmds.setAttr('defaultHardwareRenderGlobals.drawStyle', 3)
# cmds.setAttr('defaultHardwareRenderGlobals.texturing', 1)
# cmds.setAttr('defaultHardwareRenderGlobals.lineSmoothing', 1)
# cmds.setAttr('defaultHardwareRenderGlobals.fullImageResolution', 1)
# cmds.setAttr('defaultHardwareRenderGlobals.geometryMask', 1)
# cmds.setAttr('defaultHardwareRenderGlobals.backgroundColor', 0, 1, 0, type = 'double3')
# cmds.glRenderEditor('hardwareRenderView', edit = True, lookThru = shotCam[0])
# cmds.workspace(fileRule = ['images', publish_path])
# cmds.glRender(renderSequence = 'hardwareRenderView')
###############################################################################################
## Playblast Render
###############################################################################################
# Get shotCams
non_startup_cams = [cmds.listRelatives(cam, parent = True, fullPath = True)[0] for cam in cmds.ls(cameras = True) if not cmds.camera(cam, query = True, startupCamera = True)]
shotCam = [cam for cam in non_startup_cams if cmds.objExists('%s.type' % cam)]
shotCamShape = [cmds.listRelatives(cam, shapes = True, fullPath = True)[0] for cam in shotCam if cmds.getAttr('%s.type' % cam) == 'shotCam']
# Get model panel
model_panel = cmds.getPanel(withFocus = True)
proceed = False
if not shotCamShape:
cmds.warning('No shotCam found in scene, please fix it first...!')
else:
if not cmds.objExists('ocean_dispShader'):
cmds.warning('ocean_dispShader not found in scene, please fix it first...!')
else:
if not cmds.objExists('oceanPreviewPlane_heightF'):
cmds.warning('oceanPreviewPlane_heightF not found in scene, please fix it first...!')
else:
if not 'modelPanel' in model_panel:
cmds.warning('No valid modelPanel in focus for playblasting...!')
else:
proceed = True
if proceed == True:
for cam in shotCamShape:
## Set appropriate camera display option settings for optimal playblasting
cmds.setAttr('%s.overscan' % cam, 1)
cmds.setAttr('%s.displayFilmGate' % cam, 0)
cmds.setAttr('%s.displayResolution' % cam, 0)
cmds.setAttr('%s.displayGateMask' % cam, 0)
cmds.setAttr('%s.displayFieldChart' % cam, 0)
cmds.setAttr('%s.displaySafeAction' % cam, 0)
cmds.setAttr('%s.displaySafeTitle' % cam, 0)
cmds.setAttr('%s.displayFilmPivot' % cam, 0)
cmds.setAttr('%s.displayFilmOrigin' % cam, 0)
## Set appropriate "SHOW" to modelPanel
cmds.modelEditor(model_panel, edit = True, displayLights = 'none')
cmds.modelEditor(model_panel, edit = True, displayLights = 'default', camera = shotCamShape[0], allObjects = False, polymeshes = True, nParticles = True, manipulators = True, pluginShapes = True, pluginObjects = ['gpuCacheDisplayFilter', True], useDefaultMaterial = True, displayAppearance = 'flatShaded', displayTextures = True)
## Set lambert1 to green matte
cmds.setAttr("lambert1.color", 0, 10, 0, type = 'double3')
cmds.setAttr("lambert1.transparency", 0, 0, 0, type = 'double3')
cmds.setAttr("lambert1.ambientColor", 0, 10, 0, type = 'double3')
cmds.setAttr("lambert1.incandescence", 0, 10, 0, type = 'double3')
cmds.setAttr("lambert1.diffuse", 0)
cmds.setAttr("lambert1.translucence", 0)
cmds.setAttr("lambert1.translucenceDepth", 0)
cmds.setAttr("lambert1.translucenceFocus", 0)
## Set ocean shader to green matte
if cmds.isConnected('ocean_dispShader.outColor', 'oceanPreviewPlane_heightF.color'):
cmds.disconnectAttr('ocean_dispShader.outColor', 'oceanPreviewPlane_heightF.color')
cmds.setAttr('oceanPreviewPlane_heightF.color', 0, 1, 0, type = 'double3')
## Set view port BG to green matte
default_bg_color = cmds.displayRGBColor('background', q = True)
default_bgTop_color = cmds.displayRGBColor('backgroundTop', q = True)
default_bgBtm_color = cmds.displayRGBColor('backgroundBottom', q = True)
cmds.displayRGBColor('background', 0, 1, 0)
cmds.displayRGBColor('backgroundTop', 0, 1, 0)
cmds.displayRGBColor('backgroundBottom', 0, 1, 0)
## Get timeslider min/max
min = cmds.playbackOptions(min = True, q = True)
max = cmds.playbackOptions(max = True, q = True)
## Force current time to min of time slider to avoid popping at frame 1 issue
[cmds.currentTime(min) for i in range(2)]
## Now find the fx stuff and make sure the groups are visible and good for playblasting
grps = ['OCEAN_hrc', 'oceanPreviewPlane_prv']
for eachGrp in grps:
if cmds.objExists(eachGrp):
cmds.setAttr('%s.visibility' % eachGrp, True)
cmds.select(clear = True)
## Find all mesh in scene that has smoothed checked and Mentalray preview smooth them...
mesh_with_smoothTag = [cmds.listRelatives(mesh, parent = True, fullPath = True)[0] for mesh in cmds.ls(type = 'mesh') if cmds.objExists('%s.smoothed' % cmds.listRelatives(mesh, parent = True, fullPath = True)[0])]
mesh_with_smoothTag = [mesh for mesh in mesh_with_smoothTag if cmds.getAttr('%s.smoothed' % mesh)]
[cmds.displaySmoothness(each, polygonObject = 3) for each in mesh_with_smoothTag if 'CHAR_' in each or 'PROP_' in each]
## Playblast rendering
cmds.playblast( filename = os.path.join(publish_path, epShotName).replace('\\', '/'),
clearCache = True,
startTime = min,
endTime = max,
viewer = False,
forceOverwrite = True,
format = 'image',
compression = 'png',
framePadding = 4,
offScreen = True,
options = False,
percent = 100,
quality = 100,
sequenceTime = False,
showOrnaments = False,
widthHeight = [(1280 * 3), (720 * 3)]
)
## Find all mesh in scene and un-preview smooth them...
[cmds.displaySmoothness(mesh, polygonObject = 1) for mesh in cmds.ls(type = 'mesh')]
## After playblast, set back the scene BG's color as default
cmds.displayRGBColor('background', default_bg_color[0], default_bg_color[1], default_bg_color[2])
cmds.displayRGBColor('backgroundTop', default_bgTop_color[0], default_bgTop_color[1], default_bgTop_color[2])
cmds.displayRGBColor('backgroundBottom', default_bgBtm_color[0], default_bgBtm_color[1], default_bgBtm_color[2])
## Set appropriate "SHOW" to modelPanel back...
cmds.modelEditor(model_panel, edit = True, useDefaultMaterial = False, displayTextures = False, displayAppearance = 'smoothShaded', activeOnly = False)
## Set lambert1 to default
cmds.setAttr("lambert1.color", 0.5, 0.5, 0.5, type = 'double3')
cmds.setAttr("lambert1.transparency", 0, 0, 0, type = 'double3')
cmds.setAttr("lambert1.ambientColor", 0, 0, 0, type = 'double3')
cmds.setAttr("lambert1.incandescence", 0, 0, 0, type = 'double3')
cmds.setAttr("lambert1.diffuse", 0.8)
cmds.setAttr("lambert1.translucence", 0)
cmds.setAttr("lambert1.translucenceDepth", 0.5)
cmds.setAttr("lambert1.translucenceFocus", 0.5)
## Set ocean shader to default color
if not cmds.isConnected('ocean_dispShader.outColor', 'oceanPreviewPlane_heightF.color'):
cmds.connectAttr('ocean_dispShader.outColor', 'oceanPreviewPlane_heightF.color', force = True)
## Finally after render, register publish to shotgun...
self._register_publish(publish_path,
group_name,
sg_task,
publish_version,
tank_type,
comment,
thumbnail_path,
[primary_publish_path])
print 'Successfully rendered nParticles Splashes to %s...' % os.path.join(publish_path, epShotName).replace('\\', '/')
print '=================================================='
def makePreview(file,
camera,
useDefaultMaterial,
percent,
quality,
startFrame,
endFrame,
widthHeight,
showOrnaments=1):
#
width, height = widthHeight
#
widthReduce = width
heightReduce = height
# Reduce Width and Height
checkValue = max(widthHeight)
if checkValue > 2048:
if width > height:
widthReduce = 2048
heightReduce = 2048 * height / width
if width < height:
widthReduce = 2048 * width / height
heightReduce = 2048
widthHeightReduce = widthReduce, heightReduce
#
filePath = os.path.dirname(file)
fileName = os.path.basename(file)
#
isMov = os.path.splitext(fileName)[-1] == '.mov'
format = [os.path.splitext(fileName)[-1][1:], u'qt'][isMov]
compression = [u'IYUV 编码解码器', u'H.264'][isMov]
#
prvName = os.path.splitext(file)[0]
#
prvWindow = "previewWindowName"
removeMayaWindow(prvWindow)
cmds.window(prvWindow, title='Animation Preview')
paneLayout = cmds.paneLayout(width=widthReduce / 2,
height=heightReduce / 2)
animationView = cmds.modelPanel(label=prvWindow,
parent=paneLayout,
menuBarVisible=0,
modelEditor=0,
camera=camera)
cmds.displayRGBColor('background', .25, .25, .25)
cmds.displayRGBColor('backgroundTop', .25, .25, .25)
cmds.displayRGBColor('backgroundBottom', .25, .25, .25)
cmds.showWindow(prvWindow)
# Set Maye View
cmds.modelEditor(animationView,
edit=1,
activeView=1,
useDefaultMaterial=useDefaultMaterial,
wireframeOnShaded=0,
fogging=0,
dl='default',
twoSidedLighting=0,
allObjects=0,
manipulators=0,
grid=0,
hud=1,
sel=0)
cmds.modelEditor(animationView,
edit=1,
activeView=1,
polymeshes=1,
subdivSurfaces=1,
fluids=1,
strokes=1,
nCloths=1,
nParticles=1,
pluginShapes=1,
pluginObjects=['gpuCacheDisplayFilter', 1],
displayAppearance='smoothShaded')
# Video Preview
cmds.playblast(startTime=startFrame,
endTime=endFrame,
format=format,
filename=prvName,
clearCache=1,
viewer=0,
showOrnaments=showOrnaments,
offScreen=1,
framePadding=4,
percent=percent,
compression=compression,
quality=quality,
widthHeight=widthHeightReduce)
# # Image Preview
# midFrame = int((endFrame - startFrame) / 2 + startFrame)
# frameRange = [startFrame, midFrame, endFrame]
# frameDic = {startFrame: '0000', midFrame: '0001', endFrame: '0002'}
# for frame in frameRange:
# cmds.playblast( startTime=frame,
# endTime=frame,
# format='iff',
# filename=prvName,
# sequenceTime=0,
# clearCache=1,
# viewer=0,
# showOrnaments=0,
# offScreen=0,
# framePadding=4,
# percent=percent,
# compression='jpg',
# quality=quality)
# previewFile = prvName + '_' + frameDic[frame] + '.jpg'
# if os.path.exists(previewFile):
# os.remove(previewFile)
# os.rename(prvName + '.' + str(frame).zfill(4) + '.jpg', previewFile)
# Remove Widow
removeMayaWindow(prvWindow)
def background(self, values):
'''Set the background color of the Viewport.
:param values: RGB value'''
cmds.displayRGBColor('background', *values)
def defaultScriptEditorColors():
"""
set the default maya environment color scheme
"""
cmds.displayRGBColor('syntaxKeywords', 0.0, 1.0, 0.0)
cmds.displayRGBColor('syntaxText', 0.78431373834609985, 0.78431373834609985, 0.78431373834609985)
cmds.displayRGBColor('syntaxStrings', 1.0, 1.0, 0.0)
cmds.displayRGBColor('syntaxComments', 1.0, 0.0, 0.0)
cmds.displayRGBColor('syntaxCommands', 0.0, 1.0, 1.0)
cmds.displayRGBColor('syntaxBackground', 0.16470588743686676, 0.16470588743686676, 0.16470588743686676)
def customScriptEditorColors():
"""
set custom maya environment color scheme
"""
cmds.displayRGBColor('syntaxKeywords', 0.14, 0.9, 0.14)
cmds.displayRGBColor('syntaxText', 0.84, 0.84, 0.84)
cmds.displayRGBColor('syntaxStrings', 0.09, 0.4, 0.1)
cmds.displayRGBColor('syntaxComments', 0.45, 0.45, 0.45)
cmds.displayRGBColor('syntaxCommands', 0.75, 0.75, 0.27)
cmds.displayRGBColor('syntaxBackground', 0.15, 0.15, 0.15)
def background(self, values):
'''Set the background color of the Viewport.
:param values: RGB value'''
cmds.displayRGBColor('background', *values)
def process(self, instance):
self.log.info("Extracting capture..")
components = instance.data['ftrackComponents'].copy()
self.log.debug('Components: {}'.format(components))
camera = instance[0]
if 'persp' in camera:
self.log.info("If you want movie review, create a camera with \
'_CAM' suffix")
return
format = instance.data('format') or 'qt'
compression = instance.data('compression') or 'h264'
off_screen = instance.data('offScreen', False)
maintain_aspect_ratio = instance.data('maintainAspectRatio', True)
try:
preset = capture.parse_active_view()
if 'show' in instance.data():
self.log.info("Overriding show: %s" % instance.data['show'])
for nodetype in instance.data['show']:
# self.log.info("Overriding show: %s" % nodetype)
if hasattr(preset['viewport_options'], nodetype):
setattr(preset['viewport_options'], nodetype, True)
else:
self.log.warning("Specified node-type in 'show' not "
"recognised: %s" % nodetype)
except:
camera_shape = cmds.listRelatives(camera, shapes=True)[0]
preset = {
"camera": camera,
"width": cmds.getAttr("defaultResolution.width"),
"height": cmds.getAttr("defaultResolution.height"),
"camera_options": type("CameraOptions", (object, capture.CameraOptions,), {
"displayFilmGate": cmds.getAttr(camera_shape + ".displayFilmGate"),
"displayResolution": cmds.getAttr(camera_shape + ".displayResolution"),
"displaySafeAction": cmds.getAttr(camera_shape + ".displaySafeAction"),
}),
"viewport_options": type("ViewportOptions", (object, capture.ViewportOptions,), {
"useDefaultMaterial": False,
"wireframeOnShaded": False,
# "displayAppearance": cmds.modelEditor(panel, query=True, displayAppearance=True),
"displayTextures": True,
"displayLights": True,
"shadows": True,
}),
"display_options": type("DisplayOptions", (object, capture.DisplayOptions,), {
"background": cmds.displayRGBColor('background', q=True),
"backgroundTop": cmds.displayRGBColor('backgroundTop', q=True),
"backgroundBottom": cmds.displayRGBColor('backgroundBottom', q=True),
'displayGradient': cmds.displayPref(dgr=True, q=True),
}),
}
# Ensure name of camera is valid
sourcePath = os.path.normpath(instance.context.data('currentFile'))
path, extension = os.path.splitext(sourcePath)
path = (path + ".png")
# Ensure name of camera is valid
sourcePath = os.path.normpath(instance.context.data('currentFile'))
path, extension = os.path.splitext(sourcePath)
if format == 'image':
# Append sub-directory for image-sequence
path = os.path.join(path, camera)
else:
path = (path + ".mov")
self.log.info("Outputting to %s" % path)
with maintained_time():
output = capture.capture(
# camera=camera,
# width=width,
# height=height,
filename=path,
# start_frame=start_frame,
# end_frame=end_frame,
format=format,
viewer=False,
compression=compression,
off_screen=off_screen,
maintain_aspect_ratio=maintain_aspect_ratio,
overwrite=True,
quality=80,
**preset
)
instance.data["outputPath_qt"] = output
