Exemplo n.º 1
0
        public static AnimatorStateTransition GetTransitionTo(FPlayAnimationEvent animEvt)
        {
            FAnimationTrack animTrack = (FAnimationTrack)animEvt.Track;

            if (animTrack.AnimatorController == null)
            {
                return(null);
            }

            AnimatorController controller = (AnimatorController)animTrack.AnimatorController;

            AnimatorState animState = null;

            AnimatorControllerLayer layer = FindLayer(controller, ((FAnimationTrack)animEvt.Track).LayerName);

            if (layer == null)
            {
                return(null);
            }

            if (layer.stateMachine.stateMachines.Length == 0)
            {
                return(null);
            }

            ChildAnimatorStateMachine fluxSM = layer.stateMachine.stateMachines[0];

            AnimatorStateMachine stateMachine = fluxSM.stateMachine;

            for (int i = 0; i != stateMachine.states.Length; ++i)
            {
                if (stateMachine.states[i].state.nameHash == animEvt._stateHash)
                {
                    animState = stateMachine.states[i].state;
                    break;
                }
            }

            if (animState == null)
            {
                //				Debug.LogError("Couldn't find state " + animEvt._animationClip );
                return(null);
            }

            for (int i = 0; i != stateMachine.states.Length; ++i)
            {
                AnimatorState state = stateMachine.states[i].state;

                AnimatorStateTransition[] transitions = state.transitions;
                for (int j = 0; j != transitions.Length; ++j)
                {
                    if (transitions[j].destinationState == animState)
                    {
                        return(transitions[j]);
                    }
                }
            }

            return(null);
        }
Exemplo n.º 2
0
 public static void CheckDeleteAnimation(FPlayAnimationEvent animEvt)
 {
     if (animEvt._animationClip != null)
     {
         Undo.RecordObject(animEvt._animationClip, "DeleteAnimation");
     }
 }
//		public override void OnTogglePreview ()
//		{
////			int currentFrame = Track.Sequence.GetCurrentFrame();
//
//			base.OnTogglePreview();
//
////			if( currentFrame >= 0 )
////				SequenceEditor.SetCurrentFrame( currentFrame );
//		}

        public override void Render(Rect rect, float headerWidth)
        {
//			bool isPreviewing = _track.IsPreviewing;

            base.Render(rect, headerWidth);

//			if( isPreviewing != _track.IsPreviewing )
//			{
//				if( Event.current.alt )
//					SyncWithAnimationWindow = true;
//			}

            switch (Event.current.type)
            {
            case EventType.DragUpdated:
                if (rect.Contains(Event.current.mousePosition))
                {
                    int numAnimationsDragged = FAnimationEventInspector.NumAnimationsDragAndDrop(Track.Sequence.FrameRate);
                    int frame = SequenceEditor.GetFrameForX(Event.current.mousePosition.x);

                    DragAndDrop.visualMode = numAnimationsDragged > 0 && Track.CanAddAt(frame) ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.Rejected;
                    Event.current.Use();
                }
                break;

            case EventType.DragPerform:
                if (rect.Contains(Event.current.mousePosition))
                {
                    AnimationClip animClip = FAnimationEventInspector.GetAnimationClipDragAndDrop(Track.Sequence.FrameRate);

                    if (animClip && Mathf.Approximately(animClip.frameRate, Track.Sequence.FrameRate))
                    {
                        int frame = SequenceEditor.GetFrameForX(Event.current.mousePosition.x);
                        int maxLength;

                        if (Track.CanAddAt(frame, out maxLength))
                        {
                            FPlayAnimationEvent animEvt = FEvent.Create <FPlayAnimationEvent>(new FrameRange(frame, frame + Mathf.Min(maxLength, Mathf.RoundToInt(animClip.length * animClip.frameRate))));
                            Track.Add(animEvt);
                            FAnimationEventInspector.SetAnimationClip(animEvt, animClip);
                            DragAndDrop.AcceptDrag();
                        }
                    }

                    Event.current.Use();
                }
                break;
            }

//			if( _wasPreviewing != _track.IsPreviewing )
//			{
//				if( _wasPreviewing )
//					SequenceEditor.OnUpdateEvent.RemoveListener( OnUpdate );
//				else
//					SequenceEditor.OnUpdateEvent.AddListener( OnUpdate );
//
//				_wasPreviewing = _track.IsPreviewing;
//			}
        }
Exemplo n.º 4
0
        protected override void Init(FObject obj)
        {
            base.Init(obj);

            _animEvt = (FPlayAnimationEvent)_evt;

            _animTrack = (FAnimationTrack)_animEvt.GetTrack();
        }
        public static void SetAnimationClip(FPlayAnimationEvent animEvent, AnimationClip animClip)
        {
            FAnimationEventInspector editor = (FAnimationEventInspector)CreateEditor(animEvent, typeof(FAnimationEventInspector));

            editor.SetAnimationClip(animClip);

            DestroyImmediate(editor);
            FAnimationTrackInspector.RebuildStateMachine((FAnimationTrack)animEvent.GetTrack());
        }
Exemplo n.º 6
0
 public static void CheckDeleteAnimation(FPlayAnimationEvent animEvt)
 {
     if (animEvt._animationClip != null && Flux.FUtility.IsAnimationEditable(animEvt._animationClip) &&            /*AssetDatabase.IsSubAsset( animEvt._animationClip )*/
         EditorUtility.DisplayDialog("Delete animation?",
                                     string.Format("The animation clip '{0}' is stored inside an animator controller, do you want to delete it?", animEvt._animationClip.name),
                                     "Delete", "Keep"))
     {
         Undo.DestroyObjectImmediate(animEvt._animationClip);
         AssetDatabase.SaveAssets();
     }
 }
Exemplo n.º 7
0
        private void PreviewAnimationEvent(FAnimationEventEditor animEvtEditor, int frame)
        {
            FPlayAnimationEvent animEvt = (FPlayAnimationEvent)animEvtEditor._evt;

            if (animEvt._animationClip == null)
            {
                return;
            }

            bool isEditable = animEvt.IsAnimationEditable();

            // render path
            if (isEditable)
            {
                TransformCurves transformCurves = new TransformCurves(animEvt.Owner, animEvt._animationClip);

                RenderTransformPath(transformCurves, animEvt.LengthTime, 1f / animEvt.Sequence.FrameRate);

                float t = (float)(frame + animEvt._startOffset - animEvt.Start) / animEvt.Sequence.FrameRate;

                if (animEvt.FrameRange.Contains(frame))
                {
//					float t = (float)(frame + animEvt._startOffset - animEvt.Start) / animEvt.Sequence.FrameRate;
                    RenderTransformAnimation(transformCurves, t);
                }

//				AnimationClipCurveData[] allCurves = AnimationUtility.GetAllCurves( animEvt._animationClip, true );
//				foreach( AnimationClipCurveData curve in allCurves )
//				{
//
//				}
            }
            else if (animEvt.FrameRange.Contains(frame))
            {
                float t = (float)(frame + animEvt._startOffset - animEvt.Start) / animEvt.Sequence.FrameRate;

                bool wasInAnimationMode = AnimationMode.InAnimationMode();

                if (!AnimationMode.InAnimationMode())
                {
                    AnimationMode.StartAnimationMode();
                }
                AnimationMode.BeginSampling();
                AnimationMode.SampleAnimationClip(animEvt.Owner.gameObject, animEvt._animationClip, t);
                AnimationMode.EndSampling();

                if (!wasInAnimationMode)
                {
                    AnimationMode.StopAnimationMode();
                }
            }
        }
Exemplo n.º 8
0
        public static void Resize(FEvent evt, FrameRange newFrameRange)
        {
            if (evt.FrameRange == newFrameRange || newFrameRange.Start > newFrameRange.End)
            {
                return;
            }

            if (newFrameRange.Length < evt.GetMinLength() || newFrameRange.Length > evt.GetMaxLength())
            {
                Debug.LogError(string.Format("Trying to resize an Event to [{0},{1}] (length: {2}) which isn't a valid length, should be between [{3},{4}]", newFrameRange.Start, newFrameRange.End, newFrameRange.Length, evt.GetMinLength(), evt.GetMaxLength()), evt);
                return;
            }

            bool changedLength = evt.Length != newFrameRange.Length;

            if (!evt.GetTrack().CanAdd(evt, newFrameRange))
            {
                return;
            }

            Undo.RecordObject(evt, changedLength ? "Resize Event" : "Move Event");

            evt.Start = newFrameRange.Start;
            evt.End   = newFrameRange.End;

            if (changedLength)
            {
                if (evt is FPlayAnimationEvent)
                {
                    FPlayAnimationEvent animEvt = (FPlayAnimationEvent)evt;

                    if (animEvt.IsAnimationEditable())
                    {
                        FAnimationEventInspector.ScaleAnimationClip(animEvt._animationClip, animEvt.FrameRange);
                    }
                }
                else if (evt is FTimescaleEvent)
                {
                    ResizeAnimationCurve((FTimescaleEvent)evt, newFrameRange);
                }
            }

            EditorUtility.SetDirty(evt);

            if (FSequenceEditorWindow.instance != null)
            {
                FSequenceEditorWindow.instance.Repaint();
            }
        }
        private void OnUpdate()
        {
            if (!_syncWithAnimationWindow)
            {
                return;
            }

            if (Selection.activeTransform != Track.Owner)
            {
                Selection.activeTransform = Track.Owner;
            }

            if (!AnimationMode.InAnimationMode())
            {
//				AnimationMode.StartAnimationMode();
                AnimationWindowProxy.StartAnimationMode();
            }

//			if( _track.IsPreviewing )
            {
                int animWindowFrame = AnimationWindowProxy.GetCurrentFrame();

                FEvent[] evts    = new FEvent[2];
                int      numEvts = Track.GetEventsAt(SequenceEditor.Sequence.CurrentFrame, ref evts);

                if (numEvts > 0)
                {
                    FPlayAnimationEvent animEvt = (FPlayAnimationEvent)evts[numEvts - 1];
                    if (animEvt.ControlsAnimation)
                    {
                        int normCurrentFrame = SequenceEditor.Sequence.CurrentFrame - animEvt.Start;

                        if (animWindowFrame > animEvt.Length)
                        {
                            animWindowFrame = animEvt.Length;
                            AnimationWindowProxy.SetCurrentFrame(animWindowFrame, animEvt.LengthTime);
                        }

                        if (animWindowFrame >= 0 && animWindowFrame != normCurrentFrame)
                        {
                            SequenceEditor.SetCurrentFrame(animEvt.Start + animWindowFrame);
                            SequenceEditor.Repaint();
                            //						Debug.Log( "AnimWindow->Flux: " + (animEvt.Start + animWindowFrame) );
                        }
                    }
                }
            }
        }
Exemplo n.º 10
0
        protected override void OnEnable()
        {
            base.OnEnable();

            if (target == null)
            {
                DestroyImmediate(this);
                return;
            }
            _animEvent     = (FPlayAnimationEvent)target;
            _animationClip = serializedObject.FindProperty("_animationClip");

            _startOffset = serializedObject.FindProperty("_startOffset");

            _frameRange = serializedObject.FindProperty("_frameRange");
        }
Exemplo n.º 11
0
        void OnSceneGUI(SceneView sceneView)
        {
            if (_track == null)
            {
                return;
            }

            for (int i = 0; i != _eventEditors.Count; ++i)
            {
                FAnimationEventEditor animEvtEditor = (FAnimationEventEditor)_eventEditors[i];
                FPlayAnimationEvent   animEvt       = (FPlayAnimationEvent)_eventEditors[i]._evt;
                if (animEvt._animationClip != null && animEvt.IsAnimationEditable() && _track.IsPreviewing)
                {
                    animEvtEditor.RenderTransformCurves(animEvt.Sequence.FrameRate);
                }
            }
        }
Exemplo n.º 12
0
        public override void UpdateEventsEditor(int frame, float time)
        {
            if (Track.RequiresEditorCache && Track.CanPreview && !Track.HasCache)
            {
                Track.CanPreview = false;
                OnTogglePreview(true);
            }

            base.UpdateEventsEditor(frame, time);
            FEvent[] evts    = new FEvent[2];
            int      numEvts = Track.GetEventsAt(frame, ref evts);

            if (numEvts > 0)
            {
//				if( AnimationMode.InAnimationMode() )
                if (_syncWithAnimationWindow)                 //&& _track.IsPreviewing )
                {
//					Debug.Log( SequenceEditor.OnUpdateEvent );
//					AnimationMode.StartAnimationMode();

//					System.Type t = typeof(EditorWindow).Assembly.GetType("UnityEditor.AnimationWindow");
//					EditorWindow animWindow = EditorWindow.GetWindow( t );
//
//
//					PropertyInfo stateProperty = t.GetProperty("state", BindingFlags.Instance | BindingFlags.Public);
//					object state = stateProperty.GetValue( animWindow, null );
//
//					Type stateT = typeof(EditorWindow).Assembly.GetType("UnityEditorInternal.AnimationWindowState");
//					FieldInfo timeField = stateT.GetField("m_PlayTime");
//					timeField.SetValue( state, time );
//
//					FieldInfo frameField = stateT.GetField("m_Frame");
//					frameField.SetValue( state, frame );

//					if( !AnimationMode.InAnimationMode() )
//						AnimationMode.StartAnimationMode();

                    FPlayAnimationEvent animEvt = (FPlayAnimationEvent)evts[numEvts - 1];
                    AnimationWindowProxy.SelectAnimationClip(animEvt._animationClip);
                    AnimationWindowProxy.SetCurrentFrame(frame - animEvt.Start, time - animEvt.StartTime);
//					Debug.Log("Flux->AnimWindow: " + (frame - animEvt.Start));
                }
            }
        }
Exemplo n.º 13
0
 public static UnityEditor.Animations.AnimatorTransition GetTransitionTo(FPlayAnimationEvent animEvt)
 {
     /*
      *          FAnimationTrack animTrack = (FAnimationTrack)animEvt.GetTrack();
      *
      *          if( animTrack.GetAnimatorController() == null )
      *                  return null;
      *
      *          UnityEditor.Animations.AnimatorController controller = (UnityEditor.Animations.AnimatorController)animTrack.GetAnimatorController();
      *
      *          UnityEditor.Animations.AnimatorState animState = null;
      *
      *          UnityEditor.Animations.AnimatorStateMachine stateMachine = controller.GetLayer(0).stateMachine;
      *
      *          for( int i = 0; i != stateMachine.stateCount; ++i )
      *          {
      *                  if( stateMachine.GetState(i).uniqueNameHash == animEvt._stateHash )
      *                  {
      *                          animState = stateMachine.GetState(i);
      *                          break;
      *                  }
      *          }
      *
      *          if( animState == null )
      *          {
      * //				Debug.LogError("Couldn't find state " + animEvt._animationClip );
      *                  return null;
      *          }
      *
      *          for( int i = 0; i != stateMachine.stateCount; ++i )
      *          {
      *                  UnityEditor.Animations.AnimatorState state = stateMachine.GetState(i);
      *                  UnityEditor.Animations.AnimatorTransition[] transitions = stateMachine.GetTransitionsFromState( state );
      *                  for( int j = 0; j != transitions.Length; ++j )
      *                  {
      *                          if( transitions[j].dstState == animState )
      *                          {
      *                                  return transitions[j];
      *                          }
      *                  }
      *          }
      */
     return(null);
 }
Exemplo n.º 14
0
        void OnSceneGUI(SceneView sceneView)
        {
            if (Track == null)
            {
                return;
            }

            for (int i = 0; i != _eventEditors.Count; ++i)
            {
                FAnimationEventEditor animEvtEditor = (FAnimationEventEditor)_eventEditors[i];
                FPlayAnimationEvent   animEvt       = (FPlayAnimationEvent)_eventEditors[i].Evt;
                if (animEvt._animationClip != null && Flux.FUtility.IsAnimationEditable(animEvt._animationClip) && ShowTransformPath /*_track.IsPreviewing*/)
                {
                    animEvtEditor.RenderTransformCurves(animEvt.Sequence.FrameRate);
                }
            }

            SceneView.RepaintAll();
        }
Exemplo n.º 15
0
        public override void Render(Rect rect, float headerWidth)
        {
            base.Render(rect, headerWidth);

            switch (Event.current.type)
            {
            case EventType.DragUpdated:
                if (rect.Contains(Event.current.mousePosition))
                {
                    int numAnimationsDragged = FAnimationEventInspector.NumAnimationsDragAndDrop(Track.Sequence.FrameRate);
                    int frame = SequenceEditor.GetFrameForX(Event.current.mousePosition.x);

                    DragAndDrop.visualMode = numAnimationsDragged > 0 && Track.CanAddAt(frame) ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.Rejected;
                    Event.current.Use();
                }
                break;

            case EventType.DragPerform:
                if (rect.Contains(Event.current.mousePosition))
                {
                    AnimationClip animClip = FAnimationEventInspector.GetAnimationClipDragAndDrop(Track.Sequence.FrameRate);

                    if (animClip && Mathf.Approximately(animClip.frameRate, Track.Sequence.FrameRate))
                    {
                        int frame = SequenceEditor.GetFrameForX(Event.current.mousePosition.x);
                        int maxLength;

                        if (Track.CanAddAt(frame, out maxLength))
                        {
                            FPlayAnimationEvent animEvt = FEvent.Create <FPlayAnimationEvent>(new FrameRange(frame, frame + Mathf.Min(maxLength, Mathf.RoundToInt(animClip.length * animClip.frameRate))));
                            Track.Add(animEvt);
                            FAnimationEventInspector.SetAnimationClip(animEvt, animClip);
                            DragAndDrop.AcceptDrag();
                        }
                    }

                    Event.current.Use();
                }
                break;
            }
        }
Exemplo n.º 16
0
        protected override void OnEnable()
        {
            base.OnEnable();

            if (target == null)
            {
                DestroyImmediate(this);
                return;
            }
            _animEvent     = (FPlayAnimationEvent)target;
            _animationClip = serializedObject.FindProperty("_animationClip");

            _startOffset = serializedObject.FindProperty("_startOffset");
            _blendLength = serializedObject.FindProperty("_blendLength");

            _frameRange = serializedObject.FindProperty("_frameRange");

            _animationClipUI = new GUIContent("动画剪辑");
            _frameRangeUI    = new GUIContent("偏移+混合");
            _startOffsetUI   = new GUIContent("偏移帧数");
            _blendLengthUI   = new GUIContent("混合帧数");
        }
Exemplo n.º 17
0
//		public static void Resize( FEvent evt, FrameRange newFrameRange )
//		{
//			if( evt.FrameRange == newFrameRange || newFrameRange.Start > newFrameRange.End )
//				return;
//
//			if( newFrameRange.Length < evt.GetMinLength() || newFrameRange.Length > evt.GetMaxLength() )
//			{
//				Debug.LogError( string.Format("Trying to resize an Event to [{0},{1}] (length: {2}) which isn't a valid length, should be between [{3},{4}]", newFrameRange.Start, newFrameRange.End, newFrameRange.Length, evt.GetMinLength(), evt.GetMaxLength() ), evt );
//				return;
//			}
//
//			bool changedLength = evt.Length != newFrameRange.Length;
//
//			if( !evt.GetTrack().CanAdd( evt, newFrameRange ) )
//				return;
//
//			Undo.RecordObject( evt, changedLength ? "Resize Event" : "Move Event" );
//
//			evt.Start = newFrameRange.Start;
//			evt.End = newFrameRange.End;
//
//			if( changedLength )
//			{
//				if( evt is FPlayAnimationEvent )
//				{
//					FPlayAnimationEvent animEvt = (FPlayAnimationEvent)evt;
//
//					if( animEvt.IsAnimationEditable() )
//					{
//						FAnimationEventInspector.ScaleAnimationClip( animEvt._animationClip, animEvt.FrameRange );
//					}
//				}
//				else if( evt is FTimescaleEvent )
//				{
//					ResizeAnimationCurve( (FTimescaleEvent)evt, newFrameRange );
//				}
//			}
//
//			EditorUtility.SetDirty( evt );
//
//			if( FSequenceEditorWindow.instance != null )
//				FSequenceEditorWindow.instance.Repaint();
//		}

        public static void Rescale(FEvent evt, FrameRange newFrameRange)
        {
            if (evt.FrameRange == newFrameRange)
            {
                return;
            }

            Undo.RecordObject(evt, string.Empty);

            evt.Start = newFrameRange.Start;
            evt.End   = newFrameRange.End;

            if (evt is FPlayAnimationEvent)
            {
                FPlayAnimationEvent animEvt = (FPlayAnimationEvent)evt;

                if (animEvt._animationClip != null)
                {
                    if (Flux.FUtility.IsAnimationEditable(animEvt._animationClip))
                    {
                        animEvt._animationClip.frameRate = animEvt.Sequence.FrameRate;
                        EditorUtility.SetDirty(animEvt._animationClip);
                    }
                    else if (Mathf.RoundToInt(animEvt._animationClip.frameRate) != animEvt.Sequence.FrameRate)
                    {
                        Debug.LogError(string.Format("Removed AnimationClip '{0}' ({1} fps) from Animation Event '{2}'",
                                                     animEvt._animationClip.name,
                                                     animEvt._animationClip.frameRate,
                                                     animEvt.name), animEvt);

                        animEvt._animationClip = null;
                    }
                }
            }

            EditorUtility.SetDirty(evt);
        }
Exemplo n.º 18
0
        public static AnimationClip CreateAnimationClip(FPlayAnimationEvent animEvent)
        {
            string filePath = EditorUtility.SaveFilePanelInProject("Create Animation...", animEvent.Owner.name, "anim", "Choose path...");

            if (string.IsNullOrEmpty(filePath))
            {
                return(null);
            }

            AnimationClip clip = UnityEditor.Animations.AnimatorController.AllocateAnimatorClip(System.IO.Path.GetFileNameWithoutExtension(filePath));

            clip.frameRate = animEvent.Sequence.FrameRate;

            Transform ownerTransform = animEvent.Owner;

            Vector3    pos = ownerTransform.localPosition;
            Quaternion rot = ownerTransform.localRotation;

            Keyframe[] xPosKeys = new Keyframe[] { new Keyframe(0, pos.x), new Keyframe(animEvent.LengthTime, pos.x) };
            Keyframe[] yPosKeys = new Keyframe[] { new Keyframe(0, pos.y), new Keyframe(animEvent.LengthTime, pos.y) };
            Keyframe[] zPosKeys = new Keyframe[] { new Keyframe(0, pos.z), new Keyframe(animEvent.LengthTime, pos.z) };

            Keyframe[] xRotKeys = new Keyframe[] { new Keyframe(0, rot.x), new Keyframe(animEvent.LengthTime, rot.x) };
            Keyframe[] yRotKeys = new Keyframe[] { new Keyframe(0, rot.y), new Keyframe(animEvent.LengthTime, rot.y) };
            Keyframe[] zRotKeys = new Keyframe[] { new Keyframe(0, rot.z), new Keyframe(animEvent.LengthTime, rot.z) };
            Keyframe[] wRotKeys = new Keyframe[] { new Keyframe(0, rot.w), new Keyframe(animEvent.LengthTime, rot.w) };

            // set the tangent mode
            int tangentMode = 10;             // 10 is unity auto tangent mode

            for (int i = 0; i != xPosKeys.Length; ++i)
            {
                xPosKeys[i].tangentMode = tangentMode;
                yPosKeys[i].tangentMode = tangentMode;
                zPosKeys[i].tangentMode = tangentMode;

                xRotKeys[i].tangentMode = tangentMode;
                yRotKeys[i].tangentMode = tangentMode;
                zRotKeys[i].tangentMode = tangentMode;
                wRotKeys[i].tangentMode = tangentMode;
            }

            AnimationCurve xPos = new AnimationCurve(xPosKeys);
            AnimationCurve yPos = new AnimationCurve(yPosKeys);
            AnimationCurve zPos = new AnimationCurve(zPosKeys);

            AnimationCurve xRot = new AnimationCurve(xRotKeys);
            AnimationCurve yRot = new AnimationCurve(yRotKeys);
            AnimationCurve zRot = new AnimationCurve(zRotKeys);
            AnimationCurve wRot = new AnimationCurve(wRotKeys);

            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.PPtrCurve(string.Empty, typeof(Transform), "m_LocalPosition.x"), xPos);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.PPtrCurve(string.Empty, typeof(Transform), "m_LocalPosition.y"), yPos);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.PPtrCurve(string.Empty, typeof(Transform), "m_LocalPosition.z"), zPos);

            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.PPtrCurve(string.Empty, typeof(Transform), "m_LocalRotation.x"), xRot);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.PPtrCurve(string.Empty, typeof(Transform), "m_LocalRotation.y"), yRot);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.PPtrCurve(string.Empty, typeof(Transform), "m_LocalRotation.z"), zRot);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.PPtrCurve(string.Empty, typeof(Transform), "m_LocalRotation.w"), wRot);

            clip.EnsureQuaternionContinuity();

            AssetDatabase.CreateAsset(clip, filePath);

            FAnimationEventInspector.SetAnimationClip(animEvent, clip);

            return(clip);
        }
Exemplo n.º 19
0
        private void UpdateEventFromController()
        {
            bool isBlending = AnimEvt.IsBlending();

            if (isBlending)
            {
                if (_transitionToState == null)
                {
                    _transitionToState = FAnimationTrackInspector.GetTransitionTo(AnimEvt);

                    if (_transitionToState == null || _transitionToState.conditions.Length > 0)
                    {
                        FAnimationTrackInspector.RebuildStateMachine((FAnimationTrack)TrackEditor.Track);

                        _transitionToState = FAnimationTrackInspector.GetTransitionTo(AnimEvt);
                    }
                }

                if (_transitionSO == null)
                {
                    if (_transitionToState != null)
                    {
                        _transitionSO       = new SerializedObject(_transitionToState);
                        _transitionExitTime = _transitionSO.FindProperty("m_ExitTime");
                        _transitionDuration = _transitionSO.FindProperty("m_TransitionDuration");
                        _transitionOffset   = _transitionSO.FindProperty("m_TransitionOffset");
                    }
                }
                else if (_transitionSO.targetObject == null)
                {
                    _transitionExitTime = null;
                    _transitionDuration = null;
                    _transitionOffset   = null;
                    _transitionSO       = null;
                }
            }
            else
            {
                if (_transitionToState != null || _transitionSO != null)
                {
                    _transitionToState  = null;
                    _transitionSO       = null;
                    _transitionExitTime = null;
                    _transitionOffset   = null;
                    _transitionDuration = null;
                }
            }

            if (_transitionSO != null)
            {
                _transitionSO.Update();
                _animEvtSO.Update();

                FPlayAnimationEvent prevAnimEvt     = (FPlayAnimationEvent)AnimTrack.Events[AnimEvt.GetId() - 1];
                AnimationClip       prevAnimEvtClip = prevAnimEvt._animationClip;
                if (prevAnimEvtClip != null)
                {
                    float blendSeconds = _blendLength.intValue / prevAnimEvtClip.frameRate;

                    if (!Mathf.Approximately(blendSeconds, _transitionDuration.floatValue))
                    {
                        _transitionDuration.floatValue = blendSeconds;
                        float p = blendSeconds / prevAnimEvtClip.length;
                        _transitionExitTime.floatValue = p > 1f ? 1f : 1f - Mathf.Clamp01(blendSeconds / prevAnimEvtClip.length);
                        _animEvtSO.ApplyModifiedProperties();
                    }

                    float startOffsetNorm = _startOffset.intValue / AnimEvt._animationClip.frameRate / AnimEvt._animationClip.length;

                    if (!Mathf.Approximately(startOffsetNorm, _transitionOffset.floatValue))
                    {
                        _transitionOffset.floatValue = startOffsetNorm;
                        _animEvtSO.ApplyModifiedProperties();
                    }
                }
                _transitionSO.ApplyModifiedProperties();
            }
        }
Exemplo n.º 20
0
        protected override void RenderEvent(FrameRange viewRange, FrameRange validKeyframeRange)
        {
            if (_animEvtSO == null)
            {
                _animEvtSO   = new SerializedObject(AnimEvt);
                _blendLength = _animEvtSO.FindProperty("_blendLength");
                _startOffset = _animEvtSO.FindProperty("_startOffset");
            }

            UpdateEventFromController();

            _animEvtSO.Update();

            FAnimationTrackEditor animTrackEditor = (FAnimationTrackEditor)TrackEditor;

            Rect transitionOffsetRect = _eventRect;

            int startOffsetHandleId = EditorGUIUtility.GetControlID(FocusType.Passive);
            int transitionHandleId  = EditorGUIUtility.GetControlID(FocusType.Passive);

            bool isBlending     = AnimEvt.IsBlending();
            bool isAnimEditable = Flux.FUtility.IsAnimationEditable(AnimEvt._animationClip);

            if (isBlending)
            {
                transitionOffsetRect.xMin  = Rect.xMin + SequenceEditor.GetXForFrame(AnimEvt.Start + AnimEvt._blendLength) - 3;
                transitionOffsetRect.width = 6;
                transitionOffsetRect.yMin  = transitionOffsetRect.yMax - 8;
            }

            switch (Event.current.type)
            {
            case EventType.MouseDown:
                if (EditorGUIUtility.hotControl == 0 && Event.current.alt && !isAnimEditable)
                {
                    if (isBlending && transitionOffsetRect.Contains(Event.current.mousePosition))
                    {
                        EditorGUIUtility.hotControl = transitionHandleId;

                        AnimatorWindowProxy.OpenAnimatorWindowWithAnimatorController((AnimatorController)AnimTrack.AnimatorController);

                        if (Selection.activeObject != _transitionToState)
                        {
                            Selection.activeObject = _transitionToState;
                        }

                        Event.current.Use();
                    }
                    else if (_eventRect.Contains(Event.current.mousePosition))
                    {
                        _mouseDown = SequenceEditor.GetFrameForX(Event.current.mousePosition.x) - AnimEvt.Start;

                        EditorGUIUtility.hotControl = startOffsetHandleId;

                        Event.current.Use();
                    }
                }
                break;

            case EventType.Ignore:
            case EventType.MouseUp:
                if (EditorGUIUtility.hotControl == transitionHandleId ||
                    EditorGUIUtility.hotControl == startOffsetHandleId)
                {
                    EditorGUIUtility.hotControl = 0;
                    Event.current.Use();
                }
                break;

            case EventType.MouseDrag:
                if (EditorGUIUtility.hotControl == transitionHandleId)
                {
                    int mouseDragPos = Mathf.Clamp(SequenceEditor.GetFrameForX(Event.current.mousePosition.x - Rect.x) - AnimEvt.Start, 0, AnimEvt.Length);

                    if (_blendLength.intValue != mouseDragPos)
                    {
                        _blendLength.intValue = mouseDragPos;

                        FPlayAnimationEvent prevAnimEvt = (FPlayAnimationEvent)animTrackEditor.Track.GetEvent(AnimEvt.GetId() - 1);

                        if (_transitionDuration != null)
                        {
                            _transitionDuration.floatValue = (_blendLength.intValue / prevAnimEvt._animationClip.frameRate) / prevAnimEvt._animationClip.length;
                        }

                        Undo.RecordObject(this, "Animation Blending");
                    }
                    Event.current.Use();
                }
                else if (EditorGUIUtility.hotControl == startOffsetHandleId)
                {
                    int mouseDragPos = Mathf.Clamp(SequenceEditor.GetFrameForX(Event.current.mousePosition.x - Rect.x) - AnimEvt.Start, 0, AnimEvt.Length);

                    int delta = _mouseDown - mouseDragPos;

                    _mouseDown = mouseDragPos;

                    _startOffset.intValue = Mathf.Clamp(_startOffset.intValue + delta, 0, AnimEvt._animationClip.isLooping ? AnimEvt.Length : Mathf.RoundToInt(AnimEvt._animationClip.length * AnimEvt._animationClip.frameRate) - AnimEvt.Length);

                    if (_transitionOffset != null)
                    {
                        _transitionOffset.floatValue = (_startOffset.intValue / AnimEvt._animationClip.frameRate) / AnimEvt._animationClip.length;
                    }

                    Undo.RecordObject(this, "Animation Offset");

                    Event.current.Use();
                }
                break;
            }

            _animEvtSO.ApplyModifiedProperties();
            if (_transitionSO != null)
            {
                _transitionSO.ApplyModifiedProperties();
            }


            switch (Event.current.type)
            {
            case EventType.DragUpdated:
                if (_eventRect.Contains(Event.current.mousePosition))
                {
                    int numAnimationsDragged = FAnimationEventInspector.NumAnimationsDragAndDrop(Evt.Sequence.FrameRate);
                    DragAndDrop.visualMode = numAnimationsDragged > 0 ? DragAndDropVisualMode.Link : DragAndDropVisualMode.Rejected;
                    Event.current.Use();
                }
                break;

            case EventType.DragPerform:
                if (_eventRect.Contains(Event.current.mousePosition))
                {
                    AnimationClip animationClipDragged = FAnimationEventInspector.GetAnimationClipDragAndDrop(Evt.Sequence.FrameRate);
                    if (animationClipDragged)
                    {
                        int animFrameLength = Mathf.RoundToInt(animationClipDragged.length * animationClipDragged.frameRate);

                        FAnimationEventInspector.SetAnimationClip(AnimEvt, animationClipDragged);

                        FrameRange maxRange = AnimEvt.GetMaxFrameRange();

                        SequenceEditor.MoveEvent(AnimEvt, new FrameRange(AnimEvt.Start, Mathf.Min(AnimEvt.Start + animFrameLength, maxRange.End)));

                        DragAndDrop.AcceptDrag();
                        Event.current.Use();
                    }
                    else
                    {
                        Event.current.Use();
                    }
                }
                break;
            }

//            FrameRange currentRange = Evt.FrameRange;

            base.RenderEvent(viewRange, validKeyframeRange);

//            if( isAnimEditable && currentRange.Length != Evt.FrameRange.Length )
//            {
//                FAnimationEventInspector.ScaleAnimationClip( AnimEvt._animationClip, Evt.FrameRange );
//            }

            if (Event.current.type == EventType.Repaint)
            {
                if (isBlending && !isAnimEditable && viewRange.Contains(AnimEvt.Start + AnimEvt._blendLength))
                {
                    GUISkin skin = FUtility.GetFluxSkin();

                    GUIStyle transitionOffsetStyle = skin.GetStyle("BlendOffset");

                    Texture2D t = FUtility.GetFluxTexture("EventBlend.png");

                    Rect r = new Rect(_eventRect.xMin, _eventRect.yMin + 1, transitionOffsetRect.center.x - _eventRect.xMin, _eventRect.height - 2);

                    Color guiColor = GUI.color;

                    Color c = new Color(1f, 1f, 1f, 0.3f);
                    c.a      *= guiColor.a;
                    GUI.color = c;

                    GUI.DrawTexture(r, t);

                    if (Event.current.alt)
                    {
                        GUI.color = Color.white;
                    }

                    transitionOffsetStyle.Draw(transitionOffsetRect, false, false, false, false);

                    GUI.color = guiColor;

//					Debug.Log ( transitionOffsetRect );
                }

//				GUI.color = Color.red;

                if (EditorGUIUtility.hotControl == transitionHandleId)
                {
                    Rect transitionOffsetTextRect = transitionOffsetRect;
                    transitionOffsetTextRect.y     -= 16;
                    transitionOffsetTextRect.height = 20;
                    transitionOffsetTextRect.width += 50;
                    GUI.Label(transitionOffsetTextRect, AnimEvt._blendLength.ToString(), EditorStyles.label);
                }

                if (EditorGUIUtility.hotControl == startOffsetHandleId)
                {
                    Rect startOffsetTextRect = _eventRect;
                    GUI.Label(startOffsetTextRect, AnimEvt._startOffset.ToString(), EditorStyles.label);
                }
            }
        }
Exemplo n.º 21
0
        public static AnimationClip CreateAnimationClip(FPlayAnimationEvent animEvent)
        {
            FAnimationTrack track = (FAnimationTrack)animEvent.Track;

            string animName = ((FAnimationTrack)animEvent.Track).LayerName + "_" + animEvent.GetId().ToString();

            AnimationClip clip = AnimatorController.AllocateAnimatorClip(animName);

            clip.frameRate = animEvent.Sequence.FrameRate;

            Transform ownerTransform = animEvent.Owner;

            Vector3 pos = ownerTransform.localPosition;

            Vector3 rot = ownerTransform.localRotation.eulerAngles;             //ownerTransform.localEulerAngles;

            Keyframe[] xPosKeys = new Keyframe[] { new Keyframe(0, pos.x), new Keyframe(animEvent.LengthTime, pos.x) };
            Keyframe[] yPosKeys = new Keyframe[] { new Keyframe(0, pos.y), new Keyframe(animEvent.LengthTime, pos.y) };
            Keyframe[] zPosKeys = new Keyframe[] { new Keyframe(0, pos.z), new Keyframe(animEvent.LengthTime, pos.z) };

            Keyframe[] xRotKeys = new Keyframe[] { new Keyframe(0, rot.x), new Keyframe(animEvent.LengthTime, rot.x) };
            Keyframe[] yRotKeys = new Keyframe[] { new Keyframe(0, rot.y), new Keyframe(animEvent.LengthTime, rot.y) };
            Keyframe[] zRotKeys = new Keyframe[] { new Keyframe(0, rot.z), new Keyframe(animEvent.LengthTime, rot.z) };

            // set the tangent mode
            int tangentMode = 10;             // 10 is unity auto tangent mode

            for (int i = 0; i != xPosKeys.Length; ++i)
            {
                xPosKeys[i].tangentMode = tangentMode;
                yPosKeys[i].tangentMode = tangentMode;
                zPosKeys[i].tangentMode = tangentMode;

                xRotKeys[i].tangentMode = tangentMode;
                yRotKeys[i].tangentMode = tangentMode;
                zRotKeys[i].tangentMode = tangentMode;
            }

            AnimationCurve xPos = new AnimationCurve(xPosKeys);
            AnimationCurve yPos = new AnimationCurve(yPosKeys);
            AnimationCurve zPos = new AnimationCurve(zPosKeys);

            AnimationCurve xRot = new AnimationCurve(xRotKeys);
            AnimationCurve yRot = new AnimationCurve(yRotKeys);
            AnimationCurve zRot = new AnimationCurve(zRotKeys);

            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "m_LocalPosition.x"), xPos);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "m_LocalPosition.y"), yPos);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "m_LocalPosition.z"), zPos);

            // workaround unity bug of spilling errors if you just set localEulerAngles
            Quaternion quat = ownerTransform.localRotation;

            Keyframe[]     xQuatKeys = new Keyframe[] { new Keyframe(0, quat.x), new Keyframe(animEvent.LengthTime, quat.x) };
            Keyframe[]     yQuatKeys = new Keyframe[] { new Keyframe(0, quat.y), new Keyframe(animEvent.LengthTime, quat.y) };
            Keyframe[]     zQuatKeys = new Keyframe[] { new Keyframe(0, quat.z), new Keyframe(animEvent.LengthTime, quat.z) };
            Keyframe[]     wQuatKeys = new Keyframe[] { new Keyframe(0, quat.w), new Keyframe(animEvent.LengthTime, quat.w) };
            AnimationCurve xQuat     = new AnimationCurve(xQuatKeys);
            AnimationCurve yQuat     = new AnimationCurve(yQuatKeys);
            AnimationCurve zQuat     = new AnimationCurve(zQuatKeys);
            AnimationCurve wQuat     = new AnimationCurve(wQuatKeys);

            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "m_LocalRotation.x"), xQuat);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "m_LocalRotation.y"), yQuat);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "m_LocalRotation.z"), zQuat);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "m_LocalRotation.w"), wQuat);

            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "localEulerAngles.x"), xRot);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "localEulerAngles.y"), yRot);
            AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "localEulerAngles.z"), zRot);

            clip.EnsureQuaternionContinuity();

            AssetDatabase.AddObjectToAsset(clip, track.AnimatorController);

            AnimationClipSettings clipSettings = AnimationUtility.GetAnimationClipSettings(clip);

            clipSettings.loopTime = false;
            AnimationUtility.SetAnimationClipSettings(clip, clipSettings);

            AssetDatabase.SaveAssets();

            FAnimationEventInspector.SetAnimationClip(animEvent, clip);

            return(clip);
        }
Exemplo n.º 22
0
//        protected override void OnEnable()
//        {
//            base.OnEnable();
//        }
//
//        protected override void OnDestroy()
//        {
//            base.OnDestroy();
//        }

//        protected override void Init( FObject obj )
//        {
//            base.Init( obj,  );
//
//            _animEvt = (FPlayAnimationEvent)_evt;
//
//            _animTrack = (FAnimationTrack)_animEvt.GetTrack();
//
//
//        }

        private void UpdateEventFromController()
        {
            bool isBlending = AnimEvt.IsBlending();

            if (isBlending)
            {
//				FPlayAnimationEvent prevAnimEvt = (FPlayAnimationEvent)_animTrack.GetEvents()[_animEvt.GetId() - 1];

                if (_transitionToState == null)
                {
                    _transitionToState = FAnimationTrackInspector.GetTransitionTo(AnimEvt);

                    if (_transitionToState == null || _transitionToState.conditions.Length > 0)
                    {
//						if( animTrackEditor.PreviewInSceneView )
//							animTrackEditor.ClearPreview();
                        FAnimationTrackInspector.RebuildStateMachine((FAnimationTrack)TrackEditor.Track);

                        _transitionToState = FAnimationTrackInspector.GetTransitionTo(AnimEvt);
                    }
                }
//				else
//				{
//					if( _transitionToState.conditions.Length > 0 )
//					{
//						FAnimationTrackInspector.RebuildStateMachine( (FAnimationTrack)_trackEditor._track );
//					}
//				}

                if (_transitionSO == null)
                {
                    if (_transitionToState != null)
                    {
                        _transitionSO = new SerializedObject(_transitionToState);
//											SerializedProperty p = _transitionSO.GetIterator();
//
//											while( p.Next( true ) )
//												Debug.Log (p.propertyPath );
                        _transitionExitTime = _transitionSO.FindProperty("m_ExitTime");
                        _transitionDuration = _transitionSO.FindProperty("m_TransitionDuration");
                        _transitionOffset   = _transitionSO.FindProperty("m_TransitionOffset");
                    }
                }
                else if (_transitionSO.targetObject == null)
                {
                    _transitionExitTime = null;
                    _transitionDuration = null;
                    _transitionOffset   = null;
                    _transitionSO       = null;
                }
            }
            else
            {
                if (_transitionToState != null || _transitionSO != null)
                {
                    _transitionToState  = null;
                    _transitionSO       = null;
                    _transitionExitTime = null;
                    _transitionOffset   = null;
                    _transitionDuration = null;
                }
            }

            if (_transitionSO != null)
            {
                _transitionSO.Update();
                _animEvtSO.Update();

                FPlayAnimationEvent prevAnimEvt = (FPlayAnimationEvent)AnimTrack.Events[AnimEvt.GetId() - 1];

                AnimationClip prevAnimEvtClip = prevAnimEvt._animationClip;
                if (prevAnimEvtClip != null)
                {
                    float exitTimeNormalized = (prevAnimEvt.Length + prevAnimEvt._startOffset) / (prevAnimEvtClip.frameRate * prevAnimEvtClip.length);

                    if (!Mathf.Approximately(exitTimeNormalized, _transitionExitTime.floatValue))
                    {
                        _transitionExitTime.floatValue = exitTimeNormalized;
                    }

                    float blendNormalized = (_blendLength.intValue / prevAnimEvtClip.frameRate) / prevAnimEvtClip.length;

                    if (!Mathf.Approximately(blendNormalized, _transitionDuration.floatValue))
                    {
                        _blendLength.intValue = Mathf.Clamp(Mathf.RoundToInt(_transitionDuration.floatValue * prevAnimEvtClip.length * prevAnimEvtClip.frameRate), 0, AnimEvt.Length);

                        _transitionDuration.floatValue = (_blendLength.intValue / prevAnimEvtClip.frameRate) / prevAnimEvtClip.length;

                        _animEvtSO.ApplyModifiedProperties();
                    }

                    float startOffsetNorm = (_startOffset.intValue / AnimEvt._animationClip.frameRate) / AnimEvt._animationClip.length;

                    if (!Mathf.Approximately(startOffsetNorm, _transitionOffset.floatValue))
                    {
                        _startOffset.intValue        = Mathf.RoundToInt(_transitionOffset.floatValue * AnimEvt._animationClip.length * AnimEvt._animationClip.frameRate);
                        _transitionOffset.floatValue = (_startOffset.intValue / AnimEvt._animationClip.frameRate) / AnimEvt._animationClip.length;

                        _animEvtSO.ApplyModifiedProperties();
                    }
                }

                _transitionSO.ApplyModifiedProperties();
            }
        }
Exemplo n.º 23
0
        public override void OnInspectorGUI()
        {
            bool rebuildTrack = false;

            base.OnInspectorGUI();

            serializedObject.Update();

            if (_animationClip.objectReferenceValue == null)
            {
                EditorGUILayout.HelpBox("无动画剪辑Clip", MessageType.Warning);
            }

            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(_animationClip, _animationClipUI);

            Rect animationClipRect = GUILayoutUtility.GetLastRect();

            if (Event.current.type == EventType.DragUpdated && animationClipRect.Contains(Event.current.mousePosition))
            {
                int numAnimations = NumAnimationsDragAndDrop(_animEvent.Sequence.FrameRate);
                if (numAnimations > 0)
                {
                    DragAndDrop.visualMode = DragAndDropVisualMode.Link;
                }
            }
            else if (Event.current.type == EventType.DragPerform && animationClipRect.Contains(Event.current.mousePosition))
            {
                if (NumAnimationsDragAndDrop(_animEvent.Sequence.FrameRate) > 0)
                {
                    DragAndDrop.AcceptDrag();
                    AnimationClip clip = GetAnimationClipDragAndDrop(_animEvent.Sequence.FrameRate);
                    if (clip != null)
                    {
                        _animationClip.objectReferenceValue = clip;
                    }
                }
            }

            if (EditorGUI.EndChangeCheck())
            {
                AnimationClip clip = (AnimationClip)_animationClip.objectReferenceValue;
                if (clip)
                {
                    if (clip.frameRate != _animEvent.Track.Container.Sequence.FrameRate)
                    {
                        Debug.LogError(string.Format("Can't add animation, it has a different frame rate from the sequence ({0} vs {1})",
                                                     clip.frameRate, _animEvent.Track.Container.Sequence.FrameRate));

                        _animationClip.objectReferenceValue = null;
                    }
                    else
                    {
                        SerializedProperty frameRangeEnd = _frameRange.FindPropertyRelative("_end");
                        FrameRange         maxFrameRange = _animEvent.GetMaxFrameRange();
                        frameRangeEnd.intValue = Mathf.Min(_animEvent.FrameRange.Start + Mathf.RoundToInt(clip.length * clip.frameRate), maxFrameRange.End);
                    }

                    rebuildTrack = true;
                }
                else
                {
                    CheckDeleteAnimation(_animEvent);
                }
            }

            if (_animEvent.IsBlending())
            {
                int id = _animEvent.GetId();
                FPlayAnimationEvent preAnimEvt = _animEvent.Track.Events[id - 1] as FPlayAnimationEvent;
                if (id > 0)
                {
                    EditorGUI.BeginChangeCheck();
                    EditorGUILayout.IntSlider(_startOffset, 0, _animEvent.GetMaxStartOffset(), _startOffsetUI);
                    EditorGUILayout.IntSlider(_blendLength, 0, preAnimEvt.Length > _animEvent.Length ? _animEvent.Length : preAnimEvt.Length, _blendLengthUI);
                    if (EditorGUI.EndChangeCheck())
                    {
                        rebuildTrack = true;
                    }
                }
            }
            else
            {
                EditorGUI.BeginChangeCheck();
                EditorGUILayout.IntSlider(_startOffset, 0, _animEvent.GetMaxStartOffset(), _startOffsetUI);
                if (EditorGUI.EndChangeCheck())
                {
                    rebuildTrack = true;
                }
            }
            serializedObject.ApplyModifiedProperties();

            if (rebuildTrack)
            {
                FAnimationTrackInspector.RebuildStateMachine((FAnimationTrack)_animEvent.Track);
            }
        }
Exemplo n.º 24
0
        public static void RebuildStateMachine(FAnimationTrack track)
        {
            if (track.AnimatorController == null || track.LayerId == -1)
            {
                return;
            }

            bool isPreviewing = track.HasCache;

            if (isPreviewing)
            {
                track.ClearCache();
            }

            Animator animator = track.Owner.GetComponent <Animator>();

            animator.runtimeAnimatorController = null;

            AnimatorController controller = (AnimatorController)track.AnimatorController;

            track.UpdateEventIds();

            AnimatorControllerLayer layer = FindLayer(controller, track.LayerName);

            if (layer == null)
            {
                controller.AddLayer(track.LayerName);
                layer = FindLayer(controller, track.LayerName);
            }

            AnimatorStateMachine fluxSM = FindStateMachine(layer.stateMachine, FLUX_STATE_MACHINE_NAME);

            if (fluxSM == null)
            {
                fluxSM = layer.stateMachine.AddStateMachine(FLUX_STATE_MACHINE_NAME);

                ChildAnimatorStateMachine[] stateMachines = layer.stateMachine.stateMachines;

                for (int i = 0; i != stateMachines.Length; ++i)
                {
                    if (stateMachines[i].stateMachine == fluxSM)
                    {
                        stateMachines[i].position = layer.stateMachine.entryPosition + new Vector3(300, 0, 0);
                        break;
                    }
                }
                layer.stateMachine.stateMachines = stateMachines;
            }

            List <FEvent> events = track.Events;

            if (fluxSM.states.Length > events.Count)
            {
                for (int i = events.Count; i < fluxSM.states.Length; ++i)
                {
                    fluxSM.RemoveState(fluxSM.states[i].state);
                }
            }
            else if (fluxSM.states.Length < events.Count)
            {
                for (int i = fluxSM.states.Length; i < events.Count; ++i)
                {
                    fluxSM.AddState(i.ToString());
                }
            }

            AnimatorState lastState = null;
            Vector3       pos       = fluxSM.entryPosition + new Vector3(300, 0, 0);

            Vector3 statePosDelta = new Vector3(0, 80, 0);

            ChildAnimatorState[] states = fluxSM.states;

            for (int i = 0; i != events.Count; ++i)
            {
                FPlayAnimationEvent animEvent = (FPlayAnimationEvent)events[i];

                if (animEvent._animationClip == null) // dump events without animations
                {
                    continue;
                }

                states[i].position = pos;

                AnimatorState state = states[i].state;

                state.name = i.ToString();

                pos += statePosDelta;

                state.motion = animEvent._animationClip;

                animEvent._stateHash = Animator.StringToHash(state.name);

                if (lastState)
                {
                    AnimatorStateTransition[] lastStateTransitions = lastState.transitions;

                    if (animEvent.IsBlending())
                    {
                        AnimatorStateTransition transition = null;

                        for (int j = lastStateTransitions.Length - 1; j > 0; --j)
                        {
                            lastState.RemoveTransition(lastStateTransitions[j]);
                        }

                        transition = lastStateTransitions.Length == 1 ? lastStateTransitions[0] : lastState.AddTransition(state);

                        transition.offset = (animEvent._startOffset / animEvent._animationClip.frameRate) / animEvent._animationClip.length;

                        FPlayAnimationEvent prevAnimEvent = (FPlayAnimationEvent)events[i - 1];

                        int offsetFrame = Mathf.RoundToInt(transition.offset * animEvent._animationClip.length * animEvent._animationClip.frameRate);
                        animEvent._startOffset = Mathf.Clamp(offsetFrame, 0, animEvent.GetMaxStartOffset());
                        transition.offset      = (animEvent._startOffset / animEvent._animationClip.frameRate) / animEvent._animationClip.length;
                        EditorUtility.SetDirty(animEvent);

                        float blendSeconds = animEvent._blendLength / prevAnimEvent._animationClip.frameRate;
                        transition.duration = blendSeconds;

                        transition.hasExitTime = true;
                        float p = blendSeconds / prevAnimEvent._animationClip.length;
                        transition.exitTime = p > 1f ? 1f : 1f - Mathf.Clamp01(blendSeconds / prevAnimEvent._animationClip.length);

                        for (int j = transition.conditions.Length - 1; j >= 0; --j)
                        {
                            transition.RemoveCondition(transition.conditions[j]);
                        }

                        //						AnimatorCondition condition = transition.conditions[0];
                        //						condition.threshold = 0;
                    }
                    else // animations not blending, needs hack for animation previewing
                    {
                        for (int j = lastStateTransitions.Length - 1; j >= 0; --j)
                        {
                            lastState.RemoveTransition(lastStateTransitions[j]);
                        }
                    }
                }

                lastState = state;
            }

            fluxSM.states = states;

            if (fluxSM.states.Length > 0)
            {
                layer.stateMachine.defaultState = fluxSM.states[0].state;
            }

            animator.runtimeAnimatorController = controller;

            if (isPreviewing)
            {
                track.CreateCache();
            }
        }