Merge pull request #5747 from ynput/bugfix/OP-4626_blender-fix-pointcache

Blender: Fix pointcache family and fix alembic extractor

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

@@ -3,11 +3,11 @@
 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 plugin, lib, ops
+from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
 
 
-class CreatePointcache(openpype.hosts.blender.api.plugin.Creator):
+class CreatePointcache(plugin.Creator):
     """Polygonal static geometry"""
 
     name = "pointcacheMain"
@@ -16,20 +16,36 @@ class CreatePointcache(openpype.hosts.blender.api.plugin.Creator):
     icon = "gears"
 
     def process(self):
+        """ Run the creator on Blender main thread"""
+        mti = ops.MainThreadItem(self._process)
+        ops.execute_in_main_thread(mti)
 
+    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 = openpype.hosts.blender.api.plugin.asset_name(asset, subset)
-        collection = bpy.data.collections.new(name=name)
-        bpy.context.scene.collection.children.link(collection)
+        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(collection, self.data)
+        lib.imprint(asset_group, self.data)
 
+        # Add selected objects to instance
         if (self.options or {}).get("useSelection"):
-            objects = lib.get_selection()
-            for obj in objects:
-                collection.objects.link(obj)
-                if obj.type == 'EMPTY':
-                    objects.extend(obj.children)
+            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 collection
+        return asset_group

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

@@ -60,18 +60,29 @@ class CacheModelLoader(plugin.AssetLoader):
 
         imported = lib.get_selection()
 
-        # Children must be linked before parents,
-        # otherwise the hierarchy will break
+        # Use first EMPTY without parent as container
+        container = next(
+            (obj for obj in imported
+             if obj.type == "EMPTY" and not obj.parent),
+            None
+        )
+
         objects = []
+        if container:
+            nodes = list(container.children)
 
-        for obj in imported:
-            obj.parent = asset_group
+            for obj in nodes:
+                obj.parent = asset_group
 
-        for obj in imported:
-            objects.append(obj)
-            imported.extend(list(obj.children))
+            bpy.data.objects.remove(container)
 
-        objects.reverse()
+            objects.extend(nodes)
+            for obj in nodes:
+                objects.extend(obj.children_recursive)
+        else:
+            for obj in imported:
+                obj.parent = asset_group
+            objects = imported
 
         for obj in objects:
             # Unlink the object from all collections
@@ -137,6 +148,7 @@ class CacheModelLoader(plugin.AssetLoader):
             bpy.context.scene.collection.children.link(containers)
 
         asset_group = bpy.data.objects.new(group_name, object_data=None)
+        asset_group.empty_display_type = 'SINGLE_ARROW'
         containers.objects.link(asset_group)
 
         objects = self._process(libpath, asset_group, group_name)

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

@@ -19,85 +19,51 @@ class CollectInstances(pyblish.api.ContextPlugin):
 
     @staticmethod
     def get_asset_groups() -> Generator:
-        """Return all 'model' collections.
-
-        Check if the family is 'model' and if it doesn't have the
-        representation set. If the representation is set, it is a loaded model
-        and we don't want to publish it.
+        """Return all instances that are empty objects asset groups.
         """
         instances = bpy.data.collections.get(AVALON_INSTANCES)
-        for obj in instances.objects:
-            avalon_prop = obj.get(AVALON_PROPERTY) or dict()
+        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 get_collections() -> Generator:
-        """Return all 'model' collections.
-
-        Check if the family is 'model' and if it doesn't have the
-        representation set. If the representation is set, it is a loaded model
-        and we don't want to publish it.
-        """
-        for collection in bpy.data.collections:
-            avalon_prop = collection.get(AVALON_PROPERTY) or dict()
-            if avalon_prop.get('id') == 'pyblish.avalon.instance':
-                yield collection
+    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()
-        collections = self.get_collections()
 
         for group in asset_groups:
-            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}"
-            instance = context.create_instance(
-                name=name,
-                family=family,
-                families=[family],
-                subset=subset,
-                asset=asset,
-                task=task,
-            )
-            objects = list(group.children)
-            members = set()
-            for obj in objects:
-                objects.extend(list(obj.children))
-                members.add(obj)
-            members.add(group)
-            instance[:] = list(members)
-            self.log.debug(json.dumps(instance.data, indent=4))
-            for obj in instance:
-                self.log.debug(obj)
+            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
 
-        for collection in collections:
-            avalon_prop = collection[AVALON_PROPERTY]
-            asset = avalon_prop['asset']
-            family = avalon_prop['family']
-            subset = avalon_prop['subset']
-            task = avalon_prop['task']
-            name = f"{asset}_{subset}"
-            instance = context.create_instance(
-                name=name,
-                family=family,
-                families=[family],
-                subset=subset,
-                asset=asset,
-                task=task,
-            )
-            members = list(collection.objects)
-            if family == "animation":
-                for obj in collection.objects:
-                    if obj.type == 'EMPTY' and obj.get(AVALON_PROPERTY):
-                        for child in obj.children:
-                            if child.type == 'ARMATURE':
-                                members.append(child)
-            members.append(collection)
+            members.append(group)
             instance[:] = members
             self.log.debug(json.dumps(instance.data, indent=4))
             for obj in instance:

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

@@ -12,8 +12,7 @@ class ExtractABC(publish.Extractor):
 
     label = "Extract ABC"
     hosts = ["blender"]
-    families = ["model", "pointcache"]
-    optional = True
+    families = ["pointcache"]
 
     def process(self, instance):
         # Define extract output file path
@@ -62,3 +61,12 @@ class ExtractABC(publish.Extractor):
 
         self.log.info("Extracted instance '%s' to: %s",
                       instance.name, representation)
+
+
+class ExtractModelABC(ExtractABC):
+    """Extract model as ABC."""
+
+    label = "Extract Model ABC"
+    hosts = ["blender"]
+    families = ["model"]
+    optional = True

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

@@ -10,7 +10,7 @@ class IncrementWorkfileVersion(pyblish.api.ContextPlugin):
     optional = True
     hosts = ["blender"]
     families = ["animation", "model", "rig", "action", "layout", "blendScene",
-                "render"]
+                "pointcache", "render"]
 
     def process(self, context):
 

openpype/settings/defaults/project_settings/blender.json

@@ -89,10 +89,10 @@
             "optional": true,
             "active": false
         },
-        "ExtractABC": {
+        "ExtractModelABC": {
             "enabled": true,
             "optional": true,
-            "active": false
+            "active": true
         },
         "ExtractBlendAnimation": {
             "enabled": true,

openpype/settings/entities/schemas/projects_schema/schemas/schema_blender_publish.json

@@ -181,12 +181,12 @@
             "name": "template_publish_plugin",
             "template_data": [
                 {
-                    "key": "ExtractFBX",
-                    "label": "Extract FBX (model and rig)"
+                    "key": "ExtractModelABC",
+                    "label": "Extract ABC (model)"
                 },
                 {
-                    "key": "ExtractABC",
-                    "label": "Extract ABC (model and pointcache)"
+                    "key": "ExtractFBX",
+                    "label": "Extract FBX (model and rig)"
                 },
                 {
                     "key": "ExtractBlendAnimation",

server_addon/blender/server/settings/publish_plugins.py

@@ -103,7 +103,7 @@ class PublishPuginsModel(BaseSettingsModel):
         default_factory=ValidatePluginModel,
         title="Extract FBX"
     )
-    ExtractABC: ValidatePluginModel = Field(
+    ExtractModelABC: ValidatePluginModel = Field(
         default_factory=ValidatePluginModel,
         title="Extract ABC"
     )
@@ -197,10 +197,10 @@ DEFAULT_BLENDER_PUBLISH_SETTINGS = {
         "optional": True,
         "active": False
     },
-    "ExtractABC": {
+    "ExtractModelABC": {
         "enabled": True,
         "optional": True,
-        "active": False
+        "active": True
     },
     "ExtractBlendAnimation": {
         "enabled": True,