You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
913 lines
35 KiB
913 lines
35 KiB
using System; |
|
using System.Collections.Generic; |
|
using System.ComponentModel; |
|
using System.Linq; |
|
using System.Reflection; |
|
using UnityEditor.MemoryProfiler; |
|
using UnityEditor.SceneManagement; |
|
using UnityEngine; |
|
using UnityEngine.Playables; |
|
using UnityEngine.Timeline; |
|
using Component = UnityEngine.Component; |
|
using Object = UnityEngine.Object; |
|
|
|
namespace UnityEditor.Timeline |
|
{ |
|
static class TimelineHelpers |
|
{ |
|
static List<Type> s_SubClassesOfTrackDrawer; |
|
|
|
// check whether the exposed reference is explicitly named |
|
static bool IsExposedReferenceExplicitlyNamed(string name) |
|
{ |
|
if (string.IsNullOrEmpty(name)) |
|
return false; |
|
|
|
GUID guid; |
|
return !GUID.TryParse(name, out guid); |
|
} |
|
|
|
static string GenerateExposedReferenceName() |
|
{ |
|
return UnityEditor.GUID.Generate().ToString(); |
|
} |
|
|
|
public static void CloneExposedReferences(ScriptableObject clone, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable) |
|
{ |
|
var cloneObject = new SerializedObject(clone); |
|
SerializedProperty prop = cloneObject.GetIterator(); |
|
while (prop.Next(true)) |
|
{ |
|
if (prop.propertyType == SerializedPropertyType.ExposedReference && prop.isArray == false) |
|
{ |
|
var exposedNameProp = prop.FindPropertyRelative("exposedName"); |
|
var sourceKey = exposedNameProp.stringValue; |
|
var destKey = sourceKey; |
|
|
|
if (!IsExposedReferenceExplicitlyNamed(sourceKey)) |
|
destKey = GenerateExposedReferenceName(); |
|
|
|
exposedNameProp.stringValue = destKey; |
|
|
|
var requiresCopy = sourceTable != destTable || sourceKey != destKey; |
|
if (requiresCopy && sourceTable != null && destTable != null) |
|
{ |
|
var valid = false; |
|
var target = sourceTable.GetReferenceValue(sourceKey, out valid); |
|
if (valid && target != null) |
|
{ |
|
var existing = destTable.GetReferenceValue(destKey, out valid); |
|
if (!valid || existing != target) |
|
{ |
|
var destTableObj = destTable as UnityEngine.Object; |
|
if (destTableObj != null) |
|
TimelineUndo.PushUndo(destTableObj, L10n.Tr("Create Clip")); |
|
destTable.SetReferenceValue(destKey, target); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
cloneObject.ApplyModifiedPropertiesWithoutUndo(); |
|
} |
|
|
|
public static ScriptableObject CloneReferencedPlayableAsset(ScriptableObject original, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, Object newOwner) |
|
{ |
|
var clone = Object.Instantiate(original); |
|
SaveCloneToAsset(clone, newOwner); |
|
if (clone == null || (clone as IPlayableAsset) == null) |
|
{ |
|
throw new InvalidCastException("could not cast instantiated object into IPlayableAsset"); |
|
} |
|
CloneExposedReferences(clone, sourceTable, destTable); |
|
TimelineUndo.RegisterCreatedObjectUndo(clone, L10n.Tr("Create clip")); |
|
|
|
return clone; |
|
} |
|
|
|
static void SaveCloneToAsset(Object clone, Object newOwner) |
|
{ |
|
if (newOwner == null) |
|
return; |
|
|
|
var containerPath = AssetDatabase.GetAssetPath(newOwner); |
|
var containerAsset = AssetDatabase.LoadAssetAtPath<Object>(containerPath); |
|
if (containerAsset != null) |
|
{ |
|
TimelineCreateUtilities.SaveAssetIntoObject(clone, containerAsset); |
|
EditorUtility.SetDirty(containerAsset); |
|
} |
|
else |
|
{ |
|
clone.hideFlags |= newOwner.hideFlags & HideFlags.DontSave; |
|
} |
|
} |
|
|
|
static AnimationClip CloneAnimationClip(AnimationClip clip, Object owner) |
|
{ |
|
if (clip == null) |
|
return null; |
|
|
|
var newClip = Object.Instantiate(clip); |
|
newClip.name = AnimationTrackRecorder.GetUniqueRecordedClipName(owner, clip.name); |
|
|
|
SaveAnimClipIntoObject(newClip, owner); |
|
TimelineUndo.RegisterCreatedObjectUndo(newClip, L10n.Tr("Create clip")); |
|
|
|
return newClip; |
|
} |
|
|
|
public static TimelineClip Clone(TimelineClip clip, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, double time, PlayableAsset newOwner = null) |
|
{ |
|
if (newOwner == null) |
|
newOwner = clip.GetParentTrack(); |
|
|
|
TimelineClip newClip = DuplicateClip(clip, sourceTable, destTable, newOwner); |
|
newClip.start = time; |
|
var track = newClip.GetParentTrack(); |
|
track.SortClips(); |
|
return newClip; |
|
} |
|
|
|
// Creates a complete clone of a track and returns it. |
|
// Does not parent, or add the track to the sequence |
|
public static TrackAsset Clone(PlayableAsset parent, TrackAsset trackAsset, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, PlayableAsset assetOwner = null) |
|
{ |
|
if (trackAsset == null) |
|
return null; |
|
|
|
var timelineAsset = trackAsset.timelineAsset; |
|
if (timelineAsset == null) |
|
return null; |
|
|
|
if (assetOwner == null) |
|
assetOwner = parent; |
|
|
|
// create a duplicate, then clear the clips and subtracks |
|
var newTrack = Object.Instantiate(trackAsset); |
|
newTrack.name = trackAsset.name; |
|
newTrack.ClearClipsInternal(); |
|
newTrack.parent = parent; |
|
newTrack.ClearSubTracksInternal(); |
|
|
|
if (trackAsset.hasCurves) |
|
newTrack.curves = CloneAnimationClip(trackAsset.curves, assetOwner); |
|
|
|
var animTrack = trackAsset as AnimationTrack; |
|
if (animTrack != null && animTrack.infiniteClip != null) |
|
((AnimationTrack)newTrack).infiniteClip = CloneAnimationClip(animTrack.infiniteClip, assetOwner); |
|
|
|
foreach (var clip in trackAsset.clips) |
|
{ |
|
var newClip = DuplicateClip(clip, sourceTable, destTable, assetOwner); |
|
newClip.SetParentTrack_Internal(newTrack); |
|
} |
|
|
|
newTrack.ClearMarkers(); |
|
foreach (var e in trackAsset.GetMarkersRaw()) |
|
{ |
|
var newMarker = Object.Instantiate(e); |
|
newTrack.AddMarker(newMarker); |
|
SaveCloneToAsset(newMarker, assetOwner); |
|
if (newMarker is IMarker) |
|
{ |
|
(newMarker as IMarker).Initialize(newTrack); |
|
} |
|
} |
|
|
|
newTrack.SetCollapsed(trackAsset.IsCollapsed()); |
|
|
|
// calling code is responsible for adding to asset, adding to sequence, and parenting, |
|
// and duplicating subtracks |
|
return newTrack; |
|
} |
|
|
|
public static IEnumerable<ITimelineItem> DuplicateItemsUsingCurrentEditMode(IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, ItemsPerTrack items, TrackAsset targetParent, double candidateTime, string undoOperation) |
|
{ |
|
if (targetParent != null) |
|
{ |
|
var aTrack = targetParent as AnimationTrack; |
|
if (aTrack != null) |
|
aTrack.ConvertToClipMode(); |
|
|
|
var duplicatedItems = DuplicateItems(items, targetParent, sourceTable, destTable, undoOperation); |
|
FinalizeInsertItemsUsingCurrentEditMode(new[] { duplicatedItems }, candidateTime); |
|
return duplicatedItems.items; |
|
} |
|
|
|
return Enumerable.Empty<ITimelineItem>(); |
|
} |
|
|
|
public static IEnumerable<ITimelineItem> DuplicateItemsUsingCurrentEditMode(IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, IEnumerable<ItemsPerTrack> items, double candidateTime, string undoOperation) |
|
{ |
|
var duplicatedItemsGroups = new List<ItemsPerTrack>(); |
|
foreach (var i in items) |
|
duplicatedItemsGroups.Add(DuplicateItems(i, i.targetTrack, sourceTable, destTable, undoOperation)); |
|
|
|
FinalizeInsertItemsUsingCurrentEditMode(duplicatedItemsGroups, candidateTime); |
|
return duplicatedItemsGroups.SelectMany(i => i.items); |
|
} |
|
|
|
internal static ItemsPerTrack DuplicateItems(ItemsPerTrack items, TrackAsset target, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, string undoOperation) |
|
{ |
|
var duplicatedItems = new List<ITimelineItem>(); |
|
var clips = items.clips.ToList(); |
|
if (clips.Any()) |
|
{ |
|
TimelineUndo.PushUndo(target, undoOperation); |
|
duplicatedItems.AddRange(DuplicateClips(clips, sourceTable, destTable, target).ToItems()); |
|
TimelineUndo.PushUndo(target, undoOperation); // second undo causes reference fixups on redo (case 1063868) |
|
} |
|
|
|
var markers = items.markers.ToList(); |
|
if (markers.Any()) |
|
{ |
|
duplicatedItems.AddRange(MarkerModifier.CloneMarkersToParent(markers, target).ToItems()); |
|
} |
|
|
|
return new ItemsPerTrack(target, duplicatedItems.ToArray()); |
|
} |
|
|
|
static void FinalizeInsertItemsUsingCurrentEditMode(IList<ItemsPerTrack> itemsGroups, double candidateTime) |
|
{ |
|
EditMode.FinalizeInsertItemsAtTime(itemsGroups, candidateTime); |
|
|
|
SelectionManager.Clear(); |
|
foreach (var itemsGroup in itemsGroups) |
|
{ |
|
var track = itemsGroup.targetTrack; |
|
var items = itemsGroup.items; |
|
|
|
EditModeUtils.SetParentTrack(items, track); |
|
|
|
track.SortClips(); |
|
|
|
TrackExtensions.ComputeBlendsFromOverlaps(track.clips); |
|
track.CalculateExtrapolationTimes(); |
|
|
|
foreach (var item in items) |
|
if (item.gui != null) item.gui.Select(); |
|
} |
|
|
|
var allItems = itemsGroups.SelectMany(x => x.items).ToList(); |
|
foreach (var item in allItems) |
|
{ |
|
SelectionManager.Add(item); |
|
} |
|
|
|
FrameItems(allItems); |
|
} |
|
|
|
internal static TimelineClip Clone(TimelineClip clip, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, PlayableAsset newOwner) |
|
{ |
|
var editorClip = EditorClipFactory.GetEditorClip(clip); |
|
// Workaround for Clips not being unity object, assign it to a editor clip wrapper, clone it, and pull the clip back out |
|
var newClip = Object.Instantiate(editorClip).clip; |
|
|
|
// perform fix ups for what Instantiate cannot properly detect |
|
SelectionManager.Remove(newClip); |
|
newClip.SetParentTrack_Internal(null); |
|
newClip.curves = null; // instantiate might copy the reference, we need to clear it |
|
|
|
// curves are explicitly owned by the clip |
|
if (clip.curves != null) |
|
{ |
|
newClip.CreateCurves(AnimationTrackRecorder.GetUniqueRecordedClipName(newOwner, clip.curves.name)); |
|
EditorUtility.CopySerialized(clip.curves, newClip.curves); |
|
TimelineCreateUtilities.SaveAssetIntoObject(newClip.curves, newOwner); |
|
} |
|
|
|
ScriptableObject playableAsset = newClip.asset as ScriptableObject; |
|
if (playableAsset != null && newClip.asset is IPlayableAsset) |
|
{ |
|
var clone = CloneReferencedPlayableAsset(playableAsset, sourceTable, destTable, newOwner); |
|
newClip.asset = clone; |
|
|
|
// special case to make the name match the recordable clips, but only if they match on the original clip |
|
var originalRecordedAsset = clip.asset as AnimationPlayableAsset; |
|
if (clip.recordable && originalRecordedAsset != null && originalRecordedAsset.clip != null) |
|
{ |
|
AnimationPlayableAsset clonedAnimationAsset = clone as AnimationPlayableAsset; |
|
if (clonedAnimationAsset != null && clonedAnimationAsset.clip != null) |
|
{ |
|
clonedAnimationAsset.clip = CloneAnimationClip(originalRecordedAsset.clip, newOwner); |
|
if (clip.displayName == originalRecordedAsset.clip.name && newClip.recordable) |
|
{ |
|
clonedAnimationAsset.name = clonedAnimationAsset.clip.name; |
|
newClip.displayName = clonedAnimationAsset.name; |
|
} |
|
} |
|
} |
|
} |
|
|
|
return newClip; |
|
} |
|
|
|
static TimelineClip[] DuplicateClips(IEnumerable<TimelineClip> clips, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, PlayableAsset newOwner) |
|
{ |
|
var newClips = new TimelineClip[clips.Count()]; |
|
|
|
int i = 0; |
|
|
|
foreach (var clip in clips) |
|
{ |
|
var newParent = newOwner == null ? clip.GetParentTrack() : newOwner; |
|
var newClip = DuplicateClip(clip, sourceTable, destTable, newParent); |
|
newClip.SetParentTrack_Internal(null); |
|
newClips[i++] = newClip; |
|
} |
|
|
|
return newClips; |
|
} |
|
|
|
static TimelineClip DuplicateClip(TimelineClip clip, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, PlayableAsset newOwner) |
|
{ |
|
var newClip = Clone(clip, sourceTable, destTable, newOwner); |
|
|
|
var track = clip.GetParentTrack(); |
|
if (track != null) |
|
{ |
|
newClip.SetParentTrack_Internal(track); |
|
track.AddClip(newClip); |
|
} |
|
|
|
var editor = CustomTimelineEditorCache.GetClipEditor(clip); |
|
try |
|
{ |
|
editor.OnCreate(newClip, track, clip); |
|
} |
|
catch (Exception e) |
|
{ |
|
Debug.LogException(e); |
|
} |
|
|
|
return newClip; |
|
} |
|
|
|
// Given a track type, return all the playable asset types that should be |
|
// visible to the user via menus |
|
|
|
// Given a track type, return all the playable asset types |
|
|
|
|
|
public static Type GetCustomDrawer(Type trackType) |
|
{ |
|
if (s_SubClassesOfTrackDrawer == null) |
|
{ |
|
s_SubClassesOfTrackDrawer = TypeCache.GetTypesDerivedFrom<TrackDrawer>().ToList(); |
|
} |
|
|
|
foreach (var drawer in s_SubClassesOfTrackDrawer) |
|
{ |
|
var attr = Attribute.GetCustomAttribute(drawer, typeof(CustomTrackDrawerAttribute), false) as CustomTrackDrawerAttribute; |
|
if (attr != null && attr.assetType.IsAssignableFrom(trackType)) |
|
return drawer; |
|
} |
|
|
|
return typeof(TrackDrawer); |
|
} |
|
|
|
public static bool HaveSameContainerAsset(Object assetA, Object assetB) |
|
{ |
|
if (assetA == null || assetB == null) |
|
return false; |
|
|
|
if ((assetA.hideFlags & HideFlags.DontSave) != 0 && (assetB.hideFlags & HideFlags.DontSave) != 0) |
|
return true; |
|
|
|
return AssetDatabase.GetAssetPath(assetA) == AssetDatabase.GetAssetPath(assetB); |
|
} |
|
|
|
public static void SaveAnimClipIntoObject(AnimationClip clip, Object asset) |
|
{ |
|
if (asset != null) |
|
{ |
|
clip.hideFlags = asset.hideFlags & ~HideFlags.HideInHierarchy; // show animation clips, even if the parent track isn't |
|
if ((clip.hideFlags & HideFlags.DontSave) == 0) |
|
{ |
|
AssetDatabase.AddObjectToAsset(clip, asset); |
|
} |
|
} |
|
} |
|
|
|
// Make sure a gameobject has all the required component for the given TrackAsset |
|
public static Component AddRequiredComponent(GameObject go, TrackAsset asset) |
|
{ |
|
if (go == null || asset == null) |
|
return null; |
|
|
|
var bindings = asset.outputs; |
|
if (!bindings.Any()) |
|
return null; |
|
|
|
var binding = bindings.First(); |
|
if (binding.outputTargetType == null || !typeof(Component).IsAssignableFrom(binding.outputTargetType)) |
|
return null; |
|
|
|
var component = go.GetComponent(binding.outputTargetType); |
|
if (component == null) |
|
{ |
|
component = Undo.AddComponent(go, binding.outputTargetType); |
|
} |
|
return component; |
|
} |
|
|
|
public static string GetTrackCategoryName(System.Type trackType) |
|
{ |
|
if (trackType == null) |
|
return string.Empty; |
|
|
|
string s = GetItemCategoryName(trackType); |
|
if (!String.IsNullOrEmpty(s)) |
|
return s; |
|
|
|
// if as display name with a path is specified use that |
|
var attr = Attribute.GetCustomAttribute(trackType, typeof(DisplayNameAttribute)) as DisplayNameAttribute; |
|
if (attr != null && attr.DisplayName.Contains('/')) |
|
return string.Empty; |
|
|
|
if (trackType.Namespace == null || trackType.Namespace.Contains("UnityEngine")) |
|
return string.Empty; |
|
|
|
return trackType.Namespace + "/"; |
|
} |
|
|
|
public static string GetItemCategoryName(System.Type itemType) |
|
{ |
|
if (itemType == null) |
|
return string.Empty; |
|
|
|
var attribute = itemType.GetCustomAttribute(typeof(MenuCategoryAttribute)) as MenuCategoryAttribute; |
|
if (attribute != null) |
|
{ |
|
var s = attribute.category; |
|
if (!s.EndsWith("/")) |
|
s += "/"; |
|
return s; |
|
} |
|
|
|
return string.Empty; |
|
} |
|
|
|
public static string GetTrackMenuName(System.Type trackType) |
|
{ |
|
return L10n.Tr(TypeUtility.GetDisplayName(trackType)); |
|
} |
|
|
|
// retrieve the duration of a single loop, taking into account speed |
|
public static double GetLoopDuration(TimelineClip clip) |
|
{ |
|
double length = clip.clipAssetDuration; |
|
if (double.IsNegativeInfinity(length) || double.IsNaN(length)) |
|
return TimelineClip.kMinDuration; |
|
|
|
if (length == double.MaxValue || double.IsInfinity(length)) |
|
{ |
|
return double.MaxValue; |
|
} |
|
|
|
return Math.Max(TimelineClip.kMinDuration, length / clip.timeScale); |
|
} |
|
|
|
public static double GetClipAssetEndTime(TimelineClip clip) |
|
{ |
|
var d = GetLoopDuration(clip); |
|
if (d < double.MaxValue) |
|
d = clip.FromLocalTimeUnbound(d); |
|
|
|
return d; |
|
} |
|
|
|
// Checks if the underlying asset duration is usable. This means the clip |
|
// can loop or hold |
|
public static bool HasUsableAssetDuration(TimelineClip clip) |
|
{ |
|
double length = clip.clipAssetDuration; |
|
return (length < TimelineClip.kMaxTimeValue) && !double.IsInfinity(length) && !double.IsNaN(length); |
|
} |
|
|
|
// Retrieves the starting point of each loop of a clip, relative to the start of the clip |
|
// Note that if clip-in is bigger than the loopDuration, negative times will be added |
|
public static double[] GetLoopTimes(TimelineClip clip) |
|
{ |
|
if (!HasUsableAssetDuration(clip)) |
|
return new[] { -clip.clipIn / clip.timeScale }; |
|
|
|
var times = new List<double>(); |
|
double loopDuration = GetLoopDuration(clip); |
|
|
|
if (loopDuration <= TimeUtility.kTimeEpsilon) |
|
return new double[] { }; |
|
|
|
|
|
double start = -clip.clipIn / clip.timeScale; |
|
double end = start + loopDuration; |
|
|
|
times.Add(start); |
|
while (end < clip.duration - WindowState.kTimeEpsilon) |
|
{ |
|
times.Add(end); |
|
end += loopDuration; |
|
} |
|
|
|
return times.ToArray(); |
|
} |
|
|
|
public static double GetCandidateTime(Vector2? mousePosition, params TrackAsset[] trackAssets) |
|
{ |
|
// Right-Click |
|
if (mousePosition != null) |
|
{ |
|
return TimeReferenceUtility.GetSnappedTimeAtMousePosition(mousePosition.Value); |
|
} |
|
|
|
// Playhead |
|
if (TimelineEditor.inspectedDirector != null) |
|
{ |
|
return TimeReferenceUtility.SnapToFrameIfRequired(TimelineEditor.inspectedSequenceTime); |
|
} |
|
|
|
// Specific tracks end |
|
if (trackAssets != null && trackAssets.Any()) |
|
{ |
|
var items = trackAssets.SelectMany(t => t.GetItems()).ToList(); |
|
return items.Any() ? items.Max(i => i.end) : 0; |
|
} |
|
|
|
// Timeline tracks end |
|
if (TimelineEditor.inspectedAsset != null) |
|
return TimelineEditor.inspectedAsset.flattenedTracks.Any() ? TimelineEditor.inspectedAsset.flattenedTracks.Max(t => t.end) : 0; |
|
|
|
return 0.0; |
|
} |
|
|
|
public static TimelineClip CreateClipOnTrack(Object asset, TrackAsset parentTrack, WindowState state) |
|
{ |
|
return CreateClipOnTrack(asset, parentTrack, GetCandidateTime(null, parentTrack), state); |
|
} |
|
|
|
public static TimelineClip CreateClipOnTrack(Object asset, TrackAsset parentTrack, double candidateTime) |
|
{ |
|
WindowState state = null; |
|
if (TimelineWindow.instance != null) |
|
state = TimelineWindow.instance.state; |
|
|
|
return CreateClipOnTrack(asset, parentTrack, candidateTime, state); |
|
} |
|
|
|
public static TimelineClip CreateClipOnTrack(Type playableAssetType, TrackAsset parentTrack, WindowState state) |
|
{ |
|
return CreateClipOnTrack(playableAssetType, null, parentTrack, GetCandidateTime(null, parentTrack), state); |
|
} |
|
|
|
public static TimelineClip CreateClipOnTrack(Type playableAssetType, TrackAsset parentTrack, double candidateTime) |
|
{ |
|
return CreateClipOnTrack(playableAssetType, null, parentTrack, candidateTime); |
|
} |
|
|
|
public static TimelineClip CreateClipOnTrack(Object asset, TrackAsset parentTrack, double candidateTime, WindowState state) |
|
{ |
|
if (parentTrack == null) |
|
return null; |
|
|
|
// pick the first clip type available, unless there is one that matches the asset |
|
var clipType = TypeUtility.GetPlayableAssetsHandledByTrack(parentTrack.GetType()).FirstOrDefault(); |
|
if (asset != null) |
|
clipType = TypeUtility.GetAssetTypesForObject(parentTrack.GetType(), asset).FirstOrDefault(); |
|
|
|
if (clipType == null) |
|
return null; |
|
|
|
return CreateClipOnTrack(clipType, asset, parentTrack, candidateTime, state); |
|
} |
|
|
|
public static TimelineClip CreateClipOnTrack(Type playableAssetType, Object assignableObject, TrackAsset parentTrack, double candidateTime) |
|
{ |
|
WindowState state = null; |
|
if (TimelineWindow.instance != null) |
|
state = TimelineWindow.instance.state; |
|
|
|
return CreateClipOnTrack(playableAssetType, assignableObject, parentTrack, candidateTime, state); |
|
} |
|
|
|
public static TimelineClip CreateClipOnTrack(Type playableAssetType, Object assignableObject, TrackAsset parentTrack, double candidateTime, WindowState state) |
|
{ |
|
if (parentTrack == null) |
|
return null; |
|
|
|
bool revertClipMode = false; |
|
|
|
// Ideally this is done automatically by the animation track, |
|
// but it's editor only because it does animation clip manipulation |
|
var animTrack = parentTrack as AnimationTrack; |
|
if (animTrack != null && animTrack.CanConvertToClipMode()) |
|
{ |
|
animTrack.ConvertToClipMode(); |
|
revertClipMode = true; |
|
} |
|
|
|
TimelineClip newClip = null; |
|
if (TypeUtility.IsConcretePlayableAsset(playableAssetType)) |
|
{ |
|
try |
|
{ |
|
newClip = parentTrack.CreateClipOfType(playableAssetType); |
|
} |
|
catch (InvalidOperationException) { } // expected on a mismatch |
|
} |
|
|
|
if (newClip == null) |
|
{ |
|
if (revertClipMode) |
|
animTrack.ConvertFromClipMode(animTrack.timelineAsset); |
|
|
|
Debug.LogWarningFormat("Cannot create a clip of type {0} on a track of type {1}", playableAssetType.Name, parentTrack.GetType().Name); |
|
return null; |
|
} |
|
|
|
AddClipOnTrack(newClip, parentTrack, candidateTime, assignableObject, state); |
|
|
|
return newClip; |
|
} |
|
|
|
/// <summary> |
|
/// Create a clip on track from an existing PlayableAsset |
|
/// </summary> |
|
public static TimelineClip CreateClipOnTrackFromPlayableAsset(IPlayableAsset asset, TrackAsset parentTrack, double candidateTime) |
|
{ |
|
if (parentTrack == null || asset == null || !TypeUtility.IsConcretePlayableAsset(asset.GetType())) |
|
return null; |
|
|
|
TimelineClip newClip = null; |
|
try |
|
{ |
|
newClip = parentTrack.CreateClipFromPlayableAsset(asset); |
|
} |
|
catch |
|
{ |
|
return null; |
|
} |
|
|
|
WindowState state = null; |
|
if (TimelineWindow.instance != null) |
|
state = TimelineWindow.instance.state; |
|
|
|
AddClipOnTrack(newClip, parentTrack, candidateTime, null, state); |
|
|
|
return newClip; |
|
} |
|
|
|
public static void CreateClipsFromObjects(Type assetType, TrackAsset targetTrack, double candidateTime, IEnumerable<Object> objects) |
|
{ |
|
foreach (var obj in objects) |
|
{ |
|
if (ObjectReferenceField.FindObjectReferences(assetType).Any(f => f.IsAssignable(obj))) |
|
{ |
|
var clip = CreateClipOnTrack(assetType, obj, targetTrack, candidateTime); |
|
candidateTime += clip.duration; |
|
} |
|
} |
|
} |
|
|
|
public static void CreateMarkersFromObjects(Type assetType, TrackAsset targetTrack, double candidateTime, IEnumerable<Object> objects) |
|
{ |
|
var mList = new List<ITimelineItem>(); |
|
foreach (var obj in objects) |
|
{ |
|
if (ObjectReferenceField.FindObjectReferences(assetType).Any(f => f.IsAssignable(obj))) |
|
{ |
|
var marker = CreateMarkerOnTrack(assetType, obj, targetTrack, candidateTime); |
|
mList.Add(marker.ToItem()); |
|
} |
|
} |
|
|
|
var state = TimelineWindow.instance.state; |
|
for (var i = 1; i < mList.Count; ++i) |
|
{ |
|
var delta = ItemsUtils.TimeGapBetweenItems(mList[i - 1], mList[i]); |
|
mList[i].start += delta; |
|
} |
|
|
|
FinalizeInsertItemsUsingCurrentEditMode(new[] { new ItemsPerTrack(targetTrack, mList) }, candidateTime); |
|
state.Refresh(); |
|
} |
|
|
|
public static IMarker CreateMarkerOnTrack(Type markerType, Object assignableObject, TrackAsset parentTrack, double candidateTime) |
|
{ |
|
WindowState state = null; |
|
if (TimelineWindow.instance != null) |
|
state = TimelineWindow.instance.state; |
|
|
|
var newMarker = parentTrack.CreateMarker(markerType, candidateTime); //Throws if marker is not an object |
|
var obj = newMarker as ScriptableObject; |
|
if (obj != null) |
|
obj.name = TypeUtility.GetDisplayName(markerType); |
|
|
|
if (assignableObject != null) |
|
{ |
|
var director = state != null ? state.editSequence.director : null; |
|
foreach (var field in ObjectReferenceField.FindObjectReferences(markerType)) |
|
{ |
|
if (field.IsAssignable(assignableObject)) |
|
{ |
|
field.Assign(newMarker as ScriptableObject, assignableObject, director); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
try |
|
{ |
|
CustomTimelineEditorCache.GetMarkerEditor(newMarker).OnCreate(newMarker, null); |
|
} |
|
catch (Exception e) |
|
{ |
|
Debug.LogException(e); |
|
} |
|
|
|
return newMarker; |
|
} |
|
|
|
public static void CreateClipsFromTypes(IEnumerable<Type> assetTypes, TrackAsset targetTrack, double candidateTime) |
|
{ |
|
foreach (var assetType in assetTypes) |
|
{ |
|
var clip = CreateClipOnTrack(assetType, targetTrack, candidateTime); |
|
candidateTime += clip.duration; |
|
} |
|
} |
|
|
|
public static void FrameItems(IEnumerable<ITimelineItem> items) |
|
{ |
|
if (items == null || !items.Any()) |
|
return; |
|
|
|
// if this is called before a repaint, the timeArea can be null |
|
if (TimelineEditor.window.timeArea == null) |
|
return; |
|
|
|
var start = (float)items.Min(x => x.start); |
|
var end = (float)items.Max(x => x.end); |
|
var timeRange = TimelineEditor.visibleTimeRange; |
|
|
|
// nothing to do |
|
if (timeRange.x <= start && timeRange.y >= end) |
|
return; |
|
|
|
timeRange.x = Mathf.Max(0, timeRange.x); |
|
timeRange.y = Mathf.Max(0, timeRange.y); |
|
|
|
var ds = start - timeRange.x; |
|
var de = end - timeRange.y; |
|
|
|
var padding = TimeReferenceUtility.PixelToTime(15) - TimeReferenceUtility.PixelToTime(0); |
|
var d = Math.Abs(ds) < Math.Abs(de) ? ds - padding : de + padding; |
|
|
|
TimelineEditor.visibleTimeRange = new Vector2(timeRange.x + d, timeRange.y + d); |
|
} |
|
|
|
public static void Frame(WindowState state, double start, double end) |
|
{ |
|
var timeRange = state.timeAreaShownRange; |
|
|
|
// nothing to do |
|
if (timeRange.x <= start && timeRange.y >= end) |
|
return; |
|
|
|
var ds = (float)start - timeRange.x; |
|
var de = (float)end - timeRange.y; |
|
|
|
var padding = state.PixelDeltaToDeltaTime(15); |
|
var d = Math.Abs(ds) < Math.Abs(de) ? ds - padding : de + padding; |
|
|
|
state.SetTimeAreaShownRange(timeRange.x + d, timeRange.y + d); |
|
} |
|
|
|
public static void RangeSelect<T>(IList<T> totalCollection, IList<T> currentSelection, T clickedItem, Action<T> selector, Action<T> remover) where T : class |
|
{ |
|
var firstSelect = currentSelection.FirstOrDefault(); |
|
if (firstSelect == null) |
|
{ |
|
selector(clickedItem); |
|
return; |
|
} |
|
|
|
var idxFirstSelect = totalCollection.IndexOf(firstSelect); |
|
var idxLastSelect = totalCollection.IndexOf(currentSelection.Last()); |
|
var idxClicked = totalCollection.IndexOf(clickedItem); |
|
|
|
//case 927807: selection is invalid |
|
if (idxFirstSelect < 0) |
|
{ |
|
SelectionManager.Clear(); |
|
selector(clickedItem); |
|
return; |
|
} |
|
|
|
// Expand the selection between the first selected clip and clicked clip (insertion order is important) |
|
if (idxFirstSelect < idxClicked) |
|
for (var i = idxFirstSelect; i <= idxClicked; ++i) |
|
selector(totalCollection[i]); |
|
else |
|
for (var i = idxFirstSelect; i >= idxClicked; --i) |
|
selector(totalCollection[i]); |
|
|
|
// If clicked inside the selected range, shrink the selection between the the click and last selected clip |
|
if (Math.Min(idxFirstSelect, idxLastSelect) < idxClicked && idxClicked < Math.Max(idxFirstSelect, idxLastSelect)) |
|
for (var i = Math.Min(idxLastSelect, idxClicked); i <= Math.Max(idxLastSelect, idxClicked); ++i) |
|
remover(totalCollection[i]); |
|
|
|
// Ensure clicked clip is selected |
|
selector(clickedItem); |
|
} |
|
|
|
/// <summary> |
|
/// Shared code for adding a clip to a track |
|
/// </summary> |
|
static void AddClipOnTrack(TimelineClip newClip, TrackAsset parentTrack, double candidateTime, Object assignableObject, WindowState state) |
|
{ |
|
var playableAsset = newClip.asset as IPlayableAsset; |
|
|
|
newClip.SetParentTrack_Internal(null); |
|
newClip.timeScale = 1.0; |
|
newClip.mixInCurve = AnimationCurve.EaseInOut(0, 0, 1, 1); |
|
newClip.mixOutCurve = AnimationCurve.EaseInOut(0, 1, 1, 0); |
|
|
|
var playableDirector = state != null ? state.editSequence.director : null; |
|
|
|
if (assignableObject != null) |
|
{ |
|
foreach (var field in ObjectReferenceField.FindObjectReferences(playableAsset.GetType())) |
|
{ |
|
if (field.IsAssignable(assignableObject)) |
|
{ |
|
newClip.displayName = assignableObject.name; |
|
field.Assign(newClip.asset as PlayableAsset, assignableObject, playableDirector); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
// get the clip editor |
|
try |
|
{ |
|
CustomTimelineEditorCache.GetClipEditor(newClip).OnCreate(newClip, parentTrack, null); |
|
} |
|
catch (Exception e) |
|
{ |
|
Debug.LogException(e); |
|
} |
|
|
|
|
|
// reset the duration as the newly assigned values may have changed the default |
|
if (playableAsset != null) |
|
{ |
|
var candidateDuration = playableAsset.duration; |
|
|
|
if (!double.IsInfinity(candidateDuration) && candidateDuration > 0) |
|
newClip.duration = Math.Min(Math.Max(candidateDuration, TimelineClip.kMinDuration), TimelineClip.kMaxTimeValue); |
|
} |
|
|
|
var newClipsByTracks = new[] { new ItemsPerTrack(parentTrack, new[] { newClip.ToItem() }) }; |
|
|
|
FinalizeInsertItemsUsingCurrentEditMode(newClipsByTracks, candidateTime); |
|
|
|
if (state != null) |
|
state.Refresh(); |
|
} |
|
|
|
public static TrackAsset CreateTrack(TimelineAsset asset, Type type, TrackAsset parent = null, string name = null) |
|
{ |
|
if (asset == null) |
|
return null; |
|
|
|
var track = asset.CreateTrack(type, parent, name); |
|
if (track != null) |
|
{ |
|
if (parent != null) |
|
parent.SetCollapsed(false); |
|
|
|
var editor = CustomTimelineEditorCache.GetTrackEditor(track); |
|
editor.OnCreate_Safe(track, null); |
|
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); |
|
} |
|
|
|
return track; |
|
} |
|
|
|
public static TrackAsset CreateTrack(Type type, TrackAsset parent = null, string name = null) |
|
{ |
|
return CreateTrack(TimelineEditor.inspectedAsset, type, parent, name); |
|
} |
|
|
|
public static T CreateTrack<T>(TimelineAsset asset, TrackAsset parent = null, string name = null) where T : TrackAsset |
|
{ |
|
return (T)CreateTrack(asset, typeof(T), parent, name); |
|
} |
|
|
|
public static T CreateTrack<T>(TrackAsset parent = null, string name = null) where T : TrackAsset |
|
{ |
|
return (T)CreateTrack(TimelineEditor.inspectedAsset, typeof(T), parent, name); |
|
} |
|
} |
|
}
|
|
|