Animate Loading Screen During CPU-Heavy Scene Load

Question

I have a scene with lots of lightweight objects and one that takes anywhere between 10 and 45 seconds to load.

At a high level, the Awake method does...

• Query database
• For each result do some (fairly heavy) calculations
• Populate a list
• Use that list to generate game objects

[Only the last step of which requires the main thread]

I have another scene to display a loading screen. It has a UI panel with a shader that shows an animation.

The Loading screen starts a coroutine to switch level...

private IEnumerator LoadNewScene() {
    AsyncOperation async = SceneManager.LoadSceneAsync("GalaxyMap", LoadSceneMode.Single);
    while (!async.isDone) {
        yield return null;
    }
}

At which point, the animation freezes for 10-45 seconds while the heavy object loads.

In an attempt to make the animation CPU-independent, it's coded as a shader using the built-in _Time property.

I assume this is because my heavy object's Awake() is running on Unity's main thread and thus is blocking updates to the shader.

If so, I can move a lot of the heavy lifting onto a background thread, but I can't work out how to release the thread back to Unity temporarily.

The Awake() method isn't async, and any attempt to create a Task and wait for it will just block the same thread.

Conversely, I could have a completion callback for when the load is done. That would allow me to release the main thread sooner, however, Unity would think my scene had finished loading prematurely and remove the loading screen.

How can I either:

• Release control of the thrad intermittently so Unity can refresh the UI
• Explicitly tell Unity when it should consider a scene "loaded" and ready for display

?

Answer 1

As mentioned in the comments, you can use an ordinary variable to pass around information about when the generation is done. Here's one way to do it:

public class GalaxyMap : MonoBehaviour {

    static bool IsGenerationComplete { get; private set; }
    public static void PrepareToGenerate() { IsGenerationComplete = false; }

    public UnityEvent OnGenerationCompleted;

    IEnumerator Start() {
        // Do the bulk of your work on another thread.
        var generatorThread = new Thread(DoBackgroundThreadWork);
        generatorThread.Start();

        // Keep ticking this Start method on the main thread
        // until our threadsafe work is done.
        while (generatorThread.ThreadState != ThreadState.Stopped) {
            yield return null;
        }

        // Now apply any final touch-ups that have to be done on the main thread.
        DoMainThreadWork();

        // Signal to any scripts that were waiting for the load to finish
        // that they can start doing their thing now.
        if (OnGenerationCompleted != null) 
            OnGenerationCompleted.Invoke();

        // Signal that we can hide the loading animation.
        IsGenerationComplete = true;
    }
    
    // Define your worker methods down here...
}

Your LoadNewScene function would then look something like this, with two waits: one for loading the scene file itself, and a second wait for the generation.

private IEnumerator LoadNewScene() {

    GalaxyMap.PrepareToGenerate();
    AsyncOperation async = SceneManager.LoadSceneAsync("GalaxyMap", LoadSceneMode.Single);

    // Wait while the scene file is loaded.
    while (!async.isDone) {
        yield return null;
    }

    // Continue waiting while the generation is in progress.
    while (!GalaxyMap.IsGenerationComplete) {
        yield return null;
    }

    // Now hide the loading animation and show the generated scene.
}

If you had other scripts that were starting to do stuff in their own Awake or Start or Update/etc. that need to happen after generation finishes, you should make them subscribe to the OnGenerationCompleted event instead to control when those behaviours kick off.