public AnimationWindowKeyframe(AnimationWindowKeyframe key)
 {
     this.time = key.time;
     this.value = key.value;
     this.curve = key.curve;
     this.m_InTangent = key.m_InTangent;
     this.m_OutTangent = key.m_OutTangent;
     this.m_TangentMode = key.m_TangentMode;
 }
 public static AnimationWindowKeyframe AddKeyframeToCurve(AnimationWindowCurve curve, object value, System.Type type, AnimationKeyTime time)
 {
     AnimationWindowKeyframe keyframe = curve.FindKeyAtTime(time);
     if (keyframe != null)
     {
         keyframe.value = value;
         return keyframe;
     }
     AnimationWindowKeyframe key = new AnimationWindowKeyframe {
         time = time.time
     };
     if (curve.isPPtrCurve)
     {
         key.value = value;
         key.curve = curve;
         curve.AddKeyframe(key, time);
         return key;
     }
     if ((type == typeof(bool)) || (type == typeof(float)))
     {
         AnimationCurve curve2 = curve.ToAnimationCurve();
         Keyframe keyframe3 = new Keyframe(time.time, (float) value);
         if (type == typeof(bool))
         {
             CurveUtility.SetKeyTangentMode(ref keyframe3, 0, TangentMode.Stepped);
             CurveUtility.SetKeyTangentMode(ref keyframe3, 1, TangentMode.Stepped);
             CurveUtility.SetKeyBroken(ref keyframe3, true);
             key.m_TangentMode = keyframe3.tangentMode;
             key.m_InTangent = float.PositiveInfinity;
             key.m_OutTangent = float.PositiveInfinity;
         }
         else
         {
             int keyIndex = curve2.AddKey(keyframe3);
             if (keyIndex != -1)
             {
                 CurveUtility.SetKeyModeFromContext(curve2, keyIndex);
                 Keyframe keyframe4 = curve2[keyIndex];
                 key.m_TangentMode = keyframe4.tangentMode;
             }
         }
         key.value = value;
         key.curve = curve;
         curve.AddKeyframe(key, time);
     }
     return key;
 }
		public void UnselectKey(AnimationWindowKeyframe keyframe)
		{
			int hash = keyframe.GetHash();
			if (this.selectedKeyHashes.Contains(hash))
			{
				this.selectedKeyHashes.Remove(hash);
			}
			this.m_SelectedKeysCache = null;
		}
		private void Refresh()
		{
			if (this.refresh == AnimationWindowState.RefreshType.Everything)
			{
				CurveRendererCache.ClearCurveRendererCache();
				this.m_ActiveKeyframeCache = null;
				this.m_AllCurvesCache = null;
				this.m_ActiveCurvesCache = null;
				this.m_CurveEditorIsDirty = true;
				this.m_dopelinesCache = null;
				this.m_SelectedKeysCache = null;
				if (this.refresh == AnimationWindowState.RefreshType.Everything && this.m_HierarchyData != null)
				{
					this.m_HierarchyData.UpdateData();
				}
				EditorCurveBinding? lastAddedCurveBinding = this.m_lastAddedCurveBinding;
				if (lastAddedCurveBinding.HasValue)
				{
					EditorCurveBinding? lastAddedCurveBinding2 = this.m_lastAddedCurveBinding;
					this.OnNewCurveAdded(lastAddedCurveBinding2.Value);
				}
				if (this.activeCurves.Count == 0 && this.dopelines.Count > 0)
				{
					this.SelectHierarchyItem(this.dopelines[0], false, false);
				}
				this.m_Refresh = AnimationWindowState.RefreshType.None;
			}
			else
			{
				if (this.refresh == AnimationWindowState.RefreshType.CurvesOnly)
				{
					this.m_ActiveKeyframeCache = null;
					this.m_ActiveCurvesCache = null;
					this.m_SelectedKeysCache = null;
					this.ReloadModifiedAnimationCurveCache();
					this.ReloadModifiedDopelineCache();
					CurveRendererCache.ClearCurveRendererCache();
					this.m_CurveEditorIsDirty = true;
					this.m_Refresh = AnimationWindowState.RefreshType.None;
					this.m_ModifiedCurves.Clear();
				}
			}
		}
 public static CurveSelection AnimationWindowKeyframeToCurveSelection(AnimationWindowKeyframe keyframe, CurveEditor curveEditor)
 {
   foreach (CurveWrapper animationCurve in curveEditor.animationCurves)
   {
     if (animationCurve.binding == keyframe.curve.binding && keyframe.GetIndex() >= 0)
       return new CurveSelection(animationCurve.id, curveEditor, keyframe.GetIndex());
   }
   return (CurveSelection) null;
 }
		public bool KeyIsSelected(AnimationWindowKeyframe keyframe)
		{
			return this.selectedKeyHashes.Contains(keyframe.GetHash());
		}
 private float GetKeyframeOffset(DopeLine dopeline, AnimationWindowKeyframe keyframe)
 {
   return dopeline.isPptrDopeline && dopeline.tallMode && (keyframe == null || keyframe.value != null) ? -1f : -5.5f;
 }
        private void DoValueField(Rect rect, AnimationWindowHierarchyNode node, int row)
        {
            bool flag = false;

            if (node is AnimationWindowHierarchyPropertyNode)
            {
                AnimationWindowCurve[] curves = node.curves;
                if (curves == null || curves.Length == 0)
                {
                    return;
                }
                AnimationWindowCurve animationWindowCurve = curves[0];
                object currentValue = CurveBindingUtility.GetCurrentValue(this.state, animationWindowCurve);
                if (currentValue is float)
                {
                    float num      = (float)currentValue;
                    Rect  position = new Rect(rect.xMax - 75f, rect.y, 50f, rect.height);
                    if (Event.current.type == EventType.MouseMove && position.Contains(Event.current.mousePosition))
                    {
                        AnimationWindowHierarchyGUI.s_WasInsideValueRectFrame = Time.frameCount;
                    }
                    EditorGUI.BeginChangeCheck();
                    if (animationWindowCurve.valueType == typeof(bool))
                    {
                        num = (float)((!GUI.Toggle(position, this.m_HierarchyItemValueControlIDs[row], num != 0f, GUIContent.none, EditorStyles.toggle)) ? 0 : 1);
                    }
                    else
                    {
                        int  num2  = this.m_HierarchyItemValueControlIDs[row];
                        bool flag2 = GUIUtility.keyboardControl == num2 && EditorGUIUtility.editingTextField && Event.current.type == EventType.KeyDown && (Event.current.character == '\n' || Event.current.character == '\u0003');
                        if (EditorGUI.s_RecycledEditor.controlID == num2 && Event.current.type == EventType.MouseDown && position.Contains(Event.current.mousePosition))
                        {
                            GUIUtility.keyboardControl = num2;
                        }
                        num = EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor, position, new Rect(0f, 0f, 0f, 0f), num2, num, EditorGUI.kFloatFieldFormatString, this.m_AnimationSelectionTextField, false);
                        if (flag2)
                        {
                            GUI.changed = true;
                            Event.current.Use();
                        }
                    }
                    if (float.IsInfinity(num) || float.IsNaN(num))
                    {
                        num = 0f;
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        string                  undoLabel = "Edit Key";
                        float                   num3      = this.state.currentTime - animationWindowCurve.timeOffset;
                        AnimationKeyTime        time      = AnimationKeyTime.Time(num3, animationWindowCurve.clip.frameRate);
                        AnimationWindowKeyframe animationWindowKeyframe = null;
                        foreach (AnimationWindowKeyframe current in animationWindowCurve.m_Keyframes)
                        {
                            if (Mathf.Approximately(current.time, num3))
                            {
                                animationWindowKeyframe = current;
                            }
                        }
                        if (animationWindowKeyframe == null)
                        {
                            AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, num, animationWindowCurve.valueType, time);
                        }
                        else
                        {
                            animationWindowKeyframe.value = num;
                        }
                        this.state.SaveCurve(animationWindowCurve, undoLabel);
                        flag = true;
                    }
                }
            }
            if (flag)
            {
                this.state.ResampleAnimation();
            }
        }
		public static AnimationWindowKeyframe AddKeyframeToCurve(AnimationWindowCurve curve, object value, Type type, AnimationKeyTime time)
		{
			AnimationWindowKeyframe animationWindowKeyframe = curve.FindKeyAtTime(time);
			if (animationWindowKeyframe != null)
			{
				animationWindowKeyframe.value = value;
				return animationWindowKeyframe;
			}
			AnimationWindowKeyframe animationWindowKeyframe2 = new AnimationWindowKeyframe();
			animationWindowKeyframe2.time = time.time;
			if (curve.isPPtrCurve)
			{
				animationWindowKeyframe2.value = value;
				animationWindowKeyframe2.curve = curve;
				curve.AddKeyframe(animationWindowKeyframe2, time);
			}
			else
			{
				if (type == typeof(bool) || type == typeof(float))
				{
					AnimationCurve animationCurve = curve.ToAnimationCurve();
					Keyframe key = new Keyframe(time.time, (float)value);
					if (type == typeof(bool))
					{
						CurveUtility.SetKeyTangentMode(ref key, 0, TangentMode.Stepped);
						CurveUtility.SetKeyTangentMode(ref key, 1, TangentMode.Stepped);
						CurveUtility.SetKeyBroken(ref key, true);
						animationWindowKeyframe2.m_TangentMode = key.tangentMode;
						animationWindowKeyframe2.m_InTangent = float.PositiveInfinity;
						animationWindowKeyframe2.m_OutTangent = float.PositiveInfinity;
					}
					else
					{
						int num = animationCurve.AddKey(key);
						if (num != -1)
						{
							CurveUtility.SetKeyModeFromContext(animationCurve, num);
							animationWindowKeyframe2.m_TangentMode = animationCurve[num].tangentMode;
						}
					}
					animationWindowKeyframe2.value = value;
					animationWindowKeyframe2.curve = curve;
					curve.AddKeyframe(animationWindowKeyframe2, time);
				}
			}
			return animationWindowKeyframe2;
		}
 private void Refresh()
 {
   if (this.refresh == AnimationWindowState.RefreshType.Everything)
   {
     CurveRendererCache.ClearCurveRendererCache();
     this.m_ActiveKeyframeCache = (AnimationWindowKeyframe) null;
     this.m_AllCurvesCache = (List<AnimationWindowCurve>) null;
     this.m_ActiveCurvesCache = (List<AnimationWindowCurve>) null;
     this.m_dopelinesCache = (List<DopeLine>) null;
     this.m_SelectedKeysCache = (List<AnimationWindowKeyframe>) null;
     this.m_ActiveCurveWrappersCache = (List<CurveWrapper>) null;
     if (this.hierarchyData != null)
       this.hierarchyData.UpdateData();
     if (this.m_lastAddedCurveBinding.HasValue)
       this.OnNewCurveAdded(this.m_lastAddedCurveBinding.Value);
     if (this.activeCurves.Count == 0 && this.dopelines.Count > 0)
       this.SelectHierarchyItem(this.dopelines[0], false, false);
     this.m_Refresh = AnimationWindowState.RefreshType.None;
   }
   else if (this.refresh == AnimationWindowState.RefreshType.CurvesOnly)
   {
     CurveRendererCache.ClearCurveRendererCache();
     this.m_ActiveKeyframeCache = (AnimationWindowKeyframe) null;
     this.m_ActiveCurvesCache = (List<AnimationWindowCurve>) null;
     this.m_ActiveCurveWrappersCache = (List<CurveWrapper>) null;
     this.m_SelectedKeysCache = (List<AnimationWindowKeyframe>) null;
     this.ReloadModifiedAnimationCurveCache();
     this.ReloadModifiedDopelineCache();
     this.m_Refresh = AnimationWindowState.RefreshType.None;
     this.m_ModifiedCurves.Clear();
   }
   if (!this.disabled || !this.recording)
     return;
   this.recording = false;
 }
Exemple #11
0
        private void DoValueField(Rect rect, AnimationWindowHierarchyNode node, int row)
        {
            bool curvesChanged = false;

            if (node is AnimationWindowHierarchyPropertyNode)
            {
                AnimationWindowCurve[] curves = node.curves;
                if (curves == null || curves.Length == 0)
                {
                    return;
                }

                // We do valuefields for dopelines that only have single curve
                AnimationWindowCurve curve = curves[0];
                object objectValue         = CurveBindingUtility.GetCurrentValue(state, curve);

                if (objectValue is float)
                {
                    float value = (float)objectValue;

                    Rect valueFieldDragRect = new Rect(rect.xMax - k_ValueFieldOffsetFromRightSide - k_ValueFieldDragWidth, rect.y, k_ValueFieldDragWidth, rect.height);
                    Rect valueFieldRect     = new Rect(rect.xMax - k_ValueFieldOffsetFromRightSide, rect.y, k_ValueFieldWidth, rect.height);

                    if (Event.current.type == EventType.MouseMove && valueFieldRect.Contains(Event.current.mousePosition))
                    {
                        s_WasInsideValueRectFrame = Time.frameCount;
                    }

                    EditorGUI.BeginChangeCheck();

                    if (curve.valueType == typeof(bool))
                    {
                        value = GUI.Toggle(valueFieldRect, m_HierarchyItemValueControlIDs[row], value != 0, GUIContent.none, EditorStyles.toggle) ? 1 : 0;
                    }
                    else
                    {
                        int  id = m_HierarchyItemValueControlIDs[row];
                        bool enterInTextField = (EditorGUIUtility.keyboardControl == id &&
                                                 EditorGUIUtility.editingTextField &&
                                                 Event.current.type == EventType.KeyDown &&
                                                 (Event.current.character == '\n' || (int)Event.current.character == 3));

                        //  Force back keyboard focus to float field editor when editing it.
                        //  TreeView forces keyboard focus on itself at mouse down and we lose focus here.
                        if (EditorGUI.s_RecycledEditor.controlID == id && Event.current.type == EventType.MouseDown && valueFieldRect.Contains(Event.current.mousePosition))
                        {
                            GUIUtility.keyboardControl = id;
                        }

                        value = EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor,
                                                       valueFieldRect,
                                                       valueFieldDragRect,
                                                       id,
                                                       value,
                                                       "g5",
                                                       m_AnimationSelectionTextField,
                                                       true);
                        if (enterInTextField)
                        {
                            GUI.changed = true;
                            Event.current.Use();
                        }
                    }

                    if (float.IsInfinity(value) || float.IsNaN(value))
                    {
                        value = 0;
                    }

                    if (EditorGUI.EndChangeCheck())
                    {
                        string undoLabel = "Edit Key";

                        AnimationKeyTime newAnimationKeyTime = AnimationKeyTime.Time(state.currentTime, curve.clip.frameRate);

                        AnimationWindowKeyframe existingKeyframe = null;
                        foreach (AnimationWindowKeyframe keyframe in curve.m_Keyframes)
                        {
                            if (Mathf.Approximately(keyframe.time, state.currentTime))
                            {
                                existingKeyframe = keyframe;
                            }
                        }

                        if (existingKeyframe == null)
                        {
                            AnimationWindowUtility.AddKeyframeToCurve(curve, value, curve.valueType, newAnimationKeyTime);
                        }
                        else
                        {
                            existingKeyframe.value = value;
                        }

                        state.SaveCurve(curve, undoLabel);
                        curvesChanged = true;
                    }
                }
            }

            if (curvesChanged)
            {
                state.ResampleAnimation();
            }
        }
 public void AddKeyframe(AnimationWindowKeyframe key, AnimationKeyTime keyTime)
 {
     this.RemoveKeyframe(keyTime);
     this.m_Keyframes.Add(key);
     if (< > f__am$cache3 == null)
     {
        private void DoValueField(Rect rect, AnimationWindowHierarchyNode node, int row)
        {
            bool flag = false;

            if (!AnimationMode.InAnimationMode())
            {
                return;
            }
            EditorGUI.BeginDisabledGroup(this.state.animationIsReadOnly);
            if (node is AnimationWindowHierarchyPropertyNode)
            {
                List <AnimationWindowCurve> curves = this.state.GetCurves(node, false);
                if (curves == null || curves.Count == 0)
                {
                    return;
                }
                AnimationWindowCurve animationWindowCurve = curves[0];
                object currentValue         = CurveBindingUtility.GetCurrentValue(this.state.activeRootGameObject, animationWindowCurve.binding);
                Type   editorCurveValueType = CurveBindingUtility.GetEditorCurveValueType(this.state.activeRootGameObject, animationWindowCurve.binding);
                if (currentValue is float)
                {
                    float num      = (float)currentValue;
                    Rect  position = new Rect(rect.xMax - 75f, rect.y, 50f, rect.height);
                    if (Event.current.type == EventType.MouseMove && position.Contains(Event.current.mousePosition))
                    {
                        AnimationWindowHierarchyGUI.s_WasInsideValueRectFrame = Time.frameCount;
                    }
                    EditorGUI.BeginChangeCheck();
                    if (editorCurveValueType == typeof(bool))
                    {
                        num = (float)((!EditorGUI.Toggle(position, num != 0f)) ? 0 : 1);
                    }
                    else
                    {
                        int  controlID = GUIUtility.GetControlID(123456544, FocusType.Keyboard, position);
                        bool flag2     = GUIUtility.keyboardControl == controlID && EditorGUIUtility.editingTextField && Event.current.type == EventType.KeyDown && (Event.current.character == '\n' || Event.current.character == '\u0003');
                        num = EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor, position, new Rect(0f, 0f, 0f, 0f), controlID, num, EditorGUI.kFloatFieldFormatString, this.m_AnimationSelectionTextField, false);
                        if (flag2)
                        {
                            GUI.changed = true;
                            Event.current.Use();
                        }
                    }
                    if (float.IsInfinity(num) || float.IsNaN(num))
                    {
                        num = 0f;
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        AnimationWindowKeyframe animationWindowKeyframe = null;
                        foreach (AnimationWindowKeyframe current in animationWindowCurve.m_Keyframes)
                        {
                            if (Mathf.Approximately(current.time, this.state.time.time))
                            {
                                animationWindowKeyframe = current;
                            }
                        }
                        if (animationWindowKeyframe == null)
                        {
                            AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, num, editorCurveValueType, this.state.time);
                        }
                        else
                        {
                            animationWindowKeyframe.value = num;
                        }
                        this.state.SaveCurve(animationWindowCurve);
                        flag = true;
                    }
                }
            }
            EditorGUI.EndDisabledGroup();
            if (flag)
            {
                this.state.ResampleAnimation();
            }
        }
Exemple #14
0
 public void AddKeyframe(AnimationWindowKeyframe key, AnimationKeyTime keyTime)
 {
     this.RemoveKeyframe(keyTime);
     this.m_Keyframes.Add(key);
     this.m_Keyframes.Sort((AnimationWindowKeyframe a, AnimationWindowKeyframe b) => a.time.CompareTo(b.time));
 }
 public void SelectKey(AnimationWindowKeyframe keyframe)
 {
   int hash = keyframe.GetHash();
   if (!this.selectedKeyHashes.Contains(hash))
     this.selectedKeyHashes.Add(hash);
   this.m_SelectedKeysCache = (List<AnimationWindowKeyframe>) null;
 }
 public static CurveSelection AnimationWindowKeyframeToCurveSelection(AnimationWindowKeyframe keyframe, CurveEditor curveEditor)
 {
     foreach (CurveWrapper wrapper in curveEditor.animationCurves)
     {
         if ((wrapper.binding == keyframe.curve.binding) && (keyframe.GetIndex() >= 0))
         {
             return new CurveSelection(wrapper.id, curveEditor, keyframe.GetIndex());
         }
     }
     return null;
 }
 public void OnGUI(AnimationWindowState state, AnimationWindowKeyframe keyframe)
 {
   if (keyframe.isPPtrCurve)
     return;
   this.backgroundRect = this.position;
   this.backgroundRect.x = state.TimeToPixel(keyframe.time) + this.position.x - (float) (DopeSheetEditor.DopeSheetPopup.s_width / 2);
   this.backgroundRect.y += 16f;
   this.backgroundRect.width = (float) DopeSheetEditor.DopeSheetPopup.s_width;
   this.backgroundRect.height = (float) DopeSheetEditor.DopeSheetPopup.s_height;
   Rect backgroundRect1 = this.backgroundRect;
   backgroundRect1.height = 16f;
   Rect backgroundRect2 = this.backgroundRect;
   backgroundRect2.y += 16f;
   backgroundRect2.height = (float) DopeSheetEditor.DopeSheetPopup.s_width;
   GUI.Box(this.backgroundRect, string.Empty);
   GUI.Box(backgroundRect2, (Texture) AssetPreview.GetAssetPreview((UnityEngine.Object) keyframe.value));
   EditorGUI.BeginChangeCheck();
   UnityEngine.Object @object = EditorGUI.ObjectField(backgroundRect1, (UnityEngine.Object) keyframe.value, keyframe.curve.m_ValueType, false);
   if (!EditorGUI.EndChangeCheck())
     return;
   keyframe.value = (object) @object;
   state.SaveCurve(keyframe.curve);
 }
Exemple #18
0
 private float GetKeyframeOffset(DopeLine dopeline, AnimationWindowKeyframe keyframe)
 {
     if ((!dopeline.isPptrDopeline || !dopeline.tallMode) || ((keyframe != null) && (keyframe.value == null)))
     {
         return -5.5f;
     }
     return -1f;
 }
 public void PasteKeys()
 {
   if (AnimationWindowState.s_KeyframeClipboard == null)
     AnimationWindowState.s_KeyframeClipboard = new List<AnimationWindowKeyframe>();
   HashSet<int> intSet = new HashSet<int>((IEnumerable<int>) this.m_SelectedKeyHashes);
   this.ClearKeySelections();
   AnimationWindowCurve animationWindowCurve1 = (AnimationWindowCurve) null;
   AnimationWindowCurve animationWindowCurve2 = (AnimationWindowCurve) null;
   float startTime = 0.0f;
   List<AnimationWindowCurve> source = new List<AnimationWindowCurve>();
   using (List<AnimationWindowKeyframe>.Enumerator enumerator = AnimationWindowState.s_KeyframeClipboard.GetEnumerator())
   {
     while (enumerator.MoveNext())
     {
       AnimationWindowKeyframe current = enumerator.Current;
       if (!source.Any<AnimationWindowCurve>() || source.Last<AnimationWindowCurve>() != current.curve)
         source.Add(current.curve);
     }
   }
   bool flag = source.Count<AnimationWindowCurve>() == this.activeCurves.Count<AnimationWindowCurve>();
   int index = 0;
   using (List<AnimationWindowKeyframe>.Enumerator enumerator = AnimationWindowState.s_KeyframeClipboard.GetEnumerator())
   {
     while (enumerator.MoveNext())
     {
       AnimationWindowKeyframe current = enumerator.Current;
       if (animationWindowCurve2 != null && current.curve != animationWindowCurve2)
         ++index;
       AnimationWindowKeyframe keyframe = new AnimationWindowKeyframe(current);
       keyframe.curve = !flag ? AnimationWindowUtility.BestMatchForPaste(keyframe.curve.binding, this.activeCurves) : this.activeCurves[index];
       if (keyframe.curve == null)
       {
         keyframe.curve = new AnimationWindowCurve(this.activeAnimationClip, current.curve.binding, current.curve.type);
         keyframe.time = current.time;
       }
       keyframe.time += this.time.time;
       if (keyframe.curve != null)
       {
         if (keyframe.curve.HasKeyframe(AnimationKeyTime.Time(keyframe.time, this.frameRate)))
           keyframe.curve.RemoveKeyframe(AnimationKeyTime.Time(keyframe.time, this.frameRate));
         if (animationWindowCurve1 == keyframe.curve)
           keyframe.curve.RemoveKeysAtRange(startTime, keyframe.time);
         keyframe.curve.m_Keyframes.Add(keyframe);
         this.SelectKey(keyframe);
         this.SaveCurve(keyframe.curve);
         animationWindowCurve1 = keyframe.curve;
         startTime = keyframe.time;
       }
       animationWindowCurve2 = current.curve;
     }
   }
   if (this.m_SelectedKeyHashes.Count == 0)
     this.m_SelectedKeyHashes = intSet;
   else
     this.ResampleAnimation();
 }
		private Rect GetKeyframeRect(DopeLine dopeline, AnimationWindowKeyframe keyframe)
		{
			return this.GetKeyframeRect(dopeline, this.state.SnapToFrame(keyframe.time));
		}
		private void HandlePaste()
		{
			this.state.ClearKeySelections();
			foreach (AnimationWindowKeyframe current in this.m_KeyframeClipboard)
			{
				AnimationWindowKeyframe animationWindowKeyframe = new AnimationWindowKeyframe(current);
				animationWindowKeyframe.time += this.state.GetTimeSeconds();
				animationWindowKeyframe.curve.m_Keyframes.Add(animationWindowKeyframe);
				this.state.SelectKey(animationWindowKeyframe);
				this.state.SaveCurve(current.curve);
			}
		}
 private Rect GetKeyframeRect(DopeLine dopeline, AnimationWindowKeyframe keyframe)
 {
   float time = keyframe == null ? 0.0f : keyframe.time;
   float width = 10f;
   if (dopeline.isPptrDopeline && dopeline.tallMode && (keyframe == null || keyframe.value != null))
     width = dopeline.position.height;
   if (dopeline.isPptrDopeline && dopeline.tallMode)
     return new Rect(this.state.TimeToPixel(this.state.SnapToFrame(time)) + this.GetKeyframeOffset(dopeline, keyframe), dopeline.position.yMin, width, dopeline.position.height);
   return new Rect(this.state.TimeToPixel(this.state.SnapToFrame(time)) + this.GetKeyframeOffset(dopeline, keyframe), dopeline.position.yMin, width, dopeline.position.height);
 }
 public static AnimationWindowKeyframe AddKeyframeToCurve(AnimationWindowCurve curve, object value, System.Type type, AnimationKeyTime time)
 {
   AnimationWindowKeyframe keyAtTime = curve.FindKeyAtTime(time);
   if (keyAtTime != null)
   {
     keyAtTime.value = value;
     return keyAtTime;
   }
   AnimationWindowKeyframe key1 = new AnimationWindowKeyframe();
   key1.time = time.time;
   if (curve.isPPtrCurve)
   {
     key1.value = value;
     key1.curve = curve;
     curve.AddKeyframe(key1, time);
   }
   else if (type == typeof (bool) || type == typeof (float))
   {
     AnimationCurve animationCurve = curve.ToAnimationCurve();
     Keyframe key2 = new Keyframe(time.time, (float) value);
     if (type == typeof (bool))
     {
       CurveUtility.SetKeyTangentMode(ref key2, 0, TangentMode.Stepped);
       CurveUtility.SetKeyTangentMode(ref key2, 1, TangentMode.Stepped);
       CurveUtility.SetKeyBroken(ref key2, true);
       key1.m_TangentMode = key2.tangentMode;
       key1.m_InTangent = float.PositiveInfinity;
       key1.m_OutTangent = float.PositiveInfinity;
     }
     else
     {
       int keyIndex = animationCurve.AddKey(key2);
       if (keyIndex != -1)
       {
         CurveUtility.SetKeyModeFromContext(animationCurve, keyIndex);
         key1.m_TangentMode = animationCurve[keyIndex].tangentMode;
       }
     }
     key1.value = value;
     key1.curve = curve;
     curve.AddKeyframe(key1, time);
   }
   return key1;
 }
 private void CreateNewPPtrKeyframe(float time, UnityEngine.Object value, AnimationWindowCurve targetCurve)
 {
   AnimationWindowKeyframe animationWindowKeyframe = new AnimationWindowKeyframe(targetCurve, new ObjectReferenceKeyframe() { time = time, value = value });
   AnimationKeyTime keyTime = AnimationKeyTime.Time(animationWindowKeyframe.time, this.state.frameRate);
   targetCurve.AddKeyframe(animationWindowKeyframe, keyTime);
   this.state.SelectKey(animationWindowKeyframe);
 }
Exemple #25
0
        private void DoValueField(Rect rect, AnimationWindowHierarchyNode node, int row)
        {
            bool flag1 = false;

            if (!AnimationMode.InAnimationMode())
            {
                return;
            }
            EditorGUI.BeginDisabledGroup(this.state.animationIsReadOnly);
            if (node is AnimationWindowHierarchyPropertyNode)
            {
                List <AnimationWindowCurve> curves = this.state.GetCurves(node, false);
                if (curves == null || curves.Count == 0)
                {
                    return;
                }
                AnimationWindowCurve curve       = curves[0];
                object      currentValue         = CurveBindingUtility.GetCurrentValue(this.state.activeRootGameObject, curve.binding);
                System.Type editorCurveValueType = CurveBindingUtility.GetEditorCurveValueType(this.state.activeRootGameObject, curve.binding);
                if (currentValue is float)
                {
                    float num      = (float)currentValue;
                    Rect  position = new Rect(rect.xMax - 75f, rect.y, 50f, rect.height);
                    if (Event.current.type == EventType.MouseMove && position.Contains(Event.current.mousePosition))
                    {
                        AnimationWindowHierarchyGUI.s_WasInsideValueRectFrame = Time.frameCount;
                    }
                    EditorGUI.BeginChangeCheck();
                    float f;
                    if (editorCurveValueType == typeof(bool))
                    {
                        f = !EditorGUI.Toggle(position, (double)num != 0.0) ? 0.0f : 1f;
                    }
                    else
                    {
                        int  controlId = GUIUtility.GetControlID(123456544, FocusType.Keyboard, position);
                        bool flag2     = GUIUtility.keyboardControl == controlId && EditorGUIUtility.editingTextField && Event.current.type == EventType.KeyDown && ((int)Event.current.character == 10 || (int)Event.current.character == 3);
                        f = EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor, position, new Rect(0.0f, 0.0f, 0.0f, 0.0f), controlId, num, EditorGUI.kFloatFieldFormatString, this.m_AnimationSelectionTextField, false);
                        if (flag2)
                        {
                            GUI.changed = true;
                            Event.current.Use();
                        }
                    }
                    if (float.IsInfinity(f) || float.IsNaN(f))
                    {
                        f = 0.0f;
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        AnimationWindowKeyframe animationWindowKeyframe = (AnimationWindowKeyframe)null;
                        using (List <AnimationWindowKeyframe> .Enumerator enumerator = curve.m_Keyframes.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                AnimationWindowKeyframe current = enumerator.Current;
                                if (Mathf.Approximately(current.time, this.state.time.time))
                                {
                                    animationWindowKeyframe = current;
                                }
                            }
                        }
                        if (animationWindowKeyframe == null)
                        {
                            AnimationWindowUtility.AddKeyframeToCurve(curve, (object)f, editorCurveValueType, this.state.time);
                        }
                        else
                        {
                            animationWindowKeyframe.value = (object)f;
                        }
                        this.state.SaveCurve(curve);
                        flag1 = true;
                    }
                }
            }
            EditorGUI.EndDisabledGroup();
            if (!flag1)
            {
                return;
            }
            this.state.ResampleAnimation();
        }