public static State GetCurveState(AnimationClip clip, EditorCurveBinding[] selection)
{
State state;
state.allAreNonBaked = true;
state.allAreBaked = false;
state.allAreRotations = false;
foreach (EditorCurveBinding binding in selection)
{
switch (GetModeFromCurveData(binding))
{
case Mode.NonBaked:
state.allAreNonBaked = false;
break;
case Mode.Baked:
state.allAreBaked = false;
break;
default:
state.allAreRotations = false;
break;
}
}
return state;
}
public KeyIdentifier(CurveRenderer _renderer, int _curveId, int _keyIndex, EditorCurveBinding _binding)
{
this.renderer = _renderer;
this.curveId = _curveId;
this.key = _keyIndex;
this.binding = _binding;
}
public static RotationCurveInterpolation.State GetCurveState(AnimationClip clip, EditorCurveBinding[] selection)
{
RotationCurveInterpolation.State result;
result.allAreNonBaked = true;
result.allAreBaked = false;
result.allAreRotations = false;
for (int i = 0; i < selection.Length; i++)
{
EditorCurveBinding data = selection[i];
RotationCurveInterpolation.Mode modeFromCurveData = RotationCurveInterpolation.GetModeFromCurveData(data);
if (modeFromCurveData == RotationCurveInterpolation.Mode.NonBaked)
{
result.allAreNonBaked = false;
}
else
{
if (modeFromCurveData == RotationCurveInterpolation.Mode.Baked)
{
result.allAreBaked = false;
}
else
{
result.allAreRotations = false;
}
}
}
return result;
}
private static void PrepareHierarchy(EditorCurveBinding curveBinding)
{
GameObject orGetGameObject = CurveBindingUtility.CreateOrGetGameObject(curveBinding.path);
if (!((UnityEngine.Object) orGetGameObject.GetComponent(curveBinding.type) == (UnityEngine.Object) null))
return;
orGetGameObject.AddComponent(curveBinding.type);
}
private TreeViewItem AddAnimatableObjectToHierarchy(GameObject root, EditorCurveBinding[] curveBindings, TreeViewItem parentNode, string path)
{
TreeViewItem item = new AddCurvesPopupObjectNode(parentNode, path, GetClassName(root, curveBindings[0])) {
icon = AssetPreview.GetMiniThumbnail(AnimationUtility.GetAnimatedObject(root, curveBindings[0]))
};
List<TreeViewItem> visibleItems = new List<TreeViewItem>();
List<EditorCurveBinding> list2 = new List<EditorCurveBinding>();
for (int i = 0; i < curveBindings.Length; i++)
{
EditorCurveBinding binding = curveBindings[i];
list2.Add(binding);
if ((i == (curveBindings.Length - 1)) || (AnimationWindowUtility.GetPropertyGroupName(curveBindings[i + 1].propertyName) != AnimationWindowUtility.GetPropertyGroupName(binding.propertyName)))
{
TreeViewItem item2 = this.CreateNode(list2.ToArray(), item);
if (item2 != null)
{
visibleItems.Add(item2);
}
list2.Clear();
}
}
visibleItems.Sort();
TreeViewUtility.SetChildParentReferences(visibleItems, item);
return item;
}
public KeyIdentifier(AnimationCurve _curve, int _curveId, int _keyIndex, EditorCurveBinding _binding)
{
this.curve = _curve;
this.curveId = _curveId;
this.key = _keyIndex;
this.binding = _binding;
}
public static void CreateDefaultCurves(AnimationWindowState state, EditorCurveBinding[] properties)
{
AnimationClip activeAnimationClip = state.activeAnimationClip;
GameObject activeRootGameObject = state.activeRootGameObject;
properties = RotationCurveInterpolation.ConvertRotationPropertiesToDefaultInterpolation(state.activeAnimationClip, properties);
foreach (EditorCurveBinding property in properties)
state.SaveCurve(AnimationWindowUtility.CreateDefaultCurve(activeAnimationClip, activeRootGameObject, property));
}
public static void SetEditorCurve(AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve)
{
AnimationUtility.Internal_SetEditorCurve(clip, binding, curve);
if (AnimationUtility.onCurveWasModified != null)
{
AnimationUtility.onCurveWasModified(clip, binding, (curve == null) ? AnimationUtility.CurveModifiedType.CurveDeleted : AnimationUtility.CurveModifiedType.CurveModified);
}
}
public static System.Type GetEditorCurveValueType(GameObject rootGameObject, EditorCurveBinding curveBinding)
{
if (rootGameObject != null)
{
return AnimationUtility.GetEditorCurveValueType(rootGameObject, curveBinding);
}
return GetEditorCurveValueType(curveBinding);
}
public static object GetCurrentValue(GameObject rootGameObject, EditorCurveBinding curveBinding)
{
if (rootGameObject != null)
{
return AnimationWindowUtility.GetCurrentValue(rootGameObject, curveBinding);
}
return GetCurrentValue(curveBinding);
}
public static void SetObjectReferenceCurve(AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes)
{
AnimationUtility.Internal_SetObjectReferenceCurve(clip, binding, keyframes);
if (AnimationUtility.onCurveWasModified != null)
{
AnimationUtility.onCurveWasModified(clip, binding, (keyframes == null) ? AnimationUtility.CurveModifiedType.CurveDeleted : AnimationUtility.CurveModifiedType.CurveModified);
}
}
public static int GetCurveGroupID(AnimationClip clip, EditorCurveBinding curveData)
{
if (curveData.type != typeof (Transform))
return -1;
int num = !((UnityEngine.Object) clip == (UnityEngine.Object) null) ? clip.GetInstanceID() : 0;
string str = curveData.propertyName.Substring(0, curveData.propertyName.Length - 1);
return num * 19603 ^ curveData.path.GetHashCode() * 729 ^ curveData.type.GetHashCode() * 27 ^ str.GetHashCode();
}
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 AnimationClipCurveData(EditorCurveBinding binding)
{
this.path = binding.path;
this.type = binding.type;
this.propertyName = binding.propertyName;
this.curve = (AnimationCurve) null;
this.classID = binding.m_ClassID;
this.scriptInstanceID = binding.m_ScriptInstanceID;
}
private static EditorCurveBinding[] GenerateTransformCurveBindingArray(string path, string property, System.Type type, int count)
{
EditorCurveBinding[] bindingArray = new EditorCurveBinding[count];
for (int i = 0; i < count; i++)
{
bindingArray[i] = EditorCurveBinding.FloatCurve(path, type, property + kPostFix[i]);
}
return bindingArray;
}
public static int GetCurveGroupID(AnimationClip clip, EditorCurveBinding curveData)
{
if (curveData.type != typeof(Transform))
{
return -1;
}
int num = (clip != null) ? clip.GetInstanceID() : 0;
string str = curveData.propertyName.Substring(0, curveData.propertyName.Length - 1);
return ((((num * 0x4c93) ^ (curveData.path.GetHashCode() * 0x2d9)) ^ (curveData.type.GetHashCode() * 0x1b)) ^ str.GetHashCode());
}
public static RotationCurveInterpolation.Mode GetModeFromCurveData(EditorCurveBinding data)
{
if (AnimationWindowUtility.IsTransformType(data.type) && data.propertyName.StartsWith("localEulerAngles"))
{
if (data.propertyName.StartsWith("localEulerAnglesBaked"))
return RotationCurveInterpolation.Mode.Baked;
return data.propertyName.StartsWith("localEulerAnglesRaw") ? RotationCurveInterpolation.Mode.RawEuler : RotationCurveInterpolation.Mode.NonBaked;
}
return AnimationWindowUtility.IsTransformType(data.type) && data.propertyName.StartsWith("m_LocalRotation") ? RotationCurveInterpolation.Mode.RawQuaternions : RotationCurveInterpolation.Mode.Undefined;
}
public static int GetCurveGroupID(AnimationClip clip, EditorCurveBinding curveData)
{
if (curveData.type != typeof(Transform))
{
return -1;
}
int num = (!(clip == null)) ? clip.GetInstanceID() : 0;
string text = curveData.propertyName.Substring(0, curveData.propertyName.Length - 1);
return num * 19603 ^ curveData.path.GetHashCode() * 729 ^ curveData.type.GetHashCode() * 27 ^ text.GetHashCode();
}
public static void CreateDefaultCurves(AnimationWindowState state, EditorCurveBinding[] properties)
{
AnimationClip activeAnimationClip = state.m_ActiveAnimationClip;
GameObject rootGameObject = state.m_RootGameObject;
properties = RotationCurveInterpolation.ConvertRotationPropertiesToDefaultInterpolation(state.m_ActiveAnimationClip, properties);
EditorCurveBinding[] array = properties;
for (int i = 0; i < array.Length; i++)
{
EditorCurveBinding binding = array[i];
state.SaveCurve(AnimationWindowUtility.CreateDefaultCurve(activeAnimationClip, rootGameObject, binding));
}
}
internal static EditorCurveBinding[] ConvertRotationPropertiesToInterpolationType(EditorCurveBinding[] selection, Mode newInterpolationMode)
{
if ((selection.Length == 4) && (GetModeFromCurveData(selection[0]) == Mode.RawQuaternions))
{
EditorCurveBinding[] bindingArray = new EditorCurveBinding[] { selection[0], selection[1], selection[2] };
string prefixForInterpolation = GetPrefixForInterpolation(newInterpolationMode);
bindingArray[0].propertyName = prefixForInterpolation + ".x";
bindingArray[1].propertyName = prefixForInterpolation + ".y";
bindingArray[2].propertyName = prefixForInterpolation + ".z";
return bindingArray;
}
return selection;
}
private void ChangeRotationInterpolation(object interpolationMode)
{
RotationCurveInterpolation.Mode newInterpolationMode = (RotationCurveInterpolation.Mode) ((int) interpolationMode);
AnimationWindowCurve[] curveArray = this.state.activeCurves.ToArray();
EditorCurveBinding[] curveBindings = new EditorCurveBinding[curveArray.Length];
for (int i = 0; i < curveArray.Length; i++)
{
curveBindings[i] = curveArray[i].binding;
}
RotationCurveInterpolation.SetInterpolation(this.state.activeAnimationClip, curveBindings, newInterpolationMode);
this.MaintainTreeviewStateAfterRotationInterpolation(newInterpolationMode);
this.state.hierarchyData.ReloadData();
}
private static PropertyModification FindPropertyModification(GameObject root, UndoPropertyModification[] modifications, EditorCurveBinding binding)
{
for (int i = 0; i < modifications.Length; i++)
{
EditorCurveBinding lhs;
AnimationUtility.PropertyModificationToEditorCurveBinding(modifications[i].propertyModification, root, out lhs);
if (lhs == binding)
{
return modifications[i].propertyModification;
}
}
return null;
}
private static PropertyModification FindPropertyModification(GameObject root, UndoPropertyModification[] modifications, EditorCurveBinding binding)
{
for (int index = 0; index < modifications.Length; ++index)
{
if (modifications[index].currentValue == null || !(modifications[index].currentValue.target is Animator))
{
EditorCurveBinding binding1;
AnimationUtility.PropertyModificationToEditorCurveBinding(modifications[index].previousValue, root, out binding1);
if (binding1 == binding)
return modifications[index].previousValue;
}
}
return (PropertyModification) null;
}
private void FillModelWithCurves(EditorCurveBinding[] curves)
{
foreach (EditorCurveBinding curveData in curves) {
string key = curveData.path;
if (paths.ContainsKey(key)) {
((ArrayList)paths[key]).Add(curveData);
} else {
ArrayList newProperties = new ArrayList();
newProperties.Add(curveData);
paths.Add(key, newProperties);
pathsKeys.Add(key);
}
}
}
private static void CollectRotationModifications(AnimationWindowState state, ref UndoPropertyModification[] modifications, ref Dictionary<object, AnimationRecording.RotationModification> rotationModifications)
{
List<UndoPropertyModification> propertyModificationList = new List<UndoPropertyModification>();
foreach (UndoPropertyModification propertyModification in modifications)
{
EditorCurveBinding binding = new EditorCurveBinding();
PropertyModification previousValue = propertyModification.previousValue;
AnimationUtility.PropertyModificationToEditorCurveBinding(previousValue, state.activeRootGameObject, out binding);
if (binding.propertyName.StartsWith("m_LocalRotation"))
{
AnimationRecording.RotationModification rotationModification;
if (!rotationModifications.TryGetValue((object) previousValue.target, out rotationModification))
{
rotationModification = new AnimationRecording.RotationModification();
rotationModifications[(object) previousValue.target] = rotationModification;
}
if (binding.propertyName.EndsWith("x"))
rotationModification.x = propertyModification;
else if (binding.propertyName.EndsWith("y"))
rotationModification.y = propertyModification;
else if (binding.propertyName.EndsWith("z"))
rotationModification.z = propertyModification;
else if (binding.propertyName.EndsWith("w"))
rotationModification.w = propertyModification;
rotationModification.lastQuatModification = propertyModification;
}
else if (previousValue.propertyPath.StartsWith("m_LocalEulerAnglesHint"))
{
AnimationRecording.RotationModification rotationModification;
if (!rotationModifications.TryGetValue((object) previousValue.target, out rotationModification))
{
rotationModification = new AnimationRecording.RotationModification();
rotationModifications[(object) previousValue.target] = rotationModification;
}
if (previousValue.propertyPath.EndsWith("x"))
rotationModification.eulerX = propertyModification;
else if (previousValue.propertyPath.EndsWith("y"))
rotationModification.eulerY = propertyModification;
else if (previousValue.propertyPath.EndsWith("z"))
rotationModification.eulerZ = propertyModification;
}
else
propertyModificationList.Add(propertyModification);
}
if (propertyModificationList.Count <= 0)
return;
modifications = propertyModificationList.ToArray();
}
internal static EditorCurveBinding[] ConvertRotationPropertiesToInterpolationType(EditorCurveBinding[] selection, RotationCurveInterpolation.Mode newInterpolationMode)
{
if (selection.Length != 4 || RotationCurveInterpolation.GetModeFromCurveData(selection[0]) != RotationCurveInterpolation.Mode.RawQuaternions)
return selection;
EditorCurveBinding[] editorCurveBindingArray = new EditorCurveBinding[3]
{
selection[0],
selection[1],
selection[2]
};
string forInterpolation = RotationCurveInterpolation.GetPrefixForInterpolation(newInterpolationMode);
editorCurveBindingArray[0].propertyName = forInterpolation + ".x";
editorCurveBindingArray[1].propertyName = forInterpolation + ".y";
editorCurveBindingArray[2].propertyName = forInterpolation + ".z";
return editorCurveBindingArray;
}
private static PropertyModification FindPropertyModification(GameObject root, UndoPropertyModification[] modifications, EditorCurveBinding binding)
{
for (int i = 0; i < modifications.Length; i++)
{
if (!(modifications[i].currentValue.target is Animator))
{
EditorCurveBinding binding2;
AnimationUtility.PropertyModificationToEditorCurveBinding(modifications[i].previousValue, root, out binding2);
if (binding2 == binding)
{
return modifications[i].previousValue;
}
}
}
return null;
}
public static AnimationWindowCurve CreateDefaultCurve(AnimationClip clip, GameObject rootGameObject, EditorCurveBinding binding)
{
Type editorCurveValueType = AnimationUtility.GetEditorCurveValueType(rootGameObject, binding);
AnimationWindowCurve animationWindowCurve = new AnimationWindowCurve(clip, binding, editorCurveValueType);
object currentValue = AnimationWindowUtility.GetCurrentValue(rootGameObject, binding);
if (clip.length == 0f)
{
AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, currentValue, editorCurveValueType, AnimationKeyTime.Time(0f, clip.frameRate));
}
else
{
AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, currentValue, editorCurveValueType, AnimationKeyTime.Time(0f, clip.frameRate));
AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, currentValue, editorCurveValueType, AnimationKeyTime.Time(clip.length, clip.frameRate));
}
return animationWindowCurve;
}
public static RotationCurveInterpolation.State GetCurveState(AnimationClip clip, EditorCurveBinding[] selection)
{
RotationCurveInterpolation.State state;
state.allAreRaw = true;
state.allAreNonBaked = true;
state.allAreBaked = true;
state.allAreRotations = true;
foreach (EditorCurveBinding data in selection)
{
RotationCurveInterpolation.Mode modeFromCurveData = RotationCurveInterpolation.GetModeFromCurveData(data);
state.allAreBaked &= modeFromCurveData == RotationCurveInterpolation.Mode.Baked;
state.allAreNonBaked &= modeFromCurveData == RotationCurveInterpolation.Mode.NonBaked;
state.allAreRaw &= modeFromCurveData == RotationCurveInterpolation.Mode.RawEuler;
state.allAreRotations &= modeFromCurveData != RotationCurveInterpolation.Mode.Undefined;
}
return state;
}
static AnimationClip Duplicate(AnimationClip src, AnimationClip dest)
{
AnimationClipCurveData[] curveDatas = AnimationUtility.GetAllCurves(src, true);
foreach(var data in curveDatas)
{
EditorCurveBinding curve = new EditorCurveBinding();
curve.path = data.path;
curve.type = data.type;
curve.propertyName = data.propertyName;
AnimationUtility.SetEditorCurve(
dest,
curve,
data.curve
);
}
return dest;
}
public static Type GetEditorCurveValueType(GameObject root, EditorCurveBinding binding)
{
return(AnimationUtility.INTERNAL_CALL_GetEditorCurveValueType(root, ref binding));
}
// Binds the property and returns the type of the bound value (Can be used to display special UI for it and to enforce correct drag and drop)
// null if it can't be bound.
public static System.Type GetEditorCurveValueType(GameObject root, EditorCurveBinding binding)
{
return(Internal_GetGameObjectEditorCurveValueType(root, binding));
}
private static extern AnimationCurve INTERNAL_CALL_GetEditorCurve(AnimationClip clip, ref EditorCurveBinding binding);
public ChangedCurve(AnimationCurve curve, int curveId, EditorCurveBinding binding)
{
this.curve = curve;
this.curveId = curveId;
this.binding = binding;
}
public static extern Type PropertyModificationToEditorCurveBinding(PropertyModification modification, GameObject gameObject, out EditorCurveBinding binding);
extern public static ObjectReferenceKeyframe[] GetObjectReferenceCurve([NotNull] AnimationClip clip, EditorCurveBinding binding);
extern private static void Internal_SetObjectReferenceCurve([NotNull] AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes, bool updateMuscleClip);
private static void Internal_SetObjectReferenceCurve(AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes)
{
AnimationUtility.INTERNAL_CALL_Internal_SetObjectReferenceCurve(clip, ref binding, keyframes);
}
private static extern bool INTERNAL_CALL_GetFloatValue(GameObject root, ref EditorCurveBinding binding, out float data);
public static bool GetFloatValue(GameObject root, EditorCurveBinding binding, out float data)
{
return(AnimationUtility.INTERNAL_CALL_GetFloatValue(root, ref binding, out data));
}
public static AnimationCurve GetEditorCurve(AnimationClip clip, string relativePath, Type type, string propertyName)
{
return(AnimationUtility.GetEditorCurve(clip, EditorCurveBinding.FloatCurve(relativePath, type, propertyName)));
}
public static void SetEditorCurve(AnimationClip clip, string relativePath, Type type, string propertyName, AnimationCurve curve)
{
AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(relativePath, type, propertyName), curve);
}
private static extern void INTERNAL_CALL_Internal_SetEditorCurve(AnimationClip clip, ref EditorCurveBinding binding, AnimationCurve curve, bool syncEditorCurve);
private static void Internal_SetEditorCurve(AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve, bool syncEditorCurve)
{
AnimationUtility.INTERNAL_CALL_Internal_SetEditorCurve(clip, ref binding, curve, syncEditorCurve);
}
extern public static AnimationCurve GetEditorCurve([NotNull] AnimationClip clip, EditorCurveBinding binding);
private static extern void INTERNAL_CALL_Internal_SetObjectReferenceCurve(AnimationClip clip, ref EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes);
internal static void SetObjectReferenceCurveNoSync(AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes)
{
Internal_SetObjectReferenceCurve(clip, binding, keyframes, false);
Internal_InvokeOnCurveWasModified(clip, binding, keyframes != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
}
extern private static void Internal_SetEditorCurve([NotNull] AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve, bool syncEditorCurves);
private static extern ObjectReferenceKeyframe[] INTERNAL_CALL_GetObjectReferenceCurve(AnimationClip clip, ref EditorCurveBinding binding);
public static bool GetObjectReferenceValue(GameObject root, EditorCurveBinding binding, out UnityEngine.Object targetObject)
{
return(AnimationUtility.INTERNAL_CALL_GetObjectReferenceValue(root, ref binding, out targetObject));
}
public static ObjectReferenceKeyframe[] GetObjectReferenceCurve(AnimationClip clip, EditorCurveBinding binding)
{
return(AnimationUtility.INTERNAL_CALL_GetObjectReferenceCurve(clip, ref binding));
}
private static extern bool INTERNAL_CALL_GetObjectReferenceValue(GameObject root, ref EditorCurveBinding binding, out UnityEngine.Object targetObject);
private static extern UnityEngine.Object INTERNAL_CALL_GetAnimatedObject(GameObject root, ref EditorCurveBinding binding);
public static UnityEngine.Object GetAnimatedObject(GameObject root, EditorCurveBinding binding)
{
return(AnimationUtility.INTERNAL_CALL_GetAnimatedObject(root, ref binding));
}
private static extern Type INTERNAL_CALL_GetEditorCurveValueType(GameObject root, ref EditorCurveBinding binding);
public static AnimationCurve GetEditorCurve(AnimationClip clip, EditorCurveBinding binding)
{
return(AnimationUtility.INTERNAL_CALL_GetEditorCurve(clip, ref binding));
}
internal static Type GetScriptableObjectEditorCurveValueType(ScriptableObject scriptableObject, EditorCurveBinding binding)
{
return(AnimationUtility.INTERNAL_CALL_GetScriptableObjectEditorCurveValueType(scriptableObject, ref binding));
}
private static extern Type INTERNAL_CALL_GetScriptableObjectEditorCurveValueType(ScriptableObject scriptableObject, ref EditorCurveBinding binding);
public static bool GetFloatValue(GameObject root, string relativePath, Type type, string propertyName, out float data)
{
return(AnimationUtility.GetFloatValue(root, EditorCurveBinding.FloatCurve(relativePath, type, propertyName), out data));
}
internal static void SetEditorCurveNoSync(AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve)
{
Internal_SetEditorCurve(clip, binding, curve, false);
Internal_InvokeOnCurveWasModified(clip, binding, curve != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
}
