creator, validator and extractor for point cloud from tyFlow

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

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+"""Creator plugin for creating point cloud."""
+from openpype.hosts.max.api import plugin
+from openpype.pipeline import CreatedInstance
+
+
+class CreatePointCloud(plugin.MaxCreator):
+    identifier = "io.openpype.creators.max.pointcloud"
+    label = "Point Cloud"
+    family = "pointcloud"
+    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(CreatePointCloud, 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/publish/extract_pointcloud.py

@@ -0,0 +1,170 @@
+import os
+import pyblish.api
+from openpype.pipeline import publish
+from pymxs import runtime as rt
+from openpype.hosts.max.api import (
+    maintained_selection
+)
+from openpype.settings import get_project_settings
+from openpype.pipeline import legacy_io
+
+
+def get_setting(project_setting=None):
+    project_setting = get_project_settings(
+        legacy_io.Session["AVALON_PROJECT"]
+    )
+    return (project_setting["max"]["PointCloud"])
+
+
+class ExtractPointCloud(publish.Extractor):
+    """
+    Extract PTF format with tyFlow operators
+    """
+
+    order = pyblish.api.ExtractorOrder - 0.2
+    label = "Extract Point Cloud"
+    hosts = ["max"]
+    families = ["pointcloud"]
+    partition_start = 1
+    partition_count = 100
+
+
+    def process(self, instance):
+        start = str(instance.data.get("frameStartHandle", 1))
+        end = str(instance.data.get("frameEndHandle", 1))
+        container = instance.data["instance_node"]
+
+        self.log.info("Extracting PRT...")
+
+        stagingdir = self.staging_dir(instance)
+        filename = "{name}.prt".format(**instance.data)
+        path = os.path.join(stagingdir, filename)
+
+        with maintained_selection():
+            job_args = self.export_particle(container,
+                                            start,
+                                            end,
+                                            path)
+            for job in job_args:
+                rt.execute(job)
+
+        self.log.info("Performing Extraction ...")
+        if "representations" not in instance.data:
+            instance.data["representations"] = []
+
+        self.log.info("Writing PRT with TyFlow Plugin...")
+        filenames = self.get_files(path, start, end)
+        self.log.info("filename: {0}".format(filenames))
+        representation = {
+            'name': 'prt',
+            'ext': 'prt',
+            'files': filenames if len(filenames) > 1 else filenames[0],
+            "stagingDir": stagingdir,
+        }
+        instance.data["representations"].append(representation)
+        self.log.info("Extracted instance '%s' to: %s" % (instance.name,
+                                                          path))
+
+    def export_particle(self,
+                        container,
+                        start,
+                        end,
+                        filepath):
+        job_args = []
+        opt_list = self.get_operators(container)
+        for operator in opt_list:
+            export_mode = "{0}.exportMode=2".format(operator)
+            job_args.append(export_mode)
+            start_frame = "{0}.frameStart={1}".format(operator,
+                                                      start)
+            job_args.append(start_frame)
+            end_frame = "{0}.frameEnd={1}".format(operator,
+                                                  end)
+            job_args.append(end_frame)
+            filepath = filepath.replace("\\", "/")
+            prt_filename = '{0}.PRTFilename="{1}"'.format(operator,
+                                                          filepath)
+
+            job_args.append(prt_filename)
+            # Partition
+            mode = "{0}.PRTPartitionsMode=2".format(operator)
+            job_args.append(mode)
+
+            additional_args = self.get_custom_attr(operator)
+            for args in additional_args:
+                job_args.append(args)
+
+            prt_export = "{0}.exportPRT()".format(operator)
+            job_args.append(prt_export)
+
+        return job_args
+
+    def get_operators(self, container):
+        """Get Export Particles Operator"""
+
+        opt_list = []
+        node = rt.getNodebyName(container)
+        selection_list = list(node.Children)
+        for sel in selection_list:
+            obj = sel.baseobject
+            # TODO: to see if it can be used maxscript instead
+            anim_names = rt.getsubanimnames(obj)
+            for anim_name in anim_names:
+                sub_anim = rt.getsubanim(obj, anim_name)
+                boolean = rt.isProperty(sub_anim, "Export_Particles")
+                event_name = sub_anim.name
+                if boolean:
+                    opt = "${0}.{1}.export_particles".format(sel.name,
+                                                             event_name)
+                    opt_list.append(opt)
+
+        return opt_list
+
+    def get_custom_attr(self, operator):
+        """Get Custom Attributes"""
+
+        custom_attr_list = []
+        attr_settings = get_setting()["attribute"]
+        for key, value in attr_settings.items():
+            custom_attr = "{0}.PRTChannels_{1}=True".format(operator,
+                                                            value)
+            self.log.debug(
+                "{0} will be added as custom attribute".format(key)
+            )
+            custom_attr_list.append(custom_attr)
+
+        return custom_attr_list
+
+    def get_files(self,
+                  path,
+                  start_frame,
+                  end_frame):
+        """
+        Note:
+            Set the filenames accordingly to the tyFlow file
+            naming extension for the publishing purpose
+
+            Actual File Output from tyFlow:
+            <SceneFile>__part<PartitionStart>of<PartitionCount>.<frame>.prt
+            e.g. tyFlow_cloth_CCCS_blobbyFill_001__part1of1_00004.prt
+            Renamed Output:
+            <instance.name>.<frame>.prt
+            e.g. pointcloudMain.0001.prt
+        """
+        filenames = []
+        filename = os.path.basename(path)
+        orig_name, ext = os.path.splitext(filename)
+        partition_start = str(self.partition_start)
+        partition_count = str(self.partition_count)
+        for frame in range(int(start_frame), int(end_frame) + 1):
+            actual_name = "{}__part{:03}of{}_{:05}".format(orig_name,
+                                                           partition_start,
+                                                           partition_count,
+                                                           frame)
+            actual_filename = path.replace(orig_name, actual_name)
+            new_name = "{}.{:04}".format(orig_name, frame)
+            renamed_filename = path.replace(orig_name, new_name)
+            os.rename(actual_filename, renamed_filename)
+            filenames.append(os.path.basename(renamed_filename))
+
+        return filenames

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

@@ -0,0 +1,74 @@
+import pyblish.api
+from openpype.pipeline import PublishValidationError
+from pymxs import runtime as rt
+
+
+class ValidatePointCloud(pyblish.api.InstancePlugin):
+    """Validate that workfile was saved."""
+
+    order = pyblish.api.ValidatorOrder
+    families = ["pointcloud"]
+    hosts = ["max"]
+    label = "Validate Point Cloud"
+
+    def process(self, instance):
+        """
+        Notes:
+
+        1. Validate the container only include tyFlow objects
+        2. Validate if tyFlow operator Export Particle exists
+
+        """
+        invalid = self.get_tyFlow_object(instance)
+        if invalid:
+            raise PublishValidationError("Non tyFlow object "
+                                         "found: {}".format(invalid))
+        invalid = self.get_tyFlow_operator(instance)
+        if invalid:
+            raise PublishValidationError("tyFlow ExportParticle operator "
+                                         "not found: {}".format(invalid))
+
+    def get_tyFlow_object(self, instance):
+        invalid = []
+        container = instance.data["instance_node"]
+        self.log.info("Validating tyFlow container "
+                      "for {}".format(container))
+
+        con = rt.getNodeByName(container)
+        selection_list = list(con.Children)
+        for sel in selection_list:
+            sel_tmp = str(sel)
+            if rt.classOf(sel) in [rt.tyFlow,
+                                   rt.Editable_Mesh]:
+                if "tyFlow" not in sel_tmp:
+                    invalid.append(sel)
+            else:
+                invalid.append(sel)
+
+        return invalid
+
+    def get_tyFlow_operator(self, instance):
+        invalid = []
+        container = instance.data["instance_node"]
+        self.log.info("Validating tyFlow object "
+                      "for {}".format(container))
+
+        con = rt.getNodeByName(container)
+        selection_list = list(con.Children)
+        bool_list = []
+        for sel in selection_list:
+            obj = sel.baseobject
+            anim_names = rt.getsubanimnames(obj)
+            for anim_name in anim_names:
+                # get all the names of the related tyFlow nodes
+                sub_anim = rt.getsubanim(obj, anim_name)
+                # check if there is export particle operator
+                boolean = rt.isProperty(sub_anim, "Export_Particles")
+                bool_list.append(str(boolean))
+            # if the export_particles property is not there
+            # it means there is not a "Export Particle" operator
+            if "True" not in bool_list:
+                self.log.error("Operator 'Export Particles' not found!")
+                invalid.append(sel)
+
+        return invalid

openpype/plugins/publish/integrate.py

@@ -80,6 +80,7 @@ class IntegrateAsset(pyblish.api.InstancePlugin):
     order = pyblish.api.IntegratorOrder
     families = ["workfile",
                 "pointcache",
+                "pointcloud",
                 "proxyAbc",
                 "camera",
                 "animation",

openpype/plugins/publish/integrate_legacy.py

@@ -76,6 +76,7 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
     order = pyblish.api.IntegratorOrder + 0.00001
     families = ["workfile",
                 "pointcache",
+                "pointcloud",
                 "proxyAbc",
                 "camera",
                 "animation",

openpype/settings/defaults/project_settings/max.json

@@ -4,5 +4,20 @@
         "aov_separator": "underscore",
         "image_format": "exr",
         "multipass": true
+    },
+    "PointCloud":{
+        "attribute":{
+            "Age": "age",
+            "Radius": "radius",
+            "Position": "position",
+            "Rotation": "rotation",
+            "Scale": "scale",
+            "Velocity": "velocity",
+            "Color": "color",
+            "TextureCoordinate": "texcoord",
+            "MaterialID": "matid",
+            "custFloats": "custFloats",
+            "custVecs": "custVecs"
+        }
     }
 }

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

@@ -51,6 +51,28 @@
                     "label": "multipass"
                 }
             ]
+        },
+        {
+            "type": "dict",
+            "collapsible": true,
+            "key": "PointCloud",
+            "label": "Point Cloud",
+            "children": [
+                {
+                    "type": "label",
+                    "label": "Define the channel attribute names before exporting as PRT"
+                },
+                {
+                    "type": "dict-modifiable",
+                    "collapsible": true,
+                    "key": "attribute",
+                    "label": "Channel Attribute",
+                    "use_label_wrap": true,
+                    "object_type": {
+                        "type": "text"
+                    }
+                }
+            ]
         }
     ]
-}
+}