//-------------------------------------------------------------------------------------------------------------
private IEnumerator INTERNAL_PlayEffectWithCallBackSceneAsync(Scene sScene, STSTransitionData sTransitionData = null, STSDelegate sDelegate = null)
{
TransitionInProgress = true;
EventSystemPrevent(false);
STSTransition tTransitionParams = GetTransitionsParams(sScene);
STSTransitionInterface[] tActualSceneInterfaced = GetTransitionInterface(sScene);
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionSceneDisable(sTransitionData);
}
AnimationTransitionOut(tTransitionParams, sTransitionData);
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitStart(sTransitionData, tTransitionParams.EffectOnExit, true);
}
while (AnimationFinished() == false)
{
yield return(null);
}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, true);
}
if (sDelegate != null)
{
sDelegate(sTransitionData);
}
AnimationTransitionIn(tTransitionParams, sTransitionData);
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tTransitionParams.EffectOnEnter, tTransitionParams.InterEffectDuration, true);
}
while (AnimationFinished() == false)
{
yield return(null);
}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, true);
}
EventSystemPrevent(true);
CameraPrevent(true);
AudioListenerPrevent(true);
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionSceneEnable(sTransitionData);
}
TransitionInProgress = false;
}
//-------------------------------------------------------------------------------------------------------------
private void AnimationTransitionOut(STSTransition sThisSceneParameters, STSTransitionData sDatas)
{
EffectType = sThisSceneParameters.EffectOnExit.GetEffect();
if (EffectType == null)
{
EffectType = new STSEffectFade();
}
STSEffectMoreInfos sMoreInfos = null;
if (sDatas != null)
{
sMoreInfos = sDatas.EffectMoreInfos;
}
EffectType.StartEffectExit(new Rect(0, 0, Screen.width, Screen.height), sMoreInfos);
}
//-------------------------------------------------------------------------------------------------------------
public override void OnInspectorGUI()
{
STSTransition tTarget = (STSTransition)target;
//if (tTarget.gameObject.GetComponent<STSTransitionInterface>() != null)
//{
serializedObject.Update();
//DrawDefaultInspector();
//EditorGUILayout.HelpBox("Determine effects scene parameters.", MessageType.Info);
EditorGUILayout.PropertyField(SPEffectOnEnter);
EditorGUILayout.PropertyField(SPEffectOnExit);
EditorGUILayout.PropertyField(SPInterEffectDuration);
serializedObject.ApplyModifiedProperties();
//}
//else
//{
// EditorGUILayout.HelpBox("Need component with interface ISTSTransitionParameters!", MessageType.Error);
//}
}
//-------------------------------------------------------------------------------------------------------------
private void AnimationTransitionIn(STSTransition sThisSceneParameters, STSTransitionData sDatas)
{
Color tOldColor = Color.black;
float tInterlude = 0;
if (EffectType != null)
{
// I get the old value of
tOldColor = new Color(EffectType.TintPrimary.r, EffectType.TintPrimary.g, EffectType.TintPrimary.b, EffectType.TintPrimary.a);
tInterlude = sThisSceneParameters.InterEffectDuration;
}
EffectType = sThisSceneParameters.EffectOnEnter.GetEffect();
if (EffectType == null)
{
EffectType = new STSEffectFade();
}
STSEffectMoreInfos sMoreInfos = null;
if (sDatas != null)
{
sMoreInfos = sDatas.EffectMoreInfos;
}
EffectType.StartEffectEnter(new Rect(0, 0, Screen.width, Screen.height), tOldColor, tInterlude, sMoreInfos);
}
//-------------------------------------------------------------------------------------------------------------
private IEnumerator INTERNAL_ActiveSceneWithoutIntermissionAsync(STSTransitionData sTransitionData, string sActualActiveSceneName, string sSceneNameToActive)
{
TransitionInProgress = true;
STSTransition tActualSceneParams = GetTransitionsParams(SceneManager.GetSceneByName(sActualActiveSceneName));
STSTransitionInterface[] tActualSceneInterfaced = GetTransitionInterface(SceneManager.GetSceneByName(sActualActiveSceneName));
STSTransitionInterface[] tOtherSceneInterfaced = GetOtherTransitionInterface(SceneManager.GetSceneByName(sActualActiveSceneName));
STSTransition tNextSceneParams = GetTransitionsParams(SceneManager.GetSceneByName(sSceneNameToActive));
STSTransitionInterface[] tNextSceneInterfaced = GetTransitionInterface(SceneManager.GetSceneByName(sSceneNameToActive));
EventSystemPrevent(false);
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionSceneDisable(sTransitionData);
}
AnimationTransitionOut(tActualSceneParams, sTransitionData);
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit, false);
}
while (AnimationFinished() == false)
{
yield return(null);
}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, false);
}
SceneManager.SetActiveScene(SceneManager.GetSceneByName(sSceneNameToActive));
CameraPrevent(true);
AudioListenerPrevent(true);
AnimationTransitionIn(tNextSceneParams, sTransitionData);
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tNextSceneParams.EffectOnEnter, tNextSceneParams.InterEffectDuration, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tNextSceneParams.EffectOnEnter, tNextSceneParams.InterEffectDuration, false);
}
while (AnimationFinished() == false)
{
yield return(null);
}
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, false);
}
EventSystemPrevent(true);
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionSceneEnable(sTransitionData);
}
TransitionInProgress = false;
}
//-------------------------------------------------------------------------------------------------------------
private IEnumerator INTERNAL_ActiveSceneWithIntermissionAsync(STSTransitionData sTransitionData, string sActualActiveSceneName, string sSceneNameToActive, string sIntermissionSceneName)
{
TransitionInProgress = true;
STSTransition tActualSceneParams = GetTransitionsParams(SceneManager.GetSceneByName(sActualActiveSceneName));
STSTransitionInterface[] tActualSceneInterfaced = GetTransitionInterface(SceneManager.GetSceneByName(sActualActiveSceneName));
STSTransitionInterface[] tOtherSceneInterfaced = GetOtherTransitionInterface(SceneManager.GetSceneByName(sActualActiveSceneName));
STSTransition tNextSceneParams = GetTransitionsParams(SceneManager.GetSceneByName(sSceneNameToActive));
STSTransitionInterface[] tNextSceneInterfaced = GetTransitionInterface(SceneManager.GetSceneByName(sSceneNameToActive));
EventSystemPrevent(false);
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionSceneDisable(sTransitionData);
}
AnimationTransitionOut(tActualSceneParams, sTransitionData);
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit, false);
}
while (AnimationFinished() == false)
{
yield return(null);
}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, false);
}
// load transition scene async
AsyncOperation tAsynchroneLoadIntermissionOperation;
tAsynchroneLoadIntermissionOperation = SceneManager.LoadSceneAsync(sIntermissionSceneName, LoadSceneMode.Additive);
tAsynchroneLoadIntermissionOperation.allowSceneActivation = false;
while (tAsynchroneLoadIntermissionOperation.progress < 0.9f)
{
yield return(null);
}
// Intermission scene will be active
tAsynchroneLoadIntermissionOperation.allowSceneActivation = true;
while (!tAsynchroneLoadIntermissionOperation.isDone)
{
yield return(null);
}
// get Transition Scene
Scene tIntermissionScene = SceneManager.GetSceneByName(sIntermissionSceneName);
// Active the next scene as root scene
SceneManager.SetActiveScene(tIntermissionScene);
// disable audiolistener of preview scene
CameraPrevent(true);
AudioListenerPrevent(true);
// get params
STSTransition tIntermissionSceneParams = GetTransitionsParams(tIntermissionScene);
STSTransitionInterface[] tIntermissionSceneInterfaced = GetTransitionInterface(tIntermissionScene);
STSIntermissionInterface[] tIntermissionInterfaced = GetIntermissionInterface(tIntermissionScene);
// disable the user interactions until fadein
EventSystemEnable(tIntermissionScene, false);
// Intermission scene is loaded
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionSceneLoaded(sTransitionData);
}
// animation in Go!
AnimationTransitionIn(tIntermissionSceneParams, sTransitionData);
// animation in
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tIntermissionSceneParams.EffectOnEnter, tIntermissionSceneParams.InterEffectDuration, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tIntermissionSceneParams.EffectOnEnter, tIntermissionSceneParams.InterEffectDuration, false);
}
while (AnimationFinished() == false)
{
yield return(null);
}
// animation in Finish
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, false);
}
// enable the user interactions
EventSystemEnable(tIntermissionScene, true);
// enable the user interactions
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionSceneEnable(sTransitionData);
}
// start stand by
STSIntermission tIntermissionSceneStandBy = GetStandByParams(tIntermissionScene);
foreach (STSIntermissionInterface tInterfaced in tIntermissionInterfaced)
{
tInterfaced.OnStandByStart(tIntermissionSceneStandBy);
}
StandBy();
while (StandByIsProgressing(tIntermissionSceneStandBy))
{
yield return(null);
}
// send call back for standby finished
foreach (STSIntermissionInterface tInterfaced in tIntermissionInterfaced)
{
tInterfaced.OnStandByFinish(tIntermissionSceneStandBy);
}
// Waiting to load the next Scene
while (WaitingToLauchNextScene(tIntermissionSceneStandBy))
{
//Debug.Log ("StandByIsNotFinished loop");
yield return(null);
}
// stanby is finish
// disable user interactions on the transition scene
EventSystemEnable(tIntermissionScene, false);
// disable user interactions on the Intermission scene
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionSceneDisable(sTransitionData);
}
// Intermission scene Transition Out GO!
AnimationTransitionOut(tIntermissionSceneParams, sTransitionData);
// Intermission scene Transition Out start
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tIntermissionSceneParams.EffectOnExit, tIntermissionSceneParams.InterEffectDuration, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tIntermissionSceneParams.EffectOnExit, tIntermissionSceneParams.InterEffectDuration, false);
}
while (AnimationFinished() == false)
{
yield return(null);
}
// Intermission scene Transition Out finished!
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, false);
}
// fadeout is finish
// will unloaded the Intermission scene
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionSceneWillUnloaded(sTransitionData);
}
AsyncOperation tAsynchroneUnloadTransition;
tAsynchroneUnloadTransition = SceneManager.UnloadSceneAsync(sIntermissionSceneName);
while (tAsynchroneUnloadTransition.progress < 0.9f)
{
yield return(null);
}
while (!tAsynchroneUnloadTransition.isDone)
{
yield return(null);
}
CameraPrevent(true);
AudioListenerPrevent(true);
SceneManager.SetActiveScene(SceneManager.GetSceneByName(sSceneNameToActive));
AnimationTransitionIn(tNextSceneParams, sTransitionData);
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tNextSceneParams.EffectOnEnter, tNextSceneParams.InterEffectDuration, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tNextSceneParams.EffectOnEnter, tNextSceneParams.InterEffectDuration, false);
}
while (AnimationFinished() == false)
{
yield return(null);
}
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, false);
}
EventSystemPrevent(true);
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionSceneEnable(sTransitionData);
}
TransitionInProgress = false;
}
//-------------------------------------------------------------------------------------------------------------
private IEnumerator INTERNAL_ChangeScenesWithIntermission(
string sIntermissionScene,
string sActualActiveScene,
string sNextActiveScene,
List <string> sScenesToAdd,
List <string> sScenesToRemove,
STSTransitionData sTransitionData)
{
//AsyncOperation tAsyncOperation;
Dictionary <string, AsyncOperation> tAsyncOperationList = new Dictionary <string, AsyncOperation>();
//-------------------------------
// ACTUAL SCENE DISABLE
//-------------------------------
TransitionInProgress = true;
//-------------------------------
Scene tActualScene = SceneManager.GetSceneByName(sActualActiveScene);
//-------------------------------
STSTransition tActualSceneParams = GetTransitionsParams(tActualScene);
STSTransitionInterface[] tActualSceneInterfaced = GetTransitionInterface(tActualScene);
STSTransitionInterface[] tOtherSceneInterfaced = GetOtherTransitionInterface(tActualScene);
// disable the user interactions
EventSystemPrevent(false);
// post scene is disable!
//if (tActualSceneParams.Interfaced != null)
//{
// tActualSceneParams.Interfaced.OnTransitionSceneDisable(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionSceneDisable(sTransitionData);
}
// scene start effect transition out!
AnimationTransitionOut(tActualSceneParams, sTransitionData);
// post scene start effect transition out!
//if (tActualSceneParams.Interfaced != null)
//{
// tActualSceneParams.Interfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit);
//}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit, false);
}
// waiting effect will finish
while (AnimationFinished() == false)
{
yield return(null);
}
// post scene finish effcet transition out
//if (tActualSceneParams.Interfaced != null)
//{
// tActualSceneParams.Interfaced.OnTransitionExitFinish(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, false);
}
//-------------------------------
// Intermission SCENE LOAD AND ENABLE
//-------------------------------
// load transition scene async
AsyncOperation tAsyncOperationIntermission = SceneManager.LoadSceneAsync(sIntermissionScene, LoadSceneMode.Additive);
tAsyncOperationIntermission.allowSceneActivation = true;
while (tAsyncOperationIntermission.progress < 0.9f)
{
yield return(null);
}
Scene tIntermissionScene = SceneManager.GetSceneByName(sIntermissionScene);
while (!tAsyncOperationIntermission.isDone)
{
AudioListenerEnable(tIntermissionScene, false);
yield return(null);
}
// get Transition Scene
// Active the next scene as root scene
SceneManager.SetActiveScene(tIntermissionScene);
// disable audiolistener of preview scene
CameraPrevent(true);
AudioListenerPrevent(true);
// disable the user interactions until fadein
EventSystemEnable(tIntermissionScene, false);
// get params
STSTransition tIntermissionSceneParams = GetTransitionsParams(tIntermissionScene);
STSTransitionInterface[] tIntermissionSceneInterfaced = GetTransitionInterface(tIntermissionScene);
STSIntermissionInterface[] tIntermissionInterfaced = GetIntermissionInterface(tIntermissionScene);
STSIntermission tIntermissionSceneStandBy = GetStandByParams(tIntermissionScene);
//-------------------------------
// COUNT SCENES TO REMOVE OR ADD
//-------------------------------
float tSceneCount = sScenesToAdd.Count + sScenesToRemove.Count;
int tSceneCounter = 0;
//-------------------------------
// UNLOADED SCENES REMOVED
//-------------------------------
foreach (string tSceneToRemove in sScenesToRemove)
{
//Debug.Log("tSceneToRemove :" + tSceneToRemove);
// fadeout is finish
// will unloaded the scene
Scene tSceneToDelete = SceneManager.GetSceneByName(tSceneToRemove);
STSTransition tSceneToDeleteParams = GetTransitionsParams(tSceneToDelete);
STSTransitionInterface[] tSceneToDeleteInterfaced = GetTransitionInterface(tSceneToDelete);
//if (tSceneToDeleteParams.Interfaced != null)
//{
// tSceneToDeleteParams.Interfaced.OnTransitionSceneWillUnloaded(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tSceneToDeleteInterfaced)
{
tInterfaced.OnTransitionSceneWillUnloaded(sTransitionData);
}
if (SceneManager.GetSceneByName(tSceneToRemove).isLoaded)
{
AsyncOperation tAsyncOperationRemove = SceneManager.UnloadSceneAsync(tSceneToRemove);
if (tAsyncOperationRemove != null)
{
tAsyncOperationRemove.allowSceneActivation = true; //? needed?
//while (tAsyncOperationRemove.progress < 0.9f)
//{
// if (tIntermissionSceneStandBy.Interfaced != null)
// {
// tIntermissionSceneStandBy.Interfaced.OnLoadingNextScenePercent(sTransitionData, tSceneToRemove, tSceneCounter, tAsyncOperationRemove.progress, (tSceneCounter + tAsyncOperationRemove.progress) / tSceneCount);
// }
// yield return null;
//}
//while (!tAsyncOperationRemove.isDone)
//{
// yield return null;
//}
}
else
{
Debug.LogWarning("UnloadSceneAsync is not possible for " + tSceneToRemove);
}
}
foreach (STSIntermissionInterface tInterfaced in tIntermissionInterfaced)
{
tInterfaced.OnUnloadScene(sTransitionData, tSceneToRemove, tSceneCounter, (tSceneCounter + 1.0F) / tSceneCount);
}
tSceneCounter++;
//Debug.Log("tSceneToRemove :" + tSceneToRemove + " finish!");
}
//-------------------------------
// Intermission start enter animation
//-------------------------------
// get params
// Intermission scene is loaded
//if (tIntermissionSceneParams.Interfaced != null)
//{
// tIntermissionSceneParams.Interfaced.OnTransitionSceneLoaded(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionSceneLoaded(sTransitionData);
}
// animation in Go!
AnimationTransitionIn(tIntermissionSceneParams, sTransitionData);
// animation in
//if (tIntermissionSceneParams.Interfaced != null)
//{
// tIntermissionSceneParams.Interfaced.OnTransitionEnterStart(sTransitionData, tIntermissionSceneParams.EffectOnEnter, tIntermissionSceneParams.InterEffectDuration);
//}
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tIntermissionSceneParams.EffectOnEnter, tIntermissionSceneParams.InterEffectDuration, true);
}
while (AnimationFinished() == false)
{
yield return(null);
}
// animation in Finish
//if (tIntermissionSceneParams.Interfaced != null)
//{
// tIntermissionSceneParams.Interfaced.OnTransitionEnterFinish(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, true);
}
// enable the user interactions
EventSystemEnable(tIntermissionScene, true);
// enable the user interactions
//if (tIntermissionSceneParams.Interfaced != null)
//{
// tIntermissionSceneParams.Interfaced.OnTransitionSceneEnable(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionSceneEnable(sTransitionData);
}
//-------------------------------
// Intermission SCENE START STAND BY
//-------------------------------
// start stand by
foreach (STSIntermissionInterface tInterfaced in tIntermissionInterfaced)
{
tInterfaced.OnStandByStart(tIntermissionSceneStandBy);
}
StandBy();
//-------------------------------
// LOADED SCENES ADDED
//-------------------------------
foreach (string tSceneToLoad in sScenesToAdd)
{
//Debug.Log("tSceneToAdd :" + tSceneToAdd);
Scene tSceneToAdd = SceneManager.GetSceneByName(tSceneToLoad);
if (SceneManager.GetSceneByName(tSceneToLoad).isLoaded)
{
foreach (STSIntermissionInterface tInterfaced in tIntermissionInterfaced)
{
tInterfaced.OnSceneAllReadyLoaded(sTransitionData, tSceneToLoad, tSceneCounter, (tSceneCounter + 1.0F) / tSceneCount);
}
//Debug.Log("tSceneToAdd :" + tSceneToAdd + " allready finish!");
AudioListenerEnable(tSceneToAdd, false);
CameraPreventEnable(tSceneToAdd, false);
EventSystemEnable(tSceneToAdd, false);
}
else
{
foreach (STSIntermissionInterface tInterfaced in tIntermissionInterfaced)
{
tInterfaced.OnLoadingSceneStart(sTransitionData, tSceneToLoad, tSceneCounter, 0.0F, 0.0F);
}
AsyncOperation tAsyncOperationAdd = SceneManager.LoadSceneAsync(tSceneToLoad, LoadSceneMode.Additive);
tAsyncOperationList.Add(tSceneToLoad, tAsyncOperationAdd);
tAsyncOperationAdd.allowSceneActivation = false;
while (tAsyncOperationAdd.progress < 0.9f)
{
foreach (STSIntermissionInterface tInterfaced in tIntermissionInterfaced)
{
tInterfaced.OnLoadingScenePercent(sTransitionData, tSceneToLoad, tSceneCounter, tAsyncOperationAdd.progress, (tSceneCounter + tAsyncOperationAdd.progress) / tSceneCount);
}
yield return(null);
}
foreach (STSIntermissionInterface tInterfaced in tIntermissionInterfaced)
{
tInterfaced.OnLoadingSceneFinish(sTransitionData, tSceneToLoad, tSceneCounter, 1.0F, (tSceneCounter + 1.0F) / tSceneCount);
}
//Debug.Log("tSceneToAdd :" + tSceneToAdd + " 90%!");
}
tSceneCounter++;
}
//-------------------------------
// Intermission STAND BY
//-------------------------------
while (StandByIsProgressing(tIntermissionSceneStandBy))
{
yield return(null);
}
// As soon as possible
foreach (STSIntermissionInterface tInterfaced in tIntermissionInterfaced)
{
tInterfaced.OnStandByFinish(tIntermissionSceneStandBy);
}
// Waiting to load the next Scene
while (WaitingToLauchNextScene(tIntermissionSceneStandBy))
{
//Debug.Log ("StandByIsNotFinished loop");
yield return(null);
}
//-------------------------------
// Intermission GO TO NEXT SCENE PROCESS
//-------------------------------
// stanby is finished And the next scene can be lauch
// disable user interactions on the Intermission scene
EventSystemEnable(tIntermissionScene, false);
//if (tIntermissionSceneParams.Interfaced != null)
//{
// tIntermissionSceneParams.Interfaced.OnTransitionSceneDisable(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionSceneDisable(sTransitionData);
}
// Intermission scene Transition Out GO!
AnimationTransitionOut(tIntermissionSceneParams, sTransitionData);
// Intermission scene Transition Out start
//if (tIntermissionSceneParams.Interfaced != null)
//{
// tIntermissionSceneParams.Interfaced.OnTransitionEnterStart(sTransitionData, tIntermissionSceneParams.EffectOnExit, tIntermissionSceneParams.InterEffectDuration);
//}
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, tIntermissionSceneParams.EffectOnExit, tIntermissionSceneParams.InterEffectDuration, true);
}
while (AnimationFinished() == false)
{
yield return(null);
}
// Intermission scene Transition Out finished!
//if (tIntermissionSceneParams.Interfaced != null)
//{
// tIntermissionSceneParams.Interfaced.OnTransitionExitFinish(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, true);
}
// fadeout is finish
// will unloaded the Intermission scene
//if (tIntermissionSceneParams.Interfaced != null)
//{
// tIntermissionSceneParams.Interfaced.OnTransitionSceneWillUnloaded(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tIntermissionSceneInterfaced)
{
tInterfaced.OnTransitionSceneWillUnloaded(sTransitionData);
}
//-------------------------------
// ACTIVE ADDED SCENES
//-------------------------------
foreach (string tSceneToAdd in sScenesToAdd)
{
// scene is loaded!
if (tAsyncOperationList.ContainsKey(tSceneToAdd))
{
AsyncOperation tAsyncOperationAdd = tAsyncOperationList[tSceneToAdd];
Scene tSceneToLoad = SceneManager.GetSceneByName(tSceneToAdd);
tAsyncOperationAdd.allowSceneActivation = true;
while (!tAsyncOperationAdd.isDone)
{
AudioListenerEnable(tSceneToLoad, false);
yield return(null);
}
AudioListenerEnable(tSceneToLoad, false);
CameraPreventEnable(tSceneToLoad, false);
EventSystemEnable(tSceneToLoad, false);
STSTransitionInterface[] tSceneToLoadInterfaced = GetTransitionInterface(tSceneToLoad);
foreach (STSTransitionInterface tInterfaced in tSceneToLoadInterfaced)
{
tInterfaced.OnTransitionSceneLoaded(sTransitionData);
}
}
}
//-------------------------------
// NEXT SCENE PROCESS
//-------------------------------
Scene tNextActiveScene = SceneManager.GetSceneByName(sNextActiveScene);
SceneManager.SetActiveScene(tNextActiveScene);
AudioListenerPrevent(true);
CameraPrevent(true);
// get params
STSTransition sNextSceneParams = GetTransitionsParams(tNextActiveScene);
STSTransitionInterface[] tNextSceneInterfaced = GetTransitionInterface(tNextActiveScene);
STSTransitionInterface[] tOtherNextSceneInterfaced = GetOtherTransitionInterface(tNextActiveScene);
EventSystemEnable(tNextActiveScene, false);
// Next scene appear by fade in
//-------------------------------
// Intermission UNLOAD
//-------------------------------
AsyncOperation tAsyncOperationIntermissionUnload = SceneManager.UnloadSceneAsync(tIntermissionScene);
if (tAsyncOperationIntermissionUnload != null)
{
tAsyncOperationIntermissionUnload.allowSceneActivation = true; //? needed?
while (tAsyncOperationIntermissionUnload.progress < 0.9f)
{
yield return(null);
}
while (!tAsyncOperationIntermissionUnload.isDone)
{
yield return(null);
}
}
else
{
Debug.LogWarning("UnloadSceneAsync is not possible for " + tIntermissionScene);
}
//-------------------------------
// NEXT SCENE ENABLE
//-------------------------------
AnimationTransitionIn(sNextSceneParams, sTransitionData);
//if (sNextSceneParams.Interfaced != null)
//{
// sNextSceneParams.Interfaced.OnTransitionEnterStart(sTransitionData, sNextSceneParams.EffectOnEnter, sNextSceneParams.InterEffectDuration);
//}
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, sNextSceneParams.EffectOnEnter, sNextSceneParams.InterEffectDuration, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, sNextSceneParams.EffectOnEnter, sNextSceneParams.InterEffectDuration, false);
}
while (AnimationFinished() == false)
{
yield return(null);
}
//if (sNextSceneParams.Interfaced != null)
//{
// sNextSceneParams.Interfaced.OnTransitionEnterFinish(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, false);
}
// fadein is finish
EventSystemPrevent(true);
// next scene is enable
//if (sNextSceneParams.Interfaced != null)
//{
// sNextSceneParams.Interfaced.OnTransitionSceneEnable(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionSceneEnable(sTransitionData);
}
// My transition is finish. I can do an another transition
TransitionInProgress = false;
}
//-------------------------------------------------------------------------------------------------------------
private IEnumerator INTERNAL_ChangeScenesWithoutIntermission(
string sActualActiveScene,
string sNextActiveScene,
List <string> sScenesToAdd,
List <string> sScenesToRemove,
STSTransitionData sTransitionData)
{
bool tRemoveActual = false;
if (sScenesToRemove.Contains(sActualActiveScene))
{
sScenesToRemove.Remove(sActualActiveScene);
tRemoveActual = true;
}
//AsyncOperation tAsyncOperation;
Dictionary <string, AsyncOperation> tAsyncOperationList = new Dictionary <string, AsyncOperation>();
//-------------------------------
// ACTUAL SCENE DISABLE
//-------------------------------
TransitionInProgress = true;
//-------------------------------
Scene tActualScene = SceneManager.GetSceneByName(sActualActiveScene);
//-------------------------------
STSTransition tActualSceneParams = GetTransitionsParams(tActualScene);
STSTransitionInterface[] tActualSceneInterfaced = GetTransitionInterface(tActualScene);
STSTransitionInterface[] tOtherSceneInterfaced = GetOtherTransitionInterface(tActualScene);
// disable the user interactions
EventSystemPrevent(false);
// post scene is disable!
//if (tActualSceneParams.Interfaced != null)
//{
// tActualSceneParams.Interfaced.OnTransitionSceneDisable(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionSceneDisable(sTransitionData);
}
// scene start effect transition out!
AnimationTransitionOut(tActualSceneParams, sTransitionData);
// post scene start effect transition out!
//if (tActualSceneParams.Interfaced != null)
//{
// tActualSceneParams.Interfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit);
//}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionExitStart(sTransitionData, tActualSceneParams.EffectOnExit, false);
}
// waiting effect will finish
while (AnimationFinished() == false)
{
yield return(null);
}
// post scene finish effcet transition out
//if (tActualSceneParams.Interfaced != null)
//{
// tActualSceneParams.Interfaced.OnTransitionExitFinish(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherSceneInterfaced)
{
tInterfaced.OnTransitionExitFinish(sTransitionData, false);
}
//-------------------------------
// COUNT SCENES TO REMOVE OR ADD
//-------------------------------
float tSceneCount = sScenesToAdd.Count + sScenesToRemove.Count;
int tSceneCounter = 0;
//-------------------------------
// UNLOADED SCENES REMOVED
//-------------------------------
foreach (string tSceneToRemove in sScenesToRemove)
{
//Debug.Log("tSceneToRemove :" + tSceneToRemove);
// fadeout is finish
// will unloaded the scene
Scene tSceneToDelete = SceneManager.GetSceneByName(tSceneToRemove);
AudioListenerEnable(tSceneToDelete, false);
CameraPreventEnable(tSceneToDelete, false);
EventSystemEnable(tSceneToDelete, false);
STSTransitionInterface[] tSceneToDeleteInterfaced = GetTransitionInterface(tSceneToDelete);
//STSTransition tSceneToDeleteParams = GetTransitionsParams(tSceneToDelete, false);
//if (tSceneToDeleteParams.Interfaced != null)
//{
// tSceneToDeleteParams.Interfaced.OnTransitionSceneWillUnloaded(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tSceneToDeleteInterfaced)
{
tInterfaced.OnTransitionSceneWillUnloaded(sTransitionData);
}
if (SceneManager.GetSceneByName(tSceneToRemove).isLoaded)
{
AsyncOperation tAsyncOperationRemove = SceneManager.UnloadSceneAsync(tSceneToRemove);
tAsyncOperationRemove.allowSceneActivation = true; //? needed?
//while (tAsyncOperationRemove.progress < 0.9f)
//{
// yield return null;
//}
//while (!tAsyncOperationRemove.isDone)
//{
// yield return null;
//}
}
tSceneCounter++;
//Debug.Log("tSceneToRemove :" + tSceneToRemove + " finish!");
}
//-------------------------------
// LOADED SCENES ADDED
//-------------------------------
foreach (string tSceneToAdd in sScenesToAdd)
{
//Debug.Log("tSceneToAdd :" + tSceneToAdd);
if (SceneManager.GetSceneByName(tSceneToAdd).isLoaded)
{
//Debug.Log("tSceneToAdd :" + tSceneToAdd + " allready finish!");
}
else
{
AsyncOperation tAsyncOperationAdd = SceneManager.LoadSceneAsync(tSceneToAdd, LoadSceneMode.Additive);
tAsyncOperationList.Add(tSceneToAdd, tAsyncOperationAdd);
tAsyncOperationAdd.allowSceneActivation = false;
//Debug.Log("tSceneToAdd :" + tSceneToAdd + " 90%!");
}
tSceneCounter++;
}
//-------------------------------
// ACTIVE ADDED SCENES
//-------------------------------
foreach (string tSceneToAdd in sScenesToAdd)
{
// scene is loaded!
if (tAsyncOperationList.ContainsKey(tSceneToAdd))
{
Scene tSceneToLoad = SceneManager.GetSceneByName(tSceneToAdd);
AsyncOperation tAsyncOperationAdd = tAsyncOperationList[tSceneToAdd];
tAsyncOperationAdd.allowSceneActivation = true;
while (tAsyncOperationAdd.progress < 0.9f)
{
yield return(null);
}
while (!tAsyncOperationAdd.isDone)
{
AudioListenerEnable(tSceneToLoad, false);
yield return(null);
}
AudioListenerEnable(tSceneToLoad, false);
CameraPreventEnable(tSceneToLoad, false);
EventSystemEnable(tSceneToLoad, false);
STSTransitionInterface[] tSceneToLoadInterfaced = GetTransitionInterface(tSceneToLoad);
foreach (STSTransitionInterface tInterfaced in tSceneToLoadInterfaced)
{
tInterfaced.OnTransitionSceneLoaded(sTransitionData);
}
//Debug.Log("tSceneToAdd :" + tSceneToAdd + " finish!");
}
}
//-------------------------------
// NEXT SCENE PROCESS
//-------------------------------
Scene tNextActiveScene = SceneManager.GetSceneByName(sNextActiveScene);
SceneManager.SetActiveScene(tNextActiveScene);
CameraPrevent(true);
AudioListenerPrevent(true);
// get params
STSTransition sNextSceneParams = GetTransitionsParams(tNextActiveScene);
STSTransitionInterface[] tNextSceneInterfaced = GetTransitionInterface(tNextActiveScene);
STSTransitionInterface[] tOtherNextSceneInterfaced = GetOtherTransitionInterface(tNextActiveScene);
EventSystemEnable(tNextActiveScene, false);
// Next scene appear by fade in
//-------------------------------
// Intermission UNLOAD
//-------------------------------
if (tRemoveActual == true)
{
foreach (STSTransitionInterface tInterfaced in tActualSceneInterfaced)
{
tInterfaced.OnTransitionSceneWillUnloaded(sTransitionData);
}
AsyncOperation tAsyncOperationIntermissionUnload = SceneManager.UnloadSceneAsync(sActualActiveScene);
tAsyncOperationIntermissionUnload.allowSceneActivation = true;
}
//-------------------------------
// NEXT SCENE ENABLE
//-------------------------------
AnimationTransitionIn(sNextSceneParams, sTransitionData);
//if (sNextSceneParams.Interfaced != null)
//{
// sNextSceneParams.Interfaced.OnTransitionEnterStart(sTransitionData, sNextSceneParams.EffectOnEnter, sNextSceneParams.InterEffectDuration);
//}
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, sNextSceneParams.EffectOnEnter, sNextSceneParams.InterEffectDuration, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterStart(sTransitionData, sNextSceneParams.EffectOnEnter, sNextSceneParams.InterEffectDuration, false);
}
while (AnimationFinished() == false)
{
yield return(null);
}
//if (sNextSceneParams.Interfaced != null)
//{
// sNextSceneParams.Interfaced.OnTransitionEnterFinish(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, true);
}
foreach (STSTransitionInterface tInterfaced in tOtherNextSceneInterfaced)
{
tInterfaced.OnTransitionEnterFinish(sTransitionData, false);
}
// fadein is finish
EventSystemPrevent(true);
// next scene is enable
//if (sNextSceneParams.Interfaced != null)
//{
// sNextSceneParams.Interfaced.OnTransitionSceneEnable(sTransitionData);
//}
foreach (STSTransitionInterface tInterfaced in tNextSceneInterfaced)
{
tInterfaced.OnTransitionSceneEnable(sTransitionData);
}
// My transition is finish. I can do an another transition
TransitionInProgress = false;
}
//-------------------------------------------------------------------------------------------------------------
public STSTransition GetTransitionsParams(Scene sScene)
{
STSTransition tTransitionParametersScript;
if (STSTransition.SharedInstanceExists(sScene))
{
//Debug.LogWarning("tTransitionParametersScript exists");
tTransitionParametersScript = STSTransition.SharedInstance(sScene);
}
else
{
//Debug.LogWarning("tTransitionParametersScript not exists");
tTransitionParametersScript = STSTransition.SharedInstance(sScene);
if (DefaultEffectOnEnter != null)
{
tTransitionParametersScript.EffectOnEnter = DefaultEffectOnEnter.Dupplicate();
}
else
{
tTransitionParametersScript.EffectOnEnter = STSEffectType.Default.Dupplicate();
}
if (DefaultEffectOnExit != null)
{
tTransitionParametersScript.EffectOnExit = DefaultEffectOnExit.Dupplicate();
}
else
{
tTransitionParametersScript.EffectOnExit = STSEffectType.Default.Dupplicate();
}
}
/*
* //Debug.Log("STSSceneManager GetTransitionsParams()");
* STSTransition tTransitionParametersScript = null;
* GameObject[] tAllRootObjects = sScene.GetRootGameObjects();
* // quick solution?!
* foreach (GameObject tObject in tAllRootObjects)
* {
* if (tObject.GetComponent<STSTransition>() != null)
* {
* tTransitionParametersScript = tObject.GetComponent<STSTransition>();
* break;
* }
* }
* // slower solution?!
* if (tTransitionParametersScript == null)
* {
* foreach (GameObject tObject in tAllRootObjects)
* {
* if (tObject.GetComponentInChildren<STSTransition>() != null)
* {
* tTransitionParametersScript = tObject.GetComponent<STSTransition>();
* break;
* }
* }
* }
* // no solution?!
* if (tTransitionParametersScript == null)
* {
* Scene tActual = SceneManager.GetActiveScene();
* SceneManager.SetActiveScene(sScene);
* // create Game Object?
* //Debug.Log ("NO PARAMS");
* GameObject tObjToSpawn = new GameObject(STSConstants.K_TRANSITION_DEFAULT_OBJECT_NAME);
* tObjToSpawn.AddComponent<STSSceneController>();
* tTransitionParametersScript = tObjToSpawn.AddComponent<STSTransition>();
* if (DefaultEffectOnEnter != null)
* {
* tTransitionParametersScript.EffectOnEnter = DefaultEffectOnEnter.Dupplicate();
* }
* else
* {
* tTransitionParametersScript.EffectOnEnter = STSEffectType.Default.Dupplicate();
* }
* if (DefaultEffectOnEnter != null)
* {
* tTransitionParametersScript.EffectOnExit = DefaultEffectOnExit.Dupplicate();
* }
* else
* {
* tTransitionParametersScript.EffectOnExit = STSEffectType.Default.Dupplicate();
* }
* SceneManager.SetActiveScene(tActual);
* }
*/
return(tTransitionParametersScript);
}
