Merge pull request #71 from Devsh-Graphics-Programming/radix_sort

Asset Reload Fixes

Author: devshgraphicsprogramming

examples_tests/18.MitsubaLoader/main.cpp

@@ -212,7 +212,7 @@ int main()
 		asset::CQuantNormalCache* qnc = am->getMeshManipulator()->getQuantNormalCache();
 
 		auto serializedLoader = core::make_smart_refctd_ptr<nbl::ext::MitsubaLoader::CSerializedLoader>(am);
-		auto mitsubaLoader = core::make_smart_refctd_ptr<nbl::ext::MitsubaLoader::CMitsubaLoader>(am, fs);
+		auto mitsubaLoader = core::make_smart_refctd_ptr<nbl::ext::MitsubaLoader::CMitsubaLoader>(am,fs);
 		serializedLoader->initialize();
 		mitsubaLoader->initialize();
 		am->addAssetLoader(std::move(serializedLoader));

include/nbl/asset/IAssetManager.h

@@ -280,7 +280,7 @@ class IAssetManager : public core::IReferenceCounted, public core::QuitSignallin
 
             if (restoreLevels)
             {
-                auto reloadParams = _params;
+                auto reloadParams = IAssetLoader::SAssetLoadParams(_params, true);
                 {
                     using flags_t = std::underlying_type_t<IAssetLoader::E_CACHING_FLAGS>;
                     constexpr uint32_t bitdepth = sizeof(flags_t)*8u;
@@ -290,25 +290,25 @@ class IAssetManager : public core::IReferenceCounted, public core::QuitSignallin
                     // set flags for levels [_hierLevel,_hierLevel+_restoreLevels) to dont look into cache and dont put into cache
                     reloadFlags = core::bitfieldInsert<flags_t>(reloadFlags, IAssetLoader::ECF_DUPLICATE_REFERENCES, _hierarchyLevel*2u, restoreLevels*2u);
                     reloadParams.cacheFlags = static_cast<IAssetLoader::E_CACHING_FLAGS>(reloadFlags);
-
                     reloadParams.restoreLevels = 0u; // make sure it wont turn into infinite recursion
-                    reloadParams.reload = true; // TODO (consider): alternative to this flag: another method in override just to let user choose asset for restore
                 }
 
                 auto reloadBundle = getAssetInHierarchy_impl<RestoreWholeBundle>(_file, _supposedFilename, reloadParams, _hierarchyLevel, _override);
 
-                if constexpr (RestoreWholeBundle)
+                if constexpr (!RestoreWholeBundle)
                 {
                     IAssetLoader::SAssetLoadContext ctx(params, file);
                     auto asset = _override->chooseDefaultAsset(bundle, ctx);
 
-                    // user responsible for checking if assets he wanted to be restored are in fact restored
-                    _override->handleRestore(std::move(asset), bundle, reloadBundle, restoreLevels);
+                    auto newChosenAsset = _override->handleRestore(std::move(asset), bundle, reloadBundle, restoreLevels);
+                    if (!newChosenAsset || newChosenAsset->isAnyDependencyDummy(restoreLevels))
+                        return {};
                 }
                 else
                 {
-                    // user responsible for checking if assets he wanted to be restored are in fact restored
                     _override->handleRestore(bundle, reloadBundle, restoreLevels);
+                    if (!whole_bundle_not_dummy(bundle))
+                        return {};
                 }
             }
 
@@ -528,7 +528,7 @@ class IAssetManager : public core::IReferenceCounted, public core::QuitSignallin
 
         //! Remove an asset from cache (calls the private methods of IAsset behind the scenes)
         //TODO change key
-        bool removeAssetFromCache(SAssetBundle& _asset) //will actually look up by asset’s key instead
+        bool removeAssetFromCache(SAssetBundle& _asset) //will actually look up by asset’s key instead
         {
             const uint32_t ix = IAsset::typeFlagToIndex(_asset.getAssetType());
             return m_assetCache[ix]->removeObject(_asset, _asset.getCacheKey());

include/nbl/asset/interchange/IAssetLoader.h

@@ -103,15 +103,26 @@ class IAssetLoader : public virtual core::IReferenceCounted
         {
         }
 
+		SAssetLoadParams(const SAssetLoadParams& rhs, bool _reload = false) :
+			decryptionKeyLen(rhs.decryptionKeyLen),
+			decryptionKey(rhs.decryptionKey),
+			cacheFlags(rhs.cacheFlags),
+			relativeDir(rhs.relativeDir),
+			loaderFlags(rhs.loaderFlags),
+			meshManipulatorOverride(rhs.meshManipulatorOverride),
+			restoreLevels(rhs.restoreLevels),
+			reload(_reload)
+		{
+		}
+
         size_t decryptionKeyLen;
         const uint8_t* decryptionKey;
         E_CACHING_FLAGS cacheFlags;
         const char* relativeDir;
         E_LOADER_PARAMETER_FLAGS loaderFlags;				//!< Flags having an impact on extraordinary tasks during loading process
 		IMeshManipulator* meshManipulatorOverride = nullptr;    //!< pointer used for specifying custom mesh manipulator to use, if nullptr - default mesh manipulator will be used
 		uint32_t restoreLevels = 0u;
-		// user should not ever write to this flag
-		bool reload = false;
+		const bool reload = false;
     };
 
     //! Struct for keeping the state of the current loadoperation for safe threading
@@ -267,7 +278,7 @@ class IAssetLoader : public virtual core::IReferenceCounted
 
 		//! Restores only the chosen asset 
 		//! The asset is chosen via chooseDefaultAsset()
-		virtual void handleRestore(core::smart_refctd_ptr<IAsset>&& _chosenAsset, SAssetBundle& _bundle, SAssetBundle& _reloadedBundle, uint32_t _restoreLevels);
+		virtual core::smart_refctd_ptr<IAsset> handleRestore(core::smart_refctd_ptr<IAsset>&& _chosenAsset, SAssetBundle& _bundle, SAssetBundle& _reloadedBundle, uint32_t _restoreLevels);
 
 		//! Restores all of assets in _bundle
 		virtual void handleRestore(SAssetBundle& _bundle, SAssetBundle& _reloadedBundle, uint32_t _restoreLevels);

src/nbl/asset/interchange/IAssetLoader.cpp

@@ -35,22 +35,24 @@ void IAssetLoader::IAssetLoaderOverride::insertAssetIntoCache(SAssetBundle& asse
         m_manager->insertAssetIntoCache(asset, ASSET_MUTABILITY_ON_CACHE_INSERT);
 }
 
-void IAssetLoader::IAssetLoaderOverride::handleRestore(core::smart_refctd_ptr<IAsset>&& _chosenAsset, SAssetBundle& _bundle, SAssetBundle& _reloadedBundle, uint32_t _restoreLevels)
+core::smart_refctd_ptr<IAsset> IAssetLoader::IAssetLoaderOverride::handleRestore(core::smart_refctd_ptr<IAsset>&& _chosenAsset, SAssetBundle& _bundle, SAssetBundle& _reloadedBundle, uint32_t _restoreLevels)
 {
     if (_bundle.getContents().size() != _reloadedBundle.getContents().size())
-        return;
+        return nullptr;
 
     auto dummies = _bundle.getContents();
     auto found_it = std::find(dummies.begin(), dummies.end(), _chosenAsset);
     if (found_it == dummies.end())
-        return;
+        return nullptr;
     const uint32_t ix = found_it - dummies.begin();
 
     auto reloaded = _reloadedBundle.getContents();
-    if (dummies.begin()[ix]->isADummyObjectForCache() && !dummies.begin()[ix]->canBeRestoredFrom(reloaded.begin()[ix].get()))
-        return;
+    if (_chosenAsset->isADummyObjectForCache() && !_chosenAsset->canBeRestoredFrom(reloaded.begin()[ix].get()))
+        return nullptr;
 
     _chosenAsset->restoreFromDummy(reloaded.begin()[ix].get(), _restoreLevels);
+
+    return _chosenAsset;
 }
 
 void IAssetLoader::IAssetLoaderOverride::handleRestore(SAssetBundle& _bundle, SAssetBundle& _reloadedBundle, uint32_t _restoreLevels)

src/nbl/ext/MitsubaLoader/CMitsubaLoader.cpp

@@ -951,7 +951,7 @@ SContext::tex_ass_type CMitsubaLoader::cacheTexture(SContext& ctx, uint32_t hier
 						if (_restore && image->isADummyObjectForCache())
 						{
 							auto loadParams = ctx.inner.params;
-							loadParams.restoreLevels = hierarchyLevel + 2u;
+							loadParams.restoreLevels = std::max(loadParams.restoreLevels, hierarchyLevel + 2u);
 							// this will restore the image being kept by found `view`
 							auto bundle = interm_getAssetInHierarchy(m_assetMgr, tex->bitmap.filename.svalue, loadParams, hierarchyLevel, ctx.override_);
 							if (bundle.getContents().empty() || image->isADummyObjectForCache())