bool IsRecording(WindowState state)
{
return(state.recording && state.IsArmedForRecord(track));
}
public static void PrevKey(UnityEngine.Object target, IEnumerable <PropertyModification> modifications, WindowState state)
{
const double eps = 1e-5;
var keyTimes = GetKeyTimes(target, modifications, state);
if (keyTimes.Count == 0)
{
return;
}
var prevKeys = keyTimes.Where(x => x < state.editSequence.time - eps);
if (prevKeys.Any())
{
state.editSequence.time = prevKeys.Max();
}
}
public override Rect RectToTimeline(Rect trackRect, WindowState state)
{
return(topMarker.RectToTimeline(trackRect, state));
}
internal static UndoPropertyModification[] ProcessUndoModification(UndoPropertyModification[] modifications, WindowState state)
{
if (HasAnyPlayableAssetModifications(modifications))
{
return(ProcessPlayableAssetModification(modifications, state));
}
return(ProcessMonoBehaviourModification(modifications, state));
}
public static bool HasCurve(IEnumerable <PropertyModification> modifications, UnityEngine.Object target,
WindowState state)
{
return(GetKeyTimes(target, modifications, state).Any());
}
public void Init(WindowState owner)
{
m_WindowState = owner;
}
public TimelineMarkerHeaderGUI(TimelineAsset asset, WindowState state)
{
m_TrackHash = -1;
timeline = asset;
this.state = state;
}
protected virtual bool IsChecked(WindowState state, TrackAsset[] tracks)
{
return(false);
}
public static void Invoke <T>(WindowState state, TrackAsset[] tracks) where T : TrackAction
{
actions.First(x => x.GetType() == typeof(T)).Execute(state, tracks);
}
protected virtual MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks)
{
return(tracks.Length > 0 ? MenuActionDisplayState.Visible : MenuActionDisplayState.Disabled);
}
public override bool Execute(WindowState state, TrackAsset[] tracks)
{
return(Do(state, tracks[0]));
}
public abstract bool Execute(WindowState state, TrackAsset[] tracks);
// For testing
internal MenuActionDisplayState InternalGetDisplayState(WindowState state, TrackAsset[] tracks)
{
return(GetDisplayState(state, tracks));
}
// background to draw during recording
void DrawRecordingTrackBackground(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state)
{
if (drawer != null)
{
drawer.DrawRecordingBackground(trackRect, trackAsset, visibleTime, state);
}
}
public void Draw(Rect rect, WindowState state, double time)
{
var clipRect = new Rect(0.0f, 0.0f, TimelineWindow.instance.position.width, TimelineWindow.instance.position.height);
clipRect.xMin += state.sequencerHeaderWidth;
using (new GUIViewportScope(clipRect))
{
Vector2 windowCoordinate = rect.min;
windowCoordinate.y += 4.0f;
windowCoordinate.x = state.TimeToPixel(time);
m_BoundingRect = new Rect((windowCoordinate.x - widgetWidth / 2.0f), windowCoordinate.y, widgetWidth, widgetHeight);
// Do not paint if the time cursor goes outside the timeline bounds...
if (Event.current.type == EventType.Repaint)
{
if (m_BoundingRect.xMax < state.timeAreaRect.xMin)
{
return;
}
if (m_BoundingRect.xMin > state.timeAreaRect.xMax)
{
return;
}
}
var top = new Vector3(windowCoordinate.x, rect.y - DirectorStyles.kDurationGuiThickness);
var bottom = new Vector3(windowCoordinate.x, rect.yMax);
if (drawLine)
{
Rect lineRect = Rect.MinMaxRect(top.x - 0.5f, top.y, bottom.x + 0.5f, bottom.y);
EditorGUI.DrawRect(lineRect, lineColor);
}
if (drawHead)
{
Color c = GUI.color;
GUI.color = headColor;
GUI.Box(bounds, m_HeaderContent, m_Style);
GUI.color = c;
if (canMoveHead)
{
EditorGUIUtility.AddCursorRect(bounds, MouseCursor.MoveArrow);
}
}
if (showTooltip)
{
m_Tooltip.text = TimeReferenceUtility.ToTimeString(time);
Vector2 position = bounds.position;
position.y = state.timeAreaRect.y;
position.y -= m_Tooltip.bounds.height;
position.x -= Mathf.Abs(m_Tooltip.bounds.width - bounds.width) / 2.0f;
Rect tooltipBounds = bounds;
tooltipBounds.position = position;
m_Tooltip.bounds = tooltipBounds;
m_Tooltip.Draw();
}
}
}
protected override bool IsChecked(WindowState state, TrackAsset[] tracks)
{
return(tracks.All(x => x.GetShowMarkers()));
}
public static void NextKey(UnityEngine.Object target, IList <PropertyModification> modifications, WindowState state)
{
const double eps = 1e-5;
var keyTimes = GetKeyTimes(modifications, state);
if (keyTimes.Count == 0)
{
return;
}
var nextKeys = keyTimes.Where(x => x > state.editSequence.time + eps);
if (nextKeys.Any())
{
state.editSequence.time = nextKeys.Min();
}
}
public static bool Do(WindowState state, TrackAsset[] tracks)
{
var action = new CopyTracksToClipboard();
return(action.Execute(state, tracks));
}
static void DrawMarkerDrawer(DrawData data, WindowState state)
{
DrawMarkerDrawerHeaderBackground(data);
DrawMarkerDrawerHeader(data, state);
DrawMarkerDrawerContentBackground(data);
}
public override bool Execute(WindowState state, TrackAsset[] tracks)
{
TimelineEditor.clipboard.CopyTracks(tracks);
return(true);
}
public MoveItemHandler(WindowState state)
{
m_State = state;
}
internal static void SelectClipsEndingBefore(WindowState state)
{
var tolerance = TimeUtility.GetEpsilon(state.editSequence.time, state.referenceSequence.frameRate);
SelectMenuCallback(x => x.end < state.editSequence.time + tolerance, state);
}
public static void AddKey(IEnumerable <PropertyModification> modifications, WindowState state)
{
var undos = modifications.Select(PropertyModificationToUndoPropertyModification).ToArray();
ProcessUndoModification(undos, state);
}
internal static void SelectClipsStartingAfter(WindowState state)
{
var tolerance = TimeUtility.GetEpsilon(state.editSequence.time, state.referenceSequence.frameRate);
SelectMenuCallback(x => x.start - state.editSequence.time >= -tolerance, state);
}
static HashSet <double> GetKeyTimes(UnityEngine.Object target, IEnumerable <PropertyModification> modifications, WindowState state)
{
var keyTimes = new HashSet <double>();
AnimationClip animationClip;
double keyTime;
bool inRange;
GetClipAndRelativeTime(target, state, out animationClip, out keyTime, out inRange);
if (animationClip == null)
{
return(keyTimes);
}
var component = target as Component;
var playableAsset = target as IPlayableAsset;
var info = AnimationClipCurveCache.Instance.GetCurveInfo(animationClip);
TimelineClip clip = null;
if (component != null)
{
GetTrackForGameObject(component.gameObject, state).FindRecordingClipAtTime(state.editSequence.time, out clip);
}
else if (playableAsset != null)
{
clip = FindClipWithAsset(state.editSequence.asset, playableAsset, state.editSequence.director);
}
foreach (var mod in modifications)
{
EditorCurveBinding temp;
if (HasBinding(target, mod, animationClip, out temp))
{
IEnumerable <double> keys = new HashSet <double>();
if (temp.isPPtrCurve)
{
var curve = info.GetObjectCurveForBinding(temp);
if (curve != null)
{
keys = curve.Select(x => (double)x.time);
}
}
else
{
var curve = info.GetCurveForBinding(temp);
if (curve != null)
{
keys = curve.keys.Select(x => (double)x.time);
}
}
// Transform the times in to 'global' space using the clip
if (clip != null)
{
foreach (var k in keys)
{
var time = clip.FromLocalTimeUnbound(k);
const double eps = 1e-5;
if (time >= clip.start - eps && time <= clip.end + eps)
{
keyTimes.Add(time);
}
}
}
// infinite clip mode, global == local space
else
{
keyTimes.UnionWith(keys);
}
}
}
return(keyTimes);
}
internal static void SelectClipsIntersecting(WindowState state)
{
SelectMenuCallback(x => x.start <= state.editSequence.time && state.editSequence.time <= x.end, state);
}
public static void RemoveCurve(UnityEngine.Object target, IEnumerable <PropertyModification> modifications, WindowState state)
{
AnimationClip clip = null;
double keyTime = 0;
var inRange = false; // not used for curves
if (!GetClipAndRelativeTime(target, state, out clip, out keyTime, out inRange))
{
return;
}
TimelineUndo.PushUndo(clip, "Remove Curve");
foreach (var mod in modifications)
{
EditorCurveBinding temp;
if (HasBinding(target, mod, clip, out temp))
{
if (temp.isPPtrCurve)
{
AnimationUtility.SetObjectReferenceCurve(clip, temp, null);
}
else
{
AnimationUtility.SetEditorCurve(clip, temp, null);
}
}
}
state.ResetPreviewMode();
}
internal static void SelectBlendsIntersecting(WindowState state)
{
SelectMenuCallback(x => SelectBlendingIntersecting(x, state.editSequence.time), state);
}
public override void OnBuildTrackContextMenu(GenericMenu menu, TrackAsset track, UnityEditor.Timeline.WindowState state)
{
base.OnBuildTrackContextMenu(menu, track, state);
menu.AddItem(EditorGUIUtility.TrTextContent("Add Nested Audio Track"), false, (parentTrack) =>
{
AddSubTrack(state, typeof(AudioTrack), "nested track " + track.GetChildTracks().Count().ToString(), track);
},
track);
menu.AddItem(EditorGUIUtility.TrTextContent("Add Effects Track"), false, (parentTrack) =>
{
AddSubTrack(state, typeof(AudioDeckTrack), "Effects" + track.GetChildTracks().Count().ToString(), track);
},
track);
}
void DrawBackground(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state)
{
bool canDrawRecordBackground = IsRecording(state);
if (canDrawRecordBackground)
{
DrawRecordingTrackBackground(trackRect, trackAsset, visibleTime, state);
}
else
{
Color trackBackgroundColor;
if (SelectionManager.Contains(track))
{
trackBackgroundColor = state.IsEditingASubTimeline() ?
DirectorStyles.Instance.customSkin.colorTrackSubSequenceBackgroundSelected :
DirectorStyles.Instance.customSkin.colorTrackBackgroundSelected;
}
else
{
trackBackgroundColor = state.IsEditingASubTimeline() ?
DirectorStyles.Instance.customSkin.colorTrackSubSequenceBackground :
DirectorStyles.Instance.customSkin.colorTrackBackground;
}
EditorGUI.DrawRect(trackRect, trackBackgroundColor);
}
}
