async void LoadList()
{
AssetList al = await Addressables.LoadAssetAsync <AssetList>(sceneList).Task;
//If you made an update to a scene, make sure that scene has been moved to a Remote Load group!
Addressables.LoadSceneAsync(al.assets[0]);
}
IEnumerator LoadScene(AssetReference addressableLevel)
{
LoginManager.LoadLevel();//switch to level load screen
yield return(null);
//Begin to load the Scene you specify
AsyncOperationHandle asyncAssetLoad = Addressables.LoadSceneAsync(addressableLevel, LoadSceneMode.Single);//.Completed += SceneLoadComplete;
//When the load is still in progress, output the Text and progress bar
while (!asyncAssetLoad.IsDone)
{
//Output the current progress
progressBar.value = asyncAssetLoad.PercentComplete;
// Check if the load has finished
if (asyncAssetLoad.PercentComplete >= 0.9f)
{
// hide the progress bar
progressBar.gameObject.SetActive(false);
//asyncAssetLoad.Completed += SceneLoadComplete;
}
//asyncOperation.allowSceneActivation = true;
yield return(null);
}
}
private IEnumerator InitState()
{
StateSceneAsyncOperationHandle = Addressables.LoadSceneAsync(gameSceneCatalogue.BoardScene, LoadSceneMode.Additive);
yield return(StateSceneAsyncOperationHandle);
signalBus.Fire <Match3Signals.CreateBoardSignal>();
}
//================ Basic
public static AsyncOperationHandle <SceneInstance> LoadSceneAsync(string pAddress, LoadSceneMode pMode, Action <float> pProgress = null, Action <SceneInstance> pOnCompleted = null)
{
var operation = Addressables.LoadSceneAsync(pAddress, pMode);
WaitLoadTask(operation, pProgress, pOnCompleted);
return(operation);
}
private void OnDownloadAR_scene(AsyncOperationHandle <IList <IResourceLocation> > obj)
{
AR_scene = new List <IResourceLocation>(obj.Result);
Debug.Log(AR_scene[0]);
downloadSize = Addressables.GetDownloadSizeAsync(AR_scene[0]);
Debug.Log(downloadSize.Result);
DownloadScene_Size1.text = downloadSize.Result.ToString();
DownloadScene_Size2.text = downloadSize.Result.ToString();
if (downloadSize.Result > 0)
{
// Delete old Bundle hahaha
//Caching.ClearCache();
Caching.ClearAllCachedVersions("remote_arscene_scenes_all");
StartCoroutine(LoadRoutine());
}
else
{
Debug.Log("There is no Update");
Addressables.LoadSceneAsync(AR_scene[0]);
}
}
public IEnumerator PreloadScene()
{
//Debug.Log($"Preloading {Scene}");
if (Application.CanStreamedLevelBeLoaded(Scene))
{
aoNormal = SceneManager.LoadSceneAsync(Scene, LoadSceneMode.Single);
aoNormal.allowSceneActivation = false;
yield return(new WaitUntil(() =>
{
//Debug.Log($"Normal progress {aoNormal.progress}");
return aoNormal.progress == 0.9f;
}));
}
else
{
#if HAS_AAS
//Debug.Log($"AAS");
var handle = Addressables.LoadSceneAsync(Scene, loadMode: LoadSceneMode.Single, activateOnLoad: false);
aoAAS = handle;
yield return(handle);
//Debug.Log($"COMPLETE");
aas = true;
#else
throw new Exception($"The specified scene {Scene} could not be be loaded.");
#endif
}
}
public ResourceHandle LoadSceneAsync <T>(string addressKey, Action <Scene> callback)
{
// @note:シーンのハンドルは保持しない
var handle = new ResourceHandle(GenerateHandleId(), addressKey, typeof(Scene));
handle.HandleScene = Addressables.LoadSceneAsync(addressKey);
handle.HandleScene.Completed += op =>
{
if (op.Status == AsyncOperationStatus.Succeeded)
{
#if UNITY_EDITOR
Fwk.DebugSystem.Log.DebugUseResourceLog.Instance.Append("key:" + addressKey);
#endif
callback(op.Result.Scene);
}
else
{
Debug.LogFormat("Status[{0}]: key => {1}", op.Status, handle.Key);
}
if (op.OperationException != null)
{
Debug.LogWarningFormat("LoadScene is null => {0}", op.OperationException.ToString());
}
};
return(handle);
}
IEnumerator LoadScene(string sceneName)
{
Debug.Log($"[Client] <b>Loading level</b> '<i>{sceneName}</i>'");
EventHub <StartedLoading> .Emit(new StartedLoading());
// Cleanup
currentReplicaPossess = ReplicaId.Invalid;
Client.replicaManager.Reset();
if (sceneHandle.IsValid())
{
yield return(Addressables.UnloadSceneAsync(sceneHandle));
}
// New map
#if !UNITY_EDITOR
sceneHandle = Addressables.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
sceneHandle.Completed += ctx => {
SendLoadSceneDone();
EventHub <EndedLoading> .Emit(new EndedLoading());
};
#else
SendLoadSceneDone();
EventHub <EndedLoading> .Emit(new EndedLoading());
#endif
}
private IEnumerator SceneChange(AssetReference scene)
{
bool transitionLoaded = _screenTransition != null;
if (transitionLoaded)
{
_screenTransition.FadeOut();
}
_loadOperation = Addressables.LoadSceneAsync(scene, LoadSceneMode.Single, activateOnLoad: false);
yield return(_loadOperation);
if (transitionLoaded)
{
yield return(new WaitUntil(() => _screenTransition.Faded));
}
yield return(_loadOperation.Result.ActivateAsync());
if (transitionLoaded)
{
_screenTransition.FadeIn();
yield return(new WaitUntil(() => !_screenTransition.Faded));
}
}
private IEnumerator LoadSceneRoutine(string sceneName, LoadSceneMode mode, Action <SceneInstance> onSuccess, Action <float> onChangeProgress, Action <string> onFail)
{
Debug.Log("LoadSceneRoutine start");
var loadSceneOperationHandle = Addressables.LoadSceneAsync(sceneName, mode, true);
var oldProgress = -1f;
while (loadSceneOperationHandle.IsValid() && !loadSceneOperationHandle.IsDone)
{
if (loadSceneOperationHandle.Status == AsyncOperationStatus.Failed)
{
Debug.LogError("Operation failed");
StopLoadScene();
onFail("Operation failed");
yield break;
}
if (loadSceneOperationHandle.OperationException != null)
{
Debug.LogError(loadSceneOperationHandle.OperationException);
StopLoadScene();
onFail.Invoke(loadSceneOperationHandle.OperationException.Message);
yield break;
}
if (oldProgress != loadSceneOperationHandle.PercentComplete)
{
oldProgress = loadSceneOperationHandle.PercentComplete;
onChangeProgress.Invoke(oldProgress);
}
yield return(null);
}
Debug.Log("LoadScene Complete!");
StopLoadScene();
onSuccess.Invoke(loadSceneOperationHandle.Result);
}
public static void LoadScene(IKeyEvaluator scene, Action callBack = null)
{
Addressables.LoadSceneAsync(scene).Completed += (loadComplete) =>
{
callBack?.Invoke();
};
}
/// <summary>
/// Load the specified addressable resource
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <param name="resourceLoadedCallback"></param>
public async Task <T> LoadResourceAsync <T>(string name)
{
//If we already loaded the resource
if (resources.ContainsKey(name + typeof(T).ToString()))
{
//Use it directly
return((T)resources[name]);
}
else
{
//Load it
if (typeof(T) == typeof(SceneInstance))
{
//If it is scene, load it to switch current scene
handles.Add(Addressables.LoadSceneAsync(name));
T result = default(T);
return(result);
}
else
{
var handle = Addressables.LoadAssetAsync <T>(name);
handles.Add(handle);
await handle;
var resource = handle.Result;
resources[name + typeof(T).ToString()] = resource;
return(resource);
}
}
}
public void LoadGameplayScene()
{
// 场景异步加载
// m_SceneAddressToLoad：场景名称
// 场景内所有的 Assets 都会被异步加载
Addressables.LoadSceneAsync(m_SceneAddressToLoad, UnityEngine.SceneManagement.LoadSceneMode.Single).Completed += OnSceneLoaded;
}
public void LoadScene(string tag)
{
Debug.Log("Addressables Procedure Started for Loading Scene: " + tag + "@" + Time.time);
Addressables.ClearDependencyCacheAsync(tag);
Addressables.InitializeAsync().Completed += delegate {
Debug.Log("Addressables.InitializeAsync.Completed:@" + Time.time);
Addressables.GetDownloadSizeAsync(tag).Completed += delegate(AsyncOperationHandle <long> obj)
{
Debug.Log("Addressables.GetDownloadSizeAsync.Completed:@" + Time.time);
float downloadSizeInMB = (float)obj.Result / 1024 / 1024;
Debug.Log("GetDownloadSizeAsync: " + obj.Result + " bytes, which is " + downloadSizeInMB + " MB");
if (size)
{
size.text += System.Environment.NewLine + "Size of download: " + downloadSizeInMB.ToString();
}
Addressables.DownloadDependenciesAsync(tag).Completed += delegate(AsyncOperationHandle opDownloadDependencies)
{
Debug.Log("Addressables.DownloadDependenciesAsync.Completed:" + opDownloadDependencies.Status + "@" + Time.time);
Addressables.LoadSceneAsync(tag).Completed += delegate(AsyncOperationHandle <SceneInstance> opLoadScene) {
Debug.Log("LoadSceneAsync.Completed: " + opLoadScene.Status + "@" + Time.time);
if (opLoadScene.Status == AsyncOperationStatus.Succeeded)
{
}
};
};
};
};
}
public static void LoadSceneAsync(string sceneName, Action <SceneInstance> callback)
{
Addressables.LoadSceneAsync(sceneName, LoadSceneMode.Single).Completed += (args) =>
{
callback?.Invoke(args.Result);
};
}
/// <summary>
/// Reset replication, instruct all clients to load the new scene, actually
/// load the new scene on the server and finally create a new GameMode instance.
/// </summary>
/// <param name="sceneName"></param>
public void LoadScene(string sceneName)
{
// Cleanup
if (gameMode != null)
{
gameMode.StartToLeaveMap();
}
IsLoadingScene = true;
++loadSceneGeneration;
numLoadScenePlayerAcks = 0;
loadSceneName = sceneName;
server.ReplicaManager.Reset();
if (sceneHandle.IsValid())
{
Addressables.UnloadSceneAsync(sceneHandle);
}
// Instruct clients
var bs = new BitStream();
bs.Write((byte)MessageId.LoadScene);
bs.Write(sceneName);
bs.Write(loadSceneGeneration);
server.NetworkInterface.BroadcastBitStream(bs, PacketReliability.ReliableSequenced);
// Disable ReplicaViews during level load
foreach (var connection in server.connections)
{
var replicaView = server.ReplicaManager.GetReplicaView(connection);
if (replicaView == null)
{
continue;
}
replicaView.IsLoadingLevel = true;
}
// Load new map
Debug.Log($"[Server] Loading level {sceneName}");
#if UNITY_EDITOR
if (SceneManager.GetSceneByName(sceneName).isLoaded)
{
SceneManager.UnloadScene(sceneName);
}
#endif
sceneHandle = Addressables.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
sceneHandle.Completed += ctx => {
IsLoadingScene = false;
gameMode = CreateGameModeForScene(sceneName);
Assert.IsNotNull(gameMode);
Debug.Log($"[Server] New GameMode <i>{gameMode}</i>");
};
}
private IEnumerator LoadScene(string name, string suffix, bool isAssetBundle, params string[] types)
{
#if AssetBundle
if (isAssetBundle)
{
#if !UNITY_EDITOR
string path = GetAssetPath(name, types);
AsyncOperationHandle <SceneInstance> handler = Addressables.LoadSceneAsync($"Assets/Bundles/{path}{suffix}");
yield return(handler);
#else
async = SceneManager.LoadSceneAsync(name);
async.allowSceneActivation = false;
yield return(async);
#endif
}
else
{
async = SceneManager.LoadSceneAsync(name);
async.allowSceneActivation = false;
yield return(async);
}
#else
async = SceneManager.LoadSceneAsync(name);
async.allowSceneActivation = false;
yield return(async);
#endif
}
public void LoadAdresseableScene(string sceneName, bool unloadLastScene)
{
if (unloadLastScene)
{
Addressables.UnloadSceneAsync(handle, true);
}
Addressables.LoadSceneAsync(sceneName, LoadSceneMode.Additive, true).Completed += AdresseableSceneLoadComplete;
}
public ETTask LoadSceneActive(string sceneName)
{
ETTaskCompletionSource tcs = new ETTaskCompletionSource();
var asset = Addressables.LoadSceneAsync(sceneName);
asset.Completed += op => { tcs.SetResult(); };
return(tcs.Task);
}
/// <summary>
/// Addressable 加载场景
/// </summary>
/// <param name="key"></param>
/// <param name="run"></param>
public void LoadSceneRun(string key, LoadObj <Scene> run = null)
{
Addressables.LoadSceneAsync(key).Completed += (obj) =>
{
run?.Invoke(obj.Result.Scene);
Addressables.Release(obj);
};
}
/// <summary>
/// <para>指定されたアドレスに紐づくシーンに遷移します</para>
/// </summary>
public AddressablesControllerHandle LoadSceneAsync
(
object address,
LoadSceneMode loadMode
)
{
var source = new TaskCompletionSource <AddressablesControllerResultCode>();
if (!m_isInitialized)
{
source.TrySetResult(AddressablesControllerResultCode.FAILURE_NOT_INITIALIZED);
return(new AddressablesControllerHandle(source.Task));
}
var isFailure = false;
var isNotExistKey = false;
void OnComplete(AsyncOperationHandle handle)
{
m_exceptionHandler -= ExceptionHandler;
if (isFailure)
{
var resultCode = isNotExistKey
? AddressablesControllerResultCode.FAILURE_KEY_NOT_EXIST
: AddressablesControllerResultCode.FAILURE_CANNOT_CONNECTION
;
source.TrySetResult(resultCode);
return;
}
if (handle.Status != AsyncOperationStatus.Succeeded)
{
source.TrySetResult(AddressablesControllerResultCode.FAILURE_UNKNOWN);
return;
}
source.TrySetResult(AddressablesControllerResultCode.SUCCESS);
}
void ExceptionHandler(Exception exception)
{
isFailure = true;
isNotExistKey = exception.Message.Contains(nameof(InvalidKeyException));
m_exceptionHandler -= ExceptionHandler;
}
m_exceptionHandler += ExceptionHandler;
var result = Addressables.LoadSceneAsync(address, loadMode);
result.Completed += handle => OnComplete(handle);
return(new AddressablesControllerHandle(result, source.Task));
}
/// <summary>
/// Loads a scene from an AssetReference
/// </summary>
/// <param name="reference"></param>
/// <param name="loadSceneMode"></param>
/// <param name="activateOnLoad"></param>
/// <param name="priority"></param>
/// <param name="progress"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async UniTask <Scene> LoadSceneFromReferenceAsync(AssetReference reference, LoadSceneMode loadSceneMode = LoadSceneMode.Single, bool activateOnLoad = true, int priority = 100, IProgress <float> progress = null, CancellationToken cancellationToken = default)
{
var asyncOperation = Addressables.LoadSceneAsync(reference, loadSceneMode, activateOnLoad, priority);
var sceneInstance = await GetAsyncOperationResultAsync(asyncOperation, progress, cancellationToken);
Logger.Log($"Loaded Scene: {sceneInstance.Scene.name}".ColoredLog(Colors.Pink));
return(sceneInstance.Scene);
}
public override void Init()
{
Addressables.LoadSceneAsync("Menu");
view.start.onClick.AddListener(ToStart);
view.setting.onClick.AddListener(Setting);
view.quit.onClick.AddListener(Quit);
Refresh();
}
public void Start()
{
if (Handle.IsValid())
{
throw new InvalidOperationException();
}
Handle = Addressables.LoadSceneAsync(_reference(), LoadSceneMode.Additive);
}
public void Load()
{
if (Loaded || _loading)
{
return;
}
_loading = true;
Addressables.LoadSceneAsync(ChunkName, LoadSceneMode.Additive).Completed += OnSceneLoaded;
}
public static void LoadSceneAdditive(string key, System.Action onComplete)
{
var handle = Addressables.LoadSceneAsync(key, UnityEngine.SceneManagement.LoadSceneMode.Additive);
handle.Completed += (scene) =>
{
onComplete();
cacheScene.Add(key, handle.Result);
};
}
// Start is called before the first frame update
public void Load(AssetReference scene)
{
Debug.Log("loading level");
if (!unloaded)
{
unloaded = true;
UnloadScene();
}
Addressables.LoadSceneAsync(scene, UnityEngine.SceneManagement.LoadSceneMode.Additive).Completed += SceneLoadCompleted;
}
// Start is called before the first frame update
private void Start()
{
JsDictionary = new Dictionary <string, string>();
Addressables.LoadAssetsAsync <TextAsset>(javaScriptLabelReference, js =>
{
JsDictionary.Add(js.name, js.text);
}).Completed += handle =>
{
Addressables.LoadSceneAsync("SampleScene");
};
}
public override void OnEvent(EventData photonEvent)
{
byte eventCode = photonEvent.Code;
if (eventCode != InitGameplayLoadingCode)
{
return;
}
Addressables.LoadSceneAsync("Gameplay").Completed += SceneLoadComplete;
}
public AsyncOperationHandle <SceneInstance> LoadSceneAsync(
AssetReferenceSceneAsset sceneReference,
LoadSceneMode loadMode,
Action <DiContainer> extraBindings,
LoadSceneRelationship containerMode,
Action <DiContainer> extraBindingsLate)
{
PrepareForLoadScene(loadMode, extraBindings, extraBindingsLate, containerMode);
return(Addressables.LoadSceneAsync(sceneReference, loadMode));
}
