private void OnLoadingScreenHideComplete()
{
LoadingScreenController.Instance.OnLoadingScreenHideComplete -= OnLoadingScreenHideComplete;
_isLoadingScene = false;
// Debug.Log("Scene load complete!");
OnSceneLoaded?.Invoke(_nextSceneName);
}
private IEnumerator LoadSceneAsync(string sceneName)
{
Time.timeScale = 1;
if (SceneTransition.Instance)
{
SceneTransition.Instance.FadeIn();
while (!SceneTransition.isDone)
{
yield return(null);
}
}
AsyncOperation operation = SceneManager.LoadSceneAsync(sceneName);
while (!operation.isDone)
{
yield return(null);
}
OnSceneLoaded?.Invoke(sceneName);
if (SceneTransition.Instance)
{
SceneTransition.Instance.FadeOut();
}
}
private void InvokeLoadedActions(List <string> sceneNames, SceneType sceneType)
{
try
{
foreach (string sceneName in sceneNames)
{ // Announce scenes individually regardless of type
OnSceneLoaded?.Invoke(sceneName);
}
switch (sceneType)
{
case SceneType.Content:
// Announce content as a set
OnContentLoaded?.Invoke(sceneNames);
break;
case SceneType.Lighting:
// We only handle lighting scenes one at a time
Debug.Assert(sceneNames.Count == 1);
OnLightingLoaded?.Invoke(sceneNames[0]);
break;
default:
// Don't announce other types of scenes invidually
break;
}
}
catch (Exception e)
{
Debug.LogError("Error when attempting to invoke loaded actions for " + string.Join(", ", sceneNames));
Debug.LogException(e);
}
}
private void LoadSceneInstant(string sceneName)
{
_isLoadingScene = false;
SceneManager.LoadScene(sceneName);
// Debug.Log("Scene load complete!");
OnSceneLoaded?.Invoke(_nextSceneName);
}
/// <summary>
/// Loads a single scene.
/// </summary>
/// <param name="scene">The scene name.</param>
/// <param name="onComplete">Optional callback.</param>
/// <returns></returns>
public static IEnumerator CoroutineLoadScene(string scene, Action onComplete = null)
{
//Block flow if the scene does not exist
if (!Application.CanStreamedLevelBeLoaded(scene))
{
if (LogLevel >= LogType.Less)
{
Debug.LogWarning(Tag + "The scene \"" + scene + "\" cannot be found or does not exist.");
}
yield break;
}
AsyncOperation op = SceneManager.LoadSceneAsync(scene);
//Wait until the current scene is loaded
while (op.progress < 0.9f)
{
yield return(null);
}
//Debug
//yield return new WaitForSeconds(1f);
onComplete?.Invoke();
OnSceneLoaded?.Invoke(new [] { scene });
}
private IEnumerator FadeAndSwitchScenes(string sceneName)
{
m_ScreenFader.FadeOut();
while (m_ScreenFader.IsFading)
{
Debug.Log("Fading...");
yield return(null);
}
OnSceneUnload?.Invoke();
yield return(SceneManager.UnloadSceneAsync(SceneManager.GetActiveScene().buildIndex));
yield return(StartCoroutine(LoadSceneAndSetActive(sceneName)));
OnSceneLoaded?.Invoke();
StateController.Instance.StateMachine.ChangeState(StateController.shop);
m_ScreenFader.FadeIn();
while (m_ScreenFader.IsFading)
{
Debug.Log("Fading...");
yield return(null);
}
}
private void InvokeLoadedActions(List <string> sceneNames, SceneType sceneType)
{
foreach (string sceneName in sceneNames)
{ // Announce scenes individually regardless of type
OnSceneLoaded?.Invoke(sceneName);
}
switch (sceneType)
{
case SceneType.Content:
// Announce content as a set
OnContentLoaded?.Invoke(sceneNames);
break;
case SceneType.Lighting:
// We only handle lighting scenes one at a time
Debug.Assert(sceneNames.Count == 1);
OnLightingLoaded?.Invoke(sceneNames[0]);
break;
default:
// Don't announce other types of scenes invidually
break;
}
}
/// <summary>
/// Load the scene in the given ScenePackage.
/// </summary>
/// <param name="scenePackage">The ScenePackage to load.</param>
public IEnumerable <SceneBuildStatus> loadScene(ScenePackage scenePackage, SceneBuildOptions options)
{
currentScenePackage = scenePackage;
yield return(new SceneBuildStatus()
{
Message = "Setting up Resources"
});
sceneResourceManager.changeResourcesToMatch(scenePackage.ResourceManager);
sceneResourceManager.initializeResources();
currentScene = scenePackage.SceneDefinition.createScene();
if (OnSceneLoading != null)
{
OnSceneLoading.Invoke(this, currentScene);
}
currentSimObjects = scenePackage.SimObjectManagerDefinition.createSimObjectManager(currentScene.getDefaultSubScene());
foreach (var status in currentScene.buildSceneStatus(options))
{
yield return(status);
}
if (OnSceneLoaded != null)
{
OnSceneLoaded.Invoke(this, currentScene);
}
}
private IEnumerator LoadScene(string targetLevel, OnSceneLoaded callback = null)
{
yield return(SceneManager.LoadSceneAsync(targetLevel, LoadSceneMode.Single));
isLoading = false;
if (callback != null)
{
callback.Invoke();
}
}
public virtual void OnSceneLoadedInvoke(Scene x)
{
if (GameSparksManager.Instance().IsDebug)
{
var subs = OnSceneLoaded?.GetInvocationList();
var debugStr = "OnSceneLoaded InvokationList: ";
subs?.ToList().ForEach(m => debugStr += "\n" + m.Method.Name);
Debug.Log(debugStr);
}
OnSceneLoaded?.Invoke(x);
}
private void SceneManager_OnSceneLoaded(Scene arg0, LoadSceneMode arg1)
{
Detach();
_active = false;
OnSceneUnloaded?.Invoke();
if (arg0.buildIndex == SceneBuildIndex)
{
Attach(arg0);
_active = true;
OnSceneLoaded?.Invoke();
}
}
private static void SceneLoadedHandler(Scene scene, LoadSceneMode mode)
{
if (AllAvailableGameObjectsByScene.ContainsKey(scene.name))
{
AllAvailableGameObjectsByScene[scene.name] = scene.GetRootGameObjects();
}
else
{
AllAvailableGameObjectsByScene.Add(scene.name, scene.GetRootGameObjects());
}
OnSceneLoaded?.Invoke(scene.name);
}
private void FinishLoading(Scene scene)
{
if (scene.buildIndex != 0)
{
if (_isLoaded && _isUnloaded)
{
_isLoaded = false;
_isUnloaded = false;
var currentScene = _loadingScene == SceneType.None ? CurrentScene : _loadingScene;
OnSceneLoaded?.Invoke(this, new SceneLoadedEventArgs(currentScene));
}
}
}
private IEnumerator LoadSceneAsync(GameScene scene, bool slowLoad = false)
{
_busy = true;
if (PopupWindow.Opened)
{
PopupWindow.Opened.Close();
}
var dimmer = slowLoad ? slowDimmer : fastDimmer;
dimmer.Switch(true);
yield return(StartCoroutine(dimmer.WaitForSwitchAsync()));
var loadedScene = GetLoadedScene();
if (loadedScene != string.Empty)
{
yield return(SceneManager.UnloadSceneAsync(loadedScene));
}
Time.timeScale = 1;
if (slowLoad)
{
dimmer.StartWaitingForTap();
yield return(StartCoroutine(dimmer.WaitForTapAsync()));
}
yield return(SceneManager.LoadSceneAsync(scene.ToStringName(), LoadSceneMode.Additive));
if (scene.IsPivot())
{
PivotScene = scene;
}
if (_hasSceneLoadingConflict)
{
_hasSceneLoadingConflict = false;
StartCoroutine(LoadSceneAsync(_conflictedLoadedScene, true));
yield break;
}
dimmer.Switch(false);
yield return(StartCoroutine(dimmer.WaitForSwitchAsync()));
OnSceneLoaded?.Invoke(null, EventArgs.Empty);
_busy = false;
}
private void OnSceneLoadedEvent(Scene _scene, LoadSceneMode _mode)
{
if (onSceneLoaded != null)
{
try
{
UIDebug.PrintDebug(UIDebug.DebugType.EVENT, transform, "UISceneManager", "On Scene Loaded", "Event invoke.");
onSceneLoaded.Invoke(_scene, _mode);
}
catch (System.Exception exception)
{
Debug.LogError("Couldn't invoke event onSceneLoaded. Error: " + exception.Message);
}
}
}
public void createScene()
{
scene = sceneDefinition.createScene();
scene.Scope = pluginManager.GlobalScope.ServiceProvider.CreateScope(); //Disposed in destroyscene
if (OnSceneLoading != null)
{
OnSceneLoading.Invoke(this, scene);
}
createSimObjects();
if (OnSceneLoaded != null)
{
OnSceneLoaded.Invoke(this, scene);
}
foreach (DebugInterface debugInterface in controller.PluginManager.DebugInterfaces)
{
debugInterface.createDebugInterface(controller.PluginManager.RendererPlugin, scene.getDefaultSubScene());
}
}
/// <summary>
/// Loads a single scene.
/// </summary>
/// <param name="scene">The scene to unload.</param>
/// <param name="onComplete">Optional callback.</param>
public static void LoadScene(string scene, Action onComplete = null)
{
//Block flow if the scene does not exist
if (!Application.CanStreamedLevelBeLoaded(scene))
{
if (LogLevel >= LogType.Less)
{
Debug.LogWarning(Tag + "The scene \"" + scene + "\" cannot be found or does not exist.");
}
return;
}
AsyncOperation op = SceneManager.LoadSceneAsync(scene);
op.completed += _ => {
onComplete?.Invoke();
OnSceneLoaded?.Invoke(new [] { scene });
};
}
private void PrepareScene()
{
SpawnCamera();
SpawnWorldUiCanvas();
sceneSettings = FindObjectOfType <SceneSettings>();
#if (UNITY_EDITOR)
levelController.StartCurrentEditorLevel();
if (sceneSettings != null && sceneSettings.levels != null)
{
currentLevel = sceneSettings.startLevel;
levelController.LoadLevel(sceneSettings.GetLevel(currentLevel));
}
#else
currentLevel = sceneSettings.startLevel;
levelController.LoadLevel(sceneSettings.GetLevel(currentLevel));
#endif
loadingScreen.Hide();
isLoading = false;
OnSceneLoaded?.Invoke();
}
internal static void Internal_OnSceneEvent(SceneEventType eventType, Scene scene, ref Guid sceneId)
{
switch (eventType)
{
case SceneEventType.OnSceneSaving: OnSceneSaving?.Invoke(scene, sceneId); break;
case SceneEventType.OnSceneSaved: OnSceneSaved?.Invoke(scene, sceneId); break;
case SceneEventType.OnSceneSaveError: OnSceneSaveError?.Invoke(scene, sceneId); break;
case SceneEventType.OnSceneLoading: OnSceneLoading?.Invoke(scene, sceneId); break;
case SceneEventType.OnSceneLoaded: OnSceneLoaded?.Invoke(scene, sceneId); break;
case SceneEventType.OnSceneLoadError: OnSceneLoadError?.Invoke(scene, sceneId); break;
case SceneEventType.OnSceneUnloading: OnSceneUnloading?.Invoke(scene, sceneId); break;
case SceneEventType.OnSceneUnloaded: OnSceneUnloaded?.Invoke(scene, sceneId); break;
}
}
/// <summary>
/// Load the scene in the given ScenePackage.
/// </summary>
/// <param name="scenePackage">The ScenePackage to load.</param>
public IEnumerable <SceneBuildStatus> loadSceneCo(ScenePackage scenePackage, SceneBuildOptions options = SceneBuildOptions.SingleUseDefinitions)
{
this.scenePackage = scenePackage;
yield return(new SceneBuildStatus()
{
Message = "Setting up Resources"
});
sceneResourceManager.changeResourcesToMatch(scenePackage.ResourceManager);
sceneResourceManager.initializeResources();
scene = scenePackage.SceneDefinition.createScene();
scene.Scope = pluginManager.GlobalScope.ServiceProvider.CreateScope();
if (OnSceneLoading != null)
{
OnSceneLoading.Invoke(this, scene);
}
currentSimObjects = scenePackage.SimObjectManagerDefinition.createSimObjectManager(scene.getDefaultSubScene());
if (dynamicMode)
{
foreach (var status in scene.buildSceneStatus(options))
{
yield return(status);
}
}
else
{
scene.buildStaticScene();
}
if (OnSceneLoaded != null)
{
OnSceneLoaded.Invoke(this, scene);
}
foreach (DebugInterface debugInterface in pluginManager.DebugInterfaces)
{
debugInterface.createDebugInterface(pluginManager.RendererPlugin, scene.getDefaultSubScene());
}
}
private IEnumerator LoadSceneByNameCoroutine(string sceneName)
{
TypedSceneName typedSceneName = null;
_typedNamesDict.TryGetValue(sceneName, out typedSceneName);
OnSceneStartLoading?.Invoke(sceneName);
if (typedSceneName != null)
{
OnSceneStartLoadingByType?.Invoke(typedSceneName.SceneType);
}
var asyncOperation = SceneManager.LoadSceneAsync(sceneName);
while (!asyncOperation.isDone)
{
yield return(null);
}
if (!Mathf.Approximately(_delayAfterLoad, 0f))
{
yield return(_delayWaiting);
}
yield return(null);
_switchCoroutine = null;
OnSceneLoaded?.Invoke(sceneName);
if (typedSceneName != null)
{
OnSceneLoadedByType?.Invoke(typedSceneName.SceneType);
}
yield return(null);
}
private void LoadingComplete(AsyncOperation obj)
{
OnSceneLoaded?.Invoke(CurrentStateInfo);
loadingOperation = null;
}
public static void SceneLoaded()
{
OnSceneLoaded?.Invoke();
}
public override void Awake()
{
base.Awake();
InternalSceneManager.sceneLoaded += (Scene scene, LoadSceneMode loadSceneMode) => { onSceneLoaded?.Invoke(); };
}
/// <summary>
/// Loads in an array of scenes additively.
/// </summary>
/// <param name="scenes">The array of scene names.</param>
/// <param name="onComplete">Optional callback.</param>
/// <param name="duplicateScenes">Should duplicate scenes be allowed. False by default.</param>
/// <returns></returns>
public static IEnumerator CoroutineLoadScenesAdditive(string[] scenes, Action onComplete = null, bool duplicateScenes = false)
{
AsyncOperation[] operations = new AsyncOperation[scenes.Length];
//Step 1: List all of operations
for (var i = 0; i < scenes.Length; i++)
{
string scene = scenes[i];
//Block flow if the scene does not exist
if (!Application.CanStreamedLevelBeLoaded(scene))
{
if (LogLevel >= LogType.Less)
{
Debug.LogWarning(Tag + "The scene \"" + scene + "\" cannot be found or does not exist.");
}
continue;
}
if (!duplicateScenes)
{
//Block flow if the scene has already been loaded
Scene sceneObj = SceneManager.GetSceneByName(scene);
if (sceneObj.isLoaded)
{
if (LogLevel >= LogType.All)
{
Debug.LogWarning(Tag + "The scene \"" + scene + "\" has already been loaded.");
}
continue;
}
}
//Start loading the scene
AsyncOperation op = SceneManager.LoadSceneAsync(scene, LoadSceneMode.Additive);
op.allowSceneActivation = false;
operations[i] = op;
//Wait until the current scene is loaded but not activated
while (op.progress < 0.9f)
{
yield return(null);
}
//Debug
//yield return new WaitForSeconds(1f);
}
//Step 2: Activate all of the operations at once
foreach (AsyncOperation op in operations)
{
if (op == null)
{
continue;
}
op.allowSceneActivation = true;
while (!op.isDone)
{
yield return(null);
}
//Debug
//yield return new WaitForSeconds(1f);
}
onComplete?.Invoke();
OnSceneLoaded?.Invoke(scenes);
}
private void OpenScene(int sceneId, out Scene scene)
{
scene = SceneManager.LoadScene(sceneId, new LoadSceneParameters(LoadSceneMode.Additive));
OnSceneLoaded?.Invoke(sceneId);
}
private static void SceneOpenedCallback(Scene scene, UnityEditor.SceneManagement.OpenSceneMode mode)
{
_gameObjectsList.Clear();
AppendAllTransformInSceneToList(scene);
OnSceneLoaded?.Invoke(_gameObjectsList);
}
/// <summary>
/// Loads in an array of scenes additively.
/// </summary>
/// <param name="scenes">The array of scene names.</param>
/// <param name="onComplete">Optional callback.</param>
/// <param name="duplicateScenes">Should duplicate scenes be allowed. False by default.</param>
public static void LoadScenesAdditive(string[] scenes, Action onComplete = null, bool duplicateScenes = false)
{
AsyncOperation[] operations = new AsyncOperation[scenes.Length];
//Step 1: Load all of operations
for (var i = 0; i < scenes.Length; i++)
{
string scene = scenes[i];
//Block flow if the scene does not exist
if (!Application.CanStreamedLevelBeLoaded(scene))
{
if (LogLevel >= LogType.Less)
{
Debug.LogWarning(Tag + "The scene \"" + scene + "\" cannot be found or does not exist.");
}
continue;
}
if (!duplicateScenes)
{
//Block flow if the scene has already been loaded
Scene sceneObj = SceneManager.GetSceneByName(scene);
if (sceneObj.isLoaded)
{
if (LogLevel >= LogType.All)
{
Debug.LogWarning(Tag + "The scene \"" + scene + "\" has already been loaded.");
}
continue;
}
}
//Load the scene and deactivate
AsyncOperation op = SceneManager.LoadSceneAsync(scene, LoadSceneMode.Additive);
op.allowSceneActivation = false;
operations[i] = op;
}
//Step 2: Activate all of the operations
foreach (AsyncOperation op in operations)
{
if (op == null)
{
continue;
}
op.allowSceneActivation = true;
}
//Step 3: Attach the callback to the last scene
for (int i = operations.Length - 1; i >= 0; i--)
{
AsyncOperation op = operations[i];
if (op == null)
{
continue;
}
op.completed += _ => {
onComplete?.Invoke();
OnSceneLoaded?.Invoke(scenes);
};
break;
}
}
private static void OnCompleteSceneLoad(OWScene oldScene, OWScene newScene)
{
OnSceneLoaded?.Invoke(newScene, InUniverse(newScene));
}
