void BackgroundLoader::FinishResources(int maxMs)
{
if (IsStarted())
{
HiresTimer timer;
backgroundLoadMutex_.Acquire();
for (auto i = backgroundLoadQueue_.begin();
i != backgroundLoadQueue_.end();)
{
Resource* resource = i->second.resource_;
unsigned numDeps = i->second.dependencies_.size();
AsyncLoadState state = resource->GetAsyncLoadState();
if (numDeps > 0 || state == ASYNC_QUEUED || state == ASYNC_LOADING)
++i;
else
{
// Finishing a resource may need it to wait for other resources to load, in which case we can not
// hold on to the mutex
backgroundLoadMutex_.Release();
FinishBackgroundLoading(i->second);
backgroundLoadMutex_.Acquire();
i = backgroundLoadQueue_.erase(i);
}
// Break when the time limit passed so that we keep sufficient FPS
if (timer.GetUSec(false) >= maxMs * 1000LL)
break;
}
backgroundLoadMutex_.Release();
}
}
void BackgroundLoader::FinishBackgroundLoading(BackgroundLoadItem& item)
{
Resource* resource = item.resource_;
bool success = resource->GetAsyncLoadState() == ASYNC_SUCCESS;
// If BeginLoad() phase was successful, call EndLoad() and get the final success/failure result
if (success)
{
#ifdef URHO3D_PROFILING
String profileBlockName("Finish" + resource->GetTypeName());
Profiler* profiler = owner_->GetSubsystem<Profiler>();
if (profiler)
profiler->BeginBlock(profileBlockName.CString());
#endif
LOGDEBUG("Finishing background loaded resource " + resource->GetName());
success = resource->EndLoad();
#ifdef URHO3D_PROFILING
if (profiler)
profiler->EndBlock();
#endif
}
resource->SetAsyncLoadState(ASYNC_DONE);
if (!success && item.sendEventOnFailure_)
{
using namespace LoadFailed;
VariantMap& eventData = owner_->GetEventDataMap();
eventData[P_RESOURCENAME] = resource->GetName();
owner_->SendEvent(E_LOADFAILED, eventData);
}
// Send event, either success or failure
{
using namespace ResourceBackgroundLoaded;
VariantMap& eventData = owner_->GetEventDataMap();
eventData[P_RESOURCENAME] = resource->GetName();
eventData[P_SUCCESS] = success;
eventData[P_RESOURCE] = resource;
owner_->SendEvent(E_RESOURCEBACKGROUNDLOADED, eventData);
}
// Store to the cache; use same mechanism as for manual resources
if (success || owner_->GetReturnFailedResources())
owner_->AddManualResource(resource);
}
void BackgroundLoader::WaitForResource(StringHash type, StringHash nameHash)
{
backgroundLoadMutex_.Acquire();
// Check if the resource in question is being background loaded
ea::pair<StringHash, StringHash> key = ea::make_pair(type, nameHash);
auto i = backgroundLoadQueue_.find(
key);
if (i != backgroundLoadQueue_.end())
{
backgroundLoadMutex_.Release();
{
Resource* resource = i->second.resource_;
HiresTimer waitTimer;
bool didWait = false;
for (;;)
{
unsigned numDeps = i->second.dependencies_.size();
AsyncLoadState state = resource->GetAsyncLoadState();
if (numDeps > 0 || state == ASYNC_QUEUED || state == ASYNC_LOADING)
{
didWait = true;
Time::Sleep(1);
}
else
break;
}
if (didWait)
URHO3D_LOGDEBUG("Waited " + ea::to_string(waitTimer.GetUSec(false) / 1000) + " ms for background loaded resource " +
resource->GetName());
}
// This may take a long time and may potentially wait on other resources, so it is important we do not hold the mutex during this
FinishBackgroundLoading(i->second);
backgroundLoadMutex_.Acquire();
backgroundLoadQueue_.erase(i);
backgroundLoadMutex_.Release();
}
else
backgroundLoadMutex_.Release();
}
void BackgroundLoader::FinishBackgroundLoading(BackgroundLoadItem& item)
{
Resource* resource = item.resource_;
bool success = resource->GetAsyncLoadState() == ASYNC_SUCCESS;
// If BeginLoad() phase was successful, call EndLoad() and get the final success/failure result
if (success)
{
URHO3D_PROFILE(ea::string("Finish" + resource->GetTypeName()).c_str());
URHO3D_LOGDEBUG("Finishing background loaded resource " + resource->GetName());
success = resource->EndLoad();
}
resource->SetAsyncLoadState(ASYNC_DONE);
if (!success && item.sendEventOnFailure_)
{
using namespace LoadFailed;
VariantMap& eventData = owner_->GetEventDataMap();
eventData[P_RESOURCENAME] = resource->GetName();
owner_->SendEvent(E_LOADFAILED, eventData);
}
// Store to the cache just before sending the event; use same mechanism as for manual resources
if (success || owner_->GetReturnFailedResources())
owner_->AddManualResource(resource);
// Send event, either success or failure
{
using namespace ResourceBackgroundLoaded;
VariantMap& eventData = owner_->GetEventDataMap();
eventData[P_RESOURCENAME] = resource->GetName();
eventData[P_SUCCESS] = success;
eventData[P_RESOURCE] = resource;
owner_->SendEvent(E_RESOURCEBACKGROUNDLOADED, eventData);
}
}
