private void FillPropertyGroup(ref EditorCurveBinding?[] propertyGroup, EditorCurveBinding lastBinding, string propertyGroupName, ref List <AnimationWindowCurve> curvesCache)
{
EditorCurveBinding binding = lastBinding;
binding.isPhantom = true;
if (!propertyGroup[0].HasValue)
{
binding.propertyName = propertyGroupName + ".x";
AnimationWindowCurve item = new AnimationWindowCurve(this.animationClip, binding, this.GetEditorCurveValueType(binding))
{
selectionBinding = this
};
curvesCache.Add(item);
}
if (!propertyGroup[1].HasValue)
{
binding.propertyName = propertyGroupName + ".y";
AnimationWindowCurve curve2 = new AnimationWindowCurve(this.animationClip, binding, this.GetEditorCurveValueType(binding))
{
selectionBinding = this
};
curvesCache.Add(curve2);
}
if (!propertyGroup[2].HasValue)
{
binding.propertyName = propertyGroupName + ".z";
AnimationWindowCurve curve3 = new AnimationWindowCurve(this.animationClip, binding, this.GetEditorCurveValueType(binding))
{
selectionBinding = this
};
curvesCache.Add(curve3);
}
}
public override void ProcessCandidates()
{
BeginKeyModification();
EditorCurveBinding[] bindings = AnimationUtility.GetCurveBindings(m_CandidateClip);
EditorCurveBinding[] objectCurveBindings = AnimationUtility.GetObjectReferenceCurveBindings(m_CandidateClip);
List <AnimationWindowCurve> curves = new List <AnimationWindowCurve>();
for (int i = 0; i < state.allCurves.Count; ++i)
{
AnimationWindowCurve curve = state.allCurves[i];
EditorCurveBinding remappedBinding = RotationCurveInterpolation.RemapAnimationBindingForRotationCurves(curve.binding, m_CandidateClip);
if (Array.Exists(bindings, binding => remappedBinding.Equals(binding)) || Array.Exists(objectCurveBindings, binding => remappedBinding.Equals(binding)))
{
curves.Add(curve);
}
}
AnimationWindowUtility.AddKeyframes(state, curves, time);
EndKeyModification();
ClearCandidates();
}
private void FillPropertyGroup(ref EditorCurveBinding?[] propertyGroup, EditorCurveBinding lastBinding, string propertyGroupName, ref List <AnimationWindowCurve> curvesCache)
{
EditorCurveBinding editorCurveBinding = lastBinding;
editorCurveBinding.isPhantom = true;
if (!propertyGroup[0].HasValue)
{
editorCurveBinding.propertyName = propertyGroupName + ".x";
AnimationWindowCurve animationWindowCurve = new AnimationWindowCurve(this.animationClip, editorCurveBinding, this.GetEditorCurveValueType(editorCurveBinding));
animationWindowCurve.selectionBinding = this;
curvesCache.Add(animationWindowCurve);
}
if (!propertyGroup[1].HasValue)
{
editorCurveBinding.propertyName = propertyGroupName + ".y";
AnimationWindowCurve animationWindowCurve2 = new AnimationWindowCurve(this.animationClip, editorCurveBinding, this.GetEditorCurveValueType(editorCurveBinding));
animationWindowCurve2.selectionBinding = this;
curvesCache.Add(animationWindowCurve2);
}
if (!propertyGroup[2].HasValue)
{
editorCurveBinding.propertyName = propertyGroupName + ".z";
AnimationWindowCurve animationWindowCurve3 = new AnimationWindowCurve(this.animationClip, editorCurveBinding, this.GetEditorCurveValueType(editorCurveBinding));
animationWindowCurve3.selectionBinding = this;
curvesCache.Add(animationWindowCurve3);
}
}
private List <AnimationWindowKeyframe> GetKeys(PropertyModification[] modifications)
{
var keys = new List <AnimationWindowKeyframe>();
EditorCurveBinding[] bindings = AnimationWindowUtility.PropertyModificationsToEditorCurveBindings(modifications, state.activeRootGameObject, state.activeAnimationClip);
if (bindings.Length == 0)
{
return(keys);
}
for (int i = 0; i < state.allCurves.Count; ++i)
{
AnimationWindowCurve curve = state.allCurves[i];
if (Array.Exists(bindings, binding => curve.binding.Equals(binding)))
{
int keyIndex = curve.GetKeyframeIndex(state.time);
if (keyIndex >= 0)
{
keys.Add(curve.m_Keyframes[keyIndex]);
}
}
}
return(keys);
}
static void AddKey(IAnimationRecordingState state, EditorCurveBinding binding, Type type, object previousValue, object currentValue)
{
AnimationClip clip = state.activeAnimationClip;
if ((clip.hideFlags & HideFlags.NotEditable) != 0)
{
return;
}
AnimationWindowCurve curve = new AnimationWindowCurve(clip, binding, type);
// Add previous value at first frame on empty curves.
if (state.addZeroFrame)
{
// Is it a new curve?
if (curve.length == 0)
{
if (state.currentFrame != 0)
{
// case 1373924
// In the case of a new curve, we also have to convert the previousValue to float for a discrete int
if (binding.isDiscreteCurve)
{
previousValue = UnityEngine.Animations.DiscreteEvaluationAttributeUtilities.ConvertDiscreteIntToFloat((int)previousValue);
}
AnimationWindowUtility.AddKeyframeToCurve(curve, previousValue, type, AnimationKeyTime.Frame(0, clip.frameRate));
}
}
}
// Add key at current frame.
AnimationWindowUtility.AddKeyframeToCurve(curve, currentValue, type, AnimationKeyTime.Frame(state.currentFrame, clip.frameRate));
state.SaveCurve(curve);
}
public static AnimationWindowCurve BestMatchForPaste(EditorCurveBinding binding, List <AnimationWindowCurve> clipboardCurves, List <AnimationWindowCurve> targetCurves)
{
AnimationWindowCurve result;
foreach (AnimationWindowCurve current in targetCurves)
{
if (current.binding == binding)
{
result = current;
return(result);
}
}
using (List <AnimationWindowCurve> .Enumerator enumerator2 = targetCurves.GetEnumerator())
{
while (enumerator2.MoveNext())
{
AnimationWindowCurve targetCurve = enumerator2.Current;
if (targetCurve.binding.propertyName == binding.propertyName)
{
if (!clipboardCurves.Exists((AnimationWindowCurve clipboardCurve) => clipboardCurve.binding == targetCurve.binding))
{
result = targetCurve;
return(result);
}
}
}
}
result = null;
return(result);
}
public static void SaveModifiedCurve(AnimationWindowCurve curve, AnimationClip clip)
{
curve.m_Keyframes.Sort((AnimationWindowKeyframe a, AnimationWindowKeyframe b) => a.time.CompareTo(b.time));
if (curve.isPPtrCurve)
{
ObjectReferenceKeyframe[] array = curve.ToObjectCurve();
if (array.Length == 0)
{
array = null;
}
AnimationUtility.SetObjectReferenceCurve(clip, curve.binding, array);
}
else
{
AnimationCurve animationCurve = curve.ToAnimationCurve();
if (animationCurve.keys.Length == 0)
{
animationCurve = null;
}
else
{
QuaternionCurveTangentCalculation.UpdateTangentsFromMode(animationCurve, clip, curve.binding);
}
AnimationUtility.SetEditorCurve(clip, curve.binding, animationCurve);
}
}
static void AddKey(IAnimationRecordingState state, EditorCurveBinding binding, Type type, object previousValue, object currentValue)
{
AnimationClip clip = state.activeAnimationClip;
if ((clip.hideFlags & HideFlags.NotEditable) != 0)
{
return;
}
AnimationWindowCurve curve = new AnimationWindowCurve(clip, binding, type);
// Add previous value at first frame on empty curves.
if (state.addZeroFrame)
{
// Is it a new curve?
if (curve.length == 0)
{
if (state.currentFrame != 0)
{
AnimationWindowUtility.AddKeyframeToCurve(curve, previousValue, type, AnimationKeyTime.Frame(0, clip.frameRate));
}
}
}
// Add key at current frame.
AnimationWindowUtility.AddKeyframeToCurve(curve, currentValue, type, AnimationKeyTime.Frame(state.currentFrame, clip.frameRate));
state.SaveCurve(curve);
}
private List <AnimationWindowKeyframe> GetKeys(PropertyModification[] modifications)
{
List <AnimationWindowKeyframe> list = new List <AnimationWindowKeyframe>();
EditorCurveBinding[] array = AnimationWindowUtility.PropertyModificationsToEditorCurveBindings(modifications, this.state.activeRootGameObject, this.state.activeAnimationClip);
List <AnimationWindowKeyframe> result;
if (array.Length == 0)
{
result = list;
}
else
{
for (int i = 0; i < this.state.allCurves.Count; i++)
{
AnimationWindowCurve curve = this.state.allCurves[i];
if (Array.Exists <EditorCurveBinding>(array, (EditorCurveBinding binding) => curve.binding.Equals(binding)))
{
int keyframeIndex = curve.GetKeyframeIndex(this.state.time);
if (keyframeIndex >= 0)
{
list.Add(curve.m_Keyframes[keyframeIndex]);
}
}
}
result = list;
}
return(result);
}
private static void AddRotationKey(IAnimationRecordingState state, EditorCurveBinding binding, Type type, Vector3 previousEulerAngles, Vector3 currentEulerAngles)
{
AnimationClip activeAnimationClip = state.activeAnimationClip;
if ((activeAnimationClip.hideFlags & HideFlags.NotEditable) == HideFlags.None)
{
EditorCurveBinding[] array = RotationCurveInterpolation.RemapAnimationBindingForRotationAddKey(binding, activeAnimationClip);
for (int i = 0; i < 3; i++)
{
AnimationWindowCurve animationWindowCurve = new AnimationWindowCurve(activeAnimationClip, array[i], type);
if (state.addZeroFrame)
{
if (animationWindowCurve.length == 0)
{
if (state.currentFrame != 0)
{
AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, previousEulerAngles[i], type, AnimationKeyTime.Frame(0, activeAnimationClip.frameRate));
}
}
}
AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, currentEulerAngles[i], type, AnimationKeyTime.Frame(state.currentFrame, activeAnimationClip.frameRate));
state.SaveCurve(animationWindowCurve);
}
}
}
public void SaveCurve(AnimationWindowCurve curve)
{
curve.m_Keyframes.Sort((AnimationWindowKeyframe a, AnimationWindowKeyframe b) => a.time.CompareTo(b.time));
Undo.RegisterCompleteObjectUndo(this.m_ActiveAnimationClip, "Edit Curve");
if (curve.isPPtrCurve)
{
ObjectReferenceKeyframe[] array = curve.ToObjectCurve();
if (array.Length == 0)
{
array = null;
}
AnimationUtility.SetObjectReferenceCurve(this.m_ActiveAnimationClip, curve.binding, array);
}
else
{
AnimationCurve animationCurve = curve.ToAnimationCurve();
if (animationCurve.keys.Length == 0)
{
animationCurve = null;
}
else
{
QuaternionCurveTangentCalculation.UpdateTangentsFromMode(animationCurve, this.m_ActiveAnimationClip, curve.binding);
}
AnimationUtility.SetEditorCurve(this.m_ActiveAnimationClip, curve.binding, animationCurve);
}
this.Repaint();
}
private void FillPropertyGroup(ref EditorCurveBinding?[] propertyGroup, EditorCurveBinding lastBinding, string propertyGroupName, ref List <AnimationWindowCurve> curvesCache)
{
var newBinding = lastBinding;
newBinding.isPhantom = true;
if (!propertyGroup[0].HasValue)
{
newBinding.propertyName = propertyGroupName + ".x";
AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, newBinding, GetEditorCurveValueType(newBinding));
curve.selectionBinding = this;
curvesCache.Add(curve);
}
if (!propertyGroup[1].HasValue)
{
newBinding.propertyName = propertyGroupName + ".y";
AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, newBinding, GetEditorCurveValueType(newBinding));
curve.selectionBinding = this;
curvesCache.Add(curve);
}
if (!propertyGroup[2].HasValue)
{
newBinding.propertyName = propertyGroupName + ".z";
AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, newBinding, GetEditorCurveValueType(newBinding));
curve.selectionBinding = this;
curvesCache.Add(curve);
}
}
public List <AnimationWindowHierarchyNode> CreateTreeFromCurves()
{
List <AnimationWindowHierarchyNode> list = new List <AnimationWindowHierarchyNode>();
List <AnimationWindowCurve> list2 = new List <AnimationWindowCurve>();
AnimationWindowCurve[] array = this.state.allCurves.ToArray();
for (int i = 0; i < array.Length; i++)
{
AnimationWindowCurve animationWindowCurve = array[i];
AnimationWindowCurve animationWindowCurve2 = (i >= array.Length - 1) ? null : array[i + 1];
list2.Add(animationWindowCurve);
bool flag = animationWindowCurve2 != null && AnimationWindowUtility.GetPropertyGroupName(animationWindowCurve2.propertyName) == AnimationWindowUtility.GetPropertyGroupName(animationWindowCurve.propertyName);
bool flag2 = animationWindowCurve2 != null && animationWindowCurve.path.Equals(animationWindowCurve2.path) && animationWindowCurve.type == animationWindowCurve2.type;
if (i == array.Length - 1 || !flag || !flag2)
{
if (list2.Count > 1)
{
list.Add(this.AddPropertyGroupToHierarchy(list2.ToArray(), (AnimationWindowHierarchyNode)this.m_RootItem));
}
else
{
list.Add(this.AddPropertyToHierarchy(list2[0], (AnimationWindowHierarchyNode)this.m_RootItem));
}
list2.Clear();
}
}
return(list);
}
protected override void RenameEnded()
{
string name = base.GetRenameOverlay().name;
string originalName = base.GetRenameOverlay().originalName;
if (name != originalName)
{
Undo.RecordObject(this.state.activeAnimationClip, "Rename Curve");
AnimationWindowCurve[] curves = this.m_RenamedNode.curves;
for (int i = 0; i < curves.Length; i++)
{
AnimationWindowCurve animationWindowCurve = curves[i];
string newPath = this.RenamePath(animationWindowCurve.path, name);
EditorCurveBinding renamedBinding = AnimationWindowUtility.GetRenamedBinding(animationWindowCurve.binding, newPath);
if (AnimationWindowUtility.CurveExists(renamedBinding, this.state.allCurves.ToArray()))
{
Debug.LogWarning("Curve already exists, renaming cancelled.");
}
else
{
AnimationWindowUtility.RenameCurvePath(animationWindowCurve, renamedBinding, animationWindowCurve.clip);
}
}
}
this.m_RenamedNode = null;
}
static void AddRotationKey(IAnimationRecordingState state, EditorCurveBinding binding, Type type, Vector3 previousEulerAngles, Vector3 currentEulerAngles)
{
AnimationClip clip = state.activeAnimationClip;
if ((clip.hideFlags & HideFlags.NotEditable) != 0)
{
return;
}
EditorCurveBinding[] additionalBindings = RotationCurveInterpolation.RemapAnimationBindingForRotationAddKey(binding, clip);
// Add key at current frame
for (int i = 0; i < 3; i++)
{
AnimationWindowCurve curve = new AnimationWindowCurve(clip, additionalBindings[i], type);
if (state.addZeroFrame)
{
// Is it a new curve?
if (curve.length == 0)
{
if (state.currentFrame != 0)
{
AnimationWindowUtility.AddKeyframeToCurve(curve, previousEulerAngles[i], type, AnimationKeyTime.Frame(0, clip.frameRate));
}
}
}
AnimationWindowUtility.AddKeyframeToCurve(curve, currentEulerAngles[i], type, AnimationKeyTime.Frame(state.currentFrame, clip.frameRate));
state.SaveCurve(curve);
}
}
public static void AddSelectedKeyframes(AnimationWindowState state, AnimationKeyTime time)
{
if (state.activeCurves.Count > 0)
{
using (List <AnimationWindowCurve> .Enumerator enumerator = state.activeCurves.GetEnumerator())
{
while (enumerator.MoveNext())
{
AnimationWindowCurve current = enumerator.Current;
AnimationWindowUtility.AddKeyframeToCurve(state, current, time);
}
}
}
else
{
using (List <AnimationWindowCurve> .Enumerator enumerator = state.allCurves.GetEnumerator())
{
while (enumerator.MoveNext())
{
AnimationWindowCurve current = enumerator.Current;
AnimationWindowUtility.AddKeyframeToCurve(state, current, time);
}
}
}
}
public static AnimationWindowCurve BestMatchForPaste(EditorCurveBinding binding, List <AnimationWindowCurve> curves)
{
using (List <AnimationWindowCurve> .Enumerator enumerator = curves.GetEnumerator())
{
while (enumerator.MoveNext())
{
AnimationWindowCurve current = enumerator.Current;
if (current.binding == binding)
{
return(current);
}
}
}
using (List <AnimationWindowCurve> .Enumerator enumerator = curves.GetEnumerator())
{
while (enumerator.MoveNext())
{
AnimationWindowCurve current = enumerator.Current;
if (current.binding.propertyName == binding.propertyName)
{
return(current);
}
}
}
if (curves.Count == 1)
{
return(curves[0]);
}
return((AnimationWindowCurve)null);
}
private static void AddKey(IAnimationRecordingState state, EditorCurveBinding binding, Type type, PropertyModification modification)
{
GameObject activeRootGameObject = state.activeRootGameObject;
AnimationClip activeAnimationClip = state.activeAnimationClip;
if ((activeAnimationClip.hideFlags & HideFlags.NotEditable) == HideFlags.None)
{
AnimationWindowCurve animationWindowCurve = new AnimationWindowCurve(activeAnimationClip, binding, type);
object currentValue = CurveBindingUtility.GetCurrentValue(activeRootGameObject, binding);
if (animationWindowCurve.length == 0)
{
object value = null;
if (!AnimationRecording.ValueFromPropertyModification(modification, binding, out value))
{
value = currentValue;
}
if (state.frame != 0)
{
AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, value, type, AnimationKeyTime.Frame(0, activeAnimationClip.frameRate));
}
}
AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, currentValue, type, AnimationKeyTime.Frame(state.frame, activeAnimationClip.frameRate));
state.SaveCurve(animationWindowCurve);
}
}
public List <AnimationWindowHierarchyNode> CreateTreeFromCurves()
{
List <AnimationWindowHierarchyNode> windowHierarchyNodeList = new List <AnimationWindowHierarchyNode>();
List <AnimationWindowCurve> animationWindowCurveList = new List <AnimationWindowCurve>();
AnimationWindowCurve[] array = this.state.allCurves.ToArray();
for (int index = 0; index < array.Length; ++index)
{
AnimationWindowCurve animationWindowCurve1 = array[index];
AnimationWindowCurve animationWindowCurve2 = index >= array.Length - 1 ? (AnimationWindowCurve)null : array[index + 1];
animationWindowCurveList.Add(animationWindowCurve1);
bool flag1 = animationWindowCurve2 != null && AnimationWindowUtility.GetPropertyGroupName(animationWindowCurve2.propertyName) == AnimationWindowUtility.GetPropertyGroupName(animationWindowCurve1.propertyName);
bool flag2 = animationWindowCurve2 != null && animationWindowCurve1.path.Equals(animationWindowCurve2.path) && animationWindowCurve1.type == animationWindowCurve2.type;
if (index == array.Length - 1 || !flag1 || !flag2)
{
if (animationWindowCurveList.Count > 1)
{
windowHierarchyNodeList.Add((AnimationWindowHierarchyNode)this.AddPropertyGroupToHierarchy(animationWindowCurveList.ToArray(), (AnimationWindowHierarchyNode)this.m_RootItem));
}
else
{
windowHierarchyNodeList.Add((AnimationWindowHierarchyNode)this.AddPropertyToHierarchy(animationWindowCurveList[0], (AnimationWindowHierarchyNode)this.m_RootItem));
}
animationWindowCurveList.Clear();
}
}
return(windowHierarchyNodeList);
}
public void GoToNextKeyframe(PropertyModification[] modifications)
{
EditorCurveBinding[] bindings = AnimationWindowUtility.PropertyModificationsToEditorCurveBindings(modifications, state.activeRootGameObject, state.activeAnimationClip);
if (bindings.Length == 0)
{
return;
}
List <AnimationWindowCurve> curves = new List <AnimationWindowCurve>();
for (int i = 0; i < state.allCurves.Count; ++i)
{
AnimationWindowCurve curve = state.allCurves[i];
if (Array.Exists(bindings, binding => curve.binding.Equals(binding)))
{
curves.Add(curve);
}
}
float newTime = AnimationWindowUtility.GetNextKeyframeTime(curves.ToArray(), time.time, state.clipFrameRate);
SetCurrentTime(state.SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToClipFrame));
state.Repaint();
}
public List <AnimationWindowHierarchyNode> CreateTreeFromCurves()
{
List <AnimationWindowHierarchyNode> list = new List <AnimationWindowHierarchyNode>();
List <AnimationWindowCurve> list2 = new List <AnimationWindowCurve>();
AnimationWindowCurve[] curveArray = this.state.allCurves.ToArray();
for (int i = 0; i < curveArray.Length; i++)
{
AnimationWindowCurve item = curveArray[i];
AnimationWindowCurve curve2 = (i >= (curveArray.Length - 1)) ? null : curveArray[i + 1];
list2.Add(item);
bool flag = (curve2 != null) && (AnimationWindowUtility.GetPropertyGroupName(curve2.propertyName) == AnimationWindowUtility.GetPropertyGroupName(item.propertyName));
bool flag2 = ((curve2 != null) && item.path.Equals(curve2.path)) && (item.type == curve2.type);
if (((i == (curveArray.Length - 1)) || !flag) || !flag2)
{
if (list2.Count > 1)
{
list.Add(this.AddPropertyGroupToHierarchy(list2.ToArray(), (AnimationWindowHierarchyNode)base.m_RootItem));
}
else
{
list.Add(this.AddPropertyToHierarchy(list2[0], (AnimationWindowHierarchyNode)base.m_RootItem));
}
list2.Clear();
}
}
return(list);
}
public static object GetCurrentValue(AnimationWindowState state, AnimationWindowCurve curve)
{
if (UnityEditor.AnimationMode.InAnimationMode() && (curve.rootGameObject != null))
{
return(AnimationWindowUtility.GetCurrentValue(curve.rootGameObject, curve.binding));
}
return(curve.Evaluate(state.currentTime - curve.timeOffset));
}
public AnimationWindowKeyframe(AnimationWindowCurve curve, Keyframe key)
{
this.time = key.time;
this.value = (object)key.value;
this.curve = curve;
this.m_InTangent = key.inTangent;
this.m_OutTangent = key.outTangent;
this.m_TangentMode = key.tangentMode;
}
public AnimationWindowKeyframe(AnimationWindowKeyframe key)
{
this.time = key.time;
this.value = key.value;
this.curve = key.curve;
this.m_InTangent = key.m_InTangent;
this.m_OutTangent = key.m_OutTangent;
this.m_TangentMode = key.m_TangentMode;
this.m_curve = key.m_curve;
}
// Retrieve current value. If bindings are available and value is animated, use bindings to get value.
// Otherwise, evaluate AnimationWindowCurve at current time.
public static object GetCurrentValue(AnimationWindowState state, AnimationWindowCurve curve)
{
if (state.previewing && curve.rootGameObject != null)
{
return(AnimationWindowUtility.GetCurrentValue(curve.rootGameObject, curve.binding));
}
else
{
return(curve.Evaluate(state.currentTime));
}
}
private void DeleteKeysAtCurrentTime(List <AnimationWindowCurve> curves)
{
using (List <AnimationWindowCurve> .Enumerator enumerator = curves.GetEnumerator())
{
while (enumerator.MoveNext())
{
AnimationWindowCurve current = enumerator.Current;
current.RemoveKeyframe(this.state.time);
this.state.SaveCurve(current);
}
}
}
public static bool CurveExists(EditorCurveBinding binding, AnimationWindowCurve[] curves)
{
for (int i = 0; i < curves.Length; i++)
{
AnimationWindowCurve animationWindowCurve = curves[i];
if (binding.propertyName == animationWindowCurve.binding.propertyName && binding.type == animationWindowCurve.binding.type && binding.path == animationWindowCurve.binding.path)
{
return(true);
}
}
return(false);
}
public void RemoveCurve(AnimationWindowCurve curve)
{
Undo.RegisterCompleteObjectUndo(this.m_ActiveAnimationClip, "Remove Curve");
if (curve.isPPtrCurve)
{
AnimationUtility.SetObjectReferenceCurve(this.m_ActiveAnimationClip, curve.binding, null);
}
else
{
AnimationUtility.SetEditorCurve(this.m_ActiveAnimationClip, curve.binding, null);
}
}
public static AnimationWindowKeyframe AddKeyframeToCurve(AnimationWindowCurve curve, object value, Type type, AnimationKeyTime time)
{
AnimationWindowKeyframe animationWindowKeyframe = curve.FindKeyAtTime(time);
AnimationWindowKeyframe result;
if (animationWindowKeyframe != null)
{
animationWindowKeyframe.value = value;
result = animationWindowKeyframe;
}
else
{
AnimationWindowKeyframe animationWindowKeyframe2 = null;
if (curve.isPPtrCurve)
{
animationWindowKeyframe2 = new AnimationWindowKeyframe();
animationWindowKeyframe2.time = time.time;
animationWindowKeyframe2.value = value;
animationWindowKeyframe2.curve = curve;
curve.AddKeyframe(animationWindowKeyframe2, time);
}
else if (type == typeof(bool) || type == typeof(float))
{
animationWindowKeyframe2 = new AnimationWindowKeyframe();
AnimationCurve animationCurve = curve.ToAnimationCurve();
Keyframe key = new Keyframe(time.time, (float)value);
if (type == typeof(bool))
{
AnimationUtility.SetKeyLeftTangentMode(ref key, AnimationUtility.TangentMode.Constant);
AnimationUtility.SetKeyRightTangentMode(ref key, AnimationUtility.TangentMode.Constant);
AnimationUtility.SetKeyBroken(ref key, true);
animationWindowKeyframe2.m_TangentMode = key.tangentMode;
animationWindowKeyframe2.m_InTangent = float.PositiveInfinity;
animationWindowKeyframe2.m_OutTangent = float.PositiveInfinity;
}
else
{
int num = animationCurve.AddKey(key);
if (num != -1)
{
CurveUtility.SetKeyModeFromContext(animationCurve, num);
animationWindowKeyframe2.m_TangentMode = animationCurve[num].tangentMode;
}
}
animationWindowKeyframe2.time = time.time;
animationWindowKeyframe2.value = value;
animationWindowKeyframe2.curve = curve;
curve.AddKeyframe(animationWindowKeyframe2, time);
}
result = animationWindowKeyframe2;
}
return(result);
}
public List <AnimationWindowHierarchyNode> CreateTreeFromCurves()
{
List <AnimationWindowHierarchyNode> nodes = new List <AnimationWindowHierarchyNode>();
List <AnimationWindowCurve> singlePropertyCurves = new List <AnimationWindowCurve>();
AnimationWindowCurve[] curves = state.allCurves.ToArray();
AnimationWindowHierarchyNode parentNode = (AnimationWindowHierarchyNode)m_RootItem;
SerializedObject so = null;
for (int i = 0; i < curves.Length; i++)
{
AnimationWindowCurve curve = curves[i];
if (!state.ShouldShowCurve(curve))
{
continue;
}
AnimationWindowCurve nextCurve = i < curves.Length - 1 ? curves[i + 1] : null;
if (curve.isSerializeReferenceCurve && state.activeRootGameObject != null)
{
var animatedObject = AnimationUtility.GetAnimatedObject(state.activeRootGameObject, curve.binding);
if (animatedObject != null && (so == null || so.targetObject != animatedObject))
{
so = new SerializedObject(animatedObject);
}
}
singlePropertyCurves.Add(curve);
bool areSameGroup = nextCurve != null && AnimationWindowUtility.GetPropertyGroupName(nextCurve.propertyName) == AnimationWindowUtility.GetPropertyGroupName(curve.propertyName);
bool areSamePathAndType = nextCurve != null && curve.path.Equals(nextCurve.path) && curve.type == nextCurve.type;
// We expect curveBindings to come sorted by propertyname
// So we compare curve vs nextCurve. If its different path or different group (think "scale.xyz" as group), then we know this is the last element of such group.
if (i == curves.Length - 1 || !areSameGroup || !areSamePathAndType)
{
if (singlePropertyCurves.Count > 1)
{
nodes.Add(AddPropertyGroupToHierarchy(singlePropertyCurves.ToArray(), parentNode, so));
}
else
{
nodes.Add(AddPropertyToHierarchy(singlePropertyCurves[0], parentNode, so));
}
singlePropertyCurves.Clear();
}
}
return(nodes);
}
