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);
}
