7669 sub sequences (#13)

Render shots which are a sub-sequence of another sequence in the context of the parent sequence to ensure frame ranges and other values which are part of the edit are accurate.
Propose to render shots from all the sequences they are part of.

Author: gplsteph

hooks/tk-multi-publish2/basic/collector.py

@@ -2,9 +2,18 @@
 # This file has been modified by Epic Games, Inc. and is subject to the license
 # file included in this repository.
 
-import sgtk
+from collections import namedtuple, defaultdict
+import copy
 import os
 
+import unreal
+
+import sgtk
+
+# A named tuple to store LevelSequence edits: the sequence/track/section
+# the edit is in.
+SequenceEdit = namedtuple("SequenceEdit", ["sequence", "track", "section"])
+
 
 HookBaseClass = sgtk.get_hook_baseclass()
 
@@ -129,26 +138,170 @@ def collect_current_session(self, settings, parent_item):
 
         return session_item
 
+    def create_asset_item(self, parent_item, asset_path, asset_type, asset_name, display_name=None):
+        """
+        Create an unreal item under the given parent item.
+
+        :param asset_path: The unreal asset path, as a string.
+        :param asset_type: The unreal asset type, as a string.
+        :param asset_name: The unreal asset name, as a string.
+        :param display_name: Optional display name for the item.
+        :returns: The created item.
+        """
+        item_type = "unreal.asset.%s" % asset_type
+        asset_item = parent_item.create_item(
+            item_type,  # Include the asset type for the publish plugin to use
+            asset_type,  # Display type
+            display_name or asset_name,  # Display name of item instance
+        )
+
+        # Set asset properties which can be used by publish plugins
+        asset_item.properties["asset_path"] = asset_path
+        asset_item.properties["asset_name"] = asset_name
+        asset_item.properties["asset_type"] = asset_type
+        return asset_item
+
     def collect_selected_assets(self, parent_item):
         """
         Creates items for assets selected in Unreal.
 
         :param parent_item: Parent Item instance
         """
         unreal_sg = sgtk.platform.current_engine().unreal_sg_engine
+        sequence_edits = None
         # Iterate through the selected assets and get their info and add them as items to be published
         for asset in unreal_sg.selected_assets:
-            asset_name = str(asset.asset_name)
-            asset_type = str(asset.asset_class)
-
-            item_type = "unreal.asset." + asset_type
-            asset_item = parent_item.create_item(
-                item_type,     # Include the asset type for the publish plugin to use
-                asset_type,    # display type
-                asset_name     # display name of item instance
+            if asset.asset_class == "LevelSequence":
+                if sequence_edits is None:
+                    sequence_edits = self.retrieve_sequence_edits()
+                self.collect_level_sequence(parent_item, asset, sequence_edits)
+            else:
+                self.create_asset_item(
+                    parent_item,
+                    # :class:`Name` instances, we cast them to strings otherwise
+                    # string operations fail down the line..
+                    "%s" % asset.object_path,
+                    "%s" % asset.asset_class,
+                    "%s" % asset.asset_name,
+                )
+
+    def get_all_paths_from_sequence(self, level_sequence, sequence_edits, visited=None):
+        """
+        Retrieve all edit paths from the given Level Sequence to top Level Sequences.
+
+        Recursively explore the sequence edits, stop the recursion when a Level
+        Sequence which is not a sub-sequence of another is reached.
+
+        Lists of Level Sequences are returned, where each list contains all the
+        the Level Sequences to traverse to reach the top Level Sequence from the
+        starting Level Sequence.
+
+        For example if a master Level Sequence contains some `Seq_<seq number>`
+        sequences and each of them contains shots like `Shot_<seq number>_<shot number>`,
+        a path for Shot_001_010 would be `[Shot_001_010, Seq_001, Master sequence]`.
+
+        If an alternate Cut is maintained with another master level Sequence, both
+        paths would be detected and returned by this method, e.g.
+        `[[Shot_001_010, Seq_001, Master sequence], [Shot_001_010, Seq_001, Master sequence 2]]`
+
+        Maintain a list of visited Level Sequences to detect cycles.
+
+        :param level_sequence: A :class:`unreal.LevelSequence` instance.
+        :param sequence_edits: A dictionary with  :class:`unreal.LevelSequence as keys and
+                                              lists of :class:`SequenceEdit` as values.
+        :param visited: A list of :class:`unreal.LevelSequence` instances, populated
+                        as nodes are visited.
+        :returns: A list of lists of Level Sequences.
+        """
+        if not visited:
+            visited = []
+        visited.append(level_sequence)
+        self.logger.info("Treating %s" % level_sequence.get_name())
+        if not sequence_edits[level_sequence]:
+            # No parent, return a list with a single entry with the current
+            # sequence
+            return [[level_sequence]]
+
+        all_paths = []
+        # Loop over parents get all paths starting from them
+        for edit in sequence_edits[level_sequence]:
+            if edit.sequence in visited:
+                self.logger.warning(
+                    "Detected a cycle in edits path %s to %s" % (
+                        "->".join(visited), edit.sequence
+                    )
+                )
+            else:
+                # Get paths from the parent and prepend the current sequence
+                # to them.
+                for edit_path in self.get_all_paths_from_sequence(
+                    edit.sequence,
+                    sequence_edits,
+                    copy.copy(visited),  # Each visit needs its own stack
+                ):
+                    self.logger.info("Got %s from %s" % (edit_path, edit.sequence.get_name()))
+                    all_paths.append([level_sequence] + edit_path)
+        return all_paths
+
+    def collect_level_sequence(self, parent_item, asset, sequence_edits):
+        """
+        Collect the items for the given Level Sequence asset.
+
+        Multiple items can be collected for a given Level Sequence if it appears
+        in multiple edits.
+
+        :param parent_item: Parent Item instance.
+        :param asset: An Unreal LevelSequence asset.
+        :param sequence_edits: A dictionary with  :class:`unreal.LevelSequence as keys and
+                                              lists of :class:`SequenceEdit` as values.
+        """
+        level_sequence = unreal.load_asset(asset.object_path)
+        for edits_path in self.get_all_paths_from_sequence(level_sequence, sequence_edits):
+            # Reverse the path to have it from top master sequence to the shot.
+            edits_path.reverse()
+            self.logger.info("Collected %s" % [x.get_name() for x in edits_path])
+            if len(edits_path) > 1:
+                display_name = "%s (%s)" % (edits_path[0].get_name(), edits_path[-1].get_name())
+            else:
+                display_name = edits_path[0].get_name()
+            item = self.create_asset_item(
+                parent_item,
+                edits_path[0].get_path_name(),
+                "LevelSequence",
+                edits_path[0].get_name(),
+                display_name,
             )
+            # Store the edits on the item so we can leverage them later when
+            # publishing.
+            item.properties["edits_path"] = edits_path
 
-            # Asset properties that can be used by publish plugins
-            asset_item.properties["asset_path"] = asset.object_path
-            asset_item.properties["asset_name"] = asset_name
-            asset_item.properties["asset_type"] = asset_type
+    def retrieve_sequence_edits(self):
+        """
+        Build a dictionary for all Level Sequences where keys are Level Sequences
+        and values the list of edits they are in.
+
+        :returns: A dictionary of :class:`unreal.LevelSequence` where values are
+                  lists of :class:`SequenceEdit`.
+        """
+        sequence_edits = defaultdict(list)
+
+        asset_helper = unreal.AssetRegistryHelpers.get_asset_registry()
+        # Retrieve all Level Sequence assets
+        all_level_sequences = asset_helper.get_assets_by_class("LevelSequence")
+        for lvseq_asset in all_level_sequences:
+            lvseq = unreal.load_asset(lvseq_asset.object_path, unreal.LevelSequence)
+            # Check shots
+            for track in lvseq.find_master_tracks_by_type(unreal.MovieSceneCinematicShotTrack):
+                for section in track.get_sections():
+                    # Not sure if you can have anything else than a MovieSceneSubSection
+                    # in a MovieSceneCinematicShotTrack, but let's be cautious here.
+                    try:
+                        # Get the Sequence attached to the section and check if
+                        # it is the one we're looking for.
+                        section_seq = section.get_sequence()
+                        sequence_edits[section_seq].append(
+                            SequenceEdit(lvseq, track, section)
+                        )
+                    except AttributeError:
+                        pass
+        return sequence_edits

hooks/tk-multi-publish2/basic/publish_movie.py

@@ -383,7 +383,20 @@ def validate(self, settings, item):
         if not asset_path or not asset_name:
             self.logger.debug("Sequence path or name not configured.")
             return False
+        # Retrieve the Level Sequences sections tree for this Level Sequence.
+        # This is needed to get frame ranges in the "edit" context.
+        edits_path = item.properties.get("edits_path")
+        if not edits_path:
+            self.logger.debug("Edits path not configured.")
+            return False
 
+        self.logger.info("Edits path %s" % edits_path)
+        item.properties["unreal_master_sequence"] = edits_path[0]
+        item.properties["unreal_shot"] = ".".join([lseq.get_name() for lseq in edits_path[1:]])
+        self.logger.info("Master sequence %s, shot %s" % (
+            item.properties["unreal_master_sequence"].get_name(),
+            item.properties["unreal_shot"] or "all shots",
+        ))
         # Get the configured publish template
         publish_template = item.properties["publish_template"]
 
@@ -415,10 +428,14 @@ def validate(self, settings, item):
             self.logger.debug("Current map must be saved first.")
             return False
 
-        # Add the map name and level sequence to fields
+        # Add the map name to fields
         world_name = unreal_map.get_name()
+        # Add the Level Sequence to fields, with the shot if any
         fields["ue_world"] = world_name
-        fields["ue_level_sequence"] = asset_name
+        if len(edits_path) > 1:
+            fields["ue_level_sequence"] = "%s_%s" % (edits_path[0].get_name(), edits_path[-1].get_name())
+        else:
+            fields["ue_level_sequence"] = edits_path[0].get_name()
 
         # Stash the level sequence and map paths in properties for the render
         item.properties["unreal_asset_path"] = asset_path
@@ -453,8 +470,12 @@ def validate(self, settings, item):
                     "Apple ProRes Media plugin must be loaded to be able to render with the Movie Render Queue, "
                     "Level Sequencer will be used for rendering."
                 )
-        else:
+
+        if not use_movie_render_queue:
+            if item.properties["unreal_shot"]:
+                raise ValueError("Rendering invidual shots for a sequence is only supported with the Movie Render Queue.")
             self.logger.info("Movie Render Queue not available, Level Sequencer will be used for rendering.")
+
         item.properties["use_movie_render_queue"] = use_movie_render_queue
         item.properties["movie_render_queue_presets"] = render_presets
         # Set the UE movie extension based on the current platform and rendering engine
@@ -554,7 +575,8 @@ def publish(self, settings, item):
                 publish_path,
                 unreal_map_path,
                 unreal_asset_path,
-                presets
+                presets,
+                item.properties.get("unreal_shot") or None,
             )
         else:
             self.logger.info("Rendering %s with the Level Sequencer." % publish_path)
@@ -763,16 +785,19 @@ def _unreal_render_sequence_with_sequencer(self, output_path, unreal_map_path, s
 
         return os.path.isfile(output_path), output_path
 
-    def _unreal_render_sequence_with_movie_queue(self, output_path, unreal_map_path, sequence_path, presets=None):
+    def _unreal_render_sequence_with_movie_queue(self, output_path, unreal_map_path, sequence_path, presets=None, shot_name=None):
         """
         Renders a given sequence in a given level with the Movie Render queue.
 
         :param str output_path: Full path to the movie to render.
         :param str unreal_map_path: Path of the Unreal map in which to run the sequence.
         :param str sequence_path: Content Browser path of sequence to render.
         :param presets: Optional :class:`unreal.MoviePipelineMasterConfig` instance to use for renderig.
+        :param str shot_name: Optional shot name to render a single shot from this sequence.
         :returns: True if a movie file was generated, False otherwise
                   string representing the path of the generated movie file
+        :raises ValueError: If a shot name is specified but can't be found in
+                            the sequence.
         """
         output_folder, output_file = os.path.split(output_path)
         movie_name = os.path.splitext(output_file)[0]
@@ -782,6 +807,19 @@ def _unreal_render_sequence_with_movie_queue(self, output_path, unreal_map_path,
         job = queue.allocate_new_job(unreal.MoviePipelineExecutorJob)
         job.sequence = unreal.SoftObjectPath(sequence_path)
         job.map = unreal.SoftObjectPath(unreal_map_path)
+        # If a specific shot was given, disable all the others.
+        if shot_name:
+            shot_found = False
+            for shot in job.shot_info:
+                if shot.outer_name != shot_name:
+                    self.logger.info("Disabling shot %s" % shot.outer_name)
+                    shot.enabled = False
+                else:
+                    shot_found = True
+            if not shot_found:
+                raise ValueError(
+                    "Unable to find shot %s in sequence %s, aborting..." % (shot_name, sequence_path)
+                )
         # Set settings from presets, if any
         if presets:
             job.set_preset_origin(presets)
@@ -823,6 +861,7 @@ def _unreal_render_sequence_with_movie_queue(self, output_path, unreal_map_path,
 
         # We can't control the name of the manifest file, so we save and then rename the file.
         _, manifest_path = unreal.MoviePipelineEditorLibrary.save_queue_to_manifest_file(queue)
+
         manifest_path = os.path.abspath(manifest_path)
         manifest_dir, manifest_file = os.path.split(manifest_path)
         f, new_path = tempfile.mkstemp(
@@ -893,6 +932,11 @@ def _unreal_render_sequence_with_movie_queue(self, output_path, unreal_map_path,
             # This need to be a path relative the to the Unreal project "Saved" folder.
             "-MoviePipelineConfig=\"%s\"" % manifest_path,
         ]
+        unreal.log(
+            "Movie Queue command-line arguments: {}".format(
+                " ".join(cmd_args)
+            )
+        )
         # Make a shallow copy of the current environment and clear some variables
         run_env = copy.copy(os.environ)
         # Prevent SG TK to try to bootstrap in the new process