Merge pull request #7 from GPLgithub/master

7669 sub sequences (#13)

Author: ryanmayeda

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