void ResourceManager::sendPendingEvents()
{
ResourceEvent event;
while( resourceEvents.try_pop_front(event) )
{
Resource* resource = event.resource;
auto base = PathGetFile(resource->path);
auto key = MurmurHash64(base.c_str(), base.size(), 0);
ResourceHandle handle = resources.get(key, HandleInvalid);
assert( handle != HandleInvalid );
event.handle = handle;
onResourceLoaded( event );
}
}
void ResourceModel::setResource(const Lumix::Path& path)
{
if (m_resource)
{
m_resource->getResourceManager()
.get(m_resource_type)
->unload(*m_resource);
m_resource->getObserverCb()
.unbind<ResourceModel, &ResourceModel::onResourceLoaded>(this);
}
char rel_path[Lumix::MAX_PATH_LENGTH];
m_editor.getRelativePath(rel_path, Lumix::MAX_PATH_LENGTH, path);
char extension[10];
Lumix::PathUtils::getExtension(extension, sizeof(extension), path);
if (strcmp(extension, "msh") == 0)
{
m_resource_type = Lumix::ResourceManager::MODEL;
}
else if (strcmp(extension, "mat") == 0)
{
m_resource_type = Lumix::ResourceManager::MATERIAL;
}
else if (strcmp(extension, "dds") == 0 || strcmp(extension, "tga") == 0 ||
strcmp(extension, "raw") == 0)
{
m_resource_type = Lumix::ResourceManager::TEXTURE;
}
else
{
m_resource_type = 0;
m_resource = nullptr;
return;
}
Lumix::ResourceManagerBase* manager =
m_editor.getEngine().getResourceManager().get(m_resource_type);
m_resource = manager->load(Lumix::Path(rel_path));
m_resource->getObserverCb()
.bind<ResourceModel, &ResourceModel::onResourceLoaded>(this);
onResourceLoaded(m_resource->getState(), m_resource->getState());
}
void Resources::loadComplete(HResource& resource)
{
String uuid = resource.getUUID();
ResourceLoadData* myLoadData = nullptr;
bool finishLoad = true;
Vector<ResourceLoadData*> dependantLoads;
{
Lock inProgresslock(mInProgressResourcesMutex);
auto iterFind = mInProgressResources.find(uuid);
if (iterFind != mInProgressResources.end())
{
myLoadData = iterFind->second;
finishLoad = myLoadData->remainingDependencies == 0;
if (finishLoad)
mInProgressResources.erase(iterFind);
}
auto iterFind2 = mDependantLoads.find(uuid);
if (iterFind2 != mDependantLoads.end())
dependantLoads = iterFind2->second;
if (finishLoad)
{
mDependantLoads.erase(uuid);
// If loadedData is null then we're probably completing load on an already loaded resource, triggered
// by its dependencies.
if (myLoadData != nullptr && myLoadData->loadedData != nullptr)
{
Lock loadedLock(mLoadedResourceMutex);
mLoadedResources[uuid] = myLoadData->resData;
resource.setHandleData(myLoadData->loadedData, uuid);
}
for (auto& dependantLoad : dependantLoads)
dependantLoad->remainingDependencies--;
}
}
for (auto& dependantLoad : dependantLoads)
{
HResource dependant = dependantLoad->resData.resource.lock();
loadComplete(dependant);
}
if (finishLoad && myLoadData != nullptr)
{
onResourceLoaded(resource);
// This should only ever be true on the main thread
if (myLoadData->notifyImmediately)
ResourceListenerManager::instance().notifyListeners(uuid);
bs_delete(myLoadData);
}
}
