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);
}
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);
}
static public void ProcessModifications(IAnimationRecordingState state, UndoPropertyModification[] modifications)
{
GameObject root = state.activeRootGameObject;
// Record modified properties
for (int i = 0; i < modifications.Length; i++)
{
EditorCurveBinding binding = new EditorCurveBinding();
PropertyModification prop = modifications[i].previousValue;
Type type = AnimationUtility.PropertyModificationToEditorCurveBinding(prop, root, out binding);
if (type != null)
{
object currentValue = CurveBindingUtility.GetCurrentValue(root, binding);
object previousValue = null;
if (!ValueFromPropertyModification(prop, binding, out previousValue))
{
previousValue = currentValue;
}
state.AddPropertyModification(binding, prop, modifications[i].keepPrefabOverride);
AddKey(state, binding, type, previousValue, currentValue);
}
}
}
static private void ProcessVector3Modification(IAnimationRecordingState state, EditorCurveBinding baseBinding, UndoPropertyModification modification, Transform target, string axis, float scale = 1.0f)
{
var binding = baseBinding;
binding.propertyName = binding.propertyName.Remove(binding.propertyName.Length - 1, 1) + axis;
object currentValue = CurveBindingUtility.GetCurrentValue(state.activeRootGameObject, binding);
var previousModification = modification.previousValue;
if (previousModification == null)
{
// create dummy
previousModification = new PropertyModification();
previousModification.target = target;
previousModification.propertyPath = binding.propertyName;
previousModification.value = ((float)currentValue).ToString(CultureInfo.InvariantCulture.NumberFormat);
}
object previousValue = currentValue;
ValueFromPropertyModification(previousModification, binding, out previousValue);
state.AddPropertyModification(binding, previousModification, modification.keepPrefabOverride);
if (scale != 1.0f)
{
previousValue = (object)((float)previousValue / scale);
currentValue = (object)((float)currentValue / scale);
}
AddKey(state, binding, typeof(float), previousValue, currentValue);
}
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);
}
}
}
private static UndoPropertyModification[] FilterRotationModifications(IAnimationRecordingState state, ref Dictionary <object, AnimationRecording.RotationModification> rotationModifications)
{
AnimationClip activeAnimationClip = state.activeAnimationClip;
GameObject activeRootGameObject = state.activeRootGameObject;
List <object> list = new List <object>();
List <UndoPropertyModification> list2 = new List <UndoPropertyModification>();
foreach (KeyValuePair <object, AnimationRecording.RotationModification> current in rotationModifications)
{
AnimationRecording.RotationModification value = current.Value;
if (state.DiscardModification(value.lastQuatModification.currentValue))
{
AnimationRecording.DiscardRotationModification(value, ref list2);
list.Add(current.Key);
}
else
{
EditorCurveBinding editorCurveBinding = default(EditorCurveBinding);
if (AnimationUtility.PropertyModificationToEditorCurveBinding(value.lastQuatModification.currentValue, activeRootGameObject, out editorCurveBinding) == null)
{
AnimationRecording.DiscardRotationModification(value, ref list2);
list.Add(current.Key);
}
}
}
foreach (object current2 in list)
{
rotationModifications.Remove(current2);
}
return(list2.ToArray());
}
private static UndoPropertyModification[] FilterModifications(IAnimationRecordingState state, ref UndoPropertyModification[] modifications)
{
AnimationClip activeAnimationClip = state.activeAnimationClip;
GameObject activeRootGameObject = state.activeRootGameObject;
List <UndoPropertyModification> list = new List <UndoPropertyModification>();
List <UndoPropertyModification> list2 = new List <UndoPropertyModification>();
for (int i = 0; i < modifications.Length; i++)
{
UndoPropertyModification item = modifications[i];
PropertyModification previousValue = item.previousValue;
if (state.DiscardModification(previousValue))
{
list.Add(item);
}
else
{
EditorCurveBinding editorCurveBinding = default(EditorCurveBinding);
if (AnimationUtility.PropertyModificationToEditorCurveBinding(previousValue, activeRootGameObject, out editorCurveBinding) != null)
{
list2.Add(item);
}
else
{
list.Add(item);
}
}
}
if (list.Count > 0)
{
modifications = list2.ToArray();
}
return(list.ToArray());
}
static public void ProcessVector3Modifications(IAnimationRecordingState state, ref System.Collections.Generic.Dictionary <object, Vector3Modification> vector3Modifications)
{
AnimationClip clip = state.activeAnimationClip;
GameObject root = state.activeRootGameObject;
foreach (KeyValuePair <object, Vector3Modification> item in vector3Modifications)
{
Vector3Modification m = item.Value;
Transform target = item.Key as Transform;
if (target == null)
{
continue;
}
EditorCurveBinding binding = new EditorCurveBinding();
Type type = AnimationUtility.PropertyModificationToEditorCurveBinding(m.last.currentValue, state.activeRootGameObject, out binding);
if (type == null)
{
continue;
}
ProcessVector3Modification(state, binding, m.x, target, "x");
ProcessVector3Modification(state, binding, m.y, target, "y");
ProcessVector3Modification(state, binding, m.z, target, "z");
}
}
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.currentFrame != 0 && state.addZeroFrame)
{
AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, value, type, AnimationKeyTime.Frame(0, activeAnimationClip.frameRate));
}
}
AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, currentValue, type, AnimationKeyTime.Frame(state.currentFrame, activeAnimationClip.frameRate));
state.SaveCurve(animationWindowCurve);
}
}
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);
}
}
private static void ProcessRootMotionModifications(IAnimationRecordingState state, ref Dictionary <object, AnimationRecording.RootMotionModification> rootMotionModifications)
{
AnimationClip activeAnimationClip = state.activeAnimationClip;
GameObject activeRootGameObject = state.activeRootGameObject;
Animator component = activeRootGameObject.GetComponent <Animator>();
bool flag = component != null && component.isHuman;
foreach (KeyValuePair <object, AnimationRecording.RootMotionModification> current in rootMotionModifications)
{
AnimationRecording.RootMotionModification value = current.Value;
Transform transform = current.Key as Transform;
Vector3 vector = transform.localScale * ((!flag) ? 1f : component.humanScale);
Vector3 localPosition = transform.localPosition;
Quaternion localRotation = transform.localRotation;
if (value.lastP.previousValue != null)
{
AnimationRecording.ProcessAnimatorModification(state, component, value.px, "MotionT.x", localPosition.x, vector.x);
AnimationRecording.ProcessAnimatorModification(state, component, value.py, "MotionT.y", localPosition.y, vector.y);
AnimationRecording.ProcessAnimatorModification(state, component, value.pz, "MotionT.z", localPosition.z, vector.z);
}
if (value.lastR.previousValue != null)
{
AnimationRecording.ProcessAnimatorModification(state, component, value.rx, "MotionQ.x", localRotation.x, 1f);
AnimationRecording.ProcessAnimatorModification(state, component, value.ry, "MotionQ.y", localRotation.y, 1f);
AnimationRecording.ProcessAnimatorModification(state, component, value.rz, "MotionQ.z", localRotation.z, 1f);
AnimationRecording.ProcessAnimatorModification(state, component, value.rw, "MotionQ.w", localRotation.w, 1f);
}
}
}
public static UndoPropertyModification[] Process(IAnimationRecordingState state, UndoPropertyModification[] modifications)
{
GameObject activeRootGameObject = state.activeRootGameObject;
UndoPropertyModification[] result;
if (activeRootGameObject == null)
{
result = modifications;
}
else if (!AnimationRecording.HasAnyRecordableModifications(activeRootGameObject, modifications))
{
result = modifications;
}
else
{
Dictionary <object, AnimationRecording.RotationModification> dictionary = new Dictionary <object, AnimationRecording.RotationModification>();
Dictionary <object, AnimationRecording.Vector3Modification> dictionary2 = new Dictionary <object, AnimationRecording.Vector3Modification>();
Dictionary <object, AnimationRecording.Vector3Modification> dictionary3 = new Dictionary <object, AnimationRecording.Vector3Modification>();
AnimationRecording.CollectRotationModifications(state, ref modifications, ref dictionary);
UndoPropertyModification[] second = AnimationRecording.FilterRotationModifications(state, ref dictionary);
UndoPropertyModification[] array = AnimationRecording.FilterModifications(state, ref modifications);
AnimationRecording.CollectVector3Modifications(state, ref modifications, ref dictionary3, "m_LocalPosition");
AnimationRecording.CollectVector3Modifications(state, ref modifications, ref dictionary2, "m_LocalScale");
AnimationRecording.ProcessAnimatorModifications(state, ref dictionary3, ref dictionary, ref dictionary2);
AnimationRecording.ProcessVector3Modifications(state, ref dictionary3);
AnimationRecording.ProcessRotationModifications(state, ref dictionary);
AnimationRecording.ProcessVector3Modifications(state, ref dictionary2);
AnimationRecording.ProcessModifications(state, modifications);
array.Concat(second);
result = array.ToArray <UndoPropertyModification>();
}
return(result);
}
static private UndoPropertyModification[] FilterRotationModifications(IAnimationRecordingState state, ref Dictionary <object, RotationModification> rotationModifications)
{
GameObject rootGameObject = state.activeRootGameObject;
List <object> itemsToRemove = new List <object>();
List <UndoPropertyModification> discardedModifications = new List <UndoPropertyModification>();
foreach (KeyValuePair <object, RotationModification> item in rotationModifications)
{
RotationModification m = item.Value;
if (state.DiscardModification(m.lastQuatModification.currentValue))
{
DiscardRotationModification(m, ref discardedModifications);
itemsToRemove.Add(item.Key);
continue;
}
EditorCurveBinding binding = new EditorCurveBinding();
Type type = AnimationUtility.PropertyModificationToEditorCurveBinding(m.lastQuatModification.currentValue, rootGameObject, out binding);
if (type == null)
{
DiscardRotationModification(m, ref discardedModifications);
itemsToRemove.Add(item.Key);
}
}
foreach (var key in itemsToRemove)
{
rotationModifications.Remove(key);
}
return(discardedModifications.ToArray());
}
static private void ProcessRootMotionModifications(IAnimationRecordingState state,
ref Dictionary <object, RootMotionModification> rootMotionModifications)
{
GameObject root = state.activeRootGameObject;
Animator animator = root.GetComponent <Animator>();
bool isHuman = animator != null ? animator.isHuman : false;
foreach (KeyValuePair <object, RootMotionModification> item in rootMotionModifications)
{
RootMotionModification m = item.Value;
Transform target = item.Key as Transform;
Vector3 scale = target.localScale * (isHuman ? animator.humanScale : 1);
Vector3 position = target.localPosition;
Quaternion rotation = target.localRotation;
if (m.lastP.previousValue != null)
{
ProcessRootMotionModification(state, animator, m.px, "MotionT.x", position.x, scale.x);
ProcessRootMotionModification(state, animator, m.py, "MotionT.y", position.y, scale.y);
ProcessRootMotionModification(state, animator, m.pz, "MotionT.z", position.z, scale.z);
}
if (m.lastR.previousValue != null)
{
ProcessRootMotionModification(state, animator, m.rx, "MotionQ.x", rotation.x, 1);
ProcessRootMotionModification(state, animator, m.ry, "MotionQ.y", rotation.y, 1);
ProcessRootMotionModification(state, animator, m.rz, "MotionQ.z", rotation.z, 1);
ProcessRootMotionModification(state, animator, m.rw, "MotionQ.w", rotation.w, 1);
}
}
}
private static void AddRotationPropertyModification(IAnimationRecordingState state, EditorCurveBinding baseBinding, UndoPropertyModification modification)
{
if (modification.previousValue != null)
{
EditorCurveBinding binding = baseBinding;
binding.propertyName = modification.previousValue.propertyPath;
AnimationMode.AddPropertyModification(binding, modification.previousValue, modification.keepPrefabOverride);
}
}
private static void AddRotationPropertyModification(IAnimationRecordingState state, EditorCurveBinding baseBinding, UndoPropertyModification modification)
{
if (modification.previousValue != null)
{
EditorCurveBinding binding = baseBinding;
binding.propertyName = modification.previousValue.propertyPath;
AnimationMode.AddPropertyModification(binding, modification.previousValue, modification.keepPrefabOverride);
}
}
public static void CreateDefaultCurves(IAnimationRecordingState state, AnimationWindowSelectionItem selectionItem, EditorCurveBinding[] properties)
{
properties = RotationCurveInterpolation.ConvertRotationPropertiesToDefaultInterpolation(selectionItem.animationClip, properties);
EditorCurveBinding[] array = properties;
for (int i = 0; i < array.Length; i++)
{
EditorCurveBinding binding = array[i];
state.SaveCurve(AnimationWindowUtility.CreateDefaultCurve(selectionItem, binding));
}
}
public static UndoPropertyModification[] Process(IAnimationRecordingState state, UndoPropertyModification[] modifications)
{
GameObject activeRootGameObject = state.activeRootGameObject;
if (activeRootGameObject == null)
{
return(modifications);
}
AnimationClip activeAnimationClip = state.activeAnimationClip;
Animator component = activeRootGameObject.GetComponent <Animator>();
if (!HasAnyRecordableModifications(activeRootGameObject, modifications))
{
return(modifications);
}
ProcessRotationModifications(state, ref modifications);
List <UndoPropertyModification> list = new List <UndoPropertyModification>();
for (int i = 0; i < modifications.Length; i++)
{
EditorCurveBinding binding = new EditorCurveBinding();
PropertyModification previousValue = modifications[i].previousValue;
System.Type type = AnimationUtility.PropertyModificationToEditorCurveBinding(previousValue, activeRootGameObject, out binding);
if (type != null)
{
if (((component != null) && component.isHuman) && ((binding.type == typeof(Transform)) && component.IsBoneTransform(previousValue.target as Transform)))
{
Debug.LogWarning("Keyframing for humanoid rig is not supported!", previousValue.target as Transform);
}
else
{
UnityEditor.AnimationMode.AddPropertyModification(binding, previousValue, modifications[i].keepPrefabOverride);
EditorCurveBinding[] bindingArray = RotationCurveInterpolation.RemapAnimationBindingForAddKey(binding, activeAnimationClip);
if (bindingArray != null)
{
for (int j = 0; j < bindingArray.Length; j++)
{
AddKey(state, bindingArray[j], type, FindPropertyModification(activeRootGameObject, modifications, bindingArray[j]));
}
}
else
{
AddKey(state, binding, type, previousValue);
}
}
}
else
{
list.Add(modifications[i]);
}
}
return(list.ToArray());
}
static private void CollectVector3Modifications(IAnimationRecordingState state, ref UndoPropertyModification[] modifications,
ref System.Collections.Generic.Dictionary <object, Vector3Modification> vector3Modifications, string propertyName)
{
List <UndoPropertyModification> outModifs = new List <UndoPropertyModification>();
foreach (var modification in modifications)
{
PropertyModification prop = modification.previousValue;
if (!(prop.target is Transform))
{
outModifs.Add(modification);
continue;
}
EditorCurveBinding binding = new EditorCurveBinding();
AnimationUtility.PropertyModificationToEditorCurveBinding(prop, state.activeRootGameObject, out binding);
if (binding.propertyName.StartsWith(propertyName))
{
Vector3Modification vector3Modification;
if (!vector3Modifications.TryGetValue(prop.target, out vector3Modification))
{
vector3Modification = new Vector3Modification();
vector3Modifications[prop.target] = vector3Modification;
}
if (binding.propertyName.EndsWith("x"))
{
vector3Modification.x = modification;
}
else if (binding.propertyName.EndsWith("y"))
{
vector3Modification.y = modification;
}
else if (binding.propertyName.EndsWith("z"))
{
vector3Modification.z = modification;
}
vector3Modification.last = modification;
}
else
{
outModifs.Add(modification);
}
}
if (vector3Modifications.Count > 0)
{
modifications = outModifs.ToArray();
}
}
public static void CreateDefaultCurves(IAnimationRecordingState state, EditorCurveBinding[] properties)
{
AnimationClip activeAnimationClip = state.activeAnimationClip;
GameObject activeRootGameObject = state.activeRootGameObject;
properties = RotationCurveInterpolation.ConvertRotationPropertiesToDefaultInterpolation(activeAnimationClip, properties);
EditorCurveBinding[] array = properties;
for (int i = 0; i < array.Length; i++)
{
EditorCurveBinding binding = array[i];
state.SaveCurve(AnimationWindowUtility.CreateDefaultCurve(activeAnimationClip, activeRootGameObject, binding));
}
}
private static void AddRotationPropertyModification(IAnimationRecordingState state, UndoPropertyModification modification)
{
if (modification.previousValue == null)
{
return;
}
EditorCurveBinding binding = default(EditorCurveBinding);
if (AnimationUtility.PropertyModificationToEditorCurveBinding(modification.previousValue, state.activeRootGameObject, out binding) != null)
{
AnimationMode.AddPropertyModification(binding, modification.previousValue, modification.keepPrefabOverride);
}
}
static void ProcessAnimatorModification(IAnimationRecordingState state, Animator animator, UndoPropertyModification modification, string name, float value, float scale)
{
AnimationClip clip = state.activeAnimationClip;
if ((clip.hideFlags & HideFlags.NotEditable) != 0)
{
return;
}
float prevValue = value;
object oValue;
if (ValueFromPropertyModification(modification.currentValue, new EditorCurveBinding(), out oValue))
{
value = (float)oValue;
}
if (ValueFromPropertyModification(modification.previousValue, new EditorCurveBinding(), out oValue))
{
prevValue = (float)oValue;
}
value = Mathf.Abs(scale) > Mathf.Epsilon ? value / scale : value;
prevValue = Mathf.Abs(scale) > Mathf.Epsilon ? prevValue / scale : prevValue;
var binding = new EditorCurveBinding();
binding.propertyName = name;
binding.path = "";
binding.type = typeof(Animator);
var prop = new PropertyModification();
prop.target = animator;
prop.propertyPath = binding.propertyName;
prop.value = value.ToString();
state.AddPropertyModification(binding, prop, modification.keepPrefabOverride);
AnimationWindowCurve curve = new AnimationWindowCurve(clip, binding, typeof(float));
if (state.addZeroFrame && state.currentFrame != 0 && curve.length == 0)
{
AnimationWindowUtility.AddKeyframeToCurve(curve, prevValue, typeof(float), AnimationKeyTime.Frame(0, clip.frameRate));
}
AnimationWindowUtility.AddKeyframeToCurve(curve, value, typeof(float), AnimationKeyTime.Frame(state.currentFrame, clip.frameRate));
state.SaveCurve(curve);
}
public static UndoPropertyModification[] ProcessModifications(IAnimationRecordingState state, UndoPropertyModification[] modifications)
{
AnimationClip activeAnimationClip = state.activeAnimationClip;
GameObject activeRootGameObject = state.activeRootGameObject;
Animator component = activeRootGameObject.GetComponent <Animator>();
UndoPropertyModification[] result = AnimationRecording.FilterModifications(state, ref modifications);
int i = 0;
while (i < modifications.Length)
{
EditorCurveBinding binding = default(EditorCurveBinding);
PropertyModification previousValue = modifications[i].previousValue;
Type type = AnimationUtility.PropertyModificationToEditorCurveBinding(previousValue, activeRootGameObject, out binding);
if (type != null)
{
if (component != null && component.isHuman && binding.type == typeof(Transform) && component.gameObject.transform != previousValue.target && component.IsBoneTransform(previousValue.target as Transform))
{
Debug.LogWarning("Keyframing for humanoid rig is not supported!", previousValue.target as Transform);
}
else
{
EditorCurveBinding[] array = RotationCurveInterpolation.RemapAnimationBindingForAddKey(binding, activeAnimationClip);
if (array != null)
{
for (int j = 0; j < array.Length; j++)
{
PropertyModification propertyModification = AnimationRecording.FindPropertyModification(activeRootGameObject, modifications, array[j]);
if (propertyModification == null)
{
propertyModification = AnimationRecording.CreateDummyPropertyModification(activeRootGameObject, previousValue, array[j]);
}
state.AddPropertyModification(array[j], propertyModification, modifications[i].keepPrefabOverride);
AnimationRecording.AddKey(state, array[j], type, propertyModification);
}
}
else
{
state.AddPropertyModification(binding, previousValue, modifications[i].keepPrefabOverride);
AnimationRecording.AddKey(state, binding, type, previousValue);
}
}
}
IL_19A:
i++;
continue;
goto IL_19A;
}
return(result);
}
private static void CollectVector3Modifications(IAnimationRecordingState state, ref UndoPropertyModification[] modifications, ref Dictionary <object, AnimationRecording.Vector3Modification> vector3Modifications, string propertyName)
{
List <UndoPropertyModification> list = new List <UndoPropertyModification>();
UndoPropertyModification[] array = modifications;
for (int i = 0; i < array.Length; i++)
{
UndoPropertyModification undoPropertyModification = array[i];
PropertyModification previousValue = undoPropertyModification.previousValue;
if (!(previousValue.target is Transform))
{
list.Add(undoPropertyModification);
}
else
{
EditorCurveBinding editorCurveBinding = default(EditorCurveBinding);
AnimationUtility.PropertyModificationToEditorCurveBinding(previousValue, state.activeRootGameObject, out editorCurveBinding);
if (editorCurveBinding.propertyName.StartsWith(propertyName))
{
AnimationRecording.Vector3Modification vector3Modification;
if (!vector3Modifications.TryGetValue(previousValue.target, out vector3Modification))
{
vector3Modification = new AnimationRecording.Vector3Modification();
vector3Modifications[previousValue.target] = vector3Modification;
}
if (editorCurveBinding.propertyName.EndsWith("x"))
{
vector3Modification.x = undoPropertyModification;
}
else if (editorCurveBinding.propertyName.EndsWith("y"))
{
vector3Modification.y = undoPropertyModification;
}
else if (editorCurveBinding.propertyName.EndsWith("z"))
{
vector3Modification.z = undoPropertyModification;
}
vector3Modification.last = undoPropertyModification;
}
else
{
list.Add(undoPropertyModification);
}
}
}
if (vector3Modifications.Count > 0)
{
modifications = list.ToArray();
}
}
static private void AddRotationPropertyModification(IAnimationRecordingState state, EditorCurveBinding baseBinding, UndoPropertyModification modification)
{
if (modification.previousValue == null)
{
return;
}
// case 817356. Reuse baseBinding as basis for rotation binding.
// This is needed to register valid bindings for m_LocalEulerAnglesHint
// that cannot be converted to EditorCurveBinding otherwise.
EditorCurveBinding binding = baseBinding;
binding.propertyName = modification.previousValue.propertyPath;
state.AddPropertyModification(binding, modification.previousValue, modification.keepPrefabOverride);
}
internal static bool ShowAtPosition(Rect buttonRect, IAnimationRecordingState state, OnNewCurveAdded newCurveCallback)
{
long num = DateTime.Now.Ticks / 0x2710L;
if (num >= (s_LastClosedTime + 50L))
{
Event.current.Use();
if (s_AddCurvesPopup == null)
{
s_AddCurvesPopup = ScriptableObject.CreateInstance<AddCurvesPopup>();
}
NewCurveAddedCallback = newCurveCallback;
s_State = state;
s_AddCurvesPopup.Init(buttonRect);
return true;
}
return false;
}
public static void ProcessModifications(IAnimationRecordingState state, UndoPropertyModification[] modifications)
{
AnimationClip activeAnimationClip = state.activeAnimationClip;
GameObject activeRootGameObject = state.activeRootGameObject;
for (int i = 0; i < modifications.Length; i++)
{
EditorCurveBinding binding = default(EditorCurveBinding);
PropertyModification previousValue = modifications[i].previousValue;
Type type = AnimationUtility.PropertyModificationToEditorCurveBinding(previousValue, activeRootGameObject, out binding);
if (type != null)
{
state.AddPropertyModification(binding, previousValue, modifications[i].keepPrefabOverride);
AnimationRecording.AddKey(state, binding, type, previousValue);
}
}
}
private static void ProcessVector3Modification(IAnimationRecordingState state, EditorCurveBinding baseBinding, UndoPropertyModification modification, Transform target, string axis)
{
EditorCurveBinding editorCurveBinding = baseBinding;
PropertyModification propertyModification = modification.previousValue;
editorCurveBinding.propertyName = editorCurveBinding.propertyName.Remove(editorCurveBinding.propertyName.Length - 1, 1) + axis;
if (propertyModification == null)
{
propertyModification = new PropertyModification();
propertyModification.target = target;
propertyModification.propertyPath = editorCurveBinding.propertyName;
object currentValue = CurveBindingUtility.GetCurrentValue(state.activeRootGameObject, editorCurveBinding);
propertyModification.value = ((float)currentValue).ToString();
}
state.AddPropertyModification(editorCurveBinding, propertyModification, modification.keepPrefabOverride);
AnimationRecording.AddKey(state, editorCurveBinding, typeof(float), propertyModification);
}
internal static bool ShowAtPosition(Rect buttonRect, IAnimationRecordingState state, AddCurvesPopup.OnNewCurveAdded newCurveCallback)
{
long num = DateTime.Now.Ticks / 10000L;
if (num >= AddCurvesPopup.s_LastClosedTime + 50L)
{
Event.current.Use();
if (AddCurvesPopup.s_AddCurvesPopup == null)
{
AddCurvesPopup.s_AddCurvesPopup = ScriptableObject.CreateInstance <AddCurvesPopup>();
}
AddCurvesPopup.NewCurveAddedCallback = newCurveCallback;
AddCurvesPopup.s_State = state;
AddCurvesPopup.s_AddCurvesPopup.Init(buttonRect);
return(true);
}
return(false);
}
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[] bindingArray = RotationCurveInterpolation.RemapAnimationBindingForRotationAddKey(binding, activeAnimationClip);
for (int i = 0; i < 3; i++)
{
AnimationWindowCurve curve = new AnimationWindowCurve(activeAnimationClip, bindingArray[i], type);
if ((curve.length == 0) && (state.frame != 0))
{
AnimationWindowUtility.AddKeyframeToCurve(curve, previousEulerAngles[i], type, AnimationKeyTime.Frame(0, activeAnimationClip.frameRate));
}
AnimationWindowUtility.AddKeyframeToCurve(curve, currentEulerAngles[i], type, AnimationKeyTime.Frame(state.frame, activeAnimationClip.frameRate));
state.SaveCurve(curve);
}
}
}
static public void ProcessModifications(IAnimationRecordingState state, UndoPropertyModification[] modifications)
{
AnimationClip clip = state.activeAnimationClip;
GameObject root = state.activeRootGameObject;
// Record modified properties
for (int i = 0; i < modifications.Length; i++)
{
EditorCurveBinding binding = new EditorCurveBinding();
PropertyModification prop = modifications[i].previousValue;
Type type = AnimationUtility.PropertyModificationToEditorCurveBinding(prop, root, out binding);
if (type != null)
{
state.AddPropertyModification(binding, prop, modifications[i].keepPrefabOverride);
AddKey(state, binding, type, prop);
}
}
}
static private void ProcessVector3Modification(IAnimationRecordingState state, EditorCurveBinding baseBinding, UndoPropertyModification modification, Transform target, string axis)
{
var binding = baseBinding;
var property = modification.previousValue;
binding.propertyName = binding.propertyName.Remove(binding.propertyName.Length - 1, 1) + axis;
if (property == null)
{
// create dummy
property = new PropertyModification();
property.target = target;
property.propertyPath = binding.propertyName;
object currentValue = CurveBindingUtility.GetCurrentValue(state.activeRootGameObject, binding);
property.value = ((float)currentValue).ToString();
}
state.AddPropertyModification(binding, property, modification.keepPrefabOverride);
AddKey(state, binding, typeof(float), property);
}
public static UndoPropertyModification[] Process(IAnimationRecordingState state, UndoPropertyModification[] modifications)
{
GameObject activeRootGameObject = state.activeRootGameObject;
UndoPropertyModification[] result;
if (activeRootGameObject == null)
{
result = modifications;
}
else if (!AnimationRecording.HasAnyRecordableModifications(activeRootGameObject, modifications))
{
result = modifications;
}
else
{
UndoPropertyModification[] first = AnimationRecording.ProcessRotationModifications(state, ref modifications);
UndoPropertyModification[] second = AnimationRecording.ProcessModifications(state, modifications);
result = first.Concat(second).ToArray <UndoPropertyModification>();
}
return(result);
}
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 curve = new AnimationWindowCurve(activeAnimationClip, binding, type);
object currentValue = CurveBindingUtility.GetCurrentValue(activeRootGameObject, binding);
if (curve.length == 0)
{
object outObject = null;
if (!ValueFromPropertyModification(modification, binding, out outObject))
{
outObject = currentValue;
}
if (state.frame != 0)
{
AnimationWindowUtility.AddKeyframeToCurve(curve, outObject, type, AnimationKeyTime.Frame(0, activeAnimationClip.frameRate));
}
}
AnimationWindowUtility.AddKeyframeToCurve(curve, currentValue, type, AnimationKeyTime.Frame(state.frame, activeAnimationClip.frameRate));
state.SaveCurve(curve);
}
}
public static UndoPropertyModification[] Process(IAnimationRecordingState state, UndoPropertyModification[] modifications)
{
GameObject activeRootGameObject = state.activeRootGameObject;
if (activeRootGameObject == null)
{
return modifications;
}
AnimationClip activeAnimationClip = state.activeAnimationClip;
Animator component = activeRootGameObject.GetComponent<Animator>();
if (!HasAnyRecordableModifications(activeRootGameObject, modifications))
{
return modifications;
}
ProcessRotationModifications(state, ref modifications);
List<UndoPropertyModification> list = new List<UndoPropertyModification>();
for (int i = 0; i < modifications.Length; i++)
{
EditorCurveBinding binding = new EditorCurveBinding();
PropertyModification previousValue = modifications[i].previousValue;
Type type = AnimationUtility.PropertyModificationToEditorCurveBinding(previousValue, activeRootGameObject, out binding);
if (type != null)
{
if (((component != null) && component.isHuman) && ((binding.type == typeof(Transform)) && component.IsBoneTransform(previousValue.target as Transform)))
{
Debug.LogWarning("Keyframing for humanoid rig is not supported!", previousValue.target as Transform);
}
else
{
AnimationMode.AddPropertyModification(binding, previousValue, modifications[i].keepPrefabOverride);
EditorCurveBinding[] bindingArray = RotationCurveInterpolation.RemapAnimationBindingForAddKey(binding, activeAnimationClip);
if (bindingArray != null)
{
for (int j = 0; j < bindingArray.Length; j++)
{
AddKey(state, bindingArray[j], type, FindPropertyModification(activeRootGameObject, modifications, bindingArray[j]));
}
}
else
{
AddKey(state, binding, type, previousValue);
}
}
}
else
{
list.Add(modifications[i]);
}
}
return list.ToArray();
}
private static void CollectRotationModifications(IAnimationRecordingState state, ref UndoPropertyModification[] modifications, ref Dictionary<object, RotationModification> rotationModifications)
{
List<UndoPropertyModification> list = new List<UndoPropertyModification>();
foreach (UndoPropertyModification modification in modifications)
{
EditorCurveBinding binding = new EditorCurveBinding();
PropertyModification previousValue = modification.previousValue;
AnimationUtility.PropertyModificationToEditorCurveBinding(previousValue, state.activeRootGameObject, out binding);
if (binding.propertyName.StartsWith("m_LocalRotation"))
{
RotationModification modification3;
if (!rotationModifications.TryGetValue(previousValue.target, out modification3))
{
modification3 = new RotationModification();
rotationModifications[previousValue.target] = modification3;
}
if (binding.propertyName.EndsWith("x"))
{
modification3.x = modification;
}
else if (binding.propertyName.EndsWith("y"))
{
modification3.y = modification;
}
else if (binding.propertyName.EndsWith("z"))
{
modification3.z = modification;
}
else if (binding.propertyName.EndsWith("w"))
{
modification3.w = modification;
}
modification3.lastQuatModification = modification;
}
else if (previousValue.propertyPath.StartsWith("m_LocalEulerAnglesHint"))
{
RotationModification modification4;
if (!rotationModifications.TryGetValue(previousValue.target, out modification4))
{
modification4 = new RotationModification();
rotationModifications[previousValue.target] = modification4;
}
modification4.useEuler = true;
if (previousValue.propertyPath.EndsWith("x"))
{
modification4.eulerX = modification;
}
else if (previousValue.propertyPath.EndsWith("y"))
{
modification4.eulerY = modification;
}
else if (previousValue.propertyPath.EndsWith("z"))
{
modification4.eulerZ = modification;
}
}
else
{
list.Add(modification);
}
}
if (rotationModifications.Count > 0)
{
modifications = list.ToArray();
}
}
private static void ProcessRotationModifications(IAnimationRecordingState state, ref UndoPropertyModification[] modifications)
{
Dictionary<object, RotationModification> rotationModifications = new Dictionary<object, RotationModification>();
CollectRotationModifications(state, ref modifications, ref rotationModifications);
foreach (KeyValuePair<object, RotationModification> pair in rotationModifications)
{
RotationModification modification = pair.Value;
Transform key = pair.Key as Transform;
if (key != null)
{
EditorCurveBinding binding = new EditorCurveBinding();
Type type = AnimationUtility.PropertyModificationToEditorCurveBinding(modification.lastQuatModification.currentValue, state.activeRootGameObject, out binding);
if (type != null)
{
AddRotationPropertyModification(state, binding, modification.x);
AddRotationPropertyModification(state, binding, modification.y);
AddRotationPropertyModification(state, binding, modification.z);
AddRotationPropertyModification(state, binding, modification.w);
if (modification.useEuler)
{
object obj2;
object obj3;
object obj4;
AddRotationPropertyModification(state, binding, modification.eulerX);
AddRotationPropertyModification(state, binding, modification.eulerY);
AddRotationPropertyModification(state, binding, modification.eulerZ);
Vector3 localEulerAngles = key.GetLocalEulerAngles(RotationOrder.OrderZXY);
Vector3 currentEulerAngles = key.GetLocalEulerAngles(RotationOrder.OrderZXY);
if (ValueFromPropertyModification(modification.eulerX.previousValue, binding, out obj2))
{
localEulerAngles.x = (float) obj2;
}
if (ValueFromPropertyModification(modification.eulerY.previousValue, binding, out obj3))
{
localEulerAngles.y = (float) obj3;
}
if (ValueFromPropertyModification(modification.eulerZ.previousValue, binding, out obj4))
{
localEulerAngles.z = (float) obj4;
}
if (ValueFromPropertyModification(modification.eulerX.currentValue, binding, out obj2))
{
currentEulerAngles.x = (float) obj2;
}
if (ValueFromPropertyModification(modification.eulerY.currentValue, binding, out obj3))
{
currentEulerAngles.y = (float) obj3;
}
if (ValueFromPropertyModification(modification.eulerZ.currentValue, binding, out obj4))
{
currentEulerAngles.z = (float) obj4;
}
AddRotationKey(state, binding, type, localEulerAngles, currentEulerAngles);
}
else
{
object obj5;
object obj6;
object obj7;
object obj8;
Quaternion localRotation = key.localRotation;
Quaternion quaternion2 = key.localRotation;
if (ValueFromPropertyModification(modification.x.previousValue, binding, out obj5))
{
localRotation.x = (float) obj5;
}
if (ValueFromPropertyModification(modification.y.previousValue, binding, out obj6))
{
localRotation.y = (float) obj6;
}
if (ValueFromPropertyModification(modification.z.previousValue, binding, out obj7))
{
localRotation.z = (float) obj7;
}
if (ValueFromPropertyModification(modification.w.previousValue, binding, out obj8))
{
localRotation.w = (float) obj8;
}
if (ValueFromPropertyModification(modification.x.currentValue, binding, out obj5))
{
quaternion2.x = (float) obj5;
}
if (ValueFromPropertyModification(modification.y.currentValue, binding, out obj6))
{
quaternion2.y = (float) obj6;
}
if (ValueFromPropertyModification(modification.z.currentValue, binding, out obj7))
{
quaternion2.z = (float) obj7;
}
if (ValueFromPropertyModification(modification.w.currentValue, binding, out obj8))
{
quaternion2.w = (float) obj8;
}
AddRotationKey(state, binding, type, localRotation.eulerAngles, quaternion2.eulerAngles);
}
}
}
}
}
