add model creator, extractors and loaders

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

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+"""Creator plugin for model."""
+from openpype.hosts.max.api import plugin
+from openpype.pipeline import CreatedInstance
+
+
+class CreateModel(plugin.MaxCreator):
+    identifier = "io.openpype.creators.max.model"
+    label = "Model"
+    family = "model"
+    icon = "gear"
+
+    def create(self, subset_name, instance_data, pre_create_data):
+        from pymxs import runtime as rt
+        sel_obj = list(rt.selection)
+        instance = super(CreateModel, self).create(
+            subset_name,
+            instance_data,
+            pre_create_data)  # type: CreatedInstance
+        container = rt.getNodeByName(instance.data.get("instance_node"))
+        # TODO: Disable "Add to Containers?" Panel
+        # parent the selected cameras into the container
+        for obj in sel_obj:
+            obj.parent = container
+        # for additional work on the node:
+        # instance_node = rt.getNodeByName(instance.get("instance_node"))

openpype/hosts/max/plugins/load/load_max_scene.py

@@ -9,7 +9,8 @@ from openpype.hosts.max.api import lib
 class MaxSceneLoader(load.LoaderPlugin):
     """Max Scene Loader"""
 
-    families = ["camera"]
+    families = ["camera",
+                "model"]
     representations = ["max"]
     order = -8
     icon = "code-fork"

openpype/hosts/max/plugins/load/load_model.py

@@ -0,0 +1,98 @@
+
+import os
+from openpype.pipeline import (
+    load, get_representation_path
+)
+from openpype.hosts.max.api.pipeline import containerise
+from openpype.hosts.max.api import lib
+
+
+class ModelAbcLoader(load.LoaderPlugin):
+    """Loading model with the Alembic loader."""
+
+    families = ["model"]
+    label = "Load Model(Alembic)"
+    representations = ["abc"]
+    order = -10
+    icon = "code-fork"
+    color = "orange"
+
+    def load(self, context, name=None, namespace=None, data=None):
+        from pymxs import runtime as rt
+
+        file_path = os.path.normpath(self.fname)
+
+        abc_before = {
+            c for c in rt.rootNode.Children
+            if rt.classOf(c) == rt.AlembicContainer
+        }
+
+        abc_import_cmd = (f"""
+AlembicImport.ImportToRoot = false
+AlembicImport.CustomAttributes = true
+AlembicImport.UVs = true
+AlembicImport.VertexColors = true
+
+importFile @"{file_path}" #noPrompt
+        """)
+
+        self.log.debug(f"Executing command: {abc_import_cmd}")
+        rt.execute(abc_import_cmd)
+
+        abc_after = {
+            c for c in rt.rootNode.Children
+            if rt.classOf(c) == rt.AlembicContainer
+        }
+
+        # This should yield new AlembicContainer node
+        abc_containers = abc_after.difference(abc_before)
+
+        if len(abc_containers) != 1:
+            self.log.error("Something failed when loading.")
+
+        abc_container = abc_containers.pop()
+
+        return containerise(
+            name, [abc_container], context, loader=self.__class__.__name__)
+
+    def update(self, container, representation):
+        from pymxs import runtime as rt
+
+        path = get_representation_path(representation)
+        node = rt.getNodeByName(container["instance_node"])
+
+        alembic_objects = self.get_container_children(node, "AlembicObject")
+        for alembic_object in alembic_objects:
+            alembic_object.source = path
+
+        lib.imprint(container["instance_node"], {
+            "representation": str(representation["_id"])
+        })
+
+    def switch(self, container, representation):
+        self.update(container, representation)
+
+    def remove(self, container):
+        from pymxs import runtime as rt
+
+        node = rt.getNodeByName(container["instance_node"])
+        rt.delete(node)
+
+    @staticmethod
+    def get_container_children(parent, type_name):
+        from pymxs import runtime as rt
+
+        def list_children(node):
+            children = []
+            for c in node.Children:
+                children.append(c)
+                children += list_children(c)
+            return children
+
+        filtered = []
+        for child in list_children(parent):
+            class_type = str(rt.classOf(child.baseObject))
+            if class_type == type_name:
+                filtered.append(child)
+
+        return filtered

openpype/hosts/max/plugins/load/load_pointcache.py

@@ -15,8 +15,7 @@ from openpype.hosts.max.api import lib
 class AbcLoader(load.LoaderPlugin):
     """Alembic loader."""
 
-    families = ["model",
-                "camera",
+    families = ["camera",
                 "animation",
                 "pointcache"]
     label = "Load Alembic"

openpype/hosts/max/plugins/publish/extract_max_scene_raw.py

@@ -20,7 +20,8 @@ class ExtractMaxSceneRaw(publish.Extractor,
     order = pyblish.api.ExtractorOrder - 0.2
     label = "Extract Max Scene (Raw)"
     hosts = ["max"]
-    families = ["camera"]
+    families = ["camera",
+                "model"]
     optional = True
 
     def process(self, instance):

openpype/hosts/max/plugins/publish/extract_model.py

@@ -0,0 +1,74 @@
+import os
+import pyblish.api
+from openpype.pipeline import (
+    publish,
+    OptionalPyblishPluginMixin
+)
+from pymxs import runtime as rt
+from openpype.hosts.max.api import (
+    maintained_selection,
+    get_all_children
+)
+
+
+class ExtractModel(publish.Extractor,
+                   OptionalPyblishPluginMixin):
+    """
+    Extract Geometry in Alembic Format
+    """
+
+    order = pyblish.api.ExtractorOrder - 0.1
+    label = "Extract Geometry (Alembic)"
+    hosts = ["max"]
+    families = ["model"]
+    optional = True
+
+    def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
+        container = instance.data["instance_node"]
+
+        self.log.info("Extracting Geometry ...")
+
+        stagingdir = self.staging_dir(instance)
+        filename = "{name}.abc".format(**instance.data)
+        filepath = os.path.join(stagingdir, filename)
+
+        # We run the render
+        self.log.info("Writing alembic '%s' to '%s'" % (filename,
+                                                        stagingdir))
+
+        export_cmd = (
+            f"""
+AlembicExport.ArchiveType = #ogawa
+AlembicExport.CoordinateSystem = #maya
+AlembicExport.CustomAttributes = true
+AlembicExport.UVs = true
+AlembicExport.VertexColors = true
+AlembicExport.PreserveInstances = true
+
+exportFile @"{filepath}" #noPrompt selectedOnly:on using:AlembicExport
+
+            """)
+
+        self.log.debug(f"Executing command: {export_cmd}")
+
+        with maintained_selection():
+            # select and export
+            rt.select(get_all_children(rt.getNodeByName(container)))
+            rt.execute(export_cmd)
+
+        self.log.info("Performing Extraction ...")
+        if "representations" not in instance.data:
+            instance.data["representations"] = []
+
+        representation = {
+            'name': 'abc',
+            'ext': 'abc',
+            'files': filename,
+            "stagingDir": stagingdir,
+        }
+        instance.data["representations"].append(representation)
+        self.log.info("Extracted instance '%s' to: %s" % (instance.name,
+                                                          filepath))