public static string GetDescription(this CurveBindingGroup group, float t) { string text = string.Empty; if (group.isFloatCurve) { if (group.count > 1) { text = text + "(" + group.curveBindingPairs[0].curve.Evaluate(t).ToString("0.##"); for (int i = 1; i < group.curveBindingPairs.Length; i++) { text = text + "," + group.curveBindingPairs[i].curve.Evaluate(t).ToString("0.##"); } text += ")"; } else { text = group.curveBindingPairs[0].curve.Evaluate(t).ToString("0.##"); } } else if (group.isObjectCurve) { Object @object = null; if (group.curveBindingPairs[0].objectCurve.Length > 0) { @object = CurveEditUtility.Evaluate(group.curveBindingPairs[0].objectCurve, t); } text = ((!(@object == null)) ? @object.get_name() : "None"); } return(text); }
private static void RemoveFloatKey(AnimationClip clip, EditorCurveBinding sourceBind, SerializedProperty prop, double time) { List <AnimationCurve> list = new List <AnimationCurve>(); List <EditorCurveBinding> list2 = new List <EditorCurveBinding>(); AnimationClipCurveInfo curveInfo = AnimationClipCurveCache.Instance.GetCurveInfo(clip); for (int i = 0; i < curveInfo.bindings.Length; i++) { EditorCurveBinding item = curveInfo.bindings[i]; if (item.get_type() == sourceBind.get_type()) { SerializedProperty serializedProperty = null; AnimationCurve animationCurve = curveInfo.curves[i]; if (prop.get_propertyPath().Equals(item.propertyName)) { serializedProperty = prop; } else if (item.propertyName.Contains(prop.get_propertyPath())) { serializedProperty = prop.get_serializedObject().FindProperty(item.propertyName); } if (serializedProperty != null) { CurveEditUtility.RemoveKeyFrameFromCurve(animationCurve, (float)time, clip.get_frameRate()); list.Add(animationCurve); list2.Add(item); } } } CurveEditUtility.UpdateEditorCurves(clip, list2, list); }
public static void AddKeyFrameToCurve(AnimationCurve curve, float time, float framerate, float value, bool stepped) { Keyframe keyframe = default(Keyframe); bool flag = true; int num = CurveEditUtility.GetKeyframeAtTime(curve, time, framerate); if (num != -1) { flag = false; keyframe = curve.get_Item(num); curve.RemoveKey(num); } keyframe.set_value(value); keyframe.set_time(CurveEditUtility.GetKeyTime(time, framerate)); num = curve.AddKey(keyframe); if (stepped) { AnimationUtility.SetKeyBroken(curve, num, stepped); AnimationUtility.SetKeyLeftTangentMode(curve, num, 3); AnimationUtility.SetKeyRightTangentMode(curve, num, 3); keyframe.set_outTangent(float.PositiveInfinity); keyframe.set_inTangent(float.PositiveInfinity); } else if (flag) { AnimationUtility.SetKeyLeftTangentMode(curve, num, 4); AnimationUtility.SetKeyRightTangentMode(curve, num, 4); } if (num != -1 && !stepped) { AnimationUtility.UpdateTangentsFromModeSurrounding(curve, num); AnimationUtility.SetKeyBroken(curve, num, false); } }
public static bool AddAnimatedParameterValueAt(this TimelineClip clip, string parameterName, float value, float time) { if (!IsParameterAnimatable(clip, parameterName)) { return(false); } // strip the prefix for embedded parameters CreateCurvesIfRequired(clip); EditorCurveBinding binding = GetCurveBinding(clip, parameterName); var curve = AnimationUtility.GetEditorCurve(clip.curves, binding) ?? new AnimationCurve(); var serializedObject = GetSerializedObject(clip); var property = serializedObject.FindProperty(parameterName); bool isStepped = property.propertyType == SerializedPropertyType.Boolean || property.propertyType == SerializedPropertyType.Integer || property.propertyType == SerializedPropertyType.Enum; CurveEditUtility.AddKeyFrameToCurve(curve, time, clip.curves.frameRate, value, isStepped); AnimationUtility.SetEditorCurve(clip.curves, binding, curve); return(true); }
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); }
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; }
internal static void UpdateClipIntersection(TimelineClip blendOutClip, TimelineClip blendInClip) { if (!blendOutClip.SupportsBlending() || !blendInClip.SupportsBlending()) { return; } if (blendInClip.end < blendOutClip.end) { return; } double duration = Math.Max(0, blendOutClip.start + blendOutClip.duration - blendInClip.start); duration = duration <= kMinOverlapTime ? 0 : duration; blendOutClip.blendOutDuration = duration; blendInClip.blendInDuration = duration; var blendInMode = blendInClip.blendInCurveMode; var blendOutMode = blendOutClip.blendOutCurveMode; if (blendInMode == TimelineClip.BlendCurveMode.Manual && blendOutMode == TimelineClip.BlendCurveMode.Auto) { blendOutClip.mixOutCurve = CurveEditUtility.CreateMatchingCurve(blendInClip.mixInCurve); } else if (blendInMode == TimelineClip.BlendCurveMode.Auto && blendOutMode == TimelineClip.BlendCurveMode.Manual) { blendInClip.mixInCurve = CurveEditUtility.CreateMatchingCurve(blendOutClip.mixOutCurve); } else if (blendInMode == TimelineClip.BlendCurveMode.Auto && blendOutMode == TimelineClip.BlendCurveMode.Auto) { blendInClip.mixInCurve = null; // resets to default curves blendOutClip.mixOutCurve = null; } }
public static bool AddAnimatedParameterValueAt(this ICurvesOwner curvesOwner, string parameterName, float value, float time) { if (!curvesOwner.IsParameterAnimatable(parameterName)) { return(false); } if (curvesOwner.curves == null) { curvesOwner.CreateCurves(curvesOwner.GetUniqueRecordedClipName()); } var binding = curvesOwner.GetCurveBinding(parameterName); var curve = AnimationUtility.GetEditorCurve(curvesOwner.curves, binding) ?? new AnimationCurve(); var serializedObject = AnimatedParameterUtility.GetSerializedPlayableAsset(curvesOwner.asset); var property = serializedObject.FindProperty(parameterName); bool isStepped = property.propertyType == SerializedPropertyType.Boolean || property.propertyType == SerializedPropertyType.Integer || property.propertyType == SerializedPropertyType.Enum; TimelineUndo.PushUndo(curvesOwner.curves, "Set Key"); CurveEditUtility.AddKeyFrameToCurve(curve, time, curvesOwner.curves.frameRate, value, isStepped); AnimationUtility.SetEditorCurve(curvesOwner.curves, binding, curve); return(true); }
private static void RemoveRotationKey(AnimationClip clip, EditorCurveBinding sourceBind, SerializedProperty prop, double time) { if (prop.get_propertyType() == 17) { List <AnimationCurve> list = new List <AnimationCurve>(); List <EditorCurveBinding> list2 = new List <EditorCurveBinding>(); AnimationClipCurveInfo curveInfo = AnimationClipCurveCache.Instance.GetCurveInfo(clip); for (int i = 0; i < curveInfo.bindings.Length; i++) { if (sourceBind.get_type() == curveInfo.bindings[i].get_type()) { if (curveInfo.bindings[i].propertyName.Contains("localEuler")) { list2.Add(curveInfo.bindings[i]); list.Add(curveInfo.curves[i]); } } } foreach (AnimationCurve current in list) { CurveEditUtility.RemoveKeyFrameFromCurve(current, (float)time, clip.get_frameRate()); } CurveEditUtility.UpdateEditorCurves(clip, list2, list); } }
internal static void UpdateClipIntersection(TimelineClip blendOutClip, TimelineClip blendInClip) { if (blendOutClip.SupportsBlending() && blendInClip.SupportsBlending()) { double num = Math.Max(0.0, blendOutClip.start + blendOutClip.duration - blendInClip.start); num = ((num > TrackExtensions.kMinOverlapTime) ? num : 0.0); blendOutClip.blendOutDuration = num; blendInClip.blendInDuration = num; TimelineClip.BlendCurveMode blendInCurveMode = blendInClip.blendInCurveMode; TimelineClip.BlendCurveMode blendOutCurveMode = blendOutClip.blendOutCurveMode; if (blendInCurveMode == TimelineClip.BlendCurveMode.Manual && blendOutCurveMode == TimelineClip.BlendCurveMode.Auto) { blendOutClip.mixOutCurve = CurveEditUtility.CreateMatchingCurve(blendInClip.mixInCurve); } else if (blendInCurveMode == TimelineClip.BlendCurveMode.Auto && blendOutCurveMode == TimelineClip.BlendCurveMode.Manual) { blendInClip.mixInCurve = CurveEditUtility.CreateMatchingCurve(blendOutClip.mixOutCurve); } else if (blendInCurveMode == TimelineClip.BlendCurveMode.Auto && blendOutCurveMode == TimelineClip.BlendCurveMode.Auto) { blendInClip.mixInCurve = null; blendOutClip.mixOutCurve = null; } } }
public static void KeyProperties(GameObject go, WindowState state, IList <EditorCurveBinding> bindings) { var allKeyedProperties = new List <PropertyModification>(); var rotationPaths = new HashSet <string>(); for (var i = 0; i < bindings.Count; ++i) { // Skip the euler and key quaternion+hint if (CurveEditUtility.IsRotationKey(bindings[i])) { rotationPaths.Add(bindings[i].path); continue; } AnimationUtility.GetFloatValue(go, bindings[i], out var val); var compo = GetTargetFromEditorBinding(go, bindings[i]); allKeyedProperties.Add(new PropertyModification { target = compo, value = val.ToString(EditorGUI.kFloatFieldFormatString), propertyPath = bindings[i].propertyName }); } foreach (var path in rotationPaths) { foreach (var binding in GetRotationBindings(path)) { var compo = GetTargetFromEditorBinding(go, binding); var readBinding = binding; switch (binding.propertyName) { case kLocalEulerHint + ".x": readBinding = EditorCurveBinding.FloatCurve(path, typeof(Transform), kLocalRotation + ".x"); break; case kLocalEulerHint + ".y": readBinding = EditorCurveBinding.FloatCurve(path, typeof(Transform), kLocalRotation + ".y"); break; case kLocalEulerHint + ".z": readBinding = EditorCurveBinding.FloatCurve(path, typeof(Transform), kLocalRotation + ".z"); break; } AnimationUtility.GetFloatValue(go, readBinding, out var val); allKeyedProperties.Add(new PropertyModification { target = compo, value = val.ToString(EditorGUI.kFloatFieldFormatString), propertyPath = binding.propertyName }); } } AddKey(allKeyedProperties, state); state.Refresh(); }
void SetProxyCurve(SerializedProperty prop, EditorCurveBinding binding) { var curve = new AnimationCurve(); CurveEditUtility.AddKeyFrameToCurve( curve, 0.0f, m_ProxyCurves.frameRate, CurveEditUtility.GetKeyValue(prop), prop.propertyType == SerializedPropertyType.Boolean); AnimationUtility.SetEditorCurve(m_ProxyCurves, binding, curve); }
private static void UpdateEditorCurves(AnimationClip clip, List <EditorCurveBinding> bindings, List <AnimationCurve> curves) { if (curves.Count != 0) { for (int i = 0; i < curves.Count; i++) { CurveEditUtility.UpdateEditorCurve(clip, bindings[i], curves[i]); } EditorUtility.SetDirty(clip); } }
private static void AddRotationKey(AnimationClip clip, EditorCurveBinding sourceBind, SerializedProperty prop, double time) { if (prop.get_propertyType() == 17) { List <AnimationCurve> list = new List <AnimationCurve>(); List <EditorCurveBinding> list2 = new List <EditorCurveBinding>(); AnimationClipCurveInfo curveInfo = AnimationClipCurveCache.Instance.GetCurveInfo(clip); for (int i = 0; i < curveInfo.bindings.Length; i++) { if (sourceBind.get_type() == curveInfo.bindings[i].get_type()) { if (curveInfo.bindings[i].propertyName.Contains("localEuler")) { list2.Add(curveInfo.bindings[i]); list.Add(curveInfo.curves[i]); } } } Vector3 localEulerAngles = ((Transform)prop.get_serializedObject().get_targetObject()).get_localEulerAngles(); if (list2.Count == 0) { string propertyGroupName = AnimationWindowUtility.GetPropertyGroupName(sourceBind.propertyName); list2.Add(EditorCurveBinding.FloatCurve(sourceBind.path, sourceBind.get_type(), propertyGroupName + ".x")); list2.Add(EditorCurveBinding.FloatCurve(sourceBind.path, sourceBind.get_type(), propertyGroupName + ".y")); list2.Add(EditorCurveBinding.FloatCurve(sourceBind.path, sourceBind.get_type(), propertyGroupName + ".z")); AnimationCurve animationCurve = new AnimationCurve(); AnimationCurve animationCurve2 = new AnimationCurve(); AnimationCurve animationCurve3 = new AnimationCurve(); CurveEditUtility.AddKeyFrameToCurve(animationCurve, (float)time, clip.get_frameRate(), localEulerAngles.x, false); CurveEditUtility.AddKeyFrameToCurve(animationCurve2, (float)time, clip.get_frameRate(), localEulerAngles.y, false); CurveEditUtility.AddKeyFrameToCurve(animationCurve3, (float)time, clip.get_frameRate(), localEulerAngles.z, false); list.Add(animationCurve); list.Add(animationCurve2); list.Add(animationCurve3); } for (int j = 0; j < list2.Count; j++) { char c = list2[j].propertyName.Last <char>(); float value = localEulerAngles.x; if (c == 'y') { value = localEulerAngles.y; } else if (c == 'z') { value = localEulerAngles.z; } CurveEditUtility.AddKeyFrameToCurve(list[j], (float)time, clip.get_frameRate(), value, false); } CurveEditUtility.UpdateEditorCurves(clip, list2, list); } }
void MixOutCurveUpdated(AnimationCurve curve, EditorCurveBinding binding) { curve.keys = CurveEditUtility.SanitizeCurveKeys(curve.keys, false); m_MixOutCurveProperty.animationCurveValue = curve; ApplyModifiedProperties(); var editorClip = target as EditorClip; if (editorClip != null) { editorClip.lastHash = editorClip.GetHashCode(); } RefreshCurves(); }
private void MixOutCurveUpdated(AnimationCurve curve, EditorCurveBinding binding) { curve.set_keys(CurveEditUtility.SanitizeCurveKeys(curve.get_keys(), false)); this.m_MixOutCurveProperty.set_animationCurveValue(curve); base.get_serializedObject().ApplyModifiedProperties(); EditorClip editorClip = base.get_target() as EditorClip; if (editorClip != null) { editorClip.lastHash = editorClip.GetHashCode(); } this.RefreshCurves(); }
public static bool HasKey(IEnumerable <PropertyModification> modifications, UnityEngine.Object target, WindowState state) { AnimationClip clip; double keyTime; bool inRange; if (!GetClipAndRelativeTime(target, state, out clip, out keyTime, out inRange)) { return(false); } return(GetKeyTimes(target, modifications, state).Any(t => (CurveEditUtility.KeyCompare((float)state.editSequence.time, (float)t, clip.frameRate) == 0))); }
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(); }
public static void RemoveKey(UnityEngine.Object target, IEnumerable <PropertyModification> modifications, WindowState state) { AnimationClip clip; double keyTime; bool inRange; if (!GetClipAndRelativeTime(target, state, out clip, out keyTime, out inRange) || !inRange) { return; } var refreshPreview = false; TimelineUndo.PushUndo(clip, "Remove Key"); foreach (var mod in modifications) { EditorCurveBinding temp; if (HasBinding(target, mod, clip, out temp)) { if (temp.isPPtrCurve) { CurveEditUtility.RemoveObjectKey(clip, temp, keyTime); if (CurveEditUtility.GetObjectKeyCount(clip, temp) == 0) { refreshPreview = true; } } else { AnimationCurve curve = AnimationUtility.GetEditorCurve(clip, temp); if (curve != null) { CurveEditUtility.RemoveKeyFrameFromCurve(curve, (float)keyTime, clip.frameRate); AnimationUtility.SetEditorCurve(clip, temp, curve); if (curve.length == 0) { AnimationUtility.SetEditorCurve(clip, temp, null); refreshPreview = true; } } } } } if (refreshPreview) { state.ResetPreviewMode(); } }
public static bool AddAnimatedParameter(this TimelineClip clip, string parameterName) { EditorCurveBinding newBinding = new EditorCurveBinding(); SerializedProperty property; if (!InternalAddParameter(clip, parameterName, ref newBinding, out property)) { return(false); } var duration = (float)clip.duration; CurveEditUtility.AddKey(clip.curves, newBinding, property, 0); CurveEditUtility.AddKey(clip.curves, newBinding, property, duration); return(true); }
public static void RemoveKey(AnimationClip clip, EditorCurveBinding sourceBinding, SerializedProperty prop, double time) { if (sourceBinding.get_isPPtrCurve()) { CurveEditUtility.RemoveObjectKey(clip, sourceBinding, time); } else if (CurveEditUtility.IsRotationKey(sourceBinding)) { CurveEditUtility.RemoveRotationKey(clip, sourceBinding, prop, time); } else { CurveEditUtility.RemoveFloatKey(clip, sourceBinding, prop, time); } }
public static bool RemoveKeyFrameFromCurve(AnimationCurve curve, float time, float framerate) { int keyframeAtTime = CurveEditUtility.GetKeyframeAtTime(curve, time, framerate); bool result; if (keyframeAtTime == -1) { result = false; } else { curve.RemoveKey(keyframeAtTime); result = true; } return(result); }
public static void RemoveObjectKey(AnimationClip clip, EditorCurveBinding sourceBinding, double time) { AnimationClipCurveInfo curveInfo = AnimationClipCurveCache.Instance.GetCurveInfo(clip); int num = Array.IndexOf <EditorCurveBinding>(curveInfo.objectBindings, sourceBinding); if (num >= 0) { ObjectReferenceKeyframe[] array = curveInfo.objectCurves[num]; int keyframeAtTime = CurveEditUtility.GetKeyframeAtTime(array, (float)time, clip.get_frameRate()); if (keyframeAtTime >= 0) { ArrayUtility.RemoveAt <ObjectReferenceKeyframe>(ref array, keyframeAtTime); AnimationUtility.SetObjectReferenceCurve(clip, sourceBinding, array); EditorUtility.SetDirty(clip); } } }
public static bool AddAnimatedParameter(this TimelineClip clip, string parameterName) { EditorCurveBinding sourceBinding = default(EditorCurveBinding); SerializedProperty prop; bool result; if (!AnimatedParameterExtensions.InternalAddParameter(clip, parameterName, ref sourceBinding, out prop)) { result = false; } else { float num = (float)clip.duration; CurveEditUtility.AddKey(clip.curves, sourceBinding, prop, 0.0); CurveEditUtility.AddKey(clip.curves, sourceBinding, prop, (double)num); result = true; } return(result); }
private static void AddObjectKey(AnimationClip clip, EditorCurveBinding sourceBinding, SerializedProperty prop, double time) { if (prop.get_propertyType() == 5) { ObjectReferenceKeyframe[] array = null; AnimationClipCurveInfo curveInfo = AnimationClipCurveCache.Instance.GetCurveInfo(clip); int num = Array.IndexOf <EditorCurveBinding>(curveInfo.objectBindings, sourceBinding); if (num >= 0) { array = curveInfo.objectCurves[num]; int num2 = CurveEditUtility.EvaluateIndex(array, (float)time); if (CurveEditUtility.KeyCompare(array[num2].time, (float)time, clip.get_frameRate()) == 0) { array[num2].value = prop.get_objectReferenceValue(); } else if (num2 < array.Length - 1 && CurveEditUtility.KeyCompare(array[num2 + 1].time, (float)time, clip.get_frameRate()) == 0) { array[num2 + 1].value = prop.get_objectReferenceValue(); } else { if (time > (double)array[0].time) { num2++; } ArrayUtility.Insert <ObjectReferenceKeyframe>(ref array, num2, new ObjectReferenceKeyframe { time = (float)time, value = prop.get_objectReferenceValue() }); } } else { array = new ObjectReferenceKeyframe[1]; array[0].time = (float)time; array[0].value = prop.get_objectReferenceValue(); } AnimationUtility.SetObjectReferenceCurve(clip, sourceBinding, array); EditorUtility.SetDirty(clip); } }
public static bool AddAnimatedParameterValueAt(this TimelineClip clip, string parameterName, float value, float time) { bool result; if (!clip.IsParameterAnimatable(parameterName)) { result = false; } else { AnimatedParameterExtensions.CreateCurvesIfRequired(clip, null); EditorCurveBinding curveBinding = clip.GetCurveBinding(parameterName); AnimationCurve animationCurve = AnimationUtility.GetEditorCurve(clip.curves, curveBinding) ?? new AnimationCurve(); SerializedObject serializedObject = AnimatedParameterExtensions.GetSerializedObject(clip); SerializedProperty serializedProperty = serializedObject.FindProperty(parameterName); bool stepped = serializedProperty.get_propertyType() == 1 || serializedProperty.get_propertyType() == null || serializedProperty.get_propertyType() == 7; CurveEditUtility.AddKeyFrameToCurve(animationCurve, time, clip.curves.get_frameRate(), value, stepped); AnimationUtility.SetEditorCurve(clip.curves, curveBinding, animationCurve); result = true; } return(result); }
public static Object Evaluate(ObjectReferenceKeyframe[] curve, float time) { return(curve[CurveEditUtility.EvaluateIndex(curve, time)].value); }
private static void AddFloatKey(AnimationClip clip, EditorCurveBinding sourceBind, SerializedProperty prop, double time) { List <AnimationCurve> list = new List <AnimationCurve>(); List <EditorCurveBinding> list2 = new List <EditorCurveBinding>(); bool flag = false; AnimationClipCurveInfo curveInfo = AnimationClipCurveCache.Instance.GetCurveInfo(clip); for (int i = 0; i < curveInfo.bindings.Length; i++) { EditorCurveBinding item = curveInfo.bindings[i]; if (item.get_type() == sourceBind.get_type()) { SerializedProperty serializedProperty = null; AnimationCurve animationCurve = curveInfo.curves[i]; if (prop.get_propertyPath().Equals(item.propertyName)) { serializedProperty = prop; } else if (item.propertyName.Contains(prop.get_propertyPath())) { serializedProperty = prop.get_serializedObject().FindProperty(item.propertyName); } if (serializedProperty != null) { float keyValue = CurveEditUtility.GetKeyValue(serializedProperty); if (!float.IsNaN(keyValue)) { flag = true; CurveEditUtility.AddKeyFrameToCurve(animationCurve, (float)time, clip.get_frameRate(), keyValue, serializedProperty.get_propertyType() == 1); list.Add(animationCurve); list2.Add(item); } } } } if (!flag) { string propertyGroupName = AnimationWindowUtility.GetPropertyGroupName(sourceBind.propertyName); if (!prop.get_hasChildren()) { float keyValue2 = CurveEditUtility.GetKeyValue(prop); if (!float.IsNaN(keyValue2)) { list2.Add(EditorCurveBinding.FloatCurve(sourceBind.path, sourceBind.get_type(), sourceBind.propertyName)); AnimationCurve animationCurve2 = new AnimationCurve(); CurveEditUtility.AddKeyFrameToCurve(animationCurve2, (float)time, clip.get_frameRate(), keyValue2, prop.get_propertyType() == 1); list.Add(animationCurve2); } } else if (prop.get_propertyType() == 4) { list2.Add(EditorCurveBinding.FloatCurve(sourceBind.path, sourceBind.get_type(), propertyGroupName + ".r")); list2.Add(EditorCurveBinding.FloatCurve(sourceBind.path, sourceBind.get_type(), propertyGroupName + ".g")); list2.Add(EditorCurveBinding.FloatCurve(sourceBind.path, sourceBind.get_type(), propertyGroupName + ".b")); list2.Add(EditorCurveBinding.FloatCurve(sourceBind.path, sourceBind.get_type(), propertyGroupName + ".a")); Color colorValue = prop.get_colorValue(); for (int j = 0; j < 4; j++) { AnimationCurve animationCurve3 = new AnimationCurve(); CurveEditUtility.AddKeyFrameToCurve(animationCurve3, (float)time, clip.get_frameRate(), colorValue.get_Item(j), prop.get_propertyType() == 1); list.Add(animationCurve3); } } else { prop = prop.Copy(); IEnumerator enumerator = prop.GetEnumerator(); try { while (enumerator.MoveNext()) { SerializedProperty serializedProperty2 = (SerializedProperty)enumerator.Current; list2.Add(EditorCurveBinding.FloatCurve(sourceBind.path, sourceBind.get_type(), serializedProperty2.get_propertyPath())); AnimationCurve animationCurve4 = new AnimationCurve(); CurveEditUtility.AddKeyFrameToCurve(animationCurve4, (float)time, clip.get_frameRate(), CurveEditUtility.GetKeyValue(serializedProperty2), serializedProperty2.get_propertyType() == 1); list.Add(animationCurve4); } } finally { IDisposable disposable; if ((disposable = (enumerator as IDisposable)) != null) { disposable.Dispose(); } } } } CurveEditUtility.UpdateEditorCurves(clip, list2, list); }