Inital commit

1 files changed, 358 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Utilities/AnimatedParameterUtility.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Utilities/AnimatedParameterUtility.cs
new file mode 100644
index 0000000..53542e3
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Utilities/AnimatedParameterUtility.cs
@@ -0,0 +1,358 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+using UnityObject = UnityEngine.Object;
+
+namespace UnityEditor.Timeline
+{
+    static class AnimatedParameterUtility
+    {
+        static readonly Type k_DefaultAnimationType = typeof(TimelineAsset);
+        static SerializedObject s_CachedObject;
+
+        public static ICurvesOwner ToCurvesOwner(IPlayableAsset playableAsset, TimelineAsset timeline)
+        {
+            if (playableAsset == null)
+                return null;
+
+            var curvesOwner = playableAsset as ICurvesOwner;
+            if (curvesOwner == null)
+            {
+                // If the asset is not directly an ICurvesOwner, it might be the asset for a TimelineClip
+                curvesOwner = TimelineRecording.FindClipWithAsset(timeline, playableAsset);
+            }
+
+            return curvesOwner;
+        }
+
+        public static bool TryGetSerializedPlayableAsset(UnityObject asset, out SerializedObject serializedObject)
+        {
+            serializedObject = null;
+            if (asset == null || Attribute.IsDefined(asset.GetType(), typeof(NotKeyableAttribute)) || !HasScriptPlayable(asset))
+                return false;
+
+            serializedObject = GetSerializedPlayableAsset(asset);
+            return serializedObject != null;
+        }
+
+        public static SerializedObject GetSerializedPlayableAsset(UnityObject asset)
+        {
+            if (!(asset is IPlayableAsset))
+                return null;
+
+            var scriptObject = asset as ScriptableObject;
+            if (scriptObject == null)
+                return null;
+
+            if (s_CachedObject == null || s_CachedObject.targetObject != asset)
+            {
+                s_CachedObject = new SerializedObject(scriptObject);
+            }
+
+            return s_CachedObject;
+        }
+
+        public static void UpdateSerializedPlayableAsset(UnityObject asset)
+        {
+            var so = GetSerializedPlayableAsset(asset);
+            if (so != null)
+                so.UpdateIfRequiredOrScript();
+        }
+
+        public static bool HasScriptPlayable(UnityObject asset)
+        {
+            if (asset == null)
+                return false;
+
+            var scriptPlayable = asset as IPlayableBehaviour;
+            return scriptPlayable != null || GetScriptPlayableFields(asset as IPlayableAsset).Any();
+        }
+
+        public static FieldInfo[] GetScriptPlayableFields(IPlayableAsset asset)
+        {
+            if (asset == null)
+                return new FieldInfo[0];
+
+            FieldInfo[] scriptPlayableFields;
+            if (!AnimatedParameterCache.TryGetScriptPlayableFields(asset.GetType(), out scriptPlayableFields))
+            {
+                scriptPlayableFields = GetScriptPlayableFields_Internal(asset);
+                AnimatedParameterCache.SetScriptPlayableFields(asset.GetType(), scriptPlayableFields);
+            }
+
+            return scriptPlayableFields;
+        }
+
+        static FieldInfo[] GetScriptPlayableFields_Internal(IPlayableAsset asset)
+        {
+            return asset.GetType()
+                .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                .Where(
+                    f => typeof(IPlayableBehaviour).IsAssignableFrom(f.FieldType) &&                                        // The field is an IPlayableBehaviour
+                    (f.IsPublic || f.GetCustomAttributes(typeof(SerializeField), false).Any()) &&       // The field is either public or marked with [SerializeField]
+                    !f.GetCustomAttributes(typeof(NotKeyableAttribute), false).Any() &&                 // The field is not marked with [NotKeyable]
+                    !f.GetCustomAttributes(typeof(HideInInspector), false).Any() &&                     // The field is not marked with [HideInInspector]
+                    !f.FieldType.GetCustomAttributes(typeof(NotKeyableAttribute), false).Any())         // The field is not of a type marked with [NotKeyable]
+                .ToArray();
+        }
+
+        public static bool HasAnyAnimatableParameters(UnityObject asset)
+        {
+            return GetAllAnimatableParameters(asset).Any();
+        }
+
+        public static IEnumerable<SerializedProperty> GetAllAnimatableParameters(UnityObject asset)
+        {
+            SerializedObject serializedObject;
+            if (!TryGetSerializedPlayableAsset(asset, out serializedObject))
+                yield break;
+
+            var prop = serializedObject.GetIterator();
+
+            // We need to keep this variable because prop starts invalid
+            var outOfBounds = false;
+            while (!outOfBounds && prop.NextVisible(true))
+            {
+                foreach (var property in SelectAnimatableProperty(prop))
+                    yield return property;
+
+                // We can become out of bounds by calling SelectAnimatableProperty, if the last iterated property is a color.
+                outOfBounds = !prop.isValid;
+            }
+        }
+
+        static IEnumerable<SerializedProperty> SelectAnimatableProperty(SerializedProperty prop)
+        {
+            // We're only interested by animatable leaf parameters
+            if (!prop.hasChildren && IsParameterAnimatable(prop))
+                yield return prop.Copy();
+
+            // Color type is not considered "visible" when iterating
+            if (prop.propertyType == SerializedPropertyType.Color)
+            {
+                var end = prop.GetEndProperty();
+
+                // For some reasons, if the last 2+ serialized properties are of type Color, prop becomes invalid and
+                // Next() throws an exception. This is not the case when only the last serialized property is a Color.
+                while (!SerializedProperty.EqualContents(prop, end) && prop.isValid && prop.Next(true))
+                {
+                    foreach (var property in SelectAnimatableProperty(prop))
+                        yield return property;
+                }
+            }
+        }
+
+        public static bool IsParameterAnimatable(UnityObject asset, string parameterName)
+        {
+            SerializedObject serializedObject;
+            if (!TryGetSerializedPlayableAsset(asset, out serializedObject))
+                return false;
+
+            var prop = serializedObject.FindProperty(parameterName);
+            return IsParameterAnimatable(prop);
+        }
+
+        public static bool IsParameterAnimatable(SerializedProperty property)
+        {
+            if (property == null)
+                return false;
+
+            bool isAnimatable;
+            if (!AnimatedParameterCache.TryGetIsPropertyAnimatable(property, out isAnimatable))
+            {
+                isAnimatable = IsParameterAnimatable_Internal(property);
+                AnimatedParameterCache.SetIsPropertyAnimatable(property, isAnimatable);
+            }
+
+            return isAnimatable;
+        }
+
+        static bool IsParameterAnimatable_Internal(SerializedProperty property)
+        {
+            if (property == null)
+                return false;
+
+            var asset = property.serializedObject.targetObject;
+
+            // Currently not supported
+            if (asset is AnimationTrack)
+                return false;
+
+            if (IsParameterKeyable(property))
+                return asset is IPlayableBehaviour || IsParameterAtPathAnimatable(asset, property.propertyPath);
+
+            return false;
+        }
+
+        static bool IsParameterKeyable(SerializedProperty property)
+        {
+            return IsTypeAnimatable(property.propertyType) && IsKeyableInHierarchy(property);
+        }
+
+        static bool IsKeyableInHierarchy(SerializedProperty property)
+        {
+            const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
+            var pathSegments = property.propertyPath.Split('.');
+            var type = property.serializedObject.targetObject.GetType();
+            foreach (var segment in pathSegments)
+            {
+                if (type.GetCustomAttributes(typeof(NotKeyableAttribute), false).Any())
+                {
+                    return false;
+                }
+
+                if (type.IsArray)
+                {
+                    if (segment != "Array")
+                        type = type.GetElementType();
+                    continue;
+                }
+
+                var fieldInfo = type.GetField(segment, bindingFlags);
+
+                if (fieldInfo == null ||
+                    fieldInfo.GetCustomAttributes(typeof(NotKeyableAttribute), false).Any() ||
+                    fieldInfo.GetCustomAttributes(typeof(HideInInspector), false).Any())
+                {
+                    return false;
+                }
+
+                type = fieldInfo.FieldType;
+            }
+
+            return true;
+        }
+
+        static bool IsParameterAtPathAnimatable(UnityObject asset, string path)
+        {
+            if (asset == null)
+                return false;
+
+            return GetScriptPlayableFields(asset as IPlayableAsset)
+                .Any(
+                f => path.StartsWith(f.Name, StringComparison.Ordinal) &&
+                path.Length > f.Name.Length &&
+                path[f.Name.Length] == '.');
+        }
+
+        public static bool IsTypeAnimatable(SerializedPropertyType type)
+        {
+            // Note: Integer is not currently supported by the animated property system
+            switch (type)
+            {
+                case SerializedPropertyType.Boolean:
+                case SerializedPropertyType.Float:
+                case SerializedPropertyType.Vector2:
+                case SerializedPropertyType.Vector3:
+                case SerializedPropertyType.Color:
+                case SerializedPropertyType.Quaternion:
+                case SerializedPropertyType.Vector4:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        public static bool IsParameterAnimated(UnityObject asset, AnimationClip animationData, string parameterName)
+        {
+            if (asset == null || animationData == null)
+                return false;
+
+            var binding = GetCurveBinding(asset, parameterName);
+            var bindings = AnimationClipCurveCache.Instance.GetCurveInfo(animationData).bindings;
+            return bindings.Any(x => BindingMatchesParameterName(x, binding.propertyName));
+        }
+
+        // Retrieve an animated parameter curve. parameter name is required to include the appropriate field for vectors
+        // e.g.: position
+        public static AnimationCurve GetAnimatedParameter(UnityObject asset, AnimationClip animationData, string parameterName)
+        {
+            if (!(asset is ScriptableObject) || animationData == null)
+                return null;
+
+            var binding = GetCurveBinding(asset, parameterName);
+            return AnimationUtility.GetEditorCurve(animationData, binding);
+        }
+
+        // get an animatable curve binding for this parameter
+        public static EditorCurveBinding GetCurveBinding(UnityObject asset, string parameterName)
+        {
+            var animationName = GetAnimatedParameterBindingName(asset, parameterName);
+            return EditorCurveBinding.FloatCurve(string.Empty, GetValidAnimationType(asset), animationName);
+        }
+
+        public static string GetAnimatedParameterBindingName(UnityObject asset, string parameterName)
+        {
+            if (asset == null)
+                return parameterName;
+
+            string bindingName;
+            if (!AnimatedParameterCache.TryGetBindingName(asset.GetType(), parameterName, out bindingName))
+            {
+                bindingName = GetAnimatedParameterBindingName_Internal(asset, parameterName);
+                AnimatedParameterCache.SetBindingName(asset.GetType(), parameterName, bindingName);
+            }
+
+            return bindingName;
+        }
+
+        static string GetAnimatedParameterBindingName_Internal(UnityObject asset, string parameterName)
+        {
+            if (asset is IPlayableBehaviour)
+                return parameterName;
+
+            // strip the IScript playable field name
+            var fields = GetScriptPlayableFields(asset as IPlayableAsset);
+            foreach (var f in fields)
+            {
+                if (parameterName.StartsWith(f.Name, StringComparison.Ordinal))
+                {
+                    if (parameterName.Length > f.Name.Length && parameterName[f.Name.Length] == '.')
+                        return parameterName.Substring(f.Name.Length + 1);
+                }
+            }
+
+            return parameterName;
+        }
+
+        public static bool BindingMatchesParameterName(EditorCurveBinding binding, string parameterName)
+        {
+            if (binding.propertyName == parameterName)
+                return true;
+
+            var indexOfDot = binding.propertyName.IndexOf('.');
+            return indexOfDot > 0 && parameterName.Length == indexOfDot &&
+                binding.propertyName.StartsWith(parameterName, StringComparison.Ordinal);
+        }
+
+        // the animated type must be a non-abstract instantiable object.
+        public static Type GetValidAnimationType(UnityObject asset)
+        {
+            return asset != null ? asset.GetType() : k_DefaultAnimationType;
+        }
+
+        public static FieldInfo GetFieldInfoForProperty(SerializedProperty property)
+        {
+            FieldInfo fieldInfo;
+
+            if (!AnimatedParameterCache.TryGetFieldInfoForProperty(property, out fieldInfo))
+            {
+                Type _;
+                fieldInfo = ScriptAttributeUtility.GetFieldInfoFromProperty(property, out _);
+                AnimatedParameterCache.SetFieldInfoForProperty(property, fieldInfo);
+            }
+
+            return fieldInfo;
+        }
+
+        public static T GetAttributeForProperty<T>(SerializedProperty property) where T : Attribute
+        {
+            var fieldInfo = GetFieldInfoForProperty(property);
+            return fieldInfo.GetCustomAttributes(typeof(T), false).FirstOrDefault() as T;
+        }
+    }
+}