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); }
public override void OnEnable() { base.OnEnable(); _animTrack = (FAnimationTrack)target; _animatorController = serializedObject.FindProperty("_animatorController"); }
public static AnimatorController CreateAnimatorController(FAnimationTrack animTrack) { string defaultFolder = "Assets/"; string defaultFileName = string.Format("{0}_{1}.controller", animTrack.Timeline.Sequence.name, animTrack.Owner.name); string defaultFilePath = AssetDatabase.GenerateUniqueAssetPath(defaultFolder + defaultFileName); defaultFileName = System.IO.Path.GetFileNameWithoutExtension(defaultFilePath); string filePath = EditorUtility.SaveFilePanel("Create new AnimatorController...", defaultFolder, defaultFileName, "controller"); if (string.IsNullOrEmpty(filePath)) { return(null); } // transform the path into a local path if (!filePath.StartsWith(Application.dataPath)) { Debug.LogError("Cannot save controller outside of the project"); return(null); } string fileLocalPath = "Assets" + filePath.Substring(Application.dataPath.Length, filePath.Length - Application.dataPath.Length); // AnimatorController animatorAtPath = (AnimatorController)AssetDatabase.LoadAssetAtPath( fileLocalPath, typeof(AnimatorController) ); return(AnimatorController.CreateAnimatorControllerAtPath(fileLocalPath)); }
public override void OnTrackChanged() { FAnimationTrack animTrack = (FAnimationTrack)Track; FAnimationTrackInspector.RebuildStateMachine(animTrack); FAnimationTrackInspector.SetAnimator(animTrack); }
protected override void Init(FObject obj) { base.Init(obj); _animEvt = (FPlayAnimationEvent)_evt; _animTrack = (FAnimationTrack)_animEvt.GetTrack(); }
public override void Init(FObject obj, FEditor owner) { base.Init(obj, owner); FAnimationTrack animTrack = (FAnimationTrack)Obj; if (animTrack.Owner.GetComponent <Animator>() == null) { Animator animator = animTrack.Owner.gameObject.AddComponent <Animator>(); Undo.RegisterCreatedObjectUndo(animator, string.Empty); } }
public override void OnEnable() { base.OnEnable(); if (target == null) { DestroyImmediate(this); return; } _animTrack = (FAnimationTrack)target; _animatorController = serializedObject.FindProperty("_animatorController"); _layerName = serializedObject.FindProperty("_layerName"); _layerId = serializedObject.FindProperty("_layerId"); }
protected override void OnDestroy() { base.OnDestroy(); //SceneView.onSceneGUIDelegate -= OnSceneGUI; FAnimationTrack animTrack = (FAnimationTrack)Obj; DestroyImmediate(animTrack.AnimatorController); animTrack.AnimatorController = null; Resources.UnloadUnusedAssets(); //if (SyncWithAnimationWindow) // SyncWithAnimationWindow = false; }
public static void SetAnimator(FAnimationTrack animTrack) { if (animTrack.Owner.GetComponent <Animator>() == null) { Animator animator = animTrack.Owner.gameObject.AddComponent <Animator>(); Undo.RegisterCreatedObjectUndo(animator, string.Empty); } if (animTrack.AnimatorController == null) { var temp = FUtility.GetFluxAssets <UnityEditor.Animations.AnimatorController>("EditorAnimatorController.controller"); var animatorController = Instantiate(temp); animTrack.LayerId = 0; animTrack.LayerName = "Base Layer"; var layers = animatorController.layers; layers[animTrack.LayerId].name = animTrack.LayerName; layers[animTrack.LayerId].stateMachine.name = animTrack.LayerName; animatorController.layers = layers; animTrack.AnimatorController = animatorController; FAnimationTrackInspector.RebuildStateMachine(animTrack); } }
// public static EditorWindow GetAnimationWindow( bool showWindow ) // { // System.Type t = typeof(EditorWindow).Assembly.GetType("UnityEditor.AnimationWindow"); // if( showWindow ) // { // return EditorWindow.GetWindow( t ); // } // // System.Reflection.MethodInfo getWindow = typeof(EditorWindow).GetMethod( "GetWindowDontShow", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static ); // System.Reflection.MethodInfo getWindowGeneric = getWindow.MakeGenericMethod( t ); // return (EditorWindow)getWindowGeneric.Invoke(null, null); // } #endregion #region Upgrade Sequences public static void Upgrade(FSequence sequence) { const int fluxVersion = Flux.FUtility.FLUX_VERSION; if (sequence.Version == fluxVersion) { return; } Debug.LogFormat("Upgrading sequence '{0}' from version '{1}' to '{2}'", sequence.name, sequence.Version, fluxVersion); // is it before 2.0.0 release? if (sequence.Version < 200) { // set TimelineContainer as Content Transform timelineContainer = null; foreach (Transform t in sequence.transform) { if (t.name == "Timeline Container") { timelineContainer = t; break; } } if (timelineContainer == null) { timelineContainer = new GameObject("SequenceContent").transform; timelineContainer.hideFlags |= HideFlags.HideInHierarchy; } sequence.Content = timelineContainer; // create a container, and add it to the sequence FContainer container = FContainer.Create(FContainer.DEFAULT_COLOR); sequence.Add(container); FTimeline[] timelines = timelineContainer.GetComponentsInChildren <FTimeline>(); foreach (FTimeline timeline in timelines) { container.Add(timeline); List <FTrack> tracks = timeline.Tracks; foreach (FTrack track in tracks) { if (track is FAnimationTrack) { FAnimationTrack animTrack = (FAnimationTrack)track; if (animTrack.AnimatorController != null) { FAnimationTrackInspector inspector = (FAnimationTrackInspector)FAnimationTrackInspector.CreateEditor(animTrack); AnimatorController controller = (AnimatorController)animTrack.AnimatorController; inspector.UpdateLayer(controller == null || controller.layers.Length == 0 ? null : controller.layers[0]); inspector.serializedObject.ApplyModifiedProperties(); if (controller.layers.Length > 0) { while (controller.layers[0].stateMachine.stateMachines.Length > 0) { controller.layers[0].stateMachine.RemoveStateMachine(controller.layers[0].stateMachine.stateMachines[controller.layers[0].stateMachine.stateMachines.Length - 1].stateMachine); } while (controller.layers[0].stateMachine.states.Length > 0) { controller.layers[0].stateMachine.RemoveState(controller.layers[0].stateMachine.states[controller.layers[0].stateMachine.states.Length - 1].state); } } Editor.DestroyImmediate(inspector); FAnimationTrackInspector.RebuildStateMachine(animTrack); } } track.CacheMode = track.RequiredCacheMode; } // foreach( FTrack track in tracks ) // { // track.CacheType = track.DefaultCacheType(); // } } } sequence.Version = fluxVersion; }
public override void OnInspectorGUI() { bool rebuildTrack = false; base.OnInspectorGUI(); serializedObject.Update(); if (_animationClip.objectReferenceValue == null) { EditorGUILayout.HelpBox("There's no Animation Clip", MessageType.Warning); Rect helpBoxRect = GUILayoutUtility.GetLastRect(); float yCenter = helpBoxRect.center.y; helpBoxRect.xMax -= 3; helpBoxRect.xMin = helpBoxRect.xMax - 50; helpBoxRect.yMin = yCenter - 12.5f; helpBoxRect.height = 25f; FAnimationTrack animTrack = (FAnimationTrack)_animEvent.Track; if (animTrack.AnimatorController == null || animTrack.LayerId == -1) { GUI.enabled = false; } if (GUI.Button(helpBoxRect, "Create")) { CreateAnimationClip(_animEvent); } GUI.enabled = true; } EditorGUI.BeginChangeCheck(); EditorGUILayout.PropertyField(_animationClip); 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.Timeline.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.Timeline.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); } } bool isAnimationEditable = Flux.FUtility.IsAnimationEditable(_animEvent._animationClip); if (isAnimationEditable) { EditorGUILayout.PropertyField(_controlsAnimation); } else { if (_controlsAnimation.boolValue) { _controlsAnimation.boolValue = false; } } if (!_controlsAnimation.boolValue) { if (_animEvent.IsBlending()) { float offset = _startOffset.intValue / _animEvent._animationClip.frameRate; float blendFinish = offset + (_blendLength.intValue / _animEvent._animationClip.frameRate); EditorGUILayout.BeginHorizontal(); EditorGUILayout.BeginHorizontal(GUILayout.Width(EditorGUIUtility.labelWidth - 5)); // hack to get around some layout issue with imgui _showBlendAndOffsetContent = EditorGUILayout.Foldout(_showBlendAndOffsetContent, new GUIContent("Offset+Blend")); EditorGUILayout.EndHorizontal(); EditorGUI.BeginChangeCheck(); EditorGUILayout.MinMaxSlider(ref offset, ref blendFinish, 0, _animEvent.GetMaxStartOffset() / _animEvent._animationClip.frameRate + _animEvent.LengthTime); if (EditorGUI.EndChangeCheck()) { _startOffset.intValue = Mathf.Clamp(Mathf.RoundToInt(offset * _animEvent.Sequence.FrameRate), 0, _animEvent.GetMaxStartOffset()); _blendLength.intValue = Mathf.Clamp(Mathf.RoundToInt((blendFinish - offset) * _animEvent.Sequence.FrameRate), 0, _animEvent.Length); rebuildTrack = true; } EditorGUILayout.EndHorizontal(); if (_showBlendAndOffsetContent) { EditorGUI.BeginChangeCheck(); ++EditorGUI.indentLevel; if (!isAnimationEditable) { EditorGUILayout.IntSlider(_startOffset, 0, _animEvent.GetMaxStartOffset()); } // if( _animEvent.IsBlending() ) { EditorGUILayout.IntSlider(_blendLength, 0, _animEvent.Length); } --EditorGUI.indentLevel; if (EditorGUI.EndChangeCheck()) { rebuildTrack = true; } } } else { EditorGUI.BeginChangeCheck(); EditorGUILayout.IntSlider(_startOffset, 0, _animEvent.GetMaxStartOffset()); if (EditorGUI.EndChangeCheck()) { rebuildTrack = true; } } } serializedObject.ApplyModifiedProperties(); if (rebuildTrack) { FAnimationTrackInspector.RebuildStateMachine((FAnimationTrack)_animEvent.Track); } }
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); }
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(); } }
public static void RebuildStateMachine(FAnimationTrack track) { /* * if( track.GetAnimatorController() == null ) * return; * * UnityEditor.Animations.AnimatorController controller = (UnityEditor.Animations.AnimatorController)track.GetAnimatorController(); * * track.UpdateEventIds(); * * //if( controller.FindParameter( ADVANCE_TRIGGER ) < 0 ) * controller.AddParameter(ADVANCE_TRIGGER, UnityEngine.AnimatorControllerParameterType.Trigger); * * UnityEditor.Animations.AnimatorControllerLayer baseLayer = controller.layers[0]; * * UnityEditor.Animations.AnimatorStateMachine baseSM = baseLayer.stateMachine; * * List<FEvent> events = track.GetEvents(); * * if (baseSM.states.Length > events.Count) * { * for (int i = events.Count; i < baseSM.states.Length; ++i) * baseSM.RemoveState( baseSM.states[i].state ); * } * else if (baseSM.states.Length < events.Count) * { * for (int i = baseSM.states.Length; i < events.Count; ++i) * baseSM.AddState( i.ToString() ); * } * * UnityEditor.Animations.AnimatorState lastState = null; * Vector3 pos = baseSM.anyStatePosition + new Vector3( 300, 0, 0 ); * * Vector3 statePosDelta = new Vector3(0, 80, 0 ); * * for( int i = 0; i != events.Count; ++i ) * { * FPlayAnimationEvent animEvent = (FPlayAnimationEvent)events[i]; * * if( animEvent._animationClip == null ) // dump events without animations * continue; * * UnityEditor.Animations.ChildAnimatorState child = baseSM.states[i]; * UnityEditor.Animations.ChildAnimatorStateMachine childMachine = baseSM.stateMachines[i]; * UnityEditor.Animations.AnimatorState state = child.state; * state.name = i.ToString(); * * child.position = pos; * * pos += statePosDelta; * * state.SetAnimationClip( animEvent._animationClip ); * * animEvent._stateHash = Animator.StringToHash( state.name ); * * if( lastState ) * { * UnityEditor.Animations.AnimatorTransition[] transitionsLastState = baseSM.GetStateMachineTransitions(childMachine.stateMachine); * * UnityEditor.Animations.AnimatorTransition transition = null; * * if( transitionsLastState.Length == 1 ) * { * if( transitionsLastState[0].destinationState != state ) * { * baseSM.RemoveTransition( transitionsLastState[0] ); * transition = baseSM.AddTransition( lastState, state ); * transition.offset = (animEvent._startOffset / animEvent._animationClip.frameRate) / animEvent._animationClip.length; * } * else * transition = transitionsLastState[0]; * } * else * { * if( transitionsLastState.Length > 0 ) * { * for( int j = 0; j != transitionsLastState.Length; ++j ) * baseSM.RemoveTransition( transitionsLastState[j] ); * } * transition = baseSM.AddTransition( lastState, state ); * transition.offset = (animEvent._startOffset / animEvent._animationClip.frameRate) / animEvent._animationClip.length; * } * * if( animEvent.IsBlending() ) * { * FPlayAnimationEvent prevAnimEvent = (FPlayAnimationEvent)events[i-1]; * * animEvent._startOffset = Mathf.Clamp( Mathf.RoundToInt(transition.offset * animEvent._animationClip.length * animEvent._animationClip.frameRate), 0, animEvent._animationClip.isLooping ? animEvent.Length : Mathf.RoundToInt( animEvent._animationClip.length * animEvent._animationClip.frameRate ) - animEvent.Length ); * transition.offset = (animEvent._startOffset / animEvent._animationClip.frameRate) / animEvent._animationClip.length; * EditorUtility.SetDirty( animEvent ); * * transition.duration = (animEvent._blendLength / prevAnimEvent._animationClip.frameRate) / prevAnimEvent._animationClip.length; * * AnimatorCondition condition = transition.GetCondition(0); * * condition.mode = TransitionConditionMode.ExitTime; * condition.exitTime = (prevAnimEvent.Length + prevAnimEvent._startOffset) / (prevAnimEvent._animationClip.length*prevAnimEvent._animationClip.frameRate); * condition.threshold = 0; * } * else // animations not blending, needs hack for animation previewing * { * animEvent._startOffset = Mathf.RoundToInt(transition.offset * animEvent._animationClip.length * animEvent._animationClip.frameRate); * EditorUtility.SetDirty( animEvent ); * * transition.duration = 0; * * AnimatorCondition condition = transition.GetCondition(0); * * condition.parameter = ADVANCE_TRIGGER; * condition.mode = TransitionConditionMode.If; * * condition.threshold = 0; * } * } * * lastState = state; * } * */ }