public override void ProcessFrame(Playable playable, FrameData info, object playerData) { base.ProcessFrame(playable, info, playerData); // Get time of the root playable in the playable graph, which is the timeline itself. var curTime = playable.GetGraph().GetRootPlayable(0).GetTime(); var prevTime = playable.GetGraph().GetRootPlayable(0).GetPreviousTime(); // If there's an event at the beginning of the track, and we're currently at the // beginning of the track, we should fire it now. checkFireTimeZeroEvent(curTime); if (!_firstFrameFired) { _firstFrameFired = true; } else { if (prevTime <= curTime) { // Sweep forward from prevTime to curTime if moving forward. sweepFireEvents(prevTime, curTime); } else { // When scrubbing backwards, sweep from the beginning of the track, potentially // firing events based on the eventScrubType. sweepFireFromBeginning(prevTime, curTime); } } }
// Called each frame while the state is set to Play public override void PrepareFrame(Playable playable, FrameData info) { var anim = Anim.Resolve(playable.GetGraph().GetResolver()); if (anim != null) { if (!string.IsNullOrEmpty(AnimName)) { anim.Play(AnimName); } if (!string.IsNullOrEmpty(AnimParamName)) { anim.SetInteger(AnimParamName, AnimParamValue); } } var spriteAnim = SpriteAnim.Resolve(playable.GetGraph().GetResolver()); if (spriteAnim != null) { if (IsPause) { spriteAnim.IsStop(true); return; } spriteAnim.Play(SpriteAnimName, IsLoop, AnimSpeed == 0 ? 1 : AnimSpeed); } }
public override void OnGraphStart(Playable playable) { // コイツは UnityEngine.Timeline.TimelinePlayable であるコトを期待している RootPlayable = playable.GetGraph().GetRootPlayable(0); PlayableDirector = (PlayableDirector)playable.GetGraph().GetResolver(); ActiveTracks = ((TimelineAsset)PlayableDirector.playableAsset).GetOutputTracks().OfType <ActiveTrack>(); }
/// <summary> /// This function is called during the ProcessFrame phase of the PlayableGraph. /// </summary> /// <param name="playable">The playable this behaviour is attached to.</param> /// <param name="info">A FrameData structure that contains information about the current frame context.</param> /// <param name="playerData">unused</param> public override void ProcessFrame(Playable playable, FrameData info, object playerData) { if (director == null || !director.isActiveAndEnabled || director.playableAsset == null) { return; } if (m_SyncTime || DetectOutOfSync(playable)) { UpdateTime(playable); if (director.playableGraph.IsValid()) { director.playableGraph.Evaluate(); #if TIMELINE_FRAMEACCURATE director.playableGraph.SynchronizeEvaluation(playable.GetGraph()); #endif } else { director.Evaluate(); } } m_SyncTime = false; #if UNITY_2021_2_OR_NEWER SyncStop(playable.GetGraph(), playable.GetTime()); #endif }
public override void ProcessFrame(Playable playable, FrameData info, object playerData) { #if UNITY_EDITOR /* * Process frame is called from OnGUI() when auditioning. * Check playing to avoid retriggering sounds while scrubbing or repainting. * Check IsQuitting to avoid accessing the RuntimeManager during the Play-In-Editor to Editor transition. */ bool playing = playable.GetGraph().IsPlaying(); if (!playing) { return; } /* When auditioning manually update the StudioSystem in place of the RuntimeManager. */ if (!Application.isPlaying) { FMODUnity.RuntimeManager.StudioSystem.update(); } #endif //UNITY_EDITOR int inputCount = playable.GetInputCount(); float time = (float)playable.GetGraph().GetRootPlayable(0).GetTime(); for (int i = 0; i < inputCount; i++) { ScriptPlayable <FMODEventPlayableBehavior> inputPlayable = (ScriptPlayable <FMODEventPlayableBehavior>)playable.GetInput(i); FMODEventPlayableBehavior input = inputPlayable.GetBehaviour(); input.UpdateBehaviour(time); } }
public override void PrepareFrame(Playable playable, FrameData info) { if (asset == null) { return; } // Ensure whether the current state should require the // asset to be playing. if (!asset.IsPlaying()) { if (Application.isPlaying && playable.GetGraph().IsPlaying()) { PlayAsset(); } } float playableTime = (float)playable.GetTime(); float delta = playableTime - asset.GetCurrentTime(); if (Math.Abs(delta) > m_maxTimeDelta || !playable.GetGraph().IsPlaying()) { if (playableTime > 0 && playableTime < asset.GetDuration()) { asset.Seek(playableTime); } } }
/// <summary> /// OnBehaviorPause is called when clip becomes deactivated. This occurs when the timeline starts, when the clip is passed it's duration, or if the timeline is stopped. /// </summary> /// <param name="playable"></param> /// <param name="info"></param> public override void OnBehaviourPause(Playable playable, FrameData info) { //Check on _dialoguePlayed is needed b/c OnBehaviorPause is called also at the beginning of the Timeline, so we need to make sure //that the Timeline has actually gone through this clip (i.e. called OnBehaviorPlay) at least once before we stop it. if (Application.isPlaying && playable.GetGraph().IsPlaying() && !playable.GetGraph().GetRootPlayable(0).IsDone() && _dialoguePlayed) { if (_pauseWhenClipEnds && !_rewindWhenClipEnds) { if (PauseTimelineEvent != null) { PauseTimelineEvent.RaiseEvent(); } } else if (!_pauseWhenClipEnds && _rewindWhenClipEnds) { if (RewindTimelineEvent != null) { RewindTimelineEvent.RaiseEvent(_rewindTime, _advanceTime); } } } }
public override void OnGraphStop(Playable playable) { _subject = subject.Resolve(playable.GetGraph().GetResolver()); if (_subject != null && isFirstClipInTrack) { if (useQuaternion) { if (isLocal) { _subject.localRotation = Quaternion.Lerp(Quaternion.Euler(src), Quaternion.Euler(dst), curve.Evaluate(0f)); } else { _subject.rotation = Quaternion.Lerp(Quaternion.Euler(src), Quaternion.Euler(dst), curve.Evaluate(0f)); } } else { if (isLocal) { _subject.localEulerAngles = Vector3.Lerp(src, dst, curve.Evaluate(0f)); } else { _subject.eulerAngles = Vector3.Lerp(src, dst, curve.Evaluate(0f)); } } _subject = subject.Resolve(playable.GetGraph().GetResolver()); } }
public override void ProcessFrame(Playable playable, FrameData info, object playerData) { //ScriptPlayable<TimeMachineBehaviour> inputPlayable = (ScriptPlayable<TimeMachineBehaviour>)playable.GetInput(i); //Debug.Log(PlayableExtensions.GetTime<ScriptPlayable<TimeMachineBehaviour>>(inputPlayable)); if (!Application.isPlaying) { return; } int inputCount = playable.GetInputCount(); for (int i = 0; i < inputCount; i++) { float inputWeight = playable.GetInputWeight(i); ScriptPlayable <TimeMachineBehaviour> inputPlayable = (ScriptPlayable <TimeMachineBehaviour>)playable.GetInput(i); TimeMachineBehaviour input = inputPlayable.GetBehaviour(); if (inputWeight > 0f) { if (!input.clipExecuted) { switch (input.action) { case TimeMachineBehaviour.TimeMachineAction.Pause: if (input.ConditionMet()) { // TODO: musíš implementovať GameManager, pomocou ktorého // budes ovládať hru a prepínať hlavné udalosti // teraz by to mohla byť ten TimelineManager // GameManager.Instance.PauseTimeline(director); input.clipExecuted = true; //this prevents the command to be executed every frame of this clip } break; case TimeMachineBehaviour.TimeMachineAction.JumpToTime: case TimeMachineBehaviour.TimeMachineAction.JumpToMarker: if (input.ConditionMet()) { //Rewind if (input.action == TimeMachineBehaviour.TimeMachineAction.JumpToTime) { //Jump to time (playable.GetGraph().GetResolver() as PlayableDirector).time = (double)input.timeToJumpTo; } else { //Jump to marker double t = markerClips[input.markerToJumpTo]; (playable.GetGraph().GetResolver() as PlayableDirector).time = t; } input.clipExecuted = false; //we want the jump to happen again! } break; } } } } }
public override void ProcessFrame(Playable playable, FrameData info, object playerData) { //ScriptPlayable<TimeMachineBehaviour> inputPlayable = (ScriptPlayable<TimeMachineBehaviour>)playable.GetInput(i); //Debug.Log(PlayableExtensions.GetTime<ScriptPlayable<TimeMachineBehaviour>>(inputPlayable)); if (!Application.isPlaying) { return; } int inputCount = playable.GetInputCount(); for (int i = 0; i < inputCount; i++) { float inputWeight = playable.GetInputWeight(i); ScriptPlayable <TimeMachineBehaviour> inputPlayable = (ScriptPlayable <TimeMachineBehaviour>)playable.GetInput(i); TimeMachineBehaviour input = inputPlayable.GetBehaviour(); if (inputWeight > 0.0f) { if (!input.clipExecuted) { switch (input.action) { /* * case TimeMachineBehaviour.TimeMachineAction.Pause: * if(input.ConditionMet()) * { * //GameManager.Instance.PauseTimeline(director); //perlu buat sendiri condition agar bisa keluar dari pause * input.clipExecuted = true; //this prevents the command to be executed every frame of this clip * } * break; */ case TimeMachineBehaviour.TimeMachineAction.JumpToTime: case TimeMachineBehaviour.TimeMachineAction.JumpToMarker: if (input.ConditionMet()) { //Rewind if (input.action == TimeMachineBehaviour.TimeMachineAction.JumpToTime) { //Jump to time (playable.GetGraph().GetResolver() as PlayableDirector).time = (double)input.timeToJumpTo; } else if (input.action == TimeMachineBehaviour.TimeMachineAction.JumpToMarker) { //Jump to marker double t = markerClips[input.markerToJumpTo]; (playable.GetGraph().GetResolver() as PlayableDirector).time = t; } input.clipExecuted = false; //we want the jump to happen again! } break; } } } } }
public override void OnPlayableCreate(Playable playable) { _self = playable; _self.SetInputCount(1); _self.SetInputWeight(0, 1); _mixer = AnimationMixerPlayable.Create(_self.GetGraph(), 1, true); _graph = _self.GetGraph(); _graph.Connect(_mixer, 0, _self, 0); _graph.Play(); }
public override void OnBehaviourPlay(Playable playable, FrameData info) { _mTran = mTran.Resolve(playable.GetGraph().GetResolver()); _relativeTarget = relativeTarget.Resolve(playable.GetGraph().GetResolver()); if (_mTran != null && _relativeTarget != null) { _mTran.position = _relativeTarget.position + _relativeTarget.rotation * offsetPos; _mTran.rotation = Quaternion.LookRotation(_relativeTarget.position - _mTran.position); _mTran.transform.localEulerAngles += offsetRot; } }
public override void ProcessFrame(Playable playable, FrameData info, object playerData) { //ScriptPlayable<TimeMachineBehaviour> inputPlayable = (ScriptPlayable<TimeMachineBehaviour>)playable.GetInput(i); //Debug.Log(PlayableExtensions.GetTime<ScriptPlayable<TimeMachineBehaviour>>(inputPlayable)); if (!Application.isPlaying) { return; } int inputCount = playable.GetInputCount(); for (int i = 0; i < inputCount; i++) { float inputWeight = playable.GetInputWeight(i); ScriptPlayable <TimeMachineBehaviour> inputPlayable = (ScriptPlayable <TimeMachineBehaviour>)playable.GetInput(i); TimeMachineBehaviour input = inputPlayable.GetBehaviour(); if (inputWeight > 0f) { switch (input.action) { case TimeMachineBehaviour.TimeMachineAction.Pause: Debug.Log("Pause"); (playable.GetGraph().GetResolver() as PlayableDirector).Pause(); break; case TimeMachineBehaviour.TimeMachineAction.JumpToTime: case TimeMachineBehaviour.TimeMachineAction.JumpToMarker: if (input.ConditionMet()) { //Rewind if (input.action == TimeMachineBehaviour.TimeMachineAction.JumpToTime) { //Jump to time (playable.GetGraph().GetResolver() as PlayableDirector).time = (double)input.timeToJumpTo; } else { //Jump to marker double t = markerClips[input.markerToJumpTo]; (playable.GetGraph().GetResolver() as PlayableDirector).time = t; } } break; } } } }
public override void OnBehaviourPause(Playable playable, FrameData info) { // The check on _dialoguePlayed is needed because OnBehaviourPause is called also at the beginning of the Timeline, // so we need to make sure that the Timeline has actually gone through this clip (i.e. called OnBehaviourPlay) at least once before we stop it if (Application.isPlaying && playable.GetGraph().IsPlaying() && !playable.GetGraph().GetRootPlayable(0).IsDone() && _dialoguePlayed) { if (_pauseWhenClipEnds) { cutsceneManager.PauseTimeline(); } } }
// 销毁playable public void DestroyPlayable() { if (m_Playable.IsValid()) { m_Playable.GetGraph().DestroySubgraph(m_Playable); } }
/// <summary> /// Displays a line of dialogue on screen by interfacing with the <c>CutsceneManager</c>. This happens as soon as the playhead reaches the clip. /// </summary> public override void OnBehaviourPlay(Playable playable, FrameData info) { if (_dialoguePlayed) { return; } // Need to ask the CutsceneManager if the cutscene is playing, since the graph is not actually stopped/paused: it's just going at speed 0 // This check is needed because when two clips are side by side and the first one stops the cutscene, // the OnBehaviourPlay of the second clip is still called and thus its dialogueLine is played (prematurely). This check makes sure it's not. if (playable.GetGraph().IsPlaying() && cutsceneManager.IsCutscenePlaying) { //TODO: Find a way to "play" dialogue lines even when scrubbing the Timeline not in Play Mode if (_dialogueLine != null) { cutsceneManager.PlayDialogueFromClip(_dialogueLine); _dialoguePlayed = true; } else { Debug.LogWarning("This clip contains no DialogueLine"); } } }
// Called every frame that the timeline is evaluated. This is called prior to // PrepareFrame on any of its input playables. public override void PrepareFrame(Playable playable, FrameData info) { // Searches for clips that are in the 'preload' area and prepares them for playback var timelineTime = playable.GetGraph().GetRootPlayable(0).GetTime(); for (int i = 0; i < playable.GetInputCount(); i++) { if (playable.GetInput(i).GetPlayableType() != typeof(VideoPlayableBehaviour)) { continue; } if (playable.GetInputWeight(i) <= 0.0f) { ScriptPlayable <VideoPlayableBehaviour> scriptPlayable = (ScriptPlayable <VideoPlayableBehaviour>)playable.GetInput(i); VideoPlayableBehaviour videoPlayableBehaviour = scriptPlayable.GetBehaviour(); double preloadTime = Math.Max(0.0, videoPlayableBehaviour.preloadTime); double clipStart = videoPlayableBehaviour.startTime; if (timelineTime > clipStart - preloadTime && timelineTime <= clipStart) { videoPlayableBehaviour.PrepareVideo(); } } } }
private void ProcessCurrentClip(Playable playable, object playerData, DialogueBehaviour input, ClipData clipData) { double currentTime = playable.GetTime(); if (currentTime > 0f) { if (clipData.state == ClipState.Pending) { clipData.state = ClipState.Started; (playerData as DialogueBinder)?.SetDialog(input.dialogueID); } if (clipData.state == ClipState.Started) { if (currentTime >= m_clipsData[m_currentClipIndex].Range.End - k_StopThreshold) { clipData.state = ClipState.Ended; } } if (clipData.state == ClipState.Ended) { if (NextClipIndexInBounds(m_currentClipIndex + 1)) { m_currentClipIndex++; playable.SetTime(m_clipsData[m_currentClipIndex].Range.Start); if (input.stopGraphOnClipEnd) { playable.GetGraph().Stop(); } } } } }
public override void ProcessFrame(Playable playable, FrameData info, object playerData) { int inputCount = playable.GetInputCount(); var rootPlayable = playable.GetGraph().GetRootPlayable(0); float time = (float)rootPlayable.GetTime(); for (int i = 0; i < inputCount; i++) { var inputPlayable = (ScriptPlayable <PC2DAddOrRemoveCameraTargetBehaviour>)playable.GetInput(i); var input = inputPlayable.GetBehaviour(); if (Application.isPlaying && (_currentTime <= input.ClipStartTime) && (time > input.ClipStartTime)) { if (input.action == PC2DAddOrRemoveCameraTarget.Add) { ProCamera2D.Instance.AddCameraTarget(input.cameraTarget); } else { ProCamera2D.Instance.RemoveCameraTarget(input.cameraTarget); } } } _currentTime = time; }
public override void OnPlayableCreate(Playable playable) { base.OnPlayableCreate(playable); m_playableGraph = playable.GetGraph(); inPlayable = playable; }
public override void PrepareFrame(Playable playable, FrameData info) { // The playable graph can sometimes evaluate outside of our control, due to the way the Timeline Window // takes control of playback, so we check if this is a manual evaluation from RecordedSessionDirector if (m_VideoPlayer == null || !m_VideoPlayer.isPrepared || !m_SessionDirector.IsEvaluating || m_SessionDirector.IsSyncing) { return; } var time = playable.GetTime(); if (time >= m_VideoLength) { m_VideoPlayer.time = m_VideoLength; return; } var videoTime = time; m_VideoPlayer.externalReferenceTime = videoTime; if (!m_VideoPlayer.isPlaying) { m_VideoPlayer.time = videoTime; if (playable.GetGraph().IsPlaying()) { m_VideoPlayer.Play(); } } }
//Called each frame when timeline is played public override void ProcessFrame(Playable playable, FrameData info, object playerData) { if (_dialoguePlayed) { return; } if (Application.isPlaying) { //Need to ask the CutsceneManager if the cutscene is playing, since the graph is not actually stopped/paused: it is just going at speed 0. if (playable.GetGraph().IsPlaying()) { if (_dialogueLine != null && _actor != null) { if (PlayDialogueEvent != null) { PlayDialogueEvent.RaiseEvent(_dialogueLine, _actor); } _dialoguePlayed = true; } else { Debug.LogWarning("This clip contains no DialogueLine"); } } } }
protected override IObservable <Unit> OnRegisterInputTrigger(Playable playable) { var collider = colliderReference.Resolve(playable.GetGraph().GetResolver()); if (collider == null) { return(null); } switch (method) { case Method.TriggerEnter: return(collider.OnTriggerEnterAsObservable().AsUnitObservable()); case Method.TriggerExit: return(collider.OnTriggerExitAsObservable().AsUnitObservable()); case Method.CollisionEnter: return(collider.OnCollisionEnterAsObservable().AsUnitObservable()); case Method.CollisionExit: return(collider.OnCollisionExitAsObservable().AsUnitObservable()); default: Debug.unityLogger.LogError(nameof(WaitForInputColliderBehaviour), $"Not implementation {method}"); return(null); } }
public override void OnPlayableCreate(Playable playable) { m_playable = playable; m_graph = playable.GetGraph(); m_onEnd = OnDialogueEnd; m_dialougeUI = GameObject.FindObjectOfType <DialougeUI>(); }
/// <summary> /// Displays a line of dialogue on screen by interfacing with the <c>CutsceneManager</c>. /// </summary> public override void ProcessFrame(Playable playable, FrameData info, object playerData) { if (_dialoguePlayed) { return; } if (Application.isPlaying) //TODO: Find a way to "play" dialogue lines even when scrubbing the Timeline not in Play Mode { // Need to ask the CutsceneManager if the cutscene is playing, since the graph is not actually stopped/paused: it's just going at speed 0. if (playable.GetGraph().IsPlaying() && cutsceneManager.IsCutscenePlaying) { if (_dialogueLine != null) { cutsceneManager.PlayDialogueFromClip(_dialogueLine); _dialoguePlayed = true; } else { Debug.LogWarning("This clip contains no DialogueLine"); } } } }
void PrepareParticleSystem(Playable playable) { // Disable automatic random seed to get deterministic results. if (particleSystem.useAutoRandomSeed) { particleSystem.useAutoRandomSeed = false; } // Override the random seed number. if (particleSystem.randomSeed != randomSeed) { particleSystem.randomSeed = randomSeed; } // Retrieve the total duration of the track. var rootPlayable = playable.GetGraph().GetRootPlayable(0); var duration = (float)rootPlayable.GetDuration(); // Particle system duration should be longer than the track duration. var main = particleSystem.main; if (main.duration < duration) { main.duration = duration; } }
/************************************************************************************************************************/ /// <summary>[Pro-Only] /// Reconnects the input of the specified `playable` to its output. /// </summary> public static void RemovePlayable(Playable playable, bool destroy = true) { if (!playable.IsValid()) { return; } Debug.Assert(playable.GetInputCount() == 1, $"{nameof(RemovePlayable)} can only be used on playables with 1 input."); Debug.Assert(playable.GetOutputCount() == 1, $"{nameof(RemovePlayable)} can only be used on playables with 1 output."); var input = playable.GetInput(0); if (!input.IsValid()) { if (destroy) { playable.Destroy(); } return; } var graph = playable.GetGraph(); var output = playable.GetOutput(0); if (output.IsValid())// Connected to another Playable. { if (destroy) { playable.Destroy(); } else { Debug.Assert(output.GetInputCount() == 1, $"{nameof(RemovePlayable)} can only be used on playables connected to a playable with 1 input."); graph.Disconnect(output, 0); graph.Disconnect(playable, 0); } graph.Connect(input, 0, output, 0); } else// Connected to the graph output. { Debug.Assert(graph.GetOutput(0).GetSourcePlayable().Equals(playable), $"{nameof(RemovePlayable)} can only be used on playables connected to another playable or to the graph output."); if (destroy) { playable.Destroy(); } else { graph.Disconnect(playable, 0); } graph.GetOutput(0).SetSourcePlayable(input); } }
public override void OnGraphStart(Playable playable) { if (!IsPlaying()) { return; } BeginRecording(playable.GetTime(), Clip.GetExportRoot(playable.GetGraph())); }
public override void OnPlayableCreate(Playable playable) { director = playable.GetGraph().GetResolver() as PlayableDirector; if (director) { director.stopped += OnDirectorStopped; } }
public void OnFrameEnd(Playable playable, FrameData info, object playerData) { if (!playable.IsValid()) { return; } ProcessRecording(playable.GetTime(), Clip.GetExportRoot(playable.GetGraph())); }