More support for scenes already loaded

[Nuwn]

Is your feature request related to a problem? Please describe.
I am fully aware that I do not fully understand how this package work. And I have a hard time understanding why this is how NGO is designed.
When writing this it's for 1.2.0.
The frustration I have is that scenes reload when connected, I'm not 100% sure if it does it on the server side, but it does on the client side.

Describe the solution you'd like
A change in how it's handled. Scenes handled by the built-in scene manager are to be tracked and handled. but scenes not loading with netcode are to be ignored. this would in my case allow me to make use of various loading scenes, or scenes for the client that doesn't need to be for networking. now, this is not a big issue when the game itself started, but when the scene is synced, these are reloaded? and may break things, loading scenes rather than DDOL is not a thing atm.

Describe alternatives you've considered
Hard to say as I'm still quite new to NGO, but I would maybe look at changing the idea itself of what happens when connected.
Sure everything can be worked around, but I like packages that have high flexibility for developer's use cases. and that's my end goal I would say. Perhaps you guys are working on improvements that will satisfy all this.

Additional context
I'll link to the forum post I made, I wait and see if this gets any feedback before I dig into more feature requests.
Unity forum

[NoelStephensUnity]

@Nuwn
Hello and thank you for using NGO!
I think you might be loading scenes in LoadSceneMode.Single which is considered a "full scene transition" (i.e. everything gets destroyed and a new scene and assets are loaded). You might want to try additively loading scenes (LoadSceneMode.Additive) as that allows you to load and unload individual scenes without impacting the rest of the scenes loaded.

You can control which scenes are synchronized on the client side by using server side scene validation.

If you want a good starting point template project where it already has a scene loading framework in place you might use this project I put together (MIT License/Free to use as you like). The repository's readme basically is a documentation walkthrough of the components included in the project and could prove to be useful or at least provide you with some additional insights in how you can use the NetworkSceneManager (as well it has some additional netcode aware UI components).

Let me know if any of this helps you?

Cheers,

Noel

[Nuwn]

Hi, thank you for taking the time to answer.

My issue is with additive loading, especially this part written in the project you sent.

"Additive: This is when you use LoadSceneMode.Additive mode to load a scene.
Loading a scene additively has no impact on any scenes currently loaded."

When I connect as a client, StartClient(), it for some reason reloads every open scene, meaning it will trigger ondestroy on all scenes currently open. This has a negative effect if you hold a reference to an object if those scenes.
And my post aimed to ask to change this behavior.

One clear example of this would be if you have a loading Scene, with a canvas that fades out before connecting. and then fade in when done. Now the results become double fade out, and you lose reference to the canvas to fade it in again.
there are a lot of benefits to not having everything in DontDestroyOnLoad which is what my post is hoping to shine a light on.

I was hoping that this behavior could be changed, and my suggestion was to not reload every scene but instead keep track of which scenes were loaded using netcode scene manager and those that are not.

There are some unwanted experiences in additive loading as well but I figured I keep one topic per post.

Thank you!

[NoelStephensUnity]

Ahh, I think I understand.
With integrated scene management the server always synchronizes clients with the scenes loaded on the server side.
If you have scenes that do not require the server to synchronize with clients then you should use server side scene validation.
However, if you are "scene switching" (i.e. LoadSceneMode.Single) then this is actually the default behavior of UnityEngine.SceneManagement.SceneManager when loading a scene in LoadSceneMode.Single:

Closes all current loaded Scenes and loads a Scene.

Really, loading a scene in "Single" mode was originally the only option and as such the DDOL (DontDestroyOnLoad) scene provided a way to "preserve GameObjects that were instantiated by the scenes already loaded".

Additive scene loading was a better solution to this approach as it allowed users to determine when they wanted a scene to load or unload.

So, in your example, if you used additive scene loading then:
The overview:

• The server-side would implement server side scene validation](https://docs-multiplayer.unity3d.com/netcode/current/basics/scenemanagement/using-networkscenemanager#scene-validation) and have a list of scenes it would not try to synchronize with late joining clients (i.e. a client joins during some transition between areas).
• Both the server and clients would use SceneManager to locally load the transition scene additively.

The sequence

• You reach a point where you want to load a new "primary" scene and potentially unload the current one.
• A scene event transition notification occurs (see below for details)
• The server and clients load (locally) the scene that has the UI for transitioning (or it is already loaded)
  • If already loaded, you would just enable the UI overlay on both the server/host and client(s)
  • If not already loaded, then both the server/host and client(s) would load (locally) the scene containing the scene transition UI additively.
    • The server would already have a list of scenes (you would write this code) that it would check when the scene validation delegate handler callback was invoked, if it was a transition scene then the delegate handler callback would return false (i.e. don't try to synchronize this scene)
• The server would begin a NetworkSceneManager SceneEventType.Load additively
  • Clients would automatically begin to load the new scene on their side.
  • Upon the server receiving the SceneEventType.LoadEventCompleted (i.e. all connected clients loaded the scene) a scene event transition notification complete event occurs (see below for details).

Scene Transition Event Notification Trigger
There are several ways to do this, but here two possibilities:

• Possibility 1: The server sends and RPC so clients know to either load the scene with the transition UI or if already loaded (additively) would enable/make visible the scene transition UI.
• Possibility 2: Both the server and client(s) would subscribe to NetworkSceneManager.OnSceneEvent and both sides would have a list of scenes that would trigger either the loading of the scene containing the transitioning UI or if already loaded would make that UI visible.

Using the additive scene loading approach, the issue you are running into becomes less problematic to solve for.

Regarding NGO supporting the NetworkSceneManager tracking the scenes and keeping them loaded when loading a scene in LoadSceneMode.Single, technically there isn't a way to do this with Unity Engine and would require all of the scenes to be reloaded or the GameObjects in the already loaded scene migrated into the DDOL.

My recommendation would be to use additive scene loading in a similar way that the [repository link I provided above] (https://github.com/NoelStephensUnity/Netcode-For-GameObjects-BootStrap-Pattern) does.

Perhaps you could explain the issues you are running into using this approach and I could assist you with that?

[Nuwn]

Just very hard to get into 😅

Been trying to get validation to work today but I cannot make it work with our workflow.

The behavior I witnessed in the client is strange.

first scene 0 is marked as an additive but the next scene becomes single, which I cannot for the life of me figure out why.

I will clarify we only do additive by default.
We always have 1 base scene which should not be needed to be synced as it should always be there.
then we load all and unload additive only.

As it is hard to jump into others' code.
I'm trying to follow the example project you sent me, should I assume you load scenes on the client side yourself, thus blocking the automatic scene loading from netcode?
I cannot see that the loading itself is serverside only?

I would prefer if I could handle the scene loading manually and then message the server to sync, but would like to use what netcode has.

[NoelStephensUnity]

Yeah... now that I am looking through the code it could be complex to follow to some degree.
Really it was meant to provide the framework of handling the loading and unloading itself and all a user would have to do is create SceneEntries and add them to a SceneLoader. The general idea was to migrate the logic up to the UI so you wouldn't need to write as much scene loading code and could focus more on just creating more SceneEntry assets and SceneLoaders at various locations within your project's scene loading and unloading "logic flow".

But that might have been a bad direction I sent you in...as the script itself is a little involved.

I put together a quick (much simpler) project that should provide you with the foundational concepts for additive scene loading and scene validation. It is a much simpler light weight project, and it should provide you with (I think) what you need to move forward with your project.

AdditiveLoadingAndValidation.zip

What you will be most interested in, once you make a build, is to start a host and then just check all of the boxes (to the right).

Then connect a client and note that the client does not load the "Server Side Only" scene (green ball).

From that point you can uncheck or check any of the toggles that load or unload their assigned scenes. The AdditiveScene1 and AdditiveScene2 scenes will get synchronized on the client side (i.e. mirror the server-host), while the server side only scene will only load and unload on the server side.

The scripts I put together are a "quick and dirty" implementation (i.e. I might have missed some of the functionality of scene validation). Either case, here is a brief description of the more pertinent scripts:

• SceneValidator: This is what handles validation of a scene and whether the NetworkSceneManager should synchronize a client with a scene being loaded or not (and what assures a late joining client is not synchronized with SceneEntries marked to not synchronize with clients).
• SceneEntry: This is basically a quick way to handle loading and unloading a scene additively as well as an easier way to have an "Object Asset" that represents a scene (it is a ScriptableObject). This determines "how the scene will be loaded". It also has a "SynchronizeWithClients" property that when un-checked will assure a client is not synchronized with that scene (i.e. the server side only SceneEntry has that un-checked).
• AdditiveSceneLoader: This is the component on the Toggle switches that initiates the loading or unloading of a scene.
• BootstrapSceneLoader: This has a property called "FirstSceneToLoad" that is a SceneEntry and basically handles loading that first scene in single mode. It also will automatically load itself from within the editor no matter what scene you have open.

Anyway, let me know if this helps with the issues you have been having with additive scene loading and scene validation.
😸

[Nuwn]

Thank you for taking the time to help and create a sample project!
It gave me ideas.

Going over all the code I have my suspicion as to what might be the culprit. I'll update you when I tested it out!

I don't think the other project was a bad one, it worked well and was small, it's just that it's sometimes challanging to jump into others code. Like i've been trying to scan through NetworkManager, ...scene, ...sync scripts for many days and I barely get any wiser haha. One reason why I haven't sent code as examples, it would not help much since it's way different.

But i'll get back to you when i've tested or made a workaround,
Thank you! Have a nice weekend!

[Nuwn]

So after a lot of testing and trying to work around things I came to these rules.

When the client syncs the scenes, at least on the first connection, the active scene will always, regardless of how the server loads it, load the active scene in single mode.
Changing the active scene before all players are connected will break their load. not yet sure how it is after, but I would assume one needs to change back the active scene to the base scene before loading. this will be an issue for late-joining players as mentioned.

This is what threw me off, as I am used to loading scenes and then setting the "gameplay/instantiate holding" scene as the active one, but this resulted in the server deleting all scenes before it, which caused a lot of issues.

You might have mentioned this rule about the active scene in some way and I just missed it. 🤔

This is what makes the "loading scene" not work properly if animated, as it is destroyed by the single mode loaded scene on startup. If the client could "hijack" the loading process and insert a scene in between that would kinda work I assume.
But this is not a thing as unity cant load scenes in parallel, so attempting to do this might break things?

Will clarify we open and close loading screens in between loads not to keep them in memory. so syncing is not a thing we want on those.

The main reason I use an active scene is to easily clean the game when loading a new level, or in our case, since it's additive, keep it for a level change without having to reload for example all player objects. or to "preload" the next part of the game. many benefits. A workaround for this would be to automove all objects, unless they are designed to be destroyed like bullets. not a pretty solution but it's a way.

Possibility 2: Both the server and client(s) would subscribe to NetworkSceneManager.OnSceneEvent and both sides would have a list of scenes that would trigger either the loading of the scene containing the transitioning UI or if already loaded would make that UI visible.
I'm not sure what you mean by this, to be honest, Are you saying that the server should keep the loading scene loaded and synced? and when the client notice a new load, operate on it?

I do wish there was a way to force additive on all scenes. but maybe that would break things in netcode?
If it doesn't say it anywhere, I might have missed it fully, that you have to have a base active scene, then it could be a thing to clarify. maybe this was not the intended behavior, netcode being so young.

To conclude I guess, workarounds are there to fit our needs, not the prettiest, but it works.

That's my findings. Would be interested to hear your take on this :)

[NoelStephensUnity]

I need to digest some of the above a bit more, but you might find this useful:
You can migrate GameObjects into any scene that you want:
SceneManager.MoveGameObjectToScene

The currently active scene just happens to be the "default scene" that something is instantiated within but there is no requirement to keep GameObjects in the Active scene. Using additive scene loading you always will have to have one scene be the "active scene", but it doesn't require you to load it in LoadSceneMode.Single (the example I provided the bootstrap loader loads the scene additively, sets it as the active scene, and then unloads the bootstrap scene).

The "possibility 2" is was one (of many) ways to handle the synchronization of loading a transition scene.

You can force additive loading on all scenes by loading them all additively (i.e. LoadSceneMode.Additive).

[Nuwn]

I never load any as single, but the client does, no matter what scene I set as active becomes a single-mode loaded scene.

And that's the case in your project as well.

If I keep my base scene active at all times, I get all synced.

However, if I put the next scene as active on the server. the base scene gets removed because the playground scene is loaded as a single.

More proof if I add more scenes.

and proof I load all additively, since you for some reason keep assuming I load things in single mode, I might be communicating badly?

[NoelStephensUnity]

Ahhh, I think I better understand the issue.
Let me try doing this on my end and see if I can replicate the issue.

[NoelStephensUnity]

Ok, I replicated the issue on my end and realized that you need to set the NetworkSceneManager.SetClientSynchronizationMode to LoadSceneMode.Additive in order to avoid the issue you are experiencing. Fortunately/Unfortunately I found a small bug in how the in-scene placed NetworkObjects get synchronized when switching the active scene the way you described above.

So, I have a branch with the fix (basically it just doesn't clear a temporary in-scene placed NetworkObject list if the currently active scene was loaded additively) which appears to resolve the issue... but I will need to write some integration tests before I can make that a PR to be in the next update of NGO.

Soooo... with that said, I went ahead and updated the sample project I provided earlier to automatically point to the branch with the fix (if you want to make your project use the same branch look at the Packages\Manifest.json file in the zip file I am providing below and replace your project's com.unity.netcode.gameobjects entry with the one in the AdditiveSceneLoading sample).

The updated AdditveSceneLoading Sample:
AdditiveLoadingAndValidation-2.zip

The updates include a new toggle switch (server-host side only) that become active when you load one of the two example additive scenes. When checked that scene will become active. If you uncheck it then the default NGOBootstrap becomes the active scene again. You can join a client in at any point and it should mirror what is on the host side.

Currently, NGO does not automatically synchronize when the host changes the currently active scene so I also added this functionality via ClientRpc so when you connect a client if you change the currently active scene it will be reflected on the Client side as well.

I do have a !!! Warning !!! to convey about switching the currently active scene around a bunch:
You need to be aware that when you spawn something it will get instantiated in the currently active scene. So if you spawn several NetworkObjects into an additively loaded scene (Scene-A), then change the active scene (Scene-B), and then spawn more NetworkObjects you will have NetworkObjects in both additively loaded scenes (Scene-A & Scene-B). If you plan on unloading one of the additively loaded scenes (say Scene-A) but want your NetworkObjects to persist you need to migrate the NetworkObjects (from Scene-A) into one of the currently loaded scenes (i.e. Scene-B) before unloading it.

Anyway, while I work up some tests for the minor fix take a look at the changes to the script files in the updated AdtiveLoadingAndValidation-2 sample, build it, and try it out for yourself.

• NetworkManagerHelper: Note that when you start the host it sets the client synchronization mode to additive.
• SetSceneAsActive: A new script file that handles synchronizing newly joining clients to the current active scene as well as handles notifying already connected clients when the currently active scene changes.

Let me know if this sample is more of what you were expecting and if the approach works for your project's goals.

Cheers,

Noel