Beispiel #1
0
        private GoCallback GenTask(string resPath, OnGameObjGot cb)
        {
            GoCallback gcb = GoCallback.Gen(cb, resPath);

            goTasks.Add(gcb.Id, gcb);
            return(gcb);
        }
Beispiel #2
0
        private bool GetFromPool(string assetPath, OnGameObjGot cb, bool doneOnUpdate, out ulong taskId)
        {
            taskId = 0;
            if (!unUsed.ContainsKey(assetPath))
            {
                return(false);
            }
            UnusedGo one = unUsed[assetPath];

            if (one.IsEmpty)
            {
                return(false);
            }
            if (doneOnUpdate)
            {
                GoCallback gcb = GenTask(assetPath, cb);
                taskId = gcb.Id;
                onUpdateTasks.Add(taskId);
            }
            else
            {
                GameObject go = one.Peek();
                cb(go, 0);
            }
            return(true);
        }
Beispiel #3
0
 public void CheckDoneOnUpdate()
 {
     if (onUpdateTasks.Count == 0)
     {
         return;
     }
     foreach (var taskId in onUpdateTasks)
     {
         if (goTasks.ContainsKey(taskId))
         {
             GoCallback task = goTasks[taskId];
             if (!task.Canceled)
             {
                 if (task.Asset != null)
                 {
                     DoInstant(taskId, task.Asset);
                 }
                 else
                 {
                     GameObject go = DoGetFromUnused(task.Path);
                     task.Do(go);
                 }
             }
         }
     }
     onUpdateTasks.Clear();
 }
Beispiel #4
0
        //取消获取,reserve标识对于取消加载的对象是缓存到自己的缓冲池
        //还是完全取消对象的加载
        public void CancelUngotGameObj(ulong cbIdx, bool reserve)
        {
            GoCallback gcb = GoCallback.Get(cbIdx);

            if (null == gcb)
            {
                return;
            }
            if (goTasks.ContainsKey(gcb.Id))
            {
                if (reserve)//需要缓存的情况
                {
                    gcb.Cb = (go, cbId) =>
                    {
                        UnuseGameObj(gcb.Path, go);
                    };
                }
                else
                {
                    goTasks.Remove(gcb.Id);
                    GoCallback.Remove(gcb.Id);
                    gcb.Cancel();
                    if (instanters.ContainsKey(gcb.Id))
                    {
                        IEnumerator instanter = instanters[gcb.Id];
                        StopCoroutine(instanter);
                        instanters.Remove(gcb.Id);
                    }
                }
            }
        }
Beispiel #5
0
        public static GoCallback Gen(OnGameObjGot cb, string path)
        {
            GoCallback acb = new GoCallback(cb, path);

            items.Add(acb.Id, acb);
            return(acb);
        }
Beispiel #6
0
 private void FinishInstant(ulong gcbId, GameObject go)
 {
     if (goTasks.ContainsKey(gcbId))
     {
         GoCallback task = goTasks[gcbId];
         task.Do(go);
         GoCallback.Remove(gcbId);
         goTasks.Remove(gcbId);
     }
     if (instanters.ContainsKey(gcbId))
     {
         instanters.Remove(gcbId);
     }
 }
Beispiel #7
0
        private ulong GetByLoad(string assetPath, OnGameObjGot cb, bool doneOnUpdate)
        {
            GoCallback gcb = GenTask(assetPath, cb);

            gcb.AssetCbId = BundleMgr.Instance.GetAsset(assetPath, (asset, cbId) =>
            {
                gcb.AssetCbId = 0;
                if (doneOnUpdate)
                {
                    gcb.Asset = (UObj)asset;
                    onUpdateTasks.Add(gcb.Id);
                }
                else
                {
                    IEnumerator instant = Instant(gcb.Id, (UObj)asset);
                    instanters.Add(gcb.Id, instant);
                    StartCoroutine(instant);
                }
            });
            return(gcb.Id);
        }