SceneManager V2 - Scenes Reborn!

[Katerlad]

This is a general Feature Request that is asking for a Overhaul/redesign to the current Scene Manager.

This overhaul is based around adding the addition of a "NetworkScene" Class object that can hold a reference to the unity scene that it is attached to, as well as all of the current Network Settings of that Scene.

Will add to it over time and discussion :)

Network Scene Example

public class/struct NetworkScene
{

//Indicates whether the scene is global or not.
public bool IsGlobal { get; set; }

// List of clients that  have scene loaded
public List<NetworkConnection> ClientsLoaded { get; set; }

// List of clients that are observing this Scene, must have the scene loaded to observe.
public List<NetworkConnection> ClientsObserving { get; set;}

//Indicates what clients have this scene set as Active
public List<NetworkConnection> ActiveSceneClient { get; set; }

//Indicates whether this is the scene active on the server.
public bool IsActiveSceneServer { get; set; }

//Whether the scene has been activated on both the Clients and Server
//This is the Activation that brings the Scene Load from 90% to 100%
public bool IsLoadActivated { get; set; }

//The AsyncOperation associated to either the client or server
public AsyncOperation SceneAO { get; set; }

//The Unity Scene assigned to the NetworkScene
public Scene Scene { get; set; }

//List of NetworkObjects in the Scene
public List<NetworkObject> ManagedNetworkObjects { get; set; }





}

Potential New Features/Changes

Loading/Unloading Scenes

Gone are the days of GlobalScene loading and Connection Scene Loading. There is only loading Network Scenes.

New Scene Load/Unload Data

Here is an example of a new overhaul of the SceneLoadData();

SceneLoadData sld = new SceneLoadData()
{
    Clients = new NetworkConnection[](); //<= NEW this is where you specify what clients you want to load the scenes. 
    AllowSceneActivation = true, // <= New - Allows a closer API structure to unity, to control this here. 
    ReplaceScenes = ReplaceOption.None,
    Params = new LoadParams()
    {
        ServerParams = new object[0],
        ClientParams = new byte[0]
    },
    Options, // <= Remove and use the new "NetworkSceneSettings" that will be passed as a separate parameter into the LoadNetworkScenes Method.
};

New NetworkSceneSettings

NetworkSceneSettings = new NetworkSceneSettings() // <= NEW make NetworkSceneSetting
    {  
        SceneLookupData =  //<= NetworkSceneSettings should only use a path for loading new scenes.
        MovedNetworkObjects = new NetworkObject[0], // <= Moved allows you to pick Network Objects to move to each requested scene.
        IsGlobal = false, //<= NEW this is where you declare if a scene is global.
        AutomaticallyUnload = true,
        AllowStacking = false,
        MakeActiveScene = Server,Client,Both, //<= This allows you to talk about the context of the NetworkScene this setting is associated to.
        LocalPhysics = LocalPhysicsMode.None,
        ReloadScenes = false, //Obsolete, Comming Soon. <= This could be readded, and a feature to cache unloaded NetworkScenes could be stored, and if a request was to load this scene in the furture the server would reload it with all of its old settings and Network Objects.
        Addressables = false
    }

Loading New Network Scenes

Removing LoadGlobalScenes and LoadConnectionScenes for LoadNetworkScene(sld,networkScenes); and

SceneLoadData  sld = new SceneLoadData()
    {
        Clients = new NetworkConnection[] {conn1, conn2}
        ReplaceScenes = ReplaceOption.None
    }
NetworkSceneData[] nsds = 
    {
        // Connection Scene load example
        new NetworkSceneSettings()
        {
            SceneLookupData = new SceneLookupData(path1),
            IsGlobal = false,
            AutomaticallyUnload = false,
            MakeActiveScene = Client;
            AllowStacking = true,
        },
        // Global Scene Load Example
        new NetworkSceneSettings()
        {
             SceneLookupData = new SceneLookupData(path2),
            IsGlobal = true, <= Ignores Clients Param on the SLD and loads for all clients and follows global rules.
            MakeActiveScene = Server,
            AutomaticallyUnload = true,
            AllowStacking = true // <= Warning will appear when loading saying since this is marked as a Global Network Scene this will be ignored.
        }
    }

//  Loads new scenes only  
InstanceFinder.SceneManagerV2.LoadNetworkScene(sld,nsds);  

Loading Existing Network Scenes

public class SceneManagerV2

{

//List of all scenes managed and loaded by SceneManagerV2
public List<NetworkScene> ManagedScenes = new()

//List of all current global scenes managed by SceneManagerV2
public List<NetworkScene> GlobalScenes { get => ManagedScenes.Where(netScene => netScene.IsGlobal == true;)}

//List of all current Connection Scenes managed by SceneManagerV2
public List<NetworkScene> ConnectionScenes { get => ManagedScenes.Where(netScene => netScene.IsGlobal == false;)}

}

public void ExampleLoadExistingNetworkScenes()
{
    List<NetworkScene> sceneFilter = InstanceFinder.SceneManagerV2.ManagedScenes.Where( scene => scene.ScenePath = path);
    
    // Uses custom sld to define load, with existing scenes from filter.   
    InstanceFinder.SceneManager.V2.LoadNetworkScene(sld, sceneFilter);  
    
    // Uses default sld, with loading the scenes found from filter.
    InstanceFinder.SceneManagerV2.LoadNetworkScene(sceneFilter); 
}

Awaitable Scene Loads/Unloads

While normally loading scenes with SceneManager is asyncronous, they are not awaitable.
So make a LoadNetworkSceneAsync () that allows you to await for scene loads if you like that work flow better!
Many of this capability can be done through the events, but some people may enjoy an await system better.
Allowing both options would be the improvement to SceneManagerV2

//Both Load Network Scene Methods load asyncronously, but this one allows you to await it. 
// waitforclients allows you to wait for all clients that are connected at the time of this call, and any future clients that connect between this call and last client loaded. False will only wait for server to load. 
QueueLoadData qld = await InstanceFinder.SceneManagerV2.LoadNetworkSceneAsync(sld,Scenes,waitforclients) 

if (qld.AllowSceneActivation == false)
{
    // Allows you to do logic between scene load and Activate Scene with a different work flow than using a custom scene processor. 
    InstanceFinder.SceneManagerV2.ActivateScenes(qld.Scenes); 
}

[FirstGearGames]

Your ideas have thus far been fantastic, but this is a lot to take in and a huge change. I'm not sure when/if time will be found for this one.

[Katerlad]

But but, think of how beautiful it would be! Haha jkjk I understand it's balancing cost.

Your SceneManager is already one of the best ones if not the best one out of the competition, but these changes would make it simpler to understand for both beginners and advanced users, while also providing advanced users easier ways to customize their scene loading process.

Definitely a cost analysis, but it's only a matter of time before some competitions sneaks in and tackle a solution like this.