public void ResetToEnd(AnimSetupType a_animType) { m_timer = GetDuration(a_animType); if (IsUiAnimatorSubModule) { m_uiAnimatorSubModule.ResetToEnd(a_animType); } else { if (m_animationSteps != null) { for (int aIdx = 0; aIdx < m_animationSteps.Count; aIdx++) { m_animationSteps [aIdx].ResetToEnd(a_animType); } } CheckTargetIndexesArray(); for (int idx = 0; idx < m_targetStepIndexes.Length; idx++) { m_targetStepIndexes [idx] = m_animationSteps.Count; } } }
public void ResetToStart(AnimSetupType a_animSetupType) { m_currentStageIndex = 0; m_timer = 0; if (m_animationSetups == null || (int)a_animSetupType >= m_animationSetups.Count) { return; } if (a_animSetupType != AnimSetupType.Loop) { m_currentLoopIterationCount = 0; } List <AnimationStage> currentAnimStages = m_animationSetups [(int)a_animSetupType].AnimationStages; if (currentAnimStages != null) { for (int sIdx = 0; sIdx < currentAnimStages.Count; sIdx++) { currentAnimStages [sIdx].ResetToStart(a_animSetupType); } } if (!Application.isPlaying) { ForceStopAllAudioSources(); } }
public void SetAnimationTimer(AnimSetupType a_animType, float a_timerValue, bool a_forceLinearTimings = false) { if (IsUiAnimatorSubModule) { m_uiAnimatorSubModule.SetAnimationTimer(a_animType, a_timerValue - m_startDelay); return; } float offset; for (int tIdx = 0; tIdx < m_targetObjects.Length; tIdx++) { offset = m_startDelay; for (int aIdx = 0; aIdx < m_animationSteps.Count; aIdx++) { if (aIdx > 0) { if (a_forceLinearTimings || m_animationSteps [aIdx].WaitForPreviousComplete) { offset += m_animationSteps [aIdx - 1].TotalExecutionDuration; } else { offset += m_animationSteps [aIdx - 1].GetTotalExecutionDuration(tIdx); } } if (a_timerValue - offset >= 0 || !m_animationSteps [aIdx].IsEffectStep) { m_animationSteps [aIdx].SetAnimationTimer(tIdx, a_animType, a_timerValue - offset, a_forceLinearTimings); } } } }
public bool UpdateState(UIAnimator a_uiAnimatorRef, AnimSetupType a_animType, float a_deltaTime) { m_timer += a_deltaTime; if (m_timer > m_startDelay) { m_finishedFlag = true; if (!m_finishedStage && m_animationInstances != null) { for (int iIdx = 0; iIdx < m_animationInstances.Count; iIdx++) { if (!m_animationInstances [iIdx].UpdateState(a_uiAnimatorRef, a_animType, a_deltaTime)) { m_finishedFlag = false; } } } if (m_finishedFlag) { m_finishedStage = true; } if (m_finishedStage && m_timer > m_cachedTotalDuration) { return(true); } } return(false); }
public void UpdateState(UIAnimator a_uiAnimatorRef, int a_targetIndex, AnimSetupType a_animType, float a_deltaTime) { m_timers[a_targetIndex] += a_deltaTime; if (m_delay.GetValue(a_targetIndex) > 0 && m_timers[a_targetIndex] <= m_delay.GetValue(a_targetIndex)) { // Animation is still waiting the allocated 'delay' return; } float postDelayStepTimer = (m_timers [a_targetIndex] - m_delay.GetValue(a_targetIndex)); if (m_audioClipDatas != null && m_audioClipDatas.Length > 0) { // Check for whether an audio clip needs to be played for (int idx = 0; idx < m_audioClipDatas.Length; idx++) { if (m_audioClipDatas [idx].Clip != null && !m_audioClipDatas [idx].HasAudioClipActivated(a_targetIndex)) { if ((m_audioClipDatas [idx].TriggerPoint == AudioClipData.CLIP_TRIGGER_POINT.START_OF_ANIM_STEP && postDelayStepTimer > m_audioClipDatas [idx].Delay.GetValue(a_targetIndex)) || (m_audioClipDatas [idx].TriggerPoint == AudioClipData.CLIP_TRIGGER_POINT.END_OF_ANIM_STEP && postDelayStepTimer > m_duration.GetValue(a_targetIndex) - m_audioClipDatas [idx].Delay.GetValue(a_targetIndex))) { a_uiAnimatorRef.TriggerAudioClip(m_audioClipDatas [idx], a_targetIndex); m_audioClipDatas [idx].MarkAudioClipActivated(a_targetIndex); } } } } SetAnimationProgress(a_targetIndex, a_animType, postDelayStepTimer / Mathf.Max(m_duration.GetValue(a_targetIndex), MIN_DURATION)); }
public void ResetToStart(AnimSetupType a_animType) { m_timer = 0; if (IsUiAnimatorSubModule) { m_uiAnimatorSubModule.ResetToStart(a_animType); } else { if (m_animationSteps != null) { for (int sIdx = m_animationSteps.Count - 1; sIdx >= 0; sIdx--) { m_animationSteps [sIdx].ResetToStart(a_animType); } } CheckTargetIndexesArray(); for (int idx = 0; idx < m_targetStepIndexes.Length; idx++) { m_targetStepIndexes [idx] = 0; } } }
public void ResetToEnd(AnimSetupType a_animType) { SetTimerValues(TotalExecutionDuration); for (int idx = 0; idx < m_numTargets; idx++) { SetAnimationProgress(idx, a_animType, 1); } }
public void ResetToEnd(AnimSetupType a_animType) { m_cachedTotalDuration = GetTotalDuration(a_animType); m_timer = m_cachedTotalDuration; m_finishedStage = true; for (int iIdx = 0; iIdx < m_animationInstances.Count; iIdx++) { m_animationInstances [iIdx].ResetToEnd(a_animType); } }
private List <AnimationStage> GetAnimationStepStages(AnimSetupType a_animType) { int setupIndex = (int)a_animType; if (m_animationSetups != null && m_animationSetups.Count > setupIndex) { return(m_animationSetups [setupIndex].AnimationStages); } return(null); }
public override void OnInspectorGUI(int a_stepIndex, AnimSetupType a_animType, SerializedObject a_serializedObject, System.Action a_onAnimatedStateChanged) { bool setupChanged = false; m_shakeAmount.OnInspectorGUI(a_serializedObject.FindProperty("m_shakeAmount"), ref setupChanged, NumTargets > 1, new GUIContent("Shake Amount")); if (setupChanged) { a_onAnimatedStateChanged(); } }
public void SetAnimType(AnimSetupType a_animType) { m_currentAnimSetupIndex = (int)a_animType; ResetToDefault(); if (Application.isPlaying) { ResetToStart(); } }
public override void OnInspectorGUI(int a_stepIndex, AnimSetupType a_animType, SerializedObject a_serializedObject, System.Action a_onAnimatedStateChanged) { bool stateChanged = false; string namePrefix = a_animType == AnimSetupType.Intro ? "Start" : "End"; DrawPropertyField(a_serializedObject, "m_animatedAlpha", ref stateChanged, new GUIContent(namePrefix + " Alpha")); if (stateChanged) { a_onAnimatedStateChanged(); } }
public override void OnInspectorGUI(int a_stepIndex, AnimSetupType a_animType, SerializedObject a_serializedObject, System.Action a_onAnimatedStateChanged) { bool setupChanged = false; string animVariablePrefix = a_animType == AnimSetupType.Intro ? "Start" : "End"; m_position.OnInspectorGUI(a_serializedObject.FindProperty("m_position"), ref setupChanged, NumTargets > 1, new GUIContent(animVariablePrefix + " Position")); m_scale.OnInspectorGUI(a_serializedObject.FindProperty("m_scale"), ref setupChanged, NumTargets > 1, new GUIContent(animVariablePrefix + " Scale")); m_rotation.OnInspectorGUI(a_serializedObject.FindProperty("m_rotation"), ref setupChanged, NumTargets > 1, new GUIContent(animVariablePrefix + " Rotation")); if (setupChanged) { a_onAnimatedStateChanged(); } }
public void SetAnimationTimer(int a_targetIndex, AnimSetupType a_animType, float a_timerValue, bool a_forceLinearTimings = false) { CheckTimerValueArray(); m_timers [a_targetIndex] = a_timerValue; if (a_timerValue - m_delay.GetValue(a_forceLinearTimings ? 0 : a_targetIndex) < 0) { SetAnimationProgress(a_targetIndex, a_animType, 0); } else { SetAnimationProgress(a_targetIndex, a_animType, (a_timerValue - m_delay.GetValue(a_forceLinearTimings ? 0 : a_targetIndex)) / Mathf.Max(m_duration.GetValue(a_forceLinearTimings ? 0 : a_targetIndex), MIN_DURATION)); } }
public void ResetToStart(AnimSetupType a_animType) { for (int idx = 0; idx < m_numTargets; idx++) { SetAnimationTimer(idx, a_animType, 0); } // Reset AudioClipData's if (m_audioClipDatas != null) { for (int idx = 0; idx < m_audioClipDatas.Length; idx++) { m_audioClipDatas [idx].ResetAll(); } } }
public void PlayAnimation(AnimSetupType a_animType, float a_delay, System.Action a_onFinish) { CheckDataInit(); SetAnimType(a_animType); m_onFinishAction = a_onFinish; if (a_delay > 0) { StartCoroutine(PlayAnimationAfterDelay(a_animType, a_delay, a_onFinish)); } else { PlayCurrentAnimationSetup(); } }
public float GetInstancesDuration(AnimSetupType a_animType) { float longestDuration = 0; float instanceDuration; for (int iIdx = 0; iIdx < m_animationInstances.Count; iIdx++) { instanceDuration = m_animationInstances [iIdx].GetDuration(a_animType); if (instanceDuration > longestDuration) { longestDuration = instanceDuration; } } return(longestDuration); }
public float GetAnimationDuration(AnimSetupType a_animType) { CheckDataInit(); List <AnimationStage> currentAnimStages = m_animationSetups [(int)a_animType].AnimationStages; float totalDuration = 0; if (currentAnimStages != null) { for (int sIdx = 0; sIdx < currentAnimStages.Count; sIdx++) { totalDuration += currentAnimStages [sIdx].GetTotalDuration(a_animType); } } return(totalDuration); }
public bool UpdateState(UIAnimator a_uiAnimatorRef, AnimSetupType a_animType, float a_deltaTime) { m_timer += a_deltaTime; if (m_timer > m_startDelay) { if (IsUiAnimatorSubModule) { return(m_uiAnimatorSubModule.UpdateState(a_animType, a_deltaTime, a_isPrimaryAnimator: false)); } m_finishedFlag = true; for (int tIdx = 0; tIdx < m_targetObjects.Length; tIdx++) { if (m_targetStepIndexes [tIdx] < m_animationSteps.Count) { if (m_targetStepIndexes [tIdx] > 0 && m_animationSteps [m_targetStepIndexes [tIdx]].WaitForPreviousComplete && !m_animationSteps [m_targetStepIndexes [tIdx]].HasStarted(tIdx)) { if (!m_animationSteps [m_targetStepIndexes [tIdx] - 1].IsCompletelyFinished()) { // Need to wait until previous anim step is completely finished m_finishedFlag = false; continue; } } m_animationSteps [m_targetStepIndexes [tIdx]].UpdateState(a_uiAnimatorRef, tIdx, a_animType, a_deltaTime); if (m_animationSteps [m_targetStepIndexes [tIdx]].IsFinished(tIdx)) { // Finished this anim step, progress to next m_targetStepIndexes [tIdx]++; } m_finishedFlag = false; } } return(m_finishedFlag); } return(false); }
public void ResetToEnd(AnimSetupType a_animSetupType) { if (m_animationSetups == null || (int)a_animSetupType >= m_animationSetups.Count) { return; } List <AnimationStage> currentAnimStages = m_animationSetups [(int)a_animSetupType].AnimationStages; m_currentStageIndex = currentAnimStages.Count - 1; m_timer = GetAnimationDuration(); if (currentAnimStages != null) { for (int sIdx = 0; sIdx < currentAnimStages.Count; sIdx++) { currentAnimStages [sIdx].ResetToEnd(a_animSetupType); } } }
public float GetDuration(AnimSetupType a_animType) { float duration = m_startDelay; if (IsUiAnimatorSubModule) { duration += m_uiAnimatorSubModule.GetAnimationDuration(a_animType); } else { for (int sIdx = 0; sIdx < m_animationSteps.Count; sIdx++) { if (m_animationSteps [sIdx] != null) { duration += m_animationSteps [sIdx].TotalExecutionDuration; } } } return(duration); }
public void SetAnimationProgress(int a_targetIndex, AnimSetupType a_animType, float a_progress) { if (!IsEffectStep && a_animType == AnimSetupType.Outro) { a_progress = 1f - a_progress; } if (a_progress < 0) { a_progress = 0; } else if (a_progress > 1) { a_progress = 1; } if (UseEasing) { a_progress = EasingManager.GetEaseProgress(m_easing, (float)a_progress); } SetAnimation(a_targetIndex, a_progress); }
public bool UpdateState(AnimSetupType a_animType, float a_deltaTime, bool a_isPrimaryAnimator) { m_currentAnimSetupIndex = (int)a_animType; return(UpdateState(a_deltaTime, a_isPrimaryAnimator)); }
public float GetTotalDuration(AnimSetupType a_animType) { return(m_startDelay + GetInstancesDuration(a_animType) + m_endDelay); }
public void PlayAnimation(AnimSetupType a_animType, float a_delay) { PlayAnimation(a_animType, a_delay, null); }
public void PlayAnimation(AnimSetupType a_animType, System.Action a_onFinish) { PlayAnimation(a_animType, 0, a_onFinish); }
private IEnumerator PlayAnimationAfterDelay(AnimSetupType a_animType, float a_delay, System.Action a_onFinish) { yield return(new WaitForSeconds(a_delay)); PlayCurrentAnimationSetup(); }
public void SetAnimationTimer(AnimSetupType a_animType, float a_timerValue, bool a_forceLinearTimings = false) { m_currentAnimSetupIndex = (int)a_animType; SetAnimationTimer(a_timerValue, a_forceLinearTimings); }
public override void OnInspectorGUI(int a_stepIndex, AnimSetupType a_animType, SerializedObject a_serializedObject, System.Action a_onAnimatedStateChanged) { }
public void SetAnimationTimer(float a_timerValue, bool a_forceLinearTimings = false) { List <AnimationStage> currentAnimStages = CurrentAnimStages; if (currentAnimStages == null) { return; } m_timer = a_timerValue; AnimSetupType currentAnimSetupType = CurrentAnimType; float timerOffset = a_timerValue; float stageDuration = 0; m_currentStageIndex = 0; for (int sIdx = 0; sIdx < currentAnimStages.Count; sIdx++) { stageDuration = currentAnimStages [sIdx].GetTotalDuration(currentAnimSetupType); if (timerOffset > stageDuration) { // Set this stage to complete state for (int iIdx = 0; iIdx < currentAnimStages [sIdx].AnimationInstances.Count; iIdx++) { for (int aIdx = 0; aIdx < currentAnimStages [sIdx].AnimationInstances[iIdx].AnimationSteps.Count; aIdx++) { // TODO: Tidy this up. Variables?! if (currentAnimStages [sIdx].AnimationInstances[iIdx].AnimationSteps [aIdx].IsEffectStep) { continue; } currentAnimStages [sIdx].AnimationInstances[iIdx].AnimationSteps [aIdx].ResetToEnd(currentAnimSetupType); } } } else if (timerOffset >= 0) { // Part way through this anim stage for (int iIdx = 0; iIdx < currentAnimStages [sIdx].AnimationInstances.Count; iIdx++) { currentAnimStages [sIdx].AnimationInstances [iIdx].SetAnimationTimer(currentAnimSetupType, timerOffset - currentAnimStages [sIdx].StartDelay, a_forceLinearTimings); } m_currentStageIndex = sIdx; } else { // Set this stage to disabled/not-started state for (int iIdx = 0; iIdx < currentAnimStages [sIdx].AnimationInstances.Count; iIdx++) { for (int aIdx = 0; aIdx < currentAnimStages [sIdx].AnimationInstances[iIdx].AnimationSteps.Count; aIdx++) { if (currentAnimStages [sIdx].AnimationInstances[iIdx].AnimationSteps [aIdx].IsEffectStep) { continue; } currentAnimStages [sIdx].AnimationInstances[iIdx].AnimationSteps [aIdx].ResetToStart(currentAnimSetupType); } } } timerOffset -= stageDuration; } }