From a8fa89a2b6b830fa379ca9be4d61f041dbafaa23 Mon Sep 17 00:00:00 2001 From: Jakub Jezek Date: Wed, 19 May 2021 17:28:08 +0200 Subject: [PATCH] Hiero: collection of soft-effects with instance creation --- .../plugins/publish/precollect_instances.py | 141 +++++++++++++++++- 1 file changed, 134 insertions(+), 7 deletions(-) diff --git a/openpype/hosts/hiero/plugins/publish/precollect_instances.py b/openpype/hosts/hiero/plugins/publish/precollect_instances.py index 8cccdec99a..6d72fa3567 100644 --- a/openpype/hosts/hiero/plugins/publish/precollect_instances.py +++ b/openpype/hosts/hiero/plugins/publish/precollect_instances.py @@ -2,6 +2,9 @@ import pyblish import openpype from openpype.hosts.hiero import api as phiero from openpype.hosts.hiero.otio import hiero_export +import hiero + +from compiler.ast import flatten # # developer reload modules from pprint import pformat @@ -14,18 +17,40 @@ class PrecollectInstances(pyblish.api.ContextPlugin): label = "Precollect Instances" hosts = ["hiero"] + audio_track_items = [] + def process(self, context): - otio_timeline = context.data["otioTimeline"] + self.otio_timeline = context.data["otioTimeline"] + selected_timeline_items = phiero.get_track_items( - selected=True, check_enabled=True, check_tagged=True) + selected=True, check_tagged=True, check_enabled=True) + + # only return enabled track items + if not selected_timeline_items: + selected_timeline_items = phiero.get_track_items( + check_enabled=True, check_tagged=True) + self.log.info( "Processing enabled track items: {}".format( selected_timeline_items)) + # add all tracks subtreck effect items to context + all_tracks = hiero.ui.activeSequence().videoTracks() + tracks_effect_items = self.collect_sub_track_items(all_tracks) + context.data["tracksEffectItems"] = tracks_effect_items + + # process all sellected timeline track items for track_item in selected_timeline_items: data = {} clip_name = track_item.name() + source_clip = track_item.source() + + # get clips subtracks and anotations + annotations = self.clip_annotations(source_clip) + subtracks = self.clip_subtrack(track_item) + self.log.debug("Annotations: {}".format(annotations)) + self.log.debug(">> Subtracks: {}".format(subtracks)) # get openpype tag data tag_data = phiero.get_track_item_pype_data(track_item) @@ -76,12 +101,15 @@ class PrecollectInstances(pyblish.api.ContextPlugin): "item": track_item, "families": families, "publish": tag_data["publish"], - "fps": context.data["fps"] + "fps": context.data["fps"], + + # clip's effect + "clipEffectItems": subtracks, + "clipAnnotations": annotations }) # otio clip data - otio_data = self.get_otio_clip_instance_data( - otio_timeline, track_item) or {} + otio_data = self.get_otio_clip_instance_data(track_item) or {} self.log.debug("__ otio_data: {}".format(pformat(otio_data))) data.update(otio_data) self.log.debug("__ data: {}".format(pformat(data))) @@ -185,6 +213,10 @@ class PrecollectInstances(pyblish.api.ContextPlugin): item = data.get("item") clip_name = item.name() + # test if any audio clips + if not self.test_any_audio(item): + return + asset = data["asset"] subset = "audioMain" @@ -215,7 +247,29 @@ class PrecollectInstances(pyblish.api.ContextPlugin): self.log.debug( "_ instance.data: {}".format(pformat(instance.data))) - def get_otio_clip_instance_data(self, otio_timeline, track_item): + def test_any_audio(self, track_item): + # collect all audio tracks to class variable + if not self.audio_track_items: + for otio_clip in self.otio_timeline.each_clip(): + if otio_clip.parent().kind != "Audio": + continue + self.audio_track_items.append(otio_clip) + + # get track item timeline range + timeline_range = self.create_otio_time_range_from_timeline_item_data( + track_item) + + # loop trough audio track items and search for overlaping clip + for otio_audio in self.audio_track_items: + parent_range = otio_audio.range_in_parent() + + # if any overaling clip found then return True + if openpype.lib.is_overlapping_otio_ranges( + parent_range, timeline_range, strict=False): + return True + + + def get_otio_clip_instance_data(self, track_item): """ Return otio objects for timeline, track and clip @@ -231,7 +285,7 @@ class PrecollectInstances(pyblish.api.ContextPlugin): ti_track_name = track_item.parent().name() timeline_range = self.create_otio_time_range_from_timeline_item_data( track_item) - for otio_clip in otio_timeline.each_clip(): + for otio_clip in self.otio_timeline.each_clip(): track_name = otio_clip.parent().name parent_range = otio_clip.range_in_parent() if ti_track_name not in track_name: @@ -258,3 +312,76 @@ class PrecollectInstances(pyblish.api.ContextPlugin): return hiero_export.create_otio_time_range( frame_start, frame_duration, fps) + + @staticmethod + def collect_sub_track_items(tracks): + """ + Returns dictionary with track index as key and list of subtracks + """ + # collect all subtrack items + sub_track_items = {} + for track in tracks: + items = track.items() + + # skip if no clips on track > need track with effect only + if items: + continue + + # skip all disabled tracks + if not track.isEnabled(): + continue + + track_index = track.trackIndex() + _sub_track_items = flatten(track.subTrackItems()) + + # continue only if any subtrack items are collected + if len(_sub_track_items) < 1: + continue + + enabled_sti = [] + # loop all found subtrack items and check if they are enabled + for _sti in _sub_track_items: + # checking if not enabled + if not _sti.isEnabled(): + continue + if isinstance(_sti, hiero.core.Annotation): + continue + # collect the subtrack item + enabled_sti.append(_sti) + + # continue only if any subtrack items are collected + if len(enabled_sti) < 1: + continue + + # add collection of subtrackitems to dict + sub_track_items[track_index] = enabled_sti + + return sub_track_items + + @staticmethod + def clip_annotations(clip): + """ + Returns list of Clip's hiero.core.Annotation + """ + annotations = [] + subTrackItems = flatten(clip.subTrackItems()) + annotations += [item for item in subTrackItems if isinstance( + item, hiero.core.Annotation)] + return annotations + + @staticmethod + def clip_subtrack(clip): + """ + Returns list of Clip's hiero.core.SubTrackItem + """ + subtracks = [] + subTrackItems = flatten(clip.parent().subTrackItems()) + for item in subTrackItems: + # avoid all anotation + if isinstance(item, hiero.core.Annotation): + continue + # # avoid all not anaibled + if not item.isEnabled(): + continue + subtracks.append(item) + return subtracks