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