Implemented creator, loader and extractor for Unreal Levels

openpype/hosts/unreal/plugins/create/create_umap.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+
+import unreal
+
+from openpype.pipeline import CreatorError
+from openpype.hosts.unreal.api.plugin import (
+    UnrealAssetCreator,
+)
+
+
+class CreateUMap(UnrealAssetCreator):
+    """Create Level."""
+
+    identifier = "io.ayon.creators.unreal.umap"
+    label = "Level"
+    family = "uasset"
+    icon = "cube"
+
+    def create(self, subset_name, instance_data, pre_create_data):
+        if pre_create_data.get("use_selection"):
+            ar = unreal.AssetRegistryHelpers.get_asset_registry()
+
+            sel_objects = unreal.EditorUtilityLibrary.get_selected_assets()
+            selection = [a.get_path_name() for a in sel_objects]
+
+            if len(selection) != 1:
+                raise CreatorError("Please select only one object.")
+
+            obj = selection[0]
+
+            asset = ar.get_asset_by_object_path(obj).get_asset()
+            sys_path = unreal.SystemLibrary.get_system_path(asset)
+
+            if not sys_path:
+                raise CreatorError(
+                    f"{Path(obj).name} is not on the disk. Likely it needs to"
+                    "be saved first.")
+
+            if Path(sys_path).suffix != ".umap":
+                raise CreatorError(f"{Path(sys_path).name} is not a Level.")
+
+        super(CreateUMap, self).create(
+            subset_name,
+            instance_data,
+            pre_create_data)

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

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+"""Load Level."""
+from pathlib import Path
+import shutil
+
+from openpype.pipeline import (
+    get_representation_path,
+    AYON_CONTAINER_ID
+)
+from openpype.hosts.unreal.api import plugin
+from openpype.hosts.unreal.api import pipeline as unreal_pipeline
+import unreal  # noqa
+
+
+class UMapLoader(plugin.Loader):
+    """Load Level."""
+
+    families = ["uasset"]
+    label = "Load Level"
+    representations = ["umap"]
+    icon = "cube"
+    color = "orange"
+
+    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.
+            options (dict): Those would be data to be imprinted. This is not
+                used now, data are imprinted by `containerise()`.
+
+        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}"
+        tools = unreal.AssetToolsHelpers().get_asset_tools()
+        asset_dir, container_name = tools.create_unique_asset_name(
+            f"{root}/{asset}/{name}", suffix=""
+        )
+
+        container_name += suffix
+
+        unreal.EditorAssetLibrary.make_directory(asset_dir)
+
+        destination_path = asset_dir.replace(
+            "/Game",
+            Path(unreal.Paths.project_content_dir()).as_posix(),
+            1)
+
+        shutil.copy(self.fname, f"{destination_path}/{name}.uasset")
+
+        # 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)
+
+        asset_content = unreal.EditorAssetLibrary.list_assets(
+            asset_dir, recursive=True, include_folder=True
+        )
+
+        for a in asset_content:
+            unreal.EditorAssetLibrary.save_asset(a)
+
+        return asset_content
+
+    def update(self, container, representation):
+        ar = unreal.AssetRegistryHelpers.get_asset_registry()
+
+        asset_dir = container["namespace"]
+        name = representation["context"]["subset"]
+
+        destination_path = asset_dir.replace(
+            "/Game",
+            Path(unreal.Paths.project_content_dir()).as_posix(),
+            1)
+
+        asset_content = unreal.EditorAssetLibrary.list_assets(
+            asset_dir, recursive=False, include_folder=True
+        )
+
+        for asset in asset_content:
+            obj = ar.get_asset_by_object_path(asset).get_asset()
+            if obj.get_class().get_name() != 'AyonAssetContainer':
+                unreal.EditorAssetLibrary.delete_asset(asset)
+
+        update_filepath = get_representation_path(representation)
+
+        shutil.copy(update_filepath, f"{destination_path}/{name}.umap")
+
+        container_path = f'{container["namespace"]}/{container["objectName"]}'
+        # update metadata
+        unreal_pipeline.imprint(
+            container_path,
+            {
+                "representation": str(representation["_id"]),
+                "parent": str(representation["parent"])
+            })
+
+        asset_content = unreal.EditorAssetLibrary.list_assets(
+            asset_dir, recursive=True, include_folder=True
+        )
+
+        for a in asset_content:
+            unreal.EditorAssetLibrary.save_asset(a)
+
+    def remove(self, container):
+        path = container["namespace"]
+        parent_path = Path(path).parent.as_posix()
+
+        unreal.EditorAssetLibrary.delete_directory(path)
+
+        asset_content = unreal.EditorAssetLibrary.list_assets(
+            parent_path, recursive=False
+        )
+
+        if len(asset_content) == 0:
+            unreal.EditorAssetLibrary.delete_directory(parent_path)

openpype/hosts/unreal/plugins/publish/collect_instance_members.py

@@ -24,7 +24,7 @@ class CollectInstanceMembers(pyblish.api.InstancePlugin):
         ar = unreal.AssetRegistryHelpers.get_asset_registry()
 
         inst_path = instance.data.get('instance_path')
-        inst_name = instance.data.get('objectName')
+        inst_name = inst_path.split('/')[-1]
 
         pub_instance = ar.get_asset_by_object_path(
             f"{inst_path}.{inst_name}").get_asset()

openpype/hosts/unreal/plugins/publish/extract_umap.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+import shutil
+
+import unreal
+
+from openpype.pipeline import publish
+
+
+class ExtractUMap(publish.Extractor):
+    """Extract a UMap."""
+
+    label = "Extract Level"
+    hosts = ["unreal"]
+    families = ["uasset"]
+    optional = True
+
+    def process(self, instance):
+        ar = unreal.AssetRegistryHelpers.get_asset_registry()
+
+        self.log.info("Performing extraction..")
+
+        staging_dir = self.staging_dir(instance)
+        filename = f"{instance.name}.umap"
+
+        members = instance.data.get("members", [])
+
+        if not members:
+            raise RuntimeError("No members found in instance.")
+
+        # UAsset publishing supports only one member
+        obj = members[0]
+
+        asset = ar.get_asset_by_object_path(obj).get_asset()
+        sys_path = unreal.SystemLibrary.get_system_path(asset)
+        filename = Path(sys_path).name
+
+        shutil.copy(sys_path, staging_dir)
+
+        if "representations" not in instance.data:
+            instance.data["representations"] = []
+
+        representation = {
+            'name': 'umap',
+            'ext': 'umap',
+            'files': filename,
+            "stagingDir": staging_dir,
+        }
+        instance.data["representations"].append(representation)