mirror of
https://github.com/ynput/ayon-core.git
synced 2025-12-24 21:04:40 +01:00
resolve: sequence loading done
This commit is contained in:
Jakub Jezek
parent
5174eed16d
commit
a64ddded96
2 changed files with 62 additions and 180 deletions
|
|
@ -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):
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue