Exemple #1
1
    def get_output_nodes(self):
        """returns the rop nodes in the scene
        """
        ropContext = hou.node('/out')

        # get the children
        outNodes = ropContext.children()

        exclude_node_types = [
            hou.nodeType(hou.nodeTypeCategories()["Driver"], "wedge")
        ]

        # remove nodes in type in exclude_node_types list
        new_out_nodes = [node for node in outNodes
                         if node.type() not in exclude_node_types]

        return new_out_nodes
    def test_typeSetDefaultIcon(self):
        nodeType = hou.nodeType(hou.objNodeTypeCategory(), "geo")
        nodeType.setIcon("SOP_box")

        nodeType.setDefaultIcon()

        self.assertEqual(nodeType.icon(), "OBJ_geo")
    def get_all_tk_alembic_nodes(cls):
        """
        Returns a list of all tk-houdini-alembicnode instances in the current
        session.
        """

        tk_node_type = TkAlembicNodeHandler.TK_ALEMBIC_NODE_TYPE

        # get all instances of tk alembic rop/sop nodes
        tk_alembic_nodes = []
        tk_alembic_nodes.extend(
            hou.nodeType(hou.sopNodeTypeCategory(),
                         tk_node_type).instances())
        tk_alembic_nodes.extend(
            hou.nodeType(hou.ropNodeTypeCategory(),
                         tk_node_type).instances())

        return tk_alembic_nodes
    def get_nodes():
        """
        Returns a list of all SGTK Mantra nodes.

        :returns: All SGTK Mantra nodes.
        :rtype: List
        """
        node_class = ToolkitMantraNodeHandler.SG_NODE_CLASS
        rop_nodes = hou.nodeType(hou.ropNodeTypeCategory(),
                                 node_class).instances()
        return rop_nodes
    def collect_node_outputs(self, parent_item):
        """
        Creates items for known output nodes

        :param parent_item: Parent Item instance
        """

        for node_category in _HOUDINI_OUTPUTS:
            for node_type in _HOUDINI_OUTPUTS[node_category]:

                if node_type == "alembic" and self._alembic_nodes_collected:
                    self.logger.debug(
                        "Skipping regular alembic node collection since tk "
                        "alembic nodes were collected. "
                    )
                    continue

                if node_type == "ifd" and self._mantra_nodes_collected:
                    self.logger.debug(
                        "Skipping regular mantra node collection since tk "
                        "mantra nodes were collected. "
                    )
                    continue

                path_parm_name = _HOUDINI_OUTPUTS[node_category][node_type]

                # get all the nodes for the category and type
                nodes = hou.nodeType(node_category, node_type).instances()

                # iterate over each node
                for node in nodes:

                    # get the evaluated path parm value
                    path = node.parm(path_parm_name).eval()

                    # ensure the output path exists
                    if not os.path.exists(path):
                        continue

                    self.logger.info(
                        "Processing %s node: %s" % (node_type, node.path()))

                    # allow the base class to collect and create the item. it
                    # should know how to handle the output path
                    item = super(HoudiniSessionCollector, self)._collect_file(
                        parent_item,
                        path,
                        frame_sequence=True
                    )

                    # the item has been created. update the display name to
                    # include the node path to make it clear to the user how it
                    # was collected within the current session.
                    item.name = "%s (%s)" % (item.name, node.path())
    def process(self, context):

        node_type = hou.nodeType(hou.ropNodeTypeCategory(), 'alembic')
        abc_nodes = node_type.instances()

        for node in list(abc_nodes):

            instance = context.create_instance(name=node.name())
            instance.set_data('family', value='cache')
            instance.set_data('path', value=node.path())
            instance.add(node)
    def process(self, context):

        node_type = hou.nodeType('Object/cam')
        cam_nodes = node_type.instances()

        for node in list(cam_nodes):

            if 'ipr' not in node.name():
                instance = context.create_instance(name=node.name())
                instance.set_data('family', value='camera')
                instance.set_data('path', value=node.path())
                instance.add(node)
Exemple #8
0
def findSelectedMantraNodes():
    """Find any currently selected Mantra (ifd) nodes."""
    nodes = hou.selectedNodes()

    mantra_type = hou.nodeType("Driver/ifd")

    nodes = [node for node in nodes if node.type() == mantra_type]

    if not nodes:
        hou.ui.displayMessage(
            "No mantra nodes selected.",
            severity=hou.severityType.Error
        )

    return tuple(nodes)
    def _get_alembic_items(self):
        """Scan the file for tk alembic nodes to potentially publish."""

        app = self.parent
        
        # see if the alembicnode app is installed
        alembic_app = app.engine.apps.get("tk-houdini-alembicnode", None)
        if not alembic_app:
            app.log_info(
                "Will not attempt to scan for alembic caches."
                "The 'tk-houdini-alembicnode' app is not installed."
            )
            return []

        # get all the tk alembic nodes in the scene
        tk_alembic_nodes = hou.nodeType(hou.ropNodeTypeCategory(),
            "sgtk_alembic").instances()

        alembic_items = []

        # add all tk alembic nodes to the list of secondary publish items.
        for tk_alembic_node in tk_alembic_nodes:

            is_bypassed = tk_alembic_node.isBypassed()

            out_path_parm = tk_alembic_node.parm("filename")
            out_path = out_path_parm.menuLabels()[out_path_parm.eval()]

            # normalize the path
            out_path = os.path.normpath(out_path)

            # only select the item if the path exists and the node is not
            # bypassed
            should_select = out_path and os.path.exists(out_path) and \
                not is_bypassed

            alembic_items.append({
                "name": tk_alembic_node.name(),
                "type": "alembic_cache",
                "description": "Full Path: %s" % (tk_alembic_node.path(),),
                "selected": should_select,
                "other_params": {
                    "path": out_path,
                    "node": tk_alembic_node,
                },
            })

        return alembic_items
Exemple #10
0
    def _get_hdadef(table, scopeop, ns, name, version):
        import hou

        # HOM doesn't like unicode :(
        scopeop = str(scopeop) if scopeop else None
        ns = str(ns) if ns else None
        name = str(name)
        version = str(version) if version else ''

        fullname = hou.hda.fullNodeTypeNameFromComponents(
            scopeop, ns, name, version
        )
        type_cat = hou.nodeTypeCategories()[table]
        nodetype = hou.nodeType(type_cat, str(fullname))
        if nodetype:
            return nodetype.definition()
Exemple #11
0
def applyLocalOverrides(objnode):
    """ Promote all material parameters from the Material SHOP
        to the node.
    """
    # Get the path to the material.
    material_path = objnode.evalParm("shop_materialpath")
    # Try to find the node.
    material_node = objnode.node(material_path)

    # The node type for the SHOP material node.
    material_type = hou.nodeType(hou.shopNodeTypeCategory(), "vopmaterial")

    # If the material node doesn't exist we need to throw an error.
    if not material_node:
        msg = "{0} is not a valid node.".format(material_path)
        raise hou.OperationFailed(msg)
    # If the material node is not actually a material we need to throw
    # an error.
    if material_node.type() != material_type:
        msg = "{0} is not a material.".format(material_path)
        raise hou.OperationFailed(msg)

    # Grab the parm template groups for the material and object.
    material_template_group = material_node.parmTemplateGroup()
    template_group = objnode.parmTemplateGroup()
    
    # We need to loop over every entry in the material group and apply the
    # 'material_spare' tag with a value of '1'.
    for template in material_template_group.entriesWithoutFolders():
        # Grab any existing tags.
        tags = template.tags()
        # Apply the tag to signify it is a material spare property.
        tags["material_spare"] = "1"
        # Set the tags back to the template.
        template.setTags(tags)
        # Replace the original template with the modified one.
        material_template_group.replace(template.name(), template)


    # Find the folder to place the parameters into.
# DOESN'T WORK with appendToFolder for some reason #material_folder = template_group.findFolder("Material")
    # For each entry in the template group, append it to the material 
    # folder.
    for template in material_template_group.entries():
        template_group.appendToFolder(template_group.findFolder("Material"), template)
    # Set the parm template group with the new parms to the object.
    objnode.setParmTemplateGroup(template_group)
    def get_node_instances(self, type_name = ADDITIONAL_AOVS_NODE_TYPE):
        """
        Return list of all node instances in the scene with type type_name.
        """

        #node_type
        node_type = hou.nodeType(hou.vopNodeTypeCategory(), type_name)
        #check
        if not (node_type):
            #log
            self.logger.debug('Wrong node_type {0}. Could not set aov attributes.'.format(type_name))
            return []

        #node_instances_list
        node_instances_list = list(node_type.instances())

        #return
        return node_instances_list
Exemple #13
0
def update_all_node_login(node_type):
  """Updates login data in all instances of the type.

  Args:
    node_type: hou.NodeType, Type of the nodes to be updated
  """
  zync_node_types = dict(
    zync_render='Driver',
    zync_sim='Dop',
    zync_sim_sop='Sop'
  )

  for zync_node_name in zync_node_types.keys():
    category_name = zync_node_types[zync_node_name]
    category = hou.nodeTypeCategories()[category_name]
    node_type = hou.nodeType(category, zync_node_name)
    if node_type:
      for node in node_type.instances():
        update_node_login(node)
    def scan_scene(self):
        """
        The scan scene method is executed once at startup and its purpose is
        to analyze the current scene and return a list of references that are
        to be potentially operated on.

        The return data structure is a list of dictionaries. Each scene reference
        that is returned should be represented by a dictionary with three keys:

        - "node": The name of the 'node' that is to be operated on. Most DCCs have
          a concept of a node, path or some other way to address a particular
          object in the scene.
        - "type": The object type that this is. This is later passed to the
          update method so that it knows how to handle the object.
        - "path": Path on disk to the referenced object.

        Toolkit will scan the list of items, see if any of the objects matches
        any templates and try to determine if there is a more recent version
        available. Any such versions are then displayed in the UI as out of date.
        """

        items = []

        # get a list of all regular lembic nodes in the file
        alembic_nodes = hou.nodeType(hou.sopNodeTypeCategory(),
            "alembic").instances()

        # return an item for each alembic node found. the breakdown app will check
        # the paths of each looking for a template match and a newer version.
        for alembic_node in alembic_nodes:

            file_parm = alembic_node.parm("fileName")
            file_path = os.path.normpath(file_parm.eval())

            items.append({
                "node": alembic_node.path(),
                "type": "alembic",
                "path": file_path,
            })

        return items
Exemple #15
0
    def test_getMetaSource(self):
        TARGET = "Scanned Asset Library Directories"

        node_type = hou.nodeType(hou.sopNodeTypeCategory(), "explodedview")

        self.assertEqual(node_type.definition().metaSource(), TARGET)
Exemple #16
0
import hou
import os
import shutil

nodes = hou.selectedNodes()
geoList = []
fileList = []
fileListDepend = []
alembicList = []
alembicPath = []
alembicArchives = []
filePath = []

geoList = [i for i in nodes if i.type() == hou.nodeType("Object/geo")]
fileList = [
    i.children() for i in geoList
    if i.children().type() == hou.nodeType("Sop/file")
    and i.children().isTimeDependent() == True
]

for i in nodes:

    typeData = i.type()

    if "Object geo" in typeData:
        geoList.append(i)
    for a in i.children():
        typeData = str(a.type())
        if "Sop file" in typeData:
            if a.isTimeDependent() == True:
                fileListDepend.append(a)
Exemple #17
0
    def convert_mantra_to_sg_nodes(self):
        """
        Utility function to convert all Mantra nodes to Shotgun
        Mantra nodes (only converts Mantra nodes that were previously
        Shotgun Mantra nodes)

        # Example use:
        import sgtk
        eng = sgtk.platform.current_engine()
        app = eng.apps["tk-houdini-mantranode"]
        # Convert previously converted Mantra nodes back to
        # Shotgun Mantra nodes:
        app.convert_from_write_nodes()
        """

        # get write nodes:
        nodes = hou.nodeType(hou.ropNodeTypeCategory(), 'ifd').instances()
        for n in nodes:

            user_dict = n.userDataDict()

            profile = user_dict.get('tk_profile_name')

            if not profile:
                # can't convert to a Shotgun Mantra Node
                # as we have missing parameters!
                continue

            node_name = n.name()
            node_pos = n.position()

            # create new Shotgun Write node:
            node_class = ToolkitMantraNodeHandler.SG_NODE_CLASS
            new_sg_n = n.parent().createNode(node_class)

            # set the profile
            try:
                parm = new_sg_n.parm(ToolkitMantraNodeHandler.PARM_CONFIG)
                index = parm.menuLabels().index(profile)
                parm.set(index)
            except ValueError:
                pass

            # copy across and knob values from the internal write node.
            exclude = []
            self.__copy_parm_values(n, new_sg_n, exclude)

            # explicitly copy some settings to the new Shotgun Mantra Node:
            # AOV Names
            nums = self.__get_all_extra_plane_numbers(n)
            for num in nums:
                parm_name = 'sgtk__aov_name{0}'.format(num)
                user_data_name = 'tk_aov_name{0}'.format(num)
                aov_name = user_dict.get(user_data_name)
                new_sg_n.parm(parm_name).set(aov_name)

            # Copy inputs and move outputs
            self.__copy_inputs_to_node(n, new_sg_n)
            self.__move_outputs_to_node(n, new_sg_n)
            self.__copy_color(n, new_sg_n)

            # delete original node:
            n.destroy()

            # rename new node:
            new_sg_n.setName(node_name)
            new_sg_n.setPosition(node_pos)
Exemple #18
0
    def test_typeIsSubnet(self):
        nodeType = hou.nodeType(hou.objNodeTypeCategory(), "subnet")

        self.assertTrue(nodeType.isSubnetType())
Exemple #19
0
def _all_job_nodes():
    return hou.nodeType(
        hou.ropNodeTypeCategory(),
        "conductor::job::0.1").instances()
Exemple #20
0
import hou

selection = hou.selectedNodes()
names = [n.name() for n in selection]
my_list = ""
if len(selection) < 1 :
    my_list = "nothing selected, please select at least one object"
else:
    a=1
    for sel in selection:
        my_list = my_list + "\n" + "selected object " + str(a) + ":" + sel.name()
        a=a+1        
hou.ui.displayMessage(my_list, buttons=('OK',))
length = len(selection)
print "Number of nodes selected: " + str(length)
paths = [n.path() for n in hou.node('/out').allSubChildren()
         if n.type() == hou.nodeType('Driver/ifd')]
selected = hou.ui.selectFromTree(choices=paths)

mantras = [hou.node(path) for path in selected]
for m in mantras:
    m.parm('matte_objects').set(' '.join(n.name() for n in hou.selectedNodes())) # CHANGE PARAMETER NAME AS REQURIED
    print ("Selected mantra nodes : ") + m.name()
    new_name=' '.join(names)
hou.ui.displayMessage("( "+ (new_name) + " )  - added to selected mantra(s) matte objects.", buttons=('*Claps*',))
    
    def convert_to_regular_alembic_nodes(cls, app):
        """Convert Toolkit Alembic nodes to regular Alembic nodes.

        :param app: The calling Toolkit Application

        """

        tk_node_type = TkAlembicNodeHandler.TK_ALEMBIC_NODE_TYPE

        # determine the surface operator type for this class of node
        sop_types = hou.sopNodeTypeCategory().nodeTypes()
        sop_type = sop_types[tk_node_type]

        # determine the render operator type for this class of node
        rop_types = hou.ropNodeTypeCategory().nodeTypes()
        rop_type = rop_types[tk_node_type]

        # get all instances of tk alembic rop/sop nodes
        tk_alembic_nodes = []
        tk_alembic_nodes.extend(
            hou.nodeType(hou.sopNodeTypeCategory(), tk_node_type).instances())
        tk_alembic_nodes.extend(
            hou.nodeType(hou.ropNodeTypeCategory(), tk_node_type).instances())

        if not tk_alembic_nodes:
            app.log_debug("No Toolkit Alembic Nodes found for conversion.")
            return

        # iterate over all the tk alembic nodes and attempt to convert them
        for tk_alembic_node in tk_alembic_nodes:

            # determine the corresponding, built-in operator type
            if tk_alembic_node.type() == sop_type:
                alembic_operator = cls.HOU_SOP_ALEMBIC_TYPE
            elif tk_alembic_node.type() == rop_type:
                alembic_operator = cls.HOU_ROP_ALEMBIC_TYPE
            else:
                app.log_warning(
                    "Unknown type for node '%s': %s'" %
                    (tk_alembic_node.name(), tk_alembic_node.type()))
                continue

            # create a new, regular Alembic node
            alembic_node = tk_alembic_node.parent().createNode(
                alembic_operator)

            # copy the file parms value to the new node
            filename = _get_output_menu_label(
                tk_alembic_node.parm(cls.NODE_OUTPUT_PATH_PARM))
            alembic_node.parm(cls.NODE_OUTPUT_PATH_PARM).set(filename)

            # copy across knob values
            _copy_parm_values(tk_alembic_node,
                              alembic_node,
                              excludes=[cls.NODE_OUTPUT_PATH_PARM])

            # store the alembic output profile name in the user data so that we
            # can retrieve it later.
            output_profile_parm = tk_alembic_node.parm(
                cls.TK_OUTPUT_PROFILE_PARM)
            tk_output_profile_name = \
                output_profile_parm.menuLabels()[output_profile_parm.eval()]
            alembic_node.setUserData(cls.TK_OUTPUT_PROFILE_NAME_KEY,
                                     tk_output_profile_name)

            # copy the inputs and move the outputs
            _copy_inputs(tk_alembic_node, alembic_node)
            if alembic_operator == cls.HOU_SOP_ALEMBIC_TYPE:
                _save_outputs_to_user_data(tk_alembic_node, alembic_node)
            elif alembic_operator == cls.HOU_ROP_ALEMBIC_TYPE:
                _move_outputs(tk_alembic_node, alembic_node)

            # make the new node the same color
            alembic_node.setColor(tk_alembic_node.color())

            # remember the name and position of the original tk alembic node
            tk_alembic_node_name = tk_alembic_node.name()
            tk_alembic_node_pos = tk_alembic_node.position()

            # destroy the original tk alembic node
            tk_alembic_node.destroy()

            # name and reposition the new, regular alembic node to match the
            # original
            alembic_node.setName(tk_alembic_node_name)
            alembic_node.setPosition(tk_alembic_node_pos)

            app.log_debug("Converted: Tk Alembic node '%s' to Alembic node." %
                          (tk_alembic_node_name, ))
    def process(self, context):

        # storing plugin data
        plugin_data = {}
        node_type = hou.nodeType("Driver/ifd")
        render_nodes = node_type.instances()

        # creating instances per mantra node
        for node in list(render_nodes):

            instance = context.create_instance(name=node.name())
            instance.set_data("family", value="deadline.render")
            instance.set_data("outputPathExpanded", value=node.parm("vm_picture").eval())
            # instance.set_data('outputPath', value=node.parm('vm_picture').unexpandedString())

            instance.add(node)

            output = node.parm("vm_picture").eval()
            output_path = os.path.dirname(output)

            # setting job data
            job_data = {}
            if instance.has_data("deadlineJobData"):
                job_data = instance.data("deadlineJobData").copy()

            paddedNumberRegex = re.compile("([0-9]+)", re.IGNORECASE)

            paddedOutputFile = ""

            # Check the output file
            output_file = output
            matches = paddedNumberRegex.findall(os.path.basename(output_file))
            if matches != None and len(matches) > 0:
                paddingString = matches[len(matches) - 1]
                paddingSize = len(paddingString)
                padding = "#"
                while len(padding) < paddingSize:
                    padding = padding + "#"
                paddedOutputFile = self.right_replace(output_file, paddingString, padding, 1)

            job_data["OutputFilename0"] = paddedOutputFile
            job_data["Plugin"] = "Houdini"

            # frame range
            start_frame = int(node.parm("f1").eval())
            end_frame = int(node.parm("f2").eval())

            frames = "{}-{}\n".format(start_frame, end_frame)
            instance.set_data("deadlineFrames", value=frames)

            # setting plugin data
            plugin_data = plugin_data.copy()
            plugin_data["OutputDriver"] = node.path()
            plugin_data["Version"] = "14"
            plugin_data["IgnoreInputs"] = "0"

            # setting data
            data = {"job": job_data, "plugin": plugin_data}
            instance.set_data("deadlineData", value=data)

            # adding ftrack data to activate processing
            instance.set_data("ftrackComponents", value={})
            instance.set_data("ftrackAssetType", value="img")

            instance.add(node)
Exemple #23
0
def getAllCameraNames():
    ''' Returns a list of all camera names '''
    return [
        i.name() for i in hou.nodeType(hou.nodeTypeCategories()['Object'],
                                       'cam').instances()
    ]
Exemple #24
0
    def onStateManagerOpen(self, origin):
        if platform.system() == "Darwin":
            origin.menubar.setNativeMenuBar(False)

        origin.enabledCol = QColor(204, 204, 204)

        origin.scrollArea.setStyleSheet(hou.qt.styleSheet().replace(
            "QLabel", "QScrollArea"))

        origin.f_import.setStyleSheet("QFrame { border: 0px; }")
        origin.f_export.setStyleSheet("QFrame { border: 0px; }")

        ssheet = ""
        ssheet += "QTreeWidget::indicator::checked\n{\n    image: url(%s/Plugins/Apps/Houdini/UserInterfaces/checkbox_on.svg);\n}" % self.core.prismRoot
        ssheet += "QTreeWidget::indicator::unchecked\n{\n    image: url(%s/Plugins/Apps/Houdini/UserInterfaces/checkbox_off.svg);\n}" % self.core.prismRoot
        ssheet += "QTreeWidget::indicator { width: 16px; height: 16px;}"

        origin.tw_export.setStyleSheet(ssheet)

        origin.b_stateFromNode.setVisible(True)
        #	origin.b_createDependency.setVisible(True)
        origin.layout().setContentsMargins(0, 0, 0, 0)

        origin.b_createExport.setText("Exp")
        origin.b_createRender.setText("Rnd")
        origin.b_createPlayblast.setText("Pb")

        origin.b_createImport.setMinimumWidth(80 * self.core.uiScaleFactor)
        origin.b_createImport.setMaximumWidth(80 * self.core.uiScaleFactor)
        origin.b_createExport.setMinimumWidth(55 * self.core.uiScaleFactor)
        origin.b_createExport.setMaximumWidth(55 * self.core.uiScaleFactor)
        origin.b_createRender.setMinimumWidth(55 * self.core.uiScaleFactor)
        origin.b_createRender.setMaximumWidth(55 * self.core.uiScaleFactor)
        origin.b_createPlayblast.setMinimumWidth(50 * self.core.uiScaleFactor)
        origin.b_createPlayblast.setMaximumWidth(50 * self.core.uiScaleFactor)
        origin.b_createDependency.setMinimumWidth(50 * self.core.uiScaleFactor)
        origin.b_createDependency.setMaximumWidth(50 * self.core.uiScaleFactor)
        origin.b_stateFromNode.setMinimumWidth(130 * self.core.uiScaleFactor)
        origin.b_stateFromNode.setMaximumWidth(130 * self.core.uiScaleFactor)
        origin.b_getRange.setMaximumWidth(200 * self.core.uiScaleFactor)
        origin.b_setRange.setMaximumWidth(200 * self.core.uiScaleFactor)

        startframe = hou.playbar.playbackRange()[0]
        endframe = hou.playbar.playbackRange()[1]
        origin.sp_rangeStart.setValue(startframe)
        origin.sp_rangeEnd.setValue(endframe)

        usdType = hou.nodeType(hou.sopNodeTypeCategory(), "pixar::usdrop")
        if usdType is not None and ".usd" not in self.plugin.outputFormats:
            self.plugin.outputFormats.insert(-2, ".usd")
        elif usdType is None and ".usd" in self.plugin.outputFormats:
            self.plugin.outputFormats.pop(
                self.plugin.outputFormats.index(".usd"))

        rsType = hou.nodeType(hou.sopNodeTypeCategory(),
                              "Redshift_Proxy_Output")
        if rsType is not None and ".rs" not in self.plugin.outputFormats:
            self.plugin.outputFormats.insert(-2, ".rs")
        elif rsType is None and ".rs" in self.plugin.outputFormats:
            self.plugin.outputFormats.pop(
                self.plugin.outputFormats.index(".rs"))
Exemple #25
0
def getOutputDriverNames():
    ''' Returns a list of all output driver names '''
    return [
        i.name() for i in hou.nodeType(hou.nodeTypeCategories()['Driver'],
                                       'arnold').instances()
    ]
Exemple #26
0
def stringToNodes(s: str,
                  hou_parent=None,
                  ne=None,
                  ignore_hdas_if_already_defined=None,
                  force_prefer_hdas=None,
                  override_network_position=None,
                  key=None):
    """
    TODO: here to be a docstring
    :param s:
    :param hou_parent:
    :param ne:
    :param ignore_hdas_if_already_defined:
    :param force_prefer_hdas:
    :override_network_position: hou.Vector2 - position in networkview pane
    :return:
    """
    if ignore_hdas_if_already_defined is None:
        ignore_hdas_if_already_defined = True
        if opt is not None:
            ignore_hdas_if_already_defined = opt.getOption(
                'hpaste.ignore_hdas_if_already_defined',
                ignore_hdas_if_already_defined)

    if force_prefer_hdas is None:
        force_prefer_hdas = False
        if opt is not None:
            force_prefer_hdas = opt.getOption('hpaste.force_prefer_hdas',
                                              force_prefer_hdas)

    s = s.encode(
        'UTF-8')  # ununicode. there should not be any unicode in it anyways
    try:
        data = json.loads(
            bz2.decompress(base64.urlsafe_b64decode(s)).decode('UTF-8'))
    except Exception as e:
        raise RuntimeError(
            "input data is either corrupted or just not a nodecode: " +
            repr(e))

    houver1 = hou.applicationVersion()

    paste_to_position = ne is not None or override_network_position is not None
    if hou_parent is None:
        if ne is None:
            nes = [
                x for x in hou.ui.paneTabs()
                if x.type() == hou.paneTabType.NetworkEditor
                and getChildContext(x.pwd(), houver1) == data['context']
            ]
            if len(nes) == 0:
                nes = [
                    x for x in hou.ui.paneTabs()
                    if x.type() == hou.paneTabType.NetworkEditor
                ]
                if len(nes) == 0:
                    raise RuntimeError(
                        "this snippet has '{0}' context. cannot find opened network editor with context '{0}' to paste in"
                        .format(data['context']))
            ne = nes[0]
        hou_parent = ne.pwd()

    # check version
    formatVersion = data['version']
    if formatVersion > current_format_version[0]:
        raise RuntimeError(
            "unsupported version of data format. Try updating hpaste to the latest version"
        )
    if data.get('version.minor', 0) > current_format_version[1]:
        print(
            'HPaste: Warning!! snippet has later format version than hpaste. Consider updating hpaste to the latest version'
        )
    if data.get('signed', False):
        print(
            'HPaste: Warning!! this snippet seem to be signed, but this version of HPaste has no idea how to check signatures! so signature check will be skipped!'
        )

    # check accepted algtypes
    supportedAlgs = set()
    if houver1[0] == 15:
        supportedAlgs.add(0)
        supportedAlgs.add(1)
        supportedAlgs.add(2)  # WITH BIG WARNING!!!
    if houver1[0] >= 16:
        supportedAlgs.add(0)
        supportedAlgs.add(1)
        supportedAlgs.add(2)
    algtype = data['algtype']
    if algtype not in supportedAlgs:
        raise RuntimeError(
            "algorithm type is not supported by this houdini version, :( ")

    # check hou version
    houver2 = data['houver']
    if not opt.getOption('hpaste.ignore_houversion_warning', False) and (
            houver1[0] != houver2[0] or houver1[1] != houver2[1]):
        print(
            "HPaste: WARNING!! nodes were copied from a different houdini version: "
            + str(houver2))

    # check context
    context = getChildContext(hou_parent, houver1)
    if context != data['context']:
        raise InvalidContextError(
            hou_parent, data['context']
        )  # RuntimeError("this snippet has '%s' context" % data['context'])

    # check sum
    code = data['code'].encode('UTF-8')
    if hashlib.sha1(code).hexdigest() != data['chsum']:
        raise RuntimeError("checksum failed!")

    if paste_to_position:
        if houver1[0] >= 16:
            olditems = hou_parent.allItems()
        else:
            olditems = hou_parent.children()

    deserialize = getDeserializer(enctype=data.get('encryptionType', None),
                                  key=key,
                                  **(data.get('encryptionData', None) or {}))

    # do the work
    for hdaitem in data.get('hdaList', []):  # added in version 2.1
        hdacode = deserialize(hdaitem['code'])
        ntype = hdaitem['type']
        ncategory = hdaitem['category']
        if ignore_hdas_if_already_defined:
            nodeType = hou.nodeType(hou.nodeTypeCategories()[ncategory], ntype)
            if nodeType is not None:
                # well, that's already a bad sign, means it is installed
                continue

        fd, temppath = tempfile.mkstemp()
        try:
            with open(temppath, 'wb') as f:
                f.write(hdacode)
            for hdadef in hou.hda.definitionsInFile(temppath):
                hdadef.copyToHDAFile('Embedded')
            # hdadef.save('Embedded')
        finally:
            os.close(fd)

        if force_prefer_hdas:
            embhdas = [
                x for x in hou.hda.definitionsInFile("Embedded")
                if (x.nodeType().name() == ntype
                    and x.nodeTypeCategory().name() == ncategory)
            ]
            if len(embhdas) == 1:
                embhdas[0].setIsPreferred(True)

    # now nodes themselves
    if formatVersion == 1:
        code = binascii.a2b_qp(code)
    elif formatVersion >= 2:
        code = deserialize(code)
    else:
        raise RuntimeError(
            "Very unexpected format version in a very unexpected place!")

    load_warnings = []
    if algtype == 0:
        # high security risk!!
        if hou.isUiAvailable():
            ok = hou.ui.displayMessage(
                "WARNING! The algorithm type used by the pasted snipped is legacy and present HIGH SECURITY RISK!\n be sure you TRUST THE SOURCE of the snippet!",
                ("CANCEL", "ok"),
                severity=hou.severityType.Warning,
                close_choice=0,
                title="SECURITY WARNING")
        else:
            ok = 0
            print(
                "for now u cannot paste SECURITY RISK snippets in non-interactive mode"
            )
        if ok != 1:
            return

        exec(code, {}, {'hou': hou, 'hou_parent': hou_parent})
    elif algtype == 1 or algtype == 2:
        # get temp file
        fd, temppath = tempfile.mkstemp()
        try:
            with open(temppath, "wb") as f:
                f.write(code)
            try:
                if algtype == 1:
                    hou_parent.loadChildrenFromFile(temppath)
                if algtype == 2:
                    try:
                        hou_parent.loadItemsFromFile(temppath)
                    except AttributeError:
                        print(
                            "WARNING!!! your hou version does not support algorithm used for copying, TRYING possibly partly backward-INCOMPATIBLE method!"
                        )
                        print("CHECK SCENE INTEGRITY")
                        hou_parent.loadChildrenFromFile(temppath)
            except hou.LoadWarning as e:
                msg = e.instanceMessage()
                print(msg)

                # truncate just for display with random number 253
                msgtrunc = False
                if len(msg) > 253:
                    msgtrunc = True
                    msg = msg[:253] + "..."
                load_warnings.append("There were warnings during load" + (
                    "(see console for full message)" if msgtrunc else "") +
                                     "\n" + msg)
        finally:
            os.close(fd)
    else:
        raise RuntimeError(
            "algorithm type is not supported. Try updating hpaste to the latest version"
        )

    if paste_to_position:
        # now collect pasted nodes
        if houver1[0] >= 16:
            newitems = [x for x in hou_parent.allItems() if x not in olditems]
        else:
            newitems = [x for x in hou_parent.children() if x not in olditems]

        if len(newitems) == 0:
            return
        # calc center
        cpos = hou.Vector2()
        bbmin = hou.Vector2()
        bbmax = hou.Vector2()
        cnt = 0
        for item in newitems:
            cnt += 1
            pos = item.position()
            cpos += pos
            for i in [0, 1]:
                if pos[i] > bbmax[i] or cnt == 1:
                    bbmax[i] = pos[i]
                if pos[i] < bbmin[i] or cnt == 1:
                    bbmin[i] = pos[i]

        cpos = cpos / cnt
        cpos[1] = bbmax[1]
        if override_network_position is None:
            offset = ne.cursorPosition() - cpos
        else:
            offset = override_network_position - cpos
        for item in newitems:
            if houver1[0] >= 16 and item.parentNetworkBox() in newitems:
                continue
            item.move(offset)

    if len(load_warnings) > 0:
        raise RuntimeWarning('snippet loaded with following warnings:\n' +
                             '\n'.join(load_warnings))
Exemple #27
0
def _all_submitter_nodes():
    return hou.nodeType(
        hou.ropNodeTypeCategory(),
        "conductor::submitter::0.1").instances()
    def convert_mantra_to_sg_nodes(self):
        """
        Utility function to convert all Mantra nodes to Shotgun
        Mantra nodes (only converts Mantra nodes that were previously
        Shotgun Mantra nodes)

        # Example use:
        import sgtk
        eng = sgtk.platform.current_engine()
        app = eng.apps["tk-houdini-mantranode"]
        # Convert previously converted Mantra nodes back to
        # Shotgun Mantra nodes:
        app.convert_from_write_nodes()
        """

        # get write nodes:
        nodes = hou.nodeType(hou.ropNodeTypeCategory(), 'ifd').instances()
        for n in nodes:

            user_dict = n.userDataDict()

            profile = user_dict.get('tk_profile_name')

            if not profile:
                # can't convert to a Shotgun Mantra Node
                # as we have missing parameters!
                continue

            node_name = n.name()
            node_pos = n.position()

            # create new Shotgun Write node:
            node_class = ToolkitMantraNodeHandler.SG_NODE_CLASS
            new_sg_n = n.parent().createNode(node_class)

            # set the profile
            try:
                parm = new_sg_n.parm(ToolkitMantraNodeHandler.PARM_CONFIG)
                index = parm.menuLabels().index(profile)
                parm.set(index)
            except ValueError:
                pass

            # copy across and knob values from the internal write node.
            exclude = []
            self.__copy_parm_values(n, new_sg_n, exclude)

            # explicitly copy some settings to the new Shotgun Mantra Node:
            # AOV Names
            nums = self.__get_all_extra_plane_numbers(n)
            for num in nums:
                parm_name = 'sgtk__aov_name{0}'.format(num)
                user_data_name = 'tk_aov_name{0}'.format(num)
                aov_name = user_dict.get(user_data_name)
                new_sg_n.parm(parm_name).set(aov_name)

            # Copy inputs and move outputs
            self.__copy_inputs_to_node(n, new_sg_n)
            self.__move_outputs_to_node(n, new_sg_n)
            self.__copy_color(n, new_sg_n)

            # delete original node:
            n.destroy()

            # rename new node:
            new_sg_n.setName(node_name)
            new_sg_n.setPosition(node_pos)
    def process(self, context):

        # storing plugin data
        plugin_data = {}
        node_type = hou.nodeType('Driver/ifd')
        render_nodes = node_type.instances()

        # creating instances per mantra node
        for node in list(render_nodes):

            instance = context.create_instance(name=node.name())
            instance.set_data('family', value='deadline.render')
            instance.set_data('outputPathExpanded', value=node.parm('vm_picture').eval())
            # instance.set_data('outputPath', value=node.parm('vm_picture').unexpandedString())

            instance.add(node)

            output = node.parm('vm_picture').eval()
            output_path = os.path.dirname(output)

            # setting job data
            job_data = {}
            if instance.has_data('deadlineJobData'):
                job_data = instance.data('deadlineJobData').copy()


            paddedNumberRegex = re.compile( "([0-9]+)", re.IGNORECASE )

            paddedOutputFile = ""

            # Check the output file
            output_file = output
            matches = paddedNumberRegex.findall( os.path.basename( output_file ) )
            if matches != None and len( matches ) > 0:
                paddingString = matches[ len( matches ) - 1 ]
                paddingSize = len( paddingString )
                padding = "#"
                while len(padding) < paddingSize:
                    padding = padding + "#"
                paddedOutputFile = self.right_replace( output_file, paddingString, padding, 1 )

            job_data['OutputFilename0'] = paddedOutputFile
            job_data['Plugin'] = 'Houdini'

            # frame range
            start_frame = int(node.parm('f1').eval())
            end_frame = int(node.parm('f2').eval())

            frames = '{}-{}\n'.format(start_frame, end_frame)
            instance.set_data('deadlineFrames', value=frames)

            # setting plugin data
            plugin_data = plugin_data.copy()
            plugin_data['OutputDriver'] = node.path()
            plugin_data['Version'] = '14'
            plugin_data['IgnoreInputs'] = '0'

            # setting data
            data = {'job': job_data, 'plugin': plugin_data}
            instance.set_data('deadlineData', value=data)

            # adding ftrack data to activate processing
            instance.set_data('ftrackComponents', value={})
            instance.set_data('ftrackAssetType', value='img')

            instance.add(node)
Exemple #30
0
    def importObject(self, taskName=None, objMerge=True):
        fileName = self.core.getCurrentFileName()
        impFileName = self.e_file.text().replace("\\", "/")

        if self.e_file.text() != "":
            versionInfoPath = os.path.join(
                os.path.dirname(os.path.dirname(self.e_file.text())),
                "versioninfo.ini")
            if os.path.exists(versionInfoPath):
                vConfig = ConfigParser()
                vConfig.read(versionInfoPath)
                if vConfig.has_option("information", "fps"):
                    impFPS = float(vConfig.get("information", "fps"))
                    curFPS = self.core.getFPS()
                    if impFPS != curFPS:
                        fString = "The FPS of the import doesn't match the FPS of the current scene:\n\nCurrent scene FPS:\t%s\nImport FPS:\t\t%s" % (
                            curFPS, impFPS)
                        msg = QMessageBox(QMessageBox.Warning, "FPS mismatch",
                                          fString, QMessageBox.Cancel)
                        msg.addButton("Continue", QMessageBox.YesRole)
                        self.core.parentWindow(msg)
                        action = msg.exec_()

                        if action != 0:
                            return False

            if taskName is None:
                vPath = os.path.dirname(self.e_file.text())
                if os.path.basename(vPath) in ["centimeter", "meter"]:
                    vName = os.path.basename(os.path.dirname(vPath))
                    vPath = os.path.dirname(vPath)
                else:
                    vName = os.path.basename(vPath)

                if len(vName.split(self.core.filenameSeperator)) == 3 and (
                        os.path.join(
                            self.core.projectPath,
                            self.core.getConfig(
                                'paths',
                                "scenes",
                                configPath=self.core.prismIni)).replace(
                                    "\\", "/") in self.e_file.text().replace(
                                        "\\", "/") or
                    (self.core.useLocalFiles and os.path.join(
                        self.core.localProjectPath,
                        self.core.getConfig(
                            'paths', "scenes",
                            configPath=self.core.prismIni)).replace("\\", "/")
                     in self.e_file.text().replace("\\", "/"))):
                    taskName = os.path.basename(os.path.dirname(vPath))
                    if taskName == "_ShotCam":
                        taskName = "ShotCam"
                else:
                    taskName = vName

            taskName = taskName.replace("$", "_")
            self.taskName = taskName

            parDirName = os.path.basename(os.path.dirname(impFileName))
            if parDirName in ["centimeter", "meter"]:
                prefFile = os.path.join(
                    os.path.dirname(os.path.dirname(impFileName)),
                    self.preferredUnit, os.path.basename(impFileName))
                if parDirName == self.unpreferredUnit and os.path.exists(
                        prefFile):
                    impFileName = prefFile
                    self.e_file.setText(impFileName)

            self.core.callHook("preImport",
                               args={
                                   "prismCore": self.core,
                                   "scenefile": fileName,
                                   "importfile": impFileName
                               })

            try:
                self.node.path()
            except:
                self.node = None
                self.fileNode = None

            if os.path.splitext(impFileName)[1] == ".hda":
                try:
                    self.node.destroy()
                except:
                    pass

                if os.path.exists(impFileName):
                    hou.hda.installFile(impFileName)
            elif self.node is None or self.fileNode is None or not self.chb_updateOnly.isChecked(
            ) or (self.fileNode is not None and
                  (self.fileNode.type().name() == "alembic")
                  == (os.path.splitext(impFileName)[1] != ".abc")
                  ) or self.node.type().name() == "subnet":
                if self.node is not None:
                    try:
                        self.node.destroy()
                    except:
                        pass

                nwBox = hou.node("/obj").findNetworkBox("Import")
                if nwBox is None:
                    nwBox = hou.node("/obj").createNetworkBox("Import")
                    nwBox.setComment("Imports")
                    #nwBox.setMinimized(True)

                if os.path.splitext(impFileName)[
                        1] == ".abc" and "_ShotCam_" in impFileName:
                    self.fileNode = None
                    self.node = hou.node("/obj").createNode(
                        "alembicarchive", "IMPORT_ShotCam")
                    self.node.parm("fileName").set(impFileName)
                    self.node.parm("buildHierarchy").pressButton()
                    self.node.moveToGoodPosition()
                else:
                    self.node = hou.node("/obj").createNode(
                        "geo", "IMPORT_" + taskName)
                    self.node.moveToGoodPosition()

                    if len(self.node.children()) > 0:
                        self.node.children()[0].destroy()
                    if os.path.splitext(impFileName)[1] == ".abc":
                        self.fileNode = self.node.createNode("alembic")
                        self.fileNode.moveToGoodPosition()
                        self.fileNode.parm("fileName").set(impFileName)
                        self.fileNode.parm("loadmode").set(1)
                        self.fileNode.parm("groupnames").set(3)
                    elif os.path.splitext(impFileName)[1] == ".fbx":
                        self.node.destroy()

                        tlSettings = [hou.frame()]
                        tlSettings += hou.playbar.playbackRange()

                        self.node = hou.hipFile.importFBX(impFileName)[0]

                        setGobalFrangeExpr = "tset `(%d-1)/$FPS` `%d/$FPS`" % (
                            tlSettings[1], tlSettings[2])
                        hou.hscript(setGobalFrangeExpr)
                        hou.playbar.setPlaybackRange(tlSettings[1],
                                                     tlSettings[2])
                        hou.setFrame(tlSettings[0])

                        self.node.setName("IMPORT_" + taskName,
                                          unique_name=True)
                        fbxObjs = [
                            x for x in self.node.children()
                            if x.type().name() == "geo"
                        ]
                        mergeGeo = self.node.createNode("geo", "FBX_Objects")
                        mergeGeo.moveToGoodPosition()
                        if len(mergeGeo.children()) > 0:
                            mergeGeo.children()[0].destroy()
                        self.fileNode = mergeGeo.createNode(
                            "merge", "Merged_Objects")
                        self.fileNode.moveToGoodPosition()
                        for i in fbxObjs:
                            i.setDisplayFlag(False)
                            objmerge = mergeGeo.createNode(
                                "object_merge", i.name())
                            objmerge.moveToGoodPosition()
                            objmerge.parm("objpath1").set(i.path())
                            objmerge.parm("xformtype").set(1)
                            self.fileNode.setNextInput(objmerge)

                        mergeGeo.layoutChildren()
                        self.node.layoutChildren()
                    elif os.path.splitext(impFileName)[1] == ".usd":
                        self.fileNode = self.node.createNode(
                            "pixar::usdimport")
                        self.fileNode.moveToGoodPosition()
                        self.fileNode.parm("import_file").set(impFileName)
                        self.fileNode.parm("import_primpath").set("/")
                        self.fileNode.parm("import_time").setExpression("$F")
                    elif os.path.splitext(impFileName)[1] == ".rs":
                        if hou.nodeType(hou.sopNodeTypeCategory(),
                                        "Redshift_Proxy_Output") is None:
                            QMessageBox.warning(
                                self.core.messageParent, "ImportFile",
                                "Format is not supported, because Redshift is not available in Houdini."
                            )
                            if nwBox is not None:
                                if len(nwBox.nodes()) == 0:
                                    nwBox.destroy()
                            try:
                                self.node.destroy()
                            except:
                                pass
                            self.fileNode = None
                            return

                        self.fileNode = self.node.createNode(
                            "redshift_proxySOP")
                        self.fileNode.moveToGoodPosition()
                        self.node.setCurrent(True, clear_all_selected=True)
                        hou.hscript("Redshift_objectSpareParameters")
                        self.node.parm("RS_objprop_proxy_enable").set(True)
                        self.node.parm("RS_objprop_proxy_file").set(
                            impFileName)
                    else:
                        self.fileNode = self.node.createNode("file")
                        self.fileNode.moveToGoodPosition()
                        self.fileNode.parm("file").set(impFileName)

                    outNode = self.fileNode.createOutputNode(
                        "null", "OUT_" + taskName)
                    outNode.setDisplayFlag(True)
                    outNode.setRenderFlag(True)

                nwBox.addNode(self.node)
                self.node.moveToGoodPosition()
                nwBox.fitAroundContents()

                self.node.setDisplayFlag(False)
                self.node.setColor(hou.Color(0.451, 0.369, 0.796))

                if self.chb_autoNameSpaces.isChecked():
                    self.removeNameSpaces()

                if objMerge and "outNode" in locals():
                    self.objMerge()

            else:
                prevData = self.node.name().split("IMPORT_")
                if len(prevData) > 1:
                    prevTaskName = prevData[1]
                else:
                    prevTaskName = self.node.name()

                self.node.setName("IMPORT_" + taskName, unique_name=True)
                for i in self.node.children():
                    if prevTaskName in i.name():
                        i.setName(i.name().replace(prevTaskName, taskName),
                                  unique_name=True)

                if os.path.splitext(impFileName)[
                        1] == ".abc" and "_ShotCam_" in impFileName:
                    self.node.parm("fileName").set(impFileName)
                    self.node.parm("buildHierarchy").pressButton()
                else:
                    if os.path.splitext(impFileName)[1] == ".abc":
                        self.fileNode.parm("fileName").set(impFileName)
                    elif os.path.splitext(impFileName)[1] == ".usd":
                        self.fileNode.parm("import_file").set(impFileName)
                    else:
                        self.fileNode.parm("file").set(impFileName)

        impNodes = []
        try:
            curNode = self.node.path()
            impNodes.append(curNode)
        except:
            pass

        try:
            fNode = self.fileNode.path()
            impNodes.append(fNode)
        except:
            pass

        self.core.callHook("postImport",
                           args={
                               "prismCore": self.core,
                               "scenefile": fileName,
                               "importfile": impFileName,
                               "importedObjects": impNodes
                           })

        self.stateManager.saveImports()
        self.updateUi()
        self.stateManager.saveStatesToScene()

        return True
Exemple #31
0
def importDataFromXmlToAbc():
# select Alembic archive #    
    abc = lastSelectedNode()
    if abc is None:
	hou.ui.setStatusMessage("Select one root Alembic Archive node.")
	hou.ui.displayMessage("No root Alembic Archive node has been selected. Select one.", title="Attention, monsieur!")
	return None
    if abc.type() == hou.nodeType(hou.objNodeTypeCategory(), 'alembicarchive'):
	print "Alembic Archive found"
    else:
	print "No Alembic Archive selected"

# XML stuff #
    #file_name = "/home/max/exported_data.xml"
    hou.ui.setStatusMessage("Choose XML file to import textures from.")
    file_name = hou.ui.selectFile(start_directory="/mnt/karramba/", title="Choose XML", pattern="*.xml")
    if file_name == "":
	return None
    file_name = os.path.expandvars(file_name)
    xml = parse(file_name)
    xmlobjects = xml.getElementsByTagName("object")
    
# parse and assign textures #	
    stat_assigned = 0
    stat_noshader = 0
    stat_newshader = 0
    i = 0
    for obj in xmlobjects:
        object_name = obj.getElementsByTagName("object_name")[0]
        object_path = object_name.childNodes[0].data
        #print object_path
        object_path = object_path.replace('|', '/')
        print object_path
        object_fullpath = abc.path() + object_path
        print object_fullpath

#get texture data from XML        
        object_texture_color = obj.getElementsByTagName("texture_color")[0]
        texture_path_color = object_texture_color.childNodes[0].data
        
        object_texture_spec = obj.getElementsByTagName("texture_spec")[0]
        texture_path_spec = object_texture_spec.childNodes[0].data
        
        object_texture_bump = obj.getElementsByTagName("texture_bump")[0]
        texture_path_bump = object_texture_bump.childNodes[0].data

#create shader if needed        
        if hou.parm(str(object_fullpath) + "/shop_materialpath") is None:
            shader_template = hou.galleries.galleryEntries("mantrasurface")[0]
            shader[i] = shader_template.createChildNode(hou.node("shop"))
            shader[i].setName(object_name)
            stat_newshader = stat_newshader + 1

        if hou.parm(str(object_fullpath) + "/shop_materialpath") is not None:
            object_shader = hou.parm(str(object_fullpath) + "/shop_materialpath").evalAsString()
            #object_shader = hou.node(str(object_fullpath)).evalParm("shop_materialpath")
            if hou.node(object_shader) is not None:
                if hou.node(object_shader).parm("baseColorMap") is not None:
                    hou.node(object_shader).parm("baseColorMap").set(str(texture_path_color))
                if hou.node(object_shader).parm("baseSpecMap") is not None:
                    hou.node(object_shader).parm("baseSpecMap").set(str(texture_path_spec))
                if hou.node(object_shader).parm("baseDispMap") is not None:
                    hou.node(object_shader).parm("baseDispMap").set(str(texture_path_bump))
                stat_assigned = stat_assigned + 1
            else:
                print object_fullpath + ": Shader assigned, but doesn't exist."
                stat_noshader = stat_noshader + 1
        i+=1

    print str(stat_assigned) + " textures assigned successfully."
    print str(stat_newshader) + " shaders created."
    print str(stat_noshader) + " shaders assigned, but not found."
    def convert_back_to_tk_alembic_nodes(cls, app):
        """Convert Alembic nodes back to Toolkit Alembic nodes.

        :param app: The calling Toolkit Application

        Note: only converts nodes that had previously been Toolkit Alembic
        nodes.

        """

        # get all rop/sop alembic nodes in the session
        alembic_nodes = []
        alembic_nodes.extend(
            hou.nodeType(hou.sopNodeTypeCategory(),
                         cls.HOU_SOP_ALEMBIC_TYPE).instances())
        alembic_nodes.extend(
            hou.nodeType(hou.ropNodeTypeCategory(),
                         cls.HOU_ROP_ALEMBIC_TYPE).instances())

        if not alembic_nodes:
            app.log_debug("No Alembic Nodes found for conversion.")
            return

        # the tk node type we'll be converting to
        tk_node_type = TkAlembicNodeHandler.TK_ALEMBIC_NODE_TYPE

        # iterate over all the alembic nodes and attempt to convert them
        for alembic_node in alembic_nodes:

            # get the user data dictionary stored on the node
            user_dict = alembic_node.userDataDict()

            # get the output_profile from the dictionary
            tk_output_profile_name = user_dict.get(
                cls.TK_OUTPUT_PROFILE_NAME_KEY)

            if not tk_output_profile_name:
                app.log_warning(
                    "Almbic node '%s' does not have an output profile name. "
                    "Can't convert to Tk Alembic node. Continuing." %
                    (alembic_node.name(), ))
                continue

            # create a new, Toolkit Alembic node:
            tk_alembic_node = alembic_node.parent().createNode(tk_node_type)

            # find the index of the stored name on the new tk alembic node
            # and set that item in the menu.
            try:
                output_profile_parm = tk_alembic_node.parm(
                    TkAlembicNodeHandler.TK_OUTPUT_PROFILE_PARM)
                output_profile_index = output_profile_parm.menuLabels().index(
                    tk_output_profile_name)
                output_profile_parm.set(output_profile_index)
            except ValueError:
                app.log_warning("No output profile found named: %s" %
                                (tk_output_profile_name, ))

            # copy over all parameter values except the output path
            _copy_parm_values(alembic_node,
                              tk_alembic_node,
                              excludes=[cls.NODE_OUTPUT_PATH_PARM])

            # copy the inputs and move the outputs
            _copy_inputs(alembic_node, tk_alembic_node)

            # determine the built-in operator type
            if alembic_node.type().name() == cls.HOU_SOP_ALEMBIC_TYPE:
                _restore_outputs_from_user_data(alembic_node, tk_alembic_node)
            elif alembic_node.type().name() == cls.HOU_ROP_ALEMBIC_TYPE:
                _move_outputs(alembic_node, tk_alembic_node)

            # make the new node the same color. the profile will set a color,
            # but do this just in case the user changed the color manually
            # prior to the conversion.
            tk_alembic_node.setColor(alembic_node.color())

            # remember the name and position of the original alembic node
            alembic_node_name = alembic_node.name()
            alembic_node_pos = alembic_node.position()

            # destroy the original alembic node
            alembic_node.destroy()

            # name and reposition the new, regular alembic node to match the
            # original
            tk_alembic_node.setName(alembic_node_name)
            tk_alembic_node.setPosition(alembic_node_pos)

            app.log_debug("Converted: Alembic node '%s' to TK Alembic node." %
                          (alembic_node_name, ))
Exemple #33
0
def importDataFromXmlToAbc():
# select Alembic archive #    
    abc = lastSelectedNode()
    if abc is None:
	hou.ui.setStatusMessage("Select one root Alembic Archive node.")
	hou.ui.displayMessage("No root Alembic Archive node has been selected. Select one.", title="Attention, monsieur!")
	return None
    if abc.type() == hou.nodeType(hou.objNodeTypeCategory(), 'alembicarchive'):
	print "Alembic Archive found"
    else:
	print "No Alembic Archive selected"

# XML stuff #
    #file_name = "/home/max/exported_data.xml"
    hou.ui.setStatusMessage("Choose XML file to import textures from.")
    file_name = hou.ui.selectFile(start_directory="/mnt/karramba/", title="Choose XML", pattern="*.xml")
    if file_name == "":
	return None
    file_name = os.path.expandvars(file_name)
    xml = parse(file_name)
    xmlobjects = xml.getElementsByTagName("object")
    
# parse and assign textures #	
    stat_assigned = 0
    stat_noshader = 0
    for obj in xmlobjects:
        object_name = obj.getElementsByTagName("object_name")[0]
        object_path = object_name.childNodes[0].data
        print object_path
	object_path = object_path.replace('|', '/')
	print object_path
        object_fullpath = abc.path() + object_path
        print object_fullpath
	
	object_texture_color = obj.getElementsByTagName("texture_color")[0]
	texture_path_color = object_texture_color.childNodes[0].data
	
	object_texture_spec = obj.getElementsByTagName("texture_spec")[0]
	texture_path_spec = object_texture_spec.childNodes[0].data
	
	object_texture_bump = obj.getElementsByTagName("texture_bump")[0]
	texture_path_bump = object_texture_bump.childNodes[0].data

        if hou.parm(str(object_fullpath) + "/shop_materialpath") is not None:
	    object_shader = hou.parm(str(object_fullpath) + "/shop_materialpath").evalAsString()
	    #object_shader = hou.node(str(object_fullpath)).evalParm("shop_materialpath")
	    if hou.node(object_shader) is not None:
		hou.node(object_shader).parm("baseColorMap").set(str(texture_path_color))
#		if hou.node(object_shader).parm("baseSpecMap") is not None:
#		    hou.node(object_shader).parm("baseSpecMap").set(str(texture_path_color))
#		else:
#		    continue
#		if hou.node(object_shader).parm("baseDispMap") is not None:
#		    hou.node(object_shader).parm("baseDispMap").set(str(texture_path_bump))
#		else:
#		    continue
		stat_assigned = stat_assigned + 1
	    else:
		print object_fullpath + ": No shader found. Could not assign the texture."
		stat_noshader = stat_noshader + 1
	else:
	    #print "Could not find assigned shader on " + object_fullpath
	    continue

    print str(stat_assigned) + " textures assigned successfully."
    print str(stat_noshader) + " destination shaders not found."
Exemple #34
0
    def convert_geometry_to_sg_nodes(self):
        """
        Utility function to convert all Geometry nodes to Shotgun
        Geometry nodes (only converts Geometry nodes that were previously
        Shotgun Geometry nodes)

        # Example use:
        import sgtk
        eng = sgtk.platform.current_engine()
        app = eng.apps["tk-houdini-geometrynode"]
        # Convert previously converted Geometry nodes back to
        # Shotgun Geometry nodes:
        app.convert_from_geometry_nodes()
        """

        # get geometry nodes:
        sop_nodes = hou.nodeType(hou.sopNodeTypeCategory(),
                                 'rop_geometry').instances()
        rop_nodes = hou.nodeType(hou.ropNodeTypeCategory(),
                                 'geometry').instances()
        nodes = sop_nodes + rop_nodes
        for n in nodes:
            try:
                user_dict = n.userDataDict()

                profile = user_dict.get('tk_profile_name')

                if not profile:
                    # can't convert to a Shotgun Geometry Node
                    # as we have missing parameters!
                    continue

                # set as selected:
                # wn.setSelected(True)
                node_name = n.name()
                node_pos = n.position()

                self._app.log_debug('Converting node: {0}'.format(n.name()))
                self._app.log_debug('path: {0}'.format(n.path()))

                # create new Shotgun Geometry node:
                node_class = ToolkitGeometryNodeHandler.SG_NODE_CLASS
                new_sg_n = n.parent().createNode(node_class)

                # set the profile
                try:
                    parm = new_sg_n.parm(ToolkitGeometryNodeHandler.PARM_CONFIG)
                    index = parm.menuLabels().index(profile)
                    parm.set(index)
                except ValueError:
                    pass

                # copy across and knob values from the internal geometry node.
                exclude = ['sopoutput']
                self.__copy_parm_values(n, new_sg_n, exclude)

                # Copy inputs and move outputs
                self.__copy_inputs_to_node(n, new_sg_n)
                self.__move_outputs_to_node(n, new_sg_n)
                self.__move_outputs_from_user_data_to_node(n, new_sg_n)
                self.__copy_color(n, new_sg_n)

                # delete original node:
                n.destroy()

                # rename new node:
                new_sg_n.setName(node_name)
                new_sg_n.setPosition(node_pos)
            except Exception as err:
                self._app.log_warning(err)
                msg = 'Problems converting node: {0}'.format(n.path())
                self._app.log_warning(msg)
    def convert_to_regular_alembic_nodes(cls, app):
        """Convert Toolkit Alembic nodes to regular Alembic nodes.

        :param app: The calling Toolkit Application

        """

        tk_node_type = TkAlembicNodeHandler.TK_ALEMBIC_NODE_TYPE

        # determine the surface operator type for this class of node
        sop_types = hou.sopNodeTypeCategory().nodeTypes()
        sop_type = sop_types[tk_node_type]

        # determine the render operator type for this class of node
        rop_types = hou.ropNodeTypeCategory().nodeTypes()
        rop_type = rop_types[tk_node_type]

        # get all instances of tk alembic rop/sop nodes
        tk_alembic_nodes = []
        tk_alembic_nodes.extend(
            hou.nodeType(hou.sopNodeTypeCategory(), tk_node_type).instances())
        tk_alembic_nodes.extend(
            hou.nodeType(hou.ropNodeTypeCategory(), tk_node_type).instances())

        if not tk_alembic_nodes:
            app.log_debug("No Toolkit Alembic Nodes found for conversion.")
            return

        # iterate over all the tk alembic nodes and attempt to convert them
        for tk_alembic_node in tk_alembic_nodes:

            # determine the corresponding, built-in operator type
            if tk_alembic_node.type() == sop_type:
                alembic_operator = cls.HOU_SOP_ALEMBIC_TYPE
            elif tk_alembic_node.type() == rop_type:
                alembic_operator = cls.HOU_ROP_ALEMBIC_TYPE
            else:
                app.log_warning("Unknown type for node '%s': %s'" %
                    (tk_alembic_node.name(), tk_alembic_node.type()))
                continue

            # create a new, regular Alembic node
            alembic_node = tk_alembic_node.parent().createNode(alembic_operator)

            # copy the file parms value to the new node
            filename = _get_output_menu_label(
                tk_alembic_node.parm(cls.NODE_OUTPUT_PATH_PARM))
            alembic_node.parm(cls.NODE_OUTPUT_PATH_PARM).set(filename)

            # copy across knob values
            _copy_parm_values(tk_alembic_node, alembic_node,
                excludes=[cls.NODE_OUTPUT_PATH_PARM])

            # store the alembic output profile name in the user data so that we
            # can retrieve it later.
            output_profile_parm = tk_alembic_node.parm(
                cls.TK_OUTPUT_PROFILE_PARM)
            tk_output_profile_name = \
                output_profile_parm.menuLabels()[output_profile_parm.eval()]
            alembic_node.setUserData(cls.TK_OUTPUT_PROFILE_NAME_KEY, 
                tk_output_profile_name)

            # copy the inputs and move the outputs
            _copy_inputs(tk_alembic_node, alembic_node)
            if alembic_operator == cls.HOU_SOP_ALEMBIC_TYPE:
                _save_outputs_to_user_data(tk_alembic_node, alembic_node)
            elif alembic_operator == cls.HOU_ROP_ALEMBIC_TYPE:
                _move_outputs(tk_alembic_node, alembic_node)

            # make the new node the same color
            alembic_node.setColor(tk_alembic_node.color())

            # remember the name and position of the original tk alembic node
            tk_alembic_node_name = tk_alembic_node.name()
            tk_alembic_node_pos = tk_alembic_node.position()

            # destroy the original tk alembic node
            tk_alembic_node.destroy()

            # name and reposition the new, regular alembic node to match the
            # original
            alembic_node.setName(tk_alembic_node_name)
            alembic_node.setPosition(tk_alembic_node_pos)

            app.log_debug("Converted: Tk Alembic node '%s' to Alembic node."
                % (tk_alembic_node_name,))
Exemple #36
0
    def process(self, context):
        import os

        import clique

        import hou

        # Find nodes by class.
        nodes = []

        node_type = hou.nodeType("Driver/ifd")
        nodes.extend(node_type.instances())

        node_type = hou.nodeType(hou.ropNodeTypeCategory(), "alembic")
        nodes.extend(node_type.instances())

        node_type = hou.nodeType(hou.ropNodeTypeCategory(), "dop")
        nodes.extend(node_type.instances())

        node_type = hou.nodeType(hou.ropNodeTypeCategory(), 'geometry')
        nodes.extend(node_type.instances())

        # Categorize nodes based on whether they are in a network box starting
        # with "remote".
        nodes_local = list(nodes)
        for box in hou.node("out").networkBoxes():
            if box.name().lower().startswith("remote"):
                for node in box.nodes():
                    if node in nodes_local:
                        nodes_local.remove(node)

        # Creating instances per node.
        for node in nodes:

            # Haven't figured out distributed simulation yet, so ignoring it as
            # a special case.
            if node.type().name() == "dop" and node not in nodes_local:
                continue

            instance = context.create_instance(name=node.name())
            instance.data["publish"] = not node.isBypassed()
            instance.add(node)

            # Determine node type specifics.
            node_type = ""
            category = ""
            output_parm = ""

            if node.type().name() == "ifd":
                node_type = "mantra"
                category = "img"
                output_parm = "vm_picture"

                # Rendering *.ifd files.
                if node.parm("soho_outputmode").eval():
                    category = "render"
                    output_parm = "soho_diskfile"

            if node.type().name() == "alembic":
                node_type = "alembic"
                category = "cache"
                output_parm = "filename"

            if node.type().name() == "dop":
                node_type = "dynamics"
                category = "cache"
                output_parm = "dopoutput"

            if node.type().name() == "geometry":
                node_type = "geometry"
                category = "cache"
                output_parm = "sopoutput"

            # Get expected output files.
            files = []
            if node.parm("trange").eval() == 0:
                frame = int(hou.frame())
                files.append(node.parm(output_parm).evalAtFrame(frame))
            else:
                start = node.parm("f1").eval()
                end = node.parm("f2").eval()
                step = node.parm("f3").eval()
                for frame in range(int(start), int(end) + 1, int(step)):
                    files.append(node.parm(output_parm).evalAtFrame(frame))

            # Except for alembic output that only ever outputs to a single file
            if node_type == "alembic":
                files = [files[0]]

            # Get extension
            ext = os.path.splitext(files[0])[1]
            # Special case for *.bgeo.sc files since it was two "extensions".
            if files[0].endswith(".bgeo.sc"):
                ext = ".bgeo.sc"

            # Create output collection.
            collections = clique.assemble(files, minimum_items=1)[0]
            collection = None
            for col in collections:
                if col.format("{tail}") == ext:
                    collection = col

            instance.data["collection"] = collection

            # Assigning families.
            families = [node_type, category, ext[1:]]
            label = node.name() + " - " + category
            if node in nodes_local:
                families += ["local"]
                instance.data["label"] = label + " - local"
            else:
                families += ["remote"]
                instance.data["label"] = label + " - remote"

            instance.data["families"] = families
            instance.data["family"] = category
    def convert_back_to_tk_alembic_nodes(cls, app):
        """Convert Alembic nodes back to Toolkit Alembic nodes.

        :param app: The calling Toolkit Application

        Note: only converts nodes that had previously been Toolkit Alembic
        nodes.

        """

        # get all rop/sop alembic nodes in the session
        alembic_nodes = []
        alembic_nodes.extend(hou.nodeType(hou.sopNodeTypeCategory(),
            cls.HOU_SOP_ALEMBIC_TYPE).instances())
        alembic_nodes.extend(hou.nodeType(hou.ropNodeTypeCategory(),
            cls.HOU_ROP_ALEMBIC_TYPE).instances())

        if not alembic_nodes:
            app.log_debug("No Alembic Nodes found for conversion.")
            return

        # the tk node type we'll be converting to
        tk_node_type = TkAlembicNodeHandler.TK_ALEMBIC_NODE_TYPE

        # iterate over all the alembic nodes and attempt to convert them
        for alembic_node in alembic_nodes:

            # get the user data dictionary stored on the node
            user_dict = alembic_node.userDataDict()

            # get the output_profile from the dictionary
            tk_output_profile_name = user_dict.get(
                cls.TK_OUTPUT_PROFILE_NAME_KEY)

            if not tk_output_profile_name:
                app.log_warning(
                    "Almbic node '%s' does not have an output profile name. "
                    "Can't convert to Tk Alembic node. Continuing." %
                    (alembic_node.name(),)
                )
                continue

            # create a new, Toolkit Alembic node:
            tk_alembic_node = alembic_node.parent().createNode(tk_node_type)

            # find the index of the stored name on the new tk alembic node
            # and set that item in the menu.
            try:
                output_profile_parm = tk_alembic_node.parm(
                    TkAlembicNodeHandler.TK_OUTPUT_PROFILE_PARM)
                output_profile_index = output_profile_parm.menuLabels().index(
                    tk_output_profile_name)
                output_profile_parm.set(output_profile_index)
            except ValueError:
                app.log_warning("No output profile found named: %s" % 
                    (tk_output_profile_name,))

            # copy over all parameter values except the output path 
            _copy_parm_values(alembic_node, tk_alembic_node,
                excludes=[cls.NODE_OUTPUT_PATH_PARM])

            # copy the inputs and move the outputs
            _copy_inputs(alembic_node, tk_alembic_node)

            # determine the built-in operator type
            if alembic_node.type().name() == cls.HOU_SOP_ALEMBIC_TYPE:
                _restore_outputs_from_user_data(alembic_node, tk_alembic_node)
            elif alembic_node.type().name() == cls.HOU_ROP_ALEMBIC_TYPE:
                _move_outputs(alembic_node, tk_alembic_node)

            # make the new node the same color. the profile will set a color, 
            # but do this just in case the user changed the color manually
            # prior to the conversion.
            tk_alembic_node.setColor(alembic_node.color())

            # remember the name and position of the original alembic node
            alembic_node_name = alembic_node.name()
            alembic_node_pos = alembic_node.position()

            # destroy the original alembic node
            alembic_node.destroy()

            # name and reposition the new, regular alembic node to match the
            # original
            tk_alembic_node.setName(alembic_node_name)
            tk_alembic_node.setPosition(alembic_node_pos)

            app.log_debug("Converted: Alembic node '%s' to TK Alembic node."
                % (alembic_node_name,))
Exemple #38
0
    def test_typeIsPython(self):
        nodeType = hou.nodeType(hou.sopNodeTypeCategory(), "tableimport")

        self.assertTrue(nodeType.isPython())
Exemple #39
0
def camImport():
    node = hou.pwd()
    clearKeys(node)
    file = node.parm("json").eval()
    if os.path.isfile(file):
        jsonData = open(file, "r")
        camData = json.load(jsonData)

        res = camData[1]["resolution"]
        fr = camData[1]["frames"]
        pos = camData[1]["camPos"]
        look = camData[1]["camCentInt"]
        up = camData[1]["camUpVector"]
        focal = camData[1]["camFocal"]
        aperture = camData[1]["camAperture"]
        clip = camData[1]["camClip"]
        fdist = camData[1]["camFocusDistance"]
        fstop = camData[1]["camFStop"]
        mblur = camData[1]["motionBlurBy"]
        p_dist = camData[1]["p_distance"]
        p_rad = camData[1]["p_radius"]
        camType = "stereocamrig"

        paralax = camData[1]["camStereoParallax"]
        ditance = camData[1]["camStereoDistance"]

        if not paralax:
            camType = "cam"

        origin = node.node("origin")
        lookat = node.node("lookat")
        cams = [None, None, None]

        for child in node.children():
            if child.type() == hou.nodeType(hou.objNodeTypeCategory(),
                                            "cam") and child.name() == 'cam':
                cams[0] = child
            if child.type() == hou.nodeType(hou.objNodeTypeCategory(),
                                            "cam") and child.name() == 'persp':
                cams[1] = child
            if child.type() == hou.nodeType(hou.objNodeTypeCategory(),
                                            "stereocamrig"):
                cams[2] = child

        for cam in cams:
            cam.parm("resx").set(res[0])
            cam.parm("resy").set(res[1])
            cam.parm("shutter").set(mblur[0] * 0.4)
            cam.parm("lookatpath").set("../lookat")
            lens = cam.node('./shopnet1/miDOF_lens')
            if lens:
                cam.parm('projection').set(4)
                cam.parm('vm_lensshader').set('./shopnet1/miDOF_lens')

            iter = 0
            for frame in fr:
                objSetKey(cam.parm("upx"), frame, up[iter][0])
                objSetKey(cam.parm("upy"), frame, up[iter][1])
                objSetKey(cam.parm("upz"), frame, up[iter][2])
                objSetKey(cam.parm("focal"), frame, focal[iter])
                objSetKey(cam.parm("aperture"), frame,
                          aperture[iter][0] * 25.4)
                objSetKey(cam.parm("near"), frame, clip[iter][0])
                objSetKey(cam.parm("far"), frame, clip[iter][1])
                objSetKey(cam.parm("focus"), frame, fdist[iter])
                objSetKey(cam.parm("fstop"), frame, fstop[iter])

                if lens:
                    objSetKey(lens.parm("focus"), frame, p_dist[iter])
                    objSetKey(lens.parm("radius"), frame, p_rad[iter])

                if camType == "stereocamrig" and cam == cams[1]:
                    objSetKey(cam.parm("ZPS"), frame, paralax[iter])
                    objSetKey(cam.parm("interaxial"), frame, ditance[iter])
                iter += 1

        cams[2].parm("lookatpath").set("../lookat_stereo")

        iter = 0
        for frame in fr:
            objSetKey(origin.parm("tx"), frame, pos[iter][0])
            objSetKey(origin.parm("ty"), frame, pos[iter][1])
            objSetKey(origin.parm("tz"), frame, pos[iter][2])

            objSetKey(lookat.parm("tx"), frame, look[iter][0])
            objSetKey(lookat.parm("ty"), frame, look[iter][1])
            objSetKey(lookat.parm("tz"), frame, look[iter][2])
            iter += 1
    def _get_rendered_image_items(self):
        """Scan the file for tk mantra nodes with already rendered images."""

        app = self.parent

        # see if the mantranode app is installed
        mantra_app = app.engine.apps.get("tk-houdini-mantranode", None)
        if not mantra_app:
            app.log_info(
                "Will not attempt to scan for rendered images."
                "The 'tk-houdini-mantranode' app is not installed."
            )
            return []

        # find all the tk mantra nodes
        tk_mantra_nodes = hou.nodeType(hou.ropNodeTypeCategory(),
            "sgtk_mantra").instances()

        # get the current version from the work file
        work_template = mantra_app.get_template("work_file_template")
        scene_name = str(hou.hipFile.name())
        scene_path = os.path.abspath(scene_name)
        fields = work_template.get_fields(scene_path)
        cur_version = fields["version"]

        # get the output_profiles for the app
        output_profiles = {}
        for output_profile in mantra_app.get_setting("output_profiles"):
            name = output_profile["name"]
            output_profiles[name] = output_profile

        render_items = []

        # for each mantra node, see which output profile is selected.
        # get the template for the selected profile and see if there are 
        # any images on disk matching the pattern. if so, add them to the
        # list of rendered items to be returned.
        for tk_mantra_node in tk_mantra_nodes:
            output_profile_parm = tk_mantra_node.parm("sgtk_output_profile")
            output_profile_name = \
                output_profile_parm.menuLabels()[output_profile_parm.eval()]
            output_profile = output_profiles[output_profile_name]
            output_template = mantra_app.get_template_by_name(
                output_profile["output_render_template"])

            paths = mantra_app.engine.tank.abstract_paths_from_template(
                    output_template, {"SEQ": "FORMAT: %d", "version": cur_version})

            if not paths:
                continue

            if len(paths) == 1:
                if paths:
                    render_items.append({
                        "type": "rendered_image",
                        "name": tk_mantra_node.name(),
                        "other_params": {'path': paths[0]},
                    })
            else:
                app.log_warning(
                    "Found multiple potential rendered image paths for "
                    "mantra node '%s'. Skipping these paths:\n  '%s'" % 
                    (tk_mantra_node.name(), "\n  ".join(paths))
                )
    
        return render_items
Exemple #41
0
import hou

#Set DefaultShape & Color Redshift Lights
hou.nodeType(hou.objNodeTypeCategory(),
             "rslight").setDefaultColor(hou.Color(1, 1, 0))
hou.nodeType(hou.objNodeTypeCategory(), "rslight").setDefaultShape('light')

hou.nodeType(hou.objNodeTypeCategory(),
             "rslighties").setDefaultColor(hou.Color(1, 1, 0))
hou.nodeType(hou.objNodeTypeCategory(), "rslighties").setDefaultShape('light')

hou.nodeType(hou.objNodeTypeCategory(),
             "rslightportal").setDefaultColor(hou.Color(1, 1, 0))
hou.nodeType(hou.objNodeTypeCategory(),
             "rslightportal").setDefaultShape('light')

hou.nodeType(hou.objNodeTypeCategory(),
             "rslightsun").setDefaultColor(hou.Color(1, 1, 0))
hou.nodeType(hou.objNodeTypeCategory(), "rslightsun").setDefaultShape('light')

hou.nodeType(hou.objNodeTypeCategory(),
             "rslightdome::2.0").setDefaultColor(hou.Color(1, 1, 0))
hou.nodeType(hou.objNodeTypeCategory(),
             "rslightdome::2.0").setDefaultShape('light')
Exemple #42
0
def isActive():
    return hou.nodeType(hou.ropNodeTypeCategory(), "Octane_ROP") is not None
    def convert_back_to_tk_mantra_nodes(cls, app):
        """Convert Mantra nodes back to Toolkit Mantra nodes.

        :param app: The calling Toolkit Application

        Note: only converts nodes that had previously been Toolkit Mantra
        nodes.

        """

        # get all instances of the built-in mantra nodes
        mantra_nodes = hou.nodeType(hou.ropNodeTypeCategory(),
                                    cls.HOU_MANTRA_NODE_TYPE).instances()

        if not mantra_nodes:
            app.log_debug("No Mantra Nodes found for conversion.")
            return

        # iterate over all the mantra nodes and attempt to convert them
        for mantra_node in mantra_nodes:

            # get the user data dictionary stored on the node
            user_dict = mantra_node.userDataDict()

            # get the output_profile from the dictionary
            tk_output_profile_name = user_dict.get(
                cls.TK_OUTPUT_PROFILE_NAME_KEY)

            if not tk_output_profile_name:
                app.log_warning(
                    "Mantra node '%s' does not have an output profile name. "
                    "Can't convert to Tk Mantra node. Continuing." %
                    (mantra_node.name(), ))
                continue

            # create new Shotgun Write node:
            tk_node_type = TkMantraNodeHandler.TK_MANTRA_NODE_TYPE
            tk_mantra_node = mantra_node.parent().createNode(tk_node_type)

            # find the index of the stored name on the new tk mantra node
            # and set that item in the menu.
            try:
                output_profile_parm = tk_mantra_node.parm(
                    TkMantraNodeHandler.TK_OUTPUT_PROFILE_PARM)
                output_profile_index = output_profile_parm.menuLabels().index(
                    tk_output_profile_name)
                output_profile_parm.set(output_profile_index)
            except ValueError:
                app.log_warning("No output profile found named: %s" %
                                (tk_output_profile_name, ))

            # copy over all parameter values except the output path
            _copy_parm_values(mantra_node, tk_mantra_node, excludes=[])

            # explicitly copy AOV settings to the new tk mantra node
            plane_numbers = _get_extra_plane_numbers(mantra_node)
            for plane_number in plane_numbers:
                plane_parm_name = cls.TK_EXTRA_PLANES_NAME % (plane_number, )
                aov_name = user_dict.get(plane_parm_name)
                tk_mantra_node.parm(plane_parm_name).set(aov_name)

            # copy the inputs and move the outputs
            _copy_inputs(mantra_node, tk_mantra_node)
            _move_outputs(mantra_node, tk_mantra_node)

            # make the new node the same color. the profile will set a color,
            # but do this just in case the user changed the color manually
            # prior to the conversion.
            tk_mantra_node.setColor(mantra_node.color())

            # remember the name and position of the original mantra node
            mantra_node_name = mantra_node.name()
            mantra_node_pos = mantra_node.position()

            # destroy the original mantra node
            mantra_node.destroy()

            # name and reposition the new, regular mantra node to match the
            # original
            tk_mantra_node.setName(mantra_node_name)
            tk_mantra_node.setPosition(mantra_node_pos)

            app.log_debug("Converted: Mantra node '%s' to TK Mantra node." %
                          (mantra_node_name, ))
Exemple #44
0
    def test_typeIsNotPython(self):
        nodeType = hou.nodeType(hou.sopNodeTypeCategory(), "file")

        self.assertFalse(nodeType.isPython())
Exemple #45
0
    def convert_to_regular_mantra_nodes(cls, app):
        """Convert Toolkit Mantra nodes to regular Mantra nodes.

        :param app: The calling Toolkit Application

        """

        # get all instances of tk mantra nodes
        tk_node_type = TkMantraNodeHandler.TK_MANTRA_NODE_TYPE
        tk_mantra_nodes = hou.nodeType(
            hou.ropNodeTypeCategory(), tk_node_type).instances()

        if not tk_mantra_nodes:
            app.log_debug("No Toolkit Mantra Nodes found for conversion.")
            return

        for tk_mantra_node in tk_mantra_nodes:

            # create a new, regular Mantra node
            mantra_node = tk_mantra_node.parent().createNode(
                cls.HOU_MANTRA_NODE_TYPE)

            # copy across knob values
            exclude_parms = [parm for parm in tk_mantra_node.parms() 
                if parm.name().startswith("sgtk_")]
            _copy_parm_values(tk_mantra_node, mantra_node,
                excludes=exclude_parms)

            # store the mantra output profile name in the user data so that we
            # can retrieve it later.
            output_profile_parm = tk_mantra_node.parm(
                cls.TK_OUTPUT_PROFILE_PARM)
            tk_output_profile_name = \
                output_profile_parm.menuLabels()[output_profile_parm.eval()]
            mantra_node.setUserData(cls.TK_OUTPUT_PROFILE_NAME_KEY, 
                tk_output_profile_name)

            # store AOV info on the new node
            plane_numbers = _get_extra_plane_numbers(tk_mantra_node)
            for plane_number in plane_numbers:
                plane_parm_name = cls.TK_EXTRA_PLANES_NAME % (plane_number,)
                mantra_node.setUserData(plane_parm_name,
                    tk_mantra_node.parm(plane_parm_name).eval())

            # copy the inputs and move the outputs
            _copy_inputs(tk_mantra_node, mantra_node)
            _move_outputs(tk_mantra_node, mantra_node)

            # make the new node the same color
            mantra_node.setColor(tk_mantra_node.color())

            # remember the name and position of the original tk mantra node
            tk_mantra_node_name = tk_mantra_node.name()
            tk_mantra_node_pos = tk_mantra_node.position()

            # destroy the original tk mantra node
            tk_mantra_node.destroy()

            # name and reposition the new, regular mantra node to match the
            # original
            mantra_node.setName(tk_mantra_node_name)
            mantra_node.setPosition(tk_mantra_node_pos)

            app.log_debug("Converted: Tk Mantra node '%s' to Mantra node."
                % (tk_mantra_node_name,))
Exemple #46
0
    def test_typeIsNotSubnet(self):
        nodeType = hou.nodeType(hou.objNodeTypeCategory(), "geo")

        self.assertFalse(nodeType.isSubnetType())
    def _get_rendered_image_items(self):
        """Scan the file for tk mantra nodes to potentially publish."""

        app = self.parent

        # see if the mantranode app is installed
        mantra_app = app.engine.apps.get("tk-houdini-mantranode", None)
        if not mantra_app:
            app.log_info(
                "Will not attempt to scan for rendered images."
                "The 'tk-houdini-mantranode' app is not installed."
            )
            return []

        # find all the tk mantra nodes
        tk_mantra_nodes = hou.nodeType(hou.ropNodeTypeCategory(),
            "sgtk_mantra").instances()

        render_items = []

        # get the current version from the work file
        work_template = mantra_app.get_template("work_file_template")
        scene_name = str(hou.hipFile.name())
        scene_path = os.path.abspath(scene_name)
        fields = work_template.get_fields(scene_path)
        cur_version = fields["version"]
        fields["SEQ"] = "FORMAT: %d"

        # get the output_profiles for the app. More efficient to do this here
        # than to repeat this logic per item in the secondary publish hook.
        output_profiles = {}
        for output_profile in mantra_app.get_setting("output_profiles"):
            name = output_profile["name"]
            output_profiles[name] = output_profile

        # for each mantra node, see which output profile is selected.
        # get the template for the selected profile. the validation hook will
        # check see if there are any images on disk matching the pattern
        for tk_mantra_node in tk_mantra_nodes:

            output_profile_parm = tk_mantra_node.parm("sgtk_output_profile")
            output_profile_name = \
                output_profile_parm.menuLabels()[output_profile_parm.eval()]
            output_profile = output_profiles[output_profile_name]
            output_template = mantra_app.get_template_by_name(
                output_profile["output_render_template"])

            is_bypassed = tk_mantra_node.isBypassed()

            paths = mantra_app.engine.tank.abstract_paths_from_template(
                output_template, fields)

            # normalize the paths
            paths = [os.path.normpath(p) for p in paths]

            # only select the item if the output path exists and the node is
            # not bypassed.
            should_select = len(paths) == 1 and not is_bypassed

            render_items.append({
                "type": "rendered_image",
                "name": tk_mantra_node.name(),
                "description": "Full Path: %s" % (tk_mantra_node.path(),),
                "selected": should_select,
                "other_params": {
                    "paths": paths,
                    "node": tk_mantra_node,
                },
            })

        return render_items
Exemple #48
0
def isActive():
	return hou.nodeType(hou.ropNodeTypeCategory(), "arnold") is not None
Exemple #49
0
def stringToNodes(s,
                  hou_parent=None,
                  ne=None,
                  ignore_hdas_if_already_defined=None,
                  force_prefer_hdas=None):
    '''
	TODO: here to be a docstring
	:param s:
	:param hou_parent:
	:param ne:
	:param ignore_hdas_if_already_defined:
	:param force_prefer_hdas:
	:return:
	'''
    if (ignore_hdas_if_already_defined is None):
        ignore_hdas_if_already_defined = True
        if (opt is not None):
            ignore_hdas_if_already_defined = opt.getOption(
                'hpaste.ignore_hdas_if_already_defined',
                ignore_hdas_if_already_defined)

    if (force_prefer_hdas is None):
        force_prefer_hdas = False
        if (opt is not None):
            force_prefer_hdas = opt.getOption('hpaste.force_prefer_hdas',
                                              force_prefer_hdas)

    paste_to_cursor = ne is not None
    if (hou_parent is None):
        if (ne is None):
            ne = hou.ui.paneTabOfType(hou.paneTabType.NetworkEditor)
            if (ne is None):
                raise RuntimeError("cannot find opened network editor")
        hou_parent = ne.pwd()

    s = str(s)  # ununicode. there should not be any unicode in it anyways
    try:
        data = json.loads(bz2.decompress(base64.urlsafe_b64decode(s)))
    except Exception as e:
        raise RuntimeError(
            "input data is either corrupted or just not a nodecode: " +
            str(e.message))

    # check version
    formatVersion = data['version']
    if (formatVersion > 2):
        raise RuntimeError(
            "unsupported version of data format. Try updating hpaste to the latest version"
        )

    # check accepted algtypes
    houver1 = hou.applicationVersion()
    supportedAlgs = set()
    if (houver1[0] == 15):
        supportedAlgs.add(0)
        supportedAlgs.add(1)
        supportedAlgs.add(2)  #WITH BIG WARNING!!!
    if (houver1[0] >= 16):
        supportedAlgs.add(0)
        supportedAlgs.add(1)
        supportedAlgs.add(2)
    algtype = data['algtype']
    if (algtype not in supportedAlgs):
        raise RuntimeError(
            "algorithm type is not supported by this houdini version, :( ")

    # check hou version
    houver2 = data['houver']
    if (houver1[0] != houver2[0] or houver1[1] != houver2[1]):
        print(
            "HPaste: WARNING!! nodes were copied from a different houdini version: "
            + str(houver2))

    # check context
    context = getChildContext(hou_parent, houver1)
    if (context != data['context']):
        raise RuntimeError("this snippet has '%s' context" % data['context'])

    # check sum
    code = data['code']
    if (hashlib.sha1(code).hexdigest() != data['chsum']):
        raise RuntimeError("checksum failed!")

    if (paste_to_cursor):
        if (houver1[0] == 16):
            olditems = hou_parent.allItems()
        else:
            olditems = hou_parent.children()

    # do the work
    for hdaitem in data.get('hdaList', []):  # added in version 2.1
        hdacode = base64.b64decode(hdaitem['code'])
        ntype = hdaitem['type']
        ncategory = hdaitem['category']
        if (ignore_hdas_if_already_defined):
            nodeType = hou.nodeType(hou.nodeTypeCategories()[ncategory], ntype)
            if (nodeType is not None):
                #well, that's already a bad sign, means it is installed
                continue

        fd, temppath = tempfile.mkstemp()
        try:
            with open(temppath, 'wb') as f:
                f.write(hdacode)
            for hdadef in hou.hda.definitionsInFile(temppath):
                hdadef.copyToHDAFile('Embedded')
                #hdadef.save('Embedded')
        finally:
            os.close(fd)

        if (force_prefer_hdas):
            embhdas = [
                x for x in hou.hda.definitionsInFile("Embedded")
                if (x.nodeType().name() == ntype
                    and x.nodeTypeCategory().name() == ncategory)
            ]
            if (len(embhdas) == 1):
                embhdas[0].setIsPreferred(True)

    #now nodes themselves
    if (formatVersion == 1):
        code = binascii.a2b_qp(code)
    elif (formatVersion >= 2):
        code = base64.b64decode(code)
    else:
        raise RuntimeError(
            "Very unexpected format version in a very inexpected place!")

    if (algtype == 0):
        # high security risk!!
        if (hou.isUiAvailable()):
            ok = hou.ui.displayMessage(
                "WARNING! The algorithm type used by the pasted snipped is legacy and present HIGH SECURITY RISK!\n be sure you TRUST THE SOURCE of the snippet!",
                ("CANCEL", "ok"),
                severity=hou.severityType.Warning,
                close_choice=0,
                title="SECURITY WARNING")
        else:
            ok = 0
            print(
                "for now u cannot paste SECURITY RISK snippets in non-interactive mode"
            )
        if (ok != 1): return

        exec(code, {}, {'hou': hou, 'hou_parent': hou_parent})
    elif (algtype == 1 or algtype == 2):
        # get temp file
        fd, temppath = tempfile.mkstemp()
        try:
            with open(temppath, "wb") as f:
                f.write(code)
            try:
                if (algtype == 1):
                    hou_parent.loadChildrenFromFile(temppath)
                if (algtype == 2):
                    try:
                        hou_parent.loadItemsFromFile(temppath)
                    except AttributeError:
                        print(
                            "WARNING!!! your hou version does not support algorithm used for copying, TRYING possibly partly backward-INCOMPATIBLE method!"
                        )
                        print("CHECK SCENE INTEGRITY")
                        hou_parent.loadChildrenFromFile(temppath)
            except hou.LoadWarning as e:
                msg = e.instanceMessage()
                print(msg)

                # truncate just for display with random number 253
                msgtrunc = False
                if (len(msg) > 253):
                    msgtrunc = True
                    msg = msg[:253] + "..."
                raise RuntimeWarning("There were warnings during load" + (
                    "(see console for full message)" if msgtrunc else "") +
                                     "\n" + msg)
        finally:
            os.close(fd)
    else:
        raise RuntimeError(
            "algorithm type is not supported. Try updating hpaste to the latest version"
        )

    if (paste_to_cursor):
        #now collect pasted nodes
        if (houver1[0] >= 16):
            newitems = [x for x in hou_parent.allItems() if x not in olditems]
        else:
            newitems = [x for x in hou_parent.children() if x not in olditems]

        if (len(newitems) == 0): return
        #calc center
        cpos = hou.Vector2()
        bbmin = hou.Vector2()
        bbmax = hou.Vector2()
        cnt = 0
        for item in newitems:
            cnt += 1
            pos = item.position()
            cpos += pos
            for i in [0, 1]:
                if (pos[i] > bbmax[i] or cnt == 1): bbmax[i] = pos[i]
                if (pos[i] < bbmin[i] or cnt == 1): bbmin[i] = pos[i]

        cpos = cpos / cnt
        cpos[1] = bbmax[1]
        offset = ne.cursorPosition() - cpos
        for item in newitems:
            if (houver1[0] >= 16 and item.parentNetworkBox() in newitems):
                continue
            item.move(offset)