Fix crash when slide change occurs

The buffer manager needs to use resolved paths for each image loading
function. Also convert to use QString to avoid unnecessary string
conversions. Also fix image loading task to use resolved paths.

Task-number: QT3DS-4177
Change-Id: I79fae56a8f49ccbdcaed1fa9eb9a9d875583d0dd
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>

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,