public void AddClip(AnimationClip clip, string newName, float speed, WrapMode wrapMode, float length)
{
if (GetAnimationData(newName) != null)
{
Debug.LogWarning("An animation with the name '" + newName + "' already exists.");
}
MecanimAnimationData animData = new MecanimAnimationData();
animData.clip = (AnimationClip)Instantiate(clip);
if (wrapMode == WrapMode.Default)
{
wrapMode = defaultWrapMode;
}
animData.clip.wrapMode = wrapMode;
animData.clip.name = newName;
animData.clipName = newName;
animData.speed = speed;
animData.originalSpeed = speed;
animData.length = length;
animData.wrapMode = wrapMode;
List <MecanimAnimationData> animationDataList = new List <MecanimAnimationData>(animations);
animationDataList.Add(animData);
animations = animationDataList.ToArray();
}
public void SetWrapMode(AnimationClip clip, WrapMode wrapMode)
{
MecanimAnimationData animData = GetAnimationData(clip);
animData.wrapMode = wrapMode;
animData.clip.wrapMode = wrapMode;
}
public void SetWrapMode(string clipName, WrapMode wrapMode)
{
MecanimAnimationData animData = GetAnimationData(clipName);
animData.wrapMode = wrapMode;
animData.clip.wrapMode = wrapMode;
}
public void SetSpeed(MecanimAnimationData animData, float speed)
{
if (animData != null)
{
animData.normalizedSpeed = speed / animData.originalSpeed;
animData.speed = speed;
if (IsPlaying(animData))
{
SetSpeed(speed);
}
}
}
public void SetNormalizedSpeed(MecanimAnimationData animData, float normalizedSpeed)
{
if (animData == null)
{
return;
}
animData.normalizedSpeed = normalizedSpeed;
animData.speed = animData.originalSpeed * animData.normalizedSpeed;
if (IsPlaying(animData))
{
SetSpeed(animData.speed);
}
}
public void CopyAnimationData(MecanimAnimationData from, ref MecanimAnimationData to)
{
if (from == null || from.clip == null)
{
return;
}
to.clip = (AnimationClip)Instantiate(from.clip);
to.clip.wrapMode = from.clip.wrapMode;
to.clip.name = from.clip.name;
to.clipName = from.clipName;
to.speed = from.speed;
to.transitionDuration = from.transitionDuration;
to.wrapMode = from.wrapMode;
to.applyRootMotion = from.applyRootMotion;
to.timesPlayed = from.timesPlayed;
to.secondsPlayed = from.secondsPlayed;
to.length = from.length;
to.originalSpeed = from.originalSpeed;
to.normalizedSpeed = from.normalizedSpeed;
to.normalizedTime = from.normalizedTime;
to.stateName = from.stateName;
}
public bool IsPlaying(MecanimAnimationData animData, float weight)
{
if (animData == null)
{
return(false);
}
if (currentAnimationData == null)
{
return(false);
}
if (currentAnimationData == animData && animData.wrapMode == WrapMode.Once && animData.timesPlayed > 0)
{
return(false);
}
if (currentAnimationData == animData && animData.wrapMode == WrapMode.Clamp && animData.timesPlayed > 0)
{
return(false);
}
if (currentAnimationData == animData && animData.wrapMode == WrapMode.ClampForever)
{
return(true);
}
if (currentAnimationData == animData)
{
return(true);
}
AnimatorClipInfo[] animationInfoArray = animator.GetCurrentAnimatorClipInfo(0);
foreach (AnimatorClipInfo animationInfo in animationInfoArray)
{
if (animData.clip == animationInfo.clip && animationInfo.weight >= weight)
{
return(true);
}
}
return(false);
}
void Start()
{
if (defaultAnimation.clip == null && animations.Length > 0)
{
SetDefaultClip(animations[0].clip, "State1", animations[0].speed, animations[0].wrapMode, false);
}
if (defaultAnimation.clip != null && currentAnimationData == null)
{
foreach (MecanimAnimationData animData in animations)
{
if (animData.clip == defaultAnimation.clip)
{
defaultAnimation.clip = (AnimationClip)Instantiate(defaultAnimation.clip);
}
}
currentAnimationData = defaultAnimation;
currentAnimationData.stateName = "State1";
currentAnimationData.length = currentAnimationData.clip.length;
AnimatorOverrideController overrideController = new AnimatorOverrideController();
overrideController.runtimeAnimatorController = controller;
overrideController["Default"] = currentAnimationData.clip;
overrideController["State1"] = currentAnimationData.clip;
animator.runtimeAnimatorController = overrideController;
animator.Play("State1", 0, 0);
if (overrideRootMotion)
{
animator.applyRootMotion = currentAnimationData.applyRootMotion;
}
SetSpeed(currentAnimationData.speed);
}
}
public bool IsPlaying(MecanimAnimationData animData)
{
return(currentAnimationData == animData);
}
public void Play(MecanimAnimationData animationData, Fix64 blendingTime, Fix64 normalizedTime, bool mirror)
{
_playAnimation(animationData, blendingTime, normalizedTime, mirror);
//DirectorPlay(animationData, blendingTime, normalizedTime, mirror);
}
public float GetSpeed(MecanimAnimationData animData)
{
return(animData.speed);
}
public void Play(MecanimAnimationData animationData)
{
_playAnimation(animationData, animationData.transitionDuration, 0, currentMirror);
}
public void Play(MecanimAnimationData animationData, bool mirror)
{
_playAnimation(animationData, animationData.transitionDuration, 0, mirror);
}
public void OnPlayAnimation(MecanimAnimationData targetAnimationData, float blendingTime, float nomalizedTime, bool mirror)
{
if (targetAnimationData == null || targetAnimationData.clip == null)
{
return;
}
bool prevMirror = currentMirror;
currentMirror = mirror;
float animSpeed = targetAnimationData.originalSpeed * (targetAnimationData.originalSpeed < 0 ? -1 : 1);
currentNomalizedTime = GetCurrentClipPosition();
currentState = "State1";
if (!mirror)
{
if (targetAnimationData.originalSpeed >= 0)
{
currentState = "State1";
}
else
{
currentState = "State2";
}
}
else
{
if (targetAnimationData.originalSpeed >= 0)
{
currentState = "State3";
}
else
{
currentState = "State4";
}
}
overrideController = new AnimatorOverrideController();
overrideController.runtimeAnimatorController = null;
overrideController.runtimeAnimatorController = controller;
if (currentAnimationData != null && currentAnimationData.clip != null)
{
overrideController["Default"] = null;
overrideController["Default"] = currentAnimationData.clip;
}
overrideController[currentState] = null;
overrideController[currentState] = targetAnimationData.clip;
if (blendingTime == -1)
{
blendingTime = defaultTransitionDuration;
}
if (blendingTime <= 0 || currentAnimationData == null)
{
animator.runtimeAnimatorController = null;
animator.runtimeAnimatorController = overrideController;
animator.Play(currentState, 0, nomalizedTime);
}
else
{
animator.runtimeAnimatorController = null;
animator.runtimeAnimatorController = overrideController;
currentAnimationData.stateName = "Default";
SetCurrentClipPosition(currentNomalizedTime);
animator.Play("Default", 0, nomalizedTime);
animator.CrossFade(currentState, (blendingTime / animSpeed), 0, nomalizedTime);
}
AnimatorStateInfo info = animator.GetCurrentAnimatorStateInfo(0);
if (info.IsName("Default"))
{
if (animator.GetBool("Mirror") != prevMirror)
{
animator.SetBool("Mirror", prevMirror);
}
}
animator.Update(0);
targetAnimationData.timesPlayed = 0;
targetAnimationData.secondsPlayed = (nomalizedTime * targetAnimationData.length) / animSpeed;
targetAnimationData.nomalizedTime = nomalizedTime;
targetAnimationData.speed = targetAnimationData.originalSpeed;
SetSpeed(targetAnimationData.originalSpeed);
if (currentAnimationData != null)
{
currentAnimationData.speed = currentAnimationData.originalSpeed;
currentAnimationData.nomalizedTime = 1;
currentAnimationData.timesPlayed = 0;
}
currentAnimationData = targetAnimationData;
currentAnimationData.stateName = currentState;
}
public Fix64 GetSpeed(MecanimAnimationData animData)
{
return(animData.speed);
}
public void SetWrapMode(MecanimAnimationData animationData, WrapMode wrapMode)
{
animationData.wrapMode = wrapMode;
animationData.clip.wrapMode = wrapMode;
}
public void Play(MecanimAnimationData animationData, float blendingTime, float normalizedTime, bool mirror)
{
_playAnimation(animationData, blendingTime, normalizedTime, mirror);
}
private void _playAnimation(MecanimAnimationData targetAnimationData, float blendingTime, float normalizedTime, bool mirror)
{
//The overrite machine. Creates an overrideController, replace its core animations and restate it back in
if (targetAnimationData == null || targetAnimationData.clip == null)
{
return;
}
bool prevMirror = currentMirror;
currentMirror = mirror;
float animSpeed = targetAnimationData.originalSpeed * (targetAnimationData.originalSpeed < 0 ? -1 : 1);
currentNormalizedTime = GetCurrentClipPosition();
currentState = "State1";
if (!mirror)
{
if (targetAnimationData.originalSpeed >= 0)
{
currentState = "State1";
}
else
{
currentState = "State2";
}
}
else
{
if (targetAnimationData.originalSpeed >= 0)
{
currentState = "State3";
}
else
{
currentState = "State4";
}
}
overrideController = new AnimatorOverrideController();
overrideController.runtimeAnimatorController = controller;
if (currentAnimationData != null && currentAnimationData.clip != null)
{
overrideController["Default"] = currentAnimationData.clip;
}
overrideController[currentState] = targetAnimationData.clip;
if (blendingTime == -1)
{
blendingTime = currentAnimationData.transitionDuration;
}
if (blendingTime == -1)
{
blendingTime = defaultTransitionDuration;
}
if (blendingTime <= 0 || currentAnimationData == null)
{
animator.runtimeAnimatorController = overrideController;
animator.Play(currentState, 0, normalizedTime);
}
else
{
animator.runtimeAnimatorController = overrideController;
currentAnimationData.stateName = "Default";
SetCurrentClipPosition(currentNormalizedTime);
animator.Play("Default", 0, normalizedTime);
animator.CrossFade(currentState, (blendingTime / animSpeed), 0, normalizedTime);
}
// Update Previous Mirror
AnimatorStateInfo info = animator.GetCurrentAnimatorStateInfo(0);
if (info.IsName("Default"))
{
if (animator.GetBool("Mirror") != prevMirror)
{
animator.SetBool("Mirror", prevMirror);
}
}
animator.Update(0);
targetAnimationData.timesPlayed = 0;
targetAnimationData.secondsPlayed = (normalizedTime * targetAnimationData.length) / animSpeed;
targetAnimationData.normalizedTime = normalizedTime;
targetAnimationData.speed = targetAnimationData.originalSpeed;
if (overrideRootMotion)
{
animator.applyRootMotion = targetAnimationData.applyRootMotion;
}
SetSpeed(targetAnimationData.originalSpeed);
if (currentAnimationData != null)
{
currentAnimationData.speed = currentAnimationData.originalSpeed;
currentAnimationData.normalizedSpeed = 1;
currentAnimationData.timesPlayed = 0;
}
currentAnimationData = targetAnimationData;
currentAnimationData.stateName = currentState;
if (MecanimControl.OnAnimationBegin != null)
{
MecanimControl.OnAnimationBegin(currentAnimationData);
}
}
public void RestoreAnimatorData(MecanimAnimationData animData, float normalizedTime)
{
currentAnimationData = animData;
currentAnimationData.normalizedTime = normalizedTime;
currentAnimationData.secondsPlayed = (normalizedTime * currentAnimationData.length) / currentAnimationData.speed;
}
public float GetNormalizedSpeed(MecanimAnimationData animData)
{
return(animData.normalizedSpeed);
}
public void CrossFade(MecanimAnimationData animationData, Fix64 blendingTime, Fix64 normalizedTime, bool mirror)
{
Play(animationData, blendingTime, normalizedTime, mirror);
}
