private void StartAnimationUpdate()
{
switch (mode)
{
case Mode.AnimationClips:
if (!AnimationMode.InAnimationMode())
{
AnimationMode.StartAnimationMode();
}
AnimationMode.BeginSampling();
AnimationMode.SampleAnimationClip(gameObject, animationClips[currentClipIndex], 0f);
AnimationMode.EndSampling();
break;
case Mode.AnimationStates:
animator.enabled = false;
animator.Play(animationStates[currentClipIndex], 0, 0f);
break;
case Mode.PlayableDirector:
director.enabled = false;
director.time = 0f;
director.Evaluate();
break;
}
}
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");
}
}
}
public void BackLevelSelect()
{
timeline.Stop();
timeline.time = timeline.playableAsset.duration - 0.01;
timeline.Evaluate();
reverse = true;
}
public void Awake()
{
director.Evaluate();
#if !UNITY_EDITOR
loadedAudio = NativeAudio.Load(noteToPlay);
#endif
}
public void Pause()
{
if (director && director.state == PlayState.Playing)
{
director.Pause();
director.Evaluate();
}
}
public void Rewind(float ft)
{
while (ft < pd.time)
{
pd.time -= .1f;
pd.Evaluate();
}
}
/// <summary> 時間を直接変更. </summary>
public void SetTime(double time)
{
Initialize();
playableDirector.Evaluate();
playableDirector.time = time;
playableDirector.Evaluate();
}
public override void FinishSequence(Action callback)
{
Director.time = Director.duration;
Director.Evaluate();
if (_callback != null)
{
_callback();
}
}
void Reset()
{
ForceClearHomeMenuElements();
ForceClearSubMenuElements();
m_InputModeText.text = string.Empty;
m_Director.playableAsset = m_RevealTimelinePlayable;
m_HomeSectionCanvasGroup.alpha = 1f;
m_HomeTextBackgroundInnerCanvasGroup.alpha = 1f;
m_HomeSectionTitlesBackgroundBorderCanvasGroup.alpha = 1f;
m_Director.time = 0f;
m_Director.Evaluate();
}
/// <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;
}
GameObject CaptureOneShot(PlayableDirector director, TimelineClip clip)
{
var time = clip.start + (clip.end - clip.start) / 2;
director.time = time;
director.Evaluate();
var maskRoot = director.gameObject.transform.Find("MaskRoot");
var reference = director.gameObject.transform.Find("Reference").gameObject;
var go = GameObject.Instantiate(reference, maskRoot);
var mask = go.AddComponent <DanceCheckPoint>();
var d = clip.asset as DanceClip;
mask.isUsedWeight = false;
mask.Weight_Head_2_Neck = d.Weight_Head_2_Neck;
mask.Weight_Neck_2_Right_Shoulder = d.Weight_Neck_2_Right_Shoulder;
mask.Weight_Right_Shoulder_2_Right_Elbow = d.Weight_Right_Shoulder_2_Right_Elbow;
mask.Weight_Right_Elbow_2_Right_Hand = d.Weight_Right_Elbow_2_Right_Hand;
mask.Weight_Neck_2_Left_Shoulder = d.Weight_Neck_2_Left_Shoulder;
mask.Weight_Left_Shoulder_Left_Elbow = d.Weight_Left_Shoulder_Left_Elbow;
mask.Weight_Left_Elbow_2_Left_Hand = d.Weight_Left_Elbow_2_Left_Hand;
mask.Weight_Neck_2_Right_Hip = d.Weight_Neck_2_Right_Hip;
mask.Weight_Right_Hip_2_Right_Knee = d.Weight_Right_Hip_2_Right_Knee;
mask.Weight_Right_Knee_2_Right_Foot = d.Weight_Right_Knee_2_Right_Foot;
mask.Weight_Neck_2_Left_Hip = d.Weight_Neck_2_Left_Hip;
mask.Weight_Left_Hip_2_Left_Knee = d.Weight_Left_Hip_2_Left_Knee;
mask.Weight_Left_Knee_2_Left_Foot = d.Weight_Left_Knee_2_Left_Foot;
DestroyImmediate(go.GetComponent <Animator>());
Match(go.transform, reference.transform);
return(go);
}
private void Seeking(float progress)
{
var newTime = Mathf.Lerp(0, (float)director.duration, progress);
director.time = newTime;
director.Evaluate();
}
void Update()
{
if (Input.GetKeyUp(KeyCode.Space))
{
director.Stop();
director.time = 0d;
director.Play();
}
if (Input.GetKeyUp(KeyCode.F1))
{
var output = ScriptPlayableOutput.Create(director.playableGraph, "");
JumpSignalEmmiter sign = ScriptableObject.CreateInstance <JumpSignalEmmiter>();
sign.jumpTime = 0;
output.PushNotification(Playable.Null, sign);
}
if (Input.GetKeyUp(KeyCode.F3))
{
director.Pause();
backward = true;
}
if (Input.GetKeyUp(KeyCode.F4))
{
backward = false;
director.Play();
}
if (backward)
{
director.time = director.time - Time.deltaTime;
director.Evaluate();
}
}
public void OnGameInitialized()
{
if (gameJustStarted)
{
// myTimeline.initialTime = 0;
myTimeline.time = 0;
currentFruitBlendedCount = 0;
fruitmixlayer = Random.Range(1, 4);
gameJustStarted = false;
DestroyPreviousFruits();
ListFruitsToBlend(fruitmixlayer);
myTimeline.Stop();
myTimeline.Evaluate();
}
else
{
myTimeline.time = 0.45f;
}
ResumeTimeline();
// noOFFruitsToDrag = noOfFruitsToDrag[currentFruitBlendedCount];
GameInitializeListeners?.Invoke(noOFFruitsToDrag);
// start of the game
// show items to cut
}
private IEnumerator tRewind(PlayableDirector Director)
{
yield return(new WaitForSeconds(0.001f * Time.deltaTime));
Director.time -= 1.0f * Time.deltaTime; //1.0f是倒带速度
Director.Evaluate();
if (Director.time < 0f)
{
Director.time = 0f;
Director.Evaluate();
}
else
{
StartCoroutine(tRewind(Director));
}
}
// Use this for initialization
void Start()
{
director = GetComponent <PlayableDirector>();
director.Stop();
director.time = isDoorOpen ? director.playableAsset.duration - 0.01 : 0f;
director.Evaluate();
}
public override void SetPrefab(string prefabName)
{
if (prefabName == currentPrefabName)
{
return;
}
base.SetPrefab(prefabName);
prefabInstance.SetActive(false);
playableDirector = prefabInstance.GetComponent <PlayableDirector>();
if (playableDirector != null)
{
playableDirector.timeUpdateMode = DirectorUpdateMode.Manual;
playableDirector.playOnAwake = false;
playableDirector.Evaluate();
}
Camera newCamera = prefabInstance.GetComponentInChildren <Camera>();
if (newCamera != null)
{
this.RuntimeAssert(newCamera.GetComponent <CameraController>() == null,
"The camera in the timeline prefab should not have a CameraController.");
cameraController.overridingCamera = newCamera;
mainCamera.enabled = false;
newCamera.targetTexture = mainCamera.targetTexture;
// Debug.Log("Switched main camera to timeline provided camera");
}
prefabInstance.SetActive(true);
}
// Update is called once per frame
void Update()
{
PixelRef pxRef = CheckPXRef();
if (!pxRef)
{
return;
}
if (!CheckPlayableDirector())
{
return;
}
float value = pxRef.GetValue(0);
float speed = Utils.MapValue(value, _inMin, _inMax, _SpeedMin, _SpeedMax);
float delay = Utils.MapValue(value, _inMin, _inMax, _Delay01Min, _Delay01Max);
double duration = _playableDirector.duration;
_playableDirector.time = Mathf.Repeat(
Time.realtimeSinceStartup * speed + (float)duration * delay, (float)duration);
_playableDirector.Evaluate();
}
public IEnumerator tRewind(PlayableDirector director)
{
yield return(new WaitForSeconds(0.001f * Time.deltaTime));
director.time -= 1.0f * Time.deltaTime; //1.0f是倒帶速度
director.Evaluate(); //director播放当前帧
if (director.time < 0f)
{
director.time = 0f;
director.Evaluate();
}
else
{
StartCoroutine(tRewind(director));
}
}
private void reverse(PlayableDirector ani)
{
//Debug.Log("called reverse function");
ani.Stop();
ani.time = ani.playableAsset.duration - 0.01;
ani.Evaluate();
}
async void Update()
{
// Debug.Log($"isPlaying:{video.isPlaying.ToString()} isPaused:{video.isPaused.ToString()} isPrepared:{video.isPrepared.ToString()}");
if (PlayingState.IsPreviewingInPlayMode)
{
if (video.isPlaying)
{
director.time = clip.start + video.time;
}
else if (director.time <= director.duration)
{
director.time += frameDelta;
}
director.Evaluate();
}
if (PlayingState.IsRecording)
{
await UniTask.WaitUntil(() => (Time.unscaledTime - timePreviousCaptured) > RecorderOptions.CurrentOptions.FrameTimeout);
timedUp = true;
}
}
public void Update()
{
if (m_PlayMode != PlayMode.Stop)
{
float dt = UnscaledGameTime? Time.unscaledDeltaTime : Time.deltaTime;
float prevTime = (float)director.time;
float newTime = prevTime + (m_PlayMode == PlayMode.Reverse ? -1.0f : 1.0f) * dt;
if (m_StopTime >= 0.0f &&
((m_PlayMode == PlayMode.Play && prevTime < m_StopTime && m_StopTime <= newTime) ||
(m_PlayMode == PlayMode.Reverse && newTime <= m_StopTime && m_StopTime < prevTime)
))
{
director.time = m_StopTime;
m_PlayMode = PlayMode.Stop;
m_StopTime = -1.0f;
}
else
{
director.time = newTime;
}
director.Evaluate();
if ((director.time <= 0.0f && m_PlayMode == PlayMode.Reverse) ||
(director.time >= director.playableAsset.duration && m_PlayMode == PlayMode.Play))
{
switch (wrapMode)
{
case WrapMode.Loop:
if (director.time <= 0.0f)
{
director.time = director.playableAsset.duration;
}
else
{
director.time = 0.0f;
}
break;
case WrapMode.PingPong:
if (m_PlayMode == PlayMode.Play)
{
m_PlayMode = PlayMode.Reverse;
}
else if (m_PlayMode == PlayMode.Reverse)
{
m_PlayMode = PlayMode.Play;
}
break;
case WrapMode.Stop:
m_PlayMode = PlayMode.Stop;
break;
}
}
}
}
void Update()
{
m_Interp += Time.deltaTime * (m_Reverse ? -1.0f : 1.0f);
m_Interp = Mathf.Clamp(m_Interp, 0.0f, (float)TimelineDirector.duration);
TimelineDirector.time = m_Interp;
TimelineDirector.Evaluate();
}
private void Start()
{
director.initialTime = 0;
director.time = 0;
director.Stop();
director.Evaluate();
director.Play();
}
public void RebuildGraph()
{
if (playableDirector != null)
{
playableDirector.RebuildGraph();
playableDirector.Evaluate();
}
}
public static void SetAnimationToMeasurement(PlayableDirector director, int measurementsToMake, int measurementIndex)
{
Debug.Log($"M782 animation to measurement {measurementIndex}/{measurementsToMake}");
float percent = measurementIndex / (float)measurementsToMake;
director.time = director.duration * percent;
director.Evaluate();
}
protected override IEnumerator Event_Content()
{
Timeline.enabled = true;
Timeline.Stop();
Timeline.Evaluate();
Timeline.enabled = false;
yield return(StartCoroutine(Event_Tieup()));
}
public void PlayCutscene(TimelineAsset cutscene)
{
// TODO block player input, keeping dialogue input enabled
m_director.playableAsset = cutscene;
m_director.Evaluate();
m_director.Play();
m_director.stopped += OnCutsceneCompleted;
}
public void SkipIntro()
{
timeline.time = timeline.duration;
timeline.Evaluate();
GameManager.GetInstance().TriggerGameStart();
discSlots.SetActive(true);
skipIntroButton.SetActive(false);
timeline.Stop();
}
void Update()
{
if (m_director.time < m_director.duration)
{
m_currentTime += Time.deltaTime * m_timeScale;
m_director.time = m_currentTime;
m_director.Evaluate();
}
}
