diff options
10 files changed, 211 insertions, 258 deletions
diff --git a/src/engine/Qt3DSRenderRuntimeBinding.cpp b/src/engine/Qt3DSRenderRuntimeBinding.cpp index 50ef3df..4499ade 100644 --- a/src/engine/Qt3DSRenderRuntimeBinding.cpp +++ b/src/engine/Qt3DSRenderRuntimeBinding.cpp @@ -716,9 +716,9 @@ struct Qt3DSRenderScene : public Q3DStudio::IScene if (image->m_ImagePath.IsValid() && qt3ds::runtime::isImagePath( image->m_ImagePath.c_str())) { const bool ibl = image->m_MappingMode == ImageMappingModes::LightProbe; - const auto unified = IBufferManager::resolveImagePath( + const auto resolved = IBufferManager::resolveImagePath( QString::fromLatin1(image->m_ImagePath.c_str()), preferKtx); - image->m_LoadedTextureData = mgr.CreateReloadableImage(unified, false, ibl); + image->m_LoadedTextureData = mgr.CreateReloadableImage(resolved, false, ibl); image->m_LoadedTextureData->m_callbacks.push_back(image); } }); @@ -774,8 +774,8 @@ struct Qt3DSRenderSceneManager : public Q3DStudio::ISceneManager, Q3DStudio::SPickFrame m_PickFrame; NVDataRef<QT3DSU8> m_StrTableData; // The boolean is to mark transparent images and ibl images - nvvector<eastl::pair<CRegisteredString, eastl::pair<bool, bool>>> m_SourcePaths; - eastl::hash_set<CRegisteredString> m_SourcePathSet; + nvvector<eastl::pair<QString, eastl::pair<bool, bool>>> m_SourcePaths; + QSet<QString> m_SourcePathSet; Qt3DSRenderScene *m_LastRenderedScene; Q3DStudio::IWindowSystem &m_WindowSystem; @@ -931,59 +931,54 @@ struct Qt3DSRenderSceneManager : public Q3DStudio::ISceneManager, NVConstDataRef<eastl::string> theSourcePathData(inParser->GetSourcePaths()); const QVector<QString> slideSourcePaths = inParser->GetSlideSourcePaths(); IBufferManager &theManager(m_Context->m_Context->GetBufferManager()); + // List of image paths to be loaded in parallel at the end. - QVector<CRegisteredString> theSourcePathList; - QVector<CRegisteredString> iblList; + QVector<QString> theSourcePathList; + QVector<QString> iblList; + + const auto preferKtx = theScene->m_Presentation->m_preferKTX; + const auto flipCompressed = theScene->m_Presentation->m_flipCompressedTextures; + const auto contextType = m_Context->m_Context->GetRenderContext().GetRenderContextType(); + for (QT3DSU32 idx = 0, end = theSourcePathData.size(); idx < end; ++idx) { const eastl::string &theValue = theSourcePathData[idx]; - CRegisteredString theSourcePath = - m_Context->m_CoreContext->GetStringTable().RegisterStr(theValue.c_str()); + QString sourcePath = QString::fromLatin1(theValue.c_str()); size_t theValueSize = theValue.size(); if (theValueSize > 3) { - CRegisteredString theObjectPath = theSourcePath; - if (qt3ds::runtime::isImagePath(theValue.c_str())) { + if (qt3ds::runtime::isImagePath(sourcePath)) { // load only images not on any slide + const QString resolvedPath + = IBufferManager::resolveImagePath(sourcePath, preferKtx); if (!theManager.isReloadableResourcesEnabled() || - !slideSourcePaths.contains(QString::fromLatin1(theValue.c_str()))) { - theManager.SetImageTransparencyToFalseIfNotSet(theObjectPath); - bool ibl = inParser->isIblImage(theObjectPath.c_str()); - bool transparent = theManager.GetImageHasTransparency(theObjectPath); - if (m_SourcePathSet.insert(theSourcePath).second) { - - m_SourcePaths.push_back(eastl::make_pair(theSourcePath, + !slideSourcePaths.contains(sourcePath)) { + theManager.SetImageTransparencyToFalseIfNotSet(resolvedPath); + bool ibl = inParser->isIblImage(theValue); + bool transparent = theManager.GetImageHasTransparency(resolvedPath); + if (!m_SourcePathSet.contains(resolvedPath)) { + m_SourcePaths.push_back(eastl::make_pair(resolvedPath, eastl::make_pair(transparent, ibl))); + m_SourcePathSet.insert(resolvedPath); } if (ibl) - iblList.push_back(theObjectPath); + iblList.push_back(resolvedPath); else - theSourcePathList.push_back(theObjectPath); + theSourcePathList.push_back(resolvedPath); } } else if (theValue.find(".mesh") != eastl::string::npos) { - theManager.LoadMesh(theObjectPath); + theManager.LoadMesh(theManager.GetStringTable().RegisterStr(theValue)); } } } - const auto preferKtx = theScene->m_Presentation->m_preferKTX; - const auto flipCompressed = theScene->m_Presentation->m_flipCompressedTextures; - const auto contextType = m_Context->m_Context->GetRenderContext().GetRenderContextType(); + // Fire off parallel loading of the source paths auto &batchLoader = m_Context->m_Context->GetImageBatchLoader(); - theSourcePathList = IBufferManager::resolveSourcePaths(*m_Context->m_StringTable, - theSourcePathList, preferKtx); - iblList = IBufferManager::resolveSourcePaths(*m_Context->m_StringTable, iblList, - preferKtx); - - QT3DSU64 imageBatchId = batchLoader.LoadImageBatch( - toConstDataRef(theSourcePathList.data(), theSourcePathList.size()), - CRegisteredString(), nullptr, contextType, false, flipCompressed); - QT3DSU64 iblImageBatchId = batchLoader.LoadImageBatch( - toConstDataRef(iblList.data(), iblList.size()), - CRegisteredString(), nullptr, contextType, true, flipCompressed); - batchLoader.BlockUntilLoaded( - static_cast<TImageBatchId>(imageBatchId)); - batchLoader.BlockUntilLoaded( - static_cast<TImageBatchId>(iblImageBatchId)); + QT3DSU64 imageBatchId = batchLoader.LoadImageBatch(theSourcePathList, {}, nullptr, + contextType, false, flipCompressed); + QT3DSU64 iblImageBatchId = batchLoader.LoadImageBatch(iblList, {}, nullptr, contextType, + true, flipCompressed); + batchLoader.BlockUntilLoaded(static_cast<TImageBatchId>(imageBatchId)); + batchLoader.BlockUntilLoaded(static_cast<TImageBatchId>(iblImageBatchId)); theIScene = QT3DS_NEW(m_Context->GetAllocator(), Qt3DSRenderScene)(*m_Context, *m_Context->m_Context, *theScene); @@ -1125,27 +1120,24 @@ struct Qt3DSRenderSceneManager : public Q3DStudio::ISceneManager, { QT3DS_ASSERT(m_Context->m_Context.mPtr); // this means graphics have been initialized - eastl::string theSourcePathStr; IBufferManager &theManager(m_Context->m_Context->GetBufferManager()); - QVector<CRegisteredString> imagePathList; - QVector<CRegisteredString> iblImagePathList; + QVector<QString> imagePathList; + QVector<QString> iblImagePathList; for (QT3DSU32 idx = 0, end = m_SourcePaths.size(); idx < end; ++idx) { - theSourcePathStr.assign(m_SourcePaths[idx].first); + QString theSourcePathStr = m_SourcePaths[idx].first; bool hasTransparency = m_SourcePaths[idx].second.first; bool isIbl = m_SourcePaths[idx].second.second; - if (theSourcePathStr.size() > 4) { - CRegisteredString theObjectPath = m_SourcePaths[idx].first; - if (qt3ds::runtime::isImagePath(theSourcePathStr.c_str())) { + if (theSourcePathStr.length() > 4) { + if (qt3ds::runtime::isImagePath(theSourcePathStr)) { theManager.SetImageHasTransparency( - theObjectPath, hasTransparency, - theManager.GetImageHasOpaquePixels(theObjectPath)); + theSourcePathStr, hasTransparency, + theManager.GetImageHasOpaquePixels(theSourcePathStr)); if (isIbl) - iblImagePathList.push_back(theObjectPath); + iblImagePathList.push_back(theSourcePathStr); else - imagePathList.push_back(theObjectPath); - } else { - if (theSourcePathStr.find(".mesh") != eastl::string::npos) - theManager.LoadMesh(theObjectPath); + imagePathList.push_back(theSourcePathStr); + } else if (theSourcePathStr.contains(QStringLiteral(".mesh"))) { + theManager.LoadMesh(theManager.GetStringTable().RegisterStr(theSourcePathStr)); } } } @@ -1159,22 +1151,12 @@ struct Qt3DSRenderSceneManager : public Q3DStudio::ISceneManager, } { + auto contextType = m_Context->m_Context->GetRenderContext().GetRenderContextType(); QT3DS_PERF_SCOPED_TIMER(m_Context->m_CoreContext->GetPerfTimer(), "Binding: Initial Batch Image Load") auto &batchLoader = m_Context->m_Context->GetImageBatchLoader(); - imagePathList = IBufferManager::resolveSourcePaths(*m_Context->m_StringTable, - imagePathList, pktx); - iblImagePathList = IBufferManager::resolveSourcePaths(*m_Context->m_StringTable, - iblImagePathList, pktx); - - batchLoader.LoadImageBatch( - toConstDataRef(imagePathList.data(), imagePathList.size()), - CRegisteredString(), nullptr, m_Context->m_Context->GetRenderContext() - .GetRenderContextType(), pktx, false); - batchLoader.LoadImageBatch( - toConstDataRef(iblImagePathList.data(), iblImagePathList.size()), - CRegisteredString(), nullptr, m_Context->m_Context->GetRenderContext() - .GetRenderContextType(), pktx, true); + batchLoader.LoadImageBatch(imagePathList, {}, nullptr, contextType, pktx, false); + batchLoader.LoadImageBatch(iblImagePathList, {}, nullptr, contextType, pktx, true); } { @@ -1360,10 +1342,8 @@ struct Qt3DSRenderSceneManager : public Q3DStudio::ISceneManager, QT3DSU32 theBinaryPathOffset = theWriteBuffer.size() - theOffsetStart; theWriteBuffer.write(QT3DSU32(m_SourcePaths.size())); - for (nvvector<pair<CRegisteredString, eastl::pair<bool, bool>>>::iterator iter - = m_SourcePaths.begin(), end = m_SourcePaths.end(); - iter != end; ++iter) { - CRegisteredString theStr(iter->first); + for (auto iter = m_SourcePaths.begin(), end = m_SourcePaths.end(); iter != end; ++iter) { + CRegisteredString theStr(theStrTable.RegisterStr(iter->first)); theStr.Remap(theStrTable.GetRemapMap()); theWriteBuffer.write(size_t(theStr.c_str())); QT3DSU32 theSourcePathFlags = iter->second.first ? 1 : 0; diff --git a/src/runtime/Qt3DSApplication.cpp b/src/runtime/Qt3DSApplication.cpp index db5d359..4c88335 100644 --- a/src/runtime/Qt3DSApplication.cpp +++ b/src/runtime/Qt3DSApplication.cpp @@ -350,26 +350,22 @@ struct STextureUploadRenderTask : public IRenderTask, public IImageLoadListener if (!m_deleteSet.isEmpty()) m_bufferManager.unloadSet(m_deleteSet); if (!m_uploadSet.isEmpty()) { - QVector<CRegisteredString> sourcePaths; + QVector<QString> sourcePaths; for (auto &s : qAsConst(m_uploadSet)) - sourcePaths.push_back(m_bufferManager.GetStringTable().RegisterStr(s)); - QT3DSU32 id = m_batchLoader.LoadImageBatch(toConstDataRef(sourcePaths.data(), - sourcePaths.size()), - CRegisteredString(), - this, m_type, m_preferKtx, false); + sourcePaths.push_back(s); + QT3DSU32 id = m_batchLoader.LoadImageBatch(sourcePaths, {}, this, m_type, + m_preferKtx, false); if (id) { m_batches[id] = m_uploadSet; m_uploadSet.clear(); } } if (!m_uploadWaitSet.isEmpty()) { - QVector<CRegisteredString> sourcePaths; + QVector<QString> sourcePaths; for (auto &s : qAsConst(m_uploadWaitSet)) - sourcePaths.push_back(m_bufferManager.GetStringTable().RegisterStr(s)); - QT3DSU32 id = m_batchLoader.LoadImageBatch(toConstDataRef(sourcePaths.data(), - sourcePaths.size()), - CRegisteredString(), - this, m_type, m_preferKtx, false); + sourcePaths.push_back(s); + QT3DSU32 id = m_batchLoader.LoadImageBatch(sourcePaths, {}, this, m_type, + m_preferKtx, false); if (id) { m_batchLoader.BlockUntilLoaded(id); m_bufferManager.loadSet(m_uploadWaitSet, m_flipCompressedTextures); @@ -379,27 +375,28 @@ struct STextureUploadRenderTask : public IRenderTask, public IImageLoadListener } void add(const QSet<QString> &set, bool wait) { + const auto resolved = IBufferManager::resolveImageSet(set, m_preferKtx); QMutexLocker loc(&m_updateMutex); if (wait) - m_uploadWaitSet.unite(set); + m_uploadWaitSet.unite(resolved); else - m_uploadSet.unite(set); - const auto unified = IBufferManager::resolveImageSet(set, m_preferKtx); - m_deleteSet.subtract(unified); + m_uploadSet.unite(resolved); + + m_deleteSet.subtract(resolved); } void remove(const QSet<QString> &set) { - const auto unified = IBufferManager::resolveImageSet(set, m_preferKtx); + const auto resolved = IBufferManager::resolveImageSet(set, m_preferKtx); QMutexLocker loc(&m_updateMutex); - m_uploadSet.subtract(unified); - m_uploadWaitSet.subtract(unified); - m_deleteSet.unite(unified); + m_uploadSet.subtract(resolved); + m_uploadWaitSet.subtract(resolved); + m_deleteSet.unite(resolved); } bool persistent() const override { return true; } - void OnImageLoadComplete(CRegisteredString inPath, ImageLoadResult::Enum inResult) override + void OnImageLoadComplete(const QString &inPath, ImageLoadResult::Enum inResult) override { Q_UNUSED(inPath); Q_UNUSED(inResult); diff --git a/src/runtimerender/Qt3DSRenderUIPLoader.cpp b/src/runtimerender/Qt3DSRenderUIPLoader.cpp index f276f6d..769c28e 100644 --- a/src/runtimerender/Qt3DSRenderUIPLoader.cpp +++ b/src/runtimerender/Qt3DSRenderUIPLoader.cpp @@ -1844,7 +1844,10 @@ struct SRenderUIPLoader : public IDOMReferenceResolver m_Reader.Att("hasTransparency", hasTransparency); bool hasOpaque = false; m_Reader.Att("hasOpaquePixels", hasOpaque); - m_BufferManager.SetImageHasTransparency(imgPath, hasTransparency, + auto resolved = IBufferManager::resolveImagePath( + QString::fromLatin1(imgPath.c_str()), + m_Presentation->m_preferKTX); + m_BufferManager.SetImageHasTransparency(resolved, hasTransparency, hasOpaque); } } diff --git a/src/runtimerender/graphobjects/Qt3DSRenderImage.cpp b/src/runtimerender/graphobjects/Qt3DSRenderImage.cpp index 458f3bf..78760b6 100644 --- a/src/runtimerender/graphobjects/Qt3DSRenderImage.cpp +++ b/src/runtimerender/graphobjects/Qt3DSRenderImage.cpp @@ -103,13 +103,13 @@ bool SImage::ClearDirty(IBufferManager &inBufferManager, IOffscreenRenderManager if (m_ImagePath.IsValid() && !m_OffscreenRendererId.IsValid() && !inRenderManager.HasOffscreenRenderer(m_ImagePath)) { // Image has sourcepath set - const QString unifiedPath = IBufferManager::resolveImagePath( + const QString resolvedPath = IBufferManager::resolveImagePath( QString::fromUtf8(m_ImagePath.c_str()), preferKtx); - if (!m_LoadedTextureData || m_LoadedTextureData->m_path != unifiedPath) { + if (!m_LoadedTextureData || m_LoadedTextureData->m_path != resolvedPath) { if (m_LoadedTextureData) m_LoadedTextureData->m_callbacks.removeOne(this); forIbl = forIbl || m_MappingMode == ImageMappingModes::LightProbe; - m_LoadedTextureData = inBufferManager.CreateReloadableImage(unifiedPath, false, + m_LoadedTextureData = inBufferManager.CreateReloadableImage(resolvedPath, false, forIbl, flipCompressed); m_LoadedTextureData->m_callbacks.push_back(this); } @@ -120,7 +120,7 @@ bool SImage::ClearDirty(IBufferManager &inBufferManager, IOffscreenRenderManager newImage.m_BSDFMipMap = m_LoadedTextureData->m_BSDFMipMap; } else if (m_Flags.IsForceLoad()) { QSet<QString> ls; - ls.insert(unifiedPath); + ls.insert(resolvedPath); inBufferManager.loadSet(ls, flipCompressed); newImage.m_Texture = m_LoadedTextureData->m_Texture; newImage.m_TextureFlags = m_LoadedTextureData->m_TextureFlags; diff --git a/src/runtimerender/resourcemanager/Qt3DSRenderBufferManager.cpp b/src/runtimerender/resourcemanager/Qt3DSRenderBufferManager.cpp index 7adba7b..658916f 100644 --- a/src/runtimerender/resourcemanager/Qt3DSRenderBufferManager.cpp +++ b/src/runtimerender/resourcemanager/Qt3DSRenderBufferManager.cpp @@ -247,9 +247,9 @@ QSet<QString> IBufferManager::resolveImageSet(const QSet<QString> &set, bool pre { QSet<QString> ret; for (auto &sourcePath : set) { - auto unified = resolveImagePath(sourcePath, preferKtx); - if (!unified.isEmpty()) - ret.insert(unified); + auto resolved = resolveImagePath(sourcePath, preferKtx); + if (!resolved.isEmpty()) + ret.insert(resolved); } return ret; } @@ -260,9 +260,9 @@ QVector<CRegisteredString> IBufferManager::resolveSourcePaths( QVector<CRegisteredString> ret; for (int i = 0; i < sourcePaths.size(); i++) { QString path = QString::fromLatin1(sourcePaths[i].c_str()); - auto unified = strTable.RegisterStr(IBufferManager::resolveImagePath(path, preferKtx)); - if (unified.IsValid()) - ret.append(unified); + auto resolved = strTable.RegisterStr(IBufferManager::resolveImagePath(path, preferKtx)); + if (resolved.IsValid()) + ret.append(resolved); } return ret; } @@ -316,9 +316,9 @@ struct SBufferManager : public IBufferManager typedef eastl::hash_set<CRegisteredString, eastl::hash<CRegisteredString>, eastl::equal_to<CRegisteredString>, ForwardingAllocator> TStringSet; - typedef nvhash_map<CRegisteredString, SImageEntry> TImageMap; + typedef QHash<QString, SImageEntry> TImageMap; typedef nvhash_map<CRegisteredString, SRenderMesh *> TMeshMap; - typedef nvhash_map<CRegisteredString, CRegisteredString> TAliasImageMap; + typedef QMap<QString, QString> TAliasImageMap; NVScopedRefCounted<NVRenderContext> m_Context; NVScopedRefCounted<IStringTable> m_StrTable; @@ -328,8 +328,8 @@ struct SBufferManager : public IBufferManager TStr m_PathBuilder; TImageMap m_ImageMap; Mutex m_LoadedImageSetMutex; - TStringSet m_LoadedImageSet; - TAliasImageMap m_AliasImageMap; + QSet<QString> m_LoadedImageSet; + QMap<QString, QString> m_AliasImageMap; TMeshMap m_MeshMap; SPrimitiveEntry m_PrimitiveNames[5]; nvvector<qt3ds::render::NVRenderVertexBufferEntry> m_EntryBuffer; @@ -350,11 +350,7 @@ struct SBufferManager : public IBufferManager , m_PerfTimer(inTimer) , mRefCount(0) , m_PathBuilder(ForwardingAllocator(ctx.GetAllocator(), "SBufferManager::m_PathBuilder")) - , m_ImageMap(ctx.GetAllocator(), "SBufferManager::m_ImageMap") , m_LoadedImageSetMutex(ctx.GetAllocator()) - , m_LoadedImageSet( - ForwardingAllocator(ctx.GetAllocator(), "SBufferManager::m_LoadedImageSet")) - , m_AliasImageMap(ctx.GetAllocator(), "SBufferManager::m_AliasImageMap") , m_MeshMap(ctx.GetAllocator(), "SBufferManager::m_MeshMap") , m_EntryBuffer(ctx.GetAllocator(), "SBufferManager::m_EntryBuffer") , m_GPUSupportsCompressedTextures(ctx.AreCompressedTexturesSupported()) @@ -365,94 +361,79 @@ struct SBufferManager : public IBufferManager QT3DS_IMPLEMENT_REF_COUNT_ADDREF_RELEASE(m_Context->GetAllocator()) - CRegisteredString CombineBaseAndRelative(const char8_t *inBase, - const char8_t *inRelative) override - { - CFileTools::CombineBaseAndRelative(inBase, inRelative, m_PathBuilder); - return m_StrTable->RegisterStr(m_PathBuilder.c_str()); - } - - void SetImageHasTransparency(CRegisteredString inImagePath, bool inHasTransparency, + void SetImageHasTransparency(const QString &resolvedPath, bool inHasTransparency, bool hasOpaque) override { - pair<TImageMap::iterator, bool> theImage = - m_ImageMap.insert(make_pair(inImagePath, SImageEntry())); - theImage.first->second.m_TextureFlags.SetHasTransparency(inHasTransparency); - theImage.first->second.m_TextureFlags.setHasOpaquePixels(hasOpaque); + if (!m_ImageMap.contains(resolvedPath)) + m_ImageMap.insert(resolvedPath, SImageEntry()); + SImageEntry &entry = m_ImageMap[resolvedPath]; + entry.m_TextureFlags.SetHasTransparency(inHasTransparency); + entry.m_TextureFlags.setHasOpaquePixels(hasOpaque); } - bool GetImageHasTransparency(CRegisteredString inSourcePath) const override + bool GetImageHasTransparency(const QString &resolvedPath) const override { - TImageMap::const_iterator theIter = m_ImageMap.find(inSourcePath); + TImageMap::const_iterator theIter = m_ImageMap.find(resolvedPath); if (theIter != m_ImageMap.end()) - return theIter->second.m_TextureFlags.HasTransparency(); + return theIter->m_TextureFlags.HasTransparency(); return false; } - bool GetImageHasOpaquePixels(CRegisteredString inSourcePath) const override + bool GetImageHasOpaquePixels(const QString &resolvedPath) const override { - TImageMap::const_iterator theIter = m_ImageMap.find(inSourcePath); + TImageMap::const_iterator theIter = m_ImageMap.find(resolvedPath); if (theIter != m_ImageMap.end()) - return theIter->second.m_TextureFlags.HasOpaquePixels(); + return theIter->m_TextureFlags.HasOpaquePixels(); return false; } - void SetImageTransparencyToFalseIfNotSet(CRegisteredString inSourcePath) override + void SetImageTransparencyToFalseIfNotSet(const QString &resolvedPath) override { - pair<TImageMap::iterator, bool> theImage = - m_ImageMap.insert(make_pair(inSourcePath, SImageEntry())); - // If we did actually insert something - if (theImage.second) - theImage.first->second.m_TextureFlags.SetHasTransparency(false); + if (!m_ImageMap.contains(resolvedPath)) { + m_ImageMap.insert(resolvedPath, SImageEntry()); + m_ImageMap[resolvedPath].m_TextureFlags.SetHasTransparency(false); + } } - void SetInvertImageUVCoords(CRegisteredString inImagePath, bool inShouldInvertCoords) override + void SetInvertImageUVCoords(const QString &resolvedPath, bool inShouldInvertCoords) override { - pair<TImageMap::iterator, bool> theImage = - m_ImageMap.insert(make_pair(inImagePath, SImageEntry())); - theImage.first->second.m_TextureFlags.SetInvertUVCoords(inShouldInvertCoords); + if (!m_ImageMap.contains(resolvedPath)) + m_ImageMap.insert(resolvedPath, SImageEntry()); + SImageEntry &entry = m_ImageMap[resolvedPath]; + entry.m_TextureFlags.SetInvertUVCoords(inShouldInvertCoords); } - bool IsImageLoaded(CRegisteredString inSourcePath) override + bool IsImageLoaded(const QString &sourcePath) override { Mutex::ScopedLock __locker(m_LoadedImageSetMutex); - return m_LoadedImageSet.find(inSourcePath) != m_LoadedImageSet.end(); + return m_LoadedImageSet.find(sourcePath) != m_LoadedImageSet.end(); } - bool AliasImagePath(CRegisteredString inSourcePath, CRegisteredString inAliasPath, - bool inIgnoreIfLoaded) override + bool AliasImagePath(const QString &resolvedPath, const QString &inAliasPath, + bool inIgnoreIfLoaded) override { - if (inSourcePath.IsValid() == false || inAliasPath.IsValid() == false) + if (resolvedPath.isEmpty() || inAliasPath.isEmpty()) return false; // If the image is loaded then we ignore this call in some cases. - if (inIgnoreIfLoaded && IsImageLoaded(inSourcePath)) + if (inIgnoreIfLoaded && IsImageLoaded(resolvedPath)) return false; - m_AliasImageMap.insert(eastl::make_pair(inSourcePath, inAliasPath)); + m_AliasImageMap.insert(resolvedPath, inAliasPath); return true; } - void UnaliasImagePath(CRegisteredString inSourcePath) override + void UnaliasImagePath(const QString &inSourcePath) override { - m_AliasImageMap.erase(inSourcePath); + m_AliasImageMap.remove(inSourcePath); } - CRegisteredString GetImagePath(CRegisteredString inSourcePath) override + QString GetImagePath(const QString &inSourcePath) override { TAliasImageMap::iterator theAliasIter = m_AliasImageMap.find(inSourcePath); if (theAliasIter != m_AliasImageMap.end()) - return theAliasIter->second; + return *theAliasIter; return inSourcePath; } - CRegisteredString getImagePath(const QString &path) - { - TAliasImageMap::iterator theAliasIter - = m_AliasImageMap.find(m_StrTable->RegisterStr(qPrintable(path))); - if (theAliasIter != m_AliasImageMap.end()) - return theAliasIter->second; - return m_StrTable->RegisterStr(qPrintable(path)); - } - template <typename V, typename C> void iterateAll(const V &vv, C c) { @@ -462,10 +443,10 @@ struct SBufferManager : public IBufferManager void loadTextureImage(SReloadableImageTextureData &data, bool flipCompressed = false) { - CRegisteredString imagePath = getImagePath(data.m_path); + QString imagePath = GetImagePath(data.m_path); TImageMap::iterator theIter = m_ImageMap.find(imagePath); - if ((theIter == m_ImageMap.end() || theIter->second.m_Loaded == false) - && imagePath.IsValid()) { + if ((theIter == m_ImageMap.end() || theIter->m_Loaded == false) + && !imagePath.isEmpty()) { NVScopedReleasable<SLoadedTexture> theLoadedImage; SImageTextureData textureData; @@ -482,14 +463,12 @@ struct SBufferManager : public IBufferManager } else { // We want to make sure that bad path fails once and doesn't fail over and over // again which could slow down the system quite a bit. - pair<TImageMap::iterator, bool> theImage = - m_ImageMap.insert(make_pair(imagePath, SImageEntry())); - theImage.first->second.m_Loaded = true; - qCWarning(WARNING, "Failed to load image: %s", imagePath.c_str()); - theIter = theImage.first; + auto theImage = m_ImageMap.insert(imagePath, SImageEntry()); + theImage->m_Loaded = true; + qCWarning(WARNING) << "Failed to load image: " << imagePath; } } else { - SImageEntry textureData = theIter->second; + const SImageEntry textureData = *theIter; if (textureData.m_Loaded) { data.m_Texture = textureData.m_Texture; data.m_TextureFlags = textureData.m_TextureFlags; @@ -574,24 +553,24 @@ struct SBufferManager : public IBufferManager #endif loadTextureImage(*m_reloadableTextures[path], flipCompressed); - CRegisteredString imagePath = getImagePath(path); + QString imagePath = GetImagePath(path); TImageMap::iterator theIter = m_ImageMap.find(imagePath); #ifndef NO_EXTERNAL_LOOKUP // Failed to look up image from map, perhaps external of UIP/UIA image // Try with full URI and load from filesystem. if (theIter == m_ImageMap.end()) - theIter = m_ImageMap.find(getImagePath(inSourcePath)); + theIter = m_ImageMap.find(GetImagePath(inSourcePath)); if (theIter == m_ImageMap.end()) { loadTextureImage(*m_reloadableTextures[path], flipCompressed); - imagePath = getImagePath(path); + imagePath = GetImagePath(path); theIter = m_ImageMap.find(imagePath); if (theIter == m_ImageMap.end()) - theIter = m_ImageMap.find(getImagePath(inSourcePath)); + theIter = m_ImageMap.find(GetImagePath(inSourcePath)); } #endif if (theIter != m_ImageMap.end()) { - SImageEntry textureData = theIter->second; + const SImageEntry textureData = *theIter; if (textureData.m_Loaded) { m_reloadableTextures[path]->m_Texture = textureData.m_Texture; m_reloadableTextures[path]->m_TextureFlags = textureData.m_TextureFlags; @@ -603,19 +582,19 @@ struct SBufferManager : public IBufferManager return m_reloadableTextures[path]; } - void doImageLoad(CRegisteredString inImagePath, + void doImageLoad(const QString inImagePath, NVScopedReleasable<SLoadedTexture> &theLoadedImage, bool inFlipCompressed = false) { QT3DS_PERF_SCOPED_TIMER(m_PerfTimer, "BufferManager: Image Decompression") theLoadedImage = SLoadedTexture::Load( - inImagePath.c_str(), m_Context->GetFoundation(), *m_InputStreamFactory, + inImagePath, m_Context->GetFoundation(), *m_InputStreamFactory, true, inFlipCompressed, m_Context->GetRenderContextType(), this); // Hackish solution to custom materials not finding their textures if they are used // in sub-presentations. if (!theLoadedImage) { - if (QDir(inImagePath.c_str()).isRelative()) { - QString searchPath = inImagePath.c_str(); + if (QDir(inImagePath).isRelative()) { + QString searchPath = inImagePath; // Trying relative to search directories. if (searchPath.startsWith(QLatin1String("../"))) { @@ -646,7 +625,7 @@ struct SBufferManager : public IBufferManager // have absolute path at this point. It points to the wrong place with // the new project structure, so we need to split it up and construct // the new absolute path here. - QString wholePath = inImagePath.c_str(); + QString wholePath = inImagePath; QStringList splitPath = wholePath.split(QLatin1String("../")); if (splitPath.size() > 1) { QString searchPath = splitPath.at(0) + splitPath.at(1); @@ -676,7 +655,7 @@ struct SBufferManager : public IBufferManager return m_reloadableResources; } - SImageTextureData LoadRenderImage(CRegisteredString inImagePath, + SImageTextureData LoadRenderImage(const QString &inImagePath, SLoadedTexture &inLoadedImage, bool inForceScanForTransparency, bool inBsdfMipmaps) override { @@ -685,10 +664,12 @@ struct SBufferManager : public IBufferManager Mutex::ScopedLock __mapLocker(m_LoadedImageSetMutex); m_LoadedImageSet.insert(inImagePath); } - pair<TImageMap::iterator, bool> theImage = - m_ImageMap.insert(make_pair(inImagePath, SImageEntry())); - bool wasInserted = theImage.second; - theImage.first->second.m_Loaded = true; + bool wasInserted = !m_ImageMap.contains(inImagePath); + if (wasInserted) + m_ImageMap.insert(inImagePath, SImageEntry()); + + auto &theImage = m_ImageMap[inImagePath]; + theImage.m_Loaded = true; // inLoadedImage.EnsureMultiplerOfFour( m_Context->GetFoundation(), inImagePath.c_str() ); NVRenderTexture2D *theTexture = m_Context->CreateTexture2D(); @@ -719,12 +700,12 @@ struct SBufferManager : public IBufferManager if (inBsdfMipmaps && NVRenderTextureFormats::isUncompressedTextureFormat(inLoadedImage.format)) { theTexture->SetMinFilter(NVRenderTextureMinifyingOp::LinearMipmapLinear); - Qt3DSRenderPrefilterTexture *theBSDFMipMap = theImage.first->second.m_BSDFMipMap; + Qt3DSRenderPrefilterTexture *theBSDFMipMap = theImage.m_BSDFMipMap; if (theBSDFMipMap == NULL) { theBSDFMipMap = Qt3DSRenderPrefilterTexture::Create( m_Context, inLoadedImage.width, inLoadedImage.height, *theTexture, destFormat, m_Context->GetFoundation()); - theImage.first->second.m_BSDFMipMap = theBSDFMipMap; + theImage.m_BSDFMipMap = theBSDFMipMap; } if (theBSDFMipMap) { @@ -733,7 +714,7 @@ struct SBufferManager : public IBufferManager } } } else if (inLoadedImage.dds) { - theImage.first->second.m_Texture = theTexture; + theImage.m_Texture = theTexture; bool supportsCompressedTextures = m_GPUSupportsCompressedTextures; bool isACompressedTexture = NVRenderTextureFormats::isCompressedTextureFormat(inLoadedImage.format); @@ -742,10 +723,10 @@ struct SBufferManager : public IBufferManager // test code for DXT decompression // if ( isDXT ) requiresDecompression = true; if (requiresDecompression) { - qCWarning(WARNING, PERF_INFO, - "Image %s is compressed format which is unsupported by " - "the graphics subsystem, decompressing in CPU", - inImagePath.c_str()); + qCWarning(WARNING, PERF_INFO) + << "Image %s is compressed format which is unsupported by " + << "the graphics subsystem, decompressing in CPU" + << inImagePath; } STextureData theDecompressedImage; for (int idx = 0; idx < inLoadedImage.dds->numMipmaps; ++idx) { @@ -775,25 +756,25 @@ struct SBufferManager : public IBufferManager inLoadedImage.ReleaseDecompressedTexture(theDecompressedImage); } if (wasInserted || inForceScanForTransparency) { - auto &flags = theImage.first->second.m_TextureFlags; + auto &flags = theImage.m_TextureFlags; bool alsoOpaquePixels = false; flags.SetHasTransparency(inLoadedImage.ScanForTransparency(alsoOpaquePixels)); flags.setHasOpaquePixels(alsoOpaquePixels); } - theImage.first->second.m_Texture = theTexture; - return theImage.first->second; + theImage.m_Texture = theTexture; + return theImage; } - SImageTextureData LoadRenderImage(CRegisteredString inImagePath, + SImageTextureData LoadRenderImage(const QString &inImagePath, bool inForceScanForTransparency, bool inBsdfMipmaps) override { - inImagePath = GetImagePath(inImagePath); + const QString imagePath = GetImagePath(inImagePath); - if (!inImagePath.IsValid()) + if (imagePath.isEmpty()) return SImageEntry(); TImageMap::iterator theIter = m_ImageMap.find(inImagePath); - if (theIter == m_ImageMap.end() && inImagePath.IsValid()) { + if (theIter == m_ImageMap.end() && !imagePath.isEmpty()) { NVScopedReleasable<SLoadedTexture> theLoadedImage; doImageLoad(inImagePath, theLoadedImage); @@ -805,14 +786,13 @@ struct SBufferManager : public IBufferManager // We want to make sure that bad path fails once and doesn't fail over and over // again // which could slow down the system quite a bit. - pair<TImageMap::iterator, bool> theImage = - m_ImageMap.insert(make_pair(inImagePath, SImageEntry())); - theImage.first->second.m_Loaded = true; - qCWarning(WARNING, "Failed to load image: %s", inImagePath.c_str()); - theIter = theImage.first; + auto theImage = m_ImageMap.insert(inImagePath, SImageEntry()); + theImage->m_Loaded = true; + qCWarning(WARNING) << "Failed to load image: " << inImagePath; + theIter = theImage; } } - return theIter->second; + return *theIter; } qt3dsimp::SMultiLoadResult LoadPrimitive(const char8_t *inRelativePath) @@ -1324,7 +1304,7 @@ struct SBufferManager : public IBufferManager m_MeshMap.clear(); for (TImageMap::iterator iter = m_ImageMap.begin(), end = m_ImageMap.end(); iter != end; ++iter) { - SImageEntry &theEntry = iter->second; + SImageEntry &theEntry = *iter; ReleaseTexture(theEntry); } m_ImageMap.clear(); @@ -1347,14 +1327,15 @@ struct SBufferManager : public IBufferManager } } { - TImageMap::iterator iter = m_ImageMap.find(inSourcePath); + const QString imagePath = QString::fromLatin1(inSourcePath.c_str()); + TImageMap::iterator iter = m_ImageMap.find(imagePath); if (iter != m_ImageMap.end()) { - SImageEntry &theEntry = iter->second; + SImageEntry &theEntry = *iter; ReleaseTexture(theEntry); - m_ImageMap.erase(inSourcePath); + m_ImageMap.remove(imagePath); { Mutex::ScopedLock __locker(m_LoadedImageSetMutex); - m_LoadedImageSet.erase(inSourcePath); + m_LoadedImageSet.remove(imagePath); } } } diff --git a/src/runtimerender/resourcemanager/Qt3DSRenderBufferManager.h b/src/runtimerender/resourcemanager/Qt3DSRenderBufferManager.h index 922e502..7445b90 100644 --- a/src/runtimerender/resourcemanager/Qt3DSRenderBufferManager.h +++ b/src/runtimerender/resourcemanager/Qt3DSRenderBufferManager.h @@ -54,20 +54,17 @@ namespace render { virtual ~IBufferManager() {} public: - // Path manipulation used to get the final path form a base path plus relative extension - virtual CRegisteredString CombineBaseAndRelative(const char8_t *inBase, - const char8_t *inRelative) = 0; - virtual void SetImageHasTransparency(CRegisteredString inSourcePath, + virtual void SetImageHasTransparency(const QString &resolvedPath, bool inHasTransparency, bool alsoOpaque) = 0; - virtual bool GetImageHasTransparency(CRegisteredString inSourcePath) const = 0; - virtual bool GetImageHasOpaquePixels(CRegisteredString inSourcePath) const = 0; - virtual void SetImageTransparencyToFalseIfNotSet(CRegisteredString inSourcePath) = 0; - virtual void SetInvertImageUVCoords(CRegisteredString inSourcePath, + virtual bool GetImageHasTransparency(const QString &resolvedPath) const = 0; + virtual bool GetImageHasOpaquePixels(const QString &resolvedPath) const = 0; + virtual void SetImageTransparencyToFalseIfNotSet(const QString &resolvedPathh) = 0; + virtual void SetInvertImageUVCoords(const QString &resolvedPath, bool inShouldInvertCoords) = 0; // Returns true if this image has been loaded into memory // This call is threadsafe. Nothing else on this object is guaranteed to be. - virtual bool IsImageLoaded(CRegisteredString inSourcePath) = 0; + virtual bool IsImageLoaded(const QString &sourcePath) = 0; // Alias one image path with another image path. Optionally this object will ignore the // call if @@ -75,9 +72,9 @@ namespace render { // to be shown // in place of an image that is loading offline. // Returns true if the image was aliased, false otherwise. - virtual bool AliasImagePath(CRegisteredString inSourcePath, CRegisteredString inAliasPath, + virtual bool AliasImagePath(const QString &resolvedPath, const QString &inAliasPath, bool inIgnoreIfLoaded) = 0; - virtual void UnaliasImagePath(CRegisteredString inSourcePath) = 0; + virtual void UnaliasImagePath(const QString &resolvedPath) = 0; // Return resolved imagepaths from unresolved sourcepaths static QString resolveImagePath(const QString &sourcePath, bool preferKtx); @@ -87,15 +84,15 @@ namespace render { // Returns the given source path unless the source path is aliased; in which case returns // the aliased path. - virtual CRegisteredString GetImagePath(CRegisteredString inSourcePath) = 0; + virtual QString GetImagePath(const QString &sourcePath) = 0; // Returns a texture and a boolean indicating if this texture has transparency in it or not. // Can't name this LoadImage because that gets mangled by windows to LoadImageA (uggh) // In some cases we need to only scan particular images for transparency. - virtual SImageTextureData LoadRenderImage(CRegisteredString inImagePath, + virtual SImageTextureData LoadRenderImage(const QString &sourcePath, SLoadedTexture &inTexture, bool inForceScanForTransparency = false, bool inBsdfMipmaps = false) = 0; - virtual SImageTextureData LoadRenderImage(CRegisteredString inSourcePath, + virtual SImageTextureData LoadRenderImage(const QString &sourcePath, bool inForceScanForTransparency = false, bool inBsdfMipmaps = false) = 0; @@ -106,8 +103,8 @@ namespace render { virtual void enableReloadableResources(bool enable) = 0; virtual bool isReloadableResourcesEnabled() const = 0; - virtual void loadSet(const QSet<QString> &unifiedImageSet, bool flipCompressed) = 0; - virtual void unloadSet(const QSet<QString> &unifiedImageSet) = 0; + virtual void loadSet(const QSet<QString> &resolvedImageSet, bool flipCompressed) = 0; + virtual void unloadSet(const QSet<QString> &resolvedImageSet) = 0; virtual void reloadAll(bool flipCompressed) = 0; virtual void loadCustomMesh(const QString &name, qt3dsimp::Mesh *mesh) = 0; diff --git a/src/runtimerender/resourcemanager/Qt3DSRenderImageBatchLoader.cpp b/src/runtimerender/resourcemanager/Qt3DSRenderImageBatchLoader.cpp index 01ec9d4..253f481 100644 --- a/src/runtimerender/resourcemanager/Qt3DSRenderImageBatchLoader.cpp +++ b/src/runtimerender/resourcemanager/Qt3DSRenderImageBatchLoader.cpp @@ -54,12 +54,12 @@ typedef Mutex::ScopedLock TScopedLock; struct SLoadingImage { SImageLoaderBatch *m_Batch; - CRegisteredString m_SourcePath; + QString m_SourcePath; QT3DSU64 m_TaskId; SLoadingImage *m_Tail; // Called from main thread - SLoadingImage(CRegisteredString inSourcePath) + SLoadingImage(const QString &inSourcePath) : m_Batch(NULL) , m_SourcePath(inSourcePath) , m_TaskId(0) @@ -113,8 +113,8 @@ struct SImageLoaderBatch // Called from main thread static SImageLoaderBatch *CreateLoaderBatch(SBatchLoader &inLoader, TImageBatchId inBatchId, - NVConstDataRef<CRegisteredString> inSourcePaths, - CRegisteredString inImageTillLoaded, + const QVector<QString> &inSourcePaths, + const QString &inImageTillLoaded, IImageLoadListener *inListener, NVRenderContextType contextType, bool iblImage, @@ -154,12 +154,12 @@ struct SImageLoaderBatch } // Called from main thread void Cancel(); - void Cancel(CRegisteredString inSourcePath); + void Cancel(const QString &inSourcePath); }; struct SBatchLoadedImage { - CRegisteredString m_SourcePath; + QString m_SourcePath; SLoadedTexture *m_Texture; SImageLoaderBatch *m_Batch; SBatchLoadedImage() @@ -169,7 +169,7 @@ struct SBatchLoadedImage } // Called from loading thread - SBatchLoadedImage(CRegisteredString inSourcePath, SLoadedTexture *inTexture, + SBatchLoadedImage(QString inSourcePath, SLoadedTexture *inTexture, SImageLoaderBatch &inBatch) : m_SourcePath(inSourcePath) , m_Texture(inTexture) @@ -184,7 +184,7 @@ struct SBatchLoadedImage struct SBatchLoader : public IImageBatchLoader { typedef nvhash_map<TImageBatchId, SImageLoaderBatch *> TImageLoaderBatchMap; - typedef nvhash_map<CRegisteredString, TImageBatchId> TSourcePathToBatchMap; + typedef QMap<QString, TImageBatchId> TSourcePathToBatchMap; typedef Pool<SLoadingImage, ForwardingAllocator> TLoadingImagePool; typedef Pool<SImageLoaderBatch, ForwardingAllocator> TBatchPool; @@ -230,7 +230,6 @@ struct SBatchLoader : public IImageBatchLoader , m_LoaderMutex(inFoundation.getAllocator()) , m_LoadedImages(inFoundation.getAllocator(), "SBatchLoader::m_LoadedImages") , m_FinishedBatches(inFoundation.getAllocator(), "SBatchLoader::m_FinishedBatches") - , m_SourcePathToBatches(inFoundation.getAllocator(), "SBatchLoader::m_SourcePathToBatches") , m_LoaderBuilderWorkspace(inFoundation.getAllocator(), "SBatchLoader::m_LoaderBuilderWorkspace") , m_LoadingImagePool( @@ -260,8 +259,8 @@ struct SBatchLoader : public IImageBatchLoader // paths // until said path is loaded. // An optional listener can be passed in to get callbacks about the batch. - TImageBatchId LoadImageBatch(NVConstDataRef<CRegisteredString> inSourcePaths, - CRegisteredString inImageTillLoaded, + TImageBatchId LoadImageBatch(const QVector<QString> &inSourcePaths, + const QString &inImageTillLoaded, IImageLoadListener *inListener, NVRenderContextType contextType, bool iblImages, @@ -297,12 +296,12 @@ struct SBatchLoader : public IImageBatchLoader } // Blocks if the image is currently in-flight - void CancelImageLoading(CRegisteredString inSourcePath) override + void CancelImageLoading(const QString &inSourcePath) override { TScopedLock __loaderLock(m_LoaderMutex); TSourcePathToBatchMap::iterator theIter = m_SourcePathToBatches.find(inSourcePath); if (theIter != m_SourcePathToBatches.end()) { - TImageBatchId theBatchId = theIter->second; + const TImageBatchId &theBatchId = theIter.value(); TImageLoaderBatchMap::iterator theBatchIter = m_Batches.find(theBatchId); if (theBatchIter != m_Batches.end()) theBatchIter->second->Cancel(inSourcePath); @@ -334,7 +333,7 @@ struct SBatchLoader : public IImageBatchLoader { TScopedLock __loaderLock(m_LoaderMutex); if (inTexture == nullptr) - qCWarning(WARNING, "Failed to load image: %s", inImage.m_SourcePath.c_str()); + qCWarning(WARNING) << "Failed to load image: " << inImage.m_SourcePath; m_LoadedImages.push_back( SBatchLoadedImage(inImage.m_SourcePath, inTexture, *inImage.m_Batch)); inImage.m_Batch->IncrementLoadedImageCount(); @@ -347,7 +346,7 @@ struct SBatchLoader : public IImageBatchLoader // Pass 1 - send out all image loaded signals for (QT3DSU32 idx = 0, end = m_LoadedImages.size(); idx < end; ++idx) { - m_SourcePathToBatches.erase(m_LoadedImages[idx].m_SourcePath); + m_SourcePathToBatches.remove(m_LoadedImages[idx].m_SourcePath); m_LoadedImages[idx].Finalize(m_BufferManager); m_LoadedImages[idx].m_Batch->IncrementFinalizedImageCount(); if (m_LoadedImages[idx].m_Batch->IsFinalizedFinished()) @@ -389,7 +388,7 @@ void SLoadingImage::LoadImage(void *inImg) QT3DS_PERF_SCOPED_TIMER(theThis->m_Batch->m_Loader.m_PerfTimer, "BatchLoader: Image Decompression") if (theThis->m_Batch->m_Loader.m_BufferManager.IsImageLoaded(theThis->m_SourcePath) == false) { SLoadedTexture *theTexture = SLoadedTexture::Load( - theThis->m_SourcePath.c_str(), theThis->m_Batch->m_Loader.m_Foundation, + theThis->m_SourcePath, theThis->m_Batch->m_Loader.m_Foundation, theThis->m_Batch->m_Loader.m_InputStreamFactory, true, theThis->m_Batch->m_flipCompressedTextures, theThis->m_Batch->m_contextType, @@ -413,7 +412,6 @@ void SLoadingImage::TaskCancelled(void *inImg) bool SBatchLoadedImage::Finalize(IBufferManager &inMgr) { if (m_Texture) { - eastl::string thepath(m_SourcePath); bool isIBL = this->m_Batch->m_ibl; inMgr.LoadRenderImage(m_SourcePath, *m_Texture, false, isIBL); inMgr.UnaliasImagePath(m_SourcePath); @@ -432,8 +430,8 @@ bool SBatchLoadedImage::Finalize(IBufferManager &inMgr) SImageLoaderBatch * SImageLoaderBatch::CreateLoaderBatch(SBatchLoader &inLoader, TImageBatchId inBatchId, - NVConstDataRef<CRegisteredString> inSourcePaths, - CRegisteredString inImageTillLoaded, + const QVector<QString> &inSourcePaths, + const QString &inImageTillLoaded, IImageLoadListener *inListener, NVRenderContextType contextType, bool iblImages, bool flipCompressedTextures) @@ -441,22 +439,20 @@ SImageLoaderBatch::CreateLoaderBatch(SBatchLoader &inLoader, TImageBatchId inBat TLoadingImageList theImages; QT3DSU32 theLoadingImageCount = 0; for (QT3DSU32 idx = 0, end = inSourcePaths.size(); idx < end; ++idx) { - CRegisteredString theSourcePath(inSourcePaths[idx]); + const QString theSourcePath(inSourcePaths[idx]); - if (theSourcePath.IsValid() == false) + if (theSourcePath.isEmpty()) continue; if (inLoader.m_BufferManager.IsImageLoaded(theSourcePath)) continue; - eastl::pair<SBatchLoader::TSourcePathToBatchMap::iterator, bool> theInserter = - inLoader.m_SourcePathToBatches.insert(eastl::make_pair(inSourcePaths[idx], inBatchId)); - - // If the loader has already seen this image. - if (theInserter.second == false) + if (inLoader.m_SourcePathToBatches.contains(inSourcePaths[idx])) continue; - if (inImageTillLoaded.IsValid()) { + inLoader.m_SourcePathToBatches.insert(inSourcePaths[idx], inBatchId); + + if (!inImageTillLoaded.isEmpty()) { // Alias the image so any further requests for this source path will result in // the default images (image till loaded). bool aliasSuccess = @@ -520,7 +516,7 @@ void SImageLoaderBatch::Cancel() m_Loader.m_ThreadPool.CancelTask(iter->m_TaskId); } -void SImageLoaderBatch::Cancel(CRegisteredString inSourcePath) +void SImageLoaderBatch::Cancel(const QString &inSourcePath) { for (TLoadingImageList::iterator iter = m_Images.begin(), end = m_Images.end(); iter != end; ++iter) { diff --git a/src/runtimerender/resourcemanager/Qt3DSRenderImageBatchLoader.h b/src/runtimerender/resourcemanager/Qt3DSRenderImageBatchLoader.h index 03b5599..e8fd82d 100644 --- a/src/runtimerender/resourcemanager/Qt3DSRenderImageBatchLoader.h +++ b/src/runtimerender/resourcemanager/Qt3DSRenderImageBatchLoader.h @@ -51,7 +51,7 @@ namespace render { virtual ~IImageLoadListener() {} public: - virtual void OnImageLoadComplete(CRegisteredString inPath, + virtual void OnImageLoadComplete(const QString &inPath, ImageLoadResult::Enum inResult) = 0; virtual void OnImageBatchComplete(QT3DSU64 inBatch) = 0; }; @@ -69,8 +69,8 @@ namespace render { // source paths // until said path is loaded. // An optional listener can be passed in to get callbacks about the batch. - virtual TImageBatchId LoadImageBatch(NVConstDataRef<CRegisteredString> inSourcePaths, - CRegisteredString inImageTillLoaded, + virtual TImageBatchId LoadImageBatch(const QVector<QString> &inSourcePaths, + const QString &inImageTillLoaded, IImageLoadListener *inListener, NVRenderContextType type, bool iblImages, @@ -78,7 +78,7 @@ namespace render { // Blocks if any of the images in the batch are in flight virtual void CancelImageBatchLoading(TImageBatchId inBatchId) = 0; // Blocks if the image is currently in-flight - virtual void CancelImageLoading(CRegisteredString inSourcePath) = 0; + virtual void CancelImageLoading(const QString &inSourcePath) = 0; // Block until every image in the batch is loaded. virtual void BlockUntilLoaded(TImageBatchId inId) = 0; diff --git a/src/runtimerender/resourcemanager/Qt3DSRenderLoadedTexture.cpp b/src/runtimerender/resourcemanager/Qt3DSRenderLoadedTexture.cpp index 634e3c0..eee0c0b 100644 --- a/src/runtimerender/resourcemanager/Qt3DSRenderLoadedTexture.cpp +++ b/src/runtimerender/resourcemanager/Qt3DSRenderLoadedTexture.cpp @@ -944,14 +944,12 @@ SLoadedTexture *SLoadedTexture::Load(const QString &path, NVFoundationBase &inFo } else if (path.endsWith(QLatin1String("ktx"), Qt::CaseInsensitive)) { // We need to flip y coordinate in shader as it cannot be done at load time for // compressed textures. - bufferManager->SetInvertImageUVCoords(bufferManager->GetStringTable().RegisterStr(path), - inFlipCompressed); + bufferManager->SetInvertImageUVCoords(path, inFlipCompressed); theLoadedImage = LoadKTX(*theStream, inFlipY, inFoundation, renderContextType); } else if (path.endsWith(QLatin1String("astc"), Qt::CaseInsensitive)) { // We need to flip y coordinate in shader as it cannot be done at load time for // compressed textures. - bufferManager->SetInvertImageUVCoords(bufferManager->GetStringTable().RegisterStr(path), - inFlipCompressed); + bufferManager->SetInvertImageUVCoords(path, inFlipCompressed); theLoadedImage = LoadASTC(fileName, inFlipY, inFoundation, renderContextType); } else { qCWarning(INTERNAL_ERROR, "Unrecognized image extension: %s", qPrintable(path)); diff --git a/src/runtimerender/resourcemanager/Qt3DSRenderLoadedTexture.h b/src/runtimerender/resourcemanager/Qt3DSRenderLoadedTexture.h index c2aca9e..62408f3 100644 --- a/src/runtimerender/resourcemanager/Qt3DSRenderLoadedTexture.h +++ b/src/runtimerender/resourcemanager/Qt3DSRenderLoadedTexture.h @@ -152,6 +152,7 @@ namespace render { STextureData DecompressDXTImage(int inMipMapIdx, STextureData *inOptLastImage = NULL); void ReleaseDecompressedTexture(STextureData inImage); + // Path must have been resolved or contain actual file or image id static SLoadedTexture *Load(const QString &inPath, NVFoundationBase &inAllocator, IInputStreamFactory &inFactory, bool inFlipY = true, bool inFlipCompressed = false, |