def jpmLH_applyHarvestFile():
##get the path and filename information
##read each line of the file in and evaluate it
## as a python command
path = cmds.optionVar(q="jpmLHpath") + "/"
name = cmds.textScrollList("jpmLH_fileList", q=1, si=1)[0]
fullname = path + name
thisFile = open(fullname)
allLines = thisFile.readlines()
thisFile.close()
for line in allLines:
cmds.select(cl=1)
layer, shaderFile, selectFile = line.split("|")
layer = layer.strip()
shaderFile = shaderFile.strip()
selectFile = selectFile.strip()
lm.jpmMakeLayer(layer)
aw_restore.jpmRestoreFromFile(selectFile, 0, 0, "add", 0)
cmds.editRenderLayerGlobals(crl=layer)
sel = cmds.ls(sl=1)
cmds.editRenderLayerMembers(layer, sel, nr=0)
if os.path.exists(shaderFile):
thatFile = open(shaderFile)
shaderLines = thatFile.readlines()
thatFile.close()
for shaderLine in shaderLines:
eval(shaderLine)
def addObjs(layerName):
globalValue = mc.getAttr(layerName+".global")
if globalValue == 0:
for target in targetObjs:
mc.editRenderLayerMembers(layerName, target,noRecurse=True)
else:
pass
def createRenderLayer(trigger):
if cmds.textScrollList('YM_ReferenceWindow_List',q=True,si=True) is None:
cmds.warning('Select Some Reference Name!!!')
return
if trigger is True:
for reference in cmds.textScrollList('YM_ReferenceWindow_List',q=True,si=True):
renderableShapes = cmds.listRelatives(findRenderableObjects(reference),p=True,f=True)
if len(renderableShapes) == 0:
continue
filenameList = getFormatFilename(cmds.referenceQuery(reference,filename=True,wcn=True))
referenceLayer = cmds.createRenderLayer(e=True,n=filenameList[1],noRecurse=True)
cmds.editRenderLayerMembers(referenceLayer,renderableShapes,nr=True)
else:
renderableObjects = list()
for reference in cmds.textScrollList('YM_ReferenceWindow_List',q=True,si=True):
for parent in cmds.listRelatives(findRenderableObjects(reference),p=True,f=True):
renderableObjects.append(parent)
if len(renderableObjects) == 0:
return
referenceLayer = cmds.createRenderLayer(e=True,n='ChangeMyName',noRecurse=True)
cmds.editRenderLayerMembers(referenceLayer,renderableObjects,nr=True)
def setChar(*arg):
'''
Smooth and render layer set up for selected characters
'''
cmds.displaySmoothness(polygonObject=3)
allTrnsf = cmds.listRelatives(allDescendents=True, type='transform')
if allTrnsf:
for trnsf in allTrnsf:
if 'facial' in trnsf:
cmds.setAttr('%s.visibility' % trnsf, 0)
selChs = cmds.ls(sl=True)
for sel in selChs:
cmds.editRenderLayerMembers('ch_master', sel, noRecurse=True)
cmds.editRenderLayerGlobals(currentRenderLayer='ch_shadows')
for sel in selChs:
cmds.editRenderLayerMembers('ch_shadows', sel, noRecurse=True)
allShps = cmds.listRelatives(allDescendents=True,
type='mesh',
fullPath=True)
for shp in allShps:
cmds.setAttr('%s.primaryVisibility' % shp, 0)
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
def addObjs(layerName):
globalValue = mc.getAttr(layerName + ".global")
if globalValue == 0:
for target in targetObjs:
mc.editRenderLayerMembers(layerName, target, noRecurse=True)
else:
pass
def attachLoneShaders():
shading_groups = getLoneSG()
if shading_groups:
log.info("Got SG to attach : {}".format(shading_groups))
grp = "dummy_attachments"
if cmds.objExists(grp):
log.info(". delete dummy group {}".format(grp))
cmds.delete(grp)
objects = list()
for sg in shading_groups:
log.info("... {}".format(sg))
obj = cmds.particle()
obj = cmds.ls(obj, transforms=True)[0]
objects.append(obj)
cmds.sets(obj, e=True, forceElement=sg)
grp = cmds.group(objects, name=grp)
result = cmds.ls(type='renderLayer')
for renderLayer in result:
cmds.editRenderLayerMembers(renderLayer, grp)
cmds.scale(0.00001, 0.00001, 0.00001, grp)
else:
log.info("SG attachments ok !")
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 layer(self,layer):
selObjShort=mc.ls(sl=1)
selObj=ls(sl=1,dag=1)
if not layer in mc.lsType('renderLayer'): createLayer(layer)
mc.editRenderLayerMembers(layer,selObj,noRecurse=0)
set.shader (layer)
for each in selObj:
mc.select(each)
def put_obj(obj,rl):
if type(obj) == types.ListType:
for x in obj:
p = cmds.listRelatives(x, shapes=True)
if (cmds.objectType(x) =="transform" or cmds.objectType(x) == "mesh" or cmds.objectType(x) == "nurbsSurface"):
cmds.editRenderLayerMembers(rl,x,noRecurse=True)
else :
cmds.editRenderLayerMembers(rl,obj,noRecurse=True)
def referenceCreateRenderLayer(referenceList):
#根据参考创建对应的渲染层
for reference in referenceList:
referenceRelativeNodes = cmds.referenceQuery(reference,nodes=True)
referenceNamespace = cmds.referenceQuery(reference,namespace=True,showNamespace=True)
transformNodes = referenceNodeTypeFilter(referenceRelativeNodes,'transform')
renderableObjects = referenceNodeRenderableCheck(transformNodes)
referenceRenderLayer = cmds.createRenderLayer(e=True,n=referenceNamespace+'_Render')
cmds.editRenderLayerMembers(referenceRenderLayer,transformNodes)
def put_obj(*args):
rl = cmds.textScrollList('rls', q=True,si=True)
if type(rl) !=types.NoneType:
sels = cmds.textScrollList('sels',q=True,ai=True)
if type(sels) !=types.NoneType:
for y in rl:
for x in sels:
cmds.editRenderLayerMembers(y,x,noRecurse=True)
rl_obj_list()
def remove_objs(*ars):
rl = cmds.textScrollList('rls', q=True,si=True)
if type(rl) !=types.NoneType:
obj = cmds.textScrollList('objs',q=True,si=True)
if type(obj) != types.NoneType:
for r in rl:
for x in obj:
cmds.editRenderLayerMembers(r,x,remove=True,nr=True)
rl_obj_list()
def removeNodes(legacyRenderLayerName):
with profiler.ProfilerMgr('legacyRenderLayer::removeNodes'):
nodeList = cmds.editRenderLayerMembers(legacyRenderLayerName,
query=True,
fullNames=True)
if nodeList:
nodes = [node for node in nodeList if cmds.objExists(node)]
cmds.editRenderLayerMembers(legacyRenderLayerName,
nodes,
remove=True)
def createRenderLayer(trigger):
if cmds.textScrollList('YM_ReferenceWindow_List', q=True, si=True) is None:
cmds.warning('Select Some Reference Name!!!')
return
if trigger is True:
for reference in cmds.textScrollList('YM_ReferenceWindow_List',
q=True,
si=True):
referenceRelativeNodes = cmds.referenceQuery(reference,
nodes=True,
dp=True)
if len(referenceRelativeNodes) == 0:
continue
visibleTransforms = list()
for transform in referenceNodeTypeFilter(referenceRelativeNodes,
'transform'):
if cmds.objExists(transform) is False:
continue
if cmds.getAttr(transform + '.visibility'):
visibleTransforms.append(transform)
if len(visibleTransforms) == 0:
continue
filenameList = getFormatFilename(
cmds.referenceQuery(reference, filename=True, wcn=True))
referenceLayer = cmds.createRenderLayer(e=True, n=filenameList[1])
cmds.editRenderLayerMembers(referenceLayer, visibleTransforms)
else:
visibleTransforms = list()
for reference in cmds.textScrollList('YM_ReferenceWindow_List',
q=True,
si=True):
referenceRelativeNodes = cmds.referenceQuery(reference,
nodes=True,
dp=True)
if len(referenceRelativeNodes) == 0:
continue
for transform in referenceNodeTypeFilter(referenceRelativeNodes,
'transform'):
if cmds.objExists(transform) is False:
continue
if cmds.getAttr(transform + '.visibility'):
visibleTransforms.append(transform)
if len(visibleTransforms) == 0:
return
referenceLayer = cmds.createRenderLayer(e=True, n='ChangeMyName')
cmds.editRenderLayerMembers(referenceLayer, visibleTransforms)
def process(self, instance):
context = instance.context
current_layer = cmds.editRenderLayerGlobals(query=True,
currentRenderLayer=True)
layer_members = cmds.editRenderLayerMembers(current_layer,
query=True,
fullNames=True)
# (NOTE): Some of renderLayer member may not exists..
layer_members = cmds.ls(layer_members)
member = instance[:]
member += cmds.listRelatives(member,
allDescendents=True,
fullPath=True) or []
instance.data.update({
"startFrame": context.data["startFrame"],
"endFrame": context.data["endFrame"],
"byFrameStep": 1,
"renderCam": cmds.ls(member, type="camera", long=True),
"category": "Playblast",
})
# Push renderlayer members into instance,
# for collecting dependencies
instance += layer_members
def SundayRenderToolsExportRenderLayer():
exportLayers = { }
RL = mel.eval('getSelectedRenderItems("RenderLayerTab", "", 0);')
for curRL in RL:
if curRL != 'defaultRenderLayer':
rl = { }
rl['objects'] = cmds.editRenderLayerMembers(curRL, query = True)
adj = cmds.editRenderLayerAdjustment(curRL, query = True, layer = True)
adjustments = { }
if adj != None:
for curAdj in adj:
adjustments[curAdj] = cmds.getAttr(curAdj)
rl['adjustments'] = adjustments
settings = { }
settings['renderable'] = cmds.getAttr(curRL + '.renderable')
rl['settings'] = settings
exportLayers[curRL] = rl
continue
print 'Default layer can not be exported'
file = SundayDialogPy.SundayDialogFileOpen('/', 0, 'Nothing!!')
if file == None:
return None
f = open(file[0] + '.rl', 'w')
f.write(str(exportLayers))
f.close()
def city2DCreateNewRenderLayer( newLayerName='' ) : sels = mc.ls( sl=True ) currLayer = mc.editRenderLayerGlobals( query=True, currentRenderLayer=True ) if not newLayerName in mc.ls( type='renderLayer' ) : mc.createRenderLayer( n=newLayerName ) for sel in sels : if not currLayer == 'defaultRenderLayer' : mc.editRenderLayerMembers( currLayer , sel , r=True ) mc.editRenderLayerMembers( newLayerName , sel ) mc.editRenderLayerGlobals( currentRenderLayer=newLayerName )
def _getLayersPasses():
'''
Recording the layers, assosiated mental core passes and Objects that are connected to.
return layersDictionary {[LAYER NAME]:
[ASSOSIATED PASSES]
[PASS CONNECTED]}
'''
listOfLayers = cmds.ls(type="renderLayer")
layersDictionary = {}
for eachlayer in listOfLayers:
allAssosiatedPasses = mapi.get_associated_passes(
eachlayer) #List of Assosiated Passes
itemInsideLayer = cmds.editRenderLayerMembers(eachlayer,
fullNames=True,
q=True) #List of Items
validItems = []
if itemInsideLayer != None:
for eachItem in itemInsideLayer:
listAttrItem = cmds.listConnections(eachItem)
if listAttrItem != None:
validItems.append(eachItem)
# for eachAPass in allAssosiatedPasses:
# if eachAPass in listAttrItem:
# validItems.append(eachItem)
layersDictionary[eachlayer] = [allAssosiatedPasses, validItems]
return layersDictionary
def get_render_layer_objects(render_layer):
"""
Get the transform nodes added to a render layer
:param render_layer: the name a render layer as a string
:return: a list of the render layers transform nodes
"""
layer_objects = list(set(cmds.editRenderLayerMembers(render_layer,
q=True,
fullNames=True)
or [])) or None
if layer_objects is None:
return False
layer_transform_nodes = []
for node in layer_objects:
if cmds.nodeType(node) != "transform":
transform_node = cmds.listRelatives(node,
parent=True,
fullPath=True)
transform_is_valid = (transform_node[0]
not in layer_transform_nodes)
if transform_node and transform_is_valid:
layer_transform_nodes.append(transform_node[0])
else:
if node not in layer_transform_nodes:
layer_transform_nodes.append(node)
return layer_transform_nodes
def _getLayersPasses():
'''
Recording the layers, assosiated mental core passes and Objects that are connected to.
return layersDictionary {[LAYER NAME]:
[ASSOSIATED PASSES]
[PASS CONNECTED]}
'''
listOfLayers = cmds.ls(type="renderLayer")
layersDictionary = {}
for eachlayer in listOfLayers:
allAssosiatedPasses = mapi.get_associated_passes(eachlayer) #List of Assosiated Passes
itemInsideLayer = cmds.editRenderLayerMembers(eachlayer,fullNames=True, q=True) #List of Items
validItems = []
if itemInsideLayer != None:
for eachItem in itemInsideLayer:
listAttrItem = cmds.listConnections(eachItem)
if listAttrItem != None:
validItems.append(eachItem)
# for eachAPass in allAssosiatedPasses:
# if eachAPass in listAttrItem:
# validItems.append(eachItem)
layersDictionary[eachlayer] = [allAssosiatedPasses,validItems]
return layersDictionary
def removeAddLightFromLayer(transform, layer, remove=False):
cmds.editRenderLayerMembers(layer,
transform,
remove = remove,
noRecurse=True)
# Remove light Shape nodes if inside the layer
lightShapeNode = getLightShapeNode(transform)
if lightShapeNode and remove:
cmds.editRenderLayerMembers(layer,
lightShapeNode,
r= remove,
nr= True)
return None
def addRenderLayer(filename,layername):
try:
cmds.file(filename,o=1,f=1)
newLyr = cmds.createRenderLayer(n=layername,empty=1,makeCurrent=1)
meshes = cmds.ls(type='mesh')
xforms = []
for i in meshes:
xf = cmds.listRelatives(i,p=1)[0]
xforms.append(xf)
cmds.editRenderLayerMembers(layername,xforms)
cmds.file(s=1,f=1)
sys.stdout.write(newLyr)
return newLyr
except Exception, e:
sys.stderr.write(str(e))
sys.exit(-1)
def getTransforms(self, renderLayer):
"""in the event that no polygons are found"""
objectsInRenderLayer = cmds.editRenderLayerMembers(renderLayer,
q=True,
nr=True)
allChildren = cmds.listRelatives(objectsInRenderLayer, ad=True)
meshPolygons = sortPolygons(allChildren)
return meshPolygons
def lightingCleanup():
charAll = ['Bing_Riglocator', 'Beep_Riglocator', 'Bo_Riglocator', 'Boop_Riglocator', 'Bang_Riglocator']
for char in charAll:
mc.editRenderLayerMembers( 'shd', char, noRecurse = 1 )
mc.editRenderLayerMembers( 'shd', 'SHD_GEO_GRP', noRecurse = 1 )
mc.select( 'SHD_GEO_GRP', r = 1 )
newShdGrp = mc.duplicate( rr = 1 )[0]
children = mc.listRelatives( newShdGrp, c = 1 )
for c in children:
shd = mc.rename( newShdGrp + '|' + c, c + '_shd' )
noVis = mc.duplicate( shd, n= c+'_noVis', rr=1)[0]
mc.setAttr( noVis + '.primaryVisibility', 0 )
mc.sets( shd , addElement = 'groundPlane_shd_vrayobjectproperties')
if not mc.objExists('groundPlane_noVis_set'): mc.sets( noVis , n = 'groundPlane_noVis_set')
else: mc.sets( noVis , add = 'groundPlane_noVis_set')
mc.hide( shd )
mc.hide( 'SHD_GEO_GRP' )
'''
def _find(self):
"""
:return: Empty render layers
:rtype: generator
"""
layers = self.ls(type="renderLayer")
layers = reference.removeReferenced(layers)
for layer in layers:
if (not cmds.editRenderLayerMembers(layer, query=True)
and not cmds.getAttr("{0}.global".format(layer))):
yield layer
def setBG(*arg):
'''
Smooth and render layer set up for selected BGs
'''
cmds.displaySmoothness(polygonObject=3)
selBGs = cmds.ls(sl=True)
cmds.editRenderLayerGlobals(currentRenderLayer='ch_master')
for sel in selBGs:
cmds.editRenderLayerMembers('ch_master', sel, noRecurse=True)
allShps = cmds.listRelatives(allDescendents=True,
type='mesh',
fullPath=True)
for shp in allShps:
cmds.setAttr('%s.primaryVisibility' % shp, 0)
cmds.editRenderLayerGlobals(currentRenderLayer='bg_master')
for sel in selBGs:
cmds.editRenderLayerMembers('bg_master', sel, noRecurse=True)
cmds.editRenderLayerGlobals(currentRenderLayer='ch_shadows')
for sel in selBGs:
cmds.editRenderLayerMembers('ch_shadows', sel, noRecurse=True)
allShps = cmds.listRelatives(allDescendents=True,
type='mesh',
fullPath=True)
for shp in allShps:
cmds.setAttr('%s.castsShadows' % shp, 0)
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
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 getSceneLights(layer=False):
'''
This function returns:
- [0] a dict of lights and their group parent (if any) inside the scene : l_dict
- [1] l_dict but filered by lights inside the current Layer: layer_l_dict
- [2] a list of lights used on the current layer: rl_lights
- [3] a list of all lights inside the scene: scnLights
- Need to look at simplyfing this code
'''
## Variables
l_dict = {}
layer_l_dict = {}
rl_lights = []
scn_Lights = []
lightTypes = getLightTypes()
scn_Lights = cmds.ls(type=["light"] + lightTypes, long=True)
## Add mesh Lights to scn_Lights list
## FIXME: review this - is making the updates really slow!!!
for meshNode in cmds.ls(type="mesh", long=True):
if cmds.getAttr("%s.aiTranslator" % meshNode) == "mesh_light":
scn_Lights.append(meshNode)
currLayer = cmds.editRenderLayerGlobals(query= True, crl=True)
currLy_objs = cmds.editRenderLayerMembers(currLayer,
query=True,
fullNames=True) or []
for l in scn_Lights:
l_obj = "|".join(l.split("|")[0:-1])
l_parent = "|".join(l.split("|")[0:-2]) or 'Root'
if l_parent not in l_dict.keys():
l_dict[l_parent] = [l]
else:
l_dict[l_parent].append(l)
if l_obj in currLy_objs or l in currLy_objs:
rl_lights.append(l_obj)
if l_parent not in layer_l_dict.keys():
layer_l_dict[l_parent] = [l]
else:
layer_l_dict[l_parent].append(l)
return l_dict, layer_l_dict, rl_lights, scn_Lights
def SundayRenderToolsImportRenderLayer():
file = SundayDialogPy.SundayDialogFileOpen('/', 1, 'Render Layer File (*.rl)')
if file == None:
return None
f = open(file[0], 'r')
iL = eval(f.read())
for curIL in iL:
cmds.createRenderLayer(name = curIL, empty = True)
addObj = iL[curIL]['objects']
try:
cmds.editRenderLayerMembers(curIL, addObj, noRecurse = True)
except:
file == None
print 'Objects not found in scene'
addAdj = iL[curIL]['adjustments']
cmds.editRenderLayerGlobals(currentRenderLayer = curIL)
for curAdj in addAdj:
if curAdj.split('.')[1] != 'instObjGroups[0]':
cmds.editRenderLayerAdjustment(curIL, curAdj)
try:
cmds.setAttr(curAdj, addAdj[curAdj])
except:
pass
print 'Missing : ' + curAdj
continue
print 'Shader Overwrite : ' + curAdj
addSet = iL[curIL]['settings']
for curSet in addSet:
if curSet == 'renderable':
cmds.setAttr(curIL + '.renderable', addSet[curSet])
continue
def lightOnCurrentLayer(myLight):
currLayer = cmds.editRenderLayerGlobals(query= True, crl = True)
currLy_objs = cmds.editRenderLayerMembers(currLayer,
query=True,
fullNames=True)
if not currLy_objs:
return False
lightShape = getLightShapeNode(myLight)
if myLight in currLy_objs or lightShape in currLy_objs:
return True
return False
def getRenderLayerObjects(self, renderLayer):
"""returns objects in a renderlayer"""
objectsInRenderLayer = cmds.editRenderLayerMembers(renderLayer,
q=True,
nr=True)
objects = []
shapeTransforms = []
#check for repeat names
for each in objectsInRenderLayer:
if each not in objects:
objects.append(each)
#check for shapes
for other in objects:
whatType = cmds.nodeType(other)
if whatType != 'mesh':
objects.remove(other)
shapeTransforms = self.sortPolygons(objects)
return shapeTransforms
def jpmLH_harvest(name):
layers = cmds.ls(type="renderLayer")
layers.sort()
selected = cmds.ls(sl=1)
path = cmds.optionVar(q="jpmLHpath")
noPath = ""
if path == "0":
noPath = cmds.confirmDialog(t="Set A Path",
ma="center",
m="You Must Set A Path",
b="OK")
if noPath == "OK":
jpmLH_setPathDialog()
fullname = path + "/" + name + ".harvest"
folder = os.path.splitext(fullname)[0]
if not os.path.exists(folder):
os.mkdir(folder)
layerString = ""
for layer in layers:
layer = layer.split(":")[-1]
if layer != "defaultRenderLayer":
cmds.editRenderLayerGlobals(crl=layer)
members = cmds.editRenderLayerMembers(layer, q=1, fn=1)
shaderFileName = folder + "/" + layer + ".SHD"
selFileName = folder + "/" + layer + ".slc"
ws.jpmSaveShadersToFile(shaderFileName, members)
aw_save.jpmSaveSelectionToFile(selFileName, members)
layerString = layerString + layer + "|" + shaderFileName + "|" + selFileName + "\n"
saveFile = file(fullname, "w+")
saveFile.write(layerString)
saveFile.close()
currentSort = 1
currentSort = cmds.optionVar(q="jpmLHalpha")
#re-populate the file list
jpmLH_populateFileList(currentSort)
def add_members(self, *members):
args = [self.name] + list(members)
cmds.editRenderLayerMembers(*args, noRecurse=True)
def members(self):
return cmds.editRenderLayerMembers(self.name, q=True, fullNames=True)
def remove_members(self, *members):
args = [self.name] + list(members)
cmds.editRenderLayerMembers(*args, remove=True)
def getObjectsFromRenderLayer(layer):
# query objects in render layer - note this could return shapes AND transforms?
objs = cmds.editRenderLayerMembers(layer, q=True)
return (objs)
card.move(0, 0, i * -2)
zDepthShader = gMT.ZDepthShader.ZDepthShader(imageFileList[i],
imageFolder, 34, 55)
AOShader = gMT.AOShader.AOShader(imageFileList[i], imageFolder)
positionShader = gMT.positionShader.positionShader(imageFileList[i], imageFolder)
#print zDepthShader
cardList.append(card)
print (cardList[i].getSG())
#editRenderLayerMembers -noRecurse zDepthRenderLayer imageCard_000;
cmds.editRenderLayerMembers(zDepthRenderLayer,
cardList[i].getPolyNode(),
noRecurse=True)
cmds.editRenderLayerGlobals(currentRenderLayer=zDepthRenderLayer)
card.setSG(zDepthShader.getSG())
#editRenderLayerMembers -noRecurse AORenderLayer imageCard_000;
cmds.editRenderLayerMembers(AORenderLayer,
cardList[i].getPolyNode(),
noRecurse=True)
cmds.editRenderLayerGlobals(currentRenderLayer=AORenderLayer)
card.setSG(AOShader.getSG())
#editRenderLayerMembers -noRecurse positionRenderLayer imageCard_000;
cmds.editRenderLayerMembers(positionRenderLayer,
cardList[i].getPolyNode(),
noRecurse=True)
def setupOverides():
#### Select renderLayer with geo, will create Matte layer.
beautyRenderLayer = cmds.editRenderLayerGlobals(q=1, crl=1)
currentRenderLayer = cmds.editRenderLayerGlobals(q=1, crl=1)
matteLayer = currentRenderLayer.replace("Beauty", "Matte")
#create Matte layer
if not cmds.objExists(matteLayer):
cmds.createRenderLayer(n=matteLayer, nr=1)
#add geo
contents = cmds.editRenderLayerMembers(currentRenderLayer, q=1, fn=1)
if contents:
for obj in contents:
try:
cmds.editRenderLayerMembers(matteLayer, obj, nr=1)
except:
pass
cmds.editRenderLayerGlobals(currentRenderLayer=matteLayer)
currentRenderLayer = matteLayer
#ADD existing visbility overides from object properties
#get settings from any existing layer ObjectProperties, to copy to matte settings
existingVis = []
layerAdj = cmds.editRenderLayerAdjustment(currentRenderLayer,
query=True,
layer=True)
if layerAdj:
for adj in layerAdj:
try:
node, attr = adj.split('.')
if node:
if cmds.nodeType(node) == 'RedshiftVisibility':
existingVis.append([adj, cmds.getAttr(adj)])
except:
pass
#TURN OFF LIGHTS, make optimizations
for light in cmds.ls(type='RedshiftPhysicalLight'):
cmds.editRenderLayerAdjustment(light + '.on', layer=currentRenderLayer)
cmds.setAttr(light + '.on', 0)
turnOff = [
"redshiftOptions.primaryGIEngine", "redshiftOptions.secondaryGIEngine",
"redshiftOptions.emissionEnable",
"redshiftOptions.subsurfaceScatteringEnable",
"redshiftOptions.refractionRaysEnable",
"redshiftOptions.reflectionRaysEnable",
"defaultRenderGlobals.enableDefaultLight"
]
for to in turnOff:
cmds.editRenderLayerAdjustment(to, layer=currentRenderLayer)
cmds.setAttr(to, 0)
#assume ulityMatteLayerOveride exists from setupRenderElements.py script
#cmds.editRenderLayerAdjustment("utilityMatteLayerOveride.matteEnable", layer=currentRenderLayer)
#cmds.setAttr("utilityMatteLayerOveride.matteEnable",1)
#get list of all aovs, turn off all
existingAovs = cmds.ls(type='RedshiftAOV')
for aov in existingAovs:
cmds.editRenderLayerAdjustment(aov + ".enabled",
layer=currentRenderLayer)
cmds.setAttr(aov + ".enabled", 0)
#turn on matte only
for aov in matteAovs.keys():
if aov in existingAovs:
cmds.setAttr(aov + ".enabled", 1)
#set layer overide renderSettings, turn off GI, resolution, filtering, lights,turn on Deep
cmds.editRenderLayerAdjustment("redshiftOptions.aovEnableDeepOutput",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment("redshiftOptions.aovDeepMergeMode",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment("redshiftOptions.exrForceMultilayer",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment("redshiftOptions.exrMultipart",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment("defaultRenderGlobals.enableDefaultLight",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment(
"redshiftOptions.unifiedMaxSamples",
layer=currentRenderLayer) #force antialiasing edges for mattes
cmds.editRenderLayerAdjustment("redshiftOptions.unifiedMinSamples",
layer=currentRenderLayer)
cmds.setAttr("redshiftOptions.aovEnableDeepOutput", 1)
cmds.setAttr("redshiftOptions.aovDeepMergeMode", 1)
cmds.setAttr("redshiftOptions.exrForceMultilayer", 0)
cmds.setAttr("redshiftOptions.exrMultipart", 0)
cmds.setAttr("redshiftOptions.unifiedMaxSamples", 32)
cmds.setAttr("redshiftOptions.unifiedMinSamples", 32)
cmds.setAttr("defaultRenderGlobals.enableDefaultLight", 1)
existingAovs = cmds.ls(type='RedshiftAOV')
if not 'rsAov_ObjectID' in existingAovs:
aov = mel.eval("redshiftCreateAov(\"ObjectID\")")
cmds.setAttr(aov + ".enabled", 1)
cmds.setAttr(aov + ".filePrefix",
"<BeautyPath>/<RenderPass>/<BeautyFile>.<RenderPass>",
type="string")
cmds.setAttr(aov + ".exrCompression", 4)
try:
mel.eval("redshiftUpdateActiveAovList")
except:
print 'Aov Window not found'
def sendToBlender(shot, update=False):
"""
Send the shot to Blender and set up all the layers needed
for rendering shadows and Freestyle
"""
# shot info
asset = shot.shotstages["Lighting"]
if not asset.latest:
cmds.warning("This shot has nothing in the lighting stage")
return
path = os.path.join(asset.getBaseDir(), "Blender")
if not os.path.exists(path):
os.makedirs(path)
try:
asset.openVersion(asset.latest)
except:
pass
# get render cam
cameras = utilities.getRenderCams()
if len(cameras) > 1:
cmds.warning("CAMERA ERROR: Too many cooks!")
return
elif len(cameras) == 0:
cmds.warning("CAMERA ERROR: Not enough cooks!")
return
else:
camera = cameras[0]
# get meshes from all render layers
layer_data = {}
layers = cmds.ls(type="renderLayer")
for layer in layers:
if len(layers) > 1 and layer == "defaultRenderLayer":
continue
elif ':' in layer:
continue
geos = cmds.editRenderLayerMembers(layer, q=True, fullNames=True)
# (make sure that we have all the children of everything selected as well
# since Alembic does NOT traverse hierearchies without using the
# super-buggy '-root [thing]' flag)
geos = geos + cmds.listRelatives(geos, c=True, ad=True, fullPath=True)
layer_data[layer] = geos
cmds.select(geos, add=True)
cmds.select(utilities.getRenderCams(), add=True)
# export alembic file
start = cmds.playbackOptions(minTime=True, q=True)
end = cmds.playbackOptions(maxTime=True, q=True)
abc_path = os.path.join(path, shot.name + ".abc")
args = "-frameRange " + str(start) + ' ' + str(end) + " -sl -file " + abc_path
cmds.AbcExport(j=args)
if update:
utilities.newFile()
return
# export render layer metadata
try:
lights = cmds.sets("BL_EXPORT_LIGHTS", q=True)
except:
lights = cmds.listRelatives(cmds.ls(type="light"), p=True)
root = {
"render_layers": layer_data,
"render_output": os.path.join(rc.getCompDirFor(shot.name), 'Footage'),
"main_cam": camera,
"lights": lights
}
j = json.dumps(root, indent=4, separators=(',',':'))
j_path = os.path.join(path, shot.name + ".json")
with open(j_path, mode='w') as file:
file.write(j)
# run blender with command
blender.run(("snp_importLibrary()",
"snp_loadScene(\"" + abc_path + '\", \"' + j_path + "\")"))
utilities.newFile()
def appendNodes(legacyRenderLayerName, nodeNames):
with profiler.ProfilerMgr('legacyRenderLayer::appendNodes'):
cmds.editRenderLayerMembers(legacyRenderLayerName,
list(nodeNames),
noRecurse=True)
def configure_layers(self, *args):
mate_shaders = self.cwd + '/Scripts/shot_builder/lib/shadow_layer_mtl.ma'
scene_references = cmds.ls(references=True)
# Reference shader file
utils.reference(mate_shaders)
# Create render layers if not exist
utils.create_render_layers(['FG', 'BG', 'SHD', 'zDepth'])
##### FG START #####
fg_layer_name = 'FG'
# Configure vray render elements
self.enable_element(fg_layer_name, {'char': True, 'env': False})
# List all object with 'char' tag attribute
fg_objects = utils.list_by_tag('char', type='transform')
# Move to FG layer
cmds.editRenderLayerMembers(fg_layer_name, utils.get_roots(fg_objects), noRecurse=True)
##### FG END #####
##### BG START #####
bg_layer_name = 'BG'
self.enable_element(bg_layer_name, {'char': False, 'env': True})
bg_objects = utils.list_by_tag('env', type='transform')
cmds.editRenderLayerMembers(bg_layer_name, utils.get_roots(bg_objects), noRecurse=True)
##### BG END #####
##### SHD START #####
shadow_layer_name = 'SHD'
# Move to foreground and background objects to SHD layer
cmds.editRenderLayerMembers(shadow_layer_name, utils.get_roots(fg_objects), noRecurse=True)
cmds.editRenderLayerMembers(shadow_layer_name, utils.get_roots(bg_objects), noRecurse=True)
# Set currendt layer to SHD
cmds.editRenderLayerGlobals(currentRenderLayer=shadow_layer_name)
# Assign matte material to foreground objects
for node in fg_objects:
cmds.select(node)
cmds.hyperShade(a='matte')
# Assign vray_wrapper material to background objects
for node in bg_objects:
cmds.select(node)
cmds.hyperShade(a='vray_wrapper')
# Configure vray render elements
self.enable_element(shadow_layer_name, {'char': False, 'env': False})
# Disable all dome lights
utils.set_layer_attr('VRayLightDomeShape', 'enabled', False, shadow_layer_name)
##### SHD END #####
##### zDepth START #####
zdepth_layer_name = 'zDepth'
# Move to foreground and background objects to zDepth layer
cmds.editRenderLayerMembers(zdepth_layer_name, utils.get_roots(fg_objects), noRecurse=True)
cmds.editRenderLayerMembers(zdepth_layer_name, utils.get_roots(bg_objects), noRecurse=True)
# Set currendt layer to zDepth
cmds.editRenderLayerGlobals(currentRenderLayer='zDepth')
# Assign matte shader for FG and BG objects
for node in fg_objects + bg_objects:
cmds.select(node)
cmds.hyperShade(a='matte')
# Configure vray render elements
self.enable_element(zdepth_layer_name, {'char': False, 'env': False})
# Create zDepth render element
zdepth_name = 'vrayRE_Z_depth'
if not cmds.objExists(zdepth_name):
maya.mel.eval('vrayAddRenderElement zdepthChannel;')
cmds.editRenderLayerAdjustment(zdepth_name + ".enabled", layer=zdepth_layer_name)
cmds.setAttr(zdepth_name + ".enabled", True)
else:
print '%s render element already exists' % zdepth_name
# Disable all dome lights
utils.set_layer_attr('VRayLightDomeShape', 'enabled', False, zdepth_layer_name)
def readCoreData(pathToXML = ''):
'''
Clean up the Scene, get the Dictionary and setup the scene.
'''
print 'MY PATHTOXML IS: %s' % pathToXML
_cleanUp()
print "Cleaned Up successfully"
mentalCoreGlobalsDict,mentalCoreLensDataDict,mentalrayGlobalsDict,miDefaultOptionDict, layerDict, mentalCorePassesDict = _XML2Dictinary(pathToXML)
# print mentalCoreGlobalsDict
# print mentalCoreLensDataDict
# print mentalrayGlobalsDict
# print miDefaultOptionDict
# print layerDict
# print mentalCorePassesDict
print "Dictionaries are here successfully"
mentalCoreAvailibleDict = {0:'Beauty', 1:'Colour', 2:'Diffuse', 3:'Diffuse Raw', 4:'Shadow',
5:'Shadow Raw', 6:'Diffuse Without Shadows', 7:'Diffuse Without Shadows Raw',
8:'Ambient', 9:'Ambient Raw', 10:'Indirect', 11:'Indirect Raw',
12:'Ambient Occlusion', 13:'Translucency', 14:'Subsurface',
15:'Subsurface Front', 16:'Subsurface Mid', 17:'Subsurface Back',
18:'Incandescence', 19:'Specular', 20:'Reflection', 21:'Refraction',
38:'Light Select', 22:'Bloom Source', 37:'Environment', 23:'Depth',
23:'Depth (Normalized)', 24:'Normal World', 24:'Normal World (Normalized)',
25:'Normal Camera', 25:'Normal Camera (Normalized)', 26:'Point World',
27:'Point Camera', 28:'Motion Vector', 28:'Motion Vector (Normalized)',
29:'Opacity', 30:'Facing Ratio', 31:'UV', 32:'Material ID', 33:'Object ID',
34:'Matte', 35:'Custom Colour', 36:'Custom Vector', 39:'Diagnostic Samples',
40:'Diagnostic Error', 41:'Diagnostic Time'}
#########################################################################
# 1- check if layer exist and if not create a new layer
#########################################################################
for eachKey, eachValue in layerDict.iteritems():
if eachKey not in cmds.ls(type="renderLayer"): #Looking for Existing layers and adding to the scene
cmds.createRenderLayer(name=eachKey)
#########################################################################
# 2- assign the each Asset under each layer
#########################################################################
if eachKey != "defaultRenderLayer": #assigning each assets to each existing layer
for eachOBJ in eachValue[1]:
cmds.editRenderLayerMembers(eachKey,eachOBJ, noRecurse=True)
#########################################################################
# 3- check the passes in the scene and create one if doesn't exist
#########################################################################
for eachKey, eachValue in mentalCorePassesDict.iteritems():
if eachValue[0] != "":
mapi.create_pass(mentalCoreAvailibleDict[eachValue[0]], n=eachKey)
#########################################################################
# 4- set each passes setting in the scene
#########################################################################
for eachSettingKey, eachSettingValue in eachValue[2].iteritems():
# print "%s.%s %s Progressing" %(eachKey,eachSettingKey,eachSettingValue)
# print type(eachSettingValue)
if eachSettingValue != "":
if type(eachSettingValue) == int:
cmds.setAttr("%s.%s"%(eachKey,eachSettingKey),eachSettingValue)
if type(eachSettingValue) == bool:
cmds.setAttr("%s.%s"%(eachKey,eachSettingKey),eachSettingValue)
if type(eachSettingValue) == str:
cmds.setAttr("%s.%s"%(eachKey,eachSettingKey),eachSettingValue, type="string")
if type(eachSettingValue) == tuple:
print "%s.%s %s Progressing" %(eachKey,eachSettingKey,eachSettingValue)
print type(eachSettingValue)
#########################################################################
# 5- connect the passes to asses in the scene
#########################################################################
if eachValue[1] != "":
mapi.link_to_pass(eachValue[1], eachKey, mapi.OBJECTS)
#########################################################################
# 6- check the associated passes and create new if doesn't exist
#########################################################################
for eachlayerKey , eachlayerValue in layerDict.iteritems():
if eachlayerValue[0] != "":
for eachAssociacted in eachlayerValue[0]:
mapi.associate_pass(eachAssociacted, eachlayerKey)
#########################################################################
# 7- set the setting of imDefaultOption
#########################################################################
miDefaultName = "miDefaultOptions"
for eachMIKey, eachIMValue in miDefaultOptionDict.iteritems():
if eachIMValue != "":
if type(eachIMValue) == int:
cmds.setAttr("%s.%s"%(miDefaultName,eachMIKey),eachIMValue)
if type(eachIMValue) == bool:
cmds.setAttr("%s.%s"%(miDefaultName,eachMIKey),eachIMValue)
if type(eachIMValue) == str:
cmds.setAttr("%s.%s"%(miDefaultName,eachMIKey),eachIMValue, type="string")
if type(eachIMValue) == tuple:
print "%s.%s %s Progressing" %(miDefaultName,eachMIKey,eachIMValue)
print type(eachIMValue)
if eachIMValue == "":
cmds.setAttr("%s.%s"%(miDefaultName,eachMIKey),"", type="string")
#########################################################################
# 8- set the setting of Mentalray Globals
#########################################################################
mentalrayName = "mentalrayGlobals"
for eachMRKey, eachMRValue in mentalrayGlobalsDict.iteritems():
if eachMRValue != "":
if type(eachMRValue) == int:
cmds.setAttr("%s.%s"%(mentalrayName,eachMRKey),eachMRValue)
if type(eachMRValue) == bool:
cmds.setAttr("%s.%s"%(mentalrayName,eachMRKey),eachMRValue)
if type(eachMRValue) == str:
cmds.setAttr("%s.%s"%(mentalrayName,eachMRKey),eachMRValue, type="string")
if type(eachMRValue) == tuple:
print "%s.%s %s Progressing" %(mentalrayName,eachMRKey,eachMRValue)
print type(eachMRValue)
if eachMRValue == "":
cmds.setAttr("%s.%s"%(mentalrayName,eachMRKey),"", type="string")
#########################################################################
# 9- set the setting of MentalCore Globals
#########################################################################
mentalcoreGlobalsName = "mentalcoreGlobals"
for eachMCGKey, eachMCGValue in mentalCoreGlobalsDict.iteritems():
if eachMCGValue != "":
if type(eachMCGValue) == int:
cmds.setAttr("%s.%s"%(mentalcoreGlobalsName,eachMCGKey),eachMCGValue)
if type(eachMCGValue) == bool:
cmds.setAttr("%s.%s"%(mentalcoreGlobalsName,eachMCGKey),eachMCGValue)
if type(eachMCGValue) == str:
cmds.setAttr("%s.%s"%(mentalcoreGlobalsName,eachMCGKey),eachMCGValue, type="string")
if type(eachMCGValue) == tuple:
print "%s.%s %s Progressing" %(mentalcoreGlobalsName,eachMCGKey,eachMCGValue)
print type(eachMCGValue)
if eachMCGValue == "":
cmds.setAttr("%s.%s"%(mentalcoreGlobalsName,eachMCGKey),"", type="string")
#########################################################################
# 10- set the setting of MentalCore Lens Data
#########################################################################
mentalcoreLensName = "mentalcoreLens"
for eachMCLKey, eachMCLValue in mentalCoreLensDataDict.iteritems():
if eachMCLValue != "":
if type(eachMCLValue) == int:
cmds.setAttr("%s.%s"%(mentalcoreLensName,eachMCLKey),eachMCLValue)
if type(eachMCLValue) == bool:
cmds.setAttr("%s.%s"%(mentalcoreLensName,eachMCLKey),eachMCLValue)
if type(eachMCLValue) == str:
cmds.setAttr("%s.%s"%(mentalcoreLensName,eachMCLKey),eachMCLValue, type="string")
if type(eachMCLValue) == tuple:
print "%s.%s %s Progressing" %(mentalcoreLensName,eachMCLKey,eachMCLValue)
print type(eachMCLValue)
if eachMCLValue == "":
cmds.setAttr("%s.%s"%(mentalcoreLensName,eachMCLKey),"", type="string")
return
def configure_layers(self, *args):
mate_shaders = self.cwd + '/Scripts/shot_builder/lib/shadow_layer_mtl.ma'
scene_references = cmds.ls(references=True)
# Reference shader file
utils.reference(mate_shaders)
# Create render layers if not exist
utils.create_render_layers(['FG', 'BG', 'SHD', 'zDepth'])
##### FG START #####
fg_layer_name = 'FG'
# Configure vray render elements
self.enable_element(fg_layer_name, {'char': True, 'env': False})
# List all object with 'char' tag attribute
fg_objects = utils.list_by_tag('char', type='transform')
# Move to FG layer
cmds.editRenderLayerMembers(fg_layer_name,
utils.get_roots(fg_objects),
noRecurse=True)
##### FG END #####
##### BG START #####
bg_layer_name = 'BG'
self.enable_element(bg_layer_name, {'char': False, 'env': True})
bg_objects = utils.list_by_tag('env', type='transform')
cmds.editRenderLayerMembers(bg_layer_name,
utils.get_roots(bg_objects),
noRecurse=True)
##### BG END #####
##### SHD START #####
shadow_layer_name = 'SHD'
# Move to foreground and background objects to SHD layer
cmds.editRenderLayerMembers(shadow_layer_name,
utils.get_roots(fg_objects),
noRecurse=True)
cmds.editRenderLayerMembers(shadow_layer_name,
utils.get_roots(bg_objects),
noRecurse=True)
# Set currendt layer to SHD
cmds.editRenderLayerGlobals(currentRenderLayer=shadow_layer_name)
# Assign matte material to foreground objects
for node in fg_objects:
cmds.select(node)
cmds.hyperShade(a='matte')
# Assign vray_wrapper material to background objects
for node in bg_objects:
cmds.select(node)
cmds.hyperShade(a='vray_wrapper')
# Configure vray render elements
self.enable_element(shadow_layer_name, {'char': False, 'env': False})
# Disable all dome lights
utils.set_layer_attr('VRayLightDomeShape', 'enabled', False,
shadow_layer_name)
##### SHD END #####
##### zDepth START #####
zdepth_layer_name = 'zDepth'
# Move to foreground and background objects to zDepth layer
cmds.editRenderLayerMembers(zdepth_layer_name,
utils.get_roots(fg_objects),
noRecurse=True)
cmds.editRenderLayerMembers(zdepth_layer_name,
utils.get_roots(bg_objects),
noRecurse=True)
# Set currendt layer to zDepth
cmds.editRenderLayerGlobals(currentRenderLayer='zDepth')
# Assign matte shader for FG and BG objects
for node in fg_objects + bg_objects:
cmds.select(node)
cmds.hyperShade(a='matte')
# Configure vray render elements
self.enable_element(zdepth_layer_name, {'char': False, 'env': False})
# Create zDepth render element
zdepth_name = 'vrayRE_Z_depth'
if not cmds.objExists(zdepth_name):
maya.mel.eval('vrayAddRenderElement zdepthChannel;')
cmds.editRenderLayerAdjustment(zdepth_name + ".enabled",
layer=zdepth_layer_name)
cmds.setAttr(zdepth_name + ".enabled", True)
else:
print '%s render element already exists' % zdepth_name
# Disable all dome lights
utils.set_layer_attr('VRayLightDomeShape', 'enabled', False,
zdepth_layer_name)
def buildRenLyr(self, renLyrObjInfo, renLyrShpInfo, *args):
'''
Create render layer and add corresponding object to render layer.
Assign materials for each render layer with renLyrShpInfo dictionary data.
Set shape render stats.
'''
nameSpace = cmds.optionMenu('nameSpaceOptMenu', q = True, v = True)
cmds.editRenderLayerGlobals(currentRenderLayer = 'defaultRenderLayer')
recreateRenLyrOpt = cmds.checkBox('recreateRenChkBox', q = True, v = True)
if recreateRenLyrOpt:
# Delete all render layers.
oldRendLyrLs = cmds.ls(type = 'renderLayer')
for oldRenLyr in oldRendLyrLs:
if not 'defaultRenderLayer' in oldRenLyr:
cmds.delete(oldRenLyr)
# Create render layers.
for renderLayer in renLyrShpInfo.keys():
cmds.createRenderLayer(empty = True, name = renderLayer, noRecurse = True)
for renLyr in renLyrShpInfo.keys():
cmds.editRenderLayerGlobals(currentRenderLayer = renLyr)
# Add objects to corresponding render layer.
for obj in renLyrObjInfo[renLyr]:
if ':' in obj:
obj = nameSpace + ':' + obj.split(':', 1)[-1]
if cmds.objExists(obj):
cmds.editRenderLayerMembers(renLyr, obj, noRecurse = True)
else:
pass
for shpObj in renLyrShpInfo[renLyr]:
mat = shpObj.assignedMat
if ':' in mat:
mat = nameSpace + ':' + mat.split(':', 1)[-1]
if not cmds.objExists(mat):
continue
shape = shpObj.shapeName
if ':' in shape:
newNameSpacedName = nameSpace + ':' + shape.split(':', 1)[-1]
if cmds.objExists(newNameSpacedName):
# Material assign.
cmds.select(newNameSpacedName, r = True)
cmds.hyperShade(assign = mat)
# Set shape render stats.
for renStat in renStatLs:
renStatVal = getattr(shpObj, renStat)
cmds.setAttr('%s.%s' %(newNameSpacedName, renStat), renStatVal)
else:
pass
else:
if cmds.objExists(shape):
# Material assign.
cmds.select(shape, r = True)
cmds.hyperShade(assign = mat)
# Set shape render stats.
for renStat in renStatLs:
renStatVal = getattr(shpObj, renStat)
cmds.setAttr('%s.%s' %(shape, renStat), renStatVal)
else:
pass
print '> Build render layer job is done.'
def main():
import maya.cmds as cmds
import maya.mel as mel
#### Select renderLayer with geo, will create lighting passes and utility layer.
#get selected renderLayer
beautyRenderLayer = cmds.editRenderLayerGlobals(q=1, crl=1)
currentRenderLayer = cmds.editRenderLayerGlobals(q=1, crl=1)
#get settings from any existing layer ObjectProperties, to copy to utility settings
existingVis = []
layerAdj = cmds.editRenderLayerAdjustment(currentRenderLayer,
query=True,
layer=True)
if layerAdj:
for adj in layerAdj:
try:
node, attr = adj.split('.')
if node:
if cmds.nodeType(node) == 'RedshiftVisibility':
existingVis.append([adj, cmds.getAttr(adj)])
except:
pass
if not "_Beauty" in currentRenderLayer:
cmds.confirmDialog(m="_\"Beauty\" not found in renderlayer")
else:
utilityLayer = currentRenderLayer.replace("Beauty", "Utility")
#create Utility layer
if not cmds.objExists(utilityLayer):
cmds.createRenderLayer(n=utilityLayer, nr=1)
#add geo
print "adding geo to", utilityLayer
contents = cmds.editRenderLayerMembers(currentRenderLayer, q=1, fn=1)
if contents:
for obj in contents:
if cmds.objExists(obj):
cmds.editRenderLayerMembers(utilityLayer, obj, nr=1)
cmds.editRenderLayerGlobals(currentRenderLayer=utilityLayer)
currentRenderLayer = utilityLayer
#add layer ObjectProperties
for vis in existingVis:
attr, val = vis
cmds.editRenderLayerAdjustment(attr, layer=currentRenderLayer)
cmds.setAttr(attr, val)
#TURN OFF LIGHTS, make optimizations
sceneLights = []
sceneLights.extend(cmds.ls(type='RedshiftPhysicalLight'))
sceneLights.extend(cmds.ls(type='RedshiftPhysicalSun'))
sceneLights.extend(cmds.ls(type='RedshiftDomeLight'))
sceneLights.extend(cmds.ls(type='RedshiftPortalLight'))
sceneLights.extend(cmds.ls(type='RedshiftIESLight'))
for light in sceneLights:
cmds.editRenderLayerAdjustment(light + '.on',
layer=currentRenderLayer)
cmds.setAttr(light + '.on', 0)
turnOff = [
"redshiftOptions.primaryGIEngine",
"redshiftOptions.secondaryGIEngine",
"redshiftOptions.emissionEnable",
"redshiftOptions.subsurfaceScatteringEnable",
"redshiftOptions.refractionRaysEnable",
"redshiftOptions.reflectionRaysEnable",
"defaultRenderGlobals.enableDefaultLight"
]
for to in turnOff:
cmds.editRenderLayerAdjustment(to, layer=currentRenderLayer)
cmds.setAttr(to, 0)
#assume ulityMatteLayerOveride exists from setupRenderElements.py script
#cmds.editRenderLayerAdjustment("utilityMatteLayerOveride.matteEnable", layer=currentRenderLayer)
#cmds.setAttr("utilityMatteLayerOveride.matteEnable",1)
'''
#CREATE mattes based on asset data found in shape nodes
matteData={}
mats=cmds.ls(type='shadingEngine')
for mat in mats:
if 'matteLayer' in cmds.listAttr(mat):
matteLayer=cmds.getAttr(mat+".matteLayer")
if matteLayer:
layer,color,name=matteLayer.split(".")
id=cmds.getAttr(mat+".rsMaterialId")
if not layer in matteData.keys():
matteData[layer]={'red':'','green':'','blue':''}
matteData[layer][color]=id
existingAovs=cmds.ls(type='RedshiftAOV')
for layer in matteData.keys():
aovMatteName='rsAov_'+layer
if not aovMatteName in existingAovs:
aov=mel.eval("redshiftCreateAov(\"Puzzle Matte\")")
cmds.setAttr(aov+".name",layer,type="string")
cmds.setAttr(aov+".enabled",0)
cmds.setAttr(aov+".filePrefix","<BeautyPath>/<RenderPass>/<BeautyFile>.<RenderPass>",type="string")
cmds.setAttr(aov+".exrCompression", 4)
cmds.rename(aov,aovMatteName)
if matteData[layer]['red']:
cmds.setAttr(aovMatteName+'.redId',matteData[layer]['red'])
if matteData[layer]['green']:
cmds.setAttr(aovMatteName+'.greenId',matteData[layer]['green'])
if matteData[layer]['blue']:
cmds.setAttr(aovMatteName+'.blueId',matteData[layer]['blue'])
'''
try:
mel.eval("redshiftUpdateActiveAovList")
except:
pass
#DETERMINE WHICH MATTES ARE USED IN CURRENT LAYER
layerMembers = []
for mem in cmds.editRenderLayerMembers(beautyRenderLayer, q=1, fn=1):
mem = mem.split('|')[1]
if not mem in layerMembers:
layerMembers.append(mem)
usedMattes = []
mats = cmds.ls(type='shadingEngine')
for mat in mats:
if 'matteLayer' in cmds.listAttr(mat):
connections = cmds.sets(mat, q=1)
if connections:
for con in connections:
par = cmds.ls(con, long=True)[0].split('|')[1]
matLayerName = cmds.getAttr(mat + ".matteLayer").split(
'.')[0]
if par in layerMembers and not matLayerName in usedMattes:
usedMattes.append(matLayerName)
#CREATE AOVS IF NOT EXIST
existingAovs = cmds.ls(type='RedshiftAOV')
#add all aovs
for utilAov in utilAovs.keys():
if not utilAov in existingAovs:
aov = mel.eval("redshiftCreateAov(\"" + utilAovs[utilAov] +
"\")")
if utilAov == 'rsAov_WorldPosition_filter':
cmds.setAttr(aov + '.name', "P_filter", type="string")
cmds.rename(aov, utilAov)
try:
mel.eval("redshiftUpdateActiveAovList")
except:
print 'Aov Window not found'
#get list of all aovs, turn off all
existingAovs = cmds.ls(type='RedshiftAOV')
for aov in existingAovs:
cmds.editRenderLayerAdjustment(aov + ".enabled",
layer=currentRenderLayer)
cmds.setAttr(aov + ".enabled", 0)
if aov == 'rsAov_WorldPosition' or aov == 'rsAov_Depth':
cmds.setAttr(aov + ".filterMode", 3)
if aov == 'rsAov_WorldPosition_filter':
cmds.setAttr(aov + ".filterMode", 0)
if aov == 'rsAov_MotionVectors':
cmds.setAttr(aov + '.outputRawVectors', 1)
cmds.setAttr(aov + '.filtering', 0)
print usedMattes
#turn on usedMattes only
for aov in usedMattes:
cmds.setAttr('rsAov_' + aov + ".enabled", 1)
cmds.setAttr("rsAov_ObjectID.enabled", 1)
#turn on utils only
for aov in utilAovs.keys():
if aov in existingAovs:
cmds.setAttr(aov + ".enabled", 1)
def remove(self, objs): """remove specific objs from render layer""" for o in objs: if o.exists: mc.editRenderLayerMembers( self.name, o, remove = True, noRecurse = True )
def qu(self):
if (cmds.checkBoxGrp(self.aa, query=True, value1=True)):
self.createRenderLayerCommand(self.chkBx1Arr[0])
if (cmds.checkBoxGrp(self.bb, query=True, value1=True)):
self.createRenderLayerCommand(self.chkBx2Arr[0])
if (cmds.checkBoxGrp(self.bb, query=True, value2=True)):
self.createRenderLayerCommand(self.chkBx2Arr[1])
if (cmds.checkBoxGrp(self.bb, query=True, value3=True)):
self.createRenderLayerCommand(self.chkBx2Arr[2])
if (cmds.checkBoxGrp(self.bb, query=True, value4=True)):
self.createRenderLayerCommand(self.chkBx2Arr[3])
utils.executeDeferred(mel.eval('renderLayerEditorRenderable RenderLayerTab \"defaultRenderLayer\" 0;'))
utils.executeDeferred(mel.eval('updateEditorFeedbackRenderLayer RenderLayerTab defaultRenderLayer;'))
allRenderLayerName = cmds.ls(type='renderLayer')
utils.executeDeferred(mel.eval('updateRendererUI;'))
utils.executeDeferred(mel.eval('unifiedRenderGlobalsWindow ;'))
for each in allRenderLayerName:
cmds.editRenderLayerGlobals(currentRenderLayer=each)
if(each=="Ambient_Occlusion"):
print "AO"
cmds.editRenderLayerAdjustment("defaultRenderGlobals.currentRenderer")
cmds.setAttr("defaultRenderGlobals.currentRenderer", "mentalRay", type="string")
cmds.editRenderLayerAdjustment("defaultRenderGlobals.imageFormat")
cmds.setAttr("defaultRenderGlobals.imageFormat", 3)
mel.eval("renderLayerBuiltinPreset occlusion " + each) # comments missing
ShadingGroup = cmds.listConnections(each, s=True, d=False, type="shadingEngine")
SurfaceShader = cmds.listConnections(ShadingGroup[0], s=True,d=False)
ao = cmds.listConnections(SurfaceShader[0], s=True, d=False )
cmds.setAttr( (ao[0]+".samples"), 32)
cmds.editRenderLayerAdjustment("miDefaultOptions.maxSamples")
cmds.setAttr("miDefaultOptions.maxSamples", 2)
cmds.editRenderLayerAdjustment("miDefaultOptions.filter")
cmds.setAttr( "miDefaultOptions.filter", 1)
cmds.editRenderLayerAdjustment("miDefaultOptions.rayTracing")
cmds.editRenderLayerAdjustment("miDefaultOptions.maxReflectionRays")
cmds.editRenderLayerAdjustment("miDefaultOptions.maxRefractionRays")
cmds.editRenderLayerAdjustment("miDefaultOptions.maxRayDepth")
cmds.editRenderLayerAdjustment("miDefaultOptions.maxShadowRayDepth")
cmds.setAttr("miDefaultOptions.maxReflectionRays", 1)
cmds.setAttr("miDefaultOptions.maxRefractionRays", 1)
cmds.setAttr("miDefaultOptions.maxRayDepth", 1)
cmds.setAttr("miDefaultOptions.maxShadowRayDepth", 2)
utils.executeDeferred(mel.eval('applyOcclusion("Ambient_Occlusion")')) # comments missing
cmds.setAttr("miDefaultOptions.globalIllum", 0)
cmds.setAttr("miDefaultOptions.finalGather", 0)
elif (each == "Beauty"):
print "Beauty"
cmds.editRenderLayerMembers("Beauty",noRecurse=True) # mentalrayIbl1
cmds.editRenderLayerAdjustment("defaultRenderGlobals.currentRenderer")
cmds.setAttr("defaultRenderGlobals.currentRenderer" , "mentalRay", type = "string" )
cmds.editRenderLayerAdjustment("defaultRenderGlobals.imageFormat")
cmds.setAttr("defaultRenderGlobals.imfPluginKey", "exr", type="string")
cmds.setAttr("defaultRenderGlobals.imageFormat",51)
# if not (cmds.isConnected( 'Beauty.renderPass', 'depth.owner' )):
# cmds.connectAttr('Beauty.renderPass', 'depth.owner', nextAvailable=True)
# else:
if ((cmds.connectionInfo( 'defaultRenderLayer.renderPass', isDestination=True) == False) and (cmds.connectionInfo( 'defaultRenderLayer.renderPass', isSource=True) == False)):
cmds.connectAttr("defaultRenderLayer.renderPass", "depth.owner",na=True)
cmds.connectAttr("defaultRenderLayer.renderPass", "diffuse.owner",na=True)
cmds.connectAttr("defaultRenderLayer.renderPass", "incandescence.owner",na=True)
cmds.connectAttr("defaultRenderLayer.renderPass", "indirect.owner",na=True)
cmds.connectAttr("defaultRenderLayer.renderPass", "mv2DToxik.owner",na=True)
cmds.connectAttr("defaultRenderLayer.renderPass", "reflection.owner",na=True)
cmds.connectAttr("defaultRenderLayer.renderPass", "refraction.owner",na=True)
cmds.connectAttr("defaultRenderLayer.renderPass", "shadow.owner",na=True)
cmds.connectAttr("defaultRenderLayer.renderPass", "specular.owner",na=True)
elif (each == "RGB"):
print "RGB"
cmds.editRenderLayerAdjustment('defaultRenderGlobals.currentRenderer')
cmds.setAttr('defaultRenderGlobals.currentRenderer', 'mayaSoftware', type='string')
cmds.editRenderLayerAdjustment('defaultRenderGlobals.imageFormat')
cmds.setAttr('defaultRenderGlobals.imageFormat', 4)
rendQual = cmds.listConnections('defaultRenderGlobals.qual')
cmds.setAttr(rendQual[0]+'.shadingSamples', 2)
cmds.setAttr(rendQual[0]+'.maxShadingSamples', 8)
cmds.setAttr(rendQual[0]+'.visibilitySamples', 1)
cmds.setAttr(rendQual[0]+'.maxVisibilitySamples', 4)
cmds.setAttr(rendQual[0]+'.edgeAntiAliasing', 0)
cmds.setAttr(rendQual[0]+'.useMultiPixelFilter', 1)
cmds.setAttr(rendQual[0]+'.redThreshold', 0.4)
cmds.setAttr(rendQual[0]+'.greenThreshold', 0.3)
cmds.setAttr(rendQual[0]+'.blueThreshold', 0.6)
cmds.setAttr('defaultRenderGlobals.motionBlur', 1)
cmds.setAttr('defaultRenderGlobals.motionBlurUseShutter', 1)
cmds.setAttr('defaultRenderGlobals.motionBlurShutterOpen', 0)
cmds.setAttr('defaultRenderGlobals.motionBlurShutterClose', 0)
cmds.setAttr('defaultRenderGlobals.motionBlurUseShutter', 0)
cmds.setAttr('defaultRenderGlobals.motionBlur', 0)
if(cmds.window(self.win, q = 1, ex = 1)):
cmds.deleteUI(self.win,window=True)
def createRenderLayer(trigger):
if cmds.textScrollList('YM_ReferenceWindow_List', q=True, si=True) is None:
cmds.warning('Select Some Reference Name!!!')
return
sceneAOVs = cmds.ls(type='aiAOV')
if trigger is True:
for reference in cmds.textScrollList('YM_ReferenceWindow_List',
q=True,
si=True):
#Get reference's RenderLayer Node and give a hint with already layered reference
count = 0
for renderLayer in referenceNodeTypeFilter(
cmds.referenceQuery(reference, nodes=True, dp=True),
'renderLayer'):
if re.search('(defaultRenderLayer){1,}', renderLayer) is None:
if cmds.confirmDialog(
title='Continue?',
message=reference +
' has some renderLayers already, Continue?',
button=['Yes', 'No'],
defaultButton='Yes',
cancelButton='No',
dismissString='No') == 'No':
count = 1
continue
if count > 0:
continue
renderableShapes = cmds.listRelatives(
findRenderableObjects(reference), p=True, f=True)
if len(renderableShapes) == 0:
continue
#Get the reference filename
filenameList = getFormatFilename(
cmds.referenceQuery(reference, filename=True, wcn=True))
#Get reference's aiAOV Node
referenceAOVs = referenceNodeTypeFilter(
cmds.referenceQuery(reference, nodes=True), 'aiAOV')
referenceLayer = cmds.createRenderLayer(e=True,
n=filenameList[1],
noRecurse=True)
cmds.editRenderLayerMembers(referenceLayer,
renderableShapes,
nr=True)
#Switch to defaultRenderLayer and set the reference AOVs to disabled
cmds.editRenderLayerGlobals(crl='defaultRenderLayer')
for aov in referenceAOVs:
cmds.setAttr(aov + '.enabled', 0)
#Switch to new Layer and set the relative AOVs to enabled , the unrelative AOVs to disabled
cmds.editRenderLayerGlobals(crl=referenceLayer)
for aov in sceneAOVs:
cmds.editRenderLayerAdjustment(aov + '.enabled',
layer=referenceLayer)
if aov not in referenceAOVs:
cmds.setAttr(aov + '.enabled', 0)
else:
cmds.setAttr(aov + '.enabled', 1)
else:
renderableObjects = list()
referenceAOVs = list()
for reference in cmds.textScrollList('YM_ReferenceWindow_List',
q=True,
si=True):
for parent in cmds.listRelatives(findRenderableObjects(reference),
p=True,
f=True):
renderableObjects.append(parent)
for aov in referenceNodeTypeFilter(
cmds.referenceQuery(reference, nodes=True), 'aiAOV'):
referenceAOVs.append(aov)
if len(renderableObjects) == 0:
return
referenceLayer = cmds.createRenderLayer(e=True,
n='ChangeMyName',
noRecurse=True)
cmds.editRenderLayerMembers(referenceLayer, renderableObjects, nr=True)
cmds.editRenderLayerGlobals(crl='defaultRenderLayer')
for aov in referenceAOVs:
cmds.setAttr(aov + '.enabled', 0)
cmds.editRenderLayerGlobals(crl=referenceLayer)
for aov in sceneAOVs:
cmds.editRenderLayerAdjustment(aov + '.enabled',
layer=referenceLayer)
if aov not in referenceAOVs:
cmds.setAttr(aov + '.enabled', 0)
else:
cmds.setAttr(aov + '.enabled', 1)
def process(self, instance):
context = instance.context
original = instance
member = instance[:]
member += cmds.listRelatives(member,
allDescendents=True,
fullPath=True) or []
cameras = cmds.ls(member, type="camera", long=True)
if not cameras:
return
# Get all valid renderlayers
# This is how Maya populates the renderlayer display
rlm_attribute = "renderLayerManager.renderLayerId"
connected_layers = cmds.listConnections(rlm_attribute) or []
valid_layers = set(connected_layers)
# Context data
workspace = context.data["workspaceDir"]
context.data["outputDir"] = os.path.join(workspace, "renders")
# Are there other renderlayer than defaultRenderLayer ?
context.data["hasRenderLayers"] = len(valid_layers) > 1
# Using Render Setup system ?
context.data["usingRenderSetup"] = lib.is_using_renderSetup()
# Get all renderable renderlayers (not referenced)
renderlayers = sorted(lib.ls_renderable_layers(),
key=lambda l: # By renderlayer displayOrder
cmds.getAttr("%s.displayOrder" % l))
# Create instance by renderlayers
collected = False
for layer in renderlayers:
all_render_cams = lib.ls_renderable_cameras(layer)
render_cams = list(set(cameras).intersection(set(all_render_cams)))
if not render_cams:
self.log.warning("No renderable camera in %s, skipping.."
"" % layer)
continue
collected = True
self.log.debug("Creating instance for renderlayer: %s" % layer)
# Check if layer is in valid (linked) layers
if layer not in valid_layers:
self.log.warning("%s is invalid, skipping" % layer)
continue
layer_members = cmds.editRenderLayerMembers(layer,
query=True,
fullNames=True)
# (NOTE): Some of renderLayer member may not exists..
layer_members = cmds.ls(layer_members)
layername = lib.pretty_layer_name(layer)
renderer = get_render_attr("currentRenderer", layer)
name_preview = utils.compose_render_filename(layer)
ext = os.path.splitext(name_preview)[-1]
# Get layer specific settings, might be overrides
data = {
"renderlayer": layer,
"startFrame": get_render_attr("startFrame", layer),
"endFrame": get_render_attr("endFrame", layer),
"byFrameStep": get_render_attr("byFrameStep", layer),
"renderer": renderer,
"fileNamePrefix": utils.get_render_filename_prefix(layer),
"fileExt": ext,
"renderCam": render_cams,
}
data.update(original.data)
data["families"] = self.families[:]
data["dependencies"] = dict()
data["futureDependencies"] = dict()
data["subset"] += "." + layername
data["category"] = "[{renderer}] {layer}".format(
renderer=data["renderer"], layer=layername)
instance = context.create_instance(data["subset"])
instance.data.update(data)
# Push renderlayer members into instance,
# for collecting dependencies
instance += layer_members
if collected:
# Original instance contain renderable camera,
# we can safely remove it
context.remove(original)
# Sort by renderlayers, masterLayer will be on top
L = (lambda i: i.data["subset"].split(".")[-1])
context.sort(key=lambda i: 0 if L(i) == "masterLayer" else L(i))
def getRenderLayerObjects(renderLayer):
objectsInLayer = cmds.editRenderLayerMembers(renderLayer, q=True)
return objectsInLayer
def setupOverides():
import maya.cmds as cmds
import maya.mel as mel
#### Select renderLayer with geo, will create lighting passes and utility layer.
#get selected renderLayer
currentRenderLayer = cmds.editRenderLayerGlobals(q=1, crl=1)
#get settings from any existing vrayObjectProperties, to copy to utility settings
existingVis = []
layerAdj = cmds.editRenderLayerAdjustment(currentRenderLayer,
query=True,
layer=True)
if layerAdj:
for adj in layerAdj:
if "vrayobjectproperties" in adj:
existingVis.append([adj, cmds.getAttr(adj)])
matteLayer = currentRenderLayer + "_DeepMatte"
#create Matte layer
if not cmds.objExists(matteLayer):
cmds.createRenderLayer(n=matteLayer, nr=1)
#add geo
print "adding geo to", matteLayer
contents = cmds.editRenderLayerMembers(currentRenderLayer, q=1, fn=1)
for obj in contents:
if cmds.objExists(obj):
cmds.editRenderLayerMembers(matteLayer, obj, nr=1)
cmds.editRenderLayerGlobals(currentRenderLayer=matteLayer)
currentRenderLayer = matteLayer
#turn off all existing render Elements in matteLayer
for elem in mel.eval('vrayRenderElementsExisting'):
cmds.editRenderLayerAdjustment(elem + ".enabled",
layer=currentRenderLayer)
cmds.setAttr(elem + ".enabled", 0)
#add render elements for Ids
if not "vrayRE_Object_ID" in mel.eval('vrayRenderElementsExisting'):
extraTex = mel.eval("vrayAddRenderElement nodeIDChannel")
if not "vrayRE_Multi_Matte_ID" in mel.eval('vrayRenderElementsExisting'):
extraTex = mel.eval("vrayAddRenderElement multimatteIDChannel")
if not "vrayRE_Render_ID" in mel.eval('vrayRenderElementsExisting'):
extraTex = mel.eval("vrayAddRenderElement renderIDChannel")
print 'here'
#set layer overide renderSettings, turn off GI, resolution, filtering, lights
cmds.editRenderLayerAdjustment("vraySettings.imageFormatStr",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment("vraySettings.giOn",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment("vraySettings.globopt_light_doLights",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment(
"vraySettings.globopt_light_doDefaultLights", layer=currentRenderLayer)
cmds.editRenderLayerAdjustment(
"vraySettings.globopt_mtl_reflectionRefraction",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment("vraySettings.globopt_mtl_glossy",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment("vraySettings.globopt_mtl_SSSEnabled",
layer=currentRenderLayer)
cmds.editRenderLayerAdjustment(
"vraySettings.globopt_light_disableSelfIllumination",
layer=currentRenderLayer)
print 'testing'
#vrayObjectProperties
for vis in existingVis:
attr, val = vis
cmds.editRenderLayerAdjustment(attr, layer=currentRenderLayer)
#set rendersettings layer overides
cmds.setAttr("vraySettings.imageFormatStr", "exr (deep)",
type="string") #set deep exr format
cmds.setAttr("vraySettings.giOn", 0) #turn off GI
cmds.setAttr("vraySettings.globopt_light_doLights",
0) #turn off all lights
cmds.setAttr("vraySettings.globopt_light_doDefaultLights",
1) #turn on headlight
cmds.setAttr("vraySettings.globopt_mtl_reflectionRefraction",
0) #turn off refraction
cmds.setAttr("vraySettings.globopt_mtl_glossy", 0) #turn off glossy
cmds.setAttr("vraySettings.globopt_mtl_SSSEnabled", 0) #turn off sss
cmds.setAttr("vraySettings.globopt_light_disableSelfIllumination",
1) #turn off self illum
cmds.setAttr("vraySettings.imgOpt_exr_compression",
3) #set zip1 compression
matteAovs = [
"vrayRE_Object_ID", "vrayRE_Multi_Matte_ID", "vrayRE_Render_ID"
]
#turn on matte aovs
for aov in matteAovs:
if aov in mel.eval('vrayRenderElementsExisting'):
cmds.setAttr(aov + ".enabled", 1)
#copy settings from VrayObjectProperties
for vis in existingVis:
attr, val = vis
cmds.setAttr(attr, val)
#disable imagePlanes
imagePlanes = cmds.ls(type="imagePlane")
for ip in imagePlanes:
cmds.editRenderLayerAdjustment(ip + ".displayMode",
layer=currentRenderLayer)
cmds.setAttr(ip + ".displayMode", 0)
print 'final'
def add( self, objs ): """add objects to the render layer""" for o in objs: if o.exists: mc.editRenderLayerMembers( self.name, o, noRecurse = True )
