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); } }