def test_motion(self): '''Change the PxrUsdIn's file and verify the dumped result.''' # test.motion.usda is a UsdGeomPointInstancer with positions, # orientations, scales, velocities, and angular velocities NodegraphAPI.GetNode('PxrUsdIn').getParameter('fileName').setValue( 'test.motion.usda', 0) CacheManager.flush() testfile = 'test.motion.xml' AttrDump.AttrDump(testfile) self.assertTrue(os.path.exists(testfile)) self.cleanUpTestFile(testfile) self.assertTrue(self.compareAgainstBaseline(testfile))
def createMtoAArnoldShadingNodes(): def getAllMtoAArnoldShadingTypes(): import RenderingAPI result = [] # Obtain a list of names of available shaders from the renderer info plug-in renderer = RenderingAPI.RenderPlugins.GetDefaultRendererPluginName() rendererInfoPlugin = RenderingAPI.RenderPlugins.GetInfoPlugin(renderer) shaderType = RenderingAPI.RendererInfo.kRendererObjectTypeShader nodeTypes = rendererInfoPlugin.getRendererObjectNames(shaderType) for node_type in nodeTypes: if node_type.startswith("Maya") or node_type.startswith("Mtoa"): result.append(node_type) return result from Katana import NodegraphAPI shader_type_list = getAllMtoAArnoldShadingTypes() result = [] i = 0 for shader_type in shader_type_list: as_node = NodegraphAPI.GetNode(shader_type) if not as_node: as_node = NodegraphAPI.CreateNode('ArnoldShadingNode', NodegraphAPI.GetRootNode()) width = 5 NodegraphAPI.SetNodePosition( as_node, (150 * math.floor(i / width), -50 * (i % width))) i += 1 as_node.getParameter('nodeType').setValue(shader_type, 0) as_node.checkDynamicParameters() as_node.getParameter('name').setValue(shader_type, 0) result.append(as_node) return result
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 ActionCallback(value): """ Callback for the layered menu, which creates a PrmanShadingNode node and sets its B{nodeType} parameter to the given C{value}, which is the name of a PRMan shader as set for the menu entry in L{PopulateCallback()}. @type value: C{str} @rtype: C{object} @param value: An arbitrary object that the menu entry that was chosen represents. In our case here, this is the name of a PRMan shader as passed to the L{LayeredMenuAPI.LayeredMenu.addEntry()} function in L{PopulateCallback()}. @return: An arbitrary object. In our case here, we return the created PrmanShadingNode node, which is then placed in the B{Node Graph} tab because it is a L{NodegraphAPI.Node} instance. """ # Create the node, set its shader, and set the name with the shader name node = NodegraphAPI.CreateNode('ArnoldShadingNode') node.getParameter('nodeType').setValue(value, 0) node.setName(value) node.getParameter('name').setValue(node.getName(), 0) NodegraphAPI.SetNodeEdited(node, True, True) return node
def __go(self, checked=False): node = NodegraphAPI.GetNode(self.__assetName) from Katana import UI4 attributeFile = UI4.Util.AssetId.BrowseForAsset( '', 'Select file', False, { 'fileTypes': 'xml', 'context': AssetAPI.kAssetContextAttributeFile }) if not attributeFile: return self.__itemClass.appendAttributeFile(attributeFile, self.__assetName)
def set_parent(self): selected_nodes = NodegraphAPI.GetAllSelectedNodes() if not selected_nodes: return output_ports = selected_nodes[-1].getOutputPorts() outport = None inputport = None for output_port in output_ports: connected_port = output_port.getConnectedPorts() outport = output_port if not connected_port: continue inputport = connected_port[-1] break if outport: outport.connect(self.getInputPort('input')) dx, dy = 0, 0 if inputport: self.getOutputPort('output').connect(inputport) dx, dy = NodegraphAPI.GetNodePosition(inputport.getNode()) ux, uy = NodegraphAPI.GetNodePosition(selected_nodes[-1]) mx = (ux + dx) / 2 my = (uy + dy) / 2 NodegraphAPI.SetNodePosition(self, [mx, my])
def __go(self, checked=False): node = NodegraphAPI.GetNode(self.__assetName) from Katana import UI4 lookFile = UI4.Util.AssetId.BrowseForAsset( '', 'Select file', False, { 'fileTypes': 'klf', 'acceptDir': True, 'context': AssetAPI.kAssetContextLookFile }) if not lookFile: return self.__itemClass.appendLookFile(lookFile, self.__assetName)
def normal_render(render_node, render_mode, frame_ranges): if isinstance(render_node, str) or isinstance(render_node, unicode): render_node = NodegraphAPI.GetNode(render_node) if not render_node: print '#warnings: not a valid render node' return for index in range(frame_ranges[0], frame_ranges[1]): # RenderManager.RenderModes.DISK_RENDER settings = RenderManager.RenderingSettings() settings.frame = index settings.mode = render_mode settings.asynchRenderMessageCB = messageHandler settings.asynch = False RenderManager.StartRender(render_mode, node=render_node, settings=settings)
def get_studio_nodes(key, value=None): # group_nodes = NodegraphAPI.GetAllNodesByType('Group', includeDeleted=False) k_nodes = NodegraphAPI.GetAllNodes(includeDeleted=False) studio_nodes = {} for k_node in k_nodes: parameter = k_node.getParameter(key) if not parameter: continue node_value = parameter.getValue(1.0) if value: if parameter.getValue(1.0) != value: continue studio_nodes.setdefault(k_node, node_value) else: studio_nodes.setdefault(k_node, node_value) return studio_nodes
def WireInlineNodes(enclosingGroup, nodeList, x=0, y=0): # Position all nodes in the nodeList and connect them to each other for i in xrange(0, len(nodeList)): NodegraphAPI.SetNodePosition(nodeList[i], (x, i * -50 + y)) if i == 0: continue nodeList[i].getInputPortByIndex(0).connect( nodeList[i - 1].getOutputPortByIndex(0)) # Connect enclosing group, if one is specified if enclosingGroup: nodeList[0].getInputPortByIndex(0).connect( enclosingGroup.getSendPort( enclosingGroup.getInputPortByIndex(0).getName())) nodeList[-1].getOutputPortByIndex(0).connect( enclosingGroup.getReturnPort( enclosingGroup.getOutputPortByIndex(0).getName()))
def getAll(): node = NodegraphAPI.GetViewNode() runtime = FnGeolib.GetRegisteredRuntimeInstance() txn = runtime.createTransaction() client = txn.createClient() op = Nodes3DAPI.GetOp(txn, node) txn.setClientOp(client, op) runtime.commit(txn) locationPathsAndData = [] traversal = FnGeolib.Util.Traversal(client, "/root") while traversal.valid(): locationPathsAndData.append( (traversal.getLocationPath(), traversal.getLocationData())) traversal.next() for i in locationPathsAndData: print i
def connectAndPlaceNodes(groupNode): noNodes = groupNode.getNumChildren() stepSize = -80 counter = 0 lastNode = groupNode.getChildByIndex(0) for n in groupNode.getChildren(): if n.getType() == "Alembic_In": pass else: counter = counter + 1 NodegraphAPI.SetNodePosition(n, (0, stepSize * counter)) lastNode.getOutputPortByIndex(0).connect(n.getInputPortByIndex(0)) lastNode = n # Connect last node to return port lastNode.getOutputPortByIndex(0).connect(groupNode.getReturnPort('out'))
def get_katana_nodes(nodes): ''' :description find the node in the scene with given name :param nodes <list> :example from core import nodegraph nodes = ['katana_camera', 'PrimitiveCreate', 'camera_abc', 'test_node'] nodegraph.get_katana_nodes(nodes) ''' knodes = [] for node in nodes: if isinstance(node, str) or isinstance(node, unicode): knode = NodegraphAPI.GetNode(node) else: knode = node if knode: knodes.append(knode) return knodes
def getParameters(parameter_name='', node=[], param_type='any', matchMode='tail'): ''' set the given parameter and value on the selected(or given) node input parameter name should be a list or string the returned type is a dict if given the parameter_name: {parameter_name:[parameter_object, ...]} or a list if the parameter_name is invalid, in this case, we simply list all parameters: [parameter_name, ...] ''' if not node: sel = NodegraphAPI.GetAllSelectedNodes() else: sel = node if not isinstance(sel, list): sel = [sel] if not isinstance(parameter_name, list): parameter_name = [parameter_name] if parameter_name and parameter_name[0]: collections = {} else: collections = [] for s in sel: #get the parameters params = traverseParameterGroup(s.getParameters()) for p in params: if param_type != 'any' and p.getType() != param_type: continue if parameter_name and parameter_name[0]: for n in parameter_name: if ( matchMode=='tail' and p.getFullName().lower().endswith(n.lower()) ) or \ ( matchMode=='include' and n.lower() in p.getFullName().lower() ): if collections.has_key(n): collections[n].append(p) else: collections.update({n: [p]}) print p.getFullName() else: collections.append(p) print p.getFullName() return collections
def _get_all_render_node_paths(self): """ Get all the paths and their enabled state from all the render nodes. :rtype: `dict` """ if not hasattr(self, "__render_paths"): def false_factory(): return False render_paths = defaultdict(false_factory) render_nodes = NodegraphAPI.GetAllNodesByType("Render") for node in render_nodes: outputs = node.getParameter("outputs") locations = [x.getValue(0) for x in outputs.getChild("locations").getChildren()] enabled_flags = [x.getValue(0) for x in outputs.getChild("enabledFlags").getChildren()] for path, enabled in zip(locations, enabled_flags): render_paths[path] |= bool(enabled) # At least one enabled to make it enabled self.__render_paths = dict(render_paths) return self.__render_paths
def PopulateCallback(layeredMenu): """ The populate call back is given to the layeredMenu as an argument. This function will determine what options are displayed to the user when the user displays the layered menu. """ display_flag = getGSVDisplayFlag() gsv_parm = NodegraphAPI.GetNode('rootNode').getParameter('variables') if display_flag is False: gsv_name = getGSV() gsv_entry = gsv_parm.getChild('%s.options' % gsv_name) for child in gsv_entry.getChildren(): layeredMenu.addEntry(str(child.getValue(0)), text=str(child.getValue(0)), color=(128, 0, 128)) else: for child in gsv_parm.getChildren(): layeredMenu.addEntry(str(child.getName()), text=str(child.getName()), color=(0, 128, 128))
def get_selected_nodes(single=False): """ Get selected nodes from the node graph, if single is given will check if a single node is selected. Kwargs: single (bool): single node selection Returns: list. Selected nodes. #FIXME (eze) this should return arrays, even is single is on """ nodes = NodegraphAPI.GetAllSelectedNodes() if single: if len(nodes) != 1: raise RuntimeError("Please select 1 node.") return nodes[0] else: return nodes
def __updateCB(self, args): if self.__updateTreeOnIdle: return for arg in args: if arg[0] in ('port_connect', 'port_disconnect'): for nodeNameKey in 'nodeNameA', 'nodeNameB': nodeName = arg[2][nodeNameKey] node = NodegraphAPI.GetNode(nodeName) if node is not None and node.getParent() == self.__node: self.__updateTreeOnIdle = True return if arg[0] in ('parameter_finalizeValue'): node = arg[2].get('node') param = arg[2].get('param') if node.getParent( ) == self.__node and param == node.getParameter('name'): self.__updateTreeOnIdle = True return
def __buildNodeChildren(self, nodeItem, selectedItems): node = NodegraphAPI.GetNode(nodeItem.getItemData()['name']) for param in node.getParameter('parameters').getChildren(): name = param.getName() if name == '__unused': continue if param.getType() != 'group': continue item = QT4Widgets.SortableTreeWidgetItem(nodeItem, name) key = hash(param) item.setItemData({'name': param.getName(), 'key': key}) if key in selectedItems: item.setSelected(True) self.__updateParamItem(item, param)
def get_asset_input_data(knode): asset_data = {} pipe_parameter = knode.getParameter('studio_pipe') asset_node = pipe_parameter.getChild('asset_node').getValue(1.0) kasset_node = NodegraphAPI.GetNode(asset_node) if not kasset_node: return asset_data parameters = kasset_node.getParameters() for category in parameters.getChildren(): if category.getName() not in studio_nodes.CATEGORIES: continue for asset in category.getChildren(): if asset.getType() != 'stringArray': continue model = asset.getChild('i1').getValue(1.0) lookdev = asset.getChild('i3').getValue(1.0) animation = asset.getChild('i5').getValue(1.0) data = {'model': model, 'lookdev': lookdev, 'animation': animation} asset_data.setdefault(asset.getName(), data) return asset_data
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 get_re_texture_nodes(): """ Get all Redshift TextureSampler Nodes Returns: dict: Dictionnary of KatanaNode:[file_path value, file_path_parameter] """ texture_sampler_dict = {} # init the dict all_node_list = NodegraphAPI.GetAllNodesByType('RedshiftShadingNode', includeDeleted=False, sortByName=True) for ktnnode in all_node_list: # check if you can get the type of the node try: node_type_value = ktnnode.getParameter("nodeType").getValue(0) except: continue if node_type_value == "TextureSampler": # try to get the file_path in the TextureSampler ts_path_param = ktnnode.getParameter('parameters.tex0.value') try: file_path = str(ts_path_param.getValue(0)) except Exception as excp: logger.warning( "Cannot get the filepath for node {}: {}".format( ktnnode, excp)) continue # skip to the next item if file_path: texture_sampler_dict[ktnnode] = [ os.path.normpath(file_path), ts_path_param ] if texture_sampler_dict: return texture_sampler_dict else: raise ValueError("No textures find in scene")
def get_re_texture_nodes(): """ Get all Render Engine Katana Texture/File nodes Returns: dict: Dictionnary of {KatanaNode:[file_path value, file_path_parameter]} Raises: ValueError """ retex_node_dict = {} all_node_list = NodegraphAPI.GetAllNodesByType('________TO CHANGE______', includeDeleted=False, sortByName=True) for ktnnode in all_node_list: # check if you can get the type of the node try: node_type_value = ktnnode.getParameter("nodeType").getValue(0) except: continue if node_type_value == "________TO CHANGE______": # try to get the file_path in the TextureSampler ts_path_param = ktnnode.getParameter('________TO CHANGE______') try: file_path = str(ts_path_param.getValue(0)) except Exception as excp: logger.warning( "Cannot get the filepath for node {}: {}".format( ktnnode, excp)) continue # skip to the next item if file_path: retex_node_dict[ktnnode] = [ os.path.normpath(file_path), ts_path_param ] if retex_node_dict: return retex_node_dict else: raise ValueError("No textures find in scene")
def addLookFileNodes(groupNode, lookRef, lookCel, ignore='False'): # -- node graph -- noAssigns = 0 assignNodes = [] for childNode in groupNode.getChildren(): if childNode.getType() == "LookFileAssign": assignNodes.append(childNode) # - LookFileAssign - nodeKstdAssign = NodegraphAPI.CreateNode('LookFileAssign') nodeKstdAssign.setParent( groupNode ) nodeKstdAssign.getParameter( 'CEL' ).setExpressionFlag( True ) nodeKstdAssign.getParameter( 'CEL' ).setExpression( lookCel ) nodeKstdAssign.getParameter( 'args.lookfile.asset.enable' ).setValue( 1, 0 ) nodeKstdAssign.getParameter( 'args.lookfile.asset.value' ).setValue( lookRef, 0 ) assignNodes.append(nodeKstdAssign) if ignore == 'True': nodeKstdAssign.setBypassed(True) return nodeKstdAssign
def RenameRenderPass(renderPass, newName): now = NodegraphAPI.GetCurrentTime() smNode = renderPass.getParent() oldName = renderPass.getName() # Return early if the name was not changed if oldName == newName: return oldName # Make sure new name is unique newName = GetUniquePassName(smNode, newName) # Update parameter renderPass.getGroupNode().setName(newName) # Update group name renderPass.getGroupNode().getParameter('passName').setValue(newName, now) # Rebuild outputs of Shadow Manager node BuildOutputs(smNode) return newName
def __createOpScriptNode(cls, parentNode, nodeName, opScript): """ Creates and returns an OpScript node with the given name, under the given parent node, and sets the text of the OpScript to the given Lua code. The OpScript node will be set to run at the location of this package. @type parentNode: C{NodegraphAPI.Node} @type nodeName: C{str} @type opScript: C{str} @rtype: C{NodegraphAPI.Node} @param parentNode: The enclosing Group node under which to create the new OpScript node. @param nodeName: The name to give the new OpScript node. @param opScript: The text of the Lua code for the OpScript node. @return: The newly created OpScript node. """ opScriptNode = NodegraphAPI.CreateNode('OpScript', parentNode) opScriptNode.setName(nodeName) opScriptNode.getParameter('CEL').setExpression("=^/__gaffer.location") opScriptNode.getParameter('script.lua').setValue(opScript, 0) return opScriptNode
def ActionCallback(value): """ The ActionCallback is given to the LayeredMenu as an argument. This function will determine what should happen when the user selects an option in the LayeredMenu. """ # flip display flag display_flag = getGSVDisplayFlag() if display_flag is True: # set flags to allow recursion through menus setGSV(value) setGSVDisplayFlag(not display_flag) """ hacky force update on the nodegraph tabs layer stack This is going to log an error, as we're manually removing the layer from the GL layer stack, and Katana will do this again during cleanup. """ node_graph = UI4.App.Tabs.FindTopTab('Node Graph').getNodeGraphWidget() layer_stack = node_graph._NodegraphWidget__nodeGraphViewInteractionLayer.layerStack( ) last_layer = layer_stack.getLayers()[-1] node_graph._NodegraphWidget__nodeGraphViewInteractionLayer.layerStack( ).removeLayer(last_layer) # layer_stack.setGraphInteraction(True) global gsvMenu node_graph.showLayeredMenu(gsvMenu) return else: setGSVDisplayFlag(not display_flag) gsv_parm = NodegraphAPI.GetNode('rootNode').getParameter('variables') if display_flag is False: gsv_name = getGSV() gsv_parm = gsv_parm.getChild('%s.value' % gsv_name) gsv_parm.setValue(value, 0) return value
def addAttributeFileNodes(groupNode, attrRef, attrCel, attrCustomBrowser='', groupName='attributeFile', ignore='False', createNode='True'): if createNode == 'True': # - AttributeFile_In - attrFileIn = NodegraphAPI.CreateNode('AttributeFile_In') attrFileIn.setParent(groupNode) attrFileIn.getParameter('CEL').setExpressionFlag(True) attrFileIn.getParameter('CEL').setExpression(attrCel) attrFileIn.getParameter('filepath').setValue(attrRef, 0) attrFileIn.getParameter('sofilepath').setValue(attrCustomBrowser, 0) if groupName is not None and groupName != '': attrFileIn.getParameter('groupAttr').setValue(groupName, 0) if ignore == 'True': attrFileIn.setBypassed(True) return attrFileIn return None
def ActionCallback(value): """ Callback for the layered menu, which creates a PrimitiveCreate node and sets its B{type} parameter to the given C{value}, which is the name of a primitive as set for the menu entry in L{PopulateCallback()}. @type value: C{str} @rtype: C{object} @param value: An arbitrary object that the menu entry that was chosen represents. In our case here, this is the name of a primitive as passed to the L{LayeredMenuAPI.LayeredMenu.addEntry()} function in L{PopulateCallback()}. @return: An arbitrary object. In our case here, we return the created PrimitiveCreate node, which is then placed in the B{Node Graph} tab because it is a L{NodegraphAPI.Node} instance. """ # Create the node, set its function, and set the name with the function name # In this case it makes the type of primitive you asked for and makes sure it has a unique name. node = NodegraphAPI.CreateNode('PrimitiveCreate') node.getParameter('type').setValue(value, 0) node.setName(value) node.getParameter('name').setValue('/root/world/geo/' + node.getName(), 0) return node
def xml_element_to_katana_scene(katana_scene, xml_element, force=False): ''' :description to create katana scene from xml element, force true is to overwrite the scene, if scene exists :param katana_scene <str> :param xml_element <PyXmlIO.Element> :param force <bool> :example from core import scene katana_scene = '/venture/shows/katana_tutorials/tmp/export_03.katana' scene.xml_element_to_katana_scene(katana_scene, xml_element) ''' if os.path.isfile(katana_scene) and not force: print '#warnings: already found katana scene' return if not os.path.isdir(os.path.dirname(katana_scene)): os.makedirs(os.path.dirname(katana_scene)) NodegraphAPI.WriteKatanaFile(katana_scene, xml_element, compress=True, archive=True, opaqueParams=None) return True