Beispiel #1
0
        protected void OnBundleRequestComplete(Request request)
        {
#if ASSETMANAGER_LOG
            Debug.Log("BundleRequestComplete " + info.fullName + "," + Time.frameCount);
#endif
            if (!request.haveError)
            {
                state = State.Loaded;
                if (onAssetBundleLoaded != null)
                {
                    onAssetBundleLoaded(this);
                }

                //Create result
                m_Result = new AssetBundleReference(request.assetBundle, info != null ? info.fullName : "");
                m_Result.AddTags(paramTags);
                if (m_DependenciesIsDone) //|| (m_DependenciesIsLoaded && DeepCheckDependenciesComplete()))
                {
                    m_Result.AddDependencies(m_Dependencies);
                    Complete();
                }
            }
            else
            {
                Debug.LogError("AssetBundleLoader fail load " + info.fullName);
                Error();
            }
        }
Beispiel #2
0
        public void UnloadUnusedBundles(string tag)
        {
            if (m_AssetBundles.Count == 0)
            {
                return;
            }

            AssetBundleReference abr = null;

            Stack <string> checkQueue = StackPool <string> .Get();

            HashSet <string> checkings = HashSetPool <string> .Get();


            Action <string> checkFun = (key) =>
            {
                abr = m_AssetBundles[key];
                checkings.Remove(key);

                if (abr.isUnused())
                {
                    //check dependencies
                    if (abr.dependencies != null && abr.dependencies.Count > 0)
                    {
                        foreach (AssetBundleReference sub in abr.dependencies)
                        {
                            //只有同样tag和空tag的ref才需要重新检查。
                            if (sub.inChain && (sub.tagCount == 0 || sub.HaveTag(tag)) && !checkings.Contains(sub.name))
                            {
                                checkQueue.Push(sub.name);
                            }
                        }
                    }

                    abr.Dispose();
                    m_AssetBundles.Remove(key);
                }
            };

            foreach (string key in m_AssetBundles.Keys)
            {
                abr = m_AssetBundles[key];
                if (abr.HaveTag(tag) && abr.inChain)
                {
                    checkQueue.Push(key);
                    checkings.Add(key);
                }
            }

            //recheck unused asset bundle
            while (checkQueue.Count > 0)
            {
                checkFun(checkQueue.Pop());
            }

            StackPool <string> .Release(checkQueue);

            HashSetPool <string> .Release(checkings);
        }
Beispiel #3
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="assetBundleName"></param>
 public void UnusedAssetBundle(string assetBundleName)
 {
     if (m_AssetBundles.ContainsKey(assetBundleName))
     {
         AssetBundleReference abr = m_AssetBundles[assetBundleName];
         abr.UnChain();
     }
 }
Beispiel #4
0
 void UnusedAllAssetBundles()
 {
     foreach (var iter in m_AssetBundles)
     {
         AssetBundleReference abr = iter.Value;
         abr.UnChain();
     }
 }
Beispiel #5
0
        public override void Clean()
        {
            onComplete           = null;
            onBeforeComplete     = null;
            onAfterComplete      = null;
            info                 = null;
            type                 = null;
            assetBundleReference = null;

            m_Result = null;
            base.Clean();
        }
        void LoadDependencies()
        {
            string[] dependencies = info.dependencies;

            for (int i = 0, l = dependencies.Length; i < l; ++i)
            {
                string dep = dependencies[i];
                AssetBundleReference abr = assetManager.LoadAssetBundleSync(dep, null, false);
                if (abr != null)
                {
                    m_Dependencies.Add(abr);
                }
            }
        }
Beispiel #7
0
        public AssetBundleReference LoadAssetBundleSync(string path, string tag, bool standalone = true)
        {
            if (string.IsNullOrEmpty(path))
            {
                return(null);
            }

            AssetBundleReference abr = null;

            if (m_AssetBundles.ContainsKey(path))
            {
                #if ASSETMANAGER_LOG
                Debug.LogFormat("LoadAssetBundleSync bundle is loaded {0},{1}", path, Time.frameCount);
                #endif
                abr = m_AssetBundles[path];
                //refresh
                abr.AddTag(tag);

                if (standalone)
                {
                    abr.Chain();
                }
            }
            else
            {
                if (m_LoadingAssetBundleLoaders.ContainsKey(path))
                {
                    Debug.LogErrorFormat("LoadAssetBundleSync async loader is active {0},{1}", path, Time.frameCount);
                    //TODO Stop async
                    return(null);
                }
                else
                {
                    #if ASSETMANAGER_LOG
                    Debug.LogFormat("LoadAssetBundleSync create new loader {0},{1}", path, Time.frameCount);
                    #endif
                    AssetBundleSyncLoader loader = m_LoaderManager.CreateAssetBundleSyncLoader(path);
                    if (loader != null)
                    {
                        loader.state = Loader.State.Inited;
                        loader.Start();
                        abr = loader.result;
                        OnAssetBundleLoaded(loader);
                    }
                }
            }

            return(abr);
        }
Beispiel #8
0
        protected void OnDependencyComplete(AssetBundleReference abr)
        {
            m_Dependencies.Add(abr);
#if ASSETMANAGER_LOG
            Debug.Log("DependencyComplete " + info.fullName + "=>" + abr.name + "," + Time.frameCount + ",(" + m_WaitDependencyCompleteCount + ")");
#endif
            if (--m_WaitDependencyCompleteCount == 0)
            {
                m_DependenciesIsDone = true;
                if (m_State == State.Loaded && m_Result != null)
                {
                    m_Result.AddDependencies(m_Dependencies);
                    Complete();
                }
            }
        }
        public override void Clean()
        {
            onComplete       = null;
            onBeforeComplete = null;
            onAfterComplete  = null;

            m_Result = null;

            info = null;

            if (m_Dependencies != null)
            {
                m_Dependencies.Clear();
            }
            base.Clean();
        }
Beispiel #10
0
        protected void RemoveAssetBundlesTag(string tag)
        {
            if (m_AssetBundles.Count == 0)
            {
                return;
            }

            AssetBundleReference abr = null;
            var iter = m_AssetBundles.GetEnumerator();

            while (iter.MoveNext())
            {
                abr = iter.Current.Value;
                if (abr.inChain && abr.HaveTag(tag))
                {
                    abr.RemoveTag(tag);
                }
            }
        }
Beispiel #11
0
        void OnAssetBundleLoaded(AssetBundleLoader loader)
        {
            AssetBundleReference abr = loader.result;

            if (abr != null)
            {
                m_AssetBundles[abr.name] = abr;

                if (loader.standalone)
                {
                    abr.Chain();
                }
                else
                {
                    abr.inChain = false;
                }

                if (m_LoadingAssetBundleLoaders.ContainsKey(abr.name))
                {
                    if (loader.autoRelease)
                    {
                        if (loader is AssetBundleAsyncLoader)
                        {
                            LoaderPool.AssetBundleAsyncLoader.Release(loader as AssetBundleAsyncLoader);
                        }
                        else
                        {
                            loader.Clean();
                        }
                    }
                    m_LoadingAssetBundleLoaders.Remove(abr.name);
                }

                abr.onDispose += OnAssetBundleDispose;
            }
        }
Beispiel #12
0
 void OnAssetBundleDispose(AssetBundleReference abr)
 {
     m_AssetBundles.Remove(abr.name);
 }
Beispiel #13
0
        public AssetBundleLoader LoadAssetBundle(string path, string tag, bool standalone, Action <AssetBundleReference> completeHandle = null)
        {
            AssetBundleLoader loader = null;

            if (string.IsNullOrEmpty(path))
            {
                return(loader);
            }

            if (m_AssetBundles.ContainsKey(path))
            {
                #if ASSETMANAGER_LOG
                Debug.Log("LoadAssetBundle asset bundle is loaded " + path + "," + Time.frameCount);
                #endif
                //asset bundle is loaded
                AssetBundleReference abr = m_AssetBundles[path];

                //refresh
                abr.AddTag(tag);

                if (standalone)
                {
                    abr.Chain();
                }

                loader           = m_LoaderManager.CreateAssetBundleAsyncLoader(path);
                loader.forceDone = true;
                loader.result    = abr;

                //call complete callback
                if (completeHandle != null)
                {
                    completeHandle(abr);
                }
            }
            else
            {
                if (m_LoadingAssetBundleLoaders.ContainsKey(path))
                {
                    #if ASSETMANAGER_LOG
                    Debug.Log("LoadAssetBundle using loading loader " + path + "," + Time.frameCount);
                    #endif
                    loader = m_LoadingAssetBundleLoaders[path];
                }
                else
                {
                    #if ASSETMANAGER_LOG
                    Debug.Log("LoadAssetBundle create new loader " + path + "," + Time.frameCount);
                    #endif
                    loader = m_LoaderManager.CreateAssetBundleAsyncLoader(path);
                    m_LoadingAssetBundleLoaders[path] = loader;
                }

                loader.AddParamTag(tag);

                if (loader.standalone == false && standalone)
                {
                    loader.standalone = true;
                }

                if (completeHandle != null)
                {
                    loader.onComplete += completeHandle;
                }

                if (loader.state == Loader.State.Idle)
                {
                    loader.onAfterComplete += OnAssetBundleLoaded;
                    loader.state            = Loader.State.Inited;
                    m_LoaderManager.ActiveLoader(loader);
                }
            }

            return(loader);
        }