Merge pull request #5670 from ynput/enhancement/OP-6890_unreal-improved_update

Unreal: Changed behaviour for updating assets

openpype/hosts/unreal/api/pipeline.py

@@ -13,8 +13,10 @@ from openpype.client import get_asset_by_name, get_assets
 from openpype.pipeline import (
     register_loader_plugin_path,
     register_creator_plugin_path,
+    register_inventory_action_path,
     deregister_loader_plugin_path,
     deregister_creator_plugin_path,
+    deregister_inventory_action_path,
     AYON_CONTAINER_ID,
     legacy_io,
 )
@@ -28,6 +30,7 @@ import unreal  # noqa
 logger = logging.getLogger("openpype.hosts.unreal")
 
 AYON_CONTAINERS = "AyonContainers"
+AYON_ASSET_DIR = "/Game/Ayon/Assets"
 CONTEXT_CONTAINER = "Ayon/context.json"
 UNREAL_VERSION = semver.VersionInfo(
     *os.getenv("AYON_UNREAL_VERSION").split(".")
@@ -127,6 +130,7 @@ def install():
     pyblish.api.register_plugin_path(str(PUBLISH_PATH))
     register_loader_plugin_path(str(LOAD_PATH))
     register_creator_plugin_path(str(CREATE_PATH))
+    register_inventory_action_path(str(INVENTORY_PATH))
     _register_callbacks()
     _register_events()
 
@@ -136,6 +140,7 @@ def uninstall():
     pyblish.api.deregister_plugin_path(str(PUBLISH_PATH))
     deregister_loader_plugin_path(str(LOAD_PATH))
     deregister_creator_plugin_path(str(CREATE_PATH))
+    deregister_inventory_action_path(str(INVENTORY_PATH))
 
 
 def _register_callbacks():
@@ -649,6 +654,141 @@ def generate_sequence(h, h_dir):
     return sequence, (min_frame, max_frame)
 
 
+def _get_comps_and_assets(
+    component_class, asset_class, old_assets, new_assets, selected
+):
+    eas = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+
+    components = []
+    if selected:
+        sel_actors = eas.get_selected_level_actors()
+        for actor in sel_actors:
+            comps = actor.get_components_by_class(component_class)
+            components.extend(comps)
+    else:
+        comps = eas.get_all_level_actors_components()
+        components = [
+            c for c in comps if isinstance(c, component_class)
+        ]
+
+    # Get all the static meshes among the old assets in a dictionary with
+    # the name as key
+    selected_old_assets = {}
+    for a in old_assets:
+        asset = unreal.EditorAssetLibrary.load_asset(a)
+        if isinstance(asset, asset_class):
+            selected_old_assets[asset.get_name()] = asset
+
+    # Get all the static meshes among the new assets in a dictionary with
+    # the name as key
+    selected_new_assets = {}
+    for a in new_assets:
+        asset = unreal.EditorAssetLibrary.load_asset(a)
+        if isinstance(asset, asset_class):
+            selected_new_assets[asset.get_name()] = asset
+
+    return components, selected_old_assets, selected_new_assets
+
+
+def replace_static_mesh_actors(old_assets, new_assets, selected):
+    smes = unreal.get_editor_subsystem(unreal.StaticMeshEditorSubsystem)
+
+    static_mesh_comps, old_meshes, new_meshes = _get_comps_and_assets(
+        unreal.StaticMeshComponent,
+        unreal.StaticMesh,
+        old_assets,
+        new_assets,
+        selected
+    )
+
+    for old_name, old_mesh in old_meshes.items():
+        new_mesh = new_meshes.get(old_name)
+
+        if not new_mesh:
+            continue
+
+        smes.replace_mesh_components_meshes(
+            static_mesh_comps, old_mesh, new_mesh)
+
+
+def replace_skeletal_mesh_actors(old_assets, new_assets, selected):
+    skeletal_mesh_comps, old_meshes, new_meshes = _get_comps_and_assets(
+        unreal.SkeletalMeshComponent,
+        unreal.SkeletalMesh,
+        old_assets,
+        new_assets,
+        selected
+    )
+
+    for old_name, old_mesh in old_meshes.items():
+        new_mesh = new_meshes.get(old_name)
+
+        if not new_mesh:
+            continue
+
+        for comp in skeletal_mesh_comps:
+            if comp.get_skeletal_mesh_asset() == old_mesh:
+                comp.set_skeletal_mesh_asset(new_mesh)
+
+
+def replace_geometry_cache_actors(old_assets, new_assets, selected):
+    geometry_cache_comps, old_caches, new_caches = _get_comps_and_assets(
+        unreal.GeometryCacheComponent,
+        unreal.GeometryCache,
+        old_assets,
+        new_assets,
+        selected
+    )
+
+    for old_name, old_mesh in old_caches.items():
+        new_mesh = new_caches.get(old_name)
+
+        if not new_mesh:
+            continue
+
+        for comp in geometry_cache_comps:
+            if comp.get_editor_property("geometry_cache") == old_mesh:
+                comp.set_geometry_cache(new_mesh)
+
+
+def delete_asset_if_unused(container, asset_content):
+    ar = unreal.AssetRegistryHelpers.get_asset_registry()
+
+    references = set()
+
+    for asset_path in asset_content:
+        asset = ar.get_asset_by_object_path(asset_path)
+        refs = ar.get_referencers(
+            asset.package_name,
+            unreal.AssetRegistryDependencyOptions(
+                include_soft_package_references=False,
+                include_hard_package_references=True,
+                include_searchable_names=False,
+                include_soft_management_references=False,
+                include_hard_management_references=False
+            ))
+        if not refs:
+            continue
+        references = references.union(set(refs))
+
+    # Filter out references that are in the Temp folder
+    cleaned_references = {
+        ref for ref in references if not str(ref).startswith("/Temp/")}
+
+    # Check which of the references are Levels
+    for ref in cleaned_references:
+        loaded_asset = unreal.EditorAssetLibrary.load_asset(ref)
+        if isinstance(loaded_asset, unreal.World):
+            # If there is at least a level, we can stop, we don't want to
+            # delete the container
+            return
+
+    unreal.log("Previous version unused, deleting...")
+
+    # No levels, delete the asset
+    unreal.EditorAssetLibrary.delete_directory(container["namespace"])
+
+
 @contextmanager
 def maintained_selection():
     """Stub to be either implemented or replaced.

openpype/hosts/unreal/plugins/inventory/delete_unused_assets.py

@@ -0,0 +1,66 @@
+import unreal
+
+from openpype.hosts.unreal.api.tools_ui import qt_app_context
+from openpype.hosts.unreal.api.pipeline import delete_asset_if_unused
+from openpype.pipeline import InventoryAction
+
+
+class DeleteUnusedAssets(InventoryAction):
+    """Delete all the assets that are not used in any level.
+    """
+
+    label = "Delete Unused Assets"
+    icon = "trash"
+    color = "red"
+    order = 1
+
+    dialog = None
+
+    def _delete_unused_assets(self, containers):
+        allowed_families = ["model", "rig"]
+
+        for container in containers:
+            container_dir = container.get("namespace")
+            if container.get("family") not in allowed_families:
+                unreal.log_warning(
+                    f"Container {container_dir} is not supported.")
+                continue
+
+            asset_content = unreal.EditorAssetLibrary.list_assets(
+                container_dir, recursive=True, include_folder=False
+            )
+
+            delete_asset_if_unused(container, asset_content)
+
+    def _show_confirmation_dialog(self, containers):
+        from qtpy import QtCore
+        from openpype.widgets import popup
+        from openpype.style import load_stylesheet
+
+        dialog = popup.Popup()
+        dialog.setWindowFlags(
+            QtCore.Qt.Window
+            | QtCore.Qt.WindowStaysOnTopHint
+        )
+        dialog.setFocusPolicy(QtCore.Qt.StrongFocus)
+        dialog.setWindowTitle("Delete all unused assets")
+        dialog.setMessage(
+            "You are about to delete all the assets in the project that \n"
+            "are not used in any level. Are you sure you want to continue?"
+        )
+        dialog.setButtonText("Delete")
+
+        dialog.on_clicked.connect(
+            lambda: self._delete_unused_assets(containers)
+        )
+
+        dialog.show()
+        dialog.raise_()
+        dialog.activateWindow()
+        dialog.setStyleSheet(load_stylesheet())
+
+        self.dialog = dialog
+
+    def process(self, containers):
+        with qt_app_context():
+            self._show_confirmation_dialog(containers)

openpype/hosts/unreal/plugins/inventory/update_actors.py

@@ -0,0 +1,84 @@
+import unreal
+
+from openpype.hosts.unreal.api.pipeline import (
+    ls,
+    replace_static_mesh_actors,
+    replace_skeletal_mesh_actors,
+    replace_geometry_cache_actors,
+)
+from openpype.pipeline import InventoryAction
+
+
+def update_assets(containers, selected):
+    allowed_families = ["model", "rig"]
+
+    # Get all the containers in the Unreal Project
+    all_containers = ls()
+
+    for container in containers:
+        container_dir = container.get("namespace")
+        if container.get("family") not in allowed_families:
+            unreal.log_warning(
+                f"Container {container_dir} is not supported.")
+            continue
+
+        # Get all containers with same asset_name but different objectName.
+        # These are the containers that need to be updated in the level.
+        sa_containers = [
+            i
+            for i in all_containers
+            if (
+                i.get("asset_name") == container.get("asset_name") and
+                i.get("objectName") != container.get("objectName")
+            )
+        ]
+
+        asset_content = unreal.EditorAssetLibrary.list_assets(
+            container_dir, recursive=True, include_folder=False
+        )
+
+        # Update all actors in level
+        for sa_cont in sa_containers:
+            sa_dir = sa_cont.get("namespace")
+            old_content = unreal.EditorAssetLibrary.list_assets(
+                sa_dir, recursive=True, include_folder=False
+            )
+
+            if container.get("family") == "rig":
+                replace_skeletal_mesh_actors(
+                    old_content, asset_content, selected)
+                replace_static_mesh_actors(
+                    old_content, asset_content, selected)
+            elif container.get("family") == "model":
+                if container.get("loader") == "PointCacheAlembicLoader":
+                    replace_geometry_cache_actors(
+                        old_content, asset_content, selected)
+                else:
+                    replace_static_mesh_actors(
+                        old_content, asset_content, selected)
+
+            unreal.EditorLevelLibrary.save_current_level()
+
+
+class UpdateAllActors(InventoryAction):
+    """Update all the Actors in the current level to the version of the asset
+    selected in the scene manager.
+    """
+
+    label = "Replace all Actors in level to this version"
+    icon = "arrow-up"
+
+    def process(self, containers):
+        update_assets(containers, False)
+
+
+class UpdateSelectedActors(InventoryAction):
+    """Update only the selected Actors in the current level to the version
+    of the asset selected in the scene manager.
+    """
+
+    label = "Replace selected Actors in level to this version"
+    icon = "arrow-up"
+
+    def process(self, containers):
+        update_assets(containers, True)

openpype/hosts/unreal/plugins/load/load_alembic_animation.py

@@ -69,7 +69,7 @@ class AnimationAlembicLoader(plugin.Loader):
         """
 
         # Create directory for asset and ayon container
-        root = "/Game/Ayon/Assets"
+        root = unreal_pipeline.AYON_ASSET_DIR
         asset = context.get('asset').get('name')
         suffix = "_CON"
         if asset:

openpype/hosts/unreal/plugins/load/load_geometrycache_abc.py

@@ -7,7 +7,11 @@ from openpype.pipeline import (
     AYON_CONTAINER_ID
 )
 from openpype.hosts.unreal.api import plugin
-from openpype.hosts.unreal.api import pipeline as unreal_pipeline
+from openpype.hosts.unreal.api.pipeline import (
+    AYON_ASSET_DIR,
+    create_container,
+    imprint,
+)
 
 import unreal  # noqa
 
@@ -21,8 +25,11 @@ class PointCacheAlembicLoader(plugin.Loader):
     icon = "cube"
     color = "orange"
 
+    root = AYON_ASSET_DIR
+
+    @staticmethod
     def get_task(
-        self, filename, asset_dir, asset_name, replace,
+        filename, asset_dir, asset_name, replace,
         frame_start=None, frame_end=None
     ):
         task = unreal.AssetImportTask()
@@ -38,8 +45,6 @@ class PointCacheAlembicLoader(plugin.Loader):
         task.set_editor_property('automated', True)
         task.set_editor_property('save', True)
 
-        # set import options here
-        # Unreal 4.24 ignores the settings. It works with Unreal 4.26
         options.set_editor_property(
             'import_type', unreal.AlembicImportType.GEOMETRY_CACHE)
 
@@ -64,13 +69,42 @@ class PointCacheAlembicLoader(plugin.Loader):
 
         return task
 
-    def load(self, context, name, namespace, data):
-        """Load and containerise representation into Content Browser.
+    def import_and_containerize(
+        self, filepath, asset_dir, asset_name, container_name,
+        frame_start, frame_end
+    ):
+        unreal.EditorAssetLibrary.make_directory(asset_dir)
 
-        This is two step process. First, import FBX to temporary path and
-        then call `containerise()` on it - this moves all content to new
-        directory and then it will create AssetContainer there and imprint it
-        with metadata. This will mark this path as container.
+        task = self.get_task(
+            filepath, asset_dir, asset_name, False, frame_start, frame_end)
+
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+
+        # Create Asset Container
+        create_container(container=container_name, path=asset_dir)
+
+    def imprint(
+        self, asset, asset_dir, container_name, asset_name, representation,
+        frame_start, frame_end
+    ):
+        data = {
+            "schema": "ayon:container-2.0",
+            "id": AYON_CONTAINER_ID,
+            "asset": asset,
+            "namespace": asset_dir,
+            "container_name": container_name,
+            "asset_name": asset_name,
+            "loader": str(self.__class__.__name__),
+            "representation": representation["_id"],
+            "parent": representation["parent"],
+            "family": representation["context"]["family"],
+            "frame_start": frame_start,
+            "frame_end": frame_end
+        }
+        imprint(f"{asset_dir}/{container_name}", data)
+
+    def load(self, context, name, namespace, options):
+        """Load and containerise representation into Content Browser.
 
         Args:
             context (dict): application context
@@ -79,30 +113,28 @@ class PointCacheAlembicLoader(plugin.Loader):
                              This is not passed here, so namespace is set
                              by `containerise()` because only then we know
                              real path.
-            data (dict): Those would be data to be imprinted. This is not used
-                         now, data are imprinted by `containerise()`.
+            data (dict): Those would be data to be imprinted.
 
         Returns:
             list(str): list of container content
-
         """
         # Create directory for asset and Ayon container
-        root = "/Game/Ayon/Assets"
         asset = context.get('asset').get('name')
         suffix = "_CON"
-        if asset:
-            asset_name = "{}_{}".format(asset, name)
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
+        version = context.get('version')
+        # Check if version is hero version and use different name
+        if not version.get("name") and version.get('type') == "hero_version":
+            name_version = f"{name}_hero"
         else:
-            asset_name = "{}".format(name)
+            name_version = f"{name}_v{version.get('name'):03d}"
 
         tools = unreal.AssetToolsHelpers().get_asset_tools()
         asset_dir, container_name = tools.create_unique_asset_name(
-            "{}/{}/{}".format(root, asset, name), suffix="")
+            f"{self.root}/{asset}/{name_version}", suffix="")
 
         container_name += suffix
 
-        unreal.EditorAssetLibrary.make_directory(asset_dir)
-
         frame_start = context.get('asset').get('data').get('frameStart')
         frame_end = context.get('asset').get('data').get('frameEnd')
 
@@ -111,30 +143,16 @@ class PointCacheAlembicLoader(plugin.Loader):
         if frame_start == frame_end:
             frame_end += 1
 
-        path = self.filepath_from_context(context)
-        task = self.get_task(
-            path, asset_dir, asset_name, False, frame_start, frame_end)
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            path = self.filepath_from_context(context)
 
-        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
+            self.import_and_containerize(
+                path, asset_dir, asset_name, container_name,
+                frame_start, frame_end)
 
-        # Create Asset Container
-        unreal_pipeline.create_container(
-            container=container_name, path=asset_dir)
-
-        data = {
-            "schema": "ayon:container-2.0",
-            "id": AYON_CONTAINER_ID,
-            "asset": asset,
-            "namespace": asset_dir,
-            "container_name": container_name,
-            "asset_name": asset_name,
-            "loader": str(self.__class__.__name__),
-            "representation": context["representation"]["_id"],
-            "parent": context["representation"]["parent"],
-            "family": context["representation"]["context"]["family"]
-        }
-        unreal_pipeline.imprint(
-            "{}/{}".format(asset_dir, container_name), data)
+        self.imprint(
+            asset, asset_dir, container_name, asset_name,
+            context["representation"], frame_start, frame_end)
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
             asset_dir, recursive=True, include_folder=True
@@ -146,27 +164,43 @@ class PointCacheAlembicLoader(plugin.Loader):
         return asset_content
 
     def update(self, container, representation):
-        name = container["asset_name"]
-        source_path = get_representation_path(representation)
-        destination_path = container["namespace"]
-        representation["context"]
+        context = representation.get("context", {})
 
-        task = self.get_task(source_path, destination_path, name, False)
-        # do import fbx and replace existing data
-        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+        unreal.log_warning(context)
 
-        container_path = "{}/{}".format(container["namespace"],
-                                        container["objectName"])
-        # update metadata
-        unreal_pipeline.imprint(
-            container_path,
-            {
-                "representation": str(representation["_id"]),
-                "parent": str(representation["parent"])
-            })
+        if not context:
+            raise RuntimeError("No context found in representation")
+
+        # Create directory for asset and Ayon container
+        asset = context.get('asset')
+        name = context.get('subset')
+        suffix = "_CON"
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
+        version = context.get('version')
+        # Check if version is hero version and use different name
+        name_version = f"{name}_v{version:03d}" if version else f"{name}_hero"
+        tools = unreal.AssetToolsHelpers().get_asset_tools()
+        asset_dir, container_name = tools.create_unique_asset_name(
+            f"{self.root}/{asset}/{name_version}", suffix="")
+
+        container_name += suffix
+
+        frame_start = int(container.get("frame_start"))
+        frame_end = int(container.get("frame_end"))
+
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            path = get_representation_path(representation)
+
+            self.import_and_containerize(
+                path, asset_dir, asset_name, container_name,
+                frame_start, frame_end)
+
+        self.imprint(
+            asset, asset_dir, container_name, asset_name, representation,
+            frame_start, frame_end)
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
-            destination_path, recursive=True, include_folder=True
+            asset_dir, recursive=True, include_folder=False
         )
 
         for a in asset_content:

openpype/hosts/unreal/plugins/load/load_skeletalmesh_abc.py

@@ -7,7 +7,11 @@ from openpype.pipeline import (
     AYON_CONTAINER_ID
 )
 from openpype.hosts.unreal.api import plugin
-from openpype.hosts.unreal.api import pipeline as unreal_pipeline
+from openpype.hosts.unreal.api.pipeline import (
+    AYON_ASSET_DIR,
+    create_container,
+    imprint,
+)
 import unreal  # noqa
 
 
@@ -20,10 +24,12 @@ class SkeletalMeshAlembicLoader(plugin.Loader):
     icon = "cube"
     color = "orange"
 
-    def get_task(self, filename, asset_dir, asset_name, replace):
+    root = AYON_ASSET_DIR
+
+    @staticmethod
+    def get_task(filename, asset_dir, asset_name, replace, default_conversion):
         task = unreal.AssetImportTask()
         options = unreal.AbcImportSettings()
-        sm_settings = unreal.AbcStaticMeshSettings()
         conversion_settings = unreal.AbcConversionSettings(
             preset=unreal.AbcConversionPreset.CUSTOM,
             flip_u=False, flip_v=False,
@@ -37,72 +43,38 @@ class SkeletalMeshAlembicLoader(plugin.Loader):
         task.set_editor_property('automated', True)
         task.set_editor_property('save', True)
 
-        # set import options here
-        # Unreal 4.24 ignores the settings. It works with Unreal 4.26
         options.set_editor_property(
             'import_type', unreal.AlembicImportType.SKELETAL)
 
-        options.static_mesh_settings = sm_settings
-        options.conversion_settings = conversion_settings
+        if not default_conversion:
+            conversion_settings = unreal.AbcConversionSettings(
+                preset=unreal.AbcConversionPreset.CUSTOM,
+                flip_u=False, flip_v=False,
+                rotation=[0.0, 0.0, 0.0],
+                scale=[1.0, 1.0, 1.0])
+            options.conversion_settings = conversion_settings
+
         task.options = options
 
         return task
 
-    def load(self, context, name, namespace, data):
-        """Load and containerise representation into Content Browser.
+    def import_and_containerize(
+        self, filepath, asset_dir, asset_name, container_name,
+        default_conversion=False
+    ):
+        unreal.EditorAssetLibrary.make_directory(asset_dir)
 
-        This is two step process. First, import FBX to temporary path and
-        then call `containerise()` on it - this moves all content to new
-        directory and then it will create AssetContainer there and imprint it
-        with metadata. This will mark this path as container.
+        task = self.get_task(
+            filepath, asset_dir, asset_name, False, default_conversion)
 
-        Args:
-            context (dict): application context
-            name (str): subset name
-            namespace (str): in Unreal this is basically path to container.
-                             This is not passed here, so namespace is set
-                             by `containerise()` because only then we know
-                             real path.
-            data (dict): Those would be data to be imprinted. This is not used
-                         now, data are imprinted by `containerise()`.
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
 
-        Returns:
-            list(str): list of container content
-        """
-
-        # Create directory for asset and ayon container
-        root = "/Game/Ayon/Assets"
-        asset = context.get('asset').get('name')
-        suffix = "_CON"
-        if asset:
-            asset_name = "{}_{}".format(asset, name)
-        else:
-            asset_name = "{}".format(name)
-        version = context.get('version')
-        # Check if version is hero version and use different name
-        if not version.get("name") and version.get('type') == "hero_version":
-            name_version = f"{name}_hero"
-        else:
-            name_version = f"{name}_v{version.get('name'):03d}"
-
-        tools = unreal.AssetToolsHelpers().get_asset_tools()
-        asset_dir, container_name = tools.create_unique_asset_name(
-            f"{root}/{asset}/{name_version}", suffix="")
-
-        container_name += suffix
-
-        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
-            unreal.EditorAssetLibrary.make_directory(asset_dir)
-
-            path = self.filepath_from_context(context)
-            task = self.get_task(path, asset_dir, asset_name, False)
-
-            unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
-
-            # Create Asset Container
-            unreal_pipeline.create_container(
-                container=container_name, path=asset_dir)
+        # Create Asset Container
+        create_container(container=container_name, path=asset_dir)
 
+    def imprint(
+        self, asset, asset_dir, container_name, asset_name, representation
+    ):
         data = {
             "schema": "ayon:container-2.0",
             "id": AYON_CONTAINER_ID,
@@ -111,12 +83,57 @@ class SkeletalMeshAlembicLoader(plugin.Loader):
             "container_name": container_name,
             "asset_name": asset_name,
             "loader": str(self.__class__.__name__),
-            "representation": context["representation"]["_id"],
-            "parent": context["representation"]["parent"],
-            "family": context["representation"]["context"]["family"]
+            "representation": representation["_id"],
+            "parent": representation["parent"],
+            "family": representation["context"]["family"]
         }
-        unreal_pipeline.imprint(
-            f"{asset_dir}/{container_name}", data)
+        imprint(f"{asset_dir}/{container_name}", data)
+
+    def load(self, context, name, namespace, options):
+        """Load and containerise representation into Content Browser.
+
+        Args:
+            context (dict): application context
+            name (str): subset name
+            namespace (str): in Unreal this is basically path to container.
+                             This is not passed here, so namespace is set
+                             by `containerise()` because only then we know
+                             real path.
+            data (dict): Those would be data to be imprinted.
+
+        Returns:
+            list(str): list of container content
+        """
+        # Create directory for asset and ayon container
+        asset = context.get('asset').get('name')
+        suffix = "_CON"
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
+        version = context.get('version')
+        # Check if version is hero version and use different name
+        if not version.get("name") and version.get('type') == "hero_version":
+            name_version = f"{name}_hero"
+        else:
+            name_version = f"{name}_v{version.get('name'):03d}"
+
+        default_conversion = False
+        if options.get("default_conversion"):
+            default_conversion = options.get("default_conversion")
+
+        tools = unreal.AssetToolsHelpers().get_asset_tools()
+        asset_dir, container_name = tools.create_unique_asset_name(
+            f"{self.root}/{asset}/{name_version}", suffix="")
+
+        container_name += suffix
+
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            path = self.filepath_from_context(context)
+
+            self.import_and_containerize(path, asset_dir, asset_name,
+                                         container_name, default_conversion)
+
+        self.imprint(
+            asset, asset_dir, container_name, asset_name,
+            context["representation"])
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
             asset_dir, recursive=True, include_folder=True
@@ -128,26 +145,36 @@ class SkeletalMeshAlembicLoader(plugin.Loader):
         return asset_content
 
     def update(self, container, representation):
-        name = container["asset_name"]
-        source_path = get_representation_path(representation)
-        destination_path = container["namespace"]
+        context = representation.get("context", {})
 
-        task = self.get_task(source_path, destination_path, name, True)
+        if not context:
+            raise RuntimeError("No context found in representation")
 
-        # do import fbx and replace existing data
-        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
-        container_path = "{}/{}".format(container["namespace"],
-                                        container["objectName"])
-        # update metadata
-        unreal_pipeline.imprint(
-            container_path,
-            {
-                "representation": str(representation["_id"]),
-                "parent": str(representation["parent"])
-            })
+        # Create directory for asset and Ayon container
+        asset = context.get('asset')
+        name = context.get('subset')
+        suffix = "_CON"
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
+        version = context.get('version')
+        # Check if version is hero version and use different name
+        name_version = f"{name}_v{version:03d}" if version else f"{name}_hero"
+        tools = unreal.AssetToolsHelpers().get_asset_tools()
+        asset_dir, container_name = tools.create_unique_asset_name(
+            f"{self.root}/{asset}/{name_version}", suffix="")
+
+        container_name += suffix
+
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            path = get_representation_path(representation)
+
+            self.import_and_containerize(path, asset_dir, asset_name,
+                                         container_name)
+
+        self.imprint(
+            asset, asset_dir, container_name, asset_name, representation)
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
-            destination_path, recursive=True, include_folder=True
+            asset_dir, recursive=True, include_folder=False
         )
 
         for a in asset_content:

openpype/hosts/unreal/plugins/load/load_skeletalmesh_fbx.py

@@ -7,7 +7,11 @@ from openpype.pipeline import (
     AYON_CONTAINER_ID
 )
 from openpype.hosts.unreal.api import plugin
-from openpype.hosts.unreal.api import pipeline as unreal_pipeline
+from openpype.hosts.unreal.api.pipeline import (
+    AYON_ASSET_DIR,
+    create_container,
+    imprint,
+)
 import unreal  # noqa
 
 
@@ -20,14 +24,79 @@ class SkeletalMeshFBXLoader(plugin.Loader):
     icon = "cube"
     color = "orange"
 
+    root = AYON_ASSET_DIR
+
+    @staticmethod
+    def get_task(filename, asset_dir, asset_name, replace):
+        task = unreal.AssetImportTask()
+        options = unreal.FbxImportUI()
+
+        task.set_editor_property('filename', filename)
+        task.set_editor_property('destination_path', asset_dir)
+        task.set_editor_property('destination_name', asset_name)
+        task.set_editor_property('replace_existing', replace)
+        task.set_editor_property('automated', True)
+        task.set_editor_property('save', True)
+
+        options.set_editor_property(
+            'automated_import_should_detect_type', False)
+        options.set_editor_property('import_as_skeletal', True)
+        options.set_editor_property('import_animations', False)
+        options.set_editor_property('import_mesh', True)
+        options.set_editor_property('import_materials', False)
+        options.set_editor_property('import_textures', False)
+        options.set_editor_property('skeleton', None)
+        options.set_editor_property('create_physics_asset', False)
+
+        options.set_editor_property(
+            'mesh_type_to_import',
+            unreal.FBXImportType.FBXIT_SKELETAL_MESH)
+
+        options.skeletal_mesh_import_data.set_editor_property(
+            'import_content_type',
+            unreal.FBXImportContentType.FBXICT_ALL)
+
+        options.skeletal_mesh_import_data.set_editor_property(
+            'normal_import_method',
+            unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS)
+
+        task.options = options
+
+        return task
+
+    def import_and_containerize(
+        self, filepath, asset_dir, asset_name, container_name
+    ):
+        unreal.EditorAssetLibrary.make_directory(asset_dir)
+
+        task = self.get_task(
+            filepath, asset_dir, asset_name, False)
+
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+
+        # Create Asset Container
+        create_container(container=container_name, path=asset_dir)
+
+    def imprint(
+        self, asset, asset_dir, container_name, asset_name, representation
+    ):
+        data = {
+            "schema": "ayon:container-2.0",
+            "id": AYON_CONTAINER_ID,
+            "asset": asset,
+            "namespace": asset_dir,
+            "container_name": container_name,
+            "asset_name": asset_name,
+            "loader": str(self.__class__.__name__),
+            "representation": representation["_id"],
+            "parent": representation["parent"],
+            "family": representation["context"]["family"]
+        }
+        imprint(f"{asset_dir}/{container_name}", data)
+
     def load(self, context, name, namespace, options):
         """Load and containerise representation into Content Browser.
 
-        This is a two step process. First, import FBX to temporary path and
-        then call `containerise()` on it - this moves all content to new
-        directory and then it will create AssetContainer there and imprint it
-        with metadata. This will mark this path as container.
-
         Args:
             context (dict): application context
             name (str): subset name
@@ -35,23 +104,15 @@ class SkeletalMeshFBXLoader(plugin.Loader):
                              This is not passed here, so namespace is set
                              by `containerise()` because only then we know
                              real path.
-            options (dict): Those would be data to be imprinted. This is not
-                used now, data are imprinted by `containerise()`.
+            data (dict): Those would be data to be imprinted.
 
         Returns:
             list(str): list of container content
-
         """
         # Create directory for asset and Ayon container
-        root = "/Game/Ayon/Assets"
-        if options and options.get("asset_dir"):
-            root = options["asset_dir"]
         asset = context.get('asset').get('name')
         suffix = "_CON"
-        if asset:
-            asset_name = "{}_{}".format(asset, name)
-        else:
-            asset_name = "{}".format(name)
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
         version = context.get('version')
         # Check if version is hero version and use different name
         if not version.get("name") and version.get('type') == "hero_version":
@@ -61,67 +122,20 @@ class SkeletalMeshFBXLoader(plugin.Loader):
 
         tools = unreal.AssetToolsHelpers().get_asset_tools()
         asset_dir, container_name = tools.create_unique_asset_name(
-            f"{root}/{asset}/{name_version}", suffix="")
+            f"{self.root}/{asset}/{name_version}", suffix=""
+        )
 
         container_name += suffix
 
         if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
-            unreal.EditorAssetLibrary.make_directory(asset_dir)
-
-            task = unreal.AssetImportTask()
-
             path = self.filepath_from_context(context)
-            task.set_editor_property('filename', path)
-            task.set_editor_property('destination_path', asset_dir)
-            task.set_editor_property('destination_name', asset_name)
-            task.set_editor_property('replace_existing', False)
-            task.set_editor_property('automated', True)
-            task.set_editor_property('save', False)
 
-            # set import options here
-            options = unreal.FbxImportUI()
-            options.set_editor_property('import_as_skeletal', True)
-            options.set_editor_property('import_animations', False)
-            options.set_editor_property('import_mesh', True)
-            options.set_editor_property('import_materials', False)
-            options.set_editor_property('import_textures', False)
-            options.set_editor_property('skeleton', None)
-            options.set_editor_property('create_physics_asset', False)
+            self.import_and_containerize(
+                path, asset_dir, asset_name, container_name)
 
-            options.set_editor_property(
-                'mesh_type_to_import',
-                unreal.FBXImportType.FBXIT_SKELETAL_MESH)
-
-            options.skeletal_mesh_import_data.set_editor_property(
-                'import_content_type',
-                unreal.FBXImportContentType.FBXICT_ALL)
-            # set to import normals, otherwise Unreal will compute them
-            # and it will take a long time, depending on the size of the mesh
-            options.skeletal_mesh_import_data.set_editor_property(
-                'normal_import_method',
-                unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS)
-
-            task.options = options
-            unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
-
-            # Create Asset Container
-            unreal_pipeline.create_container(
-                container=container_name, path=asset_dir)
-
-        data = {
-            "schema": "ayon:container-2.0",
-            "id": AYON_CONTAINER_ID,
-            "asset": asset,
-            "namespace": asset_dir,
-            "container_name": container_name,
-            "asset_name": asset_name,
-            "loader": str(self.__class__.__name__),
-            "representation": context["representation"]["_id"],
-            "parent": context["representation"]["parent"],
-            "family": context["representation"]["context"]["family"]
-        }
-        unreal_pipeline.imprint(
-            f"{asset_dir}/{container_name}", data)
+        self.imprint(
+            asset, asset_dir, container_name, asset_name,
+            context["representation"])
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
             asset_dir, recursive=True, include_folder=True
@@ -133,58 +147,36 @@ class SkeletalMeshFBXLoader(plugin.Loader):
         return asset_content
 
     def update(self, container, representation):
-        name = container["asset_name"]
-        source_path = get_representation_path(representation)
-        destination_path = container["namespace"]
+        context = representation.get("context", {})
 
-        task = unreal.AssetImportTask()
+        if not context:
+            raise RuntimeError("No context found in representation")
 
-        task.set_editor_property('filename', source_path)
-        task.set_editor_property('destination_path', destination_path)
-        task.set_editor_property('destination_name', name)
-        task.set_editor_property('replace_existing', True)
-        task.set_editor_property('automated', True)
-        task.set_editor_property('save', True)
+        # Create directory for asset and Ayon container
+        asset = context.get('asset')
+        name = context.get('subset')
+        suffix = "_CON"
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
+        version = context.get('version')
+        # Check if version is hero version and use different name
+        name_version = f"{name}_v{version:03d}" if version else f"{name}_hero"
+        tools = unreal.AssetToolsHelpers().get_asset_tools()
+        asset_dir, container_name = tools.create_unique_asset_name(
+            f"{self.root}/{asset}/{name_version}", suffix="")
 
-        # set import options here
-        options = unreal.FbxImportUI()
-        options.set_editor_property('import_as_skeletal', True)
-        options.set_editor_property('import_animations', False)
-        options.set_editor_property('import_mesh', True)
-        options.set_editor_property('import_materials', True)
-        options.set_editor_property('import_textures', True)
-        options.set_editor_property('skeleton', None)
-        options.set_editor_property('create_physics_asset', False)
+        container_name += suffix
 
-        options.set_editor_property('mesh_type_to_import',
-                                    unreal.FBXImportType.FBXIT_SKELETAL_MESH)
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            path = get_representation_path(representation)
 
-        options.skeletal_mesh_import_data.set_editor_property(
-            'import_content_type',
-            unreal.FBXImportContentType.FBXICT_ALL
-        )
-        # set to import normals, otherwise Unreal will compute them
-        # and it will take a long time, depending on the size of the mesh
-        options.skeletal_mesh_import_data.set_editor_property(
-            'normal_import_method',
-            unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS
-        )
+            self.import_and_containerize(
+                path, asset_dir, asset_name, container_name)
 
-        task.options = options
-        # do import fbx and replace existing data
-        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
-        container_path = "{}/{}".format(container["namespace"],
-                                        container["objectName"])
-        # update metadata
-        unreal_pipeline.imprint(
-            container_path,
-            {
-                "representation": str(representation["_id"]),
-                "parent": str(representation["parent"])
-            })
+        self.imprint(
+            asset, asset_dir, container_name, asset_name, representation)
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
-            destination_path, recursive=True, include_folder=True
+            asset_dir, recursive=True, include_folder=False
         )
 
         for a in asset_content:

openpype/hosts/unreal/plugins/load/load_staticmesh_abc.py

@@ -7,7 +7,11 @@ from openpype.pipeline import (
     AYON_CONTAINER_ID
 )
 from openpype.hosts.unreal.api import plugin
-from openpype.hosts.unreal.api import pipeline as unreal_pipeline
+from openpype.hosts.unreal.api.pipeline import (
+    AYON_ASSET_DIR,
+    create_container,
+    imprint,
+)
 import unreal  # noqa
 
 
@@ -20,6 +24,8 @@ class StaticMeshAlembicLoader(plugin.Loader):
     icon = "cube"
     color = "orange"
 
+    root = AYON_ASSET_DIR
+
     @staticmethod
     def get_task(filename, asset_dir, asset_name, replace, default_conversion):
         task = unreal.AssetImportTask()
@@ -53,14 +59,40 @@ class StaticMeshAlembicLoader(plugin.Loader):
 
         return task
 
+    def import_and_containerize(
+        self, filepath, asset_dir, asset_name, container_name,
+        default_conversion=False
+    ):
+        unreal.EditorAssetLibrary.make_directory(asset_dir)
+
+        task = self.get_task(
+            filepath, asset_dir, asset_name, False, default_conversion)
+
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+
+        # Create Asset Container
+        create_container(container=container_name, path=asset_dir)
+
+    def imprint(
+        self, asset, asset_dir, container_name, asset_name, representation
+    ):
+        data = {
+            "schema": "ayon:container-2.0",
+            "id": AYON_CONTAINER_ID,
+            "asset": asset,
+            "namespace": asset_dir,
+            "container_name": container_name,
+            "asset_name": asset_name,
+            "loader": str(self.__class__.__name__),
+            "representation": representation["_id"],
+            "parent": representation["parent"],
+            "family": representation["context"]["family"]
+        }
+        imprint(f"{asset_dir}/{container_name}", data)
+
     def load(self, context, name, namespace, options):
         """Load and containerise representation into Content Browser.
 
-        This is two step process. First, import FBX to temporary path and
-        then call `containerise()` on it - this moves all content to new
-        directory and then it will create AssetContainer there and imprint it
-        with metadata. This will mark this path as container.
-
         Args:
             context (dict): application context
             name (str): subset name
@@ -68,15 +100,12 @@ class StaticMeshAlembicLoader(plugin.Loader):
                              This is not passed here, so namespace is set
                              by `containerise()` because only then we know
                              real path.
-            data (dict): Those would be data to be imprinted. This is not used
-                         now, data are imprinted by `containerise()`.
+            data (dict): Those would be data to be imprinted.
 
         Returns:
             list(str): list of container content
-
         """
         # Create directory for asset and Ayon container
-        root = "/Game/Ayon/Assets"
         asset = context.get('asset').get('name')
         suffix = "_CON"
         asset_name = f"{asset}_{name}" if asset else f"{name}"
@@ -93,39 +122,22 @@ class StaticMeshAlembicLoader(plugin.Loader):
 
         tools = unreal.AssetToolsHelpers().get_asset_tools()
         asset_dir, container_name = tools.create_unique_asset_name(
-            f"{root}/{asset}/{name_version}", suffix="")
+            f"{self.root}/{asset}/{name_version}", suffix="")
 
         container_name += suffix
 
         if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
-            unreal.EditorAssetLibrary.make_directory(asset_dir)
-
             path = self.filepath_from_context(context)
-            task = self.get_task(
-                path, asset_dir, asset_name, False, default_conversion)
 
-            unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
+            self.import_and_containerize(path, asset_dir, asset_name,
+                                         container_name, default_conversion)
 
-            # Create Asset Container
-            unreal_pipeline.create_container(
-                container=container_name, path=asset_dir)
-
-        data = {
-            "schema": "ayon:container-2.0",
-            "id": AYON_CONTAINER_ID,
-            "asset": asset,
-            "namespace": asset_dir,
-            "container_name": container_name,
-            "asset_name": asset_name,
-            "loader": str(self.__class__.__name__),
-            "representation": context["representation"]["_id"],
-            "parent": context["representation"]["parent"],
-            "family": context["representation"]["context"]["family"]
-        }
-        unreal_pipeline.imprint(f"{asset_dir}/{container_name}", data)
+        self.imprint(
+            asset, asset_dir, container_name, asset_name,
+            context["representation"])
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
-            asset_dir, recursive=True, include_folder=True
+            asset_dir, recursive=True, include_folder=False
         )
 
         for a in asset_content:
@@ -134,27 +146,36 @@ class StaticMeshAlembicLoader(plugin.Loader):
         return asset_content
 
     def update(self, container, representation):
-        name = container["asset_name"]
-        source_path = get_representation_path(representation)
-        destination_path = container["namespace"]
+        context = representation.get("context", {})
 
-        task = self.get_task(source_path, destination_path, name, True, False)
+        if not context:
+            raise RuntimeError("No context found in representation")
 
-        # do import fbx and replace existing data
-        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+        # Create directory for asset and Ayon container
+        asset = context.get('asset')
+        name = context.get('subset')
+        suffix = "_CON"
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
+        version = context.get('version')
+        # Check if version is hero version and use different name
+        name_version = f"{name}_v{version:03d}" if version else f"{name}_hero"
+        tools = unreal.AssetToolsHelpers().get_asset_tools()
+        asset_dir, container_name = tools.create_unique_asset_name(
+            f"{self.root}/{asset}/{name_version}", suffix="")
 
-        container_path = "{}/{}".format(container["namespace"],
-                                        container["objectName"])
-        # update metadata
-        unreal_pipeline.imprint(
-            container_path,
-            {
-                "representation": str(representation["_id"]),
-                "parent": str(representation["parent"])
-            })
+        container_name += suffix
+
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            path = get_representation_path(representation)
+
+            self.import_and_containerize(path, asset_dir, asset_name,
+                                         container_name)
+
+        self.imprint(
+            asset, asset_dir, container_name, asset_name, representation)
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
-            destination_path, recursive=True, include_folder=True
+            asset_dir, recursive=True, include_folder=False
         )
 
         for a in asset_content:

openpype/hosts/unreal/plugins/load/load_staticmesh_fbx.py

@@ -7,7 +7,11 @@ from openpype.pipeline import (
     AYON_CONTAINER_ID
 )
 from openpype.hosts.unreal.api import plugin
-from openpype.hosts.unreal.api import pipeline as unreal_pipeline
+from openpype.hosts.unreal.api.pipeline import (
+    AYON_ASSET_DIR,
+    create_container,
+    imprint,
+)
 import unreal  # noqa
 
 
@@ -20,6 +24,8 @@ class StaticMeshFBXLoader(plugin.Loader):
     icon = "cube"
     color = "orange"
 
+    root = AYON_ASSET_DIR
+
     @staticmethod
     def get_task(filename, asset_dir, asset_name, replace):
         task = unreal.AssetImportTask()
@@ -46,14 +52,39 @@ class StaticMeshFBXLoader(plugin.Loader):
 
         return task
 
+    def import_and_containerize(
+        self, filepath, asset_dir, asset_name, container_name
+    ):
+        unreal.EditorAssetLibrary.make_directory(asset_dir)
+
+        task = self.get_task(
+            filepath, asset_dir, asset_name, False)
+
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+
+        # Create Asset Container
+        create_container(container=container_name, path=asset_dir)
+
+    def imprint(
+        self, asset, asset_dir, container_name, asset_name, representation
+    ):
+        data = {
+            "schema": "ayon:container-2.0",
+            "id": AYON_CONTAINER_ID,
+            "asset": asset,
+            "namespace": asset_dir,
+            "container_name": container_name,
+            "asset_name": asset_name,
+            "loader": str(self.__class__.__name__),
+            "representation": representation["_id"],
+            "parent": representation["parent"],
+            "family": representation["context"]["family"]
+        }
+        imprint(f"{asset_dir}/{container_name}", data)
+
     def load(self, context, name, namespace, options):
         """Load and containerise representation into Content Browser.
 
-        This is two step process. First, import FBX to temporary path and
-        then call `containerise()` on it - this moves all content to new
-        directory and then it will create AssetContainer there and imprint it
-        with metadata. This will mark this path as container.
-
         Args:
             context (dict): application context
             name (str): subset name
@@ -61,23 +92,15 @@ class StaticMeshFBXLoader(plugin.Loader):
                              This is not passed here, so namespace is set
                              by `containerise()` because only then we know
                              real path.
-            options (dict): Those would be data to be imprinted. This is not
-                used now, data are imprinted by `containerise()`.
+            options (dict): Those would be data to be imprinted.
 
         Returns:
             list(str): list of container content
         """
-
         # Create directory for asset and Ayon container
-        root = "/Game/Ayon/Assets"
-        if options and options.get("asset_dir"):
-            root = options["asset_dir"]
         asset = context.get('asset').get('name')
         suffix = "_CON"
-        if asset:
-            asset_name = "{}_{}".format(asset, name)
-        else:
-            asset_name = "{}".format(name)
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
         version = context.get('version')
         # Check if version is hero version and use different name
         if not version.get("name") and version.get('type') == "hero_version":
@@ -87,35 +110,20 @@ class StaticMeshFBXLoader(plugin.Loader):
 
         tools = unreal.AssetToolsHelpers().get_asset_tools()
         asset_dir, container_name = tools.create_unique_asset_name(
-            f"{root}/{asset}/{name_version}", suffix=""
+            f"{self.root}/{asset}/{name_version}", suffix=""
         )
 
         container_name += suffix
 
-        unreal.EditorAssetLibrary.make_directory(asset_dir)
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            path = self.filepath_from_context(context)
 
-        path = self.filepath_from_context(context)
-        task = self.get_task(path, asset_dir, asset_name, False)
+            self.import_and_containerize(
+                path, asset_dir, asset_name, container_name)
 
-        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
-
-        # Create Asset Container
-        unreal_pipeline.create_container(
-            container=container_name, path=asset_dir)
-
-        data = {
-            "schema": "ayon:container-2.0",
-            "id": AYON_CONTAINER_ID,
-            "asset": asset,
-            "namespace": asset_dir,
-            "container_name": container_name,
-            "asset_name": asset_name,
-            "loader": str(self.__class__.__name__),
-            "representation": context["representation"]["_id"],
-            "parent": context["representation"]["parent"],
-            "family": context["representation"]["context"]["family"]
-        }
-        unreal_pipeline.imprint(f"{asset_dir}/{container_name}", data)
+        self.imprint(
+            asset, asset_dir, container_name, asset_name,
+            context["representation"])
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
             asset_dir, recursive=True, include_folder=True
@@ -127,27 +135,36 @@ class StaticMeshFBXLoader(plugin.Loader):
         return asset_content
 
     def update(self, container, representation):
-        name = container["asset_name"]
-        source_path = get_representation_path(representation)
-        destination_path = container["namespace"]
+        context = representation.get("context", {})
 
-        task = self.get_task(source_path, destination_path, name, True)
+        if not context:
+            raise RuntimeError("No context found in representation")
 
-        # do import fbx and replace existing data
-        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+        # Create directory for asset and Ayon container
+        asset = context.get('asset')
+        name = context.get('subset')
+        suffix = "_CON"
+        asset_name = f"{asset}_{name}" if asset else f"{name}"
+        version = context.get('version')
+        # Check if version is hero version and use different name
+        name_version = f"{name}_v{version:03d}" if version else f"{name}_hero"
+        tools = unreal.AssetToolsHelpers().get_asset_tools()
+        asset_dir, container_name = tools.create_unique_asset_name(
+            f"{self.root}/{asset}/{name_version}", suffix="")
 
-        container_path = "{}/{}".format(container["namespace"],
-                                        container["objectName"])
-        # update metadata
-        unreal_pipeline.imprint(
-            container_path,
-            {
-                "representation": str(representation["_id"]),
-                "parent": str(representation["parent"])
-            })
+        container_name += suffix
+
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            path = get_representation_path(representation)
+
+            self.import_and_containerize(
+                path, asset_dir, asset_name, container_name)
+
+        self.imprint(
+            asset, asset_dir, container_name, asset_name, representation)
 
         asset_content = unreal.EditorAssetLibrary.list_assets(
-            destination_path, recursive=True, include_folder=True
+            asset_dir, recursive=True, include_folder=False
         )
 
         for a in asset_content:

openpype/hosts/unreal/plugins/load/load_uasset.py

@@ -41,7 +41,7 @@ class UAssetLoader(plugin.Loader):
         """
 
         # Create directory for asset and Ayon container
-        root = "/Game/Ayon/Assets"
+        root = unreal_pipeline.AYON_ASSET_DIR
         asset = context.get('asset').get('name')
         suffix = "_CON"
         asset_name = f"{asset}_{name}" if asset else f"{name}"

openpype/hosts/unreal/plugins/load/load_yeticache.py

@@ -86,7 +86,7 @@ class YetiLoader(plugin.Loader):
             raise RuntimeError("Groom plugin is not activated.")
 
         # Create directory for asset and Ayon container
-        root = "/Game/Ayon/Assets"
+        root = unreal_pipeline.AYON_ASSET_DIR
         asset = context.get('asset').get('name')
         suffix = "_CON"
         asset_name = f"{asset}_{name}" if asset else f"{name}"