public override bool Execute(IEnumerable <TrackAsset> tracks) { tracks = tracks.RemoveTimelineMarkerTrackFromList(TimelineEditor.inspectedAsset); if (tracks.Any()) { SelectionManager.RemoveTimelineSelection(); } foreach (var track in TrackExtensions.FilterTracks(tracks)) { var newTrack = track.Duplicate(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector); //Add all duplicated tracks to selection SelectionManager.Add(newTrack); foreach (var childTrack in newTrack.GetFlattenedChildTracks()) { SelectionManager.Add(childTrack); } //Duplicate bindings for tracks and subtracks if (TimelineEditor.inspectedDirector != null) { DuplicateBindings(track, newTrack, TimelineEditor.inspectedDirector); } } TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); return(true); }
public static void Insert(TimelineAsset asset, double at, double amount, double tolerance) { var tracks = asset.flattenedTracks.Where(x => x.lockedInHierarchy == false).ToList(); // gather all clips var clips = tracks.SelectMany(x => x.clips).Where(x => (x.start - at) >= -tolerance).ToList(); var markers = tracks.SelectMany(x => x.GetMarkers()).Where(x => (x.time - at) >= -tolerance).ToList(); // push undo on the tracks for the clips that are being modified foreach (var t in clips.Select(x => x.parentTrack).Distinct()) { TimelineUndo.PushUndo(t, kInsertTime); } // push the clips foreach (var clip in clips) { clip.start += amount; } // push undos and move the markers foreach (var marker in markers) { var obj = marker as UnityEngine.Object; if (obj != null) { TimelineUndo.PushUndo(obj, kInsertTime); } marker.time += amount; } TimelineEditor.Refresh(RefreshReason.ContentsModified); }
public override bool Execute(IEnumerable <TrackAsset> tracks) { tracks = tracks.RemoveTimelineMarkerTrackFromList(TimelineEditor.inspectedAsset); if (tracks.Any()) { SelectionManager.RemoveTimelineSelection(); } foreach (var track in TrackExtensions.FilterTracks(tracks)) { var newTrack = track.Duplicate(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector); SelectionManager.Add(newTrack); foreach (var childTrack in newTrack.GetFlattenedChildTracks()) { SelectionManager.Add(childTrack); } if (TimelineEditor.inspectedDirector != null) { var binding = TimelineEditor.inspectedDirector.GetGenericBinding(track); if (binding != null) { TimelineUndo.PushUndo(TimelineEditor.inspectedDirector, L10n.Tr("Duplicate")); TimelineEditor.inspectedDirector.SetGenericBinding(newTrack, binding); } } } TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); return(true); }
public static bool CollapseGroup() { if (TrackHeadActive()) { var quit = false; foreach (var track in SelectionManager.SelectedTracks()) { if (!track.GetChildTracks().Any()) { continue; } if (!quit && !track.GetCollapsed()) { quit = true; } track.SetCollapsed(true); } if (quit) { TimelineEditor.Refresh(RefreshReason.ContentsModified); return(true); } var selectedTrack = SelectionManager.SelectedTracks().LastOrDefault(); var parent = selectedTrack != null ? selectedTrack.parent as TrackAsset : null; if (parent) { SelectionManager.SelectOnly(parent); FrameTrackHeader(GetVisibleTracks().First(x => x.track == parent)); return(true); } } return(false); }
public static bool UnCollapseGroup(IEnumerable <TrackAsset> tracks) { if (!TrackHeadActive()) { return(false); } var didUncollapse = false; foreach (TrackAsset track in tracks) { if (!track.GetChildTracks().Any()) { continue; } if (track.GetCollapsed()) { didUncollapse = true; track.SetCollapsed(false); } } if (didUncollapse) { TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); return(true); } return(SelectFirstClipStartingFrom(tracks.Last())); }
internal static UndoPropertyModification[] ProcessPlayableAssetModification(UndoPropertyModification[] modifications, WindowState state, bool allowAdd) { // can't record without a director since the asset being modified might be a scene instance if (state == null || state.editSequence.director == null) { return(modifications); } var remaining = new List <UndoPropertyModification>(); foreach (UndoPropertyModification mod in modifications) { if (!ProcessPlayableAssetModification(mod, state, allowAdd)) { remaining.Add(mod); } } if (remaining.Count != modifications.Length) { TimelineEditor.Refresh(RefreshReason.ContentsModified); } return(remaining.ToArray()); }
public override void OnInspectorGUI() { serializedObject.Update(); EditorGUI.BeginChangeCheck(); EditorGUILayout.PropertyField(m_FrameRateProperty, Styles.FrameRate, GUILayout.MinWidth(k_MinWidth)); var frameRate = m_FrameRateProperty.doubleValue; EditorGUILayout.PropertyField(m_DurationModeProperty, Styles.DurationMode, GUILayout.MinWidth(k_MinWidth)); var durationMode = (TimelineAsset.DurationMode)m_DurationModeProperty.enumValueIndex; var inputEvent = InputEvent.None; if (durationMode == TimelineAsset.DurationMode.FixedLength) { TimelineInspectorUtility.TimeField(m_FixedDurationProperty, Styles.Duration, false, frameRate, double.Epsilon, TimelineClip.kMaxTimeValue * 2, ref inputEvent); } else { var isMixed = targets.Length > 1; TimelineInspectorUtility.TimeField(Styles.Duration, ((TimelineAsset)target).duration, true, isMixed, frameRate, double.MinValue, double.MaxValue, ref inputEvent); } DrawIgnorePreviewProperty(); var changed = EditorGUI.EndChangeCheck(); serializedObject.ApplyModifiedProperties(); if (changed) { TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); } }
public static bool CollapseGroup(IEnumerable <TrackAsset> tracks) { if (!TrackHeadActive()) { return(false); } var didCollapse = false; foreach (TrackAsset track in tracks) { if (!track.GetChildTracks().Any()) { continue; } if (!track.GetCollapsed()) { didCollapse = true; track.SetCollapsed(true); } } if (didCollapse) { TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); return(true); } return(SelectAndShowParentTrack(tracks.LastOrDefault())); }
public static void Insert(TimelineAsset asset, double at, double amount, double tolerance) { var tracks = asset.flattenedTracks.Where(x => x.lockedInHierarchy == false).ToList(); // gather all clips var clips = tracks.SelectMany(x => x.clips).Where(x => (x.start - at) >= -tolerance).ToList(); var markers = tracks.SelectMany(x => x.GetMarkers()).Where(x => (x.time - at) >= -tolerance).ToList(); // push undo on the tracks for the clips that are being modified UndoExtensions.RegisterClips(clips, kInsertTime); // push the clips foreach (var clip in clips) { clip.start += amount; } // push undos and move the markers UndoExtensions.RegisterMarkers(markers, kInsertTime); foreach (var marker in markers) { marker.time += amount; } TimelineEditor.Refresh(RefreshReason.ContentsModified); }
internal bool Execute(ActionContext context, Func <ITimelineItem, ITimelineItem, double> gapBetweenItems) { List <ITimelineItem> items = new List <ITimelineItem>(); items.AddRange(context.clips.Select(p => p.ToItem())); items.AddRange(context.markers.Select(p => p.ToItem())); List <ItemsPerTrack> selectedItems = items.ToItemsPerTrack().ToList(); if (selectedItems.Any()) { var requestedTime = CalculateDuplicateTime(selectedItems, gapBetweenItems); var duplicatedItems = TimelineHelpers.DuplicateItemsUsingCurrentEditMode(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector, selectedItems, requestedTime, "Duplicate Items"); TimelineHelpers.FrameItems(duplicatedItems); SelectionManager.RemoveTimelineSelection(); foreach (var item in duplicatedItems) { SelectionManager.Add(item); } } var tracks = context.tracks.ToArray(); if (tracks.Length > 0) { tracks.Invoke <DuplicateTracks>(); } TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); return(true); }
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); }
public virtual void OnPlayableAssetChangedInInspector() { if (m_ShouldRebuild) { TimelineEditor.Refresh(RefreshReason.ContentsModified); } m_ShouldRebuild = false; }
public static void FinishTrim() { s_CurrentTrimItem = null; TimelineCursors.ClearCursor(); ClearEditMode(); TimelineEditor.Refresh(RefreshReason.ContentsModified); }
public void GoToNextKeyframe(PropertyModification[] modifications) { if (modifications.Length == 0 || modifications[0].target == null) { return; } TimelineRecording.NextKey(modifications[0].target, modifications, state); TimelineEditor.Refresh(RefreshReason.SceneNeedsUpdate); }
static void AddMarkersCallback(ICollection <TrackAsset> targets, Type markerType, double time, Object obj) { SelectionManager.Clear(); foreach (var target in targets) { var marker = TimelineHelpers.CreateMarkerOnTrack(markerType, obj, target, time); SelectionManager.Add(marker); } TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); }
public override bool Execute(IEnumerable <TimelineClip> clips) { bool success = ClipModifier.Split(clips, TimelineEditor.inspectedSequenceTime, TimelineEditor.inspectedDirector); if (success) { TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); } return(success); }
static void ResetFrameLockedPlayback(Object[] asset) { if (TimelineWindow.instance != null && TimelineWindow.instance.state != null && TimelinePreferences.instance.playbackLockedToFrame && ContainsMasterAsset(asset)) { TimelineEditor.RefreshPreviewPlay(); } }
public override bool Execute(IEnumerable <TrackAsset> tracks) { foreach (var animTrack in tracks.OfType <AnimationTrack>()) { animTrack.ConvertFromClipMode(TimelineEditor.inspectedAsset); } TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); return(true); }
public override bool Execute(IEnumerable <TrackAsset> tracks) { foreach (var animTrack in tracks.OfType <AnimationTrack>()) { ConvertToRecordableClip(animTrack); } TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); return(true); }
public override bool Execute(WindowState state, TrackAsset[] tracks) { foreach (var animTrack in tracks.OfType <AnimationTrack>()) { animTrack.ConvertFromClipMode(state.editSequence.asset); } TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); return(true); }
public override bool Execute(IEnumerable <TrackAsset> tracks) { foreach (var animTrack in tracks.OfType <AnimationTrack>()) { animTrack.UnarmForRecord(); animTrack.trackOffset = trackOffset; } TimelineEditor.Refresh(RefreshReason.ContentsModified); return(true); }
public override void OnInspectorGUI() { if (target == null) { return; } serializedObject.Update(); if (!m_TimelineWindow) { m_TimelineWindow = TimelineWindow.instance; } ShowAnimationClipField(); ShowRecordableClipRename(); ShowAnimationClipWarnings(); EditorGUI.BeginChangeCheck(); TransformOffsetsGUI(); // extra checks are because the context menu may need to cause a re-evaluate bool changed = EditorGUI.EndChangeCheck() || m_LastPosition != m_PositionProperty.vector3Value || m_LastRotation != m_RotationProperty.vector3Value; m_LastPosition = m_PositionProperty.vector3Value; m_LastRotation = m_RotationProperty.vector3Value; if (changed) { // updates the changed properties and pushes them to the active playable serializedObject.ApplyModifiedProperties(); ((AnimationPlayableAsset)target).LiveLink(); // force an evaluate to happen next frame if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) { TimelineWindow.instance.state.Evaluate(); } } EditorGUI.BeginChangeCheck(); EditorGUILayout.PropertyField(m_ApplyFootIK, Styles.ApplyFootIK); EditorGUILayout.PropertyField(m_Loop, Styles.Loop); if (EditorGUI.EndChangeCheck()) { TimelineEditor.Refresh(RefreshReason.ContentsModified); } serializedObject.ApplyModifiedProperties(); }
// Called when a prefab change is applied to the scene. // Redraw so control tracks that use prefabs can show changes void OnPrefabApplied(GameObject go) { if (!state.previewMode) return; // if we added a component this frame, then rebuild, otherwise just let // the individual playable handle the prefab application if (Time.frameCount == m_ComponentAddedFrame) TimelineEditor.Refresh(RefreshReason.ContentsModified); else TimelineEditor.Refresh(RefreshReason.SceneNeedsUpdate); }
public override bool Execute(WindowState state, TrackAsset[] tracks) { foreach (var animTrack in tracks.OfType <AnimationTrack>()) { state.UnarmForRecord(animTrack); TimelineUndo.PushUndo(animTrack, "Set Transform Offsets"); animTrack.trackOffset = trackOffset; } TimelineEditor.Refresh(RefreshReason.ContentsModified); return(true); }
public static void SetLockState(IEnumerable <TrackAsset> tracks, bool shouldLock) { if (!tracks.Any()) { return; } foreach (var track in tracks) { if (TimelineUtility.IsLockedFromGroup(track)) { continue; } if (track as GroupTrack == null) { SetLockState(track.GetChildTracks().ToArray(), shouldLock); } TimelineUndo.PushUndo(track, L10n.Tr("Lock Tracks")); track.locked = shouldLock; } // find the tracks we've locked. unselect anything locked and remove recording. foreach (var track in tracks) { if (TimelineUtility.IsLockedFromGroup(track) || !track.locked) { continue; } var flattenedChildTracks = track.GetFlattenedChildTracks(); foreach (var i in track.clips) { SelectionManager.Remove(i); } track.UnarmForRecord(); foreach (var child in flattenedChildTracks) { SelectionManager.Remove(child); child.UnarmForRecord(); foreach (var clip in child.GetClips()) { SelectionManager.Remove(clip); } } } // no need to rebuild, just repaint (including inspectors) InspectorWindow.RepaintAllInspectors(); TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); }
static WaveformPreview CreateWaveformPreview(AudioClip audioClip, Rect quantizedRect) { WaveformPreview preview = WaveformPreviewFactory.Create((int)quantizedRect.width, audioClip); Color waveColour = GammaCorrect(DirectorStyles.Instance.customSkin.colorAudioWaveform); Color transparent = waveColour; transparent.a = 0; preview.backgroundColor = transparent; preview.waveColor = waveColour; preview.SetChannelMode(WaveformPreview.ChannelMode.MonoSum); preview.updated += () => TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); return(preview); }
public override bool Execute(ActionContext context) { if (!CanPaste(context.invocationTime)) { return(false); } PasteItems(context.invocationTime); PasteTracks(); TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); return(true); }
public static void Lock(TrackAsset[] tracks, bool shouldlock) { if (tracks.Length == 0) { return; } foreach (var track in tracks.Where(t => !TimelineUtility.IsLockedFromGroup(t))) { TimelineUndo.PushUndo(track, L10n.Tr("Lock Tracks")); track.locked = shouldlock; } TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); }
static void ShowHide(IEnumerable <TrackAsset> tracks, bool shouldLock) { if (!tracks.Any()) { return; } foreach (var track in tracks) { track.SetShowTrackMarkers(shouldLock); } TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); }
public static void ResetClipOffsets(TimelineClip[] clips) { foreach (var clip in clips) { var asset = clip.asset as AnimationPlayableAsset; if (asset != null) { asset.ResetOffsets(); } } InspectorWindow.RepaintAllInspectors(); TimelineEditor.Refresh(RefreshReason.ContentsModified); }