diff options
Diffstat (limited to 'Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation')
24 files changed, 2746 insertions, 0 deletions
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipActions.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipActions.cs new file mode 100644 index 0000000..4c79048 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipActions.cs @@ -0,0 +1,96 @@ +using System.ComponentModel; +using System.Linq; +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; +using ClipAction = UnityEditor.Timeline.ItemAction<UnityEngine.Timeline.TimelineClip>; + +namespace UnityEditor.Timeline +{ + [MenuEntry("Match Offsets To Previous Clip", MenuOrder.CustomClipAction.AnimClipMatchPrevious), UsedImplicitly] + class MatchOffsetsPreviousAction : ClipAction + { + public override bool Execute(WindowState state, TimelineClip[] items) + { + AnimationOffsetMenu.MatchClipsToPrevious(state, items.Where(x => IsValidClip(x, TimelineEditor.inspectedDirector)).ToArray()); + return true; + } + + private static bool IsValidClip(TimelineClip clip, PlayableDirector director) + { + return clip != null && + clip.parentTrack != null && + (clip.asset as AnimationPlayableAsset) != null && + clip.parentTrack.clips.Any(x => x.start < clip.start) && + TimelineUtility.GetSceneGameObject(director, clip.parentTrack) != null; + } + + protected override MenuActionDisplayState GetDisplayState(WindowState state, TimelineClip[] items) + { + if (!items.All(TimelineAnimationUtilities.IsAnimationClip)) + return MenuActionDisplayState.Hidden; + + var director = TimelineEditor.inspectedDirector; + if (TimelineEditor.inspectedDirector == null) + return MenuActionDisplayState.Hidden; + + if (items.Any(c => IsValidClip(c, director))) + return MenuActionDisplayState.Visible; + + return MenuActionDisplayState.Hidden; + } + } + + [MenuEntry("Match Offsets To Next Clip", MenuOrder.CustomClipAction.AnimClipMatchNext), UsedImplicitly] + class MatchOffsetsNextAction : ClipAction + { + public override bool Execute(WindowState state, TimelineClip[] items) + { + AnimationOffsetMenu.MatchClipsToNext(state, items.Where(x => IsValidClip(x, TimelineEditor.inspectedDirector)).ToArray()); + return true; + } + + private static bool IsValidClip(TimelineClip clip, PlayableDirector director) + { + return clip != null && + clip.parentTrack != null && + (clip.asset as AnimationPlayableAsset) != null && + clip.parentTrack.clips.Any(x => x.start > clip.start) && + TimelineUtility.GetSceneGameObject(director, clip.parentTrack) != null; + } + + protected override MenuActionDisplayState GetDisplayState(WindowState state, TimelineClip[] items) + { + if (!items.All(TimelineAnimationUtilities.IsAnimationClip)) + return MenuActionDisplayState.Hidden; + + var director = TimelineEditor.inspectedDirector; + if (TimelineEditor.inspectedDirector == null) + return MenuActionDisplayState.Hidden; + + if (items.Any(c => IsValidClip(c, director))) + return MenuActionDisplayState.Visible; + + return MenuActionDisplayState.Hidden; + } + } + + [MenuEntry("Reset Offsets", MenuOrder.CustomClipAction.AnimClipResetOffset), UsedImplicitly] + class ResetOffsets : ClipAction + { + public override bool Execute(WindowState state, TimelineClip[] items) + { + AnimationOffsetMenu.ResetClipOffsets(state, items.Where(TimelineAnimationUtilities.IsAnimationClip).ToArray()); + return true; + } + + protected override MenuActionDisplayState GetDisplayState(WindowState state, TimelineClip[] items) + { + if (!items.All(TimelineAnimationUtilities.IsAnimationClip)) + return MenuActionDisplayState.Hidden; + + return MenuActionDisplayState.Visible; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipActions.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipActions.cs.meta new file mode 100644 index 0000000..0632984 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipActions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bf22284ca28e7ef4490033b61e9b52cd +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/Animation/AnimationClipCurveCache.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipCurveCache.cs new file mode 100644 index 0000000..8570a73 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipCurveCache.cs @@ -0,0 +1,436 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEditor; +using UnityEditorInternal; + +namespace UnityEditor.Timeline +{ + struct CurveBindingPair + { + public EditorCurveBinding binding; + public AnimationCurve curve; + public ObjectReferenceKeyframe[] objectCurve; + } + + class CurveBindingGroup + { + public CurveBindingPair[] curveBindingPairs { get; set; } + public Vector2 timeRange { get; set; } + public Vector2 valueRange { get; set; } + + public bool isFloatCurve + { + get + { + return curveBindingPairs != null && curveBindingPairs.Length > 0 && + curveBindingPairs[0].curve != null; + } + } + + public bool isObjectCurve + { + get + { + return curveBindingPairs != null && curveBindingPairs.Length > 0 && + curveBindingPairs[0].objectCurve != null; + } + } + + public int count + { + get + { + if (curveBindingPairs == null) + return 0; + return curveBindingPairs.Length; + } + } + } + + class AnimationClipCurveInfo + { + bool m_CurveDirty = true; + bool m_KeysDirty = true; + + public bool dirty + { + get { return m_CurveDirty; } + set + { + m_CurveDirty = value; + if (m_CurveDirty) + { + m_KeysDirty = true; + if (m_groupings != null) + m_groupings.Clear(); + } + } + } + + public AnimationCurve[] curves; + public EditorCurveBinding[] bindings; + + public EditorCurveBinding[] objectBindings; + public List<ObjectReferenceKeyframe[]> objectCurves; + + Dictionary<string, CurveBindingGroup> m_groupings; + + // to tell whether the cache has changed + public int version { get; private set; } + + float[] m_KeyTimes; + + Dictionary<EditorCurveBinding, float[]> m_individualBindinsKey; + + public float[] keyTimes + { + get + { + if (m_KeysDirty || m_KeyTimes == null) + { + RebuildKeyCache(); + } + return m_KeyTimes; + } + } + + public float[] GetCurveTimes(EditorCurveBinding curve) + { + return GetCurveTimes(new[] { curve }); + } + + public float[] GetCurveTimes(EditorCurveBinding[] curves) + { + if (m_KeysDirty || m_KeyTimes == null) + { + RebuildKeyCache(); + } + + var keyTimes = new List<float>(); + for (int i = 0; i < curves.Length; i++) + { + var c = curves[i]; + if (m_individualBindinsKey.ContainsKey(c)) + { + keyTimes.AddRange(m_individualBindinsKey[c]); + } + } + return keyTimes.ToArray(); + } + + void RebuildKeyCache() + { + m_individualBindinsKey = new Dictionary<EditorCurveBinding, float[]>(); + + List<float> keys = curves.SelectMany(y => y.keys).Select(z => z.time).ToList(); + for (int i = 0; i < objectCurves.Count; i++) + { + var kf = objectCurves[i]; + keys.AddRange(kf.Select(x => x.time)); + } + + for (int b = 0; b < bindings.Count(); b++) + { + m_individualBindinsKey.Add(bindings[b], curves[b].keys.Select(k => k.time).Distinct().ToArray()); + } + + m_KeyTimes = keys.OrderBy(x => x).Distinct().ToArray(); + m_KeysDirty = false; + } + + public void Update(AnimationClip clip) + { + List<EditorCurveBinding> postfilter = new List<EditorCurveBinding>(); + var clipBindings = AnimationUtility.GetCurveBindings(clip); + for (int i = 0; i < clipBindings.Length; i++) + { + var bind = clipBindings[i]; + if (!bind.propertyName.Contains("LocalRotation.w")) + postfilter.Add(RotationCurveInterpolation.RemapAnimationBindingForRotationCurves(bind, clip)); + } + bindings = postfilter.ToArray(); + + curves = new AnimationCurve[bindings.Length]; + for (int i = 0; i < bindings.Length; i++) + { + curves[i] = AnimationUtility.GetEditorCurve(clip, bindings[i]); + } + + objectBindings = AnimationUtility.GetObjectReferenceCurveBindings(clip); + objectCurves = new List<ObjectReferenceKeyframe[]>(objectBindings.Length); + for (int i = 0; i < objectBindings.Length; i++) + { + objectCurves.Add(AnimationUtility.GetObjectReferenceCurve(clip, objectBindings[i])); + } + + m_CurveDirty = false; + m_KeysDirty = true; + + version = version + 1; + } + + public bool GetBindingForCurve(AnimationCurve curve, ref EditorCurveBinding binding) + { + for (int i = 0; i < curves.Length; i++) + { + if (curve == curves[i]) + { + binding = bindings[i]; + return true; + } + } + return false; + } + + public AnimationCurve GetCurveForBinding(EditorCurveBinding binding) + { + for (int i = 0; i < curves.Length; i++) + { + if (binding.Equals(bindings[i])) + { + return curves[i]; + } + } + return null; + } + + public ObjectReferenceKeyframe[] GetObjectCurveForBinding(EditorCurveBinding binding) + { + if (objectCurves == null) + return null; + + for (int i = 0; i < objectCurves.Count; i++) + { + if (binding.Equals(objectBindings[i])) + { + return objectCurves[i]; + } + } + return null; + } + + // given a groupID, get the list of curve bindings + public CurveBindingGroup GetGroupBinding(string groupID) + { + if (m_groupings == null) + m_groupings = new Dictionary<string, CurveBindingGroup>(); + + CurveBindingGroup result = null; + if (!m_groupings.TryGetValue(groupID, out result)) + { + result = new CurveBindingGroup(); + result.timeRange = new Vector2(float.MaxValue, float.MinValue); + result.valueRange = new Vector2(float.MaxValue, float.MinValue); + List<CurveBindingPair> found = new List<CurveBindingPair>(); + for (int i = 0; i < bindings.Length; i++) + { + if (bindings[i].GetGroupID() == groupID) + { + CurveBindingPair pair = new CurveBindingPair(); + pair.binding = bindings[i]; + pair.curve = curves[i]; + found.Add(pair); + + for (int k = 0; k < curves[i].keys.Length; k++) + { + var key = curves[i].keys[k]; + result.timeRange = new Vector2(Mathf.Min(key.time, result.timeRange.x), Mathf.Max(key.time, result.timeRange.y)); + result.valueRange = new Vector2(Mathf.Min(key.value, result.valueRange.x), Mathf.Max(key.value, result.valueRange.y)); + } + } + } + for (int i = 0; i < objectBindings.Length; i++) + { + if (objectBindings[i].GetGroupID() == groupID) + { + CurveBindingPair pair = new CurveBindingPair(); + pair.binding = objectBindings[i]; + pair.objectCurve = objectCurves[i]; + found.Add(pair); + + for (int k = 0; k < objectCurves[i].Length; k++) + { + var key = objectCurves[i][k]; + result.timeRange = new Vector2(Mathf.Min(key.time, result.timeRange.x), Mathf.Max(key.time, result.timeRange.y)); + } + } + } + + result.curveBindingPairs = found.OrderBy(x => AnimationWindowUtility.GetComponentIndex(x.binding.propertyName)).ToArray(); + + m_groupings.Add(groupID, result); + } + return result; + } + } + + // Cache for storing the animation clip data + class AnimationClipCurveCache + { + static AnimationClipCurveCache s_Instance; + Dictionary<AnimationClip, AnimationClipCurveInfo> m_ClipCache = new Dictionary<AnimationClip, AnimationClipCurveInfo>(); + bool m_IsEnabled; + + + public static AnimationClipCurveCache Instance + { + get + { + if (s_Instance == null) + { + s_Instance = new AnimationClipCurveCache(); + } + + return s_Instance; + } + } + + public void OnEnable() + { + if (!m_IsEnabled) + { + AnimationUtility.onCurveWasModified += OnCurveWasModified; + m_IsEnabled = true; + } + } + + public void OnDisable() + { + if (m_IsEnabled) + { + AnimationUtility.onCurveWasModified -= OnCurveWasModified; + m_IsEnabled = false; + } + } + + // callback when a curve is edited. Force the cache to update next time it's accessed + void OnCurveWasModified(AnimationClip clip, EditorCurveBinding binding, AnimationUtility.CurveModifiedType modification) + { + if (modification == AnimationUtility.CurveModifiedType.CurveDeleted) + { + m_ClipCache.Remove(clip); + } + else + { + AnimationClipCurveInfo data; + if (m_ClipCache.TryGetValue(clip, out data)) + { + data.dirty = true; + } + } + } + + public AnimationClipCurveInfo GetCurveInfo(AnimationClip clip) + { + AnimationClipCurveInfo data; + if (clip == null) + return null; + if (!m_ClipCache.TryGetValue(clip, out data)) + { + data = new AnimationClipCurveInfo(); + data.dirty = true; + m_ClipCache[clip] = data; + } + if (data.dirty) + { + data.Update(clip); + } + return data; + } + + public void ClearCachedProxyClips() + { + var toRemove = new List<AnimationClip>(); + foreach (var entry in m_ClipCache) + { + var clip = entry.Key; + if (clip != null && (clip.hideFlags & HideFlags.HideAndDontSave) == HideFlags.HideAndDontSave) + toRemove.Add(clip); + } + + foreach (var clip in toRemove) + { + m_ClipCache.Remove(clip); + Object.DestroyImmediate(clip, true); + } + } + + + public void Clear() + { + ClearCachedProxyClips(); + m_ClipCache.Clear(); + } + + } + + static class EditorCurveBindingExtension + { + // identifier to generate an id thats the same for all curves in the same group + public static string GetGroupID(this EditorCurveBinding binding) + { + return binding.type + AnimationWindowUtility.GetPropertyGroupName(binding.propertyName); + } + } + + + static class CurveBindingGroupExtensions + { + // Extentions to determine curve types + public static bool IsEnableGroup(this CurveBindingGroup curves) + { + return curves.isFloatCurve && curves.count == 1 && curves.curveBindingPairs[0].binding.propertyName == "m_Enabled"; + } + + public static bool IsVectorGroup(this CurveBindingGroup curves) + { + if (!curves.isFloatCurve) + return false; + if (curves.count <= 1 || curves.count > 4) + return false; + char l = curves.curveBindingPairs[0].binding.propertyName.Last(); + return l == 'x' || l == 'y' || l == 'z' || l == 'w'; + } + + public static bool IsColorGroup(this CurveBindingGroup curves) + { + if (!curves.isFloatCurve) + return false; + if (curves.count != 3 && curves.count != 4) + return false; + char l = curves.curveBindingPairs[0].binding.propertyName.Last(); + return l == 'r' || l == 'g' || l == 'b' || l == 'a'; + } + + public static string GetDescription(this CurveBindingGroup group, float t) + { + string result = string.Empty; + if (group.isFloatCurve) + { + if (group.count > 1) + { + result += "(" + group.curveBindingPairs[0].curve.Evaluate(t).ToString("0.##"); + for (int j = 1; j < group.curveBindingPairs.Length; j++) + { + result += "," + group.curveBindingPairs[j].curve.Evaluate(t).ToString("0.##"); + } + result += ")"; + } + else + { + result = group.curveBindingPairs[0].curve.Evaluate(t).ToString("0.##"); + } + } + else if (group.isObjectCurve) + { + Object obj = null; + if (group.curveBindingPairs[0].objectCurve.Length > 0) + obj = CurveEditUtility.Evaluate(group.curveBindingPairs[0].objectCurve, t); + result = (obj == null ? "None" : obj.name); + } + + return result; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipCurveCache.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipCurveCache.cs.meta new file mode 100644 index 0000000..47fcaa3 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationClipCurveCache.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 07a967d2fca95324f8922df8394a5655 +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/Animation/AnimationOffsetMenu.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationOffsetMenu.cs new file mode 100644 index 0000000..dbfc688 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationOffsetMenu.cs @@ -0,0 +1,82 @@ +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class AnimationOffsetMenu + { + public static GUIContent MatchPreviousMenuItem = EditorGUIUtility.TrTextContent("Match Offsets To Previous Clip"); + public static GUIContent MatchNextMenuItem = EditorGUIUtility.TrTextContent("Match Offsets To Next Clip"); + public static string MatchFieldsPrefix = "Match Offsets Fields/"; + public static GUIContent ResetOffsetMenuItem = EditorGUIUtility.TrTextContent("Reset Offsets"); + + static bool EnforcePreviewMode(WindowState state) + { + state.previewMode = true; // try and set the preview mode + if (!state.previewMode) + { + Debug.LogError("Match clips cannot be completed because preview mode cannot be enabed"); + return false; + } + return true; + } + + internal static void MatchClipsToPrevious(WindowState state, TimelineClip[] clips) + { + if (!EnforcePreviewMode(state)) + return; + + clips = clips.OrderBy(x => x.start).ToArray(); + foreach (var clip in clips) + { + var sceneObject = TimelineUtility.GetSceneGameObject(state.editSequence.director, clip.parentTrack); + if (sceneObject != null) + { + TimelineUndo.PushUndo(clip.asset, "Match Clip"); + TimelineAnimationUtilities.MatchPrevious(clip, sceneObject.transform, state.editSequence.director); + } + } + + InspectorWindow.RepaintAllInspectors(); + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + internal static void MatchClipsToNext(WindowState state, TimelineClip[] clips) + { + if (!EnforcePreviewMode(state)) + return; + + clips = clips.OrderByDescending(x => x.start).ToArray(); + foreach (var clip in clips) + { + var sceneObject = TimelineUtility.GetSceneGameObject(state.editSequence.director, clip.parentTrack); + if (sceneObject != null) + { + TimelineUndo.PushUndo(clip.asset, "Match Clip"); + TimelineAnimationUtilities.MatchNext(clip, sceneObject.transform, state.editSequence.director); + } + } + + InspectorWindow.RepaintAllInspectors(); + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + public static void ResetClipOffsets(WindowState state, TimelineClip[] clips) + { + foreach (var clip in clips) + { + if (clip.asset is AnimationPlayableAsset) + { + TimelineUndo.PushUndo(clip.asset, "Reset Offsets"); + var playableAsset = (AnimationPlayableAsset)clip.asset; + playableAsset.ResetOffsets(); + } + } + state.rebuildGraph = true; + + InspectorWindow.RepaintAllInspectors(); + TimelineEditor.Refresh(RefreshReason.SceneNeedsUpdate); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationOffsetMenu.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationOffsetMenu.cs.meta new file mode 100644 index 0000000..e628663 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationOffsetMenu.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9ace5095cc37ed849b52109d2ee305d4 +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/Animation/AnimationPlayableAssetEditor.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationPlayableAssetEditor.cs new file mode 100644 index 0000000..e4bebc1 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationPlayableAssetEditor.cs @@ -0,0 +1,65 @@ +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomTimelineEditor(typeof(AnimationPlayableAsset)), UsedImplicitly] + class AnimationPlayableAssetEditor : ClipEditor + { + public static readonly string k_NoClipAssignedError = LocalizationDatabase.GetLocalizedString("No animation clip assigned"); + public static readonly string k_LegacyClipError = LocalizationDatabase.GetLocalizedString("Legacy animation clips are not supported"); + static readonly string k_MotionCurveError = LocalizationDatabase.GetLocalizedString("You are using motion curves without applyRootMotion enabled on the Animator. The root transform will not be animated"); + static readonly string k_RootCurveError = LocalizationDatabase.GetLocalizedString("You are using root curves without applyRootMotion enabled on the Animator. The root transform will not be animated"); + + /// <inheritdoc/> + public override ClipDrawOptions GetClipOptions(TimelineClip clip) + { + var clipOptions = base.GetClipOptions(clip); + var asset = clip.asset as AnimationPlayableAsset; + + if (asset != null) + clipOptions.errorText = GetErrorText(asset, clip.parentTrack as AnimationTrack, clipOptions.errorText); + + if (clip.recordable) + clipOptions.highlightColor = DirectorStyles.Instance.customSkin.colorAnimationRecorded; + + return clipOptions; + } + + /// <inheritdoc /> + public override void OnCreate(TimelineClip clip, TrackAsset track, TimelineClip clonedFrom) + { + var asset = clip.asset as AnimationPlayableAsset; + if (asset != null && asset.clip != null && asset.clip.legacy) + { + asset.clip = null; + Debug.LogError("Legacy Animation Clips are not supported"); + } + } + + string GetErrorText(AnimationPlayableAsset animationAsset, AnimationTrack track, string defaultError) + { + if (animationAsset.clip == null) + return k_NoClipAssignedError; + if (animationAsset.clip.legacy) + return k_LegacyClipError; + if (animationAsset.clip.hasMotionCurves || animationAsset.clip.hasRootCurves) + { + if (track != null && track.trackOffset == TrackOffset.Auto) + { + var animator = track.GetBinding(TimelineEditor.inspectedDirector); + if (animator != null && !animator.applyRootMotion && !animationAsset.clip.hasGenericRootTransform) + { + if (animationAsset.clip.hasMotionCurves) + return k_MotionCurveError; + return k_RootCurveError; + } + } + } + + return defaultError; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationPlayableAssetEditor.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationPlayableAssetEditor.cs.meta new file mode 100644 index 0000000..0a749e8 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationPlayableAssetEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f7fed0d9d0f7a7f41a8525aa79e790b1 +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/Animation/AnimationTrackActions.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationTrackActions.cs new file mode 100644 index 0000000..0b1a171 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationTrackActions.cs @@ -0,0 +1,151 @@ +using System.ComponentModel; +using System.Linq; +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [MenuEntry("Add Override Track", MenuOrder.CustomTrackAction.AnimAddOverrideTrack), UsedImplicitly] + class AddOverrideTrackAction : TrackAction + { + public override bool Execute(WindowState state, TrackAsset[] tracks) + { + foreach (var animTrack in tracks.OfType<AnimationTrack>()) + { + TimelineHelpers.CreateTrack(typeof(AnimationTrack), animTrack, "Override " + animTrack.GetChildTracks().Count()); + } + + return true; + } + + protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks) + { + if (tracks.Any(t => t.isSubTrack || !t.GetType().IsAssignableFrom(typeof(AnimationTrack)))) + return MenuActionDisplayState.Hidden; + + if (tracks.Any(t => t.lockedInHierarchy)) + return MenuActionDisplayState.Disabled; + + return MenuActionDisplayState.Visible; + } + } + + [MenuEntry("Convert To Clip Track", MenuOrder.CustomTrackAction.AnimConvertToClipMode), UsedImplicitly] + class ConvertToClipModeAction : TrackAction + { + public override bool Execute(WindowState state, TrackAsset[] tracks) + { + foreach (var animTrack in tracks.OfType<AnimationTrack>()) + animTrack.ConvertToClipMode(); + + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + + return true; + } + + protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks) + { + if (tracks.Any(t => !t.GetType().IsAssignableFrom(typeof(AnimationTrack)))) + return MenuActionDisplayState.Hidden; + + if (tracks.Any(t => t.lockedInHierarchy)) + return MenuActionDisplayState.Disabled; + + if (tracks.OfType<AnimationTrack>().All(a => a.CanConvertToClipMode())) + return MenuActionDisplayState.Visible; + + return MenuActionDisplayState.Hidden; + } + } + + [MenuEntry("Convert To Infinite Clip", MenuOrder.CustomTrackAction.AnimConvertFromClipMode), UsedImplicitly] + class ConvertFromClipTrackAction : TrackAction + { + public override bool Execute(WindowState state, TrackAsset[] tracks) + { + foreach (var animTrack in tracks.OfType<AnimationTrack>()) + animTrack.ConvertFromClipMode(state.editSequence.asset); + + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + + return true; + } + + protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks) + { + if (tracks.Any(t => !t.GetType().IsAssignableFrom(typeof(AnimationTrack)))) + return MenuActionDisplayState.Hidden; + + if (tracks.Any(t => t.lockedInHierarchy)) + return MenuActionDisplayState.Disabled; + + if (tracks.OfType<AnimationTrack>().All(a => a.CanConvertFromClipMode())) + return MenuActionDisplayState.Visible; + + return MenuActionDisplayState.Hidden; + } + } + + abstract class TrackOffsetBaseAction : TrackAction + { + public abstract TrackOffset trackOffset { get; } + + protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks) + { + if (tracks.Any(t => !t.GetType().IsAssignableFrom(typeof(AnimationTrack)))) + return MenuActionDisplayState.Hidden; + + if (tracks.Any(t => t.lockedInHierarchy)) + return MenuActionDisplayState.Disabled; + + return MenuActionDisplayState.Visible; + } + + protected override bool IsChecked(WindowState state, TrackAsset[] tracks) + { + return tracks.OfType<AnimationTrack>().All(t => t.trackOffset == trackOffset); + } + + public override bool Execute(WindowState state, TrackAsset[] tracks) + { + foreach (var animTrack in tracks.OfType<AnimationTrack>()) + { + state.UnarmForRecord(animTrack); + TimelineUndo.PushUndo(animTrack, "Set Transform Offsets"); + animTrack.trackOffset = trackOffset; + } + + TimelineEditor.Refresh(RefreshReason.ContentsModified); + return true; + } + } + + + [MenuEntry("Track Offsets/Apply Transform Offsets", MenuOrder.CustomTrackAction.AnimApplyTrackOffset), UsedImplicitly] + class ApplyTransformOffsetAction : TrackOffsetBaseAction + { + public override TrackOffset trackOffset + { + get { return TrackOffset.ApplyTransformOffsets; } + } + } + + [MenuEntry("Track Offsets/Apply Scene Offsets", MenuOrder.CustomTrackAction.AnimApplySceneOffset), UsedImplicitly] + class ApplySceneOffsetAction : TrackOffsetBaseAction + { + public override TrackOffset trackOffset + { + get { return TrackOffset.ApplySceneOffsets; } + } + } + + [MenuEntry("Track Offsets/Auto (Deprecated)", MenuOrder.CustomTrackAction.AnimApplyAutoOffset), UsedImplicitly] + class ApplyAutoAction : TrackOffsetBaseAction + { + public override TrackOffset trackOffset + { + get { return TrackOffset.Auto; } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationTrackActions.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationTrackActions.cs.meta new file mode 100644 index 0000000..4ca0e4d --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/AnimationTrackActions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d4553f2006f48b6448553cb525d2876e +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/Animation/BindingSelector.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingSelector.cs new file mode 100644 index 0000000..7f3cdde --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingSelector.cs @@ -0,0 +1,224 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEditor.Timeline; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor +{ + class BindingSelector + { + TreeViewController m_TreeView; + public TreeViewController treeViewController + { + get { return m_TreeView; } + } + + TreeViewState m_TrackGlobalTreeViewState; + TreeViewState m_TreeViewState; + BindingTreeViewDataSource m_TreeViewDataSource; + CurveDataSource m_CurveDataSource; + TimelineWindow m_Window; + CurveEditor m_CurveEditor; + ReorderableList m_DopeLines; + string[] m_StringList = {}; + int[] m_Selection; + bool m_PartOfSelection; + public BindingSelector(EditorWindow window, CurveEditor curveEditor, TreeViewState trackGlobalTreeViewState) + { + m_Window = window as TimelineWindow; + m_CurveEditor = curveEditor; + m_TrackGlobalTreeViewState = trackGlobalTreeViewState; + + m_DopeLines = new ReorderableList(m_StringList, typeof(string), false, false, false, false); + m_DopeLines.drawElementBackgroundCallback = null; + m_DopeLines.showDefaultBackground = false; + m_DopeLines.index = 0; + m_DopeLines.headerHeight = 0; + m_DopeLines.elementHeight = 20; + m_DopeLines.draggable = false; + } + + public bool selectable { get { return true; } } + + public object selectableObject + { + get { return this; } + } + + public bool selected + { + get { return m_PartOfSelection; } + set + { + m_PartOfSelection = value; + + if (!m_PartOfSelection) + { + m_DopeLines.index = -1; + } + } + } + + public virtual void Delete(WindowState state) + { + // we dont support deleting the summary + if (m_DopeLines.index < 1) + return; + + if (m_CurveDataSource == null) + return; + + var clip = m_CurveDataSource.animationClip; + if (clip == null) + return; + + int curveIndexToDelete = m_DopeLines.index - 1; + var bindings = AnimationUtility.GetCurveBindings(clip); + + if (curveIndexToDelete >= bindings.Length) + return; + + TimelineUndo.PushUndo(clip, "Delete Curve"); + AnimationUtility.SetEditorCurve(clip, bindings[m_DopeLines.index - 1], null); + state.rebuildGraph = true; + } + + public void OnGUI(Rect targetRect) + { + if (m_TreeView == null) + return; + + m_TreeView.OnEvent(); + m_TreeView.OnGUI(targetRect, GUIUtility.GetControlID(FocusType.Passive)); + } + + public void InitIfNeeded(Rect rect, CurveDataSource dataSource, bool isNewSelection) + { + if (Event.current.type != EventType.Layout) + return; + + m_CurveDataSource = dataSource; + var clip = dataSource.animationClip; + + List<EditorCurveBinding> allBindings = new List<EditorCurveBinding>(); + allBindings.Add(new EditorCurveBinding { propertyName = "Summary" }); + if (clip != null) + allBindings.AddRange(AnimationUtility.GetCurveBindings(clip)); + + m_DopeLines.list = allBindings.ToArray(); + + if (m_TreeViewState != null) + { + if (isNewSelection) + RefreshAll(); + + return; + } + + m_TreeViewState = m_TrackGlobalTreeViewState != null ? m_TrackGlobalTreeViewState : new TreeViewState(); + + m_TreeView = new TreeViewController(m_Window, m_TreeViewState) + { + useExpansionAnimation = false, + deselectOnUnhandledMouseDown = true + }; + + m_TreeView.selectionChangedCallback += OnItemSelectionChanged; + + m_TreeViewDataSource = new BindingTreeViewDataSource(m_TreeView, clip, m_CurveDataSource); + + m_TreeView.Init(rect, m_TreeViewDataSource, new BindingTreeViewGUI(m_TreeView), null); + + m_TreeViewDataSource.UpdateData(); + + RefreshSelection(); + } + + void OnItemSelectionChanged(int[] selection) + { + RefreshSelection(selection); + } + + void RefreshAll() + { + RefreshTree(); + RefreshSelection(); + } + + void RefreshSelection() + { + RefreshSelection(m_TreeViewState.selectedIDs != null ? m_TreeViewState.selectedIDs.ToArray() : null); + } + + void RefreshSelection(int[] selection) + { + if (selection == null || selection.Length == 0) + { + // select all. + if (m_TreeViewDataSource.GetRows().Count > 0) + { + m_Selection = m_TreeViewDataSource.GetRows().Select(r => r.id).ToArray(); + } + } + else + { + m_Selection = selection; + } + + RefreshCurves(); + } + + public void RefreshCurves() + { + if (m_CurveDataSource == null || m_Selection == null) + return; + + var bindings = new List<EditorCurveBinding>(); + foreach (int s in m_Selection) + { + var item = (CurveTreeViewNode)m_TreeView.FindItem(s); + if (item != null && item.bindings != null) + bindings.AddRange(item.bindings); + } + + var wrappers = m_CurveDataSource.GenerateWrappers(bindings); + m_CurveEditor.animationCurves = wrappers.ToArray(); + } + + public void RefreshTree() + { + if (m_TreeViewDataSource == null) + return; + + if (m_Selection == null) + m_Selection = new int[0]; + + // get the names of the previous items + var selected = m_Selection.Select(x => m_TreeViewDataSource.FindItem(x)).Where(t => t != null).Select(c => c.displayName).ToArray(); + + // update the source + m_TreeViewDataSource.UpdateData(); + + // find the same items + var reselected = m_TreeViewDataSource.GetRows().Where(x => selected.Contains(x.displayName)).Select(x => x.id).ToArray(); + if (!reselected.Any()) + { + if (m_TreeViewDataSource.GetRows().Count > 0) + { + reselected = new[] { m_TreeViewDataSource.GetItem(0).id }; + } + } + + // update the selection + OnItemSelectionChanged(reselected); + } + + internal virtual bool IsRenamingNodeAllowed(TreeViewItem node) + { + return false; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingSelector.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingSelector.cs.meta new file mode 100644 index 0000000..b08aa56 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingSelector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c171b9ca03610ea4faa426e082a1075d +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/Animation/BindingTreeViewDataSource.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSource.cs new file mode 100644 index 0000000..8118285 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSource.cs @@ -0,0 +1,139 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEditor; +using UnityEditor.IMGUI.Controls; +using UnityEditor.Timeline; +using UnityEngine; + +namespace UnityEditorInternal +{ + class BindingTreeViewDataSource : TreeViewDataSource + { + public const int RootID = int.MinValue; + public const int GroupID = -1; + + AnimationClip m_Clip; + CurveDataSource m_CurveDataSource; + + public BindingTreeViewDataSource( + TreeViewController treeView, AnimationClip clip, CurveDataSource curveDataSource) + : base(treeView) + { + m_Clip = clip; + showRootItem = false; + m_CurveDataSource = curveDataSource; + } + + void SetupRootNodeSettings() + { + showRootItem = false; + SetExpanded(RootID, true); + SetExpanded(GroupID, true); + } + + static string GroupName(EditorCurveBinding binding) + { + string property = AnimationWindowUtility.NicifyPropertyGroupName(binding.type, binding.propertyName); + if (!string.IsNullOrEmpty(binding.path)) + { + property = binding.path + " : " + property; + } + + int lastArrayIdx = property.LastIndexOf("Array."); + if (lastArrayIdx != -1) + { + property = property.Substring(0, lastArrayIdx - 1); + } + return property; + } + + static string PropertyName(EditorCurveBinding binding, string arrayPrefixToRemove = "") + { + string propertyName = AnimationWindowUtility.GetPropertyDisplayName(binding.propertyName); + if (propertyName.Contains("Array")) + { + propertyName = propertyName.Replace("Array.", ""); + propertyName = propertyName.Replace(arrayPrefixToRemove, ""); + propertyName = propertyName.TrimStart('.'); + } + return propertyName; + } + + public override void FetchData() + { + if (m_Clip == null) + return; + + var bindings = AnimationUtility.GetCurveBindings(m_Clip) + .Union(AnimationUtility.GetObjectReferenceCurveBindings(m_Clip)) + .ToArray(); + + var results = bindings.GroupBy(p => GroupName(p), p => p, (key, g) => new + { + parent = key, + bindings = g.ToList() + }).OrderBy(t => + { + //Force transform order first + if (t.parent == "Position") return -3; + if (t.parent == "Rotation") return -2; + if (t.parent == "Scale") return -1; + return 0; + }).ThenBy(t => t.parent); + + m_RootItem = new CurveTreeViewNode(RootID, null, "root", null) + { + children = new List<TreeViewItem>(1) + }; + + var groupingNode = new CurveTreeViewNode(GroupID, m_RootItem, m_CurveDataSource.groupingName, bindings) + { + children = new List<TreeViewItem>() + }; + + m_RootItem.children.Add(groupingNode); + + foreach (var r in results) + { + var newNode = new CurveTreeViewNode(r.parent.GetHashCode(), groupingNode, r.parent, r.bindings.ToArray()); + groupingNode.children.Add(newNode); + if (r.bindings.Count > 1) + { + for (int b = 0; b < r.bindings.Count; b++) + { + if (newNode.children == null) + newNode.children = new List<TreeViewItem>(); + + var binding = r.bindings[b]; + var bindingNode = new CurveTreeViewNode(binding.GetHashCode(), newNode, PropertyName(binding, newNode.displayName), new[] {binding}); + newNode.children.Add(bindingNode); + } + } + } + + SetupRootNodeSettings(); + m_NeedRefreshRows = true; + } + + public void UpdateData() + { + m_TreeView.ReloadData(); + } + } + + class CurveTreeViewNode : TreeViewItem + { + EditorCurveBinding[] m_Bindings; + + public EditorCurveBinding[] bindings + { + get { return m_Bindings; } + } + + public CurveTreeViewNode(int id, TreeViewItem parent, string displayName, EditorCurveBinding[] bindings) + : base(id, parent != null ? parent.depth + 1 : -1, parent, displayName) + { + m_Bindings = bindings; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSource.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSource.cs.meta new file mode 100644 index 0000000..b553947 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9c2177aaf0fde92439246adc2dc0bfa2 +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/Animation/BindingTreeViewDataSourceGUI.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSourceGUI.cs new file mode 100644 index 0000000..443a216 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSourceGUI.cs @@ -0,0 +1,80 @@ +using UnityEditor; +using UnityEditor.IMGUI.Controls; +using UnityEngine; + +namespace UnityEditorInternal +{ + class BindingTreeViewGUI : TreeViewGUI + { + static readonly float s_RowRightOffset = 10; + static readonly float s_ColorIndicatorTopMargin = 3; + static readonly Color s_KeyColorForNonCurves = new Color(0.7f, 0.7f, 0.7f, 0.5f); + static readonly Color s_ChildrenCurveLabelColor = new Color(1.0f, 1.0f, 1.0f, 0.7f); + + public BindingTreeViewGUI(TreeViewController treeView) + : base(treeView, true) + { + k_IconWidth = 13.0f; + } + + public override void OnRowGUI(Rect rowRect, TreeViewItem node, int row, bool selected, bool focused) + { + Color originalColor = GUI.color; + GUI.color = node.parent == null || + node.parent.id == BindingTreeViewDataSource.RootID || + node.parent.id == BindingTreeViewDataSource.GroupID ? + Color.white : + s_ChildrenCurveLabelColor; + + base.OnRowGUI(rowRect, node, row, selected, focused); + + GUI.color = originalColor; + DoCurveColorIndicator(rowRect, node as CurveTreeViewNode); + } + + protected override bool IsRenaming(int id) + { + return false; + } + + public override bool BeginRename(TreeViewItem item, float delay) + { + return false; + } + + void DoCurveColorIndicator(Rect rect, CurveTreeViewNode node) + { + if (node == null) + return; + + if (Event.current.type != EventType.Repaint) + return; + + Color originalColor = GUI.color; + + if (node.bindings.Length == 1 && !node.bindings[0].isPPtrCurve) + GUI.color = CurveUtility.GetPropertyColor(node.bindings[0].propertyName); + else + GUI.color = s_KeyColorForNonCurves; + + Texture icon = CurveUtility.GetIconCurve(); + rect = new Rect(rect.xMax - s_RowRightOffset - (icon.width * 0.5f) - 5, rect.yMin + s_ColorIndicatorTopMargin, icon.width, icon.height); + + GUI.DrawTexture(rect, icon, ScaleMode.ScaleToFit, true, 1); + + GUI.color = originalColor; + } + + protected override Texture GetIconForItem(TreeViewItem item) + { + var node = item as CurveTreeViewNode; + if (node == null) + return null; + + if (node.bindings == null || node.bindings.Length == 0) + return null; + + return AssetPreview.GetMiniTypeThumbnail(node.bindings[0].type); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSourceGUI.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSourceGUI.cs.meta new file mode 100644 index 0000000..2e16c1b --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/BindingTreeViewDataSourceGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3c09dc5cd0a70cf40856b7d406106ee1 +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/Animation/ClipCurveEditor.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/ClipCurveEditor.cs new file mode 100644 index 0000000..da1d0e6 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/ClipCurveEditor.cs @@ -0,0 +1,332 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.Timeline; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor +{ + class ClipCurveEditor + { + internal readonly CurveEditor m_CurveEditor; + static readonly CurveEditorSettings s_CurveEditorSettings = new CurveEditorSettings + { + hSlider = false, + vSlider = false, + hRangeLocked = false, + vRangeLocked = false, + scaleWithWindow = true, + hRangeMin = 0.0f, + showAxisLabels = true, + allowDeleteLastKeyInCurve = true, + rectangleToolFlags = CurveEditorSettings.RectangleToolFlags.MiniRectangleTool + }; + + static readonly float s_GridLabelWidth = 40.0f; + + readonly BindingSelector m_BindingHierarchy; + public BindingSelector bindingHierarchy + { + get { return m_BindingHierarchy; } + } + + public Rect shownAreaInsideMargins + { + get { return m_CurveEditor != null ? m_CurveEditor.shownAreaInsideMargins : new Rect(1, 1, 1, 1); } + } + + Vector2 m_ScrollPosition = Vector2.zero; + + readonly CurveDataSource m_DataSource; + + float m_LastFrameRate = 30.0f; + int m_LastClipVersion = -1; + int m_LastCurveCount = -1; + TrackViewModelData m_ViewModel; + bool m_ShouldRestoreShownArea; + + bool isNewSelection + { + get + { + if (m_ViewModel == null || m_DataSource == null) + return true; + + return m_ViewModel.lastInlineCurveDataID != m_DataSource.id; + } + } + + internal CurveEditor curveEditor + { + get { return m_CurveEditor; } + } + + public ClipCurveEditor(CurveDataSource dataSource, TimelineWindow parentWindow, TrackAsset hostTrack) + { + m_DataSource = dataSource; + + m_CurveEditor = new CurveEditor(new Rect(0, 0, 1000, 100), new CurveWrapper[0], false); + + s_CurveEditorSettings.vTickStyle = new TickStyle + { + tickColor = { color = DirectorStyles.Instance.customSkin.colorInlineCurveVerticalLines }, + distLabel = 20, + stubs = true + }; + + s_CurveEditorSettings.hTickStyle = new TickStyle + { + // hide horizontal lines by giving them a transparent color + tickColor = { color = new Color(0.0f, 0.0f, 0.0f, 0.0f) }, + distLabel = 0 + }; + + m_CurveEditor.settings = s_CurveEditorSettings; + + m_ViewModel = TimelineWindowViewPrefs.GetTrackViewModelData(hostTrack); + + m_ShouldRestoreShownArea = true; + m_CurveEditor.ignoreScrollWheelUntilClicked = true; + m_CurveEditor.curvesUpdated = OnCurvesUpdated; + + m_BindingHierarchy = new BindingSelector(parentWindow, m_CurveEditor, m_ViewModel.inlineCurvesState); + } + + public void SelectAllKeys() + { + m_CurveEditor.SelectAll(); + } + + public void FrameClip() + { + m_CurveEditor.InvalidateBounds(); + m_CurveEditor.FrameClip(false, true); + } + + public CurveDataSource dataSource + { + get { return m_DataSource; } + } + + internal void OnCurvesUpdated() + { + if (m_DataSource == null) + return; + + if (m_CurveEditor == null) + return; + + if (m_CurveEditor.animationCurves.Length == 0) + return; + + List<CurveWrapper> curvesToUpdate = m_CurveEditor.animationCurves.Where(c => c.changed).ToList(); + + // nothing changed, return. + if (curvesToUpdate.Count == 0) + return; + + AnimationClip clip = m_DataSource.animationClip; + + // something changed, manage the undo properly. + Undo.RegisterCompleteObjectUndo(clip, "Edit Clip Curve"); + + foreach (CurveWrapper c in curvesToUpdate) + { + AnimationUtility.SetEditorCurve(clip, c.binding, c.curve); + c.changed = false; + } + + m_DataSource.UpdateCurves(curvesToUpdate); + } + + public void DrawHeader(Rect headerRect) + { + m_BindingHierarchy.InitIfNeeded(headerRect, m_DataSource, isNewSelection); + + try + { + GUILayout.BeginArea(headerRect); + m_ScrollPosition = GUILayout.BeginScrollView(m_ScrollPosition, GUIStyle.none, GUI.skin.verticalScrollbar); + m_BindingHierarchy.OnGUI(new Rect(0, 0, headerRect.width, headerRect.height)); + GUILayout.EndScrollView(); + GUILayout.EndArea(); + } + catch (Exception e) + { + Debug.LogException(e); + } + } + + class FrameFormatCurveEditorState : ICurveEditorState + { + public TimeArea.TimeFormat timeFormat + { + get { return TimeArea.TimeFormat.Frame; } + } + public Vector2 timeRange { get { return new Vector2(0, 1); } } + public bool rippleTime { get { return false; } } + } + + class UnformattedCurveEditorState : ICurveEditorState + { + public TimeArea.TimeFormat timeFormat + { + get { return TimeArea.TimeFormat.None; } + } + public Vector2 timeRange { get { return new Vector2(0, 1); } } + public bool rippleTime { get { return false; } } + } + + void UpdateCurveEditorIfNeeded(WindowState state) + { + if ((Event.current.type != EventType.Layout) || (m_DataSource == null) || (m_BindingHierarchy == null) || (m_DataSource.animationClip == null)) + return; + + AnimationClipCurveInfo curveInfo = AnimationClipCurveCache.Instance.GetCurveInfo(m_DataSource.animationClip); + int version = curveInfo.version; + if (version != m_LastClipVersion) + { + // tree has changed + if (m_LastCurveCount != curveInfo.curves.Length) + { + m_BindingHierarchy.RefreshTree(); + m_LastCurveCount = curveInfo.curves.Length; + } + else + { + // update just the curves + m_BindingHierarchy.RefreshCurves(); + } + m_LastClipVersion = version; + } + + if (state.timeInFrames) + m_CurveEditor.state = new FrameFormatCurveEditorState(); + else + m_CurveEditor.state = new UnformattedCurveEditorState(); + + m_CurveEditor.invSnap = state.referenceSequence.frameRate; + } + + public void DrawCurveEditor(Rect rect, WindowState state, Vector2 clipRange, bool loop, bool selected) + { + var curveEndTime = m_DataSource.start + m_DataSource.animationClip.length / m_DataSource.timeScale; + var curveRange = new Vector2(state.TimeToPixel(m_DataSource.start), state.TimeToPixel(curveEndTime)); + + SetupMarginsAndRect(rect, curveRange, state); + UpdateCurveEditorIfNeeded(state); + + if (m_ShouldRestoreShownArea) + RestoreShownArea(); + m_CurveEditor.SetShownHRangeInsideMargins(0.0f, m_DataSource.animationClip.length); //align the curve with the clip. + + if (m_LastFrameRate != state.referenceSequence.frameRate) + { + m_CurveEditor.hTicks.SetTickModulosForFrameRate(state.referenceSequence.frameRate); + m_LastFrameRate = state.referenceSequence.frameRate; + } + + foreach (var cw in m_CurveEditor.animationCurves) + cw.renderer.SetWrap(WrapMode.Default, loop ? WrapMode.Loop : WrapMode.Default); + + using (new GUIGroupScope(rect)) + { + var localRect = new Rect(0.0f, 0.0f, rect.width, rect.height); + var localClipRange = new Vector2(Mathf.Floor(clipRange.x - rect.xMin), Mathf.Ceil(clipRange.y - rect.xMin)); + var localCurveRange = new Vector2(Mathf.Floor(curveRange.x - rect.xMin), Mathf.Ceil(curveRange.y - rect.xMin)); + + EditorGUI.DrawRect(new Rect(localCurveRange.x, 0.0f, 1.0f, rect.height), new Color(1.0f, 1.0f, 1.0f, 0.5f)); + DrawCurveEditorBackground(localRect, localClipRange); + + if (selected) + { + var selectionRect = new Rect(localClipRange.x, 0.0f, localClipRange.y - localClipRange.x, localRect.height); + DrawOutline(selectionRect); + } + + EditorGUI.BeginChangeCheck(); + { + var evt = Event.current; + if (evt.type == EventType.Layout || evt.type == EventType.Repaint || selected) + m_CurveEditor.CurveGUI(); + } + if (EditorGUI.EndChangeCheck()) + OnCurvesUpdated(); + + DrawOverlay(localRect, localClipRange, DirectorStyles.Instance.customSkin.colorInlineCurveOutOfRangeOverlay); + DrawGrid(localRect, localCurveRange); + } + } + + void SetupMarginsAndRect(Rect rect, Vector2 curveRange, WindowState state) + { + var timelineWidth = state.TimeToPixel(Mathf.Max((float)state.editSequence.duration, state.timeAreaShownRange.y)); + m_CurveEditor.rect = new Rect(-rect.xMin, 0.0f, timelineWidth, rect.height); + m_CurveEditor.leftmargin = curveRange.x; + m_CurveEditor.rightmargin = timelineWidth - curveRange.y; + m_CurveEditor.topmargin = m_CurveEditor.bottommargin = CalculateTopMargin(rect.height); + } + + void RestoreShownArea() + { + if (isNewSelection) + FrameClip(); + else + m_CurveEditor.shownAreaInsideMargins = m_ViewModel.inlineCurvesShownAreaInsideMargins; + m_ShouldRestoreShownArea = false; + } + + static void DrawCurveEditorBackground(Rect rect, Vector2 activeRange) + { + if (EditorGUIUtility.isProSkin) + return; + + var animEditorBackgroundRect = Rect.MinMaxRect(0.0f, rect.yMin, rect.xMax, rect.yMax); + + // Curves are not legible in Personal Skin so we need to darken the background a bit. + EditorGUI.DrawRect(animEditorBackgroundRect, DirectorStyles.Instance.customSkin.colorInlineCurvesBackground); + } + + static float CalculateTopMargin(float height) + { + return Mathf.Clamp(0.15f * height, 10.0f, 40.0f); + } + + static void DrawOutline(Rect rect, float thickness = 2.0f) + { + // Draw top selected lines. + EditorGUI.DrawRect(new Rect(rect.xMin, rect.yMin, rect.width, thickness), Color.white); + + // Draw bottom selected lines. + EditorGUI.DrawRect(new Rect(rect.xMin, rect.yMax - thickness, rect.width, thickness), Color.white); + + // Draw Left Selected Lines + EditorGUI.DrawRect(new Rect(rect.xMin, rect.yMin, thickness, rect.height), Color.white); + + // Draw Right Selected Lines + EditorGUI.DrawRect(new Rect(rect.xMax - thickness, rect.yMin, thickness, rect.height), Color.white); + } + + static void DrawOverlay(Rect rect, Vector2 clipRange, Color color) + { + var leftSide = new Rect(rect.xMin, rect.yMin, clipRange.x - rect.xMin, rect.height); + EditorGUI.DrawRect(leftSide, color); + + var rightSide = new Rect(Mathf.Max(0.0f, clipRange.y), rect.yMin, rect.xMax, rect.height); + EditorGUI.DrawRect(rightSide, color); + } + + void DrawGrid(Rect rect, Vector2 curveRange) + { + var gridXPos = Mathf.Max(curveRange.x - s_GridLabelWidth, rect.xMin); + var gridRect = new Rect(gridXPos, rect.y, s_GridLabelWidth, rect.height); + var originalRect = m_CurveEditor.rect; + + m_CurveEditor.rect = new Rect(0.0f, 0.0f, rect.width, rect.height); + using (new GUIGroupScope(gridRect)) + m_CurveEditor.GridGUI(); + m_CurveEditor.rect = originalRect; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/ClipCurveEditor.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/ClipCurveEditor.cs.meta new file mode 100644 index 0000000..5ae80d2 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/ClipCurveEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d49b2ed20045e034f9cdf6a6d95e6183 +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/Animation/CurveDataSource.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurveDataSource.cs new file mode 100644 index 0000000..b5ad13b --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurveDataSource.cs @@ -0,0 +1,272 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + abstract class CurveDataSource + { + public static CurveDataSource Create(IRowGUI trackGUI) + { + if (trackGUI.asset is AnimationTrack) + return new InfiniteClipCurveDataSource(trackGUI); + + return new TrackParametersCurveDataSource(trackGUI); + } + + public static CurveDataSource Create(TimelineClipGUI clipGUI) + { + if (clipGUI.clip.animationClip != null) + return new ClipAnimationCurveDataSource(clipGUI); + + return new ClipParametersCurveDataSource(clipGUI); + } + + int? m_ID = null; + public int id + { + get + { + if (!m_ID.HasValue) + m_ID = CreateHashCode(); + + return m_ID.Value; + } + } + + readonly IRowGUI m_TrackGUI; + protected IRowGUI trackGUI { get { return m_TrackGUI; } } + + protected CurveDataSource(IRowGUI trackGUI) + { + m_TrackGUI = trackGUI; + } + + public abstract AnimationClip animationClip { get; } + public abstract float start { get; } + public abstract float timeScale { get; } + public abstract string groupingName { get; } + public virtual void UpdateCurves(List<CurveWrapper> updatedCurves) {} + public virtual void RebuildCurves() {} // Only necessary when using proxies + + public Rect GetBackgroundRect(WindowState state) + { + var trackRect = m_TrackGUI.boundingRect; + return new Rect( + state.timeAreaTranslation.x + trackRect.xMin, + trackRect.y, + (float)state.editSequence.asset.duration * state.timeAreaScale.x, + trackRect.height + ); + } + + public List<CurveWrapper> GenerateWrappers(List<EditorCurveBinding> bindings) + { + var wrappers = new List<CurveWrapper>(bindings.Count); + int curveWrapperId = 0; + + foreach (EditorCurveBinding b in bindings) + { + // General configuration + var wrapper = new CurveWrapper + { + id = curveWrapperId++, + binding = b, + groupId = -1, + hidden = false, + readOnly = false, + getAxisUiScalarsCallback = () => new Vector2(1, 1) + }; + + // Specific configuration + ConfigureCurveWrapper(wrapper); + + wrappers.Add(wrapper); + } + + return wrappers; + } + + protected virtual void ConfigureCurveWrapper(CurveWrapper wrapper) + { + wrapper.color = CurveUtility.GetPropertyColor(wrapper.binding.propertyName); + wrapper.renderer = new NormalCurveRenderer(AnimationUtility.GetEditorCurve(animationClip, wrapper.binding)); + wrapper.renderer.SetCustomRange(0.0f, animationClip.length); + } + + protected virtual int CreateHashCode() + { + return m_TrackGUI.asset.GetHashCode(); + } + } + + class ClipAnimationCurveDataSource : CurveDataSource + { + static readonly string k_GroupingName = L10n.Tr("Animated Values"); + + readonly TimelineClipGUI m_ClipGUI; + + public ClipAnimationCurveDataSource(TimelineClipGUI clipGUI) : base(clipGUI.parent) + { + m_ClipGUI = clipGUI; + } + + public override AnimationClip animationClip + { + get { return m_ClipGUI.clip.animationClip; } + } + + public override float start + { + get { return (float)m_ClipGUI.clip.FromLocalTimeUnbound(0.0); } + } + + public override float timeScale + { + get { return (float)m_ClipGUI.clip.timeScale; } + } + + public override string groupingName + { + get { return k_GroupingName; } + } + + protected override int CreateHashCode() + { + return base.CreateHashCode().CombineHash(m_ClipGUI.clip.GetHashCode()); + } + } + + class ClipParametersCurveDataSource : CurveDataSource + { + static readonly string k_GroupingName = L10n.Tr("Clip Properties"); + + readonly TimelineClipGUI m_ClipGUI; + readonly CurvesProxy m_CurvesProxy; + + public ClipParametersCurveDataSource(TimelineClipGUI clipGUI) : base(clipGUI.parent) + { + m_ClipGUI = clipGUI; + m_CurvesProxy = new CurvesProxy(clipGUI.clip); + } + + public override AnimationClip animationClip + { + get { return m_CurvesProxy.curves; } + } + + public override float start + { + get { return (float)m_ClipGUI.clip.FromLocalTimeUnbound(0.0); } + } + + public override float timeScale + { + get { return (float)m_ClipGUI.clip.timeScale; } + } + + public override string groupingName + { + get { return k_GroupingName; } + } + + public override void UpdateCurves(List<CurveWrapper> updatedCurves) + { + m_CurvesProxy.UpdateCurves(updatedCurves); + } + + public override void RebuildCurves() + { + m_CurvesProxy.RebuildCurves(); + } + + protected override void ConfigureCurveWrapper(CurveWrapper wrapper) + { + m_CurvesProxy.ConfigureCurveWrapper(wrapper); + } + + protected override int CreateHashCode() + { + return base.CreateHashCode().CombineHash(m_ClipGUI.clip.GetHashCode()); + } + } + + class InfiniteClipCurveDataSource : CurveDataSource + { + static readonly string k_GroupingName = L10n.Tr("Animated Values"); + + readonly AnimationTrack m_AnimationTrack; + + public InfiniteClipCurveDataSource(IRowGUI trackGui) : base(trackGui) + { + m_AnimationTrack = trackGui.asset as AnimationTrack; + } + + public override AnimationClip animationClip + { + get { return m_AnimationTrack.infiniteClip; } + } + + public override float start + { + get { return 0.0f; } + } + + public override float timeScale + { + get { return 1.0f; } + } + + public override string groupingName + { + get { return k_GroupingName; } + } + } + + class TrackParametersCurveDataSource : CurveDataSource + { + static readonly string k_GroupingName = L10n.Tr("Track Properties"); + + readonly CurvesProxy m_CurvesProxy; + + public TrackParametersCurveDataSource(IRowGUI trackGui) : base(trackGui) + { + m_CurvesProxy = new CurvesProxy(trackGui.asset); + } + + public override AnimationClip animationClip + { + get { return m_CurvesProxy.curves; } + } + + public override float start + { + get { return 0.0f; } + } + + public override float timeScale + { + get { return 1.0f; } + } + + public override string groupingName + { + get { return k_GroupingName; } + } + + public override void UpdateCurves(List<CurveWrapper> updatedCurves) + { + m_CurvesProxy.UpdateCurves(updatedCurves); + } + + public override void RebuildCurves() + { + m_CurvesProxy.RebuildCurves(); + } + + protected override void ConfigureCurveWrapper(CurveWrapper wrapper) + { + m_CurvesProxy.ConfigureCurveWrapper(wrapper); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurveDataSource.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurveDataSource.cs.meta new file mode 100644 index 0000000..6416ecf --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurveDataSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 87a1ae9719ec25d44a4dbec20ec0f892 +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/Animation/CurvesProxy.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurvesProxy.cs new file mode 100644 index 0000000..ce17112 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurvesProxy.cs @@ -0,0 +1,302 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; +using UnityObject = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class CurvesProxy : ICurvesOwner + { + public AnimationClip curves + { + get { return proxyCurves != null ? proxyCurves : m_OriginalOwner.curves; } + } + + public bool hasCurves + { + get { return m_IsAnimatable || m_OriginalOwner.hasCurves; } + } + + public double duration + { + get { return m_OriginalOwner.duration; } + } + + public string defaultCurvesName + { + get { return m_OriginalOwner.defaultCurvesName; } + } + + public UnityObject asset + { + get { return m_OriginalOwner.asset; } + } + + public UnityObject assetOwner + { + get { return m_OriginalOwner.assetOwner; } + } + + public TrackAsset targetTrack + { + get { return m_OriginalOwner.targetTrack; } + } + + readonly ICurvesOwner m_OriginalOwner; + readonly bool m_IsAnimatable; + readonly Dictionary<EditorCurveBinding, SerializedProperty> m_PropertiesMap = new Dictionary<EditorCurveBinding, SerializedProperty>(); + int m_ProxyIsRebuilding = 0; + + AnimationClip m_ProxyCurves; + AnimationClip proxyCurves + { + get + { + if (!m_IsAnimatable) return null; + + if (m_ProxyCurves == null) + RebuildProxyCurves(); + + return m_ProxyCurves; + } + } + + List<SerializedProperty> m_AllAnimatableParameters; + List<SerializedProperty> allAnimatableParameters + { + get + { + var so = AnimatedParameterUtility.GetSerializedPlayableAsset(m_OriginalOwner.asset); + if (so == null) + return null; + + so.UpdateIfRequiredOrScript(); + + if (m_AllAnimatableParameters == null) + m_AllAnimatableParameters = m_OriginalOwner.GetAllAnimatableParameters().ToList(); + + return m_AllAnimatableParameters; + } + } + + public CurvesProxy([NotNull] ICurvesOwner originalOwner) + { + m_OriginalOwner = originalOwner; + m_IsAnimatable = originalOwner.HasAnyAnimatableParameters(); + + RebuildProxyCurves(); + } + + public void CreateCurves(string curvesClipName) + { + m_OriginalOwner.CreateCurves(curvesClipName); + } + + public void ConfigureCurveWrapper(CurveWrapper wrapper) + { + var color = CurveUtility.GetPropertyColor(wrapper.binding.propertyName); + wrapper.color = color; + + float h, s, v; + Color.RGBToHSV(color, out h, out s, out v); + wrapper.wrapColorMultiplier = Color.HSVToRGB(h, s * 0.33f, v * 1.15f); + + var curve = AnimationUtility.GetEditorCurve(proxyCurves, wrapper.binding); + + wrapper.renderer = new NormalCurveRenderer(curve); + + // Use curve length instead of animation clip length + wrapper.renderer.SetCustomRange(0.0f, curve.keys.Last().time); + } + + public void RebuildCurves() + { + RebuildProxyCurves(); + } + + public void UpdateCurves(List<CurveWrapper> updatedCurves) + { + if (m_ProxyIsRebuilding > 0) + return; + + Undo.RegisterCompleteObjectUndo(m_OriginalOwner.asset, "Edit Clip Curve"); + + if (m_OriginalOwner.curves != null) + Undo.RegisterCompleteObjectUndo(m_OriginalOwner.curves, "Edit Clip Curve"); + + foreach (var curve in updatedCurves) + { + UpdateCurve(curve.binding, curve.curve); + } + + AnimatedParameterUtility.UpdateSerializedPlayableAsset(m_OriginalOwner.asset); + } + + void UpdateCurve(EditorCurveBinding binding, AnimationCurve curve) + { + ApplyConstraints(binding, curve); + + if (curve.length == 0) + { + HandleAllKeysDeleted(binding); + } + else if (curve.length == 1) + { + HandleConstantCurveValueChanged(binding, curve); + } + else + { + HandleCurveUpdated(binding, curve); + } + } + + void ApplyConstraints(EditorCurveBinding binding, AnimationCurve curve) + { + if (curve.length == 0) + return; + + var curveUpdated = false; + + var property = m_PropertiesMap[binding]; + if (property.propertyType == SerializedPropertyType.Boolean) + { + TimelineAnimationUtilities.ConstrainCurveToBooleanValues(curve); + curveUpdated = true; + } + else + { + var range = AnimatedParameterUtility.GetAttributeForProperty<RangeAttribute>(property); + if (range != null) + { + TimelineAnimationUtilities.ConstrainCurveToRange(curve, range.min, range.max); + curveUpdated = true; + } + } + + if (!curveUpdated) + return; + + using (new RebuildGuard(this)) + { + AnimationUtility.SetEditorCurve(m_ProxyCurves, binding, curve); + } + } + + void HandleCurveUpdated(EditorCurveBinding binding, AnimationCurve updatedCurve) + { + if (!m_OriginalOwner.hasCurves) + m_OriginalOwner.CreateCurves(null); + + AnimationUtility.SetEditorCurve(m_OriginalOwner.curves, binding, updatedCurve); + } + + void HandleConstantCurveValueChanged(EditorCurveBinding binding, AnimationCurve updatedCurve) + { + var prop = m_PropertiesMap[binding]; + if (prop == null) + return; + + Undo.RegisterCompleteObjectUndo(prop.serializedObject.targetObject, "Edit Clip Curve"); + prop.serializedObject.UpdateIfRequiredOrScript(); + CurveEditUtility.SetFromKeyValue(prop, updatedCurve.keys[0].value); + prop.serializedObject.ApplyModifiedProperties(); + } + + void HandleAllKeysDeleted(EditorCurveBinding binding) + { + if (m_OriginalOwner.hasCurves) + { + // Remove curve from original asset + AnimationUtility.SetEditorCurve(m_OriginalOwner.curves, binding, null); + m_OriginalOwner.SanitizeCurvesData(); + } + + // Ensure proxy still has constant value + RebuildProxyCurves(); + } + + void RebuildProxyCurves() + { + if (!m_IsAnimatable) + return; + + using (new RebuildGuard(this)) + { + if (m_ProxyCurves == null) + { + m_ProxyCurves = new AnimationClip + { + legacy = true, + name = "Constant Curves", + hideFlags = HideFlags.HideAndDontSave, + frameRate = m_OriginalOwner.targetTrack.timelineAsset == null + ? TimelineAsset.EditorSettings.kDefaultFps + : m_OriginalOwner.targetTrack.timelineAsset.editorSettings.fps + }; + } + else + { + m_ProxyCurves.ClearCurves(); + } + + m_OriginalOwner.SanitizeCurvesData(); + AnimatedParameterUtility.UpdateSerializedPlayableAsset(m_OriginalOwner.asset); + + foreach (var param in allAnimatableParameters) + CreateProxyCurve(param, m_ProxyCurves, m_OriginalOwner.asset, param.propertyPath); + + AnimationClipCurveCache.Instance.GetCurveInfo(m_ProxyCurves).dirty = true; + } + } + + void CreateProxyCurve(SerializedProperty prop, AnimationClip clip, UnityObject owner, string propertyName) + { + var binding = AnimatedParameterUtility.GetCurveBinding(owner, propertyName); + + var originalCurve = m_OriginalOwner.hasCurves + ? AnimationUtility.GetEditorCurve(m_OriginalOwner.curves, binding) + : null; + + if (originalCurve != null) + { + AnimationUtility.SetEditorCurve(clip, binding, originalCurve); + } + else + { + var curve = new AnimationCurve(); + + CurveEditUtility.AddKeyFrameToCurve( + curve, 0.0f, clip.frameRate, CurveEditUtility.GetKeyValue(prop), + prop.propertyType == SerializedPropertyType.Boolean); + + AnimationUtility.SetEditorCurve(clip, binding, curve); + } + + m_PropertiesMap[binding] = prop; + } + + struct RebuildGuard : IDisposable + { + CurvesProxy m_Owner; + AnimationUtility.OnCurveWasModified m_Callback; + + public RebuildGuard(CurvesProxy owner) + { + m_Callback = AnimationUtility.onCurveWasModified; + AnimationUtility.onCurveWasModified = null; + m_Owner = owner; + m_Owner.m_ProxyIsRebuilding++; + } + + public void Dispose() + { + AnimationUtility.onCurveWasModified = m_Callback; + m_Owner.m_ProxyIsRebuilding--; + m_Owner = null; + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurvesProxy.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurvesProxy.cs.meta new file mode 100644 index 0000000..18e3029 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/CurvesProxy.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d72ccd2c66ea846fc842adf682b11526 +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/Animation/TimelineAnimationUtilities.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/TimelineAnimationUtilities.cs new file mode 100644 index 0000000..60cf7cc --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/TimelineAnimationUtilities.cs @@ -0,0 +1,435 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEditor; +using UnityEngineInternal; +using UnityEngine.Timeline; +using UnityEngine.Playables; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class TimelineAnimationUtilities + { + public enum OffsetEditMode + { + None = -1, + Translation = 0, + Rotation = 1 + } + + public static bool ValidateOffsetAvailabitity(PlayableDirector director, Animator animator) + { + if (director == null || animator == null) + return false; + + return true; + } + + public static TimelineClip GetPreviousClip(TimelineClip clip) + { + TimelineClip previousClip = null; + foreach (var c in clip.parentTrack.clips) + { + if (c.start < clip.start && (previousClip == null || c.start >= previousClip.start)) + previousClip = c; + } + return previousClip; + } + + public static TimelineClip GetNextClip(TimelineClip clip) + { + return clip.parentTrack.clips.Where(c => c.start > clip.start).OrderBy(c => c.start).FirstOrDefault(); + } + + public struct RigidTransform + { + public Vector3 position; + public Quaternion rotation; + + public static RigidTransform Compose(Vector3 pos, Quaternion rot) + { + RigidTransform ret; + ret.position = pos; + ret.rotation = rot; + return ret; + } + + public static RigidTransform Mul(RigidTransform a, RigidTransform b) + { + RigidTransform ret; + ret.rotation = a.rotation * b.rotation; + ret.position = a.position + a.rotation * b.position; + return ret; + } + + public static RigidTransform Inverse(RigidTransform a) + { + RigidTransform ret; + ret.rotation = Quaternion.Inverse(a.rotation); + ret.position = ret.rotation * (-a.position); + return ret; + } + + public static RigidTransform identity + { + get { return Compose(Vector3.zero, Quaternion.identity); } + } + } + + + private static Matrix4x4 GetTrackMatrix(Transform transform, AnimationTrack track) + { + Matrix4x4 trackMatrix = Matrix4x4.TRS(track.position, track.rotation, Vector3.one); + + // in scene off mode, the track offsets are set to the preview position which is stored in the track + if (track.trackOffset == TrackOffset.ApplySceneOffsets) + { + trackMatrix = Matrix4x4.TRS(track.sceneOffsetPosition, Quaternion.Euler(track.sceneOffsetRotation), Vector3.one); + } + + // put the parent transform on to the track matrix + if (transform.parent != null) + { + trackMatrix = transform.parent.localToWorldMatrix * trackMatrix; + } + + return trackMatrix; + } + + // Given a world space position and rotation, updates the clip offsets to match that + public static RigidTransform UpdateClipOffsets(AnimationPlayableAsset asset, AnimationTrack track, Transform transform, Vector3 globalPosition, Quaternion globalRotation) + { + Matrix4x4 worldToLocal = transform.worldToLocalMatrix; + Matrix4x4 clipMatrix = Matrix4x4.TRS(asset.position, asset.rotation, Vector3.one); + Matrix4x4 trackMatrix = GetTrackMatrix(transform, track); + + + // Use the transform to find the proper goal matrix with scale taken into account + var oldPos = transform.position; + var oldRot = transform.rotation; + transform.position = globalPosition; + transform.rotation = globalRotation; + Matrix4x4 goal = transform.localToWorldMatrix; + transform.position = oldPos; + transform.rotation = oldRot; + + // compute the new clip matrix. + Matrix4x4 newClip = trackMatrix.inverse * goal * worldToLocal * trackMatrix * clipMatrix; + return RigidTransform.Compose(newClip.GetColumn(3), MathUtils.QuaternionFromMatrix(newClip)); + } + + public static RigidTransform GetTrackOffsets(AnimationTrack track, Transform transform) + { + Vector3 position = track.position; + Quaternion rotation = track.rotation; + if (transform != null && transform.parent != null) + { + position = transform.parent.TransformPoint(position); + rotation = transform.parent.rotation * rotation; + MathUtils.QuaternionNormalize(ref rotation); + } + + return RigidTransform.Compose(position, rotation); + } + + public static void UpdateTrackOffset(AnimationTrack track, Transform transform, RigidTransform offsets) + { + if (transform != null && transform.parent != null) + { + offsets.position = transform.parent.InverseTransformPoint(offsets.position); + offsets.rotation = Quaternion.Inverse(transform.parent.rotation) * offsets.rotation; + MathUtils.QuaternionNormalize(ref offsets.rotation); + } + + track.position = offsets.position; + track.eulerAngles = AnimationUtility.GetClosestEuler(offsets.rotation, track.eulerAngles, RotationOrder.OrderZXY); + track.UpdateClipOffsets(); + } + + static MatchTargetFields GetMatchFields(TimelineClip clip) + { + var track = clip.parentTrack as AnimationTrack; + if (track == null) + return MatchTargetFieldConstants.None; + + var asset = clip.asset as AnimationPlayableAsset; + var fields = track.matchTargetFields; + if (asset != null && !asset.useTrackMatchFields) + fields = asset.matchTargetFields; + return fields; + } + + static void WriteMatchFields(AnimationPlayableAsset asset, RigidTransform result, MatchTargetFields fields) + { + Vector3 position = asset.position; + + position.x = fields.HasAny(MatchTargetFields.PositionX) ? result.position.x : position.x; + position.y = fields.HasAny(MatchTargetFields.PositionY) ? result.position.y : position.y; + position.z = fields.HasAny(MatchTargetFields.PositionZ) ? result.position.z : position.z; + + asset.position = position; + + // check first to avoid unnecessary conversion errors + if (fields.HasAny(MatchTargetFieldConstants.Rotation)) + { + Vector3 eulers = asset.eulerAngles; + Vector3 resultEulers = result.rotation.eulerAngles; + + eulers.x = fields.HasAny(MatchTargetFields.RotationX) ? resultEulers.x : eulers.x; + eulers.y = fields.HasAny(MatchTargetFields.RotationY) ? resultEulers.y : eulers.y; + eulers.z = fields.HasAny(MatchTargetFields.RotationZ) ? resultEulers.z : eulers.z; + + asset.eulerAngles = AnimationUtility.GetClosestEuler(Quaternion.Euler(eulers), asset.eulerAngles, RotationOrder.OrderZXY); + } + } + + public static void MatchPrevious(TimelineClip currentClip, Transform matchPoint, PlayableDirector director) + { + const double timeEpsilon = 0.00001; + MatchTargetFields matchFields = GetMatchFields(currentClip); + if (matchFields == MatchTargetFieldConstants.None || matchPoint == null) + return; + + double cachedTime = director.time; + + // finds previous clip + TimelineClip previousClip = GetPreviousClip(currentClip); + if (previousClip == null || currentClip == previousClip) + return; + + // make sure the transform is properly updated before modifying the graph + director.Evaluate(); + + var parentTrack = currentClip.parentTrack as AnimationTrack; + + var blendIn = currentClip.blendInDuration; + currentClip.blendInDuration = 0; + var blendOut = previousClip.blendOutDuration; + previousClip.blendOutDuration = 0; + + //evaluate previous without current + parentTrack.RemoveClip(currentClip); + director.RebuildGraph(); + double previousEndTime = currentClip.start > previousClip.end ? previousClip.end : currentClip.start; + director.time = previousEndTime - timeEpsilon; + director.Evaluate(); // add port to evaluate only track + + var targetPosition = matchPoint.position; + var targetRotation = matchPoint.rotation; + + // evaluate current without previous + parentTrack.AddClip(currentClip); + parentTrack.RemoveClip(previousClip); + director.RebuildGraph(); + director.time = currentClip.start + timeEpsilon; + director.Evaluate(); + + ////////////////////////////////////////////////////////////////////// + //compute offsets + + var animationPlayable = currentClip.asset as AnimationPlayableAsset; + var match = UpdateClipOffsets(animationPlayable, parentTrack, matchPoint, targetPosition, targetRotation); + WriteMatchFields(animationPlayable, match, matchFields); + + ////////////////////////////////////////////////////////////////////// + + currentClip.blendInDuration = blendIn; + previousClip.blendOutDuration = blendOut; + + parentTrack.AddClip(previousClip); + director.RebuildGraph(); + director.time = cachedTime; + director.Evaluate(); + } + + public static void MatchNext(TimelineClip currentClip, Transform matchPoint, PlayableDirector director) + { + const double timeEpsilon = 0.00001; + MatchTargetFields matchFields = GetMatchFields(currentClip); + if (matchFields == MatchTargetFieldConstants.None || matchPoint == null) + return; + + double cachedTime = director.time; + + // finds next clip + TimelineClip nextClip = GetNextClip(currentClip); + if (nextClip == null || currentClip == nextClip) + return; + + // make sure the transform is properly updated before modifying the graph + director.Evaluate(); + + var parentTrack = currentClip.parentTrack as AnimationTrack; + + var blendOut = currentClip.blendOutDuration; + var blendIn = nextClip.blendInDuration; + currentClip.blendOutDuration = 0; + nextClip.blendInDuration = 0; + + //evaluate previous without current + parentTrack.RemoveClip(currentClip); + director.RebuildGraph(); + director.time = nextClip.start + timeEpsilon; + director.Evaluate(); // add port to evaluate only track + + var targetPosition = matchPoint.position; + var targetRotation = matchPoint.rotation; + + // evaluate current without next + parentTrack.AddClip(currentClip); + parentTrack.RemoveClip(nextClip); + director.RebuildGraph(); + director.time = Math.Min(nextClip.start, currentClip.end - timeEpsilon); + director.Evaluate(); + + ////////////////////////////////////////////////////////////////////// + //compute offsets + + var animationPlayable = currentClip.asset as AnimationPlayableAsset; + var match = UpdateClipOffsets(animationPlayable, parentTrack, matchPoint, targetPosition, targetRotation); + WriteMatchFields(animationPlayable, match, matchFields); + + ////////////////////////////////////////////////////////////////////// + + currentClip.blendOutDuration = blendOut; + nextClip.blendInDuration = blendIn; + + parentTrack.AddClip(nextClip); + director.RebuildGraph(); + director.time = cachedTime; + director.Evaluate(); + } + + public static TimelineWindowTimeControl CreateTimeController(WindowState state, TimelineClip clip) + { + var animationWindow = EditorWindow.GetWindow<AnimationWindow>(); + var timeController = ScriptableObject.CreateInstance<TimelineWindowTimeControl>(); + timeController.Init(animationWindow.state, clip); + return timeController; + } + + public static TimelineWindowTimeControl CreateTimeController(WindowState state, TimelineWindowTimeControl.ClipData clipData) + { + var animationWindow = EditorWindow.GetWindow<AnimationWindow>(); + var timeController = ScriptableObject.CreateInstance<TimelineWindowTimeControl>(); + timeController.Init(animationWindow.state, clipData); + return timeController; + } + + public static void EditAnimationClipWithTimeController(AnimationClip animationClip, TimelineWindowTimeControl timeController, Object sourceObject) + { + var animationWindow = EditorWindow.GetWindow<AnimationWindow>(); + animationWindow.EditSequencerClip(animationClip, sourceObject, timeController); + } + + public static void UnlinkAnimationWindowFromTracks(IEnumerable<TrackAsset> tracks) + { + var clips = new List<AnimationClip>(); + foreach (var track in tracks) + { + var animationTrack = track as AnimationTrack; + if (animationTrack != null && animationTrack.infiniteClip != null) + clips.Add(animationTrack.infiniteClip); + + GetAnimationClips(track.GetClips(), clips); + } + UnlinkAnimationWindowFromAnimationClips(clips); + } + + public static void UnlinkAnimationWindowFromClips(IEnumerable<TimelineClip> timelineClips) + { + var clips = new List<AnimationClip>(); + GetAnimationClips(timelineClips, clips); + UnlinkAnimationWindowFromAnimationClips(clips); + } + + public static void UnlinkAnimationWindowFromAnimationClips(ICollection<AnimationClip> clips) + { + if (clips.Count == 0) + return; + + UnityEngine.Object[] windows = Resources.FindObjectsOfTypeAll(typeof(AnimationWindow)); + foreach (var animWindow in windows.OfType<AnimationWindow>()) + { + if (animWindow != null && animWindow.state != null && animWindow.state.linkedWithSequencer && clips.Contains(animWindow.state.activeAnimationClip)) + animWindow.UnlinkSequencer(); + } + } + + public static void UnlinkAnimationWindow() + { + UnityEngine.Object[] windows = Resources.FindObjectsOfTypeAll(typeof(AnimationWindow)); + foreach (var animWindow in windows.OfType<AnimationWindow>()) + { + if (animWindow != null && animWindow.state != null && animWindow.state.linkedWithSequencer) + animWindow.UnlinkSequencer(); + } + } + + private static void GetAnimationClips(IEnumerable<TimelineClip> timelineClips, List<AnimationClip> clips) + { + foreach (var timelineClip in timelineClips) + { + if (timelineClip.curves != null) + clips.Add(timelineClip.curves); + AnimationPlayableAsset apa = timelineClip.asset as AnimationPlayableAsset; + if (apa != null && apa.clip != null) + clips.Add(apa.clip); + } + } + + public static int GetAnimationWindowCurrentFrame() + { + var animationWindow = EditorWindow.GetWindow<AnimationWindow>(); + if (animationWindow) + return animationWindow.state.currentFrame; + return -1; + } + + public static void SetAnimationWindowCurrentFrame(int frame) + { + var animationWindow = EditorWindow.GetWindow<AnimationWindow>(); + if (animationWindow) + animationWindow.state.currentFrame = frame; + } + + public static void ConstrainCurveToBooleanValues(AnimationCurve curve) + { + // Clamp the values first + var keys = curve.keys; + for (var i = 0; i < keys.Length; i++) + { + var key = keys[i]; + key.value = key.value < 0.5f ? 0.0f : 1.0f; + keys[i] = key; + } + curve.keys = keys; + + // Update the tangents once all the values are clamped + for (var i = 0; i < curve.length; i++) + { + AnimationUtility.SetKeyLeftTangentMode(curve, i, AnimationUtility.TangentMode.Constant); + AnimationUtility.SetKeyRightTangentMode(curve, i, AnimationUtility.TangentMode.Constant); + } + } + + public static void ConstrainCurveToRange(AnimationCurve curve, float minValue, float maxValue) + { + var keys = curve.keys; + for (var i = 0; i < keys.Length; i++) + { + var key = keys[i]; + key.value = Mathf.Clamp(key.value, minValue, maxValue); + keys[i] = key; + } + curve.keys = keys; + } + + public static bool IsAnimationClip(TimelineClip clip) + { + return clip != null && (clip.asset as AnimationPlayableAsset) != null; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/TimelineAnimationUtilities.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/TimelineAnimationUtilities.cs.meta new file mode 100644 index 0000000..78ae589 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Animation/TimelineAnimationUtilities.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9685354eb873b8d4699078b307b0f260 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: |