From c55fba8ab2a1c9d3df65eda4a5a1e957f4aa1f78 Mon Sep 17 00:00:00 2001 From: Andrew Lee Date: Sun, 19 Apr 2020 17:19:32 -0400 Subject: Inital commit --- .../Editor/Manipulators/AddDelete.meta | 8 + .../Manipulators/AddDelete/AddDeleteItemModeMix.cs | 26 ++ .../AddDelete/AddDeleteItemModeMix.cs.meta | 11 + .../AddDelete/AddDeleteItemModeReplace.cs | 18 ++ .../AddDelete/AddDeleteItemModeReplace.cs.meta | 11 + .../AddDelete/AddDeleteItemModeRipple.cs | 18 ++ .../AddDelete/AddDeleteItemModeRipple.cs.meta | 11 + .../Manipulators/AddDelete/IAddDeleteItemMode.cs | 10 + .../AddDelete/IAddDeleteItemMode.cs.meta | 11 + .../Editor/Manipulators/Cursors.meta | 8 + .../Editor/Manipulators/Cursors/TimelineCursors.cs | 95 ++++++ .../Manipulators/Cursors/TimelineCursors.cs.meta | 11 + .../Editor/Manipulators/EditMode.cs | 344 +++++++++++++++++++++ .../Editor/Manipulators/EditMode.cs.meta | 11 + .../Editor/Manipulators/EditModeInputHandler.cs | 199 ++++++++++++ .../Manipulators/EditModeInputHandler.cs.meta | 11 + .../Editor/Manipulators/Move.meta | 8 + .../Editor/Manipulators/Move/IMoveItemMode.cs | 28 ++ .../Editor/Manipulators/Move/IMoveItemMode.cs.meta | 11 + .../Editor/Manipulators/Move/MoveItemHandler.cs | 312 +++++++++++++++++++ .../Manipulators/Move/MoveItemHandler.cs.meta | 11 + .../Editor/Manipulators/Move/MoveItemModeMix.cs | 138 +++++++++ .../Manipulators/Move/MoveItemModeMix.cs.meta | 11 + .../Manipulators/Move/MoveItemModeReplace.cs | 99 ++++++ .../Manipulators/Move/MoveItemModeReplace.cs.meta | 11 + .../Editor/Manipulators/Move/MoveItemModeRipple.cs | 271 ++++++++++++++++ .../Manipulators/Move/MoveItemModeRipple.cs.meta | 11 + .../Editor/Manipulators/Move/MovingItems.cs | 137 ++++++++ .../Editor/Manipulators/Move/MovingItems.cs.meta | 11 + .../Editor/Manipulators/Sequence.meta | 8 + .../Editor/Manipulators/Sequence/EaseClip.cs | 146 +++++++++ .../Editor/Manipulators/Sequence/EaseClip.cs.meta | 11 + .../Editor/Manipulators/Sequence/Jog.cs | 61 ++++ .../Editor/Manipulators/Sequence/Jog.cs.meta | 11 + .../Sequence/MarkerHeaderContextMenu.cs | 24 ++ .../Sequence/MarkerHeaderContextMenu.cs.meta | 11 + .../Manipulators/Sequence/RectangleSelect.cs | 36 +++ .../Manipulators/Sequence/RectangleSelect.cs.meta | 11 + .../Editor/Manipulators/Sequence/RectangleTool.cs | 169 ++++++++++ .../Manipulators/Sequence/RectangleTool.cs.meta | 11 + .../Editor/Manipulators/Sequence/RectangleZoom.cs | 23 ++ .../Manipulators/Sequence/RectangleZoom.cs.meta | 11 + .../Manipulators/Sequence/SelectAndMoveItem.cs | 297 ++++++++++++++++++ .../Sequence/SelectAndMoveItem.cs.meta | 11 + .../Editor/Manipulators/Sequence/TrackZoom.cs | 20 ++ .../Editor/Manipulators/Sequence/TrackZoom.cs.meta | 11 + .../Editor/Manipulators/Sequence/TrimClip.cs | 232 ++++++++++++++ .../Editor/Manipulators/Sequence/TrimClip.cs.meta | 11 + .../Editor/Manipulators/TimeAreaAutoPanner.cs | 72 +++++ .../Editor/Manipulators/TimeAreaAutoPanner.cs.meta | 11 + .../Editor/Manipulators/TimeIndicator.cs | 47 +++ .../Editor/Manipulators/TimeIndicator.cs.meta | 11 + .../Editor/Manipulators/TimelineClipGroup.cs | 54 ++++ .../Editor/Manipulators/TimelineClipGroup.cs.meta | 11 + .../Editor/Manipulators/Trim.meta | 8 + .../Editor/Manipulators/Trim/ITrimItemMode.cs | 23 ++ .../Editor/Manipulators/Trim/ITrimItemMode.cs.meta | 11 + .../Editor/Manipulators/Trim/TrimItemModeMix.cs | 102 ++++++ .../Manipulators/Trim/TrimItemModeMix.cs.meta | 11 + .../Manipulators/Trim/TrimItemModeReplace.cs | 139 +++++++++ .../Manipulators/Trim/TrimItemModeReplace.cs.meta | 11 + .../Editor/Manipulators/Trim/TrimItemModeRipple.cs | 97 ++++++ .../Manipulators/Trim/TrimItemModeRipple.cs.meta | 11 + .../Editor/Manipulators/Utils.meta | 8 + .../Editor/Manipulators/Utils/EditModeGUIUtils.cs | 27 ++ .../Manipulators/Utils/EditModeGUIUtils.cs.meta | 11 + .../Editor/Manipulators/Utils/EditModeMixUtils.cs | 137 ++++++++ .../Manipulators/Utils/EditModeMixUtils.cs.meta | 11 + .../Manipulators/Utils/EditModeReplaceUtils.cs | 57 ++++ .../Utils/EditModeReplaceUtils.cs.meta | 11 + .../Manipulators/Utils/EditModeRippleUtils.cs | 108 +++++++ .../Manipulators/Utils/EditModeRippleUtils.cs.meta | 11 + .../Editor/Manipulators/Utils/EditModeUtils.cs | 123 ++++++++ .../Manipulators/Utils/EditModeUtils.cs.meta | 11 + .../Editor/Manipulators/Utils/ManipulatorsUtils.cs | 19 ++ .../Manipulators/Utils/ManipulatorsUtils.cs.meta | 11 + .../Editor/Manipulators/Utils/PlacementValidity.cs | 13 + .../Manipulators/Utils/PlacementValidity.cs.meta | 11 + 78 files changed, 4165 insertions(+) create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeMix.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeMix.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeReplace.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeReplace.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeRipple.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeRipple.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/IAddDeleteItemMode.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/IAddDeleteItemMode.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors/TimelineCursors.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors/TimelineCursors.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditMode.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditMode.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditModeInputHandler.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditModeInputHandler.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/IMoveItemMode.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/IMoveItemMode.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemHandler.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemHandler.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeMix.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeMix.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeReplace.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeReplace.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeRipple.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeRipple.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MovingItems.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MovingItems.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeAreaAutoPanner.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeAreaAutoPanner.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeIndicator.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeIndicator.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimelineClipGroup.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimelineClipGroup.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/ITrimItemMode.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/ITrimItemMode.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeMix.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeMix.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeReplace.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeReplace.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeRipple.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeRipple.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeGUIUtils.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeGUIUtils.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeMixUtils.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeMixUtils.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeReplaceUtils.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeReplaceUtils.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeRippleUtils.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeRippleUtils.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeUtils.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeUtils.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/ManipulatorsUtils.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/ManipulatorsUtils.cs.meta create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/PlacementValidity.cs create mode 100644 Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/PlacementValidity.cs.meta (limited to 'Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators') diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete.meta new file mode 100644 index 0000000..b18202d --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: db34f310723c62440a05d3e69f262a70 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeMix.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeMix.cs new file mode 100644 index 0000000..2e8a429 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeMix.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace UnityEditor.Timeline +{ + class AddDeleteItemModeMix : IAddDeleteItemMode + { + public void InsertItemsAtTime(IEnumerable itemsGroups, double requestedTime) + { + ItemsUtils.SetItemsStartTime(itemsGroups, requestedTime); + EditModeMixUtils.PrepareItemsForInsertion(itemsGroups); + + if (!EditModeMixUtils.CanInsert(itemsGroups)) + { + var validTime = itemsGroups.Select(c => c.targetTrack).Max(parent => parent.duration); + ItemsUtils.SetItemsStartTime(itemsGroups, validTime); + } + } + + public void RemoveItems(IEnumerable itemsGroups) + { + // Nothing + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeMix.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeMix.cs.meta new file mode 100644 index 0000000..d3d73d7 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeMix.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 41e14f40b915ca743a3dffd18ffc65ab +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeReplace.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeReplace.cs new file mode 100644 index 0000000..6cda779 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeReplace.cs @@ -0,0 +1,18 @@ +using System.Collections.Generic; + +namespace UnityEditor.Timeline +{ + class AddDeleteItemModeReplace : IAddDeleteItemMode + { + public void InsertItemsAtTime(IEnumerable itemsGroups, double requestedTime) + { + ItemsUtils.SetItemsStartTime(itemsGroups, requestedTime); + EditModeReplaceUtils.Insert(itemsGroups); + } + + public void RemoveItems(IEnumerable itemsGroups) + { + // Nothing + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeReplace.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeReplace.cs.meta new file mode 100644 index 0000000..ea32217 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeReplace.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ea28dc637ae40484da709200d3328587 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeRipple.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeRipple.cs new file mode 100644 index 0000000..97de7d1 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeRipple.cs @@ -0,0 +1,18 @@ +using System.Collections.Generic; + +namespace UnityEditor.Timeline +{ + class AddDeleteItemModeRipple : IAddDeleteItemMode + { + public void InsertItemsAtTime(IEnumerable itemsGroups, double requestedTime) + { + ItemsUtils.SetItemsStartTime(itemsGroups, requestedTime); + EditModeRippleUtils.Insert(itemsGroups); + } + + public void RemoveItems(IEnumerable itemsGroups) + { + EditModeRippleUtils.Remove(itemsGroups); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeRipple.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeRipple.cs.meta new file mode 100644 index 0000000..94155e5 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/AddDeleteItemModeRipple.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 88338eb35defad644a48718188e8f219 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/IAddDeleteItemMode.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/IAddDeleteItemMode.cs new file mode 100644 index 0000000..e943ac1 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/IAddDeleteItemMode.cs @@ -0,0 +1,10 @@ +using System.Collections.Generic; + +namespace UnityEditor.Timeline +{ + interface IAddDeleteItemMode + { + void InsertItemsAtTime(IEnumerable itemsGroups, double requestedTime); + void RemoveItems(IEnumerable itemsGroups); + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/IAddDeleteItemMode.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/IAddDeleteItemMode.cs.meta new file mode 100644 index 0000000..1296e1f --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/AddDelete/IAddDeleteItemMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4db13e1060deaae48b30246ed63b7c9b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors.meta new file mode 100644 index 0000000..0647cb5 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4ad09461bf994e54da846f726a23118e +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors/TimelineCursors.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors/TimelineCursors.cs new file mode 100644 index 0000000..4935cab --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors/TimelineCursors.cs @@ -0,0 +1,95 @@ +using System.Collections.Generic; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class TimelineCursors + { + public enum CursorType + { + MixBoth, + MixLeft, + MixRight, + Replace, + Ripple, + + Pan + } + + class CursorInfo + { + public readonly string assetPath; + public readonly Vector2 hotSpot; + public readonly MouseCursor mouseCursorType; + + public CursorInfo(string assetPath, Vector2 hotSpot, MouseCursor mouseCursorType) + { + this.assetPath = assetPath; + this.hotSpot = hotSpot; + this.mouseCursorType = mouseCursorType; + } + } + + const string k_CursorAssetRoot = "Cursors/"; + const string k_CursorAssetsNamespace = "Timeline."; + const string k_CursorAssetExtension = ".png"; + + const string k_MixBothCursorAssetName = k_CursorAssetsNamespace + "MixBoth" + k_CursorAssetExtension; + const string k_MixLeftCursorAssetName = k_CursorAssetsNamespace + "MixLeft" + k_CursorAssetExtension; + const string k_MixRightCursorAssetName = k_CursorAssetsNamespace + "MixRight" + k_CursorAssetExtension; + const string k_ReplaceCursorAssetName = k_CursorAssetsNamespace + "Replace" + k_CursorAssetExtension; + const string k_RippleCursorAssetName = k_CursorAssetsNamespace + "Ripple" + k_CursorAssetExtension; + + static readonly string s_PlatformPath = (Application.platform == RuntimePlatform.WindowsEditor) ? "Windows/" : "macOS/"; + static readonly string s_CursorAssetDirectory = k_CursorAssetRoot + s_PlatformPath; + + static readonly Dictionary s_CursorInfoLookup = new Dictionary + { + {CursorType.MixBoth, new CursorInfo(s_CursorAssetDirectory + k_MixBothCursorAssetName, new Vector2(16, 18), MouseCursor.CustomCursor)}, + {CursorType.MixLeft, new CursorInfo(s_CursorAssetDirectory + k_MixLeftCursorAssetName, new Vector2(7, 18), MouseCursor.CustomCursor)}, + {CursorType.MixRight, new CursorInfo(s_CursorAssetDirectory + k_MixRightCursorAssetName, new Vector2(25, 18), MouseCursor.CustomCursor)}, + {CursorType.Replace, new CursorInfo(s_CursorAssetDirectory + k_ReplaceCursorAssetName, new Vector2(16, 28), MouseCursor.CustomCursor)}, + {CursorType.Ripple, new CursorInfo(s_CursorAssetDirectory + k_RippleCursorAssetName, new Vector2(26, 19), MouseCursor.CustomCursor)}, + {CursorType.Pan, new CursorInfo(null, Vector2.zero, MouseCursor.Pan)} + }; + + static readonly Dictionary s_CursorAssetCache = new Dictionary(); + + static CursorType? s_CurrentCursor; + + public static void SetCursor(CursorType cursorType) + { + if (s_CurrentCursor.HasValue && s_CurrentCursor.Value == cursorType) return; + + s_CurrentCursor = cursorType; + var cursorInfo = s_CursorInfoLookup[cursorType]; + + Texture2D cursorAsset = null; + + if (cursorInfo.mouseCursorType == MouseCursor.CustomCursor) + { + cursorAsset = LoadCursorAsset(cursorInfo.assetPath); + } + + EditorGUIUtility.SetCurrentViewCursor(cursorAsset, cursorInfo.hotSpot, cursorInfo.mouseCursorType); + } + + public static void ClearCursor() + { + if (!s_CurrentCursor.HasValue) return; + + EditorGUIUtility.ClearCurrentViewCursor(); + s_CurrentCursor = null; + } + + static Texture2D LoadCursorAsset(string assetPath) + { + if (!s_CursorAssetCache.ContainsKey(assetPath)) + { + s_CursorAssetCache.Add(assetPath, (Texture2D)EditorGUIUtility.Load(assetPath)); + } + + return s_CursorAssetCache[assetPath]; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors/TimelineCursors.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors/TimelineCursors.cs.meta new file mode 100644 index 0000000..0e017d0 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Cursors/TimelineCursors.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f16e09785c984c445a0467e30f845636 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditMode.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditMode.cs new file mode 100644 index 0000000..475b586 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditMode.cs @@ -0,0 +1,344 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class EditMode + { + public enum EditType + { + None = -1, + Mix = 0, + Ripple = 1, + Replace = 2 + } + + interface ISubEditMode + { + IMoveItemMode moveItemMode { get; } + IMoveItemDrawer moveItemDrawer { get; } + ITrimItemMode trimItemMode { get; } + ITrimItemDrawer trimItemDrawer { get; } + IAddDeleteItemMode addDeleteItemMode { get; } + + Color color { get; } + KeyCode clutchKey { get; } + + void Reset(); + } + + class SubEditMode: ISubEditMode + where TMoveMode : class, IMoveItemMode, IMoveItemDrawer, new() + where TTrimMode : class, ITrimItemMode, ITrimItemDrawer, new() + where TAddDeleteMode : class, IAddDeleteItemMode, new() + { + public SubEditMode(Color guiColor, KeyCode key) + { + color = guiColor; + clutchKey = key; + Reset(); + } + + public void Reset() + { + m_MoveItemMode = new TMoveMode(); + m_TrimItemMode = new TTrimMode(); + m_AddDeleteItemMode = new TAddDeleteMode(); + } + + TMoveMode m_MoveItemMode; + TTrimMode m_TrimItemMode; + TAddDeleteMode m_AddDeleteItemMode; + + public IMoveItemMode moveItemMode { get { return m_MoveItemMode; } } + public IMoveItemDrawer moveItemDrawer { get { return m_MoveItemMode; } } + public ITrimItemMode trimItemMode { get { return m_TrimItemMode; } } + public ITrimItemDrawer trimItemDrawer { get { return m_TrimItemMode; } } + public IAddDeleteItemMode addDeleteItemMode { get { return m_AddDeleteItemMode; } } + public Color color { get; } + public KeyCode clutchKey { get; } + } + + static readonly Dictionary k_EditModes = new Dictionary + { + { EditType.Mix, new SubEditMode(DirectorStyles.kMixToolColor, KeyCode.Alpha1) }, + { EditType.Ripple, new SubEditMode(DirectorStyles.kRippleToolColor, KeyCode.Alpha2) }, + { EditType.Replace, new SubEditMode(DirectorStyles.kReplaceToolColor, KeyCode.Alpha3) } + }; + + static EditType s_CurrentEditType = EditType.Mix; + static EditType s_OverrideEditType = EditType.None; + + static ITrimmable s_CurrentTrimItem; + static TrimEdge s_CurrentTrimDirection; + static MoveItemHandler s_CurrentMoveItemHandler; + static EditModeInputHandler s_InputHandler = new EditModeInputHandler(); + + static ITrimItemMode trimMode + { + get { return GetSubEditMode(editType).trimItemMode; } + } + + static ITrimItemDrawer trimDrawer + { + get { return GetSubEditMode(editType).trimItemDrawer; } + } + + static IMoveItemMode moveMode + { + get { return GetSubEditMode(editType).moveItemMode; } + } + + static IMoveItemDrawer moveDrawer + { + get { return GetSubEditMode(editType).moveItemDrawer; } + } + + static IAddDeleteItemMode addDeleteMode + { + get { return GetSubEditMode(editType).addDeleteItemMode; } + } + + public static EditModeInputHandler inputHandler + { + get { return s_InputHandler; } + } + + static Color modeColor + { + get { return GetSubEditMode(editType).color; } + } + + public static EditType editType + { + get + { + if (s_OverrideEditType != EditType.None) + return s_OverrideEditType; + + var window = TimelineWindow.instance; + if (window != null) + s_CurrentEditType = window.state.editType; + + return s_CurrentEditType; + } + set + { + s_CurrentEditType = value; + + var window = TimelineWindow.instance; + if (window != null) + window.state.editType = value; + + s_OverrideEditType = EditType.None; + } + } + + static ISubEditMode GetSubEditMode(EditType type) + { + var subEditMode = k_EditModes[type]; + if (subEditMode != null) + return subEditMode; + + Debug.LogError("Unsupported editmode type"); + return null; + } + + static EditType GetSubEditType(KeyCode key) + { + foreach (var subEditMode in k_EditModes) + { + if (subEditMode.Value.clutchKey == key) + return subEditMode.Key; + } + return EditType.None; + } + + public static void ClearEditMode() + { + k_EditModes[editType].Reset(); + } + + public static void BeginTrim(ITimelineItem item, TrimEdge trimDirection) + { + var itemToTrim = item as ITrimmable; + if (itemToTrim == null) return; + + s_CurrentTrimItem = itemToTrim; + s_CurrentTrimDirection = trimDirection; + trimMode.OnBeforeTrim(itemToTrim, trimDirection); + TimelineUndo.PushUndo(itemToTrim.parentTrack, "Trim Clip"); + } + + public static void TrimStart(ITimelineItem item, double time) + { + var itemToTrim = item as ITrimmable; + if (itemToTrim == null) return; + + trimMode.TrimStart(itemToTrim, time); + } + + public static void TrimEnd(ITimelineItem item, double time, bool affectTimeScale) + { + var itemToTrim = item as ITrimmable; + if (itemToTrim == null) return; + + trimMode.TrimEnd(itemToTrim, time, affectTimeScale); + } + + public static void DrawTrimGUI(WindowState state, TimelineItemGUI item, TrimEdge edge) + { + trimDrawer.DrawGUI(state, item.rect, modeColor, edge); + } + + public static void FinishTrim() + { + s_CurrentTrimItem = null; + + TimelineCursors.ClearCursor(); + ClearEditMode(); + + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + public static void BeginMove(MoveItemHandler moveItemHandler) + { + s_CurrentMoveItemHandler = moveItemHandler; + moveMode.BeginMove(s_CurrentMoveItemHandler.movingItems); + } + + public static void UpdateMove() + { + moveMode.UpdateMove(s_CurrentMoveItemHandler.movingItems); + } + + public static void OnTrackDetach(IEnumerable grabbedTrackItems) + { + moveMode.OnTrackDetach(grabbedTrackItems); + } + + public static void HandleTrackSwitch(IEnumerable grabbedTrackItems) + { + moveMode.HandleTrackSwitch(grabbedTrackItems); + } + + public static bool AllowTrackSwitch() + { + return moveMode.AllowTrackSwitch(); + } + + public static double AdjustStartTime(WindowState state, ItemsPerTrack itemsGroup, double time) + { + return moveMode.AdjustStartTime(state, itemsGroup, time); + } + + public static bool ValidateDrag(ItemsPerTrack itemsGroup) + { + return moveMode.ValidateMove(itemsGroup); + } + + public static void DrawMoveGUI(WindowState state, IEnumerable movingItems) + { + moveDrawer.DrawGUI(state, movingItems, modeColor); + } + + public static void FinishMove() + { + var manipulatedItemsList = s_CurrentMoveItemHandler.movingItems; + moveMode.FinishMove(manipulatedItemsList); + + foreach (var itemsGroup in manipulatedItemsList) + foreach (var item in itemsGroup.items) + item.parentTrack = itemsGroup.targetTrack; + + s_CurrentMoveItemHandler = null; + + TimelineCursors.ClearCursor(); + ClearEditMode(); + + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + public static void FinalizeInsertItemsAtTime(IEnumerable newItems, double requestedTime) + { + addDeleteMode.InsertItemsAtTime(newItems, requestedTime); + } + + public static void PrepareItemsDelete(IEnumerable newItems) + { + addDeleteMode.RemoveItems(newItems); + } + + public static void HandleModeClutch() + { + if (Event.current.type == EventType.KeyDown && EditorGUI.IsEditingTextField()) + return; + + var prevType = editType; + + if (Event.current.type == EventType.KeyDown) + { + var clutchEditType = GetSubEditType(Event.current.keyCode); + if (clutchEditType != EditType.None) + { + s_OverrideEditType = clutchEditType; + Event.current.Use(); + } + } + else if (Event.current.type == EventType.KeyUp) + { + var clutchEditType = GetSubEditType(Event.current.keyCode); + if (clutchEditType == s_OverrideEditType) + { + s_OverrideEditType = EditType.None; + Event.current.Use(); + } + } + + if (prevType != editType) + { + if (s_CurrentTrimItem != null) + { + trimMode.OnBeforeTrim(s_CurrentTrimItem, s_CurrentTrimDirection); + } + else if (s_CurrentMoveItemHandler != null) + { + if (s_CurrentMoveItemHandler.movingItems == null) + { + s_CurrentMoveItemHandler = null; + return; + } + + foreach (var movingItems in s_CurrentMoveItemHandler.movingItems) + { + if (movingItems != null && movingItems.HasAnyDetachedParents()) + { + foreach (var items in movingItems.items) + { + items.parentTrack = movingItems.originalTrack; + } + } + } + + var movingSelection = s_CurrentMoveItemHandler.movingItems; + + // Handle clutch key transition if needed + GetSubEditMode(prevType).moveItemMode.OnModeClutchExit(movingSelection); + moveMode.OnModeClutchEnter(movingSelection); + + moveMode.BeginMove(movingSelection); + moveMode.HandleTrackSwitch(movingSelection); + + UpdateMove(); + s_CurrentMoveItemHandler.RefreshPreviewItems(); + + TimelineWindow.instance.state.rebuildGraph = true; // TODO Rebuild only if parent changed + } + + TimelineWindow.instance.Repaint(); // TODO Refresh the toolbar without doing a full repaint? + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditMode.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditMode.cs.meta new file mode 100644 index 0000000..4ec42d4 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: dfd084fea478f3148b7de3d83bab1d8c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditModeInputHandler.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditModeInputHandler.cs new file mode 100644 index 0000000..6a204d9 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditModeInputHandler.cs @@ -0,0 +1,199 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class EditModeInputHandler + { + readonly MoveInputHandler m_MoveHandler; + readonly TrimInputHandler m_TrimHandler; + + public EditModeInputHandler() + { + m_MoveHandler = new MoveInputHandler(); + m_TrimHandler = new TrimInputHandler(); + } + + public void ProcessMove(InputEvent action, double value) + { + if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) + ProcessInputAction(m_MoveHandler, action, value, TimelineWindow.instance.state); + } + + public void ProcessTrim(InputEvent action, double value, bool stretch) + { + if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) + { + m_TrimHandler.stretch = stretch; + ProcessInputAction(m_TrimHandler, action, value, TimelineWindow.instance.state); + } + } + + public void SetValueForEdge(IEnumerable items, AttractedEdge edge, double value) + { + if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) + MoveInputHandler.SetValueForEdge(items, edge, value, TimelineWindow.instance.state); + } + + public void OnGUI(WindowState state, Event evt) + { + if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) + { + m_MoveHandler.OnGUI(evt); + m_TrimHandler.OnGUI(state); + } + } + + static void ProcessInputAction(IInputHandler handler, InputEvent action, double value, WindowState state) + { + var items = SelectionManager.SelectedItems(); + switch (action) + { + case InputEvent.None: + return; + case InputEvent.DragEnter: + handler.OnEnterDrag(items, state); + break; + case InputEvent.Drag: + handler.OnDrag(value, state); + break; + case InputEvent.DragExit: + handler.OnExitDrag(); + break; + case InputEvent.KeyboardInput: + handler.OnSetValue(items, value, state); + break; + default: + return; + } + } + + interface IInputHandler + { + void OnEnterDrag(IEnumerable items, WindowState state); + void OnDrag(double value, WindowState state); + void OnExitDrag(); + void OnSetValue(IEnumerable items, double value, WindowState state); + } + + class TrimInputHandler : IInputHandler + { + bool isDragging { get; set; } + public bool stretch { get; set; } + + IEnumerable grabbedItems { get; set; } + + public void OnEnterDrag(IEnumerable items, WindowState state) + { + grabbedItems = items.OfType().ToArray(); + foreach (var item in grabbedItems) + { + EditMode.BeginTrim(item, TrimEdge.End); + } + + isDragging = true; + } + + public void OnDrag(double endValue, WindowState state) + { + var trimValue = endValue; + trimValue = TimelineWindow.instance.state.SnapToFrameIfRequired(trimValue); + + foreach (var item in grabbedItems) + { + EditMode.TrimEnd(item, trimValue, stretch); + } + state.UpdateRootPlayableDuration(state.editSequence.duration); + } + + public void OnExitDrag() + { + isDragging = false; + EditMode.FinishTrim(); + TimelineWindow.instance.Repaint(); + } + + public void OnSetValue(IEnumerable items, double endValue, WindowState state) + { + foreach (var item in items.OfType()) + { + EditMode.BeginTrim(item, TrimEdge.End); + EditMode.TrimEnd(item, endValue, stretch); + EditMode.FinishTrim(); + } + state.UpdateRootPlayableDuration(state.editSequence.duration); + } + + public void OnGUI(WindowState state) + { + if (!isDragging) return; + + foreach (var item in grabbedItems) + { + EditMode.DrawTrimGUI(state, item.gui, TrimEdge.End); + } + } + } + + class MoveInputHandler : IInputHandler + { + MoveItemHandler m_MoveItemHandler; + + public void OnEnterDrag(IEnumerable items, WindowState state) + { + if (items.Any()) + { + m_MoveItemHandler = new MoveItemHandler(state); + m_MoveItemHandler.Grab(items, items.First().parentTrack); + } + } + + public void OnDrag(double value, WindowState state) + { + if (m_MoveItemHandler == null) return; + + var startValue = value; + startValue = state.SnapToFrameIfRequired(startValue); + m_MoveItemHandler.OnAttractedEdge(null, ManipulateEdges.Both, AttractedEdge.None, startValue); + } + + public void OnExitDrag() + { + if (m_MoveItemHandler == null) return; + + m_MoveItemHandler.Drop(); + m_MoveItemHandler = null; + GUIUtility.ExitGUI(); + } + + public void OnSetValue(IEnumerable items, double value, WindowState state) + { + if (!items.Any()) return; + + m_MoveItemHandler = new MoveItemHandler(state); + m_MoveItemHandler.Grab(items, items.First().parentTrack); + m_MoveItemHandler.OnAttractedEdge(null, ManipulateEdges.Both, AttractedEdge.None, value); + m_MoveItemHandler.Drop(); + m_MoveItemHandler = null; + } + + public void OnGUI(Event evt) + { + if (m_MoveItemHandler != null) + m_MoveItemHandler.OnGUI(evt); + } + + public static void SetValueForEdge(IEnumerable items, AttractedEdge edge, double value, WindowState state) + { + var handler = new MoveItemHandler(state); + foreach (var item in items) + { + handler.Grab(new[] {item}, item.parentTrack); + handler.OnAttractedEdge(null, ManipulateEdges.Both, edge, value); + handler.Drop(); + } + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditModeInputHandler.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditModeInputHandler.cs.meta new file mode 100644 index 0000000..7ea2d6d --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/EditModeInputHandler.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 459f6a07ee4a58b42ba2568b097c3ec4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move.meta new file mode 100644 index 0000000..b8648c3 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: bd3ffb9a97575a44a82f9ca086813154 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/IMoveItemMode.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/IMoveItemMode.cs new file mode 100644 index 0000000..ac459ca --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/IMoveItemMode.cs @@ -0,0 +1,28 @@ +using System.Collections.Generic; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + interface IMoveItemMode + { + void OnTrackDetach(IEnumerable itemsGroups); + void HandleTrackSwitch(IEnumerable itemsGroups); + bool AllowTrackSwitch(); + + double AdjustStartTime(WindowState state, ItemsPerTrack itemsGroup, double time); + + void OnModeClutchEnter(IEnumerable itemsGroups); + void OnModeClutchExit(IEnumerable itemsGroups); + + void BeginMove(IEnumerable itemsGroups); + void UpdateMove(IEnumerable itemsGroups); + void FinishMove(IEnumerable itemsGroups); + + bool ValidateMove(ItemsPerTrack itemsGroup); + } + + interface IMoveItemDrawer + { + void DrawGUI(WindowState state, IEnumerable movingItems, Color color); + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/IMoveItemMode.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/IMoveItemMode.cs.meta new file mode 100644 index 0000000..619723e --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/IMoveItemMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3ff3d24ea34f9f74cb138e435f5f491e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemHandler.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemHandler.cs new file mode 100644 index 0000000..aac3e4d --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemHandler.cs @@ -0,0 +1,312 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class MoveItemHandler : IAttractable, IAttractionHandler + { + bool m_Grabbing; + + MovingItems m_LeftMostMovingItems; + MovingItems m_RightMostMovingItems; + + HashSet m_ItemGUIs; + ItemsGroup m_ItemsGroup; + + public TrackAsset targetTrack { get; private set; } + + public bool allowTrackSwitch { get; private set; } + + int m_GrabbedModalUndoGroup = -1; + + readonly WindowState m_State; + + public MovingItems[] movingItems { get; private set; } + + public MoveItemHandler(WindowState state) + { + m_State = state; + } + + public void Grab(IEnumerable items, TrackAsset referenceTrack) + { + Grab(items, referenceTrack, Vector2.zero); + } + + public void Grab(IEnumerable items, TrackAsset referenceTrack, Vector2 mousePosition) + { + if (items == null) return; + + items = items.ToArray(); // Cache enumeration result + + if (!items.Any()) return; + + m_GrabbedModalUndoGroup = Undo.GetCurrentGroup(); + + var trackItems = items.GroupBy(c => c.parentTrack).ToArray(); + var trackItemsCount = trackItems.Length; + var tracks = items.Select(c => c.parentTrack).Where(x => x != null).Distinct(); + + movingItems = new MovingItems[trackItemsCount]; + + allowTrackSwitch = trackItemsCount == 1 && !trackItems.SelectMany(x => x).Any(x => x is MarkerItem); // For now, track switch is only supported when all items are on the same track and there are no items + foreach (var sourceTrack in tracks) + { + // one push per track handles all the clips on the track + TimelineUndo.PushUndo(sourceTrack, "Move Items"); + + // push all markers on the track because of ripple + foreach (var marker in sourceTrack.GetMarkers().OfType()) + TimelineUndo.PushUndo(marker, "Move Items"); + } + + for (var i = 0; i < trackItemsCount; ++i) + { + var track = trackItems[i].Key; + var grabbedItems = new MovingItems(m_State, track, trackItems[i].ToArray(), referenceTrack, mousePosition, allowTrackSwitch); + movingItems[i] = grabbedItems; + } + + m_LeftMostMovingItems = null; + m_RightMostMovingItems = null; + + foreach (var grabbedTrackItems in movingItems) + { + if (m_LeftMostMovingItems == null || m_LeftMostMovingItems.start > grabbedTrackItems.start) + m_LeftMostMovingItems = grabbedTrackItems; + + if (m_RightMostMovingItems == null || m_RightMostMovingItems.end < grabbedTrackItems.end) + m_RightMostMovingItems = grabbedTrackItems; + } + + m_ItemGUIs = new HashSet(); + m_ItemsGroup = new ItemsGroup(items); + + foreach (var item in items) + m_ItemGUIs.Add(item.gui); + + targetTrack = referenceTrack; + + EditMode.BeginMove(this); + m_Grabbing = true; + } + + public void Drop() + { + if (IsValidDrop()) + { + foreach (var grabbedItems in movingItems) + { + var track = grabbedItems.targetTrack; + TimelineUndo.PushUndo(track, "Move Items"); + + if (EditModeUtils.IsInfiniteTrack(track) && grabbedItems.clips.Any()) + ((AnimationTrack)track).ConvertToClipMode(); + } + + EditMode.FinishMove(); + + Done(); + } + else + { + Cancel(); + } + + EditMode.ClearEditMode(); + } + + bool IsValidDrop() + { + return movingItems.All(g => g.canDrop); + } + + void Cancel() + { + if (!m_Grabbing) + return; + + // TODO fix undo reselection persistency + // identify the clips by their playable asset, since that reference will survive the undo + // This is a workaround, until a more persistent fix for selection of clips across Undo can be found + var assets = movingItems.SelectMany(x => x.clips).Select(x => x.asset); + + Undo.RevertAllDownToGroup(m_GrabbedModalUndoGroup); + + // reselect the clips from the original clip + var clipsToSelect = movingItems.Select(x => x.originalTrack).SelectMany(x => x.GetClips()).Where(x => assets.Contains(x.asset)).ToArray(); + SelectionManager.RemoveTimelineSelection(); + + foreach (var c in clipsToSelect) + SelectionManager.Add(c); + + Done(); + } + + void Done() + { + foreach (var movingItem in movingItems) + { + foreach (var item in movingItem.items) + { + if (item.gui != null) + item.gui.isInvalid = false; + } + } + + movingItems = null; + m_LeftMostMovingItems = null; + m_RightMostMovingItems = null; + m_Grabbing = false; + + m_State.Refresh(); + } + + public double start { get { return m_ItemsGroup.start; } } + + public double end { get { return m_ItemsGroup.end; } } + + public bool ShouldSnapTo(ISnappable snappable) + { + var itemGUI = snappable as TimelineItemGUI; + return itemGUI != null && !m_ItemGUIs.Contains(itemGUI); + } + + public void UpdateTrackTarget(TrackAsset track) + { + if (!EditMode.AllowTrackSwitch()) + return; + + targetTrack = track; + + var targetTracksChanged = false; + + foreach (var grabbedItem in movingItems) + { + var prevTrackGUI = grabbedItem.targetTrack; + + grabbedItem.SetReferenceTrack(track); + + targetTracksChanged = grabbedItem.targetTrack != prevTrackGUI; + } + + if (targetTracksChanged) + EditMode.HandleTrackSwitch(movingItems); + + RefreshPreviewItems(); + + m_State.rebuildGraph |= targetTracksChanged; + } + + public void OnGUI(Event evt) + { + if (!m_Grabbing) + return; + + if (evt.type != EventType.Repaint) + return; + + var isValid = IsValidDrop(); + + using (new GUIViewportScope(m_State.GetWindow().sequenceContentRect)) + { + foreach (var grabbedClip in movingItems) + { + grabbedClip.RefreshBounds(m_State, evt.mousePosition); + + if (!grabbedClip.HasAnyDetachedParents()) + continue; + + grabbedClip.Draw(isValid); + } + + if (isValid) + { + EditMode.DrawMoveGUI(m_State, movingItems); + } + else + { + TimelineCursors.ClearCursor(); + } + } + } + + public void OnAttractedEdge(IAttractable attractable, ManipulateEdges manipulateEdges, AttractedEdge edge, double time) + { + double offset; + + if (edge == AttractedEdge.Right) + { + var duration = end - start; + var startTime = time - duration; + startTime = EditMode.AdjustStartTime(m_State, m_RightMostMovingItems, startTime); + + offset = startTime + duration - end; + } + else + { + if (edge == AttractedEdge.Left) + time = EditMode.AdjustStartTime(m_State, m_LeftMostMovingItems, time); + + offset = time - start; + } + + if (start + offset < 0.0) + offset = -start; + + if (!offset.Equals(0.0)) + { + foreach (var grabbedClips in movingItems) + grabbedClips.start += offset; + + EditMode.UpdateMove(); + + RefreshPreviewItems(); + } + } + + public void RefreshPreviewItems() + { + foreach (var movingItemsGroup in movingItems) + { + // Check validity + var valid = ValidateItemDrag(movingItemsGroup); + + foreach (var item in movingItemsGroup.items) + { + if (item.gui != null) + item.gui.isInvalid = !valid; + } + + movingItemsGroup.canDrop = valid; + } + } + + static bool ValidateItemDrag(ItemsPerTrack itemsGroup) + { + //TODO-marker: this is to prevent the drag operation from being canceled when moving only markers + if (itemsGroup.clips.Any()) + { + if (itemsGroup.targetTrack == null) + return false; + + if (itemsGroup.targetTrack.lockedInHierarchy) + return false; + + if (itemsGroup.items.Any(i => !i.IsCompatibleWithTrack(itemsGroup.targetTrack))) + return false; + + return EditMode.ValidateDrag(itemsGroup); + } + + return true; + } + + public void OnTrackDetach() + { + EditMode.OnTrackDetach(movingItems); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemHandler.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemHandler.cs.meta new file mode 100644 index 0000000..43dce6a --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemHandler.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f6bd368ab00d75c459e2582e017191e6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeMix.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeMix.cs new file mode 100644 index 0000000..d4df368 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeMix.cs @@ -0,0 +1,138 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class MoveItemModeMix : IMoveItemMode, IMoveItemDrawer + { + public void OnTrackDetach(IEnumerable itemsGroups) + { + // Nothing + } + + public void HandleTrackSwitch(IEnumerable itemsGroups) + { + foreach (var itemsGroup in itemsGroups) + { + var targetTrack = itemsGroup.targetTrack; + if (targetTrack != null && itemsGroup.items.Any()) + { + var compatible = itemsGroup.items.First().IsCompatibleWithTrack(targetTrack) && + !EditModeUtils.IsInfiniteTrack(targetTrack); + var track = compatible ? targetTrack : null; + + if (track != null) + TimelineUndo.PushUndo(track, "Move Items"); + + EditModeUtils.SetParentTrack(itemsGroup.items, track); + } + else + { + EditModeUtils.SetParentTrack(itemsGroup.items, null); + } + } + } + + public bool AllowTrackSwitch() + { + return true; + } + + public double AdjustStartTime(WindowState state, ItemsPerTrack itemsGroup, double time) + { + return time; + } + + public void OnModeClutchEnter(IEnumerable itemsGroups) + { + // Nothing + } + + public void OnModeClutchExit(IEnumerable itemsGroups) + { + // Nothing + } + + public void BeginMove(IEnumerable itemsGroups) + { + // Nothing + } + + public void UpdateMove(IEnumerable itemsGroups) + { + // Nothing + } + + public void FinishMove(IEnumerable itemsGroups) + { + // Nothing + } + + public bool ValidateMove(ItemsPerTrack itemsGroup) + { + var track = itemsGroup.targetTrack; + var items = itemsGroup.items; + + if (EditModeUtils.IsInfiniteTrack(track)) + { + double startTime; + double stopTime; + EditModeUtils.GetInfiniteClipBoundaries(track, out startTime, out stopTime); + + return items.All(item => + !EditModeUtils.IsItemWithinRange(item, startTime, stopTime) && + !EditModeUtils.IsRangeWithinItem(startTime, stopTime, item)); + } + + var siblings = ItemsUtils.GetItemsExcept(itemsGroup.targetTrack, items); + return items.All(item => EditModeMixUtils.GetPlacementValidity(item, siblings) == PlacementValidity.Valid); + } + + public void DrawGUI(WindowState state, IEnumerable movingItems, Color color) + { + var selectionHasAnyBlendIn = false; + var selectionHasAnyBlendOut = false; + + foreach (var grabbedItems in movingItems) + { + var bounds = grabbedItems.onTrackItemsBounds; + + var counter = 0; + foreach (var item in grabbedItems.items.OfType()) + { + if (item.hasLeftBlend) + { + EditModeGUIUtils.DrawBoundsEdge(bounds[counter], color, TrimEdge.Start); + selectionHasAnyBlendIn = true; + } + + if (item.hasRightBlend) + { + EditModeGUIUtils.DrawBoundsEdge(bounds[counter], color, TrimEdge.End); + selectionHasAnyBlendOut = true; + } + counter++; + } + } + + if (selectionHasAnyBlendIn && selectionHasAnyBlendOut) + { + TimelineCursors.SetCursor(TimelineCursors.CursorType.MixBoth); + } + else if (selectionHasAnyBlendIn) + { + TimelineCursors.SetCursor(TimelineCursors.CursorType.MixLeft); + } + else if (selectionHasAnyBlendOut) + { + TimelineCursors.SetCursor(TimelineCursors.CursorType.MixRight); + } + else + { + TimelineCursors.ClearCursor(); + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeMix.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeMix.cs.meta new file mode 100644 index 0000000..966ebfa --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeMix.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a2a8aecb05814e644abbb070fbd91156 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeReplace.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeReplace.cs new file mode 100644 index 0000000..4d55820 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeReplace.cs @@ -0,0 +1,99 @@ +using System.Collections.Generic; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class MoveItemModeReplace : IMoveItemMode, IMoveItemDrawer + { + public void OnTrackDetach(IEnumerable itemsGroups) + { + // Nothing + } + + public void HandleTrackSwitch(IEnumerable itemsGroups) + { + // Nothing + } + + public bool AllowTrackSwitch() + { + return true; + } + + public double AdjustStartTime(WindowState state, ItemsPerTrack itemsGroup, double time) + { + return time; + } + + public void OnModeClutchEnter(IEnumerable itemsGroups) + { + // TODO + } + + public void OnModeClutchExit(IEnumerable itemsGroups) + { + // TODO + } + + public void BeginMove(IEnumerable itemsGroups) + { + foreach (var itemsGroup in itemsGroups) + { + EditModeUtils.SetParentTrack(itemsGroup.items, null); + } + } + + public void UpdateMove(IEnumerable itemsGroups) + { + // Nothing + } + + public void FinishMove(IEnumerable itemsGroups) + { + EditModeReplaceUtils.Insert(itemsGroups); + } + + public bool ValidateMove(ItemsPerTrack itemsGroup) + { + return true; + } + + public void DrawGUI(WindowState state, IEnumerable movingItems, Color color) + { + var operationWillReplace = false; + + foreach (var itemsPerTrack in movingItems) + { + var bounds = itemsPerTrack.onTrackItemsBounds; + + var counter = 0; + foreach (var item in itemsPerTrack.items) + { + if (EditModeUtils.GetFirstIntersectedItem(itemsPerTrack.items, item.start) != null) + { + EditModeGUIUtils.DrawBoundsEdge(bounds[counter], color, TrimEdge.Start); + operationWillReplace = true; + } + + if (EditModeUtils.GetFirstIntersectedItem(itemsPerTrack.items, item.end) != null) + { + EditModeGUIUtils.DrawBoundsEdge(bounds[counter], color, TrimEdge.End); + operationWillReplace = true; + } + + counter++; + // TODO Display swallowed clips? + } + } + + if (operationWillReplace) + { + TimelineCursors.SetCursor(TimelineCursors.CursorType.Replace); + } + else + { + TimelineCursors.ClearCursor(); + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeReplace.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeReplace.cs.meta new file mode 100644 index 0000000..abcc2f3 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeReplace.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ea5e2240e8a7d9046a651557deec40b2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeRipple.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeRipple.cs new file mode 100644 index 0000000..aadf5f7 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeRipple.cs @@ -0,0 +1,271 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class MoveItemModeRipple : IMoveItemMode, IMoveItemDrawer + { + const float k_SnapToEdgeDistance = 30.0f; + + class PrevItemInfo + { + public ITimelineItem item; + public ITimelineItem firstSelectedItem; + public bool blending; + + public PrevItemInfo(ITimelineItem item, ITimelineItem firstSelectedItem) + { + this.item = item; + this.firstSelectedItem = firstSelectedItem; + blending = item != null && item.end > firstSelectedItem.start; + } + } + + readonly Dictionary> m_NextItems = new Dictionary>(); + readonly Dictionary m_PreviousItem = new Dictionary(); + double m_PreviousEnd; + + bool m_TrackLocked; + bool m_Detached; + + public void OnTrackDetach(IEnumerable itemsGroups) + { + if (m_TrackLocked) + return; + + if (m_Detached) + return; + + if (itemsGroups.Any(x => x.markers.Any())) + return; + + // Ripple can either remove or not clips when detaching them from their track. + // Keep it off for now. TODO: add clutch key to toggle this feature? + //EditModeRippleUtils.Remove(manipulatedClipsList); + + StartDetachMode(itemsGroups); + } + + public void HandleTrackSwitch(IEnumerable itemsGroups) + { + // Nothing + } + + public bool AllowTrackSwitch() + { + return !m_TrackLocked; + } + + public double AdjustStartTime(WindowState state, ItemsPerTrack itemsGroup, double time) + { + var track = itemsGroup.targetTrack; + if (track == null) + return time; + + double start; + double end; + + if (EditModeUtils.IsInfiniteTrack(track)) + { + EditModeUtils.GetInfiniteClipBoundaries(track, out start, out end); + } + else + { + var siblings = ItemsUtils.GetItemsExcept(track, itemsGroup.items); + var firstIntersectedItem = EditModeUtils.GetFirstIntersectedItem(siblings, time); + + if (firstIntersectedItem == null) + return time; + + start = firstIntersectedItem.start; + end = firstIntersectedItem.end; + } + + var closestTime = Math.Abs(time - start) < Math.Abs(time - end) ? start : end; + + var pixelTime = state.TimeToPixel(time); + var pixelClosestTime = state.TimeToPixel(closestTime); + + if (Math.Abs(pixelTime - pixelClosestTime) < k_SnapToEdgeDistance) + return closestTime; + + return time; + } + + void StartDetachMode(IEnumerable itemsGroups) + { + m_Detached = true; + + foreach (var itemsGroup in itemsGroups) + EditModeUtils.SetParentTrack(itemsGroup.items, null); + } + + public void OnModeClutchEnter(IEnumerable itemsGroups) + { + StartDetachMode(itemsGroups); + m_TrackLocked = false; + } + + public void OnModeClutchExit(IEnumerable itemsGroups) + { + m_Detached = false; + m_TrackLocked = false; + } + + public void BeginMove(IEnumerable itemsGroups) + { + m_NextItems.Clear(); + m_PreviousItem.Clear(); + var itemTypes = ItemsUtils.GetItemTypes(itemsGroups).ToList(); + + foreach (var itemsGroup in itemsGroups) + { + //can only ripple items of the same type as those selected + var sortedSelectedItems = itemsGroup.items.OrderBy(i => i.start).ToList(); + var siblings = itemsGroup.targetTrack.GetItemsExcept(itemsGroup.items); + var sortedSiblingsToRipple = siblings.Where(i => itemTypes.Contains(i.GetType())).OrderBy(i => i.start).ToList(); + var start = sortedSelectedItems.First().start; + + m_NextItems.Add(itemsGroup.targetTrack, sortedSiblingsToRipple.Where(i => i.start > start).ToList()); + m_PreviousItem.Add(itemsGroup.targetTrack, CalculatePrevItemInfo(sortedSelectedItems, sortedSiblingsToRipple, itemTypes)); + } + + m_PreviousEnd = itemsGroups.Max(m => m.items.Max(c => c.end)); + } + + public void UpdateMove(IEnumerable itemsGroups) + { + if (m_Detached) + return; + + m_TrackLocked = true; + + var overlap = 0.0; + foreach (var itemsGroup in itemsGroups) + { + var track = itemsGroup.targetTrack; + if (track == null) continue; + + var prevItemInfo = m_PreviousItem[track]; + if (prevItemInfo.item != null) + { + var prevItem = prevItemInfo.item; + var firstItem = prevItemInfo.firstSelectedItem; + + if (prevItemInfo.blending) + prevItemInfo.blending = prevItem.end > firstItem.start; + + if (prevItemInfo.blending) + { + var b = EditModeUtils.BlendDuration(firstItem, TrimEdge.End); + overlap = Math.Max(overlap, Math.Max(prevItem.start, prevItem.end - firstItem.end + firstItem.start + b) - firstItem.start); + } + else + { + overlap = Math.Max(overlap, prevItem.end - firstItem.start); + } + } + } + + if (overlap > 0) + { + foreach (var itemsGroup in itemsGroups) + { + foreach (var item in itemsGroup.items) + item.start += overlap; + } + } + + var newEnd = itemsGroups.Max(m => m.items.Max(c => c.end)); + + var offset = newEnd - m_PreviousEnd; + m_PreviousEnd = newEnd; + + foreach (var itemsGroup in itemsGroups) + { + foreach (var item in m_NextItems[itemsGroup.targetTrack]) + item.start += offset; + } + } + + static PrevItemInfo CalculatePrevItemInfo(List orderedSelection, List orderedSiblings, IEnumerable itemTypes) + { + ITimelineItem previousItem = null; + ITimelineItem firstSelectedItem = null; + var gap = double.PositiveInfinity; + + foreach (var type in itemTypes) + { + var firstSelectedItemOfType = orderedSelection.FirstOrDefault(i => i.GetType() == type); + if (firstSelectedItemOfType == null) continue; + + var previousItemOfType = orderedSiblings.LastOrDefault(i => i.GetType() == type && i.start < firstSelectedItemOfType.start); + if (previousItemOfType == null) continue; + + var currentGap = firstSelectedItemOfType.start - previousItemOfType.end; + if (currentGap < gap) + { + gap = currentGap; + firstSelectedItem = firstSelectedItemOfType; + previousItem = previousItemOfType; + } + } + + return new PrevItemInfo(previousItem, firstSelectedItem); + } + + public bool ValidateMove(ItemsPerTrack itemsGroup) + { + return true; + } + + public void FinishMove(IEnumerable itemsGroups) + { + if (m_Detached) + EditModeRippleUtils.Insert(itemsGroups); + + m_Detached = false; + m_TrackLocked = false; + } + + public void DrawGUI(WindowState state, IEnumerable movingItems, Color color) + { + if (m_Detached) + { + var xMin = float.MaxValue; + var xMax = float.MinValue; + + foreach (var grabbedItems in movingItems) + { + xMin = Math.Min(xMin, grabbedItems.onTrackItemsBounds.Min(b => b.xMin)); // TODO Cache this? + xMax = Math.Max(xMax, grabbedItems.onTrackItemsBounds.Max(b => b.xMax)); + } + + foreach (var grabbedItems in movingItems) + { + var bounds = Rect.MinMaxRect(xMin, grabbedItems.onTrackItemsBounds[0].yMin, + xMax, grabbedItems.onTrackItemsBounds[0].yMax); + + EditModeGUIUtils.DrawOverlayRect(bounds, new Color(1.0f, 1.0f, 1.0f, 0.5f)); + + EditModeGUIUtils.DrawBoundsEdge(bounds, color, TrimEdge.Start); + } + } + else + { + foreach (var grabbedItems in movingItems) + { + var bounds = Rect.MinMaxRect(grabbedItems.onTrackItemsBounds.Min(b => b.xMin), grabbedItems.onTrackItemsBounds[0].yMin, + grabbedItems.onTrackItemsBounds.Max(b => b.xMax), grabbedItems.onTrackItemsBounds[0].yMax); + + EditModeGUIUtils.DrawBoundsEdge(bounds, color, TrimEdge.Start); + } + } + + TimelineCursors.SetCursor(TimelineCursors.CursorType.Ripple); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeRipple.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeRipple.cs.meta new file mode 100644 index 0000000..890c3ed --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MoveItemModeRipple.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: eebde5009793ce948bf5d4c4435b89b9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MovingItems.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MovingItems.cs new file mode 100644 index 0000000..1620269 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MovingItems.cs @@ -0,0 +1,137 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class MovingItems : ItemsPerTrack + { + TrackAsset m_ReferenceTrack; + readonly bool m_AllowTrackSwitch; + + readonly Rect[] m_ItemsBoundsOnTrack; + readonly Vector2[] m_ItemsMouseOffsets; + + static readonly Rect s_InvisibleBounds = new Rect(float.MaxValue, float.MaxValue, 0.0f, 0.0f); + + public TrackAsset originalTrack { get; } + + public override TrackAsset targetTrack + { + get + { + if (m_AllowTrackSwitch) + return m_ReferenceTrack; + + return originalTrack; + } + } + + public bool canDrop; + + public double start + { + get { return m_ItemsGroup.start; } + set { m_ItemsGroup.start = value; } + } + + public double end + { + get { return m_ItemsGroup.end; } + } + + public Rect[] onTrackItemsBounds + { + get { return m_ItemsBoundsOnTrack; } + } + + public MovingItems(WindowState state, TrackAsset parentTrack, ITimelineItem[] items, TrackAsset referenceTrack, Vector2 mousePosition, bool allowTrackSwitch) + : base(parentTrack, items) + { + originalTrack = parentTrack; + m_ReferenceTrack = referenceTrack; + m_AllowTrackSwitch = allowTrackSwitch; + + m_ItemsBoundsOnTrack = new Rect[items.Length]; + m_ItemsMouseOffsets = new Vector2[items.Length]; + + for (int i = 0; i < items.Length; ++i) + { + var itemGUi = items[i].gui; + + if (itemGUi != null) + { + m_ItemsBoundsOnTrack[i] = itemGUi.rect; + m_ItemsMouseOffsets[i] = mousePosition - m_ItemsBoundsOnTrack[i].position; + } + } + + canDrop = true; + } + + public void SetReferenceTrack(TrackAsset track) + { + m_ReferenceTrack = track; + } + + public bool HasAnyDetachedParents() + { + return m_ItemsGroup.items.Any(x => x.parentTrack == null); + } + + public void RefreshBounds(WindowState state, Vector2 mousePosition) + { + for (int i = 0; i < m_ItemsGroup.items.Length; ++i) + { + var item = m_ItemsGroup.items[i]; + var itemGUI = item.gui; + + if (item.parentTrack != null) + { + m_ItemsBoundsOnTrack[i] = itemGUI.visible ? itemGUI.rect : s_InvisibleBounds; + } + else + { + if (targetTrack != null) + { + var trackGUI = (TimelineTrackGUI)TimelineWindow.instance.allTracks.FirstOrDefault(t => t.track == targetTrack); + if (trackGUI == null) return; + var trackRect = trackGUI.boundingRect; + m_ItemsBoundsOnTrack[i] = itemGUI.RectToTimeline(trackRect, state); + } + else + { + m_ItemsBoundsOnTrack[i].position = mousePosition - m_ItemsMouseOffsets[i]; + } + } + } + } + + public void Draw(bool isValid) + { + for (int i = 0; i < m_ItemsBoundsOnTrack.Length; ++i) + { + var rect = m_ItemsBoundsOnTrack[i]; + DrawItemInternal(m_ItemsGroup.items[i], rect, isValid); + } + } + + static void DrawItemInternal(ITimelineItem item, Rect rect, bool isValid) + { + var clipGUI = item.gui as TimelineClipGUI; + + if (clipGUI != null) + { + if (isValid) + { + clipGUI.DrawGhostClip(rect); + } + else + { + clipGUI.DrawInvalidClip(rect); + } + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MovingItems.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MovingItems.cs.meta new file mode 100644 index 0000000..f3c7fdb --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Move/MovingItems.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 81a142c61a4e14d46bb21b02548ad24d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence.meta new file mode 100644 index 0000000..64e65bc --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: dec586c160776104da4d9a4e472662bc +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs new file mode 100644 index 0000000..7dddf3a --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs @@ -0,0 +1,146 @@ +using System; +using System.Text; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class EaseClip : Manipulator + { + bool m_IsCaptured; + bool m_UndoSaved; + TimelineClipHandle m_EaseClipHandler; + ManipulateEdges m_Edges; + TimelineClip m_Clip; + StringBuilder m_OverlayText = new StringBuilder(""); + double m_OriginalValue; + + public static readonly string EaseInClipText = L10n.Tr("Ease In Clip"); + public static readonly string EaseOutClipText = L10n.Tr("Ease Out Clip"); + public static readonly string EaseInText = L10n.Tr("Ease In"); + public static readonly string EaseOutText = L10n.Tr("Ease Out"); + public static readonly string DurationFrameText = L10n.Tr(" Duration {0:0.00;-0.00} frames "); + public static readonly string DurationSecText = L10n.Tr(" Duration {0:0.00;-0.00} s "); + public static readonly string DeltaFrameText = L10n.Tr("({0:+0.00;-0.00} frames)"); + public static readonly string DeltaSecText = L10n.Tr("({0:+0.00;-0.00} s)"); + + protected override bool MouseDown(Event evt, WindowState state) + { + if (evt.modifiers != ManipulatorsUtils.actionModifier) + return false; + return MouseDownInternal(evt, state, PickerUtils.PickedLayerableOfType()); + } + + protected bool MouseDownInternal(Event evt, WindowState state, TimelineClipHandle handle) + { + if (handle == null) + return false; + + if (handle.clipGUI.clip != null && !handle.clipGUI.clip.clipCaps.HasAny(ClipCaps.Blending)) + return false; + + m_Edges = ManipulateEdges.Right; + if (handle.trimDirection == TrimEdge.Start) + m_Edges = ManipulateEdges.Left; + + if (m_Edges == ManipulateEdges.Left && handle.clipGUI.clip.hasBlendIn || m_Edges == ManipulateEdges.Right && handle.clipGUI.clip.hasBlendOut) + return false; + + m_IsCaptured = true; + m_UndoSaved = false; + + m_EaseClipHandler = handle; + m_Clip = handle.clipGUI.clip; + m_OriginalValue = m_Edges == ManipulateEdges.Left ? m_Clip.easeInDuration : m_Clip.easeOutDuration; + + + // Change cursor only when OnGUI Process (not in test) + if (GUIUtility.guiDepth > 0) + TimelineCursors.SetCursor(m_Edges == ManipulateEdges.Left ? TimelineCursors.CursorType.MixRight : TimelineCursors.CursorType.MixLeft); + + state.AddCaptured(this); + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!m_IsCaptured) + return false; + m_IsCaptured = false; + m_UndoSaved = false; + state.captured.Clear(); + + // Clear cursor only when OnGUI Process (not in test) + if (GUIUtility.guiDepth > 0) + TimelineCursors.ClearCursor(); + + return true; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (!m_IsCaptured) + return false; + if (!m_UndoSaved) + { + var uiClip = m_EaseClipHandler.clipGUI; + string undoName = m_Edges == ManipulateEdges.Left ? EaseInClipText : EaseOutClipText; + TimelineUndo.PushUndo(uiClip.clip.parentTrack, undoName); + m_UndoSaved = true; + } + + double d = state.PixelDeltaToDeltaTime(evt.delta.x); + if (m_Edges == ManipulateEdges.Left) + { + m_Clip.easeInDuration = Math.Max(0, m_Clip.easeInDuration + d); + } + else if (m_Edges == ManipulateEdges.Right) + { + m_Clip.easeOutDuration = Math.Max(0, m_Clip.easeOutDuration - d); + } + RefreshOverlayStrings(m_EaseClipHandler, state); + return true; + } + + public override void Overlay(Event evt, WindowState state) + { + if (!m_IsCaptured) + return; + if (m_OverlayText.Length > 0) + { + int stringLength = m_OverlayText.Length; + var r = new Rect(evt.mousePosition.x - (stringLength / 2.0f), + m_EaseClipHandler.clipGUI.rect.yMax, + stringLength, 20); + GUI.Label(r, m_OverlayText.ToString(), TimelineWindow.styles.tinyFont); + } + } + + void RefreshOverlayStrings(TimelineClipHandle handle, WindowState state) + { + m_OverlayText.Length = 0; + m_OverlayText.Append(m_Edges == ManipulateEdges.Left ? EaseInText : EaseOutText); + double easeDuration = m_Edges == ManipulateEdges.Left ? m_Clip.easeInDuration : m_Clip.easeOutDuration; + double deltaDuration = easeDuration - m_OriginalValue; + bool hasDurationDelta = Math.Abs(deltaDuration) > double.Epsilon; + if (state.timeInFrames) + { + easeDuration *= state.editSequence.frameRate; + deltaDuration *= state.editSequence.frameRate; + m_OverlayText.AppendFormat(DurationFrameText, easeDuration); + if (hasDurationDelta) + { + m_OverlayText.AppendFormat(DeltaFrameText, deltaDuration); + } + } + else + { + m_OverlayText.AppendFormat(DurationSecText, easeDuration); + if (hasDurationDelta) + { + m_OverlayText.AppendFormat(DeltaSecText, deltaDuration); + } + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs.meta new file mode 100644 index 0000000..a161d2f --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b7cabea05434bb9479aee1e121b0d103 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs new file mode 100644 index 0000000..b470b58 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs @@ -0,0 +1,61 @@ +using UnityEditor.ShortcutManagement; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class Jog : Manipulator + { + Vector2 m_MouseDownOrigin = Vector2.zero; + + [ClutchShortcut("Timeline/Jog", typeof(TimelineWindow), KeyCode.J)] + static void JogShortcut(ShortcutArguments args) + { + if (args.stage == ShortcutStage.Begin) + { + (args.context as TimelineWindow).state.isJogging = true; + } + else if (args.stage == ShortcutStage.End) + { + (args.context as TimelineWindow).state.isJogging = false; + } + } + + protected override bool MouseDown(Event evt, WindowState state) + { + if (!state.isJogging) + return false; + + m_MouseDownOrigin = evt.mousePosition; + state.playbackSpeed = 0.0f; + state.Play(); + + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!state.isJogging) + { + return false; + } + + m_MouseDownOrigin = evt.mousePosition; + state.playbackSpeed = 0.0f; + state.Play(); + return false; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (!state.isJogging) + return false; + + var distance = evt.mousePosition - m_MouseDownOrigin; + + state.playbackSpeed = distance.x * 0.002f; + state.Play(); + return true; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs.meta new file mode 100644 index 0000000..9f26650 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 949b7e126b3f27940885a6808a15458e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs new file mode 100644 index 0000000..a6b7c87 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs @@ -0,0 +1,24 @@ +using System; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class TimelineMarkerHeaderContextMenu : Manipulator + { + protected override bool ContextClick(Event evt, WindowState state) + { + if (!state.showMarkerHeader) + return false; + + if (!(state.GetWindow().markerHeaderRect.Contains(evt.mousePosition) + || state.GetWindow().markerContentRect.Contains(evt.mousePosition))) + return false; + + SequencerContextMenu.ShowMarkerHeaderContextMenu(evt.mousePosition, state); + return true; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs.meta new file mode 100644 index 0000000..6f6012a --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e74ddf4132f3401409c824bed60280ee +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs new file mode 100644 index 0000000..17342ef --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs @@ -0,0 +1,36 @@ +using System.Linq; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class RectangleSelect : RectangleTool + { + protected override bool enableAutoPan { get { return false; } } + + protected override bool CanStartRectangle(Event evt, Vector2 mousePosition, WindowState state) + { + if (evt.button != 0 || evt.alt) + return false; + + return PickerUtils.pickedElements.All(e => e is IRowGUI); + } + + protected override bool OnFinish(Event evt, WindowState state, Rect rect) + { + var selectables = state.spacePartitioner.GetItemsInArea(rect).ToList(); + + if (!selectables.Any()) + return false; + + if (ItemSelection.CanClearSelection(evt)) + SelectionManager.Clear(); + + foreach (var selectable in selectables) + { + ItemSelection.HandleItemSelection(evt, selectable); + } + + return true; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs.meta new file mode 100644 index 0000000..ddff16e --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: edd4f4b395430604d935bcf0b14c7d42 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs new file mode 100644 index 0000000..5de1eb6 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs @@ -0,0 +1,169 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + abstract class RectangleTool + { + struct TimelinePoint + { + readonly double m_Time; + readonly float m_YPos; + readonly float m_YScrollPos; + + readonly WindowState m_State; + readonly TimelineTreeViewGUI m_TreeViewGUI; + + public TimelinePoint(WindowState state, Vector2 mousePosition) + { + m_State = state; + m_TreeViewGUI = state.GetWindow().treeView; + + m_Time = m_State.PixelToTime(mousePosition.x); + m_YPos = mousePosition.y; + m_YScrollPos = m_TreeViewGUI.scrollPosition.y; + } + + public Vector2 ToPixel() + { + return new Vector2(m_State.TimeToPixel(m_Time), m_YPos - (m_TreeViewGUI.scrollPosition.y - m_YScrollPos)); + } + } + + TimeAreaAutoPanner m_TimeAreaAutoPanner; + + TimelinePoint m_StartPoint; + Vector2 m_EndPixel = Vector2.zero; + + Rect m_ActiveRect; + + protected abstract bool enableAutoPan { get; } + protected abstract bool CanStartRectangle(Event evt, Vector2 mousePosition, WindowState state); + protected abstract bool OnFinish(Event evt, WindowState state, Rect rect); + + int m_Id; + + public void OnGUI(WindowState state, EventType rawType, Vector2 mousePosition) + { + if (m_Id == 0) + m_Id = GUIUtility.GetPermanentControlID(); + + if (state == null || state.GetWindow().treeView == null) + return; + + var evt = Event.current; + + if (rawType == EventType.MouseDown || evt.type == EventType.MouseDown) + { + if (state.IsCurrentEditingASequencerTextField()) + return; + + m_ActiveRect = TimelineWindow.instance.sequenceContentRect; + + if (!m_ActiveRect.Contains(mousePosition)) + return; + + if (!CanStartRectangle(evt, mousePosition, state)) + return; + + if (enableAutoPan) + m_TimeAreaAutoPanner = new TimeAreaAutoPanner(state); + + m_StartPoint = new TimelinePoint(state, mousePosition); + m_EndPixel = mousePosition; + + GUIUtility.hotControl = m_Id; //HACK: Because the treeView eats all the events, steal the hotControl if necessary... + evt.Use(); + + return; + } + + switch (evt.GetTypeForControl(m_Id)) + { + case EventType.KeyDown: + { + if (GUIUtility.hotControl == m_Id) + { + if (evt.keyCode == KeyCode.Escape) + { + m_TimeAreaAutoPanner = null; + + GUIUtility.hotControl = 0; + evt.Use(); + } + } + + return; + } + + case EventType.MouseDrag: + { + if (GUIUtility.hotControl != m_Id) + return; + + m_EndPixel = mousePosition; + evt.Use(); + + return; + } + + case EventType.MouseUp: + { + if (GUIUtility.hotControl != m_Id) + return; + + m_TimeAreaAutoPanner = null; + + var rect = CurrentRectangle(); + + if (IsValidRect(rect)) + OnFinish(evt, state, rect); + + GUIUtility.hotControl = 0; + evt.Use(); + + return; + } + } + + if (GUIUtility.hotControl == m_Id) + { + if (evt.type == EventType.Repaint) + { + var r = CurrentRectangle(); + + if (IsValidRect(r)) + { + using (new GUIViewportScope(m_ActiveRect)) + { + DrawRectangle(r); + } + } + } + + if (m_TimeAreaAutoPanner != null) + m_TimeAreaAutoPanner.OnGUI(evt); + } + } + + protected virtual void DrawRectangle(Rect rect) + { + EditorStyles.selectionRect.Draw(rect, GUIContent.none, false, false, false, false); + } + + static bool IsValidRect(Rect rect) + { + return rect.width >= 1.0f && rect.height >= 1.0f; + } + + Rect CurrentRectangle() + { + var startPixel = m_StartPoint.ToPixel(); + return Rect.MinMaxRect( + Math.Min(startPixel.x, m_EndPixel.x), + Math.Min(startPixel.y, m_EndPixel.y), + Math.Max(startPixel.x, m_EndPixel.x), + Math.Max(startPixel.y, m_EndPixel.y)); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs.meta new file mode 100644 index 0000000..3a0d71a --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 24a7ce8b48db53747a4e8abbda77eac4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs new file mode 100644 index 0000000..0a2d45f --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs @@ -0,0 +1,23 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class RectangleZoom : RectangleTool + { + protected override bool enableAutoPan { get { return true; } } + + protected override bool CanStartRectangle(Event evt, Vector2 mousePosition, WindowState state) + { + return evt.button == 1 && evt.modifiers == (EventModifiers.Alt | EventModifiers.Shift); + } + + protected override bool OnFinish(Event evt, WindowState state, Rect rect) + { + var x = state.PixelToTime(rect.xMin); + var y = state.PixelToTime(rect.xMax); + state.SetTimeAreaShownRange(x, y); + + return true; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs.meta new file mode 100644 index 0000000..e32aad5 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5aa8f57287fc17149bcd798be813180b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs new file mode 100644 index 0000000..b8d9a77 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs @@ -0,0 +1,297 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class ClearSelection : Manipulator + { + protected override bool MouseDown(Event evt, WindowState state) + { + // If we hit this point this means no one used the mouse down events. We can safely clear the selection if needed + if (evt.button != 0) + return false; + + var window = state.GetWindow(); + + if (!window.sequenceRect.Contains(evt.mousePosition)) + return false; + + if (ItemSelection.CanClearSelection(evt)) + { + SelectionManager.Clear(); + return true; + } + + return false; + } + } + + static class ItemSelection + { + public static bool CanClearSelection(Event evt) + { + return !evt.control && !evt.command && !evt.shift; + } + + public static void RangeSelectItems(ITimelineItem lastItemToSelect) + { + var selectSorted = SelectionManager.SelectedItems().ToList(); + var firstSelect = selectSorted.FirstOrDefault(); + if (firstSelect == null) + { + SelectionManager.Add(lastItemToSelect); + return; + } + + var allTracks = TimelineEditor.inspectedAsset.flattenedTracks; + var allItems = allTracks.SelectMany(ItemsUtils.GetItems).ToList(); + TimelineHelpers.RangeSelect(allItems, selectSorted, lastItemToSelect, SelectionManager.Add, SelectionManager.Remove); + } + + public static ISelectable HandleSingleSelection(Event evt) + { + var item = PickerUtils.PickedLayerableOfType(); + + if (item != null) + { + var selected = item.IsSelected(); + if (!selected && CanClearSelection(evt)) + SelectionManager.Clear(); + + if (evt.modifiers == EventModifiers.Shift) + { + if (!selected) + RangeSelectItems((item as TimelineItemGUI).item); + } + else + { + HandleItemSelection(evt, item); + } + } + + return item; + } + + public static void HandleItemSelection(Event evt, ISelectable item) + { + if (evt.modifiers == ManipulatorsUtils.actionModifier) + { + if (item.IsSelected()) + item.Deselect(); + else + item.Select(); + } + else + { + if (!item.IsSelected()) + item.Select(); + } + } + } + + class SelectAndMoveItem : Manipulator + { + bool m_Dragged; + SnapEngine m_SnapEngine; + TimeAreaAutoPanner m_TimeAreaAutoPanner; + Vector2 m_MouseDownPosition; + + bool m_HorizontalMovementDone; + bool m_VerticalMovementDone; + + MoveItemHandler m_MoveItemHandler; + bool m_CycleMarkersPending; + + protected override bool MouseDown(Event evt, WindowState state) + { + if (evt.alt || evt.button != 0) + return false; + + m_Dragged = false; + + // Cycling markers and selection are mutually exclusive operations + if (!HandleMarkerCycle() && !HandleSingleSelection(evt)) + return false; + + m_MouseDownPosition = evt.mousePosition; + m_VerticalMovementDone = false; + m_HorizontalMovementDone = false; + + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!m_Dragged) + { + var item = PickerUtils.PickedLayerableOfType(); + + if (item == null) + return false; + + if (!item.IsSelected()) + return false; + + // Re-selecting an item part of a multi-selection should only keep this item selected. + if (SelectionManager.Count() > 1 && ItemSelection.CanClearSelection(evt)) + { + SelectionManager.Clear(); + item.Select(); + return true; + } + + if (m_CycleMarkersPending) + { + m_CycleMarkersPending = false; + TimelineMarkerClusterGUI.CycleMarkers(); + return true; + } + + return false; + } + + m_TimeAreaAutoPanner = null; + + DropItems(); + + m_SnapEngine = null; + m_MoveItemHandler = null; + + state.Evaluate(); + state.RemoveCaptured(this); + m_Dragged = false; + TimelineCursors.ClearCursor(); + + return true; + } + + protected override bool DoubleClick(Event evt, WindowState state) + { + return MouseDown(evt, state) && MouseUp(evt, state); + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (state.editSequence.isReadOnly) + return false; + + // case 1099285 - ctrl-click can cause no clips to be selected + var selectedItemsGUI = SelectionManager.SelectedItems(); + if (!selectedItemsGUI.Any()) + { + m_Dragged = false; + return false; + } + + const float hDeadZone = 5.0f; + const float vDeadZone = 5.0f; + + bool vDone = m_VerticalMovementDone || Math.Abs(evt.mousePosition.y - m_MouseDownPosition.y) > vDeadZone; + bool hDone = m_HorizontalMovementDone || Math.Abs(evt.mousePosition.x - m_MouseDownPosition.x) > hDeadZone; + + m_CycleMarkersPending = false; + + if (!m_Dragged) + { + var canStartMove = vDone || hDone; + + if (canStartMove) + { + state.AddCaptured(this); + m_Dragged = true; + + var referenceTrack = GetTrackDropTargetAt(state, m_MouseDownPosition); + + foreach (var item in selectedItemsGUI) + item.gui.StartDrag(); + + m_MoveItemHandler = new MoveItemHandler(state); + + m_MoveItemHandler.Grab(selectedItemsGUI, referenceTrack, m_MouseDownPosition); + + m_SnapEngine = new SnapEngine(m_MoveItemHandler, m_MoveItemHandler, ManipulateEdges.Both, + state, m_MouseDownPosition); + + m_TimeAreaAutoPanner = new TimeAreaAutoPanner(state); + } + } + + if (!m_VerticalMovementDone) + { + m_VerticalMovementDone = vDone; + + if (m_VerticalMovementDone) + m_MoveItemHandler.OnTrackDetach(); + } + + if (!m_HorizontalMovementDone) + { + m_HorizontalMovementDone = hDone; + } + + if (m_Dragged) + { + if (m_HorizontalMovementDone) + m_SnapEngine.Snap(evt.mousePosition, evt.modifiers); + + if (m_VerticalMovementDone) + { + var track = GetTrackDropTargetAt(state, evt.mousePosition); + m_MoveItemHandler.UpdateTrackTarget(track); + } + + state.Evaluate(); + } + + return true; + } + + public override void Overlay(Event evt, WindowState state) + { + if (!m_Dragged) + return; + + if (m_TimeAreaAutoPanner != null) + m_TimeAreaAutoPanner.OnGUI(evt); + + m_MoveItemHandler.OnGUI(evt); + + if (!m_MoveItemHandler.allowTrackSwitch || m_MoveItemHandler.targetTrack != null) + { + TimeIndicator.Draw(state, m_MoveItemHandler.start, m_MoveItemHandler.end); + m_SnapEngine.OnGUI(); + } + } + + bool HandleMarkerCycle() + { + m_CycleMarkersPending = TimelineMarkerClusterGUI.CanCycleMarkers(); + return m_CycleMarkersPending; + } + + bool HandleSingleSelection(Event evt) + { + return ItemSelection.HandleSingleSelection(evt) != null; + } + + void DropItems() + { + // Order matters here: m_MoveItemHandler.movingItems is destroyed during call to Drop() + foreach (var movingItem in m_MoveItemHandler.movingItems) + { + foreach (var item in movingItem.items) + item.gui.StopDrag(); + } + + m_MoveItemHandler.Drop(); + } + + static TrackAsset GetTrackDropTargetAt(WindowState state, Vector2 point) + { + var track = state.spacePartitioner.GetItemsAtPosition(point).FirstOrDefault(); + return track != null ? track.asset : null; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs.meta new file mode 100644 index 0000000..16f0152 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f4f988528bbbb0846a4cb50efb4587a5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs new file mode 100644 index 0000000..fc167f4 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs @@ -0,0 +1,20 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TrackZoom : Manipulator + { + // only handles 'vertical' zoom. horizontal is handled in timelineGUI + protected override bool MouseWheel(Event evt, WindowState state) + { + if (EditorGUI.actionKey) + { + state.trackScale = Mathf.Min(Mathf.Max(state.trackScale + (evt.delta.y * 0.1f), 1.0f), 100.0f); + return true; + } + + return false; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs.meta new file mode 100644 index 0000000..a13fea6 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6e7c80eefe2def5459e0b486b3ab96e2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs new file mode 100644 index 0000000..0918a17 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs @@ -0,0 +1,232 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TrimClip : Manipulator + { + class TrimClipAttractionHandler : IAttractionHandler + { + public void OnAttractedEdge(IAttractable attractable, ManipulateEdges manipulateEdges, AttractedEdge edge, double time) + { + var clipGUI = attractable as TimelineClipGUI; + if (clipGUI == null) + return; + + var clipItem = ItemsUtils.ToItem(clipGUI.clip); + if (manipulateEdges == ManipulateEdges.Right) + { + bool affectTimeScale = Event.current.modifiers == EventModifiers.Shift; // TODO Do not use Event.current from here. + EditMode.TrimEnd(clipItem, time, affectTimeScale); + } + else if (manipulateEdges == ManipulateEdges.Left) + { + EditMode.TrimStart(clipItem, time); + } + } + } + + bool m_IsCaptured; + TimelineClipHandle m_TrimClipHandler; + + double m_OriginalDuration; + double m_OriginalTimeScale; + bool m_UndoSaved; + SnapEngine m_SnapEngine; + + readonly StringBuilder m_OverlayText = new StringBuilder(); + readonly List m_OverlayStrings = new List(); + + static readonly double kEpsilon = 0.0000001; + + protected override bool MouseDown(Event evt, WindowState state) + { + var handle = PickerUtils.PickedLayerableOfType(); + if (handle == null) + return false; + + if (handle.clipGUI.clip.parentTrack != null && handle.clipGUI.clip.parentTrack.lockedInHierarchy) + return false; + + if (ItemSelection.CanClearSelection(evt)) + SelectionManager.Clear(); + + if (!SelectionManager.Contains(handle.clipGUI.clip)) + SelectionManager.Add(handle.clipGUI.clip); + + m_TrimClipHandler = handle; + + m_IsCaptured = true; + state.AddCaptured(this); + + m_UndoSaved = false; + + var clip = m_TrimClipHandler.clipGUI.clip; + + m_OriginalDuration = clip.duration; + m_OriginalTimeScale = clip.timeScale; + + RefreshOverlayStrings(m_TrimClipHandler, state); + + // in ripple trim, the right edge moves and needs to snap + var edges = ManipulateEdges.Right; + if (EditMode.editType != EditMode.EditType.Ripple && m_TrimClipHandler.trimDirection == TrimEdge.Start) + edges = ManipulateEdges.Left; + m_SnapEngine = new SnapEngine(m_TrimClipHandler.clipGUI, new TrimClipAttractionHandler(), edges, state, + evt.mousePosition); + + EditMode.BeginTrim(ItemsUtils.ToItem(clip), m_TrimClipHandler.trimDirection); + + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!m_IsCaptured) + return false; + + m_IsCaptured = false; + m_TrimClipHandler = null; + m_UndoSaved = false; + m_SnapEngine = null; + EditMode.FinishTrim(); + + state.captured.Clear(); + + return true; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (state.editSequence.isReadOnly) + return false; + + if (!m_IsCaptured) + return false; + + if (!m_UndoSaved) + { + var uiClip = m_TrimClipHandler.clipGUI; + TimelineUndo.PushUndo(uiClip.clip.parentTrack, "Trim Clip"); + if (TimelineUtility.IsRecordableAnimationClip(uiClip.clip)) + { + TimelineUndo.PushUndo(uiClip.clip.animationClip, "Trim Clip"); + } + + m_UndoSaved = true; + } + + if (m_SnapEngine != null) + m_SnapEngine.Snap(evt.mousePosition, evt.modifiers); + + RefreshOverlayStrings(m_TrimClipHandler, state); + + if (Selection.activeObject != null) + EditorUtility.SetDirty(Selection.activeObject); + + // updates the duration of the graph without rebuilding + state.UpdateRootPlayableDuration(state.editSequence.duration); + + return true; + } + + public override void Overlay(Event evt, WindowState state) + { + if (!m_IsCaptured) + return; + + EditMode.DrawTrimGUI(state, m_TrimClipHandler.clipGUI, m_TrimClipHandler.trimDirection); + + bool trimStart = m_TrimClipHandler.trimDirection == TrimEdge.Start; + + TimeIndicator.Draw(state, trimStart ? m_TrimClipHandler.clipGUI.start : m_TrimClipHandler.clipGUI.end); + + if (m_SnapEngine != null) + m_SnapEngine.OnGUI(trimStart, !trimStart); + + if (m_OverlayStrings.Count > 0) + { + const float padding = 4.0f; + var labelStyle = TimelineWindow.styles.tinyFont; + var longestLine = labelStyle.CalcSize( + new GUIContent(m_OverlayStrings.Aggregate("", (max, cur) => max.Length > cur.Length ? max : cur))); + var stringLength = longestLine.x + padding; + var lineHeight = longestLine.y + padding; + + var r = new Rect(evt.mousePosition.x - (stringLength / 2.0f), + m_TrimClipHandler.clipGUI.rect.yMax, + stringLength, lineHeight); + + foreach (var s in m_OverlayStrings) + { + GUI.Label(r, s, labelStyle); + r.y += lineHeight; + } + } + } + + void RefreshOverlayStrings(TimelineClipHandle handle, WindowState state) + { + m_OverlayStrings.Clear(); + + m_OverlayText.Length = 0; + + var differenceDuration = handle.clipGUI.clip.duration - m_OriginalDuration; + bool hasDurationDelta = Math.Abs(differenceDuration) > kEpsilon; + + if (state.timeInFrames) + { + var durationInFrame = handle.clipGUI.clip.duration * state.referenceSequence.frameRate; + m_OverlayText.Append("duration: ").Append(durationInFrame.ToString("f2")).Append(" frames"); + + if (hasDurationDelta) + { + m_OverlayText.Append(" ("); + + if (differenceDuration > 0.0) + m_OverlayText.Append("+"); + + var valueInFrame = differenceDuration * state.referenceSequence.frameRate; + m_OverlayText.Append(valueInFrame.ToString("f2")).Append(" frames)"); + } + } + else + { + m_OverlayText.Append("duration: ").Append(handle.clipGUI.clip.duration.ToString("f2")).Append("s"); + + if (hasDurationDelta) + { + m_OverlayText.Append(" ("); + + if (differenceDuration > 0.0) + m_OverlayText.Append("+"); + + m_OverlayText.Append(differenceDuration.ToString("f2")).Append("s)"); + } + } + + m_OverlayStrings.Add(m_OverlayText.ToString()); + + m_OverlayText.Length = 0; + + var differenceSpeed = m_OriginalTimeScale - handle.clipGUI.clip.timeScale; + if (Math.Abs(differenceSpeed) > kEpsilon) + { + m_OverlayText.Append("speed: ").Append(handle.clipGUI.clip.timeScale.ToString("p2")); + + m_OverlayText.Append(" ("); + + if (differenceSpeed > 0.0) + m_OverlayText.Append("+"); + + m_OverlayText.Append(differenceSpeed.ToString("p2")).Append(")"); + + m_OverlayStrings.Add(m_OverlayText.ToString()); + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs.meta new file mode 100644 index 0000000..063a1c6 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 511aa760b8728a940a41c29837945292 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeAreaAutoPanner.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeAreaAutoPanner.cs new file mode 100644 index 0000000..8052d65 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeAreaAutoPanner.cs @@ -0,0 +1,72 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class TimeAreaAutoPanner + { + readonly WindowState m_State; + readonly TimelineWindow m_Window; + readonly Rect m_ViewRect; + + const float k_PixelDistanceToMaxSpeed = 100.0f; + const float k_MaxPanSpeed = 30.0f; + + public TimeAreaAutoPanner(WindowState state) + { + m_State = state; + m_Window = m_State.GetWindow(); + + var shownRange = m_State.timeAreaShownRange; + var trackViewBounds = m_Window.sequenceRect; + m_ViewRect = Rect.MinMaxRect(m_State.TimeToPixel(shownRange.x), trackViewBounds.yMin, + m_State.TimeToPixel(shownRange.y), trackViewBounds.yMax); + } + + public void OnGUI(Event evt) + { + if (evt.type != EventType.Layout) + return; + + var hFactor = 0.0f; + var vFactor = 0.0f; + + bool horizontalPan = GetPanFactor(evt.mousePosition.x, m_ViewRect.xMin, m_ViewRect.xMax, out hFactor); + bool verticalPan = GetPanFactor(evt.mousePosition.y, m_ViewRect.yMin, m_ViewRect.yMax, out vFactor); + + if (horizontalPan) + { + var translation = m_State.timeAreaTranslation; + translation.x += hFactor * k_MaxPanSpeed; + + m_State.SetTimeAreaTransform(translation, m_State.timeAreaScale); + } + + if (verticalPan) + { + var translation = m_Window.treeView.scrollPosition; + translation.y -= vFactor * k_MaxPanSpeed; + + m_Window.treeView.scrollPosition = translation; + } + } + + static bool GetPanFactor(float v, float min, float max, out float factor) + { + factor = 0.0f; + + if (v < min) + { + factor = Mathf.Clamp01((min - v) / k_PixelDistanceToMaxSpeed); + return true; + } + + if (v > max) + { + factor = -Mathf.Clamp01((v - max) / k_PixelDistanceToMaxSpeed); + return true; + } + + return false; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeAreaAutoPanner.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeAreaAutoPanner.cs.meta new file mode 100644 index 0000000..00a9eaf --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeAreaAutoPanner.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 02e1fe0a338b35545a5fed1345848332 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeIndicator.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeIndicator.cs new file mode 100644 index 0000000..d896ae5 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeIndicator.cs @@ -0,0 +1,47 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + static class TimeIndicator + { + static readonly Tooltip s_Tooltip = new Tooltip(DirectorStyles.Instance.displayBackground, DirectorStyles.Instance.tinyFont); + + public static void Draw(WindowState state, double time) + { + var bounds = state.timeAreaRect; + bounds.xMin = Mathf.Max(bounds.xMin, state.TimeToTimeAreaPixel(time)); + + using (new GUIViewportScope(state.timeAreaRect)) + { + s_Tooltip.text = TimeReferenceUtility.ToTimeString(time); + + var tooltipBounds = s_Tooltip.bounds; + tooltipBounds.xMin = bounds.xMin - (tooltipBounds.width / 2.0f); + tooltipBounds.y = bounds.y; + s_Tooltip.bounds = tooltipBounds; + + if (time >= 0) + s_Tooltip.Draw(); + } + + if (time >= 0) + { + Graphics.DrawLineAtTime(state, time, Color.black, true); + } + } + + public static void Draw(WindowState state, double start, double end) + { + var bounds = state.timeAreaRect; + bounds.xMin = Mathf.Max(bounds.xMin, state.TimeToTimeAreaPixel(start)); + bounds.xMax = Mathf.Min(bounds.xMax, state.TimeToTimeAreaPixel(end)); + + var color = DirectorStyles.Instance.selectedStyle.focused.textColor; + color.a = 0.12f; + EditorGUI.DrawRect(bounds, color); + + Draw(state, start); + Draw(state, end); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeIndicator.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeIndicator.cs.meta new file mode 100644 index 0000000..c8244f7 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimeIndicator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1d446e57147ca9b4183edfbbfa9bf206 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimelineClipGroup.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimelineClipGroup.cs new file mode 100644 index 0000000..03f4d8d --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimelineClipGroup.cs @@ -0,0 +1,54 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TimelineClipGroup + { + readonly TimelineClip[] m_Clips; + readonly TimelineClip m_LeftMostClip; + readonly TimelineClip m_RightMostClip; + + public TimelineClip[] clips + { + get { return m_Clips; } + } + + public double start + { + get { return m_LeftMostClip.start; } + set + { + var offset = value - m_LeftMostClip.start; + + foreach (var clip in m_Clips) + clip.start += offset; + } + } + + public double end + { + get { return m_RightMostClip.end; } + } + + public TimelineClipGroup(IEnumerable clips) + { + Debug.Assert(clips != null && clips.Any()); + + m_Clips = clips.ToArray(); + m_LeftMostClip = null; + m_RightMostClip = null; + + foreach (var clip in m_Clips) + { + if (m_LeftMostClip == null || clip.start < m_LeftMostClip.start) + m_LeftMostClip = clip; + + if (m_RightMostClip == null || clip.end > m_RightMostClip.end) + m_RightMostClip = clip; + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimelineClipGroup.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimelineClipGroup.cs.meta new file mode 100644 index 0000000..6106644 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/TimelineClipGroup.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b8c3bda3a988b5f4c910a5c3f722d0be +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim.meta new file mode 100644 index 0000000..e40400f --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: f6d64d8648793944dbadfd71f0f4b0a1 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/ITrimItemMode.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/ITrimItemMode.cs new file mode 100644 index 0000000..9286600 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/ITrimItemMode.cs @@ -0,0 +1,23 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + enum TrimEdge + { + Start, + End + } + + interface ITrimItemMode + { + void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection); + + void TrimStart(ITrimmable item, double time); + void TrimEnd(ITrimmable item, double time, bool affectTimeScale); + } + + interface ITrimItemDrawer + { + void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge); + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/ITrimItemMode.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/ITrimItemMode.cs.meta new file mode 100644 index 0000000..0dc6ddc --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/ITrimItemMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b4a5ce78107bc38409a3bb5e8b3289ac +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeMix.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeMix.cs new file mode 100644 index 0000000..7232c29 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeMix.cs @@ -0,0 +1,102 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TrimItemModeMix : ITrimItemMode, ITrimItemDrawer + { + ITrimmable m_Item; + + double m_Min; + double m_Max; + + public void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection) + { + m_Item = item; + + var sortedItems = ItemsUtils.GetItemsExcept(item.parentTrack, new[] {item}) + .OfType() + .OrderBy(c => c.start); + + var itemStart = (DiscreteTime)item.start; + var itemEnd = (DiscreteTime)item.end; + + var overlapped = sortedItems.LastOrDefault(c => (DiscreteTime)c.start == itemStart && (DiscreteTime)c.end == itemEnd); + + ITrimmable nextItem; + ITrimmable prevItem; + + m_Min = 0.0; + m_Max = double.PositiveInfinity; + + var blendableItem = item as IBlendable; + if (blendableItem != null && blendableItem.supportsBlending) + { + if (trimDirection == TrimEdge.Start) + { + nextItem = sortedItems.FirstOrDefault(c => (DiscreteTime)c.start >= itemStart && (DiscreteTime)c.end > itemEnd); + prevItem = sortedItems.LastOrDefault(c => (DiscreteTime)c.start <= itemStart && (DiscreteTime)c.end < itemEnd); + + if (prevItem != null) + m_Min = prevItem.start + EditModeUtils.BlendDuration(prevItem, TrimEdge.Start); + + if (nextItem != null) + m_Max = nextItem.start; + } + else + { + nextItem = sortedItems.FirstOrDefault(c => c != overlapped && (DiscreteTime)c.start >= itemStart && (DiscreteTime)c.end >= itemEnd); + prevItem = sortedItems.LastOrDefault(c => c != overlapped && (DiscreteTime)c.start <= itemStart && (DiscreteTime)c.end <= itemEnd); + + if (prevItem != null) + m_Min = prevItem.end; + + if (nextItem != null) + m_Max = nextItem.end - EditModeUtils.BlendDuration(nextItem, TrimEdge.End); + } + } + else + { + nextItem = sortedItems.FirstOrDefault(c => (DiscreteTime)c.start > itemStart); + prevItem = sortedItems.LastOrDefault(c => (DiscreteTime)c.start < itemStart); + + if (prevItem != null) + m_Min = prevItem.end; + + if (nextItem != null) + m_Max = nextItem.start; + } + } + + public void TrimStart(ITrimmable item, double time) + { + time = Math.Min(Math.Max(time, m_Min), m_Max); + item.SetStart(time); + } + + public void TrimEnd(ITrimmable item, double time, bool affectTimeScale) + { + time = Math.Min(Math.Max(time, m_Min), m_Max); + item.SetEnd(time, affectTimeScale); + } + + public void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge) + { + if (EditModeUtils.HasBlends(m_Item, edge)) + { + EditModeGUIUtils.DrawBoundsEdge(bounds, color, edge); + var cursorType = (edge == TrimEdge.End) + ? TimelineCursors.CursorType.MixRight + : TimelineCursors.CursorType.MixLeft; + + TimelineCursors.SetCursor(cursorType); + } + else + { + TimelineCursors.ClearCursor(); + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeMix.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeMix.cs.meta new file mode 100644 index 0000000..cac1412 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeMix.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5ddd9f7d3cce6724696a33752ab2f5a4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeReplace.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeReplace.cs new file mode 100644 index 0000000..4cc798c --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeReplace.cs @@ -0,0 +1,139 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TrimItemModeReplace : ITrimItemMode, ITrimItemDrawer + { + ITrimmable m_Item; + + ITrimmable m_ItemToBeReplaced; + double m_ClipOriginalEdgeValue; + bool m_TrimReplace; + + double m_Min; + double m_Max; + + public void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection) + { + m_Item = item; + + var sortedClips = ItemsUtils.GetItemsExcept(item.parentTrack, new[] { item }) + .OfType() + .OrderBy(c => c.start); + + var clipStart = (DiscreteTime)item.start; + var clipEnd = (DiscreteTime)item.end; + + var overlapped = sortedClips.LastOrDefault(c => (DiscreteTime)c.start == clipStart && (DiscreteTime)c.end == clipEnd); + + ITrimmable nextItem; + ITrimmable prevItem; + + m_Min = 0.0; + m_Max = double.PositiveInfinity; + + if (trimDirection == TrimEdge.Start) + { + nextItem = sortedClips.FirstOrDefault(c => (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end > clipEnd); + prevItem = sortedClips.LastOrDefault(c => (DiscreteTime)c.start <= clipStart && (DiscreteTime)c.end < clipEnd); + + if (prevItem != null) + m_Min = prevItem.start + EditModeUtils.BlendDuration(prevItem, TrimEdge.Start) + TimelineClip.kMinDuration; + + if (nextItem != null) + m_Max = nextItem.start; + + m_ItemToBeReplaced = prevItem; + + if (m_ItemToBeReplaced != null) + m_ClipOriginalEdgeValue = m_ItemToBeReplaced.end; + } + else + { + nextItem = sortedClips.FirstOrDefault(c => c != overlapped && (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end >= clipEnd); + prevItem = sortedClips.LastOrDefault(c => c != overlapped && (DiscreteTime)c.start <= clipStart && (DiscreteTime)c.end <= clipEnd); + + if (prevItem != null) + m_Min = prevItem.end; + + if (nextItem != null) + m_Max = nextItem.end - EditModeUtils.BlendDuration(nextItem, TrimEdge.End) - TimelineClip.kMinDuration; + + m_ItemToBeReplaced = nextItem; + + if (m_ItemToBeReplaced != null) + m_ClipOriginalEdgeValue = m_ItemToBeReplaced.start; + } + + m_TrimReplace = false; + } + + public void TrimStart(ITrimmable item, double time) + { + time = Math.Min(Math.Max(time, m_Min), m_Max); + + if (m_ItemToBeReplaced != null) + { + if (!m_TrimReplace) + m_TrimReplace = item.start >= m_ItemToBeReplaced.end; + } + + time = Math.Max(time, 0.0); + + item.SetStart(time); + + if (m_ItemToBeReplaced != null && m_TrimReplace) + { + var prevEnd = Math.Min(item.start, m_ClipOriginalEdgeValue); + m_ItemToBeReplaced.SetEnd(prevEnd, false); + } + } + + public void TrimEnd(ITrimmable item, double time, bool affectTimeScale) + { + time = Math.Min(Math.Max(time, m_Min), m_Max); + + if (m_ItemToBeReplaced != null) + { + if (!m_TrimReplace) + m_TrimReplace = item.end <= m_ItemToBeReplaced.start; + } + + item.SetEnd(time, affectTimeScale); + + if (m_ItemToBeReplaced != null && m_TrimReplace) + { + var nextStart = Math.Max(item.end, m_ClipOriginalEdgeValue); + m_ItemToBeReplaced.SetStart(nextStart); + } + } + + public void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge) + { + bool shouldDraw = m_ItemToBeReplaced != null && (edge == TrimEdge.End && m_Item.end > m_ClipOriginalEdgeValue) || + (edge == TrimEdge.Start && m_Item.start < m_ClipOriginalEdgeValue); + + if (shouldDraw) + { + var cursorType = TimelineCursors.CursorType.Replace; + if (EditModeUtils.HasBlends(m_Item, edge)) + { + color = DirectorStyles.kMixToolColor; + cursorType = (edge == TrimEdge.End) + ? TimelineCursors.CursorType.MixRight + : TimelineCursors.CursorType.MixLeft; + } + + EditModeGUIUtils.DrawBoundsEdge(bounds, color, edge); + TimelineCursors.SetCursor(cursorType); + } + else + { + TimelineCursors.ClearCursor(); + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeReplace.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeReplace.cs.meta new file mode 100644 index 0000000..a68744e --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeReplace.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 769f6f5dd7c8f2d4c9ab1caba0bd2628 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeRipple.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeRipple.cs new file mode 100644 index 0000000..1cce7a6 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeRipple.cs @@ -0,0 +1,97 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TrimItemModeRipple : ITrimItemMode, ITrimItemDrawer + { + double m_OriginalClipStart; + double m_OriginalClipEnd; + + ITrimmable[] m_NextItems; + + double m_BlendDuration; + + double m_TrimStartShift; + + public void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection) + { + m_OriginalClipStart = item.start; + m_OriginalClipEnd = item.end; + m_TrimStartShift = 0.0; + + var sortedClips = ItemsUtils.GetItemsExcept(item.parentTrack, new[] { item }) + .OfType() + .OrderBy(c => c.start); + + var clipStart = (DiscreteTime)item.start; + var clipEnd = (DiscreteTime)item.end; + + m_NextItems = sortedClips.Where(c => (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end >= clipEnd).ToArray(); + + var overlapped = sortedClips.LastOrDefault(c => (DiscreteTime)c.start == clipStart && (DiscreteTime)c.end == clipEnd); + + if (overlapped != null) + { + m_BlendDuration = overlapped.end - overlapped.start; + } + else + { + m_BlendDuration = 0.0; + + var prevClip = sortedClips.LastOrDefault(c => (DiscreteTime)c.start <= clipStart && (DiscreteTime)c.end <= clipEnd); + if (prevClip != null) + m_BlendDuration += Math.Max(prevClip.end - item.start, 0.0); + + var nextClip = sortedClips.FirstOrDefault(c => (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end >= clipEnd); + if (nextClip != null) + m_BlendDuration += Math.Max(item.end - nextClip.start, 0.0); + } + } + + public void TrimStart(ITrimmable item, double time) + { + var prevEnd = item.end; + + // HACK If time is negative, make sure we shift the SetStart operation to a positive space. + if (time < 0.0) + m_TrimStartShift = Math.Max(-time, m_TrimStartShift); + + item.start = m_OriginalClipEnd - item.duration + m_TrimStartShift; + time += m_TrimStartShift; + + if (m_BlendDuration > 0.0) + time = Math.Min(time, item.end - m_BlendDuration); + + item.SetStart(time); + + item.start = m_OriginalClipStart; + + var offset = item.end - prevEnd; + foreach (var timelineClip in m_NextItems) + timelineClip.start += offset; + } + + public void TrimEnd(ITrimmable item, double time, bool affectTimeScale) + { + var prevEnd = item.end; + + if (m_BlendDuration > 0.0) + time = Math.Max(time, item.start + m_BlendDuration); + + item.SetEnd(time, affectTimeScale); + + var offset = item.end - prevEnd; + foreach (var timelineClip in m_NextItems) + timelineClip.start += offset; + } + + public void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge) + { + EditModeGUIUtils.DrawBoundsEdge(bounds, color, edge); + TimelineCursors.SetCursor(TimelineCursors.CursorType.Ripple); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeRipple.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeRipple.cs.meta new file mode 100644 index 0000000..0c58aff --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Trim/TrimItemModeRipple.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 20c8bb6b47a526c4c96ca73314fe2856 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils.meta new file mode 100644 index 0000000..b4af7ca --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 67e9c6cf60c57a54f9f4db1bc33fd2e3 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeGUIUtils.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeGUIUtils.cs new file mode 100644 index 0000000..392709f --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeGUIUtils.cs @@ -0,0 +1,27 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + static class EditModeGUIUtils + { + public static void DrawBoundsEdge(Rect bounds, Color color, TrimEdge edge, float width = 4.0f) + { + var r = bounds; + r.yMin += 2.0f; + r.yMax -= 2.0f; + r.width = width; + + r.x = edge == TrimEdge.End ? bounds.xMax : bounds.xMin - width; + + EditorGUI.DrawRect(r, color); + } + + public static void DrawOverlayRect(Rect bounds, Color overlayColor) + { + var c = overlayColor; + c.a = 0.2f; + EditorGUI.DrawRect(bounds, c); + EditorGUI.DrawOutline(bounds, 1.0f, new Color(1.0f, 1.0f, 1.0f, 0.5f)); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeGUIUtils.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeGUIUtils.cs.meta new file mode 100644 index 0000000..6fdf542 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeGUIUtils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8938e753b3f47374889d5cf3265b563c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeMixUtils.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeMixUtils.cs new file mode 100644 index 0000000..ca34f4b --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeMixUtils.cs @@ -0,0 +1,137 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class EditModeMixUtils + { + static readonly List k_UnrecoverablePlacements = new List + { + PlacementValidity.InvalidIsWithin, + PlacementValidity.InvalidStartsInBlend, + PlacementValidity.InvalidContainsBlend + }; + + public static bool CanInsert(IEnumerable itemsGroups) + { + foreach (var itemsGroup in itemsGroups) + { + var siblings = ItemsUtils.GetItemsExcept(itemsGroup.targetTrack, itemsGroup.items); + foreach (var item in itemsGroup.items) + { + var placementValidity = GetPlacementValidity(item, siblings); + + if (k_UnrecoverablePlacements.Contains(placementValidity)) + { + return false; + } + } + } + + return true; + } + + //Corrects clips durations to fit at insertion point, if needed + public static void PrepareItemsForInsertion(IEnumerable itemsGroups) + { + foreach (var itemsGroup in itemsGroups) + { + var siblings = ItemsUtils.GetItemsExcept(itemsGroup.targetTrack, itemsGroup.items); + foreach (var item in itemsGroup.items.OfType()) + { + var eatenItems = siblings.Where(c => EditModeUtils.IsItemWithinRange(c, item.start, item.end)).ToList(); + + var intersectedItem = EditModeUtils.GetFirstIntersectedItem(siblings, item.end); + if (intersectedItem != null) + eatenItems.Add(intersectedItem); + + var blendableItems = eatenItems.OfType(); + if (blendableItems.Any()) + { + var minTime = blendableItems.Min(c => c.end - c.rightBlendDuration); + + if (item.end > minTime) + item.SetEnd(minTime, false); + } + } + } + } + + public static PlacementValidity GetPlacementValidity(ITimelineItem item, IEnumerable otherItems) + { + if (item.duration <= 0.0) + return PlacementValidity.Valid; //items without any duration can always be placed + + var sortedItems = otherItems.Where(i => i.duration > 0.0).OrderBy(c => c.start); + var candidates = new List(); + foreach (var sortedItem in sortedItems) + { + if ((DiscreteTime)sortedItem.start >= (DiscreteTime)item.end) + { + // No need to process further + break; + } + + if ((DiscreteTime)sortedItem.end <= (DiscreteTime)item.start) + { + // Skip + continue; + } + + candidates.Add(sortedItem); + } + + var discreteStart = (DiscreteTime)item.start; + var discreteEnd = (DiscreteTime)item.end; + + // Note: Order of tests matters + for (int i = 0, n = candidates.Count; i < n; i++) + { + var candidate = candidates[i]; + + var blendItem = item as IBlendable; + if (blendItem != null && blendItem.supportsBlending) + { + if (EditModeUtils.Contains(candidate.start, candidate.end, item)) + return PlacementValidity.InvalidIsWithin; + + if (i < n - 1) + { + var nextCandidate = candidates[i + 1]; + + var discreteNextCandidateStart = (DiscreteTime)nextCandidate.start; + var discreteCandidateEnd = (DiscreteTime)candidate.end; + + if (discreteCandidateEnd > discreteNextCandidateStart) + { + if (discreteStart >= discreteNextCandidateStart) + { + // Note: In case the placement is fully within a blend, + // InvalidStartsInBlend MUST have priority + return PlacementValidity.InvalidStartsInBlend; + } + + if (discreteEnd > discreteNextCandidateStart && discreteEnd <= discreteCandidateEnd) + return PlacementValidity.InvalidEndsInBlend; + + if (discreteStart < discreteNextCandidateStart && discreteEnd > discreteCandidateEnd) + return PlacementValidity.InvalidContainsBlend; + } + } + + if (EditModeUtils.Contains(item.start, item.end, candidate)) + return PlacementValidity.InvalidContains; + } + else + { + if (EditModeUtils.Overlaps(item, candidate.start, candidate.end) + || EditModeUtils.Overlaps(candidate, item.start, item.end)) + return PlacementValidity.InvalidOverlapWithNonBlendableClip; + } + } + + return PlacementValidity.Valid; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeMixUtils.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeMixUtils.cs.meta new file mode 100644 index 0000000..f36da89 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeMixUtils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 505965fb9ab352b4d88882d7c8d822bf +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeReplaceUtils.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeReplaceUtils.cs new file mode 100644 index 0000000..d004a5a --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeReplaceUtils.cs @@ -0,0 +1,57 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class EditModeReplaceUtils + { + public static void Insert(IEnumerable itemsGroups) + { + foreach (var itemsGroup in itemsGroups) + { + Insert(itemsGroup.targetTrack, itemsGroup.items); + } + } + + static void Insert(TrackAsset track, IEnumerable items) + { + if (track == null) return; + var orderedItems = ItemsUtils.GetItemsExcept(track, items) + .OfType() + .OrderBy(i => i.start).ToArray(); + + foreach (var item in items.OfType()) + { + var from = item.start; + var to = item.end; + + var overlappedItems = orderedItems.Where(i => EditModeUtils.Overlaps(i, from, to)); + + foreach (var overlappedItem in overlappedItems) + { + if (EditModeUtils.IsItemWithinRange(overlappedItem, from, to)) + { + overlappedItem.Delete(); + } + else + { + if (overlappedItem.start >= from) + overlappedItem.TrimStart(to); + else + overlappedItem.TrimEnd(from); + } + } + + var includingItems = orderedItems.Where(c => c.start to); + foreach (var includingItem in includingItems) + { + var newItem = includingItem.CloneTo(track, includingItem.start) as ITrimmable; + includingItem.TrimStart(to); + if (newItem != null) + newItem.SetEnd(from, false); + } + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeReplaceUtils.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeReplaceUtils.cs.meta new file mode 100644 index 0000000..3184352 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeReplaceUtils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6ca745fb561cbf640b6e603f95662fa0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeRippleUtils.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeRippleUtils.cs new file mode 100644 index 0000000..a705fc6 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeRippleUtils.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class EditModeRippleUtils + { + public static void Insert(IEnumerable itemsGroups) + { + var start = double.MaxValue; + var end = double.MinValue; + + foreach (var itemsGroup in itemsGroups) + { + start = Math.Min(start, itemsGroup.items.Min(c => c.start)); + end = Math.Max(end, itemsGroup.items.Max(c => c.end)); + } + + var offset = 0.0; + var discreteStart = (DiscreteTime)start; + var discreteEnd = (DiscreteTime)end; + var itemTypes = ItemsUtils.GetItemTypes(itemsGroups); + var siblingsToRipple = new List(); + + foreach (var itemsGroup in itemsGroups) + { + //can only ripple items of the same type as those selected + siblingsToRipple.AddRange(ItemsUtils.GetItemsExcept(itemsGroup.targetTrack, itemsGroup.items).Where(i => itemTypes.Contains(i.GetType()))); + foreach (var item in siblingsToRipple) + { + var discreteItemStart = (DiscreteTime)item.start; + var discreteItemEnd = (DiscreteTime)item.end; + + if ((discreteItemStart < discreteStart && discreteItemEnd > discreteStart) || (discreteItemStart >= discreteStart && discreteItemStart < discreteEnd)) + offset = Math.Max(offset, end - item.start); + } + } + + if (offset > 0.0) + { + foreach (var sibling in siblingsToRipple) + { + if ((DiscreteTime)sibling.end > (DiscreteTime)start) + sibling.start += offset; + } + } + } + + public static void Remove(IEnumerable itemsGroups) + { + foreach (var itemsGroup in itemsGroups) + Remove(itemsGroup.targetTrack, itemsGroup.items); + } + + static void Remove(TrackAsset track, IEnumerable items) + { + if (track == null) return; + + //can only ripple items of the same type as those selected + var itemTypes = ItemsUtils.GetItemTypes(items); + var siblingsToRipple = ItemsUtils.GetItemsExcept(track, items) + .Where(i => itemTypes.Contains(i.GetType())) + .OrderBy(c => c.start) + .ToArray(); + + var orderedItems = items + .OrderBy(c => c.start) + .ToArray(); + + var cumulativeOffset = 0.0; + + foreach (var item in orderedItems) + { + var offset = item.end - item.start; + var start = item.start - cumulativeOffset; + var end = item.end - cumulativeOffset; + + var nextItem = siblingsToRipple.FirstOrDefault(c => (DiscreteTime)c.start > (DiscreteTime)start && (DiscreteTime)c.start < (DiscreteTime)end); + if (nextItem != null) + { + offset -= end - nextItem.start; + } + + var prevItem = siblingsToRipple.FirstOrDefault(c => (DiscreteTime)c.end > (DiscreteTime)start && (DiscreteTime)c.end < (DiscreteTime)end); + if (prevItem != null) + { + offset -= prevItem.end - start; + } + + if (offset <= 0.0) + continue; + + cumulativeOffset += offset; + + for (int i = siblingsToRipple.Length - 1; i >= 0; --i) + { + var c = siblingsToRipple[i]; + if ((DiscreteTime)c.start < (DiscreteTime)start) + break; + + c.start = c.start - offset; + } + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeRippleUtils.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeRippleUtils.cs.meta new file mode 100644 index 0000000..1178683 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeRippleUtils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 495e2738ac7d88a41a158cd2e237d70b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeUtils.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeUtils.cs new file mode 100644 index 0000000..126f349 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeUtils.cs @@ -0,0 +1,123 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class EditModeUtils + { + public static void Delete(IEnumerable items) + { + if (items == null) + return; + + foreach (var item in items) + item.Delete(); + } + + public static void SetStart(IEnumerable items, double time) + { + var offset = time - items.Min(c => c.start); + + foreach (var item in items) + item.start += offset; + } + + public static void SetParentTrack(IEnumerable items, TrackAsset parentTrack) + { + foreach (var item in items) + { + if (item.parentTrack == parentTrack) + continue; + + item.parentTrack = parentTrack; + + var clipGUI = item.gui as TimelineClipGUI; + if (clipGUI != null) + { + clipGUI.clipCurveEditor = null; + } + } + } + + public static ITimelineItem GetFirstIntersectedItem(IEnumerable items, double time) + { + return items.FirstOrDefault(c => Intersects(time, c.start, c.end)); + } + + static bool Intersects(double time, double start, double end) + { + var discreteTime = (DiscreteTime)time; + return discreteTime > (DiscreteTime)start && discreteTime < (DiscreteTime)end; + } + + public static bool Overlaps(ITimelineItem item, double from, double to) + { + var discreteFrom = (DiscreteTime)from; + var discreteTo = (DiscreteTime)to; + var discreteStart = (DiscreteTime)item.start; + + if (discreteStart >= discreteFrom && discreteStart < discreteTo) + return true; + + var discreteEnd = (DiscreteTime)item.end; + + if (discreteEnd > discreteFrom && discreteEnd <= discreteTo) + return true; + + return false; + } + + public static bool IsItemWithinRange(ITimelineItem item, double from, double to) + { + return (DiscreteTime)item.start >= (DiscreteTime)from && (DiscreteTime)item.end <= (DiscreteTime)to; + } + + public static bool IsRangeWithinItem(double from, double to, ITimelineItem item) + { + return (DiscreteTime)from >= (DiscreteTime)item.start && (DiscreteTime)to <= (DiscreteTime)item.end; + } + + public static bool Contains(double from, double to, ITimelineItem item) + { + return (DiscreteTime)from < (DiscreteTime)item.start && (DiscreteTime)to > (DiscreteTime)item.end; + } + + public static bool HasBlends(ITimelineItem item, TrimEdge edge) + { + var blendable = item as IBlendable; + if (blendable == null) return false; + + return edge == TrimEdge.Start && blendable.hasLeftBlend || edge == TrimEdge.End && blendable.hasRightBlend; + } + + public static double BlendDuration(ITimelineItem item, TrimEdge edge) + { + var blendable = item as IBlendable; + if (blendable == null) return 0.0; + + return edge == TrimEdge.Start ? blendable.leftBlendDuration : blendable.rightBlendDuration; + } + + public static bool IsInfiniteTrack(TrackAsset track) + { + var aTrack = track as AnimationTrack; + return aTrack != null && aTrack.CanConvertToClipMode(); + } + + public static void GetInfiniteClipBoundaries(TrackAsset track, out double start, out double end) + { + var info = AnimationClipCurveCache.Instance.GetCurveInfo(((AnimationTrack)track).infiniteClip); + if (info.keyTimes.Length > 0) + { + start = info.keyTimes.Min(); + end = info.keyTimes.Max(); + } + else + { + start = end = 0.0f; + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeUtils.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeUtils.cs.meta new file mode 100644 index 0000000..cf5984a --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/EditModeUtils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 70eae1897c9d308448eb3bb0b5be9f58 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/ManipulatorsUtils.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/ManipulatorsUtils.cs new file mode 100644 index 0000000..c56aa1d --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/ManipulatorsUtils.cs @@ -0,0 +1,19 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + static class ManipulatorsUtils + { + public static EventModifiers actionModifier + { + get + { + if (Application.platform == RuntimePlatform.OSXEditor || + Application.platform == RuntimePlatform.OSXPlayer) + return EventModifiers.Command; + + return EventModifiers.Control; + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/ManipulatorsUtils.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/ManipulatorsUtils.cs.meta new file mode 100644 index 0000000..3b611ea --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/ManipulatorsUtils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e177382a693dea644acd34e3e7a3feb3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/PlacementValidity.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/PlacementValidity.cs new file mode 100644 index 0000000..76c0ced --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/PlacementValidity.cs @@ -0,0 +1,13 @@ +namespace UnityEditor.Timeline +{ + enum PlacementValidity + { + Valid, + InvalidContains, + InvalidIsWithin, + InvalidStartsInBlend, + InvalidEndsInBlend, + InvalidContainsBlend, + InvalidOverlapWithNonBlendableClip + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/PlacementValidity.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/PlacementValidity.cs.meta new file mode 100644 index 0000000..571f365 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Utils/PlacementValidity.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 335020228a0fe124897f51f25f6350ee +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: -- cgit v1.2.3