public void setTransition()
{
if (tran == null)
{
tran = targetController.layers[0].stateMachine.AddAnyStateTransition(state);
tran.duration = 0;
tran.hasFixedDuration = false;
tran.hasExitTime = false;
tran.canTransitionToSelf = false;
}
AnimatorCondition animatorCondition = new AnimatorCondition();
animatorCondition.mode = AnimatorConditionMode.Equals;
animatorCondition.parameter = "WeaponNumber";
animatorCondition.threshold = weaponNumber;
var cons = tran.conditions;
for (int i = 0; i < cons.Length; i++)
{
tran.RemoveCondition(cons[i]);
}
tran.AddCondition(AnimatorConditionMode.Equals, weaponNumber, "WeaponNumber");
tran.AddCondition(AnimatorConditionMode.Equals, comboCount, "ComboCount");
tran.AddCondition(AnimatorConditionMode.Equals, stateNumber, "State");
if (oneShot)
{
tran.canTransitionToSelf = true;
tran.AddCondition(AnimatorConditionMode.If, 0, "OneShot");
}
}
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();
}
}
