def uninitializePlugin(mobject):
global rendererModules
global materialNodeModules
global generalNodeModules
mplugin = OpenMayaMPx.MFnPlugin(mobject)
for rendererModule in rendererModules:
try:
cmds.renderer(rendererModule.kPluginCmdName, edit=True, unregisterRenderer=True)
except:
sys.stderr.write( "Failed to unregister renderer: %s\n" % kPluginCmdName )
try:
mplugin.deregisterCommand( kPluginCmdName )
except:
sys.stderr.write( "Failed to unregister command: %s\n" % kPluginCmdName )
# Unregister materials
try:
for materialNodeModule in materialNodeModules:
mplugin.deregisterNode( materialNodeModule.kPluginNodeId )
except:
sys.stderr.write( "Failed to deregister node: %s\n" % materialNodeModule.kPluginNodeName )
raise
# Unregister general nodes
try:
for generalNodeModule in generalNodeModules:
mplugin.deregisterNode( generalNodeModule.kPluginNodeId )
except:
sys.stderr.write( "Failed to deregister node: %s\n" % generalNodeModule.kPluginNodeName )
raise
def get_available_renderers(self):
"""
Return a list of available renderers.
"""
res = []
renderers = cmds.renderer(query=True, namesOfAvailableRenderers=True)
for renderer in renderers:
renderer_ui_name = cmds.renderer(renderer,
query=True,
rendererUIName=True)
res.append((renderer_ui_name, renderer))
return res
def uninitializePlugin(mobject):
global materialNodeModules
global generalNodeModules
mplugin = OpenMayaMPx.MFnPlugin(mobject)
try:
cmds.renderer("Mitsuba", edit=True, unregisterRenderer=True)
except:
sys.stderr.write( "Failed to unregister renderer: %s\n" % kPluginCmdName )
try:
mplugin.deregisterCommand( kPluginCmdName )
except:
sys.stderr.write( "Failed to unregister command: %s\n" % kPluginCmdName )
def uninitializePlugin(mobject):
global materialNodeModules
global generalNodeModules
mplugin = OpenMayaMPx.MFnPlugin(mobject)
try:
cmds.renderer("Cycles", edit=True, unregisterRenderer=True)
except:
sys.stderr.write("Failed to unregister renderer: %s\n" %
kPluginCmdName)
try:
mplugin.deregisterCommand(kPluginCmdName)
except:
sys.stderr.write("Failed to unregister command: %s\n" % kPluginCmdName)
def get_renderer_globals_node(renderer_name):
'''
For the given renderer name, return the name of its renderer globals node.
#TODO:(lws)
Note that if more than one node is found, raise an exception. This is to
simplify things for now, but may need to support multiple nodes later.
renderer_name: str. e.g. "vray" or "arnold"
return: str. e.g. "defaultRenderGlobals"
'''
if not renderer_exists(renderer_name):
logger.debug("Renderer does not exist: %s", renderer_name)
return ""
globals_nodes = cmds.renderer(renderer_name, q=True,
globalsNodes=True) or []
if not globals_nodes:
return ""
if len(globals_nodes) > 1:
raise Exception("More than 1 %s renderer globals node found: %s" %
(renderer_name, globals_nodes))
return globals_nodes[0]
def renderer_exists(renderer_name):
'''
Return True if the given renderer (name) can be found in the maya session
renderer_name: str. e.g. "vray" or "arnold"
'''
return renderer_name in (cmds.renderer(q=True, namesOfAvailableRenderers=True) or [])
def _WriteViewportImage(self, outputImageName, suffix):
# Make sure the hardware renderer is available
MAYA_RENDERER_NAME = 'mayaHardware2'
mayaRenderers = cmds.renderer(query=True, namesOfAvailableRenderers=True)
self.assertIn(MAYA_RENDERER_NAME, mayaRenderers)
# Make it the current renderer.
cmds.setAttr('defaultRenderGlobals.currentRenderer', MAYA_RENDERER_NAME,
type='string')
# Set the image format to PNG.
cmds.setAttr('defaultRenderGlobals.imageFormat', 32)
# Set the render mode to shaded and textured.
cmds.setAttr('hardwareRenderingGlobals.renderMode', 4)
# Specify the output image prefix. The path to it is built from the
# workspace directory.
cmds.setAttr('defaultRenderGlobals.imageFilePrefix',
'%s_%s' % (outputImageName, suffix),
type='string')
# Apply the viewer's color transform to the rendered image, otherwise
# it comes out too dark.
cmds.setAttr("defaultColorMgtGlobals.outputTransformEnabled", 1)
# Do the render.
cmds.ogsRender(camera=self._cameraName, currentFrame=True,
width=self._viewportWidth, height=self._viewportHeight)
def _WriteViewportImage(self, outputImageName, suffix):
# Make sure the hardware renderer is available
MAYA_RENDERER_NAME = 'mayaHardware2'
mayaRenderers = cmds.renderer(query=True, namesOfAvailableRenderers=True)
self.assertIn(MAYA_RENDERER_NAME, mayaRenderers)
# Make it the current renderer.
cmds.setAttr('defaultRenderGlobals.currentRenderer', MAYA_RENDERER_NAME,
type='string')
# Set the image format to PNG.
cmds.setAttr('defaultRenderGlobals.imageFormat', 32)
# Set the render mode to shaded and textured.
cmds.setAttr('hardwareRenderingGlobals.renderMode', 4)
# Specify the output image prefix. The path to it is built from the
# workspace directory.
cmds.setAttr('defaultRenderGlobals.imageFilePrefix',
'%s_%s' % (outputImageName, suffix),
type='string')
# Apply the viewer's color transform to the rendered image, otherwise
# it comes out too dark.
cmds.setAttr("defaultColorMgtGlobals.outputTransformEnabled", 1)
# Do the render.
cmds.ogsRender(camera=self._cameraName, currentFrame=True, width=1920,
height=1080)
def get_renderers(self):
render_engines = []
render_name = mc.renderer(query=True, namesOfAvailableRenderers=True)
for renderers in render_name:
if renderers in ['arnold','vray','renderman','redshift']:
render_engines.append(renderers)
return render_engines
def get_render_engines(self):
renders = []
plugins = cmds.renderer(query=True, namesOfAvailableRenderers=True)
for plugin in plugins:
if plugin not in ['mayaHardware2', 'mayaVector', 'turtle']:
renders.append(plugin)
return renders
def render_frame(frame):
# Set frame range.
render_globals = pm.PyNode("defaultRenderGlobals")
render_globals.startFrame.set(frame)
render_globals.endFrame.set(frame)
# Collect sequence render data.
data = {
"sequence_render_function": "",
"camera": "persp",
"width": 0,
"height": 0,
"save_to_render_view": ""
}
# Get render camera.
for node in pm.ls(type="camera"):
if node.renderable.get():
data["camera"] = node.getParent().name()
# Sequence render mel function.
data["sequence_render_function"] = cmds.renderer(
cmds.getAttr("defaultRenderGlobals.currentRenderer"),
query=True,
renderSequenceProcedure=True)
# Get resolution.
data["width"] = pm.getAttr("defaultResolution.width")
data["height"] = pm.getAttr("defaultResolution.height")
# Render sequence.
mel.eval("{sequence_render_function}({width}, {height}, \"{camera}\", "
"\"{save_to_render_view}\")".format(**data))
def __init__(self, renderer, defaultNodeExporter):
super(DefaultRendererNodeExporter, self).__init__()
nodes = set(cmds.renderer(renderer, query=True, globalsNodes=True))
# Compute the list of nodes specific to a renderer
nodes.difference_update(defaultNodeExporter.getNodes())
# Preserve the computed list
self.setNodes(list(nodes))
def _WriteViewportImage(self, outputImageName, suffix):
# Make sure the hardware renderer is available
MAYA_RENDERER_NAME = 'mayaHardware2'
mayaRenderers = cmds.renderer(query=True, namesOfAvailableRenderers=True)
self.assertIn(MAYA_RENDERER_NAME, mayaRenderers)
# Make it the current renderer.
cmds.setAttr('defaultRenderGlobals.currentRenderer', MAYA_RENDERER_NAME,
type='string')
# Set the image format to PNG.
cmds.setAttr('defaultRenderGlobals.imageFormat', 32)
# Set the render mode to shaded and textured.
cmds.setAttr('hardwareRenderingGlobals.renderMode', 4)
# Enable the UI object filter so that the rendered image includes
# selection highlighting when using the Viewport 2.0 render delegate.
filterNames = cmds.getAttr(
'hardwareRenderingGlobals.objectTypeFilterNameArray')
filterIndex = filterNames.index('UI')
filterValues = cmds.getAttr(
'hardwareRenderingGlobals.objectTypeFilterValueArray')
filterValues[filterIndex] = 1
cmds.setAttr('hardwareRenderingGlobals.objectTypeFilterValueArray',
filterValues, type='Int32Array')
# Specify the output image prefix. The path to it is built from the
# workspace directory.
cmds.setAttr('defaultRenderGlobals.imageFilePrefix',
'%s_%s' % (outputImageName, suffix),
type='string')
# Apply the viewer's color transform to the rendered image, otherwise
# it comes out too dark.
cmds.setAttr("defaultColorMgtGlobals.outputTransformEnabled", 1)
# Do the render.
cmds.ogsRender(camera=self._cameraName, currentFrame=True,
width=self._viewportWidth, height=self._viewportHeight)
def create_vray_settings():
# Try register vray
try:
cmds.renderer("vray")
except RuntimeError:
print("Vray already Registered")
# Collect all vray-Attributes
globalsTabLabels = cmds.renderer("vray", query=True, globalsTabLabels=True)
globalsTabCreateProcNames = cmds.renderer("vray",
query=True,
globalsTabCreateProcNames=True)
globalsTabUpdateProcNames = cmds.renderer("vray",
query=True,
globalsTabUpdateProcNames=True)
# Construct Vray-Renderer
for tab_id in range(len(globalsTabLabels)):
cmds.renderer("vray",
edit=True,
addGlobalsTab=[
str(globalsTabLabels[tab_id]),
str(globalsTabCreateProcNames[tab_id]),
str(globalsTabUpdateProcNames[tab_id]),
])
# Create DAG for VRAYSETTINGS
cmds.shadingNode("VRaySettingsNode", asUtility=True, name="vraySettings")
def get_renderer_plugin(renderer_name):
'''
For the given renderer name, return the renderer's plugin name
Attempt to find the corellation between the renderer name and the plugin name
by asking maya for it's active renderer's global render settings node,
and then asking what node type that is, and then asking which plugin provides
the node type.
# THIS DOESN'T ALWAYS WORK! For some reason the "vraysettings" node isn't
# always listed as one of the global render settings nodes. So we resort
# to a hard mapping of needed
'''
# Mapping of render name to plugin name
renderer_plugin_map = {"vray": "vrayformaya", "arnold": "mtoa"}
# register the rendeder if not's not already registered
if not cmds.renderer(renderer_name, exists=True):
logger.debug("registering renderer: %s", renderer_name)
cmds.renderer(renderer_name)
# Get all plugin node types
plugin_node_types = {}
for plugin_name in cmds.pluginInfo(q=True, listPlugins=True) or []:
plugin_node_types[plugin_name] = cmds.pluginInfo(
plugin_name, q=True, dependNode=True) or []
# Cycle through all all of the global render settings nodes
for node in cmds.renderer(renderer_name, q=True, globalsNodes=True) or []:
for plugin_name, node_types in plugin_node_types.iteritems():
if cmds.nodeType(node) in node_types:
return plugin_name
# Resort to a hard-coded mapping as a fail-safe
# TODO:(lws) This should not be necesary. Find a more reliable way to find the renderer plugin name!
logger.warning(
"Unable to determine plugin from renderer's global render nodes. Resorting to hard mapping"
)
return renderer_plugin_map.get(renderer_name)
def renderer(*args, **kwargs):
if len(args):
doPassSelf = kwargs.pop('passSelf', False)
else:
doPassSelf = False
for key in ['commandRenderProcedure', 'cr']:
try:
cb = kwargs[key]
if callable(cb):
kwargs[key] = _factories.makeUICallback(cb, args, doPassSelf)
except KeyError:
pass
res = cmds.renderer(*args, **kwargs)
return res
def registerRenderer ():
# Defore register the renderer, you need to register command to eval the render
try:
# Register renderer
mc.renderer ("niepce", rendererUIName = "Niepce Renderer")
# Attach globals node
mc.renderer ("niepce", edit = True, addGlobalsNode = "defaulRenderGlobals")
mc.renderer ("niepce", edit = True, addGlobalsTab = ("Common", "createMayaSoftwareCommonGlobalsTab","updateMayaSoftwareCommonGlobalsTab"))
# Pre render support
# - Render region is not supported
# - Batch render is not support
mc.renderer ("niepce",
edit = True,
renderProcedure = "niStartRendering")
except:
om.MGlobal.displayError ("Faild to register renderer.")
def _Snapshot(self, outName):
cmds.select([])
# Make sure the hardware renderer is available
MAYA_RENDERER_NAME = 'mayaHardware2'
mayaRenderers = cmds.renderer(query=True, namesOfAvailableRenderers=True)
self.assertIn(MAYA_RENDERER_NAME, mayaRenderers)
# Make it the current renderer.
cmds.setAttr('defaultRenderGlobals.currentRenderer', MAYA_RENDERER_NAME,
type='string')
# Set the image format to PNG.
cmds.setAttr('defaultRenderGlobals.imageFormat', 32)
# Set the render mode to shaded and textured.
cmds.setAttr('hardwareRenderingGlobals.renderMode', 4)
cmds.setAttr('defaultRenderGlobals.imageFilePrefix', outName,
type='string')
# Do the render.
cmds.ogsRender(camera='top', currentFrame=True, width=400, height=400)
def setUpClass(cls):
super(RenderSetupTest, cls).setUpClass()
cls.previousAutoConvertFlag = None if not conversion.hasAutoConvertFlag(
) else conversion.getAutoConvertFlag()
conversion.setAutoConvertFlag(
False) # otherwise a dialog prompts during non-batch test
# Unpredictability of idle queue job execution timing means that
# some idle queue jobs (e.g. mental ray plugin load) execute in
# legacy render layer mode (which is what our automated tests are
# set up to do), but render setup tests expect render setup mode.
# With flushIdleQueue() at start of render setup tests, all test
# executions start with the same clean slate for idle queue jobs.
cmds.flushIdleQueue()
# This MEL global variable controls which render layer system is used
# to run regression tests. By default, even when using render setup,
# regression tests are run in legacy render layer mode, so that
# legacy render layer tests run unchanged and therefore flag any
# legacy render layer regressions.
# Here, we change the mode to render setup during the render setup tests."
mel.eval(
"global int $renderSetupEnableDuringTests; $renderSetupEnableDuringTests = 1"
)
# Some code now needs to have the mayaSoftware renderer to succeed
# when it manipulates a render setup and/or a render layer because
# of the Render Settings collection.
# A Render Settings collection requests all the default nodes from
# the default renderer. When executing some regression tests
# through Mutt the default renderer (i.e. mayaSoftware) is not loaded.
# Impose mayaSoftware as the default renderer
if not cmds.renderer("mayaSoftware", exists=True):
mel.eval('registerMayaSoftwareRenderer')
cls._prevRenderer = cmds.preferredRenderer(query=True)
cmds.preferredRenderer("mayaSoftware", makeCurrent=True)
import maya.cmds as cmds
import maya.mel as mel
import mtoa.utils
from mtoa.core import createOptions
import dwpublish_index
import os
import json
"""
Load MTOA plugin if not present
"""
if cmds.renderer("arnold", exists=True) == 0:
cmds.loadPlugin("mtoa.so")
'''
Create Arnold Render Options nodes
'''
createOptions()
'''
Files Path
'''
iblFilePath = '/servers/RHS/DEV/nleblanc/dad/turntable/sourceimages/ibl_neutral_rig_01.tx'
cycloGeoFilePath = '/servers/RHS/DEV/nleblanc/dad/turntable/geo/cyclo_v003.abc'
camPropsFilePath = '/servers/RHS/DEV/nleblanc/dad/turntable/geo/props_cam.abc'
macBethFilePath = '/servers/RHS/DEV/nleblanc/dad/turntable/sourceimages/macBeth_1k.tx'
dadGeoFilePath = '/servers/RHS/DEV/nleblanc/dad/turntable/geo/dad_v001.abc'
'''
Procedures
'''
def getSceneBBoxCenter(model):
rootBBox = cmds.exactWorldBoundingBox(model, ignoreInvisible=True)
def unr():
cmds.renderer('test', edit=True, unr=True)
def uninitializePlugin(mobject):
global rendererModules
global generalNodeModules
global shadingNodeGroups
global translatorModules
mplugin = OpenMayaMPx.MFnPlugin(mobject, kPluginCompany, "1.0", "Any")
for rendererModule in rendererModules:
try:
cmds.renderer(rendererModule.kPluginCmdName,
edit=True,
unregisterRenderer=True)
except:
sys.stderr.write("Failed to unregister renderer: %s\n" %
rendererModule.kPluginCmdName)
try:
mplugin.deregisterCommand(rendererModule.kPluginCmdName)
except:
sys.stderr.write("Failed to unregister command: %s\n" %
rendererModule.kPluginCmdName)
# Unregister materials, textures, volumes, lights
for shadingModule, shadingNodeNames in shadingNodeGroups.iteritems():
print("%s - Unegistering %s nodes" % (kPluginName, shadingModule))
for shadingNodeName in shadingNodeNames:
try:
node = None
try:
__import__(shadingModule, fromlist=[shadingNodeName])
module = sys.modules[shadingModule + '.' + shadingNodeName]
reload(module)
node = module
except ImportError:
OpenMaya.MGlobal.displayError(
"Failed to load %s" %
(shadingModule + '.' + shadingNodeName))
if node:
mplugin.deregisterNode(node.kPluginNodeId)
except:
sys.stderr.write("Failed to unregister node: %s\n" %
(shadingModule + '.' + shadingNodeName))
raise
# Unregister general nodes
try:
for generalNodeModule in generalNodeModules:
mplugin.deregisterNode(generalNodeModule.kPluginNodeId)
except:
sys.stderr.write("Failed to unregister node: %s\n" %
generalNodeModule.kPluginNodeName)
raise
# Unregister translator nodes
try:
for translatorModule in translatorModules:
if translatorModule:
mplugin.deregisterFileTranslator(
translatorModule.kPluginTranslatorTypeName)
except:
sys.stderr.write("Failed to unregister node: %s\n" %
translatorModule.kPluginTranslatorTypeName)
raise
def unregisterArnoldRenderer():
cmds.deleteUI('ArnoldMenu', menu=True)
cmds.renderer('arnold', unregisterRenderer=True)
arnoldShelf.removeArnoldShelf()
rendererCallbacks.clearCallbacks()
def registerRenderer():
cmds.renderer("Cycles", rendererUIName=kPluginCmdName)
cmds.renderer("Cycles", edit=True, renderProcedure=kPluginCmdName)
batchRenderProcedureMel = createMelPythonCallback("CyclesRenderer",
"batchRenderProcedure",
True)
cmds.renderer("Cycles",
edit=True,
batchRenderProcedure=batchRenderProcedureMel)
commandRenderProcedureMel = createMelPythonCallback(
"CyclesRenderer", "commandRenderProcedure", True)
cmds.renderer("Cycles",
edit=True,
commandRenderProcedure=commandRenderProcedureMel)
batchRenderOptionsProcedureMel = createMelPythonCallback(
"CyclesRenderer", "batchRenderOptionsProcedure")
cmds.renderer("Cycles",
edit=True,
batchRenderOptionsProcedure=batchRenderOptionsProcedureMel)
batchRenderOptionsStringProcedureMel = createMelPythonCallback(
"CyclesRenderer", "batchRenderOptionsStringProcedure")
cmds.renderer(
"Cycles",
edit=True,
batchRenderOptionsStringProcedure=batchRenderOptionsStringProcedureMel)
cancelBatchRenderProcedureMel = createMelPythonCallback(
"CyclesRenderer", "cancelBatchRenderProcedure")
cmds.renderer("Cycles",
edit=True,
cancelBatchRenderProcedure=cancelBatchRenderProcedureMel)
cmds.renderer("Cycles",
edit=True,
renderRegionProcedure="mayaRenderRegion")
cmds.renderer("Cycles",
edit=True,
addGlobalsTab=("Common",
"createMayaSoftwareCommonGlobalsTab",
"updateMayaSoftwareCommonGlobalsTab"))
cmds.renderer(
"Cycles",
edit=True,
addGlobalsTab=("Cycles Common",
createMelPythonCallback("CyclesRendererUI",
"createRenderSettings"),
createMelPythonCallback("CyclesRenderer",
"updateRenderSettings")))
cmds.renderer("Cycles",
edit=True,
addGlobalsNode="defaultCyclesRenderGlobals")
def get_renderers_list(self):
return cmds.renderer(query=True, namesOfAvailableRenderers=True)
def unregisterRenderer ():
try:
mc.renderer ("niepce", edit = True, unregisterRenderer = True)
except:
om.MGlobal.displayError ("Faild to unregister renderer.")
def register():
cmds.renderer( 'test', rendererUIName='Another Renderer')
#cmds.renderer( 'test', edit=True, addGlobalsNode='defaultRenderGlobals' )
cmds.renderer( 'test', edit=True, addGlobalsTab=('Common', test, up) )
print cmds.renderer( 'test', query=True, globalsTabUpdateProcNames=True )
def registerRenderer():
cmds.renderer("Mitsuba", rendererUIName=kPluginCmdName)
cmds.renderer("Mitsuba", edit=True, renderProcedure=kPluginCmdName)
batchRenderProcedureMel = createMelPythonCallback("MitsubaRenderer", "batchRenderProcedure", True)
cmds.renderer("Mitsuba", edit=True, batchRenderProcedure=batchRenderProcedureMel)
commandRenderProcedureMel = createMelPythonCallback("MitsubaRenderer", "commandRenderProcedure", True)
cmds.renderer("Mitsuba", edit=True, commandRenderProcedure=commandRenderProcedureMel)
batchRenderOptionsProcedureMel = createMelPythonCallback("MitsubaRenderer", "batchRenderOptionsProcedure")
cmds.renderer("Mitsuba", edit=True, batchRenderOptionsProcedure=batchRenderOptionsProcedureMel)
batchRenderOptionsStringProcedureMel = createMelPythonCallback("MitsubaRenderer", "batchRenderOptionsStringProcedure")
cmds.renderer("Mitsuba", edit=True, batchRenderOptionsStringProcedure=batchRenderOptionsStringProcedureMel)
cancelBatchRenderProcedureMel = createMelPythonCallback("MitsubaRenderer", "cancelBatchRenderProcedure")
cmds.renderer("Mitsuba", edit=True, cancelBatchRenderProcedure=cancelBatchRenderProcedureMel)
cmds.renderer("Mitsuba", edit=True, renderRegionProcedure="mayaRenderRegion" )
cmds.renderer("Mitsuba", edit=True, addGlobalsTab=("Common",
"createMayaSoftwareCommonGlobalsTab",
"updateMayaSoftwareCommonGlobalsTab"))
cmds.renderer("Mitsuba", edit=True, addGlobalsTab=("Mitsuba Common",
createMelPythonCallback("MitsubaRendererUI", "createRenderSettings"),
createMelPythonCallback("MitsubaRenderer", "updateRenderSettings")))
cmds.renderer("Mitsuba", edit=True, addGlobalsNode="defaultMitsubaRenderGlobals" )
def render(startFrame = None,endFrame = None,frameStep = 1,
render_dir = None,
renderLayer = None,camera = None,
renderer = 'sw',**kwargs):
# 解析输入参数
startFrame = startFrame if startFrame not in ['None'] else None
endFrame = endFrame if endFrame not in ['None'] else None
render_dir = render_dir if render_dir not in ['None'] else None
renderLayer = renderLayer if renderLayer not in ['None'] else None
camera = camera if camera not in ['None'] else None
renderer = renderer if renderer not in ['None'] else None
# 渲染相关设置
scenepath = os.path.abspath(kwargs['scene_path'])
print("\nSTEP 0 获取场景路径: {}\n".format(scenepath))
workspace = cmds.workspace(q=True,fullName = True) # /maya/projects/default
print("\nSTEP 1 获取工作空间: {}\n".format(workspace))
if not render_dir:
render_dir = '/'.join([workspace,'images'])
print("\nSTEP 2.1 设置渲染图片路径: {}\n".format(render_dir))
if not os.path.isdir(render_dir):
try:
os.makedirs(render_dir)
print("\nSTEP 2.2 新建图片路径: {}\n".format(render_dir))
except:
raise Exception('can not make Folder named: %s ' % render_dir)
open_scene(scenepath)
refs = list_referenced_files()
print("\nSTEP 4 场景相关文件: {} \n".format(refs))
# 设置起始和结束帧
if not startFrame:
startFrame = int(cmds.currentTime(query = True))
if (not endFrame) or (endFrame < startFrame):
endFrame = startFrame
# startFrame,endFrame = playback_selection_range()
print("\nSTEP 5 起始帧: {} 结束帧: {}\n".format(startFrame,endFrame))
# 设置渲染层， 不同的渲染器对渲染层有不同的配置参数
if not renderLayer:
renderLayer = cmds.editRenderLayerGlobals(q = True,currentRenderLayer = True)
print("\nSTEP 6.1 未指定渲染层，获取当前渲染层: {}\n".format(renderLayer))
elif renderLayer not in cmds.ls(type = 'renderLayer'):
renderLayer = cmds.editRenderLayerGlobals(q = True,currentRenderLayer = True)
print('\nSTEP 6.2 指定的渲染层不在当前maya环境上, 使用默认的渲染层: %s\n' %(renderLayer))
else:
if cmds.editRenderLayerGlobals(q = True,currentRenderLayer = True) != renderLayer:
cmds.editRenderLayerGlobals(currentRenderLayer = renderLayer)
print('\nSTEP 6.3 指定的渲染层在当前maya环境上,但不是当前默认渲染层，设置为默认渲染层: %s\n' %(renderLayer))
# 设置摄像机
render_cam = 'persp'
change_render_cam(render_cam)
print("\nSTEP 7 设置默认摄像机: {}\n".format(render_cam))
# get camera 获取摄像机
if not camera:
_cameras = [i for i in cmds.listCameras(p = True) if cmds.getAttr('%s.renderable' % i)]
if _cameras:
camera = _cameras[0]
else:
camera = 'persp'
print("\nSTEP 8 当前使用的摄像机: {}\n".format(camera))
#打印当前渲染器设置
# render_glob = "defaultRenderGlobals"
# list_Attr = cmds.listAttr(render_glob, r=True, s=True)
# print("\n")
# for attr in list_Attr:
# get_attr_name = "%s.%s"%(render_glob, attr)
# print("STEP 9 默认Render的全局配置信息: {} = {}".format(get_attr_name, cmds.getAttr(get_attr_name)))
# print("\n")
# load renderer 加载渲染器
currenders = cmds.renderer(q=True, namesOfAvailableRenderers=True)
print('\nSTEP 9 当前可用的渲染器有: {} \n'.format(currenders))
print("\nSTEP 10 当前插件路径: {} \n".format(os.environ['MAYA_PLUG_IN_PATH']))
cmds.loadPlugin( allPlugins=True )
if renderer:
if renderer:
if renderer != cmds.getAttr('defaultRenderGlobals.currentRenderer'):
renderer_dict = {'vray':'vrayformaya',
'arnold':'mtoa',
'mentalRay':'Mayatomr'}
for key in renderer_dict.keys():
if renderer == key:
if not cmds.pluginInfo(renderer_dict[key], q=True, l=True):
try:
cmds.loadPlugin(renderer_dict[key])
break
except:
raise Exception('can not load vray renderer')
try:
cmds.setAttr('defaultRenderGlobals.currentRenderer',renderer,type = 'string')
except:
raise Exception('error: set currentRenderer %s fail' % renderer)
else:
renderer = cmds.getAttr('defaultRenderGlobals.currentRenderer')
print('\nSTEP 12 指定的渲染器位当前默认渲染器: %s\n' %(renderer))
w, h = scene_resolution()
print('\nSTEP 13 当前图片分辨率：X={} Y={} .\n'.format(w,h))
# 设置图像输出格式 cmds.getAttr('defaultRenderGlobals.imageFormat',asString = True)
_format = getFormatType("PNG")
print('\nSTEP 14 设置输出图像的格式: %s\n' %(_format))
print('# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #')
print('STEP 15 开始执行渲染任务...\n')
cd = int(endFrame) + 1
for i in range(int(startFrame), int(cd)):
cmds.currentTime(i, u = True)
if renderer == 'sw':
cmds.render()
elif renderer == 'mr':
out = cmds.Mayatomr(preview = True, camera = camera)
print("cmds.Mayatomr:",out)
else:
pass
if renderer == 'vray':
cmds.setAttr ('defaultRenderGlobals.animation', 1 )
cmds.setAttr ('defaultRenderGlobals.startFrame', startFrame )
cmds.setAttr ('defaultRenderGlobals.endFrame', endFrame )
print(cmds.setAttr ('vraySettings.animBatchOnly', 0))
out = pm.vrend(preview = True,camera = camera)
print("pm.vrend:",out)
elif renderer == 'arnold':
for i in range(startFrame,endFrame+1,1):
cmds.currentTime(i)
out = cmds.arnoldRender(seq=str(i),camera = camera )
print("cmds.arnoldRender:",out)
print('# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #')
def getMayaRenderers():
return cmds.renderer(q=1, namesOfAvailableRenderers=1), cmds.getAttr(
"defaultRenderGlobals.currentRenderer")
def getListofAvailableRenderers(self):
return cmds.renderer(query=True, namesOfAvailableRenderers=True)
