Merge branch 'develop' into enhancement/OP-7133_3dsMax--optional-custom-attributes-for-abc-extract

openpype/hosts/aftereffects/api/pipeline.py

@@ -74,11 +74,6 @@ class AfterEffectsHost(HostBase, IWorkfileHost, ILoadHost, IPublishHost):
 
         register_loader_plugin_path(LOAD_PATH)
         register_creator_plugin_path(CREATE_PATH)
-        log.info(PUBLISH_PATH)
-
-        pyblish.api.register_callback(
-            "instanceToggled", on_pyblish_instance_toggled
-        )
 
         register_event_callback("application.launched", application_launch)
 
@@ -186,11 +181,6 @@ def application_launch():
     check_inventory()
 
 
-def on_pyblish_instance_toggled(instance, old_value, new_value):
-    """Toggle layer visibility on instance toggles."""
-    instance[0].Visible = new_value
-
-
 def ls():
     """Yields containers from active AfterEffects document.
 

openpype/hosts/aftereffects/plugins/create/create_render.py

@@ -56,16 +56,15 @@ class RenderCreator(Creator):
         use_composition_name = (pre_create_data.get("use_composition_name") or
                                 len(comps) > 1)
         for comp in comps:
+            composition_name = re.sub(
+                "[^{}]+".format(SUBSET_NAME_ALLOWED_SYMBOLS),
+                "",
+                comp.name
+            )
             if use_composition_name:
                 if "{composition}" not in subset_name_from_ui.lower():
                     subset_name_from_ui += "{Composition}"
 
-                composition_name = re.sub(
-                    "[^{}]+".format(SUBSET_NAME_ALLOWED_SYMBOLS),
-                    "",
-                    comp.name
-                )
-
                 dynamic_fill = prepare_template_data({"composition":
                                                       composition_name})
                 subset_name = subset_name_from_ui.format(**dynamic_fill)
@@ -81,6 +80,8 @@ class RenderCreator(Creator):
                         inst.subset_name))
 
             data["members"] = [comp.id]
+            data["orig_comp_name"] = composition_name
+
             new_instance = CreatedInstance(self.family, subset_name, data,
                                            self)
             if "farm" in pre_create_data:
@@ -88,7 +89,7 @@ class RenderCreator(Creator):
                 new_instance.creator_attributes["farm"] = use_farm
 
             review = pre_create_data["mark_for_review"]
-            new_instance.creator_attributes["mark_for_review"] = review
+            new_instance. creator_attributes["mark_for_review"] = review
 
             api.get_stub().imprint(new_instance.id,
                                    new_instance.data_to_store())
@@ -150,16 +151,18 @@ class RenderCreator(Creator):
                                            subset_change.new_value)
 
     def remove_instances(self, instances):
+        """Removes metadata and renames to original comp name if available."""
         for instance in instances:
             self._remove_instance_from_context(instance)
             self.host.remove_instance(instance)
 
-            subset = instance.data["subset"]
             comp_id = instance.data["members"][0]
             comp = api.get_stub().get_item(comp_id)
+            orig_comp_name = instance.data.get("orig_comp_name")
             if comp:
-                new_comp_name = comp.name.replace(subset, '')
-                if not new_comp_name:
+                if orig_comp_name:
+                    new_comp_name = orig_comp_name
+                else:
                     new_comp_name = "dummyCompName"
                 api.get_stub().rename_item(comp_id,
                                            new_comp_name)

openpype/hosts/aftereffects/plugins/create/workfile_creator.py

@@ -1,3 +1,4 @@
+from openpype import AYON_SERVER_ENABLED
 import openpype.hosts.aftereffects.api as api
 from openpype.client import get_asset_by_name
 from openpype.pipeline import (
@@ -43,6 +44,14 @@ class AEWorkfileCreator(AutoCreator):
         task_name = context.get_current_task_name()
         host_name = context.host_name
 
+        existing_asset_name = None
+        if existing_instance is not None:
+            if AYON_SERVER_ENABLED:
+                existing_asset_name = existing_instance.get("folderPath")
+
+            if existing_asset_name is None:
+                existing_asset_name = existing_instance["asset"]
+
         if existing_instance is None:
             asset_doc = get_asset_by_name(project_name, asset_name)
             subset_name = self.get_subset_name(
@@ -50,10 +59,13 @@ class AEWorkfileCreator(AutoCreator):
                 project_name, host_name
             )
             data = {
-                "asset": asset_name,
                 "task": task_name,
                 "variant": self.default_variant
             }
+            if AYON_SERVER_ENABLED:
+                data["folderPath"] = asset_name
+            else:
+                data["asset"] = asset_name
             data.update(self.get_dynamic_data(
                 self.default_variant, task_name, asset_doc,
                 project_name, host_name, None
@@ -68,7 +80,7 @@ class AEWorkfileCreator(AutoCreator):
                                    new_instance.data_to_store())
 
         elif (
-            existing_instance["asset"] != asset_name
+            existing_asset_name != asset_name
             or existing_instance["task"] != task_name
         ):
             asset_doc = get_asset_by_name(project_name, asset_name)
@@ -76,6 +88,10 @@ class AEWorkfileCreator(AutoCreator):
                 self.default_variant, task_name, asset_doc,
                 project_name, host_name
             )
-            existing_instance["asset"] = asset_name
+            if AYON_SERVER_ENABLED:
+                existing_instance["folderPath"] = asset_name
+            else:
+                existing_instance["asset"] = asset_name
+
             existing_instance["task"] = task_name
             existing_instance["subset"] = subset_name

openpype/hosts/aftereffects/plugins/publish/collect_workfile.py

@@ -1,6 +1,8 @@
 import os
 
 import pyblish.api
+
+from openpype.client import get_asset_name_identifier
 from openpype.pipeline.create import get_subset_name
 
 
@@ -48,9 +50,11 @@ class CollectWorkfile(pyblish.api.ContextPlugin):
         asset_entity = context.data["assetEntity"]
         project_entity = context.data["projectEntity"]
 
+        asset_name = get_asset_name_identifier(asset_entity)
+
         instance_data = {
             "active": True,
-            "asset": asset_entity["name"],
+            "asset": asset_name,
             "task": task,
             "frameStart": context.data['frameStart'],
             "frameEnd": context.data['frameEnd'],

openpype/hosts/blender/api/__init__.py

@@ -10,6 +10,7 @@ from .pipeline import (
     ls,
     publish,
     containerise,
+    BlenderHost,
 )
 
 from .plugin import (
@@ -47,6 +48,7 @@ __all__ = [
     "ls",
     "publish",
     "containerise",
+    "BlenderHost",
 
     "Creator",
     "Loader",

openpype/hosts/blender/api/lib.py

@@ -188,7 +188,7 @@ def imprint(node: bpy.types.bpy_struct_meta_idprop, data: Dict):
             # Support values evaluated at imprint
             value = value()
 
-        if not isinstance(value, (int, float, bool, str, list)):
+        if not isinstance(value, (int, float, bool, str, list, dict)):
             raise TypeError(f"Unsupported type: {type(value)}")
 
         imprint_data[key] = value
@@ -266,9 +266,59 @@ def read(node: bpy.types.bpy_struct_meta_idprop):
     return data
 
 
-def get_selection() -> List[bpy.types.Object]:
-    """Return the selected objects from the current scene."""
-    return [obj for obj in bpy.context.scene.objects if obj.select_get()]
+def get_selected_collections():
+    """
+    Returns a list of the currently selected collections in the outliner.
+
+    Raises:
+        RuntimeError: If the outliner cannot be found in the main Blender
+        window.
+
+    Returns:
+        list: A list of `bpy.types.Collection` objects that are currently
+        selected in the outliner.
+    """
+    window = bpy.context.window or bpy.context.window_manager.windows[0]
+
+    try:
+        area = next(
+            area for area in window.screen.areas
+            if area.type == 'OUTLINER')
+        region = next(
+            region for region in area.regions
+            if region.type == 'WINDOW')
+    except StopIteration as e:
+        raise RuntimeError("Could not find outliner. An outliner space "
+                           "must be in the main Blender window.") from e
+
+    with bpy.context.temp_override(
+        window=window,
+        area=area,
+        region=region,
+        screen=window.screen
+    ):
+        ids = bpy.context.selected_ids
+
+    return [id for id in ids if isinstance(id, bpy.types.Collection)]
+
+
+def get_selection(include_collections: bool = False) -> List[bpy.types.Object]:
+    """
+    Returns a list of selected objects in the current Blender scene.
+
+    Args:
+        include_collections (bool, optional): Whether to include selected
+        collections in the result. Defaults to False.
+
+    Returns:
+        List[bpy.types.Object]: A list of selected objects.
+    """
+    selection = [obj for obj in bpy.context.scene.objects if obj.select_get()]
+
+    if include_collections:
+        selection.extend(get_selected_collections())
+
+    return selection
 
 
 @contextlib.contextmanager

openpype/hosts/blender/api/ops.py

@@ -31,6 +31,14 @@ PREVIEW_COLLECTIONS: Dict = dict()
 TIMER_INTERVAL: float = 0.01 if platform.system() == "Windows" else 0.1
 
 
+def execute_function_in_main_thread(f):
+    """Decorator to move a function call into main thread items"""
+    def wrapper(*args, **kwargs):
+        mti = MainThreadItem(f, *args, **kwargs)
+        execute_in_main_thread(mti)
+    return wrapper
+
+
 class BlenderApplication(QtWidgets.QApplication):
     _instance = None
     blender_windows = {}
@@ -238,8 +246,24 @@ class LaunchQtApp(bpy.types.Operator):
 
         self.before_window_show()
 
+        def pull_to_front(window):
+            """Pull window forward to screen.
+
+            If Window is minimized this will un-minimize, then it can be raised
+            and activated to the front.
+            """
+            window.setWindowState(
+                (window.windowState() & ~QtCore.Qt.WindowMinimized) |
+                QtCore.Qt.WindowActive
+            )
+            window.raise_()
+            window.activateWindow()
+
         if isinstance(self._window, ModuleType):
             self._window.show()
+            pull_to_front(self._window)
+
+            # Pull window to the front
             window = None
             if hasattr(self._window, "window"):
                 window = self._window.window
@@ -254,6 +278,7 @@ class LaunchQtApp(bpy.types.Operator):
             on_top_flags = origin_flags | QtCore.Qt.WindowStaysOnTopHint
             self._window.setWindowFlags(on_top_flags)
             self._window.show()
+            pull_to_front(self._window)
 
             # if on_top_flags != origin_flags:
             #     self._window.setWindowFlags(origin_flags)
@@ -275,6 +300,10 @@ class LaunchCreator(LaunchQtApp):
     def before_window_show(self):
         self._window.refresh()
 
+    def execute(self, context):
+        host_tools.show_publisher(tab="create")
+        return {"FINISHED"}
+
 
 class LaunchLoader(LaunchQtApp):
     """Launch Avalon Loader."""
@@ -299,7 +328,7 @@ class LaunchPublisher(LaunchQtApp):
     bl_label = "Publish..."
 
     def execute(self, context):
-        host_tools.show_publish()
+        host_tools.show_publisher(tab="publish")
         return {"FINISHED"}
 
 
@@ -416,7 +445,6 @@ class TOPBAR_MT_avalon(bpy.types.Menu):
         layout.operator(SetResolution.bl_idname, text="Set Resolution")
         layout.separator()
         layout.operator(LaunchWorkFiles.bl_idname, text="Work Files...")
-        # TODO (jasper): maybe add 'Reload Pipeline'
 
 
 def draw_avalon_menu(self, context):

openpype/hosts/blender/api/pipeline.py

@@ -10,6 +10,12 @@ from . import ops
 
 import pyblish.api
 
+from openpype.host import (
+    HostBase,
+    IWorkfileHost,
+    IPublishHost,
+    ILoadHost
+)
 from openpype.client import get_asset_by_name
 from openpype.pipeline import (
     schema,
@@ -29,6 +35,14 @@ from openpype.lib import (
 )
 import openpype.hosts.blender
 from openpype.settings import get_project_settings
+from .workio import (
+    open_file,
+    save_file,
+    current_file,
+    has_unsaved_changes,
+    file_extensions,
+    work_root,
+)
 
 
 HOST_DIR = os.path.dirname(os.path.abspath(openpype.hosts.blender.__file__))
@@ -47,6 +61,101 @@ IS_HEADLESS = bpy.app.background
 log = Logger.get_logger(__name__)
 
 
+class BlenderHost(HostBase, IWorkfileHost, IPublishHost, ILoadHost):
+    name = "blender"
+
+    def install(self):
+        """Override install method from HostBase.
+        Install Blender host functionality."""
+        install()
+
+    def get_containers(self) -> Iterator:
+        """List containers from active Blender scene."""
+        return ls()
+
+    def get_workfile_extensions(self) -> List[str]:
+        """Override get_workfile_extensions method from IWorkfileHost.
+        Get workfile possible extensions.
+
+        Returns:
+            List[str]: Workfile extensions.
+        """
+        return file_extensions()
+
+    def save_workfile(self, dst_path: str = None):
+        """Override save_workfile method from IWorkfileHost.
+        Save currently opened workfile.
+
+        Args:
+            dst_path (str): Where the current scene should be saved. Or use
+                current path if `None` is passed.
+        """
+        save_file(dst_path if dst_path else bpy.data.filepath)
+
+    def open_workfile(self, filepath: str):
+        """Override open_workfile method from IWorkfileHost.
+        Open workfile at specified filepath in the host.
+
+        Args:
+            filepath (str): Path to workfile.
+        """
+        open_file(filepath)
+
+    def get_current_workfile(self) -> str:
+        """Override get_current_workfile method from IWorkfileHost.
+        Retrieve currently opened workfile path.
+
+        Returns:
+            str: Path to currently opened workfile.
+        """
+        return current_file()
+
+    def workfile_has_unsaved_changes(self) -> bool:
+        """Override wokfile_has_unsaved_changes method from IWorkfileHost.
+        Returns True if opened workfile has no unsaved changes.
+
+        Returns:
+            bool: True if scene is saved and False if it has unsaved
+                modifications.
+        """
+        return has_unsaved_changes()
+
+    def work_root(self, session) -> str:
+        """Override work_root method from IWorkfileHost.
+        Modify workdir per host.
+
+        Args:
+            session (dict): Session context data.
+
+        Returns:
+            str: Path to new workdir.
+        """
+        return work_root(session)
+
+    def get_context_data(self) -> dict:
+        """Override abstract method from IPublishHost.
+        Get global data related to creation-publishing from workfile.
+
+        Returns:
+            dict: Context data stored using 'update_context_data'.
+        """
+        property = bpy.context.scene.get(AVALON_PROPERTY)
+        if property:
+            return property.to_dict()
+        return {}
+
+    def update_context_data(self, data: dict, changes: dict):
+        """Override abstract method from IPublishHost.
+        Store global context data to workfile.
+
+        Args:
+            data (dict): New data as are.
+            changes (dict): Only data that has been changed. Each value has
+                tuple with '(<old>, <new>)' value.
+        """
+        bpy.context.scene[AVALON_PROPERTY] = data
+
+
 def pype_excepthook_handler(*args):
     traceback.print_exception(*args)
 

openpype/hosts/blender/api/plugin.py

@@ -1,28 +1,34 @@
 """Shared functionality for pipeline plugins for Blender."""
 
+import itertools
 from pathlib import Path
 from typing import Dict, List, Optional
 
 import bpy
 
+from openpype import AYON_SERVER_ENABLED
 from openpype.pipeline import (
-    LegacyCreator,
+    Creator,
+    CreatedInstance,
     LoaderPlugin,
 )
-from .pipeline import AVALON_CONTAINERS
+from openpype.lib import BoolDef
+
+from .pipeline import (
+    AVALON_CONTAINERS,
+    AVALON_INSTANCES,
+    AVALON_PROPERTY,
+)
 from .ops import (
     MainThreadItem,
     execute_in_main_thread
 )
-from .lib import (
-    imprint,
-    get_selection
-)
+from .lib import imprint
 
 VALID_EXTENSIONS = [".blend", ".json", ".abc", ".fbx"]
 
 
-def asset_name(
+def prepare_scene_name(
     asset: str, subset: str, namespace: Optional[str] = None
 ) -> str:
     """Return a consistent name for an asset."""
@@ -40,9 +46,16 @@ def get_unique_number(
     avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
     if not avalon_container:
         return "01"
-    asset_groups = avalon_container.all_objects
-
-    container_names = [c.name for c in asset_groups if c.type == 'EMPTY']
+    # Check the names of both object and collection containers
+    obj_asset_groups = avalon_container.objects
+    obj_group_names = {
+        c.name for c in obj_asset_groups
+        if c.type == 'EMPTY' and c.get(AVALON_PROPERTY)}
+    coll_asset_groups = avalon_container.children
+    coll_group_names = {
+        c.name for c in coll_asset_groups
+        if c.get(AVALON_PROPERTY)}
+    container_names = obj_group_names.union(coll_group_names)
     count = 1
     name = f"{asset}_{count:0>2}_{subset}"
     while name in container_names:
@@ -134,20 +147,224 @@ def deselect_all():
     bpy.context.view_layer.objects.active = active
 
 
-class Creator(LegacyCreator):
-    """Base class for Creator plug-ins."""
+class BaseCreator(Creator):
+    """Base class for Blender Creator plug-ins."""
     defaults = ['Main']
 
-    def process(self):
-        collection = bpy.data.collections.new(name=self.data["subset"])
-        bpy.context.scene.collection.children.link(collection)
-        imprint(collection, self.data)
+    create_as_asset_group = False
 
-        if (self.options or {}).get("useSelection"):
-            for obj in get_selection():
-                collection.objects.link(obj)
+    @staticmethod
+    def cache_subsets(shared_data):
+        """Cache instances for Creators shared data.
 
-        return collection
+        Create `blender_cached_subsets` key when needed in shared data and
+        fill it with all collected instances from the scene under its
+        respective creator identifiers.
+
+        If legacy instances are detected in the scene, create
+        `blender_cached_legacy_subsets` key and fill it with
+        all legacy subsets from this family as a value.  # key or value?
+
+        Args:
+            shared_data(Dict[str, Any]): Shared data.
+
+        Return:
+            Dict[str, Any]: Shared data with cached subsets.
+        """
+        if not shared_data.get('blender_cached_subsets'):
+            cache = {}
+            cache_legacy = {}
+
+            avalon_instances = bpy.data.collections.get(AVALON_INSTANCES)
+            avalon_instance_objs = (
+                avalon_instances.objects if avalon_instances else []
+            )
+
+            for obj_or_col in itertools.chain(
+                    avalon_instance_objs,
+                    bpy.data.collections
+            ):
+                avalon_prop = obj_or_col.get(AVALON_PROPERTY, {})
+                if not avalon_prop:
+                    continue
+
+                if avalon_prop.get('id') != 'pyblish.avalon.instance':
+                    continue
+
+                creator_id = avalon_prop.get('creator_identifier')
+                if creator_id:
+                    # Creator instance
+                    cache.setdefault(creator_id, []).append(obj_or_col)
+                else:
+                    family = avalon_prop.get('family')
+                    if family:
+                        # Legacy creator instance
+                        cache_legacy.setdefault(family, []).append(obj_or_col)
+
+            shared_data["blender_cached_subsets"] = cache
+            shared_data["blender_cached_legacy_subsets"] = cache_legacy
+
+        return shared_data
+
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        """Override abstract method from Creator.
+        Create new instance and store it.
+
+        Args:
+            subset_name(str): Subset name of created instance.
+            instance_data(dict): Instance base data.
+            pre_create_data(dict): Data based on pre creation attributes.
+                Those may affect how creator works.
+        """
+        # Get Instance Container or create it if it does not exist
+        instances = bpy.data.collections.get(AVALON_INSTANCES)
+        if not instances:
+            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
+            bpy.context.scene.collection.children.link(instances)
+
+        # Create asset group
+        if AYON_SERVER_ENABLED:
+            asset_name = instance_data["folderPath"]
+        else:
+            asset_name = instance_data["asset"]
+
+        name = prepare_scene_name(asset_name, subset_name)
+        if self.create_as_asset_group:
+            # Create instance as empty
+            instance_node = bpy.data.objects.new(name=name, object_data=None)
+            instance_node.empty_display_type = 'SINGLE_ARROW'
+            instances.objects.link(instance_node)
+        else:
+            # Create instance collection
+            instance_node = bpy.data.collections.new(name=name)
+            instances.children.link(instance_node)
+
+        self.set_instance_data(subset_name, instance_data)
+
+        instance = CreatedInstance(
+            self.family, subset_name, instance_data, self
+        )
+        instance.transient_data["instance_node"] = instance_node
+        self._add_instance_to_context(instance)
+
+        imprint(instance_node, instance_data)
+
+        return instance_node
+
+    def collect_instances(self):
+        """Override abstract method from BaseCreator.
+        Collect existing instances related to this creator plugin."""
+
+        # Cache subsets in shared data
+        self.cache_subsets(self.collection_shared_data)
+
+        # Get cached subsets
+        cached_subsets = self.collection_shared_data.get(
+            "blender_cached_subsets"
+        )
+        if not cached_subsets:
+            return
+
+        # Process only instances that were created by this creator
+        for instance_node in cached_subsets.get(self.identifier, []):
+            property = instance_node.get(AVALON_PROPERTY)
+            # Create instance object from existing data
+            instance = CreatedInstance.from_existing(
+                instance_data=property.to_dict(),
+                creator=self
+            )
+            instance.transient_data["instance_node"] = instance_node
+
+            # Add instance to create context
+            self._add_instance_to_context(instance)
+
+    def update_instances(self, update_list):
+        """Override abstract method from BaseCreator.
+        Store changes of existing instances so they can be recollected.
+
+        Args:
+            update_list(List[UpdateData]): Changed instances
+                and their changes, as a list of tuples.
+        """
+
+        if AYON_SERVER_ENABLED:
+            asset_name_key = "folderPath"
+        else:
+            asset_name_key = "asset"
+
+        for created_instance, changes in update_list:
+            data = created_instance.data_to_store()
+            node = created_instance.transient_data["instance_node"]
+            if not node:
+                # We can't update if we don't know the node
+                self.log.error(
+                    f"Unable to update instance {created_instance} "
+                    f"without instance node."
+                )
+                return
+
+            # Rename the instance node in the scene if subset or asset changed
+            if (
+                "subset" in changes.changed_keys
+                or asset_name_key in changes.changed_keys
+            ):
+                asset_name = data[asset_name_key]
+                name = prepare_scene_name(
+                    asset=asset_name, subset=data["subset"]
+                )
+                node.name = name
+
+            imprint(node, data)
+
+    def remove_instances(self, instances: List[CreatedInstance]):
+
+        for instance in instances:
+            node = instance.transient_data["instance_node"]
+
+            if isinstance(node, bpy.types.Collection):
+                for children in node.children_recursive:
+                    if isinstance(children, bpy.types.Collection):
+                        bpy.data.collections.remove(children)
+                    else:
+                        bpy.data.objects.remove(children)
+
+                bpy.data.collections.remove(node)
+            elif isinstance(node, bpy.types.Object):
+                bpy.data.objects.remove(node)
+
+            self._remove_instance_from_context(instance)
+
+    def set_instance_data(
+        self,
+        subset_name: str,
+        instance_data: dict
+    ):
+        """Fill instance data with required items.
+
+        Args:
+            subset_name(str): Subset name of created instance.
+            instance_data(dict): Instance base data.
+            instance_node(bpy.types.ID): Instance node in blender scene.
+        """
+        if not instance_data:
+            instance_data = {}
+
+        instance_data.update(
+            {
+                "id": "pyblish.avalon.instance",
+                "creator_identifier": self.identifier,
+                "subset": subset_name,
+            }
+        )
+
+    def get_pre_create_attr_defs(self):
+        return [
+            BoolDef("use_selection",
+                    label="Use selection",
+                    default=True)
+        ]
 
 
 class Loader(LoaderPlugin):
@@ -241,7 +458,7 @@ class AssetLoader(LoaderPlugin):
             namespace: Use pre-defined namespace
             options: Additional settings dictionary
         """
-        # TODO (jasper): make it possible to add the asset several times by
+        # TODO: make it possible to add the asset several times by
         # just re-using the collection
         filepath = self.filepath_from_context(context)
         assert Path(filepath).exists(), f"{filepath} doesn't exist."
@@ -252,7 +469,7 @@ class AssetLoader(LoaderPlugin):
             asset, subset
         )
         namespace = namespace or f"{asset}_{unique_number}"
-        name = name or asset_name(
+        name = name or prepare_scene_name(
             asset, subset, unique_number
         )
 
@@ -281,7 +498,9 @@ class AssetLoader(LoaderPlugin):
 
         # asset = context["asset"]["name"]
         # subset = context["subset"]["name"]
-        # instance_name = asset_name(asset, subset, unique_number) + '_CON'
+        # instance_name = prepare_scene_name(
+        #     asset, subset, unique_number
+        # ) + '_CON'
 
         # return self._get_instance_collection(instance_name, nodes)
 

openpype/hosts/blender/api/render_lib.py

@@ -1,4 +1,4 @@
-import os
+from pathlib import Path
 
 import bpy
 
@@ -59,7 +59,7 @@ def get_render_product(output_path, name, aov_sep):
         instance (pyblish.api.Instance): The instance to publish.
         ext (str): The image format to render.
     """
-    filepath = os.path.join(output_path, name)
+    filepath = output_path / name.lstrip("/")
     render_product = f"{filepath}{aov_sep}beauty.####"
     render_product = render_product.replace("\\", "/")
 
@@ -180,7 +180,7 @@ def set_node_tree(output_path, name, aov_sep, ext, multilayer):
         return []
 
     output.file_slots.clear()
-    output.base_path = output_path
+    output.base_path = str(output_path)
 
     aov_file_products = []
 
@@ -191,8 +191,9 @@ def set_node_tree(output_path, name, aov_sep, ext, multilayer):
 
         output.file_slots.new(filepath)
 
-        aov_file_products.append(
-            (render_pass.name, os.path.join(output_path, filepath)))
+        filename = str(output_path / filepath.lstrip("/"))
+
+        aov_file_products.append((render_pass.name, filename))
 
         node_input = output.inputs[-1]
 
@@ -214,12 +215,11 @@ def imprint_render_settings(node, data):
 def prepare_rendering(asset_group):
     name = asset_group.name
 
-    filepath = bpy.data.filepath
+    filepath = Path(bpy.data.filepath)
     assert filepath, "Workfile not saved. Please save the file first."
 
-    file_path = os.path.dirname(filepath)
-    file_name = os.path.basename(filepath)
-    file_name, _ = os.path.splitext(file_name)
+    dirpath = filepath.parent
+    file_name = Path(filepath.name).stem
 
     project = get_current_project_name()
     settings = get_project_settings(project)
@@ -232,7 +232,7 @@ def prepare_rendering(asset_group):
     set_render_format(ext, multilayer)
     aov_list, custom_passes = set_render_passes(settings)
 
-    output_path = os.path.join(file_path, render_folder, file_name)
+    output_path = Path.joinpath(dirpath, render_folder, file_name)
 
     render_product = get_render_product(output_path, name, aov_sep)
     aov_file_product = set_node_tree(

openpype/hosts/blender/blender_addon/startup/init.py

@@ -1,9 +1,9 @@
 from openpype.pipeline import install_host
-from openpype.hosts.blender import api
+from openpype.hosts.blender.api import BlenderHost
 
 
 def register():
-    install_host(api)
+    install_host(BlenderHost())
 
 
 def unregister():

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

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""Converter for legacy Houdini subsets."""
+from openpype.pipeline.create.creator_plugins import SubsetConvertorPlugin
+from openpype.hosts.blender.api.lib import imprint
+
+
+class BlenderLegacyConvertor(SubsetConvertorPlugin):
+    """Find and convert any legacy subsets in the scene.
+
+    This Converter will find all legacy subsets in the scene and will
+    transform them to the current system. Since the old subsets doesn't
+    retain any information about their original creators, the only mapping
+    we can do is based on their families.
+
+    Its limitation is that you can have multiple creators creating subset
+    of the same family and there is no way to handle it. This code should
+    nevertheless cover all creators that came with OpenPype.
+
+    """
+    identifier = "io.openpype.creators.blender.legacy"
+    family_to_id = {
+        "action": "io.openpype.creators.blender.action",
+        "camera": "io.openpype.creators.blender.camera",
+        "animation": "io.openpype.creators.blender.animation",
+        "blendScene": "io.openpype.creators.blender.blendscene",
+        "layout": "io.openpype.creators.blender.layout",
+        "model": "io.openpype.creators.blender.model",
+        "pointcache": "io.openpype.creators.blender.pointcache",
+        "render": "io.openpype.creators.blender.render",
+        "review": "io.openpype.creators.blender.review",
+        "rig": "io.openpype.creators.blender.rig",
+    }
+
+    def __init__(self, *args, **kwargs):
+        super(BlenderLegacyConvertor, self).__init__(*args, **kwargs)
+        self.legacy_subsets = {}
+
+    def find_instances(self):
+        """Find legacy subsets in the scene.
+
+        Legacy subsets are the ones that doesn't have `creator_identifier`
+        parameter on them.
+
+        This is using cached entries done in
+        :py:meth:`~BaseCreator.cache_subsets()`
+
+        """
+        self.legacy_subsets = self.collection_shared_data.get(
+            "blender_cached_legacy_subsets")
+        if not self.legacy_subsets:
+            return
+        self.add_convertor_item(
+            "Found {} incompatible subset{}".format(
+                len(self.legacy_subsets),
+                "s" if len(self.legacy_subsets) > 1 else ""
+            )
+        )
+
+    def convert(self):
+        """Convert all legacy subsets to current.
+
+        It is enough to add `creator_identifier` and `instance_node`.
+
+        """
+        if not self.legacy_subsets:
+            return
+
+        for family, instance_nodes in self.legacy_subsets.items():
+            if family in self.family_to_id:
+                for instance_node in instance_nodes:
+                    creator_identifier = self.family_to_id[family]
+                    self.log.info(
+                        "Converting {} to {}".format(instance_node.name,
+                                                     creator_identifier)
+                    )
+                    imprint(instance_node, data={
+                        "creator_identifier": creator_identifier
+                    })

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

@@ -2,30 +2,29 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-import openpype.hosts.blender.api.plugin
-from openpype.hosts.blender.api import lib
+from openpype.hosts.blender.api import lib, plugin
 
 
-class CreateAction(openpype.hosts.blender.api.plugin.Creator):
-    """Action output for character rigs"""
+class CreateAction(plugin.BaseCreator):
+    """Action output for character rigs."""
 
-    name = "actionMain"
+    identifier = "io.openpype.creators.blender.action"
     label = "Action"
     family = "action"
     icon = "male"
 
-    def process(self):
+    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
+        )
 
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = openpype.hosts.blender.api.plugin.asset_name(asset, subset)
-        collection = bpy.data.collections.new(name=name)
-        bpy.context.scene.collection.children.link(collection)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(collection, self.data)
+        # Get instance name
+        name = plugin.prepare_scene_name(instance_data["asset"], subset_name)
 
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             for obj in lib.get_selection():
                 if (obj.animation_data is not None
                         and obj.animation_data.action is not None):

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

@@ -1,51 +1,32 @@
 """Create an animation asset."""
 
-import bpy
-
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateAnimation(plugin.Creator):
-    """Animation output for character rigs"""
+class CreateAnimation(plugin.BaseCreator):
+    """Animation output for character rigs."""
 
-    name = "animationMain"
+    identifier = "io.openpype.creators.blender.animation"
     label = "Animation"
     family = "animation"
     icon = "male"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
+    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
+        )
 
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        # name = self.name
-        # if not name:
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        # asset_group = bpy.data.objects.new(name=name, object_data=None)
-        # asset_group.empty_display_type = 'SINGLE_ARROW'
-        asset_group = bpy.data.collections.new(name=name)
-        instances.children.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
-
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             selected = lib.get_selection()
             for obj in selected:
-                asset_group.objects.link(obj)
-        elif (self.options or {}).get("asset_group"):
-            obj = (self.options or {}).get("asset_group")
-            asset_group.objects.link(obj)
+                collection.objects.link(obj)
+        elif pre_create_data.get("asset_group"):
+            # Use for Load Blend automated creation of animation instances
+            # upon loading rig files
+            obj = pre_create_data.get("asset_group")
+            collection.objects.link(obj)
 
-        return asset_group
+        return collection

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

@@ -2,50 +2,33 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateBlendScene(plugin.Creator):
-    """Generic group of assets"""
+class CreateBlendScene(plugin.BaseCreator):
+    """Generic group of assets."""
 
-    name = "blendScene"
+    identifier = "io.openpype.creators.blender.blendscene"
     label = "Blender Scene"
     family = "blendScene"
     icon = "cubes"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
+    maintain_selection = False
 
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
 
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
+        instance_node = super().create(subset_name,
+                                       instance_data,
+                                       pre_create_data)
 
-        # Add selected objects to instance
-        if (self.options or {}).get("useSelection"):
-            bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
+        if pre_create_data.get("use_selection"):
+            selection = lib.get_selection(include_collections=True)
+            for data in selection:
+                if isinstance(data, bpy.types.Collection):
+                    instance_node.children.link(data)
+                elif isinstance(data, bpy.types.Object):
+                    instance_node.objects.link(data)
 
-        return asset_group
+        return instance_node

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

@@ -2,62 +2,41 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
+from openpype.hosts.blender.api import plugin, lib
 from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
 
 
-class CreateCamera(plugin.Creator):
-    """Polygonal static geometry"""
+class CreateCamera(plugin.BaseCreator):
+    """Polygonal static geometry."""
 
-    name = "cameraMain"
+    identifier = "io.openpype.creators.blender.camera"
     label = "Camera"
     family = "camera"
     icon = "video-camera"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
+    create_as_asset_group = True
 
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
 
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
+        asset_group = super().create(subset_name,
+                                     instance_data,
+                                     pre_create_data)
 
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        print(f"self.data: {self.data}")
-        lib.imprint(asset_group, self.data)
-
-        if (self.options or {}).get("useSelection"):
-            bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
+        bpy.context.view_layer.objects.active = asset_group
+        if pre_create_data.get("use_selection"):
+            for obj in lib.get_selection():
+                obj.parent = asset_group
         else:
             plugin.deselect_all()
-            camera = bpy.data.cameras.new(subset)
-            camera_obj = bpy.data.objects.new(subset, camera)
+            camera = bpy.data.cameras.new(subset_name)
+            camera_obj = bpy.data.objects.new(subset_name, camera)
 
+            instances = bpy.data.collections.get(AVALON_INSTANCES)
             instances.objects.link(camera_obj)
 
-            camera_obj.select_set(True)
-            asset_group.select_set(True)
             bpy.context.view_layer.objects.active = asset_group
-            bpy.ops.object.parent_set(keep_transform=True)
+            camera_obj.parent = asset_group
 
         return asset_group

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

@@ -2,50 +2,31 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateLayout(plugin.Creator):
-    """Layout output for character rigs"""
+class CreateLayout(plugin.BaseCreator):
+    """Layout output for character rigs."""
 
-    name = "layoutMain"
+    identifier = "io.openpype.creators.blender.layout"
     label = "Layout"
     family = "layout"
     icon = "cubes"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
+    create_as_asset_group = True
 
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
 
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
+        asset_group = super().create(subset_name,
+                                     instance_data,
+                                     pre_create_data)
 
         # Add selected objects to instance
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
+            for obj in lib.get_selection():
+                obj.parent = asset_group
 
         return asset_group

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

@@ -2,50 +2,30 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateModel(plugin.Creator):
-    """Polygonal static geometry"""
+class CreateModel(plugin.BaseCreator):
+    """Polygonal static geometry."""
 
-    name = "modelMain"
+    identifier = "io.openpype.creators.blender.model"
     label = "Model"
     family = "model"
     icon = "cube"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
+    create_as_asset_group = True
 
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        asset_group = super().create(subset_name,
+                                     instance_data,
+                                     pre_create_data)
 
         # Add selected objects to instance
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
+            for obj in lib.get_selection():
+                obj.parent = asset_group
 
         return asset_group

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

@@ -1,51 +1,29 @@
 """Create a pointcache asset."""
 
-import bpy
-
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreatePointcache(plugin.Creator):
-    """Polygonal static geometry"""
+class CreatePointcache(plugin.BaseCreator):
+    """Polygonal static geometry."""
 
-    name = "pointcacheMain"
+    identifier = "io.openpype.creators.blender.pointcache"
     label = "Point Cache"
     family = "pointcache"
     icon = "gears"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
+    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
+        )
 
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
+        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)
 
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
-
-        # Add selected objects to instance
-        if (self.options or {}).get("useSelection"):
-            bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
-
-        return asset_group
+        return collection

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

@@ -1,42 +1,31 @@
 """Create render."""
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib
+from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.render_lib import prepare_rendering
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
 
 
-class CreateRenderlayer(plugin.Creator):
-    """Single baked camera"""
+class CreateRenderlayer(plugin.BaseCreator):
+    """Single baked camera."""
 
-    name = "renderingMain"
+    identifier = "io.openpype.creators.blender.render"
     label = "Render"
     family = "render"
     icon = "eye"
 
-    def process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.collections.new(name=name)
-
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
         try:
-            instances.children.link(asset_group)
-            self.data['task'] = get_current_task_name()
-            lib.imprint(asset_group, self.data)
+            # Run parent create method
+            collection = super().create(
+                subset_name, instance_data, pre_create_data
+            )
 
-            prepare_rendering(asset_group)
+            prepare_rendering(collection)
         except Exception:
             # Remove the instance if there was an error
-            bpy.data.collections.remove(asset_group)
+            bpy.data.collections.remove(collection)
             raise
 
         # TODO: this is undesiderable, but it's the only way to be sure that
@@ -50,4 +39,4 @@ class CreateRenderlayer(plugin.Creator):
         # now it is to force the file to be saved.
         bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
 
-        return asset_group
+        return collection

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

@@ -1,47 +1,27 @@
 """Create review."""
 
-import bpy
-
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateReview(plugin.Creator):
-    """Single baked camera"""
+class CreateReview(plugin.BaseCreator):
+    """Single baked camera."""
 
-    name = "reviewDefault"
+    identifier = "io.openpype.creators.blender.review"
     label = "Review"
     family = "review"
     icon = "video-camera"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
+    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
+        )
 
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.collections.new(name=name)
-        instances.children.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
-
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             selected = lib.get_selection()
             for obj in selected:
-                asset_group.objects.link(obj)
-        elif (self.options or {}).get("asset_group"):
-            obj = (self.options or {}).get("asset_group")
-            asset_group.objects.link(obj)
+                collection.objects.link(obj)
 
-        return asset_group
+        return collection

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

@@ -2,50 +2,30 @@
 
 import bpy
 
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
 
 
-class CreateRig(plugin.Creator):
-    """Artist-friendly rig with controls to direct motion"""
+class CreateRig(plugin.BaseCreator):
+    """Artist-friendly rig with controls to direct motion."""
 
-    name = "rigMain"
+    identifier = "io.openpype.creators.blender.rig"
     label = "Rig"
     family = "rig"
     icon = "wheelchair"
 
-    def process(self):
-        """ Run the creator on Blender main thread"""
-        mti = ops.MainThreadItem(self._process)
-        ops.execute_in_main_thread(mti)
+    create_as_asset_group = True
 
-    def _process(self):
-        # Get Instance Container or create it if it does not exist
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        if not instances:
-            instances = bpy.data.collections.new(name=AVALON_INSTANCES)
-            bpy.context.scene.collection.children.link(instances)
-
-        # Create instance object
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = plugin.asset_name(asset, subset)
-        asset_group = bpy.data.objects.new(name=name, object_data=None)
-        asset_group.empty_display_type = 'SINGLE_ARROW'
-        instances.objects.link(asset_group)
-        self.data['task'] = get_current_task_name()
-        lib.imprint(asset_group, self.data)
+    def create(
+        self, subset_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        asset_group = super().create(subset_name,
+                                     instance_data,
+                                     pre_create_data)
 
         # Add selected objects to instance
-        if (self.options or {}).get("useSelection"):
+        if pre_create_data.get("use_selection"):
             bpy.context.view_layer.objects.active = asset_group
-            selected = lib.get_selection()
-            for obj in selected:
-                if obj.parent in selected:
-                    obj.select_set(False)
-                    continue
-            selected.append(asset_group)
-            bpy.ops.object.parent_set(keep_transform=True)
+            for obj in lib.get_selection():
+                obj.parent = asset_group
 
         return asset_group

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

@@ -0,0 +1,121 @@
+import bpy
+
+from openpype import AYON_SERVER_ENABLED
+from openpype.pipeline import CreatedInstance, AutoCreator
+from openpype.client import get_asset_by_name
+from openpype.hosts.blender.api.plugin import BaseCreator
+from openpype.hosts.blender.api.pipeline import (
+    AVALON_PROPERTY,
+    AVALON_CONTAINERS
+)
+
+
+class CreateWorkfile(BaseCreator, AutoCreator):
+    """Workfile auto-creator.
+
+    The workfile instance stores its data on the `AVALON_CONTAINERS` collection
+    as custom attributes, because unlike other instances it doesn't have an
+    instance node of its own.
+
+    """
+    identifier = "io.openpype.creators.blender.workfile"
+    label = "Workfile"
+    family = "workfile"
+    icon = "fa5.file"
+
+    def create(self):
+        """Create workfile instances."""
+        existing_instance = next(
+            (
+                instance for instance in self.create_context.instances
+                if instance.creator_identifier == self.identifier
+            ),
+            None,
+        )
+
+        project_name = self.project_name
+        asset_name = self.create_context.get_current_asset_name()
+        task_name = self.create_context.get_current_task_name()
+        host_name = self.create_context.host_name
+
+        existing_asset_name = None
+        if existing_instance is not None:
+            if AYON_SERVER_ENABLED:
+                existing_asset_name = existing_instance.get("folderPath")
+
+            if existing_asset_name is None:
+                existing_asset_name = existing_instance["asset"]
+
+        if not existing_instance:
+            asset_doc = get_asset_by_name(project_name, asset_name)
+            subset_name = self.get_subset_name(
+                task_name, task_name, asset_doc, project_name, host_name
+            )
+            data = {
+                "task": task_name,
+                "variant": task_name,
+            }
+            if AYON_SERVER_ENABLED:
+                data["folderPath"] = asset_name
+            else:
+                data["asset"] = asset_name
+            data.update(
+                self.get_dynamic_data(
+                    task_name,
+                    task_name,
+                    asset_doc,
+                    project_name,
+                    host_name,
+                    existing_instance,
+                )
+            )
+            self.log.info("Auto-creating workfile instance...")
+            current_instance = CreatedInstance(
+                self.family, subset_name, data, self
+            )
+            instance_node = bpy.data.collections.get(AVALON_CONTAINERS, {})
+            current_instance.transient_data["instance_node"] = instance_node
+            self._add_instance_to_context(current_instance)
+        elif (
+            existing_asset_name != asset_name
+            or existing_instance["task"] != task_name
+        ):
+            # Update instance context if it's different
+            asset_doc = get_asset_by_name(project_name, asset_name)
+            subset_name = self.get_subset_name(
+                task_name, task_name, asset_doc, project_name, host_name
+            )
+            if AYON_SERVER_ENABLED:
+                existing_instance["folderPath"] = asset_name
+            else:
+                existing_instance["asset"] = asset_name
+
+            existing_instance["task"] = task_name
+            existing_instance["subset"] = subset_name
+
+    def collect_instances(self):
+
+        instance_node = bpy.data.collections.get(AVALON_CONTAINERS)
+        if not instance_node:
+            return
+
+        property = instance_node.get(AVALON_PROPERTY)
+        if not property:
+            return
+
+        # Create instance object from existing data
+        instance = CreatedInstance.from_existing(
+            instance_data=property.to_dict(),
+            creator=self
+        )
+        instance.transient_data["instance_node"] = instance_node
+
+        # Add instance to create context
+        self._add_instance_to_context(instance)
+
+    def remove_instances(self, instances):
+        for instance in instances:
+            node = instance.transient_data["instance_node"]
+            del node[AVALON_PROPERTY]
+
+            self._remove_instance_from_context(instance)

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

@@ -7,7 +7,7 @@ def append_workfile(context, fname, do_import):
     asset = context['asset']['name']
     subset = context['subset']['name']
 
-    group_name = plugin.asset_name(asset, subset)
+    group_name = plugin.prepare_scene_name(asset, subset)
 
     # We need to preserve the original names of the scenes, otherwise,
     # if there are duplicate names in the current workfile, the imported

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

@@ -137,9 +137,9 @@ class CacheModelLoader(plugin.AssetLoader):
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         containers = bpy.data.collections.get(AVALON_CONTAINERS)

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

@@ -7,7 +7,7 @@ from typing import Dict, List, Optional
 
 import bpy
 from openpype.pipeline import get_representation_path
-import openpype.hosts.blender.api.plugin
+from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.pipeline import (
     containerise_existing,
     AVALON_PROPERTY,
@@ -16,7 +16,7 @@ from openpype.hosts.blender.api.pipeline import (
 logger = logging.getLogger("openpype").getChild("blender").getChild("load_action")
 
 
-class BlendActionLoader(openpype.hosts.blender.api.plugin.AssetLoader):
+class BlendActionLoader(plugin.AssetLoader):
     """Load action from a .blend file.
 
     Warning:
@@ -46,8 +46,8 @@ class BlendActionLoader(openpype.hosts.blender.api.plugin.AssetLoader):
         libpath = self.filepath_from_context(context)
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
-        lib_container = openpype.hosts.blender.api.plugin.asset_name(asset, subset)
-        container_name = openpype.hosts.blender.api.plugin.asset_name(
+        lib_container = plugin.prepare_scene_name(asset, subset)
+        container_name = plugin.prepare_scene_name(
             asset, subset, namespace
         )
 
@@ -152,7 +152,7 @@ class BlendActionLoader(openpype.hosts.blender.api.plugin.AssetLoader):
         assert libpath.is_file(), (
             f"The file doesn't exist: {libpath}"
         )
-        assert extension in openpype.hosts.blender.api.plugin.VALID_EXTENSIONS, (
+        assert extension in plugin.VALID_EXTENSIONS, (
             f"Unsupported file: {libpath}"
         )
 

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

@@ -42,9 +42,9 @@ class AudioLoader(plugin.AssetLoader):
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)

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

@@ -4,11 +4,11 @@ from pathlib import Path
 import bpy
 
 from openpype.pipeline import (
-    legacy_create,
     get_representation_path,
     AVALON_CONTAINER_ID,
+    registered_host
 )
-from openpype.pipeline.create import get_legacy_creator_by_name
+from openpype.pipeline.create import CreateContext
 from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.lib import imprint
 from openpype.hosts.blender.api.pipeline import (
@@ -20,7 +20,7 @@ from openpype.hosts.blender.api.pipeline import (
 class BlendLoader(plugin.AssetLoader):
     """Load assets from a .blend file."""
 
-    families = ["model", "rig", "layout", "camera", "blendScene"]
+    families = ["model", "rig", "layout", "camera"]
     representations = ["blend"]
 
     label = "Append Blend"
@@ -32,7 +32,7 @@ class BlendLoader(plugin.AssetLoader):
         empties = [obj for obj in objects if obj.type == 'EMPTY']
 
         for empty in empties:
-            if empty.get(AVALON_PROPERTY):
+            if empty.get(AVALON_PROPERTY) and empty.parent is None:
                 return empty
 
         return None
@@ -57,19 +57,21 @@ class BlendLoader(plugin.AssetLoader):
                 obj.get(AVALON_PROPERTY).get('family') == 'rig'
             )
         ]
+        if not rigs:
+            return
+
+        # Create animation instances for each rig
+        creator_identifier = "io.openpype.creators.blender.animation"
+        host = registered_host()
+        create_context = CreateContext(host)
 
         for rig in rigs:
-            creator_plugin = get_legacy_creator_by_name("CreateAnimation")
-            legacy_create(
-                creator_plugin,
-                name=rig.name.split(':')[-1] + "_animation",
-                asset=asset,
-                options={
-                    "useSelection": False,
+            create_context.create(
+                creator_identifier=creator_identifier,
+                variant=rig.name.split(':')[-1],
+                pre_create_data={
+                    "use_selection": False,
                     "asset_group": rig
-                },
-                data={
-                    "dependencies": representation
                 }
             )
 
@@ -100,6 +102,7 @@ class BlendLoader(plugin.AssetLoader):
 
         # Link all the container children to the collection
         for obj in container.children_recursive:
+            print(obj)
             bpy.context.scene.collection.objects.link(obj)
 
         # Remove the library from the blend file
@@ -130,9 +133,9 @@ class BlendLoader(plugin.AssetLoader):
 
         representation = str(context["representation"]["_id"])
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)

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

@@ -0,0 +1,221 @@
+from typing import Dict, List, Optional
+from pathlib import Path
+
+import bpy
+
+from openpype.pipeline import (
+    get_representation_path,
+    AVALON_CONTAINER_ID,
+)
+from openpype.hosts.blender.api import plugin
+from openpype.hosts.blender.api.lib import imprint
+from openpype.hosts.blender.api.pipeline import (
+    AVALON_CONTAINERS,
+    AVALON_PROPERTY,
+)
+
+
+class BlendSceneLoader(plugin.AssetLoader):
+    """Load assets from a .blend file."""
+
+    families = ["blendScene"]
+    representations = ["blend"]
+
+    label = "Append Blend"
+    icon = "code-fork"
+    color = "orange"
+
+    @staticmethod
+    def _get_asset_container(collections):
+        for coll in collections:
+            parents = [c for c in collections if c.user_of_id(coll)]
+            if coll.get(AVALON_PROPERTY) and not parents:
+                return coll
+
+        return None
+
+    def _process_data(self, libpath, group_name, family):
+        # Append all the data from the .blend file
+        with bpy.data.libraries.load(
+            libpath, link=False, relative=False
+        ) as (data_from, data_to):
+            for attr in dir(data_to):
+                setattr(data_to, attr, getattr(data_from, attr))
+
+        members = []
+
+        # Rename the object to add the asset name
+        for attr in dir(data_to):
+            for data in getattr(data_to, attr):
+                data.name = f"{group_name}:{data.name}"
+                members.append(data)
+
+        container = self._get_asset_container(
+            data_to.collections)
+        assert container, "No asset group found"
+
+        container.name = group_name
+
+        # Link the group to the scene
+        bpy.context.scene.collection.children.link(container)
+
+        # Remove the library from the blend file
+        library = bpy.data.libraries.get(bpy.path.basename(libpath))
+        bpy.data.libraries.remove(library)
+
+        return container, members
+
+    def process_asset(
+        self, context: dict, name: str, namespace: Optional[str] = None,
+        options: Optional[Dict] = None
+    ) -> Optional[List]:
+        """
+        Arguments:
+            name: Use pre-defined name
+            namespace: Use pre-defined namespace
+            context: Full parenthood of representation to load
+            options: Additional settings dictionary
+        """
+        libpath = self.filepath_from_context(context)
+        asset = context["asset"]["name"]
+        subset = context["subset"]["name"]
+
+        try:
+            family = context["representation"]["context"]["family"]
+        except ValueError:
+            family = "model"
+
+        asset_name = plugin.prepare_scene_name(asset, subset)
+        unique_number = plugin.get_unique_number(asset, subset)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
+        namespace = namespace or f"{asset}_{unique_number}"
+
+        avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
+        if not avalon_container:
+            avalon_container = bpy.data.collections.new(name=AVALON_CONTAINERS)
+            bpy.context.scene.collection.children.link(avalon_container)
+
+        container, members = self._process_data(libpath, group_name, family)
+
+        avalon_container.children.link(container)
+
+        data = {
+            "schema": "openpype:container-2.0",
+            "id": AVALON_CONTAINER_ID,
+            "name": name,
+            "namespace": namespace or '',
+            "loader": str(self.__class__.__name__),
+            "representation": str(context["representation"]["_id"]),
+            "libpath": libpath,
+            "asset_name": asset_name,
+            "parent": str(context["representation"]["parent"]),
+            "family": context["representation"]["context"]["family"],
+            "objectName": group_name,
+            "members": members,
+        }
+
+        container[AVALON_PROPERTY] = data
+
+        objects = [
+            obj for obj in bpy.data.objects
+            if obj.name.startswith(f"{group_name}:")
+        ]
+
+        self[:] = objects
+        return objects
+
+    def exec_update(self, container: Dict, representation: Dict):
+        """
+        Update the loaded asset.
+        """
+        group_name = container["objectName"]
+        asset_group = bpy.data.collections.get(group_name)
+        libpath = Path(get_representation_path(representation)).as_posix()
+
+        assert asset_group, (
+            f"The asset is not loaded: {container['objectName']}"
+        )
+
+        # Get the parents of the members of the asset group, so we can
+        # re-link them after the update.
+        # Also gets the transform for each object to reapply after the update.
+        collection_parents = {}
+        member_transforms = {}
+        members = asset_group.get(AVALON_PROPERTY).get("members", [])
+        loaded_collections = {c for c in bpy.data.collections if c in members}
+        loaded_collections.add(bpy.data.collections.get(AVALON_CONTAINERS))
+        for member in members:
+            if isinstance(member, bpy.types.Object):
+                member_parents = set(member.users_collection)
+                member_transforms[member.name] = member.matrix_basis.copy()
+            elif isinstance(member, bpy.types.Collection):
+                member_parents = {
+                    c for c in bpy.data.collections if c.user_of_id(member)}
+            else:
+                continue
+
+            member_parents = member_parents.difference(loaded_collections)
+            if member_parents:
+                collection_parents[member.name] = list(member_parents)
+
+        old_data = dict(asset_group.get(AVALON_PROPERTY))
+
+        self.exec_remove(container)
+
+        family = container["family"]
+        asset_group, members = self._process_data(libpath, group_name, family)
+
+        for member in members:
+            if member.name in collection_parents:
+                for parent in collection_parents[member.name]:
+                    if isinstance(member, bpy.types.Object):
+                        parent.objects.link(member)
+                    elif isinstance(member, bpy.types.Collection):
+                        parent.children.link(member)
+            if member.name in member_transforms and isinstance(
+                member, bpy.types.Object
+            ):
+                member.matrix_basis = member_transforms[member.name]
+
+        avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
+        avalon_container.children.link(asset_group)
+
+        # Restore the old data, but reset members, as they don't exist anymore
+        # This avoids a crash, because the memory addresses of those members
+        # are not valid anymore
+        old_data["members"] = []
+        asset_group[AVALON_PROPERTY] = old_data
+
+        new_data = {
+            "libpath": libpath,
+            "representation": str(representation["_id"]),
+            "parent": str(representation["parent"]),
+            "members": members,
+        }
+
+        imprint(asset_group, new_data)
+
+    def exec_remove(self, container: Dict) -> bool:
+        """
+        Remove an existing container from a Blender scene.
+        """
+        group_name = container["objectName"]
+        asset_group = bpy.data.collections.get(group_name)
+
+        members = set(asset_group.get(AVALON_PROPERTY).get("members", []))
+
+        if members:
+            for attr_name in dir(bpy.data):
+                attr = getattr(bpy.data, attr_name)
+                if not isinstance(attr, bpy.types.bpy_prop_collection):
+                    continue
+
+                # ensure to make a list copy because we
+                # we remove members as we iterate
+                for data in list(attr):
+                    if data not in members or data == asset_group:
+                        continue
+
+                    attr.remove(data)
+
+        bpy.data.collections.remove(asset_group)

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

@@ -87,9 +87,9 @@ class AbcCameraLoader(plugin.AssetLoader):
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)

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

@@ -90,9 +90,9 @@ class FbxCameraLoader(plugin.AssetLoader):
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)

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

@@ -134,9 +134,9 @@ class FbxModelLoader(plugin.AssetLoader):
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)

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

@@ -123,6 +123,7 @@ class JsonLayoutLoader(plugin.AssetLoader):
         #     raise ValueError("Creator plugin \"CreateCamera\" was "
         #                      "not found.")
 
+        # TODO: Refactor legacy create usage to new style creators
         # legacy_create(
         #     creator_plugin,
         #     name="camera",
@@ -148,9 +149,9 @@ class JsonLayoutLoader(plugin.AssetLoader):
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        asset_name = plugin.asset_name(asset, subset)
+        asset_name = plugin.prepare_scene_name(asset, subset)
         unique_number = plugin.get_unique_number(asset, subset)
-        group_name = plugin.asset_name(asset, subset, unique_number)
+        group_name = plugin.prepare_scene_name(asset, subset, unique_number)
         namespace = namespace or f"{asset}_{unique_number}"
 
         avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)

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

@@ -96,14 +96,14 @@ class BlendLookLoader(plugin.AssetLoader):
         asset = context["asset"]["name"]
         subset = context["subset"]["name"]
 
-        lib_container = plugin.asset_name(
+        lib_container = plugin.prepare_scene_name(
             asset, subset
         )
         unique_number = plugin.get_unique_number(
             asset, subset
         )
         namespace = namespace or f"{asset}_{unique_number}"
-        container_name = plugin.asset_name(
+        container_name = plugin.prepare_scene_name(
             asset, subset, unique_number
         )
 

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

@@ -1,72 +1,15 @@
-import os
-import bpy
-
 import pyblish.api
-from openpype.pipeline import get_current_task_name, get_current_asset_name
 from openpype.hosts.blender.api import workio
 
 
-class SaveWorkfiledAction(pyblish.api.Action):
-    """Save Workfile."""
-    label = "Save Workfile"
-    on = "failed"
-    icon = "save"
-
-    def process(self, context, plugin):
-        bpy.ops.wm.avalon_workfiles()
-
-
 class CollectBlenderCurrentFile(pyblish.api.ContextPlugin):
     """Inject the current working file into context"""
 
     order = pyblish.api.CollectorOrder - 0.5
     label = "Blender Current File"
     hosts = ["blender"]
-    actions = [SaveWorkfiledAction]
 
     def process(self, context):
         """Inject the current working file"""
         current_file = workio.current_file()
-
         context.data["currentFile"] = current_file
-
-        assert current_file, (
-            "Current file is empty. Save the file before continuing."
-        )
-
-        folder, file = os.path.split(current_file)
-        filename, ext = os.path.splitext(file)
-
-        task = get_current_task_name()
-
-        data = {}
-
-        # create instance
-        instance = context.create_instance(name=filename)
-        subset = "workfile" + task.capitalize()
-
-        data.update({
-            "subset": subset,
-            "asset": get_current_asset_name(),
-            "label": subset,
-            "publish": True,
-            "family": "workfile",
-            "families": ["workfile"],
-            "setMembers": [current_file],
-            "frameStart": bpy.context.scene.frame_start,
-            "frameEnd": bpy.context.scene.frame_end,
-        })
-
-        data["representations"] = [{
-            "name": ext.lstrip("."),
-            "ext": ext.lstrip("."),
-            "files": file,
-            "stagingDir": folder,
-        }]
-
-        instance.data.update(data)
-
-        self.log.info("Collected instance: {}".format(file))
-        self.log.info("Scene path: {}".format(current_file))
-        self.log.info("staging Dir: {}".format(folder))
-        self.log.info("subset: {}".format(subset))

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

@@ -0,0 +1,43 @@
+import bpy
+
+import pyblish.api
+
+from openpype.pipeline.publish import KnownPublishError
+from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
+
+
+class CollectBlenderInstanceData(pyblish.api.InstancePlugin):
+    """Validator to verify that the instance is not empty"""
+
+    order = pyblish.api.CollectorOrder
+    hosts = ["blender"]
+    families = ["model", "pointcache", "animation", "rig", "camera", "layout",
+                "blendScene"]
+    label = "Collect Instance"
+
+    def process(self, instance):
+        instance_node = instance.data["transientData"]["instance_node"]
+
+        # Collect members of the instance
+        members = [instance_node]
+        if isinstance(instance_node, bpy.types.Collection):
+            members.extend(instance_node.objects)
+            members.extend(instance_node.children)
+
+            # Special case for animation instances, include armatures
+            if instance.data["family"] == "animation":
+                for obj in instance_node.objects:
+                    if obj.type == 'EMPTY' and obj.get(AVALON_PROPERTY):
+                        members.extend(
+                            child for child in obj.children
+                            if child.type == 'ARMATURE'
+                        )
+        elif isinstance(instance_node, bpy.types.Object):
+            members.extend(instance_node.children_recursive)
+        else:
+            raise KnownPublishError(
+                f"Unsupported instance node type '{type(instance_node)}' "
+                f"for instance '{instance}'"
+            )
+
+        instance[:] = members

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

@@ -1,70 +0,0 @@
-import json
-from typing import Generator
-
-import bpy
-
-import pyblish.api
-from openpype.hosts.blender.api.pipeline import (
-    AVALON_INSTANCES,
-    AVALON_PROPERTY,
-)
-
-
-class CollectInstances(pyblish.api.ContextPlugin):
-    """Collect the data of a model."""
-
-    hosts = ["blender"]
-    label = "Collect Instances"
-    order = pyblish.api.CollectorOrder
-
-    @staticmethod
-    def get_asset_groups() -> Generator:
-        """Return all instances that are empty objects asset groups.
-        """
-        instances = bpy.data.collections.get(AVALON_INSTANCES)
-        for obj in list(instances.objects) + list(instances.children):
-            avalon_prop = obj.get(AVALON_PROPERTY) or {}
-            if avalon_prop.get('id') == 'pyblish.avalon.instance':
-                yield obj
-
-    @staticmethod
-    def create_instance(context, group):
-        avalon_prop = group[AVALON_PROPERTY]
-        asset = avalon_prop['asset']
-        family = avalon_prop['family']
-        subset = avalon_prop['subset']
-        task = avalon_prop['task']
-        name = f"{asset}_{subset}"
-        return context.create_instance(
-            name=name,
-            family=family,
-            families=[family],
-            subset=subset,
-            asset=asset,
-            task=task,
-        )
-
-    def process(self, context):
-        """Collect the models from the current Blender scene."""
-        asset_groups = self.get_asset_groups()
-
-        for group in asset_groups:
-            instance = self.create_instance(context, group)
-            members = []
-            if isinstance(group, bpy.types.Collection):
-                members = list(group.objects)
-                family = instance.data["family"]
-                if family == "animation":
-                    for obj in group.objects:
-                        if obj.type == 'EMPTY' and obj.get(AVALON_PROPERTY):
-                            members.extend(
-                                child for child in obj.children
-                                if child.type == 'ARMATURE')
-            else:
-                members = group.children_recursive
-
-            members.append(group)
-            instance[:] = members
-            self.log.debug(json.dumps(instance.data, indent=4))
-            for obj in instance:
-                self.log.debug(obj)

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

@@ -11,12 +11,12 @@ import pyblish.api
 
 
 class CollectBlenderRender(pyblish.api.InstancePlugin):
-    """Gather all publishable render layers from renderSetup."""
+    """Gather all publishable render instances."""
 
     order = pyblish.api.CollectorOrder + 0.01
     hosts = ["blender"]
     families = ["render"]
-    label = "Collect Render Layers"
+    label = "Collect Render"
     sync_workfile_version = False
 
     @staticmethod
@@ -73,12 +73,11 @@ class CollectBlenderRender(pyblish.api.InstancePlugin):
     def process(self, instance):
         context = instance.context
 
-        render_data = bpy.data.collections[str(instance)].get("render_data")
+        instance_node = instance.data["transientData"]["instance_node"]
+        render_data = instance_node.get("render_data")
 
         assert render_data, "No render data found."
 
-        self.log.info(f"render_data: {dict(render_data)}")
-
         render_product = render_data.get("render_product")
         aov_file_product = render_data.get("aov_file_product")
         ext = render_data.get("image_format")
@@ -100,7 +99,7 @@ class CollectBlenderRender(pyblish.api.InstancePlugin):
         expected_files = expected_beauty | expected_aovs
 
         instance.data.update({
-            "family": "render.farm",
+            "families": ["render", "render.farm"],
             "frameStart": frame_start,
             "frameEnd": frame_end,
             "frameStartHandle": frame_handle_start,
@@ -119,5 +118,3 @@ class CollectBlenderRender(pyblish.api.InstancePlugin):
             "colorspaceView": "ACES 1.0 SDR-video",
             "renderProducts": colorspace.ARenderProduct(),
         })
-
-        self.log.info(f"data: {instance.data}")

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

@@ -16,10 +16,12 @@ class CollectReview(pyblish.api.InstancePlugin):
 
         self.log.debug(f"instance: {instance}")
 
+        datablock = instance.data["transientData"]["instance_node"]
+
         # get cameras
         cameras = [
             obj
-            for obj in instance
+            for obj in datablock.all_objects
             if isinstance(obj, bpy.types.Object) and obj.type == "CAMERA"
         ]
 
@@ -31,11 +33,12 @@ class CollectReview(pyblish.api.InstancePlugin):
 
         focal_length = cameras[0].data.lens
 
-        # get isolate objects list from meshes instance members .
+        # get isolate objects list from meshes instance members.
+        types = {"MESH", "GPENCIL"}
         isolate_objects = [
             obj
             for obj in instance
-            if isinstance(obj, bpy.types.Object) and obj.type == "MESH"
+            if isinstance(obj, bpy.types.Object) and obj.type in types
         ]
 
         if not instance.data.get("remove"):

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

@@ -0,0 +1,37 @@
+from pathlib import Path
+
+from pyblish.api import InstancePlugin, CollectorOrder
+
+
+class CollectWorkfile(InstancePlugin):
+    """Inject workfile data into its instance."""
+
+    order = CollectorOrder
+    label = "Collect Workfile"
+    hosts = ["blender"]
+    families = ["workfile"]
+
+    def process(self, instance):
+        """Process collector."""
+
+        context = instance.context
+        filepath = Path(context.data["currentFile"])
+        ext = filepath.suffix
+
+        instance.data.update(
+            {
+                "setMembers": [filepath.as_posix()],
+                "frameStart": context.data.get("frameStart", 1),
+                "frameEnd": context.data.get("frameEnd", 1),
+                "handleStart": context.data.get("handleStart", 1),
+                "handledEnd": context.data.get("handleEnd", 1),
+                "representations": [
+                    {
+                        "name": ext.lstrip("."),
+                        "ext": ext.lstrip("."),
+                        "files": filepath.name,
+                        "stagingDir": filepath.parent,
+                    }
+                ],
+            }
+        )

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

@@ -4,10 +4,9 @@ import bpy
 
 from openpype.pipeline import publish
 from openpype.hosts.blender.api import plugin
-from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractABC(publish.Extractor):
+class ExtractABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract as ABC."""
 
     label = "Extract ABC"
@@ -15,28 +14,32 @@ class ExtractABC(publish.Extractor):
     families = ["pointcache"]
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        filename = f"{instance.name}.abc"
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        instance_name = f"{asset_name}_{subset}"
+        filename = f"{instance_name}.abc"
         filepath = os.path.join(stagingdir, filename)
 
         # Perform extraction
-        self.log.info("Performing extraction..")
+        self.log.debug("Performing extraction..")
 
         plugin.deselect_all()
 
-        selected = []
-        active = None
+        asset_group = instance.data["transientData"]["instance_node"]
 
+        selected = []
         for obj in instance:
-            obj.select_set(True)
-            selected.append(obj)
-            # Set as active the asset group
-            if obj.get(AVALON_PROPERTY):
-                active = obj
+            if isinstance(obj, bpy.types.Object):
+                obj.select_set(True)
+                selected.append(obj)
 
         context = plugin.create_blender_context(
-            active=active, selected=selected)
+            active=asset_group, selected=selected)
 
         with bpy.context.temp_override(**context):
             # We export the abc
@@ -59,8 +62,8 @@ class ExtractABC(publish.Extractor):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)
 
 
 class ExtractModelABC(ExtractABC):

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

@@ -6,7 +6,10 @@ from openpype.pipeline import publish
 from openpype.hosts.blender.api import plugin
 
 
-class ExtractAnimationABC(publish.Extractor):
+class ExtractAnimationABC(
+        publish.Extractor,
+        publish.OptionalPyblishPluginMixin,
+):
     """Extract as ABC."""
 
     label = "Extract Animation ABC"
@@ -15,18 +18,25 @@ class ExtractAnimationABC(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        filename = f"{instance.name}.abc"
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        instance_name = f"{asset_name}_{subset}"
+        filename = f"{instance_name}.abc"
+
         filepath = os.path.join(stagingdir, filename)
 
         # Perform extraction
-        self.log.info("Performing extraction..")
+        self.log.debug("Performing extraction..")
 
         plugin.deselect_all()
 
         selected = []
-        asset_group = None
+        asset_group = instance.data["transientData"]["instance_node"]
 
         objects = []
         for obj in instance:
@@ -66,5 +76,5 @@ class ExtractAnimationABC(publish.Extractor):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)

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

@@ -5,7 +5,7 @@ import bpy
 from openpype.pipeline import publish
 
 
-class ExtractBlend(publish.Extractor):
+class ExtractBlend(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract a blend file."""
 
     label = "Extract Blend"
@@ -14,30 +14,44 @@ class ExtractBlend(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
 
         stagingdir = self.staging_dir(instance)
-        filename = f"{instance.name}.blend"
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        instance_name = f"{asset_name}_{subset}"
+        filename = f"{instance_name}.blend"
         filepath = os.path.join(stagingdir, filename)
 
         # Perform extraction
-        self.log.info("Performing extraction..")
+        self.log.debug("Performing extraction..")
 
         data_blocks = set()
 
-        for obj in instance:
-            data_blocks.add(obj)
+        for data in instance:
+            data_blocks.add(data)
             # Pack used images in the blend files.
-            if obj.type == 'MESH':
-                for material_slot in obj.material_slots:
-                    mat = material_slot.material
-                    if mat and mat.use_nodes:
-                        tree = mat.node_tree
-                        if tree.type == 'SHADER':
-                            for node in tree.nodes:
-                                if node.bl_idname == 'ShaderNodeTexImage':
-                                    if node.image:
-                                        node.image.pack()
+            if not (
+                isinstance(data, bpy.types.Object) and data.type == 'MESH'
+            ):
+                continue
+            for material_slot in data.material_slots:
+                mat = material_slot.material
+                if not (mat and mat.use_nodes):
+                    continue
+                tree = mat.node_tree
+                if tree.type != 'SHADER':
+                    continue
+                for node in tree.nodes:
+                    if node.bl_idname != 'ShaderNodeTexImage':
+                        continue
+                    # Check if image is not packed already
+                    # and pack it if not.
+                    if node.image and node.image.packed_file is None:
+                        node.image.pack()
 
         bpy.data.libraries.write(filepath, data_blocks)
 
@@ -52,5 +66,5 @@ class ExtractBlend(publish.Extractor):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)

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

@@ -5,7 +5,10 @@ import bpy
 from openpype.pipeline import publish
 
 
-class ExtractBlendAnimation(publish.Extractor):
+class ExtractBlendAnimation(
+        publish.Extractor,
+        publish.OptionalPyblishPluginMixin,
+):
     """Extract a blend file."""
 
     label = "Extract Blend"
@@ -14,14 +17,20 @@ class ExtractBlendAnimation(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
 
         stagingdir = self.staging_dir(instance)
-        filename = f"{instance.name}.blend"
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        instance_name = f"{asset_name}_{subset}"
+        filename = f"{instance_name}.blend"
         filepath = os.path.join(stagingdir, filename)
 
         # Perform extraction
-        self.log.info("Performing extraction..")
+        self.log.debug("Performing extraction..")
 
         data_blocks = set()
 
@@ -50,5 +59,5 @@ class ExtractBlendAnimation(publish.Extractor):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)

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

@@ -7,7 +7,7 @@ from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractCameraABC(publish.Extractor):
+class ExtractCameraABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract camera as ABC."""
 
     label = "Extract Camera (ABC)"
@@ -16,22 +16,23 @@ class ExtractCameraABC(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        filename = f"{instance.name}.abc"
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        instance_name = f"{asset_name}_{subset}"
+        filename = f"{instance_name}.abc"
         filepath = os.path.join(stagingdir, filename)
 
         # Perform extraction
-        self.log.info("Performing extraction..")
+        self.log.debug("Performing extraction..")
 
         plugin.deselect_all()
 
-        asset_group = None
-        for obj in instance:
-            if obj.get(AVALON_PROPERTY):
-                asset_group = obj
-                break
-        assert asset_group, "No asset group found"
+        asset_group = instance.data["transientData"]["instance_node"]
 
         # Need to cast to list because children is a tuple
         selected = list(asset_group.children)
@@ -64,5 +65,5 @@ class ExtractCameraABC(publish.Extractor):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)

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

@@ -6,7 +6,7 @@ from openpype.pipeline import publish
 from openpype.hosts.blender.api import plugin
 
 
-class ExtractCamera(publish.Extractor):
+class ExtractCamera(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract as the camera as FBX."""
 
     label = "Extract Camera (FBX)"
@@ -15,13 +15,19 @@ class ExtractCamera(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        filename = f"{instance.name}.fbx"
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        instance_name = f"{asset_name}_{subset}"
+        filename = f"{instance_name}.fbx"
         filepath = os.path.join(stagingdir, filename)
 
         # Perform extraction
-        self.log.info("Performing extraction..")
+        self.log.debug("Performing extraction..")
 
         plugin.deselect_all()
 
@@ -73,5 +79,5 @@ class ExtractCamera(publish.Extractor):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)

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

@@ -7,7 +7,7 @@ from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractFBX(publish.Extractor):
+class ExtractFBX(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract as FBX."""
 
     label = "Extract FBX"
@@ -16,24 +16,28 @@ class ExtractFBX(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        filename = f"{instance.name}.fbx"
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        instance_name = f"{asset_name}_{subset}"
+        filename = f"{instance_name}.fbx"
         filepath = os.path.join(stagingdir, filename)
 
         # Perform extraction
-        self.log.info("Performing extraction..")
+        self.log.debug("Performing extraction..")
 
         plugin.deselect_all()
 
-        selected = []
-        asset_group = None
+        asset_group = instance.data["transientData"]["instance_node"]
 
+        selected = []
         for obj in instance:
             obj.select_set(True)
             selected.append(obj)
-            if obj.get(AVALON_PROPERTY):
-                asset_group = obj
 
         context = plugin.create_blender_context(
             active=asset_group, selected=selected)
@@ -84,5 +88,5 @@ class ExtractFBX(publish.Extractor):
         }
         instance.data["representations"].append(representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)

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

@@ -10,7 +10,41 @@ from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractAnimationFBX(publish.Extractor):
+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,
+):
     """Extract as animation."""
 
     label = "Extract FBX"
@@ -19,23 +53,43 @@ class ExtractAnimationFBX(publish.Extractor):
     optional = True
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
 
         # Perform extraction
-        self.log.info("Performing extraction..")
+        self.log.debug("Performing extraction..")
 
-        # The first collection object in the instance is taken, as there
-        # should be only one that contains the asset group.
-        collection = [
-            obj for obj in instance if type(obj) is bpy.types.Collection][0]
+        asset_group = instance.data["transientData"]["instance_node"]
 
-        # Again, the first object in the collection is taken , as there
-        # should be only the asset group in the collection.
-        asset_group = collection.objects[0]
+        # Get objects in this collection (but not in children collections)
+        # 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)
 
-        armature = [
-            obj for obj in asset_group.children if obj.type == 'ARMATURE'][0]
+        # 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)
+
+        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(
+                f"Unable to find ARMATURE in collection: "
+                f"{asset_group.name}"
+            )
+        elif len(armatures) > 1:
+            self.log.warning(
+                "Found more than one ARMATURE, using "
+                f"only first of: {armatures}"
+            )
+        armature = armatures[0]
 
         object_action_pairs = []
         original_actions = []
@@ -44,9 +98,6 @@ class ExtractAnimationFBX(publish.Extractor):
         ending_frames = []
 
         # For each armature, we make a copy of the current action
-        curr_action = None
-        copy_action = None
-
         if armature.animation_data and armature.animation_data.action:
             curr_action = armature.animation_data.action
             copy_action = curr_action.copy()
@@ -56,12 +107,20 @@ class ExtractAnimationFBX(publish.Extractor):
             starting_frames.append(curr_frame_range[0])
             ending_frames.append(curr_frame_range[1])
         else:
-            self.log.info("Object have no animation.")
+            self.log.info(
+                f"Armature '{armature.name}' has no animation, "
+                f"skipping FBX animation extraction for {instance}."
+            )
             return
 
         asset_group_name = asset_group.name
-        asset_group.name = asset_group.get(AVALON_PROPERTY).get("asset_name")
+        asset_name = asset_group.get(AVALON_PROPERTY).get("asset_name")
+        if asset_name:
+            # Rename for the export; this data is only present when loaded
+            # from a JSON Layout (layout family)
+            asset_group.name = asset_name
 
+        # Remove : from the armature name for the export
         armature_name = armature.name
         original_name = armature_name.split(':')[1]
         armature.name = original_name
@@ -84,13 +143,16 @@ class ExtractAnimationFBX(publish.Extractor):
         for obj in bpy.data.objects:
             obj.select_set(False)
 
-        asset_group.select_set(True)
+        root.select_set(True)
         armature.select_set(True)
-        fbx_filename = f"{instance.name}_{armature.name}.fbx"
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        instance_name = f"{asset_name}_{subset}"
+        fbx_filename = f"{instance_name}_{armature.name}.fbx"
         filepath = os.path.join(stagingdir, fbx_filename)
 
         override = plugin.create_blender_context(
-            active=asset_group, selected=[asset_group, armature])
+            active=root, selected=[root, armature])
         bpy.ops.export_scene.fbx(
             override,
             filepath=filepath,
@@ -104,7 +166,7 @@ class ExtractAnimationFBX(publish.Extractor):
         )
         armature.name = armature_name
         asset_group.name = asset_group_name
-        asset_group.select_set(False)
+        root.select_set(True)
         armature.select_set(False)
 
         # We delete the baked action and set the original one back
@@ -119,7 +181,7 @@ class ExtractAnimationFBX(publish.Extractor):
                 pair[1].user_clear()
                 bpy.data.actions.remove(pair[1])
 
-        json_filename = f"{instance.name}.json"
+        json_filename = f"{instance_name}.json"
         json_path = os.path.join(stagingdir, json_filename)
 
         json_dict = {
@@ -158,5 +220,5 @@ class ExtractAnimationFBX(publish.Extractor):
         instance.data["representations"].append(fbx_representation)
         instance.data["representations"].append(json_representation)
 
-        self.log.info("Extracted instance '{}' to: {}".format(
-                      instance.name, fbx_representation))
+        self.log.debug("Extracted instance '{}' to: {}".format(
+                       instance.name, fbx_representation))

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

@@ -11,10 +11,10 @@ from openpype.hosts.blender.api import plugin
 from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
-class ExtractLayout(publish.Extractor):
+class ExtractLayout(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """Extract a layout."""
 
-    label = "Extract Layout"
+    label = "Extract Layout (JSON)"
     hosts = ["blender"]
     families = ["layout"]
     optional = True
@@ -45,7 +45,7 @@ class ExtractLayout(publish.Extractor):
                 starting_frames.append(curr_frame_range[0])
                 ending_frames.append(curr_frame_range[1])
             else:
-                self.log.info("Object have no animation.")
+                self.log.info("Object has no animation.")
                 continue
 
             asset_group_name = asset.name
@@ -113,11 +113,14 @@ class ExtractLayout(publish.Extractor):
         return None, n
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
 
         # Perform extraction
-        self.log.info("Performing extraction..")
+        self.log.debug("Performing extraction..")
 
         if "representations" not in instance.data:
             instance.data["representations"] = []
@@ -125,13 +128,22 @@ class ExtractLayout(publish.Extractor):
         json_data = []
         fbx_files = []
 
-        asset_group = bpy.data.objects[str(instance)]
+        asset_group = instance.data["transientData"]["instance_node"]
 
         fbx_count = 0
 
         project_name = instance.context.data["projectEntity"]["name"]
         for asset in asset_group.children:
             metadata = asset.get(AVALON_PROPERTY)
+            if not metadata:
+                # Avoid raising error directly if there's just invalid data
+                # inside the instance; better to log it to the artist
+                # TODO: This should actually be validated in a validator
+                self.log.warning(
+                    f"Found content in layout that is not a loaded "
+                    f"asset, skipping: {asset.name_full}"
+                )
+                continue
 
             version_id = metadata["parent"]
             family = metadata["family"]
@@ -212,7 +224,11 @@ class ExtractLayout(publish.Extractor):
 
             json_data.append(json_element)
 
-        json_filename = "{}.json".format(instance.name)
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        instance_name = f"{asset_name}_{subset}"
+        json_filename = f"{instance_name}.json"
+
         json_path = os.path.join(stagingdir, json_filename)
 
         with open(json_path, "w+") as file:
@@ -245,5 +261,5 @@ class ExtractLayout(publish.Extractor):
             }
             instance.data["representations"].append(fbx_representation)
 
-        self.log.info("Extracted instance '%s' to: %s",
-                      instance.name, json_representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, json_representation)

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

@@ -9,7 +9,7 @@ from openpype.hosts.blender.api import capture
 from openpype.hosts.blender.api.lib import maintained_time
 
 
-class ExtractPlayblast(publish.Extractor):
+class ExtractPlayblast(publish.Extractor, publish.OptionalPyblishPluginMixin):
     """
     Extract viewport playblast.
 
@@ -24,9 +24,8 @@ class ExtractPlayblast(publish.Extractor):
     order = pyblish.api.ExtractorOrder + 0.01
 
     def process(self, instance):
-        self.log.info("Extracting capture..")
-
-        self.log.info(instance.data)
+        if not self.is_active(instance.data):
+            return
 
         # get scene fps
         fps = instance.data.get("fps")
@@ -34,14 +33,14 @@ class ExtractPlayblast(publish.Extractor):
             fps = bpy.context.scene.render.fps
             instance.data["fps"] = fps
 
-        self.log.info(f"fps: {fps}")
+        self.log.debug(f"fps: {fps}")
 
         # If start and end frames cannot be determined,
         # get them from Blender timeline.
         start = instance.data.get("frameStart", bpy.context.scene.frame_start)
         end = instance.data.get("frameEnd", bpy.context.scene.frame_end)
 
-        self.log.info(f"start: {start}, end: {end}")
+        self.log.debug(f"start: {start}, end: {end}")
         assert end > start, "Invalid time range !"
 
         # get cameras
@@ -52,10 +51,13 @@ class ExtractPlayblast(publish.Extractor):
 
         # get output path
         stagingdir = self.staging_dir(instance)
-        filename = instance.name
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        filename = f"{asset_name}_{subset}"
+
         path = os.path.join(stagingdir, filename)
 
-        self.log.info(f"Outputting images to {path}")
+        self.log.debug(f"Outputting images to {path}")
 
         project_settings = instance.context.data["project_settings"]["blender"]
         presets = project_settings["publish"]["ExtractPlayblast"]["presets"]
@@ -100,7 +102,7 @@ class ExtractPlayblast(publish.Extractor):
 
         frame_collection = collections[0]
 
-        self.log.info(f"We found collection of interest {frame_collection}")
+        self.log.debug(f"Found collection of interest {frame_collection}")
 
         instance.data.setdefault("representations", [])
 

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

@@ -24,13 +24,20 @@ class ExtractThumbnail(publish.Extractor):
     presets = {}
 
     def process(self, instance):
-        self.log.info("Extracting capture..")
+        self.log.debug("Extracting capture..")
+
+        if instance.data.get("thumbnailSource"):
+            self.log.debug("Thumbnail source found, skipping...")
+            return
 
         stagingdir = self.staging_dir(instance)
-        filename = instance.name
+        asset_name = instance.data["assetEntity"]["name"]
+        subset = instance.data["subset"]
+        filename = f"{asset_name}_{subset}"
+
         path = os.path.join(stagingdir, filename)
 
-        self.log.info(f"Outputting images to {path}")
+        self.log.debug(f"Outputting images to {path}")
 
         camera = instance.data.get("review_camera", "AUTO")
         start = instance.data.get("frameStart", bpy.context.scene.frame_start)
@@ -61,7 +68,7 @@ class ExtractThumbnail(publish.Extractor):
 
         thumbnail = os.path.basename(self._fix_output_path(path))
 
-        self.log.info(f"thumbnail: {thumbnail}")
+        self.log.debug(f"thumbnail: {thumbnail}")
 
         instance.data.setdefault("representations", [])
 

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

@@ -1,8 +1,12 @@
 import pyblish.api
+from openpype.pipeline.publish import OptionalPyblishPluginMixin
 from openpype.hosts.blender.api.workio import save_file
 
 
-class IncrementWorkfileVersion(pyblish.api.ContextPlugin):
+class IncrementWorkfileVersion(
+        pyblish.api.ContextPlugin,
+        OptionalPyblishPluginMixin
+):
     """Increment current workfile version."""
 
     order = pyblish.api.IntegratorOrder + 0.9
@@ -10,9 +14,11 @@ class IncrementWorkfileVersion(pyblish.api.ContextPlugin):
     optional = True
     hosts = ["blender"]
     families = ["animation", "model", "rig", "action", "layout", "blendScene",
-                "pointcache", "render"]
+                "pointcache", "render.farm"]
 
     def process(self, context):
+        if not self.is_active(context.data):
+            return
 
         assert all(result["success"] for result in context.data["results"]), (
             "Publishing not successful so version is not increased.")
@@ -23,4 +29,4 @@ class IncrementWorkfileVersion(pyblish.api.ContextPlugin):
 
         save_file(filepath, copy=False)
 
-        self.log.info('Incrementing script version')
+        self.log.debug('Incrementing blender workfile version')

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

@@ -1,9 +1,13 @@
 import json
 
 import pyblish.api
+from openpype.pipeline.publish import OptionalPyblishPluginMixin
 
 
-class IntegrateAnimation(pyblish.api.InstancePlugin):
+class IntegrateAnimation(
+        pyblish.api.InstancePlugin,
+        OptionalPyblishPluginMixin,
+):
     """Generate a JSON file for animation."""
 
     label = "Integrate Animation"
@@ -13,7 +17,7 @@ class IntegrateAnimation(pyblish.api.InstancePlugin):
     families = ["setdress"]
 
     def process(self, instance):
-        self.log.info("Integrate Animation")
+        self.log.debug("Integrate Animation")
 
         representation = instance.data.get('representations')[0]
         json_path = representation.get('publishedFiles')[0]

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

@@ -5,10 +5,15 @@ import bpy
 import pyblish.api
 
 import openpype.hosts.blender.api.action
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    PublishValidationError,
+    OptionalPyblishPluginMixin
+)
 
 
-class ValidateCameraZeroKeyframe(pyblish.api.InstancePlugin):
+class ValidateCameraZeroKeyframe(pyblish.api.InstancePlugin,
+                                 OptionalPyblishPluginMixin):
     """Camera must have a keyframe at frame 0.
 
     Unreal shifts the first keyframe to frame 0. Forcing the camera to have
@@ -40,8 +45,12 @@ class ValidateCameraZeroKeyframe(pyblish.api.InstancePlugin):
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                f"Camera must have a keyframe at frame 0: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                f"Camera must have a keyframe at frame 0: {names}"
             )

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

@@ -19,7 +19,7 @@ class ValidateDeadlinePublish(pyblish.api.InstancePlugin,
     """
 
     order = ValidateContentsOrder
-    families = ["render.farm"]
+    families = ["render"]
     hosts = ["blender"]
     label = "Validate Render Output for Deadline"
     optional = True
@@ -36,12 +36,12 @@ class ValidateDeadlinePublish(pyblish.api.InstancePlugin,
                 "Render output folder "
                 "doesn't match the blender scene name! "
                 "Use Repair action to "
-                "fix the folder file path.."
+                "fix the folder file path."
             )
 
     @classmethod
     def repair(cls, instance):
-        container = bpy.data.collections[str(instance)]
+        container = instance.data["transientData"]["instance_node"]
         prepare_rendering(container)
         bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
         cls.log.debug("Reset the render output folder...")

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

@@ -2,8 +2,24 @@ import bpy
 
 import pyblish.api
 
+from openpype.pipeline.publish import (
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 
-class ValidateFileSaved(pyblish.api.InstancePlugin):
+
+class SaveWorkfileAction(pyblish.api.Action):
+    """Save Workfile."""
+    label = "Save Workfile"
+    on = "failed"
+    icon = "save"
+
+    def process(self, context, plugin):
+        bpy.ops.wm.avalon_workfiles()
+
+
+class ValidateFileSaved(pyblish.api.ContextPlugin,
+                        OptionalPyblishPluginMixin):
     """Validate that the workfile has been saved."""
 
     order = pyblish.api.ValidatorOrder - 0.01
@@ -11,10 +27,35 @@ class ValidateFileSaved(pyblish.api.InstancePlugin):
     label = "Validate File Saved"
     optional = False
     exclude_families = []
+    actions = [SaveWorkfileAction]
 
-    def process(self, instance):
-        if [ef for ef in self.exclude_families
-                if instance.data["family"] in ef]:
+    def process(self, context):
+        if not self.is_active(context.data):
             return
+
+        if not context.data["currentFile"]:
+            # File has not been saved at all and has no filename
+            raise PublishValidationError(
+                "Current file is empty. Save the file before continuing."
+            )
+
+        # Do not validate workfile has unsaved changes if only instances
+        # present of families that should be excluded
+        families = {
+            instance.data["family"] for instance in context
+            # Consider only enabled instances
+            if instance.data.get("publish", True)
+            and instance.data.get("active", True)
+        }
+
+        def is_excluded(family):
+            return any(family in exclude_family
+                       for exclude_family in self.exclude_families)
+
+        if all(is_excluded(family) for family in families):
+            self.log.debug("Only excluded families found, skipping workfile "
+                           "unsaved changes validation..")
+            return
+
         if bpy.data.is_dirty:
-            raise RuntimeError("Workfile is not saved.")
+            raise PublishValidationError("Workfile has unsaved changes.")

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

@@ -0,0 +1,19 @@
+import pyblish.api
+from openpype.pipeline.publish import PublishValidationError
+
+
+class ValidateInstanceEmpty(pyblish.api.InstancePlugin):
+    """Validator to verify that the instance is not empty"""
+
+    order = pyblish.api.ValidatorOrder - 0.01
+    hosts = ["blender"]
+    families = ["model", "pointcache", "rig", "camera" "layout", "blendScene"]
+    label = "Validate Instance is not Empty"
+    optional = False
+
+    def process(self, instance):
+        # Members are collected by `collect_instance` so we only need to check
+        # whether any member is included. The instance node will be included
+        # as a member as well, hence we will check for at least 2 members
+        if len(instance) < 2:
+            raise PublishValidationError(f"Instance {instance.name} is empty.")

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

@@ -4,17 +4,24 @@ import bpy
 
 import pyblish.api
 
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 import openpype.hosts.blender.api.action
 
 
-class ValidateMeshHasUvs(pyblish.api.InstancePlugin):
+class ValidateMeshHasUvs(
+        pyblish.api.InstancePlugin,
+        OptionalPyblishPluginMixin,
+):
     """Validate that the current mesh has UV's."""
 
     order = ValidateContentsOrder
     hosts = ["blender"]
     families = ["model"]
-    label = "Mesh Has UV's"
+    label = "Mesh Has UVs"
     actions = [openpype.hosts.blender.api.action.SelectInvalidAction]
     optional = True
 
@@ -49,8 +56,11 @@ class ValidateMeshHasUvs(pyblish.api.InstancePlugin):
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
+            raise PublishValidationError(
                 f"Meshes found in instance without valid UV's: {invalid}"
             )

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

@@ -4,11 +4,16 @@ import bpy
 
 import pyblish.api
 
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 import openpype.hosts.blender.api.action
 
 
-class ValidateMeshNoNegativeScale(pyblish.api.Validator):
+class ValidateMeshNoNegativeScale(pyblish.api.Validator,
+                                  OptionalPyblishPluginMixin):
     """Ensure that meshes don't have a negative scale."""
 
     order = ValidateContentsOrder
@@ -27,8 +32,12 @@ class ValidateMeshNoNegativeScale(pyblish.api.Validator):
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                f"Meshes found in instance with negative scale: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                f"Meshes found in instance with negative scale: {names}"
             )

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

@@ -5,10 +5,15 @@ import bpy
 import pyblish.api
 
 import openpype.hosts.blender.api.action
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 
 
-class ValidateNoColonsInName(pyblish.api.InstancePlugin):
+class ValidateNoColonsInName(pyblish.api.InstancePlugin,
+                             OptionalPyblishPluginMixin):
     """There cannot be colons in names
 
     Object or bone names cannot include colons. Other software do not
@@ -36,8 +41,12 @@ class ValidateNoColonsInName(pyblish.api.InstancePlugin):
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                f"Objects found with colon in name: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                f"Objects found with colon in name: {names}"
             )

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

@@ -3,10 +3,17 @@ from typing import List
 import bpy
 
 import pyblish.api
+from openpype.pipeline.publish import (
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 import openpype.hosts.blender.api.action
 
 
-class ValidateObjectIsInObjectMode(pyblish.api.InstancePlugin):
+class ValidateObjectIsInObjectMode(
+        pyblish.api.InstancePlugin,
+        OptionalPyblishPluginMixin,
+):
     """Validate that the objects in the instance are in Object Mode."""
 
     order = pyblish.api.ValidatorOrder - 0.01
@@ -25,8 +32,12 @@ class ValidateObjectIsInObjectMode(pyblish.api.InstancePlugin):
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                f"Object found in instance is not in Object Mode: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                f"Object found in instance is not in Object Mode: {names}"
             )

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

@@ -2,8 +2,14 @@ import bpy
 
 import pyblish.api
 
+from openpype.pipeline.publish import (
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 
-class ValidateRenderCameraIsSet(pyblish.api.InstancePlugin):
+
+class ValidateRenderCameraIsSet(pyblish.api.InstancePlugin,
+                                OptionalPyblishPluginMixin):
     """Validate that there is a camera set as active for rendering."""
 
     order = pyblish.api.ValidatorOrder
@@ -13,5 +19,8 @@ class ValidateRenderCameraIsSet(pyblish.api.InstancePlugin):
     optional = False
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         if not bpy.context.scene.camera:
-            raise RuntimeError("No camera is active for rendering.")
+            raise PublishValidationError("No camera is active for rendering.")

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

@@ -6,10 +6,15 @@ import bpy
 import pyblish.api
 
 import openpype.hosts.blender.api.action
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+    ValidateContentsOrder,
+    OptionalPyblishPluginMixin,
+    PublishValidationError
+)
 
 
-class ValidateTransformZero(pyblish.api.InstancePlugin):
+class ValidateTransformZero(pyblish.api.InstancePlugin,
+                            OptionalPyblishPluginMixin):
     """Transforms can't have any values
 
     To solve this issue, try freezing the transforms. So long
@@ -38,9 +43,13 @@ class ValidateTransformZero(pyblish.api.InstancePlugin):
         return invalid
 
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         invalid = self.get_invalid(instance)
         if invalid:
-            raise RuntimeError(
-                "Object found in instance has not"
-                f" transform to zero: {invalid}"
+            names = ", ".join(obj.name for obj in invalid)
+            raise PublishValidationError(
+                "Objects found in instance which do not"
+                f" have transform set to zero: {names}"
             )

openpype/hosts/celaction/plugins/publish/collect_celaction_instances.py

@@ -1,6 +1,8 @@
 import os
 import pyblish.api
 
+from openpype.client import get_asset_name_identifier
+
 
 class CollectCelactionInstances(pyblish.api.ContextPlugin):
     """ Adds the celaction render instances """
@@ -17,8 +19,10 @@ class CollectCelactionInstances(pyblish.api.ContextPlugin):
         asset_entity = context.data["assetEntity"]
         project_entity = context.data["projectEntity"]
 
+        asset_name = get_asset_name_identifier(asset_entity)
+
         shared_instance_data = {
-            "asset": asset_entity["name"],
+            "asset": asset_name,
             "frameStart": asset_entity["data"]["frameStart"],
             "frameEnd": asset_entity["data"]["frameEnd"],
             "handleStart": asset_entity["data"]["handleStart"],

openpype/hosts/flame/plugins/publish/collect_timeline_otio.py

@@ -1,5 +1,6 @@
 import pyblish.api
 
+from openpype.client import get_asset_name_identifier
 import openpype.hosts.flame.api as opfapi
 from openpype.hosts.flame.otio import flame_export
 from openpype.pipeline.create import get_subset_name
@@ -33,13 +34,15 @@ class CollecTimelineOTIO(pyblish.api.ContextPlugin):
             project_settings=context.data["project_settings"]
         )
 
+        asset_name = get_asset_name_identifier(asset_doc)
+
         # adding otio timeline to context
         with opfapi.maintained_segment_selection(sequence) as selected_seg:
             otio_timeline = flame_export.create_otio_timeline(sequence)
 
             instance_data = {
                 "name": subset_name,
-                "asset": asset_doc["name"],
+                "asset": asset_name,
                 "subset": subset_name,
                 "family": "workfile",
                 "families": []

openpype/hosts/fusion/api/lib.py

@@ -280,7 +280,11 @@ def get_current_comp():
 
 
 @contextlib.contextmanager
-def comp_lock_and_undo_chunk(comp, undo_queue_name="Script CMD"):
+def comp_lock_and_undo_chunk(
+    comp,
+    undo_queue_name="Script CMD",
+    keep_undo=True,
+):
     """Lock comp and open an undo chunk during the context"""
     try:
         comp.Lock()
@@ -288,4 +292,4 @@ def comp_lock_and_undo_chunk(comp, undo_queue_name="Script CMD"):
         yield
     finally:
         comp.Unlock()
-        comp.EndUndo()
+        comp.EndUndo(keep_undo)

openpype/hosts/fusion/api/menu.py

@@ -1,3 +1,4 @@
+import os
 import sys
 
 from qtpy import QtWidgets, QtCore, QtGui
@@ -18,6 +19,10 @@ from openpype.resources import get_openpype_icon_filepath
 from .pipeline import FusionEventHandler
 from .pulse import FusionPulse
 
+
+MENU_LABEL = os.environ["AVALON_LABEL"]
+
+
 self = sys.modules[__name__]
 self.menu = None
 
@@ -26,7 +31,7 @@ class OpenPypeMenu(QtWidgets.QWidget):
     def __init__(self, *args, **kwargs):
         super(OpenPypeMenu, self).__init__(*args, **kwargs)
 
-        self.setObjectName("OpenPypeMenu")
+        self.setObjectName(f"{MENU_LABEL}Menu")
 
         icon_path = get_openpype_icon_filepath()
         icon = QtGui.QIcon(icon_path)
@@ -41,7 +46,7 @@ class OpenPypeMenu(QtWidgets.QWidget):
             | QtCore.Qt.WindowStaysOnTopHint
         )
         self.render_mode_widget = None
-        self.setWindowTitle("OpenPype")
+        self.setWindowTitle(MENU_LABEL)
 
         asset_label = QtWidgets.QLabel("Context", self)
         asset_label.setStyleSheet(

openpype/hosts/fusion/deploy/ayon/Config/menu.fu

@@ -0,0 +1,60 @@
+{
+    Action
+    {
+        ID = "AYON_Menu",
+        Category = "AYON",
+        Name = "AYON Menu",
+
+        Targets =
+        {
+            Composition =
+            {
+                Execute = _Lua [=[
+                    local scriptPath = app:MapPath("AYON:../MenuScripts/launch_menu.py")
+                    if bmd.fileexists(scriptPath) == false then
+                        print("[AYON Error] Can't run file: " .. scriptPath)
+                    else
+                        target:RunScript(scriptPath)
+                    end
+                ]=],
+            },
+        },
+    },
+    Action
+    {
+        ID = "AYON_Install_PySide2",
+        Category = "AYON",
+        Name = "Install PySide2",
+
+        Targets =
+        {
+            Composition =
+            {
+                Execute = _Lua [=[
+                    local scriptPath = app:MapPath("AYON:../MenuScripts/install_pyside2.py")
+                    if bmd.fileexists(scriptPath) == false then
+                        print("[AYON Error] Can't run file: " .. scriptPath)
+                    else
+                        target:RunScript(scriptPath)
+                    end
+                ]=],
+            },
+        },
+    },
+    Menus
+    {
+        Target = "ChildFrame",
+
+        Before "Help"
+        {
+            Sub "AYON"
+            {
+                "AYON_Menu{}",
+                "_",
+                Sub "Admin" {
+                    "AYON_Install_PySide2{}"
+                }
+            }
+        },
+    },
+}

openpype/hosts/fusion/deploy/ayon/fusion_shared.prefs

@@ -0,0 +1,19 @@
+{
+Locked = true,
+Global = {
+  Paths = {
+    Map = {
+      ["AYON:"] = "$(OPENPYPE_FUSION)/deploy/ayon",
+      ["Config:"] = "UserPaths:Config;AYON:Config",
+      ["Scripts:"] = "UserPaths:Scripts;Reactor:System/Scripts",
+    },
+  },
+  Script = {
+    PythonVersion = 3,
+    Python3Forced = true
+    },
+  UserInterface = {
+    Language = "en_US"
+    },
+  },
+}

openpype/hosts/fusion/deploy/openpype/Config/menu.fu

@@ -10,7 +10,7 @@
             Composition =
             {
                 Execute = _Lua [=[
-                    local scriptPath = app:MapPath("OpenPype:MenuScripts/openpype_menu.py")
+                    local scriptPath = app:MapPath("OpenPype:../MenuScripts/launch_menu.py")
                     if bmd.fileexists(scriptPath) == false then
                         print("[OpenPype Error] Can't run file: " .. scriptPath)
                     else
@@ -31,7 +31,7 @@
             Composition =
             {
                 Execute = _Lua [=[
-                    local scriptPath = app:MapPath("OpenPype:MenuScripts/install_pyside2.py")
+                    local scriptPath = app:MapPath("OpenPype:../MenuScripts/install_pyside2.py")
                     if bmd.fileexists(scriptPath) == false then
                         print("[OpenPype Error] Can't run file: " .. scriptPath)
                     else

openpype/hosts/fusion/deploy/openpype/fusion_shared.prefs

@@ -3,7 +3,7 @@ Locked = true,
 Global = {
   Paths = {
     Map = {
-      ["OpenPype:"] = "$(OPENPYPE_FUSION)/deploy",
+      ["OpenPype:"] = "$(OPENPYPE_FUSION)/deploy/openpype",
       ["Config:"] = "UserPaths:Config;OpenPype:Config",
       ["Scripts:"] = "UserPaths:Scripts;Reactor:System/Scripts",
     },

openpype/hosts/fusion/hooks/pre_fusion_profile_hook.py

@@ -2,6 +2,7 @@ import os
 import shutil
 import platform
 from pathlib import Path
+from openpype import AYON_SERVER_ENABLED
 from openpype.hosts.fusion import (
     FUSION_HOST_DIR,
     FUSION_VERSIONS_DICT,
@@ -161,6 +162,13 @@ class FusionCopyPrefsPrelaunch(PreLaunchHook):
         # profile directory variables to customize Fusion
         # to define where it can read custom scripts and tools from
         master_prefs_variable = f"FUSION{profile_version}_MasterPrefs"
-        master_prefs = Path(FUSION_HOST_DIR, "deploy", "fusion_shared.prefs")
+
+        if AYON_SERVER_ENABLED:
+            master_prefs = Path(
+                FUSION_HOST_DIR, "deploy", "ayon", "fusion_shared.prefs")
+        else:
+            master_prefs = Path(
+                FUSION_HOST_DIR, "deploy", "openpype", "fusion_shared.prefs")
+
         self.log.info(f"Setting {master_prefs_variable}: {master_prefs}")
         self.launch_context.env[master_prefs_variable] = str(master_prefs)

openpype/hosts/fusion/plugins/create/create_saver.py

@@ -69,8 +69,6 @@ class CreateSaver(NewCreator):
             # TODO Is this needed?
             saver[file_format]["SaveAlpha"] = 1
 
-        self._imprint(saver, instance_data)
-
         # Register the CreatedInstance
         instance = CreatedInstance(
             family=self.family,
@@ -78,6 +76,8 @@ class CreateSaver(NewCreator):
             data=instance_data,
             creator=self,
         )
+        data = instance.data_to_store()
+        self._imprint(saver, data)
 
         # Insert the transient data
         instance.transient_data["tool"] = saver
@@ -149,9 +149,7 @@ class CreateSaver(NewCreator):
 
         # get frame padding from anatomy templates
         anatomy = Anatomy()
-        frame_padding = int(
-            anatomy.templates["render"].get("frame_padding", 4)
-        )
+        frame_padding = anatomy.templates["frame_padding"]
 
         # Subset change detected
         workdir = os.path.normpath(legacy_io.Session["AVALON_WORKDIR"])

openpype/hosts/fusion/plugins/create/create_workfile.py

@@ -1,6 +1,7 @@
 from openpype.hosts.fusion.api import (
     get_current_comp
 )
+from openpype import AYON_SERVER_ENABLED
 from openpype.client import get_asset_by_name
 from openpype.pipeline import (
     AutoCreator,
@@ -68,6 +69,13 @@ class FusionWorkfileCreator(AutoCreator):
         task_name = self.create_context.get_current_task_name()
         host_name = self.create_context.host_name
 
+        if existing_instance is None:
+            existing_instance_asset = None
+        elif AYON_SERVER_ENABLED:
+            existing_instance_asset = existing_instance["folderPath"]
+        else:
+            existing_instance_asset = existing_instance["asset"]
+
         if existing_instance is None:
             asset_doc = get_asset_by_name(project_name, asset_name)
             subset_name = self.get_subset_name(
@@ -75,10 +83,13 @@ class FusionWorkfileCreator(AutoCreator):
                 project_name, host_name
             )
             data = {
-                "asset": asset_name,
                 "task": task_name,
                 "variant": self.default_variant
             }
+            if AYON_SERVER_ENABLED:
+                data["folderPath"] = asset_name
+            else:
+                data["asset"] = asset_name
             data.update(self.get_dynamic_data(
                 self.default_variant, task_name, asset_doc,
                 project_name, host_name, None
@@ -91,7 +102,7 @@ class FusionWorkfileCreator(AutoCreator):
             self._add_instance_to_context(new_instance)
 
         elif (
-            existing_instance["asset"] != asset_name
+            existing_instance_asset != asset_name
             or existing_instance["task"] != task_name
         ):
             asset_doc = get_asset_by_name(project_name, asset_name)
@@ -99,6 +110,9 @@ class FusionWorkfileCreator(AutoCreator):
                 self.default_variant, task_name, asset_doc,
                 project_name, host_name
             )
-            existing_instance["asset"] = asset_name
+            if AYON_SERVER_ENABLED:
+                existing_instance["folderPath"] = asset_name
+            else:
+                existing_instance["asset"] = asset_name
             existing_instance["task"] = task_name
             existing_instance["subset"] = subset_name

openpype/hosts/fusion/plugins/load/actions.py

@@ -11,6 +11,7 @@ class FusionSetFrameRangeLoader(load.LoaderPlugin):
     families = ["animation",
                 "camera",
                 "imagesequence",
+                "render",
                 "yeticache",
                 "pointcache",
                 "render"]
@@ -46,6 +47,7 @@ class FusionSetFrameRangeWithHandlesLoader(load.LoaderPlugin):
     families = ["animation",
                 "camera",
                 "imagesequence",
+                "render",
                 "yeticache",
                 "pointcache",
                 "render"]

openpype/hosts/fusion/plugins/load/load_usd.py

@@ -0,0 +1,87 @@
+from openpype.pipeline import (
+    load,
+    get_representation_path,
+)
+from openpype.hosts.fusion.api import (
+    imprint_container,
+    get_current_comp,
+    comp_lock_and_undo_chunk
+)
+from openpype.hosts.fusion.api.lib import get_fusion_module
+
+
+class FusionLoadUSD(load.LoaderPlugin):
+    """Load USD into Fusion
+
+    Support for USD was added since Fusion 18.5
+    """
+
+    families = ["*"]
+    representations = ["*"]
+    extensions = {"usd", "usda", "usdz"}
+
+    label = "Load USD"
+    order = -10
+    icon = "code-fork"
+    color = "orange"
+
+    tool_type = "uLoader"
+
+    @classmethod
+    def apply_settings(cls, project_settings, system_settings):
+        super(FusionLoadUSD, cls).apply_settings(project_settings,
+                                                 system_settings)
+        if cls.enabled:
+            # Enable only in Fusion 18.5+
+            fusion = get_fusion_module()
+            version = fusion.GetVersion()
+            major = version[1]
+            minor = version[2]
+            is_usd_supported = (major, minor) >= (18, 5)
+            cls.enabled = is_usd_supported
+
+    def load(self, context, name, namespace, data):
+        # Fallback to asset name when namespace is None
+        if namespace is None:
+            namespace = context['asset']['name']
+
+        # Create the Loader with the filename path set
+        comp = get_current_comp()
+        with comp_lock_and_undo_chunk(comp, "Create tool"):
+
+            path = self.fname
+
+            args = (-32768, -32768)
+            tool = comp.AddTool(self.tool_type, *args)
+            tool["Filename"] = path
+
+            imprint_container(tool,
+                              name=name,
+                              namespace=namespace,
+                              context=context,
+                              loader=self.__class__.__name__)
+
+    def switch(self, container, representation):
+        self.update(container, representation)
+
+    def update(self, container, representation):
+
+        tool = container["_tool"]
+        assert tool.ID == self.tool_type, f"Must be {self.tool_type}"
+        comp = tool.Comp()
+
+        path = get_representation_path(representation)
+
+        with comp_lock_and_undo_chunk(comp, "Update tool"):
+            tool["Filename"] = path
+
+            # Update the imprinted representation
+            tool.SetData("avalon.representation", str(representation["_id"]))
+
+    def remove(self, container):
+        tool = container["_tool"]
+        assert tool.ID == self.tool_type, f"Must be {self.tool_type}"
+        comp = tool.Comp()
+
+        with comp_lock_and_undo_chunk(comp, "Remove tool"):
+            tool.Delete()

openpype/hosts/fusion/plugins/publish/extract_render_local.py

@@ -25,20 +25,24 @@ def enabled_savers(comp, savers):
     """
     passthrough_key = "TOOLB_PassThrough"
     original_states = {}
-    enabled_save_names = {saver.Name for saver in savers}
+    enabled_saver_names = {saver.Name for saver in savers}
+
+    all_savers = comp.GetToolList(False, "Saver").values()
+    savers_by_name = {saver.Name: saver for saver in all_savers}
+
     try:
-        all_savers = comp.GetToolList(False, "Saver").values()
         for saver in all_savers:
             original_state = saver.GetAttrs()[passthrough_key]
-            original_states[saver] = original_state
+            original_states[saver.Name] = original_state
 
             # The passthrough state we want to set (passthrough != enabled)
-            state = saver.Name not in enabled_save_names
+            state = saver.Name not in enabled_saver_names
             if state != original_state:
                 saver.SetAttrs({passthrough_key: state})
         yield
     finally:
-        for saver, original_state in original_states.items():
+        for saver_name, original_state in original_states.items():
+            saver = savers_by_name[saver_name]
             saver.SetAttrs({"TOOLB_PassThrough": original_state})
 
 

openpype/hosts/fusion/plugins/publish/validate_saver_resolution.py

@@ -0,0 +1,105 @@
+import pyblish.api
+from openpype.pipeline import (
+    PublishValidationError,
+    OptionalPyblishPluginMixin,
+)
+
+from openpype.hosts.fusion.api.action import SelectInvalidAction
+from openpype.hosts.fusion.api import comp_lock_and_undo_chunk
+
+
+def get_tool_resolution(tool, frame):
+    """Return the 2D input resolution to a Fusion tool
+
+    If the current tool hasn't been rendered its input resolution
+    hasn't been saved. To combat this, add an expression in
+    the comments field to read the resolution
+
+    Args
+        tool (Fusion Tool): The tool to query input resolution
+        frame (int): The frame to query the resolution on.
+
+    Returns:
+        tuple: width, height as 2-tuple of integers
+
+    """
+    comp = tool.Composition
+
+    # False undo removes the undo-stack from the undo list
+    with comp_lock_and_undo_chunk(comp, "Read resolution", False):
+        # Save old comment
+        old_comment = ""
+        has_expression = False
+        if tool["Comments"][frame] != "":
+            if tool["Comments"].GetExpression() is not None:
+                has_expression = True
+                old_comment = tool["Comments"].GetExpression()
+                tool["Comments"].SetExpression(None)
+            else:
+                old_comment = tool["Comments"][frame]
+                tool["Comments"][frame] = ""
+
+        # Get input width
+        tool["Comments"].SetExpression("self.Input.OriginalWidth")
+        width = int(tool["Comments"][frame])
+
+        # Get input height
+        tool["Comments"].SetExpression("self.Input.OriginalHeight")
+        height = int(tool["Comments"][frame])
+
+        # Reset old comment
+        tool["Comments"].SetExpression(None)
+        if has_expression:
+            tool["Comments"].SetExpression(old_comment)
+        else:
+            tool["Comments"][frame] = old_comment
+
+        return width, height
+
+
+class ValidateSaverResolution(
+    pyblish.api.InstancePlugin, OptionalPyblishPluginMixin
+):
+    """Validate that the saver input resolution matches the asset resolution"""
+
+    order = pyblish.api.ValidatorOrder
+    label = "Validate Asset Resolution"
+    families = ["render"]
+    hosts = ["fusion"]
+    optional = True
+    actions = [SelectInvalidAction]
+
+    def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
+        resolution = self.get_resolution(instance)
+        expected_resolution = self.get_expected_resolution(instance)
+        if resolution != expected_resolution:
+            raise PublishValidationError(
+                "The input's resolution does not match "
+                "the asset's resolution {}x{}.\n\n"
+                "The input's resolution is {}x{}.".format(
+                    expected_resolution[0], expected_resolution[1],
+                    resolution[0], resolution[1]
+                )
+            )
+
+    @classmethod
+    def get_invalid(cls, instance):
+        resolution = cls.get_resolution(instance)
+        expected_resolution = cls.get_expected_resolution(instance)
+        if resolution != expected_resolution:
+            saver = instance.data["tool"]
+            return [saver]
+
+    @classmethod
+    def get_resolution(cls, instance):
+        saver = instance.data["tool"]
+        first_frame = instance.data["frameStartHandle"]
+        return get_tool_resolution(saver, frame=first_frame)
+
+    @classmethod
+    def get_expected_resolution(cls, instance):
+        data = instance.data["assetEntity"]["data"]
+        return data["resolutionWidth"], data["resolutionHeight"]

openpype/hosts/harmony/api/TB_sceneOpened.js

@@ -13,7 +13,7 @@ var LD_OPENHARMONY_PATH = System.getenv('LIB_OPENHARMONY_PATH');
 LD_OPENHARMONY_PATH = LD_OPENHARMONY_PATH + '/openHarmony.js';
 LD_OPENHARMONY_PATH = LD_OPENHARMONY_PATH.replace(/\\/g, "/");
 include(LD_OPENHARMONY_PATH);
-this.__proto__['$'] = $;
+//this.__proto__['$'] = $;
 
 function Client() {
     var self = this;

openpype/hosts/harmony/plugins/publish/extract_render.py

@@ -59,8 +59,8 @@ class ExtractRender(pyblish.api.InstancePlugin):
 
         args = [application_path, "-batch",
                 "-frames", str(frame_start), str(frame_end),
-                "-scene", scene_path]
-        self.log.info(f"running [ {application_path} {' '.join(args)}")
+                scene_path]
+        self.log.info(f"running: {' '.join(args)}")
         proc = subprocess.Popen(
             args,
             stdout=subprocess.PIPE,

openpype/hosts/hiero/api/menu.py

@@ -95,18 +95,18 @@ def menu_install():
 
     menu.addSeparator()
 
-    publish_action = menu.addAction("Publish...")
-    publish_action.setIcon(QtGui.QIcon("icons:Output.png"))
-    publish_action.triggered.connect(
-        lambda *args: publish(hiero.ui.mainWindow())
-    )
-
     creator_action = menu.addAction("Create...")
     creator_action.setIcon(QtGui.QIcon("icons:CopyRectangle.png"))
     creator_action.triggered.connect(
         lambda: host_tools.show_creator(parent=main_window)
     )
 
+    publish_action = menu.addAction("Publish...")
+    publish_action.setIcon(QtGui.QIcon("icons:Output.png"))
+    publish_action.triggered.connect(
+        lambda *args: publish(hiero.ui.mainWindow())
+    )
+
     loader_action = menu.addAction("Load...")
     loader_action.setIcon(QtGui.QIcon("icons:CopyRectangle.png"))
     loader_action.triggered.connect(

openpype/hosts/hiero/api/plugin.py

@@ -11,7 +11,6 @@ import qargparse
 from openpype.settings import get_current_project_settings
 from openpype.lib import Logger
 from openpype.pipeline import LoaderPlugin, LegacyCreator
-from openpype.pipeline.context_tools import get_current_project_asset
 from openpype.pipeline.load import get_representation_path_from_context
 from . import lib
 
@@ -32,7 +31,7 @@ def load_stylesheet():
 class CreatorWidget(QtWidgets.QDialog):
 
     # output items
-    items = dict()
+    items = {}
 
     def __init__(self, name, info, ui_inputs, parent=None):
         super(CreatorWidget, self).__init__(parent)
@@ -494,9 +493,8 @@ class ClipLoader:
         joint `data` key with asset.data dict into the representation
 
         """
-        asset_name = self.context["representation"]["context"]["asset"]
-        asset_doc = get_current_project_asset(asset_name)
-        log.debug("__ asset_doc: {}".format(pformat(asset_doc)))
+
+        asset_doc = self.context["asset"]
         self.data["assetData"] = asset_doc["data"]
 
     def _make_track_item(self, source_bin_item, audio=False):
@@ -644,8 +642,8 @@ class PublishClip:
     Returns:
         hiero.core.TrackItem: hiero track item object with pype tag
     """
-    vertical_clip_match = dict()
-    tag_data = dict()
+    vertical_clip_match = {}
+    tag_data = {}
     types = {
         "shot": "shot",
         "folder": "folder",
@@ -707,9 +705,10 @@ class PublishClip:
         self._create_parents()
 
     def convert(self):
-
         # solve track item data and add them to tag data
-        self._convert_to_tag_data()
+        tag_hierarchy_data = self._convert_to_tag_data()
+
+        self.tag_data.update(tag_hierarchy_data)
 
         # if track name is in review track name and also if driving track name
         # is not in review track name: skip tag creation
@@ -723,16 +722,23 @@ class PublishClip:
         if self.rename:
             # rename track item
             self.track_item.setName(new_name)
-            self.tag_data["asset"] = new_name
+            self.tag_data["asset_name"] = new_name
         else:
-            self.tag_data["asset"] = self.ti_name
+            self.tag_data["asset_name"] = self.ti_name
             self.tag_data["hierarchyData"]["shot"] = self.ti_name
 
+        # AYON unique identifier
+        folder_path = "/{}/{}".format(
+            tag_hierarchy_data["hierarchy"],
+            self.tag_data["asset_name"]
+        )
+        self.tag_data["folderPath"] = folder_path
         if self.tag_data["heroTrack"] and self.review_layer:
             self.tag_data.update({"reviewTrack": self.review_layer})
         else:
             self.tag_data.update({"reviewTrack": None})
 
+        # TODO: remove debug print
         log.debug("___ self.tag_data: {}".format(
             pformat(self.tag_data)
         ))
@@ -891,7 +897,7 @@ class PublishClip:
                     tag_hierarchy_data = hero_data
 
         # add data to return data dict
-        self.tag_data.update(tag_hierarchy_data)
+        return tag_hierarchy_data
 
     def _solve_tag_hierarchy_data(self, hierarchy_formatting_data):
         """ Solve tag data from hierarchy data and templates. """

openpype/hosts/hiero/plugins/publish/collect_frame_tag_instances.py

@@ -5,6 +5,8 @@ import json
 
 import pyblish.api
 
+from openpype.client import get_asset_name_identifier
+
 
 class CollectFrameTagInstances(pyblish.api.ContextPlugin):
     """Collect frames from tags.
@@ -99,6 +101,9 @@ class CollectFrameTagInstances(pyblish.api.ContextPlugin):
 
         # first collect all available subset tag frames
         subset_data = {}
+        context_asset_doc = context.data["assetEntity"]
+        context_asset_name = get_asset_name_identifier(context_asset_doc)
+
         for tag_data in sequence_tags:
             frame = int(tag_data["start"])
 
@@ -115,7 +120,7 @@ class CollectFrameTagInstances(pyblish.api.ContextPlugin):
                 subset_data[subset] = {
                     "frames": [frame],
                     "format": tag_data["format"],
-                    "asset": context.data["assetEntity"]["name"]
+                    "asset": context_asset_name
                 }
         return subset_data
 

openpype/hosts/hiero/plugins/publish/precollect_instances.py

@@ -1,9 +1,12 @@
 import pyblish
+
+from openpype import AYON_SERVER_ENABLED
 from openpype.pipeline.editorial import is_overlapping_otio_ranges
+
 from openpype.hosts.hiero import api as phiero
 from openpype.hosts.hiero.api.otio import hiero_export
-import hiero
 
+import hiero
 # # developer reload modules
 from pprint import pformat
 
@@ -80,25 +83,24 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
                 if k not in ("id", "applieswhole", "label")
             })
 
-            asset = tag_data["asset"]
+            asset, asset_name = self._get_asset_data(tag_data)
+
             subset = tag_data["subset"]
 
             # insert family into families
-            family = tag_data["family"]
             families = [str(f) for f in tag_data["families"]]
-            families.insert(0, str(family))
 
             # form label
-            label = asset
-            if asset != clip_name:
+            label = "{} -".format(asset)
+            if asset_name != clip_name:
                 label += " ({})".format(clip_name)
             label += " {}".format(subset)
-            label += " {}".format("[" + ", ".join(families) + "]")
 
             data.update({
                 "name": "{}_{}".format(asset, subset),
                 "label": label,
                 "asset": asset,
+                "asset_name": asset_name,
                 "item": track_item,
                 "families": families,
                 "publish": tag_data["publish"],
@@ -176,9 +178,9 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
             })
 
     def create_shot_instance(self, context, **data):
+        subset = "shotMain"
         master_layer = data.get("heroTrack")
         hierarchy_data = data.get("hierarchyData")
-        asset = data.get("asset")
         item = data.get("item")
         clip_name = item.name()
 
@@ -189,23 +191,21 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
             return
 
         asset = data["asset"]
-        subset = "shotMain"
+        asset_name = data["asset_name"]
 
         # insert family into families
         family = "shot"
 
         # form label
-        label = asset
-        if asset != clip_name:
+        label = "{} -".format(asset)
+        if asset_name != clip_name:
             label += " ({}) ".format(clip_name)
         label += " {}".format(subset)
-        label += " [{}]".format(family)
 
         data.update({
             "name": "{}_{}".format(asset, subset),
             "label": label,
             "subset": subset,
-            "asset": asset,
             "family": family,
             "families": []
         })
@@ -215,7 +215,33 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
         self.log.debug(
             "_ instance.data: {}".format(pformat(instance.data)))
 
+    def _get_asset_data(self, data):
+        folder_path = data.pop("folderPath", None)
+
+        if data.get("asset_name"):
+            asset_name = data["asset_name"]
+        else:
+            asset_name = data["asset"]
+
+        # backward compatibility for clip tags
+        # which are missing folderPath key
+        # TODO remove this in future versions
+        if not folder_path:
+            hierarchy_path = data["hierarchy"]
+            folder_path = "/{}/{}".format(
+                hierarchy_path,
+                asset_name
+            )
+
+        if AYON_SERVER_ENABLED:
+            asset = folder_path
+        else:
+            asset = asset_name
+
+        return asset, asset_name
+
     def create_audio_instance(self, context, **data):
+        subset = "audioMain"
         master_layer = data.get("heroTrack")
 
         if not master_layer:
@@ -230,23 +256,21 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
             return
 
         asset = data["asset"]
-        subset = "audioMain"
+        asset_name = data["asset_name"]
 
         # insert family into families
         family = "audio"
 
         # form label
-        label = asset
-        if asset != clip_name:
+        label = "{} -".format(asset)
+        if asset_name != clip_name:
             label += " ({}) ".format(clip_name)
         label += " {}".format(subset)
-        label += " [{}]".format(family)
 
         data.update({
             "name": "{}_{}".format(asset, subset),
             "label": label,
             "subset": subset,
-            "asset": asset,
             "family": family,
             "families": ["clip"]
         })

openpype/hosts/hiero/plugins/publish/precollect_workfile.py

@@ -7,6 +7,7 @@ from qtpy.QtGui import QPixmap
 
 import hiero.ui
 
+from openpype import AYON_SERVER_ENABLED
 from openpype.hosts.hiero.api.otio import hiero_export
 
 
@@ -17,9 +18,11 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
     order = pyblish.api.CollectorOrder - 0.491
 
     def process(self, context):
-
         asset = context.data["asset"]
-        subset = "workfile"
+        asset_name = asset
+        if AYON_SERVER_ENABLED:
+            asset_name = asset_name.split("/")[-1]
+
         active_timeline = hiero.ui.activeSequence()
         project = active_timeline.project()
         fps = active_timeline.framerate().toFloat()
@@ -27,7 +30,7 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
         # adding otio timeline to context
         otio_timeline = hiero_export.create_otio_timeline()
 
-        # get workfile thumnail paths
+        # get workfile thumbnail paths
         tmp_staging = tempfile.mkdtemp(prefix="pyblish_tmp_")
         thumbnail_name = "workfile_thumbnail.png"
         thumbnail_path = os.path.join(tmp_staging, thumbnail_name)
@@ -49,8 +52,8 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
         }
 
         # get workfile paths
-        curent_file = project.path()
-        staging_dir, base_name = os.path.split(curent_file)
+        current_file = project.path()
+        staging_dir, base_name = os.path.split(current_file)
 
         # creating workfile representation
         workfile_representation = {
@@ -59,13 +62,16 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
             'files': base_name,
             "stagingDir": staging_dir,
         }
-
+        family = "workfile"
         instance_data = {
-            "name": "{}_{}".format(asset, subset),
-            "asset": asset,
-            "subset": "{}{}".format(asset, subset.capitalize()),
+            "label": "{} - {}Main".format(
+                asset, family),
+            "name": "{}_{}".format(asset_name, family),
+            "asset": context.data["asset"],
+            # TODO use 'get_subset_name'
+            "subset": "{}{}Main".format(asset_name, family.capitalize()),
             "item": project,
-            "family": "workfile",
+            "family": family,
             "families": [],
             "representations": [workfile_representation, thumb_representation]
         }
@@ -78,7 +84,7 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
             "activeProject": project,
             "activeTimeline": active_timeline,
             "otioTimeline": otio_timeline,
-            "currentFile": curent_file,
+            "currentFile": current_file,
             "colorspace": self.get_colorspace(project),
             "fps": fps
         }

openpype/hosts/hiero/plugins/publish_old_workflow/collect_assetbuilds.py

@@ -1,5 +1,6 @@
 from pyblish import api
-from openpype.client import get_assets
+
+from openpype.client import get_assets, get_asset_name_identifier
 
 
 class CollectAssetBuilds(api.ContextPlugin):
@@ -19,10 +20,13 @@ class CollectAssetBuilds(api.ContextPlugin):
     def process(self, context):
         project_name = context.data["projectName"]
         asset_builds = {}
-        for asset in get_assets(project_name):
-            if asset["data"]["entityType"] == "AssetBuild":
-                self.log.debug("Found \"{}\" in database.".format(asset))
-                asset_builds[asset["name"]] = asset
+        for asset_doc in get_assets(project_name):
+            if asset_doc["data"].get("entityType") != "AssetBuild":
+                continue
+
+            asset_name = get_asset_name_identifier(asset_doc)
+            self.log.debug("Found \"{}\" in database.".format(asset_doc))
+            asset_builds[asset_name] = asset_doc
 
         for instance in context:
             if instance.data["family"] != "clip":
@@ -50,9 +54,7 @@ class CollectAssetBuilds(api.ContextPlugin):
             # Collect asset builds.
             data = {"assetbuilds": []}
             for name in asset_names:
-                data["assetbuilds"].append(
-                    asset_builds[name]
-                )
+                data["assetbuilds"].append(asset_builds[name])
             self.log.debug(
                 "Found asset builds: {}".format(data["assetbuilds"])
             )

openpype/hosts/houdini/api/creator_node_shelves.py

@@ -173,6 +173,7 @@ def install():
         os.remove(filepath)
 
     icon = get_openpype_icon_filepath()
+    tab_menu_label = os.environ.get("AVALON_LABEL") or "AYON"
 
     # Create context only to get creator plugins, so we don't reset and only
     # populate what we need to retrieve the list of creator plugins
@@ -197,14 +198,14 @@ def install():
             if not network_categories:
                 continue
 
-            key = "openpype_create.{}".format(identifier)
+            key = "ayon_create.{}".format(identifier)
             log.debug(f"Registering {key}")
             script = CREATE_SCRIPT.format(identifier=identifier)
             data = {
                 "script": script,
                 "language": hou.scriptLanguage.Python,
                 "icon": icon,
-                "help": "Create OpenPype publish instance for {}".format(
+                "help": "Create Ayon publish instance for {}".format(
                     creator.label
                 ),
                 "help_url": None,
@@ -213,7 +214,7 @@ def install():
                 "cop_viewer_categories": [],
                 "network_op_type": None,
                 "viewer_op_type": None,
-                "locations": ["OpenPype"]
+                "locations": [tab_menu_label]
             }
             label = "Create {}".format(creator.label)
             tool = hou.shelves.tool(key)

openpype/hosts/houdini/api/lib.py

@@ -11,20 +11,21 @@ import json
 import six
 
 from openpype.lib import StringTemplate
-from openpype.client import get_asset_by_name
+from openpype.client import get_project, get_asset_by_name
 from openpype.settings import get_current_project_settings
 from openpype.pipeline import (
+    Anatomy,
     get_current_project_name,
     get_current_asset_name,
-    registered_host
-)
-from openpype.pipeline.context_tools import (
-    get_current_context_template_data,
-    get_current_project_asset
+    registered_host,
+    get_current_context,
+    get_current_host_name,
 )
+from openpype.pipeline.create import CreateContext
+from openpype.pipeline.template_data import get_template_data
+from openpype.pipeline.context_tools import get_current_project_asset
 from openpype.widgets import popup
 from openpype.tools.utils.host_tools import get_tool_by_name
-from openpype.pipeline.create import CreateContext
 
 import hou
 
@@ -120,8 +121,8 @@ def get_id_required_nodes():
     return list(nodes)
 
 
-def get_output_parameter(node):
-    """Return the render output parameter name of the given node
+def get_export_parameter(node):
+    """Return the export output parameter of the given node
 
     Example:
         root = hou.node("/obj")
@@ -136,13 +137,70 @@ def get_output_parameter(node):
         hou.Parm
 
     """
+    node_type = node.type().description()
 
-    node_type = node.type().name()
-    if node_type == "geometry":
+    # Ensures the proper Take is selected for each ROP to retrieve the correct
+    # ifd
+    try:
+        rop_take = hou.takes.findTake(node.parm("take").eval())
+        if rop_take is not None:
+            hou.takes.setCurrentTake(rop_take)
+    except AttributeError:
+        # hou object doesn't always have the 'takes' attribute
+        pass
+
+    if node_type == "Mantra" and node.parm("soho_outputmode").eval():
+        return node.parm("soho_diskfile")
+    elif node_type == "Alfred":
+        return node.parm("alf_diskfile")
+    elif (node_type == "RenderMan" or node_type == "RenderMan RIS"):
+        pre_ris22 = node.parm("rib_outputmode") and \
+            node.parm("rib_outputmode").eval()
+        ris22 = node.parm("diskfile") and node.parm("diskfile").eval()
+        if pre_ris22 or ris22:
+            return node.parm("soho_diskfile")
+    elif node_type == "Redshift" and node.parm("RS_archive_enable").eval():
+        return node.parm("RS_archive_file")
+    elif node_type == "Wedge" and node.parm("driver").eval():
+        return get_export_parameter(node.node(node.parm("driver").eval()))
+    elif node_type == "Arnold":
+        return node.parm("ar_ass_file")
+    elif node_type == "Alembic" and node.parm("use_sop_path").eval():
+        return node.parm("sop_path")
+    elif node_type == "Shotgun Mantra" and node.parm("soho_outputmode").eval():
+        return node.parm("sgtk_soho_diskfile")
+    elif node_type == "Shotgun Alembic" and node.parm("use_sop_path").eval():
+        return node.parm("sop_path")
+    elif node.type().nameWithCategory() == "Driver/vray_renderer":
+        return node.parm("render_export_filepath")
+
+    raise TypeError("Node type '%s' not supported" % node_type)
+
+
+def get_output_parameter(node):
+    """Return the render output parameter of the given node
+
+    Example:
+        root = hou.node("/obj")
+        my_alembic_node = root.createNode("alembic")
+        get_output_parameter(my_alembic_node)
+        # Result: "output"
+
+    Args:
+        node(hou.Node): node instance
+
+    Returns:
+        hou.Parm
+
+    """
+    node_type = node.type().description()
+    category = node.type().category().name()
+
+    # Figure out which type of node is being rendered
+    if node_type == "Geometry" or node_type == "Filmbox FBX" or \
+            (node_type == "ROP Output Driver" and category == "Sop"):
         return node.parm("sopoutput")
-    elif node_type == "alembic":
-        return node.parm("filename")
-    elif node_type == "comp":
+    elif node_type == "Composite":
         return node.parm("copoutput")
     elif node_type == "opengl":
         return node.parm("picture")
@@ -151,6 +209,17 @@ def get_output_parameter(node):
             return node.parm("ar_ass_file")
     elif node_type == "Redshift_Proxy_Output":
         return node.parm("RS_archive_file")
+    elif node_type == "ifd":
+        if node.evalParm("soho_outputmode"):
+            return node.parm("soho_diskfile")
+    elif node_type == "Octane":
+        return node.parm("HO_img_fileName")
+    elif node_type == "Fetch":
+        inner_node = node.node(node.parm("source").eval())
+        if inner_node:
+            return get_output_parameter(inner_node)
+    elif node.type().nameWithCategory() == "Driver/vray_renderer":
+        return node.parm("SettingsOutput_img_file_path")
 
     raise TypeError("Node type '%s' not supported" % node_type)
 
@@ -568,9 +637,9 @@ def get_template_from_value(key, value):
     return parm
 
 
-def get_frame_data(node, handle_start=0, handle_end=0, log=None):
-    """Get the frame data: start frame, end frame, steps,
-    start frame with start handle and end frame with end handle.
+def get_frame_data(node, log=None):
+    """Get the frame data: `frameStartHandle`, `frameEndHandle`
+    and `byFrameStep`.
 
     This function uses Houdini node's `trange`, `t1, `t2` and `t3`
     parameters as the source of truth for the full inclusive frame
@@ -578,20 +647,17 @@ def get_frame_data(node, handle_start=0, handle_end=0, log=None):
     range including the handles.
 
     The non-inclusive frame start and frame end without handles
-    are computed by subtracting the handles from the inclusive
+    can be computed by subtracting the handles from the inclusive
     frame range.
 
     Args:
         node (hou.Node): ROP node to retrieve frame range from,
             the frame range is assumed to be the frame range
             *including* the start and end handles.
-        handle_start (int): Start handles.
-        handle_end (int): End handles.
-        log (logging.Logger): Logger to log to.
 
     Returns:
-        dict: frame data for start, end, steps,
-              start with handle and end with handle
+        dict: frame data for `frameStartHandle`, `frameEndHandle`
+            and `byFrameStep`.
 
     """
 
@@ -622,11 +688,6 @@ def get_frame_data(node, handle_start=0, handle_end=0, log=None):
         data["frameEndHandle"] = int(node.evalParm("f2"))
         data["byFrameStep"] = node.evalParm("f3")
 
-    data["handleStart"] = handle_start
-    data["handleEnd"] = handle_end
-    data["frameStart"] = data["frameStartHandle"] + data["handleStart"]
-    data["frameEnd"] = data["frameEndHandle"] - data["handleEnd"]
-
     return data
 
 
@@ -804,6 +865,45 @@ def get_camera_from_container(container):
     return cameras[0]
 
 
+def get_current_context_template_data_with_asset_data():
+    """
+    TODOs:
+        Support both 'assetData' and 'folderData' in future.
+    """
+
+    context = get_current_context()
+    project_name = context["project_name"]
+    asset_name = context["asset_name"]
+    task_name = context["task_name"]
+    host_name = get_current_host_name()
+
+    anatomy = Anatomy(project_name)
+    project_doc = get_project(project_name)
+    asset_doc = get_asset_by_name(project_name, asset_name)
+
+    # get context specific vars
+    asset_data = asset_doc["data"]
+
+    # compute `frameStartHandle` and `frameEndHandle`
+    frame_start = asset_data.get("frameStart")
+    frame_end = asset_data.get("frameEnd")
+    handle_start = asset_data.get("handleStart")
+    handle_end = asset_data.get("handleEnd")
+    if frame_start is not None and handle_start is not None:
+        asset_data["frameStartHandle"] = frame_start - handle_start
+
+    if frame_end is not None and handle_end is not None:
+        asset_data["frameEndHandle"] = frame_end + handle_end
+
+    template_data = get_template_data(
+        project_doc, asset_doc, task_name, host_name
+    )
+    template_data["root"] = anatomy.roots
+    template_data["assetData"] = asset_data
+
+    return template_data
+
+
 def get_context_var_changes():
     """get context var changes."""
 
@@ -823,7 +923,7 @@ def get_context_var_changes():
         return houdini_vars_to_update
 
     # Get Template data
-    template_data = get_current_context_template_data()
+    template_data = get_current_context_template_data_with_asset_data()
 
     # Set Houdini Vars
     for item in houdini_vars:
@@ -978,7 +1078,7 @@ def self_publish():
 def add_self_publish_button(node):
     """Adds a self publish button to the rop node."""
 
-    label = os.environ.get("AVALON_LABEL") or "OpenPype"
+    label = os.environ.get("AVALON_LABEL") or "AYON"
 
     button_parm = hou.ButtonParmTemplate(
         "ayon_self_publish",

openpype/hosts/houdini/api/pipeline.py

@@ -3,7 +3,6 @@
 import os
 import sys
 import logging
-import contextlib
 
 import hou  # noqa
 
@@ -66,15 +65,7 @@ class HoudiniHost(HostBase, IWorkfileHost, ILoadHost, IPublishHost):
         register_event_callback("open", on_open)
         register_event_callback("new", on_new)
 
-        pyblish.api.register_callback(
-            "instanceToggled", on_pyblish_instance_toggled
-        )
-
         self._has_been_setup = True
-        # add houdini vendor packages
-        hou_pythonpath = os.path.join(HOUDINI_HOST_DIR, "vendor")
-
-        sys.path.append(hou_pythonpath)
 
         # Set asset settings for the empty scene directly after launch of
         # Houdini so it initializes into the correct scene FPS,
@@ -406,54 +397,3 @@ def _set_context_settings():
 
     lib.reset_framerange()
     lib.update_houdini_vars_context()
-
-
-def on_pyblish_instance_toggled(instance, new_value, old_value):
-    """Toggle saver tool passthrough states on instance toggles."""
-    @contextlib.contextmanager
-    def main_take(no_update=True):
-        """Enter root take during context"""
-        original_take = hou.takes.currentTake()
-        original_update_mode = hou.updateModeSetting()
-        root = hou.takes.rootTake()
-        has_changed = False
-        try:
-            if original_take != root:
-                has_changed = True
-                if no_update:
-                    hou.setUpdateMode(hou.updateMode.Manual)
-                hou.takes.setCurrentTake(root)
-                yield
-        finally:
-            if has_changed:
-                if no_update:
-                    hou.setUpdateMode(original_update_mode)
-                hou.takes.setCurrentTake(original_take)
-
-    if not instance.data.get("_allowToggleBypass", True):
-        return
-
-    nodes = instance[:]
-    if not nodes:
-        return
-
-    # Assume instance node is first node
-    instance_node = nodes[0]
-
-    if not hasattr(instance_node, "isBypassed"):
-        # Likely not a node that can actually be bypassed
-        log.debug("Can't bypass node: %s", instance_node.path())
-        return
-
-    if instance_node.isBypassed() != (not old_value):
-        print("%s old bypass state didn't match old instance state, "
-              "updating anyway.." % instance_node.path())
-
-    try:
-        # Go into the main take, because when in another take changing
-        # the bypass state of a note cannot be done due to it being locked
-        # by default.
-        with main_take(no_update=True):
-            instance_node.bypass(not new_value)
-    except hou.PermissionError as exc:
-        log.warning("%s - %s", instance_node.path(), exc)

openpype/hosts/houdini/api/plugin.py

@@ -6,6 +6,8 @@ from abc import (
 )
 import six
 import hou
+
+from openpype import AYON_SERVER_ENABLED
 from openpype.pipeline import (
     CreatorError,
     LegacyCreator,
@@ -142,12 +144,13 @@ class HoudiniCreatorBase(object):
 
     @staticmethod
     def create_instance_node(
-            node_name, parent,
-            node_type="geometry"):
+        asset_name, node_name, parent, node_type="geometry"
+    ):
         # type: (str, str, str) -> hou.Node
         """Create node representing instance.
 
         Arguments:
+            asset_name (str): Asset name.
             node_name (str): Name of the new node.
             parent (str): Name of the parent node.
             node_type (str, optional): Type of the node.
@@ -182,8 +185,13 @@ class HoudiniCreator(NewCreator, HoudiniCreatorBase):
             if node_type is None:
                 node_type = "geometry"
 
+            if AYON_SERVER_ENABLED:
+                asset_name = instance_data["folderPath"]
+            else:
+                asset_name = instance_data["asset"]
+
             instance_node = self.create_instance_node(
-                subset_name, "/out", node_type)
+                asset_name, subset_name, "/out", node_type)
 
             self.customize_node_look(instance_node)
 

openpype/hosts/houdini/api/shelves.py

@@ -7,10 +7,11 @@ from openpype.settings import get_project_settings
 from openpype.pipeline import get_current_project_name
 
 from openpype.lib import StringTemplate
-from openpype.pipeline.context_tools import get_current_context_template_data
 
 import hou
 
+from .lib import get_current_context_template_data_with_asset_data
+
 log = logging.getLogger("openpype.hosts.houdini.shelves")
 
 
@@ -23,29 +24,33 @@ def generate_shelves():
     # load configuration of houdini shelves
     project_name = get_current_project_name()
     project_settings = get_project_settings(project_name)
-    shelves_set_config = project_settings["houdini"]["shelves"]
+    shelves_configs = project_settings["houdini"]["shelves"]
 
-    if not shelves_set_config:
+    if not shelves_configs:
         log.debug("No custom shelves found in project settings.")
         return
 
     # Get Template data
-    template_data = get_current_context_template_data()
+    template_data = get_current_context_template_data_with_asset_data()
+
+    for config in shelves_configs:
+        selected_option = config["options"]
+        shelf_set_config = config[selected_option]
 
-    for shelf_set_config in shelves_set_config:
         shelf_set_filepath = shelf_set_config.get('shelf_set_source_path')
-        shelf_set_os_filepath = shelf_set_filepath[current_os]
-        if shelf_set_os_filepath:
-            shelf_set_os_filepath = get_path_using_template_data(
-                shelf_set_os_filepath, template_data
-            )
-            if not os.path.isfile(shelf_set_os_filepath):
-                log.error("Shelf path doesn't exist - "
-                          "{}".format(shelf_set_os_filepath))
-                continue
+        if shelf_set_filepath:
+            shelf_set_os_filepath = shelf_set_filepath[current_os]
+            if shelf_set_os_filepath:
+                shelf_set_os_filepath = get_path_using_template_data(
+                    shelf_set_os_filepath, template_data
+                )
+                if not os.path.isfile(shelf_set_os_filepath):
+                    log.error("Shelf path doesn't exist - "
+                              "{}".format(shelf_set_os_filepath))
+                    continue
 
-            hou.shelves.newShelfSet(file_path=shelf_set_os_filepath)
-            continue
+                hou.shelves.loadFile(shelf_set_os_filepath)
+                continue
 
         shelf_set_name = shelf_set_config.get('shelf_set_name')
         if not shelf_set_name:

openpype/hosts/houdini/plugins/create/create_arnold_ass.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 """Creator plugin for creating Arnold ASS files."""
 from openpype.hosts.houdini.api import plugin
+from openpype.lib import BoolDef
 
 
 class CreateArnoldAss(plugin.HoudiniCreator):
@@ -21,6 +22,9 @@ class CreateArnoldAss(plugin.HoudiniCreator):
 
         instance_data.pop("active", None)
         instance_data.update({"node_type": "arnold"})
+        creator_attributes = instance_data.setdefault(
+            "creator_attributes", dict())
+        creator_attributes["farm"] = pre_create_data["farm"]
 
         instance = super(CreateArnoldAss, self).create(
             subset_name,
@@ -52,3 +56,15 @@ class CreateArnoldAss(plugin.HoudiniCreator):
         # Lock any parameters in this list
         to_lock = ["ar_ass_export_enable", "family", "id"]
         self.lock_parameters(instance_node, to_lock)
+
+    def get_instance_attr_defs(self):
+        return [
+            BoolDef("farm",
+                    label="Submitting to Farm",
+                    default=False)
+        ]
+
+    def get_pre_create_attr_defs(self):
+        attrs = super().get_pre_create_attr_defs()
+        # Use same attributes as for instance attributes
+        return attrs + self.get_instance_attr_defs()

openpype/hosts/houdini/plugins/create/create_arnold_rop.py

@@ -13,6 +13,9 @@ class CreateArnoldRop(plugin.HoudiniCreator):
     # Default extension
     ext = "exr"
 
+    # Default to split export and render jobs
+    export_job = True
+
     def create(self, subset_name, instance_data, pre_create_data):
         import hou
 
@@ -48,6 +51,15 @@ class CreateArnoldRop(plugin.HoudiniCreator):
             "ar_exr_half_precision": 1           # half precision
         }
 
+        if pre_create_data.get("export_job"):
+            ass_filepath = \
+                "{export_dir}{subset_name}/{subset_name}.$F4.ass".format(
+                    export_dir=hou.text.expandString("$HIP/pyblish/ass/"),
+                    subset_name=subset_name,
+                )
+            parms["ar_ass_export_enable"] = 1
+            parms["ar_ass_file"] = ass_filepath
+
         instance_node.setParms(parms)
 
         # Lock any parameters in this list
@@ -66,6 +78,9 @@ class CreateArnoldRop(plugin.HoudiniCreator):
             BoolDef("farm",
                     label="Submitting to Farm",
                     default=True),
+            BoolDef("export_job",
+                    label="Split export and render jobs",
+                    default=self.export_job),
             EnumDef("image_format",
                     image_format_enum,
                     default=self.ext,

openpype/hosts/houdini/plugins/create/create_bgeo.py

@@ -2,7 +2,8 @@
 """Creator plugin for creating pointcache bgeo files."""
 from openpype.hosts.houdini.api import plugin
 from openpype.pipeline import CreatedInstance, CreatorError
-from openpype.lib import EnumDef
+import hou
+from openpype.lib import EnumDef, BoolDef
 
 
 class CreateBGEO(plugin.HoudiniCreator):
@@ -13,11 +14,13 @@ class CreateBGEO(plugin.HoudiniCreator):
     icon = "gears"
 
     def create(self, subset_name, instance_data, pre_create_data):
-        import hou
 
         instance_data.pop("active", None)
 
         instance_data.update({"node_type": "geometry"})
+        creator_attributes = instance_data.setdefault(
+            "creator_attributes", dict())
+        creator_attributes["farm"] = pre_create_data["farm"]
 
         instance = super(CreateBGEO, self).create(
             subset_name,
@@ -58,6 +61,13 @@ class CreateBGEO(plugin.HoudiniCreator):
 
         instance_node.setParms(parms)
 
+    def get_instance_attr_defs(self):
+        return [
+            BoolDef("farm",
+                    label="Submitting to Farm",
+                    default=False)
+        ]
+
     def get_pre_create_attr_defs(self):
         attrs = super().get_pre_create_attr_defs()
         bgeo_enum = [
@@ -89,4 +99,10 @@ class CreateBGEO(plugin.HoudiniCreator):
 
         return attrs + [
             EnumDef("bgeo_type", bgeo_enum, label="BGEO Options"),
+        ] + self.get_instance_attr_defs()
+
+    def get_network_categories(self):
+        return [
+            hou.ropNodeTypeCategory(),
+            hou.sopNodeTypeCategory()
         ]

openpype/hosts/houdini/plugins/create/create_composite.py

@@ -45,6 +45,11 @@ class CreateCompositeSequence(plugin.HoudiniCreator):
 
         instance_node.setParms(parms)
 
+        # Manually set f1 & f2 to $FSTART and $FEND respectively
+        # to match other Houdini nodes default.
+        instance_node.parm("f1").setExpression("$FSTART")
+        instance_node.parm("f2").setExpression("$FEND")
+
         # Lock any parameters in this list
         to_lock = ["prim_to_detail_pattern"]
         self.lock_parameters(instance_node, to_lock)

openpype/hosts/houdini/plugins/create/create_hda.py

@@ -5,6 +5,7 @@ from openpype.client import (
     get_subsets,
 )
 from openpype.hosts.houdini.api import plugin
+import hou
 
 
 class CreateHDA(plugin.HoudiniCreator):
@@ -16,13 +17,13 @@ class CreateHDA(plugin.HoudiniCreator):
     icon = "gears"
     maintain_selection = False
 
-    def _check_existing(self, subset_name):
+    def _check_existing(self, asset_name, subset_name):
         # type: (str) -> bool
         """Check if existing subset name versions already exists."""
         # Get all subsets of the current asset
         project_name = self.project_name
         asset_doc = get_asset_by_name(
-            project_name, self.data["asset"], fields=["_id"]
+            project_name, asset_name, fields=["_id"]
         )
         subset_docs = get_subsets(
             project_name, asset_ids=[asset_doc["_id"]], fields=["name"]
@@ -34,8 +35,8 @@ class CreateHDA(plugin.HoudiniCreator):
         return subset_name.lower() in existing_subset_names_low
 
     def create_instance_node(
-            self, node_name, parent, node_type="geometry"):
-        import hou
+        self, asset_name, node_name, parent, node_type="geometry"
+    ):
 
         parent_node = hou.node("/obj")
         if self.selected_nodes:
@@ -61,7 +62,7 @@ class CreateHDA(plugin.HoudiniCreator):
                 hda_file_name="$HIP/{}.hda".format(node_name)
             )
             hda_node.layoutChildren()
-        elif self._check_existing(node_name):
+        elif self._check_existing(asset_name, node_name):
             raise plugin.OpenPypeCreatorError(
                 ("subset {} is already published with different HDA"
                  "definition.").format(node_name))
@@ -81,3 +82,8 @@ class CreateHDA(plugin.HoudiniCreator):
             pre_create_data)  # type: plugin.CreatedInstance
 
         return instance
+
+    def get_network_categories(self):
+        return [
+            hou.objNodeTypeCategory()
+        ]

openpype/hosts/houdini/plugins/create/create_mantra_ifd.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+"""Creator plugin for creating pointcache alembics."""
+from openpype.hosts.houdini.api import plugin
+from openpype.pipeline import CreatedInstance
+from openpype.lib import BoolDef
+
+
+class CreateMantraIFD(plugin.HoudiniCreator):
+    """Mantra .ifd Archive"""
+    identifier = "io.openpype.creators.houdini.mantraifd"
+    label = "Mantra IFD"
+    family = "mantraifd"
+    icon = "gears"
+
+    def create(self, subset_name, instance_data, pre_create_data):
+        import hou
+        instance_data.pop("active", None)
+        instance_data.update({"node_type": "ifd"})
+        creator_attributes = instance_data.setdefault(
+            "creator_attributes", dict())
+        creator_attributes["farm"] = pre_create_data["farm"]
+        instance = super(CreateMantraIFD, self).create(
+            subset_name,
+            instance_data,
+            pre_create_data)  # type: CreatedInstance
+
+        instance_node = hou.node(instance.get("instance_node"))
+
+        filepath = "{}{}".format(
+            hou.text.expandString("$HIP/pyblish/"),
+            "{}.$F4.ifd".format(subset_name))
+        parms = {
+            # Render frame range
+            "trange": 1,
+            # Arnold ROP settings
+            "soho_diskfile": filepath,
+            "soho_outputmode": 1
+        }
+
+        instance_node.setParms(parms)
+
+        # Lock any parameters in this list
+        to_lock = ["soho_outputmode", "family", "id"]
+        self.lock_parameters(instance_node, to_lock)
+
+    def get_instance_attr_defs(self):
+        return [
+            BoolDef("farm",
+                    label="Submitting to Farm",
+                    default=False)
+        ]
+
+    def get_pre_create_attr_defs(self):
+        attrs = super().get_pre_create_attr_defs()
+        # Use same attributes as for instance attributes
+        return attrs + self.get_instance_attr_defs()

openpype/hosts/houdini/plugins/create/create_mantra_rop.py

@@ -12,6 +12,9 @@ class CreateMantraROP(plugin.HoudiniCreator):
     family = "mantra_rop"
     icon = "magic"
 
+    # Default to split export and render jobs
+    export_job = True
+
     def create(self, subset_name, instance_data, pre_create_data):
         import hou  # noqa
 
@@ -44,6 +47,15 @@ class CreateMantraROP(plugin.HoudiniCreator):
             "vm_picture": filepath,
         }
 
+        if pre_create_data.get("export_job"):
+            ifd_filepath = \
+                "{export_dir}{subset_name}/{subset_name}.$F4.ifd".format(
+                    export_dir=hou.text.expandString("$HIP/pyblish/ifd/"),
+                    subset_name=subset_name,
+                )
+            parms["soho_outputmode"] = 1
+            parms["soho_diskfile"] = ifd_filepath
+
         if self.selected_nodes:
             # If camera found in selection
             # we will use as render camera
@@ -78,6 +90,9 @@ class CreateMantraROP(plugin.HoudiniCreator):
             BoolDef("farm",
                     label="Submitting to Farm",
                     default=True),
+            BoolDef("export_job",
+                    label="Split export and render jobs",
+                    default=self.export_job),
             EnumDef("image_format",
                     image_format_enum,
                     default="exr",

openpype/hosts/houdini/plugins/create/create_pointcache.py

@@ -1,10 +1,12 @@
 # -*- coding: utf-8 -*-
 """Creator plugin for creating pointcache alembics."""
 from openpype.hosts.houdini.api import plugin
+from openpype.lib import BoolDef
 
 import hou
 
 
+
 class CreatePointCache(plugin.HoudiniCreator):
     """Alembic ROP to pointcache"""
     identifier = "io.openpype.creators.houdini.pointcache"
@@ -15,6 +17,9 @@ class CreatePointCache(plugin.HoudiniCreator):
     def create(self, subset_name, instance_data, pre_create_data):
         instance_data.pop("active", None)
         instance_data.update({"node_type": "alembic"})
+        creator_attributes = instance_data.setdefault(
+            "creator_attributes", dict())
+        creator_attributes["farm"] = pre_create_data["farm"]
 
         instance = super(CreatePointCache, self).create(
             subset_name,
@@ -105,3 +110,15 @@ class CreatePointCache(plugin.HoudiniCreator):
         else:
             return min(outputs,
                        key=lambda node: node.evalParm('outputidx'))
+
+    def get_instance_attr_defs(self):
+        return [
+            BoolDef("farm",
+                    label="Submitting to Farm",
+                    default=False)
+        ]
+
+    def get_pre_create_attr_defs(self):
+        attrs = super().get_pre_create_attr_defs()
+        # Use same attributes as for instance attributes
+        return attrs + self.get_instance_attr_defs()