public virtual void Initialize <T>(ResourceCacheMask mask, Dictionary <int, ResourceConfig <T> > configs, bool cacheOn = true) where T : GameDataMap <int, T>, new()
        {
            ResourceCachePool pool = null;

            foreach (ResourceConfig <T> config in configs.Values)
            {
                if (CheckLevelShow(config.Level))
                {
                    if (((int)mask & config.Mask) != 0)
                    {
                        if (!mPools.ContainsKey(config.ID))
                        {
                            pool = new ResourceCachePool();
                            pool.Initialize(config, ResourceCacheBindParent.CacheUnused, GetLevel(), this, cacheOn);
                            mPools.Add(config.ID, pool);
                        }
                    }
                }
            }
            if (IsPrintOn)
            {
                PrintTimerId = -1;
                PrintTimer(true);
            }
        }
        protected virtual ResourceCachePool GetEntityFromManager(int poolId, out ResourceCacheEntity entity)
        {
            entity = null;
            ResourceCachePool pool = null;

            if (mPools.ContainsKey(poolId))
            {
                pool   = mPools[poolId];
                entity = mPools[poolId].Acquire();;
            }
            return(pool);
        }
 protected virtual void Release(int instanceId)
 {
     if (mAcquiredItems.ContainsKey(instanceId))
     {
         ResourceCacheEntity entity = mAcquiredItems[instanceId];
         if (entity.IsTimerOn)
         {
             TimerTaskQueue.Instance.DelTimer(entity.InstanceId);
         }
         mAcquiredItems.Remove(instanceId);
         ResourceCachePool pool = mPools[entity.ManagerId];
         pool.Release(entity);
     }
 }
        public virtual int Play(int poolId, int duration, Transform parent, ResourceCacheBehaviourParam param, int delay = 0)
        {
            int instanceId = -1;
            ResourceCacheEntity entity;
            ResourceCachePool   pool = GetEntityFromManager(poolId, out entity);

            if (pool != null && entity != null)
            {
                entity.SetParent(parent, false);
                AdjustParam(ref param, ref duration, delay);
                instanceId = GenInstanceId(entity, duration);
                pool.AddToStrategy(instanceId);
                HandleEntity(entity, param);
            }
            return(instanceId);
        }
        protected virtual void ClearInternal(ResourceCacheMask mask)
        {
            CACHE.Clear();
            List <int> poolKeys = mPools.Keys.ToList();

            foreach (int key in poolKeys)
            {
                ResourceCachePool pool = mPools[key];
                if ((pool.GetMask() & (int)mask) != 0)
                {
                    pool.Clear();
                    CACHE.Add(key);
                }
            }
            foreach (int key in CACHE)
            {
                mPools.Remove(key);
            }
        }
        public virtual void Initialize <T>(ResourceCacheMask mask, Dictionary <int, ResourceConfig <T> > configs, bool cacheOn = true)
        {
            ResourceCachePool pool = null;

            foreach (ResourceConfig <T> config in configs.Values)
            {
                if (CheckLevelShow(config.Level))
                {
                    if (((int)mask & config.Mask) != 0)
                    {
                        if (!mPools.ContainsKey(config.Id))
                        {
                            pool = new ResourceCachePool();
                            pool.Initialize(config, ResourceCacheBindParent.CacheUnused, GetLevel(), this, cacheOn);
                            mPools.Add(config.Id, pool);
                        }
                    }
                }
            }
#if UNITY_EDITOR
            PrintTimerId = -1;
            PrintTimer(true);
#endif
        }