Houdini: Implement Load Asset LOP HDA

server_addon/houdini/client/ayon_houdini/api/lib.py

@@ -1037,6 +1037,231 @@ def sceneview_snapshot(
     log.debug("A snapshot of sceneview has been saved to: {}".format(filepath))
 
 
+def get_background_images(node, raw=False):
+    """"Return background images defined inside node.
+
+    Similar to `nodegraphutils.saveBackgroundImages` but this method also
+    allows to retrieve the data as JSON encodable data instead of
+    `hou.NetworkImage` instances when using `raw=True`
+    """
+
+    def _parse(image_data):
+        image = hou.NetworkImage(image_data["path"],
+                                 hou.BoundingRect(*image_data["rect"]))
+        if "relativetopath" in image_data:
+            image.setRelativeToPath(image_data["relativetopath"])
+        if "brightness" in image_data:
+            image.setBrightness(image_data["brightness"])
+        return image
+
+    data = node.userData("backgroundimages")
+    if not data:
+        return []
+
+    try:
+        images = json.loads(data)
+    except json.decoder.JSONDecodeError:
+        images = []
+
+    if not raw:
+        images = [_parse(_data) for _data in images]
+    return images
+
+
+def set_background_images(node, images):
+    """Set hou.NetworkImage background images under given hou.Node
+
+    Similar to: `nodegraphutils.loadBackgroundImages`
+
+    """
+
+    def _serialize(image):
+        """Return hou.NetworkImage as serialized dict"""
+        if isinstance(image, dict):
+            # Assume already serialized, only do some minor validations
+            if "path" not in image:
+                raise ValueError("Missing `path` key in image dictionary.")
+            if "rect" not in image:
+                raise ValueError("Missing `rect` key in image dictionary.")
+            if len(image["rect"]) != 4:
+                raise ValueError("`rect` value must be list of four floats.")
+            return image
+
+        rect = image.rect()
+        rect_min = rect.min()
+        rect_max = rect.max()
+        data = {
+            "path": image.path(),
+            "rect": [rect_min.x(), rect_min.y(), rect_max.x(), rect_max.y()],
+        }
+        if image.brightness() != 1.0:
+            data["brightness"] = image.brightness()
+        if image.relativeToPath():
+            data["relativetopath"] = image.relativeToPath()
+        return data
+
+    with hou.undos.group('Edit Background Images'):
+        if images:
+            assert all(isinstance(image, (dict, hou.NetworkImage))
+                       for image in images)
+            data = json.dumps([_serialize(image) for image in images])
+            node.setUserData("backgroundimages", data)
+        else:
+            node.destroyUserData("backgroundimages", must_exist=False)
+
+
+def set_node_thumbnail(node, image_path, rect=None):
+    """Set hou.NetworkImage attached to node.
+
+    If an existing connected image is found it assumes that is the existing
+    thumbnail and will update that particular instance instead.
+
+    When `image_path` is None an existing attached `hou.NetworkImage` will be
+    removed.
+
+    Arguments:
+        node (hou.Node): Node to set thumbnail for.
+        image_path (Union[str, None]): Path to image to set.
+            If None is set then the thumbnail will be removed if it exists.
+        rect (hou.BoundingRect): Bounding rect for the relative placement
+            to the node.
+
+    Returns:
+        hou.NetworkImage or None: The network image that was set or None if
+            instead it not set or removed.
+
+    """
+
+    parent = node.parent()
+    images = get_background_images(parent)
+
+    node_path = node.path()
+    # Find first existing image attached to node
+    index, image = next(
+        (
+            (index, image) for index, image in enumerate(images) if
+            image.relativeToPath() == node_path
+        ),
+        (None, None)
+    )
+    if image_path is None:
+        # Remove image if it exists
+        if image:
+            images.remove(image)
+            set_background_images(parent, images)
+        return
+
+    if rect is None:
+        rect = hou.BoundingRect(-1, -1, 1, 1)
+
+    if isinstance(image_path, hou.NetworkImage):
+        image = image_path
+        if index is not None:
+            images[index] = image
+        else:
+            images.append(image)
+    elif image is None:
+        # Create the image
+        image = hou.NetworkImage(image_path, rect)
+        image.setRelativeToPath(node.path())
+        images.append(image)
+    else:
+        # Update first existing image
+        image.setRect(rect)
+        image.setPath(image_path)
+
+    set_background_images(parent, images)
+
+    return image
+
+
+def remove_all_thumbnails(node):
+    """Remove all node thumbnails.
+
+    Removes all network background images that are linked to the given node.
+    """
+    parent = node.parent()
+    images = get_background_images(parent)
+    node_path = node.path()
+    images = [
+        image for image in images if image.relativeToPath() != node_path
+    ]
+    set_background_images(parent, images)
+
+
+def get_node_thumbnail(node, first_only=True):
+    """Return node thumbnails.
+
+    Return network background images that are linked to the given node.
+    By default, only returns the first one found, unless `first_only` is False.
+
+    Returns:
+        Union[hou.NetworkImage, List[hou.NetworkImage]]:
+            Connected network images
+
+    """
+    parent = node.parent()
+    images = get_background_images(parent)
+    node_path = node.path()
+
+    def is_attached_to_node(image):
+        return image.relativeToPath() == node_path
+
+    attached_images = filter(is_attached_to_node, images)
+
+    # Find first existing image attached to node
+    if first_only:
+        return next(attached_images, None)
+    else:
+        return attached_images
+
+
+def find_active_network(category, default):
+    """Find the first active network editor in the UI.
+
+    If no active network editor pane is found at the given category then the
+    `default` path will be used as fallback.
+
+    For example, to find an active LOPs network:
+    >>> network = find_active_network(
+    ...     category=hou.lopNodeTypeCategory(),
+    ...     fallback="/stage"
+    ... )
+    hou.Node("/stage/lopnet1")
+
+    Arguments:
+        category (hou.NodeTypeCategory): The node network category type.
+        default (str): The default path to fallback to if no active pane
+            is found with the given category.
+
+    Returns:
+        hou.Node: The node network to return.
+
+    """
+    # Find network editors that are current tab of given category
+    index = 0
+    while True:
+        pane = hou.ui.paneTabOfType(hou.paneTabType.NetworkEditor, index)
+        if pane is None:
+            break
+
+        index += 1
+        if not pane.isCurrentTab():
+            continue
+
+        pwd = pane.pwd()
+        if pwd.type().category() != category:
+            continue
+
+        if not pwd.isEditable():
+            continue
+
+        return pwd
+
+    # Default to the fallback if no valid candidate was found
+    return hou.node(default)
+
+
 def update_content_on_context_change():
     """Update all Creator instances to current asset"""
     host = registered_host()

server_addon/houdini/client/ayon_houdini/api/pipeline.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 """Pipeline tools for OpenPype Houdini integration."""
 import os
+import six
+import json
 import logging
 
 import hou  # noqa
@@ -26,6 +28,8 @@
     env_value_to_bool,
 )
 
+from .lib import JSON_PREFIX
+
 
 log = logging.getLogger("ayon_houdini")
 
@@ -258,7 +262,25 @@ def parse_container(container):
         dict: The container schema data for this container node.
 
     """
-    data = lib.read(container)
+    # Read only relevant parms
+    # TODO: Clean up this hack replacing `lib.read(container)`
+
+    data = {}
+    for name in ["name", "namespace", "loader", "representation", "id"]:
+        parm = container.parm(name)
+        if not parm:
+            return {}
+
+        value = parm.eval()
+
+        # test if value is json encoded dict
+        if isinstance(value, str) and value.startswith(JSON_PREFIX):
+            try:
+                value = json.loads(value[len(JSON_PREFIX):])
+            except json.JSONDecodeError:
+                # not a json
+                pass
+        data[name] = value
 
     # Backwards compatibility pre-schemas for containers
     data["schema"] = data.get("schema", "openpype:container-1.0")

server_addon/houdini/client/ayon_houdini/plugins/load/load_asset_lop.py

@@ -0,0 +1,52 @@
+from ayon_core.pipeline import load
+from ayon_houdini.api.lib import find_active_network
+
+import hou
+
+
+class LOPLoadAssetLoader(load.LoaderPlugin):
+    """Load reference/payload into Solaris using AYON `lop_import` LOP"""
+
+    product_types = {"*"}
+    label = "Load Asset (LOPs)"
+    representations = ["usd", "abc", "usda", "usdc"]
+    order = -10
+    icon = "code-fork"
+    color = "orange"
+
+    def load(self, context, name=None, namespace=None, data=None):
+
+        # Define node name
+        namespace = namespace if namespace else context["folder"]["name"]
+        node_name = "{}_{}".format(namespace, name) if namespace else name
+
+        # Create node
+        network = find_active_network(
+            category=hou.lopNodeTypeCategory(),
+            default="/stage"
+        )
+        node = network.createNode("ayon::lop_import", node_name=node_name)
+        node.moveToGoodPosition()
+
+        # Set representation id
+        parm = node.parm("representation")
+        parm.set(context["representation"]["id"])
+        parm.pressButton()  # trigger callbacks
+
+        nodes = [node]
+        self[:] = nodes
+
+    def update(self, container, context):
+        node = container["node"]
+
+        # Set representation id
+        parm = node.parm("representation")
+        parm.set(context["representation"]["id"])
+        parm.pressButton()  # trigger callbacks
+
+    def remove(self, container):
+        node = container["node"]
+        node.destroy()
+
+    def switch(self, container, context):
+        self.update(container, context)

server_addon/houdini/client/ayon_houdini/startup/otls/ayon_lop_import.hda/INDEX__SECTION

@@ -0,0 +1,13 @@
+Operator:     ayon::lop_import::1.0
+Label:        AYON Load Asset
+Path:         oplib:/ayon::Lop/lop_import::1.0?ayon::Lop/lop_import::1.0
+Icon:         opdef:/ayon::Lop/lop_import::1.0?IconImage
+Table:        Lop
+License:
+Extra:
+User:
+Inputs:       0 to 1
+Subnet:       true
+Python:       false
+Empty:        false
+Modified:     Thu Jun  10 16:44:00 2024

server_addon/houdini/client/ayon_houdini/startup/otls/ayon_lop_import.hda/Sections.list

@@ -0,0 +1,4 @@
+""
+INDEX__SECTION	INDEX_SECTION
+houdini.hdalibrary	houdini.hdalibrary
+ayon_8_8Lop_1lop__import_8_81.0	ayon::Lop/lop_import::1.0

server_addon/houdini/client/ayon_houdini/startup/otls/ayon_lop_import.hda/ayon_8_8Lop_1lop__import_8_81.0/Contents.dir/Contents.createtimes

@@ -0,0 +1,6 @@
+{
+	"hdaroot/warn_no_representation_set.def":1708980551,
+	"hdaroot/reference.def":1698150558,
+	"hdaroot/output0.def":1698215383,
+	"hdaroot.def":1717451587
+}

server_addon/houdini/client/ayon_houdini/startup/otls/ayon_lop_import.hda/ayon_8_8Lop_1lop__import_8_81.0/Contents.dir/Contents.houdini_versions

@@ -0,0 +1,9 @@
+{
+	"values":["20.0.703"
+	],
+	"indexes":{
+		"hdaroot/warn_no_representation_set.userdata":0,
+		"hdaroot/reference.userdata":0,
+		"hdaroot/output0.userdata":0
+	}
+}