public SimpleKeyFrame(int frame, float value)
{
this.frame = frame;
this.value = value;
left = CONSTANT;
right = CONSTANT;
}
public AnimationCurveData(AnimationUtility.TangentMode tangentMode, glTFAnimationTarget.AnimationProperties property, int samplerIndex, int elementCount)
{
TangentMode = tangentMode;
AnimationProperty = property;
SamplerIndex = samplerIndex;
ElementCount = elementCount;
}
static void SetKeyRightTangentMode(SerializedProperty keyframeInfo, AnimationUtility.TangentMode tangentMode)
{
var tangentModeProp = keyframeInfo.FindPropertyRelative("tangentMode");
tangentModeProp.intValue &= ~kRightTangentMask;
tangentModeProp.intValue |= (int)tangentMode << 5;
}
public void SetBoth(AnimationUtility.TangentMode mode, List <KeyIdentifier> keysToSet)
{
List <ChangedCurve> list = new List <ChangedCurve>();
foreach (KeyIdentifier current in keysToSet)
{
AnimationCurve curve = current.curve;
Keyframe keyframe = current.keyframe;
AnimationUtility.SetKeyBroken(ref keyframe, false);
AnimationUtility.SetKeyRightTangentMode(ref keyframe, mode);
AnimationUtility.SetKeyLeftTangentMode(ref keyframe, mode);
if (mode == AnimationUtility.TangentMode.Free)
{
float num = CurveUtility.CalculateSmoothTangent(keyframe);
keyframe.inTangent = num;
keyframe.outTangent = num;
}
curve.MoveKey(current.key, keyframe);
AnimationUtility.UpdateTangentsFromModeSurrounding(curve, current.key);
ChangedCurve item = new ChangedCurve(curve, current.curveId, current.binding);
if (!list.Contains(item))
{
list.Add(item);
}
}
this.updater.UpdateCurves(list, "Set Tangents");
}
public AnimationCurveData(AnimationUtility.TangentMode tangentMode, GLTFAnimationTarget.AnimationProperty property, int samplerIndex, int elementCount)
{
this.tangentMode = tangentMode;
animationProperty = property;
this.samplerIndex = samplerIndex;
this.elementCount = elementCount;
}
/// <summary>
/// set an animation curbe to a linear curve, or other type of tangentMode
/// use: ExtReflexion.SetAnimationCurveTangentMode(_animationCurve, AnimationUtility.TangentMode.Linear);
/// </summary>
/// <param name="curve"></param>
/// <param name=""></param>
public static void SetAnimationCurveTangentMode(AnimationCurve curve, AnimationUtility.TangentMode tangentMode)
{
for (int i = 0; i < curve.length; i++)
{
AnimationUtility.SetKeyLeftTangentMode(curve, i, tangentMode);
AnimationUtility.SetKeyRightTangentMode(curve, i, tangentMode);
}
}
public static void SetKeyModeFromContext(AnimationCurve curve, int keyIndex)
{
Keyframe key = curve[keyIndex];
bool flag = false;
bool flag2 = false;
if (keyIndex > 0)
{
if (AnimationUtility.GetKeyBroken(curve[keyIndex - 1]))
{
flag = true;
}
if (AnimationUtility.GetKeyRightTangentMode(curve[keyIndex - 1]) == AnimationUtility.TangentMode.ClampedAuto)
{
flag2 = true;
}
}
if (keyIndex < curve.length - 1)
{
if (AnimationUtility.GetKeyBroken(curve[keyIndex + 1]))
{
flag = true;
}
if (AnimationUtility.GetKeyLeftTangentMode(curve[keyIndex + 1]) == AnimationUtility.TangentMode.ClampedAuto)
{
flag2 = true;
}
}
AnimationUtility.SetKeyBroken(ref key, flag);
if (flag && !flag2)
{
if (keyIndex > 0)
{
AnimationUtility.SetKeyLeftTangentMode(ref key, AnimationUtility.GetKeyRightTangentMode(curve[keyIndex - 1]));
}
if (keyIndex < curve.length - 1)
{
AnimationUtility.SetKeyRightTangentMode(ref key, AnimationUtility.GetKeyLeftTangentMode(curve[keyIndex + 1]));
}
}
else
{
AnimationUtility.TangentMode tangentMode = AnimationUtility.TangentMode.Free;
if ((keyIndex == 0 || AnimationUtility.GetKeyRightTangentMode(curve[keyIndex - 1]) == AnimationUtility.TangentMode.ClampedAuto) && (keyIndex == curve.length - 1 || AnimationUtility.GetKeyLeftTangentMode(curve[keyIndex + 1]) == AnimationUtility.TangentMode.ClampedAuto))
{
tangentMode = AnimationUtility.TangentMode.ClampedAuto;
}
else if ((keyIndex == 0 || AnimationUtility.GetKeyRightTangentMode(curve[keyIndex - 1]) == AnimationUtility.TangentMode.Auto) && (keyIndex == curve.length - 1 || AnimationUtility.GetKeyLeftTangentMode(curve[keyIndex + 1]) == AnimationUtility.TangentMode.Auto))
{
tangentMode = AnimationUtility.TangentMode.Auto;
}
AnimationUtility.SetKeyLeftTangentMode(ref key, tangentMode);
AnimationUtility.SetKeyRightTangentMode(ref key, tangentMode);
}
curve.MoveKey(keyIndex, key);
}
public static void SetKeyModeFromContext(AnimationCurve curve, int keyIndex)
{
Keyframe key = curve[keyIndex];
bool broken = false;
bool flag2 = false;
if (keyIndex > 0)
{
if (AnimationUtility.GetKeyBroken(curve[keyIndex - 1]))
{
broken = true;
}
if (AnimationUtility.GetKeyRightTangentMode(curve[keyIndex - 1]) == AnimationUtility.TangentMode.ClampedAuto)
{
flag2 = true;
}
}
if (keyIndex < (curve.length - 1))
{
if (AnimationUtility.GetKeyBroken(curve[keyIndex + 1]))
{
broken = true;
}
if (AnimationUtility.GetKeyLeftTangentMode(curve[keyIndex + 1]) == AnimationUtility.TangentMode.ClampedAuto)
{
flag2 = true;
}
}
AnimationUtility.SetKeyBroken(ref key, broken);
if (broken && !flag2)
{
if (keyIndex > 0)
{
AnimationUtility.SetKeyLeftTangentMode(ref key, AnimationUtility.GetKeyRightTangentMode(curve[keyIndex - 1]));
}
if (keyIndex < (curve.length - 1))
{
AnimationUtility.SetKeyRightTangentMode(ref key, AnimationUtility.GetKeyLeftTangentMode(curve[keyIndex + 1]));
}
}
else
{
AnimationUtility.TangentMode free = AnimationUtility.TangentMode.Free;
if (((keyIndex == 0) || (AnimationUtility.GetKeyRightTangentMode(curve[keyIndex - 1]) == AnimationUtility.TangentMode.ClampedAuto)) && ((keyIndex == (curve.length - 1)) || (AnimationUtility.GetKeyLeftTangentMode(curve[keyIndex + 1]) == AnimationUtility.TangentMode.ClampedAuto)))
{
free = AnimationUtility.TangentMode.ClampedAuto;
}
else if (((keyIndex == 0) || (AnimationUtility.GetKeyRightTangentMode(curve[keyIndex - 1]) == AnimationUtility.TangentMode.Auto)) && ((keyIndex == (curve.length - 1)) || (AnimationUtility.GetKeyLeftTangentMode(curve[keyIndex + 1]) == AnimationUtility.TangentMode.Auto)))
{
free = AnimationUtility.TangentMode.Auto;
}
AnimationUtility.SetKeyLeftTangentMode(ref key, free);
AnimationUtility.SetKeyRightTangentMode(ref key, free);
}
curve.MoveKey(keyIndex, key);
}
private static bool CanExportTangentModeAsSpline(AnimationUtility.TangentMode tangentMode)
{
switch (tangentMode)
{
case AnimationUtility.TangentMode.Auto:
case AnimationUtility.TangentMode.ClampedAuto:
case AnimationUtility.TangentMode.Free:
return(true);
}
return(false);
}
public void ToggleWeighted(WeightedMode weightedMode, List <KeyIdentifier> keysToSet)
{
bool flag = keysToSet.TrueForAll((KeyIdentifier key) => (key.keyframe.weightedMode & weightedMode) == weightedMode);
List <ChangedCurve> list = new List <ChangedCurve>();
foreach (KeyIdentifier current in keysToSet)
{
AnimationCurve curve = current.curve;
Keyframe keyframe = current.keyframe;
bool flag2 = (keyframe.weightedMode & weightedMode) == weightedMode;
if (flag2 == flag)
{
WeightedMode weightedMode2 = keyframe.weightedMode;
keyframe.weightedMode = ((!flag2) ? (keyframe.weightedMode | weightedMode) : (keyframe.weightedMode & ~weightedMode));
if (keyframe.weightedMode != WeightedMode.None)
{
AnimationUtility.TangentMode keyRightTangentMode = AnimationUtility.GetKeyRightTangentMode(keyframe);
AnimationUtility.TangentMode keyLeftTangentMode = AnimationUtility.GetKeyLeftTangentMode(keyframe);
if ((weightedMode2 & WeightedMode.Out) == WeightedMode.None && (keyframe.weightedMode & WeightedMode.Out) == WeightedMode.Out)
{
if (keyRightTangentMode == AnimationUtility.TangentMode.Linear || keyRightTangentMode == AnimationUtility.TangentMode.Constant)
{
AnimationUtility.SetKeyRightTangentMode(ref keyframe, AnimationUtility.TangentMode.Free);
}
if (current.key < curve.length - 1)
{
keyframe.outWeight = 0.333333343f;
}
}
if ((weightedMode2 & WeightedMode.In) == WeightedMode.None && (keyframe.weightedMode & WeightedMode.In) == WeightedMode.In)
{
if (keyLeftTangentMode == AnimationUtility.TangentMode.Linear || keyLeftTangentMode == AnimationUtility.TangentMode.Constant)
{
AnimationUtility.SetKeyLeftTangentMode(ref keyframe, AnimationUtility.TangentMode.Free);
}
if (current.key > 0)
{
keyframe.inWeight = 0.333333343f;
}
}
}
curve.MoveKey(current.key, keyframe);
AnimationUtility.UpdateTangentsFromModeSurrounding(curve, current.key);
ChangedCurve item = new ChangedCurve(curve, current.curveId, current.binding);
if (!list.Contains(item))
{
list.Add(item);
}
}
}
this.updater.UpdateCurves(list, "Toggle Weighted");
}
public static int TangentModeToHoudiniRampInterpolation(AnimationUtility.TangentMode tangentMode)
{
if (tangentMode == AnimationUtility.TangentMode.Constant)
{
return(0);
}
else if (tangentMode == AnimationUtility.TangentMode.Linear)
{
return(1);
}
// Use Catmull-Rom for all smooth interpolation
return(2);
}
public void SetTangent(int leftRight, AnimationUtility.TangentMode mode, List <KeyIdentifier> keysToSet)
{
List <ChangedCurve> list = new List <ChangedCurve>();
foreach (KeyIdentifier current in keysToSet)
{
AnimationCurve curve = current.curve;
Keyframe keyframe = current.keyframe;
AnimationUtility.SetKeyBroken(ref keyframe, true);
if (leftRight == 2)
{
AnimationUtility.SetKeyLeftTangentMode(ref keyframe, mode);
AnimationUtility.SetKeyRightTangentMode(ref keyframe, mode);
}
else if (leftRight == 0)
{
AnimationUtility.SetKeyLeftTangentMode(ref keyframe, mode);
if (AnimationUtility.GetKeyRightTangentMode(keyframe) == AnimationUtility.TangentMode.ClampedAuto || AnimationUtility.GetKeyRightTangentMode(keyframe) == AnimationUtility.TangentMode.Auto)
{
AnimationUtility.SetKeyRightTangentMode(ref keyframe, AnimationUtility.TangentMode.Free);
}
}
else
{
AnimationUtility.SetKeyRightTangentMode(ref keyframe, mode);
if (AnimationUtility.GetKeyLeftTangentMode(keyframe) == AnimationUtility.TangentMode.ClampedAuto || AnimationUtility.GetKeyLeftTangentMode(keyframe) == AnimationUtility.TangentMode.Auto)
{
AnimationUtility.SetKeyLeftTangentMode(ref keyframe, AnimationUtility.TangentMode.Free);
}
}
if (mode == AnimationUtility.TangentMode.Constant && (leftRight == 0 || leftRight == 2))
{
keyframe.inTangent = float.PositiveInfinity;
}
if (mode == AnimationUtility.TangentMode.Constant && (leftRight == 1 || leftRight == 2))
{
keyframe.outTangent = float.PositiveInfinity;
}
curve.MoveKey(current.key, keyframe);
AnimationUtility.UpdateTangentsFromModeSurrounding(curve, current.key);
ChangedCurve item = new ChangedCurve(curve, current.curveId, current.binding);
if (!list.Contains(item))
{
list.Add(item);
}
}
this.updater.UpdateCurves(list, "Set Tangents");
}
public static void SetAnimationCurveTangentModes(AnimationCurve animCurve, List <int> tangentValues)
{
#if UNITY_EDITOR
AnimationUtility.TangentMode leftTangent = AnimationUtility.TangentMode.Free;
AnimationUtility.TangentMode rightTangent = AnimationUtility.TangentMode.Free;
for (int i = 0; i < tangentValues.Count; ++i)
{
if (i > 0)
{
leftTangent = rightTangent;
}
rightTangent = HEU_HAPIUtility.HoudiniRampInterpolationToTangentMode(tangentValues[i]);
AnimationUtility.SetKeyLeftTangentMode(animCurve, i, leftTangent);
AnimationUtility.SetKeyRightTangentMode(animCurve, i, rightTangent);
}
#endif
}
public static void SetKeyRightTangentMode(AnimationCurve curve, int index, AnimationUtility.TangentMode tangentMode)
{
if (curve == null)
{
throw new ArgumentNullException("curve");
}
if (index < 0 || index >= curve.length)
{
throw new ArgumentException("Index out of bounds.");
}
Keyframe key = curve[index];
if (tangentMode != AnimationUtility.TangentMode.Free)
{
AnimationUtility.SetKeyBroken(ref key, true);
}
AnimationUtility.SetKeyRightTangentMode(ref key, tangentMode);
curve.MoveKey(index, key);
AnimationUtility.UpdateTangentsFromModeSurrounding(curve, index);
}
public static void SetKeyRightTangentMode(AnimationCurve curve, int index, AnimationUtility.TangentMode tangentMode)
{
if (curve == null)
{
throw new ArgumentNullException("curve");
}
if (index < 0 || index >= curve.length)
{
throw new ArgumentOutOfRangeException("index", string.Format("Index ({0}) must be in the range of 0 to {1}.", index, curve.length - 1));
}
Keyframe key = curve[index];
if (tangentMode != AnimationUtility.TangentMode.Free)
{
AnimationUtility.SetKeyBroken(ref key, true);
}
AnimationUtility.SetKeyRightTangentMode(ref key, tangentMode);
curve.MoveKey(index, key);
AnimationUtility.UpdateTangentsFromModeSurrounding(curve, index);
}
public static void SetKeyRightTangentMode(AnimationCurve curve, int index, AnimationUtility.TangentMode tangentMode)
{
if (curve == null)
{
throw new ArgumentNullException("curve");
}
if (index < 0 || index >= curve.length)
{
return;
}
Keyframe key = curve[index];
if (tangentMode != AnimationUtility.TangentMode.Free)
{
key.tangentMode |= AnimationUtility.kBrokenMask;
}
key.tangentMode &= ~AnimationUtility.kRightTangentMask;
key.tangentMode |= (int)((int)tangentMode << 3);
curve.MoveKey(index, key);
AnimationUtility.Internal_UpdateTangents(curve, index);
}
internal static void SetKeyRightTangentMode(ref Keyframe key, AnimationUtility.TangentMode tangentMode)
{
key.tangentMode &= ~AnimationUtility.kRightTangentMask;
key.tangentMode |= (int)((int)tangentMode << 5);
}
public static void AddAnimationKey(float frameRate, AnimationCurve curve, int frame, float value, AnimationUtility.TangentMode left, AnimationUtility.TangentMode right)
{
AnimationKeyTime a = FrameToAnimationKey(frame, frameRate);
int idx = curve.AddKey(new Keyframe(a.Time, value));
AnimationUtility.SetKeyLeftTangentMode(curve, idx, left);
AnimationUtility.SetKeyRightTangentMode(curve, idx, right);
}
public void AddTangentMenuItems(GenericMenu menu, List <KeyIdentifier> keyList)
{
bool flag = keyList.Count > 0;
bool on = flag;
bool on2 = flag;
bool on3 = flag;
bool on4 = flag;
bool on5 = flag;
bool flag2 = flag;
bool flag3 = flag;
bool on6 = flag;
bool flag4 = flag;
bool flag5 = flag;
bool flag6 = flag;
bool on7 = flag;
bool flag7 = flag;
foreach (KeyIdentifier current in keyList)
{
Keyframe keyframe = current.keyframe;
AnimationUtility.TangentMode keyLeftTangentMode = AnimationUtility.GetKeyLeftTangentMode(keyframe);
AnimationUtility.TangentMode keyRightTangentMode = AnimationUtility.GetKeyRightTangentMode(keyframe);
bool keyBroken = AnimationUtility.GetKeyBroken(keyframe);
if (keyLeftTangentMode != AnimationUtility.TangentMode.ClampedAuto || keyRightTangentMode != AnimationUtility.TangentMode.ClampedAuto)
{
on = false;
}
if (keyLeftTangentMode != AnimationUtility.TangentMode.Auto || keyRightTangentMode != AnimationUtility.TangentMode.Auto)
{
on2 = false;
}
if (keyBroken || keyLeftTangentMode != AnimationUtility.TangentMode.Free || keyRightTangentMode != AnimationUtility.TangentMode.Free)
{
on3 = false;
}
if (keyBroken || keyLeftTangentMode != AnimationUtility.TangentMode.Free || keyframe.inTangent != 0f || keyRightTangentMode != AnimationUtility.TangentMode.Free || keyframe.outTangent != 0f)
{
on4 = false;
}
if (!keyBroken)
{
on5 = false;
}
if (!keyBroken || keyLeftTangentMode != AnimationUtility.TangentMode.Free)
{
flag3 = false;
}
if (!keyBroken || keyLeftTangentMode != AnimationUtility.TangentMode.Linear)
{
on6 = false;
}
if (!keyBroken || keyLeftTangentMode != AnimationUtility.TangentMode.Constant)
{
flag4 = false;
}
if (!keyBroken || keyRightTangentMode != AnimationUtility.TangentMode.Free)
{
flag6 = false;
}
if (!keyBroken || keyRightTangentMode != AnimationUtility.TangentMode.Linear)
{
on7 = false;
}
if (!keyBroken || keyRightTangentMode != AnimationUtility.TangentMode.Constant)
{
flag7 = false;
}
if ((keyframe.weightedMode & WeightedMode.In) == WeightedMode.None)
{
flag2 = false;
}
if ((keyframe.weightedMode & WeightedMode.Out) == WeightedMode.None)
{
flag5 = false;
}
}
if (flag)
{
menu.AddItem(EditorGUIUtility.TrTextContent("Clamped Auto", null, null), on, new GenericMenu.MenuFunction2(this.SetClampedAuto), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Auto", null, null), on2, new GenericMenu.MenuFunction2(this.SetAuto), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Free Smooth", null, null), on3, new GenericMenu.MenuFunction2(this.SetEditable), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Flat", null, null), on4, new GenericMenu.MenuFunction2(this.SetFlat), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Broken", null, null), on5, new GenericMenu.MenuFunction2(this.SetBroken), keyList);
menu.AddSeparator("");
menu.AddItem(EditorGUIUtility.TrTextContent("Left Tangent/Free", null, null), flag3, new GenericMenu.MenuFunction2(this.SetLeftEditable), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Left Tangent/Linear", null, null), on6, new GenericMenu.MenuFunction2(this.SetLeftLinear), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Left Tangent/Constant", null, null), flag4, new GenericMenu.MenuFunction2(this.SetLeftConstant), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Left Tangent/Weighted", null, null), flag2, new GenericMenu.MenuFunction2(this.ToggleLeftWeighted), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Right Tangent/Linear", null, null), on7, new GenericMenu.MenuFunction2(this.SetRightLinear), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Right Tangent/Constant", null, null), flag7, new GenericMenu.MenuFunction2(this.SetRightConstant), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Both Tangents/Free", null, null), flag6 && flag3, new GenericMenu.MenuFunction2(this.SetBothEditable), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Right Tangent/Weighted", null, null), flag5, new GenericMenu.MenuFunction2(this.ToggleRightWeighted), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Both Tangents/Constant", null, null), flag7 && flag4, new GenericMenu.MenuFunction2(this.SetBothConstant), keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Both Tangents/Weighted", null, null), flag5 && flag2, new GenericMenu.MenuFunction2(this.ToggleBothWeighted), keyList);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Weighted", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Auto", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Free Smooth", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Flat", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Broken", null, null));
menu.AddSeparator("");
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Left Tangent/Free", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Left Tangent/Linear", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Left Tangent/Constant", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Right Tangent/Free", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Right Tangent/Linear", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Right Tangent/Constant", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Both Tangents/Free", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Both Tangents/Linear", null, null));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Both Tangents/Constant", null, null));
}
}
private static extern void Internal_SetKeyRightTangentMode(ref Keyframe key, AnimationUtility.TangentMode tangentMode);
public AnimationCurveData(AnimationUtility.TangentMode tangentMode, glTFAnimationTarget.AnimationPropertys property, int samplerIndex)
{
TangentMode = tangentMode;
AnimationProperty = property;
SamplerIndex = samplerIndex;
}
internal static void SetKeyRightTangentMode(ref Keyframe key, AnimationUtility.TangentMode tangentMode)
{
AnimationUtility.Internal_SetKeyRightTangentMode(ref key, tangentMode);
}
public AnimationCurveData(AnimationUtility.TangentMode tangentMode, glTFAnimationTarget.AnimationPropertys property, int samplerIndex, int elementCount)
: this(tangentMode, glTFAnimationTarget.AnimationPropertysToAnimationProperties(property), samplerIndex, elementCount)
{
}
public UnityGradientToCurveWindow(ColorGradient colorGradient)
{
this.colorGradient = colorGradient;
this.gradient = new Gradient();
this.mode = AnimationUtility.TangentMode.Linear;
}
public void AddTangentMenuItems(GenericMenu menu, List <KeyIdentifier> keyList)
{
bool flag = keyList.Count > 0;
bool on = flag;
bool flag3 = flag;
bool flag4 = flag;
bool flag5 = flag;
bool flag6 = flag;
bool flag7 = flag;
bool flag8 = flag;
bool flag9 = flag;
bool flag10 = flag;
bool flag11 = flag;
bool flag12 = flag;
foreach (KeyIdentifier identifier in keyList)
{
Keyframe key = identifier.keyframe;
AnimationUtility.TangentMode keyLeftTangentMode = AnimationUtility.GetKeyLeftTangentMode(key);
AnimationUtility.TangentMode keyRightTangentMode = AnimationUtility.GetKeyRightTangentMode(key);
bool keyBroken = AnimationUtility.GetKeyBroken(key);
if ((keyLeftTangentMode != AnimationUtility.TangentMode.ClampedAuto) || (keyRightTangentMode != AnimationUtility.TangentMode.ClampedAuto))
{
on = false;
}
if ((keyLeftTangentMode != AnimationUtility.TangentMode.Auto) || (keyRightTangentMode != AnimationUtility.TangentMode.Auto))
{
flag3 = false;
}
if ((keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Free)) || (keyRightTangentMode != AnimationUtility.TangentMode.Free))
{
flag4 = false;
}
if ((keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Free)) || (((key.inTangent != 0f) || (keyRightTangentMode != AnimationUtility.TangentMode.Free)) || (key.outTangent != 0f)))
{
flag5 = false;
}
if (!keyBroken)
{
flag6 = false;
}
if (!keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Free))
{
flag7 = false;
}
if (!keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Linear))
{
flag8 = false;
}
if (!keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Constant))
{
flag9 = false;
}
if (!keyBroken || (keyRightTangentMode != AnimationUtility.TangentMode.Free))
{
flag10 = false;
}
if (!keyBroken || (keyRightTangentMode != AnimationUtility.TangentMode.Linear))
{
flag11 = false;
}
if (!keyBroken || (keyRightTangentMode != AnimationUtility.TangentMode.Constant))
{
flag12 = false;
}
}
if (flag)
{
menu.AddItem(EditorGUIUtility.TextContent("Clamped Auto"), on, new GenericMenu.MenuFunction2(this.SetClampedAuto), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Auto"), flag3, new GenericMenu.MenuFunction2(this.SetAuto), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Free Smooth"), flag4, new GenericMenu.MenuFunction2(this.SetEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Flat"), flag5, new GenericMenu.MenuFunction2(this.SetFlat), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Broken"), flag6, new GenericMenu.MenuFunction2(this.SetBroken), keyList);
menu.AddSeparator("");
menu.AddItem(EditorGUIUtility.TextContent("Left Tangent/Free"), flag7, new GenericMenu.MenuFunction2(this.SetLeftEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Left Tangent/Linear"), flag8, new GenericMenu.MenuFunction2(this.SetLeftLinear), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Left Tangent/Constant"), flag9, new GenericMenu.MenuFunction2(this.SetLeftConstant), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Right Tangent/Free"), flag10, new GenericMenu.MenuFunction2(this.SetRightEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Right Tangent/Linear"), flag11, new GenericMenu.MenuFunction2(this.SetRightLinear), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Right Tangent/Constant"), flag12, new GenericMenu.MenuFunction2(this.SetRightConstant), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Both Tangents/Free"), flag10 && flag7, new GenericMenu.MenuFunction2(this.SetBothEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Both Tangents/Linear"), flag11 && flag8, new GenericMenu.MenuFunction2(this.SetBothLinear), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Both Tangents/Constant"), flag12 && flag9, new GenericMenu.MenuFunction2(this.SetBothConstant), keyList);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TextContent("Clamped Auto"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Auto"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Free Smooth"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Flat"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Broken"));
menu.AddSeparator("");
menu.AddDisabledItem(EditorGUIUtility.TextContent("Left Tangent/Free"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Left Tangent/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Left Tangent/Constant"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Right Tangent/Free"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Right Tangent/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Right Tangent/Constant"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Both Tangents/Free"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Both Tangents/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Both Tangents/Constant"));
}
}
public override void OnGUI(Rect rect)
{
var position = MarginRect(rect, 5);
position.height = EditorGUIUtility.singleLineHeight;
position.y += EditorGUIUtility.standardVerticalSpacing;
EditorGUI.LabelField(position, "Unity Gradient");
position.y += LineHeight;
EditorGUI.GradientField(IndentPosition(position), gradient);
position.y += LineHeight;
EditorGUI.LabelField(position, "Tangent Mode");
position.y += LineHeight;
mode = (AnimationUtility.TangentMode)EditorGUI.EnumPopup(IndentPosition(position), mode);
position.y += LineHeight;
EditorGUI.LabelField(position, "import");
position.y += LineHeight;
if (GUI.Button(IndentPosition(position), "x"))
{
var(v0, v1, v2) = GetCurves();
colorGradient.shareColorMode = false;
colorGradient.axes[0].xCurve = v0;
colorGradient.axes[1].xCurve = v1;
colorGradient.axes[2].xCurve = v2;
editorWindow.Close();
}
position.y += LineHeight;
if (colorGradient.axesCount == 2)
{
if (GUI.Button(IndentPosition(position), "y"))
{
var(v0, v1, v2) = GetCurves();
colorGradient.shareColorMode = false;
colorGradient.axes[0].yCurve = v0;
colorGradient.axes[1].yCurve = v1;
colorGradient.axes[2].yCurve = v2;
editorWindow.Close();
}
position.y += LineHeight;
if (GUI.Button(IndentPosition(position), "x, y"))
{
var(v0, v1, v2) = GetCurves();
colorGradient.shareColorMode = false;
colorGradient.axes[0].xCurve = v0;
colorGradient.axes[1].xCurve = v1;
colorGradient.axes[2].xCurve = v2;
colorGradient.axes[0].yCurve = new AnimationCurve((Keyframe[])v0.keys.Clone());
colorGradient.axes[1].yCurve = new AnimationCurve((Keyframe[])v1.keys.Clone());
colorGradient.axes[2].yCurve = new AnimationCurve((Keyframe[])v2.keys.Clone());
editorWindow.Close();
}
position.y += LineHeight;
}
}
public static void SetKeyRightTangentMode(AnimationCurve curve, int index, AnimationUtility.TangentMode tangentMode)
{
AnimationUtility.VerifyCurveAndKeyframeIndex(curve, index);
AnimationUtility.SetKeyRightTangentModeInternal(curve, index, tangentMode);
}
public static extern void SetKeyRightTangentMode([NotNull] AnimationCurve curve, int index, AnimationUtility.TangentMode tangentMode);
private static extern void INTERNAL_CALL_SetKeyRightTangentMode(ref Keyframe key, AnimationUtility.TangentMode tangentMode);
private static extern void SetKeyRightTangentModeInternal(AnimationCurve curve, int index, AnimationUtility.TangentMode tangentMode);
