def createNodeInContainer(container, nodetypecategory, nodetypename, nodename,
exact_node_type):
"""This function attempts to create a node of a given type category and
type name in a given container. If the container does not allow a given
type category, this funciton creates a network of a correct type first,
and then creates the required node within that network.
If exact_node_type is true, it attempts to create a node of the exact
nodetypename; otherwise, the nodtypename may be resolved to the
preferred namespace or version of that typename.
It retuns a pair of nodes, the fist being the node created in the
container and the second being the node of a required operator type
(which in most cases will be the same nodes).
"""
return (hou.Node(), hou.Node())
def buildPaintNode(node, nextnode, parms, props):
""" Finds a paint node at or prior to node which matches parms.
If not found, builds one. If the attribute does not exist,
creates the attribute to paint.
It will be inserted prior to nextnode if not none.
"""
return hou.Node()
def genericTool(scriptargs,
nodetypename,
nodename=None,
isreusable=False,
iscapture=False,
allow_obj_sel=True,
custom=False,
merge_context=False,
orient=None,
exact_node_type=True,
force_filter=False):
""" Invokes a generic SOP tool.
If isreusable is True, then the tool will try to reuse existing
nodes of matching type in the network before creating any new nodes.
If iscapture is True, then the tool is considered to be a capture-type
tool. Capture-type tools will attempt to create new nodes before
any deform-type SOPs in the network.
If merge_context is True, then we create the generator in context,
while merging it together with the current display sop.
If orient is set, it should be an instance of OrientInfo.
If exact_node_type is True, it creates the node of the exact type
specified by nodetypename. However, if exact_node_type is False,
then the base type may get resolved to another namespace or
another version, and the created node may be of that resolved type
(eg 'hda' may resolve to 'mynamespace::hda::2.0').
If force_Filter is True, we will treat as a filter even if
it can optionally have no inputs.
"""
return hou.Node()
def findAllChildNodesOfType(parentnode,
nodetype,
dorecurse=False,
basetypematch=False):
""" Returns a list of all child nodes that match the given node
type
"""
return hou.Node()
def getGeometrySelections(sceneviewer,
selectors,
allow_obj_selection=True,
prompt=None):
""" This function invokes a geometry selection for each
selector in "selectors". The selector is not started, but
its properties are used when calling sceneviewer.selectGeometry().
"""
return (None, [], hou.Node())
def findChildNodeOfType(parentnode,
nodetype,
dorecurse=False,
basetypematch=False):
""" This function does a search of the node container hierarchy
(rather than connection hierarchy) searching for a matching
node type.
"""
return hou.Node()
def findChildNodeOfTypeWithParms(parentnode,
nodetype,
parmlist,
dorecurse=False,
basetypematch=False):
""" This function does a search of the node container hierarchy
(rather than connection hierarchy) searching for a matching
node type which also has the given parameter list match.
"""
return hou.Node()
def createSopNodeContainer(sceneviewer,
newobjectname,
merge_context=False,
merge_creator=None):
""" Creates a scene level object node to contain a new SOP node.
This function may return an existing object node if the Model in
Context option is turned on, or the merge_context parameter is
set to True.
"""
return hou.Node()
def createSopNodeGenerator(container,
nodetypename,
nodename,
merge_context=False,
exact_node_type=True):
""" Creates a SOP node that doesn't require an input. If the container
already has nodes, this new SOP may be merged with the existing SOPs.
"""
# Look at the type of nodes that go inside the current node.
return hou.Node()
def genericSopNodeGeneratorTool(scriptargs,
nodetypename,
nodename,
merge_context=False,
prompt=None,
exact_node_type=True):
""" A generic tool for instantiating SOP generator nodes such as Box and
Sphere. The user is prompted to select a location in the viewport if
the tool was not invoked with the Ctrl key. The new SOP may be merged
into an existing scene level object depending onthe merge_context
parameter value.
"""
return hou.Node()
def genericSopNodeFilterTool(scriptargs,
nodetypename,
nodename,
isreusable=False,
iscapture=False,
allow_obj_sel=True,
selector_indices=(),
exact_node_type=True):
""" A generic tool for creating a SOP node that takes another SOP node
as input. The user is prompted for selections based on the selector
bindings set in the OPbindings file.
"""
return hou.Node()
def genericTool(scriptargs,
nodetypename,
nodename=None,
nodetypecategory=None,
exact_node_type=True):
""" Handles the creation of any node in a Network Editor pane.
This function is intended to instantiate a node of a given type from
shelf tools, and thus, if exact_node_type argument is True, it creates
the node of the exact type specified by nodetypename.
However, if exact_node_type argument is False, then the base type may
get resolved to another namespace or another version, and
the created node may be of that resolved type (eg 'hda' may resolve to
'mynamespace::hda::2.0').
"""
return hou.Node()
def findInputNodeOfTypeWithParms(endnode,
nodetype,
parmlist,
includeme=False,
seennodes=None,
basetypematch=False):
"""Finds any nodes that are an ancestor of endnode, match
nodetype, and have the parameters & value pairs listed in the
parmlist dictionary.
If basetypematch is true, only the node type's base name is checked,
ie, node type's namespace and version components are ignored
when testing against the matchtype (eg, matchtype 'hda' will match
node types 'hda', 'hda::1.5' and 'userx::hda', etc). Otherwise,
the node type name must match exactly the matchtype string.
"""
return hou.Node()
def findOutputNodeOfTypeWithParms(startnode,
nodetype,
parmlist,
includeme=False,
seennodes=None,
basetypematch=False,
returnall=False):
""" Finds any nodes that are a descendent of startnode, match
nodetype, and have the parameters & value pairs listed in the
parmlist dictionary.
If basetypematch is true, only the node type's base name is checked,
ie, node type's namespace and version components are ignored
when testing against the matchtype (eg, matchtype 'hda' will match
node types 'hda', 'hda::1.5' and 'userx::hda', etc). Otherwise,
the node type name must match exactly the matchtype string.
If returnall is true, returns a list of all matches in depth
first order, or an empty list if no matches are found.
"""
return hou.Node()
def findInputNode(endnode, searchnode, seennodes=None):
""" This function searches the endnode's hierarchy to find if the
given search node is connected
"""
return hou.Node()
def createSopNodeFilter(container, nodetypename, nodename, exact_node_type):
""" Creates a SOP node that takes an input. """
# Look at the type of nodes that go inside the current node.
return hou.Node()
def findAncestorOfType(startnode, category, nodetype, basetypematch=False):
""" Return closest ancestor (or self) of 'startnode' with the specified
category and type.
"""
return hou.Node()
def chooseNode(possible_nodes, title, message):
""" Prompts the user to select on of the given nodes. If there is only a
single node, then that node is automatically returned. The title
and message parameters determine what will show up in the prompt.
"""
return hou.Node()
def findDeformTypeInputSop(endnode):
""" This function does a depth first traversal of the node
input hierarchy to find the first deform-type node.
Returns the deform-type node. Returns None if no such node exists.
"""
return hou.Node()
def _askUserToSelectNode(nodes, title, message):
return hou.Node()
def findGreatestCommonDescendent(endnode, searchnodes, seennodes=None):
""" Starting from end node and heading up the input chain
locate the first node that doesn't have all of searchnodes
on the same input wire.
"""
return hou.Node()
