void Scene::HandleResourceBackgroundLoaded(StringHash eventType, VariantMap& eventData)
{
using namespace ResourceBackgroundLoaded;
if (asyncLoading_)
{
Resource* resource = static_cast<Resource*>(eventData[P_RESOURCE].GetPtr());
if (asyncProgress_.resources_.Contains(resource->GetNameHash()))
{
asyncProgress_.resources_.Erase(resource->GetNameHash());
++asyncProgress_.loadedResources_;
}
}
}
void BackgroundLoader::ThreadFunction()
{
while (shouldRun_)
{
backgroundLoadMutex_.Acquire();
// Search for a queued resource that has not been loaded yet
HashMap<Pair<StringHash, StringHash>, BackgroundLoadItem>::Iterator i = backgroundLoadQueue_.Begin();
while (i != backgroundLoadQueue_.End())
{
if (i->second_.resource_->GetAsyncLoadState() == ASYNC_QUEUED)
break;
else
++i;
}
if (i == backgroundLoadQueue_.End())
{
// No resources to load found
backgroundLoadMutex_.Release();
Time::Sleep(5);
}
else
{
BackgroundLoadItem& item = i->second_;
Resource* resource = item.resource_;
// We can be sure that the item is not removed from the queue as long as it is in the
// "queued" or "loading" state
backgroundLoadMutex_.Release();
bool success = false;
SharedPtr<File> file = owner_->GetFile(resource->GetName(), item.sendEventOnFailure_);
if (file)
{
resource->SetAsyncLoadState(ASYNC_LOADING);
success = resource->BeginLoad(*file);
}
// Process dependencies now
// Need to lock the queue again when manipulating other entries
Pair<StringHash, StringHash> key = MakePair(resource->GetType(), resource->GetNameHash());
backgroundLoadMutex_.Acquire();
if (item.dependents_.Size())
{
for (HashSet<Pair<StringHash, StringHash> >::Iterator i = item.dependents_.Begin();
i != item.dependents_.End(); ++i)
{
HashMap<Pair<StringHash, StringHash>, BackgroundLoadItem>::Iterator j = backgroundLoadQueue_.Find(*i);
if (j != backgroundLoadQueue_.End())
j->second_.dependencies_.Erase(key);
}
item.dependents_.Clear();
}
resource->SetAsyncLoadState(success ? ASYNC_SUCCESS : ASYNC_FAIL);
backgroundLoadMutex_.Release();
}
}
}
