protected override Task <Scene> OnLoadAsync(string id, ISceneLoadParameters parameters, IContext context)
{
var provider = context.Get <IProvider <string, ISceneInfo> >();
var info = provider.Get <TInfo>(id);
return(OnLoadAsync(id, info, (TLoadParameters)parameters, context));
}
public async Task <Scene> LoadAsync(string id, ISceneLoadParameters parameters)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(id));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
LogSceneLoad(id, parameters, true);
Loading?.Invoke(id, parameters);
Scene scene = await OnLoadAsync(id, parameters);
SceneInstance instance = OnAddScene(id, scene, parameters);
Instances.Add(scene, instance);
Loaded?.Invoke(id, scene, parameters);
LogSceneLoaded(id, scene, parameters, true);
return(scene);
}
private static void LogSceneLoaded(string id, ISceneInfo info, ISceneLoadParameters parameters, Scene scene, bool isAsync = false)
{
Log.Debug("Manager Scene Loader loaded", new
{
id,
info = new
{
info.LoaderId,
info.Address
},
parameters = new
{
parameters.AddMode,
parameters.PhysicsMode,
parameters.AllowActivation
},
scene = new
{
scene.handle,
scene.name,
scene.path,
scene.buildIndex,
scene.rootCount,
scene.isSubScene
},
isAsync
});
}
protected virtual Scene OnLoad(string id, ISceneLoadParameters parameters)
{
ISceneLoader loader = this.GetLoaderByScene(id);
Scene scene = loader.Load(id, parameters, Context);
return(scene);
}
protected virtual Task <Scene> OnLoadAsync(string id, ISceneLoadParameters parameters)
{
ISceneLoader loader = this.GetLoaderByScene(id);
Task <Scene> task = loader.LoadAsync(id, parameters, Context);
return(task);
}
protected virtual SceneInstance OnAddScene(string id, Scene scene, ISceneLoadParameters parameters)
{
if (Description.RegisterApplicationForScenes && ProviderInstance.TryGet(out IProvider <Scene, IApplication> provider) && !provider.Entries.ContainsKey(scene))
{
provider.Add(scene, Application);
}
return(new SceneInstance(scene, id));
}
private static void LogSceneLoad(string id, ISceneLoadParameters parameters, bool isAsync = false)
{
Log.Debug("Scene loading", new
{
id,
parameters = new
{
parameters.AddMode,
parameters.PhysicsMode,
parameters.AllowActivation
},
isAsync
});
}
public Task <Scene> LoadAsync(string id, ISceneLoadParameters parameters, IContext context)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(id));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(OnLoadAsync(id, parameters, context));
}
protected override Scene OnLoad(string id, ISceneInfo info, ISceneLoadParameters parameters, IContext context)
{
LogSceneLoading(id, info, parameters);
var options = new LoadSceneParameters(parameters.AddMode, parameters.PhysicsMode);
Scene scene = SceneManager.LoadScene(info.Address, options);
if (RegisterApplication)
{
OnRegisterApplication(scene, context);
}
LogSceneLoaded(id, info, parameters, scene);
return(scene);
}
private static void LogSceneLoading(string id, ISceneInfo info, ISceneLoadParameters parameters, bool isAsync = false)
{
Log.Debug("Manager Scene Loader loading", new
{
id,
info = new
{
info.LoaderId,
info.Address
},
parameters = new
{
parameters.AddMode,
parameters.PhysicsMode,
parameters.AllowActivation
},
isAsync
});
}
private static void LogSceneLoaded(string id, Scene scene, ISceneLoadParameters parameters, bool isAsync = false)
{
Log.Debug("Scene loaded", new
{
id,
scene = new
{
scene.handle,
scene.name,
scene.path,
scene.buildIndex,
scene.rootCount,
scene.isSubScene
},
parameters = new
{
parameters.AddMode,
parameters.PhysicsMode,
parameters.AllowActivation
},
isAsync
});
}
protected SceneLoader(ISceneLoadParameters defaultLoadParameters, ISceneUnloadParameters defaultUnloadParameters) : base(defaultLoadParameters, defaultUnloadParameters)
{
}
public static bool TryGetDefaultLoadParametersByScene(this ISceneModule sceneModule, string id, out ISceneLoadParameters parameters)
{
if (TryGetLoaderByScene(sceneModule, id, out ISceneLoader loader))
{
parameters = loader.DefaultLoadParameters;
return(true);
}
parameters = null;
return(false);
}
public static Task <Scene> LoadAsync(this ISceneModule sceneModule, string id)
{
ISceneLoadParameters parameters = GetDefaultLoadParametersByScene(sceneModule, id);
return(sceneModule.LoadAsync(id, parameters));
}
protected SceneLoaderBase(ISceneLoadParameters defaultLoadParameters, ISceneUnloadParameters defaultUnloadParameters)
{
DefaultLoadParameters = defaultLoadParameters ?? throw new ArgumentNullException(nameof(defaultLoadParameters));
DefaultUnloadParameters = defaultUnloadParameters ?? throw new ArgumentNullException(nameof(defaultUnloadParameters));
}
protected override async Task <Scene> OnLoadAsync(string id, ISceneInfo info, ISceneLoadParameters parameters, IContext context)
{
LogSceneLoading(id, info, parameters, true);
var provider = ProviderInstance.Get <IProvider <Scene, AsyncOperation> >();
var options = new LoadSceneParameters(parameters.AddMode, parameters.PhysicsMode);
AsyncOperation operation = SceneManager.LoadSceneAsync(info.Address, options);
Scene scene = SceneManager.GetSceneAt(SceneManager.sceneCount - 1);
if (RegisterApplication)
{
OnRegisterApplication(scene, context);
}
operation.allowSceneActivation = parameters.AllowActivation;
provider.Add(scene, operation);
if (operation.allowSceneActivation)
{
while (!operation.isDone)
{
await Task.Yield();
}
provider.Remove(scene);
}
else
{
while (operation.progress < 0.9F)
{
await Task.Yield();
}
}
LogSceneLoaded(id, info, parameters, scene, true);
return(scene);
}
public ManagerSceneLoader(ISceneLoadParameters defaultLoadParameters, ISceneUnloadParameters defaultUnloadParameters) : base(defaultLoadParameters, defaultUnloadParameters)
{
}
protected abstract Scene OnLoad(string id, ISceneLoadParameters parameters, IContext context);
protected abstract Task <Scene> OnLoadAsync(string id, ISceneLoadParameters parameters, IContext context);
