Mirrors/overte-Armored-Dragon
3
0
Fork 0
mirror of https://github.com/Armored-Dragon/overte.git synced 2025-03-11 16:13:16 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Black box asynch resource retrieval

Browse source
This commit is contained in:
Zach Pomerantz 2016-05-09 14:56:25 -07:00
parent 22081a8606
commit 9ac783a88d
4 changed files with 11 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
interface/src/Application.cpp
View file

@ -584,12 +584,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
// put the NodeList and datagram processing on the node thread
nodeList->moveToThread(nodeThread);
// Model background downloads need to happen on the Datagram Processor Thread. The idle loop will
// emit checkBackgroundDownloads to cause the ModelCache to check it's queue for requested background
// downloads.
auto modelCache = DependencyManager::get<ModelCache>();
connect(this, &Application::checkBackgroundDownloads, modelCache.data(), &ModelCache::checkAsynchronousGets);
// put the audio processing on a separate thread
QThread* audioThread = new QThread();
audioThread->setObjectName("Audio Thread");
@ -2746,9 +2740,6 @@ void Application::idle(uint64_t now) {
}
_overlayConductor.update(secondsSinceLastUpdate);
// check for any requested background downloads.
emit checkBackgroundDownloads();
}
void Application::setLowVelocityFilter(bool lowVelocityFilter) {

2
interface/src/Application.h
View file

@ -224,8 +224,6 @@ public:
signals:
void svoImportRequested(const QString& url);
void checkBackgroundDownloads();
void fullAvatarURLChanged(const QString& newValue, const QString& modelName);
void beforeAboutToQuit();

22
libraries/networking/src/ResourceCache.cpp
View file

@ -316,23 +316,6 @@ void ResourceCache::setRequestLimit(int limit) {
}
}
void ResourceCache::getResourceAsynchronously(const QUrl& url) {
qCDebug(networking) << "ResourceCache::getResourceAsynchronously" << url.toString();
QWriteLocker locker(&_resourcesToBeGottenLock);
_resourcesToBeGotten.enqueue(QUrl(url));
}
void ResourceCache::checkAsynchronousGets() {
assert(QThread::currentThread() == thread());
QWriteLocker locker(&_resourcesToBeGottenLock);
if (!_resourcesToBeGotten.isEmpty()) {
QUrl url = _resourcesToBeGotten.dequeue();
locker.unlock();
getResource(url);
}
}
QSharedPointer<Resource> ResourceCache::getResource(const QUrl& url, const QUrl& fallback,
bool delayLoad, void* extra) {
QSharedPointer<Resource> resource;
@ -346,8 +329,11 @@ QSharedPointer<Resource> ResourceCache::getResource(const QUrl& url, const QUrl&
}
if (QThread::currentThread() != thread()) {
qCDebug(networking) << "Fetching asynchronously:" << url;
assert(delayLoad);
getResourceAsynchronously(url);
QMetaObject::invokeMethod(this, "getResource",
Q_ARG(QUrl, url), Q_ARG(QUrl, fallback), Q_ARG(bool, delayLoad));
// Cannot use extra parameter as it might be freed before the invocation
return QSharedPointer<Resource>();
}

17
libraries/networking/src/ResourceCache.h
View file

@ -179,9 +179,6 @@ public:
signals:
void dirty();
public slots:
void checkAsynchronousGets();
protected slots:
void updateTotalSize(const qint64& deltaSize);
@ -190,6 +187,13 @@ protected slots:
// and delegate to it (see TextureCache::prefetch(const QUrl&, int).
ScriptableResource* prefetch(const QUrl& url, void* extra);
/// Loads a resource from the specified URL.
/// \param fallback a fallback URL to load if the desired one is unavailable
/// \param delayLoad if true, don't load the resource immediately; wait until load is first requested
/// \param extra extra data to pass to the creator, if appropriate
QSharedPointer<Resource> getResource(const QUrl& url, const QUrl& fallback = QUrl(),
bool delayLoad = false, void* extra = NULL);
private slots:
void clearATPAssets();
@ -200,13 +204,6 @@ protected:
// the QScriptEngine will delete the pointer when it is garbage collected.
Q_INVOKABLE ScriptableResource* prefetch(const QUrl& url) { return prefetch(url, nullptr); }
/// Loads a resource from the specified URL.
/// \param fallback a fallback URL to load if the desired one is unavailable
/// \param delayLoad if true, don't load the resource immediately; wait until load is first requested
/// \param extra extra data to pass to the creator, if appropriate
QSharedPointer<Resource> getResource(const QUrl& url, const QUrl& fallback = QUrl(),
bool delayLoad = false, void* extra = NULL);
/// Creates a new resource.
virtual QSharedPointer<Resource> createResource(const QUrl& url,
const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) = 0;