def create_render_layers(names): scene_render_layers = cmds.ls(type='renderLayer') for layer in names: if layer not in scene_render_layers: cmds.createRenderLayer(name=layer)
def create_render_layers(names):
scene_render_layers = cmds.ls(type='renderLayer')
for layer in names:
if layer not in scene_render_layers:
cmds.createRenderLayer(name=layer)
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 setupGICache(self):
print "setupGI"
#shotName = "%SHOTNAME%"
RLList = cmds.ls(type="renderLayer")
if "GI_RL" not in RLList:
cmds.createRenderLayer( noRecurse=True, name='GI_RL',mc=True, g=True )
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.dontSaveImage")
cmds.setAttr("vraySettings.dontSaveImage",1)
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.globopt_gi_dontRenderImage")
cmds.setAttr("vraySettings.globopt_gi_dontRenderImage",1)
cmds.editRenderLayerAdjustment( 'GI_RL', 'vraySettings.imap_mode')
cmds.setAttr('vraySettings.imap_mode', 6)
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.imap_dontDelete")
cmds.setAttr("vraySettings.imap_dontDelete",1)
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.imap_autoSave")
cmds.setAttr("vraySettings.imap_autoSave",1)
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.mode")
cmds.setAttr("vraySettings.mode",0)
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.relements_enableall")
cmds.setAttr("vraySettings.relements_enableall",0)
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.useCameraPath")
cmds.setAttr("vraySettings.useCameraPath", 1)
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.imap_useCameraPath")
cmds.setAttr("vraySettings.imap_useCameraPath", 1)
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.dontDelete")
cmds.setAttr("vraySettings.dontDelete", 1)
cmds.editRenderLayerAdjustment( 'GI_RL', "vraySettings.autoSave")
cmds.setAttr("vraySettings.autoSave", 1)
vrlmap = self.CachePath + '/' + self.dsShot + '_GICache.vrlmap'
vrmap = self.CachePath + '/' + self.dsShot + '_GICache.vrmap'
cmds.setAttr("vraySettings.autoSaveFile", vrlmap, type= "string")
cmds.setAttr("vraySettings.imap_autoSaveFile", vrmap, type="string")
self.refresh()
def createRenderLayerCommand(self,nm): print 'its this one...' if not (cmds.objExists(nm) and cmds.nodeType(nm) == "renderLayer" ): try: print "creating ",nm cmds.createRenderLayer( name= nm , number=1, noRecurse=True) return except: print "Unexpected error:", sys.exc_info()[0]
def mkApllyRL(): mkLayerName = [] for i in range (int (RlCount)): mkRlName = cmds.textFieldGrp(TxtFg[i], text = True,query = True) mkLayerName.append(mkRlName) mkRlexists = cmds.ls (mkRlName, type = 'renderLayer') if mkRlexists == []: cmds.createRenderLayer(n = mkRlName,empty = True) vrayUpdateUI()
def createRenderLayerCommand(self, nm):
print 'its this one...'
if not (cmds.objExists(nm) and cmds.nodeType(nm) == "renderLayer"):
try:
print "creating ", nm
cmds.createRenderLayer(name=nm, number=1, noRecurse=True)
return
except:
print "Unexpected error:", sys.exc_info()[0]
def createRenderlayers(states=None, nodes=None):
layerName = str(states["matteName"])
if nodes:
objects = []
for n in nodes:
cmds.select("%s:*" % n)
objects = objects + (cmds.ls(sl=True, long=True, type="transform"))
cmds.select(objects)
if objects:
cmds.createRenderLayer(objects, n=layerName, number=1, noRecurse=True, mc=True)
def doIt(self, argList):
st = cmds.ls(sl=1)
cmds.createRenderLayer(st)
cmds.vray("objectProperties", "add_single")
cmds.editRenderLayerGlobals(currentRenderLayer="renderLayer")
cmds.setAttr("vrayobjectproperties.primaryVisibility", 0)
cmds.editRenderLayerAdjustment(
"vrayobjectproperties.primaryVisibility")
cmds.setAttr("vrayobjectproperties.primaryVisibility", 1)
cmds.rename("renderLayer", str(st))
cmds.rename("vrayobjectproperties", str(st))
def createRL(*args):
layers = []
rls = [
"CarKey", "CarEnv", "BGKey", "BGEnv", "AO", "MatteA", "MatteB",
"MoVec", "Shadow"
]
movecShd = cmds.ls("*:*moVec_SHD")
if not movecShd:
movecShd = cmds.ls("*moVec_SHD")
if movecShd:
mvsg = cmds.listConnections(movecShd, type="shadingEngine")[0]
else:
cmds.warning("Can't find the movec shader")
aoShd = cmds.ls("*:*AO_SHD")
if not aoShd:
aoShd = cmds.ls("*AO_SHD")
if aoShd:
aosg = cmds.listConnections(aoShd, type="shadingEngine")[0]
else:
cmds.warning("can't find the ao shader")
for rl in rls:
if cmds.checkBox(widgets[rl], q=True, v=True):
layers.append(rl)
for each in layers:
cmds.createRenderLayer(n=renderLayer[each], mc=True, empty=True)
if each == "MoVec":
cmds.editRenderLayerAdjustment(
'defaultArnoldRenderOptions.motion_blur_enable',
lyr="ALL_MoVec")
cmds.setAttr("defaultArnoldRenderOptions.motion_blur_enable", 1)
cmds.editRenderLayerAdjustment(
"defaultArnoldRenderOptions.referenceTime", lyr="ALL_MoVec")
cmds.setAttr("defaultArnoldRenderOptions.referenceTime", 0.5)
cmds.editRenderLayerAdjustment(
"defaultArnoldRenderOptions.ignoreMotionBlur", lyr="ALL_MoVec")
cmds.setAttr("defaultArnoldRenderOptions.ignoreMotionBlur", 1)
print mvsg
if mvsg:
cmds.connectAttr("%s.message" % mvsg,
"ALL_MoVec.shadingGroupOverride",
f=True)
if each == "AO":
print aosg
if aosg:
cmds.connectAttr("%s.message" % aosg,
"ALL_AO.shadingGroupOverride",
f=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 createLayersFromLights(self, selectedGeometry=[], lightsSelected=[]):
#select all the lights in the scene includin IBL nodes
lights = cmds.ls(type=self.lightTypes)
if selectedGeometry != None and selectedGeometry != []:
geometry = list(
set(selectedGeometry) - set(lights) -
set(cmds.ls(type=self.NonGeoTypes)))
else:
#UPDATE:
geometry = cmds.ls(dag=True, geometry=True, selection=True)
#Bug Fix Issue #10 (This takes out the lights that are geo types and makes sure we only have what we understand as geo
geometry = list(
set(geometry) - set(lights) -
set(cmds.ls(type=self.NonGeoTypes)))
if geometry == []:
#select all the geometry in the scene
geometry = cmds.ls(geometry=True)
#take out the ibl shapes from the geo selection
# Bug fix Issue #1 and #8
geometry = list(
set(geometry) - set(lights) -
set(cmds.ls(type=self.NonGeoTypes)))
if lightsSelected != None and lightsSelected != []:
selectedLights = lightsSelected
else:
#see if there is any number of lights the the artist has selected
selectedLights = cmds.ls(dag=True,
selection=True,
type=self.lightTypes)
#if there isn't any lights selected just create one layer for each light
if selectedLights == []:
lightGroups = self.groupLightsByName(lights)
for group in lightGroups:
test = lightGroups[group]
lightTrans = cmds.listRelatives(test, p=1)
layerElements = geometry + lightGroups[group]
layerName = self.extractLightName(lightGroups[group][-1])
layerName += '_Light'
cmds.createRenderLayer(layerElements, name=layerName)
else:
#if we have a certain number of lights selected create a layer with all of those lights attached
lightTrans = cmds.listRelatives(selectedLights, p=1)
layerElements = geometry + lightTrans
layerName = self.extractLightName(lightTrans[-1])
cmds.createRenderLayer(layerElements, name=layerName)
def createRL(numSamples, spread, maxDistance):
# create a new render layer that includes all objects and all new objects
cmds.createRenderLayer(name='ao', g=True, makeCurrent=True)
# create a new surface shader for the ambient occlusion shader
surfShader = cmds.shadingNode('surfaceShader', asShader=True, name='amb_occl_surf_shader')
aoShader = cmds.shadingNode('mib_amb_occlusion', asShader=True, name='amb_occl')
cmds.connectAttr(aoShader+'.outValue', surfShader+'.outColor')
# create a new shading group for the ao shader
sg = cmds.sets(renderable=True, noSurfaceShader=True, empty=True, name='aoSG')
cmds.connectAttr(surfShader+'.outColor', sg+'.surfaceShader')
# add objects to render layer and adjust settings
reAdd(numSamples, spread, maxDistance)
def __init__(self):
self.widgets = {}
try:
mel.eval('mrRenderLayerPresetMenu "AOLayer";')
if not cmds.objExists('AOLayer'):
cmds.createRenderLayer(name='AOLayer', num=2)
mel.eval("mrRenderLayerBuiltinPreset occlusion AOLayer;")
cmds.editRenderLayerGlobals(currentRenderLayer='AOLayer')
cmds.setAttr('mib_amb_occlusion1.samples', 64)
except RuntimeError:
print "mrRenderLayerPresetMenu already initializied"
self.buildUI()
def add_depth_layer():
depth_layer_name = "DEPTH_LAYER"
if table:
cmd.select(obj_name+":Mesh", plane_name, r=True)
else:
cmd.select(obj_name+":Mesh")
cmd.createRenderLayer(name=depth_layer_name)
mel.eval("renderLayerBuiltinPreset linearDepth DEPTH_LAYER")
cmd.disconnectAttr("samplerInfo1.cameraNearClipPlane", "setRange1.oldMinX")
cmd.disconnectAttr("samplerInfo1.cameraFarClipPlane", "setRange1.oldMaxX")
cmd.setAttr("setRange1.minX", 0)
cmd.setAttr("setRange1.maxX", 1)
cmd.setAttr("setRange1.oldMinX", min_range)
cmd.setAttr("setRange1.oldMaxX", max_range)
def add_depth_layer():
depth_layer_name = "DEPTH_LAYER"
if table:
cmd.select(obj_name + ":Mesh", plane_name, r=True)
else:
cmd.select(obj_name + ":Mesh")
cmd.createRenderLayer(name=depth_layer_name)
mel.eval("renderLayerBuiltinPreset linearDepth DEPTH_LAYER")
cmd.disconnectAttr("samplerInfo1.cameraNearClipPlane", "setRange1.oldMinX")
cmd.disconnectAttr("samplerInfo1.cameraFarClipPlane", "setRange1.oldMaxX")
cmd.setAttr("setRange1.minX", 0)
cmd.setAttr("setRange1.maxX", 1)
cmd.setAttr("setRange1.oldMinX", min_range)
cmd.setAttr("setRange1.oldMaxX", max_range)
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 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 takeSnapShot(targetObj, renderPath, rotX=-30.0, rotY=45.0, rotZ=0.0, resX=300, resY=300, useBoundingBox=False):
'''
Take a snapshot of the selected object using the Maya renderer then move the image to a directory
'''
# build the bounding box and find it's centre
bBox = targetObj
if useBoundingBox is True:
bBox = buildBoundingBoxGeo(targetObj, noChildren=False, ignoreInv=True)
focusPoint = cmds.xform(bBox, query=True, ws=True, t=True)
# build the camera the move and orient it
tempCam = cmds.camera(ar=True, ff=3, fl=35)
camName = tempCam[1]
cmds.setAttr(camName+'.renderable', True)
cmds.setAttr(camName+'.displayFilmGate', True)
cmds.setAttr(camName+'.displayResolution', True)
cmds.setAttr(camName+'.backgroundColor', 0.5, 0.5, 0.5, type='double3') #transform
cmds.move(focusPoint[0], focusPoint[1], focusPoint[2], tempCam, ws=True)
cmds.rotate( rotX, rotY, rotZ, tempCam, ws=True)
# build the bounding box then fit the camera
cmds.select(bBox, r=True)
cmds.viewFit(camName, an = False, f = 0.9 )
if useBoundingBox is True:
cmds.delete(bBox)
# set the render globals
cmds.currentTime(1)
cmds.setAttr('defaultRenderGlobals.imageFormat', 8)
cmds.setAttr('defaultRenderQuality.edgeAntiAliasing', 0)
cmds.setAttr('defaultRenderQuality.shadingSamples', 2)
cmds.setAttr('defaultRenderQuality.maxShadingSamples', 8)
cmds.setAttr('defaultRenderQuality.useMultiPixelFilter', 1)
cmds.setAttr('defaultRenderQuality.enableRaytracing', 0)
# build the lightrig
lightRigGrp = cmds.group(em=True, name='lightRigGroup')
lightMain = cmds.directionalLight(rotation=(-20, -45, 0), intensity=0.8)
lightFill = cmds.directionalLight(rotation=(-20, 45, 0), intensity=0.4)
lightUnder = cmds.directionalLight(rotation=(75, 0, 0), intensity=0.15)
lightKey = cmds.directionalLight(rotation=(-25, 145, 0), intensity=4.0)
cmds.parent([lightMain, lightFill, lightUnder, lightKey], lightRigGrp)
cmds.rotate( rotX, rotY, rotZ, lightRigGrp, ws=True)
# select everything, build the special shader, render, then delete everything
cmds.select([targetObj, lightRigGrp], r=True)
renderLayerName = cmds.createRenderLayer(name='tempSnapShot_rlayer', mc=True)
shaderNodes = buildReverseNormalShader() #build the shader
cmds.sets(targetObj, e=True, forceElement=shaderNodes[0]) #adding the shader here means it's in the render layer
tempImage= cmds.render(camName, layer=renderLayerName, x=resX, y=resY)
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
cmds.delete([lightRigGrp, tempCam[0], renderLayerName, shaderNodes[0], shaderNodes[1], shaderNodes[2], shaderNodes[3]])
# copy the thumbnail to the desired location
output = cmds.sysFile(tempImage, rename=renderPath)
if output==True:
print 'Path for thumbnail: ' + renderPath
return renderPath
return None
def CreateRenderLayers():
cmds.editRenderLayerGlobals( currentRenderLayer = "defaultRenderLayer")
#******************************************************************
Layers = ["Signature","SQRSignature", "ContextSig", "Product","Wireframe","Subdivision_0","Subdivision_1","UVs"]
for i in Layers:
if not cmds.objExists(i):
cmds.createRenderLayer(n = i, g = True)
cmds.setAttr("defaultRenderLayer.renderable", False)
cmds.setAttr("persp.renderable", True)
RenderLayerManagerClass.EditLayer(settings = [
["persp.renderable", "none", False ]
],
layers = ["Signature","SQRSignature", "ContextSig", "Product", "Wireframe", "Subdivision_0", "Subdivision_1", "UVs"] )
cmds.editRenderLayerGlobals( currentRenderLayer = "defaultRenderLayer")
def createRenderLayer(*args, **kwargs):
res = cmds.createRenderLayer(*args, **kwargs)
wraps = _factories.simpleCommandWraps['createRenderLayer']
for func, wrapCondition in wraps:
if wrapCondition.eval(kwargs):
res = func(res)
break
return res
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 create_layer(self, root_items, name='pfad_layer'):
""" Create layer and include all root/all objects """
# name_001
name = '{0}_{1:03d}'.format(name, len(self.rl))
# Create render layer, noRecurse->add all child objects of root obj
__rl = cmds.createRenderLayer(root_items, noRecurse=False, name=name)
return __rl
def createLayersFromLights(self, selectedGeometry=[], lightsSelected=[]): #select all the lights in the scene includin IBL nodes lights = cmds.ls(type=self.lightTypes) if selectedGeometry !=None and selectedGeometry !=[]: geometry = list(set(selectedGeometry) - set(lights) -set(cmds.ls(type =self.NonGeoTypes))) else: #UPDATE: geometry = cmds.ls(dag=True,geometry=True, selection=True) #Bug Fix Issue #10 (This takes out the lights that are geo types and makes sure we only have what we understand as geo geometry = list(set(geometry) - set(lights) -set(cmds.ls(type =self.NonGeoTypes))) if geometry == []: #select all the geometry in the scene geometry = cmds.ls(geometry=True) #take out the ibl shapes from the geo selection # Bug fix Issue #1 and #8 geometry = list(set(geometry) - set(lights) -set(cmds.ls(type =self.NonGeoTypes))) if lightsSelected !=None and lightsSelected !=[]: selectedLights = lightsSelected else: #see if there is any number of lights the the artist has selected selectedLights = cmds.ls(dag=True, selection=True, type=self.lightTypes) #if there isn't any lights selected just create one layer for each light if selectedLights == []: lightGroups = self.groupLightsByName(lights) for group in lightGroups: test = lightGroups[group] lightTrans = cmds.listRelatives(test, p=1) layerElements = geometry + lightGroups[group] layerName = self.extractLightName(lightGroups[group][-1]) layerName += '_Light' cmds.createRenderLayer(layerElements, name=layerName) else: #if we have a certain number of lights selected create a layer with all of those lights attached lightTrans = cmds.listRelatives(selectedLights, p=1) layerElements = geometry + lightTrans layerName = self.extractLightName(lightTrans[-1]) cmds.createRenderLayer(layerElements, name=layerName)
def jpmMakeLayer(name):
allLayers = cmds.ls(et="renderLayer")
layerExists = 0
for layer in allLayers:
if name == layer:
layerExists = 1
if not layerExists:
cmds.createRenderLayer(name=name, number=1, empty=1, mc=1)
cmds.editRenderLayerAdjustment("defaultRenderGlobals.imageFilePrefix",
lyr=name)
cmds.setAttr("defaultRenderGlobals.imageFilePrefix",
name,
type="string")
cmds.setAttr((name + ".renderable"), 0)
print("Layer " + name + " made\n")
else:
print("Layer " + name + " already exists")
def assignTurntable(Camera):
#Works differently from the snapshots since they don't have the distinction of signature
#Get the name for the turntable layer
RenderLayer = "Turntable" + Camera[-1]
#Create a new render layer for the turntable
cmds.createRenderLayer( n = RenderLayer, g = True )
RenderLayerManagerClass.EditLayer(settings = [
[Camera + ".renderable", "none", True ],
["persp.renderable", "none", False ],
["defaultRenderGlobals.animation", "none", True],
["defaultRenderGlobals.startFrame", "none", cmds.getAttr(Camera + ".StartRange")],
["defaultRenderGlobals.endFrame", "none", cmds.getAttr(Camera + ".StopRange")],
["defaultRenderGlobals.outFormatControl", "none", 0],
["defaultRenderGlobals.putFrameBeforeExt", "none", 1],
["defaultRenderGlobals.periodInExt ", "none", 0],
["defaultRenderGlobals.imageFilePrefix", "string", "<Camera>/<Scene>_<Layer>_"],
["defaultRenderGlobals.extensionPadding", "none", 2]
],
layers = [RenderLayer] )
cmds.editRenderLayerGlobals( currentRenderLayer = RenderLayer)
#If background objects exist render the turntable with the background else use the shadow plane if it exists
if cmds.objExists("CMBackground"):
cmds.editRenderLayerAdjustment("CMBackground.visibility")
cmds.setAttr("CMBackground.visibility", 1)
if cmds.objExists("ShadowPlane"):
cmds.editRenderLayerAdjustment("ShadowPlane.visibility")
cmds.setAttr("ShadowPlane.visibility", 0)
#If userlights and light rig exist use the userlights for the turntable
if cmds.objExists("UserLights") and cmds.objExists("CMLightRig"):
cmds.editRenderLayerAdjustment("UserLights.visibility")
cmds.setAttr("UserLights.visibility", 1)
cmds.editRenderLayerAdjustment("CMLightRig.visibility")
cmds.setAttr("CMLightRig.visibility", 0)
RenderLayerManagerClass.EditLayer(settings = [["vraySettings.fileNamePrefix", "string", "<Camera>/<Scene>_<Layer>_"]],
layers = [RenderLayer] )
def createRL(*args):
layers = []
rls = ["CarKey", "CarEnv", "BGKey", "BGEnv", "AO", "MatteA", "MatteB", "MoVec", "Shadow"]
movecShd = cmds.ls("*:*moVec_SHD")
if not movecShd:
movecShd = cmds.ls("*moVec_SHD")
if movecShd:
mvsg = cmds.listConnections(movecShd, type="shadingEngine")[0]
else:
cmds.warning("Can't find the movec shader")
aoShd = cmds.ls("*:*AO_SHD")
if not aoShd:
aoShd = cmds.ls("*AO_SHD")
if aoShd:
aosg = cmds.listConnections(aoShd, type="shadingEngine")[0]
else:
cmds.warning("can't find the ao shader")
for rl in rls:
if cmds.checkBox(widgets[rl], q=True, v=True):
layers.append(rl)
for each in layers:
cmds.createRenderLayer(n=renderLayer[each], mc=True, empty=True)
if each == "MoVec":
cmds.editRenderLayerAdjustment('defaultArnoldRenderOptions.motion_blur_enable', lyr="ALL_MoVec")
cmds.setAttr("defaultArnoldRenderOptions.motion_blur_enable", 1)
cmds.editRenderLayerAdjustment("defaultArnoldRenderOptions.referenceTime", lyr="ALL_MoVec")
cmds.setAttr("defaultArnoldRenderOptions.referenceTime", 0.5)
cmds.editRenderLayerAdjustment("defaultArnoldRenderOptions.ignoreMotionBlur", lyr="ALL_MoVec")
cmds.setAttr("defaultArnoldRenderOptions.ignoreMotionBlur", 1)
print mvsg
if mvsg:
cmds.connectAttr("%s.message"%mvsg, "ALL_MoVec.shadingGroupOverride", f=True)
if each == "AO":
print aosg
if aosg:
cmds.connectAttr("%s.message"%aosg, "ALL_AO.shadingGroupOverride", f=True)
def setup_depth(self):
""" Sets up maya depth layers """
if self.use_table_:
cmd.select(self.obj_name_ + ":Mesh", self.plane_name_, r=True)
else:
cmd.select(self.obj_name_ + ":Mesh")
cmd.createRenderLayer(name=self.depth_layer_name_)
mel.eval("renderLayerBuiltinPreset linearDepth DEPTH_LAYER")
cmd.disconnectAttr("samplerInfo1.cameraNearClipPlane",
"setRange1.oldMinX")
cmd.disconnectAttr("samplerInfo1.cameraFarClipPlane",
"setRange1.oldMaxX")
cmd.setAttr("setRange1.minX", 0)
cmd.setAttr("setRange1.maxX", 1.0)
cmd.setAttr("setRange1.minY", 0)
cmd.setAttr("setRange1.maxY", 1.0)
cmd.setAttr("setRange1.minZ", 0)
cmd.setAttr("setRange1.maxZ", 1.0)
cmd.setAttr("setRange1.oldMinX", self.min_range_)
cmd.setAttr("setRange1.oldMaxX", self.max_range_)
def create_rl(num_samples, spread, max_distance):
"""
create a new render layer that includes all objects and all new objects
keyword args:
num_samples -- number of samples in the AO shader, higher samples == longer render times
spread -- angle at which the rays are cast out from the surface, smaller angle creates a harsher transition
max_distance -- how far the ray traces out into the scene before determining a collision
"""
cmds.createRenderLayer(name="ao", g=True, makeCurrent=True)
# create a new surface shader for the ambient occlusion shader
surf_shader = cmds.shadingNode("surfaceShader", asShader=True, name="amb_occl_surf_shader")
ao_shader = cmds.shadingNode("mib_amb_occlusion", asShader=True, name="amb_occl")
cmds.connectAttr(ao_shader + ".outValue", surf_shader + ".outColor")
# create a new shading group for the ao shader
sg = cmds.sets(renderable=True, noSurfaceShader=True, empty=True, name="aoSG")
cmds.connectAttr(surf_shader + ".outColor", sg + ".surfaceShader")
# add objects to render layer and adjust settings
re_add(num_samples, spread, max_distance)
def createLayersFromLights(self, selectedGeometry=[], lightsSelected=[]):
#select all the lights in the scene includin IBL nodes
lights = cmds.ls(type=['light', 'mentalrayIblShape'])
if selectedGeometry != None and selectedGeometry != []:
geometry = selectedGeometry
else:
#UPDATE:
geometry = cmds.ls(dag=True, geometry=True, selection=True)
if geometry == []:
#select all the geometry in the scene
geometry = cmds.ls(geometry=True)
#take out the ibl shapes from the geo selection
geometry = list(set(geometry) - set(lights))
if lightsSelected != None and lightsSelected != []:
selectedLights = lightsSelected
else:
#see if there is any number of lights the the artist has selected
selectedLights = cmds.ls(dag=True,
selection=True,
type=['light', 'mentalrayIblShape'])
#if there isn't any lights selected just create one layer for each light
if selectedLights == []:
lightGroups = self.groupLightsByName(lights)
for group in lightGroups:
test = lightGroups[group]
lightTrans = cmds.listRelatives(test, p=1)
layerElements = geometry + lightGroups[group]
layerName = self.extractLightName(lightGroups[group][-1])
cmds.createRenderLayer(layerElements, name=layerName)
else:
#if we have a certain number of lights selected create a layer with all of those lights attached
lightTrans = cmds.listRelatives(selectedLights, p=1)
layerElements = geometry + lightTrans
layerName = self.extractLightName(lightTrans[-1])
cmds.createRenderLayer(layerElements, name=layerName)
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 setup_ao(target):
# setup backdrop
cmds.polyPlane(name="ao_backdrop", w=15, h=15)
cmds.select(clear=True)
cmds.select("ao_backdrop")
cmds.move(0, -0.5, 0, relative=True)
'''
mel.eval('select -r ao_backdrop;')
mel.eval('sets -renderable true -noSurfaceShader true ' + \
'-empty -name -table_matSG;')
mel.eval('select -r ao_backdrop ; sets -e -forceElement table_matSG;')
'''
# create new render layer
select_objs(target)
cmds.createRenderLayer(name='ao', makeCurrent=True)
# create a new surface shader for the ambient occlusion shader
surf_shader = cmds.shadingNode('surfaceShader', asShader=True, \
name='amb_occl_surf_shader')
ao_shader = cmds.shadingNode('mib_amb_occlusion', asShader=True, name='amb_occl')
cmds.connectAttr(ao_shader + '.outValue', surf_shader + '.outColor')
# create a new shading group for the ao shader
sg = cmds.sets(renderable=True, noSurfaceShader=True, empty=True, name='aoSG')
cmds.connectAttr(surf_shader + '.outColor', sg + '.surfaceShader')
# switch to the ao render layer
cmds.editRenderLayerGlobals(currentRenderLayer='ao')
#mel.eval('editRenderLayerGlobals -currentRenderLayer defaultRenderLayer;')
select_objs(target)
objects = cmds.ls(selection=True)
cmds.select(objects)
mel.eval('sets -e -forceElement ' + sg)
change_ao_settings()
change_render_settings()
def createLayersFromLights(self, selectedGeometry=[], lightsSelected=[]): #select all the lights in the scene includin IBL nodes lights = cmds.ls(type=['light','mentalrayIblShape']) if selectedGeometry !=None and selectedGeometry !=[]: geometry = selectedGeometry else: #UPDATE: geometry = cmds.ls(dag=True,geometry=True, selection=True) if geometry == []: #select all the geometry in the scene geometry = cmds.ls(geometry=True) #take out the ibl shapes from the geo selection geometry = list(set(geometry) - set(lights)) if lightsSelected !=None and lightsSelected !=[]: selectedLights = lightsSelected else: #see if there is any number of lights the the artist has selected selectedLights = cmds.ls(dag=True, selection=True, type=['light','mentalrayIblShape']) #if there isn't any lights selected just create one layer for each light if selectedLights == []: lightGroups = self.groupLightsByName(lights) for group in lightGroups: test = lightGroups[group] lightTrans = cmds.listRelatives(test, p=1) layerElements = geometry + lightGroups[group] layerName = self.extractLightName(lightGroups[group][-1]) cmds.createRenderLayer(layerElements, name=layerName) else: #if we have a certain number of lights selected create a layer with all of those lights attached lightTrans = cmds.listRelatives(selectedLights, p=1) layerElements = geometry + lightTrans layerName = self.extractLightName(lightTrans[-1]) cmds.createRenderLayer(layerElements, name=layerName)
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 makeRenderLayer(self, namespace, key) : selObjs = [] if key in self.renderLayerGrp.keys() : objs = self.renderLayerGrp[key] for each in objs : selObj = '%s:%s' % (namespace, each) if mc.objExists(selObj) : selObjs.append(selObj) if selObjs : result = mc.createRenderLayer(selObjs, name = key, number = 1, noRecurse = True) print 'Create render layer %s -> %s' % (key, selObjs) return result
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 createPropRenderLayerCmd(self, rigGrp, camera, frame) :
layers = []
extraLayers = []
if mc.checkBox('%s_namespaceCB' % self.ui, q = True, v = True) :
namespace = rigGrp
else :
namespace = mayaTools.getNamespace(rigGrp)
# rigGrp = '%s:Rig_Grp' % (namespace)
key = 'prop'
# set prefix
mc.setAttr('defaultRenderGlobals.imageFilePrefix', '%s_<RenderLayer>' % namespace, type = "string")
extraLayers = mc.textScrollList('%s_renderLayerTSL' % self.ui, q = True, si = True)
baseLayer = layers
# add extra layer
if mc.checkBox('%s_extraCB' % self.ui, q = True, v = True) :
if extraLayers :
layers = layers + extraLayers
# else :
# mm.eval('error "Select atlease 1 render layers";')
# if not, use default layer
else :
result = mc.createRenderLayer(rigGrp, name = key, number = 1, noRecurse = True)
print 'Create render layer %s -> %s' % (key, rigGrp)
layers.append(result)
mc.setAttr('defaultRenderLayer.renderable', 0)
self.exportChar(namespace, rigGrp, layers, camera, frame)
mc.setAttr('defaultRenderLayer.renderable', 1)
if not mc.checkBox('%s_extraCB' % self.ui, q = True, v = True) :
mc.delete(baseLayer)
if mc.checkBox('%s_deleteCB' % self.ui, q = True, v = True) :
mc.delete(extraLayers)
self.listRenderLayer()
def make_layer(name,sf,ef, r_type):
rl_name = name
sels = cmds.ls(sl=True)
r_cam = cmds.textScrollList('r_cam', q=True, si=True)
cs = lambda x:cmds.listRelatives(x,shapes=True)
#check object exist
if not(cmds.objExists(name)):
l = cmds.createRenderLayer(n=rl_name, number=2,noRecurse=True)
drg = "defaultRenderGlobals"
cmds.editRenderLayerGlobals(crl=l)
cmds.editRenderLayerAdjustment("defaultRenderGlobals.imageFilePrefix")
cmds.editRenderLayerAdjustment("defaultRenderGlobals.imageFormat")
cmds.editRenderLayerAdjustment(drg+".currentRenderer")
cmds.setAttr(drg+".ren","mayaSoftware",typ="string")
cmds.setAttr(drg+".imageFilePrefix",rl_name,typ="string")
cmds.setAttr(drg+".imageFormat",32)
cmds.setAttr(drg + ".startFrame", sf)
cmds.setAttr(drg + ".endFrame", ef)
else: l = rl_name
put_obj(sels,rl_name)
# Collect Camera data
a_cam = cm_list()
a_cam = a_cam[0]
# All camera's renderable attribute is OFF.
for ac in a_cam:
cmds.setAttr(ac+".renderable", 0)
# Turn on "renderble" : selected camera.
cam = []
if not(type(r_cam) == types.NoneType):
for rc in r_cam:
x = cs(rc)
cmds.setAttr(x[0]+".renderable", 1)
cam.append(x)
return (l,cam)
def make_layer(n,cus,sw,sf,ef, r_type):
rl_name= ""
if sw:
rl_name = cus
else:
rl_name = n
l = cmds.createRenderLayer(n=rl_name, number=2,noRecurse=True)
cmds.editRenderLayerGlobals(crl=l)
cmds.editRenderLayerAdjustment("defaultRenderGlobals.imageFilePrefix")
cmds.editRenderLayerAdjustment("defaultRenderGlobals.imageFormat")
drg = "defaultRenderGlobals"
cmds.setAttr(drg+".imageFilePrefix",rl_name,typ="string")
cmds.setAttr(drg+".imageFormat",32)
cmds.setAttr(drg + ".startFrame", sf)
cmds.setAttr(drg + ".endFrame", ef)
if (r_type == "AO"):
cmds.editRenderLayerAdjustment(drg+".currentRenderer")
cmds.setAttr(drg+".ren","mentalRay",typ="string")
return l
def setupScene():
global util
errormsgs = []
util = Utils.utils()
chks = ['keychk', 'rimchk','colchk','occchk','rgbachk','gshchk','matchk']
chkstats = [mc.checkBox(x, q = True, v = True) for x in chks]
if not 1 in chkstats:
mc.confirmDialog(t='Warning', m = 'No layers are selected', b='OK', ma = "center")
return
#get dict of assets in their respective render layer groups
grpDict = findGrpDict()
layergrps = grpDict.keys()
layergrps.sort()
#find the path of the file, check naming of file and query the timeline
filepath = mc.file(q = True, sn = True)
filename = os.path.basename(filepath)
fildir = os.path.dirname(filepath)
refcut = mc.checkBox("refchk", q = True, v = True)
try:
shotname = filename.split("_")[1]
except:
mc.confirmDialog(t='Warning', m = 'Scene name is not correct', b='OK', ma = "center")
return
shstart = mc.playbackOptions(q = True, ast = True)
shend = mc.playbackOptions(q = True, aet = True)
#query the camera and the camera group
cam = mc.optionMenu('camlite', q = True, v = True)
#setup the name of the new files
clfile = filename[:-9] + "cl" + filename[-7:]
#check the file exists, then change to vesion folder
curr_path = fildir+'/'
clfilepath=curr_path+clfile
if mc.file(clfilepath,q=1,ex=1):
Overrite = mc.confirmDialog(
title='Confirm ',
message='Overwrite the existing file? ',
button=['Yes', 'No'],
defaultButton='Yes',
cancelButton='No',
dismissString='No')
if Overrite =='No':
return
chkpath=mc.getFileList (folder=curr_path)
ver_count=chkpath.count('ver')
verpath= curr_path+'ver/'
if not ver_count:
mc.sysFile(verpath,makeDir=1)
# else:
# verpath= curr_path+'ver/'
files = [ f for f in os.listdir(verpath) if (os.path.isfile (os.path.join(verpath,f))) and f[len(f)-3:len(f)]=='.ma']
if files:
ver = str(len(files)+1)
else:
ver='01'
newpath=verpath+clfile
mc.sysFile(filepath,copy=newpath)
newname=clfile[:19]+'%s.ma'%ver.zfill(2)
chgname=verpath+newname
mc.sysFile(newpath,rename=chgname)
#select all the assets specified in the setup window to export to a new file
selasts = []
refcutmiss = []
for each in layergrps:
for ast in grpDict[each]:
selasts.append(ast)
#add the camera to the selection
selasts.append(cam)
#add the ground and matte groups to the selection if they exist, else warn that they have not been setup
gndmteobjs = ["Grp_Ground", "Grp_Matte"]
if mc.objExists("Grp_Ground"):
gndmteobjs.pop(gndmteobjs.index("Grp_Ground"))
selasts.append("Grp_Ground")
if mc.objExists("Grp_Matte"):
gndmteobjs.pop(gndmteobjs.index("Grp_Matte"))
selasts.append("Grp_Matte")
if gndmteobjs:
gndmtemsg = "\n".join(gndmteobjs)
rslt = mc.confirmDialog(t='Warning', m="Ground/Matte Objects dont\nexist or havent been set up", b=['Continue', 'Cancel'], db='Continue', cb='Cancel', ds='Cancel', ma = 'center')
if rslt == 'Cancel':
return
else:
pass
mc.select(selasts, r = True)
#cmfile = filename[:-9] + "cm" + filename[-7:]
#export all selected assets, cameras and ground/matte groups to a new _cl_v00 file
mc.file((fildir + "/" + clfile), op = "v=0", typ = "mayaAscii", pr = True, es = True, f=True )
#force open the new _cl_v00 file without saving the old one
mc.file((fildir + "/" + clfile), op = "v=0", typ = "mayaAscii", lrd = "all", o = True, f = True)
#select camera and export selected camera to a new _cm_v00 file
#mc.select(cam, r = True)
#mc.file((fildir + "/" + cmfile), op = "v=0", typ = "mayaAscii", pr = True, es = True)
mc.select(cl = True)
#set the timeline and render globals, and move assets to their respective groups
mc.playbackOptions(e = True, ast = shstart)
mc.playbackOptions(e = True, aet = shend)
setrendglobals(shotname, shstart, shend)
try:
Utils.moveAssetsToGrps()
except:
pass
#setup the useBackground shader and assign it to the ground/matte objects if they exist
gndusebg = "groundmatteuseBGshader"
if mc.objExists(gndusebg):
mc.delete(gndusebg)
gndusebg = mc.shadingNode("useBackground", asShader = True, n = gndusebg)
mc.setAttr((gndusebg + ".specularColor"), 0, 0, 0, type = "double3")
mc.setAttr((gndusebg + ".reflectivity"), 0)
mc.setAttr((gndusebg + ".reflectionLimit"), 0)
mc.setAttr((gndusebg + ".shadowMask"), 0)
if mc.objExists("Grp_Ground"):
mc.select("Grp_Ground", r = True)
mc.hyperShade(assign = gndusebg)
if mc.objExists("Grp_Matte"):
mc.select("Grp_Matte", r = True)
mc.hyperShade(assign = gndusebg)
#query the rim/key light required and import the relevant light file from /assets/lighting
locquery = mc.optionMenu('Location', q = True, v = True)
rmkylight = mc.optionMenu('Time', q = True, v = True)
camquery = mc.optionMenu('camlite', q = True, v = True)
rmkyfile = "%s/%s/Location/%s/%s_rimkey.ma"%(util.path, util.litePath,locquery,rmkylight)
rimliteL = "%s:rimL"%rmkylight
rimliteR = "%s:rimR"%rmkylight
#refdoom = "%s:ref_doom"%rmkylight
keylite = "%s:key"%rmkylight
#fillite = "%s:fill"%rmkylight
#eyespec = "%s:eyespc"%rmkylight
if os.path.exists(rmkyfile):
if mc.objExists(rimliteL):
mc.delete(rimliteL)
if mc.objExists(rimliteR):
mc.delete(rimliteR)
#if mc.objExists(fillite):
#mc.delete(fillite)
if mc.objExists(keylite):
mc.delete(keylite)
mc.file(rmkyfile, i = True, typ = "mayaAscii", ra = True, ns = rmkylight, op = "v=0;p=17", pr = True)
else:
mc.confirmDialog(t='Warning', m = '%s file is not accessible'%rmkylight, b='OK', ma = "center")
return
#find the names of the imported rim/key lights in the scene and parent them to the 'Rim_key' group
if mc.objExists("LIGHTS"):
mc.delete("LIGHTS")
sclites = mc.ls(type = "light")
for each in sclites:
if ":rimL" in each:
rimliteL = mc.listRelatives(each, p = True)[0]
elif ":rimR" in each:
rimliteR = mc.listRelatives(each, p = True)[0]
#elif ":fill" in each:
#fillite = mc.listRelatives(each, p = True)[0]
elif ":key" in each:
keylite = mc.listRelatives(each, p = True)[0]
keygrp = "%s:key_set"%rmkylight
mc.group(n = "LIGHTS", em = True)
mc.parent(keygrp,"LIGHTS" )
#query common lights required and import the relevant light file from /assets/lighting/commonlights
commonfile = "%s/%s/common_lights/common_lights.ma"%(util.path, util.litePath)
commonlight="commonlight"
#litequery=mc.optionMenu('amblite',q=True,v=True)
#GIrAMB = "%s:%s"%(commonlight,litequery)
if os.path.exists(commonfile):
if mc.objExists(commonlight):
mc.delete(commonlight)
mc.file(commonfile, i = True, typ = "mayaAscii", ra = True, ns = commonlight, op = "v=0;p=17", pr = True)
else:
mc.confirmDialog(t='Warning', m = '%s file is not accessible'%commonlight, b='OK', ma = "center")
return
#mc.parent("commonlight:commonLight_sets","LIGHTS" )
#spclite_parnt=mc.parent(spclite,camquery)
#find shape node of key light
if mc.objExists(keylite):
keyliteshp = mc.listRelatives(keylite, c = True, s = True)
#setup the mat shaders
rgbashaders = rgbashader(shotname)
mc.select(cl = True)
myShader = mc.shadingNode('lambert', asShader=True)
mc.setAttr (myShader+".colorR", 0.886)
mc.setAttr (myShader+".colorG" ,0.961)
mc.setAttr (myShader+".colorB" ,0.961)
# assign cam folder
if camquery[14:] =='Ct':
camname = "Center"
elif camquery[14:]=='Lt':
camname = "Left"
else:
camname = "Right"
#remove all existing render layers
mc.editRenderLayerGlobals(crl = "defaultRenderLayer")
renlyrs = mc.ls(type = "renderLayer")
for each in renlyrs:
if not "defaultRenderLayer" in each:
mc.delete(each)
#cut the references of all assets if marked so in the light setup options
for each in layergrps:
for ast in grpDict[each]:
if refcut:
try:
cutref(ast)
except:
refcutmiss.append(ast)
#main loop for creating all the render layers with their respective settings working on each render layer group per loop
sqname = shotname[:5]
shname = shotname[5:]
matindex = 0
for lyr in layergrps:
asts = grpDict[lyr]
#create key layer, add key light
if mc.checkBox("keychk", q = True, v = True):
keylayer = (lyr + 'key')
mc.select(asts, r = True)
mc.select(keylite, add = True)
#mc.select(refdoom, add = True)
#mc.select(eyespec, add = True)
if mc.objExists("Grp_Ground"):
mc.select("Grp_Ground", add = True)
if mc.objExists("Grp_Matte"):
mc.select("Grp_Matte", add = True)
mc.createRenderLayer(mc = True, n = keylayer)
mc.editRenderLayerAdjustment(gndusebg + ".shadowMask")
mc.setAttr(gndusebg + ".miOcclusionMask", 0)
mc.connectAttr(keylayer+'.renderPass', 'diff.owner',nextAvailable=True)
mc.connectAttr(keylayer+'.renderPass', 'amb.owner', nextAvailable=True)
mc.connectAttr(keylayer+'.renderPass', 'sha.owner', nextAvailable=True)
mc.connectAttr(keylayer+'.renderPass', 'spc.owner', nextAvailable=True)
mc.connectAttr(keylayer+'.renderPass', 'inc.owner',nextAvailable=True)
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/<RenderPass>/%s%s_<RenderLayer>_<RenderPass>_v01"%(sqname,shname,camname,lyr,sqname,shname)
mc.editRenderLayerAdjustment ("defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix", fileprefix, type = "string")
mc.editRenderLayerAdjustment('miDefaultOptions.rayTracing')
mc.setAttr('miDefaultOptions.rayTracing',1)
mc.editRenderLayerAdjustment( 'miDefaultOptions.maxReflectionRays' )
mc.setAttr('miDefaultOptions.maxReflectionRays', 3)
mc.editRenderLayerAdjustment( 'miDefaultOptions.maxRefractionRays' )
mc.setAttr('miDefaultOptions.maxRefractionRays', 0)
mc.editRenderLayerAdjustment( 'miDefaultOptions.maxRayDepth')
mc.setAttr('miDefaultOptions.maxRayDepth',20)
#create rim layer, add rimlight
if mc.checkBox("rimchk", q = True, v = True):
rimlayer = (lyr + 'rim')
mc.select(asts, r = True)
mc.select(rimliteL, add = True)
mc.select(rimliteR, add = True)
mc.createRenderLayer(mc = True, n = rimlayer)
rimsh='%s:Rimshader'%commonlight
#mc.shadingNode("lambert", asShader = True, n = rimsh )
#mc.setAttr((rimsh+'.color'),1, 1, 1, type = "double3")
#mc.setAttr((rimsh+'.diffuse'),1)
mc.select(rimsh)
mel.eval('hookShaderOverride("%s","","%s")'%(rimlayer,rimsh))
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/%s%s_<RenderLayer>_v01"%(sqname, shname,camname,lyr, sqname, shname)
mc.editRenderLayerAdjustment ("defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix", fileprefix, type = "string")
mc.editRenderLayerAdjustment('miDefaultOptions.rayTracing')
mc.setAttr('miDefaultOptions.rayTracing',0)
#create col layer,add amb light
if mc.checkBox("colchk",q= True,v = True):
collayer= (lyr+ 'col')
mc.select(asts, r = True)
Col_light='%s:colLight'%commonlight
mc.select(Col_light,add=True)
mc.createRenderLayer(mc = True, n = collayer)
mc.editRenderLayerAdjustment ("defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix", fileprefix, type = "string")
#create occ layer
if mc.checkBox("occchk",q=True,v=True):
occlayer = (lyr + 'occ')
mc.select(asts,r=True)
if mc.objExists("Grp_Ground"):
mc.select("Grp_Ground", add = True)
if mc.objExists("Grp_Matte"):
mc.select("Grp_Matte", add = True)
mc.createRenderLayer(mc = True, n = occlayer)
mel.eval("renderLayerBuiltinPreset occlusion %s "%occlayer)
ShaderList=mc.ls (sl=1)
Mib_Amb=mc.listConnections(ShaderList,t='mib_amb_occlusion')
mc.setAttr(Mib_Amb[0]+'.samples',64)
mc.setAttr(Mib_Amb[0]+'.spread',0.8)
mc.setAttr(Mib_Amb[0]+'.max_distance',20)
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/%s%s_<RenderLayer>_v01"%(sqname, shname,camname,lyr, sqname, shname)
mc.editRenderLayerAdjustment ("defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix", fileprefix, type = "string")
#create mat layer and assign r, g and b shaders in turn using matindex, turn off raytracing using layer override
if mc.checkBox("rgbachk", q = True, v = True):
rgbalayer = (lyr + 'rgba')
mc.select(asts, r = True)
mc.createRenderLayer(mc = True, n = rgbalayer)
for i in range(len(asts)):
shindex = matindex%4
matindex += 1
mc.select(asts[i], r = True)
mc.hyperShade(assign = rgbashaders[shindex])
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/%s%s_<RenderLayer>_v01"%(sqname, shname,camname,lyr, sqname, shname)
mc.editRenderLayerAdjustment ("defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix", fileprefix, type = "string")
mc.setAttr('miDefaultOptions.rayTracing',0)
#create ground shadow layer, add key light and turn on shadow mask of useBG shader using layer override
if mc.checkBox("gshchk", q = True, v = True):
gshlayer = (lyr + 'gsh')
mc.select(asts, r = True)
mc.select(keylite, add = True)
if mc.objExists("Grp_Ground"):
mc.select("Grp_Ground", add = True)
if mc.objExists("Grp_Matte"):
mc.select("Grp_Matte", add = True)
mc.createRenderLayer(mc = True, n = gshlayer)
mc.editRenderLayerAdjustment(gndusebg + ".shadowMask")
mc.setAttr(gndusebg + ".shadowMask", 1)
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/%s%s_<RenderLayer>_v01"%(sqname, shname,camname,lyr, sqname, shname)
mc.editRenderLayerAdjustment ("defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix", fileprefix, type = "string")
mc.editRenderLayerAdjustment('miDefaultOptions.rayTracing')
mc.setAttr('miDefaultOptions.rayTracing',1)
mc.editRenderLayerAdjustment( 'miDefaultOptions.maxReflectionRays' )
mc.setAttr('miDefaultOptions.maxReflectionRays', 0)
mc.editRenderLayerAdjustment( 'miDefaultOptions.maxRefractionRays' )
mc.setAttr('miDefaultOptions.maxRefractionRays', 0)
mc.editRenderLayerAdjustment( 'miDefaultOptions.maxRayDepth')
mc.setAttr('miDefaultOptions.maxRayDepth',20)
#turn off receive shadows and primary visibility of the all the assets using changespreadattr()
for ast in asts:
changespreadattr(ast, "receiveShadows", 0)
changespreadattr(ast, "primaryVisibility", 0)
#create mat layer
if mc.checkBox("matchk",q= True, v = True):
matlayer = (lyr + 'mat')
mc.select(asts, r = True)
Zdep='%s:Zdepthshader'%commonlight
mc.select(asts, r = True)
mc.createRenderLayer(mc = True, n = matlayer)
mc.select(Zdep)
mel.eval('hookShaderOverride("%s","","%s")'%(matlayer,Zdep))
mc.connectAttr(matlayer+'.renderPass', 'camnml.owner', nextAvailable=True)
mc.connectAttr(matlayer+'.renderPass', 'nml.owner', nextAvailable=True)
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/<RenderPass>/%s%s_<RenderLayer>_<RenderPass>_v01"%(sqname,shname,camname,lyr,sqname,shname)
mc.editRenderLayerAdjustment ("defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix", fileprefix, type = "string")
mc.editRenderLayerAdjustment('miDefaultOptions.rayTracing')
mc.setAttr('miDefaultOptions.rayTracing',0)
mc.editRenderLayerAdjustment( 'miDefaultOptions.maxReflectionRays' )
mc.setAttr('miDefaultOptions.maxReflectionRays', 1)
mc.editRenderLayerAdjustment( 'miDefaultOptions.maxRefractionRays' )
mc.setAttr('miDefaultOptions.maxRefractionRays', 1)
mc.editRenderLayerAdjustment( 'miDefaultOptions.maxRayDepth')
mc.setAttr('miDefaultOptions.maxRayDepth',1)
mc.editRenderLayerGlobals(crl = "defaultRenderLayer")
mc.setAttr("defaultRenderLayer.renderable",0)
mc.select(cl = True)
# mc.checkBoxGrp ('enableColorProfile',e=1,v1=1)
# mc.optionMenuGrp('inputColorProfile',e=1,enable=1)
# mc.optionMenuGrp('outputColorProfile',e=1,enable=1)
# mc.optionMenuGrp('inputColorProfile',e=1 ,sl=1 )
# mc.optionMenuGrp('outputColorProfile',e=1 ,sl=2)
# mc.setAttr ("defaultRenderGlobals.inputColorProfile",1)
# mc.setAttr ("defaultRenderGlobals.outputColorProfile",2)
mc.confirmDialog(t='Message', m = 'Scene setup completed successfully', b='OK', ma = "center")
def create(self):
if self.exists:
raise Exception('This layer already exists...')
cmds.createRenderLayer(name=self.name, empty=True)
def create(self):
if self.exists:
raise Exception('This layer already exists...')
cmds.createRenderLayer(name=self.name, empty=True)
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'
d=1,
p=0,
type='shadingEngine')[0]
meshes = cmds.ls(type=['mesh', 'nurbsSurface'])
xforms = []
for mesh in meshes:
xforms.append(cmds.listRelatives(mesh, p=1)[0])
# make a new renderLayer if it doesn't already exist.
layers = cmds.ls(type='renderLayer')
if layerName in layers:
cmds.editRenderLayerGlobals(crl=layerName)
if layerName != 'defaultRenderLayer':
cmds.editRenderLayerMembers(layerName, xforms)
modLayers.append(layerName)
else:
cmds.createRenderLayer(xforms, mc=1, name=layerName)
cmds.setAttr(layerName + '.renderable', 0)
importLayers.append(layerName)
# assign material to objects if material isn't default.
if shadingGroup.split(':')[-1] != 'initialShadingGroup':
cmds.select(meshes, r=1)
cmds.sets(e=1, forceElement=shadingGroup)
if int(doOverrides) == 1:
for mesh in meshes:
if cmds.getAttr(sourceGeo + '.castsShadows') != cmds.getAttr(
mesh + '.castsShadows'):
cmds.setAttr(mesh + '.castsShadows',
cmds.getAttr(sourceGeo + '.castsShadows'))
if cmds.getAttr(sourceGeo + '.receiveShadows') != cmds.getAttr(
mesh + '.receiveShadows'):
cmds.setAttr(mesh + '.receiveShadows',
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)
from PIL import Image
# When you first import a file you must give it the full path
gMT.psource( r'C:\Users\zklinger\Google Drive\Docs\PROJECTS\CODE\PYTHON\gravModTools\gravModTools.py' )
imageFolder = 'C:\Users\zklinger\Google Drive\Docs\PROJECTS\SB\IMG\SB_011\\'
imageFileList = cmds.getFileList(folder=imageFolder, filespec='*.tif')
#print imageFileList[0][11:14]
cardList = list()
#createRenderLayer -name "layer1" -number 1 -noRecurse `ls -selection`;
zDepthRenderLayer = cmds.createRenderLayer(empty=True,
name='zDepthRenderLayer',
number=1, noRecurse=True)
for i in range(len(imageFileList)):
im = Image.open(imageFolder + imageFileList[i])
#print im.size[0], im.size[1]
# imageName = imageFileList[i].split("_"))
card = gMT.ImageCard.ImageCard(imageFileList[i], (im.size[0] / 100.0), (im.size[1] / 100.0))
shader = gMT.XPassShader.XPassShader(imageFileList[i], imageFolder)
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
card.setSG(shader.getSG())
card.move(0, 0, i * -2)
zDepthShader = gMT.ZDepthShader.ZDepthShader(imageFileList[i],
def doFileAnalysis(infile,*args):
print '\ninfile: %s' % (infile)
print 'project: %s' % (cmds.workspace(q=1,fn=1))
cmds.file(infile,o=1,f=1)
# first: if this is not a mayaBinary file, save it as one.
scenePath = infile
if os.path.splitext(infile)[-1] != '.mb':
# remove all unknown nodes and save as MB
unk = cmds.ls(type='unknown')
if unk:
for i in unk:
try:
cmds.lockNode(i,lock=0)
cmds.delete(i)
except:
pass
scenePath = os.path.splitext(infile)[0]+'.mb'
cmds.file(rename=scenePath)
cmds.file(s=1,f=1,type='mayaBinary')
meshes = []
surfaces = []
meshes = cmds.ls(type='mesh',l=1)
surfaces = cmds.ls(type='nurbsSurface',l=1)
# create temp camera
cam = cmds.camera()
cmds.setAttr(cam[0]+'.rx',-35)
cmds.setAttr(cam[0]+'.ry',45)
meshXforms = []
if meshes:
for mesh in meshes:
xf = cmds.listRelatives(mesh,p=1,f=1)[0]
meshXforms.append(xf)
if surfaces:
for surface in surfaces:
xf = cmds.listRelatives(surface,p=1,f=1)[0]
meshXforms.append(xf)
meshXforms = [f for f in meshXforms if cmds.getAttr(f+'.visibility') == 1]
if not meshXforms:
# nothing here, throw an error
cmds.quit(ec=86,f=1)
cmds.select(meshXforms)
# set active resolution before fitting.
cmds.setAttr('defaultResolution.aspectLock',0)
cmds.setAttr('defaultResolution.width',720)
cmds.setAttr('defaultResolution.height',405)
cmds.setAttr('defaultResolution.pixelAspect',1)
cmds.setAttr('defaultResolution.deviceAspectRatio',1.778)
cmds.viewFit(cam[1],f=0.9)
cmds.viewClipPlane(cam[1],acp=1)
cmds.select(cl=1)
allCams = cmds.ls(type='camera')
for c in allCams:
cmds.setAttr(c+'.renderable',0)
cmds.setAttr(cam[1]+'.renderable',1)
engine = cmds.sets(renderable=1,noSurfaceShader=1,em=1)
mat = cmds.shadingNode('surfaceShader',asShader=1)
cmds.connectAttr(mat+'.outColor',engine+'.surfaceShader')
aotex = cmds.shadingNode('mib_amb_occlusion',asTexture=1)
cmds.connectAttr(aotex+'.outValue',mat+'.outColor')
cmds.setAttr(aotex+'.samples',32)
# create a new temporary render layer and add all objects
rlayer = cmds.createRenderLayer(n='tempLayer',g=1,mc=1)
# assign AO shader to all meshes and surfaces
if meshes:
cmds.sets(meshes,e=1,fe=engine)
if surfaces:
cmds.sets(surfaces,e=1,fe=engine)
# get all existing file textures and add the paths to a list
textures = []
fileNodes = cmds.ls(type='file')
for node in fileNodes:
tex = cmds.getAttr(node+'.fileTextureName')
textures.append(tex.strip().replace('\n',''))
# set mental ray as the current renderer and set up output settings
cmds.setAttr('defaultRenderGlobals.currentRenderer','mentalRay',type='string')
# to prevent overwriting other images with the same name, use the unix timestamp as the image name.
rand_imageFilePrefix = str(int(time.time()))
mel.eval('miCreateDefaultNodes();')
cmds.setAttr('defaultRenderGlobals.imageFormat',8)
cmds.setAttr('defaultRenderGlobals.outFormatControl',0)
cmds.setAttr('defaultRenderGlobals.useFrameExt',0)
cmds.setAttr('defaultRenderGlobals.animation',0)
cmds.setAttr('defaultRenderGlobals.useMayaFileName',1)
cmds.setAttr('defaultRenderGlobals.imageFilePrefix',rand_imageFilePrefix,type='string')
mel.eval('miCreateDefaultNodes();')
cmds.setAttr('miDefaultOptions.rayTracing',1)
cmds.setAttr('miDefaultOptions.maxSamples',2)
cmds.setAttr('miDefaultOptions.minSamples',0)
cmds.setAttr('miDefaultOptions.maxReflectionRays',1)
cmds.setAttr('miDefaultOptions.finalGather',0)
cmds.setAttr('miDefaultOptions.filter',2)
# get output filename
tempProject = cmds.workspace(q=1,fn=1)
outFile = os.path.join(tempProject,'images',rlayer,rand_imageFilePrefix+'.jpg')
# disable all render layers except rlayer
layers = cmds.ls(type='renderLayer')
for layer in layers:
cmds.setAttr(layer+'.renderable',0)
cmds.setAttr(rlayer+'.renderable',1)
ren = cmds.Mayatomr(r=1,camera=cam[1],x=720,y=405,l=rlayer,rv=5)
st = 'screenshot written to %s' % (outFile)
print(st)
return infile,outFile,textures,scenePath,ren
def mkCreateRL(name): mkRlexists = cmds.ls (name, type = 'renderLayer') if mkRlexists == []: cmds.createRenderLayer(n = name,empty = True) vrayUpdateUI()
def setupScene():
global util
errormsgs = []
util = Utils.utils()
chks = [
'keychk', 'rimchk', 'colchk', 'occchk', 'rgbachk', 'gshchk', 'matchk'
]
chkstats = [mc.checkBox(x, q=True, v=True) for x in chks]
if not 1 in chkstats:
mc.confirmDialog(t='Warning',
m='No layers are selected',
b='OK',
ma="center")
return
#get dict of assets in their respective render layer groups
grpDict = findGrpDict()
layergrps = grpDict.keys()
layergrps.sort()
#find the path of the file, check naming of file and query the timeline
filepath = mc.file(q=True, sn=True)
filename = os.path.basename(filepath)
fildir = os.path.dirname(filepath)
refcut = mc.checkBox("refchk", q=True, v=True)
try:
shotname = filename.split("_")[1]
except:
mc.confirmDialog(t='Warning',
m='Scene name is not correct',
b='OK',
ma="center")
return
shstart = mc.playbackOptions(q=True, ast=True)
shend = mc.playbackOptions(q=True, aet=True)
#query the camera and the camera group
cam = mc.optionMenu('camlite', q=True, v=True)
#setup the name of the new files
clfile = filename[:-9] + "cl" + filename[-7:]
#check the file exists, then change to vesion folder
curr_path = fildir + '/'
clfilepath = curr_path + clfile
if mc.file(clfilepath, q=1, ex=1):
Overrite = mc.confirmDialog(title='Confirm ',
message='Overwrite the existing file? ',
button=['Yes', 'No'],
defaultButton='Yes',
cancelButton='No',
dismissString='No')
if Overrite == 'No':
return
chkpath = mc.getFileList(folder=curr_path)
ver_count = chkpath.count('ver')
verpath = curr_path + 'ver/'
if not ver_count:
mc.sysFile(verpath, makeDir=1)
# else:
# verpath= curr_path+'ver/'
files = [
f for f in os.listdir(verpath)
if (os.path.isfile(os.path.join(verpath, f))) and f[len(f) -
3:len(f)] == '.ma'
]
if files:
ver = str(len(files) + 1)
else:
ver = '01'
newpath = verpath + clfile
mc.sysFile(filepath, copy=newpath)
newname = clfile[:19] + '%s.ma' % ver.zfill(2)
chgname = verpath + newname
mc.sysFile(newpath, rename=chgname)
#select all the assets specified in the setup window to export to a new file
selasts = []
refcutmiss = []
for each in layergrps:
for ast in grpDict[each]:
selasts.append(ast)
#add the camera to the selection
selasts.append(cam)
#add the ground and matte groups to the selection if they exist, else warn that they have not been setup
gndmteobjs = ["Grp_Ground", "Grp_Matte"]
if mc.objExists("Grp_Ground"):
gndmteobjs.pop(gndmteobjs.index("Grp_Ground"))
selasts.append("Grp_Ground")
if mc.objExists("Grp_Matte"):
gndmteobjs.pop(gndmteobjs.index("Grp_Matte"))
selasts.append("Grp_Matte")
if gndmteobjs:
gndmtemsg = "\n".join(gndmteobjs)
rslt = mc.confirmDialog(
t='Warning',
m="Ground/Matte Objects dont\nexist or havent been set up",
b=['Continue', 'Cancel'],
db='Continue',
cb='Cancel',
ds='Cancel',
ma='center')
if rslt == 'Cancel':
return
else:
pass
mc.select(selasts, r=True)
#cmfile = filename[:-9] + "cm" + filename[-7:]
#export all selected assets, cameras and ground/matte groups to a new _cl_v00 file
mc.file((fildir + "/" + clfile),
op="v=0",
typ="mayaAscii",
pr=True,
es=True,
f=True)
#force open the new _cl_v00 file without saving the old one
mc.file((fildir + "/" + clfile),
op="v=0",
typ="mayaAscii",
lrd="all",
o=True,
f=True)
#select camera and export selected camera to a new _cm_v00 file
#mc.select(cam, r = True)
#mc.file((fildir + "/" + cmfile), op = "v=0", typ = "mayaAscii", pr = True, es = True)
mc.select(cl=True)
#set the timeline and render globals, and move assets to their respective groups
mc.playbackOptions(e=True, ast=shstart)
mc.playbackOptions(e=True, aet=shend)
setrendglobals(shotname, shstart, shend)
try:
Utils.moveAssetsToGrps()
except:
pass
#setup the useBackground shader and assign it to the ground/matte objects if they exist
gndusebg = "groundmatteuseBGshader"
if mc.objExists(gndusebg):
mc.delete(gndusebg)
gndusebg = mc.shadingNode("useBackground", asShader=True, n=gndusebg)
mc.setAttr((gndusebg + ".specularColor"), 0, 0, 0, type="double3")
mc.setAttr((gndusebg + ".reflectivity"), 0)
mc.setAttr((gndusebg + ".reflectionLimit"), 0)
mc.setAttr((gndusebg + ".shadowMask"), 0)
if mc.objExists("Grp_Ground"):
mc.select("Grp_Ground", r=True)
mc.hyperShade(assign=gndusebg)
if mc.objExists("Grp_Matte"):
mc.select("Grp_Matte", r=True)
mc.hyperShade(assign=gndusebg)
#query the rim/key light required and import the relevant light file from /assets/lighting
locquery = mc.optionMenu('Location', q=True, v=True)
rmkylight = mc.optionMenu('Time', q=True, v=True)
camquery = mc.optionMenu('camlite', q=True, v=True)
rmkyfile = "%s/%s/Location/%s/%s_rimkey.ma" % (util.path, util.litePath,
locquery, rmkylight)
rimliteL = "%s:rimL" % rmkylight
rimliteR = "%s:rimR" % rmkylight
#refdoom = "%s:ref_doom"%rmkylight
keylite = "%s:key" % rmkylight
#fillite = "%s:fill"%rmkylight
#eyespec = "%s:eyespc"%rmkylight
if os.path.exists(rmkyfile):
if mc.objExists(rimliteL):
mc.delete(rimliteL)
if mc.objExists(rimliteR):
mc.delete(rimliteR)
#if mc.objExists(fillite):
#mc.delete(fillite)
if mc.objExists(keylite):
mc.delete(keylite)
mc.file(rmkyfile,
i=True,
typ="mayaAscii",
ra=True,
ns=rmkylight,
op="v=0;p=17",
pr=True)
else:
mc.confirmDialog(t='Warning',
m='%s file is not accessible' % rmkylight,
b='OK',
ma="center")
return
#find the names of the imported rim/key lights in the scene and parent them to the 'Rim_key' group
if mc.objExists("LIGHTS"):
mc.delete("LIGHTS")
sclites = mc.ls(type="light")
for each in sclites:
if ":rimL" in each:
rimliteL = mc.listRelatives(each, p=True)[0]
elif ":rimR" in each:
rimliteR = mc.listRelatives(each, p=True)[0]
#elif ":fill" in each:
#fillite = mc.listRelatives(each, p = True)[0]
elif ":key" in each:
keylite = mc.listRelatives(each, p=True)[0]
keygrp = "%s:key_set" % rmkylight
mc.group(n="LIGHTS", em=True)
mc.parent(keygrp, "LIGHTS")
#query common lights required and import the relevant light file from /assets/lighting/commonlights
commonfile = "%s/%s/common_lights/common_lights.ma" % (util.path,
util.litePath)
commonlight = "commonlight"
#litequery=mc.optionMenu('amblite',q=True,v=True)
#GIrAMB = "%s:%s"%(commonlight,litequery)
if os.path.exists(commonfile):
if mc.objExists(commonlight):
mc.delete(commonlight)
mc.file(commonfile,
i=True,
typ="mayaAscii",
ra=True,
ns=commonlight,
op="v=0;p=17",
pr=True)
else:
mc.confirmDialog(t='Warning',
m='%s file is not accessible' % commonlight,
b='OK',
ma="center")
return
#mc.parent("commonlight:commonLight_sets","LIGHTS" )
#spclite_parnt=mc.parent(spclite,camquery)
#find shape node of key light
if mc.objExists(keylite):
keyliteshp = mc.listRelatives(keylite, c=True, s=True)
#setup the mat shaders
rgbashaders = rgbashader(shotname)
mc.select(cl=True)
myShader = mc.shadingNode('lambert', asShader=True)
mc.setAttr(myShader + ".colorR", 0.886)
mc.setAttr(myShader + ".colorG", 0.961)
mc.setAttr(myShader + ".colorB", 0.961)
# assign cam folder
if camquery[14:] == 'Ct':
camname = "Center"
elif camquery[14:] == 'Lt':
camname = "Left"
else:
camname = "Right"
#remove all existing render layers
mc.editRenderLayerGlobals(crl="defaultRenderLayer")
renlyrs = mc.ls(type="renderLayer")
for each in renlyrs:
if not "defaultRenderLayer" in each:
mc.delete(each)
#cut the references of all assets if marked so in the light setup options
for each in layergrps:
for ast in grpDict[each]:
if refcut:
try:
cutref(ast)
except:
refcutmiss.append(ast)
#main loop for creating all the render layers with their respective settings working on each render layer group per loop
sqname = shotname[:5]
shname = shotname[5:]
matindex = 0
for lyr in layergrps:
asts = grpDict[lyr]
#create key layer, add key light
if mc.checkBox("keychk", q=True, v=True):
keylayer = (lyr + 'key')
mc.select(asts, r=True)
mc.select(keylite, add=True)
#mc.select(refdoom, add = True)
#mc.select(eyespec, add = True)
if mc.objExists("Grp_Ground"):
mc.select("Grp_Ground", add=True)
if mc.objExists("Grp_Matte"):
mc.select("Grp_Matte", add=True)
mc.createRenderLayer(mc=True, n=keylayer)
mc.editRenderLayerAdjustment(gndusebg + ".shadowMask")
mc.setAttr(gndusebg + ".miOcclusionMask", 0)
mc.connectAttr(keylayer + '.renderPass',
'diff.owner',
nextAvailable=True)
mc.connectAttr(keylayer + '.renderPass',
'amb.owner',
nextAvailable=True)
mc.connectAttr(keylayer + '.renderPass',
'sha.owner',
nextAvailable=True)
mc.connectAttr(keylayer + '.renderPass',
'spc.owner',
nextAvailable=True)
mc.connectAttr(keylayer + '.renderPass',
'inc.owner',
nextAvailable=True)
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/<RenderPass>/%s%s_<RenderLayer>_<RenderPass>_v01" % (
sqname, shname, camname, lyr, sqname, shname)
mc.editRenderLayerAdjustment(
"defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix",
fileprefix,
type="string")
mc.editRenderLayerAdjustment('miDefaultOptions.rayTracing')
mc.setAttr('miDefaultOptions.rayTracing', 1)
mc.editRenderLayerAdjustment('miDefaultOptions.maxReflectionRays')
mc.setAttr('miDefaultOptions.maxReflectionRays', 3)
mc.editRenderLayerAdjustment('miDefaultOptions.maxRefractionRays')
mc.setAttr('miDefaultOptions.maxRefractionRays', 0)
mc.editRenderLayerAdjustment('miDefaultOptions.maxRayDepth')
mc.setAttr('miDefaultOptions.maxRayDepth', 20)
#create rim layer, add rimlight
if mc.checkBox("rimchk", q=True, v=True):
rimlayer = (lyr + 'rim')
mc.select(asts, r=True)
mc.select(rimliteL, add=True)
mc.select(rimliteR, add=True)
mc.createRenderLayer(mc=True, n=rimlayer)
rimsh = '%s:Rimshader' % commonlight
#mc.shadingNode("lambert", asShader = True, n = rimsh )
#mc.setAttr((rimsh+'.color'),1, 1, 1, type = "double3")
#mc.setAttr((rimsh+'.diffuse'),1)
mc.select(rimsh)
mel.eval('hookShaderOverride("%s","","%s")' % (rimlayer, rimsh))
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/%s%s_<RenderLayer>_v01" % (
sqname, shname, camname, lyr, sqname, shname)
mc.editRenderLayerAdjustment(
"defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix",
fileprefix,
type="string")
mc.editRenderLayerAdjustment('miDefaultOptions.rayTracing')
mc.setAttr('miDefaultOptions.rayTracing', 0)
#create col layer,add amb light
if mc.checkBox("colchk", q=True, v=True):
collayer = (lyr + 'col')
mc.select(asts, r=True)
Col_light = '%s:colLight' % commonlight
mc.select(Col_light, add=True)
mc.createRenderLayer(mc=True, n=collayer)
mc.editRenderLayerAdjustment(
"defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix",
fileprefix,
type="string")
#create occ layer
if mc.checkBox("occchk", q=True, v=True):
occlayer = (lyr + 'occ')
mc.select(asts, r=True)
if mc.objExists("Grp_Ground"):
mc.select("Grp_Ground", add=True)
if mc.objExists("Grp_Matte"):
mc.select("Grp_Matte", add=True)
mc.createRenderLayer(mc=True, n=occlayer)
mel.eval("renderLayerBuiltinPreset occlusion %s " % occlayer)
ShaderList = mc.ls(sl=1)
Mib_Amb = mc.listConnections(ShaderList, t='mib_amb_occlusion')
mc.setAttr(Mib_Amb[0] + '.samples', 64)
mc.setAttr(Mib_Amb[0] + '.spread', 0.8)
mc.setAttr(Mib_Amb[0] + '.max_distance', 20)
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/%s%s_<RenderLayer>_v01" % (
sqname, shname, camname, lyr, sqname, shname)
mc.editRenderLayerAdjustment(
"defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix",
fileprefix,
type="string")
#create mat layer and assign r, g and b shaders in turn using matindex, turn off raytracing using layer override
if mc.checkBox("rgbachk", q=True, v=True):
rgbalayer = (lyr + 'rgba')
mc.select(asts, r=True)
mc.createRenderLayer(mc=True, n=rgbalayer)
for i in range(len(asts)):
shindex = matindex % 4
matindex += 1
mc.select(asts[i], r=True)
mc.hyperShade(assign=rgbashaders[shindex])
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/%s%s_<RenderLayer>_v01" % (
sqname, shname, camname, lyr, sqname, shname)
mc.editRenderLayerAdjustment(
"defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix",
fileprefix,
type="string")
mc.setAttr('miDefaultOptions.rayTracing', 0)
#create ground shadow layer, add key light and turn on shadow mask of useBG shader using layer override
if mc.checkBox("gshchk", q=True, v=True):
gshlayer = (lyr + 'gsh')
mc.select(asts, r=True)
mc.select(keylite, add=True)
if mc.objExists("Grp_Ground"):
mc.select("Grp_Ground", add=True)
if mc.objExists("Grp_Matte"):
mc.select("Grp_Matte", add=True)
mc.createRenderLayer(mc=True, n=gshlayer)
mc.editRenderLayerAdjustment(gndusebg + ".shadowMask")
mc.setAttr(gndusebg + ".shadowMask", 1)
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/%s%s_<RenderLayer>_v01" % (
sqname, shname, camname, lyr, sqname, shname)
mc.editRenderLayerAdjustment(
"defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix",
fileprefix,
type="string")
mc.editRenderLayerAdjustment('miDefaultOptions.rayTracing')
mc.setAttr('miDefaultOptions.rayTracing', 1)
mc.editRenderLayerAdjustment('miDefaultOptions.maxReflectionRays')
mc.setAttr('miDefaultOptions.maxReflectionRays', 0)
mc.editRenderLayerAdjustment('miDefaultOptions.maxRefractionRays')
mc.setAttr('miDefaultOptions.maxRefractionRays', 0)
mc.editRenderLayerAdjustment('miDefaultOptions.maxRayDepth')
mc.setAttr('miDefaultOptions.maxRayDepth', 20)
#turn off receive shadows and primary visibility of the all the assets using changespreadattr()
for ast in asts:
changespreadattr(ast, "receiveShadows", 0)
changespreadattr(ast, "primaryVisibility", 0)
#create mat layer
if mc.checkBox("matchk", q=True, v=True):
matlayer = (lyr + 'mat')
mc.select(asts, r=True)
Zdep = '%s:Zdepthshader' % commonlight
mc.select(asts, r=True)
mc.createRenderLayer(mc=True, n=matlayer)
mc.select(Zdep)
mel.eval('hookShaderOverride("%s","","%s")' % (matlayer, Zdep))
mc.connectAttr(matlayer + '.renderPass',
'camnml.owner',
nextAvailable=True)
mc.connectAttr(matlayer + '.renderPass',
'nml.owner',
nextAvailable=True)
fileprefix = "%s/%s/%s/ch/%s/<RenderLayer>/<RenderPass>/%s%s_<RenderLayer>_<RenderPass>_v01" % (
sqname, shname, camname, lyr, sqname, shname)
mc.editRenderLayerAdjustment(
"defaultRenderGlobals.imageFilePrefix")
mc.setAttr("defaultRenderGlobals.imageFilePrefix",
fileprefix,
type="string")
mc.editRenderLayerAdjustment('miDefaultOptions.rayTracing')
mc.setAttr('miDefaultOptions.rayTracing', 0)
mc.editRenderLayerAdjustment('miDefaultOptions.maxReflectionRays')
mc.setAttr('miDefaultOptions.maxReflectionRays', 1)
mc.editRenderLayerAdjustment('miDefaultOptions.maxRefractionRays')
mc.setAttr('miDefaultOptions.maxRefractionRays', 1)
mc.editRenderLayerAdjustment('miDefaultOptions.maxRayDepth')
mc.setAttr('miDefaultOptions.maxRayDepth', 1)
mc.editRenderLayerGlobals(crl="defaultRenderLayer")
mc.setAttr("defaultRenderLayer.renderable", 0)
mc.select(cl=True)
# mc.checkBoxGrp ('enableColorProfile',e=1,v1=1)
# mc.optionMenuGrp('inputColorProfile',e=1,enable=1)
# mc.optionMenuGrp('outputColorProfile',e=1,enable=1)
# mc.optionMenuGrp('inputColorProfile',e=1 ,sl=1 )
# mc.optionMenuGrp('outputColorProfile',e=1 ,sl=2)
# mc.setAttr ("defaultRenderGlobals.inputColorProfile",1)
# mc.setAttr ("defaultRenderGlobals.outputColorProfile",2)
mc.confirmDialog(t='Message',
m='Scene setup completed successfully',
b='OK',
ma="center")
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 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 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 setupOverides():
currentRenderLayer=cmds.editRenderLayerGlobals(q=1, crl=1)
if not "BTY" in currentRenderLayer:
cmds.confirmDialog(m="\"BTY\" prefix not found in current renderlayer. Please switch to a BTY* Layer and try again.")
return
#### 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("BTY","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:
cmds.editRenderLayerMembers(matteLayer,obj,nr=1)
cmds.editRenderLayerGlobals(currentRenderLayer=matteLayer)
currentRenderLayer=matteLayer
#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("defaultRenderGlobals.enableDefaultLight",layer=currentRenderLayer)
cmds.setAttr("redshiftOptions.aovEnableDeepOutput",1)
cmds.setAttr("redshiftOptions.aovDeepMergeMode",1)
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)
mel.eval("redshiftUpdateActiveAovList")
def create(self): """create render layer if not exists""" if not self.exists: mc.createRenderLayer( name = self.name, empty = 1 )
def create(parentName):
with profiler.ProfilerMgr('create'):
newName = 'rs_%s' % parentName
return cmds.createRenderLayer(name=newName, empty=True)
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 layer(self,layer): if not mc.objExists(layer): mc.createRenderLayer(n=layer)
def bakeTextureTool(obj, xRes, yRes, imFormat, alpha=True):
'''{'del_path':'Rendering/Render/bakeTextureTool()ONLYSE',
'usage':'$fun(cmds.ls(sl=True)[0], 512, 512, "iff", alpha=True)',
}
'''
#if str(type(objects)) == "<type 'str'>" or str(type(objects)) == "<type 'unicode'>":
#objects = [objects]
#obj = cmds.ls(sl=True)[0]
#xRes=1024
#yRes=1024
#imFormat = "tif"
#alpha=True
imFormatV = ["tif", "iff", "jpg", "rgb", "rla", "tga", "bmp", "hdr"
].index(imFormat) + 1
cmds.scriptEditorInfo(sr=True, suppressWarnings=True)
#set path
prj = cmds.workspace(q=True, rd=True)
if not os.path.exists(prj + "sourceimages"):
os.mkdir(prj + "sourceimages")
os.chdir(prj + "sourceimages")
if os.path.exists("lightMap"):
os.rename("lightMap", "lightMapOrig")
os.mkdir("lightMap")
#create and set textureBakeSet
if cmds.objExists("tempBakeSet*"):
cmds.delete("tempBakeSet*")
tempBakeSet = mel.eval(r'createBakeSet( "tempBakeSet", "textureBakeSet")')
cmds.setAttr("%s.colorMode" % tempBakeSet, 0)
cmds.setAttr("%s.xResolution" % tempBakeSet, xRes)
cmds.setAttr("%s.yResolution" % tempBakeSet, yRes)
cmds.setAttr("%s.fileFormat" % tempBakeSet, imFormatV)
if alpha:
cmds.setAttr("%s.bakeAlpha" % tempBakeSet, 1)
#copy new renderLayer for bake
bakeSetRL = cmds.createRenderLayer(g=True, n="tempBakeSetL")
#get shape and shadingEngine
if not cmds.objectType(obj, i="mesh"):
obj = cmds.listRelatives(obj, f=True, type="mesh")
if obj != None:
obj = obj[0]
sE = cmds.listConnections(obj, type="shadingEngine")
if sE != None: sE = sE[0]
#print obj,sE
if obj != None and sE != None:
mel.eval('assignBakeSet( "%s", "%s")' % (tempBakeSet, obj))
startF = cmds.playbackOptions(q=True, min=True)
endF = cmds.playbackOptions(q=True, max=True)
for curF in range(startF, endF + 1):
cmds.currentTime(curF, e=True)
mapName = cmds.convertLightmap(sE,
obj,
camera="persp",
prj=prj + "sourceimages")[0]
if os.path.exists("lightMap/%s.%04d.%s" %
(mapName, curF, imFormat)):
os.remove("lightMap/%s.%04d.%s" % (mapName, curF, imFormat))
os.rename("lightMap/%s.%s" % (mapName, imFormat),
"lightMap/%s.%04d.%s" % (mapName, curF, imFormat))
print "saved image %s.%04d.%s" % (mapName, curF, imFormat)
if os.path.exists(mapName):
shutil.rmtree(mapName)
print "saved images squeuence to %s\%s" % (os.getcwd(), mapName)
os.rename("lightMap", mapName)
os.rename("lightMapOrig", "lightMap")
cmds.delete(tempBakeSet)
cmds.scriptEditorInfo(sr=False, suppressWarnings=False)
import maya.cmds as cmds
import sys
sys.path.append(r'C:\Users\zklinger\Documents\maya\scripts\maya-python-imageCard\scripts')
import gravModTools as gMT
from PIL import Image
imageFolder = 'C:\Users\zklinger\Documents\maya\scripts\maya-python-imageCard\example\layers\\'
imageFileList = cmds.getFileList(folder=imageFolder, filespec='*.png')
cardList = list()
#createRenderLayer -name "layer1" -number 1 -noRecurse `ls -selection`;
zDepthRenderLayer = cmds.createRenderLayer(empty=True,
name='zDepthRenderLayer',
number=1, noRecurse=True)
#createRenderLayer -name "layer1" -number 1 -noRecurse `ls -selection`;
AORenderLayer = cmds.createRenderLayer(empty=True,
name='AORenderLayer',
number=2, noRecurse=True)
#createRenderLayer -name "layer1" -number 1 -noRecurse `ls -selection`;
positionRenderLayer = cmds.createRenderLayer(empty=True,
name='positionRenderLayer',
number=2, noRecurse=True)
for i in range(len(imageFileList)):
im = Image.open(imageFolder + imageFileList[i])
# imageName = imageFileList[i].split("_"))
