public static void BindWithEditorValidation(PlayableDirector director, TrackAsset bindTo, Object objectToBind)
{
TrackEditor trackEditor = CustomTimelineEditorCache.GetTrackEditor(bindTo);
Object validatedObject = trackEditor.GetBindingFrom_Safe(objectToBind, bindTo);
Bind(director, bindTo, validatedObject);
}
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
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);
}
internal static void RecursiveSubtrackClone(TrackAsset source, TrackAsset duplicate, PlayableDirector director, PlayableAsset assetOwner)
{
var subtracks = source.GetChildTracks();
foreach (var sub in subtracks)
{
var newSub = TimelineHelpers.Clone(duplicate, sub, director, assetOwner);
duplicate.AddChild(newSub);
RecursiveSubtrackClone(sub, newSub, director, assetOwner);
// Call the custom editor on Create
var customEditor = CustomTimelineEditorCache.GetTrackEditor(newSub);
try
{
customEditor.OnCreate(newSub, sub);
}
catch (Exception e)
{
Debug.LogException(e);
}
// registration has to happen AFTER recursion
TimelineUndo.RegisterCreatedObjectUndo(newSub, "Duplicate");
TimelineCreateUtilities.SaveAssetIntoObject(newSub, assetOwner);
}
}
public static IMarker CloneMarkerToParent(IMarker marker, TrackAsset parent)
{
var markerObject = marker as ScriptableObject;
if (markerObject == null)
{
return(null);
}
var newMarkerObject = Object.Instantiate(markerObject);
AddMarkerToParent(newMarkerObject, parent);
newMarkerObject.name = markerObject.name;
try
{
CustomTimelineEditorCache.GetMarkerEditor((IMarker)newMarkerObject).OnCreate((IMarker)newMarkerObject, marker);
}
catch (Exception e)
{
Debug.LogException(e);
}
return((IMarker)newMarkerObject);
}
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);
try
{
editor.OnCreate(track, null);
}
catch (Exception e)
{
Debug.LogException(e);
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
}
return(track);
}
void DrawSimpleClip(Rect targetRect, ClipBorder border, Color overlay)
{
var drawOptions = UpdateClipDrawOptions(CustomTimelineEditorCache.GetClipEditor(clip), clip);
var blends = GetClipBlends();
ClipDrawer.DrawSimpleClip(clip, targetRect, border, overlay, drawOptions, blends);
}
static TimelineClip DuplicateClip(TimelineClip clip, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, PlayableAsset newOwner)
{
var newClip = Clone(clip, sourceTable, destTable, newOwner);
var track = clip.parentTrack;
if (track != null)
{
newClip.parentTrack = track;
track.AddClip(newClip);
}
var editor = CustomTimelineEditorCache.GetClipEditor(clip);
try
{
editor.OnCreate(newClip, track, clip);
}
catch (Exception e)
{
Debug.LogException(e);
}
return(newClip);
}
public virtual void OnEnable()
{
m_IsBuiltInType = target != null && target.GetType().Assembly == typeof(TrackAsset).Assembly;
m_Name = serializedObject.FindProperty("m_Name");
m_TrackCurvesWrapper = new TrackCurvesWrapper(target as TrackAsset);
m_HeaderIcon = TrackResourceCache.s_DefaultIcon.image;
// only worry about the first track. if types are different, a different inspector is used.
var track = target as TrackAsset;
if (track != null)
{
var drawer = CustomTimelineEditorCache.GetTrackEditor(track);
UnityEngine.Object binding = null;
var director = m_Context as PlayableDirector;
if (director != null)
{
binding = director.GetGenericBinding(track);
}
var options = drawer.GetTrackOptions(track, binding);
if (options.icon != null)
{
m_HeaderIcon = options.icon;
}
else
{
m_HeaderIcon = TrackResourceCache.GetTrackIcon(track).image;
}
}
}
static TimelineClip DuplicateClip(TimelineClip clip, PlayableDirector director, PlayableAsset newOwner)
{
var newClip = Clone(clip, director, newOwner);
var track = clip.parentTrack;
if (track != null)
{
newClip.parentTrack = track;
track.AddClip(newClip);
}
var editor = CustomTimelineEditorCache.GetClipEditor(clip);
try
{
editor.OnCreate(newClip, track, clip);
}
catch (Exception e)
{
Debug.LogException(e);
}
return(newClip);
}
/// <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.parentTrack = 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(state, newClipsByTracks, candidateTime);
if (state != null)
{
state.Refresh();
}
}
public static TrackDrawOptions GetTrackOptions_Safe(this TrackEditor editor, TrackAsset track, UnityEngine.Object binding)
{
try
{
return(editor.GetTrackOptions(track, binding));
}
catch (Exception e)
{
Debug.LogException(e);
return(CustomTimelineEditorCache.GetDefaultTrackEditor().GetTrackOptions(track, binding));
}
}
static ClipDrawOptions UpdateClipDrawOptions(ClipEditor clipEditor, TimelineClip clip)
{
try
{
return(clipEditor.GetClipOptions(clip));
}
catch (Exception e)
{
Debug.LogException(e);
}
return(CustomTimelineEditorCache.GetDefaultClipEditor().GetClipOptions(clip));
}
public TimelineClipGUI(TimelineClip clip, IRowGUI parent, IZOrderProvider provider) : base(parent)
{
zOrderProvider = provider;
zOrder = provider.Next();
m_EditorItem = EditorClipFactory.GetEditorClip(clip);
m_ClipEditor = CustomTimelineEditorCache.GetClipEditor(clip);
supportResize = true;
leftHandle = new TimelineClipHandle(this, TrimEdge.Start);
rightHandle = new TimelineClipHandle(this, TrimEdge.End);
ItemToItemGui.Add(clip, this);
}
public static IList<PlayableDirector> GetSubTimelines(TimelineClip clip, IExposedPropertyTable director)
{
var editor = CustomTimelineEditorCache.GetClipEditor(clip);
List<PlayableDirector> directors = new List<PlayableDirector>();
try
{
editor.GetSubTimelines(clip, director as PlayableDirector, directors);
}
catch (Exception e)
{
Debug.LogException(e);
}
return directors;
}
void UpdateDrawData()
{
if (Event.current.type == EventType.Layout)
{
try
{
m_MarkerDrawOptions = m_Editor.GetMarkerOptions(marker);
}
catch (Exception e)
{
Debug.LogException(e);
m_MarkerDrawOptions = CustomTimelineEditorCache.GetDefaultMarkerEditor().GetMarkerOptions(marker);
}
}
}
void OnBeforeSequenceChange()
{
treeView = null;
m_MarkerHeaderGUI = null;
m_TimeAreaDirty = true;
state.Reset();
m_PlayableLookup.ClearPlayableLookup();
// clear old editors to caches, like audio previews, get flushed
CustomTimelineEditorCache.ClearCache <ClipEditor>();
CustomTimelineEditorCache.ClearCache <MarkerEditor>();
CustomTimelineEditorCache.ClearCache <TrackEditor>();
m_PreviousMasterSequence = state.masterSequence.asset;
}
void UpdateDrawData(WindowState state)
{
if (Event.current.type == EventType.Layout)
{
m_TrackDrawData.m_ShowTrackBindings = false;
m_TrackDrawData.m_TrackBinding = null;
if (state.editSequence.director != null && showSceneReference)
{
m_TrackDrawData.m_ShowTrackBindings = state.GetWindow().currentMode.ShouldShowTrackBindings(state);
m_TrackDrawData.m_TrackBinding = state.editSequence.director.GetGenericBinding(track);
}
var lastError = m_TrackDrawOptions.errorText;
var lastHeight = m_TrackDrawOptions.minimumHeight;
try
{
m_TrackDrawOptions = m_TrackEditor.GetTrackOptions(track, m_TrackDrawData.m_TrackBinding);
}
catch (Exception e)
{
Debug.LogException(e);
m_TrackDrawOptions = CustomTimelineEditorCache.GetDefaultTrackEditor().GetTrackOptions(track, m_TrackDrawData.m_TrackBinding);
}
m_TrackDrawData.m_AllowsRecording = DoesTrackAllowsRecording(track);
m_TrackDrawData.m_TrackIcon = m_TrackDrawOptions.icon;
if (m_TrackDrawData.m_TrackIcon == null)
{
m_TrackDrawData.m_TrackIcon = m_DefaultTrackIcon.image;
}
// if the problem state has changed, it may be due to external bindings
// in that case, we need to tell the graph to rebuild.
// there is no notification from the engine for some markers that invalidate the graph (addcomponent)
if (m_TrackDrawData.m_ShowTrackBindings && lastError != null && !lastError.Equals(m_TrackDrawOptions.errorText) && !state.playing)
{
state.rebuildGraph = true;
}
// track height has changed. need to update gui
if (!Mathf.Approximately(lastHeight, m_TrackDrawOptions.minimumHeight))
{
state.Refresh();
}
}
}
public TimelineMarkerGUI(IMarker theMarker, IRowGUI parent, IZOrderProvider provider) : base(parent)
{
marker = theMarker;
m_Selectable = marker.GetType().IsSubclassOf(typeof(UnityObject));
m_MarkerHash = 0;
var o = marker as object;
if (!o.Equals(null))
{
m_MarkerHash = o.GetHashCode();
}
zOrderProvider = provider;
zOrder = zOrderProvider.Next();
ItemToItemGui.Add(marker, this);
m_Editor = CustomTimelineEditorCache.GetMarkerEditor(theMarker);
}
public TimelineTrackGUI(TreeViewController tv, TimelineTreeViewGUI w, int id, int depth, TreeViewItem parent, string displayName, TrackAsset sequenceActor)
: base(tv, w, id, depth, parent, displayName, sequenceActor, false)
{
AnimationTrack animationTrack = sequenceActor as AnimationTrack;
if (animationTrack != null)
{
m_InfiniteTrackDrawer = new InfiniteTrackDrawer(new AnimationTrackKeyDataSource(animationTrack));
}
else if (sequenceActor.HasAnyAnimatableParameters() && !sequenceActor.clips.Any())
{
m_InfiniteTrackDrawer = new InfiniteTrackDrawer(new TrackPropertyCurvesDataSource(sequenceActor));
}
UpdateInfiniteClipEditor(w.TimelineWindow);
var bindings = track.outputs.ToArray();
m_TrackDrawData.m_HasBinding = bindings.Length > 0;
if (m_TrackDrawData.m_HasBinding)
{
m_TrackDrawData.m_Binding = bindings[0];
}
m_TrackDrawData.m_IsSubTrack = IsSubTrack();
m_TrackDrawData.m_AllowsRecording = DoesTrackAllowsRecording(sequenceActor);
m_DefaultTrackIcon = TrackResourceCache.GetTrackIcon(track);
m_TrackEditor = CustomTimelineEditorCache.GetTrackEditor(sequenceActor);
try
{
m_TrackDrawOptions = m_TrackEditor.GetTrackOptions(track, null);
}
catch (Exception e)
{
Debug.LogException(e);
m_TrackDrawOptions = CustomTimelineEditorCache.GetDefaultTrackEditor().GetTrackOptions(track, null);
}
m_TrackDrawOptions.errorText = null; // explicitly setting to null for an uninitialized state
RebuildGUICacheIfNecessary();
}
static void RecursiveSubtrackClone(TrackAsset source, TrackAsset duplicate, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, PlayableAsset assetOwner)
{
var subtracks = source.GetChildTracks();
foreach (var sub in subtracks)
{
var newSub = TimelineHelpers.Clone(duplicate, sub, sourceTable, destTable, assetOwner);
duplicate.AddChild(newSub);
RecursiveSubtrackClone(sub, newSub, sourceTable, destTable, assetOwner);
// Call the custom editor on Create
var customEditor = CustomTimelineEditorCache.GetTrackEditor(newSub);
customEditor.OnCreate_Safe(newSub, sub);
// registration has to happen AFTER recursion
TimelineCreateUtilities.SaveAssetIntoObject(newSub, assetOwner);
TimelineUndo.RegisterCreatedObjectUndo(newSub, L10n.Tr("Duplicate"));
}
}
void UpdateDrawData(WindowState state)
{
if (Event.current.type == EventType.Layout)
{
m_TrackDrawData.m_ShowTrackBindings = false;
m_TrackDrawData.m_TrackBinding = null;
if (state.editSequence.director != null && showSceneReference)
{
m_TrackDrawData.m_ShowTrackBindings = state.GetWindow().currentMode.ShouldShowTrackBindings(state);
m_TrackDrawData.m_TrackBinding = state.editSequence.director.GetGenericBinding(track);
}
var lastError = m_TrackDrawOptions.errorText;
var lastHeight = m_TrackDrawOptions.minimumHeight;
try
{
m_TrackDrawOptions = m_TrackEditor.GetTrackOptions(track, m_TrackDrawData.m_TrackBinding);
}
catch (Exception e)
{
Debug.LogException(e);
m_TrackDrawOptions = CustomTimelineEditorCache.GetDefaultTrackEditor().GetTrackOptions(track, m_TrackDrawData.m_TrackBinding);
}
m_TrackDrawData.m_AllowsRecording = DoesTrackAllowsRecording(track);
m_TrackDrawData.m_TrackIcon = m_TrackDrawOptions.icon;
if (m_TrackDrawData.m_TrackIcon == null)
{
m_TrackDrawData.m_TrackIcon = m_DefaultTrackIcon.image;
}
// track height has changed. need to update gui
if (!Mathf.Approximately(lastHeight, m_TrackDrawOptions.minimumHeight))
{
state.Refresh();
}
}
}
public static void BindWithInteractiveEditorValidation(PlayableDirector director, TrackAsset bindTo, Object objectToBind)
{
TrackEditor trackEditor = CustomTimelineEditorCache.GetTrackEditor(bindTo);
if (trackEditor.SupportsBindingAssign())
{
BindWithEditorValidation(director, bindTo, objectToBind);
}
else
{
Type bindingType = TypeUtility.GetTrackBindingAttribute(bindTo.GetType())?.type;
BindingAction action = GetBindingAction(bindingType, objectToBind);
if (action == BindingAction.BindToMissingComponent)
{
InteractiveBindToMissingComponent(director, bindTo, objectToBind, bindingType);
}
else
{
var validatedObject = GetBinding(action, objectToBind, bindingType);
Bind(director, bindTo, validatedObject);
}
}
}
public static IMarker CreateMarkerAtTime(TrackAsset parent, Type markerType, double time)
{
var marker = parent.CreateMarker(markerType, time);
var obj = marker as ScriptableObject;
if (obj != null)
{
obj.name = TypeUtility.GetDisplayName(markerType);
}
SelectionManager.Add(marker);
try
{
CustomTimelineEditorCache.GetMarkerEditor(marker).OnCreate(marker, null);
}
catch (Exception e)
{
Debug.LogException(e);
}
return(marker);
}
public static bool HasCustomEditor(TimelineClip clip)
{
var editor = CustomTimelineEditorCache.GetClipEditor(clip);
return(editor != CustomTimelineEditorCache.GetDefaultClipEditor());
}
internal static TrackAsset Duplicate(this TrackAsset track, PlayableDirector director,
TimelineAsset destinationTimeline = null)
{
if (track == null)
{
return(null);
}
// if the destination is us, clear to avoid bad parenting (case 919421)
if (destinationTimeline == track.timelineAsset)
{
destinationTimeline = null;
}
var timelineParent = track.parent as TimelineAsset;
var trackParent = track.parent as TrackAsset;
if (timelineParent == null && trackParent == null)
{
Debug.LogWarning("Cannot duplicate track because it is not parented to known type");
return(null);
}
// Determine who the final parent is. If we are pasting into another track, it's always the timeline.
// Otherwise it's the original parent
PlayableAsset finalParent = destinationTimeline != null ? destinationTimeline : track.parent;
// grab the list of tracks to generate a name from (923360) to get the list of names
// no need to do this part recursively
var finalTrackParent = finalParent as TrackAsset;
var finalTimelineAsset = finalParent as TimelineAsset;
var otherTracks = (finalTimelineAsset != null) ? finalTimelineAsset.trackObjects : finalTrackParent.subTracksObjects;
// Important to create the new objects before pushing the original undo, or redo breaks the
// sequence
var newTrack = TimelineHelpers.Clone(finalParent, track, director, finalParent);
newTrack.name = TimelineCreateUtilities.GenerateUniqueActorName(otherTracks, newTrack.name);
RecursiveSubtrackClone(track, newTrack, director, finalParent);
TimelineUndo.RegisterCreatedObjectUndo(newTrack, "Duplicate");
TimelineCreateUtilities.SaveAssetIntoObject(newTrack, finalParent);
TimelineUndo.PushUndo(finalParent, "Duplicate");
if (destinationTimeline != null) // other timeline
{
destinationTimeline.AddTrackInternal(newTrack);
}
else if (timelineParent != null) // this timeline, no parent
{
ReparentTracks(new List <TrackAsset> {
newTrack
}, timelineParent, timelineParent.GetRootTracks().Last(), false);
}
else // this timeline, with parent
{
trackParent.AddChild(newTrack);
}
// Call the custom editor. this check prevents the call when copying to the clipboard
if (destinationTimeline == null || destinationTimeline == TimelineEditor.inspectedAsset)
{
var customEditor = CustomTimelineEditorCache.GetTrackEditor(newTrack);
try
{
customEditor.OnCreate(newTrack, track);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
return(newTrack);
}
