def LocateAllModoIblNodes():
nodes = []
for node in cmds.ls(type="modoEnvironment"):
linkedNode = cmds.defaultNavigation(destination=node + ".environmentColor", defaultTraversal=True)
#check if there's a file node plugged in and create one if there's not
if linkedNode == []:
fileNode = cmds.shadingNode('file', asTexture=True)
linkedNode = cmds.defaultNavigation(connectToExisting=True, source=fileNode, destination="%s.environmentColor" % node, force=True)
if(linkedNode == None):
continue
#break out of the array the first entry
linkedNode = linkedNode[0]
if(cmds.nodeType(linkedNode) != "file"):
continue
#we have a texture, but check to see that it's lat/long mapped.
if(cmds.attributeQuery("format", node=str(node), exists=True)):
mappingType = cmds.getAttr(node+".format")
if(mappingType != 2):
cmds.scrollField("rendererErrorText", edit=True, text="Selected modo Environment node is mapped to use non-spherical mapping.")
continue
#everything look valid
strAttribute = str(linkedNode) + ".fileTextureName"
#craft an entry for the node list
entry = strAttribute, node, linkedNode
nodes.append(entry)
return nodes
def test_create_node_and_compile(self):
mel.eval("source createRenderNode")
test_void_input = cmds.shadingNode("test_void_input", asShader=True)
test_void_output = cmds.shadingNode("test_void_output", asUtility=True)
sphere = cmds.sphere()
cmds.select(sphere, replace=True)
node_sg = cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name="test_void_inputSG1")
cmds.defaultNavigation(connectToExisting=True,
source=test_void_input,
destination=node_sg)
mel.eval('connectNodeToNodeOverride("%s", "%s")' %
(test_void_input, node_sg))
cmds.sets(edit=True, forceElement=node_sg)
cmds.connectAttr(test_void_output + ".voidOutput",
test_void_input + ".voidInput[0]",
force=True)
cmds.connectAttr(test_void_output + ".param3",
test_void_input + ".param3",
force=True)
mel.eval("delightRender %s" % self.renderpass)
def create_file_node(imgLoca, name, uRep, vRep, uNoise, vNoise):
'''Creates a file node for an image in a directory and apply options to
it.
Parameters:
imgLoca [str] : The image location on the disc drive. Should be in the
format that is created by 'os.path.abspath'.
name [str] : The name of the file node.
uRep [float] : The number of repetitions of the texture in the U-axis
(Y).
vRep [float] : The number of repetitions of the texture in the V-axis
(X).
uNoise [float] : The amplitude of the noise effect on the texture in
the U-axis (Y).
vNoise [float] : The amplitude of the noise effect on the texture in
the V-axis (X).
On Exit:
Creates a file and file2d texture from the 'imgLoca' with the options
in the parameters. It is then returned in a tuple at the end of the
function.
'''
file_ = mf.create_shader_node('file', asTexture=True, name=name,
fileTextureName=imgLoca, filterType=1)
file2d = mf.create_shader_node('place2dTexture', asUtility=True,
repeatU=uRep, repeatV=vRep, noiseU=uNoise,
noiseV=vNoise)
cmds.defaultNavigation(ce=True, source=file2d, destination=file_)
return (file_,file2d)
def set_texture(material, tex_attr, file_path):
"""
Connects a file node with all its additional nodes
Args:
material (unicode): name of the material
tex_attr (unicode): name of the texture attribute
file_path (unicode): filepath of texture
"""
if file_path:
full_attr = "{}.{}".format(material, tex_attr)
sources = cmds.listConnections(full_attr, type='file')
if sources:
# There can be only one source connected to a texture input attribute
cmds.setAttr(sources[0] + '.fileTextureName',
file_path,
type='string')
else:
place2d_node = cmds.shadingNode('place2dTexture',
asUtility=True,
ss=True)
file_node = cmds.shadingNode('file', asTexture=True, ss=True)
clib.set_attr(file_node, "fileTextureName", file_path)
# Make the default connections
cmds.defaultNavigation(connectToExisting=True,
source=place2d_node,
destination=file_node)
cmds.defaultNavigation(connectToExisting=True,
source=file_node,
destination=full_attr,
force=True)
def arnoldShaderSetup(self, mesh, keepShaderValue, udimValue,
DisplacementFile):
MaxBound = max([self.MinLuma, self.MaxLuma], key=abs)
if keepShaderValue == "False":
shader = cmds.shadingNode("aiStandard",
name=mesh + "_aiStandard",
asShader=True)
shading_group = cmds.sets(name=mesh + "SG",
renderable=True,
noSurfaceShader=True,
empty=True)
cmds.connectAttr('%s.outColor' % shader,
'%s.surfaceShader' % shading_group)
else:
shape = cmds.listRelatives(mesh, shapes=True)
shading_group = cmds.listConnections(shape, type='shadingEngine')
displacement_shader = cmds.shadingNode("displacementShader",
name=mesh +
"_displacementShader",
asShader=True)
file_node = cmds.shadingNode("file",
name=mesh + "_displacement_File",
asTexture=True,
isColorManaged=True)
uv = cmds.shadingNode("place2dTexture", asUtility=True)
cmds.setAttr(file_node + ".filterType", 0)
cmds.setAttr(file_node + ".fileTextureName",
DisplacementFile,
type="string")
cmds.setAttr(file_node + ".colorSpace", "Raw", type="string")
cmds.setAttr(mesh + ".aiDispPadding", MaxBound)
if udimValue == "True":
cmds.setAttr(file_node + ".uvTilingMode", 3)
cmds.setAttr(file_node + ".uvTileProxyQuality", 4)
if keepShaderValue == "False":
cmds.connectAttr('%s.displacement' % displacement_shader,
'%s.displacementShader' % shading_group,
force=True)
else:
cmds.connectAttr('%s.displacement' % displacement_shader,
'%s.displacementShader' % str(shading_group[0]),
force=True)
cmds.defaultNavigation(connectToExisting=True,
source=uv,
destination=file_node)
cmds.connectAttr('%s.outColorR' % file_node,
'%s.displacement' % displacement_shader)
cmds.select(cmds.listRelatives(mesh, shapes=True))
if keepShaderValue == "False":
cmds.hyperShade(assign=shading_group)
def applyShaderColor(self, name, R=0.5, G=0.5, B=0.5, *args):
shPrefix = mc.textField(self.shPrefix, text=True, q=True)
shSuffix = mc.textField(self.shSuffix, text=True, q=True)
shType = self.initShaderType()
print ">> " + shPrefix + shType + shSuffix
shaderName = shPrefix + name + "_" + shType + shSuffix
shadingGroupName = shaderName + 'SG'
selectionList = mc.ls(selection=True, type="transform")
if selectionList:
if not mc.objExists(shaderName):
mc.shadingNode(self.shaderType, asShader=True, name=shaderName)
if self.shaderType == "RMSGPSurface":
mc.setAttr(shaderName + ".surfaceColor",
R,
G,
B,
type="double3")
mc.setAttr(shaderName + ".specularGain", 0)
mc.setAttr(shaderName + ".specularFeatures", 0)
else:
mc.setAttr(shaderName + ".color", R, G, B, type="double3")
mc.sets(renderable=True,
empty=1,
noSurfaceShader=True,
name=shadingGroupName)
mc.defaultNavigation(source=shaderName,
destination=shadingGroupName,
connectToExisting=1)
for obj in selectionList:
mc.sets(obj, forceElement=shadingGroupName, e=1)
mc.select(selectionList)
else:
print ">> No selection"
def modify_tex () :
#create and assign texture
textureA = cmds.shadingNode("lambert", asShader = True, name = "TextureA")
cmds.setAttr(textureA + ".color", 0.5,0.78,0.28)#grey
textureASG = cmds.sets( renderable = True, noSurfaceShader = True, empty = True, name = 'TextureASG')
#get all objects in scene
# cmds.select(ado = True)
# global Object_List
# Object_List = cmds.ls(selection = True)
cmds.select('Object1', r = True)
cmds.defaultNavigation(connectToExisting = True, source = "TextureA", destination = "TextureASG")
cmds.sets(e = True, forceElement = "TextureASG")
# for item in Object_List :
# cmds.select(item,r = True)
# cmds.defaultNavigation(connectToExisting = True, source = "TextureA", destination = "TextureASG")
# cmds.sets(e = True, forceElement = "TextureASG")
# def sewing_pieces() :
# cmds.polyUnite(Object_List, n = 'result')
# def export_fbx() :
# # cmds.select(ado = True)
cmds.select('Object1', r = True)
cmds.file(wrspFldr + '//' + filename + '.fbx', f = True, op = "v = 0;", typ = "FBX export", pr = True, es = True)
def applyLambertRandocmdsolour():
selected = cmds.ls(sl=True)
size=len(selected)
for item in selected:
cmds.shadingNode('lambert', asShader=True)
cmds.sets(r=True,nss=True,em=True,n='lambert'+str(i)+'SG')
cmds.sets(e=True,fe='lambert'+str(item)+'SG')
cmds.defaultNavigation(ce=True,s='lambert'+str(item), d='lambert'+str(item)+'SG')
def checkIDbyobj_break(arg):
sel = cmds.ls(sl=True)
obj2shapes = cmds.listRelatives(sel)
shapes2SG = cmds.listConnections(obj2shapes,s=0,type='shadingEngine')
shapes2SGnew = cmds.duplicate(shapes2SG,po=True)
SG2AU = cmds.listConnections(shapes2SG,d=0,type='aiUtility')
SG2AW = cmds.listConnections(SG2AU,d=0,type='aiWriteColor')
SG2AUnew = cmds.duplicate(SG2AU,po=True)
for i in range(0,len(SG2AUnew)):
cmds.connectAttr(SG2AW[0]+".outColor",SG2AUnew[0]+".color")
cmds.connectAttr(SG2AUnew[0]+".outColor",shapes2SGnew[0]+".surfaceShader")
cmds.defaultNavigation(source = SG2AUnew[0],destination = obj2shapes[0]+".instObjGroups[0]",connectToExisting=True)
def addScrollListTex():
sel = selectListS()
texTemp = cmds.group(name = 'texTempNode', empty = True)
texTempList.append(texTemp)
cmds.addAttr(texTemp, longName = 'texTemp', usedAsColor = True, attributeType = 'float3')
cmds.addAttr(longName = 'texTempR', attributeType = 'float', parent = 'texTemp')
cmds.addAttr(longName = 'texTempG', attributeType = 'float', parent = 'texTemp')
cmds.addAttr(longName = 'texTempB', attributeType = 'float', parent = 'texTemp')
cmds.defaultNavigation(createNew = True, destination = '%s.texTemp' % texTemp)
tsList = scrollListItemsColor()
tsList.append(texTemp)
cmds.textScrollList(tslColorList, edit = True, removeAll = True)
cmds.textScrollList(tslColorList, append = tsList, edit = True)
def test_create_node_and_compile(self):
sphere = cmds.sphere()
node = cmds.shadingNode("dl_layer", asShader=True)
cmds.select(sphere, replace=True)
node_sg = cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name=node)
cmds.defaultNavigation(connectToExisting=True,
source=node,
destination=node_sg)
mel.eval('connectNodeToNodeOverride("%s", "%s")' % (node, node_sg))
cmds.sets(edit=True, forceElement=node_sg)
mel.eval("delightRender %s" % self.renderpass)
def addShaderToSelected(self,*args):
selected = cmds.ls(sl = True)
for surf in selected:
newMat = cmds.shadingNode('lambert', asShader=True, name = surf+'_instPaint1')
newSG = cmds.sets(name = newMat+'SG', r = True, nss = True, em = True)
texture = cmds.shadingNode('file', asTexture = True, name = surf+'_instPaintFile1')
#cmds.connectAttr(texture+.'outColor' ,newMat+'.color', force = True )
cmds.defaultNavigation(connectToExisting = True, source = texture, destination = newMat)
cmds.defaultNavigation(connectToExisting = True, source = newMat, destination = newSG)
cmds.select( clear=True )
print "select",surf
cmds.select(surf)
print "assign",newMat,"to",surf
cmds.hyperShade( newMat, assign=True )
cmds.sets(edit= True,fe = newSG)
def addScrollListTex():
sel = selectListS()
texTemp = cmds.group(name='texTempNode', empty=True)
texTempList.append(texTemp)
cmds.addAttr(texTemp,
longName='texTemp',
usedAsColor=True,
attributeType='float3')
cmds.addAttr(longName='texTempR', attributeType='float', parent='texTemp')
cmds.addAttr(longName='texTempG', attributeType='float', parent='texTemp')
cmds.addAttr(longName='texTempB', attributeType='float', parent='texTemp')
cmds.defaultNavigation(createNew=True, destination='%s.texTemp' % texTemp)
tsList = scrollListItemsColor()
tsList.append(texTemp)
cmds.textScrollList(tslColorList, edit=True, removeAll=True)
cmds.textScrollList(tslColorList, append=tsList, edit=True)
def updateUi(self): """update UI based on baseMesh""" blends = mc.ls( mc.defaultNavigation( ren = True, d = self.baseMesh.shape.name ), typ = 'blendShape' ) self.blends_cmb.clear() if blends: self.blends_cmb.addItems( blends ) self.updateTargets()
def setShader(
self,
Bobject,
args=0
): #gets the shape node, then sets the shader node to a blinn
self.getShape = cmds.listRelatives(Bobject, shapes=True)[0]
getBlinn = cmds.shadingNode('blinn', asShader=True)
getNewSet = cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True)
cmds.connectAttr(getBlinn + '.outColor',
getNewSet + '.surfaceShader',
f=True)
cmds.defaultNavigation(source=getBlinn,
destination=self.getShape + '.instObjGroups[0]',
connectToExisting=True)
def LocateAllVRayIblNodes():
#VRay nodes need to be treated differently. A VRay dome can be linked to a regular file node (or rather, this is all we support)
#so we must follow this node to get the texture path to change
nodes = []
for node in cmds.ls(type="VRayLightDomeShape"):
linkedNode = cmds.defaultNavigation(destination=node + ".domeTex", defaultTraversal=True)
if(linkedNode == None):
continue
#if no file texture is linked to the domeTex, then create one and link it up
if(linkedNode == []):
fileNode = cmds.shadingNode('file', asTexture=True)
cmds.defaultNavigation(connectToExisting=True, source=fileNode, destination=node + ".domeTex", force=True)
linkedNode = cmds.defaultNavigation(destination=node + ".domeTex", defaultTraversal=True)
if(linkedNode == None or linkedNode == []):
cmds.scrollField("rendererErrorText", edit=True, text="Could not create and link texture node to VRay Light Dome domeTex attribute slot.")
continue
if cmds.getAttr("%s.useDomeTex" % node) == 0:
cmds.setAttr("%s.useDomeTex" % node, 1)
#break out of the array the first entry
linkedNode = linkedNode[0]
if(cmds.nodeType(linkedNode) != "file"):
continue
#we have a texture, but check to see that linked to a VRayPlaceEnvTex that is set for Spherical maps.
vrayTexNode = cmds.listConnections(linkedNode, s=True, d=False, t="VRayPlaceEnvTex")
validTexNode = False
if(vrayTexNode != None):
texNode = vrayTexNode[0]
if(cmds.attributeQuery("mappingType", node=str(texNode), exists=True)):
mappingType = cmds.getAttr(texNode+".mappingType")
if(mappingType != 2):
cmds.scrollField("rendererErrorText", edit=True, text="Selected VRay Light Dome is mapped to use non-spherical mapping.")
continue
#everything look valid
strAttribute = str(linkedNode) + ".fileTextureName"
#craft an entry for the node list
entry = strAttribute, node, linkedNode
nodes.append(entry)
return nodes
def test_create_node_and_compile(self):
mel.eval("source createRenderNode")
test_void_input = cmds.shadingNode("test_void_input", asShader=True)
test_void_output = cmds.shadingNode("test_void_output", asUtility=True)
sphere = cmds.sphere()
cmds.select(sphere, replace=True)
node_sg = cmds.sets(renderable=True, noSurfaceShader=True, empty=True, name="test_void_inputSG1");
cmds.defaultNavigation(connectToExisting=True, source=test_void_input, destination=node_sg)
mel.eval('connectNodeToNodeOverride("%s", "%s")' % (test_void_input, node_sg))
cmds.sets(edit=True, forceElement=node_sg)
cmds.connectAttr(test_void_output + ".voidOutput", test_void_input + ".voidInput[0]", force=True)
cmds.connectAttr(test_void_output + ".param3", test_void_input + ".param3", force=True)
mel.eval("delightRender %s" % self.renderpass)
def terrain_random_noise():
'''Creates a random noise texture which is most effective at creating and
blending layered textures.
On Exit:
Creates and returns the noise and place2dTexture node
'''
noise = mf.create_shader_node('noise', asTexture=True, ratio=rand.random(),
frequencyRatio=rand.uniform(1, 10),
depthMax=rand.randint(1,8), time=rand.random(),
frequency=rand.uniform(2,15),
spottyness=rand.random(),
sizeRand=rand.random(),
falloff=rand.randint(0,2))
noise2d = mf.create_shader_node('place2dTexture', asUtility=True)
cmds.defaultNavigation(ce=True, source=noise2d, destination=noise)
return (noise, noise2d)
def LocateAllArnoldIblNodes():
#Arnold nodes are like VRay nodes in that it can be linked to a regular file node (or rather, this is all we support)
#so we must follow this node to get the texture path to change
nodes = []
for node in cmds.ls(type="aiSkyDomeLight"):
linkedNode = cmds.defaultNavigation(destination=node + ".color", defaultTraversal=True)
if(linkedNode == None):
continue
#if no file texture is linked to the domeTex, then create one and link it up
if(linkedNode == []):
fileNode = cmds.shadingNode('file', asTexture=True)
cmds.defaultNavigation(connectToExisting=True, source=fileNode, destination=node + ".color", force=True)
linkedNode = cmds.defaultNavigation(destination=node + ".color", defaultTraversal=True)
if(linkedNode == None or linkedNode == []):
cmds.scrollField("rendererErrorText", edit=True, text="Could not create and link texture node to Arnold aiSkyDomeLight color attribute slot.")
continue
#break out of the array the first entry
linkedNode = linkedNode[0]
if(cmds.nodeType(linkedNode) != "file"):
continue
#we have a texture, but check to see that it's lat/long mapped.
if(cmds.attributeQuery("format", node=str(node), exists=True)):
mappingType = cmds.getAttr(node+".format")
if(mappingType != 2):
cmds.scrollField("rendererErrorText", edit=True, text="Selected Arnold SkyDomeLight is mapped to use non-spherical mapping.")
continue
#everything look valid
strAttribute = str(linkedNode) + ".fileTextureName"
#craft an entry for the node list
entry = strAttribute, node, linkedNode
nodes.append(entry)
return nodes
def createNode():
cmds.shadingNode('lambert', asShader=True, name=shader_name)
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name=shader_name + 'SG')
cmds.connectAttr(shader_name + '.outColor',
shader_name + 'SG' + '.surfaceShader',
force=True)
cmds.select(allDagObjects=True)
cmds.hyperShade(assign=shader_name)
cmds.defaultNavigation(createNew=True, destination=shader_name + '.color')
cmds.defaultNavigation(defaultTraversal=True,
destination=shader_name + '.color')
cmds.shadingNode('projection', asUtility=True, name=projection_name)
cmds.defaultNavigation(force=True,
connectToExisting=True,
source=projection_name,
destination=shader_name + '.color')
cmds.connectAttr(projection_name + '.outColor',
shader_name + '.color',
force=True)
# fit to bounding box
cmds.shadingNode('place3dTexture',
asUtility=True,
name=place3dTexture_name)
cmds.defaultNavigation(force=True,
connectToExisting=True,
source=place3dTexture_name + '.worldInverseMatrix',
destination=projection_name + '.placementMatrix')
cmds.setAttr(projection_name + '.vAngle', 90)
cmds.setAttr(projection_name + '.uAngle', 180)
cmds.setAttr(place3dTexture_name + '.scale',
1.063134,
0.81531,
1.063134,
type='double3')
cmds.setAttr(place3dTexture_name + '.translate',
1.49012e-06,
0.263951,
0.011244,
type='double3')
def doIt(self, args):
outName = self.parseArguments(args)
fileData = None
# TODO: Try except, with the following command
# cmds.file(force=True, options="groups=0;ptgroups=0;materials=1;smoothing=1;normals=1", type="OBJexport", pr=True, ea=(baseOutputMaterials % (outName+".obj")))
with open(kBaseOutputMaterials % ("%s.mtl" % outName)) as f:
fileData = f.read()
materials = fileData.split('newmtl ')[1:]
print "Got n=%s materials" % len(materials)
newProps = []
for material in materials:
props = material.split('\n')
if not props[0].endswith('SG'):
continue
sgName = props[0]
name = cmds.defaultNavigation(defaultTraversal=True, destination="%s.surfaceShader" % sgName)[0]
type = self.getMaterialType(name)
print "Material %s has type %s" % (name, type)
def genTiledTx(self):
"""Generate shading network for tiled texture.
"""
commonName = self.sanitise(self.prefix + self.ext)
# Create combined texture node
txCombinedNodeType = mc.optionMenuGrp("txType", query=True, value=True)
if txCombinedNodeType == 'plusMinusAverage':
txCombinedNode = mc.shadingNode(txCombinedNodeType,
name=txCombinedNodeType + '_' +
commonName,
asUtility=True)
elif txCombinedNodeType == 'layeredTexture':
txCombinedNode = mc.shadingNode(txCombinedNodeType,
name=txCombinedNodeType + '_' +
commonName,
asTexture=True)
for i, item in enumerate(self.lsTiles):
u, v = self.getUVOffset(item)
name = self.sanitise(item)
# Create place2dTexture nodes
nodeType = 'place2dTexture'
place2dTextureNode = mc.shadingNode(nodeType,
name=nodeType + '_' + name,
asUtility=True)
mc.setAttr(place2dTextureNode + '.translateFrameU', u)
mc.setAttr(place2dTextureNode + '.translateFrameV', v)
mc.setAttr(place2dTextureNode + '.wrapU', 0)
mc.setAttr(place2dTextureNode + '.wrapV', 0)
# Create file nodes
nodeType = 'file'
fileNode = mc.shadingNode(nodeType,
name=nodeType + '_' + name,
asTexture=True)
mc.setAttr(fileNode + '.filterType', 0)
mc.setAttr(fileNode + '.fileTextureName',
os.path.join(self.txDir, item),
type="string")
mc.setAttr(fileNode + '.defaultColor', 0, 0, 0, type="double3")
# Add custom Vray attributes to file nodes
if mc.checkBoxGrp("vrayAttr", query=True, value1=True):
mel.eval('vray addAttributesFromGroup %s vray_file_gamma 1;' %
fileNode)
if mc.checkBoxGrp("vrayAttr", query=True, value2=True):
mel.eval(
'vray addAttributesFromGroup %s vray_file_allow_neg_colors 1;'
% fileNode)
# Connect up attributes
mc.defaultNavigation(connectToExisting=True,
source=place2dTextureNode,
destination=fileNode)
if txCombinedNodeType == 'plusMinusAverage':
mc.connectAttr(fileNode + '.outColor',
txCombinedNode + '.input3D[%d]' % i,
force=True)
elif txCombinedNodeType == 'layeredTexture':
mc.connectAttr(fileNode + '.outColor',
txCombinedNode + '.inputs[%d].color' % i,
force=True)
mc.setAttr(txCombinedNode + '.inputs[%d].blendMode' % i, 4)
# Create asset container then remove combined texture node from container for easy connections to shaders
if mc.checkBox("asset", query=True, value=True):
containerNode = mc.container(name='tiles_' + commonName,
addNode=txCombinedNode,
includeNetwork=True,
includeShaders=True,
includeHierarchyAbove=True,
includeHierarchyBelow=True)
mc.container(containerNode, edit=True, removeNode=txCombinedNode)
mc.select(txCombinedNode)
return
def execute_action(self, name, params, sg_publish_data):
"""
Execute a given action. The data sent to this be method will
represent one of the actions enumerated by the generate_actions method.
:param name: Action name string representing one of the items returned by generate_actions.
:param params: Params data, as specified by generate_actions.
:param sg_publish_data: Shotgun data dictionary with all the standard publish fields.
:returns: No return value expected.
"""
app = self.parent
app.log_debug(
"Execute action called for action %s. "
"Parameters: %s. Publish Data: %s" % (name, params, sg_publish_data)
)
# resolve path
# toolkit uses utf-8 encoded strings internally and Maya API expects unicode
# so convert the path to ensure filenames containing complex characters are supported
path = six.ensure_str(self.get_publish_path(sg_publish_data))
# get non-standard shotgun fields to check for scene master files
eng = sgtk.platform.current_engine()
odd_fields = eng.shotgun.find_one("PublishedFile",
[['id', 'is', sg_publish_data['id']]],
['sg_render_settings_json'])
# Gather additional files for lighting and other path field input
linked_paths = eng.shotgun.find_one("PublishedFile",
[['entity', 'is', eng.context.entity],
['published_file_type', 'is', {"type":"PublishedFileType",'id': 196}]],
['path'])
app.log_debug(">>>>> LINKED PATHS ")
app.log_debug(linked_paths)
if name == "reference":
self._create_reference(path, sg_publish_data)
if name == "import":
self._do_import(path, sg_publish_data)
if odd_fields["sg_render_settings_json"] != None:
app.log_debug(">>>>> Running Master File Setup")
# Import the renderSetup and json modules
# This enables the importing of saved render layers/layer settings
import maya.app.renderSetup.model.renderSetup as renderSetup
import json
# Import the render layers and AOVs
with open(odd_fields['sg_render_settings_json']['local_path_windows'], "r") as filename:
renderSetup.instance().decode(json.load(filename), renderSetup.DECODE_AND_OVERWRITE, None)
# save namespace from sg_publish_data for editing
namespace_name = os.path.splitext(sg_publish_data['code'])[0]
# check namespace for a valid first character
# Maya rejects strings starting with non-letter characters
# and cuts it off at the first available break character, like _ or .
if re.search(r"[a-zA-Z]", namespace_name[0]) == None:
namespace_name = "_" + "_".join(namespace_name.split("_")[1:])
else:
pass
# Merge and Delete the namespace created during the import
# This should allow all the render settings to rebind correctly
cmds.namespace(removeNamespace = namespace_name, mergeNamespaceWithRoot = True)
if linked_paths != None:
# Create texture node
cmds.defaultNavigation(defaultTraversal = True, destination='ai_Light_EnvShape.color')
cmds.shadingNode('file', asTexture = True, isColorManaged = True, name = 'ai_Light_Env_HDR')
# Apply path within new texture node
cmds.setAttr('ai_Light_Env_HDR.fileTextureName', linked_paths['path']['local_path_windows'], type = 'string')
# Connect texture to environment light
cmds.connectAttr('ai_Light_Env_HDR.outColor', 'ai_Light_EnvShape.color', force = True)
# Create 2D Texture controls and connect them to the texture file node
cmds.shadingNode('place2dTexture', asUtility = True, name = "ai_Light_Env_p2dt")
for i in cmds.listAttr('ai_Light_Env_p2dt'):
try:
cmds.connectAttr('ai_Light_Env_p2dt.%s' % i, 'ai_Light_Env_HDR.%s' % i, force = True)
except:
pass
else:
app.log_debug(">>>>> Could Not Find Color HDR")
else:
pass
if name == "texture_node":
self._create_texture_node(path, sg_publish_data)
if name == "udim_texture_node":
self._create_udim_texture_node(path, sg_publish_data)
if name == "image_plane":
self._create_image_plane(path, sg_publish_data)
def Rebuild(self):
try:
libraryPath = '/dsPipe/Library/asset/3D/Bricks/mBricks/'
texturePath = '/dsPipe/Library/asset/3D/Bricks/LEGO_Colors/'
#libraryPath = 'C:\Users\Per\Documents\Test'
#print 'libraryPath='+libraryPath
try:
name = cmds.ls('m*',long=True,type='transform',geometry=False,dependencyNodes=False,dagObjects=False,shapes=False,textures=False,materials=False)
for each in name:
#list()
shapeList=[]
#print 'each='+each
meshName = each.split('|')[-1]
#print 'meshName='+str(meshName)
shapeName = cmds.listRelatives(each,type='shape')[-1]
shapeList = cmds.ls(shapeName, long=True)[0]
#print 'shapeName='+shapeName
#print 'shapeList='+shapeList
#cmds.select('|Model|Wagon|Gandalf|Hip|Body|m3814_MINI_UPPER_PART_0|m3814_MINI_UPPER_PART_Shape0.LEGO_materialID')
materialID = 0
try:
IDPath = shapeList+'.LEGO_materialID'
#print 'IDPath='+IDPath
materialID = cmds.getAttr(IDPath)
#print 'materialID=',materialID
except:
pass
removeLong = meshName.split('|')[-1]
#print 'removeLong='+removeLong
nName = removeLong.split('_')[0]
#print 'nName='+nName
#filePath = libraryPath +"/" + nName +'_LOD2.ma'
filePath = libraryPath + nName + '/Dev/Maya/' + nName +'_Cl.ma'
#print 'file dont exist = '+filePath
if not os.path.exists(filePath):
print 'Not cleaned = '+filePath
pass
else:
#print 'filePath='+filePath
importedFile = cmds.file( filePath, r=True, type='mayaAscii',returnNewNodes=True, namespace='LOD')
last = importedFile[-1]
#print 'last='+last
lastSplit = last.split('|')[1]
shadingAssign = last.split('|')[2]
#print 'lastSplit='+lastSplit
if materialID == 0:
shadingGrp = cmds.listConnections(shapeList, type="shadingEngine")[0]
#print 'shadingGrp='+shadingGrp
cmds.sets(shadingAssign, forceElement = shadingGrp)
else:
### It looks at the materialID fetches that texture and assigns it to a Vray shader and assign it too the brick....
try:
shader = 'LegoS_'+str(materialID)
cmds.shadingNode( 'VRayMtl' , asShader=True, name=shader)
texturePath = '/dsPipe/Library/Asset/Bricks/LEGO_Colors/'+str(materialID)+'.png'
inTexture = 'color_'+str(materialID)
outTexture = 'place2dTexture_color_'+str(materialID)
cmds.shadingNode('file',name = inTexture, asTexture=True);
cmds.shadingNode('place2dTexture',name = outTexture, asUtility = True)
cmds.connectAttr(outTexture+'.outUV', inTexture+'.uvCoord', f=True)
cmds.connectAttr(outTexture+'.outUvFilterSize', inTexture+'.uvFilterSize', f=True)
cmds.connectAttr(outTexture+'.coverage', inTexture+'.coverage', f=True)
cmds.connectAttr(outTexture+'.translateFrame', inTexture+'.translateFrame', f=True)
cmds.connectAttr(outTexture+'.rotateFrame', inTexture+'.rotateFrame', f=True)
cmds.connectAttr(outTexture+'.mirrorU', inTexture+'.mirrorU', f=True)
cmds.connectAttr(outTexture+'.mirrorV', inTexture+'.mirrorV', f=True)
cmds.connectAttr(outTexture+'.stagger', inTexture+'.stagger', f=True)
cmds.connectAttr(outTexture+'.wrapU', inTexture+'.wrapU', f=True)
cmds.connectAttr(outTexture+'.wrapV', inTexture+'.wrapV', f=True)
cmds.connectAttr(outTexture+'.repeatUV', inTexture+'.repeatUV', f=True)
cmds.connectAttr(outTexture+'.vertexUvOne', inTexture+'.vertexUvOne', f=True)
cmds.connectAttr(outTexture+'.vertexUvTwo', inTexture+'.vertexUvTwo', f=True)
cmds.connectAttr(outTexture+'.vertexUvThree', inTexture+'.vertexUvThree', f=True)
cmds.connectAttr(outTexture+'.vertexCameraOne', inTexture+'.vertexCameraOne', f=True)
cmds.connectAttr(outTexture+'.noiseUV', inTexture+'.noiseUV', f=True)
cmds.connectAttr(outTexture+'.offset', inTexture+'.offset', f=True)
cmds.connectAttr(outTexture+'.rotateUV', inTexture+'.rotateUV', f=True)
cmds.setAttr(inTexture+'.fileTextureName',str(texturePath),type = "string" )
cmds.defaultNavigation(destination=shader, source=inTexture, connectToExisting=True)
cmds.setAttr(inTexture+'.filterType', 0)
cmds.setAttr(shader+'.brdfType', 0)
cmds.setAttr(shader+'.traceReflections', 0)
cmds.setAttr(shader+'.hilightGlossinessLock', 0)
cmds.setAttr(shader+'.reflectionColor',0.2, 0.2, 0.2, type="double3" )
cmds.setAttr(shader+'.hilightGlossiness',0.4)
cmds.setAttr(shader+'.reflectionsMaxDepth', 1)
cmds.setAttr(shader+'.refractionsMaxDepth', 1)
except:
print 'fail creating shadingNode'
pass
try:
cmds.sets(name='LegoS_'+str(materialID)+'SG', empty = True,renderable = True,noSurfaceShader = True)
except:
print 'fail creating SG'
pass
try:
cmds.connectAttr('LegoS_'+str(materialID)+'.outColor', 'LegoS_'+str(materialID)+'SG.surfaceShader',f = True)
except:
print 'fail connecting'
pass
try:
cmds.sets(shadingAssign, forceElement = 'LegoS_'+str(materialID)+'SG')
except:
print 'fail connecting mesh to shader'
pass
### Parents back to the groupe it was from...
cmds.parent( lastSplit, cmds.pickWalk( each, direction='up' ))
### Copys location and so on..
cmds.copyAttr(each ,lastSplit ,inConnections=True,values=True)
### Deletes the old brick...
cmds.delete(each)
except Exception as e:
print 'ERROR:', e
print 'Fail sort names'
pass
except Exception as e:
print 'ERROR:', e
print 'fail'
pass
def shaderSetup():
splashShader = cmds.shadingNode("lambert",
asShader=True,
name="mainSplashDisc_Shader")
splashShaderEngine = "mainSplashDisc_ShaderSG"
splashTexture = cmds.shadingNode("file",
asTexture=True,
name="mainSplashDisc_Texture")
splash_P2DT = cmds.createNode("place2dTexture", name="mainSplashDisc_P2DT")
cmds.connectAttr(splash_P2DT + ".coverage",
splashTexture + ".coverage",
force=True)
cmds.connectAttr(splash_P2DT + ".translateFrame",
splashTexture + ".translateFrame",
force=True)
cmds.connectAttr(splash_P2DT + ".rotateFrame",
splashTexture + ".rotateFrame",
force=True)
cmds.connectAttr(splash_P2DT + ".mirrorU",
splashTexture + ".mirrorU",
force=True)
cmds.connectAttr(splash_P2DT + ".mirrorV",
splashTexture + ".mirrorV",
force=True)
cmds.connectAttr(splash_P2DT + ".stagger",
splashTexture + ".stagger",
force=True)
cmds.connectAttr(splash_P2DT + ".wrapU",
splashTexture + ".wrapU",
force=True)
cmds.connectAttr(splash_P2DT + ".wrapV",
splashTexture + ".wrapV",
force=True)
cmds.connectAttr(splash_P2DT + ".repeatUV",
splashTexture + ".repeatUV",
force=True)
cmds.connectAttr(splash_P2DT + ".offset",
splashTexture + ".offset",
force=True)
cmds.connectAttr(splash_P2DT + ".rotateUV",
splashTexture + ".rotateUV",
force=True)
cmds.connectAttr(splash_P2DT + ".noiseUV",
splashTexture + ".noiseUV",
force=True)
cmds.connectAttr(splash_P2DT + ".vertexUvOne",
splashTexture + ".vertexUvOne",
force=True)
cmds.connectAttr(splash_P2DT + ".vertexUvTwo",
splashTexture + ".vertexUvTwo",
force=True)
cmds.connectAttr(splash_P2DT + ".vertexUvThree",
splashTexture + ".vertexUvThree",
force=True)
cmds.connectAttr(splash_P2DT + ".vertexCameraOne",
splashTexture + ".vertexCameraOne",
force=True)
cmds.connectAttr(splash_P2DT + ".outUV", splashTexture + ".uv", force=True)
cmds.connectAttr(splash_P2DT + ".outUvFilterSize",
splashTexture + ".uvFilterSize",
force=True)
cmds.connectAttr(splashTexture + ".outColor",
splashShader + ".color",
force=True)
cmds.connectAttr(splashTexture + ".outTransparency",
splashShader + ".transparency",
force=True)
cmds.setAttr("%s.fileTextureName" % splashTexture,
"I:/lsapipeline/fx/sprites/water/water_gloop_3.tga",
type="string")
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name=splashShaderEngine)
cmds.defaultNavigation(connectToExisting=True,
source=splashShader,
destination=splashShaderEngine)
# cmds.connectAttr(splashShader + ".outColor", splashShaderEngine + ".surfaceShader")
# splashShaderEngine = cmds.createNode("shadingEngine", name="%s_SG"%projectName)
# cmds.defaultNavigation(connectToExisting=True, source=splashShader, destination=splashShaderEngine)
# cmds.sets(edit=True, forceElement=splashShaderEngine)
# cmds.connectAttr(splashShaderEngine + ".message", "lightLinker1.shadowLink[3].shadowObject", force = True)
# cmds.connectAttr(splashShaderEngine + ".message", "lightLinker1.link[3].object", force = True)
# cmds.connectAttr(splashShaderEngine + ".partition","renderPartition.sets[3]", force = True)
# cmds.connectAttr(splashShader + ".outColor", splashShaderEngine + ".surfaceShader", force = True)
#
# cmds.connectAttr(objectname + ".instObjGroups[0]", splashShaderEngine + ".dagSetMembers[0]", force = True)
#
return
# def _cleanupNURBSPlane(NURBSPlane = '', boatName = ''):
# """
# Cleans the scene up after the NURBSPLane setup
# """
# ##Cleanup
# if not cmds.objExists('Shot_FX_hrc'):
# cmds.group(n = 'Shot_FX_hrc', em = True)
#
# cmds.parent(NURBSPlane[0], 'Shot_FX_hrc')
# cmds.setAttr('%s.visibility' % NURBSPlane[0], 0)
# if cmds.objExists('%s:world_ctrl' % boatName):
# cmds.parentConstraint('%s:cog_ctrl' % boatName, NURBSPlane[0], mo = False, skipRotate = ['x', 'y' , 'z'], skipTranslate = ['y'])
# else:
# cmds.warning('Cannot find %s. The rig needs to have the correct naming for the world_ctrl!' % '%s:world_ctrl' % boatName)
# def buildOceanNurbsPreviewPlane(xRes = 20, zRes = 20, size = 8, oceanShader = '', boatName = ''):
# """
# Creates NURBS plane that moves along with ocean so we can intersect this with our boatName to create the emitter curves
# """
# if cmds.objExists('%s_NurbsIntersect_geo' % boatName):
# cmds.warning('Skipping %s_NurbsIntersect. Already exists in the scene!' % boatName)
# else:
# NURBSPlane = cmds.nurbsPlane( width=1,lengthRatio = 1,degree = 1, patchesU=xRes, patchesV=zRes, axis = (0,1,0) , constructionHistory = 0, name = '%s_NurbsIntersect_geo' % boatName)
#
# ## Now set the attrs of the NURBSPlane
# cmds.setAttr ( "%s.rotate" % NURBSPlane[0], lock= True)
# cmds.setAttr ("%s.scaleY" % NURBSPlane[0], lock= True)
# cmds.setAttr ("%s.scaleX" % NURBSPlane[0], size)
# cmds.setAttr ("%s.scaleZ" % NURBSPlane[0], size)
# cmds.setAttr ( "%s.translateY" % NURBSPlane[0] , lock= True)
# #cmds.setAttr (NURBSPlane[0] + ".visibility",0)
# cmds.setAttr ("%s.primaryVisibility" % NURBSPlane[0],0)
# cmds.setAttr ("%s.visibleInReflections" % NURBSPlane[0],0)
# cmds.setAttr ("%s.visibleInRefractions" % NURBSPlane[0],0)
# ## Cleanup the build
# _cleanupNURBSPlane(NURBSPlane, boatName)
# ## Build the expression
# _buildNURBSPlaneExpression(NURBSPlane, xRes, zRes, oceanShader)
#
# def _buildNURBSPlaneExpression(NURBSPlane, xRes, zRes, oceanShader):
# """
# Function to setup the expression that hooks the nurbsPlane to the ocean
# @param NURBSPlane: The build of the nurbsPlane, this build command should have returned a list. Due to refactoring we're just handling this list instead of accepting the actual name
# @type NURBSPlane: List
# """
# ## Now build the expression to connect the cv's of the NURBSPlane to the ocean
# xSize = xRes+1
# zSize = zRes+1
#
# expStringList = ['float $u, $v;\n float $minx = %s.scaleX * -0.5 + %s.translateX;\n' % (NURBSPlane[0], NURBSPlane[0]),
# 'float $maxx = %s.scaleX * 0.5 + %s.translateX;\n' % (NURBSPlane[0], NURBSPlane[0]),
# 'float $minz = %s.scaleZ * -0.5 + %s.translateZ;\n' % (NURBSPlane[0], NURBSPlane[0]),
# 'float $maxz = %s.scaleZ * 0.5 + %s.translateZ;\n' % (NURBSPlane[0], NURBSPlane[0]),
# 'float $disp[] = `colorAtPoint -o A -su %s -sv %s -mu $minx -mv $minz -xu $maxx -xv $maxz %s`;\n' % (str(xSize), str(zSize), oceanShader)
# ]
# expString = utils.processExpressionString(expStringList)
# #unfold loop and use output connections
# i=0
# for x in range(xSize):
# planeX = x * zSize
# for z in range(zSize):
# planeZ= zSize - z - 1
# addTo = "%s.cv[%s].yv = $disp[%s];\n" % (NURBSPlane[0], str(planeX +planeZ), str(i))
# expString += addTo
# #increment by 1
# i=i+1
#
# ## Check if the expression already exists in the scene, if so delete it
# utils.checkExpressionExists( '%s_IntersectionPlane' % NURBSPlane[0])
#
# ## Build new expression
# cmds.expression(n = '%s_IntersectionPlane' % '_'.join(NURBSPlane[0].split(':')), string = expString)
def generateConnectedTestScene(self,
shadingNodeAttributes,
ignoreColorSpaceFileRules=False):
"""
Generate test scene containing a UsdPreviewSurface with bindings to other shading nodes
exports correctly.
:type shadingNodeAttributes: List[Tuple[str, Any]]
:type ignoreColorSpaceFileRules: bool
"""
maya_file = os.path.join(self.temp_dir,
"UsdExportConnectedUsdPreviewSurfaceTest.ma")
cmds.file(force=True, new=True)
mesh = "ConnectedMaterialSphere"
cmds.polySphere(name=mesh,
subdivisionsX=20,
subdivisionsY=20,
radius=1)
cmds.group(mesh, name="Geom")
cmds.group("Geom", name="UsdPreviewSurfaceExportTest")
shading_node = "usdPreviewSurface_Connected"
cmds.shadingNode("usdPreviewSurface", name=shading_node, asShader=True)
for attr in shadingNodeAttributes:
if isinstance(attr[1], Gf.Vec3f):
cmds.setAttr(
"%s.%s" % (shading_node, attr[0]),
attr[1][0],
attr[1][1],
attr[1][2],
)
else:
cmds.setAttr("%s.%s" % (shading_node, attr[0]), attr[1])
texture_dir = os.path.join(self.input_dir,
"UsdExportUsdPreviewSurfaceTest")
cmds.defaultNavigation(createNew=True,
destination="%s.diffuseColor" % shading_node)
file_node = cmds.shadingNode("file",
asTexture=True,
name="Brazilian_Rosewood_Texture")
cmds.setAttr(file_node + ".ignoreColorSpaceFileRules",
ignoreColorSpaceFileRules)
cmds.setAttr(
file_node + ".fileTextureName",
os.path.join(texture_dir, "Brazilian_rosewood_pxr128.png"),
type="string",
)
cmds.connectAttr("%s.outColor" % file_node,
"%s.diffuseColor" % shading_node,
force=True)
# This file node should have stayed "sRGB":
if not ignoreColorSpaceFileRules:
self.assertEqual(cmds.getAttr(file_node + ".colorSpace"), "sRGB")
cmds.defaultNavigation(createNew=True,
destination="%s.roughness" % shading_node)
file_node = cmds.shadingNode("file",
asTexture=True,
name="Brazilian_Rosewood_Bump_Texture")
cmds.setAttr(file_node + ".ignoreColorSpaceFileRules",
ignoreColorSpaceFileRules)
cmds.setAttr(
file_node + ".fileTextureName",
os.path.join(texture_dir, "Brazilian_rosewood_pxr128_bmp.png"),
type="string",
)
cmds.connectAttr("%s.outColorR" % file_node,
"%s.roughness" % shading_node,
force=True)
# The monochrome file node should have been set to "Raw" automatically:
if not ignoreColorSpaceFileRules:
self.assertEqual(cmds.getAttr(file_node + ".colorSpace"), "Raw")
cmds.defaultNavigation(createNew=True,
destination="%s.clearcoatRoughness" %
shading_node)
cmds.connectAttr(
"%s.outColorR" % file_node,
"%s.clearcoatRoughness" % shading_node,
force=True,
)
cmds.defaultNavigation(createNew=True,
destination="%s.normal" % shading_node)
file_node = cmds.shadingNode("file",
asTexture=True,
name="Brazilian_Rosewood_Normal_Texture")
cmds.setAttr(
file_node + ".fileTextureName",
os.path.join(texture_dir, "Brazilian_rosewood_pxr128_n.png"),
type="string",
)
cmds.connectAttr("%s.outColor" % file_node,
"%s.normal" % shading_node,
force=True)
# The file node should have been set to "NormalMap" automatically:
self.assertEqual(cmds.getAttr(file_node + ".colorSpace"), "Raw")
self.assertEqual(cmds.getAttr(file_node + ".colorGainR"), 2)
self.assertEqual(cmds.getAttr(file_node + ".colorGainG"), 2)
self.assertEqual(cmds.getAttr(file_node + ".colorGainB"), 2)
self.assertEqual(cmds.getAttr(file_node + ".colorOffsetR"), -1)
self.assertEqual(cmds.getAttr(file_node + ".colorOffsetG"), -1)
self.assertEqual(cmds.getAttr(file_node + ".colorOffsetB"), -1)
self.assertEqual(cmds.getAttr(file_node + ".alphaGain"), 1)
self.assertEqual(cmds.getAttr(file_node + ".alphaOffset"), 0)
shading_engine = "%sSG" % shading_node
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name=shading_engine)
cmds.connectAttr(
"%s.outColor" % shading_node,
"%s.surfaceShader" % shading_engine,
force=True,
)
cmds.sets(mesh, edit=True, forceElement=shading_engine)
cmds.file(rename=maya_file)
cmds.file(save=True, type="mayaAscii")
self.assertTrue(os.path.exists(maya_file))
return maya_file
def addImageAsColor():
cmds.shadingNode('file',
asTexture=True,
isColorManaged=True,
name=color_file_name)
cmds.shadingNode('place2dTexture',
asUtility=True,
name=place2dTexture_name)
cmds.connectAttr(place2dTexture_name + '.coverage',
color_file_name + '.coverage',
force=True)
cmds.connectAttr(place2dTexture_name + '.translateFrame',
color_file_name + '.translateFrame',
force=True)
cmds.connectAttr(place2dTexture_name + '.rotateFrame',
color_file_name + '.rotateFrame',
force=True)
cmds.connectAttr(place2dTexture_name + '.mirrorU',
color_file_name + '.mirrorU',
force=True)
cmds.connectAttr(place2dTexture_name + '.mirrorV',
color_file_name + '.mirrorV',
force=True)
cmds.connectAttr(place2dTexture_name + '.stagger',
color_file_name + '.stagger',
force=True)
cmds.connectAttr(place2dTexture_name + '.wrapU',
color_file_name + '.wrapU',
force=True)
cmds.connectAttr(place2dTexture_name + '.wrapV',
color_file_name + '.wrapV',
force=True)
cmds.connectAttr(place2dTexture_name + '.repeatUV',
color_file_name + '.repeatUV',
force=True)
cmds.connectAttr(place2dTexture_name + '.offset',
color_file_name + '.offset',
force=True)
cmds.connectAttr(place2dTexture_name + '.rotateUV',
color_file_name + '.rotateUV',
force=True)
cmds.connectAttr(place2dTexture_name + '.noiseUV',
color_file_name + '.noiseUV',
force=True)
cmds.connectAttr(place2dTexture_name + '.vertexUvOne',
color_file_name + '.vertexUvOne',
force=True)
cmds.connectAttr(place2dTexture_name + '.vertexUvTwo',
color_file_name + '.vertexUvTwo',
force=True)
cmds.connectAttr(place2dTexture_name + '.vertexUvThree',
color_file_name + '.vertexUvThree',
force=True)
cmds.connectAttr(place2dTexture_name + '.vertexCameraOne',
color_file_name + '.vertexCameraOne',
force=True)
cmds.connectAttr(place2dTexture_name + '.outUV',
color_file_name + '.uv',
force=True)
cmds.connectAttr(place2dTexture_name + '.outUvFilterSize',
color_file_name + '.uvFilterSize',
force=True)
cmds.defaultNavigation(force=True,
connectToExisting=True,
source=color_file_name,
destination=projection_name + '.image')
cmds.connectAttr(color_file_name + '.outColor',
projection_name + '.image',
force=True)
cmds.setAttr(color_file_name + '.fileTextureName',
front_color_path,
type="string")
def avShaderSetup(self, mesh, keepShaderValue, fdmUdimValue, xyzUdimValue,
FloatDisplacementFile, XYZDisplacementFile,
RenderEngineValue):
if keepShaderValue == "False":
if RenderEngineValue == "0":
shader = cmds.shadingNode("aiStandard",
name=mesh + "_aiStandard",
asShader=True)
else:
shader = cmds.shadingNode("VRayMtl",
name=mesh + "_VRayMtl",
asShader=True)
shading_group = cmds.sets(name=mesh + "SG",
renderable=True,
noSurfaceShader=True,
empty=True)
cmds.connectAttr('%s.outColor' % shader,
'%s.surfaceShader' % shading_group)
else:
shape = cmds.listRelatives(mesh, shapes=True)
shading_group = cmds.listConnections(shape, type='shadingEngine')
floatUv = cmds.shadingNode("place2dTexture", asUtility=True)
floatFile_node = cmds.shadingNode("file",
name="float_displacement_File",
asTexture=True,
isColorManaged=True)
cmds.setAttr(floatFile_node + ".filterType", 3)
if not FloatDisplacementFile == "none":
cmds.setAttr(floatFile_node + ".fileTextureName",
FloatDisplacementFile,
type="string")
cmds.setAttr(floatFile_node + ".colorSpace", "Raw", type="string")
cmds.setAttr(floatFile_node + ".defaultColor",
0.0,
0.0,
0.0,
type="double3")
cmds.defaultNavigation(connectToExisting=True,
source=floatUv,
destination=floatFile_node)
XYZuv = cmds.shadingNode("place2dTexture", asUtility=True)
XYZFile_node = cmds.shadingNode("file",
name="XYZ_displacement_File",
asTexture=True,
isColorManaged=True)
cmds.setAttr(XYZFile_node + ".filterType", 3)
cmds.setAttr(XYZFile_node + ".fileTextureName",
XYZDisplacementFile,
type="string")
cmds.setAttr(XYZFile_node + ".colorSpace", "Raw", type="string")
XYZLayeredTexture = cmds.shadingNode("layeredTexture",
name="It_XYZ_displacement",
asTexture=True,
isColorManaged=True)
XYZLayerBlendR = cmds.shadingNode("blendColors",
name="XYZ_R_intensity",
asUtility=True)
XYZLayerBlendG = cmds.shadingNode("blendColors",
name="XYZ_G_intensity",
asUtility=True)
XYZLayerBlendB = cmds.shadingNode("blendColors",
name="XYZ_B_intensity",
asUtility=True)
cmds.setAttr(XYZLayerBlendR + ".color2", 0.0, 0.0, 0.0, type="double3")
cmds.setAttr(XYZLayerBlendG + ".color2", 0.0, 0.0, 0.0, type="double3")
cmds.setAttr(XYZLayerBlendB + ".color2", 0.0, 0.0, 0.0, type="double3")
cmds.setAttr(XYZLayerBlendR + ".blender", 0)
cmds.setAttr(XYZLayerBlendG + ".blender", 0)
cmds.setAttr(XYZLayerBlendB + ".blender", 0)
cmds.defaultNavigation(connectToExisting=True,
source=XYZuv,
destination=XYZFile_node)
cmds.connectAttr('%s.outColor' % XYZFile_node,
'%s.inputs[1].color' % XYZLayeredTexture)
cmds.connectAttr('%s.outColor' % XYZFile_node,
'%s.inputs[0].color' % XYZLayeredTexture)
cmds.disconnectAttr('%s.outColor' % XYZFile_node,
'%s.inputs[0].color' % XYZLayeredTexture)
cmds.setAttr(XYZLayeredTexture + ".inputs[0].color",
0.5,
0.5,
0.5,
type="double3")
cmds.setAttr(XYZLayeredTexture + ".inputs[0].blendMode", 5)
cmds.setAttr(XYZLayeredTexture + ".inputs[1].blendMode", 4)
cmds.connectAttr('%s.outColorR' % XYZLayeredTexture,
'%s.color1R' % XYZLayerBlendR)
cmds.connectAttr('%s.outColorR' % XYZLayeredTexture,
'%s.color1G' % XYZLayerBlendR)
cmds.connectAttr('%s.outColorR' % XYZLayeredTexture,
'%s.color1B' % XYZLayerBlendR)
cmds.connectAttr('%s.outColorG' % XYZLayeredTexture,
'%s.color1R' % XYZLayerBlendG)
cmds.connectAttr('%s.outColorG' % XYZLayeredTexture,
'%s.color1G' % XYZLayerBlendG)
cmds.connectAttr('%s.outColorG' % XYZLayeredTexture,
'%s.color1B' % XYZLayerBlendG)
cmds.connectAttr('%s.outColorB' % XYZLayeredTexture,
'%s.color1R' % XYZLayerBlendB)
cmds.connectAttr('%s.outColorB' % XYZLayeredTexture,
'%s.color1G' % XYZLayerBlendB)
cmds.connectAttr('%s.outColorB' % XYZLayeredTexture,
'%s.color1B' % XYZLayerBlendB)
MapsMerge = cmds.shadingNode("plusMinusAverage",
name="merger",
asUtility=True)
cmds.connectAttr('%s.output' % XYZLayerBlendR,
'%s.input3D[0]' % MapsMerge)
cmds.connectAttr('%s.output' % XYZLayerBlendG,
'%s.input3D[1]' % MapsMerge)
cmds.connectAttr('%s.output' % XYZLayerBlendB,
'%s.input3D[2]' % MapsMerge)
cmds.connectAttr('%s.outColorR' % floatFile_node,
'%s.input3D[3].input3Dx' % MapsMerge)
cmds.connectAttr('%s.outColorR' % floatFile_node,
'%s.input3D[3].input3Dy' % MapsMerge)
cmds.connectAttr('%s.outColorR' % floatFile_node,
'%s.input3D[3].input3Dz' % MapsMerge)
luminance = cmds.shadingNode("luminance",
name="ConvertToLuminance",
asUtility=True)
cmds.connectAttr('%s.output3D' % MapsMerge, '%s.value' % luminance)
displacement_shader = cmds.shadingNode("displacementShader",
name=mesh +
"_displacementShader",
asShader=True)
cmds.connectAttr('%s.outValue' % luminance,
'%s.displacement' % displacement_shader)
if fdmUdimValue == "True":
cmds.setAttr(floatFile_node + ".uvTilingMode", 3)
cmds.setAttr(floatFile_node + ".uvTileProxyQuality", 4)
if xyzUdimValue == "True":
cmds.setAttr(XYZFile_node + ".uvTilingMode", 3)
cmds.setAttr(XYZFile_node + ".uvTileProxyQuality", 4)
if keepShaderValue == "False":
cmds.connectAttr('%s.displacement' % displacement_shader,
'%s.displacementShader' % shading_group,
force=True)
else:
cmds.connectAttr('%s.displacement' % displacement_shader,
'%s.displacementShader' % str(shading_group[0]),
force=True)
cmds.select(cmds.listRelatives(mesh, shapes=True))
if keepShaderValue == "False":
cmds.hyperShade(assign=shading_group)
## creation des numéros de plan pour la cam
shotList2 = ("011", "012", "013", "014", "021", "056", "057", "210", "223",
"254", "255", "257", "266", "269", "270", "273")
shotList = ("060", "061", "063", "064", "076", "085", "102", "134", "142",
"301")
shotLen = len(shotList)
mc.playbackOptions(maxTime=shotLen - 1, animationEndTime=shotLen - 1)
i = -1
shaderName = "constBlanc"
shadingGroupName = shaderName + 'SG'
mc.shadingNode("surfaceShader", asShader=True, name=shaderName)
mc.setAttr(shaderName + ".outColor", 1, 1, 1, type="double3")
mc.sets(renderable=True, empty=1, noSurfaceShader=True, name=shadingGroupName)
mc.defaultNavigation(source=shaderName,
destination=shadingGroupName,
connectToExisting=1)
for item in shotList:
shotCurveName = "shotCurve" + item
shotCurve = mc.textCurves(name=shotCurveName,
ch=0,
f="Arial",
t="sc" + item)
shotNumberName = "sc" + item
shotNumber = mc.planarSrf(name=shotNumberName, polygon=3)
##mc.setAttr(shotNumberName + ".scale", 0.08, 0.08, 0.08, type="double3")
mc.sets("sc" + item, forceElement=shadingGroupName, e=1)
mc.delete(shotCurveName + "Shape")
mc.setKeyframe(value=0, t=i, attribute="visibility")
i += 1
def shaderSetup():
splashShader = cmds.shadingNode("lambert",asShader=True, name="mainSplashDisc_Shader")
splashShaderEngine = "mainSplashDisc_ShaderSG"
splashTexture = cmds.shadingNode("file", asTexture = True, name="mainSplashDisc_Texture")
splash_P2DT = cmds.createNode("place2dTexture", name="mainSplashDisc_P2DT")
cmds.connectAttr(splash_P2DT + ".coverage", splashTexture + ".coverage", force = True)
cmds.connectAttr(splash_P2DT + ".translateFrame", splashTexture + ".translateFrame", force = True)
cmds.connectAttr(splash_P2DT + ".rotateFrame", splashTexture + ".rotateFrame", force = True)
cmds.connectAttr(splash_P2DT + ".mirrorU", splashTexture + ".mirrorU", force = True)
cmds.connectAttr(splash_P2DT + ".mirrorV", splashTexture + ".mirrorV", force = True)
cmds.connectAttr(splash_P2DT + ".stagger", splashTexture + ".stagger", force = True)
cmds.connectAttr(splash_P2DT + ".wrapU", splashTexture + ".wrapU", force = True)
cmds.connectAttr(splash_P2DT + ".wrapV", splashTexture + ".wrapV", force = True)
cmds.connectAttr(splash_P2DT + ".repeatUV", splashTexture + ".repeatUV", force = True)
cmds.connectAttr(splash_P2DT + ".offset", splashTexture + ".offset", force = True)
cmds.connectAttr(splash_P2DT + ".rotateUV", splashTexture + ".rotateUV", force = True)
cmds.connectAttr(splash_P2DT + ".noiseUV", splashTexture + ".noiseUV", force = True)
cmds.connectAttr(splash_P2DT + ".vertexUvOne", splashTexture + ".vertexUvOne", force = True)
cmds.connectAttr(splash_P2DT + ".vertexUvTwo", splashTexture + ".vertexUvTwo", force = True)
cmds.connectAttr(splash_P2DT + ".vertexUvThree", splashTexture + ".vertexUvThree", force = True)
cmds.connectAttr(splash_P2DT + ".vertexCameraOne", splashTexture + ".vertexCameraOne", force = True)
cmds.connectAttr(splash_P2DT + ".outUV", splashTexture + ".uv", force = True)
cmds.connectAttr(splash_P2DT + ".outUvFilterSize", splashTexture + ".uvFilterSize", force = True)
cmds.connectAttr(splashTexture + ".outColor", splashShader + ".color", force = True)
cmds.connectAttr(splashTexture + ".outTransparency", splashShader + ".transparency", force = True)
cmds.setAttr("%s.fileTextureName"%splashTexture,"I:/lsapipeline/fx/sprites/water/water_gloop_3.tga",type="string")
cmds.sets(renderable=True,noSurfaceShader=True,empty=True,name=splashShaderEngine)
cmds.defaultNavigation (connectToExisting=True, source=splashShader, destination=splashShaderEngine)
# cmds.connectAttr(splashShader + ".outColor", splashShaderEngine + ".surfaceShader")
# splashShaderEngine = cmds.createNode("shadingEngine", name="%s_SG"%projectName)
# cmds.defaultNavigation(connectToExisting=True, source=splashShader, destination=splashShaderEngine)
# cmds.sets(edit=True, forceElement=splashShaderEngine)
# cmds.connectAttr(splashShaderEngine + ".message", "lightLinker1.shadowLink[3].shadowObject", force = True)
# cmds.connectAttr(splashShaderEngine + ".message", "lightLinker1.link[3].object", force = True)
# cmds.connectAttr(splashShaderEngine + ".partition","renderPartition.sets[3]", force = True)
# cmds.connectAttr(splashShader + ".outColor", splashShaderEngine + ".surfaceShader", force = True)
#
# cmds.connectAttr(objectname + ".instObjGroups[0]", splashShaderEngine + ".dagSetMembers[0]", force = True)
#
return
# def _cleanupNURBSPlane(NURBSPlane = '', boatName = ''):
# """
# Cleans the scene up after the NURBSPLane setup
# """
# ##Cleanup
# if not cmds.objExists('Shot_FX_hrc'):
# cmds.group(n = 'Shot_FX_hrc', em = True)
#
# cmds.parent(NURBSPlane[0], 'Shot_FX_hrc')
# cmds.setAttr('%s.visibility' % NURBSPlane[0], 0)
# if cmds.objExists('%s:world_ctrl' % boatName):
# cmds.parentConstraint('%s:cog_ctrl' % boatName, NURBSPlane[0], mo = False, skipRotate = ['x', 'y' , 'z'], skipTranslate = ['y'])
# else:
# cmds.warning('Cannot find %s. The rig needs to have the correct naming for the world_ctrl!' % '%s:world_ctrl' % boatName)
# def buildOceanNurbsPreviewPlane(xRes = 20, zRes = 20, size = 8, oceanShader = '', boatName = ''):
# """
# Creates NURBS plane that moves along with ocean so we can intersect this with our boatName to create the emitter curves
# """
# if cmds.objExists('%s_NurbsIntersect_geo' % boatName):
# cmds.warning('Skipping %s_NurbsIntersect. Already exists in the scene!' % boatName)
# else:
# NURBSPlane = cmds.nurbsPlane( width=1,lengthRatio = 1,degree = 1, patchesU=xRes, patchesV=zRes, axis = (0,1,0) , constructionHistory = 0, name = '%s_NurbsIntersect_geo' % boatName)
#
# ## Now set the attrs of the NURBSPlane
# cmds.setAttr ( "%s.rotate" % NURBSPlane[0], lock= True)
# cmds.setAttr ("%s.scaleY" % NURBSPlane[0], lock= True)
# cmds.setAttr ("%s.scaleX" % NURBSPlane[0], size)
# cmds.setAttr ("%s.scaleZ" % NURBSPlane[0], size)
# cmds.setAttr ( "%s.translateY" % NURBSPlane[0] , lock= True)
# #cmds.setAttr (NURBSPlane[0] + ".visibility",0)
# cmds.setAttr ("%s.primaryVisibility" % NURBSPlane[0],0)
# cmds.setAttr ("%s.visibleInReflections" % NURBSPlane[0],0)
# cmds.setAttr ("%s.visibleInRefractions" % NURBSPlane[0],0)
# ## Cleanup the build
# _cleanupNURBSPlane(NURBSPlane, boatName)
# ## Build the expression
# _buildNURBSPlaneExpression(NURBSPlane, xRes, zRes, oceanShader)
#
# def _buildNURBSPlaneExpression(NURBSPlane, xRes, zRes, oceanShader):
# """
# Function to setup the expression that hooks the nurbsPlane to the ocean
# @param NURBSPlane: The build of the nurbsPlane, this build command should have returned a list. Due to refactoring we're just handling this list instead of accepting the actual name
# @type NURBSPlane: List
# """
# ## Now build the expression to connect the cv's of the NURBSPlane to the ocean
# xSize = xRes+1
# zSize = zRes+1
#
# expStringList = ['float $u, $v;\n float $minx = %s.scaleX * -0.5 + %s.translateX;\n' % (NURBSPlane[0], NURBSPlane[0]),
# 'float $maxx = %s.scaleX * 0.5 + %s.translateX;\n' % (NURBSPlane[0], NURBSPlane[0]),
# 'float $minz = %s.scaleZ * -0.5 + %s.translateZ;\n' % (NURBSPlane[0], NURBSPlane[0]),
# 'float $maxz = %s.scaleZ * 0.5 + %s.translateZ;\n' % (NURBSPlane[0], NURBSPlane[0]),
# 'float $disp[] = `colorAtPoint -o A -su %s -sv %s -mu $minx -mv $minz -xu $maxx -xv $maxz %s`;\n' % (str(xSize), str(zSize), oceanShader)
# ]
# expString = utils.processExpressionString(expStringList)
# #unfold loop and use output connections
# i=0
# for x in range(xSize):
# planeX = x * zSize
# for z in range(zSize):
# planeZ= zSize - z - 1
# addTo = "%s.cv[%s].yv = $disp[%s];\n" % (NURBSPlane[0], str(planeX +planeZ), str(i))
# expString += addTo
# #increment by 1
# i=i+1
#
# ## Check if the expression already exists in the scene, if so delete it
# utils.checkExpressionExists( '%s_IntersectionPlane' % NURBSPlane[0])
#
# ## Build new expression
# cmds.expression(n = '%s_IntersectionPlane' % '_'.join(NURBSPlane[0].split(':')), string = expString)
def vrayShaderSetup(self, mesh, keepShaderValue, udimValue,
DisplacementFile):
if keepShaderValue == "False":
shader = cmds.shadingNode("VRayMtl",
name=mesh + "_VRayMtl",
asShader=True)
shading_group = cmds.sets(name=mesh + "SG",
renderable=True,
noSurfaceShader=True,
empty=True)
cmds.connectAttr('%s.outColor' % shader,
'%s.surfaceShader' % shading_group)
else:
shape = cmds.listRelatives(mesh, shapes=True)
shading_group = cmds.listConnections(shape, type='shadingEngine')
displacement_shader = cmds.shadingNode("displacementShader",
name=mesh +
"_displacementShader",
asShader=True)
file_node = cmds.shadingNode("file",
name=mesh + "_displacement_File",
asTexture=True,
isColorManaged=True)
uv = cmds.shadingNode("place2dTexture", asUtility=True)
cmds.setAttr(file_node + ".filterType", 0)
cmds.setAttr(file_node + ".fileTextureName",
DisplacementFile,
type="string")
cmds.setAttr(file_node + ".colorSpace", "Raw", type="string")
if udimValue == "True":
cmds.setAttr(file_node + ".uvTilingMode", 3)
cmds.setAttr(file_node + ".uvTileProxyQuality", 4)
else:
cmds.addAttr(file_node,
longName='MaxLumaValue',
attributeType='double')
cmds.addAttr(file_node,
longName='MinLumaValue',
attributeType='double')
cmds.setAttr(file_node + ".MaxLumaValue", self.MaxLuma)
cmds.setAttr(file_node + ".MinLumaValue", self.MinLuma)
cmds.connectAttr('%s.MaxLumaValue' % file_node,
'%s.vrayDisplacementMaxValueR' % mesh,
force=True)
cmds.connectAttr('%s.MaxLumaValue' % file_node,
'%s.vrayDisplacementMaxValueG' % mesh,
force=True)
cmds.connectAttr('%s.MaxLumaValue' % file_node,
'%s.vrayDisplacementMaxValueB' % mesh,
force=True)
cmds.connectAttr('%s.MinLumaValue' % file_node,
'%s.vrayDisplacementMinValueR' % mesh,
force=True)
cmds.connectAttr('%s.MinLumaValue' % file_node,
'%s.vrayDisplacementMinValueG' % mesh,
force=True)
cmds.connectAttr('%s.MinLumaValue' % file_node,
'%s.vrayDisplacementMinValueB' % mesh,
force=True)
if keepShaderValue == "False":
cmds.connectAttr('%s.displacement' % displacement_shader,
'%s.displacementShader' % shading_group,
force=True)
else:
cmds.connectAttr('%s.displacement' % displacement_shader,
'%s.displacementShader' % str(shading_group[0]),
force=True)
cmds.defaultNavigation(connectToExisting=True,
source=uv,
destination=file_node,
quiet=True)
cmds.connectAttr('%s.outColorR' % file_node,
'%s.displacement' % displacement_shader)
cmds.select(cmds.listRelatives(mesh, shapes=True))
if keepShaderValue == "False":
cmds.hyperShade(assign=shading_group)
