Feature: USD Workflow for Maya, Houdini and Blender

openpype/hosts/blender/api/lib.py

@@ -365,3 +365,62 @@ def maintained_time():
         yield
     finally:
         bpy.context.scene.frame_current = current_time
+
+
+def get_all_parents(obj):
+    """Get all recursive parents of object.
+
+    Arguments:
+        obj (bpy.types.Object): Object to get all parents for.
+
+    Returns:
+        List[bpy.types.Object]: All parents of object
+
+    """
+    result = []
+    while True:
+        obj = obj.parent
+        if not obj:
+            break
+        result.append(obj)
+    return result
+
+
+def get_highest_root(objects):
+    """Get the highest object (the least parents) among the objects.
+
+    If multiple objects have the same amount of parents (or no parents) the
+    first object found in the input iterable will be returned.
+
+    Note that this will *not* return objects outside of the input list, as
+    such it will not return the root of node from a child node. It is purely
+    intended to find the highest object among a list of objects. To instead
+    get the root from one object use, e.g. `get_all_parents(obj)[-1]`
+
+    Arguments:
+        objects (List[bpy.types.Object]): Objects to find the highest root in.
+
+    Returns:
+        Optional[bpy.types.Object]: First highest root found or None if no
+            `bpy.types.Object` found in input list.
+
+    """
+    included_objects = {obj.name_full for obj in objects}
+    num_parents_to_obj = {}
+    for obj in objects:
+        if isinstance(obj, bpy.types.Object):
+            parents = get_all_parents(obj)
+            # included parents
+            parents = [parent for parent in parents if
+                       parent.name_full in included_objects]
+            if not parents:
+                # A node without parents must be a highest root
+                return obj
+
+            num_parents_to_obj.setdefault(len(parents), obj)
+
+    if not num_parents_to_obj:
+        return
+
+    minimum_parent = min(num_parents_to_obj)
+    return num_parents_to_obj[minimum_parent]

openpype/hosts/blender/api/plugin.py

@@ -25,7 +25,8 @@
 )
 from .lib import imprint
 
-VALID_EXTENSIONS = [".blend", ".json", ".abc", ".fbx"]
+VALID_EXTENSIONS = [".blend", ".json", ".abc", ".fbx",
+                    ".usd", ".usdc", ".usda"]
 
 
 def prepare_scene_name(

openpype/hosts/blender/plugins/create/create_usd.py

@@ -0,0 +1,30 @@
+"""Create a USD Export."""
+
+from openpype.hosts.blender.api import plugin, lib
+
+
+class CreateUSD(plugin.BaseCreator):
+    """Create USD Export"""
+
+    identifier = "io.openpype.creators.blender.usd"
+    name = "usdMain"
+    label = "USD"
+    family = "usd"
+    icon = "gears"
+
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        # Run parent create method
+        collection = super().create(
+            subset_name, instance_data, pre_create_data
+        )
+
+        if pre_create_data.get("use_selection"):
+            objects = lib.get_selection()
+            for obj in objects:
+                collection.objects.link(obj)
+                if obj.type == 'EMPTY':
+                    objects.extend(obj.children)
+
+        return collection

openpype/hosts/blender/plugins/load/load_abc.py

@@ -26,10 +26,11 @@ class CacheModelLoader(plugin.AssetLoader):
     Note:
         At least for now it only supports Alembic files.
     """
-    families = ["model", "pointcache", "animation"]
-    representations = ["abc"]
+    families = ["model", "pointcache", "animation", "usd"]
+    representations = ["abc", "usd"]
 
-    label = "Load Alembic"
+    # TODO: Should USD loader be a separate loader instead?
+    label = "Load Alembic/USD"
     icon = "code-fork"
     color = "orange"
 
@@ -53,10 +54,21 @@ def _process(self, libpath, asset_group, group_name):
         plugin.deselect_all()
 
         relative = bpy.context.preferences.filepaths.use_relative_paths
-        bpy.ops.wm.alembic_import(
-            filepath=libpath,
-            relative_path=relative
-        )
+
+        if any(libpath.lower().endswith(ext)
+               for ext in [".usd", ".usda", ".usdc"]):
+            # USD
+            bpy.ops.wm.usd_import(
+                filepath=libpath,
+                relative_path=relative
+            )
+
+        else:
+            # Alembic
+            bpy.ops.wm.alembic_import(
+                filepath=libpath,
+                relative_path=relative
+            )
 
         imported = lib.get_selection()
 

openpype/hosts/blender/plugins/publish/collect_instance.py

@@ -12,7 +12,7 @@ class CollectBlenderInstanceData(pyblish.api.InstancePlugin):
     order = pyblish.api.CollectorOrder
     hosts = ["blender"]
     families = ["model", "pointcache", "animation", "rig", "camera", "layout",
-                "blendScene"]
+                "blendScene", "usd"]
     label = "Collect Instance"
 
     def process(self, instance):

openpype/hosts/blender/plugins/publish/extract_fbx_animation.py

@@ -7,40 +7,10 @@
 
 from openpype.pipeline import publish
 from openpype.hosts.blender.api import plugin
+from openpype.hosts.blender.api.lib import get_highest_root
 from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-def get_all_parents(obj):
-    """Get all recursive parents of object"""
-    result = []
-    while True:
-        obj = obj.parent
-        if not obj:
-            break
-        result.append(obj)
-    return result
-
-
-def get_highest_root(objects):
-    # Get the highest object that is also in the collection
-    included_objects = {obj.name_full for obj in objects}
-    num_parents_to_obj = {}
-    for obj in objects:
-        if isinstance(obj, bpy.types.Object):
-            parents = get_all_parents(obj)
-            # included parents
-            parents = [parent for parent in parents if
-                       parent.name_full in included_objects]
-            if not parents:
-                # A node without parents must be a highest root
-                return obj
-
-            num_parents_to_obj.setdefault(len(parents), obj)
-
-    minimum_parent = min(num_parents_to_obj)
-    return num_parents_to_obj[minimum_parent]
-
-
 class ExtractAnimationFBX(
         publish.Extractor,
         publish.OptionalPyblishPluginMixin,
@@ -68,19 +38,24 @@ def process(self, instance):
         # and for those objects include the children hierarchy
         # TODO: Would it make more sense for the Collect Instance collector
         #   to also always retrieve all the children?
-        objects = set(asset_group.objects)
 
         # From the direct children of the collection find the 'root' node
         # that we want to export - it is the 'highest' node in a hierarchy
-        root = get_highest_root(objects)
+        root = get_highest_root(asset_group.objects)
+        if not root:
+            raise publish.KnownPublishError(
+                f"No root object found in instance: {asset_group.name}"
+                f"No objects in asset group: {asset_group.name}"
+            )
 
+        objects = set(asset_group.objects)
         for obj in list(objects):
             objects.update(obj.children_recursive)
 
         # Find all armatures among the objects, assume to find only one
         armatures = [obj for obj in objects if obj.type == "ARMATURE"]
         if not armatures:
-            raise RuntimeError(
+            raise publish.KnownPublishError(
                 f"Unable to find ARMATURE in collection: "
                 f"{asset_group.name}"
             )

openpype/hosts/blender/plugins/publish/extract_usd.py

@@ -0,0 +1,79 @@
+import os
+
+import bpy
+
+from openpype.pipeline import publish
+from openpype.hosts.blender.api import plugin, lib
+
+
+class ExtractUSD(publish.Extractor):
+    """Extract as USD."""
+
+    label = "Extract USD"
+    hosts = ["blender"]
+    families = ["usd"]
+
+    def process(self, instance):
+
+        # Ignore runtime instances (e.g. USD layers)
+        # TODO: This is better done via more specific `families`
+        if not instance.data.get("transientData", {}).get("instance_node"):
+            return
+
+        # Define extract output file path
+        stagingdir = self.staging_dir(instance)
+        filename = f"{instance.name}.usd"
+        filepath = os.path.join(stagingdir, filename)
+
+        # Perform extraction
+        self.log.debug("Performing extraction..")
+
+        # Select all members to "export selected"
+        plugin.deselect_all()
+
+        selected = []
+        for obj in instance:
+            if isinstance(obj, bpy.types.Object):
+                obj.select_set(True)
+                selected.append(obj)
+
+        root = lib.get_highest_root(objects=instance[:])
+        if not root:
+            instance_node = instance.data["transientData"]["instance_node"]
+            raise publish.KnownPublishError(
+                f"No root object found in instance: {instance_node.name}"
+            )
+        self.log.debug(f"Exporting using active root: {root.name}")
+
+        context = plugin.create_blender_context(
+            active=root, selected=selected)
+
+        # Export USD
+        bpy.ops.wm.usd_export(
+            context,
+            filepath=filepath,
+            selected_objects_only=True,
+            export_textures=False,
+            relative_paths=False,
+            export_animation=False,
+            export_hair=False,
+            export_uvmaps=True,
+            # TODO: add for new version of Blender (4+?)
+            # export_mesh_colors=True,
+            export_normals=True,
+            export_materials=True,
+            use_instancing=True
+        )
+
+        plugin.deselect_all()
+
+        # Add representation
+        representation = {
+            'name': 'usd',
+            'ext': 'usd',
+            'files': filename,
+            "stagingDir": stagingdir,
+        }
+        instance.data.setdefault("representations", []).append(representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)

openpype/hosts/houdini/api/lib.py

@@ -525,6 +525,30 @@ def maintained_selection():
                 node.setSelected(on=True)
 
 
+@contextmanager
+def parm_values(overrides):
+    """Override Parameter values during the context.
+
+    Arguments:
+        overrides (List[Tuple[hou.Parm, Any]]): The overrides per parm
+            that should be applied during context.
+
+    """
+
+    originals = []
+    try:
+        for parm, value in overrides:
+            originals.append((parm, parm.eval()))
+            parm.set(value)
+        yield
+    finally:
+        for parm, value in originals:
+            # Parameter might not exist anymore so first
+            # check whether it's still valid
+            if hou.parm(parm.path()):
+                parm.set(value)
+
+
 def reset_framerange():
     """Set frame range and FPS to current asset"""
 

openpype/hosts/houdini/api/plugin.py

@@ -197,6 +197,7 @@ def create(self, subset_name, instance_data, pre_create_data):
 
             instance_data["instance_node"] = instance_node.path()
             instance_data["instance_id"] = instance_node.path()
+            instance_data["families"] = self.get_publish_families()
             instance = CreatedInstance(
                 self.family,
                 subset_name,
@@ -245,6 +246,7 @@ def collect_instances(self):
             node_path = instance.path()
             node_data["instance_id"] = node_path
             node_data["instance_node"] = node_path
+            node_data["families"] = self.get_publish_families()
 
             created_instance = CreatedInstance.from_existing(
                 node_data, self
@@ -270,6 +272,7 @@ def imprint(self, node, values, update=False):
         # from the node's path
         values.pop("instance_node", None)
         values.pop("instance_id", None)
+        values.pop("families", None)
         imprint(node, values, update=update)
 
     def remove_instances(self, instances):
@@ -311,6 +314,22 @@ def customize_node_look(
         node.setUserData('nodeshape', shape)
         node.setColor(color)
 
+    def get_publish_families(self):
+        """Return families for the instances of this creator.
+
+        Allow a Creator to define multiple families so that a creator can
+        e.g. specify `usd` and `usdrop`.
+
+        There is no need to override this method if you only have the
+        primary family defined by the `family` property as that will always
+        be set.
+
+        Returns:
+            list: families for instances of this creator
+
+        """
+        return []
+
     def get_network_categories(self):
         """Return in which network view type this creator should show.