private void Start()
{
// AnimationClipPlayableを構築
var clip1Playable = AnimationClipPlayable.Create(graph, Clip1);
var clip2Playable = AnimationClipPlayable.Create(graph, Clip2);
var clip3Playable = AnimationClipPlayable.Create(graph, Clip3);
// ミキサーを生成して、Clip1とClip2を登録
// （代わりにAnimatorControllerPlayableとかでも可能）
mixer = AnimationMixerPlayable.Create(graph, 2, true);
mixer.ConnectInput(0, clip1Playable, 0);
mixer.ConnectInput(1, clip2Playable, 0);
// outputを生成して、出力先を自身のAnimatorに設定
var output = AnimationPlayableOutput.Create(graph, "output", GetComponent <Animator>());
// playableをoutputに流し込む
output.SetSourcePlayable(mixer);
graph.Play();
}
public void Configure(Animator animator, EnemyAnimationConfig config)
{
graph = PlayableGraph.Create();
graph.SetTimeUpdateMode(DirectorUpdateMode.GameTime);
mixer = AnimationMixerPlayable.Create(graph, 4);
var clip = AnimationClipPlayable.Create(graph, config.Move);
clip.Pause();
mixer.ConnectInput((int)Clip.Move, clip, 0);
clip = AnimationClipPlayable.Create(graph, config.Intro);
clip.SetDuration(config.Intro.length);
clip.Pause();
mixer.ConnectInput((int)Clip.Intro, clip, 0);
clip = AnimationClipPlayable.Create(graph, config.Outro);
clip.SetDuration(config.Outro.length);
clip.Pause();
mixer.ConnectInput((int)Clip.Outro, clip, 0);
clip = AnimationClipPlayable.Create(graph, config.Dying);
clip.SetDuration(config.Dying.length);
clip.Pause();
mixer.ConnectInput((int)Clip.Dying, clip, 0);
var output = AnimationPlayableOutput.Create(graph, "Enemy", animator);
output.SetSourcePlayable(mixer);
}
//次のアニメーションのプレイアブル作成
private void SetNextAnimationPlayable()
{
if (setPlayAnimation != null && playableGraph.IsValid())
{
if (mixer.IsValid())
{
playableGraph.Disconnect(mixer, 0);
playableGraph.Disconnect(mixer, 1);
}
else
{
mixer = AnimationMixerPlayable.Create(playableGraph, 2, true);
var output = AnimationPlayableOutput.Create(playableGraph, "output", GetComponent <Animator>());
output.SetSourcePlayable(mixer);
}
if (_beforePlayAnimation.IsValid())
{
_beforePlayAnimation.Destroy();
}
if (_nowPlayAnimation.IsValid())
{
_beforePlayAnimation = _nowPlayAnimation;
}
//今のアニメーションに設定
nowPlayAnimation = setPlayAnimation;
_beforeNowPlayClip = nowPlayAnimation;
setPlayAnimation = null;
//アニメーションプレイアブル作成
_nowPlayAnimation = AnimationClipPlayable.Create(playableGraph, nowPlayAnimation);
mixer.ConnectInput(0, _nowPlayAnimation, 0);
mixer.ConnectInput(1, _beforePlayAnimation, 0);
}
}
public void OnResult(MMResult result)
{
if (result.Clip == null)
{
return;
}
bool needBlend = m_currentClip.IsNull() == false;
if (needBlend)
{
if (result.Clip == m_currentClip.GetAnimationClip())
{
return;
}
AnimationClipPlayable blendOutClip = m_currentClip;
m_mixer.DisconnectInput(0);
m_mixer.DisconnectInput(1);
m_mixer.ConnectInput(1, blendOutClip, 0, 1.0f);
m_weight = 0.0f;
m_mixer.SetInputWeight(0, 0.0f);
m_mixer.SetInputWeight(1, 1.0f);
}
else
{
m_mixer.SetInputWeight(0, 1.0f);
m_mixer.SetInputWeight(1, 0.0f);
}
m_currentClip = AnimationClipPlayable.Create(m_graph, result.Clip);
m_currentClip.SetTime(result.Time);
m_mixer.DisconnectInput(0);
m_mixer.ConnectInput(0, m_currentClip, 0, needBlend? 0.0f : 1.0f);
}
/// <summary>
/// Animationの再生
/// </summary>
/// <param name="hash">AnimationのHash</param>
/// <param name="duration">クロスフェードの時間</param>
public void Play(uint hash, float duration = 0.0f)
{
fadeTime = 0.0f;
this.duration = duration;
if (!animationDatas.TryGetValue(hash, out currentAnimationData))
{
return;
}
if (duration <= Ashe.Const.Float.EPSILON)
{
mixer.ConnectInput(currentMixerSlot, currentAnimationData.clipPlayable, 0, 1.0f);
}
else
{
mixer.ConnectInput(currentMixerSlot, currentAnimationData.clipPlayable, 0);
int prevSlot = currentMixerSlot;
currentMixerSlot = currentMixerSlot == 1 ? 0 : 1;
float t = fadeTime / duration;
mixer.SetInputWeight(currentMixerSlot, t);
mixer.SetInputWeight(prevSlot, 1.0f - t);
}
playableGraph.Play();
}
void EnablePreview()
{
if (!Application.isEditor || haveGraph)
{
return;
}
if ((Camera.main.transform.position - new Vector3(0f, 1f, -10f)).magnitude < 0.01f)
{
Debug.Log("Default camera detected, moving");
Camera.main.transform.position = new Vector3(0f, 1f, 2f);
Camera.main.transform.eulerAngles = new Vector3(0f, 180f, 0f);
}
proxy = GetComponent <VRMBlendShapeProxy>();
animator = GetComponent <Animator>();
graph = PlayableGraph.Create("Avatar Animation " + UnityEngine.Random.Range(0, 1000000));
var output = AnimationPlayableOutput.Create(graph, "BaseOutput", animator);
mixer = AnimationMixerPlayable.Create(graph, 1);
output.SetSourcePlayable(mixer);
toGraph = new int[animations.Length];
var tpose = AssetDatabase.LoadAssetAtPath <AnimationClip>(AssetDatabase.GUIDToAssetPath("3293cdd72fddb9e428a98388947b4697"));
var tposePlayable = AnimationClipPlayable.Create(graph, tpose);
tposePlayable.SetApplyFootIK(false);
mixer.SetInputCount(1);
mixer.ConnectInput(0, tposePlayable, 0);
mixer.SetInputWeight(0, 1);
int anims = 1;
for (int i = 0; i < animations.Length; i++)
{
var clip = animations[i].animation;
toGraph[i] = -1;
if (clip == null)
{
continue;
}
toGraph[i] = anims;
var clipPlayable = AnimationClipPlayable.Create(graph, clip);
clipPlayable.SetApplyFootIK(false);
mixer.SetInputCount(anims + 1);
mixer.ConnectInput(anims, clipPlayable, 0);
mixer.SetInputWeight(anims, 0);
anims++;
}
graph.Play();
haveGraph = true;
}
//別のAnimationが次に再生するアニメーションとしてセットされたらPlayableを変更する
private void SetAnimationPlayable()
{
//次に再生するアニメーションが登録されていればアニメーションを変更
if (setClip != null)
{
frameCount = 0;
if (playableGraph.IsValid() && mixer.IsValid())
{
mixer.SetTime(0);
nowClipPlayable.SetTime(0);
if (beforeClipPlayable.IsValid())
{
beforeClipPlayable.SetTime(0);
}
}
//mixerがすでに生成されていればmixerの登録を削除
if (mixer.IsValid())
{
playableGraph.Disconnect(mixer, 0);
playableGraph.Disconnect(mixer, 1);
}
//されていなければ生成、登録
else
{
mixer = AnimationMixerPlayable.Create(playableGraph, 2, true);
var output = AnimationPlayableOutput.Create(playableGraph, "output", GetComponent <Animator>());
output.SetSourcePlayable(mixer);
}
//前のアニメーションがあればそれを削除
if (beforeClipPlayable.IsValid())
{
beforeClipPlayable.Destroy();
}
//前のアニメーションに現在のアニメーションを登録
if (nowClipPlayable.IsValid())
{
beforeClipPlayable = nowClipPlayable;
}
//現在のアニメーションにセットされたアニメーションを設定
nowClip = setClip;
beforeClip = nowClip;
setClip = null;
//アニメーションプレイアブル作成
nowClipPlayable = AnimationClipPlayable.Create(playableGraph, nowClip);
mixer.ConnectInput(0, nowClipPlayable, 0);
mixer.ConnectInput(1, beforeClipPlayable, 0);
}
}
public void Init(AnimationClip clip1, AnimationClip clip2, float weight)
{
var clip1Playable = AnimationClipPlayable.Create(m_playableGraph, clip1);
var clip2Playable = AnimationClipPlayable.Create(m_playableGraph, clip2);
m_mixerPlayable.ConnectInput(0, clip1Playable, 0);
m_mixerPlayable.ConnectInput(1, clip2Playable, 0);
firstClipWeight = Mathf.Clamp01(weight);
m_firstClipLength = clip1.length;
m_secondClipLength = clip2.length;
clip1Playable.SetSpeed(m_firstClipLength);
clip2Playable.SetSpeed(m_secondClipLength);
m_mixerPlayable.SetInputWeight(0, 1);
}
public Handler Add(RuntimeAnimatorController controller)
{
m_Animator.runtimeAnimatorController = null;
var controllerPlayable = AnimatorControllerPlayable.Create(m_Graph, controller);
controllerPlayable.SetTime(0f);
var index = m_AnimatorHandlers.Count;
if (index >= m_MaxMixingCount)
{
throw new System.InvalidOperationException(string.Format("More than the specified count of AnimatorController have been added. (max: {0})", m_MaxMixingCount));
}
var Weight = 0f;
m_AnimatorControllerMixer.ConnectInput(index, controllerPlayable, 0, Weight);
var handler = new Handler(Type.Animator, index, Weight, OnChangeWeight, OnRemove);
handler.SetAnimatorController(controllerPlayable);
m_AnimatorHandlers.Add(handler);
var target = m_PlayableOutput.GetTarget();
if (target != null)
{
target.Rebind();
}
return(handler);
}
private void ChangeAnimation(RuntimeAnimatorController animatorController, float time)
{
if (!init)
{
Start();
}
currentConnectedIdx = (currentConnectedIdx + 1) % 2;
previousAnimator = currentAnimatorPlayable;
currentAnimatorPlayable = AnimatorControllerPlayable.Create(playableGraph, animatorController);
playableGraph.Disconnect(mixPlayable, currentConnectedIdx);
//mixPlayable = AnimationMixerPlayable.Create(playableGraph, 2);
//mixPlayable.ConnectInput(0, previousAnimator, 0);
mixPlayable.ConnectInput(currentConnectedIdx, currentAnimatorPlayable, 0);
//playableOutput.SetSourcePlayable(mixPlayable);
transTime = 0;
transTotalTime = time;
weight = 0;
if (currentAnimatorController)
{
Debug.Log(currentAnimatorController.ToString() + "->" + animatorController.ToString());
}
currentAnimatorController = animatorController;
//playableGraph.Play();
}
/*
* //</public Methods>
*/
/*
* //<private Methods>
*/
private bool ConnectProcess(AnimBox anim_box)
{
graph.Disconnect(mixer, 0);
graph.Disconnect(mixer, 1);
if (prePlayable.IsValid())
{
prePlayable.Destroy();
}
prePlayable = currentPlayable;
currentAnim = anim_box;
currentPlayable = AnimationClipPlayable.Create(graph, anim_box.clip);
mixer.ConnectInput(1, prePlayable, 0);
mixer.ConnectInput(0, currentPlayable, 0);
once = false;
return(true);
}
public Handler CreateMixer(int inputCount)
{
var index = m_SequenceHandlers.Count;
if (index >= m_MaxMixingCount)
{
throw new System.InvalidOperationException(string.Format("More than the specified count of AnimationMixerPlayable have been added. (max: {0})", m_MaxMixingCount));
}
var Weight = 0f;
var mixer = AnimationMixerPlayable.Create(m_Graph, inputCount, false);
m_SequenceMixer.ConnectInput(index, mixer, 0, Weight);
var handler = new Handler(Type.Sequence, index, Weight, OnChangeWeight, OnRemove);
handler.SetMixer(mixer);
m_SequenceHandlers.Add(handler);
var target = m_PlayableOutput.GetTarget();
if (target != null)
{
target.Rebind();
}
return(handler);
}
public void SetupPlayables(ref PlayableGraph a_playableGraph, ref AnimationMixerPlayable a_mixer, float a_startTime)
{
List <AnimationClip> clips = SourceBlendSpace.FinalClips;
a_mixer.SetInputCount(clips.Count);
float blendSpaceLength = clips[0].length;
float normalizedClipSpeed = 1f;
for (int i = 0; i < clips.Count; ++i)
{
AnimationClip clip = clips[i];
var clipPlayable = AnimationClipPlayable.Create(a_playableGraph, clip);
if (SourceBlendSpace.NormalizeTime)
{
normalizedClipSpeed = clip.length / blendSpaceLength;
}
clipPlayable.SetTime(a_startTime * normalizedClipSpeed);
clipPlayable.SetTime(a_startTime * normalizedClipSpeed);
a_mixer.ConnectInput(i, clipPlayable, 0, Weightings[i]);
clipPlayable.SetSpeed(normalizedClipSpeed);
}
}
public Instance(EntityManager entityManager, Entity owner, PlayableGraph graph, Entity animStateOwner, AnimGraph_Emote settings)
{
m_EntityManager = entityManager;
m_Owner = owner;
m_AnimStateOwner = animStateOwner;
m_settings = settings;
m_mixer = AnimationMixerPlayable.Create(graph, settings.emoteData.Length + 1);
var ports = new int[m_settings.emoteData.Length + 1];
for (var i = 0; i < ports.Length; i++)
{
ports[i] = i;
}
m_Transition = new SimpleTranstion <AnimationMixerPlayable>(m_mixer, ports);
for (int i = 0; i < settings.emoteData.Length; i++)
{
var clip = settings.emoteData[i].clip;
var clipPlayable = AnimationClipPlayable.Create(graph, clip);
clipPlayable.SetDuration(clip.length);
clipPlayable.Pause();
var port = i + 1;
m_mixer.ConnectInput(port, clipPlayable, 0);
m_mixer.SetInputWeight(port, 0.0f);
}
}
public BlendTree2d(PlayableGraph graph, List <BlendSpaceNode> nodes)
{
m_Nodes = nodes;
var count = m_Nodes.Count;
m_Positions = new Vector2[count];
m_Clips = new AnimationClipPlayable[count];
m_Weights = new float[count];
m_Mixer = AnimationMixerPlayable.Create(graph, count);
m_Mixer.SetPropagateSetTime(true);
for (var i = 0; i < count; i++)
{
var node = m_Nodes[i];
var clip = AnimationClipPlayable.Create(graph, node.clip);
node.clipLength = node.clip.length;
clip.Play();
m_Mixer.ConnectInput(i, clip, 0);
m_Clips[i] = clip;
m_Nodes[i] = node;
}
masterSpeed = 1f;
SetBlendPosition(Vector2.zero);
}
public void RemoveZeroWeightsInput()
{
int size = mixer.GetInputCount();
for (int i = 0; i < size; i++)
{
if (mixer.GetInputWeight(i) <= 0)
{
mixer.GetInput(i).Destroy();
for (int j = i + 1; j < size; j++)
{
// double localTime = ((AnimationClipPlayable)mixer.GetInput(j)).GetTime();
float _weight = mixer.GetInputWeight(j);
Playable clip = mixer.GetInput(j);
// clip.SetTime(localTime);
mixer.DisconnectInput(j);
mixer.ConnectInput(j - 1, clip, 0);
mixer.SetInputWeight(j - 1, _weight);
}
i--;
size--;
mixer.SetInputCount(size);
}
}
}
//===========================================================================================
/**
* @brief
*
*********************************************************************************************/
private void AddClipToPreview(AnimationClip a_clip)
{
if (m_previewActive && a_clip != null)
{
m_blendWeights.Add(0f);
AnimationMixerPlayable mixer = MxMPreviewScene.Mixer;
int inputId = mixer.GetInputCount();
mixer.SetInputCount(inputId + 1);
var clipPlayable = AnimationClipPlayable.Create(MxMPreviewScene.PlayableGraph, a_clip);
mixer.ConnectInput(inputId, clipPlayable, 0);
for (int i = 0; i < mixer.GetInputCount(); ++i)
{
var playable = mixer.GetInput(i);
if (playable.IsValid())
{
playable.SetTime(0f);
}
}
CalculateBlendWeights();
ApplyBlendWeights();
}
}
//AnimationClipの切り替え
public void reconnect(AnimationClip clip)
{
//切断
graph.Disconnect(mixer, 0);
graph.Disconnect(mixer, 1);
if (beforePlayable.IsValid())
{
beforePlayable.Destroy();
}
//更新
beforePlayable = nowPlayable;
nowPlayable = AnimationClipPlayable.Create(graph, clip);
//再接続
mixer.ConnectInput(1, beforePlayable, 0);
mixer.ConnectInput(0, nowPlayable, 0);
if (playParam.reverse)
{
//逆再生時の時間設定
nowPlayable.SetTime(nowPlayable.GetAnimationClip().length);
nowPlayable.SetSpeed(-1f);
}
else
{
//通常時の時間設定
nowPlayable.SetSpeed(1f);
}
//同期遷移時の時間設定
if (playParam.syncTrans)
{
nowPlayable.SetTime(beforePlayable.GetTime());
}
//遷移コルーチンがあるなら停止する(重複して遷移コルーチンが走らないようにする)
if (fadeCoroutine != null)
{
player.StopCoroutine(fadeCoroutine);
}
//遷移中のモーションミックス開始
fadeCoroutine = player.StartCoroutine(crossFadeCoroutine(playParam.fadeDuration, playParam.waitFade));
}
public void Blend(AnimationScriptPlayable playable, float duration, AnimationCurve transitionCurve)
{
if (tweening && lastTween != null)
{
lastTween.callOnCompletes();
lastTween.setOnUpdate((float value) => { });
lastTween.setOnComplete(() => { });
// LeanTween.pause(lastTween.id);
}
// tweenPlayable = AnimatorControllerPlayable.Create(playableGraph, ac);
tweenPlayable = playable;
mixerPlayable = AnimationMixerPlayable.Create(playableGraph, 2);
mixerPlayable.ConnectInput(0, activePlayable, 0);
mixerPlayable.ConnectInput(1, tweenPlayable, 0);
// Plays the Graph.
mixerPlayable.SetInputWeight(0, 1);
playableOutput.SetSourcePlayable(mixerPlayable);
lastTween = LeanTween
.value(playerController.gameObject, 0f, 1f, duration)
.setEase(transitionCurve)
.setOnUpdate((float value) =>
{
mixerPlayable.SetInputWeight(0, 1f - value);
mixerPlayable.SetInputWeight(1, value);
})
.setOnComplete(() =>
{
tweening = false;
playableGraph.Disconnect(mixerPlayable, 0);
playableGraph.Disconnect(mixerPlayable, 1);
playableOutput.SetSourcePlayable(tweenPlayable);
var prevActive = activePlayable;
activePlayable = tweenPlayable;
// prevActive.Destroy();
mixerPlayable.Destroy();
});
tweening = true;
}
public void Play(AnimationClip nextAnimationClip, float fadeTime, float speed)
{
if (nextAnimationClip == null)
{
return;
}
if (currentAnimationClip == null)
{
graph.Disconnect(mixer, 1);
currentPlayable = AnimationClipPlayable.Create(graph, nextAnimationClip);
currentPlayable.SetSpeed(speed);
mixer.ConnectInput(0, currentPlayable, 0);
mixer.SetInputWeight(0, 1f);
currentAnimationClip = nextAnimationClip;
}
else if (!currentAnimationClip.name.StartsWith(nextAnimationClip.name))
{
graph.Disconnect(mixer, 0);
graph.Disconnect(mixer, 1);
if (previousPlayable.IsValid())
{
previousPlayable.Destroy();
}
currentAnimationClip = nextAnimationClip;
previousPlayable = currentPlayable;
currentPlayable = AnimationClipPlayable.Create(graph, nextAnimationClip);
currentPlayable.SetSpeed(speed);
mixer.ConnectInput(0, currentPlayable, 0);
mixer.ConnectInput(1, previousPlayable, 0);
if (fadeTime <= 0f)
{
mixer.SetInputWeight(0, 1f);
mixer.SetInputWeight(1, 0f);
return;
}
if (mixerCoroutine != null)
{
StopCoroutine(mixerCoroutine);
mixerCoroutine = null;
}
mixerCoroutine = StartCoroutine(PlayCoroutine(fadeTime));
}
}
public AnimationGraph(string name, Animator animator, int maxMixingCount)
{
m_MaxMixingCount = maxMixingCount;
m_Animator = animator;
m_Graph = PlayableGraph.Create(name);
m_Graph.SetTimeUpdateMode(DirectorUpdateMode.GameTime);
m_RootMixer = AnimationMixerPlayable.Create(m_Graph, 2, false);
m_AnimatorControllerMixer = AnimationMixerPlayable.Create(m_Graph, maxMixingCount, false);
m_SequenceMixer = AnimationMixerPlayable.Create(m_Graph, maxMixingCount, false);
m_RootMixer.ConnectInput(0, m_AnimatorControllerMixer, 0, 1f);
m_RootMixer.ConnectInput(1, m_SequenceMixer, 0, 0f);
m_PlayableOutput = AnimationPlayableOutput.Create(m_Graph, "Animation", animator);
m_PlayableOutput.SetSourcePlayable(m_RootMixer);
m_Graph.Play();
}
public void Connect(int index, Playable timeline)
{
if (!Animation.IsNull() && Animation.IsValid())
{
Animation.ConnectInput(index, timeline, 0);
}
if (!Audio.IsNull() && Audio.IsValid())
{
Audio.ConnectInput(index, timeline, 1);
}
}
protected void InitPlayable()
{
graph = PlayableGraph.Create();
mixer = AnimationMixerPlayable.Create(graph, 2, true);
mixer.ConnectInput(0, currentPlayable, 0);
mixer.SetInputWeight(0, 1);
var output = AnimationPlayableOutput.Create(graph, name + " output", animator);
output.SetSourcePlayable(mixer, 0);
graph.Play();
}
public override void OnChangeClip(ClipBehaviour fromClip, float fromWeight, ClipBehaviour toClip, float toWeight)
{
m_Mixer.DisconnectInput(0);
m_Mixer.DisconnectInput(1);
if (fromClip != null)
{
var playable = ((AnimationClipBehaviour)fromClip).Playable;
m_Mixer.ConnectInput(0, playable, 0, fromWeight);
}
if (toClip != null)
{
var playable = ((AnimationClipBehaviour)toClip).Playable;
m_Mixer.ConnectInput(1, playable, 0, toWeight);
}
m_Mixer.SetInputWeight(0, fromWeight);
m_Mixer.SetInputWeight(1, toWeight);
}
/*
* //</public Methods>
*/
private void ConnectProcess(AnimationClip animation_clip)
{
if (animation_clip == GetCurrentMotion)
{
PlayAble = false;
return;
}
PlayAble = true;
graph.Disconnect(mixer, 0);
graph.Disconnect(mixer, 1);
if (prePlayable.IsValid())
{
prePlayable.Destroy();
}
prePlayable = currentPlayable;
GetCurrentMotion = animation_clip;
currentPlayable = AnimationClipPlayable.Create(graph, animation_clip);
mixer.ConnectInput(1, prePlayable, 0);
mixer.ConnectInput(0, currentPlayable, 0);
}
/// <summary>
/// Adds clip to Aniamtion Graph and then plays the clip.
/// </summary>
/// <param name="blendTime">Time taken to blend between current clip and next clip</param>
/// <param name="clipOffset">How many seconds to offset the clip's start time</param>
public void Play(AnimationClip clip, float blendTime = .2f, float clipOffset = 0)
{
if (!clip)
{
Debug.LogError("Cannot Play Null Clip", gameObject);
return;
}
if (!playableLookup.TryGetValue(clip, out var next))
{
if (!graph.IsValid())
{
CreateGraph();
}
playableLookup[clip] = next = AnimationClipPlayable.Create(graph, clip);
}
var current = mixer.GetInput(0);
next.SetTime(clipOffset);
mixer.DisconnectInput(0);
mixer.DisconnectInput(1);
mixer.ConnectInput(0, next, 0);
if (blendTime <= 0)
{
mixer.SetInputWeight(0, 1);
}
else
{
if (current.IsValid() && ((AnimationClipPlayable)current).GetAnimationClip() != ((AnimationClipPlayable)next).GetAnimationClip())
{
mixer.ConnectInput(1, current, 0);
}
mixer.SetInputWeight(0, 0);
mixer.SetInputWeight(1, 1);
}
this.blendTime = blendTime;
changeTime = Time.time;
}
void CreatePlayableGraph()
{
playableGraph = PlayableGraph.Create();
var playableOutput = AnimationPlayableOutput.Create(playableGraph, "PlayableGraphSample", GetComponent <Animator>());
mixerPlayable = AnimationMixerPlayable.Create(playableGraph, 2);
playableOutput.SetSourcePlayable(mixerPlayable);
var clipPlayable1 = AnimationClipPlayable.Create(playableGraph, clip1);
var clipPlayable2 = AnimationClipPlayable.Create(playableGraph, clip2);
//playableGraph.Connect(clipPlayable1,0,mixerPlayable,0);
//playableGraph.Connect(clipPlayable2, 0, mixerPlayable, 1);
//上面的两行与下面的两行代码是等价的
mixerPlayable.ConnectInput(0, clipPlayable1, 0);
mixerPlayable.ConnectInput(1, clipPlayable2, 0);
weight = Mathf.Clamp01(weight);
mixerPlayable.SetInputWeight(0, 1.0f - weight);//分别设置两个数据端口的权重
mixerPlayable.SetInputWeight(1, weight);
playableGraph.Play();
GraphVisualizerClient.Show(playableGraph, this.GetType().Name);
}
public EnemyAnimator Configure(Animator animator, EnemyAnimationConfig config)
{
flag = true;
hasAppearClip = config.Appear;
hasDisappearClip = config.Disappear;
graph = PlayableGraph.Create();
graph.SetTimeUpdateMode(DirectorUpdateMode.GameTime);
mixer = AnimationMixerPlayable.Create(
graph, hasAppearClip || hasDisappearClip ? 6 : 4
);
var clip = AnimationClipPlayable.Create(graph, config.Move);
clip.Pause();
int val = (int)Clip.Move;
mixer.ConnectInput(val, clip, 0);
clip = AnimationClipPlayable.Create(graph, config.Intro);
clip.SetDuration(config.Intro.length);
clip.Pause();
val = (int)Clip.Intro;
mixer.ConnectInput(val, clip, 0);
clip = AnimationClipPlayable.Create(graph, config.Outro);
clip.SetDuration(config.Outro.length);
clip.Pause();
val = (int)Clip.Outro;
mixer.ConnectInput(val, clip, 0);
clip = AnimationClipPlayable.Create(graph, config.Dying);
clip.SetDuration(config.Dying.length);
clip.Pause();
val = (int)Clip.Dying;
mixer.ConnectInput(val, clip, 0);
if (hasAppearClip)
{
clip = AnimationClipPlayable.Create(graph, config.Appear);
clip.SetDuration(config.Appear.length);
clip.Pause();
mixer.ConnectInput((int)Clip.Appear, clip, 0);
}
if (hasDisappearClip)
{
clip = AnimationClipPlayable.Create(graph, config.Disappear);
clip.SetDuration(config.Disappear.length);
clip.Pause();
mixer.ConnectInput((int)Clip.Disappear, clip, 0);
}
var output = AnimationPlayableOutput.Create(graph, "Enemy", animator);
output.SetSourcePlayable(mixer);
return(this);
}
public void RemoveZeroWeightsInputsAnimations(
AnimationMixerPlayable mixer,
List <float> blendingWeights,
List <float> currentWeights,
List <int> curretClipsIndex,
List <LogicAnimationsSequence> animationsSequences
)
{
int size = mixer.GetInputCount();
for (int i = 0; i < size; i++)
{
if (currentWeights[i] <= 0f)
{
int sequenceMixerInputsCount = mixer.GetInput(i).GetInputCount();
if (sequenceMixerInputsCount > 0)
{
for (int mixerInputInputsIndex = 0; mixerInputInputsIndex < sequenceMixerInputsCount; mixerInputInputsIndex++)
{
mixer.GetInput(i).GetInput(mixerInputInputsIndex).Destroy();
}
for (int as_Index = 0; as_Index < animationsSequences.Count; as_Index++)
{
if (curretClipsIndex[i] == animationsSequences[as_Index].dataIndex)
{
animationsSequences.RemoveAt(as_Index);
break;
}
}
}
mixer.GetInput(i).Destroy();
blendingWeights.RemoveAt(i);
curretClipsIndex.RemoveAt(i);
currentWeights.RemoveAt(i);
for (int j = i + 1; j < size; j++)
{
// double localTime = ((AnimationClipPlayable)mixer.GetInput(j)).GetTime();
float _weight = mixer.GetInputWeight(j);
Playable clip = mixer.GetInput(j);
// clip.SetTime(localTime);
mixer.DisconnectInput(j);
mixer.ConnectInput(j - 1, clip, 0);
mixer.SetInputWeight(j - 1, _weight);
}
i--;
size--;
mixer.SetInputCount(size);
}
}
}
private void Start()
{
if (nowPlayAnimation != null)
{
_beforeNowPlayClip = nowPlayAnimation;
// AnimationClipをMixerに登録
_nowPlayAnimation = AnimationClipPlayable.Create(playableGraph, nowPlayAnimation);
mixer = AnimationMixerPlayable.Create(playableGraph, 2, true);
mixer.ConnectInput(0, _nowPlayAnimation, 0);
mixer.SetInputWeight(0, 1);
var output = AnimationPlayableOutput.Create(playableGraph, "output", GetComponent <Animator>());
output.SetSourcePlayable(mixer);
playableGraph.Play();
}
}
