// PRIVATE METHODS: ----------------------------------------------------------------------- private void Setup() { if (!this.runtimeController) { throw new Exception(ERR_NORTC); } if (this.characterAnimator.animator.playableGraph.IsValid()) { this.characterAnimator.animator.playableGraph.Destroy(); } if (this.graph.IsValid()) { this.graph.Destroy(); } this.graph = PlayableGraph.Create(GRAPH_NAME); this.graph.SetTimeUpdateMode(DirectorUpdateMode.GameTime); AnimationPlayableOutput output = AnimationPlayableOutput.Create( this.graph, GRAPH_NAME, this.characterAnimator.animator ); this.SetupSectionDefaultStates(); this.SetupSectionStates(); this.SetupSectionGestures(); output.SetSourcePlayable(this.mixerGesturesOutput); output.SetSourceOutputPort(0); this.graph.Play(); }
private void Play(AnimationClip animClip) { m_Graph = PlayableGraph.Create(name + " Character Anims"); m_Graph.SetTimeUpdateMode(DirectorUpdateMode.GameTime); // Create the starting animation clip. AnimationClipPlayable animPlayable = AnimationClipPlayable.Create(m_Graph, animClip); // Create the transition mixer for changing animations over time. AnimationMixerPlayable transitionMixer = AnimationMixerPlayable.Create(m_Graph, 2); // Connect the base clip to the transition mixer. m_Graph.Connect(animPlayable, 0, transitionMixer, 1); transitionMixer.SetInputWeight(0, 0); transitionMixer.SetInputWeight(1, 1); // Create the layer output to handle 'heels'/'barefoot' options. AnimationPlayableOutput playableOutput = AnimationPlayableOutput.Create(m_Graph, "LayerMixer", m_Animator); AnimationLayerMixerPlayable layerMixer = AnimationLayerMixerPlayable.Create(m_Graph, 2); // Set the 'heels' layer to additive. layerMixer.SetLayerAdditive(1, true); playableOutput.SetSourcePlayable(layerMixer); layerMixer.ConnectInput(0, transitionMixer, 0, 1); m_Graph.Play(); }
public void SetAnimation(AnimationClip clip) { _clip = AnimationClipPlayable.Create(_graph, clip); _output = AnimationPlayableOutput.Create(_graph, "output", _animator); _output.SetSourcePlayable(_clip); _clipTotalTime = (int)clip.length; }
//Create and play the playable graph void CreateAndPlayTree() { graph = PlayableGraph.Create(); animationOutput = AnimationPlayableOutput.Create(graph, "Animation", animator); masterMixer = AnimationLayerMixerPlayable.Create(graph, siblingTracks.Count + 2); for (var i = 0; i < siblingTracks.Count; i++) { var animatorTrack = siblingTracks[i]; var mix = animatorTrack.CreateClipsMixer(graph); graph.Connect(mix, 0, masterMixer, i); masterMixer.SetInputWeight(i, 1f); if (animatorTrack.mask != null) { masterMixer.SetLayerMaskFromAvatarMask((uint)i, animatorTrack.mask); } masterMixer.SetLayerAdditive((uint)i, animatorTrack.blendMode == AnimationBlendMode.Additive); } animatorPlayable = AnimatorControllerPlayable.Create(graph, animator.runtimeAnimatorController); graph.Connect(animatorPlayable, 0, masterMixer, siblingTracks.Count + 1); masterMixer.SetInputWeight(siblingTracks.Count + 1, 0f); animationOutput.SetSourcePlayable(masterMixer); // graph.Play(); // masterMixer.Pause(); // GraphVisualizerClient.Show(graph, this.name); }
public static PlayableGraph BuildPlayableGraph(Animator animator, IList <IRigLayer> layers, SyncSceneToStreamLayer syncSceneToStreamLayer) { string graphName = animator.gameObject.transform.name + "_Rigs"; PlayableGraph graph = PlayableGraph.Create(graphName); graph.SetTimeUpdateMode(DirectorUpdateMode.GameTime); IEnumerable <PlayableChain> playableChains = BuildPlayables(animator, graph, layers, syncSceneToStreamLayer); foreach (var chain in playableChains) { if (!chain.IsValid()) { continue; } AnimationPlayableOutput output = AnimationPlayableOutput.Create(graph, String.Format("%1-Output", chain.name), animator); output.SetAnimationStreamSource(AnimationStreamSource.PreviousInputs); output.SetSortingOrder(k_AnimationOutputPriority); // Connect last rig playable to output output.SetSourcePlayable(chain.playables[chain.playables.Length - 1]); } return(graph); }
AnimationScriptPlayable[] BuildRigPlayables(PlayableGraph graph, Rig rig, ref AnimationPlayableOutput output) { if (rig == null || rig.jobs == null || rig.jobs.Length == 0) { return(null); } var count = rig.jobs.Length; var playables = new AnimationScriptPlayable[count]; for (int i = 0; i < count; ++i) { var binder = rig.constraints[i].binder; playables[i] = binder.CreatePlayable(graph, rig.jobs[i]); } // Set null input on first rig playable in order to use inputWeight // to set job constraint weight playables[0].AddInput(Playable.Null, 0, 1); // Connect rest of rig playables serially for (int i = 1; i < count; ++i) { playables[i].AddInput(playables[i - 1], 0, 1); } // Connect last rig playable to output output.SetSourcePlayable(playables[playables.Length - 1]); return(playables); }
private void PlayAnimation() { AnimationClip cur = idleClip; switch (curState) { case PlayerState.Idle: { cur = idleClip; } break; case PlayerState.Jump: { cur = jumpClip; } break; case PlayerState.Run: { cur = runClip; } break; } AnimationClipPlayable animationClip1 = AnimationClipPlayable.Create(playableGraph, cur); //playableGraph.Connect(animationClip1,0, animationLayerMixerPlayable, 0); //animationLayerMixerPlayable.SetLayerMaskFromAvatarMask(1, bbb); animationPlayableOutput.SetSourcePlayable(animationClip1); //Debug.Log("f**k"); playableGraph.Play(); }
private void BuildOutput() { PlayableDirector.Evaluate(); if (PlayableDirector.playableGraph.IsValid()) { _outputTrackIndex = 0; _trackAsset = (PlayableDirector.playableAsset as TimelineAsset)?.GetOutputTrack(_outputTrackIndex); _originalOutput = (AnimationPlayableOutput)PlayableDirector.playableGraph.GetOutputByType <AnimationPlayableOutput>(_outputTrackIndex); _originalSourcePlayable = _originalOutput.GetSourcePlayable(); _clone = PlayableDirector.playableAsset.CreatePlayable(PlayableDirector.playableGraph, PlayableDirector.gameObject); _mixer = AnimationMixerPlayable.Create(PlayableDirector.playableGraph, 2); _cloneIndex = _mixer.AddInput(_clone, 0); _originalIndex = _mixer.AddInput(_originalSourcePlayable, 0, 1f); if (_originalOutput.IsOutputValid() && _originalOutput.GetTarget() != null) { _output = AnimationPlayableOutput.Create(PlayableDirector.playableGraph, "OverridedDirectorOutput" + GetInstanceID(), _originalOutput.GetTarget()); _output.SetSourcePlayable(_mixer); _output.SetSourceOutputPort(_originalOutput.GetSourceOutputPort()); _output.SetWeight(1f); _originalOutput.SetTarget(null); } else { Debug.Log("Original Director Output is invalid"); } } }
/// <summary> /// Called by Unity. /// </summary> private void OnEnable() { _cubismFadeMotionList = GetComponent <CubismFadeController>().CubismFadeMotionList; // Fail silently... if (_cubismFadeMotionList == null) { Debug.LogError("CubismMotionController : CubismFadeMotionList doesn't set in CubismFadeController."); return; } // Get Animator. var animator = GetComponent <Animator>(); if (animator.runtimeAnimatorController != null) { Debug.LogWarning("Animator Controller was set in Animator component."); return; } _isActive = true; // Disabble animator's playablegrap. var graph = animator.playableGraph; if (graph.IsValid()) { graph.GetOutput(0).SetWeight(0); } // Create Playable Graph. _playableGrap = PlayableGraph.Create("Playable Graph : " + this.FindCubismModel().name); _playableGrap.SetTimeUpdateMode(DirectorUpdateMode.GameTime); // Create Playable Output. _playableOutput = AnimationPlayableOutput.Create(_playableGrap, "Animation", animator); _playableOutput.SetWeight(1); // Create animation layer mixer. _layerMixer = AnimationLayerMixerPlayable.Create(_playableGrap, LayerCount); // Create cubism motion layers. if (_motionLayers == null) { LayerCount = (LayerCount < 1) ? 1 : LayerCount; _motionLayers = new CubismMotionLayer[LayerCount]; } for (var i = 0; i < LayerCount; ++i) { _motionLayers[i] = CubismMotionLayer.CreateCubismMotionLayer(_playableGrap, _cubismFadeMotionList); _motionLayers[i].AnimationEndHandler += OnAnimationEnd; _layerMixer.ConnectInput(i, _motionLayers[i].PlayableOutput, 0); _layerMixer.SetInputWeight(i, 1.0f); } // Set Playable Output. _playableOutput.SetSourcePlayable(_layerMixer); }
static public void Play(Animator animator, Playable playable, PlayableGraph graph) { AnimationPlayableOutput playableOutput = AnimationPlayableOutput.Create(graph, "AnimationClip", animator); playableOutput.SetSourcePlayable(playable, 0); graph.SyncUpdateAndTimeMode(animator); graph.Play(); }
public void ConnectTracksToPlayableGraph(AnimationClip clip, Animator anim) { AnimationPlayableOutput playableOutput = AnimationPlayableOutput.Create(timeline.pg, "Animation", anim); var clipPlayable = AnimationClipPlayable.Create(timeline.pg, clip); playableOutput.SetSourcePlayable(clipPlayable); playableOutput.SetSourceInputPort(0); }
public void CreatePlayable(Animator animator = null) { m_PlayableGraph.SetTimeUpdateMode(DirectorUpdateMode.GameTime); m_PlayableGraph.Play(); m_Playable = ScriptPlayable <VisualAnimationPlayable> .Create(m_PlayableGraph).GetBehaviour(); m_AnimationPlayableOutput = AnimationPlayableOutput.Create(m_PlayableGraph, "Output", animator); m_AnimationPlayableOutput.SetSourcePlayable(m_Playable.Playable, 0); }
public void Initialize(GameObject go) { this.go = go; graph = PlayableGraph.Create("Preapare Data Graph"); mixer = AnimationMixerPlayable.Create(graph, 0, false); animationOutput = AnimationPlayableOutput.Create(graph, "Animation Output", go.GetComponent <Animator>()); animationOutput.SetSourcePlayable(mixer); graph.SetTimeUpdateMode(DirectorUpdateMode.Manual); }
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 EvaluationGraph(Animator animator, AnimationClip clip) { m_Graph = PlayableGraph.Create("Evaluation-Graph"); m_Graph.SetTimeUpdateMode(DirectorUpdateMode.Manual); var clipPlayable = AnimationClipPlayable.Create(m_Graph, clip); m_Output = AnimationPlayableOutput.Create(m_Graph, "Evaluation-Graph-Output", animator); m_Output.SetSourcePlayable(clipPlayable); }
private void Start() { m_graph = PlayableGraph.Create(); m_graph.SetTimeUpdateMode(DirectorUpdateMode.GameTime); m_mixer = AnimationMixerPlayable.Create(m_graph, 2); m_output = AnimationPlayableOutput.Create(m_graph, "Animation", GetComponent <Animator>()); m_output.SetSourcePlayable(m_mixer); m_graph.Play(); }
public static AnimatorControllerPlayable PlayAnimatorController(Animator animator, RuntimeAnimatorController controller, out PlayableGraph graph) { graph = PlayableGraph.Create(); AnimationPlayableOutput output = AnimationPlayableOutput.Create(graph, "AnimatorControllerPlayable", animator); AnimatorControllerPlayable animatorControllerPlayable = AnimatorControllerPlayable.Create(graph, controller); output.SetSourcePlayable(animatorControllerPlayable); graph.SyncUpdateAndTimeMode(animator); graph.Play(); return(animatorControllerPlayable); }
public static AnimationLayerMixerPlayable PlayLayerMixer(Animator animator, int inputCount, out PlayableGraph graph) { graph = PlayableGraph.Create(); AnimationPlayableOutput output = AnimationPlayableOutput.Create(graph, "Mixer", animator); AnimationLayerMixerPlayable animationLayerMixerPlayable = AnimationLayerMixerPlayable.Create(graph, inputCount); output.SetSourcePlayable(animationLayerMixerPlayable); graph.SyncUpdateAndTimeMode(animator); graph.Play(); return(animationLayerMixerPlayable); }
void CreateGraph() { m_PlayableGraph = PlayableGraph.Create(name); m_PlayableGraph.SetTimeUpdateMode(DirectorUpdateMode.GameTime); m_PlayableOutput = AnimationPlayableOutput.Create(m_PlayableGraph, "Animation", animator); m_RootMixerPlayable = AnimationMixerPlayable.Create(m_PlayableGraph, 1); m_PlayableOutput.SetSourcePlayable(m_RootMixerPlayable); m_PlayableGraph.Play(); }
public void Create(Animator animator) { string name = animator.gameObject.name; _graph = PlayableGraph.Create(name); _graph.SetTimeUpdateMode(DirectorUpdateMode.Manual); _mixerRoot = AnimationLayerMixerPlayable.Create(_graph); _output = AnimationPlayableOutput.Create(_graph, name, animator); _output.SetSourcePlayable(_mixerRoot); }
private void InitializeAnimations() { npcData.Animator = gameObject.AddComponent <Animator>(); PlayableGraph playableGraph = PlayableGraph.Create(); AnimationClipPlayable clipPlayable = AnimationClipPlayable.Create(playableGraph, npcData.IdleFront); AnimationPlayableOutput playableOutput = AnimationPlayableOutput.Create(playableGraph, "idleFront", npcData.Animator); playableOutput.SetSourcePlayable(clipPlayable); playableGraph.Play(); }
public static AnimationClipPlayable PlayClip(Animator animator, AnimationClip clip, out PlayableGraph graph) { graph = PlayableGraph.Create(); AnimationPlayableOutput output = AnimationPlayableOutput.Create(graph, "AnimationClip", animator); AnimationClipPlayable animationClipPlayable = AnimationClipPlayable.Create(graph, clip); output.SetSourcePlayable(animationClipPlayable); graph.SyncUpdateAndTimeMode(animator); graph.Play(); return(animationClipPlayable); }
static public AnimationMixerPlayable PlayMixer(Animator animator, int inputCount, out PlayableGraph graph) { graph = PlayableGraph.Create(); AnimationPlayableOutput playableOutput = AnimationPlayableOutput.Create(graph, "Mixer", animator); var mixer = AnimationMixerPlayable.Create(graph, inputCount); playableOutput.SetSourcePlayable(mixer); graph.SyncUpdateAndTimeMode(animator); graph.Play(); return(mixer); }
public void Play(AnimationClip animationClip) { var animationClipPlayable = AnimationClipPlayable.Create(playableGraph, animationClip); var prePlayable = animationPlayableOutput.GetSourcePlayable(); if (prePlayable.IsValid()) { prePlayable.Destroy(); } animationPlayableOutput.SetSourcePlayable(animationClipPlayable); playableGraph.Play(); }
void Start() { graph = PlayableGraph.Create("RotateCube"); AnimationPlayableOutput animOutput = AnimationPlayableOutput.Create(graph, "Animation", GetComponent <Animator>()); AnimationClipPlayable clipPlay = AnimationClipPlayable.Create(graph, clip); animOutput.SetSourcePlayable(clipPlay); graph.Play(); // 另一种写法,更方便的接口 //AnimationPlayableUtilities.PlayClip(GetComponent<Animator>(), clip, out graph); }
// Start is called before the first frame update void Start() { playableGraph = PlayableGraph.Create(); animationPlayableOutput = AnimationPlayableOutput.Create(playableGraph, "", GetComponent <Animator>()); AnimationClipPlayable animationClip1 = AnimationClipPlayable.Create(playableGraph, runClip); //playableGraph.Connect(animationClip1,0, animationLayerMixerPlayable, 0); //animationLayerMixerPlayable.SetLayerMaskFromAvatarMask(1, bbb); animationPlayableOutput.SetSourcePlayable(animationClip1); //Debug.Log("f**k"); playableGraph.Play(); }
//Use this instead of the MonoBehaviour Start Function protected override void Init() { animator = GetComponent <Animator>(); playableGraph = PlayableGraph.Create(); //playableGraph.SetTimeUpdateMode(DirectorUpdateMode.Manual); playableOutput = AnimationPlayableOutput.Create(playableGraph, "Anim", animator); playableClip = AnimationClipPlayable.Create(playableGraph, clip); playableOutput.SetSourcePlayable(playableClip); }
/* public void UpdateHandPositions() * { * setEdit(); * editHandCoord(); * printHandCoord(); * //logAnimations(); * * MainCameraControl.main.viewModel.localScale = scale; * * XRInputManager xrInput = XRInputManager.GetXRInputManager(); * Vector3 leftHandPos = xrInput.Get(Controller.Left, CommonUsages.devicePosition); * Quaternion leftHandRot = xrInput.Get(Controller.Left, CommonUsages.deviceRotation); * Vector3 rightHandPos = xrInput.Get(Controller.Right, CommonUsages.devicePosition); * Quaternion rightHandRot = xrInput.Get(Controller.Right, CommonUsages.deviceRotation); * * Transform rightHand = xrInput.GetGameTransform(Controller.Right); * rightHand.localPosition += new Vector3(rightPosX, rightPosY, rightPosZ); * rightHand.localRotation *= Quaternion.Euler(rightRotX, rightRotY, rightRotZ); * ik.solver.rightHandEffector.target = rightHand; * ik.solver.rightHandEffector.positionWeight = 1f; * * Transform leftHand = xrInput.GetGameTransform(Controller.Left); * leftHand.localPosition += new Vector3(leftPosX, leftPosY, leftPosZ); * leftHand.localRotation *= Quaternion.Euler(leftRotX, leftRotY, leftRotZ); * ik.references.leftHand.localRotation = leftHand.localRotation; * ik.references.leftHand.localPosition = leftHand.localPosition; *//* ik.solver.leftHandEffector.target = leftHand; * ik.solver.leftHandEffector.positionWeight = 1f;*//* * * }*/ public void disableArmAnimations() { Animator anim = player.playerAnimator; Transform leftLowerArm = ik.references.leftForearm; AvatarMask mask = new AvatarMask(); mask.AddTransformPath(leftLowerArm); PlayableGraph graph = player.playerAnimator.playableGraph; AnimationPlayableOutput playableOutput = AnimationPlayableOutput.Create(graph, "LayerMixer", anim); AnimationMixerPlayable mixer = AnimationMixerPlayable.Create(graph, 2); playableOutput.SetSourcePlayable(mixer); }
public void Awake() { graph = PlayableGraph.Create(); graph.SetTimeUpdateMode(mode); playableOutput = AnimationPlayableOutput.Create(graph, "EthanWithPlayable", GetComponent <Animator>()); var runClip = AnimationClipPlayable.Create(graph, run); playableOutput.SetSourcePlayable(runClip); graph.Play(); }
public void Play(AnimationClip clip = null, float time = 0, float speed = 0) { if (clip == null && this.clip == null) { throw new Exception("An AnimationClip must be set at least once to play."); } if (clip != null) { playable = AnimationClipPlayable.Create(graph, clip); this.clip = clip; output.SetSourcePlayable(playable); } if (speed == 0f) { speed = clip.apparentSpeed; } playable.SetSpeed(speed); playable.SetTime(time); playable.SetDuration(clip.averageDuration); graph.Play(); }