def InitializeNode(smNode):
smNode.hideNodegraphGroupControls()
smNode.addInputPort('inputScene')
smNode.addInputPort('sharedDeps')
smNode.addOutputPort('originalScene')
# Merge node exists so that we have a valid scene even with
# nothing plugged in
mergeNode = NodegraphAPI.CreateNode('Merge', smNode)
mergeNode.addInputPort('i0').connect(smNode.getSendPort('inputScene'))
mergeDot = NodegraphAPI.CreateNode('Dot', smNode)
mergeDot.getInputPortByIndex(0).connect(mergeNode.getOutputPortByIndex(0))
attr = mergeDot.getAttributes()
attr['ns_basicDisplay'] = True
mergeDot.setAttributes(attr)
sceneDot1 = NodegraphAPI.CreateNode('Dot', smNode)
sceneDot1.getInputPortByIndex(0).connect(mergeDot.getOutputPortByIndex(0))
sceneDot1.getOutputPortByIndex(0).connect(
smNode.getReturnPort('originalScene'))
sharedDepDotNode = NodegraphAPI.CreateNode('Dot', smNode)
sharedDepDotNode.getInputPortByIndex(0).connect(
smNode.getSendPort('sharedDeps'))
NodegraphAPI.SetNodePosition(mergeNode, (-200, 100))
NodegraphAPI.SetNodePosition(mergeDot, (-200, 0))
NodegraphAPI.SetNodePosition(sharedDepDotNode, (100, 100))
NodegraphAPI.SetNodePosition(sceneDot1, (-350, RENDER_NODE_POSITION))
AddNodeReferenceParam(smNode, 'mergeNode', mergeNode)
AddNodeReferenceParam(smNode, 'mergeDot', mergeDot)
AddNodeReferenceParam(smNode, 'sharedDepDotNode', sharedDepDotNode)
def addLayer(self, aovName, filter='gaussian_filter'):
Utils.UndoStack.OpenGroup('Add "%s" AOV' % aovName)
try:
mergeGrp = SA.getMergeGrp(self)
returnPort = mergeGrp.getInputPortByIndex(0)
lastPort = returnPort.getConnectedPort(0)
lastNode = lastPort.getNode()
if '_MERGE_SETUP_' in lastNode.getName():
pos = (0, 0)
else:
pos = NodegraphAPI.GetNodePosition(lastNode)
aovLayer = self.__createAOVgroup(aovName, filter)
aovLayer.getInputPortByIndex(0).connect(lastPort)
aovLayer.getOutputPortByIndex(0).connect(returnPort)
NodegraphAPI.SetNodePosition(aovLayer, (pos[0], pos[1] - 50))
p1 = NodegraphAPI.GetNodePosition(aovLayer)
NodegraphAPI.SetNodePosition(mergeGrp, (p1[0], p1[1] - 80))
mergeRod = mergeGrp.getChildByIndex(2)
aovList = []
for aov in self.getChildren():
if '_MERGE_SETUP_' not in aov.getName():
name = str(aov.getName()).replace('_AOV_', '')
aovList.append(name)
aovList.append('primary')
names = ",".join(aovList)
mergeRod.getParameter(
'args.renderSettings.outputs.outputName.mergeOutputs.enable'
).setValue(1, 0)
mergeRod.getParameter(
'args.renderSettings.outputs.outputName.mergeOutputs.value'
).setValue(names, 0)
finally:
Utils.UndoStack.CloseGroup()
def __layoutOutputGroupContents(self, subGroup):
try:
from Katana import DrawingModule
except:
return
portName = subGroup.getOutputPortByIndex(0).getConnectedPort(0).getName()
merge = self.getMergeNodeForOutput(portName)
if not merge or merge.getType() != 'Merge':
return
nodes = []
widths = []
for port in merge.getInputPorts():
connectedPort = port.getConnectedPort(0)
if not connectedPort:
continue
node = connectedPort.getNode()
nodes.append(node)
bounds = DrawingModule.nodeWorld_getBoundsOfListOfNodes([node])
widths.append(bounds[2] - bounds[0])
NodegraphAPI.SetNodePosition(merge, (0, 0))
maxWidth = reduce(max, widths, 0) + 10
x = maxWidth * (len(widths) - 1) / -2.0
for node in nodes:
NodegraphAPI.SetNodePosition(node, (x, 100))
x += maxWidth
def addSampleBlock(root = NodegraphAPI.GetRootNode(),name = 'sample',task='Object'):
children = root.getChildren()
nbChildren = root.getNumChildren()
dotNode = None
for child in children:
if child.getType() == 'Dot':
dotNode = child
dotNodePos = NodegraphAPI.GetNodePosition(dotNode)
newSampleNode = createOpScriptSample(root,name,task)
paramUI(root,name,task)
#reorder the button to be the last param
newSampleParam = root.getParameters()
paramAddBlocker = newSampleParam.getChild('addSampleNode')
numberOfChild = newSampleParam.getNumChildren() -1
newSampleParam.reorderChild(paramAddBlocker,numberOfChild)
if nbChildren == 1:
sendGroup = root.getSendPort('in')
newSampleNode.getInputPort('i0').connect(sendGroup)
newSampleNode.getOutputPort('out').connect(dotNode.getInputPort('input'))
NodegraphAPI.SetNodePosition(dotNode,(dotNodePos[0],dotNodePos[1]-50))
else:
inputDotNodeProducer = dotNode.getInputSource('input',NodegraphAPI.GetCurrentGraphState())[0]
inputDotNodeProducer.connect(newSampleNode.getInputPort('i0'))
newSampleNode.getOutputPort('out').connect(dotNode.getInputPort('input'))
NodegraphAPI.SetNodePosition(newSampleNode,dotNodePos)
NodegraphAPI.SetNodePosition(dotNode,(dotNodePos[0],dotNodePos[1]-50))
def createRestParts(self, InData):
root = (InData[2][0] - 100, InData[2][1] - 100)
mergeNode = NodegraphAPI.CreateNode('Merge',
NodegraphAPI.GetRootNode())
NodegraphAPI.SetNodePosition(mergeNode, root)
mergeNode.addInputPort('i%d' % 0)
mergeNode.addInputPort('i%d' % 1)
mergeNode.getInputPort("i0").connect(InData[0].getOutputPort("out"))
mergeNode.getInputPort("i1").connect(InData[1].getOutputPort("out"))
upstreamDot = NodegraphAPI.CreateNode('Dot',
NodegraphAPI.GetRootNode())
downstreamDot = NodegraphAPI.CreateNode('Dot',
NodegraphAPI.GetRootNode())
NodegraphAPI.SetNodePosition(downstreamDot, (root[0] - 400, root[1]))
NodegraphAPI.SetNodePosition(upstreamDot,
(root[0] - 400, root[1] + 200))
downstreamDot.getInputPort("input").connect(
upstreamDot.getOutputPort("output"))
origNode = InData[3]
upstreamDot.getInputPort("input").connect(
origNode.getOutputPort("out"))
LookFileBakeNode = NodegraphAPI.CreateNode('LookFileBake',
NodegraphAPI.GetRootNode())
NodegraphAPI.SetNodePosition(LookFileBakeNode,
(root[0] - 200, root[1] - 100))
LookFileBakeNode.getInputPort("orig").connect(
downstreamDot.getOutputPort("output"))
LookFileBakeNode.getInputPort("default").connect(
mergeNode.getOutputPort("out"))
def connectInsideGroup(self,node_list,parent_node):
send_port =parent_node.getSendPort('in')
return_port = parent_node.getReturnPort('out')
if len(node_list) == 0:
send_port.connect(return_port)
elif len(node_list) == 1:
node_list[0].getOutputPortByIndex(0).connect(return_port)
node_list[0].getInputPortByIndex(0).connect(send_port)
elif len(node_list) == 2:
node_list[0].getInputPortByIndex(0).connect(send_port)
node_list[1].getOutputPortByIndex(0).connect(return_port)
node_list[0].getOutputPortByIndex(0).connect(node_list[1].getInputPortByIndex(0))
NodegraphAPI.SetNodePosition(node_list[0],(0,100))
elif len(node_list) > 2:
for index, node in enumerate(node_list[:-1]):
node.getOutputPortByIndex(0).connect(node_list[index+1].getInputPortByIndex(0))
NodegraphAPI.SetNodePosition(node,(0,index * -100))
node_list[0].getInputPortByIndex(0).connect(send_port)
node_list[-1].getOutputPortByIndex(0).connect(return_port)
NodegraphAPI.SetNodePosition(node_list[-1],(0,len(node_list) * -100))
#node= GafferThreeSequenceNode()
def build(self):
informationTuple = self.depthDigger()
materialNodeMap = informationTuple[0]
levelNodeMap = informationTuple[1]
nodeDataMap = informationTuple[2]
nodeMergeList = []
"""Reset node position"""
i = 0
for materialNodes in materialNodeMap:
i += 1
offsetX = (i-1)*500
#~ Create a group to hold some nodes in single material
groupNode = NodegraphAPI.CreateNode('Group', NodegraphAPI.GetRootNode())
groupName = "%s_%s"%(materialNodes,self.suffixGroup)
groupNode.setName(groupName)
NodegraphAPI.SetNodePosition(groupNode, (0 + offsetX, 0))
#~ Create a Network Material Node
networkMaterialNode = NodegraphAPI.CreateNode('NetworkMaterial', NodegraphAPI.GetRootNode())
NodegraphAPI.SetNodePosition(networkMaterialNode, (0 + offsetX, -250))
materialName = "%s_%s"%(materialNodes,self.suffixNetworkMaterial)
networkMaterialNode.getParameter('name').setValue(str(materialName), 0)
networkMaterialNode.addInputPort('arnoldSurface')
networkMaterialNode.addInputPort('arnoldBump')
nodeMergeList.append(networkMaterialNode)
tempLevelCount = {}
for node in materialNodeMap[materialNodes]:
for level in levelNodeMap:
if node in levelNodeMap[level]:
if tempLevelCount.has_key(level):
tempLevelCount[level] += 1
else:
tempLevelCount[level] = 1
for node in materialNodeMap[materialNodes]:
thisLevel = 1
for level in levelNodeMap:
if node in levelNodeMap[level]:
thisLevel = level
offsetY = (thisLevel - 1)*100
name = str(node)
offset = (offsetX,offsetY)
type = str(nodeDataMap[name][0])
paraList = nodeDataMap[name][1]
"""Create"""
activeNode = self.createNodes(name,offset,type,paraList)
activeNode.setParent(groupNode)
upstreamMergeNode = self.createMergeNodes(nodeMergeList, NodegraphAPI.GetRootNode())
NodegraphAPI.SetNodePosition(upstreamMergeNode,((len(nodeMergeList)/2)*500, -600))
upstreamMergeNode.setName("MaterialsMerge")
dowmstreamMergeNode = NodegraphAPI.CreateNode('Merge',NodegraphAPI.GetRootNode())
dowmstreamMergeNode.addInputPort('i%d' % 0)
dowmstreamMergeNode.getInputPort("i0").connect(upstreamMergeNode.getOutputPort("out"))
NodegraphAPI.SetNodePosition(dowmstreamMergeNode,((len(nodeMergeList)/2)*500, -1000))
dowmstreamMergeNode.setName("MergePass")
self.pos = ((len(nodeMergeList)/2)*500, -1000)
"""Connect"""
self.connectNodes()
Result = dowmstreamMergeNode
return Result
def createAlembicNode(self):
AlembicData = self.AlembicData
MaterialData = self.MaterialData
# Create Node
modelName = "Model_In"
nodeList = []
standardNode = NodegraphAPI.CreateNode('Alembic_In',
NodegraphAPI.GetRootNode())
#standardNode.getParameter('name').setValue("/root/world/geo/%s"%modelName, 0)
#standardNode.setName(modelName)
standardNode.getParameter('abcAsset').setValue(
"C:/Users/mili/Desktop/c_NGJL_mod.abc", 0)
NodegraphAPI.SetNodePosition(standardNode, (0, 0))
nodeList.append(standardNode)
pruneNode = NodegraphAPI.CreateNode('Prune',
NodegraphAPI.GetRootNode())
NodegraphAPI.SetNodePosition(standardNode, (0, 50))
pruneNode.getInputPort('A').connect(standardNode.getOutputPort('out'))
nodeList.append(pruneNode)
facesetGroupNode = NodegraphAPI.CreateNode('GroupStack',
NodegraphAPI.GetRootNode())
facesetGroupNode.setName("FaceSetGroup")
facesetGroupNode.setChildNodeType('FaceSetCreate')
facesetGroupNode.getInputPort('in').connect(
pruneNode.getOutputPort('out'))
NodegraphAPI.SetNodePosition(facesetGroupNode, (0, -50))
nodeList.append(facesetGroupNode)
materialassignGroupNode = NodegraphAPI.CreateNode(
'GroupStack', NodegraphAPI.GetRootNode())
materialassignGroupNode.setName("MaterialAssignGroup")
materialassignGroupNode.setChildNodeType('MaterialAssign')
materialassignGroupNode.getInputPort('in').connect(
facesetGroupNode.getOutputPort('out'))
NodegraphAPI.SetNodePosition(materialassignGroupNode, (0, -100))
nodeList.append(materialassignGroupNode)
nodegraphTab = UI4.App.Tabs.FindTopTab('Node Graph')
for data in AlembicData:
self.createFaceSet(facesetGroupNode, data)
for material in MaterialData:
data = (material, MaterialData[material])
self.createMatrialAssign(materialassignGroupNode, data)
pruneNode = NodegraphAPI.GetNode("Prune")
pruneList = [
'/root/world/geo/%s/front' % modelName,
'/root/world/geo/%s/persp' % modelName,
'/root/world/geo/%s/side' % modelName,
'/root/world/geo/%s/top' % modelName,
]
pruneNode.getParameter('cel').setValue('(' + ' '.join(pruneList) + ')',
0)
if nodegraphTab:
nodegraphTab.floatNodes(nodeList)
def make_node_networks(knode, asset_inputs):
input_dot = NodegraphAPI.CreateNode('Dot', parent=knode)
output_dot = NodegraphAPI.CreateNode('Dot', parent=knode)
ing, x, y = 300, 0, 0
dot_x = ing * (len(asset_inputs)) / 2
NodegraphAPI.SetNodePosition(input_dot, [dot_x, 0])
NodegraphAPI.SetNodePosition(output_dot, [dot_x, -300])
pipe_parameter = knode.getParameter('studio_pipe')
for category in studio_nodes.CATEGORIES:
if category not in asset_inputs:
continue
for asset in asset_inputs[category]:
output_define = create_output_define(knode)
output_define.setName('%s_output_define' % asset)
render_node = NodegraphAPI.CreateNode('Render', parent=knode)
render_node.setName('%s_render' % asset)
render_node.getParameter('passName').setValue(
'%s_render' % asset, 1.0)
render_parameter = render_node.getParameters()
render_asset_name = render_parameter.createChildString(
'asset_name', asset)
hint = {'readOnly': 'True'}
render_asset_name.setHintString(str(hint))
NodegraphAPI.SetNodePosition(output_define, [x, -100])
NodegraphAPI.SetNodePosition(render_node, [x, -200])
x += ing
# dependency connections
input_dot.getOutputPort('output').connect(
output_define.getInputPort('input'))
input_dot.getOutputPort('output').connect(
output_dot.getInputPort('input'))
output_define.getOutputPort('out').connect(
render_node.getInputPort('input'))
knode.getSendPort('input').connect(input_dot.getInputPort('input'))
output_dot.getOutputPort('output').connect(
knode.getReturnPort('output'))
# set expressions
attributes = {
'color_space':
'args.renderSettings.outputs.outputName.rendererSettings.colorSpace.value',
'file_extension':
'args.renderSettings.outputs.outputName.rendererSettings.fileExtension.value',
'render_camera':
'args.renderSettings.outputs.outputName.rendererSettings.cameraName.value',
'render_location':
'args.renderSettings.outputs.outputName.locationSettings.renderLocation.value'
}
for driver, driven in attributes.items():
if driver == 'render_location':
name = '/%s/%s.' % (asset, asset)
extension = 'self.getNode().getParent().getParameter(\'studio_pipe.file_extension\').getValue(1.0)'
expression = 'self.getNode().getParent().getParameter(\'%s.%s\').getValue(1.0) + \'%s\' + %s' % (
'studio_pipe', driver, name, extension)
else:
expression = 'self.getNode().getParent().getParameter(\'%s.%s\').getValue(1.0)' % (
'studio_pipe', driver)
driven_parameter = output_define.getParameter(driven)
driven_parameter.setExpression(expression)
def create_puppet_group(knode, contents, position, ing):
'''
:description create asset groups and its dependency nodes
:param knode <NodegraphAPI node object>
:param contents <dict>
:param position <list>
:param ing <int>
'''
puppet_group = NodegraphAPI.CreateNode('Group', parent=knode)
puppet_group.setName('%s_group' % contents['name'])
NodegraphAPI.SetNodePosition(puppet_group, position)
puppet_group.addOutputPort('out')
merge_node = create_merge_node([0, 0], puppet_group, contents['name'])
input_port = merge_node.addInputPort('input')
look_resolve, look_assign = None, None
if contents['category'] != 'camera':
look_resolve = NodegraphAPI.CreateNode('LookFileResolve',
parent=puppet_group)
look_resolve.setName('%s_resolve' % contents['name'])
look_resolve.getOutputPort('out').connect(input_port)
look_assign = NodegraphAPI.CreateNode('LookFileAssign',
parent=puppet_group)
look_assign.setName('%s_klf' % contents['name'])
look_assign.getOutputPort('out').connect(
look_resolve.getInputPort('A'))
input_port = look_assign.getInputPort('input')
klf_parameter = look_assign.getParameter('args.lookfile.asset')
expression = get_expression('lookdev', contents['category'],
contents['name'], 'i3')
klf_parameter.getChild('value').setExpression(expression)
klf_parameter.getChild('enable').setValue(True, 1.0)
cel_parameter = look_assign.getParameter('CEL')
puppet_location = os.path.join(studio_nodes.SCENE_GRAPH_LOCATION,
contents['category'], contents['name'])
cel_parameter.setValue(puppet_location.encode(), 1.0)
alembic_node = NodegraphAPI.CreateNode('Alembic_In', parent=puppet_group)
alembic_node.setName('%s_alembic' % contents['name'])
alembic_node.getOutputPort('out').connect(input_port)
scenegraph_location = os.path.join(studio_nodes.SCENE_GRAPH_LOCATION,
contents['category'])
name_parameter = alembic_node.getParameter('name')
name_parameter.setValue(scenegraph_location.encode(), 1.0)
name_parameter.setUseNodeDefault(False)
abc_parameter = alembic_node.getParameter('abcAsset')
expression = get_expression('animation', contents['category'],
contents['name'], 'i5')
abc_parameter.setExpression(expression)
abc_parameter.setUseNodeDefault(False)
# set the position
x, y = [0, 100]
for each in [look_resolve, look_assign, alembic_node]:
if not each:
continue
NodegraphAPI.SetNodePosition(each, [x, y])
y += ing
return puppet_group
def createShadingNetwork(cls, parentNode=None, xPos=0, yPos=0):
"""
Convenience function to create the shading network for our SkyDome.
Can be called from inside Katana using:
C{Plugins.GafferThreeAPI.PackageClasses.SkyDomePackage.createShadingNetwork()}
"""
if parentNode is None:
parentNode = NodegraphAPI.GetRootNode()
# Create shading network
imageNode = NodegraphAPI.CreateNode('ArnoldShadingNode', parentNode)
imageNode.getParameter('name').setValue('skyDomeImage', 0)
NodegraphAPI.SetNodePosition(imageNode, (xPos, yPos + 120))
imageNode.getParameter('nodeType').setValue('image', 0)
imageNode.checkDynamicParameters()
lightNode = NodegraphAPI.CreateNode('ArnoldShadingNode', parentNode)
lightNode.getParameter('name').setValue('skyDomeLight', 0)
NodegraphAPI.SetNodePosition(lightNode, (xPos, yPos + 80))
lightNode.getParameter('nodeType').setValue('skydome_light', 0)
lightNode.checkDynamicParameters()
lightNode.getInputPort('color').connect(imageNode.getOutputPort('out'))
hdriLightNode = NodegraphAPI.CreateNode('NetworkMaterial', parentNode)
hdriLightNode.getParameter('name').setValue('hdriSkyDomeLight', 0)
NodegraphAPI.SetNodePosition(hdriLightNode, (xPos, yPos + 40))
hdriLightNode.addInputPort('arnoldSurface')
hdriLightNode.getInputPort('arnoldSurface').connect(
lightNode.getOutputPort('out'))
lookFileMaterialsOutNode = NodegraphAPI.CreateNode(
'LookFileMaterialsOut', parentNode)
lookFileMaterialsOutNode.setName('hdriSkiDomeLight_bake')
NodegraphAPI.SetNodePosition(lookFileMaterialsOutNode, (xPos, yPos))
lookFileMaterialsOutNode.getParameter('saveTo').setValue(
cls.DEFAULT_BAKED_LIGHT_FILENAME, 0)
lookFileMaterialsOutNode.getInputPort('in').connect(
hdriLightNode.getOutputPort('out'))
# Expose shading node parameters on the network material
cls.__exposeShaderParameter(imageNode, 'filename', 'HDRI_map',
{'widget': 'fileInput'})
cls.__exposeShaderParameter(imageNode, 'sflip')
cls.__exposeShaderParameter(imageNode, 'tflip')
cls.__exposeShaderParameter(imageNode, 'multiply', 'color')
cls.__exposeShaderParameter(lightNode, 'matrix')
cls.__exposeShaderParameter(lightNode, 'intensity')
cls.__exposeShaderParameter(lightNode, 'exposure')
cls.__exposeShaderParameter(lightNode, 'samples')
return lookFileMaterialsOutNode
def importLmtl(self):
pos = NodegraphAPI.GetViewPortPosition(NodegraphAPI.GetRootNode())
currentItemName = str(self.listWidget.currentItem().text())
checkCat = str(self.catedoryCB.currentText())
if not checkCat == 'ALL':
klfName = os.path.join(self.directory, checkCat,
currentItemName + '.klf')
expression = 'path.join(getenv("MATLIB",0), "material_library", "{}", "{}")'.format(
checkCat, currentItemName + '.klf')
else:
klfName = os.path.join(
str(self.listWidget.currentItem().data(
QtCore.Qt.UserRole).toPyObject()),
currentItemName + '.klf')
expression= 'path.join(getenv("MATLIB",0), "material_library", "{}", "{}")'\
.format(str(self.listWidget.currentItem().data(QtCore.Qt.UserRole).toPyObject()).split(os.sep)[-1], currentItemName+'.klf')
if os.path.exists(klfName):
materialNode = NodegraphAPI.CreateNode('Material',
NodegraphAPI.GetRootNode())
materialNode.getParameter('name').setValue(currentItemName, 0)
DrawingModule.SetCustomNodeColor(materialNode, 0.2, 0.27, 0.4)
materialNode.getParameter('action').setValue(
'create from Look File', 0)
materialNode.getParameter('lookfile.lookfile').setExpression(
expression)
NodegraphAPI.SetNodePosition(materialNode,
((pos[0][0]), pos[0][1]))
materialAssign = NodegraphAPI.CreateNode(
'MaterialAssign', NodegraphAPI.GetRootNode())
materialAssign.setName('MA_' + currentItemName)
materialAssign.getParameter(
'args.materialAssign.value').setExpression(
"scenegraphLocationFromNode(getNode('{}'))".format(
materialNode.getName()))
DrawingModule.SetCustomNodeColor(materialAssign, 0.2, 0.27, 0.4)
NodegraphAPI.SetNodePosition(materialAssign,
((pos[0][0]), pos[0][1] - 50))
materialNode.getOutputPort('out').connect(
materialAssign.getInputPort('input'))
NodegraphAPI.SetNodeEdited(materialAssign,
edited=True,
exclusive=True)
else:
QtGui.QMessageBox.information(
None, currentItemName,
'There in no Look File for {}, try importing Material!'.format(
currentItemName))
def PositionNodes(smNode):
for i, passItem in enumerate(GetRenderPasses(smNode)):
node = passItem.getGroupNode()
NodegraphAPI.SetNodePosition(node, (HORIZONTAL_NODE_OFFSET *
(i - 1), RENDER_NODE_POSITION))
# Organize light passes inside a render pass
for j, lightPassItem in enumerate(GetLightPasses(smNode, passItem)):
subnode = lightPassItem.getGroupNode()
NodegraphAPI.SetNodePosition(subnode,
(HORIZONTAL_NODE_OFFSET *
(j - 1), RENDER_NODE_POSITION))
return
def build(self,InPos):
offsetX = InPos[0] - 200
offsetY = InPos[1]
AlembicData = self.AlembicData
MaterialData = self.MaterialData
#~ Create Node
modelName = "asset"
nodeList = []
self.standardNode = NodegraphAPI.CreateNode('Alembic_In', NodegraphAPI.GetRootNode())
self.standardNode.getParameter('name').setValue("/root/world/geo/%s"%modelName, 0)
self.standardNode.setName("Asset")
self.standardNode.getParameter('abcAsset').setValue("C:/Users/mili/Desktop/c_NGJL_mod.abc", 0)
NodegraphAPI.SetNodePosition(self.standardNode, (0+offsetX, 150+offsetY))
nodeList.append(self.standardNode)
pruneNode = NodegraphAPI.CreateNode('Prune', NodegraphAPI.GetRootNode())
NodegraphAPI.SetNodePosition(pruneNode, (0+offsetX, 100+offsetY))
pruneNode.getInputPort('A').connect(self.standardNode.getOutputPort('out'))
nodeList.append(pruneNode)
pruneList = [
'/root/world/geo/%s/front'%modelName,
'/root/world/geo/%s/persp'%modelName,
'/root/world/geo/%s/side'%modelName,
'/root/world/geo/%s/top'%modelName,
]
pruneNode.getParameter('cel').setValue('(' + ' '.join(pruneList) + ')', 0)
facesetGroupNode = NodegraphAPI.CreateNode('GroupStack', NodegraphAPI.GetRootNode())
facesetGroupNode.setName("FaceSetGroup")
facesetGroupNode.setChildNodeType('FaceSetCreate')
facesetGroupNode.getInputPort('in').connect(pruneNode.getOutputPort('out'))
NodegraphAPI.SetNodePosition(facesetGroupNode, (0+offsetX, 50+offsetY))
nodeList.append(facesetGroupNode)
materialassignGroupNode = NodegraphAPI.CreateNode('GroupStack', NodegraphAPI.GetRootNode())
materialassignGroupNode.setName("MaterialAssignGroup")
materialassignGroupNode.setChildNodeType('MaterialAssign')
materialassignGroupNode.getInputPort('in').connect(facesetGroupNode.getOutputPort('out'))
NodegraphAPI.SetNodePosition(materialassignGroupNode, (0+offsetX, offsetY))
nodeList.append(materialassignGroupNode)
for data in AlembicData:
self.createFaceSet(facesetGroupNode,data)
for material in MaterialData:
data = (material,MaterialData[material])
self.createMatrialAssign(materialassignGroupNode,data)
Result = materialassignGroupNode
return Result
def create_alembic_node(contents, position, current_asset, parent):
'''
:description to create the alembic node inside the custom asset group
:param contents <dict>
:param position <list>
:param current_asset <str>
:param parent <NodegraphAPI node object>
'''
alembic_node = NodegraphAPI.CreateNode('Alembic_In', parent=parent)
alembic_node.setName('%s_abc' % contents['name'])
NodegraphAPI.SetNodePosition(alembic_node, position)
scenegraph_location = os.path.join(
studio_nodes.SCENE_GRAPH_LOCATION, contents['category'])
location_parameter = alembic_node.getParameter('name')
location_parameter.setValue(scenegraph_location, 1.0)
location_parameter.setUseNodeDefault(False)
abc_parameter = alembic_node.getParameter('abcAsset')
expression = get_expression(current_asset)
abc_parameter.setExpression(expression)
abc_parameter.setUseNodeDefault(False)
source_path = abc_parameter.getValue(1.0)
if not os.path.isfile(source_path):
version = os.path.basename(os.path.split(source_path)[0])
message = 'not found %s version %s %s\n' % (contents['name'], version, source_path)
QtGui.QMessageBox.warning(None, 'warning', message, QtGui.QMessageBox.Ok)
return alembic_node
def __init__(self):
try:
Utils.UndoStack.DisableCapture()
try:
self.setName("UsdMaterialBake")
self.setType("UsdMaterialBake")
networkVersion = "1.0"
parameters_XML = _parameters_XML.format(
networkVersion=networkVersion)
self.getParameters().parseXML(parameters_XML)
self.addInputPort("orig")
self.addInputPort("default")
self.addOutputPort("out")
dot = NodegraphAPI.CreateNode('Dot', self)
dot.getInputPortByIndex(0).connect(self.getSendPort("orig"))
dot.getOutputPortByIndex(0).connect(self.getReturnPort("out"))
NodegraphAPI.SetNodePosition(dot, (0, 200))
NodegraphAPI.SetNodeShapeAttr(self, 'basicDisplay', 1)
NodegraphAPI.SetNodeShapeAttr(self, 'iconName', '')
finally:
Utils.UndoStack.EnableCapture()
except Exception:
log.exception("CREATE UsdMaterialBake FAILED.")
raise
self.__timer = None
self.__interruptWidget = None
def deleteBlocker(blockerName='Blocker1', root=NodegraphAPI.GetRootNode()):
#get the node to delete
blockerToDelete = NodegraphAPI.GetNode(blockerName)
#get the position of the node
blockerToDeletePos = NodegraphAPI.GetNodePosition(blockerToDelete)
#get the connected node ports to the blocker to delete and reconnect those ports together
outPort = blockerToDelete.getInputPort('in').getConnectedPort(0)
inPort = blockerToDelete.getOutputPort('out').getConnectedPort(0)
outPort.connect(inPort)
#delete the blocker node
blockerToDelete.delete()
#delete the param of the blocker
paramToDelete = root.getParameter(blockerName)
param = root.getParameters()
param.deleteChild(paramToDelete)
#reposition the node inside the blockerGroup
nodeType = 'Group'
portToFind = inPort
nodeToMove = portToFind.getNode()
pos = blockerToDeletePos
while (nodeType != 'Dot'):
oldPos = NodegraphAPI.GetNodePosition(nodeToMove)
nodeType = nodeToMove.getType()
NodegraphAPI.SetNodePosition(nodeToMove, pos)
if nodeType != 'Dot':
portToFind = nodeToMove.getOutputPort('out').getConnectedPort(0)
nodeToMove = portToFind.getNode()
pos = oldPos
def getFilterAssetStackOutput(self, outputName, build=False):
outputGroup = self.__getNodeConnectedToGroupPort(self, outputName)
if not outputGroup:
if build:
raise TypeError("Output port '%s' doesn't exist" % outputName)
return None
port = outputGroup.getOutputPortByIndex(0)
if not port:
return None
node = self.__getNodeConnectedToGroupPort(outputGroup, port.getName())
if not node:
if build:
raise TypeError('Internal Importatomic graph error')
return None
if node.getBaseType() == 'GroupStack':
return node
if not build:
return None
stack = NodegraphAPI.CreateNode('GroupStack', outputGroup)
mergeOutputPort = node.getOutputPortByIndex(0)
mergeConnectedPort = mergeOutputPort.getConnectedPort(0)
mergeOutputPort.disconnect(mergeConnectedPort)
stack.getInputPortByIndex(0).connect(mergeOutputPort)
stack.getOutputPortByIndex(0).connect(mergeConnectedPort)
NodegraphAPI.SetNodePosition(stack, (0, -100))
return stack
def importKlf(self):
pos = NodegraphAPI.GetViewPortPosition(NodegraphAPI.GetRootNode())
currentItemName = str(self.listWidget.currentItem().text())
checkCat = str(self.catedoryCB.currentText())
if not checkCat == 'ALL':
klfName = os.path.join(self.directory, checkCat,
currentItemName + '.klf')
expression = 'path.join(getenv("MATLIB",0), "material_library", "{}", "{}")'.format(
checkCat, currentItemName + '.klf')
else:
klfName = os.path.join(
str(self.listWidget.currentItem().data(
QtCore.Qt.UserRole).toPyObject()),
currentItemName + '.klf')
expression= 'path.join(getenv("MATLIB",0), "material_library", "{}", "{}")'\
.format(str(self.listWidget.currentItem().data(QtCore.Qt.UserRole).toPyObject()).split(os.sep)[-1], currentItemName+'.klf')
if os.path.exists(klfName):
lfm = NodegraphAPI.CreateNode('LookFileMaterialsIn',
NodegraphAPI.GetRootNode())
lfm.setName('LFMI_' + currentItemName)
DrawingModule.SetCustomNodeColor(lfm, 0.4, 0, 0.15)
lfm.getParameter('lookfile').setExpression(expression)
NodegraphAPI.SetNodePosition(lfm, ((pos[0][0]), pos[0][1]))
else:
QtGui.QMessageBox.information(
None, currentItemName,
'There is no Look File for {}, try importing Material!'.format(
currentItemName))
def create_merge(nodes, *args):
mergeNode = NodegraphAPI.CreateNode('Merge', NodegraphAPI.GetRootNode())
NodegraphAPI.SetNodePosition(mergeNode, (600, 0))
id = 0
for node in nodes:
if not node:
continue
in_port = mergeNode.addInputPort('i%s' % id).connect(
node.getOutputPort('out'))
id += 1
def createNodes(self,InName,InOffset,InType,InParaList):
#~ Create Node
standardNode = NodegraphAPI.CreateNode('ArnoldShadingNode', NodegraphAPI.GetRootNode())
standardNode.getParameter('name').setValue(InName, 0)
NodegraphAPI.SetNodePosition(standardNode, (0+InOffset[0], 0+InOffset[1]))
standardNode.getParameter('nodeType').setValue(InType, 0)
standardNode.checkDynamicParameters()
#~ Set Node Attribute
self.setParameter(standardNode,InName,InParaList)
return standardNode
def LayoutInputNodes(node):
spacing = (200, 100)
pos = NodegraphAPI.GetNodePosition(node)
x = pos[0] - (spacing[0] * (node.getNumInputPorts() - 1)) / 2
y = pos[1] + spacing[1]
for port in node.getInputPorts():
if port.getNumConnectedPorts():
inputNode = port.getConnectedPort(0).getNode()
NodegraphAPI.SetNodePosition(inputNode, (x, y))
x += spacing[0]
def create_viewer_settings(attribute_name):
"""
Create viewer color settings.
Creates a group stack with 1 group node per unique attribute_name
value.
This can used to find values of surfacing attributes as in
attribute_name = "geometry.arbitrary.surfacing_object"
attribute_name = "geometry.arbitrary.surfacing_project'
Args:
attribute_name (str): name of the attribute
Returns:
None
"""
rootNode = NodegraphAPI.GetRootNode()
material_stack = NodegraphAPI.CreateNode("GroupStack", rootNode)
material_stack.setName("Surfacing_viewer_settings")
selected_node = katana.get_selected_nodes(single=True)
attribute_values = katana.get_objects_attribute_values(
selected_node, attribute_name)
position_y = 0
for attribute_value in attribute_values:
random_color = utils.get_random_color(attribute_value)
viewer_settings = NodegraphAPI.CreateNode("ViewerObjectSettings",
rootNode)
viewer_settings.setName("viewerColor_%s" % attribute_value)
katana.add_node_to_group_last(material_stack,
viewer_settings,
inputPort="input")
viewer_settings_value = viewer_settings.getParameter(
"args.viewer.default.drawOptions.color")
viewer_settings_value.getChild("value").getChild("i0").setValue(
random_color[0], 0)
viewer_settings_value.getChild("value").getChild("i1").setValue(
random_color[1], 0)
viewer_settings_value.getChild("value").getChild("i2").setValue(
random_color[2], 0)
viewer_settings_value.getChild("enable").setValue(True, 0)
cel_statement = '/root/world//*{attr("%s.value") == "%s"}' % (
attribute_name,
attribute_value,
)
viewer_settings.getParameter("CEL").setValue(cel_statement, 0)
NodegraphAPI.SetNodePosition(viewer_settings, (0, position_y))
position_y = position_y - 50
def create(gnode, path):
rigGroup = SA.BuildLocationPackageForPath(gnode, path)
rigGroup.setName(os.path.basename(path) + '_package')
rigGroup.setType(PackageName)
SA.AddNodeReferenceForPath(gnode, path, 'package', rigGroup)
primCreate = NodegraphAPI.CreateNode('PrimitiveCreate', rigGroup)
primCreate.addInputPort('in')
primCreate.getParameter('name').setExpression('getParent().pathName')
primCreate.getParameter('type').setValue('locator', 0)
pointConstraint = NodegraphAPI.CreateNode('PointConstraint', rigGroup)
pointConstraint.getParameter('basePath').setExpression('getParent().pathName')
p = pointConstraint.getParameter('addToConstraintList')
if p: p.setValue(1, 0)
pointConstraint.setBypassed(True)
orientConstraint = NodegraphAPI.CreateNode('OrientConstraint', rigGroup)
orientConstraint.getParameter('basePath').setExpression('getParent().pathName')
p = orientConstraint.getParameter('addToConstraintList')
if p: p.setValue(1, 0)
orientConstraint.setBypassed(True)
orientConstraint.getOutputPortByIndex(0).connect(rigGroup.getReturnPort(
rigGroup.getOutputPortByIndex(0).getName()))
SA.WireInlineNodes(rigGroup, [primCreate, pointConstraint, orientConstraint])
SA.AddNodeReferenceParam(rigGroup, 'node_primCreate',
primCreate)
SA.AddNodeReferenceParam(rigGroup, 'node_pointConstraint',
pointConstraint)
SA.AddNodeReferenceParam(rigGroup, 'node_orientConstraint',
orientConstraint)
yPos=0
NodegraphAPI.SetNodePosition(primCreate, (0, yPos))
NodegraphAPI.SetNodePosition(pointConstraint, (0, yPos-50))
NodegraphAPI.SetNodePosition(orientConstraint, (0, yPos-100))
def addBlocker(root=NodegraphAPI.GetRootNode()):
children = root.getChildren()
dotNode = None
for child in children:
if child.getType() == 'Dot':
dotNode = child
dotNodePos = NodegraphAPI.GetNodePosition(dotNode)
newBlocker = createSingleBlocker(root, 'getParent().getParent().', False)
paramui(root, newBlocker.getName(), False, True)
#reorder the button to be the last param
newBlockerParam = root.getParameters()
paramAddBlocker = newBlockerParam.getChild('addBlocker')
numberOfChild = newBlockerParam.getNumChildren() - 1
newBlockerParam.reorderChild(paramAddBlocker, numberOfChild)
inputDotNodeProducer = dotNode.getInputSource(
'input', NodegraphAPI.GetCurrentGraphState())[0]
inputDotNodeProducer.connect(newBlocker.getInputPort('in'))
newBlocker.getOutputPort('out').connect(dotNode.getInputPort('input'))
NodegraphAPI.SetNodePosition(newBlocker, dotNodePos)
NodegraphAPI.SetNodePosition(dotNode, (dotNodePos[0], dotNodePos[1] - 50))
def createMasterBlocker(name='BlockerGroup',
parent=NodegraphAPI.GetRootNode()):
rootNode = parent
#create the groupNode
groupNode = NodegraphAPI.CreateNode('Group', rootNode)
groupNode.setName(name)
#add in and out port
groupNode.addInputPort('in')
groupNode.addOutputPort('out')
#add attribute to switch the display of group node to normal node
groupNodeAttrDict = {'ns_basicDisplay': 1, 'ns_iconName': ''}
groupNode.setAttributes(groupNodeAttrDict)
blockerName = 'Blocker1'
#create a first blocker
blocker = createSingleBlocker(groupNode, 'getParent().getParent().', False)
paramui(groupNode, blocker.getName(), True)
#reorder the button addBlocker to be the last param
blockerParam = groupNode.getParameters()
paramAddBlocker = blockerParam.getChild('addBlocker')
numberOfChild = blockerParam.getNumChildren() - 1
blockerParam.reorderChild(paramAddBlocker, numberOfChild)
#create a dot node
dotNode = NodegraphAPI.CreateNode('Dot', groupNode)
dotNode.setName('outDot')
#connection
sendGroup = groupNode.getSendPort('in')
returnGroup = groupNode.getReturnPort('out')
blocker.getInputPort('in').connect(sendGroup)
blocker.getOutputPort('out').connect(dotNode.getInputPort('input'))
dotNode.getOutputPort('output').connect(returnGroup)
#set position of nodes
centralPos = NodegraphAPI.GetNodePosition(blocker)
NodegraphAPI.SetNodePosition(dotNode, (centralPos[0], centralPos[1] - 50))
#put the node under the mouse
currentSelection = NodegraphAPI.GetAllSelectedNodes()
for node in currentSelection:
NodegraphAPI.SetNodeSelected(node, False)
NodegraphAPI.SetNodeSelected(groupNode, True)
# Get list of selected nodes
nodeList = NodegraphAPI.GetAllSelectedNodes()
# Find Nodegraph tab and float nodes
nodegraphTab = UI4.App.Tabs.FindTopTab('Node Graph')
if nodegraphTab:
nodegraphTab.floatNodes(nodeList)
def setMasterMaterial(self, masterMaterialPath):
self.setLookFileMaterialEnabled(False)
n = self.getNode()
mmOs = SA.GetRefNode(n, 'mmOs')
if not mmOs:
if not masterMaterialPath:
return
# TODO: switch this to OpScript and upgrade existing Gaffer nodes
mmOs = NodegraphAPI.CreateNode('OpScript', n)
mmOs.setName('mmos')
SA.AddNodeReferenceParam(n, 'node_mmOs', mmOs)
material = SA.GetRefNode(n, 'material')
x, y = NodegraphAPI.GetNodePosition(material)
NodegraphAPI.SetNodePosition(mmOs, (x - 100, y))
mmOs.getInputPortByIndex(0).connect(
material.getInputPortByIndex(0).getConnectedPort(0))
material.getInputPortByIndex(0).connect(
mmOs.getOutputPortByIndex(0))
mmOs.getParameter('CEL').setExpression(
"""str(getParent().pathName) + '/master'""")
mmOs.getParameter('script.lua').setValue(
Resources.MASTERMATERIAL_OPSCRIPT, 0)
NodegraphAPI.UserParameters.CreateString(mmOs, 'mmOs')
if not masterMaterialPath:
mmOs.setBypassed(True)
return
gp = self.getGafferPro()
mmItem = gp.getScriptItemForPath(masterMaterialPath)
mmScriptItemClass = ScriptItems.GetGafferScriptItemClass(
'GafferProMasterMaterialPackage')
if not isinstance(mmItem, mmScriptItemClass):
raise TypeError("%r doesn't exist as master material" %
(masterMaterialPath))
mmOs.getParameter('user.mmOs').setExpression(
"""getNode(%r).pathName""" % mmItem.getNode().getName())
mmOs.setBypassed(False)
def create_collections(attribute_name):
"""
Create collections by attribute values.
Creates a group stack with 1 collection create node per unique attribute_name
value.
This can used to find values of surfacing attributes as in
attribute_name = "geometry.arbitrary.surfacing_object"
attribute_name = "geometry.arbitrary.surfacing_project'
Args:
attribute_name (str): name of the attribute
Returns:
list: collections names
"""
rootNode = NodegraphAPI.GetRootNode()
selected_node = katana.get_selected_nodes(single=True)
node_outPort = selected_node.getOutputPort("out")
surfacing_projects = katana.get_objects_attribute_values(
selected_node, attribute_name)
group_stack = NodegraphAPI.CreateNode("GroupStack", rootNode)
group_stack.setName("surfacing_collections")
group_stack_inputPort = group_stack.getInputPort("in")
node_outPort.connect(group_stack_inputPort)
collections_name_list = []
position_y = 0
for surfacing_project in surfacing_projects:
collection_create = NodegraphAPI.CreateNode("CollectionCreate",
rootNode)
collection_name = "%s" % surfacing_project
collection_create.setName(collection_name)
collections_name_list.append(surfacing_project)
# collection_create_location = collection_create.getParameter('/')
# collection_create_location.setValue(location,0)
collection_create_name = collection_create.getParameter("name")
collection_create_name.setValue("%s" % surfacing_project, 0)
collection_create_cel = collection_create.getParameter("CEL")
collection_create_cel.setValue(
'/root/world//*{attr("%s.value") == "%s"}' %
(attribute_name, surfacing_project),
0,
)
katana.add_node_to_group_last(group_stack, collection_create)
NodegraphAPI.SetNodePosition(collection_create, (0, position_y))
position_y = position_y - 50
return collections_name_list
def add_node_dependency(self):
input_dot = NodegraphAPI.CreateNode('Dot', parent=self)
# output_define = NodegraphAPI.CreateNode('RenderOutputDefine', parent=self)
output_define = self.create_output_define()
render = NodegraphAPI.CreateNode('Render', parent=self)
output_dot = NodegraphAPI.CreateNode('Dot', parent=self)
NodegraphAPI.SetNodePosition(input_dot, [100, 0])
NodegraphAPI.SetNodePosition(output_define, [0, -100])
NodegraphAPI.SetNodePosition(render, [0, -200])
NodegraphAPI.SetNodePosition(output_dot, [100, -300])
# dependency connections
input_dot.getOutputPort('output').connect(
output_define.getInputPort('input'))
input_dot.getOutputPort('output').connect(
output_dot.getInputPort('input'))
output_define.getOutputPort('out').connect(
render.getInputPort('input'))
self.getSendPort('input').connect(input_dot.getInputPort('input'))
output_dot.getOutputPort('output').connect(
self.getReturnPort('output'))
# set expressions
attributes = {
'color_space':
'args.renderSettings.outputs.outputName.rendererSettings.colorSpace.value',
'file_extension':
'args.renderSettings.outputs.outputName.rendererSettings.fileExtension.value',
'render_camera':
'args.renderSettings.outputs.outputName.rendererSettings.cameraName.value',
'render_location':
'args.renderSettings.outputs.outputName.locationSettings.renderLocation.value'
}
for driver, driven in attributes.items():
expression = 'self.getNode().getParent().getParameter(\'%s.%s\').getValue(1.0)' % (
self.pipe_parameter, driver)
driven_parameter = output_define.getParameter(driven)
driven_parameter.setExpression(expression)
def create_merge_node(position, parent, name):
'''
:description to create merge node inside the custom asset group
:param parent <NodegraphAPI node object>
:param position <list>
'''
merge_node = NodegraphAPI.CreateNode('Merge', parent=parent)
merge_node.setName('%s_merge' % name)
NodegraphAPI.SetNodePosition(merge_node, position)
out_port = merge_node.getOutputPort('out')
if not parent.getOutputPort('out'):
parent.addOutputPort('out')
return_port = parent.getReturnPort('out')
return_port.connect(out_port)
return merge_node
