|
public MoveKey ( int index, |
||
| index | int | The index of the key to move. |
| key | The key (with its new time) to insert. | |
| return | int | |
public static void SetLinear(ref AnimationCurve curve) {
for (int i = 0; i < curve.length; i++) {
Keyframe boxed = curve.keys[i]; // getting around the fact that Keyframe is a struct by pre-boxing
boxed.tangentMode = GetNewTangentKeyMode(boxed.tangentMode, TangentDirection.Left, TangentMode.Linear);
boxed.tangentMode = GetNewTangentKeyMode(boxed.tangentMode, TangentDirection.Right, TangentMode.Linear);
curve.MoveKey(i, (Keyframe)boxed);
curve.SmoothTangents(i, 0f);
}
}
static public int MoveKey(IntPtr l)
{
try {
#if DEBUG
var method = System.Reflection.MethodBase.GetCurrentMethod();
string methodName = GetMethodName(method);
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.BeginSample(methodName);
#else
Profiler.BeginSample(methodName);
#endif
#endif
UnityEngine.AnimationCurve self = (UnityEngine.AnimationCurve)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
UnityEngine.Keyframe a2;
checkValueType(l, 3, out a2);
var ret = self.MoveKey(a1, a2);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
#if DEBUG
finally {
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.EndSample();
#else
Profiler.EndSample();
#endif
}
#endif
}
// UnityEditor.CurveUtility.cs (c) Unity Technologies
public static void UpdateTangentsFromMode(AnimationCurve curve, int index)
{
if (index < 0 || index >= curve.length)
return;
Keyframe key = curve [index];
if (KeyframeUtil.GetKeyTangentMode (key, 0) == TangentMode.Linear && index >= 1) {
key.inTangent = CalculateLinearTangent (curve, index, index - 1);
curve.MoveKey (index, key);
}
if (KeyframeUtil.GetKeyTangentMode (key, 1) == TangentMode.Linear && index + 1 < curve.length) {
key.outTangent = CalculateLinearTangent (curve, index, index + 1);
curve.MoveKey (index, key);
}
if (KeyframeUtil.GetKeyTangentMode (key, 0) != TangentMode.Smooth && KeyframeUtil.GetKeyTangentMode (key, 1) != TangentMode.Smooth)
return;
curve.SmoothTangents (index, 0.0f);
}
static public int MoveKey(IntPtr l)
{
try {
UnityEngine.AnimationCurve self = (UnityEngine.AnimationCurve)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
UnityEngine.Keyframe a2;
checkValueType(l, 3, out a2);
var ret = self.MoveKey(a1, a2);
pushValue(l, ret);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static int MoveKey(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
UnityEngine.AnimationCurve obj = (UnityEngine.AnimationCurve)ToLua.CheckObject(L, 1, typeof(UnityEngine.AnimationCurve));
int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
UnityEngine.Keyframe arg1 = (UnityEngine.Keyframe)ToLua.CheckObject(L, 3, typeof(UnityEngine.Keyframe));
int o = obj.MoveKey(arg0, arg1);
LuaDLL.lua_pushinteger(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
/// <summary>
/// Adds the keyframe to curve.
/// </summary>
/// <param name="animationCurve">Animation curve.</param>
/// <param name="animatedClip">Animated clip.</param>
/// <param name="binding">Binding.</param>
/// <param name="value">Value.</param>
/// <param name="type">Type.</param>
/// <param name="time">Time.</param>
public static void AddKeyframeToCurve(AnimationCurve animationCurve, AnimationClip animatedClip, EditorCurveBinding binding, float value, Type type, float time)
{
//frame comparing (frame=(int)(time*animatedClip.frameRate)
int keyframeIndex = Array.FindIndex (animationCurve.keys, (itm) => (int)(itm.time * animatedClip.frameRate) == (int)(time * animatedClip.frameRate));
Keyframe key = default(Keyframe);
if (keyframeIndex < 0) {
if (type == typeof(bool) || type == typeof(float)) {
key = new Keyframe (time, value);
if (type == typeof(bool)) {
//CurveUtility.SetKeyTangentMode (ref key, 0, TangentMode.Stepped);
//CurveUtility.SetKeyTangentMode (ref key, 1, TangentMode.Stepped);
//CurveUtility.SetKeyBroken (ref key, true);
key.SetKeyTangentMode (0, TangentMode.Stepped);
key.SetKeyTangentMode (1, TangentMode.Stepped);
key.SetKeyBroken (true);
} else {
int num = animationCurve.AddKey (key);
if (num != -1) {
animationCurve.SetKeyModeFromContext (num);
}
}
}
} else {
//??? maybe I should add new time too
//animationCurve.keys[keyframeIndex].value=value;
key = animationCurve.keys [keyframeIndex];
key.value = value;
animationCurve.MoveKey (keyframeIndex, key);
}
//Save changes
SaveCurve (animationCurve, animatedClip, binding);
}
void SetKeyframe(AnimationCurve curve, int keyframeIndex, Keyframe newValue)
{
var keys = curve.keys;
if (keyframeIndex > 0)
newValue.time = Mathf.Max(keys[keyframeIndex - 1].time + settings.keyTimeClampingDistance, newValue.time);
if (keyframeIndex < keys.Length - 1)
newValue.time = Mathf.Min(keys[keyframeIndex + 1].time - settings.keyTimeClampingDistance, newValue.time);
curve.MoveKey(keyframeIndex, newValue);
Invalidate();
}
public static void SetKeyModeFromContext(AnimationCurve curve, int keyIndex)
{
Keyframe key = curve[keyIndex];
bool broken = false;
if ((keyIndex > 0) && GetKeyBroken(curve[keyIndex - 1]))
{
broken = true;
}
if ((keyIndex < (curve.length - 1)) && GetKeyBroken(curve[keyIndex + 1]))
{
broken = true;
}
SetKeyBroken(ref key, broken);
if (broken)
{
if (keyIndex > 0)
{
SetKeyTangentMode(ref key, 0, GetKeyTangentMode(curve[keyIndex - 1], 1));
}
if (keyIndex < (curve.length - 1))
{
SetKeyTangentMode(ref key, 1, GetKeyTangentMode(curve[keyIndex + 1], 0));
}
}
else
{
TangentMode smooth = TangentMode.Smooth;
if ((keyIndex > 0) && (GetKeyTangentMode(curve[keyIndex - 1], 1) != TangentMode.Smooth))
{
smooth = TangentMode.Editable;
}
if ((keyIndex < (curve.length - 1)) && (GetKeyTangentMode(curve[keyIndex + 1], 0) != TangentMode.Smooth))
{
smooth = TangentMode.Editable;
}
SetKeyTangentMode(ref key, 0, smooth);
SetKeyTangentMode(ref key, 1, smooth);
}
curve.MoveKey(keyIndex, key);
}
void OnGUI()
{
bool isCurveChanged = false;
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true), GUILayout.Height(50));
EditorGUILayout.LabelField("Click _curve to edit ->", GUILayout.ExpandWidth(false));
EditorGUI.BeginChangeCheck();
_curve = EditorGUILayout.CurveField(_curve, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
if (EditorGUI.EndChangeCheck())
{
isCurveChanged = true;
}
GUILayout.EndHorizontal();
EditorGUILayout.Separator();
EditorGUILayout.Separator();
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
EditorGUILayout.LabelField("Nr.", GUILayout.MinWidth(20.0f));
EditorGUILayout.LabelField("X", GUILayout.MinWidth(50.0f));
EditorGUILayout.LabelField("Y", GUILayout.MinWidth(50.0f));
EditorGUILayout.LabelField("inTangent", GUILayout.MinWidth(50.0f));
EditorGUILayout.LabelField("outTangent", GUILayout.MinWidth(50.0f));
GUILayout.EndHorizontal();
for (int i = 0; i < _curve.keys.Length; i++)
{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
EditorGUILayout.LabelField(i + ".", GUILayout.MinWidth(20.0f));
EditorGUI.BeginChangeCheck();
float x = EditorGUILayout.FloatField(_curve.keys[i].time);
float y = EditorGUILayout.FloatField(_curve.keys[i].value);
//int mode = EditorGUILayout.IntField( curve.keys[i].tangentMode );
float inTangent = EditorGUILayout.FloatField(_curve.keys[i].inTangent);
float outTangent = EditorGUILayout.FloatField(_curve.keys[i].outTangent);
if (EditorGUI.EndChangeCheck())
{
if ((i == 0 || (_curve.keys.Length > 0 && x != _curve.keys[0].time)) && (i == _curve.length - 1 || (x != _curve.keys[_curve.length - 1].time)))
{
Keyframe keyframe = new Keyframe(x, y, inTangent, outTangent);
//keyframe.tangentMode = (int)mode;
_curve.MoveKey(i, keyframe);
isCurveChanged = true;
}
}
GUILayout.EndHorizontal();
EditorGUILayout.Separator();
}
if (isCurveChanged)
{
CurveSerialProp.animationCurveValue = _curve;
CurveSerialProp.serializedObject.ApplyModifiedProperties();
_curve = CurveSerialProp.animationCurveValue;
}
}
public static void setSteppedInterval(AnimationCurve curve, int i, int nextI)
{
if (curve.keys[i].value == curve.keys[nextI].value){
return;
}
object thisKeyframeBoxed = curve[i];
object nextKeyframeBoxed = curve[nextI];
if (!KeyframeUtil.isKeyBroken(thisKeyframeBoxed))
KeyframeUtil.SetKeyBroken(thisKeyframeBoxed, true);
if (!KeyframeUtil.isKeyBroken(nextKeyframeBoxed))
KeyframeUtil.SetKeyBroken(nextKeyframeBoxed, true);
KeyframeUtil.SetKeyTangentMode(thisKeyframeBoxed, 1, TangentMode.Stepped);
KeyframeUtil.SetKeyTangentMode(nextKeyframeBoxed, 0, TangentMode.Stepped);
Keyframe thisKeyframe = (Keyframe)thisKeyframeBoxed;
Keyframe nextKeyframe = (Keyframe)nextKeyframeBoxed;
thisKeyframe.outTangent = float.PositiveInfinity;
nextKeyframe.inTangent = float.PositiveInfinity;
curve.MoveKey(i, thisKeyframe);
curve.MoveKey(nextI, nextKeyframe);
}
private static void UpdateTangentsFromMode(AnimationCurve curve, int index)
{
if ((index >= 0) && (index < curve.length))
{
Keyframe key = curve[index];
if ((GetKeyTangentMode(key, 0) == TangentMode.Linear) && (index >= 1))
{
key.inTangent = CalculateLinearTangent(curve, index, index - 1);
curve.MoveKey(index, key);
}
if ((GetKeyTangentMode(key, 1) == TangentMode.Linear) && ((index + 1) < curve.length))
{
key.outTangent = CalculateLinearTangent(curve, index, index + 1);
curve.MoveKey(index, key);
}
if ((GetKeyTangentMode(key, 0) == TangentMode.Smooth) || (GetKeyTangentMode(key, 1) == TangentMode.Smooth))
{
curve.SmoothTangents(index, 0f);
}
}
}
void UpdateTangentsFromMode(AnimationCurve curve, int index)
{
if (index < 0 || index >= curve.length)
return;
Keyframe key = curve[index];
// Adjust linear tangent
if (GetKeyTangentMode(key, 0) == TangentMode.Linear && index >= 1)
{
key.inTangent = CalculateLinearTangent(curve[index], curve[index-1]);
}
if (GetKeyTangentMode(key, 1) == TangentMode.Linear && index+1 < curve.length)
{
key.outTangent = CalculateLinearTangent(curve[index], curve[index+1]);
}
float smoothWeight = 0.0F;
// if (index > 0 && index < curve.length - 1)
// {
// smoothWeight = Mathf.InverseLerp(curve[index - 1].time, curve[index + 1].time, curve[index].time) * 2 - 1;
// }
if (GetKeyTangentMode(key, 0) == TangentMode.Smooth)
{
curve.SmoothTangents(index, smoothWeight);
key.inTangent = curve[index].inTangent;
}
if (GetKeyTangentMode(key, 1) == TangentMode.Smooth)
{
curve.SmoothTangents(index, smoothWeight);
key.outTangent = curve[index].outTangent;
}
curve.MoveKey(index, key);
}
public static void setLinearInterval(AnimationCurve curve, int i, int nextI)
{
Keyframe thisKeyframe = curve[i];
Keyframe nextKeyframe = curve[nextI];
thisKeyframe.outTangent = CurveExtension.CalculateLinearTangent(curve, i, nextI);
nextKeyframe.inTangent = CurveExtension.CalculateLinearTangent(curve, nextI, i);
KeyframeUtil.SetKeyBroken((object)thisKeyframe, true);
KeyframeUtil.SetKeyBroken((object)nextKeyframe, true);
KeyframeUtil.SetKeyTangentMode((object)thisKeyframe, 1, TangentMode.Linear);
KeyframeUtil.SetKeyTangentMode((object)nextKeyframe, 0, TangentMode.Linear);
curve.MoveKey(i, thisKeyframe);
curve.MoveKey(nextI, nextKeyframe);
}
/// <summary>
/// Move/Change an existing key in an AnimationCurve.
/// Maintains TangentMode and updates neighbours.
/// </summary>
/// <param name="curve">The existing AnimationCurve.</param>
/// <param name="index">The index of the current Keyframe.</param>
/// <param name="keyframe">The new Keyframe data.</param>
/// <returns>The index of the Keyframe.</returns>
public static int MoveKey(AnimationCurve curve, int index, Keyframe keyframe)
{
// Save the tangent mode.
Keyframe old = curve[index];
keyframe.tangentMode = old.tangentMode;
int newIndex = curve.MoveKey(index, keyframe);
// Respect the tangentMode and update as necessary.
if (IsAuto(keyframe.tangentMode))
{
curve.SmoothTangents(newIndex, 0);
}
else if (IsBroken(keyframe.tangentMode))
{
if (IsLeftLinear(keyframe.tangentMode))
{
SetKeyLeftLinear(curve, newIndex);
}
if (IsRightLinear(keyframe.tangentMode))
{
SetKeyRightLinear(curve, newIndex);
}
}
// update the left neighbour
if (newIndex > 0)
{
// Update tangent data based on tangent mode.
int tangentMode = curve[newIndex - 1].tangentMode;
if (IsAuto(tangentMode))
{
curve.SmoothTangents(newIndex - 1, 0);
}
if (IsBroken(tangentMode))
{
if (IsRightLinear(tangentMode))
{
SetKeyRightLinear(curve, newIndex - 1);
}
}
}
// update the right neighbour
if (newIndex < curve.length - 1)
{
// Update tangent data based on tangent mode.
int tangentMode = curve[newIndex + 1].tangentMode;
if (IsAuto(tangentMode))
{
curve.SmoothTangents(newIndex + 1, 0);
}
if (IsBroken(tangentMode))
{
if (IsLeftLinear(tangentMode))
{
SetKeyLeftLinear(curve, newIndex + 1);
}
}
}
return newIndex;
}
/// <summary>
/// Set the indexed key of an AnimationCurve to RightLinear.
/// </summary>
/// <param name="curve">The curve to change.</param>
/// <param name="index">The index of the key to set to RightLinear.</param>
public static void SetKeyRightLinear(AnimationCurve curve, int index)
{
Keyframe kf = curve[index];
float tangentValue = kf.outTangent;
if (index < curve.length - 1)
{
Keyframe next = curve[index + 1];
tangentValue = (next.value - kf.value) / (next.time - kf.time);
}
Keyframe newKeyframe = new Keyframe(kf.time, kf.value, kf.inTangent, tangentValue);
// Get current tangent mode.
int leftTangent = (IsAuto(kf.tangentMode) || kf.tangentMode == 0) ? 0 : (kf.tangentMode % 8) - 1;
newKeyframe.tangentMode = leftTangent + 16 + 1;
curve.MoveKey(index, newKeyframe);
}
private static void UpdateTangentsFromMode(AnimationCurve curve, int index)
{
if (index < 0 || index >= curve.length)
{
return;
}
Keyframe key = curve[index];
if (CurveUtility.GetKeyTangentMode(key, 0) == TangentMode.Linear && index >= 1)
{
key.inTangent = CurveUtility.CalculateLinearTangent(curve, index, index - 1);
curve.MoveKey(index, key);
}
if (CurveUtility.GetKeyTangentMode(key, 1) == TangentMode.Linear && index + 1 < curve.length)
{
key.outTangent = CurveUtility.CalculateLinearTangent(curve, index, index + 1);
curve.MoveKey(index, key);
}
if (CurveUtility.GetKeyTangentMode(key, 0) == TangentMode.Smooth || CurveUtility.GetKeyTangentMode(key, 1) == TangentMode.Smooth)
{
curve.SmoothTangents(index, 0f);
}
}
private void AddAnimationReturnToGameDeck(Vector3 endPosition)
{
var clip = new AnimationClip();
var curve = AnimationCurve.EaseInOut(0, transform.position.x, 1, endPosition.x);
clip.SetCurve("",typeof(Transform),"localPosition.x", curve);
curve = AnimationCurve.EaseInOut(0, transform.position.y, 0.7f, 0f);
clip.SetCurve("",typeof(Transform),"localPosition.y", curve);
curve = new AnimationCurve();
curve.AddKey(0, transform.position.z);
var keyframe = curve[0];
keyframe.outTangent = 1;
curve.MoveKey(0, keyframe);
curve.AddKey(0.4f, transform.position.z+2.5f);
curve.AddKey(0.70f, transform.position.z+4.7f);
curve.AddKey(1f, endPosition.z);
keyframe = curve[3];
keyframe.inTangent = 0;
curve.MoveKey(3, keyframe);
clip.SetCurve("",typeof(Transform),"localPosition.z", curve);
clip.wrapMode = WrapMode.Once;
// var animEv= new AnimationEvent();
// animEv.functionName="animFinished";
// animEv.time=clip.length;
// clip.AddEvent(animEv);
clip.legacy = true;
GetComponent<Animation>().AddClip(clip, "ReturnToGameDeckAnimation");
}
private static void Internal_UpdateTangents(AnimationCurve curve, int index)
{
if ((index >= 0) && (index < curve.length))
{
Keyframe key = curve[index];
if ((GetKeyLeftTangentMode(key) == TangentMode.Linear) && (index >= 1))
{
key.inTangent = Internal_CalculateLinearTangent(curve, index, index - 1);
curve.MoveKey(index, key);
}
if ((GetKeyRightTangentMode(key) == TangentMode.Linear) && ((index + 1) < curve.length))
{
key.outTangent = Internal_CalculateLinearTangent(curve, index, index + 1);
curve.MoveKey(index, key);
}
if ((GetKeyLeftTangentMode(key) == TangentMode.ClampedAuto) || (GetKeyRightTangentMode(key) == TangentMode.ClampedAuto))
{
Internal_CalculateAutoTangent(curve, index);
}
if ((GetKeyLeftTangentMode(key) == TangentMode.Auto) || (GetKeyRightTangentMode(key) == TangentMode.Auto))
{
curve.SmoothTangents(index, 0f);
}
if (((GetKeyLeftTangentMode(key) == TangentMode.Free) && (GetKeyRightTangentMode(key) == TangentMode.Free)) && !GetKeyBroken(key))
{
key.outTangent = key.inTangent;
curve.MoveKey(index, key);
}
if (GetKeyLeftTangentMode(key) == TangentMode.Constant)
{
key.inTangent = float.PositiveInfinity;
curve.MoveKey(index, key);
}
if (GetKeyRightTangentMode(key) == TangentMode.Constant)
{
key.outTangent = float.PositiveInfinity;
curve.MoveKey(index, key);
}
}
}
public static void SetKeyRightTangentMode(AnimationCurve curve, int index, 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 != TangentMode.Free)
{
SetKeyBroken(ref key, true);
}
SetKeyRightTangentMode(ref key, tangentMode);
curve.MoveKey(index, key);
UpdateTangentsFromModeSurrounding(curve, index);
}
/// <summary>
/// <para>Change the specified keyframe broken tangent flag.</para>
/// </summary>
/// <param name="curve">The curve to modify.</param>
/// <param name="index">Keyframe index.</param>
/// <param name="broken">Broken flag.</param>
public static void SetKeyBroken(AnimationCurve curve, int index, bool broken)
{
if (curve == null)
{
throw new ArgumentNullException("curve");
}
if ((index < 0) || (index >= curve.length))
{
throw new ArgumentException("Index out of bounds.");
}
Keyframe key = curve[index];
SetKeyBroken(ref key, broken);
curve.MoveKey(index, key);
UpdateTangentsFromModeSurrounding(curve, index);
}
public static void SetKeyModeFromContext(AnimationCurve curve, int keyIndex)
{
Keyframe key = curve[keyIndex];
bool broken = false;
if (keyIndex > 0 && CurveUtility.GetKeyBroken(curve[keyIndex - 1]))
broken = true;
if (keyIndex < curve.length - 1 && CurveUtility.GetKeyBroken(curve[keyIndex + 1]))
broken = true;
CurveUtility.SetKeyBroken(ref key, broken);
if (broken)
{
if (keyIndex > 0)
CurveUtility.SetKeyTangentMode(ref key, 0, CurveUtility.GetKeyTangentMode(curve[keyIndex - 1], 1));
if (keyIndex < curve.length - 1)
CurveUtility.SetKeyTangentMode(ref key, 1, CurveUtility.GetKeyTangentMode(curve[keyIndex + 1], 0));
}
else
{
TangentMode mode = TangentMode.Smooth;
if (keyIndex > 0 && CurveUtility.GetKeyTangentMode(curve[keyIndex - 1], 1) != TangentMode.Smooth)
mode = TangentMode.Editable;
if (keyIndex < curve.length - 1 && CurveUtility.GetKeyTangentMode(curve[keyIndex + 1], 0) != TangentMode.Smooth)
mode = TangentMode.Editable;
CurveUtility.SetKeyTangentMode(ref key, 0, mode);
CurveUtility.SetKeyTangentMode(ref key, 1, mode);
}
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);
}
/// <summary>
/// Add a new key to an AnimationCurve.
/// Ensures the integrity of other key's tangent modes.
/// </summary>
/// <param name="curve">The existing AnimationCurve.</param>
/// <param name="keyframe">The new keyframe</param>
/// <returns>The index of the newly added key.</returns>
public static int AddKey(AnimationCurve curve, Keyframe keyframe)
{
if (curve.length == 0)
{
return curve.AddKey(keyframe);
}
else if (curve.length == 1)
{
// Save the existing keyframe data. (Unity changes the tangent info).
Keyframe temp = curve[0];
int newIndex = curve.AddKey(keyframe);
if(newIndex == -1)
{
return 0;
}
else if(newIndex == 0)
{
curve.MoveKey(1, temp);
}
else
{
curve.MoveKey(0, temp);
}
return newIndex;
}
else
{
Keyframe left = new Keyframe();
Keyframe right = new Keyframe();
for (int i = 0; i < curve.length - 1; i++)
{
Keyframe l = curve[i];
Keyframe r = curve[i + 1];
if (l.time < keyframe.time && keyframe.time < r.time)
{
left = l;
right = r;
}
}
int index = curve.AddKey(keyframe);
// Handle left neighbour.
if (index > 0)
{
// Restore the saved data.
curve.MoveKey(index - 1, left);
// Update tangent data based on tangent mode.
int tangentMode = curve[index - 1].tangentMode;
if (IsAuto(tangentMode))
{
curve.SmoothTangents(index - 1, 0);
}
if (IsBroken(tangentMode))
{
if (IsRightLinear(tangentMode))
{
SetKeyRightLinear(curve, index - 1);
}
}
}
// Handle the Right neighbour.
if (index < curve.length - 1)
{
// Restore the saved data.
curve.MoveKey(index + 1, right);
// Update tangent data based on tangent mode.
int tangentMode = curve[index + 1].tangentMode;
if (IsAuto(tangentMode))
{
curve.SmoothTangents(index + 1, 0);
}
if (IsBroken(tangentMode))
{
if (IsLeftLinear(tangentMode))
{
SetKeyLeftLinear(curve, index + 1);
}
}
}
return index;
}
}
static void fixAngles(AnimationCurve curve, JsonData[] curveData)
{
if (curve.keys.Length <3)
return;
float currValue, previousValue;
for (int previousI=0, i = 1; i < curve.keys.Length; previousI= i++) {
if (curveData[previousI] != null && curveData[previousI].IsString && ((string)curveData[previousI]).Equals("stepped"))
continue;
currValue = curve.keys[i].value;
previousValue = curve.keys[previousI].value;
while ((currValue - previousValue) > 180 ){
currValue -= 360;
}
while ((currValue - previousValue) < -180){
currValue += 360;
}
if (curve.keys[i].value != currValue){
curve.MoveKey(i, new Keyframe(curve.keys[i].time , currValue));
}
}
}
/// <summary>
/// Set the indexed key of an AnimationCurve to LeftLinear.
/// </summary>
/// <param name="curve">The curve to change.</param>
/// <param name="index">The index of the key to set to LeftLinear.</param>
public static void SetKeyLeftLinear(AnimationCurve curve, int index)
{
Keyframe kf = curve[index];
float tangentValue = kf.inTangent;
if (index > 0)
{
Keyframe prev = curve[index - 1];
tangentValue = (kf.value - prev.value) / (kf.time - prev.time);
}
Keyframe newKeyframe = new Keyframe(kf.time, kf.value, tangentValue, kf.outTangent);
int rightTangent = kf.tangentMode > 16 ? (kf.tangentMode / 8) * 8 : 0;
newKeyframe.tangentMode = rightTangent + 1 + 4;
curve.MoveKey(index, newKeyframe);
}
public static void setCustomTangents(AnimationCurve curve, int i, int nextI, JsonData tangentArray)
{
float diffValue = curve[nextI].value - curve[i].value;
float diffTime = curve[nextI].time - curve[i].time;
if (diffValue == 0)
return;
float cx1 = parseFloat(tangentArray[0]);
float cy1 = parseFloat(tangentArray[1]);
float cx2 = parseFloat(tangentArray[2]);
float cy2 = parseFloat(tangentArray[3]);
Vector2 p0 = new Vector2(0 , curve[i].value);
Vector2 p3 = new Vector2(diffTime , curve[nextI].value);
Vector2 cOrig1 = new Vector2(diffTime * cx1, curve[i].value);
cOrig1.y += diffValue > 0 ? diffValue * cy1 : -1.0f * Mathf.Abs(diffValue * cy1);
Vector2 cOrig2 = new Vector2(diffTime * cx2, curve[i].value);
cOrig2.y += diffValue > 0 ? diffValue * cy2 : -1.0f * Mathf.Abs(diffValue * cy2);
Vector2 p1 = getBezierPoint(p0, cOrig1, cOrig2, p3, 1.0f / 3.0f);
Vector2 p2 = getBezierPoint(p0, cOrig1, cOrig2, p3, 2.0f / 3.0f);
Vector2 c1tg, c2tg, c1, c2;
calcControlPoints(p0,p1,p2,p3, out c1, out c2);
c1tg = c1 - p0;
c2tg = c2 - p3;
float outTangent = c1tg.y / c1tg.x;
float inTangent = c2tg.y / c2tg.x;
object thisKeyframeBoxed = curve[i];
object nextKeyframeBoxed = curve[nextI];
if (!KeyframeUtil.isKeyBroken(thisKeyframeBoxed))
KeyframeUtil.SetKeyBroken(thisKeyframeBoxed, true);
KeyframeUtil.SetKeyTangentMode(thisKeyframeBoxed, 1, TangentMode.Editable);
if (!KeyframeUtil.isKeyBroken(nextKeyframeBoxed))
KeyframeUtil.SetKeyBroken(nextKeyframeBoxed, true);
KeyframeUtil.SetKeyTangentMode(nextKeyframeBoxed, 0, TangentMode.Editable);
Keyframe thisKeyframe = (Keyframe)thisKeyframeBoxed;
Keyframe nextKeyframe = (Keyframe)nextKeyframeBoxed;
thisKeyframe.outTangent = outTangent;
nextKeyframe.inTangent = inTangent;
curve.MoveKey(i, thisKeyframe);
curve.MoveKey(nextI, nextKeyframe);
//* test method
bool ok = true;
float startTime = thisKeyframe.time;
float epsilon = 0.001f;
for (float j=0; j < 25f; j++) {
float t = j/25.0f;
Vector2 t1 = getBezierPoint(p0, cOrig1, cOrig2, p3, t);
Vector2 t2 = getBezierPoint(p0, c1, c2, p3, t);
float curveValue = curve.Evaluate(startTime + diffTime * t);
if (!NearlyEqual(t1.y, t2.y, epsilon)
|| !NearlyEqual(t2.y, curveValue, epsilon)){
Debug.LogError("time = "+ t + " t1 = ["+t1.y.ToString("N8")+"] t2 = ["+t2.y.ToString("N8")+"] curve = ["+curveValue.ToString("N8")+"]");
ok = false;
}
}
if (!ok)
Debug.LogWarning("something wrong with bezier points");
//*/
}
