def createRig(self):
pm.currentTime(0, e=True)
global sel_objects
sel_objects = pm.ls(sl=True, tr=True)
if sel_objects == []:
print '\n# Error: Please select an object first'
pm.confirmDialog(title = 'Error: Nothing Selected',
m = 'Please select an object to create the light rig around.',
button = 'Ok',
db = 'Ok')
self.close()
gui(dock=False)
else:
global light_name
light_name = 'light1'
name_request = pm.promptDialog(
t='Light Name',
m='Enter Your New Light\'s Name',
ma='left',
tx='Ex: key_light',
st='text',
b=['Ok', 'Cancel'],
db='Ok',
cb='Cancel',
ds='Cancel')
if name_request == 'Ok':
light_name = pm.promptDialog(query=True, text=True)
global sel_center
sel_center = command.averageCoords(sel_objects)
global rigOrbit, rigInterv, rigLight
rigOrbit = pm.group(n='olp_orbitsGrp1', em=True)
rigInterv = pm.group(n='olp_intervalsGrp1', em=True)
rigLight = self.createLight(sel_center)
self.setExpression()
pm.createRenderLayer([sel_objects, rigOrbit, rigInterv, rigLight], noRecurse=True, name='{0}_layer'.format(light_name))
self.createVis()
pm.xform(rigOrbit, a=True, t=sel_center)
pm.xform(rigInterv, a=True, t=sel_center)
pm.parent(rigLight, rigInterv)
pm.parent(rigInterv, rigOrbit)
pm.select(sel_objects, r=True)
# GUI Components enable/disable
self.enableDisable_component(self.createRig_btn, enabled=False)
self.enableDisable_component(self.deleteRig_btn, enabled=True)
self.enableDisable_component(self.distance_label, enabled=True)
self.enableDisable_component(self.distance_float, enabled=True)
self.enableDisable_component(self.orbit_label, enabled=True)
self.enableDisable_component(self.orbit_int, enabled=True)
self.enableDisable_component(self.interv_label, enabled=True)
self.enableDisable_component(self.interv_int, enabled=True)
self.enableDisable_component(self.showVis_ckbx, enabled=True)
def createRLayer(self):
'''Create and assign renderlayer for chrystal shading asset'''
pm.select(cl = True)
#Create renderLayer
#------------------------------------------------------------------
#Default
self.default_renderLayer = pm.nodetypes.RenderLayer.defaultRenderLayer();pm.select(cl = True)
#outerHull
self.chrystal_shader_outerHull_refract_rlyr = pm.createRenderLayer(e = True, n = 'cs_outerHull_refract_rlyr');pm.select(cl = True)
self.chrystal_shader_outerHull_diffuse_rlyr = pm.createRenderLayer(e = True, n = 'cs_outerHull_diffuse_rlyr');pm.select(cl = True)
#intermediate
self.chrystal_shader_intermediary_sss_refract_rlyr = pm.createRenderLayer(e = True, n = 'cs_intermediary_sss_refract_rlyr');pm.select(cl = True)
self.chrystal_shader_intermediary_sss_simple_rlyr = pm.createRenderLayer(e = True, n = 'cs_intermediary_sss_simple_rlyr');pm.select(cl = True)
self.chrystal_shader_intermediary_diffuse_rlyr = pm.createRenderLayer(e = True, n = 'cs_intermediary_diffuse_rlyr');pm.select(cl = True)
self.chrystal_shader_intermediary_mask_rlyr = pm.createRenderLayer(e = True, n = 'cs_intermediary_mask_rlyr');pm.select(cl = True)
#inner
self.chrystal_shader_inner_sss_rlyr = pm.createRenderLayer(e = True, n = 'cs_inner_sss_rlyr');pm.select(cl = True)
#datapasses
self.chrystal_shader_datapasses_rlyr = pm.createRenderLayer(e = True, n = 'cs_datapasses_rlyr');pm.select(cl = True)
#statusMsg
#if(self.verbose):print('Successfuly created renderLayer')
#Assign membership for renderLayer
#------------------------------------------------------------------
pm.select(cl = True)
#outerHull refract
self.chrystal_shader_outerHull_refract_rlyr.addMembers([self.innerChrystal_grp, self.outerHull_grp], noRecurse = True);pm.select(cl = True)
#outerHull diffuse
self.chrystal_shader_outerHull_diffuse_rlyr.addMembers([self.innerHull_grp, self.outerHull_grp, self.intermediary_grp , self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp], noRecurse = True);pm.select(cl = True)
#intermediary sss refract
self.chrystal_shader_intermediary_sss_refract_rlyr.addMembers([self.innerHull_grp, self.outerHull_grp, self.intermediary_grp , self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp, self.chrystal_intermediary_lights_grp], noRecurse = True);pm.select(cl = True)
#intermediary sss simple
self.chrystal_shader_intermediary_sss_simple_rlyr.addMembers([self.innerHull_grp, self.outerHull_grp, self.intermediary_grp , self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp, self.chrystal_intermediary_lights_grp], noRecurse = True);pm.select(cl = True)
#intermediary diffuse
self.chrystal_shader_intermediary_diffuse_rlyr.addMembers([self.innerHull_grp, self.outerHull_grp, self.intermediary_grp , self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp], noRecurse = True);pm.select(cl = True)
#intermediary mask
self.chrystal_shader_intermediary_mask_rlyr.addMembers([self.innerHull_grp, self.outerHull_grp, self.intermediary_grp , self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp], noRecurse = True);pm.select(cl = True)
#inner sss
self.chrystal_shader_inner_sss_rlyr.addMembers([self.innerHull_grp, self.outerHull_grp, self.intermediary_grp , self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp, self.inner_chrystal_lights_grp], noRecurse = True);pm.select(cl = True)
#datapasses
self.chrystal_shader_datapasses_rlyr.addMembers([self.innerHull_grp, self.outerHull_grp, self.intermediary_grp , self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp], noRecurse = True);pm.select(cl = True)
pm.select(cl = True)
def create_wireframe_rl(name="wireframe"):
"""
Creates wireframe material
Creates wireframe layer
Adds all geometry and rendercam to the renderlayer
@param name: str layername
"""
mat_name = "%s_mat" % name
if not pm.objExists(mat_name):
material_node = pm.shadingNode("lambert", n=mat_name, asShader=True)
material_node.setColor([1, 1, 1])
material_sg_node = pm.sets(renderable=True, noSurfaceShader=True, empty=True, name="%sSG" % mat_name)
material_sg_node.miContourEnable.set(1)
material_sg_node.miContourColor.set([0,0,0])
material_sg_node.miContourWidth.set(1.5)
material_node.outColor >> material_sg_node.surfaceShader
if not pm.objExists(name):
render_layer = pm.createRenderLayer(n=name)
render_layer.setCurrent()
render_layer.addMembers(pm.ls(geometry=True, cameras=True))
material_sg_node.message >> render_layer.shadingGroupOverride
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 testSetRenderLayer(self):
cam1 = pmc.camera()[0]
defaultlayer = pmc.nodetypes.RenderLayer.defaultRenderLayer()
newlayer = pmc.createRenderLayer()
defaultlayer.setCurrent()
with render_layer_active(newlayer):
cam2 = pmc.camera()[0]
self.assertEqual(pmc.nodetypes.RenderLayer.currentLayer(), newlayer)
self.assertEqual(pmc.nodetypes.RenderLayer.currentLayer(), defaultlayer)
self.assertTrue(defaultlayer.inLayer(cam1))
self.assertTrue(newlayer.inLayer(cam2))
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 testSetRenderLayer(self):
cam1 = pmc.camera()[0]
defaultlayer = pmc.nodetypes.RenderLayer.defaultRenderLayer()
newlayer = pmc.createRenderLayer()
defaultlayer.setCurrent()
with render_layer_active(newlayer):
cam2 = pmc.camera()[0]
self.assertEqual(pmc.nodetypes.RenderLayer.currentLayer(),
newlayer)
self.assertEqual(pmc.nodetypes.RenderLayer.currentLayer(),
defaultlayer)
self.assertTrue(defaultlayer.inLayer(cam1))
self.assertTrue(newlayer.inLayer(cam2))
def makeLayer(name=None):
""" A Layer creation widget that includes custom layer attributes. """
if not name:
run = pm.promptDialog(title='Create New Layer',
message='Enter Name:',
button=['OK', 'Cancel'],
defaultButton='OK',
cancelButton='Cancel',
dismissString='Cancel')
if run == 'OK':
name = pm.promptDialog(query=True, text=True)
else:
return None
if pm.PyNode(name):
pm.warning(
'Layer (or an object) with that name already exists. Skipping...')
return False
else:
lyr = pm.createRenderLayer(name=name, number=1, empty=True)
return lyr
def makeLayer( name=None ):
""" A Layer creation widget. """
if not name:
run = pm.promptDialog(
title='Create New Layer',
message='Enter Name:',
button=['OK', 'Cancel'],
defaultButton='OK',
cancelButton='Cancel',
dismissString='Cancel'
)
if run == 'OK':
name = pm.promptDialog(query=True, text=True)
else:
return None
try:
exists = pm.PyNode(name)
if exists:
pm.warning('Sort Control Could not create layer: {0}'.format(name))
return False
except:
lyr = pm.createRenderLayer( name=name, number=1, empty=True )
return lyr
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 createRenderLayer(name):
#创建渲染层
#
#参数name: 需要输入渲染层的名字
#
#获取所有的模型对象
allgeos = getallGeos()
topgrp = list(set([i.getParent(-1) for i in allgeos]))
members = getallTops()
#切换渲染器
try:
defaultLayer = pm.nodetypes.RenderLayer.defaultRenderLayer()
defaultLayer.setCurrent()
except:
pass
#删除所有的AOV
at.delAOV()
#删除所有的渲染层
renderLayers = pm.ls(type='renderLayer')
for rl in renderLayers:
if 'defaultRenderLayer' not in rl.name():
pm.delete(rl)
#创建渲染层
if name == "bg_color":
for key in ['AO', 'NOM', 'Fre', 'Z']:
at.createAOV(key)
members = getsetTops() + getlightTops()
elif name == "chr_color":
for key in ['AO', 'NOM', 'Fre', 'sss']:
at.createAOV(key)
im = importLight()
members = getchrandpropTops() + im
elif name == "night_chr_color":
for key in ['AO', 'NOM', 'Fre', 'sss']:
at.createAOV(key)
im = importLight()
members = getchrandpropTops() + im
elif name in [
"chr_idp1", "chr_idp2", "chr_idp3", "bg_idp1", "bg_idp2", "bg_idp3"
]:
delAllShaders(topgrp)
shader, sg = CNG.createIDPNode('Maeet')
CNG.assignShader(topgrp, shader, sg)
elif name == "shadow":
delAllShaders(topgrp)
at.createAOV('COCC')
shader, sg = CNG.createShadow()
CNG.assignShader(topgrp, shader, sg)
elif name == "RGBlight":
delAllShaders(topgrp)
shader, sg = CNG.createRGBlight()
CNG.assignShader(topgrp, shader, sg)
elif name == "FOGlight":
delAllShaders(topgrp)
shader, sg = CNG.createFOGlight()
CNG.assignShader(topgrp, shader, sg)
else:
pass
if name == 'night_chr_color':
layerName = 'chr_color'
else:
layerName = name
try:
layer = pm.nodetypes.RenderLayer.findLayerByName(layerName)
except:
layer = pm.createRenderLayer(name=layerName, e=1)
try:
defaultLayer = pm.nodetypes.RenderLayer.defaultRenderLayer()
defaultLayer.renderable.set(0)
except:
pass
layer.setCurrent()
if members:
layer.addMembers(members)
try:
saveFile(name)
except:
pass
def createRenderLayer(name):
# 创建渲染层
#
# 参数name: 需要输入渲染层的名字
#
# 获取所有的模型对象
allgeos = getallGeos()
topgrp = list(set([i.getParent(-1) for i in allgeos]))
members = getallTops()
# 切换渲染器
try:
defaultLayer = pm.nodetypes.RenderLayer.defaultRenderLayer()
defaultLayer.setCurrent()
except:
pass
# 删除所有的AOV
at.delAOV()
# 删除所有的渲染层
renderLayers = pm.ls(type="renderLayer")
for rl in renderLayers:
if "defaultRenderLayer" not in rl.name():
pm.delete(rl)
# 创建渲染层
if name == "bg_color":
for key in ["AO", "NOM", "Fre", "Z"]:
at.createAOV(key)
members = getsetTops() + getlightTops()
elif name == "chr_color":
for key in ["AO", "NOM", "Fre", "sss"]:
at.createAOV(key)
im = importLight()
members = getchrandpropTops() + im
elif name == "night_chr_color":
for key in ["AO", "NOM", "Fre", "sss"]:
at.createAOV(key)
im = importLight()
members = getchrandpropTops() + im
elif name in ["chr_idp1", "chr_idp2", "chr_idp3", "bg_idp1", "bg_idp2", "bg_idp3"]:
delAllShaders(topgrp)
shader, sg = CNG.createIDPNode("Maeet")
CNG.assignShader(topgrp, shader, sg)
elif name == "shadow":
delAllShaders(topgrp)
at.createAOV("COCC")
shader, sg = CNG.createShadow()
CNG.assignShader(topgrp, shader, sg)
elif name == "RGBlight":
delAllShaders(topgrp)
shader, sg = CNG.createRGBlight()
CNG.assignShader(topgrp, shader, sg)
elif name == "FOGlight":
delAllShaders(topgrp)
shader, sg = CNG.createFOGlight()
CNG.assignShader(topgrp, shader, sg)
else:
pass
if name == "night_chr_color":
layerName = "chr_color"
else:
layerName = name
try:
layer = pm.nodetypes.RenderLayer.findLayerByName(layerName)
except:
layer = pm.createRenderLayer(name=layerName, e=1)
try:
defaultLayer = pm.nodetypes.RenderLayer.defaultRenderLayer()
defaultLayer.renderable.set(0)
except:
pass
layer.setCurrent()
if members:
layer.addMembers(members)
try:
saveFile(name)
except:
pass
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 createRLayer(self):
'''Create and assign renderlayer for chrystal shading asset'''
pm.select(cl=True)
#Create renderLayer
#------------------------------------------------------------------
#Default
self.default_renderLayer = pm.nodetypes.RenderLayer.defaultRenderLayer(
)
pm.select(cl=True)
#outerHull
self.chrystal_shader_outerHull_refract_rlyr = pm.createRenderLayer(
e=True, n='cs_outerHull_refract_rlyr')
pm.select(cl=True)
self.chrystal_shader_outerHull_diffuse_rlyr = pm.createRenderLayer(
e=True, n='cs_outerHull_diffuse_rlyr')
pm.select(cl=True)
#intermediate
self.chrystal_shader_intermediary_sss_refract_rlyr = pm.createRenderLayer(
e=True, n='cs_intermediary_sss_refract_rlyr')
pm.select(cl=True)
self.chrystal_shader_intermediary_sss_simple_rlyr = pm.createRenderLayer(
e=True, n='cs_intermediary_sss_simple_rlyr')
pm.select(cl=True)
self.chrystal_shader_intermediary_diffuse_rlyr = pm.createRenderLayer(
e=True, n='cs_intermediary_diffuse_rlyr')
pm.select(cl=True)
self.chrystal_shader_intermediary_mask_rlyr = pm.createRenderLayer(
e=True, n='cs_intermediary_mask_rlyr')
pm.select(cl=True)
#inner
self.chrystal_shader_inner_sss_rlyr = pm.createRenderLayer(
e=True, n='cs_inner_sss_rlyr')
pm.select(cl=True)
#datapasses
self.chrystal_shader_datapasses_rlyr = pm.createRenderLayer(
e=True, n='cs_datapasses_rlyr')
pm.select(cl=True)
#statusMsg
#if(self.verbose):print('Successfuly created renderLayer')
#Assign membership for renderLayer
#------------------------------------------------------------------
pm.select(cl=True)
#outerHull refract
self.chrystal_shader_outerHull_refract_rlyr.addMembers(
[self.innerChrystal_grp, self.outerHull_grp], noRecurse=True)
pm.select(cl=True)
#outerHull diffuse
self.chrystal_shader_outerHull_diffuse_rlyr.addMembers([
self.innerHull_grp, self.outerHull_grp, self.intermediary_grp,
self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp
],
noRecurse=True)
pm.select(cl=True)
#intermediary sss refract
self.chrystal_shader_intermediary_sss_refract_rlyr.addMembers(
[
self.innerHull_grp, self.outerHull_grp, self.intermediary_grp,
self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp,
self.chrystal_intermediary_lights_grp
],
noRecurse=True)
pm.select(cl=True)
#intermediary sss simple
self.chrystal_shader_intermediary_sss_simple_rlyr.addMembers(
[
self.innerHull_grp, self.outerHull_grp, self.intermediary_grp,
self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp,
self.chrystal_intermediary_lights_grp
],
noRecurse=True)
pm.select(cl=True)
#intermediary diffuse
self.chrystal_shader_intermediary_diffuse_rlyr.addMembers(
[
self.innerHull_grp, self.outerHull_grp, self.intermediary_grp,
self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp
],
noRecurse=True)
pm.select(cl=True)
#intermediary mask
self.chrystal_shader_intermediary_mask_rlyr.addMembers([
self.innerHull_grp, self.outerHull_grp, self.intermediary_grp,
self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp
],
noRecurse=True)
pm.select(cl=True)
#inner sss
self.chrystal_shader_inner_sss_rlyr.addMembers([
self.innerHull_grp, self.outerHull_grp, self.intermediary_grp,
self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp,
self.inner_chrystal_lights_grp
],
noRecurse=True)
pm.select(cl=True)
#datapasses
self.chrystal_shader_datapasses_rlyr.addMembers([
self.innerHull_grp, self.outerHull_grp, self.intermediary_grp,
self.innerChrystal_grp, self.inner_chrystal_rockremainder_grp
],
noRecurse=True)
pm.select(cl=True)
pm.select(cl=True)
