public override void Resolve(object o)
{
var p = _func == null
? CoroutineExtensions.WaitUntil(_yieldInstruction)
: CoroutineExtensions.WaitUntil(_func);
p.ThenResolvePromise(_promise, o);
}
public static IPromise LoadWithoutActivating(string sceneName, LoadSceneMode mode = LoadSceneMode.Additive)
{
var asyncOp = SceneManager.LoadSceneAsync(sceneName, mode);
asyncOp.allowSceneActivation = false;
return(CoroutineExtensions.WaitUntil(() => asyncOp.progress >= 0.9f)
.Then(() => Promise.Resolved(asyncOp)));
}
public static IPromise LoadAssetPromise(this AssetBundle bundle, string assetName)
{
var p = Promise.Create();
var request = bundle.LoadAssetAsync(assetName);
CoroutineExtensions.WaitUntil(request)
.ThenDo(() => p.Resolve(request.asset));
return(p);
}
// --------- AssetBundle extension methods --------- //
public static IPromise LoadAllAssetsPromise(this AssetBundle bundle)
{
var p = Promise.Create();
var request = bundle.LoadAllAssetsAsync();
CoroutineExtensions.WaitUntil(request)
.ThenDo(() => p.Resolve(request.allAssets));
return(p);
}
private static void Init()
{
var obj = new GameObject("CoroutineExtensions")
{
hideFlags = HideFlags.HideInHierarchy
};
DontDestroyOnLoad(obj);
_instance = obj.AddComponent <CoroutineExtensions>();
}
public IPromise ThenTween(float time, Action <float> onUpdate, Easing.Functions easing = Easing.Functions.Linear, bool unscaled = false)
{
var p = Create();
if (CurrentState == EPromiseState.Resolved)
{
CoroutineExtensions.Tween(time, onUpdate, easing, unscaled).ThenResolvePromise(p, PromisedObject);
}
else
{
_resolutions.Add(TweenResolution.Create(time, onUpdate, easing, unscaled, p));
}
return(p);
}
public IPromise ThenWaitUntil(Func <bool> evaluator)
{
var p = Create();
if (CurrentState == EPromiseState.Resolved)
{
CoroutineExtensions.WaitUntil(evaluator).ThenResolvePromise(p, PromisedObject);
}
else
{
_resolutions.Add(WaitUntilResolution.Create(evaluator, p));
}
return(p);
}
public IPromise ThenWaitUntil(YieldInstruction yieldInstruction)
{
var p = Create();
if (CurrentState == EPromiseState.Resolved)
{
CoroutineExtensions.WaitUntil(yieldInstruction).ThenResolvePromise(p, PromisedObject);
}
else
{
_resolutions.Add(WaitUntilResolution.Create(yieldInstruction, p));
}
return(p);
}
public IPromise ThenWaitForSeconds(float time, bool unscaled = false)
{
var p = Create();
if (CurrentState == EPromiseState.Resolved)
{
CoroutineExtensions.WaitForSeconds(time, unscaled).ThenResolvePromise(p, PromisedObject);
}
else
{
_resolutions.Add(WaitForSecondsResolution.Create(time, unscaled, p));
}
return(p);
}
// ReSharper disable once UnusedMember.Local
private static IPromise LoadFromFileAsync(string bundlePath)
{
if (!LoadedBundles.ContainsKey(bundlePath))
{
LoadedBundles.Add(bundlePath, Promise.Create());
var path = Path.Combine(Application.streamingAssetsPath, bundlePath).Replace("\\", "/");
var request = AssetBundle.LoadFromFileAsync(path);
CoroutineExtensions.WaitUntil(request)
.ThenDo(() =>
{
Debug.Log($"Loaded AssetBundle at: {path}");
LoadedBundles[bundlePath].Resolve(request.assetBundle);
});
}
return(LoadedBundles[bundlePath]);
}
public static IPromise LoadAsync(string path)
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
var promise = Promise.Create();
promise.Resolve(Resources.Load(path));
return(promise);
}
#endif
var p = Promise.Create();
var resourceRequest = Resources.LoadAsync(path);
CoroutineExtensions.WaitUntil(resourceRequest)
.ThenLog("Loaded resource at: " + path)
.ThenDo(() => p.Resolve(resourceRequest.asset));
return(p);
}
public static IPromise LoadSceneAsync(string sceneName, LoadSceneMode mode = LoadSceneMode.Additive)
{
return(CoroutineExtensions.WaitUntil(SceneManager.LoadSceneAsync(sceneName, mode))
.Then(() => WaitUntilSceneIsLoaded(SceneManager.GetSceneByName(sceneName))));
}
public override void Resolve(object o)
{
CoroutineExtensions.Tween(_time, _from, _to, _onUpdate, _easing, _unscaled).ThenResolvePromise(_promise, o);
}
public static IPromise LoadSceneAsync(int sceneBuildIndex, LoadSceneMode mode = LoadSceneMode.Additive)
{
return(CoroutineExtensions.WaitUntil(SceneManager.LoadSceneAsync(sceneBuildIndex, mode))
.Then(() => WaitUntilSceneIsLoaded(SceneManager.GetSceneByBuildIndex(sceneBuildIndex))));
}
public override void Resolve(object o)
{
CoroutineExtensions.WaitForSeconds(_time, _unscaled).ThenResolvePromise(_promise, o);
}
public static IPromise UnloadSceneAsync(Scene scene)
{
return(CoroutineExtensions.WaitUntil(SceneManager.UnloadSceneAsync(scene)));
}
public static IPromise UnloadSceneAsync(int sceneBuildIndex)
{
return(CoroutineExtensions.WaitUntil(SceneManager.UnloadSceneAsync(sceneBuildIndex)));
}
private static IPromise WaitUntilSceneIsLoaded(Scene scene)
{
return(CoroutineExtensions.WaitUntil(() => scene.isLoaded)
.Then(() => Promise.Resolved(scene)));
}
