Add custom frame range support for local rendering

client/ayon_max/api/lib.py

@@ -1060,3 +1060,58 @@ def build_general_output_filename(
         ext = match.group("ext")
         filename = f"{name}_{element}..{ext}"
     return os.path.join(output_dir, filename)
+
+
+def get_expected_frames(instance: pyblish.api.Instance) -> list[int]:
+    """Get expected frames from the instance.
+
+    Args:
+        instance (pyblish.api.Instance): The Pyblish instance.
+
+    Returns:
+        list[int]: A list containing the expected frames.
+    """
+    def parse_frame_range(frame_str: str) -> list[int]:
+        """Parse a frame range string into a list of frames.
+
+        Args:
+            frame_str (str): The frame range string.
+
+        Returns:
+            list[int]: A list of frames.
+        """
+        frames = []
+        for part in frame_str.split(","):
+            part = part.strip()
+            if not part:
+                continue
+
+            if "-" in part:
+                start_end = part.split("-", 1)
+                if len(start_end) != 2 or not start_end[0] or not start_end[1]:
+                    raise ValueError(
+                        f"Invalid frame range segment: '{part}'"
+                    )
+
+                start, end = map(int, start_end)
+                if start > end:
+                    raise ValueError(
+                        f"Frame range start must be less than or equal "
+                        f"to end: '{part}'"
+                    )
+                frames.extend(range(start, end + 1))
+            else:
+                frames.append(int(part))
+
+        if not frames:
+            raise ValueError(
+                f"No valid frames could be parsed from '{frame_str}'"
+            )
+        return frames
+
+    frames = instance.data.get("customFrames", "")
+    if frames:
+        return parse_frame_range(frames)
+    frame_start = int(rt.rendStart)
+    frame_end = int(rt.rendEnd)
+    return list(range(frame_start, frame_end + 1))

client/ayon_max/api/lib_renderproducts.py

@@ -38,7 +38,7 @@ def __init__(self, project_settings: Dict[str, Any] = None):
                 get_current_project_name()
             )
 
-    def get_render_products(self) -> Dict[str, list[str]]:
+    def get_render_products(self, frame_range: list[int]) -> Dict[str, list[str]]:
         """Get render output file paths for the current scene.
 
         Handles both beauty and AOV extraction with shared setup logic.
@@ -50,8 +50,7 @@ def get_render_products(self) -> Dict[str, list[str]]:
                 (e.g., "Cryptomatte", "Alpha").
         """
         extension = self.image_format()
-        start_frame = int(rt.rendStart)
-        end_frame = int(rt.rendEnd)
+
         # todo: Support Custom Frames sequences 0,5-10,100-120
         # we can add filtering frames list to get expected frames list
         # instead of using start and end frame
@@ -60,7 +59,7 @@ def get_render_products(self) -> Dict[str, list[str]]:
         render_dict: Dict[str, list[str]] = {}
 
         # Always add beauty pass
-        render_dict["beauty"] = self.get_expected_beauty(start_frame, end_frame, extension)
+        render_dict["beauty"] = self.get_expected_beauty(frame_range, extension)
 
         # Optionally add AOVs
         renderer = get_current_renderer()
@@ -70,8 +69,7 @@ def get_render_products(self) -> Dict[str, list[str]]:
             for aov_name, aov_filepath in render_elements:
                 aov_expected_files = self.get_expected_files(
                     aov_filepath,
-                    start_frame,
-                    end_frame,
+                    frame_range,
                     aov_name,
                     renderer_name
                 )
@@ -80,7 +78,7 @@ def get_render_products(self) -> Dict[str, list[str]]:
         return render_dict
 
     def get_multiple_render_products(
-            self, outputs: list[str], cameras: list[str]
+            self, outputs: list[str], cameras: list[str], frame_range: list[int]
     ) -> Dict[str, list[str]]:
         """Get render output file paths for multiple cameras.
 
@@ -105,11 +103,9 @@ def get_multiple_render_products(
             filename, ext = os.path.splitext(output)
             filename = filename.replace(".", "")
             ext = ext.replace(".", "")
-            start_frame = int(rt.rendStart)
-            end_frame = int(rt.rendEnd)
 
             # Always add beauty pass
-            beauty_files = self.get_expected_beauty(start_frame, end_frame, ext)
+            beauty_files = self.get_expected_beauty(frame_range, ext)
             render_output_frames[f"{camera}_beauty"] = beauty_files
 
             # Add AOVs
@@ -118,8 +114,7 @@ def get_multiple_render_products(
                 for aov_name, aov_filepath in render_elements:
                     aov_expected_files = self.get_expected_files(
                         aov_filepath,
-                        start_frame,
-                        end_frame,
+                        frame_range,
                         aov_name,
                         renderer_name
                     )
@@ -128,13 +123,13 @@ def get_multiple_render_products(
         return render_output_frames
 
     def get_expected_beauty(
-            self, start_frame: int, end_frame: int, extension: str
+            self, frame_range: list[int], extension: str
     ) -> list[str]:
         """Get expected beauty render output file paths for each frame.
 
         Args:
-            start_frame (int): The starting frame number.
-            end_frame (int): The ending frame number.
+            frame_range (list[int]): The frame range to generate expected
+                output file paths for.
             extension (str): The file extension for the output files.
 
         Returns:
@@ -151,8 +146,7 @@ def get_expected_beauty(
 
         return self.get_expected_files(
             output_path,
-            start_frame,
-            end_frame,
+            frame_range,
             "",
             renderer_name
         )
@@ -258,17 +252,15 @@ def get_arnold_render_output(self, arnold_renderer: Any, extension: str) -> str:
     def get_expected_files(
         self,
         filepath: str,
-        start_frame: int,
-        end_frame: int,
+        frame_range: list[int],
         aov_name: str,
         renderer_name: str,
     ) -> list[str]:
         """Get expected files
 
         Args:
             filepath (str): filepath of the render output.
-            start_frame (int): start frame of the render sequence.
-            end_frame (int): end frame of the render sequence.
+            frame_range (list[int]): range of frames of the render sequence.
             aov_name (str): name of the AOV.
             renderer_name (str): name of the renderer.
 
@@ -281,7 +273,7 @@ def get_expected_files(
         name, ext = os.path.splitext(filename)
         name = name.lstrip(".")
         aov_name = aov_name.strip()
-        for frame in range(start_frame, end_frame + 1):
+        for frame in frame_range:
             aov_filename =  f"{name}.{frame:04d}{ext}"
             expected_aov = os.path.join(directory, aov_filename)
             if aov_name and renderer_name.startswith("V_Ray_"):

client/ayon_max/plugins/publish/collect_frame_range.py

@@ -1,12 +1,13 @@
 # -*- coding: utf-8 -*-
 import pyblish.api
 from pymxs import runtime as rt
+from ayon_max.api.lib import get_expected_frames
 
 
 class CollectFrameRange(pyblish.api.InstancePlugin):
     """Collect Frame Range."""
 
-    order = pyblish.api.CollectorOrder + 0.011
+    order = pyblish.api.CollectorOrder + 0.019
     label = "Collect Frame Range"
     hosts = ['max']
     families = ["camera", "maxrender",
@@ -16,8 +17,10 @@ class CollectFrameRange(pyblish.api.InstancePlugin):
 
     def process(self, instance):
         if instance.data["productBaseType"] == "maxrender":
-            instance.data["frameStartHandle"] = int(rt.rendStart)
-            instance.data["frameEndHandle"] = int(rt.rendEnd)
+            frame_range = get_expected_frames(instance)
+            instance.data["frameStartHandle"] = min(frame_range)
+            instance.data["frameEndHandle"] = max(frame_range)
+            instance.data["expectedFrameRange"] = frame_range
 
         elif instance.data["productBaseType"] in {"tycache", "tyspline"}:
             operator = instance.data["operator"]

client/ayon_max/plugins/publish/collect_render.py

@@ -60,7 +60,8 @@ def process(self, instance):
         renderer_name = str(renderer).split(":")[0]
         renderproducts = RenderProducts(context.data["project_settings"])
         img_format = renderproducts.image_format()
-        files_by_aov: Dict[str, list[str]] = renderproducts.get_render_products()
+        expected_frames = instance.data.get("expectedFrameRange", [])
+        files_by_aov: Dict[str, list[str]] = renderproducts.get_render_products(expected_frames)
 
 
         camera = rt.viewport.GetCamera()
@@ -94,7 +95,7 @@ def process(self, instance):
             instance.data["cameras"] = sel_cam
 
             files_by_aov = renderproducts.get_multiple_render_products(
-                outputs, sel_cam
+                outputs, sel_cam, expected_frames
             )
 
         if "expectedFiles" not in instance.data:

client/ayon_max/plugins/publish/extract_render.py

@@ -37,7 +37,9 @@ def process(self, instance):
                 if camera else rt.viewport.GetCamera()
             )
 
-            for frame in range(int(rt.rendStart), int(rt.rendEnd) + 1):
+            was_cancelled = rt.Name('wasCancelled')
+            was_cancelled.value = False
+            for frame in instance.data["expectedFrameRange"]:
                 _, cancelled = rt.render(
                     frame=frame,
                     vfb=False,
@@ -46,8 +48,7 @@ def process(self, instance):
                 )
                 if cancelled:
                     raise KnownPublishError(f"Render cancelled at frame {frame}.")
-
-                self.log.debug("Local render extraction completed.")
+            self.log.debug("Local render extraction completed.")
         else:
             self.log.debug(
                 "Local render extraction for multi-camera is already "