diff --git a/pype/hosts/resolve/plugin.py b/pype/hosts/resolve/plugin.py index a3c5b51fc0..a94042c03e 100644 --- a/pype/hosts/resolve/plugin.py +++ b/pype/hosts/resolve/plugin.py @@ -1,5 +1,6 @@ import re from avalon import api +import pype.api as pype from pype.hosts import resolve from avalon.vendor import qargparse from . import lib @@ -303,16 +304,6 @@ class SequenceLoader(api.Loader): ], default=0, help="Where do you want clips to be loaded?" - ), - qargparse.Choice( - "load_how", - label="How to load clips", - items=[ - "original timing", - "sequential in order" - ], - default=0, - help="Would you like to place it at orignal timing?" ) ] @@ -358,9 +349,6 @@ class ClipLoader: # try to get value from options or evaluate key value for `handles` self.with_handles = options.get("handles") or bool( options.get("handles") is True) - # try to get value from options or evaluate key value for `load_how` - self.sequencial_load = options.get("sequencially") or bool( - "Sequentially in order" in options.get("load_how", "")) # try to get value from options or evaluate key value for `load_to` self.new_timeline = options.get("newTimeline") or bool( "New timeline" in options.get("load_to", "")) @@ -384,12 +372,7 @@ class ClipLoader: else: self.active_timeline = lib.get_current_sequence() - if options.get("track"): - # if multiselection is set then use options track - self.active_track = options["track"] - else: - self.active_track = lib.get_current_track( - self.active_timeline, self.data["track_name"]) + cls.timeline = self.active_timeline def _populate_data(self): """ Gets context and convert it to self.data @@ -407,7 +390,6 @@ class ClipLoader: subset = str(repr_cntx["subset"]) representation = str(repr_cntx["representation"]) self.data["clip_name"] = "_".join([asset, subset, representation]) - self.data["track_name"] = "_".join([subset, representation]) self.data["versionData"] = self.context["version"]["data"] # gets file path file = self.fname @@ -418,10 +400,6 @@ class ClipLoader: return None self.data["path"] = file.replace("\\", "/") - # convert to hashed path - if repr_cntx.get("frame"): - self._fix_path_hashes() - # solve project bin structure path hierarchy = str("/".join(( "Loader", @@ -433,16 +411,6 @@ class ClipLoader: return True - def _fix_path_hashes(self): - """ Convert file path where it is needed padding with hashes - """ - file = self.data["path"] - if "#" not in file: - frame = self.context["representation"]["context"].get("frame") - padding = len(frame) - file = file.replace(frame, "#" * padding) - self.data["path"] = file - def _get_asset_data(self): """ Get all available asset data @@ -452,117 +420,40 @@ class ClipLoader: asset_name = self.context["representation"]["context"]["asset"] self.data["assetData"] = pype.get_asset(asset_name)["data"] - def _make_track_item(self, source_bin_item, audio=False): - """ Create track item with """ - - clip = source_bin_item.activeItem() - - # add to track as clip item - if not audio: - track_item = hiero.core.TrackItem( - self.data["clip_name"], hiero.core.TrackItem.kVideo) - else: - track_item = hiero.core.TrackItem( - self.data["clip_name"], hiero.core.TrackItem.kAudio) - - track_item.setSource(clip) - track_item.setSourceIn(self.handle_start) - track_item.setTimelineIn(self.timeline_in) - track_item.setSourceOut(self.media_duration - self.handle_end) - track_item.setTimelineOut(self.timeline_out) - track_item.setPlaybackSpeed(1) - self.active_track.addTrackItem(track_item) - - return track_item - def load(self): # create project bin for the media to be imported into self.active_bin = lib.create_bin(self.data["binPath"]) # create mediaItem in active project bin # create clip media - self.media = hiero.core.MediaSource(self.data["path"]) - self.media_duration = int(self.media.duration()) + media_pool_item = lib.create_media_pool_item( + self.data["path"], self.active_bin) + clip_property = media_pool_item.GetClipProperty() + + source_in = int(clip_property["Start"]) + source_out = int(clip_property["End"]) # get handles - self.handle_start = self.data["versionData"].get("handleStart") - self.handle_end = self.data["versionData"].get("handleEnd") - if self.handle_start is None: - self.handle_start = int(self.data["assetData"]["handleStart"]) - if self.handle_end is None: - self.handle_end = int(self.data["assetData"]["handleEnd"]) - - if self.sequencial_load: - last_track_item = lib.get_current_track_items( - track_name=self.active_track.name()) - if len(last_track_item) == 0: - last_timeline_out = 0 - else: - last_track_item = last_track_item[-1] - last_timeline_out = int(last_track_item.timelineOut()) + 1 - self.timeline_in = last_timeline_out - self.timeline_out = last_timeline_out + int( - self.data["assetData"]["clipOut"] - - self.data["assetData"]["clipIn"]) - else: - self.timeline_in = int(self.data["assetData"]["clipIn"]) - self.timeline_out = int(self.data["assetData"]["clipOut"]) - - # check if slate is included - # either in version data families or by calculating frame diff - slate_on = next( - # check iterate if slate is in families - (f for f in self.context["version"]["data"]["families"] - if "slate" in f), - # if nothing was found then use default None - # so other bool could be used - None) or bool((( - # put together duration of clip attributes - self.timeline_out - self.timeline_in + 1) \ - + self.handle_start \ - + self.handle_end - # and compare it with meda duration - ) > self.media_duration) - - print("__ slate_on: `{}`".format(slate_on)) - - # if slate is on then remove the slate frame from begining - if slate_on: - self.media_duration -= 1 - self.handle_start += 1 - - # create Clip from Media - clip = hiero.core.Clip(self.media) - clip.setName(self.data["clip_name"]) - - # add Clip to bin if not there yet - if self.data["clip_name"] not in [ - b.name() for b in self.active_bin.items()]: - bin_item = hiero.core.BinItem(clip) - self.active_bin.addItem(bin_item) - - # just make sure the clip is created - # there were some cases were hiero was not creating it - source_bin_item = None - for item in self.active_bin.items(): - if self.data["clip_name"] in item.name(): - source_bin_item = item - if not source_bin_item: - print("Problem with created Source clip: `{}`".format( - self.data["clip_name"])) + handle_start = self.data["versionData"].get("handleStart") + handle_end = self.data["versionData"].get("handleEnd") + if handle_start is None: + handle_start = int(self.data["assetData"]["handleStart"]) + if handle_end is None: + handle_end = int(self.data["assetData"]["handleEnd"]) # include handles if self.with_handles: - self.timeline_in -= self.handle_start - self.timeline_out += self.handle_end - self.handle_start = 0 - self.handle_end = 0 + source_in -= handle_start + source_out += handle_end + handle_start = 0 + handle_end = 0 # make track item from source in bin as item - track_item = self._make_track_item(source_bin_item) + timeline_item = lib.create_timeline_item( + media_pool_item, self.active_timeline, source_in, source_out) print("Loading clips: `{}`".format(self.data["clip_name"])) - return track_item + return timeline_item class Creator(api.Creator): diff --git a/pype/plugins/resolve/load/load_sequence.py b/pype/plugins/resolve/load/load_sequence.py index 489355b72d..6cbda26025 100644 --- a/pype/plugins/resolve/load/load_sequence.py +++ b/pype/plugins/resolve/load/load_sequence.py @@ -19,24 +19,23 @@ class LoadClip(resolve.SequenceLoader): # for loader multiselection timeline = None - track = None # presets - clip_color_last = "green" - clip_color = "red" + clip_color_last = "Olive" + clip_color = "Orange" def load(self, context, name, namespace, options): # in case loader uses multiselection - if self.track and self.timeline: + if self.timeline: options.update({ "timeline": self.timeline, - "track": self.track }) # load clip to timeline and get main variables - track_item = phiero.ClipLoader(self, context, **options).load() - namespace = namespace or track_item.name() + timeline_item = resolve.plugin.ClipLoader( + self, context, **options).load() + namespace = namespace or timeline_item.GetName() version = context['version'] version_data = version.get("data", {}) version_name = version.get("name", None) @@ -64,15 +63,12 @@ class LoadClip(resolve.SequenceLoader): }) # update color of clip regarding the version order - self.set_item_color(track_item, version) - - # deal with multiselection - self.multiselection(track_item) + self.set_item_color(timeline_item, version) self.log.info("Loader done: `{}`".format(name)) return resolve.containerise( - track_item, + timeline_item, name, namespace, context, self.__class__.__name__, data_imprint) @@ -87,7 +83,7 @@ class LoadClip(resolve.SequenceLoader): # load clip to timeline and get main variables name = container['name'] namespace = container['namespace'] - track_item = resolve.get_track_item_by_name(namespace) + timeline_item = resolve.lib.get_pype_track_item_by_name(namespace) version = io.find_one({ "type": "version", "_id": representation["parent"] @@ -98,43 +94,38 @@ class LoadClip(resolve.SequenceLoader): object_name = "{}_{}".format(name, namespace) file = api.get_representation_path(representation).replace("\\", "/") - # reconnect media to new path - track_item.source().reconnectMedia(file) - - # add additional metadata from the version to imprint Avalon knob - add_keys = [ - "frameStart", "frameEnd", "source", "author", - "fps", "handleStart", "handleEnd" - ] - - # move all version data keys to tag data - data_imprint = {} - for key in add_keys: - data_imprint.update({ - key: version_data.get(key, str(None)) - }) - - # add variables related to version context - data_imprint.update({ - "representation": str(representation["_id"]), - "version": version_name, - "colorspace": colorspace, - "objectName": object_name - }) - - # update color of clip regarding the version order - self.set_item_color(track_item, version) - - return resolve.update_container(track_item, data_imprint) + # TODO: implement update + # # reconnect media to new path + # track_item.source().reconnectMedia(file) + # + # # add additional metadata from the version to imprint Avalon knob + # add_keys = [ + # "frameStart", "frameEnd", "source", "author", + # "fps", "handleStart", "handleEnd" + # ] + # + # # move all version data keys to tag data + # data_imprint = {} + # for key in add_keys: + # data_imprint.update({ + # key: version_data.get(key, str(None)) + # }) + # + # # add variables related to version context + # data_imprint.update({ + # "representation": str(representation["_id"]), + # "version": version_name, + # "colorspace": colorspace, + # "objectName": object_name + # }) + # + # # update color of clip regarding the version order + # self.set_item_color(timeline_item, version) + # + # return resolve.set_track_item_pype_tag(timeline_item, data_imprint) @classmethod - def multiselection(cls, track_item): - if not cls.track: - cls.track = track_item.parent() - cls.sequence = cls.track.parent() - - @classmethod - def set_item_color(cls, track_item, version): + def set_item_color(cls, timeline_item, version): # define version name version_name = version.get("name", None) @@ -148,6 +139,6 @@ class LoadClip(resolve.SequenceLoader): # set clip colour if version_name == max_version: - track_item.source().binItem().setColor(cls.clip_color_last) + timeline_item.SetClipColor(cls.clip_color_last) else: - track_item.source().binItem().setColor(cls.clip_color) + timeline_item.SetClipColor(cls.clip_color)