public override void Init(string assetBundlePath, string assetPath, LoadMode loadMode, params object[] args)
        {
            base.Init(assetBundlePath, assetPath, loadMode, args);

            LoaderCallback callback = (isOk, asset) =>
            {
                if (IsReadyDisposed)  // 中途释放
                {
                    OnFinish(null);
                    return;
                }

                if (!isOk)
                {
                    OnFinish(null);
                    Debuger.LogError(LOG_TAG, "Error on AssetLoader loaded... {0}|{1}", assetBundlePath, assetPath);
                    return;
                }

                Object prefab   = asset as Object;
                Object instance = Object.Instantiate(prefab);
                instance.name = prefab.name;

                if (Application.isEditor)
                {
                    LoadedAssetDebugger.Create("InstanceAsset", GetUniqueKey(), instance);
                }

                OnFinish(instance);
            };

            _assetLoader = BaseLoader.Load <AssetLoader>(assetBundlePath, assetPath, loadMode, callback, true);
        }
Beispiel #2
0
        IEnumerator Start()
        {
            Object getAsset = null;

#if UNITY_EDITOR
            if (IsEditorLoadAsset)
            {
                getAsset = UnityEditor.AssetDatabase.LoadAssetAtPath <Object>(AssetConfig.GetEditorAssetPathRoot() + AssetPath);
                if (getAsset == null)
                {
                    Debuger.LogError("Asset is NULL(from {0} Folder): {1}", AssetConfig.GetEditorAssetPathRoot(), AssetPath);
                }


                OnFinish(getAsset);
            }
            else
#endif
            if (!IsLoadAssetBundle)
            {
                string extension = Path.GetExtension(AssetPath);
                string path      = AssetPath.Substring(0, AssetPath.Length - extension.Length); // remove extensions

                // 去掉 "GameAssets/"
                if (path.StartsWith(AssetConfig.GameAssetsFolder))
                {
                    path = path.Replace(AssetConfig.GameAssetsFolder, "");
                }

                getAsset = Resources.Load <Object>(path);
                if (getAsset == null)
                {
                    Debuger.LogError("Asset is NULL(from Resources Folder): {0}", path);
                }
                OnFinish(getAsset);
            }
            else
            {
                _bundleLoader = BaseLoader.Load <AssetBundleLoader>(AssetBundlePath, "", loadMode, null);

                while (!_bundleLoader.IsCompleted)
                {
                    if (IsReadyDisposed) // 中途释放
                    {
                        _bundleLoader.Release();
                        OnFinish(null);
                        yield break;
                    }
                    yield return(null);
                }

                if (!_bundleLoader.IsSuccess)
                {
                    Debuger.LogError(LOG_TAG, "Load bundle Failed(Error) when Finished: {0}", AssetBundlePath);
                    _bundleLoader.Release();
                    OnFinish(null);
                    yield break;
                }

                var assetBundle = _bundleLoader.assetBundle;

                var assetName = AssetPath;
                if (!assetBundle.isStreamedSceneAssetBundle)
                {
                    if (loadMode == LoadMode.Sync)
                    {
                        getAsset = assetBundle.LoadAsset(assetName);

                        if (getAsset != null)
                        {
                            _bundleLoader.PushLoadedAsset(assetName, getAsset);
                        }
                    }
                    else
                    {
                        var request = assetBundle.LoadAssetAsync(assetName);
                        while (!request.isDone)
                        {
                            yield return(null);
                        }

                        getAsset = request.asset;

                        if (getAsset != null)
                        {
                            _bundleLoader.PushLoadedAsset(assetName, getAsset);
                        }
                    }
                }
                else
                {
                    // if it's a scene in asset bundle, do nothing
                    // but set a default Object as the result

                    //TODO:
                    Debuger.LogWarning(LOG_TAG, "Can't load any assets from A scene asset bundle");
                    getAsset = null;
                }

                if (getAsset == null)
                {
                    Debuger.LogError(LOG_TAG, "Asset is NULL(From asset bundle): {0}", AssetPath);
                }
            }

            if (Application.isEditor)
            {
                if (getAsset != null)
                {
                    LoadedAssetDebugger.Create(getAsset.GetType().Name, GetUniqueKey(), getAsset);
                }
            }

            OnFinish(getAsset);
        }