Files
.vs
Assets
Library
APIUpdater
Artifacts
Bee
BuildPlayerData
PackageCache
com.unity.collab-proxy@2.5.2
com.unity.editorcoroutines@1.0.0
com.unity.ext.nunit@1.0.6
com.unity.feature.development@1.0.1
com.unity.ide.rider@3.0.31
com.unity.ide.visualstudio@2.0.22
com.unity.ide.vscode@1.2.5
com.unity.modules.ai@1.0.0
com.unity.modules.androidjni@1.0.0
com.unity.modules.animation@1.0.0
com.unity.modules.assetbundle@1.0.0
com.unity.modules.audio@1.0.0
com.unity.modules.cloth@1.0.0
com.unity.modules.director@1.0.0
com.unity.modules.imageconversion@1.0.0
com.unity.modules.imgui@1.0.0
com.unity.modules.jsonserialize@1.0.0
com.unity.modules.particlesystem@1.0.0
com.unity.modules.physics2d@1.0.0
com.unity.modules.physics@1.0.0
com.unity.modules.screencapture@1.0.0
com.unity.modules.subsystems@1.0.0
com.unity.modules.terrain@1.0.0
com.unity.modules.terrainphysics@1.0.0
com.unity.modules.tilemap@1.0.0
com.unity.modules.ui@1.0.0
com.unity.modules.uielements@1.0.0
com.unity.modules.umbra@1.0.0
com.unity.modules.unityanalytics@1.0.0
com.unity.modules.unitywebrequest@1.0.0
com.unity.modules.unitywebrequestassetbundle@1.0.0
com.unity.modules.unitywebrequestaudio@1.0.0
com.unity.modules.unitywebrequesttexture@1.0.0
com.unity.modules.unitywebrequestwww@1.0.0
com.unity.modules.vehicles@1.0.0
com.unity.modules.video@1.0.0
com.unity.modules.vr@1.0.0
com.unity.modules.wind@1.0.0
com.unity.modules.xr@1.0.0
com.unity.performance.profile-analyzer@1.2.2
com.unity.settings-manager@2.0.1
com.unity.test-framework@1.1.33
com.unity.testtools.codecoverage@1.2.6
com.unity.textmeshpro@3.0.6
com.unity.timeline@1.7.6
DocCodeExamples
Documentation~
Editor
Actions
Menus
ActionContext.cs
ActionContext.cs.meta
ActionManager.cs
ActionManager.cs.meta
ClipAction.cs
ClipAction.cs.meta
ClipsActions.cs
ClipsActions.cs.meta
IAction.cs
IAction.cs.meta
IMenuChecked.cs
IMenuChecked.cs.meta
IMenuName.cs
IMenuName.cs.meta
Invoker.cs
Invoker.cs.meta
MarkerAction.cs
MarkerAction.cs.meta
MarkerActions.cs
MarkerActions.cs.meta
Menus.meta
TimelineAction.cs
TimelineAction.cs.meta
TimelineActions.cs
TimelineActions.cs.meta
TrackAction.cs
TrackAction.cs.meta
TrackActions.cs
TrackActions.cs.meta
Activation
Analytics
Animation
Attributes
Audio
ControlTrack
CustomEditors
Extensions
Items
Localization
Manipulators
Playables
Properties
Recording
Signals
State
StyleSheets
Undo
Utilities
Window
inspectors
treeview
Actions.meta
Activation.meta
Analytics.meta
Animation.meta
Attributes.meta
Audio.meta
ControlTrack.meta
CurveEditUtility.cs
CurveEditUtility.cs.meta
CustomEditors.meta
DirectorNamedColor.cs
DirectorNamedColor.cs.meta
DirectorStyles.cs
DirectorStyles.cs.meta
Extensions.meta
Items.meta
Localization.meta
Manipulators.meta
MenuPriority.cs
MenuPriority.cs.meta
Playables.meta
Properties.meta
Recording.meta
Shortcuts.cs
Shortcuts.cs.meta
Signals.meta
State.meta
StyleSheets.meta
TimelineEditor.cs
TimelineEditor.cs.meta
TimelineHelpers.cs
TimelineHelpers.cs.meta
TimelineSelection.cs
TimelineSelection.cs.meta
TimelineUtility.cs
TimelineUtility.cs.meta
Tooltip.cs
Tooltip.cs.meta
Trackhead.cs
Trackhead.cs.meta
Undo.meta
Unity.Timeline.Editor.asmdef
Unity.Timeline.Editor.asmdef.meta
UnityEditorInternals.cs
UnityEditorInternals.cs.meta
Utilities.meta
Window.meta
inspectors.meta
treeview.meta
Runtime
Samples~
.signature
CHANGELOG.md
CHANGELOG.md.meta
DocCodeExamples.meta
Editor.meta
LICENSE.md
LICENSE.md.meta
README.md
README.md.meta
Runtime.meta
ValidationExceptions.json
ValidationExceptions.json.meta
package.json
package.json.meta
com.unity.ugui@1.0.0
com.unity.visualscripting@1.9.4
PackageManager
PlayModeViewStates
PlayerDataCache
ScriptAssemblies
Search
ShaderCache
SplashScreenCache
StateCache
UIElements
AnnotationManager
ArtifactDB
ArtifactDB-lock
BuildPlayer.prefs
BuildSettings.asset
EditorOnlyScriptingSettings.json
EditorOnlyVirtualTextureState.json
EditorSnapSettings.asset
EditorUserBuildSettings.asset
InspectorExpandedItems.asset
LastBuild.buildreport
LastSceneManagerSetup.txt
LibraryFormatVersion.txt
MonoManager.asset
SceneVisibilityState.asset
ScriptMapper
ShaderCache.db
SourceAssetDB
SourceAssetDB-lock
SpriteAtlasDatabase.asset
Style.catalog
expandedItems
ilpp.pid
Logs
Packages
ProjectSettings
UserSettings
obj
.vsconfig
Assembly-CSharp.Player.csproj
Assembly-CSharp.csproj
TM1.sln
Unity.CollabProxy.Editor.csproj
Unity.EditorCoroutines.Editor.csproj
Unity.Performance.Profile-Analyzer.Editor.csproj
Unity.PlasticSCM.Editor.csproj
Unity.Rider.Editor.csproj
Unity.Settings.Editor.csproj
Unity.TestTools.CodeCoverage.Editor.OpenCover.Model.csproj
Unity.TestTools.CodeCoverage.Editor.OpenCover.Mono.Reflection.csproj
Unity.TestTools.CodeCoverage.Editor.csproj
Unity.TextMeshPro.Editor.csproj
Unity.TextMeshPro.Player.csproj
Unity.TextMeshPro.csproj
Unity.Timeline.Editor.csproj
Unity.Timeline.Player.csproj
Unity.Timeline.csproj
Unity.VSCode.Editor.csproj
Unity.VisualScripting.Core.Editor.csproj
Unity.VisualScripting.Core.Player.csproj
Unity.VisualScripting.Core.csproj
Unity.VisualScripting.Flow.Editor.csproj
Unity.VisualScripting.Flow.Player.csproj
Unity.VisualScripting.Flow.csproj
Unity.VisualScripting.SettingsProvider.Editor.csproj
Unity.VisualScripting.Shared.Editor.csproj
Unity.VisualScripting.State.Editor.csproj
Unity.VisualScripting.State.Player.csproj
Unity.VisualScripting.State.csproj
Unity.VisualStudio.Editor.csproj
UnityEditor.TestRunner.csproj
UnityEditor.UI.csproj
UnityEngine.TestRunner.Player.csproj
UnityEngine.TestRunner.csproj
UnityEngine.UI.Player.csproj
UnityEngine.UI.csproj

528 lines
18 KiB
C#
Raw Permalink Normal View History

2025-01-17 13:10:20 +01:00
using System.Collections.Generic;
using System.Linq;
using JetBrains.Annotations;
using UnityEditor.Timeline.Actions;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;
namespace UnityEditor.Timeline
{
[MenuEntry("Edit in Animation Window", MenuPriority.TrackActionSection.editInAnimationWindow)]
class EditTrackInAnimationWindow : TrackAction
{
public static bool Do(TrackAsset track)
{
AnimationClip clipToEdit = null;
AnimationTrack animationTrack = track as AnimationTrack;
if (animationTrack != null)
{
if (!animationTrack.CanConvertToClipMode())
return false;
clipToEdit = animationTrack.infiniteClip;
}
else if (track.hasCurves)
{
clipToEdit = track.curves;
}
if (clipToEdit == null)
return false;
GameObject gameObject = null;
if (TimelineEditor.inspectedDirector != null)
gameObject = TimelineUtility.GetSceneGameObject(TimelineEditor.inspectedDirector, track);
var timeController = TimelineAnimationUtilities.CreateTimeController(CreateTimeControlClipData(track));
TimelineAnimationUtilities.EditAnimationClipWithTimeController(clipToEdit, timeController, gameObject);
return true;
}
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks)
{
if (!tracks.Any())
return ActionValidity.Invalid;
var firstTrack = tracks.First();
if (firstTrack is AnimationTrack)
{
var animTrack = firstTrack as AnimationTrack;
if (animTrack.CanConvertToClipMode())
return ActionValidity.Valid;
}
else if (firstTrack.hasCurves)
{
return ActionValidity.Valid;
}
return ActionValidity.NotApplicable;
}
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
return Do(tracks.First());
}
static TimelineWindowTimeControl.ClipData CreateTimeControlClipData(TrackAsset track)
{
var data = new TimelineWindowTimeControl.ClipData();
data.track = track;
data.start = track.start;
data.duration = track.duration;
return data;
}
}
[MenuEntry("Lock selected track only", MenuPriority.TrackActionSection.lockSelected)]
class LockSelectedTrack : TrackAction, IMenuName
{
public static readonly string LockSelectedTrackOnlyText = L10n.Tr("Lock selected track only");
public static readonly string UnlockSelectedTrackOnlyText = L10n.Tr("Unlock selected track only");
public string menuName { get; private set; }
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks)
{
UpdateMenuName(tracks);
if (tracks.Any(track => TimelineUtility.IsLockedFromGroup(track) || track is GroupTrack || !track.subTracksObjects.Any()))
return ActionValidity.NotApplicable;
return ActionValidity.Valid;
}
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
if (!tracks.Any()) return false;
var hasUnlockedTracks = tracks.Any(x => !x.locked);
Lock(tracks.Where(p => !(p is GroupTrack)).ToArray(), hasUnlockedTracks);
return true;
}
void UpdateMenuName(IEnumerable<TrackAsset> tracks)
{
menuName = tracks.All(t => t.locked) ? UnlockSelectedTrackOnlyText : LockSelectedTrackOnlyText;
}
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);
}
}
[MenuEntry("Lock", MenuPriority.TrackActionSection.lockTrack)]
[Shortcut(Shortcuts.Timeline.toggleLock)]
class LockTrack : TrackAction, IMenuName
{
static readonly string k_LockText = L10n.Tr("Lock");
static readonly string k_UnlockText = L10n.Tr("Unlock");
public string menuName { get; private set; }
void UpdateMenuName(IEnumerable<TrackAsset> tracks)
{
menuName = tracks.Any(x => !x.locked) ? k_LockText : k_UnlockText;
}
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
if (!tracks.Any()) return false;
var hasUnlockedTracks = tracks.Any(x => !x.locked);
SetLockState(tracks, hasUnlockedTracks);
return true;
}
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks)
{
UpdateMenuName(tracks);
tracks = tracks.RemoveTimelineMarkerTrackFromList(TimelineEditor.inspectedAsset);
if (!tracks.Any())
return ActionValidity.NotApplicable;
if (tracks.Any(TimelineUtility.IsLockedFromGroup))
return ActionValidity.Invalid;
return ActionValidity.Valid;
}
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);
}
}
[UsedImplicitly]
[MenuEntry("Show Markers", MenuPriority.TrackActionSection.showHideMarkers)]
[ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)]
class ShowHideMarkers : TrackAction, IMenuChecked
{
public bool isChecked { get; private set; }
void UpdateCheckedStatus(IEnumerable<TrackAsset> tracks)
{
isChecked = tracks.All(x => x.GetShowMarkers());
}
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks)
{
UpdateCheckedStatus(tracks);
if (tracks.Any(x => x is GroupTrack) || tracks.Any(t => t.GetMarkerCount() == 0))
return ActionValidity.NotApplicable;
if (tracks.Any(t => t.lockedInHierarchy))
{
return ActionValidity.Invalid;
}
return ActionValidity.Valid;
}
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
if (!tracks.Any()) return false;
var hasUnlockedTracks = tracks.Any(x => !x.GetShowMarkers());
ShowHide(tracks, hasUnlockedTracks);
return true;
}
static void ShowHide(IEnumerable<TrackAsset> tracks, bool shouldLock)
{
if (!tracks.Any())
return;
foreach (var track in tracks)
track.SetShowTrackMarkers(shouldLock);
TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw);
}
}
[MenuEntry("Mute selected track only", MenuPriority.TrackActionSection.muteSelected), UsedImplicitly]
class MuteSelectedTrack : TrackAction, IMenuName
{
public static readonly string MuteSelectedText = L10n.Tr("Mute selected track only");
public static readonly string UnmuteSelectedText = L10n.Tr("Unmute selected track only");
public string menuName { get; private set; }
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks)
{
UpdateMenuName(tracks);
if (tracks.Any(track => TimelineUtility.IsParentMuted(track) || track is GroupTrack || !track.subTracksObjects.Any()))
return ActionValidity.NotApplicable;
return ActionValidity.Valid;
}
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
if (!tracks.Any())
return false;
var hasUnmutedTracks = tracks.Any(x => !x.muted);
Mute(tracks.Where(p => !(p is GroupTrack)).ToArray(), hasUnmutedTracks);
return true;
}
void UpdateMenuName(IEnumerable<TrackAsset> tracks)
{
menuName = tracks.All(t => t.muted) ? UnmuteSelectedText : MuteSelectedText;
}
public static void Mute(TrackAsset[] tracks, bool shouldMute)
{
if (tracks.Length == 0)
return;
foreach (var track in tracks.Where(t => !TimelineUtility.IsParentMuted(t)))
{
TimelineUndo.PushUndo(track, L10n.Tr("Mute Tracks"));
track.muted = shouldMute;
}
TimelineEditor.Refresh(RefreshReason.ContentsModified);
}
}
[MenuEntry("Mute", MenuPriority.TrackActionSection.mute)]
[Shortcut(Shortcuts.Timeline.toggleMute)]
class MuteTrack : TrackAction, IMenuName
{
static readonly string k_MuteText = L10n.Tr("Mute");
static readonly string k_UnMuteText = L10n.Tr("Unmute");
public string menuName { get; private set; }
void UpdateMenuName(IEnumerable<TrackAsset> tracks)
{
menuName = tracks.Any(x => !x.muted) ? k_MuteText : k_UnMuteText;
}
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
if (!tracks.Any() || tracks.Any(TimelineUtility.IsParentMuted))
return false;
var hasUnmutedTracks = tracks.Any(x => !x.muted);
Mute(tracks, hasUnmutedTracks);
return true;
}
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks)
{
UpdateMenuName(tracks);
if (tracks.Any(TimelineUtility.IsLockedFromGroup))
return ActionValidity.Invalid;
return ActionValidity.Valid;
}
public static void Mute(IEnumerable<TrackAsset> tracks, bool shouldMute)
{
if (!tracks.Any())
return;
foreach (var track in tracks)
{
if (track as GroupTrack == null)
Mute(track.GetChildTracks().ToArray(), shouldMute);
TimelineUndo.PushUndo(track, L10n.Tr("Mute Tracks"));
track.muted = shouldMute;
}
TimelineEditor.Refresh(RefreshReason.ContentsModified);
}
}
class DeleteTracks : TrackAction
{
public static void Do(TimelineAsset timeline, TrackAsset track)
{
SelectionManager.Remove(track);
TrackModifier.DeleteTrack(timeline, track);
}
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks) => ActionValidity.Valid;
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
tracks = tracks.RemoveTimelineMarkerTrackFromList(TimelineEditor.inspectedAsset);
// disable preview mode so deleted tracks revert to default state
// Case 956129: Disable preview mode _before_ deleting the tracks, since clip data is still needed
TimelineEditor.state.previewMode = false;
TimelineAnimationUtilities.UnlinkAnimationWindowFromTracks(tracks);
foreach (var track in tracks)
Do(TimelineEditor.inspectedAsset, track);
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
return true;
}
}
class CopyTracksToClipboard : TrackAction
{
public static bool Do(TrackAsset[] tracks)
{
var action = new CopyTracksToClipboard();
return action.Execute(tracks);
}
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks) => ActionValidity.Valid;
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
tracks = tracks.RemoveTimelineMarkerTrackFromList(TimelineEditor.inspectedAsset);
TimelineEditor.clipboard.CopyTracks(tracks);
return true;
}
}
class DuplicateTracks : TrackAction
{
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks) => ActionValidity.Valid;
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;
}
internal static void DuplicateBindings(TrackAsset track, TrackAsset newTrack, PlayableDirector director)
{
var originalTracks = track.GetFlattenedChildTracks().Append(track);
var newTracks = newTrack.GetFlattenedChildTracks().Append(newTrack);
var toBind = new List<Tuple<TrackAsset, Object>>();
// Collect all track bindings to duplicate
var originalIt = originalTracks.GetEnumerator();
var newIt = newTracks.GetEnumerator();
while (originalIt.MoveNext() && newIt.MoveNext())
{
var binding = director.GetGenericBinding(originalIt.Current);
if (binding != null)
toBind.Add(new Tuple<TrackAsset, Object>(newIt.Current, binding));
}
//Only create Director undo if there are bindings to duplicate
if (toBind.Count > 0)
TimelineUndo.PushUndo(TimelineEditor.inspectedDirector, L10n.Tr("Duplicate"));
//Assign bindings for all tracks after undo.
foreach (var binding in toBind)
{
TimelineEditor.inspectedDirector.SetGenericBinding(binding.Item1, binding.Item2);
}
}
}
[MenuEntry("Remove Invalid Markers", MenuPriority.TrackActionSection.removeInvalidMarkers), UsedImplicitly]
class RemoveInvalidMarkersAction : TrackAction
{
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks)
{
if (tracks.Any(target => target != null && target.GetMarkerCount() != target.GetMarkersRaw().Count()))
return ActionValidity.Valid;
return ActionValidity.NotApplicable;
}
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
bool anyRemoved = false;
foreach (var target in tracks)
{
var invalids = target.GetMarkersRaw().Where(x => !(x is IMarker)).ToList();
foreach (var m in invalids)
{
anyRemoved = true;
target.DeleteMarkerRaw(m);
}
}
if (anyRemoved)
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
return anyRemoved;
}
}
[Shortcut(Shortcuts.Timeline.collapseTrack)]
[UsedImplicitly]
class CollapseTrackAction : TrackAction
{
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks)
{
var collapsibleTracks = tracks.Where(track => track.subTracksObjects.Any());
if (!collapsibleTracks.Any())
return ActionValidity.NotApplicable;
if (collapsibleTracks.All(track => track.IsCollapsed()))
return ActionValidity.NotApplicable;
return ActionValidity.Valid;
}
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
return KeyboardNavigation.TryCollapse(tracks.Where(track => track.subTracksObjects.Any() && !track.IsCollapsed()));
}
}
[Shortcut(Shortcuts.Timeline.expandTrack)]
[UsedImplicitly]
class ExpandTrackAction : TrackAction
{
public override ActionValidity Validate(IEnumerable<TrackAsset> tracks)
{
var collapsibleTracks = tracks.Where(track => track.subTracksObjects.Any());
if (!collapsibleTracks.Any())
return ActionValidity.NotApplicable;
if (collapsibleTracks.All(track => !track.IsCollapsed()))
return ActionValidity.NotApplicable;
return ActionValidity.Valid;
}
public override bool Execute(IEnumerable<TrackAsset> tracks)
{
return KeyboardNavigation.TryExpand(tracks.Where(track => track.subTracksObjects.Any() && track.IsCollapsed()));
}
}
}