public MoveKey ( int index, |
||
index | int | The index of the key to move. |
key | The key (with its new time) to insert. | |
리턴 | 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"); //*/ }