update validators

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

@@ -72,8 +72,6 @@ class ExtractPointCloud(publish.Extractor):
         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)
@@ -153,8 +151,8 @@ class ExtractPointCloud(publish.Extractor):
         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)
+        partition_start = self.partition_start
+        partition_count = 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,

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

@@ -1,6 +1,15 @@
 import pyblish.api
 from openpype.pipeline import PublishValidationError
 from pymxs import runtime as rt
+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 ValidatePointCloud(pyblish.api.InstancePlugin):
@@ -15,8 +24,14 @@ class ValidatePointCloud(pyblish.api.InstancePlugin):
         """
         Notes:
 
-        1. Validate the container only include tyFlow objects
-        2. Validate if tyFlow operator Export Particle exists
+            1. Validate the container only include tyFlow objects
+            2. Validate if tyFlow operator Export Particle exists
+            3. Validate if the export mode of Export Particle is at PRT format
+            4. Validate the partition count and range set as default value
+                Partition Count : 100
+                Partition Range : 1 to 1
+            5. Validate if the custom attribute(s) exist as parameter(s)
+                of export_particle operator
 
         """
         invalid = self.get_tyFlow_object(instance)
@@ -28,6 +43,19 @@ class ValidatePointCloud(pyblish.api.InstancePlugin):
             raise PublishValidationError("tyFlow ExportParticle operator "
                                          "not found: {}".format(invalid))
 
+        invalid = self.validate_export_mode(instance)
+        if invalid:
+            raise PublishValidationError("The export mode is not at PRT")
+
+        invalid = self.validate_partition_value(instance)
+        if invalid:
+            raise PublishValidationError("tyFlow Partition setting is "
+                                         "not at the default value")
+        invalid = self.validate_custom_attribute(instance)
+        if invalid:
+            raise PublishValidationError("Custom Attribute not found "
+                                         ":{}".format(invalid))
+
     def get_tyFlow_object(self, instance):
         invalid = []
         container = instance.data["instance_node"]
@@ -72,3 +100,92 @@ class ValidatePointCloud(pyblish.api.InstancePlugin):
                 invalid.append(sel)
 
         return invalid
+
+    def validate_custom_attribute(self, instance):
+        invalid = []
+        container = instance.data["instance_node"]
+        self.log.info("Validating tyFlow custom "
+                      "attributes for {}".format(container))
+
+        con = rt.getNodeByName(container)
+        selection_list = list(con.Children)
+        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")
+                event_name = sub_anim.name
+                if boolean:
+                    opt = "${0}.{1}.export_particles".format(sel.name,
+                                                             event_name)
+                    attributes = get_setting()["attribute"]
+                    for key, value in attributes.items():
+                        custom_attr = "{0}.PRTChannels_{1}".format(opt,
+                                                                   value)
+                        try:
+                            rt.execute(custom_attr)
+                        except RuntimeError:
+                            invalid.add(key)
+
+        return invalid
+
+    def validate_partition_value(self, instance):
+        invalid = []
+        container = instance.data["instance_node"]
+        self.log.info("Validating tyFlow partition "
+                      "value for {}".format(container))
+
+        con = rt.getNodeByName(container)
+        selection_list = list(con.Children)
+        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")
+                event_name = sub_anim.name
+                if boolean:
+                    opt = "${0}.{1}.export_particles".format(sel.name,
+                                                             event_name)
+                    count = rt.execute(f'{opt}.PRTPartitionsCount')
+                    if count != 100:
+                        invalid.append(count)
+                    start = rt.execute(f'{opt}.PRTPartitionsFrom')
+                    if start != 1:
+                        invalid.append(start)
+                    end = rt.execute(f'{opt}.PRTPartitionsTo')
+                    if end != 1:
+                        invalid.append(end)
+
+        return invalid
+
+    def validate_export_mode(self, instance):
+        invalid = []
+        container = instance.data["instance_node"]
+        self.log.info("Validating tyFlow partition "
+                      "value for {}".format(container))
+
+        con = rt.getNodeByName(container)
+        selection_list = list(con.Children)
+        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")
+                event_name = sub_anim.name
+                if boolean:
+                    opt = "${0}.{1}.export_particles".format(sel.name,
+                                                             event_name)
+                    export_mode = rt.execute(f'{opt}.exportMode')
+                    if export_mode != 2:
+                        invalid.append(export_mode)
+
+        return invalid