Library/PackageCache/com.unity.postprocessing@2.1.6/PostProcessing/Editor/Utils/CurveEditor.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using UnityEngine;
   4
   5 namespace UnityEditor.Rendering.PostProcessing
   6 {
   7     internal sealed class CurveEditor
   8     {
   9         #region Enums
  10
  11         enum EditMode
  12         {
  13             None,
  14             Moving,
  15             TangentEdit
  16         }
  17
  18         enum Tangent
  19         {
  20             In,
  21             Out
  22         }
  23
  24         #endregion
  25
  26         #region Structs
  27
  28         public struct Settings
  29         {
  30             public Rect bounds;
  31             public RectOffset padding;
  32             public Color selectionColor;
  33             public float curvePickingDistance;
  34             public float keyTimeClampingDistance;
  35
  36             public static Settings defaultSettings
  37             {
  38                 get
  39                 {
  40                     return new Settings
  41                     {
  42                         bounds = new Rect(0f, 0f, 1f, 1f),
  43                         padding = new RectOffset(10, 10, 10, 10),
  44                         selectionColor = Color.yellow,
  45                         curvePickingDistance = 6f,
  46                         keyTimeClampingDistance = 1e-4f
  47                     };
  48                 }
  49             }
  50         }
  51
  52         public struct CurveState
  53         {
  54             public bool visible;
  55             public bool editable;
  56             public uint minPointCount;
  57             public float zeroKeyConstantValue;
  58             public Color color;
  59             public float width;
  60             public float handleWidth;
  61             public bool showNonEditableHandles;
  62             public bool onlyShowHandlesOnSelection;
  63             public bool loopInBounds;
  64
  65             public static CurveState defaultState
  66             {
  67                 get
  68                 {
  69                     return new CurveState
  70                     {
  71                         visible = true,
  72                         editable = true,
  73                         minPointCount = 2,
  74                         zeroKeyConstantValue = 0f,
  75                         color = Color.white,
  76                         width = 2f,
  77                         handleWidth = 2f,
  78                         showNonEditableHandles = true,
  79                         onlyShowHandlesOnSelection = false,
  80                         loopInBounds = false
  81                     };
  82                 }
  83             }
  84         }
  85
  86         public struct Selection
  87         {
  88             public SerializedProperty curve;
  89             public int keyframeIndex;
  90             public Keyframe? keyframe;
  91
  92             public Selection(SerializedProperty curve, int keyframeIndex, Keyframe? keyframe)
  93             {
  94                 this.curve = curve;
  95                 this.keyframeIndex = keyframeIndex;
  96                 this.keyframe = keyframe;
  97             }
  98         }
  99
 100         internal struct MenuAction
 101         {
 102             internal SerializedProperty curve;
 103             internal int index;
 104             internal Vector3 position;
 105
 106             internal MenuAction(SerializedProperty curve)
 107             {
 108                 this.curve = curve;
 109                 this.index = -1;
 110                 this.position = Vector3.zero;
 111             }
 112
 113             internal MenuAction(SerializedProperty curve, int index)
 114             {
 115                 this.curve = curve;
 116                 this.index = index;
 117                 this.position = Vector3.zero;
 118             }
 119
 120             internal MenuAction(SerializedProperty curve, Vector3 position)
 121             {
 122                 this.curve = curve;
 123                 this.index = -1;
 124                 this.position = position;
 125             }
 126         }
 127
 128         #endregion
 129
 130         #region Fields & properties
 131
 132         public Settings settings { get; private set; }
 133
 134         readonly Dictionary<SerializedProperty, CurveState> m_Curves;
 135         Rect m_CurveArea;
 136
 137         SerializedProperty m_SelectedCurve;
 138         int m_SelectedKeyframeIndex = -1;
 139
 140         EditMode m_EditMode = EditMode.None;
 141         Tangent m_TangentEditMode;
 142
 143         bool m_Dirty;
 144
 145         #endregion
 146
 147         #region Constructors & destructors
 148
 149         public CurveEditor()
 150             : this(Settings.defaultSettings)
 151         { }
 152
 153         public CurveEditor(Settings settings)
 154         {
 155             this.settings = settings;
 156             m_Curves = new Dictionary<SerializedProperty, CurveState>();
 157         }
 158
 159         #endregion
 160
 161         #region Public API
 162
 163         public void Add(params SerializedProperty[] curves)
 164         {
 165             foreach (var curve in curves)
 166                 Add(curve, CurveState.defaultState);
 167         }
 168
 169         public void Add(SerializedProperty curve)
 170         {
 171             Add(curve, CurveState.defaultState);
 172         }
 173
 174         public void Add(SerializedProperty curve, CurveState state)
 175         {
 176             // Make sure the property is in fact an AnimationCurve
 177             var animCurve = curve.animationCurveValue;
 178             if (animCurve == null)
 179                 throw new ArgumentException("curve");
 180
 181             if (m_Curves.ContainsKey(curve))
 182                 Debug.LogWarning("Curve has already been added to the editor");
 183
 184             m_Curves.Add(curve, state);
 185         }
 186
 187         public void Remove(SerializedProperty curve)
 188         {
 189             m_Curves.Remove(curve);
 190         }
 191
 192         public void RemoveAll()
 193         {
 194             m_Curves.Clear();
 195         }
 196
 197         public CurveState GetCurveState(SerializedProperty curve)
 198         {
 199             CurveState state;
 200             if (!m_Curves.TryGetValue(curve, out state))
 201                 throw new KeyNotFoundException("curve");
 202
 203             return state;
 204         }
 205
 206         public void SetCurveState(SerializedProperty curve, CurveState state)
 207         {
 208             if (!m_Curves.ContainsKey(curve))
 209                 throw new KeyNotFoundException("curve");
 210
 211             m_Curves[curve] = state;
 212         }
 213
 214         public Selection GetSelection()
 215         {
 216             Keyframe? key = null;
 217             if (m_SelectedKeyframeIndex > -1)
 218             {
 219                 var curve = m_SelectedCurve.animationCurveValue;
 220
 221                 if (m_SelectedKeyframeIndex >= curve.length)
 222                     m_SelectedKeyframeIndex = -1;
 223                 else
 224                     key = curve[m_SelectedKeyframeIndex];
 225             }
 226
 227             return new Selection(m_SelectedCurve, m_SelectedKeyframeIndex, key);
 228         }
 229
 230         public void SetKeyframe(SerializedProperty curve, int keyframeIndex, Keyframe keyframe)
 231         {
 232             var animCurve = curve.animationCurveValue;
 233             SetKeyframe(animCurve, keyframeIndex, keyframe);
 234             SaveCurve(curve, animCurve);
 235         }
 236
 237         public bool OnGUI(Rect rect)
 238         {
 239             if (Event.current.type == EventType.Repaint)
 240                 m_Dirty = false;
 241
 242             GUI.BeginClip(rect);
 243             {
 244                 var area = new Rect(Vector2.zero, rect.size);
 245                 m_CurveArea = settings.padding.Remove(area);
 246
 247                 foreach (var curve in m_Curves)
 248                     OnCurveGUI(area, curve.Key, curve.Value);
 249
 250                 OnGeneralUI(area);
 251             }
 252             GUI.EndClip();
 253
 254             return m_Dirty;
 255         }
 256
 257         #endregion
 258
 259         #region UI & events
 260
 261         void OnCurveGUI(Rect rect, SerializedProperty curve, CurveState state)
 262         {
 263             // Discard invisible curves
 264             if (!state.visible)
 265                 return;
 266
 267             var animCurve = curve.animationCurveValue;
 268             var keys = animCurve.keys;
 269             var length = keys.Length;
 270
 271             // Curve drawing
 272             // Slightly dim non-editable curves
 273             var color = state.color;
 274             if (!state.editable || !GUI.enabled)
 275                 color.a *= 0.5f;
 276
 277             Handles.color = color;
 278             var bounds = settings.bounds;
 279
 280             if (length == 0)
 281             {
 282                 var p1 = CurveToCanvas(new Vector3(bounds.xMin, state.zeroKeyConstantValue));
 283                 var p2 = CurveToCanvas(new Vector3(bounds.xMax, state.zeroKeyConstantValue));
 284                 Handles.DrawAAPolyLine(state.width, p1, p2);
 285             }
 286             else if (length == 1)
 287             {
 288                 var p1 = CurveToCanvas(new Vector3(bounds.xMin, keys[0].value));
 289                 var p2 = CurveToCanvas(new Vector3(bounds.xMax, keys[0].value));
 290                 Handles.DrawAAPolyLine(state.width, p1, p2);
 291             }
 292             else
 293             {
 294                 var prevKey = keys[0];
 295                 for (int k = 1; k < length; k++)
 296                 {
 297                     var key = keys[k];
 298                     var pts = BezierSegment(prevKey, key);
 299
 300                     if (float.IsInfinity(prevKey.outTangent) || float.IsInfinity(key.inTangent))
 301                     {
 302                         var s = HardSegment(prevKey, key);
 303                         Handles.DrawAAPolyLine(state.width, s[0], s[1], s[2]);
 304                     }
 305                     else Handles.DrawBezier(pts[0], pts[3], pts[1], pts[2], color, null, state.width);
 306
 307                     prevKey = key;
 308                 }
 309
 310                 // Curve extents & loops
 311                 if (keys[0].time > bounds.xMin)
 312                 {
 313                     if (state.loopInBounds)
 314                     {
 315                         var p1 = keys[length - 1];
 316                         p1.time -= settings.bounds.width;
 317                         var p2 = keys[0];
 318                         var pts = BezierSegment(p1, p2);
 319
 320                         if (float.IsInfinity(p1.outTangent) || float.IsInfinity(p2.inTangent))
 321                         {
 322                             var s = HardSegment(p1, p2);
 323                             Handles.DrawAAPolyLine(state.width, s[0], s[1], s[2]);
 324                         }
 325                         else Handles.DrawBezier(pts[0], pts[3], pts[1], pts[2], color, null, state.width);
 326                     }
 327                     else
 328                     {
 329                         var p1 = CurveToCanvas(new Vector3(bounds.xMin, keys[0].value));
 330                         var p2 = CurveToCanvas(keys[0]);
 331                         Handles.DrawAAPolyLine(state.width, p1, p2);
 332                     }
 333                 }
 334
 335                 if (keys[length - 1].time < bounds.xMax)
 336                 {
 337                     if (state.loopInBounds)
 338                     {
 339                         var p1 = keys[length - 1];
 340                         var p2 = keys[0];
 341                         p2.time += settings.bounds.width;
 342                         var pts = BezierSegment(p1, p2);
 343
 344                         if (float.IsInfinity(p1.outTangent) || float.IsInfinity(p2.inTangent))
 345                         {
 346                             var s = HardSegment(p1, p2);
 347                             Handles.DrawAAPolyLine(state.width, s[0], s[1], s[2]);
 348                         }
 349                         else Handles.DrawBezier(pts[0], pts[3], pts[1], pts[2], color, null, state.width);
 350                     }
 351                     else
 352                     {
 353                         var p1 = CurveToCanvas(keys[length - 1]);
 354                         var p2 = CurveToCanvas(new Vector3(bounds.xMax, keys[length - 1].value));
 355                         Handles.DrawAAPolyLine(state.width, p1, p2);
 356                     }
 357                 }
 358             }
 359
 360             // Make sure selection is correct (undo can break it)
 361             bool isCurrentlySelectedCurve = curve == m_SelectedCurve;
 362
 363             if (isCurrentlySelectedCurve && m_SelectedKeyframeIndex >= length)
 364                 m_SelectedKeyframeIndex = -1;
 365
 366             if (!state.editable)
 367                 m_SelectedKeyframeIndex = -1;
 368
 369             float enabledFactor = GUI.enabled ? 1f : 0.8f;
 370
 371             // Handles & keys
 372             for (int k = 0; k < length; k++)
 373             {
 374                 bool isCurrentlySelectedKeyframe = k == m_SelectedKeyframeIndex;
 375                 var e = Event.current;
 376
 377                 var pos = CurveToCanvas(keys[k]);
 378                 var hitRect = new Rect(pos.x - 8f, pos.y - 8f, 16f, 16f);
 379                 var offset = isCurrentlySelectedCurve
 380                     ? new RectOffset(5, 5, 5, 5)
 381                     : new RectOffset(6, 6, 6, 6);
 382
 383                 var outTangent = pos + CurveTangentToCanvas(keys[k].outTangent).normalized * 40f;
 384                 var inTangent = pos - CurveTangentToCanvas(keys[k].inTangent).normalized * 40f;
 385                 var inTangentHitRect = new Rect(inTangent.x - 7f, inTangent.y - 7f, 14f, 14f);
 386                 var outTangentHitrect = new Rect(outTangent.x - 7f, outTangent.y - 7f, 14f, 14f);
 387
 388                 // Draw
 389                 if (state.editable || state.showNonEditableHandles)
 390                 {
 391                     if (e.type == EventType.Repaint)
 392                     {
 393                         var selectedColor = (isCurrentlySelectedCurve && isCurrentlySelectedKeyframe)
 394                             ? settings.selectionColor
 395                             : state.color;
 396
 397                         // Keyframe
 398                         EditorGUI.DrawRect(offset.Remove(hitRect), selectedColor * enabledFactor);
 399
 400                         // Tangents
 401                         if (isCurrentlySelectedCurve && (!state.onlyShowHandlesOnSelection || (state.onlyShowHandlesOnSelection && isCurrentlySelectedKeyframe)))
 402                         {
 403                             Handles.color = selectedColor * enabledFactor;
 404
 405                             if (k > 0 || state.loopInBounds)
 406                             {
 407                                 Handles.DrawAAPolyLine(state.handleWidth, pos, inTangent);
 408                                 EditorGUI.DrawRect(offset.Remove(inTangentHitRect), selectedColor);
 409                             }
 410
 411                             if (k < length - 1 || state.loopInBounds)
 412                             {
 413                                 Handles.DrawAAPolyLine(state.handleWidth, pos, outTangent);
 414                                 EditorGUI.DrawRect(offset.Remove(outTangentHitrect), selectedColor);
 415                             }
 416                         }
 417                     }
 418                 }
 419
 420                 // Events
 421                 if (state.editable)
 422                 {
 423                     // Keyframe move
 424                     if (m_EditMode == EditMode.Moving && e.type == EventType.MouseDrag && isCurrentlySelectedCurve && isCurrentlySelectedKeyframe)
 425                     {
 426                         EditMoveKeyframe(animCurve, keys, k);
 427                     }
 428
 429                     // Tangent editing
 430                     if (m_EditMode == EditMode.TangentEdit && e.type == EventType.MouseDrag && isCurrentlySelectedCurve && isCurrentlySelectedKeyframe)
 431                     {
 432                         bool alreadyBroken = !(Mathf.Approximately(keys[k].inTangent, keys[k].outTangent) || (float.IsInfinity(keys[k].inTangent) && float.IsInfinity(keys[k].outTangent)));
 433                         EditMoveTangent(animCurve, keys, k, m_TangentEditMode, e.shift || !(alreadyBroken || e.control));
 434                     }
 435
 436                     // Keyframe selection & context menu
 437                     if (e.type == EventType.MouseDown && rect.Contains(e.mousePosition))
 438                     {
 439                         if (hitRect.Contains(e.mousePosition))
 440                         {
 441                             if (e.button == 0)
 442                             {
 443                                 SelectKeyframe(curve, k);
 444                                 m_EditMode = EditMode.Moving;
 445                                 e.Use();
 446                             }
 447                             else if (e.button == 1)
 448                             {
 449                                 // Keyframe context menu
 450                                 var menu = new GenericMenu();
 451                                 menu.AddItem(new GUIContent("Delete Key"), false, (x) =>
 452                                 {
 453                                     var action = (MenuAction)x;
 454                                     var curveValue = action.curve.animationCurveValue;
 455                                     action.curve.serializedObject.Update();
 456                                     RemoveKeyframe(curveValue, action.index);
 457                                     m_SelectedKeyframeIndex = -1;
 458                                     SaveCurve(action.curve, curveValue);
 459                                     action.curve.serializedObject.ApplyModifiedProperties();
 460                                 }, new MenuAction(curve, k));
 461                                 menu.ShowAsContext();
 462                                 e.Use();
 463                             }
 464                         }
 465                     }
 466
 467                     // Tangent selection & edit mode
 468                     if (e.type == EventType.MouseDown && rect.Contains(e.mousePosition))
 469                     {
 470                         if (inTangentHitRect.Contains(e.mousePosition) && (k > 0 || state.loopInBounds))
 471                         {
 472                             SelectKeyframe(curve, k);
 473                             m_EditMode = EditMode.TangentEdit;
 474                             m_TangentEditMode = Tangent.In;
 475                             e.Use();
 476                         }
 477                         else if (outTangentHitrect.Contains(e.mousePosition) && (k < length - 1 || state.loopInBounds))
 478                         {
 479                             SelectKeyframe(curve, k);
 480                             m_EditMode = EditMode.TangentEdit;
 481                             m_TangentEditMode = Tangent.Out;
 482                             e.Use();
 483                         }
 484                     }
 485
 486                     // Mouse up - clean up states
 487                     if (e.rawType == EventType.MouseUp && m_EditMode != EditMode.None)
 488                     {
 489                         m_EditMode = EditMode.None;
 490                     }
 491
 492                     // Set cursors
 493                     {
 494                         EditorGUIUtility.AddCursorRect(hitRect, MouseCursor.MoveArrow);
 495
 496                         if (k > 0 || state.loopInBounds)
 497                             EditorGUIUtility.AddCursorRect(inTangentHitRect, MouseCursor.RotateArrow);
 498
 499                         if (k < length - 1 || state.loopInBounds)
 500                             EditorGUIUtility.AddCursorRect(outTangentHitrect, MouseCursor.RotateArrow);
 501                     }
 502                 }
 503             }
 504
 505             Handles.color = Color.white;
 506             SaveCurve(curve, animCurve);
 507         }
 508
 509         void OnGeneralUI(Rect rect)
 510         {
 511             var e = Event.current;
 512
 513             // Selection
 514             if (e.type == EventType.MouseDown)
 515             {
 516                 GUI.FocusControl(null);
 517                 m_SelectedCurve = null;
 518                 m_SelectedKeyframeIndex = -1;
 519                 bool used = false;
 520
 521                 var hit = CanvasToCurve(e.mousePosition);
 522                 float curvePickValue = CurveToCanvas(hit).y;
 523
 524                 // Try and select a curve
 525                 foreach (var curve in m_Curves)
 526                 {
 527                     if (!curve.Value.editable || !curve.Value.visible)
 528                         continue;
 529
 530                     var prop = curve.Key;
 531                     var state = curve.Value;
 532                     var animCurve = prop.animationCurveValue;
 533                     float hitY = animCurve.length == 0
 534                         ? state.zeroKeyConstantValue
 535                         : animCurve.Evaluate(hit.x);
 536
 537                     var curvePos = CurveToCanvas(new Vector3(hit.x, hitY));
 538
 539                     if (Mathf.Abs(curvePos.y - curvePickValue) < settings.curvePickingDistance)
 540                     {
 541                         m_SelectedCurve = prop;
 542
 543                         if (e.clickCount == 2 && e.button == 0)
 544                         {
 545                             // Create a keyframe on double-click on this curve
 546                             EditCreateKeyframe(animCurve, hit, true, state.zeroKeyConstantValue);
 547                             SaveCurve(prop, animCurve);
 548                         }
 549                         else if (e.button == 1)
 550                         {
 551                             // Curve context menu
 552                             var menu = new GenericMenu();
 553                             menu.AddItem(new GUIContent("Add Key"), false, (x) =>
 554                             {
 555                                 var action = (MenuAction)x;
 556                                 var curveValue = action.curve.animationCurveValue;
 557                                 action.curve.serializedObject.Update();
 558                                 EditCreateKeyframe(curveValue, hit, true, 0f);
 559                                 SaveCurve(action.curve, curveValue);
 560                                 action.curve.serializedObject.ApplyModifiedProperties();
 561                             }, new MenuAction(prop, hit));
 562                             menu.ShowAsContext();
 563                             e.Use();
 564                             used = true;
 565                         }
 566                     }
 567                 }
 568
 569                 if (e.clickCount == 2 && e.button == 0 && m_SelectedCurve == null)
 570                 {
 571                     // Create a keyframe on every curve on double-click
 572                     foreach (var curve in m_Curves)
 573                     {
 574                         if (!curve.Value.editable || !curve.Value.visible)
 575                             continue;
 576
 577                         var prop = curve.Key;
 578                         var state = curve.Value;
 579                         var animCurve = prop.animationCurveValue;
 580                         EditCreateKeyframe(animCurve, hit, e.alt, state.zeroKeyConstantValue);
 581                         SaveCurve(prop, animCurve);
 582                     }
 583                 }
 584                 else if (!used && e.button == 1)
 585                 {
 586                     // Global context menu
 587                     var menu = new GenericMenu();
 588                     menu.AddItem(new GUIContent("Add Key At Position"), false, () => ContextMenuAddKey(hit, false));
 589                     menu.AddItem(new GUIContent("Add Key On Curves"), false, () => ContextMenuAddKey(hit, true));
 590                     menu.ShowAsContext();
 591                 }
 592
 593                 e.Use();
 594             }
 595
 596             // Delete selected key(s)
 597             if (e.type == EventType.KeyDown && (e.keyCode == KeyCode.Delete || e.keyCode == KeyCode.Backspace))
 598             {
 599                 if (m_SelectedKeyframeIndex != -1 && m_SelectedCurve != null)
 600                 {
 601                     var animCurve = m_SelectedCurve.animationCurveValue;
 602                     var length = animCurve.length;
 603
 604                     if (m_Curves[m_SelectedCurve].minPointCount < length && length >= 0)
 605                     {
 606                         EditDeleteKeyframe(animCurve, m_SelectedKeyframeIndex);
 607                         m_SelectedKeyframeIndex = -1;
 608                         SaveCurve(m_SelectedCurve, animCurve);
 609                     }
 610
 611                     e.Use();
 612                 }
 613             }
 614         }
 615
 616         void SaveCurve(SerializedProperty prop, AnimationCurve curve)
 617         {
 618             prop.animationCurveValue = curve;
 619         }
 620
 621         void Invalidate()
 622         {
 623             m_Dirty = true;
 624         }
 625
 626         #endregion
 627
 628         #region Keyframe manipulations
 629
 630         void SelectKeyframe(SerializedProperty curve, int keyframeIndex)
 631         {
 632             m_SelectedKeyframeIndex = keyframeIndex;
 633             m_SelectedCurve = curve;
 634             Invalidate();
 635         }
 636
 637         void ContextMenuAddKey(Vector3 hit, bool createOnCurve)
 638         {
 639             SerializedObject serializedObject = null;
 640
 641             foreach (var curve in m_Curves)
 642             {
 643                 if (!curve.Value.editable || !curve.Value.visible)
 644                     continue;
 645
 646                 var prop = curve.Key;
 647                 var state = curve.Value;
 648
 649                 if (serializedObject == null)
 650                 {
 651                     serializedObject = prop.serializedObject;
 652                     serializedObject.Update();
 653                 }
 654
 655                 var animCurve = prop.animationCurveValue;
 656                 EditCreateKeyframe(animCurve, hit, createOnCurve, state.zeroKeyConstantValue);
 657                 SaveCurve(prop, animCurve);
 658             }
 659
 660             if (serializedObject != null)
 661                 serializedObject.ApplyModifiedProperties();
 662
 663             Invalidate();
 664         }
 665
 666         void EditCreateKeyframe(AnimationCurve curve, Vector3 position, bool createOnCurve, float zeroKeyConstantValue)
 667         {
 668             float tangent = EvaluateTangent(curve, position.x);
 669
 670             if (createOnCurve)
 671             {
 672                 position.y = curve.length == 0
 673                     ? zeroKeyConstantValue
 674                     : curve.Evaluate(position.x);
 675             }
 676
 677             AddKeyframe(curve, new Keyframe(position.x, position.y, tangent, tangent));
 678         }
 679
 680         void EditDeleteKeyframe(AnimationCurve curve, int keyframeIndex)
 681         {
 682             RemoveKeyframe(curve, keyframeIndex);
 683         }
 684
 685         void AddKeyframe(AnimationCurve curve, Keyframe newValue)
 686         {
 687             curve.AddKey(newValue);
 688             Invalidate();
 689         }
 690
 691         void RemoveKeyframe(AnimationCurve curve, int keyframeIndex)
 692         {
 693             curve.RemoveKey(keyframeIndex);
 694             Invalidate();
 695         }
 696
 697         void SetKeyframe(AnimationCurve curve, int keyframeIndex, Keyframe newValue)
 698         {
 699             var keys = curve.keys;
 700
 701             if (keyframeIndex > 0)
 702                 newValue.time = Mathf.Max(keys[keyframeIndex - 1].time + settings.keyTimeClampingDistance, newValue.time);
 703
 704             if (keyframeIndex < keys.Length - 1)
 705                 newValue.time = Mathf.Min(keys[keyframeIndex + 1].time - settings.keyTimeClampingDistance, newValue.time);
 706
 707             curve.MoveKey(keyframeIndex, newValue);
 708             Invalidate();
 709         }
 710
 711         void EditMoveKeyframe(AnimationCurve curve, Keyframe[] keys, int keyframeIndex)
 712         {
 713             var key = CanvasToCurve(Event.current.mousePosition);
 714             float inTgt = keys[keyframeIndex].inTangent;
 715             float outTgt = keys[keyframeIndex].outTangent;
 716             SetKeyframe(curve, keyframeIndex, new Keyframe(key.x, key.y, inTgt, outTgt));
 717         }
 718
 719         void EditMoveTangent(AnimationCurve curve, Keyframe[] keys, int keyframeIndex, Tangent targetTangent, bool linkTangents)
 720         {
 721             var pos = CanvasToCurve(Event.current.mousePosition);
 722
 723             float time = keys[keyframeIndex].time;
 724             float value = keys[keyframeIndex].value;
 725
 726             pos -= new Vector3(time, value);
 727
 728             if (targetTangent == Tangent.In && pos.x > 0f)
 729                 pos.x = 0f;
 730
 731             if (targetTangent == Tangent.Out && pos.x < 0f)
 732                 pos.x = 0f;
 733
 734             float tangent;
 735
 736             if (Mathf.Approximately(pos.x, 0f))
 737                 tangent = pos.y < 0f ? float.PositiveInfinity : float.NegativeInfinity;
 738             else
 739                 tangent = pos.y / pos.x;
 740
 741             float inTangent = keys[keyframeIndex].inTangent;
 742             float outTangent = keys[keyframeIndex].outTangent;
 743
 744             if (targetTangent == Tangent.In || linkTangents)
 745                 inTangent = tangent;
 746             if (targetTangent == Tangent.Out || linkTangents)
 747                 outTangent = tangent;
 748
 749             SetKeyframe(curve, keyframeIndex, new Keyframe(time, value, inTangent, outTangent));
 750         }
 751
 752         #endregion
 753
 754         #region Maths utilities
 755
 756         Vector3 CurveToCanvas(Keyframe keyframe)
 757         {
 758             return CurveToCanvas(new Vector3(keyframe.time, keyframe.value));
 759         }
 760
 761         Vector3 CurveToCanvas(Vector3 position)
 762         {
 763             var bounds = settings.bounds;
 764             var output = new Vector3((position.x - bounds.x) / (bounds.xMax - bounds.x), (position.y - bounds.y) / (bounds.yMax - bounds.y));
 765             output.x = output.x * (m_CurveArea.xMax - m_CurveArea.xMin) + m_CurveArea.xMin;
 766             output.y = (1f - output.y) * (m_CurveArea.yMax - m_CurveArea.yMin) + m_CurveArea.yMin;
 767             return output;
 768         }
 769
 770         Vector3 CanvasToCurve(Vector3 position)
 771         {
 772             var bounds = settings.bounds;
 773             var output = position;
 774             output.x = (output.x - m_CurveArea.xMin) / (m_CurveArea.xMax - m_CurveArea.xMin);
 775             output.y = (output.y - m_CurveArea.yMin) / (m_CurveArea.yMax - m_CurveArea.yMin);
 776             output.x = Mathf.Lerp(bounds.x, bounds.xMax, output.x);
 777             output.y = Mathf.Lerp(bounds.yMax, bounds.y, output.y);
 778             return output;
 779         }
 780
 781         Vector3 CurveTangentToCanvas(float tangent)
 782         {
 783             if (!float.IsInfinity(tangent))
 784             {
 785                 var bounds = settings.bounds;
 786                 float ratio = (m_CurveArea.width / m_CurveArea.height) / ((bounds.xMax - bounds.x) / (bounds.yMax - bounds.y));
 787                 return new Vector3(1f, -tangent / ratio).normalized;
 788             }
 789
 790             return float.IsPositiveInfinity(tangent) ? Vector3.up : Vector3.down;
 791         }
 792
 793         Vector3[] BezierSegment(Keyframe start, Keyframe end)
 794         {
 795             var segment = new Vector3[4];
 796
 797             segment[0] = CurveToCanvas(new Vector3(start.time, start.value));
 798             segment[3] = CurveToCanvas(new Vector3(end.time, end.value));
 799
 800             float middle = start.time + ((end.time - start.time) * 0.333333f);
 801             float middle2 = start.time + ((end.time - start.time) * 0.666666f);
 802
 803             segment[1] = CurveToCanvas(new Vector3(middle, ProjectTangent(start.time, start.value, start.outTangent, middle)));
 804             segment[2] = CurveToCanvas(new Vector3(middle2, ProjectTangent(end.time, end.value, end.inTangent, middle2)));
 805
 806             return segment;
 807         }
 808
 809         Vector3[] HardSegment(Keyframe start, Keyframe end)
 810         {
 811             var segment = new Vector3[3];
 812
 813             segment[0] = CurveToCanvas(start);
 814             segment[1] = CurveToCanvas(new Vector3(end.time, start.value));
 815             segment[2] = CurveToCanvas(end);
 816
 817             return segment;
 818         }
 819
 820         float ProjectTangent(float inPosition, float inValue, float inTangent, float projPosition)
 821         {
 822             return inValue + ((projPosition - inPosition) * inTangent);
 823         }
 824
 825         float EvaluateTangent(AnimationCurve curve, float time)
 826         {
 827             int prev = -1, next = 0;
 828             for (int i = 0; i < curve.keys.Length; i++)
 829             {
 830                 if (time > curve.keys[i].time)
 831                 {
 832                     prev = i;
 833                     next = i + 1;
 834                 }
 835                 else break;
 836             }
 837
 838             if (next == 0)
 839                 return 0f;
 840
 841             if (prev == curve.keys.Length - 1)
 842                 return 0f;
 843
 844             const float kD = 1e-3f;
 845             float tp = Mathf.Max(time - kD, curve.keys[prev].time);
 846             float tn = Mathf.Min(time + kD, curve.keys[next].time);
 847
 848             float vp = curve.Evaluate(tp);
 849             float vn = curve.Evaluate(tn);
 850
 851             if (Mathf.Approximately(tn, tp))
 852                 return (vn - vp > 0f) ? float.PositiveInfinity : float.NegativeInfinity;
 853
 854             return (vn - vp) / (tn - tp);
 855         }
 856
 857         #endregion
 858     }
 859 }