//-------∽-★-∽------∽-★-∽--------∽-★-∽数据操作∽-★-∽--------∽-★-∽------∽-★-∽--------//
protected override LoadReq ExcuteLoad(LoadReq req_)
{
LoadReq req = req_;
AbstractLoader loader = LoaderFactory.GetLoader(req_.type);
req = loader.LoadAsync(req);
if (loader.isDone)
{
LoaderFactory.CloseLoader(loader);
return req;
}
req.OnStart();
//m_isAsync = isAsync_;
//m_progress = 0;
//m_data = null;
//m_errorStr = null;
m_isOpen = true;
m_done = false;
m_loading = true;
m_loaders.Add(loader);
SchUpdate(true);
//__print("○load start: " + loader.UrlStr);
NotifyAsynEvt(LOAD_EVT.START, req);
return req;
}
static IPop m_loadView;//当前加载条
static LoadMgr()
{
m_mainLoader = new QueueLoader();
m_mainLoader.evt_enabled = true;
m_subLoader = new MultiLoader();
}
//-------∽-★-∽------∽-★-∽--------∽-★-∽数据管理∽-★-∽--------∽-★-∽------∽-★-∽--------//
override protected void Step(float delta_)
{
tmp_b = true;
for (int i = m_loaders.Count-1; i >=0 ; --i)
{
tmp_loader = m_loaders[i];
if (tmp_loader.isDone)
{
LoaderFactory.CloseLoader(tmp_loader);
m_loaders.RemoveAt(i);
}
else
{
tmp_b = false;
}
}
tmp_loader = null;
if (tmp_b)
{
OnComplete();
}
}
static public AbstractLoader GetLoader(LoadReqType type_)
{
AbstractLoader loader = null;
switch (type_)
{
case LoadReqType.QUEUE:
loader = m_pool.Pop <QueueLoader>();
break;
case LoadReqType.BATCH:
loader = m_pool.Pop <BatchLoader>();
break;
case LoadReqType.LEVEL:
loader = m_pool.Pop <LevelLoader>();
break;
case LoadReqType.DELAY:
loader = m_pool.Pop <DelayLoader>();
break;
case LoadReqType.PROGRESS:
loader = m_pool.Pop <ProgLoader>();
break;
default:
loader = m_pool.Pop <AssetLoader>();
break;
}
return(loader);
}
//-------∽-★-∽------∽-★-∽--------∽-★-∽数据管理∽-★-∽--------∽-★-∽------∽-★-∽--------//
override protected void Step(float delta_)
{
tmp_b = true;
tmp_progress = 0;
for (int i = 0; i < m_load_num; ++i)
{
tmp_loader = m_loaders[i];
tmp_progress += tmp_loader.Progress;
if (!tmp_loader.isDone)
{
tmp_b = false; //需要全部完成
}
}
tmp_loader = null;
if (tmp_b)
{
m_data = m_loaders[0].Data; //取第一个
OnComplete();
}
else
{
tmp_progress /= m_load_num;
//Log.Debug(tmp_progress);
SetProgress(tmp_progress);
}
}
protected AbstractLoader StartLoader(LoadReq req_)
{
AbstractLoader loader = LoaderFactory.GetLoader(req_.type);
loader.LoadAsync(req_);
return(loader);
}
static public void CloseLoader(AbstractLoader loader_)
{
if (loader_ == null)
{
return;
}
loader_.Close();
m_pool.Push(loader_);
}
void LoadOne()
{
LoadReq req_ = m_loadReqQue.load_reqs[m_load_idx];
if (m_loader == null || m_loader.Req.type != req_.type)
{
LoaderFactory.CloseLoader(m_loader);
m_loader = LoaderFactory.GetLoader(req_.type);
}
m_loader.LoadAsync(req_);
CheckLoaded();
}
protected override void __Stop()
{
if (m_loaders.Count > 0)
{
for (int i=0; i < m_loaders.Count; ++i)
{
tmp_loader = m_loaders[i];
LoaderFactory.CloseLoader(tmp_loader);
}
m_loaders.Clear();
}
SchUpdate(false);
}
protected override void __Stop()
{
if (m_loaders.Count == 0)
{
return;
}
for (int i = 0; i < m_loaders.Count; ++i)
{
tmp_loader = m_loaders[i];
CloseLoader(tmp_loader);
}
tmp_loader = null;
m_loaders.Clear();
SchUpdate(false);
}
protected override void StartLoad()
{
LoadReq[] load_reqs = m_loadReqQue.load_reqs;
for (int i = 0; i < m_load_num; ++i)
{
AbstractLoader loader = StartLoader(load_reqs[i]);
m_loaders.Add(loader);
}
Step(0);
if (!isDone)
{
m_loadReq.OnStart();
SchUpdate(true);
}
}
protected override void __Stop()
{
LoaderFactory.CloseLoader(m_loader);
m_loader = null;
SchUpdate(false);
}
protected void CloseLoader(AbstractLoader loader_)
{
LoaderFactory.CloseLoader(loader_);
}
