def collectShaderInfoInLayer():
sel = pm.ls(sl=True, dag=True, type='mesh')
shader_info_all_layers = []
for renderlayer in pm.ls(type='renderLayer'):
pm.editRenderLayerGlobals( currentRenderLayer=renderlayer )
#// shader_info_layer stores the info for each seleted objs in CURRENT layer
#// flush content of shader_info_layer
shader_info_layer = []
for mesh in sel:
SG_list = pm.listConnections(mesh, t='shadingEngine')
#print SG_list
if( SG_list == None ):
continue
if( len(SG_list) < 1 ):
SG_list.append('initialShadingGroup')
#// store mesh & material in CURRENT layer
shader_info_layer.append( ( mesh, SG_list[0] ) )
shader_info_all_layers.append( ( renderlayer, shader_info_layer ) )
pm.editRenderLayerGlobals( currentRenderLayer='defaultRenderLayer' )
return shader_info_all_layers
def doExecution(*args):
is_find = pm.checkBox( UI_name[0], q=True, value=True )
is_fix = pm.checkBox( UI_name[1], q=True, value=True )
is_fixLayer = pm.checkBox( UI_name[2], q=True, value=True )
shader_info_all_layers = []
if( is_find ):
findErrorShape()
if( is_fixLayer ):
#// collect shaders info in each layer
shader_info_all_layers = collectShaderInfoInLayer()
if( is_fix ):
fixComponentShading()
if( is_fixLayer ):
for shd_layer in shader_info_all_layers:
#// switch to a specified layer
curr_layer = shd_layer[0]
pm.editRenderLayerGlobals( currentRenderLayer=curr_layer )
#// parsing string for mesh & shader from list
#// assign shader to mesh from list
for shd in shd_layer[1]:
obj = shd[0]
SG = shd[1]
pm.sets( SG, edit=True, forceElement=obj )
pm.editRenderLayerGlobals( currentRenderLayer='defaultRenderLayer' )
return 1
def addItems(self, parent):
column = 0
self.renderLayers = self.getRenderLayers() # Get render layers
self.renderLayerDict = {} # Dictionary to store layer name and the assosiated AOVS
for layer in self.renderLayers:
if str(layer.name()) not in self.renderLayerDict:
self.renderLayerDict[str(layer.name())] = [] # Add elements to Dictionary as Key with empty list as value
# vrayRenderElements = pm.listConnections(layer, s=1, type='VRayRenderElement') # Find all the AOVS connected to each render layers and Append to the Dictionary self.renderLayerDict[Key] = Value
vrayRenderElements = pm.ls(type='VRayRenderElement')
for element in vrayRenderElements:
if element.name() not in self.renderLayerDict[str(layer.name())]:
self.renderLayerDict[str(layer.name())].append(str(element.name()))
# vrayRenderElementSets = pm.listConnections(layer, s=1, type='VRayRenderElementSet')
vrayRenderElementSets = pm.ls(type='VRayRenderElementSet')
for set in vrayRenderElementSets:
if set.name() not in self.renderLayerDict[str(layer.name())]:
self.renderLayerDict[str(layer.name())].append(str(set.name()))
panels = pm.getPanel( type='modelPanel' ) # Get all the Model panels and Set show to None
for panel in panels:
if '|' in panel:
panel = panel.split('|')[-1]
pm.modelEditor(panel, e=1, allObjects=0)
for key, values in self.renderLayerDict.iteritems(): # Update tree widget with top parent node as render layer name and childs as Aovs
pm.editRenderLayerGlobals(currentRenderLayer=key) # select current render layer and find the Aovs state (Enabled or Disabled)
layer_item = self.addParent(parent, column, key, 'data Layers')
for value in sorted(values):
self.addChild(layer_item, column, value, 'data Aovs')
def switchToMasterLayer():
if pc.editRenderLayerGlobals(
q=True, currentRenderLayer=True).lower().startswith('default'):
return
for layer in getRenderLayers(renderableOnly=False):
if layer.name().lower().startswith('default'):
pc.editRenderLayerGlobals(currentRenderLayer=layer)
break
def submit_all(self, *a):
""" Iterates over all active render layers and submits each one individually. """
render_layers = [layer for layer in pm.ls(type='renderLayer') if (not 'defaultRenderLayer' in str(layer)) and layer.renderable.get()]
for layer in render_layers:
pm.editRenderLayerGlobals(crl=layer)
self.submit()
def loadAdvancedShaders():
'''
'''
# check if shader already loaded
# check SHADER namespace or shading_layer
removeAdvancedShaders()
# delete if already loaded
# load shader file
# import shaders
filepath = pm.fileDialog2(
fm=1,
cap='Choose advanced shader file',
ff='mathilda_advanced_shaders.ma (mathilda_advanced_shaders.ma)')
if filepath is None:
pm.error('Shader file not provided.')
pm.importFile(filepath[0], i=True, ns='SHADERS')
# create renderlayer
allGeoShapes = []
bodyGeoGrp = pm.PyNode('RIG:GEO' + ':' + 'CT_geo_grp')
faceGeoGrp = pm.PyNode('RIG:FACE:CT_mouth_geo_grp')
for shape in bodyGeoGrp.getChildren(ad=True, s=True):
if 'simple' not in shape.name():
allGeoShapes.append(shape)
for shape in faceGeoGrp.getChildren(ad=True, s=True):
allGeoShapes.append(shape)
allGeoShapes.append('RIG:frontHair_pfx')
allGeoShapes.append('RIG:backHair_pfx')
layer = pm.createRenderLayer(allGeoShapes, n='advanced_shading')
pm.editRenderLayerGlobals(crl=layer)
# get all advanced shaders
allSGs = pm.ls(type='shadingEngine')
advSGs = filter(lambda sg: 'SHADERS' in sg.namespaceList(), allSGs)
# transfer SGs on masterLayer first
masterLyr = pm.PyNode('defaultRenderLayer')
for sg in advSGs:
transferSG(sg, 'SHADERS' + ':', 'RIG:', masterLyr, layer)
# transfer SGs on advanced_shading
# this should override masterLayer
advLyr = pm.PyNode('SHADERS' + ':' + 'advanced_shading')
for sg in advSGs:
transferSG(sg, 'SHADERS' + ':', 'RIG:', advLyr, layer)
# clean up imported data
importedGeo = pm.PyNode('SHADERS' + ':' + 'CT_shaders_geo_grp')
pm.delete(importedGeo)
pm.delete(advLyr)
# add subdivApprox node
approxNode = createSubdivApproxNode()
assignApproxNode(approxNode, [bodyGeoGrp, faceGeoGrp])
def render_layer():
layers = core.ls(type='renderLayer')
for layer in layers:
attribute = layer.attr('renderable')
attribute.set(False)
geometrys = core.listTransforms(geometry=True)
layer = 'scene_preview'
if core.objExists(layer):
core.editRenderLayerGlobals(crl='defaultRenderLayer')
core.delete(layer)
render_layer = core.createRenderLayer(geometrys, n=layer, num=1, nr=1)
render_layer.setCurrent()
def loadAdvancedShaders():
'''
'''
# check if shader already loaded
# check SHADER namespace or shading_layer
removeAdvancedShaders()
# delete if already loaded
# load shader file
# import shaders
filepath = pm.fileDialog2(fm=1, cap='Choose advanced shader file', ff='mathilda_advanced_shaders.ma (mathilda_advanced_shaders.ma)')
if filepath is None:
pm.error('Shader file not provided.')
pm.importFile(filepath[0], i=True, ns='SHADERS')
# create renderlayer
allGeoShapes = []
bodyGeoGrp = pm.PyNode('RIG:GEO'+':'+'CT_geo_grp')
faceGeoGrp = pm.PyNode('RIG:FACE:CT_mouth_geo_grp')
for shape in bodyGeoGrp.getChildren(ad=True, s=True):
if 'simple' not in shape.name():
allGeoShapes.append(shape)
for shape in faceGeoGrp.getChildren(ad=True, s=True):
allGeoShapes.append(shape)
allGeoShapes.append('RIG:frontHair_pfx')
allGeoShapes.append('RIG:backHair_pfx')
layer = pm.createRenderLayer(allGeoShapes, n='advanced_shading')
pm.editRenderLayerGlobals(crl=layer)
# get all advanced shaders
allSGs = pm.ls(type='shadingEngine')
advSGs = filter(lambda sg: 'SHADERS' in sg.namespaceList(), allSGs)
# transfer SGs on masterLayer first
masterLyr = pm.PyNode('defaultRenderLayer')
for sg in advSGs:
transferSG(sg, 'SHADERS'+':', 'RIG:', masterLyr, layer)
# transfer SGs on advanced_shading
# this should override masterLayer
advLyr = pm.PyNode('SHADERS'+':'+'advanced_shading')
for sg in advSGs:
transferSG(sg, 'SHADERS'+':', 'RIG:', advLyr, layer)
# clean up imported data
importedGeo = pm.PyNode('SHADERS'+':'+'CT_shaders_geo_grp')
pm.delete(importedGeo)
pm.delete(advLyr)
# add subdivApprox node
approxNode = createSubdivApproxNode()
assignApproxNode(approxNode, [bodyGeoGrp, faceGeoGrp])
def test_run():
frame = 10, 11, 12, 13, 15, 30
layer = pmel.ls(type='renderLayer')
dir(layer[0].renderable.get())
for f in frame:
for i in layer:
if i.renderable.get():
print '========'
print str(i)
pmel.editRenderLayerGlobals(currentRenderLayer=i)
print f
print '********'
def pop(self):
""" Pop the render layer to remove display in the scene. """
# Set back tot he old render layer
pm.editRenderLayerGlobals(currentRenderLayer=self.old_render_layer)
editor = pm.modelEditor(self.playblast_panel, edit=True,
displayTextures=True)
# Reset the background colors
pm.displayRGBColor("background", *self.old_bkg_color)
pm.displayRGBColor("backgroundTop", *self.old_bkg_top_color)
pm.displayRGBColor("backgroundBottom", *self.old_bkg_bottom_color)
# Change the attributes on the meshes
for obj in self.meshes_with_color:
obj.setAttr('displayColors', 1)
self.handle_gpu_mesh(1)
self.pop_namespace_materials()
def sceneTeardown(*a):
''' Tears down all rendering-related elements created by the
sort controller.'''
# Get all framebuffers that aren't referenced
buffers = pm.ls(typ='VRayRenderElement')
for b in buffers:
if b.isReferenced(): buffers.remove(b)
if b.nodeType() == 'VRayRenderElementSet': buffers.remove(b)
# And delete them
pm.delete(buffers)
# Get all render layers
layers = getAllLayers()
# Have to be on the default render layers to delete the rest
pm.editRenderLayerGlobals(crl='defaultRenderLayer')
# And delete them
[pm.delete(lay) for lay in layers]
def pop(self):
""" Pop the render layer to remove display in the scene. """
# Set back tot he old render layer
pm.editRenderLayerGlobals(currentRenderLayer=self.old_render_layer)
editor = pm.modelEditor(self.playblast_panel,
edit=True,
displayTextures=True)
# Reset the background colors
pm.displayRGBColor("background", *self.old_bkg_color)
pm.displayRGBColor("backgroundTop", *self.old_bkg_top_color)
pm.displayRGBColor("backgroundBottom", *self.old_bkg_bottom_color)
# Change the attributes on the meshes
for obj in self.meshes_with_color:
obj.setAttr('displayColors', 1)
self.handle_gpu_mesh(1)
self.pop_namespace_materials()
def checkOverride(self):
self.layer=pm.editRenderLayerGlobals( query=True, currentRenderLayer=True )
if self.layer!='defaultRenderLayer':
override_list=cmds.editRenderLayerAdjustment( self.layer,layer=True,q=True)
if override_list != None:
if self.attr in override_list:
self.label.setStyleSheet("color: rgb(255, 127, 0);")
def overrideAttrRun(self, mode):
items = self.weightListWidget.selectedItems()
if pm.editRenderLayerGlobals(q=1, crl=1) == 'defaultRenderLayer':
return 0
attrList = []
pm.undoInfo(ock=1)
for x in items:
attrList.append(x.text())
for x in self.objectList:
for y in attrList:
try:
if mode:
pm.editRenderLayerAdjustment(x.attr(y))
else:
overrideList = pm.editRenderLayerAdjustment(q=1)
if x.attr(y).name() in overrideList:
pm.editRenderLayerAdjustment(x.attr(y), remove=1)
except:
print x
pm.undoInfo(cck=1)
def changeRenderLayer(self):
layerName = self.treeWidget.currentItem()
if layerName.text(0) in self.renderLayers:
pm.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
pm.editRenderLayerGlobals(currentRenderLayer=str(layerName.text(0)))
else:
layer = layerName.parent()
pm.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
pm.editRenderLayerGlobals(currentRenderLayer=str(layer.text(0)))
def transferSG(sg, srcNS, destNS, srcLyr, destLyr):
pm.editRenderLayerGlobals(crl=srcLyr)
srcObjs = pm.sets(sg, q=True)
pm.editRenderLayerGlobals(crl=destLyr)
for srcObj in srcObjs:
destName = srcObj.replace(srcNS, destNS)
try:
destObj = pm.PyNode(destName)
# print 'assign: ' + destObj
pm.sets(sg, e=True, fe=destObj)
except pm.MayaObjectError as e:
destName = destName.replace('GEO', 'NEWGEO')
destObj = pm.PyNode(destName)
# print 'assign: ' + destObj
pm.sets(sg, e=True, fe=destObj)
except:
print "Unexpected error...", sys.exc_info()[0]
def mousePressEvent(self,event):
self.layer=pm.editRenderLayerGlobals( query=True, currentRenderLayer=True )
if self.layer != 'defaultRenderLayer':
if event.button() == QtCore.Qt.RightButton:
point=event.pos()
item=self.childAt(point)
if item in self.attr_dict:
self.mouseMenu(item,self.attr_dict[item])
def transferSG(sg, srcNS, destNS, srcLyr, destLyr):
pm.editRenderLayerGlobals(crl=srcLyr)
srcObjs = pm.sets(sg, q=True)
pm.editRenderLayerGlobals(crl=destLyr)
for srcObj in srcObjs:
destName = srcObj.replace(srcNS, destNS)
try:
destObj = pm.PyNode(destName)
# print 'assign: ' + destObj
pm.sets(sg, e=True, fe=destObj)
except pm.MayaObjectError as e:
destName = destName.replace('GEO', 'NEWGEO')
destObj = pm.PyNode(destName)
# print 'assign: ' + destObj
pm.sets(sg, e=True, fe=destObj)
except:
print "Unexpected error...", sys.exc_info()[0]
def main():
current_layer = pm.editRenderLayerGlobals(currentRenderLayer=1, q=1)
all_meshes = get_meshes_in_layer(current_layer)
if all_meshes:
sg_nodes = get_all_sg_node_in_layer(all_meshes)
if not pm.objExists('AO_SG'):
ao_sg_node = create_ao_shader()[1]
else:
ao_sg_node = pm.PyNode('AO_SG')
progress_dialog = QProgressDialog(
'<Total:%s>Assign materials,Please wait......' % len(sg_nodes),
'Cancel', 0, len(sg_nodes))
progress_dialog.setWindowModality(Qt.WindowModal)
progress_dialog.show()
value = 0
start = time.time()
for sg_node in sg_nodes:
progress_dialog.setValue(value)
if progress_dialog.wasCanceled():
break
my_list = get_my_list(sg_node, all_meshes)
#sg_node, dis_attr, opacity_attr, meshes
try:
if my_list[3]:
if 'AO_SG' in my_list[0].name():
value += 1
continue
#no dis, no opacity
if not my_list[1] and not my_list[2]:
pm.sets(ao_sg_node, fe=my_list[3])
#dis, no opacity
elif my_list[1] and not my_list[2]:
dis_sg_node = pm.sets(noSurfaceShader=1,
renderable=1,
empty=1,
name='AO_SG_dis')
pm.connectAttr(pm.PyNode('AO_shader').outColor,
dis_sg_node.surfaceShader,
force=1)
pm.connectAttr(my_list[1],
dis_sg_node.displacementShader)
pm.sets(dis_sg_node, fe=my_list[3])
#no dis, opacity
elif not my_list[1] and my_list[2]:
shader, opacity_sg_node = create_ao_shader()
pm.connectAttr(my_list[2], shader.opacity)
pm.sets(opacity_sg_node, fe=my_list[3])
#dis, opacity
elif my_list[1] and my_list[2]:
shader, dis_sg_node = create_ao_shader()
pm.connectAttr(my_list[2], shader.opacity)
pm.connectAttr(my_list[1],
dis_sg_node.displacementShader)
pm.sets(dis_sg_node, fe=my_list[3])
except Exception as e:
print e
value += 1
print 'AO cast %s(s)' % str(time.time() - start)
def autoSubmitExplicit(frame_range, cluster, restrictions, priority):
render_layers = [pm.PyNode('btyHomeLogoNight'), pm.PyNode('btyAwayLogoNight')]
submit_dict = getSceneData('mayapy')
for layer in render_layers:
pm.editRenderLayerGlobals(crl=layer)
submit_dict['package']['layers'] = str(layer)
submit_dict['name'] = pm.sceneName().basename().rstrip('.mb') + ' : ' + str(layer)
submit_dict['package']['range'] = frame_range
submit_dict['cluster'] = cluster
submit_dict['restrictions'] = restrictions
submit_dict['priority'] = priority
subprocess.Popen(['c:\\program files (x86)\\pfx\\qube\\bin\\qube-console.exe', '--nogui', '--submitDict', str(submit_dict)])
def autoSubmitAll(frame_range, cluster, restrictions, priority):
render_layers = [layer for layer in pm.ls(type='renderLayer') if (not 'defaultRenderLayer' in str(layer)) and layer.renderable.get()]
submit_dict = getSceneData('mayapy')
for layer in render_layers:
pm.editRenderLayerGlobals(crl=layer)
submit_dict['package']['layers'] = str(layer)
submit_dict['name'] = pm.sceneName().basename().rstrip('.mb') + ' : ' + str(layer)
submit_dict['package']['range'] = frame_range
submit_dict['cluster'] = cluster
submit_dict['restrictions'] = restrictions
submit_dict['priority'] = priority
subprocess.Popen(['c:\\program files (x86)\\pfx\\qube\\bin\\qube-console.exe', '--nogui', '--submitDict', str(submit_dict)])
def push(self):
""" Push the render layer to display in the scene. """
self.old_render_layer = pm.editRenderLayerGlobals(query=True,
currentRenderLayer=True)
editor = pm.modelEditor(self.playblast_panel, edit=True,
displayTextures=False, displayAppearance='smoothShaded')
# pm.modelEditor(editor, edit=True, displayTextures=False)
pm.editRenderLayerGlobals(currentRenderLayer=self.layer.name())
# pm.modelEditor('modelPanel4', query=True, displayTextures=False)
# Change the background color
pm.displayRGBColor("background", 0, 0, 0)
pm.displayRGBColor("backgroundTop", 0, 0, 0)
pm.displayRGBColor("backgroundBottom", 0, 0, 0)
self.get_meshes_with_color()
for obj in self.meshes_with_color:
obj.setAttr('displayColors', 0)
self.handle_gpu_mesh(0)
self.push_namespace_materials()
def aw_assimilator(self):
args=pm.ls(sl=True)
targets=args[-1:]
src=args[0]
obj, curRndrLyr, assShdr, counter ='','','',0
print "Targets are: %s\nAnd Source is: %s" % (",".join(map(str,targets)),src)
allRndrLayers=pm.ls(type='renderLayer')
# get all render layers just in case
srcShape=str(aw_shaderAss.findShape(src))
assRndrLayers=[]
print srcShape
if srcShape:
assRndrLayers=pm.listConnections(srcShape, type='renderLayer')
# get all assigned render layers of the source
for obj in assRndrLayers:
curRndrLyr=assRndrLayers[counter]
# store the current render layer from the list
for target in targets:
if curRndrLyr != "defaultRenderLayer":
print "Assigning %s to render layer - %s" % (target,curRndrLyr)
pm.editRenderLayerGlobals(crl=curRndrLyr)
# change the render layer to the current one
assSG = self.findSG(aw_shaderAss.findShape(src))
# Get the shading group of the source and store
editRenderLayerMembers(curRndrLyr,target)
# assign the target to the render layer
cmds.sets(target, forceElement=assSG)
# assign the shading group we just received to the target
counter+=1
else:
print "Master Layer: assigning " + target + "'s shader\n"
editRenderLayerGlobals(crl=curRndrLyr)
# change the render layer to the current one
assSG=self.findSG(self.findShape(src))
# Get the shading group of the source and store
if pm.objExists(assSG) and pm.objExists(target) and pm.objectType(assSG) =='set':
pm.sets(target, forceElement=assSG)
# assign the shading group we just received to the target
counter+=1
def RenderLayerClean():
ok = WarningMessage("Deseas Borrar todos los render layers.")
if ok:
rs = renderSetup.instance()
##Move in Defatul RenderLayer
pm.editRenderLayerGlobals(crl="defaultRenderLayer")
rs.clearAll()
RenderLayer = pm.ls(type='renderLayer')
for layer in RenderLayer:
if layer != 'defaultRenderLayer':
pm.delete(layer)
pm.inViewMessage(amg='<hl>RenderLayers!!!!Clean</hl>.',
pos='midCenter',
fade=True)
else:
pm.inViewMessage(amg='<hl>RenderLayer_Cancel</hl>.',
pos='midCenter',
fade=True)
def push(self):
""" Push the render layer to display in the scene. """
self.old_render_layer = pm.editRenderLayerGlobals(
query=True, currentRenderLayer=True)
editor = pm.modelEditor(self.playblast_panel,
edit=True,
displayTextures=False,
displayAppearance='smoothShaded')
# pm.modelEditor(editor, edit=True, displayTextures=False)
pm.editRenderLayerGlobals(currentRenderLayer=self.layer.name())
# pm.modelEditor('modelPanel4', query=True, displayTextures=False)
# Change the background color
pm.displayRGBColor("background", 0, 0, 0)
pm.displayRGBColor("backgroundTop", 0, 0, 0)
pm.displayRGBColor("backgroundBottom", 0, 0, 0)
self.get_meshes_with_color()
for obj in self.meshes_with_color:
obj.setAttr('displayColors', 0)
self.handle_gpu_mesh(0)
self.push_namespace_materials()
def getOutputFilePaths(renderLayer=None,
useCurrentLayer=False,
camera=None,
useCurrentCamera=False,
ignoreStartupCameras=True,
switchToLayer=False,
framePadder='?'):
outputFilePaths = []
renderLayers = None
if renderLayer:
renderLayers = [pc.nt.RenderLayer(renderLayer)]
elif not useCurrentLayer:
layers = getRenderLayers()
if layers:
renderLayers = layers
if renderLayers is None:
renderLayers = [None]
for layer in renderLayers:
if layer != pc.editRenderLayerGlobals(q=1, crl=1) and switchToLayer:
pc.editRenderLayerGlobals(crl=layer)
renderableCams = getCameras(True, ignoreStartupCameras)
cameras = None
if camera:
cameras = [camera]
elif not useCurrentCamera:
if renderableCams:
cameras = renderableCams
if cameras is None:
cameras = [getCameras(False, False)[0]]
for cam in cameras:
gins = getGenericImageName(layer=layer,
camera=cam,
framePadder=framePadder)
outputFilePaths.extend(gins)
return outputFilePaths
def hideInRlHide_PB_hit(self):
self.createVisAttrNode()
render_layer = pm.editRenderLayerGlobals(query=True, currentRenderLayer=True)
node = pm.PyNode(render_layer)
rlid = node.getAttr('rlid')
sel_list = pm.ls(selection=True)
for obj in sel_list:
obj_s = obj.getShape()
attr_node = pm.PyNode('rlid_'+str(rlid)+'_vis_off_pxrAttr')
if rlid != 0:
pm.editRenderLayerAdjustment(obj_s.visibility)
pm.connectAttr(attr_node.defaultInt, obj_s.visibility, f=True)
def hideInRlDetach_PB_hit(self):
render_layer = pm.editRenderLayerGlobals(query=True, currentRenderLayer=True)
node = pm.PyNode(render_layer)
rlid = node.getAttr('rlid')
if rlid != 0:
sel_list = pm.ls(selection=True)
for obj in sel_list:
try:
obj = obj.getShape()
except AttributeError:
pass
pm.editRenderLayerAdjustment(obj.visibility, remove=True)
def hideInRlSelect_PB_hit(self):
render_layer = pm.editRenderLayerGlobals(query=True, currentRenderLayer=True)
node = pm.PyNode(render_layer)
rlid = node.getAttr('rlid')
if rlid != 0:
attr_node = pm.PyNode('rlid_'+str(rlid)+'_vis_off_pxrAttr')
node_list = pm.listConnections(attr_node.defaultInt, s=False, d=True)
sel_list = []
for node in node_list:
if node.type() != 'renderLayer':
sel_list.append(node)
pm.select(sel_list, replace=True)
def set_renderable_current(state):
"""
Info:
Sets renderable status for currewnt render layer
Args:
state = True/False , if True (Enable) , if Flase (Disable)
"""
cur_rly = pm.editRenderLayerGlobals(q=1, crl=1)
if state:
pm.setAttr('{}.renderable'.format(cur_rly), 1)
else:
pm.setAttr('{}.renderable'.format(cur_rly), 0)
def update_window_render_layer():
"""
Updates the window's current Render Layer attribute and
the Render Layer buttons availability.
:return: None
"""
# Get the Render Layer's name and assign it to
# the window's current_render_layer
_window.current_render_layer = pmc.editRenderLayerGlobals(
query=True, currentRenderLayer=True)
# Update the Render Layer buttons, to lock them in case this is the defaultRenderLayer
_window.render_change_trigger()
def commonAttrOverrideRemove_PB_hit(self):
current_RL = pm.editRenderLayerGlobals(query=True, currentRenderLayer=True)
if current_RL is 'defaultRenderLayer':
pass
else:
attr, option = self.checkCommonAttrData()
mesh_list = self.getSelMeshList()
if attr is 'primaryVisibility':
for mesh in mesh_list:
pm.editRenderLayerAdjustment(mesh.name()+'.'+attr, remove=True)
else:
for mesh in mesh_list:
mesh_t = mesh.getTransform()
pm.editRenderLayerAdjustment(mesh_t.name()+'.'+attr, remove=True)
def removeAdvancedShaders():
'''
'''
# remove layer
try:
layer = pm.nt.RenderLayer('advanced_shading')
pm.editRenderLayerGlobals(crl='defaultRenderLayer')
pm.delete(layer)
except pm.MayaObjectError:
pass
# remove imported namespace
try:
pm.namespace(dnc=True, rm='SHADERS')
except RuntimeError:
pass
# remove approxNode
try:
approxNode = pm.PyNode('mathildaSubdivApprox')
pm.delete(approxNode)
except pm.MayaObjectError:
pass
def removeAdvancedShaders():
'''
'''
# remove layer
try:
layer = pm.nt.RenderLayer('advanced_shading')
pm.editRenderLayerGlobals(crl='defaultRenderLayer')
pm.delete(layer)
except pm.MayaObjectError:
pass
# remove imported namespace
try:
pm.namespace(dnc=True, rm='SHADERS')
except RuntimeError:
pass
# remove approxNode
try:
approxNode = pm.PyNode('mathildaSubdivApprox')
pm.delete(approxNode)
except pm.MayaObjectError:
pass
def __test(self, *a):
import pprint
layer = pm.editRenderLayerGlobals(q=True, crl=True)
if self.jobtype == 'mayacmd':
self.submit_dict['package']['-rl'] = str(layer)
name_prefix = 'maya(cmd) '
elif self.jobtype == 'mayapy':
self.submit_dict['package']['layer'] = str(layer)
name_prefix = 'maya(py) '
self.submit_dict['name'] = name_prefix + pm.sceneName().basename().rstrip('.mb') + ' : ' + str(layer)
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(self.submit_dict)
return
def set_render_global_set():
pm.undoInfo(openChunk=True)
# 카메라 Far Clip 설정
for cam in [x for x in cmds.ls(type='camera')]:
try:
cmds.setAttr(cam + '.farClipPlane', 100000000)
except:
pass
current_render_layer = pm.editRenderLayerGlobals(
query=True, currentRenderLayer=True)
pm.loadPlugin('vrayformaya', quiet=True)
# 레드쉬프트 렌더러로 변경
render_globals = pm.PyNode('defaultRenderGlobals')
pm.mel.eval('unifiedRenderGlobalsWindow();')
pm.mel.eval('fillSelectedTabForCurrentRenderer();')
pm.mel.eval(
'updateCurrentRendererSel("unifiedRenderGlobalsRendererSelOptionMenu");'
)
render_globals.currentRenderer.set(lock=False)
render_globals.currentRenderer.set('vray')
pm.mel.eval('rendererChanged')
vray_settings = pm.PyNode('vraySettings')
vray_settings.animType.set(True)
vray_settings.animBatchOnly.set(True)
render_globals.startFrame.set(
pm.playbackOptions(query=True, minTime=True))
render_globals.endFrame.set(
pm.playbackOptions(query=True, maxTime=True))
pm.editRenderLayerGlobals(currentRenderLayer=current_render_layer)
pm.undoInfo(closeChunk=True)
def submit( self, qube_gui=0, *a ):
""" Runs the Qube submission console command for the current render layer. """
layer = pm.editRenderLayerGlobals(q=True, crl=True)
if self.jobtype == 'mayacmd':
self.submit_dict['package']['-rl'] = str(layer)
name_prefix = 'maya(cmd) '
elif self.jobtype == 'mayapy':
self.submit_dict['package']['layers'] = str(layer)
name_prefix = 'maya(py) '
self.submit_dict['name'] = name_prefix + pm.sceneName().basename().rstrip('.mb') + ' : ' + str(layer)
if qube_gui:
subprocess.Popen(['c:\\program files (x86)\\pfx\\qube\\bin\\qube-console.exe', '--submitDict', str(self.submit_dict)])
else:
subprocess.Popen(['c:\\program files (x86)\\pfx\\qube\\bin\\qube-console.exe', '--nogui', '--submitDict', str(self.submit_dict)])
def getGenericImageName(layer=None,
camera=None,
resolveAOVs=True,
framePadder='?'):
gins = []
path = None
# if currentRenderer() == 'redshift':
# path = pc.PyNode('redshiftOptions').imageFilePrefix.get()
if path is None:
if layer is None and camera is None:
fin = pc.renderSettings(fin=True, lut=True)
elif layer is None:
fin = pc.renderSettings(fin=True, lut=True, camera=camera)
elif camera is None:
fin = pc.renderSettings(fin=True, lut=True, layer=layer)
else:
fin = pc.renderSettings(fin=True,
lut=True,
layer=layer,
camera=camera)
path = fin[0]
if resolveAOVs:
if not camera:
cams = getCameras(True, False)
if cams:
camera = cams[0]
gins = resolveAOVsInPath(
path, layer if layer else pc.editRenderLayerGlobals(q=1, crl=1),
camera if camera else '', framePadder)
if not gins:
gins = [path]
if isAnimationOn():
gins = [removeLastNumber(gin, framePadder)[0] for gin in gins]
return gins
def submit_to_deadline(self):
# 파일을 저장하기 직전 반드시 마스터 렌더 레이어로 이동한 후 저장하도록 한다.
pm.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
# 파일 강제 저장
cur = cmds.file(query=True, sceneName=True)
if cmds.file(query=True, modified=True):
cmds.file(force=True, save=True)
# 아웃풋 경로 생성
project_path = dirs(self.project_path_field.text())
output_path = dirs(self.output_field.text())
# 로그인 쿠키
cookie = MoonLoginCookie.get_login_user()
# 주어진 데이터를 이용하여 데드라인에 잡을 생성한다.
priority = self.priority_field.text()
pool = self.pool_combo.currentText()
sec_pool = self.sec_pool_combo.currentText()
group = self.group_combo.currentText()
concurrent_task = self.concurrent_task_field.text()
frame_per_task = self.chunk_size_field.text()
gpus_per_task = self.gpu_per_task_field.text()
if self.render_layer_checkbox.isChecked():
individual_set = self.individual_render_layer_widget.get_data()
else:
individual_set = {}
job = moon.deadline.JobInfo('MayaBatch')
job.add('Name', self.job_name_field.text())
job.add('Comment', self.comment_field.text())
job.add('Frames', self.get_frame_range())
job.add('UserName', cookie.name.encode('euc-kr'))
job.add('Department', cookie.team)
job.add('ChunkSize', frame_per_task)
job.add('Pool', pool)
job.add('SecondaryPool', sec_pool)
job.add('Group', group)
job.add('Priority', priority)
job.add('MachineLimit', self.limit_machine_field.text())
job.add('ConcurrentTasks', concurrent_task)
job.add('OutputDirectory0', output_path)
if self.suspended_checkbox.isChecked():
job.add('InitialStatus', 'Suspended')
plugin = moon.deadline.PluginInfo()
plugin.add('SceneFile', cur)
plugin.add('Camera', self.camera_combo.currentText())
plugin.add('ProjectPath', project_path)
plugin.add('OutputFilePath', output_path)
plugin.add('Renderer', 'vray')
plugin.add('Version', cmds.about(version=True))
plugin.add('Build', '64bit')
plugin.add('StrictErrorChecking', True)
plugin.add('GPUsPerTask', gpus_per_task)
plugin.add('RedshiftVerbose', '2')
# 렌더레이어를 사용하기로 되어있다면,
# 서브미션을 각각 생성해서 던져주어야 한다.
if self.render_layer_checkbox.isChecked():
plugin.add('UsingRenderLayers', '1')
plugin.add('UseLegacyRenderLayers', '1')
for layer in pm.ls(type='renderLayer'):
if 'defaultRenderLayer' in layer.name():
continue
if layer.namespace() != '':
continue
if not layer.renderable.get():
continue
# 잡의 이름도 변경해준다.
job.add('BatchName', self.job_name_field.text())
job.add('Name', '{} - {}'.format(self.job_name_field.text(),
layer))
# 렌더레이어를 지정해준다.
plugin.add('RenderLayer', layer)
# Individual Render Layers 세팅을 확인한다.
if layer.name() in individual_set:
data = individual_set[layer.name()]
job.add('Priority', data['priority'])
job.add('Pool', data['pool'])
job.add('SecondaryPool', data['sec_pool'])
job.add('Group', data['group'])
job.add('ConcurrentTasks', data['concurrent_task'])
job.add('ChunkSize', data['frame_per_task'])
plugin.add('GPUsPerTask', data['gpus_per_task'])
else:
job.add('Priority', priority)
job.add('Pool', pool)
job.add('SecondaryPool', sec_pool)
job.add('Group', group)
job.add('ConcurrentTasks', concurrent_task)
job.add('ChunkSize', frame_per_task)
plugin.add('GPUsPerTask', gpus_per_task)
# 데드라인에 던져준다.
submission = moon.deadline.Submission(job, plugin, cur)
submission.submit()
else:
submission = moon.deadline.Submission(job, plugin, cur)
submission.submit()
# 데드라인에 잡을 생성하여 전달하고 난 후 서브미터를 종료한다.
self.accept()
# ----------------------------------------------------------------------
# Import
# ----------------------------------------------------------------------
import pymel.core as pm
# ----------------------------------------------------------------------
# Configuration
# ----------------------------------------------------------------------
# ----------------------------------------------------------------------
# Main Script
# ----------------------------------------------------------------------
lis_sel = pm.ls(sl=True)
if lis_sel:
for sel in lis_sel:
print(sel)
if pm.nodeType(sel) == "VRayObjectProperties":
render_layer = pm.editRenderLayerGlobals(query=True, currentRenderLayer=True)
try:
print(render_layer)
pm.editRenderLayerAdjustment(sel.ignore, layer=render_layer)
pm.editRenderLayerAdjustment(sel.primaryVisibility, layer=render_layer)
pm.setAttr(sel.ignore, 0)
pm.setAttr(sel.primaryVisibility, 0)
except Exception as ex:
print('ERROR: {}'.format(ex))
def create(self):
""" Create the render layer. This will generate the colors for
each namespace, create flat shaders for each of these colors per
namespace. A namespace render layer is also generated in maya.
"""
# Query for the shading group set
assigned = pm.sets("initialShadingGroup", query=True)
if assigned:
# Create new lambert shader
default_lambert = pm.shadingNode("lambert", asShader=True)
attrs = default_lambert.listAttr(scalar=True,
read=True,
settable=True,
keyable=True)
for attr in attrs:
num_child_attrs = pm.attributeQuery(
attr.name(includeNode=False),
node="lambert1",
numberOfChildren=True)
plug = attr.listConnections(plugs=True,
destination=False,
source=True)
if plug:
attr.connectAttr(plug[0])
elif num_child_attrs:
attr_val = pm.getAttr('lambert1.{0}'.format(attr))
default_lambert.setAttr(attr_val)
# Add parent attribute if there are any
parent_attr = pm.attributeQuery(attr,
lp=True,
n="lambert1")
if parent_attr and parent_attr[0] not in attrs:
attrs.append(parent_attr[0])
shading_group = pm.sets(renderable=True, noSurfaceShader=True)
default_lambert.connectAttr('outColor',
'{0}.surfaceShader'.format(
shading_group.name()),
f=True)
for item in assigned:
is_object = pm.ls(item, o=True)
if is_object:
try:
shade_remove = pm.sets(item.name(),
rm='initialShadingGroup',
e=True)
pm.sets(item, e=True, fe=shading_group)
except RuntimeError:
shade_remove = None
print "Problem removing " + str(
item) + " from the initialShadingGroup"
# Get namespaces and generate colors based on those namespaces
self.get_namespaces()
self.get_namespace_colors()
# Must replace with internal object function
# _getNamespaceInfoFromStructureFile(self.struc, self.namespaces,
# [], [], [], [], [])
# _getColors(self.namespaces, self.colors)
old_namespace = pm.namespaceInfo(currentNamespace=True)
old_render_layer = pm.editRenderLayerGlobals(q=True,
currentRenderLayer=True)
layer = ""
for i, cur_namespace in enumerate(self.namespaces):
# Will probably need to remove
if cur_namespace == 'stereoCam':
continue
if layer == '':
layer = pm.createRenderLayer(makeCurrent=True,
name="namespaceLayer")
if not pm.namespace(set=(":" + str(cur_namespace))):
continue
(red, green, blue) = self.colors[i]
dag_namespace = pm.namespaceInfo(dp=1, lod=True)
pm.select(dag_namespace, replace=True)
geom = pm.ls(visible=True,
type=['mesh', 'nurbsSurface'],
dag=True,
ni=True,
selection=True)
gpu_mesh = []
if pm.objectType(tagFromType="rfxAlembicMeshGpuCache"):
gpu_mesh = pm.ls(selection=True,
visible=True,
dag=True,
noIntermediate=True,
type="rfxAlembicMeshGpuCache",
long=True)
pm.select(clear=True)
if len(geom) > 0:
material = str(shadingNode('surfaceShader', asShader=True))
setAttr((material + ".outColor"),
red,
green,
blue,
type='double3')
shader = str(
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True))
connectAttr((material + ".outColor"),
(shader + ".surfaceShader"),
f=True)
for j in range(0, len(geom)):
existingShaders = listConnections(geom[j],
source=False,
plugs=False,
destination=True,
type="shadingEngine")
if len(existingShaders) > 0:
editRenderLayerMembers(layer, geom[j])
retry = 0
# first try to set the shader in object mode
retry = 1
# Use shading group hijack method for everything...
#if (catch(`sets -noWarnings -forceElement $shader $geom[$j]`)) {
# $retry = 1;
#}
if retry == 1:
# Couldn't assign shader. Various alternative approaches to assigning the shader have not worked 100% of the time.
# So add a couple of extra attributes to the shadingGroup - defaultShader and namespaceShader, and connect the respective
# shaders to these. During pushRenderLayer (PlayblastTool), check for the existence of the namespaceShader, and if present,
# find it's connection and plug it into the surfaceShader attribute, thus "hijacking" the shading group. During popRenderLayer,
# connect the attribute plugged into defaultShader and plug this back into the surfaceShader attribute. This is messy, but it
# sidesteps material assignment alltogether.
for k in range(0, len(existingShaders)):
if not objExists(existingShaders[k] +
".defaultShader"):
addAttr(existingShaders[k],
ln="defaultShader",
at="message")
defaultMat = listConnections(
(existingShaders[k] +
".surfaceShader"),
s=1,
d=0)
if len(defaultMat):
connectAttr(
(defaultMat[0] + ".message"),
(existingShaders[k] +
".defaultShader"))
addAttr(existingShaders[k],
ln="namespaceShader",
at="message")
connectAttr((material + ".message"),
(existingShaders[k] +
".namespaceShader"))
retry = 0
# temp until we feel confident retiring the next section of code
if retry == 1:
print "Using alternate shader assignment strategy on " + geom[
j] + "\n"
# couldn't assign shader. Emergency fall-back: Switch back to defaultRenderLayer, unassign and re-assign the existing shaders, then
# switch back to namespace layer and try again.
existingShaders = self.stringArrayReverse(
existingShaders)
"""
To-do: Add an explanation about why reversing the shaders array is necessary once we've confirmed that we are good. -HM
"""
# store the existing material assignments
comps = []
indices = []
for k in range(1, len(existingShaders)):
indices[k - 1] = len(comps)
assigned = cmds.sets(existingShaders[k], q=1)
for m in range(0, len(assigned)):
obj = ls(o=assigned[m])
if obj[0] == geom[j]:
comps.append(assigned[m])
# unassign the existing materials
for k in range(0, len(existingShaders)):
cmds.sets(geom[j], rm=existingShaders[k], e=1)
if catch(lambda: cmds.sets(geom[j],
noWarnings=1,
forceElement=shader)):
mel.warning("Couldn't "
"assign namespace shader to " +
geom[j])
continue
else:
print(
"DeepPlayblastUtilities: Alternate "
"shader assignment worked for " + geom[j] +
".\n")
editRenderLayerGlobals(
currentRenderLayer="defaultRenderLayer")
# switch back to defaultRenderLayer
# and re-assign (assign first shader to whole
# object, then component assign subsequent shaders)
cmds.sets(geom[j], e=1, fe=existingShaders[0])
for k in range(0, len(indices)):
end = (int(
(k < len(indices) - 1) and indices[k + 1]
or (len(comps))))
for m in range(indices[k], end):
cmds.sets(comps[m],
e=1,
fe=existingShaders[k + 1])
# switch to namespace layer
editRenderLayerGlobals(currentRenderLayer=layer)
if len(gpu_mesh) > 0:
# end if size($existingShaders)
for j in range(0, len(gpu_mesh)):
pm.editRenderLayerMembers(layer, gpu_mesh[j])
pm.setAttr((gpu_mesh[j] + ".defaultColor"),
red,
green,
blue,
type='double3')
pm.setAttr((gpu_mesh[j] + ".colorsMode"), 0)
self.gpu_meshes.append(gpu_mesh[j])
if layer != "":
pm.namespace(set=old_namespace)
pm.editRenderLayerGlobals(currentRenderLayer=old_render_layer)
self.layer = layer
self.gpu_meshes = list(set(self.gpu_meshes))
def create(self):
""" Create the render layer. This will generate the colors for
each namespace, create flat shaders for each of these colors per
namespace. A namespace render layer is also generated in maya.
"""
# Query for the shading group set
assigned = pm.sets("initialShadingGroup", query=True)
if assigned:
# Create new lambert shader
default_lambert = pm.shadingNode("lambert", asShader=True)
attrs = default_lambert.listAttr(scalar=True, read=True, settable=True, keyable=True)
for attr in attrs:
num_child_attrs = pm.attributeQuery(
attr.name(includeNode=False),
node="lambert1",
numberOfChildren=True
)
plug = attr.listConnections(plugs=True, destination=False, source=True)
if plug:
attr.connectAttr(plug[0])
elif num_child_attrs:
attr_val = pm.getAttr('lambert1.{0}'.format(attr))
default_lambert.setAttr(attr_val)
# Add parent attribute if there are any
parent_attr = pm.attributeQuery(attr, lp=True, n="lambert1")
if parent_attr and parent_attr[0] not in attrs:
attrs.append(parent_attr[0])
shading_group = pm.sets(renderable=True, noSurfaceShader=True)
default_lambert.connectAttr(
'outColor',
'{0}.surfaceShader'.format(shading_group.name()),
f=True
)
for item in assigned:
is_object = pm.ls(item, o=True)
if is_object:
try:
shade_remove = pm.sets(item.name(),
rm='initialShadingGroup',
e=True)
pm.sets(item, e=True, fe=shading_group)
except RuntimeError:
shade_remove = None
print "Problem removing " + str(item) + " from the initialShadingGroup"
# Get namespaces and generate colors based on those namespaces
self.get_namespaces()
self.get_namespace_colors()
# Must replace with internal object function
# _getNamespaceInfoFromStructureFile(self.struc, self.namespaces,
# [], [], [], [], [])
# _getColors(self.namespaces, self.colors)
old_namespace = pm.namespaceInfo(currentNamespace=True)
old_render_layer = pm.editRenderLayerGlobals(q=True, currentRenderLayer=True)
layer = ""
for i, cur_namespace in enumerate(self.namespaces):
# Will probably need to remove
if cur_namespace == 'stereoCam':
continue
if layer == '':
layer = pm.createRenderLayer(makeCurrent=True, name="namespaceLayer")
if not pm.namespace(set=(":" + str(cur_namespace))):
continue
(red, green, blue) = self.colors[i]
dag_namespace = pm.namespaceInfo(dp=1, lod=True)
pm.select(dag_namespace, replace=True)
geom = pm.ls(visible=True, type=['mesh', 'nurbsSurface'], dag=True, ni=True, selection=True)
gpu_mesh = []
if pm.objectType(tagFromType="rfxAlembicMeshGpuCache"):
gpu_mesh = pm.ls(selection=True, visible=True, dag=True, noIntermediate=True,
type="rfxAlembicMeshGpuCache", long=True)
pm.select(clear=True)
if len(geom)>0:
material=str(shadingNode('surfaceShader', asShader=True))
setAttr((material + ".outColor"),
red,green,blue,
type='double3')
shader=str(cmds.sets(renderable=True,
noSurfaceShader=True, empty=True))
connectAttr((material + ".outColor"),(shader + ".surfaceShader"),
f=True)
for j in range(0,len(geom)):
existingShaders=listConnections(geom[j],
source=False,
plugs=False,
destination=True,
type="shadingEngine")
if len(existingShaders)>0:
editRenderLayerMembers(layer,geom[j])
retry=0
# first try to set the shader in object mode
retry=1
# Use shading group hijack method for everything...
#if (catch(`sets -noWarnings -forceElement $shader $geom[$j]`)) {
# $retry = 1;
#}
if retry == 1:
# Couldn't assign shader. Various alternative approaches to assigning the shader have not worked 100% of the time.
# So add a couple of extra attributes to the shadingGroup - defaultShader and namespaceShader, and connect the respective
# shaders to these. During pushRenderLayer (PlayblastTool), check for the existence of the namespaceShader, and if present,
# find it's connection and plug it into the surfaceShader attribute, thus "hijacking" the shading group. During popRenderLayer,
# connect the attribute plugged into defaultShader and plug this back into the surfaceShader attribute. This is messy, but it
# sidesteps material assignment alltogether.
for k in range(0,len(existingShaders)):
if not objExists(existingShaders[k] + ".defaultShader"):
addAttr(existingShaders[k],
ln="defaultShader",at="message")
defaultMat=listConnections((existingShaders[k] + ".surfaceShader"),
s=1,d=0)
if len(defaultMat):
connectAttr((defaultMat[0] + ".message"),(existingShaders[k] + ".defaultShader"))
addAttr(existingShaders[k],
ln="namespaceShader",at="message")
connectAttr((material + ".message"),(existingShaders[k] + ".namespaceShader"))
retry=0
# temp until we feel confident retiring the next section of code
if retry == 1:
print "Using alternate shader assignment strategy on " + geom[j] + "\n"
# couldn't assign shader. Emergency fall-back: Switch back to defaultRenderLayer, unassign and re-assign the existing shaders, then
# switch back to namespace layer and try again.
existingShaders = self.stringArrayReverse(existingShaders)
"""
To-do: Add an explanation about why reversing the shaders array is necessary once we've confirmed that we are good. -HM
"""
# store the existing material assignments
comps=[]
indices=[]
for k in range(1,len(existingShaders)):
indices[k - 1]=len(comps)
assigned=cmds.sets(existingShaders[k],
q=1)
for m in range(0,len(assigned)):
obj=ls(o=assigned[m])
if obj[0] == geom[j]:
comps.append(assigned[m])
# unassign the existing materials
for k in range(0,len(existingShaders)):
cmds.sets(geom[j],
rm=existingShaders[k],e=1)
if catch( lambda: cmds.sets(geom[j],
noWarnings=1,forceElement=shader) ):
mel.warning("Couldn't "
"assign namespace shader to " + geom[j])
continue
else:
print ("DeepPlayblastUtilities: Alternate "
"shader assignment worked for " +
geom[j] + ".\n")
editRenderLayerGlobals(currentRenderLayer="defaultRenderLayer")
# switch back to defaultRenderLayer
# and re-assign (assign first shader to whole
# object, then component assign subsequent shaders)
cmds.sets(geom[j],
e=1,fe=existingShaders[0])
for k in range(0,len(indices)):
end = (int((k<len(indices) - 1) and
indices[k + 1] or (len(comps))))
for m in range(indices[k],end):
cmds.sets(comps[m],
e=1,fe=existingShaders[k + 1])
# switch to namespace layer
editRenderLayerGlobals(currentRenderLayer=layer)
if len(gpu_mesh)>0:
# end if size($existingShaders)
for j in range(0,len(gpu_mesh)):
pm.editRenderLayerMembers(layer,gpu_mesh[j])
pm.setAttr((gpu_mesh[j] + ".defaultColor"),
red,green,blue,
type='double3')
pm.setAttr((gpu_mesh[j] + ".colorsMode"), 0)
self.gpu_meshes.append(gpu_mesh[j])
if layer != "":
pm.namespace(set=old_namespace)
pm.editRenderLayerGlobals(currentRenderLayer=old_render_layer)
self.layer = layer
self.gpu_meshes = list(set(self.gpu_meshes))
