resolve the conflict

openpype/hosts/max/api/colorspace.py

@@ -0,0 +1,50 @@
+import attr
+from pymxs import runtime as rt
+
+
+@attr.s
+class LayerMetadata(object):
+    """Data class for Render Layer metadata."""
+    frameStart = attr.ib()
+    frameEnd = attr.ib()
+
+
+@attr.s
+class RenderProduct(object):
+    """Getting Colorspace as
+    Specific Render Product Parameter for submitting
+    publish job.
+    """
+    colorspace = attr.ib()                      # colorspace
+    view = attr.ib()
+    productName = attr.ib(default=None)
+
+
+class ARenderProduct(object):
+
+    def __init__(self):
+        """Constructor."""
+        # Initialize
+        self.layer_data = self._get_layer_data()
+        self.layer_data.products = self.get_colorspace_data()
+
+    def _get_layer_data(self):
+        return LayerMetadata(
+            frameStart=int(rt.rendStart),
+            frameEnd=int(rt.rendEnd),
+        )
+
+    def get_colorspace_data(self):
+        """To be implemented by renderer class.
+        This should return a list of RenderProducts.
+        Returns:
+            list: List of RenderProduct
+        """
+        colorspace_data = [
+            RenderProduct(
+                colorspace="sRGB",
+                view="ACES 1.0",
+                productName=""
+            )
+        ]
+        return colorspace_data

openpype/hosts/max/api/lib.py

@@ -121,7 +121,14 @@ def get_all_children(parent, node_type=None):
 
 
 def get_current_renderer():
-    """get current renderer"""
+    """
+    Notes:
+        Get current renderer for Max
+
+    Returns:
+        "{Current Renderer}:{Current Renderer}"
+        e.g. "Redshift_Renderer:Redshift_Renderer"
+    """
     return rt.renderers.production
 
 

openpype/hosts/max/api/lib_renderproducts.py

@@ -3,94 +3,126 @@
 # arnold
 # https://help.autodesk.com/view/ARNOL/ENU/?guid=arnold_for_3ds_max_ax_maxscript_commands_ax_renderview_commands_html
 import os
+
 from pymxs import runtime as rt
-from openpype.hosts.max.api.lib import (
-    get_current_renderer,
-    get_default_render_folder
-)
-from openpype.pipeline.context_tools import get_current_project_asset
-from openpype.settings import get_project_settings
+
+from openpype.hosts.max.api.lib import get_current_renderer
 from openpype.pipeline import legacy_io
+from openpype.settings import get_project_settings
 
 
 class RenderProducts(object):
 
     def __init__(self, project_settings=None):
-        self._project_settings = project_settings
-        if not self._project_settings:
-            self._project_settings = get_project_settings(
-                legacy_io.Session["AVALON_PROJECT"]
-            )
+        self._project_settings = project_settings or get_project_settings(
+            legacy_io.Session["AVALON_PROJECT"])
+
+    def get_beauty(self, container):
+        render_dir = os.path.dirname(rt.rendOutputFilename)
+
+        output_file = os.path.join(render_dir, container)
 
-    def render_product(self, container):
-        folder = rt.maxFilePath
-        file = rt.maxFileName
-        folder = folder.replace("\\", "/")
         setting = self._project_settings
-        render_folder = get_default_render_folder(setting)
-        filename, ext = os.path.splitext(file)
+        img_fmt = setting["max"]["RenderSettings"]["image_format"]   # noqa
 
-        output_file = os.path.join(folder,
-                                   render_folder,
-                                   filename,
+        start_frame = int(rt.rendStart)
+        end_frame = int(rt.rendEnd) + 1
+
+        return {
+            "beauty": self.get_expected_beauty(
+                output_file, start_frame, end_frame, img_fmt
+            )
+        }
+
+    def get_aovs(self, container):
+        render_dir = os.path.dirname(rt.rendOutputFilename)
+
+        output_file = os.path.join(render_dir,
                                    container)
 
-        context = get_current_project_asset()
-        # TODO: change the frame range follows the current render setting
-        startFrame = int(rt.rendStart)
-        endFrame = int(rt.rendEnd) + 1
-
-        img_fmt = self._project_settings["max"]["RenderSettings"]["image_format"]   # noqa
-        full_render_list = self.beauty_render_product(output_file,
-                                                      startFrame,
-                                                      endFrame,
-                                                      img_fmt)
+        setting = self._project_settings
+        img_fmt = setting["max"]["RenderSettings"]["image_format"]   # noqa
 
+        start_frame = int(rt.rendStart)
+        end_frame = int(rt.rendEnd) + 1
         renderer_class = get_current_renderer()
         renderer = str(renderer_class).split(":")[0]
-
-
-        if renderer == "VUE_File_Renderer":
-            return full_render_list
+        render_dict = {}
 
         if renderer in [
             "ART_Renderer",
-            "Redshift_Renderer",
             "V_Ray_6_Hotfix_3",
             "V_Ray_GPU_6_Hotfix_3",
             "Default_Scanline_Renderer",
             "Quicksilver_Hardware_Renderer",
         ]:
-            render_elem_list = self.render_elements_product(output_file,
-                                                            startFrame,
-                                                            endFrame,
-                                                            img_fmt)
-            if render_elem_list:
-                full_render_list.extend(iter(render_elem_list))
-            return full_render_list
+            render_name = self.get_render_elements_name()
+            if render_name:
+                for name in render_name:
+                    render_dict.update({
+                        name: self.get_expected_render_elements(
+                            output_file, name, start_frame,
+                            end_frame, img_fmt)
+                    })
+        elif renderer == "Redshift_Renderer":
+            render_name = self.get_render_elements_name()
+            if render_name:
+                rs_aov_files = rt.Execute("renderers.current.separateAovFiles")
+                # this doesn't work, always returns False
+                # rs_AovFiles = rt.RedShift_Renderer().separateAovFiles
+                if img_fmt == "exr" and not rs_aov_files:
+                    for name in render_name:
+                        if name == "RsCryptomatte":
+                            render_dict.update({
+                                name: self.get_expected_render_elements(
+                                    output_file, name, start_frame,
+                                    end_frame, img_fmt)
+                            })
+                else:
+                    for name in render_name:
+                        render_dict.update({
+                            name: self.get_expected_render_elements(
+                                output_file, name, start_frame,
+                                end_frame, img_fmt)
+                        })
 
-        if renderer == "Arnold":
-            aov_list = self.arnold_render_product(output_file,
-                                                  startFrame,
-                                                  endFrame,
-                                                  img_fmt)
-            if aov_list:
-                full_render_list.extend(iter(aov_list))
-            return full_render_list
+        elif renderer == "Arnold":
+            render_name = self.get_arnold_product_name()
+            if render_name:
+                for name in render_name:
+                    render_dict.update({
+                        name: self.get_expected_arnold_product(
+                            output_file, name, start_frame, end_frame, img_fmt)
+                    })
+        elif renderer in [
+            "V_Ray_6_Hotfix_3",
+            "V_Ray_GPU_6_Hotfix_3"
+        ]:
+            if img_fmt != "exr":
+                render_name = self.get_render_elements_name()
+                if render_name:
+                    for name in render_name:
+                        render_dict.update({
+                            name: self.get_expected_render_elements(
+                                output_file, name, start_frame,
+                                end_frame, img_fmt)      # noqa
+                        })
 
-    def beauty_render_product(self, folder, startFrame, endFrame, fmt):
+        return render_dict
+
+    def get_expected_beauty(self, folder, start_frame, end_frame, fmt):
         beauty_frame_range = []
-        for f in range(startFrame, endFrame):
-            beauty_output = f"{folder}.{f}.{fmt}"
+        for f in range(start_frame, end_frame):
+            frame = "%04d" % f
+            beauty_output = f"{folder}.{frame}.{fmt}"
             beauty_output = beauty_output.replace("\\", "/")
             beauty_frame_range.append(beauty_output)
 
         return beauty_frame_range
 
-    # TODO: Get the arnold render product
-    def arnold_render_product(self, folder, startFrame, endFrame, fmt):
-        """Get all the Arnold AOVs"""
-        aovs = []
+    def get_arnold_product_name(self):
+        """Get all the Arnold AOVs name"""
+        aov_name = []
 
         amw = rt.MaxToAOps.AOVsManagerWindow()
         aov_mgr = rt.renderers.current.AOVManager
@@ -100,34 +132,51 @@ class RenderProducts(object):
             return
         for i in range(aov_group_num):
             # get the specific AOV group
-            for aov in aov_mgr.drivers[i].aov_list:
-                for f in range(startFrame, endFrame):
-                    render_element = f"{folder}_{aov.name}.{f}.{fmt}"
-                    render_element = render_element.replace("\\", "/")
-                    aovs.append(render_element)
-
+            aov_name.extend(aov.name for aov in aov_mgr.drivers[i].aov_list)
         # close the AOVs manager window
         amw.close()
 
-        return aovs
+        return aov_name
 
-    def render_elements_product(self, folder, startFrame, endFrame, fmt):
-        """Get all the render element output files. """
-        render_dirname = []
+    def get_expected_arnold_product(self, folder, name,
+                                    start_frame, end_frame, fmt):
+        """Get all the expected Arnold AOVs"""
+        aov_list = []
+        for f in range(start_frame, end_frame):
+            frame = "%04d" % f
+            render_element = f"{folder}_{name}.{frame}.{fmt}"
+            render_element = render_element.replace("\\", "/")
+            aov_list.append(render_element)
 
-        render_elem = rt.MaxOps.GetCurRenderElementMgr()
+        return aov_list
+
+    def get_render_elements_name(self):
+        """Get all the render element names for general """
+        render_name = []
+        render_elem = rt.maxOps.GetCurRenderElementMgr()
         render_elem_num = render_elem.NumRenderElements()
+        if render_elem_num < 1:
+            return
         # get render elements from the renders
         for i in range(render_elem_num):
             renderlayer_name = render_elem.GetRenderElement(i)
-            target, renderpass = str(renderlayer_name).split(":")
             if renderlayer_name.enabled:
-                for f in range(startFrame, endFrame):
-                    render_element = f"{folder}_{renderpass}.{f}.{fmt}"
-                    render_element = render_element.replace("\\", "/")
-                    render_dirname.append(render_element)
+                target, renderpass = str(renderlayer_name).split(":")
+                render_name.append(renderpass)
 
-        return render_dirname
+        return render_name
+
+    def get_expected_render_elements(self, folder, name,
+                                     start_frame, end_frame, fmt):
+        """Get all the expected render element output files. """
+        render_elements = []
+        for f in range(start_frame, end_frame):
+            frame = "%04d" % f
+            render_element = f"{folder}_{name}.{frame}.{fmt}"
+            render_element = render_element.replace("\\", "/")
+            render_elements.append(render_element)
+
+        return render_elements
 
     def image_format(self):
         return self._project_settings["max"]["RenderSettings"]["image_format"]  # noqa

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

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+"""Creator plugin for creating camera."""
+from openpype.hosts.max.api import plugin
+from openpype.pipeline import CreatedInstance
+
+
+class CreateRedshiftProxy(plugin.MaxCreator):
+    identifier = "io.openpype.creators.max.redshiftproxy"
+    label = "Redshift Proxy"
+    family = "redshiftproxy"
+    icon = "gear"
+
+    def create(self, subset_name, instance_data, pre_create_data):
+
+        _ = super(CreateRedshiftProxy, self).create(
+            subset_name,
+            instance_data,
+            pre_create_data)  # type: CreatedInstance

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

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 """Creator plugin for creating camera."""
+import os
 from openpype.hosts.max.api import plugin
 from openpype.hosts.max.api.lib_rendersettings import RenderSettings
 
@@ -12,8 +13,13 @@ class CreateRender(plugin.MaxCreator):
     icon = "gear"
 
     def create(self, subset_name, instance_data, pre_create_data):
-        """Plugin entry point."""
-        instance = super().create(
+        from pymxs import runtime as rt
+        sel_obj = list(rt.selection)
+        file = rt.maxFileName
+        filename, _ = os.path.splitext(file)
+        instance_data["AssetName"] = filename
+
+        instance = super(CreateRender, self).create(
             subset_name,
             instance_data,
             pre_create_data)

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

@@ -1,9 +1,8 @@
-
 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
 from openpype.hosts.max.api.lib import maintained_selection
-from openpype.hosts.max.api.pipeline import containerise
 from openpype.pipeline import get_representation_path, load
 
 
@@ -23,25 +22,21 @@ class ModelAbcLoader(load.LoaderPlugin):
         file_path = os.path.normpath(self.fname)
 
         abc_before = {
-            c for c in rt.RootNode.Children
-            if rt.ClassOf(c) == rt.AlembicContainer
+            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)
+        rt.AlembicImport.ImportToRoot = False
+        rt.AlembicImport.CustomAttributes = True
+        rt.AlembicImport.UVs = True
+        rt.AlembicImport.VertexColors = True
+        rt.importFile(file_path, rt.name("noPrompt"))
 
         abc_after = {
-            c for c in rt.RootNode.Children
-            if rt.ClassOf(c) == rt.AlembicContainer
+            c
+            for c in rt.rootNode.Children
+            if rt.classOf(c) == rt.AlembicContainer
         }
 
         # This should yield new AlembicContainer node
@@ -53,10 +48,12 @@ importFile @"{file_path}" #noPrompt
         abc_container = abc_containers.pop()
 
         return containerise(
-            name, [abc_container], context, loader=self.__class__.__name__)
+            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"])
         rt.Select(node.Children)
@@ -75,9 +72,10 @@ importFile @"{file_path}" #noPrompt
         with maintained_selection():
             rt.Select(node)
 
-        lib.imprint(container["instance_node"], {
-            "representation": str(representation["_id"])
-        })
+        lib.imprint(
+            container["instance_node"],
+            {"representation": str(representation["_id"])},
+        )
 
     def switch(self, container, representation):
         self.update(container, representation)

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

@@ -1,8 +1,8 @@
 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
 from openpype.hosts.max.api.lib import maintained_selection
-from openpype.hosts.max.api.pipeline import containerise
 from openpype.pipeline import get_representation_path, load
 
 
@@ -22,10 +22,7 @@ class FbxModelLoader(load.LoaderPlugin):
         rt.FBXImporterSetParam("Animation", False)
         rt.FBXImporterSetParam("Cameras", False)
         rt.FBXImporterSetParam("Preserveinstances", True)
-        rt.ImportFile(
-            filepath,
-            rt.Name("noPrompt"),
-            using=rt.FBXIMP)
+        rt.importFile(filepath, rt.name("noPrompt"), using=rt.FBXIMP)
 
         container = rt.GetNodeByName(name)
         if not container:
@@ -36,32 +33,29 @@ class FbxModelLoader(load.LoaderPlugin):
             selection.Parent = container
 
         return containerise(
-            name, [container], context, loader=self.__class__.__name__)
+            name, [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"])
-        rt.Select(node.Children)
-        fbx_reimport_cmd = (
-            f"""
-FBXImporterSetParam "Animation" false
-FBXImporterSetParam "Cameras" false
-FBXImporterSetParam "AxisConversionMethod" true
-FbxExporterSetParam "UpAxis" "Y"
-FbxExporterSetParam "Preserveinstances" true
+        node = rt.getNodeByName(container["instance_node"])
+        rt.select(node.Children)
 
-importFile @"{path}" #noPrompt using:FBXIMP
-        """)
-        rt.Execute(fbx_reimport_cmd)
+        rt.FBXImporterSetParam("Animation", False)
+        rt.FBXImporterSetParam("Cameras", False)
+        rt.FBXImporterSetParam("AxisConversionMethod", True)
+        rt.FBXImporterSetParam("UpAxis", "Y")
+        rt.FBXImporterSetParam("Preserveinstances", True)
+        rt.importFile(path, rt.name("noPrompt"), using=rt.FBXIMP)
 
         with maintained_selection():
             rt.Select(node)
 
-        lib.imprint(container["instance_node"], {
-            "representation": str(representation["_id"])
-        })
+        lib.imprint(
+            container["instance_node"],
+            {"representation": str(representation["_id"])},
+        )
 
     def switch(self, container, representation):
         self.update(container, representation)

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

@@ -5,6 +5,7 @@ Because of limited api, alembics can be only loaded, but not easily updated.
 
 """
 import os
+from openpype.pipeline import load, get_representation_path
 
 from openpype.hosts.max.api import lib, maintained_selection
 from openpype.hosts.max.api.pipeline import containerise
@@ -14,9 +15,7 @@ from openpype.pipeline import get_representation_path, load
 class AbcLoader(load.LoaderPlugin):
     """Alembic loader."""
 
-    families = ["camera",
-                "animation",
-                "pointcache"]
+    families = ["camera", "animation", "pointcache"]
     label = "Load Alembic"
     representations = ["abc"]
     order = -10
@@ -29,17 +28,18 @@ class AbcLoader(load.LoaderPlugin):
         file_path = os.path.normpath(self.fname)
 
         abc_before = {
-            c for c in rt.RootNode.Children
-            if rt.ClassOf(c) == rt.AlembicContainer
+            c
+            for c in rt.rootNode.Children
+            if rt.classOf(c) == rt.AlembicContainer
         }
+
         rt.AlembicImport.ImportToRoot = False
-        rt.AlembicImport.StartFrame = True
-        rt.AlembicImport.EndFrame = True
-        rt.ImportFile(file_path, rt.Name("noPrompt"))
+        rt.importFile(file_path, rt.name("noPrompt"))
 
         abc_after = {
-            c for c in rt.RootNode.Children
-            if rt.ClassOf(c) == rt.AlembicContainer
+            c
+            for c in rt.rootNode.Children
+            if rt.classOf(c) == rt.AlembicContainer
         }
 
         # This should yield new AlembicContainer node
@@ -55,7 +55,8 @@ class AbcLoader(load.LoaderPlugin):
                 cam_shape.playbackType = 2
 
         return containerise(
-            name, [abc_container], context, loader=self.__class__.__name__)
+            name, [abc_container], context, loader=self.__class__.__name__
+        )
 
     def update(self, container, representation):
         from pymxs import runtime as rt
@@ -63,9 +64,14 @@ class AbcLoader(load.LoaderPlugin):
         path = get_representation_path(representation)
         node = rt.GetNodeByName(container["instance_node"])
 
-        lib.imprint(container["instance_node"], {
-            "representation": str(representation["_id"])
-        })
+        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"])},
+        )
 
         with maintained_selection():
             rt.Select(node.Children)

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

@@ -0,0 +1,63 @@
+import os
+import clique
+
+from openpype.pipeline import (
+    load,
+    get_representation_path
+)
+from openpype.hosts.max.api.pipeline import containerise
+from openpype.hosts.max.api import lib
+
+
+class RedshiftProxyLoader(load.LoaderPlugin):
+    """Load rs files with Redshift Proxy"""
+
+    label = "Load Redshift Proxy"
+    families = ["redshiftproxy"]
+    representations = ["rs"]
+    order = -9
+    icon = "code-fork"
+    color = "white"
+
+    def load(self, context, name=None, namespace=None, data=None):
+        from pymxs import runtime as rt
+
+        filepath = self.filepath_from_context(context)
+        rs_proxy = rt.RedshiftProxy()
+        rs_proxy.file = filepath
+        files_in_folder = os.listdir(os.path.dirname(filepath))
+        collections, remainder = clique.assemble(files_in_folder)
+        if collections:
+            rs_proxy.is_sequence = True
+
+        container = rt.container()
+        container.name = name
+        rs_proxy.Parent = container
+
+        asset = rt.getNodeByName(name)
+
+        return containerise(
+            name, [asset], 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"])
+        for children in node.Children:
+            children_node = rt.getNodeByName(children.name)
+            for proxy in children_node.Children:
+                proxy.file = 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)

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

@@ -5,7 +5,8 @@ import pyblish.api
 
 from pymxs import runtime as rt
 from openpype.pipeline import get_current_asset_name
-from openpype.hosts.max.api.lib import get_max_version
+from openpype.hosts.max.api import colorspace
+from openpype.hosts.max.api.lib import get_max_version, get_current_renderer
 from openpype.hosts.max.api.lib_renderproducts import RenderProducts
 from openpype.client import get_last_version_by_subset_name
 
@@ -28,8 +29,16 @@ class CollectRender(pyblish.api.InstancePlugin):
         context.data['currentFile'] = current_file
         asset = get_current_asset_name()
 
-        render_layer_files = RenderProducts().render_product(instance.name)
+        files_by_aov = RenderProducts().get_beauty(instance.name)
         folder = folder.replace("\\", "/")
+        aovs = RenderProducts().get_aovs(instance.name)
+        files_by_aov.update(aovs)
+
+        if "expectedFiles" not in instance.data:
+            instance.data["expectedFiles"] = list()
+            instance.data["files"] = list()
+            instance.data["expectedFiles"].append(files_by_aov)
+            instance.data["files"].append(files_by_aov)
 
         img_format = RenderProducts().image_format()
         project_name = context.data["projectName"]
@@ -38,7 +47,6 @@ class CollectRender(pyblish.api.InstancePlugin):
         version_doc = get_last_version_by_subset_name(project_name,
                                                       instance.name,
                                                       asset_id)
-
         self.log.debug("version_doc: {0}".format(version_doc))
         version_int = 1
         if version_doc:
@@ -46,22 +54,42 @@ class CollectRender(pyblish.api.InstancePlugin):
 
         self.log.debug(f"Setting {version_int} to context.")
         context.data["version"] = version_int
-        # setup the plugin as 3dsmax for the internal renderer
+        # OCIO config not support in
+        # most of the 3dsmax renderers
+        # so this is currently hard coded
+        # TODO: add options for redshift/vray ocio config
+        instance.data["colorspaceConfig"] = ""
+        instance.data["colorspaceDisplay"] = "sRGB"
+        instance.data["colorspaceView"] = "ACES 1.0 SDR-video"
+        instance.data["renderProducts"] = colorspace.ARenderProduct()
+        instance.data["publishJobState"] = "Suspended"
+        instance.data["attachTo"] = []
+        renderer_class = get_current_renderer()
+        renderer = str(renderer_class).split(":")[0]
+        # also need to get the render dir for conversion
         data = {
-            "subset": instance.name,
             "asset": asset,
+            "subset": str(instance.name),
             "publish": True,
             "maxversion": str(get_max_version()),
             "imageFormat": img_format,
             "family": 'maxrender',
             "families": ['maxrender'],
+            "renderer": renderer,
             "source": filepath,
-            "expectedFiles": render_layer_files,
             "plugin": "3dsmax",
             "frameStart": int(rt.rendStart),
             "frameEnd": int(rt.rendEnd),
             "version": version_int,
             "farm": True
         }
-        self.log.info("data: {0}".format(data))
         instance.data.update(data)
+
+        # TODO: this should be unified with maya and its "multipart" flag
+        #       on instance.
+        if renderer == "Redshift_Renderer":
+            instance.data.update(
+                {"separateAovFiles": rt.Execute(
+                    "renderers.current.separateAovFiles")})
+
+        self.log.info("data: {0}".format(data))

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

@@ -0,0 +1,62 @@
+import os
+import pyblish.api
+from openpype.pipeline import publish
+from pymxs import runtime as rt
+from openpype.hosts.max.api import maintained_selection
+
+
+class ExtractRedshiftProxy(publish.Extractor):
+    """
+    Extract Redshift Proxy with rsProxy
+    """
+
+    order = pyblish.api.ExtractorOrder - 0.1
+    label = "Extract RedShift Proxy"
+    hosts = ["max"]
+    families = ["redshiftproxy"]
+
+    def process(self, instance):
+        container = instance.data["instance_node"]
+        start = int(instance.context.data.get("frameStart"))
+        end = int(instance.context.data.get("frameEnd"))
+
+        self.log.info("Extracting Redshift Proxy...")
+        stagingdir = self.staging_dir(instance)
+        rs_filename = "{name}.rs".format(**instance.data)
+        rs_filepath = os.path.join(stagingdir, rs_filename)
+        rs_filepath = rs_filepath.replace("\\", "/")
+
+        rs_filenames = self.get_rsfiles(instance, start, end)
+
+        with maintained_selection():
+            # select and export
+            con = rt.getNodeByName(container)
+            rt.select(con.Children)
+            # Redshift rsProxy command
+            # rsProxy fp selected compress connectivity startFrame endFrame
+            # camera warnExisting transformPivotToOrigin
+            rt.rsProxy(rs_filepath, 1, 0, 0, start, end, 0, 1, 1)
+
+        self.log.info("Performing Extraction ...")
+
+        if "representations" not in instance.data:
+            instance.data["representations"] = []
+
+        representation = {
+            'name': 'rs',
+            'ext': 'rs',
+            'files': rs_filenames if len(rs_filenames) > 1 else rs_filenames[0],    # noqa
+            "stagingDir": stagingdir,
+        }
+        instance.data["representations"].append(representation)
+        self.log.info("Extracted instance '%s' to: %s" % (instance.name,
+                                                          stagingdir))
+
+    def get_rsfiles(self, instance, startFrame, endFrame):
+        rs_filenames = []
+        rs_name = instance.data["name"]
+        for frame in range(startFrame, endFrame + 1):
+            rs_filename = "%s.%04d.rs" % (rs_name, frame)
+            rs_filenames.append(rs_filename)
+
+        return rs_filenames

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

@@ -0,0 +1,21 @@
+import pyblish.api
+import os
+
+
+class SaveCurrentScene(pyblish.api.ContextPlugin):
+    """Save current scene
+
+    """
+
+    label = "Save current file"
+    order = pyblish.api.ExtractorOrder - 0.49
+    hosts = ["max"]
+    families = ["maxrender", "workfile"]
+
+    def process(self, context):
+        from pymxs import runtime as rt
+        folder = rt.maxFilePath
+        file = rt.maxFileName
+        current = os.path.join(folder, file)
+        assert context.data["currentFile"] == current
+        rt.saveMaxFile(current)

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

@@ -0,0 +1,43 @@
+import os
+import pyblish.api
+from pymxs import runtime as rt
+from openpype.pipeline.publish import (
+    RepairAction,
+    ValidateContentsOrder,
+    PublishValidationError,
+    OptionalPyblishPluginMixin
+)
+from openpype.hosts.max.api.lib_rendersettings import RenderSettings
+
+
+class ValidateDeadlinePublish(pyblish.api.InstancePlugin,
+                              OptionalPyblishPluginMixin):
+    """Validates Render File Directory is
+    not the same in every submission
+    """
+
+    order = ValidateContentsOrder
+    families = ["maxrender"]
+    hosts = ["max"]
+    label = "Render Output for Deadline"
+    optional = True
+    actions = [RepairAction]
+
+    def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+        file = rt.maxFileName
+        filename, ext = os.path.splitext(file)
+        if filename not in rt.rendOutputFilename:
+            raise PublishValidationError(
+                "Render output folder "
+                "doesn't match the max scene name! "
+                "Use Repair action to "
+                "fix the folder file path.."
+            )
+
+    @classmethod
+    def repair(cls, instance):
+        container = instance.data.get("instance_node")
+        RenderSettings().render_output(container)
+        cls.log.debug("Reset the render output folder...")

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

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+import pyblish.api
+from openpype.pipeline import PublishValidationError
+from pymxs import runtime as rt
+from openpype.pipeline.publish import RepairAction
+from openpype.hosts.max.api.lib import get_current_renderer
+
+
+class ValidateRendererRedshiftProxy(pyblish.api.InstancePlugin):
+    """
+    Validates Redshift as the current renderer for creating
+    Redshift Proxy
+    """
+
+    order = pyblish.api.ValidatorOrder
+    families = ["redshiftproxy"]
+    hosts = ["max"]
+    label = "Redshift Renderer"
+    actions = [RepairAction]
+
+    def process(self, instance):
+        invalid = self.get_redshift_renderer(instance)
+        if invalid:
+            raise PublishValidationError("Please install Redshift for 3dsMax"
+                                         " before using the Redshift proxy instance")   # noqa
+        invalid = self.get_current_renderer(instance)
+        if invalid:
+            raise PublishValidationError("The Redshift proxy extraction"
+                                         "discontinued since the current renderer is not Redshift")  # noqa
+
+    def get_redshift_renderer(self, instance):
+        invalid = list()
+        max_renderers_list = str(rt.RendererClass.classes)
+        if "Redshift_Renderer" not in max_renderers_list:
+            invalid.append(max_renderers_list)
+
+        return invalid
+
+    def get_current_renderer(self, instance):
+        invalid = list()
+        renderer_class = get_current_renderer()
+        current_renderer = str(renderer_class).split(":")[0]
+        if current_renderer != "Redshift_Renderer":
+            invalid.append(current_renderer)
+
+        return invalid
+
+    @classmethod
+    def repair(cls, instance):
+        for Renderer in rt.RendererClass.classes:
+            renderer = Renderer()
+            if "Redshift_Renderer" in str(renderer):
+                rt.renderers.production = renderer
+                break