def get_pass_names(renderer, layer):
"""Helper method to return the passes for a given layer"""
cur_layer = cmds.editRenderLayerGlobals(q=True, currentRenderLayer=True)
cmds.editRenderLayerGlobals(currentRenderLayer=layer)
pass_names = []
if renderer == zync.VRAY_RENDERER:
render_element_nodes = cmds.ls(type="VRayRenderElement")
for element in render_element_nodes:
if cmds.getAttr(element + '.enabled'):
element_attrs = cmds.listAttr(element)
vray_name_attr = [ x for x in element_attrs if re.match('vray_name_.*', x) or re.match('vray_filename_.*', x) ]
pass_names.append(cmds.getAttr(element + '.' +vray_name_attr[0]))
if renderer == zync.MENTAL_RAY_RENDERER:
pass_names.append('MasterBeauty')
render_pass_nodes = cmds.listConnections(layer + '.renderPass')
if render_pass_nodes:
for pass_ in render_pass_nodes:
print " pass %s for %s" % (pass_, layer)
if cmds.getAttr(pass_ + '.renderable'):
pass_names.append(pass_)
cmds.editRenderLayerGlobals(currentRenderLayer=cur_layer)
return pass_names
def modifySubdivisions(*args):
if cmds.objExists("CMForegroundPlane"):
if cmds.window("SubdivisionsTextWindow", query = True, exists = True):
cmds.deleteUI("SubdivisionsTextWindow")
SubdivisionTextClass.UpdateSubSnap()
if os.path.exists(SubdivisionTextClass.ImagePath):
cmds.window( "SubdivisionsTextWindow", title = "Subdivisions Text" )
cmds.formLayout("SubWriterLayout", numberOfDivisions=100, w = 740, h = 400)
cmds.picture( "BasePicture", image = SubdivisionTextClass.ImagePath )
cmds.editRenderLayerGlobals( currentRenderLayer = "Subdivision_0")
SubdivisionTextClass.subColor = cmds.getAttr("CMForegroundPlane.imageName")[-5]
cmds.editRenderLayerGlobals( currentRenderLayer = "defaultRenderLayer")
cmds.window( "SubdivisionsTextWindow", edit = True, w = 740, h = 400)
#Create popupMenu for images
cmds.popupMenu( "SubdivisionPopUp", parent = "BasePicture" )
cmds.menuItem( label='TopLeft' , p = "SubdivisionPopUp", c = functools.partial(SubdivisionTextClass.ChangePos, "lt") )
cmds.menuItem( label='TopRight' , p = "SubdivisionPopUp", c = functools.partial(SubdivisionTextClass.ChangePos, "rt") )
cmds.menuItem( label='BottomLeft' , p = "SubdivisionPopUp", c = functools.partial(SubdivisionTextClass.ChangePos, "lb") )
cmds.menuItem( label='BottomRight', p = "SubdivisionPopUp", c = functools.partial(SubdivisionTextClass.ChangePos, "rb") )
cmds.menuItem( label='ToggleColor', p = "SubdivisionPopUp", c = SubdivisionTextClass.toggleSubdivisionColour )
cmds.showWindow("SubdivisionsTextWindow")
else:
cmds.confirmDialog(m = "The signature camera must be created before running this tool")
def SubdivisionLevelChanged(*args):
cmds.editRenderLayerGlobals( currentRenderLayer = "defaultRenderLayer")
for mesh in cmds.listRelatives(cmds.getAttr("CMSettings.ModelName"), allDescendents = True):
try:
cmds.setAttr(mesh + "Smooth.divisions", cmds.intSlider("SubdivisionLevel",query = True, value = True))
except:
pass
def bRgb_mask(*args):
t = "MASK"
sels = cmds.ls(sl=True)
name = get_name(t)
sf = int(cmds.textFieldGrp('start_frame', q=True, tx=True))
ef = int(cmds.textFieldGrp('end_frame', q=True, tx=True))
print len(args)
if args[0] == "ch" :
type_l = ("face", "hair", "all")
for x in type_l:
name = get_name(args[0]+"_"+x+"_"+t)
if not(cmds.objExists(name)) :
rl = make_layer(name,sf,ef,t)
elif type(args[0]) == types.StringType:
name = get_name(args[0]+"_"+t)
if not(cmds.objExists(name)) :
rl = make_layer(name, sf, ef, t)
else :
name = get_name(t)
if not(cmds.objExists(name)) :
rl = make_layer(name, sf, ef, t)
if not(cmds.objExists(name)) :
cmds.editRenderLayerGlobals(crl= rl[0])
cmds.setAttr("defaultRenderGlobals.ren", "mayaSoftware", typ='string')
maya_set()
if len(sels) != 0 : cmds.select(sels,r=True)
return name
def NAMEmatchOverrideButton(* args):
clearList()
currentLayer = mc.editRenderLayerGlobals( query=True, currentRenderLayer=True )
selectionDefiner()
for trgCt in range(len(trgCmpList)):
for srcCt in range(len(srcCmpList)):
if trgCmpList[trgCt] == srcCmpList[srcCt]:
srcObjSel = srcTrList[srcCt]
trgObjSel = trgTrList[trgCt]
mc.select(srcObjSel,replace=True)
mc.select(trgObjSel,add=True)
getLayers()
getSelectedLayers()
for actLayer in actLayerList:
for selLayer in selLayerList:
if actLayer == selLayer:
mc.editRenderLayerGlobals(currentRenderLayer=actLayer)
overrideTransfer(actLayer)
actLayerList[:]=[]
selLayerList[:]=[]
sourceObj[:]=[]
targetObjs[:]=[]
sourceShape[:]=[]
targetShapes[:]=[]
if trgCmpList[trgCt] not in srcCmpList:
print trgTrList[trgCt] + " doesn't match! "
mc.select(srcGrp,replace=True)
mc.select(trgGrp,add=True)
mc.editRenderLayerGlobals(currentRenderLayer=currentLayer)
def collect_layer_info(layer, renderer):
cur_layer = cmds.editRenderLayerGlobals(q=True, currentRenderLayer=True)
cmds.editRenderLayerGlobals(currentRenderLayer=layer)
layer_info = {}
# get list of active render passes
layer_info['render_passes'] = []
if renderer == "vray" and cmds.getAttr('vraySettings.imageFormatStr') != 'exr (multichannel)' and cmds.getAttr('vraySettings.relements_enableall') != False:
pass_list = cmds.ls(type='VRayRenderElement')
pass_list += cmds.ls(type='VRayRenderElementSet')
for r_pass in pass_list:
if cmds.getAttr('%s.enabled' % (r_pass,)) == True:
layer_info['render_passes'].append(r_pass)
# get prefix information
if renderer == 'vray':
node = 'vraySettings'
attribute = 'fileNamePrefix'
elif renderer in ("sw", "mr"):
node = 'defaultRenderGlobals'
attribute = 'imageFilePrefix'
try:
layer_prefix = cmds.getAttr('%s.%s' % (node, attribute))
layer_info['prefix'] = layer_prefix
except Exception:
layer_info['prefix'] = ''
cmds.editRenderLayerGlobals(currentRenderLayer=cur_layer)
return layer_info
def setDefaultRenderState(self):
if cmds.editRenderLayerGlobals( query=True, currentRenderLayer=True ) != "defaultRenderLayer":
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
for node in self.getAOVs:
self.getInitState = cmds.getAttr("%s.enabled" % node)
node = node.split('aiAOV_')[1]
self.defaultRenderLayerState[node] = self.getInitState
def takeSnapShot(targetObj, renderPath, rotX=-30.0, rotY=45.0, rotZ=0.0, resX=300, resY=300, useBoundingBox=False):
'''
Take a snapshot of the selected object using the Maya renderer then move the image to a directory
'''
# build the bounding box and find it's centre
bBox = targetObj
if useBoundingBox is True:
bBox = buildBoundingBoxGeo(targetObj, noChildren=False, ignoreInv=True)
focusPoint = cmds.xform(bBox, query=True, ws=True, t=True)
# build the camera the move and orient it
tempCam = cmds.camera(ar=True, ff=3, fl=35)
camName = tempCam[1]
cmds.setAttr(camName+'.renderable', True)
cmds.setAttr(camName+'.displayFilmGate', True)
cmds.setAttr(camName+'.displayResolution', True)
cmds.setAttr(camName+'.backgroundColor', 0.5, 0.5, 0.5, type='double3') #transform
cmds.move(focusPoint[0], focusPoint[1], focusPoint[2], tempCam, ws=True)
cmds.rotate( rotX, rotY, rotZ, tempCam, ws=True)
# build the bounding box then fit the camera
cmds.select(bBox, r=True)
cmds.viewFit(camName, an = False, f = 0.9 )
if useBoundingBox is True:
cmds.delete(bBox)
# set the render globals
cmds.currentTime(1)
cmds.setAttr('defaultRenderGlobals.imageFormat', 8)
cmds.setAttr('defaultRenderQuality.edgeAntiAliasing', 0)
cmds.setAttr('defaultRenderQuality.shadingSamples', 2)
cmds.setAttr('defaultRenderQuality.maxShadingSamples', 8)
cmds.setAttr('defaultRenderQuality.useMultiPixelFilter', 1)
cmds.setAttr('defaultRenderQuality.enableRaytracing', 0)
# build the lightrig
lightRigGrp = cmds.group(em=True, name='lightRigGroup')
lightMain = cmds.directionalLight(rotation=(-20, -45, 0), intensity=0.8)
lightFill = cmds.directionalLight(rotation=(-20, 45, 0), intensity=0.4)
lightUnder = cmds.directionalLight(rotation=(75, 0, 0), intensity=0.15)
lightKey = cmds.directionalLight(rotation=(-25, 145, 0), intensity=4.0)
cmds.parent([lightMain, lightFill, lightUnder, lightKey], lightRigGrp)
cmds.rotate( rotX, rotY, rotZ, lightRigGrp, ws=True)
# select everything, build the special shader, render, then delete everything
cmds.select([targetObj, lightRigGrp], r=True)
renderLayerName = cmds.createRenderLayer(name='tempSnapShot_rlayer', mc=True)
shaderNodes = buildReverseNormalShader() #build the shader
cmds.sets(targetObj, e=True, forceElement=shaderNodes[0]) #adding the shader here means it's in the render layer
tempImage= cmds.render(camName, layer=renderLayerName, x=resX, y=resY)
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
cmds.delete([lightRigGrp, tempCam[0], renderLayerName, shaderNodes[0], shaderNodes[1], shaderNodes[2], shaderNodes[3]])
# copy the thumbnail to the desired location
output = cmds.sysFile(tempImage, rename=renderPath)
if output==True:
print 'Path for thumbnail: ' + renderPath
return renderPath
return None
def snapShot(cam, objs, renderPath):
# build the lightrig
lightRigGrp = cmds.group(em=True, name='lightRigGroup')
lightMain = cmds.directionalLight(rotation=(-20, -45, 0), intensity=0.8)
lightFill = cmds.directionalLight(rotation=(-20, 45, 0), intensity=0.4)
lightUnder = cmds.directionalLight(rotation=(75, 0, 0), intensity=0.15)
lightKey = cmds.directionalLight(rotation=(-25, 145, 0), intensity=4.0)
cmds.parent([lightMain, lightFill, lightUnder, lightKey], lightRigGrp)
# select everything, build the special shader, render, then delete everything
renderLayerName = cmds.createRenderLayer(name='tempSnapShot_rlayer', empty=True, mc=True)
cmds.editRenderLayerMembers(renderLayerName, objs)
cmds.editRenderLayerMembers(renderLayerName, lightRigGrp)
shaderNodes = buildTempShader() #build the shader
cmds.sets(objs, e=True, forceElement=shaderNodes[0]) #adding the shader here means it's in the render layer
tempImage= cmds.render(cam, layer=renderLayerName)
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
cmds.delete(lightRigGrp, cam, renderLayerName)
cmds.delete(shaderNodes)
# copy the thumbnail to the desired location
output = cmds.sysFile(tempImage, rename=renderPath)
if output==True:
print 'Path for thumbnail: ' + renderPath
return renderPath
return None
def layerChanged(self, index):
self.curLayer = self.renderLayer.itemText(index)
if self.curLayer == "defaultRenderLayer":
self.disableLayerOverrides()
else:
self.enableLayerOverrides()
for cache in self.ABCViewerNode:
c = self.ABCViewerNode[cache]
over = c.getLayerOverrides(self.getLayer())
if over:
self.overrideProps.setChecked(over["removeProperties"])
self.overrideShaders.setChecked(over["removeShaders"])
self.overrideDisps.setChecked(over["removeDisplacements"])
self.updateTree()
if self.hierarchyWidget.currentItem():
self.itemCLicked(self.hierarchyWidget.currentItem(), 0, force=True)
# change it in maya too
curLayer = cmds.editRenderLayerGlobals(query=1, currentRenderLayer=1)
if curLayer != self.curLayer:
cmds.editRenderLayerGlobals( currentRenderLayer=self.curLayer)
def _export_ass(self):
import mtoa.cmds.arnoldRender as ar
filePath=cmds.file(q=True,sn=True)
#getting fields for version
shot_temp=self.parent.sgtk.templates["maya_shot_work"]
shotgunFields=shot_temp.get_fields(filePath)
#getting output path
area_temp=self.parent.sgtk.templates['maya_ass_export_area']
path=area_temp.apply_fields(shotgunFields).replace('\\','/')
#setting ass export path
cmds.workspace(fileRule = ['ASS', path])
#account for renderlayers
for layer in cmds.ls(type='renderLayer'):
#discarding referenced layers
if ':' not in layer:
#checking whether layer needs to be rendered
if cmds.getAttr(layer+'.renderable')==1:
cmds.editRenderLayerGlobals( currentRenderLayer=layer )
try:
ar.arnoldBatchRender('')
except Exception, e:
raise TankError("Failed to export Ass files: %s" % e)
def useDefaultRenderLayer():
""" Analisys if must use the Default Render Layer (masterLayer) checking the option in the UI.
Set to use it if need.
"""
# analisys to use the defaultRenderLayer:
useDefaultRL = cmds.checkBox('defaultRenderLayerCB', query=True, value=True)
if useDefaultRL:
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
def reAdd(samplesField, spreadField, maxDistanceField): # switch to the ao render layer cmds.editRenderLayerGlobals(currentRenderLayer='ao') objects = cmds.ls(g=True) cmds.select(objects) cmds.hyperShade(a='amb_occl_surf_shader') changeAOSettings(samplesField, spreadField, maxDistanceField)
def re_add(samples_field, spread_field, max_distance_field):
"""if AO already has been setup, just add all the objects to the AO layer"""
# switch to the ao render layer
cmds.editRenderLayerGlobals(currentRenderLayer="ao")
objects = cmds.ls(g=True)
cmds.select(objects)
cmds.hyperShade(a="amb_occl_surf_shader")
change_ao_settings(samples_field, spread_field, max_distance_field)
def get_layer_override(layer, node, attribute='imageFilePrefix'):
"""Helper method to return the layer override value for the given node and attribute"""
cur_layer = cmds.editRenderLayerGlobals(q=True, currentRenderLayer=True)
cmds.editRenderLayerGlobals(currentRenderLayer=layer)
attr = '.'.join([node, attribute])
layer_override = cmds.getAttr(attr)
cmds.editRenderLayerGlobals(currentRenderLayer=cur_layer)
return layer_override
def img_name(*args):
name = cmds.textScrollList('rl_list',q=True,si=True)
if type(name) != types.NoneType:
cmds.editRenderLayerGlobals(crl=name[0])
i_n = cmds.getAttr("defaultRenderGlobals.imageFilePrefix")
cmds.textScrollList('img_list', e=True,ra=True,ams=False,append=i_n)
cmds.textFieldGrp('ch_name', e=True, tx = name[0])
cmds.textFieldGrp('ch_fname', e=True, tx = name[0])
def disableImagePlane():
objs = mc.ls(typ="imagePlane")
for obj in objs:
if not mc.editRenderLayerGlobals(q=1, crl=1) == "defaultRenderLayer":
mc.editRenderLayerAdjustment(obj + ".displayMode")
mc.setAttr(obj + ".displayMode", 0)
if not mc.editRenderLayerGlobals(q=1, crl=1) == "defaultRenderLayer":
mc.editRenderLayerAdjustment(obj + ".type")
mc.setAttr(obj + ".type", 1)
def CreateSnap():
#Create a snapshot from the signature image
SubdivisionTextClass.ImagePath = cmds.getAttr("CMSettings.ProjectPath") + "/temp/" + cmds.getAttr("CMSettings.ModelName") + "_Subdivision_Temp_0" + ".png"
cmds.editRenderLayerGlobals( currentRenderLayer = "Subdivision_0")
ScreenCapture.ScreenCapture(SubdivisionTextClass.ImagePath, [740,400])
cmds.editRenderLayerGlobals( currentRenderLayer = "defaultRenderLayer")
#Return the camera to whatever it was
cmds.modelPanel( perspPanel, edit = True, camera = oldCamera)
def _cleanUp():
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
cmds.select(clear=True)
listOfLayers = cmds.ls(type="renderLayer")
cmds.select("defaultRenderLayer")
for eachlayer in listOfLayers:
if eachlayer != "defaultRenderLayer":
cmds.delete(eachlayer)
for eachPass in mapi.get_all_passes():
cmds.delete(eachPass)
def set_layer_attr(node_type, attr_name, attr_value, layer): # Set currendt layer cmds.editRenderLayerGlobals(currentRenderLayer=layer) nodes = cmds.ls(type=node_type) for node in nodes: cmds.editRenderLayerAdjustment(node + '.' + attr_name, layer=layer) cmds.setAttr(node + '.' + attr_name, attr_value)
def on_renderlayer_clicked(self):
renderlayer=self.renderlayer_listWidget.selectedItems()[0].text()
cmds.editRenderLayerGlobals( currentRenderLayer=renderlayer)
cmds.refresh()
regionNode=cmds.listConnections(renderlayer+'.message',type='network')[0]
cmds.select(regionNode)
def MaterialOverrides(shaderGroup, layers):
for i in layers:
cmds.editRenderLayerGlobals(currentRenderLayer = i)
try:
cmds.select( clear=True )
cmds.select(cmds.getAttr("CMSettings.ModelName"))
cmds.sets(cmds.ls(selection = True), forceElement = shaderGroup, e = True, n = i + "WireSet")
except:
print "Failed to assign shader"
cmds.editRenderLayerGlobals(currentRenderLayer = "defaultRenderLayer")
def assignSnapShots(Camera):
cmds.editRenderLayerGlobals( currentRenderLayer = "defaultRenderLayer")
#Remove all cameras from the default renderlayer
cmds.setAttr(Camera + ".renderable", False)
#If the camera is a signature
if cmds.getAttr(Camera + ".CMSignature"):
#Make the camera renderable in the signature and the SQR signature layers, remove the mask for png images and make the background color 247
RenderLayerManagerClass.EditLayer(settings = [
[Camera + ".mask", "none", False ],
[Camera + ".renderable", "none", True ]
],
layers = ["Signature", "SQRSignature"] )
#Make the camera renderable in the product layer
RenderLayerManagerClass.EditLayer(settings = [
[Camera + ".renderable", "none", True ]
],
layers = ["ContextSig", "Subdivision_0", "Subdivision_1", "UVs"] )
#Remove it from the wireframe layer
RenderLayerManagerClass.EditLayer(settings = [
[Camera + ".renderable", "RemoveFromLayer" ]
],
layers = ["Product", "Wireframe"] )
#If the camera is a product camera
else:
#Remove the overrides in the signature layers
RenderLayerManagerClass.EditLayer(settings = [
[Camera + ".mask", "RemoveFromLayer" ],
[Camera + ".renderable", "RemoveFromLayer" ]
],
layers = ["Signature", "SQRSignature"] )
#Remove it from the signature layers
RenderLayerManagerClass.EditLayer(settings = [
[Camera + ".renderable", "RemoveFromLayer", True ]
],
layers = ["ContextSig", "Subdivision_0", "Subdivision_1", "UVs"] )
#Make it renderable in the product layer
if cmds.getAttr(Camera + ".CMRenderProductShot"):
RenderLayerManagerClass.EditLayer(settings = [
[Camera + ".renderable", "none", True ]
],
layers = ["Product"] )
#Make it renderable in the wirframe layer
if cmds.getAttr(Camera + ".CMRenderWireFrame"):
RenderLayerManagerClass.EditLayer(settings = [
[Camera + ".renderable", "none", True ]
],
layers = ["Wireframe"] )
def SELmatchOverrideButton(* args):
clearList()
currentLayer = mc.editRenderLayerGlobals( query=True, currentRenderLayer=True )
getLayers()
getSelectedLayers()
for actLayer in actLayerList:
for selLayer in selLayerList:
if actLayer == selLayer:
mc.editRenderLayerGlobals(currentRenderLayer=actLayer)
overrideTransfer(actLayer)
mc.editRenderLayerGlobals(currentRenderLayer=currentLayer)
def SELmatchLayerButton(* args):
clearList()
currentLayer = mc.editRenderLayerGlobals( query=True, currentRenderLayer=True )
getLayers()
getSelectedLayers()
for actLayer in actLayerList:
for selLayer in selLayerList:
if actLayer == selLayer:
mc.editRenderLayerGlobals(currentRenderLayer=actLayer)
addObjs(actLayer)
mc.editRenderLayerGlobals(currentRenderLayer=currentLayer)
def disconnectArnold():
for node in getRegionNode():
renderlayer=cmds.listConnections(node+'.renderlayer')[0]
cmds.editRenderLayerGlobals( currentRenderLayer=renderlayer)
cmds.refresh()
for n in cmds.listConnections('defaultArnoldRenderOptions.regionMinX',type='container'):
cmds.delete(n)
def getGiSettings(self, vrlmap, vrmap, renderLayer):
cmds.editRenderLayerGlobals( currentRenderLayer=renderLayer)
cmds.setAttr("vraySettings.mode", 2)
cmds.setAttr("vraySettings.imap_mode", 2)
cmds.setAttr("vraySettings.autoSave", 0)
cmds.setAttr("vraySettings.dontDelete", 0)
cmds.setAttr("vraySettings.imap_dontDelete", 0)
cmds.setAttr("vraySettings.autoSaveFile", vrlmap, type= "string")
cmds.setAttr("vraySettings.imap_autoSaveFile", vrmap, type="string")
cmds.setAttr("vraySettings.imap_fileName", vrlmap, type= "string")
cmds.setAttr("vraySettings.fileName", vrmap, type="string")
self.mayaSave()
def dpaf_getOverrideData(self, queryValue, queryLayer):
# query override value without switching layers : it can query everything! (queryValue = 'object.attribute' or 'fps') # dataType problem?
value = ''
overrideList = cmds.listConnections(queryValue, p= 1) if queryValue != 'fps' else ['fps']
# if this attr has override by some layer(s)
if overrideList:
# find override
queryLayerProx = queryLayer
findOverride = 0
while findOverride == 0 and queryValue != 'fps':
for override in overrideList:
Buffer = override.split('.')
if Buffer[0] == queryLayerProx:
value = cmds.getAttr(Buffer[0] + '.' +Buffer[1] + '.plug')
if cmds.editRenderLayerGlobals(q= 1, currentRenderLayer= 1) == 'defaultRenderLayer':
if self.dpaf_hasOverride(queryValue, queryLayer) and queryLayer != 'defaultRenderLayer':
value = cmds.getAttr(Buffer[0] + '.' +Buffer[1] + '.value')
else:
if self.dpaf_hasOverride(queryValue, queryLayerProx) and cmds.editRenderLayerGlobals(q= 1, currentRenderLayer= 1) != queryLayer:
if self.dpaf_hasOverride(queryValue, queryLayer) or self.dpaf_hasOverride(queryValue, cmds.editRenderLayerGlobals(q= 1, currentRenderLayer= 1)):
if queryLayer != 'defaultRenderLayer':
value = cmds.getAttr(Buffer[0] + '.' +Buffer[1] + '.value')
else:
if self.dpaf_hasOverride(queryValue, cmds.editRenderLayerGlobals(q= 1, currentRenderLayer= 1)):
value = cmds.getAttr(Buffer[0] + '.' +Buffer[1] + '.value')
findOverride = 1
break
# if this layer has no override, change queryLayer to defaultLayer(masterLayer)
queryLayerProx = 'defaultRenderLayer' if findOverride == 0 else queryLayerProx
# return value
if queryValue == 'defaultRenderGlobals.startFrame' or queryValue == 'defaultRenderGlobals.endFrame' or queryValue == 'fps':
timeUnit = cmds.currentUnit(q= 1, t= 1) # mel.eval('currentTimeUnitToFPS')
if timeUnit[-3:] == 'fps':
value = round(round(value * 6000, 0) / (6000 / float(timeUnit.split('fps')[0])), 3) if queryValue != 'fps' else float(timeUnit.split('fps')[0])
return { # maya stores 'ticks/tps'(sec) behind, vvv-> frame = int(sec * tps) / tpf
'game' : round(round(value * 6000, 0) / 400, 3) if queryValue != 'fps' else 15.0,
'film' : round(round(value * 6000, 0) / 250, 3) if queryValue != 'fps' else 24.0,
'pal' : round(round(value * 6000, 0) / 240, 3) if queryValue != 'fps' else 25.0,
'ntsc' : round(round(value * 6000, 0) / 200, 3) if queryValue != 'fps' else 30.0,
'show' : round(round(value * 6000, 0) / 125, 3) if queryValue != 'fps' else 48.0,
'palf' : round(round(value * 6000, 0) / 120, 3) if queryValue != 'fps' else 50.0,
'ntscf' : round(round(value * 6000, 0) / 100, 3) if queryValue != 'fps' else 60.0,
'millisec' : round(round(value * 6000, 0) / 6, 3) if queryValue != 'fps' else 1000.0,
'sec' : round(round(value * 6000, 0) / 6000, 3) if queryValue != 'fps' else (1/1.0),
'min' : round(round(value * 6000, 0) / 360000, 3) if queryValue != 'fps' else (1/60.0),
'hour' : round(round(value * 6000, 0) / 21600000, 3) if queryValue != 'fps' else (1/3600.0),
}.get(timeUnit, value)
else:
return value
else:
return cmds.getAttr(queryValue)
def getSelectedRegionNode(self):
if self.renderlayer_listWidget.selectedItems():
renderlayer=self.renderlayer_listWidget.selectedItems()[0].text()
cmds.editRenderLayerGlobals( currentRenderLayer=renderlayer)
cmds.refresh()
regionNode=cmds.listConnections(renderlayer+'.message',type='network')[0]
return regionNode
else:
return None
def DeleteWireframeShader():
layers = ["Wireframe", "Subdivision_0", "Subdivision_1"]
for i in layers:
cmds.editRenderLayerGlobals(currentRenderLayer = i)
try:cmds.sets(clear = i + "WireSet")
except:pass
ShaderObjects = ["WireShader","WireSet","WireMap","WirePlacer","ContourShader"]
for i in ShaderObjects:
if cmds.objExists(i + "Vray"):
cmds.delete(i + "Vray")
if cmds.objExists(i + "MR"):
cmds.delete(i + "MR")
def setupIDs():
currentRenderLayer = cmds.editRenderLayerGlobals(q=1, crl=1)
#apply IDs
objIDs = {}
sceneData = {'asset': {}, 'material': {}, 'object': {}}
for sh in cmds.ls(g=1):
shadingGrps = cmds.listConnections(sh, type='shadingEngine')
if shadingGrps:
shader = cmds.ls(cmds.listConnections(shadingGrps), materials=1)[0]
objIDs, id = generateIDs(sh, 'rsObjectId', objIDs,
currentRenderLayer)
def submitRenderLayer():
""" Launch Render Submitter window for the current render layer.
"""
frameRange = "%s-%s" % (int(mc.getAttr('defaultRenderGlobals.startFrame')),
int(mc.getAttr('defaultRenderGlobals.endFrame')))
currentLayer = mc.editRenderLayerGlobals(query=True,
currentRenderLayer=True)
from tools.renderQueue import render_submit
# render_submit.run_maya(frameRange=frameRange, flags='-rl %s' %currentLayer)
render_submit.run_maya(frameRange=frameRange, layers=currentLayer)
def foolCheckRenderSettings(self, renderLayerList):
severity = 0
# get the timeslider range:
# startFrame = pm.playbackOptions(q=True, minTime=True)
# endFrame = pm.playbackOptions(q=True, maxTime=True)
startFrame = cmds.playbackOptions(q=True, minTime=True)
endFrame = cmds.playbackOptions(q=True, maxTime=True)
# activeRenderLayer = pm.editRenderLayerGlobals(q=True, currentRenderLayer=True)
activeRenderLayer = cmds.editRenderLayerGlobals(
q=True, currentRenderLayer=True)
# go through all renderlayers:
for layer in renderLayerList:
try:
cmds.editRenderLayerGlobals(currentRenderLayer=layer)
except RuntimeError:
continue
# get paths
# comparePath = pm.renderSettings(firstImageName=True, lastImageName=True, fp=True)
comparePath = cmds.renderSettings(firstImageName=True,
lastImageName=True,
fp=True)
filePath, fileBase = os.path.split(comparePath[0])
## COmmon for all render engines
# get the render range
# animStart = pm.getAttr("defaultRenderGlobals.startFrame")
animStart = cmds.getAttr("defaultRenderGlobals.startFrame")
# animEnd = pm.getAttr("defaultRenderGlobals.endFrame")
animEnd = cmds.getAttr("defaultRenderGlobals.endFrame")
if animStart != startFrame or animEnd != endFrame:
# msg = "Timeslider range and render ranges are different in {4}. {0}-{1} >> {2}-{3}".format(startFrame,
msg = "Timeslider range and Render ranges are different (%s)" % layer
self.minorProblemNodes.append([
"defaultRenderGlobals", layer,
"unifiedRenderGlobalsWindow;", msg
]) # RG is for Render Globals
severity += 1
return severity
def override_color_mod(self):
print ' '
print 'override_color_mod'
#print 'self.attribute_name_pointer_dic = ',self.attribute_name_pointer_dic
#print 'self.layer_overrides_dic = ',self.layer_overrides_dic
for attr in self.attribute_name_pointer_dic:
pointer = self.attribute_name_pointer_dic[attr]
#print 'setting ' + attr + ' to black'
pointer.setStyleSheet(
"QLabel { background:rgb(65,66,66); color : rgb(180,180,180); }"
)
for override in self.layer_overrides_dic:
#print 'attr = ',attr
#print 'override = ',override
if attr in override:
#print 'match, turning ' + attr + ' orange'
pointer.setStyleSheet(
"QLabel { background:rgb(65,66,66); color : rgb(225,120,0); }"
)
cmds.editRenderLayerGlobals(
currentRenderLayer=self.current_render_layer)
def setCurrentLayer(self):
"""Set current layer"""
try:
curLayer = cmds.editRenderLayerGlobals(query=1,
currentRenderLayer=1)
except:
return
curLayeridx = self.renderLayer.findText(curLayer)
if curLayeridx != -1:
self.renderLayer.setCurrentIndex(curLayeridx)
self.curLayer = curLayer
def process(self, context):
# Workaround bug pyblish-base#250
if not contextplugin_should_run(self, context):
return
layer = cmds.editRenderLayerGlobals(query=True,
currentRenderLayer=True)
cameras = cmds.ls(type="camera", long=True)
renderable = any(c for c in cameras if cmds.getAttr(c + ".renderable"))
assert renderable, ("Current render layer '%s' has no renderable "
"camera" % layer)
def onDoubleClick(self):
row = self.foolcheck_listWidget.currentRow()
if row == -1:
return
if (row+1) <= len(self.imanager.majorProblemNodes):
nodeToGet = self.imanager.majorProblemNodes[(row)][0]
layerToGo = self.imanager.majorProblemNodes[(row)][1]
melToEval = self.imanager.majorProblemNodes[(row)][2]
else:
nodeToGet = self.imanager.minorProblemNodes[(row)-(len(self.imanager.majorProblemNodes))][0]
layerToGo = self.imanager.minorProblemNodes[(row)-(len(self.imanager.majorProblemNodes))][1]
melToEval = self.imanager.minorProblemNodes[(row)-(len(self.imanager.majorProblemNodes))][2]
if not nodeToGet == None:
# first go to the problematic layer
# pm.editRenderLayerGlobals(currentRenderLayer=layerToGo)
cmds.editRenderLayerGlobals(currentRenderLayer=layerToGo)
# pm.select(nodeToGet)
cmds.select(nodeToGet)
mel.eval(melToEval)
def setframe(*args):
#check renderer
if cmds.getAttr('defaultRenderGlobals.ren') != 'arnold':
cmds.setAttr('defaultRenderGlobals.ren', 'arnold', type='string')
cameras = cmds.ls(cameras = 1)
transforms = cmds.listRelatives(cameras, parent=1)
for t in transforms:
if "main" in t:
cutNo = t.split("_")[1]
frames = re.findall(r'\d+_\d+', t)[0]
startFrames = frames.partition("_")[0]
endFrames = frames.partition("_")[2]
imageFilePrefix=cmds.getAttr("defaultRenderGlobals.imageFilePrefix")
cmds.setAttr("defaultRenderGlobals.imageFilePrefix",imageFilePrefix.replace(imageFilePrefix.split("/")[0],cutNo),type="string")
cmds.editRenderLayerGlobals( currentRenderLayer='defaultRenderLayer' )
cmds.playbackOptions(minTime= startFrames,maxTime = endFrames)
cmds.setAttr("defaultRenderGlobals.startFrame", startFrames)
cmds.setAttr("defaultRenderGlobals.endFrame", endFrames)
cmds.editRenderLayerGlobals( currentRenderLayer='defaultRenderLayer' )
def do_render(self):
if self.maya.renderer == "vray":
mc.setAttr("vraySettings.animType", 0)
self.maya.set_render_frame_ext()
row_count = self.data_model.rowCount()
mc.progressWindow(title="Rendering...",
isInterruptable=1,
status="start rendering...",
min=0, max=row_count,
progress=0)
for row in xrange(row_count):
item_index = self.data_model.index(row, 5)
render_item = item_index.data()
progress_bar = self.table_view.indexWidget(self.data_model.index(row, 4))
render_layer = render_item.name
render_model = render_item.model
if render_item.renderable:
mc.editRenderLayerGlobals(currentRenderLayer=render_layer)
camera = render_item.camera
if render_model == "Custom":
frames = get_range_data.get_range_data(render_item.frames)
else:
frame_range = self.maya.get_default_frame_range()
frames = get_range_data.get_range_data(frame_range)
progress_bar.setRange(0, len(frames))
for frame_index, frame in enumerate(frames):
if mc.progressWindow(query=1, isCancelled=1):
print "Interrupt by press Esc."
break
mc.RenderViewWindow()
mel.eval("setTestResolutionVar(1)")
mc.currentTime(frame)
current_frame_render_path = self.maya.get_current_render_frame_path(frame)
mel.eval('renderWindowRenderCamera render renderView ' + camera)
final_path = self.maya.copy_from_temp(current_frame_render_path)
print "render to %s" % final_path
progress_bar.setValue(frame_index+1)
mc.progressWindow(endProgress=1)
if self.shut_down_check.isChecked():
os.system("shutdown -s -t 60")
def detect_overrides(self):
print 'detect_overrides '
self.layer_overrides_dic = {}
for layer in self.render_layers_in_order:
print ' '
print 'layer = ', layer
cmds.editRenderLayerGlobals(currentRenderLayer=layer)
for attr in self.scriptJob_attrs:
if attr in self.xforms:
light_parent = cmds.listRelatives(
self.current_chosen_light, parent=True)
light_parent = light_parent[0]
light_name_attr = light_parent + '.' + attr
else:
light_name_attr = self.current_chosen_light + '.' + attr
value = cmds.getAttr(light_name_attr)
for default_attr in self.default_layer_values_dic:
if default_attr == attr:
print 'default_attr = ', default_attr
print cmds.editRenderLayerGlobals(
query=True, currentRenderLayer=True)
print 'attr = ', attr
attr_value = cmds.getAttr(light_name_attr)
default_attr = self.default_layer_values_dic[attr]
print 'attr_value = ', attr_value
print 'default_attr = ', default_attr
if attr_value != default_attr:
print 'attr_value = ', attr_value
print 'default_attr = ', default_attr
self.layer_overrides_dic[attr] = layer
print 'self.layer_overrides_dic = ', self.layer_overrides_dic
cmds.editRenderLayerGlobals(
currentRenderLayer=self.current_render_layer)
def set_layer_overrides(node_attribute, override_data):
"""
Set layer values overrides for a node attribute from the given per layer
override data
:param node_attribute: a node's attribute name as a string
:param override_data: dictionary data where keys are render layer
and values the layer's override value
:return:
"""
current_layer = cmds.editRenderLayerGlobals(query=True, crl=True)
# Query the existing layerOverride Values
layer_values = gather_attribute_override_data(node_attribute) or {}
# Remove all layer overrides
for render_layer in layer_values.keys():
cmds.editRenderLayerAdjustment(node_attribute,
layer=render_layer,
remove=True)
# Merge user layer Override and pre-existing override values
for render_layer, value in override_data.iteritems():
layer_values[render_layer] = value
# Query the master layer value
master_value = cmds.getAttr(node_attribute)
render_layers = [x for x in cmds.ls(type='renderLayer')
if x != 'defaultRenderLayer']
# Set override value per layer
for render_layer in render_layers:
if render_layer == current_layer:
continue
value = layer_values.get(render_layer, False)
cmds.setAttr(node_attribute, value)
cmds.editRenderLayerAdjustment(node_attribute,
layer=render_layer)
cmds.setAttr(node_attribute, master_value)
current_layer_valid = current_layer in layer_values.keys()
if "defaultRenderLayer" not in current_layer and current_layer_valid:
cmds.editRenderLayerAdjustment(node_attribute, layer=current_layer)
cmds.setAttr(node_attribute, layer_values[current_layer])
return
def timeRange(*arg):
# Set to normal mode for all display layers
dpLayers = cmds.ls(type='displayLayer')
for dpLay in dpLayers:
if dpLay == 'defaultLayer':
continue
cmds.setAttr('%s.displayType' % dpLay, 0)
# Set fps to PAL
cmds.currentUnit(time='pal')
setFrameRange()
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
# Turn off dummy
allCtrls = cmds.ls(type='transform')
for ctrl in allCtrls:
if 'ROOT' in ctrl:
if cmds.objExists('%s.Dummy' % ctrl):
cmds.cutKey(ctrl, at='Dummy', cl=True)
cmds.setAttr('%s.Dummy' % ctrl, 0)
def reAssignMat(self):
'''
Reassign materials for each render layer with renLyrMatInfo dictionary data.
'''
for renLyr in self.renLyrMatInfo.keys():
try:
# Select render layer.
cmds.editRenderLayerGlobals(currentRenderLayer=renLyr)
for matAssignTable in self.renLyrMatInfo[renLyr]:
mat = matAssignTable[0]
assignedObjLs = matAssignTable[1]
if assignedObjLs:
for assignedObj in assignedObjLs:
# Convert assigned object name to deformed object.
if '.f' in assignedObj:
assignedObj = assignedObj.split('.f')[0].split(
':'
)[-1] + 'ShapeDeformed' + '.f' + assignedObj.split(
'.f')[-1]
elif 'Shape' in assignedObj:
assignedObj = assignedObj.split(
':')[-1] + 'Deformed'
print assignedObj
# If assignedObj is transform node, skip this.
else:
continue
# Assign the material.
cmds.select(assignedObj, r=True)
cmds.hyperShade(assign=mat)
else:
pass
except:
pass
print '> Reassign materials job is done.'
def main(log=None):
if not log:
import logging
log = logging.getLogger()
allRenderLayer = cmds.ls(type='renderLayer')
allRenderLayer.remove('defaultRenderLayer')
if allRenderLayer:
for x in allRenderLayer:
try:
cmds.editRenderLayerGlobals(
currentRenderLayer='defaultRenderLayer')
cmds.delete(x)
except:
log.error("delete render layer error:%s" % x)
import traceback
log.error(traceback.format_exc())
else:
log.warning("render layer delete successful:%s" % x)
else:
log.debug('There is no render layer in the scene')
def CREATETEMPfn(self, *args):
if cmds.objExists('shotMaster') == False:
cmds.confirmDialog(icn='warning', title='Error', message='There is no shotMaster within scene file!', \
button=['Ok'])
cmds.error('error: cancelled by user')
#Create render layer
cmds.createRenderLayer(n='ANIM_TEMP', noRecurse=True)
#Import Transform object [Char and Props]
cmds.select('char', 'props', hi=True)
TEMPlis = cmds.ls(sl=True)
cmds.select(cl=True)
for chk in TEMPlis:
cmds.select(chk)
if cmds.ls(sl=True, showType=True)[1] == 'transform':
cmds.editRenderLayerMembers('ANIM_TEMP', chk, nr=True)
#Import Transform object [Char and Props]
#Import Transform [Sets]
cmds.select('sets', hi=True)
TEMPlis = cmds.ls(sl=True)
cmds.select(cl=True)
for chk in TEMPlis:
cmds.select(chk)
if cmds.ls(sl=True, showType=True)[1] == 'transform':
cmds.editRenderLayerMembers('ANIM_TEMP', chk, nr=True)
cmds.editRenderLayerGlobals(crl='ANIM_TEMP')
cmds.hyperShade(assign='lambert1')
#Import Transform [Sets]
cmds.select(cl=True)
cmds.confirmDialog(icn='information',
title='Done',
message='ANIM_TEMP has been created.',
button=['Ok'])
return
def fixBadObjects():
cmds.editRenderLayerGlobals(crl = 'defaultRenderLayer')
objects = cmds.ls(sl = 1)
if objects:
addText = u'修复结果'.center(57, '-') + '\n'
cmds.scrollField('ScrollText', e = 1, it = addText, ip = 0)
feedBackCaseA, feedBackCaseB = [], []
for object in objects:
connections = cmds.listConnections(object, c = 1,p = 1, t = 'shadingEngine')
if not connections:
cmds.sets(object, fe = 'initialShadingGroup', e = 1)
addText = u'>>> %s 被赋予默认lamber1材质\n' % object
feedBackCaseA.append(addText)
else:
check = [x for x in connections[::2] if 'compInstObjGroups' in x]
if check:
id = connections.index(check[0])
cmds.disconnectAttr(connections[id], connections[id + 1])
addText = u'>>> %s 断开可能引发错误的连接\n' % object
feedBackCaseB.append(addText)
cmds.scrollField('ScrollText', e = 1, it = ''.join(feedBackCaseA), ip = 0)
cmds.scrollField('ScrollText', e = 1, it = ''.join(feedBackCaseB), ip = 0)
def w04_updataUI(self, *args):
cmds.text('w04_filename', e=True)
cmds.textFieldGrp("w04_Imageformat",
e=True,
text=str(self.w04_getExtension())[1:-1])
cmds.textFieldGrp('w04_path',
e=True,
text=cmds.workspace(q=True, rootDirectory=True) +
'images')
cmds.textFieldGrp("w04_RenderLayer",
e=True,
text=cmds.editRenderLayerGlobals(
q=True, currentRenderLayer=True))
cmds.textFieldGrp("w04_RenderUsing",
e=True,
text=cmds.getAttr("defaultRenderGlobals.ren"))
cmds.textFieldGrp("w04_RenderableCams",
e=True,
text=str(self.w04_renderableCams())[1:-1].replace(
"u'", '').replace("'", ''))
cmds.textFieldGrp("w04_Extension",
e=True,
text=self.w04_animationType())
cmds.textFieldGrp(
"w04_paddingzero",
e=True,
text=str(cmds.getAttr("defaultRenderGlobals.extensionPadding")))
cmds.textFieldGrp("w04_imageSize",
e=True,
text='%s*%s' %
(cmds.getAttr("defaultResolution.width"),
cmds.getAttr("defaultResolution.height")))
enValue = cmds.checkBox('w04_setFrameRange', q=True, v=True)
cmds.radioButtonGrp('w04_uiFrameRangeStyle', e=True, en=enValue)
if cmds.radioButtonGrp('w04_uiFrameRangeStyle', q=True,
select=True) == 1 and cmds.checkBox(
'w04_setFrameRange', q=True, v=True):
ranV, segV = True, False
else:
ranV, segV = False, True
cmds.intFieldGrp("w04_startFrame", e=True, en=ranV)
cmds.intFieldGrp("w04_endFrame", e=True, en=ranV)
cmds.intFieldGrp("w04_byFrame", e=True, en=ranV)
cmds.frameLayout('w04_uiFrameSegLayout', e=True, collapse=not segV)
cmds.scrollField('w04_uiFrameSegments', e=True, en=segV)
self.w04_uiFrameSegments_cmd()
def beforeSceneSave(userdata):
# Set the 'defaultRenderLayer' as the current render layer before saving
prefRenderSetup = cmds.optionVar(q="renderSetupEnable")
# 1 = New Render Setup
# 0 = Legacy Render Layers
if prefRenderSetup == 1:
global curLayer
curLayer = cmds.editRenderLayerGlobals(q=True, currentRenderLayer=True)
if curLayer != "defaultRenderLayer":
try:
cmds.editRenderLayerGlobals(
currentRenderLayer="defaultRenderLayer")
print "# INFO: set 'defaultRenderLayer' as current render layer before saving the scene"
except:
# In Maya 2017 Update 3 switching the render layer throws an error, but in fact still switches the layer
# so we manually check if the default layer is active before printing an info or a warning
checkLayer = cmds.editRenderLayerGlobals(
q=True, currentRenderLayer=True)
if checkLayer == "defaultRenderLayer":
print "# INFO: set 'defaultRenderLayer' as current render layer before saving the scene"
else:
print "# WARNING: FAILED to set 'defaultRenderLayer' as current render layer before saving the scene!"
def _on_renderlayer_switch(self, *args):
"""Callback that updates on Maya renderlayer switch"""
if maya.OpenMaya.MFileIO.isNewingFile():
# Don't perform a check during file open or file new as
# the renderlayers will not be in a valid state yet.
return
layer = cmds.editRenderLayerGlobals(query=True,
currentRenderLayer=True)
if layer != "defaultRenderLayer":
self.warn_layer.show()
else:
self.warn_layer.hide()
def _GetExportedStage(self, activeRenderLayerName,
renderLayerMode='defaultLayer', **kwargs):
cmds.file(os.path.abspath('UsdExportRenderLayerModeTest.ma'),
open=True, force=True)
usdFilePathFormat = 'UsdExportRenderLayerModeTest_activeRenderLayer-%s_renderLayerMode-%s.usda'
usdFilePath = usdFilePathFormat % (activeRenderLayerName, renderLayerMode)
usdFilePath = os.path.abspath(usdFilePath)
cmds.editRenderLayerGlobals(currentRenderLayer=activeRenderLayerName)
self.assertEqual(self._GetCurrentRenderLayerName(), activeRenderLayerName)
# Export to USD.
cmds.usdExport(mergeTransformAndShape=True, file=usdFilePath,
shadingMode='none', renderLayerMode=renderLayerMode, **kwargs)
stage = Usd.Stage.Open(usdFilePath)
self.assertTrue(stage)
# Make sure the current render layer is the same as what it was pre-export.
self.assertEqual(self._GetCurrentRenderLayerName(), activeRenderLayerName)
return stage
def enabled_render_layers():
old_layer = cmds.editRenderLayerGlobals(
query=True,
currentRenderLayer=True,
)
try:
rs = renderSetup.instance()
def switchToLayer(layer):
def _switch():
rs.switchToLayer(layer)
return _switch
enabled_layers = []
for layer in rs.getRenderLayers() + [rs.getDefaultRenderLayer()]:
layer.switchToLayer = switchToLayer(layer)
if layer.isRenderable():
enabled_layers.append(layer)
yield enabled_layers
finally:
cmds.editRenderLayerGlobals(currentRenderLayer=old_layer)
def setup_ao(target):
# setup backdrop
cmds.polyPlane(name="ao_backdrop", w=15, h=15)
cmds.select(clear=True)
cmds.select("ao_backdrop")
cmds.move(0, -0.5, 0, relative=True)
'''
mel.eval('select -r ao_backdrop;')
mel.eval('sets -renderable true -noSurfaceShader true ' + \
'-empty -name -table_matSG;')
mel.eval('select -r ao_backdrop ; sets -e -forceElement table_matSG;')
'''
# create new render layer
select_objs(target)
cmds.createRenderLayer(name='ao', makeCurrent=True)
# create a new surface shader for the ambient occlusion shader
surf_shader = cmds.shadingNode('surfaceShader', asShader=True, \
name='amb_occl_surf_shader')
ao_shader = cmds.shadingNode('mib_amb_occlusion', asShader=True, name='amb_occl')
cmds.connectAttr(ao_shader + '.outValue', surf_shader + '.outColor')
# create a new shading group for the ao shader
sg = cmds.sets(renderable=True, noSurfaceShader=True, empty=True, name='aoSG')
cmds.connectAttr(surf_shader + '.outColor', sg + '.surfaceShader')
# switch to the ao render layer
cmds.editRenderLayerGlobals(currentRenderLayer='ao')
#mel.eval('editRenderLayerGlobals -currentRenderLayer defaultRenderLayer;')
select_objs(target)
objects = cmds.ls(selection=True)
cmds.select(objects)
mel.eval('sets -e -forceElement ' + sg)
change_ao_settings()
change_render_settings()
def NAMEmatchAllButton(*args):
clearList()
currentLayer = mc.editRenderLayerGlobals(query=True,
currentRenderLayer=True)
selectionDefiner()
for trgCt in range(len(trgCmpList)):
for srcCt in range(len(srcCmpList)):
if trgCmpList[trgCt] == srcCmpList[srcCt]:
srcObjSel = srcTrList[srcCt]
trgObjSel = trgTrList[trgCt]
mc.select(srcObjSel, replace=True)
mc.select(trgObjSel, add=True)
getLayers()
getSelectedLayers()
for actLayer in actLayerList:
for selLayer in selLayerList:
if actLayer == selLayer:
mc.editRenderLayerGlobals(
currentRenderLayer=actLayer)
addObjs(actLayer)
shaderTransfer()
overrideTransfer(actLayer)
actLayerList[:] = []
selLayerList[:] = []
sourceObj[:] = []
targetObjs[:] = []
sourceShape[:] = []
targetShapes[:] = []
if trgCmpList[trgCt] not in srcCmpList:
print trgTrList[trgCt] + " doesn't match! "
mc.select(srcGrp, replace=True)
mc.select(trgGrp, add=True)
mc.editRenderLayerGlobals(currentRenderLayer=currentLayer)
def get_aov_names(self):
""" Find all the active AOVs in the scene and return their names in a
list.
"""
# Default beauty pass will always be added to the start of the list
aov_name_ls = [self.default_beauty_aov_name]
if self.renderer == "arnold":
# List all Arnold AOV nodes
aov_node_ls = mc.ls(type="aiAOV")
for aov_node in aov_node_ls:
# Only add to list if AOV is enabled
if mc.getAttr("%s.enabled" % aov_node):
aov_name_ls.append(mc.getAttr("%s.name" % aov_node))
elif self.renderer == "redshift":
# Only if global AOV mode is enabled
if mc.getAttr("redshiftOptions.aovGlobalEnableMode") == 1:
# List all Redshift AOV nodes
aov_node_ls = mc.ls(type="RedshiftAOV")
for aov_node in aov_node_ls:
# Only add to list if AOV is enabled
if mc.getAttr("%s.enabled" % aov_node):
aov_name_ls.append(mc.getAttr("%s.name" % aov_node))
else:
mc.optionMenu("aov_comboBox", edit=True, enable=False)
elif self.renderer == "mentalRay":
# Get the current render layer
current_layer = mc.editRenderLayerGlobals(query=True,
currentRenderLayer=True)
# List all MentalRay render pass nodes
aov_node_ls = mc.ls(type="renderPass")
for aov_node in aov_node_ls:
# Only add to list if render pass is connected to current
# render layer and is renderable
associated_layers = mc.listConnections("%s.owner" % aov_node)
if associated_layers is not None:
if current_layer in associated_layers:
if mc.getAttr("%s.renderable" % aov_node):
aov_name_ls.append(aov_node)
# Return list
return aov_name_ls
def proxSet(self, mode, value):
over = cmds.checkBoxGrp(self.myCheck2, q=1, v1=1)
user_attr = ['.idm', '.mm', '.visibilityMode']
tmp = cmds.ls(sl=1, dag=1, type='mesh')
if tmp == []:
#cmds.confirmDialog(m='未选择物体', button='确定')
cmds.warning('未选择物体')
return
rsProxys = cmds.listConnections(tmp, type='RedshiftProxyMesh')
for i in rsProxys:
if over == 1:
if 'defaultRenderLayer' != cmds.editRenderLayerGlobals(
q=1, currentRenderLayer=1):
cmds.editRenderLayerAdjustment(i + user_attr[mode])
cmds.setAttr(i + user_attr[mode], value)
def _export_ass(self):
import mtoa.cmds.arnoldRender as ar
filePath = cmds.file(q=True, sn=True)
#getting frame range
endFrame = cmds.getAttr('defaultRenderGlobals.endFrame')
startFrame = cmds.getAttr('defaultRenderGlobals.startFrame')
#getting fields for version
shot_temp = self.parent.sgtk.templates["maya_shot_work"]
shotgunFields = shot_temp.get_fields(filePath)
#getting output path
area_temp = self.parent.sgtk.templates['maya_ass_export_area']
path = area_temp.apply_fields(shotgunFields).replace('\\', '/')
#setting ass export path
cmds.workspace(fileRule=['ASS', path])
#account for renderlayers
for layer in cmds.ls(type='renderLayer'):
#discarding referenced layers
if ':' not in layer:
#checking whether layer needs to be rendered
if cmds.getAttr(layer + '.renderable') == 1:
cmds.editRenderLayerGlobals(currentRenderLayer=layer)
try:
ar.arnoldBatchRender('')
except Exception, e:
raise TankError("Failed to export Ass files: %s" % e)
def getRenderLayers():
renderLayers = cmds.ls(type='renderLayer')
renderLayerData = []
for renderLayer in renderLayers:
renderable = cmds.getAttr(renderLayer + '.renderable')
if 'defaultRenderLayer' in renderLayer and len(renderLayers) == 1:
cmds.editRenderLayerGlobals(currentRenderLayer=renderLayer)
renderPasses = getPasses()
data = {
'name': renderLayer,
'renderAble': renderable,
'passes': renderPasses
}
renderLayerData.append(data)
elif 'defaultRenderLayer' not in renderLayer:
cmds.editRenderLayerGlobals(currentRenderLayer=renderLayer)
renderPasses = getPasses()
data = {
'name': renderLayer,
'renderAble': renderable,
'passes': renderPasses
}
renderLayerData.append(data)
return renderLayerData
def layerChanged(self, index):
self.curLayer = self.renderLayer.itemText(index)
if self.curLayer == "defaultRenderLayer":
self.disableLayerOverrides()
else:
self.enableLayerOverrides()
for cache in self.ABCViewerNode:
c = self.ABCViewerNode[cache]
over = c.getLayerOverrides(self.getLayer())
if over:
self.overrideProps.setChecked(over["removeProperties"])
self.overrideShaders.setChecked(over["removeShaders"])
self.overrideDisps.setChecked(over["removeDisplacements"])
self.updateTree()
if self.hierarchyWidget.currentItem():
self.itemCLicked(self.hierarchyWidget.currentItem(), 0, force=True)
# change it in maya too
curLayer = cmds.editRenderLayerGlobals(query=1, currentRenderLayer=1)
if curLayer != self.curLayer:
cmds.editRenderLayerGlobals(currentRenderLayer=self.curLayer)
def list():
""" Output layer overrides for the current layer.
"""
layer = mc.editRenderLayerGlobals(query=True, currentRenderLayer=True)
adjustments = mc.editRenderLayerAdjustment(layer, query=True, layer=True)
print("\n*** List of overrides for layer '%s:' ***" % layer)
if adjustments:
for adj in adjustments:
print("%s = %s" % (adj, mc.getAttr(adj)))
else:
print("None")
print("\n")
def get_render_layer(self, value=None):
if not value:
render_layers = [
mc.editRenderLayerGlobals(q=1, currentRenderLayer=1)
]
else:
render_layers = mc.ls(type='renderLayer')
render_layers = [
layer for layer in render_layers
if 'defaultRenderLayer' not in layer
]
render_layers = [
layer for layer in render_layers
if mc.getAttr('%s.renderable' % layer)
]
return render_layers
