public static SceneAssetRequest LoadSceneAsync(string path, bool additive, LoadedCallback loadedCallback = null)
{
if (string.IsNullOrEmpty(path))
{
GameLog.LogError("invalid path");
return(null);
}
path = GetExistPath(path);
var asset = new SceneAssetRequestAsync(path, additive);
if (!additive)
{
if (_runningScene != null)
{
_runningScene.Release();;
_runningScene = null;
}
_runningScene = asset;
}
if (loadedCallback != null)
{
asset.completed += loadedCallback;
}
asset.Load();
asset.Retain();
_scenes.Add(asset);
GameLog.Log(string.Format("LoadScene:{0}", path));
return(asset);
}
/// <summary>
/// 场景包加载完真正异步加载场景
/// </summary>
/// <param name="name"></param>
/// <param name="onLoaded"></param>
private void __LoadScene(string name, LoadedCallback onLoaded, bool async)
{
LevelLoader sLoader = LoaderPool.Instance.GetLoader <LevelLoader> ();
sLoader.Init(name, onLoaded, async);
StartLoad(sLoader, async);
}
internal virtual bool Update()
{
if (checkRequires)
{
UpdateRequires();
}
if (!isDone)
{
return(true);
}
if (completed == null)
{
return(false);
}
try
{
completed.Invoke(this);
}
catch (Exception ex)
{
GameLog.LogException(ex);
}
completed = null;
return(false);
}
protected void Complete()
{
if (completed != null)
{
completed(this);
completed = null;
}
}
public void Start(IUILoader uiLoader, LoadedCallback callback)
{
mActive = true;
visible = true;
mUILoader = uiLoader;
mOnLoadedCallback = callback;
mUILoader.LoadPopup(name, mOnLoaded);
}
private void OnLoaded(GameObject go)
{
if (!mActive)
{
mUILoader.UnloadInstance(go);
return;
}
gameObject = go;
RectTransform rectTrans = go.transform as RectTransform;
rectTrans.SetParent(popup_root, false);
rectTrans.offsetMin = Vector2.zero;
rectTrans.offsetMax = Vector2.zero;
rectTrans.localRotation = Quaternion.identity;
rectTrans.localScale = Vector3.one;
bool overlay = false;
mBehaviours.Clear();
go.GetComponents <MonoBehaviour>(mBehaviours);
bool paraSet = false;
for (int i = 0, imax = mBehaviours.Count; i < imax; i++)
{
MonoBehaviour behaviour = mBehaviours[i];
IUIParameterHandler handler = behaviour as IUIParameterHandler;
if (handler != null)
{
try { handler.SetParameter(param); } catch (System.Exception e) { Debug.LogError(e); }
paraSet = true;
}
IPopupOverlay popupOverlay = behaviour as IPopupOverlay;
if (popupOverlay != null && popupOverlay.Overlay)
{
overlay = true;
}
}
if (param != null && !paraSet)
{
Debug.LogErrorFormat(go, "[UIManager] No parameter handler found for '{0]' !", name);
}
if (mFocusState == 1)
{
for (int i = 0, imax = mBehaviours.Count; i < imax; i++)
{
IUIFocusHandler handler = mBehaviours[i] as IUIFocusHandler;
if (handler != null)
{
try { handler.OnFocus(); } catch (System.Exception e) { Debug.LogException(e); }
}
}
mFocusState = 2;
}
go.SetActive(visible);
LoadedCallback callback = mOnLoadedCallback;
mOnLoadedCallback = null;
callback(this, overlay);
}
public static AssetRequest LoadModel(string path, LoadedCallback loadedCallback = null)
{
Type type = typeof(GameObject);
stringBuilder.Clear();
stringBuilder.Append(ModelPathPrefix);
stringBuilder.Append(path);
return(LoadAssetAsync(stringBuilder.ToString(), type, loadedCallback));
}
public void LoadScene(string name, LoadedCallback onLoaded, bool async, bool enter = true)
{
if (string.IsNullOrEmpty(name))
{
Util.LogWarning("资源路径不能为空---");
return;
}
string sceneName = name.Substring(name.LastIndexOf("/") + 1);
if (AppConst.UseAssetBundle)
{
string abPath = "Scenes/" + sceneName;
LoadAssetBundle(abPath, delegate(object data){
if (data == null)
{
Util.LogError("Load Scene Bundle Fail, name: " + sceneName);
if (onLoaded != null)
{
onLoaded(data);
}
return;
}
if (enter)
{
__LoadScene(sceneName, onLoaded, async);
}
else
{
string abName = FileHelper.CheckBundleName(abPath);
if (!m_handLoad.Contains(abName))
{
m_handLoad.Add(abName);
}
if (onLoaded != null)
{
onLoaded(data);
}
}
}, async);
}
else
{
if (enter)
{
__LoadScene(sceneName, onLoaded, async);
}
else
{
if (onLoaded != null)
{
onLoaded(null);
}
}
}
}
public static AssetRequest LoadAssetAsync(string path, Type type, LoadedCallback loadedCallback = null)
{
AssetRequest assetRequest = LoadAsset(path, type, true);
// todo 这个loadedCallback 是我自己加的，源码里是怎么实现异步加载的
if (loadedCallback != null)
{
assetRequest.completed += loadedCallback;
}
return(assetRequest);
}
public static AssetRequest LoadUI(string path, LoadedCallback loadedCallback = null)
{
Type type = typeof(GameObject);
string suffix = GetSuffixOfAsset(type);
stringBuilder.Clear();
stringBuilder.Append(UIPathPrefix);
stringBuilder.Append(path);
stringBuilder.Append(".");
stringBuilder.Append(suffix);
return(LoadAssetAsync(stringBuilder.ToString(), type, loadedCallback));
}
public void LoadPrefab(string strPath, LoadedCallback onLoaded)
{
if (string.IsNullOrEmpty(strPath))
{
Util.LogWarning("资源路径不能为空---");
return;
}
string[] items = strPath.Split('/');
string name = items[items.Length - 1];
LoadAssetFromBundle(strPath, name, typeof(GameObject), onLoaded, true);
}
/// <summary>
/// 主动加载时有加载完回调
/// </summary>
/// <param name="callback"></param>
public void AddHandleCallBack(LoadedCallback callback)
{
if (callback != null)
{
if (m_onRefLoaded == null)
{
m_onRefLoaded = callback;
}
else
{
m_onRefLoaded += callback;
}
}
}
/**
* If the db is loaded, call the callback immediately, otherwise, register the callback
*/
public static void loadOrCallback(LoadedCallback loadCallback)
{
lock (isloadedCallback)
{
if (db != null)
{
loadCallback.Invoke(db);
}
else
{
isloadedCallback += loadCallback;
}
}
}
public override void Reset()
{
base.Reset();
m_stateCurrent = 0;
m_stageCount = 1;
m_parents.Clear();
m_childs.Clear();
allChildsPassed = false;
m_onRefLoaded = null;
m_abRequest = null;
if (m_wwwRequest != null)
{
m_wwwRequest.Dispose();
m_wwwRequest = null;
}
}
public void LoadAsset(string path, LoadedCallback onLoaded, System.Type type = null, bool async = true, AssetType assetType = AssetType.GameObject)
{
string ext = SenLib.Helper.GetExtOfAsset(assetType);
string fullPath = string.Format("Assets/{0}{1}{2}", AppConst.ResDataDir, path, ext);
if (!FileHelper.CheckFileExist(fullPath))
{
SG.LogMgr.UnityError(string.Format("Load Asset, Path:[ {0} ] not exist! ", fullPath));
if (onLoaded != null)
{
onLoaded(null);
}
return;
}
AssetLoader aLoader = LoaderPool.Instance.GetLoader <AssetLoader> ();
aLoader.Init(fullPath, type, onLoaded, async);
StartLoad(aLoader, async);
}
public BundleLoader.BundleState LoadAssetBundle(string path, LoadedCallback onLoaded, bool async = true, BundleLoader parent = null)
{
string abName = FileHelper.CheckBundleName(path);
if (!ManifestHasBundleInfo(abName))
{
if (onLoaded != null)
{
onLoaded(null);
}
return(BundleLoader.BundleState.NotExist);
}
LoadedBundle loadedCache = LoadedBundleCtrl.Instance.ReferenceLoadedBundle(abName);
if (loadedCache != null)
{
if (onLoaded != null)
{
onLoaded(loadedCache);
}
return(BundleLoader.BundleState.Loaded);
}
BundleLoader loadingCache = BundleLoaderCtrl.Instance.GetBundleLoader(abName);
if (loadingCache != null)
{
loadingCache.AddHandleCallBack(onLoaded);
loadingCache.AddParent(parent);
return(BundleLoader.BundleState.Loading);
}
string fullpath = FileHelper.SearchFilePath(GetManifestType(abName).ToString(), abName); //包最终加载路径
BundleLoader bLoader = LoaderPool.Instance.GetLoader <BundleLoader>();
bLoader.Init(fullpath, abName, onLoaded, async, parent);
return(BundleLoader.BundleState.JustLoad);
}
public void Init(LoadedCallback onInit)
{
if (AppConst.UseAssetBundle)
{
m_bundleNames.Clear();
LoadManifest(ManifestType.Lua_Bundles);
LoadManifest(ManifestType.UI_Bundles);
LoadManifest(ManifestType.World_Bundles);
Util.Log("LoadManifest manifest over---------");
}
FileHelper.AddBigBundleName("UI/Materials");
LoadedBundleCtrl.Instance.SetPersistentBundles(new string[] { "shaders" });
if (null != onInit)
{
onInit(null);
}
}
public void Init(string path, string abName, LoadedCallback refCallback, bool async = true, BundleLoader parent = null, bool manifest = false)
{
base.Init(path, null, async); //null不使用父类回调
Util.Log(string.Format("Init BundleLoader path:{0}, name:{1}", path, abName));
m_abName = abName;
AddHandleCallBack(refCallback);
AddParent(parent);
BundleLoaderCtrl.Instance.AddBundleLoader(abName, this);
if (manifest)
{
StartLoad();
}
else
{
string[] dependencies = LoadModule.Instance.GetDependencies(abName);
for (int i = 0; i < dependencies.Length; ++i)
{
m_childs.Add(dependencies[i]);
if (i == dependencies.Length - 1)
{
allChildsPassed = true;
}
BundleState state = LoadModule.Instance.LoadAssetBundle(dependencies[i], null, async, this);
if (state == BundleState.NotExist || state == BundleState.Loaded)
{
m_childs.Remove(dependencies[i]);
}
}
if (m_childs.Count == 0 && m_state != LoaderState.FINISHED) //无依赖直接加载自己
{
StartLoad();
}
}
}
private new void Initialize ()
{
// FIXME this should not be handled using Events.AddHandler, since those handlers are removable via the plugin
// hook up the TemplateApplied callback so we
// can notify controls when their template has
// been instantiated as a visual tree.
Events.AddHandler (this, EventIds.FrameworkElement_TemplateAppliedEvent, template_applied);
if (OverridesLayoutMethod ("MeasureOverride"))
measure_cb = new MeasureOverrideCallback (InvokeMeasureOverride);
if (OverridesLayoutMethod ("ArrangeOverride"))
arrange_cb = new ArrangeOverrideCallback (InvokeArrangeOverride);
if (OverridesGetDefaultTemplate ())
get_default_template_cb = InvokeGetDefaultTemplate;
loaded_hook_cb = InvokeLoadedHook;
NativeMethods.framework_element_register_managed_overrides (native, measure_cb, arrange_cb, get_default_template_cb, loaded_hook_cb);
}
/// <summary>
/// 手动从Bundle中加载资源唯一入口
/// </summary>
/// <param name="path"></param>
/// <param name="name"></param>
/// <param name="type"></param>
/// <param name="onLoaded"></param>
/// <param name="async"></param>
private void LoadAssetFromBundle(string path, string assetName, System.Type type, LoadedCallback onLoaded, bool async, AssetType assetType = AssetType.GameObject)
{
if (AppConst.UseAssetBundle)
{
Util.Log(string.Format("LoadAssetFromBundle, bundle:{0}, asset:{1}", path, assetName));
LoadAssetBundle(path, (data) => {
LoadedBundle abCache = data as LoadedBundle;
object asset = null;
if (abCache != null)
{
string abName = FileHelper.CheckBundleName(path);
var cache = LoadedBundleCtrl.Instance.UnReferenceLoadedBundle(abName);
if (cache != null && 0 == cache.ReferencedCount)
{
cache.ReferencedCount = 1;
if (!m_handLoad.Contains(abName))
{
m_handLoad.Add(abName);
}
}
if (!string.IsNullOrEmpty(assetName))
{
asset = abCache.LoadAsset(assetName, type);
if (type != null && type == typeof(GameObject))
{
abCache.UnloadSelf();
}
}
else
{
asset = abCache.Bundle;
}
}
if (asset == null)
{
Util.LogError(string.Format("LoadAssetFromBundle, path:{0},name:{1}, asset is null", path, assetName));
}
if (onLoaded != null)
{
onLoaded(asset);
}
}, async);
}
else
{
LoadAsset(path, onLoaded, type, false, assetType);
}
}
private static IEnumerator loadAssetBundleCoroutine(string path, int version, bool isFixed, LoadedCallback callback)
{
string keyName = makeKey(path, version);
AssetBundleRef abRef;
if (_refs.TryGetValue(keyName, out abRef))
{
refreshRef(abRef);
if (abRef.assetBundle != null)
{
callback(abRef.assetBundle);
yield return(null);
}
else
{ // in www loading ...
abRef.callbacks.Add(callback);
}
}
else
{
abRef = new AssetBundleRef(null, path, version);
abRef.callbacks.Add(callback);
addRef(keyName, isFixed, abRef);
using (WWW www = WWW.LoadFromCacheOrDownload(path, version))
{
yield return(www);
if (www.error != null)
{
_refs.Remove(keyName);
throw new Exception("WWW download:" + www.error + "! [path]" + path);
}
abRef = null;
if (_refs.TryGetValue(keyName, out abRef))
{
abRef.assetBundle = www.assetBundle;
for (int i = 0, n = abRef.callbacks.Count; i < n; i++)
{
abRef.callbacks[i](abRef.assetBundle);
}
abRef.callbacks.Clear();
}
else
{
www.assetBundle.Unload(true);
throw new Exception("loadAssetBundleCoroutine: can not find keyName:" + keyName);
}
}
}
}
public static void loadAssetBundle(string path, int version, bool isFixed, LoadedCallback callback)
{
_behaviour.StartCoroutine(loadAssetBundleCoroutine(path, version, isFixed, callback));
}
public void Init(string path, System.Type type, LoadedCallback onLoaded, bool async = true)
{
base.Init(path, onLoaded, async);
m_assetType = type;
}
