change the signatures of IAssetLoader interm_get a little bit, and make our first indirect load example

devshgraphicsprogramming · devshgraphicsprogramming · commit e0a23fcda9a8 · 2026-02-06T21:48:45.000+01:00
diff --git a/include/nbl/asset/IAssetManager.h b/include/nbl/asset/IAssetManager.h
@@ -385,8 +385,10 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted
         uint32_t getAssetLoaderCount() { return static_cast<uint32_t>(m_loaders.vector.size()); }
 
         //! @returns 0xdeadbeefu on failure or 0-based index on success.
-        uint32_t addAssetLoader(core::smart_refctd_ptr<IAssetLoader>&& _loader)
+        inline uint32_t addAssetLoader(core::smart_refctd_ptr<IAssetLoader>&& _loader)
         {
+            if (!_loader)
+                return 0xdeadbeefu;
             // there's no way it ever fails, so no 0xdeadbeef return
             const char** exts = _loader->getAssociatedFileExtensions();
             size_t extIx = 0u;
@@ -395,8 +397,10 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted
             m_loaders.pushToVector(std::move(_loader));
             return static_cast<uint32_t>(m_loaders.vector.size())-1u;
         }
-        void removeAssetLoader(IAssetLoader* _loader)
+        inline void removeAssetLoader(IAssetLoader* _loader)
         {
+            if (!_loader)
+                return;
             m_loaders.eraseFromVector(
                 std::find_if(std::begin(m_loaders.vector), std::end(m_loaders.vector), [_loader](const core::smart_refctd_ptr<IAssetLoader>& a)->bool { return a.get()==_loader; })
             );
@@ -409,8 +413,10 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted
         // Asset Writers [FOLLOWING ARE NOT THREAD SAFE]
         uint32_t getAssetWriterCount() { return static_cast<uint32_t>(m_writers.perType.getSize()); } // todo.. well, it's not really writer count.. but rather type<->writer association count
 
-        void addAssetWriter(core::smart_refctd_ptr<IAssetWriter>&& _writer)
+        inline void addAssetWriter(core::smart_refctd_ptr<IAssetWriter>&& _writer)
         {
+            if (!_writer)
+                return;
             const uint64_t suppTypes = _writer->getSupportedAssetTypesBitfield();
             const char** exts = _writer->getAssociatedFileExtensions();
             for (uint32_t i = 0u; i < IAsset::ET_STANDARD_TYPES_COUNT; ++i)
@@ -425,8 +431,10 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted
                 }
             }
         }
-        void removeAssetWriter(IAssetWriter* _writer)
+        inline void removeAssetWriter(IAssetWriter* _writer)
         {
+            if (!_writer)
+                return;
             const uint64_t suppTypes = _writer->getSupportedAssetTypesBitfield();
             const char** exts = _writer->getAssociatedFileExtensions();
             size_t extIx = 0u;
diff --git a/include/nbl/asset/ICPUScene.h b/include/nbl/asset/ICPUScene.h
@@ -181,7 +181,7 @@ class ICPUScene final : public IAsset, public IScene
             Count
         };
         //
-        inline bool addEnvLight(const EEnvLightType type, core::smart_refctd_ptr<ICPUImageView>&& tex)
+        inline bool addEnvLight(const EEnvLightType type, core::smart_refctd_ptr<const ICPUImageView>&& tex)
         {
             if (!tex)
                 return false;
@@ -232,7 +232,7 @@ class ICPUScene final : public IAsset, public IScene
         //
         SInstanceStorage m_instances;
         //
-        core::vector<core::smart_refctd_ptr<ICPUImageView>> m_envLightTexs;
+        core::vector<core::smart_refctd_ptr<const ICPUImageView>> m_envLightTexs;
         core::vector<EEnvLightType> m_envLightTypes;
         //
         const uint8_t m_maxMorphTargetGeometryCountLog2;
diff --git a/include/nbl/asset/interchange/IAssetLoader.h b/include/nbl/asset/interchange/IAssetLoader.h
@@ -177,6 +177,9 @@ class NBL_API2 IAssetLoader : public virtual core::IReferenceCounted
 			public:
 				NBL_API2 IAssetLoaderOverride(IAssetManager* _manager);
 
+				//
+				inline IAssetManager* getManager() const {return m_manager;}
+
 				//!
 				template<class AssetT>
 				inline std::pair<core::smart_refctd_ptr<AssetT>,const IAssetMetadata*> findDefaultAsset(const std::string& inSearchKey, const SAssetLoadContext& ctx, const uint32_t hierarchyLevel)
@@ -270,7 +273,7 @@ class NBL_API2 IAssetLoader : public virtual core::IReferenceCounted
 
 				//! After a successful load of an asset or sub-asset
 				//TODO change name
-				virtual void insertAssetIntoCache(SAssetBundle& asset, const std::string& supposedKey, const SAssetLoadContext& ctx, const uint32_t hierarchyLevel);
+				virtual void insertAssetIntoCache(SAssetBundle& asset, const std::string& supposedKey, const SAssetLoadParams& _params, const uint32_t hierarchyLevel);
 		};
 
 	public:
@@ -291,25 +294,105 @@ class NBL_API2 IAssetLoader : public virtual core::IReferenceCounted
 		//! Loads an asset from an opened file, returns nullptr in case of failure.
 		virtual SAssetBundle loadAsset(system::IFile* _file, const SAssetLoadParams& _params, IAssetLoaderOverride* _override, uint32_t _hierarchyLevel = 0u) = 0;
 
+		//
 		virtual void initialize() {}
 
+		//
+		static core::smart_refctd_ptr<ICPUImageView> createDefaultImageView(core::smart_refctd_ptr<asset::ICPUImage>&& image);
+
 	protected:
 		// accessors for loaders
-		SAssetBundle interm_getAssetInHierarchy(IAssetManager* _mgr, system::IFile* _file, const std::string& _supposedFilename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override);
-		SAssetBundle interm_getAssetInHierarchy(IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override);
+		SAssetBundle interm_getAssetInHierarchy(system::IFile* _file, const std::string& _supposedFilename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override);
+		SAssetBundle interm_getAssetInHierarchy(const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override);
 		// only the overload we use for now
-		SAssetBundle interm_getAssetInHierarchyWithAllContent(IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override);
+		SAssetBundle interm_getAssetInHierarchyWithAllContent(const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override);
 
 		void interm_setAssetMutability(const IAssetManager* _mgr, IAsset* _asset, const bool _val);
 
 		bool insertBuiltinAssetIntoCache(IAssetManager* _mgr, SAssetBundle& _asset, const std::string _path);
 		bool insertBuiltinAssetIntoCache(IAssetManager* _mgr, core::smart_refctd_ptr<IAsset>& _asset, core::smart_refctd_ptr<IAssetMetadata>&& metadata, const std::string _path);
 		bool insertBuiltinAssetIntoCache(IAssetManager* _mgr, core::smart_refctd_ptr<IAsset>&& _asset, core::smart_refctd_ptr<IAssetMetadata>&& metadata, const std::string _path);
 
+		// TODO: make static?
 		inline void setAssetInBundle(SAssetBundle& bundle, const uint32_t offset, core::smart_refctd_ptr<IAsset>&& _asset)
 		{
 			bundle.setAsset(offset,std::move(_asset));
 		}
+
+		//
+		template<typename PathOrFile> requires is_any_of_v<PathOrFile,system::IFile*,std::string>
+		SAssetBundle interm_getImageViewInHierarchy(const PathOrFile& pathOrFile, const IAssetLoader::SAssetLoadParams& _params, const uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
+		{
+			// TODO: first we needed to try-load to figure out the cache key to be used, but we could do it differently I guess
+			// TODO: this load shouldn't add to cache until we exit successfully
+			auto bundle = interm_getAssetInHierarchy(pathOrFile,_params,_hierarchyLevel,_override);
+			auto contentRange = bundle.getContents();
+			if (contentRange.empty())
+				return {};
+			if (const auto origType=bundle.getAssetType(); origType==IAsset::E_TYPE::ET_IMAGE_VIEW)
+				return bundle;
+			else if (origType!=IAsset::E_TYPE::ET_IMAGE)
+			{
+				_params.logger.log(
+					"IAssetLoader::interm_getImageViewInHierarchy loaded assed with key \"%s\" with was of type %s not IMAGE",
+					system::ILogger::ELL_ERROR,bundle.getCacheKey().c_str(),system::to_string(origType).c_str()
+				);
+				return {};
+			}
+
+			const auto cacheKey = bundle.getCacheKey()+"?view?IAssetLoader?default";
+			SAssetLoadContext ctx(_params,nullptr);
+			// search the cache for the imageview
+			{
+				const asset::IAsset::E_TYPE types[]{asset::IAsset::ET_IMAGE_VIEW,asset::IAsset::ET_TERMINATING_ZERO};
+				auto cachedBundle = _override->findCachedAsset(cacheKey,types,ctx,_hierarchyLevel);
+				// check if found
+				if (!cachedBundle.getContents().empty())
+					return cachedBundle;
+			}
+
+			// ok now create default views for all the images
+			auto container = core::make_refctd_dynamic_array<SAssetBundle::contents_container_t>(contentRange.size());
+			auto outIt = container->begin();
+			for (auto& asset : contentRange)
+				*(outIt++) = createDefaultImageView(core::smart_refctd_ptr_static_cast<ICPUImage>(asset));
+			bundle = SAssetBundle(nullptr,std::move(container));
+			_override->insertAssetIntoCache(bundle,cacheKey,_params,_hierarchyLevel);
+			return bundle;
+		}
+
+#if 0
+		// should we have derivative, bump and normalmap getters or shall we support all 3 in Frontend?
+		static std::string imageViewCacheKey(const CElementTexture::Bitmap& bitmap, const CMitsubaMaterialCompilerFrontend::E_IMAGE_VIEW_SEMANTIC semantic)
+		{
+			std::string key = bitmap.filename.svalue;
+			switch (semantic)
+			{
+				case CMitsubaMaterialCompilerFrontend::EIVS_NORMAL_MAP:
+					key += "?deriv?n";
+					break;
+				case CMitsubaMaterialCompilerFrontend::EIVS_BUMP_MAP:
+					key += "?deriv?h";
+					{
+						static const char* wrap[5]
+						{
+							"?repeat",
+							"?mirror",
+							"?clamp",
+							"?zero",
+							"?one"
+						};
+						key += wrap[bitmap.wrapModeU];
+						key += wrap[bitmap.wrapModeV];
+					}
+					break;
+				default:
+					break;
+			}
+			key += "?view";
+			return key;
+		}
+#endif
 };
 
 }
diff --git a/include/nbl/ext/MitsubaLoader/SContext.h b/include/nbl/ext/MitsubaLoader/SContext.h
@@ -6,7 +6,6 @@
 
 
 #include "nbl/asset/ICPUPolygonGeometry.h"
-//#include "nbl/asset/utils/IGeometryCreator.h"
 #include "nbl/asset/interchange/CIESProfileLoader.h"
 
 #include "nbl/ext/MitsubaLoader/CMitsubaMetadata.h"
@@ -49,63 +48,13 @@ struct SContext final
 		core::unordered_map<const CElementShape::ShapeGroup*,group_ass_type> groupCache;
 		//
 		core::unordered_map<const CElementShape*,CMitsubaMetadata::SGeometryMetaPair> shapeCache;
-#if 0
+
+#if 0 // stuff that belongs in the Material Compiler backend
 		//image, sampler
 		using tex_ass_type = std::tuple<core::smart_refctd_ptr<asset::ICPUImageView>,core::smart_refctd_ptr<asset::ICPUSampler>>;
-		//image, scale
+		//image, scale 
 		core::map<core::smart_refctd_ptr<asset::ICPUImage>,float> derivMapCache;
 
-		//
-		static std::string imageViewCacheKey(const CElementTexture::Bitmap& bitmap, const CMitsubaMaterialCompilerFrontend::E_IMAGE_VIEW_SEMANTIC semantic)
-		{
-			std::string key = bitmap.filename.svalue;
-			switch (bitmap.channel)
-			{
-				case CElementTexture::Bitmap::CHANNEL::R:
-					key += "?rrrr";
-					break;
-				case CElementTexture::Bitmap::CHANNEL::G:
-					key += "?gggg";
-					break;
-				case CElementTexture::Bitmap::CHANNEL::B:
-					key += "?bbbb";
-					break;
-				case CElementTexture::Bitmap::CHANNEL::A:
-					key += "?aaaa";
-					break;
-				default:
-					break;
-			}
-			switch (semantic)
-			{
-				case CMitsubaMaterialCompilerFrontend::EIVS_BLEND_WEIGHT:
-					key += "?blend";
-					break;
-				case CMitsubaMaterialCompilerFrontend::EIVS_NORMAL_MAP:
-					key += "?deriv?n";
-					break;
-				case CMitsubaMaterialCompilerFrontend::EIVS_BUMP_MAP:
-					key += "?deriv?h";
-					{
-						static const char* wrap[5]
-						{
-							"?repeat",
-							"?mirror",
-							"?clamp",
-							"?zero",
-							"?one"
-						};
-						key += wrap[bitmap.wrapModeU];
-						key += wrap[bitmap.wrapModeV];
-					}
-					break;
-				default:
-					break;
-			}
-			key += "?view";
-			return key;
-		}
-
 		static asset::ISampler::SParams emissionProfileSamplerParams(const CElementEmissionProfile* profile, const asset::CIESProfileMetadata& meta)
 		{
 			return {
diff --git a/src/nbl/asset/IAssetManager.cpp b/src/nbl/asset/IAssetManager.cpp
@@ -236,14 +236,14 @@ SAssetBundle IAssetManager::getAssetInHierarchy_impl(system::IFile* _file, const
         ((levelFlags & IAssetLoader::ECF_DONT_CACHE_TOP_LEVEL) != IAssetLoader::ECF_DONT_CACHE_TOP_LEVEL) &&
         ((levelFlags & IAssetLoader::ECF_DUPLICATE_TOP_LEVEL) != IAssetLoader::ECF_DUPLICATE_TOP_LEVEL))
     {
-        _override->insertAssetIntoCache(bundle, filename.string(), ctx, _hierarchyLevel);
+        _override->insertAssetIntoCache(bundle, filename.string(), ctx.params, _hierarchyLevel);
     }
     else if (bundle.getContents().empty())
     {
         bool addToCache;
         bundle = _override->handleLoadFail(addToCache, file.get(), filename.string(), filename.string(), ctx, _hierarchyLevel);
         if (!bundle.getContents().empty() && addToCache)
-            _override->insertAssetIntoCache(bundle, filename.string(), ctx, _hierarchyLevel);
+            _override->insertAssetIntoCache(bundle, filename.string(), ctx.params, _hierarchyLevel);
     }            
     return bundle;
 }
diff --git a/src/nbl/asset/interchange/IAssetLoader.cpp b/src/nbl/asset/interchange/IAssetLoader.cpp
@@ -6,8 +6,8 @@
 
 #include "nbl/asset/IAssetManager.h"
 
-using namespace nbl;
-using namespace asset;
+using namespace nbl::core;
+using namespace nbl::asset;
 
 // todo NEED DOCS
 IAssetLoader::IAssetLoaderOverride::IAssetLoaderOverride(IAssetManager* _manager) : m_manager(_manager), m_system(m_manager->getSystem())
@@ -26,28 +26,28 @@ SAssetBundle IAssetLoader::IAssetLoaderOverride::findCachedAsset(const std::stri
     return chooseRelevantFromFound(found->begin(), found->end(), ctx, hierarchyLevel);
 }
 
-void IAssetLoader::IAssetLoaderOverride::insertAssetIntoCache(SAssetBundle& asset, const std::string& supposedKey, const SAssetLoadContext& ctx, const uint32_t hierarchyLevel)
+void IAssetLoader::IAssetLoaderOverride::insertAssetIntoCache(SAssetBundle& asset, const std::string& supposedKey, const SAssetLoadParams& _params, const uint32_t hierarchyLevel)
 {
     m_manager->changeAssetKey(asset, supposedKey);
 
-    auto levelFlag = ctx.params.cacheFlags >> (uint64_t(hierarchyLevel) * 2ull);
+    auto levelFlag = _params.cacheFlags >> (uint64_t(hierarchyLevel) * 2ull);
     if (!(levelFlag&ECF_DONT_CACHE_TOP_LEVEL))
         m_manager->insertAssetIntoCache(asset,ASSET_MUTABILITY_ON_CACHE_INSERT);
 }
 
-SAssetBundle IAssetLoader::interm_getAssetInHierarchy(IAssetManager* _mgr, system::IFile* _file, const std::string& _supposedFilename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
+SAssetBundle IAssetLoader::interm_getAssetInHierarchy(system::IFile* _file, const std::string& _supposedFilename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
 {
-    return _mgr->getAssetInHierarchy(_file, _supposedFilename, _params, _hierarchyLevel, _override);
+    return _override->getManager()->getAssetInHierarchy(_file, _supposedFilename, _params, _hierarchyLevel, _override);
 }
 
-SAssetBundle IAssetLoader::interm_getAssetInHierarchy(IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
+SAssetBundle IAssetLoader::interm_getAssetInHierarchy(const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
 {
-    return _mgr->getAssetInHierarchy(_filename, _params, _hierarchyLevel, _override);
+    return _override->getManager()->getAssetInHierarchy(_filename, _params, _hierarchyLevel, _override);
 }
 
-SAssetBundle IAssetLoader::interm_getAssetInHierarchyWithAllContent(IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
+SAssetBundle IAssetLoader::interm_getAssetInHierarchyWithAllContent(const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
 {
-	auto firstLoad = interm_getAssetInHierarchy(_mgr,_filename,_params,_hierarchyLevel,_override);
+	auto firstLoad = interm_getAssetInHierarchy(_filename,_params,_hierarchyLevel,_override);
 	auto bundleHasAllContent = [](const SAssetBundle& retval)->bool
 	{
 		for (const auto& asset : retval.getContents())
@@ -60,10 +60,10 @@ SAssetBundle IAssetLoader::interm_getAssetInHierarchyWithAllContent(IAssetManage
 
 	IAssetLoader::SAssetLoadParams paramCopy = _params;
 	paramCopy.cacheFlags = ECF_DUPLICATE_REFERENCES;
-	auto secondLoad = interm_getAssetInHierarchy(_mgr,_filename,paramCopy,_hierarchyLevel,_override);
+	auto secondLoad = interm_getAssetInHierarchy(_filename,paramCopy,_hierarchyLevel,_override);
 	if (bundleHasAllContent(secondLoad))
 	{
-		_mgr->removeAssetFromCache(firstLoad);
+		_override->getManager()->removeAssetFromCache(firstLoad);
 		return secondLoad;
 	}
 	else
@@ -83,15 +83,47 @@ bool IAssetLoader::insertBuiltinAssetIntoCache(IAssetManager* _mgr, SAssetBundle
 
 
 
-
-bool IAssetLoader::insertBuiltinAssetIntoCache(IAssetManager* _mgr,  core::smart_refctd_ptr<IAsset>& _asset, core::smart_refctd_ptr<IAssetMetadata>&& metadata, const std::string _path)
+// if I can figure out the template for this, move to header
+bool IAssetLoader::insertBuiltinAssetIntoCache(IAssetManager* _mgr,  smart_refctd_ptr<IAsset>& _asset, smart_refctd_ptr<IAssetMetadata>&& metadata, const std::string _path)
 {
     asset::SAssetBundle bundle(std::move(metadata), { _asset });
     return insertBuiltinAssetIntoCache(_mgr, bundle, _path);
 }
 
-bool IAssetLoader::insertBuiltinAssetIntoCache(IAssetManager* _mgr, core::smart_refctd_ptr<IAsset>&& _asset, core::smart_refctd_ptr<IAssetMetadata>&& metadata, const std::string _path)
+bool IAssetLoader::insertBuiltinAssetIntoCache(IAssetManager* _mgr, smart_refctd_ptr<IAsset>&& _asset, smart_refctd_ptr<IAssetMetadata>&& metadata, const std::string _path)
 {
     asset::SAssetBundle bundle(std::move(metadata), { std::move(_asset) });
     return insertBuiltinAssetIntoCache(_mgr, bundle, _path);
 }
+
+
+smart_refctd_ptr<ICPUImageView> IAssetLoader::createDefaultImageView(core::smart_refctd_ptr<asset::ICPUImage>&& image)
+{
+	if (!image)
+		return nullptr;
+	const auto& imageParams = image->getCreationParameters();
+
+	using view_type_e = IImageViewBase::E_TYPE;
+	IImageViewBase::E_TYPE viewType;
+	switch (imageParams.type)
+	{
+		case ICPUImage::ET_1D:
+			viewType = view_type_e::ET_1D_ARRAY;
+			break;
+		case ICPUImage::ET_2D:
+			viewType = view_type_e::ET_2D_ARRAY;
+			break;
+		case ICPUImage::ET_3D:
+			viewType = view_type_e::ET_3D;
+			break;
+		default:
+			return nullptr;
+	}
+
+	return ICPUImageView::create({
+		//.subUsages = // shall we somehow narrow in-case the image itself has extended usage?
+		.image = std::move(image),
+		.viewType = viewType,
+		.format = imageParams.format
+	});
+}
diff --git a/src/nbl/ext/MitsubaLoader/CGLSLMitsubaLoaderBuiltinIncludeGenerator.h b/src/nbl/ext/MitsubaLoader/CGLSLMitsubaLoaderBuiltinIncludeGenerator.h
diff --git a/src/nbl/ext/MitsubaLoader/CMitsubaLoader.cpp b/src/nbl/ext/MitsubaLoader/CMitsubaLoader.cpp

Original file line number	Diff line number	Diff line change
`@@ -385,8 +385,10 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted`
`385`	`385`	`uint32_t getAssetLoaderCount() { return static_cast<uint32_t>(m_loaders.vector.size()); }`
`386`	`386`
`387`	`387`	`//! @returns 0xdeadbeefu on failure or 0-based index on success.`
`388`		`- uint32_t addAssetLoader(core::smart_refctd_ptr<IAssetLoader>&& _loader)`
	`388`	`+ inline uint32_t addAssetLoader(core::smart_refctd_ptr<IAssetLoader>&& _loader)`
`389`	`389`	`{`
	`390`	`+ if (!_loader)`
	`391`	`+ return 0xdeadbeefu;`
`390`	`392`	`// there's no way it ever fails, so no 0xdeadbeef return`
`391`	`393`	`const char** exts = _loader->getAssociatedFileExtensions();`
`392`	`394`	`size_t extIx = 0u;`
`@@ -395,8 +397,10 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted`
`395`	`397`	`m_loaders.pushToVector(std::move(_loader));`
`396`	`398`	`return static_cast<uint32_t>(m_loaders.vector.size())-1u;`
`397`	`399`	`}`
`398`		`- void removeAssetLoader(IAssetLoader* _loader)`
	`400`	`+ inline void removeAssetLoader(IAssetLoader* _loader)`
`399`	`401`	`{`
	`402`	`+ if (!_loader)`
	`403`	`+ return;`
`400`	`404`	`m_loaders.eraseFromVector(`
`401`	`405`	`std::find_if(std::begin(m_loaders.vector), std::end(m_loaders.vector), [_loader](const core::smart_refctd_ptr<IAssetLoader>& a)->bool { return a.get()==_loader; })`
`402`	`406`	`);`
`@@ -409,8 +413,10 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted`
`409`	`413`	`// Asset Writers [FOLLOWING ARE NOT THREAD SAFE]`
`410`	`414`	`uint32_t getAssetWriterCount() { return static_cast<uint32_t>(m_writers.perType.getSize()); } // todo.. well, it's not really writer count.. but rather type<->writer association count`
`411`	`415`
`412`		`- void addAssetWriter(core::smart_refctd_ptr<IAssetWriter>&& _writer)`
	`416`	`+ inline void addAssetWriter(core::smart_refctd_ptr<IAssetWriter>&& _writer)`
`413`	`417`	`{`
	`418`	`+ if (!_writer)`
	`419`	`+ return;`
`414`	`420`	`const uint64_t suppTypes = _writer->getSupportedAssetTypesBitfield();`
`415`	`421`	`const char** exts = _writer->getAssociatedFileExtensions();`
`416`	`422`	`for (uint32_t i = 0u; i < IAsset::ET_STANDARD_TYPES_COUNT; ++i)`
`@@ -425,8 +431,10 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted`
`425`	`431`	`}`
`426`	`432`	`}`
`427`	`433`	`}`
`428`		`- void removeAssetWriter(IAssetWriter* _writer)`
	`434`	`+ inline void removeAssetWriter(IAssetWriter* _writer)`
`429`	`435`	`{`
	`436`	`+ if (!_writer)`
	`437`	`+ return;`
`430`	`438`	`const uint64_t suppTypes = _writer->getSupportedAssetTypesBitfield();`
`431`	`439`	`const char** exts = _writer->getAssociatedFileExtensions();`
`432`	`440`	`size_t extIx = 0u;`
Original file line number	Diff line number	Diff line change
`@@ -236,14 +236,14 @@ SAssetBundle IAssetManager::getAssetInHierarchy_impl(system::IFile* _file, const`
`236`	`236`	`((levelFlags & IAssetLoader::ECF_DONT_CACHE_TOP_LEVEL) != IAssetLoader::ECF_DONT_CACHE_TOP_LEVEL) &&`
`237`	`237`	`((levelFlags & IAssetLoader::ECF_DUPLICATE_TOP_LEVEL) != IAssetLoader::ECF_DUPLICATE_TOP_LEVEL))`
`238`	`238`	`{`
`239`		`- _override->insertAssetIntoCache(bundle, filename.string(), ctx, _hierarchyLevel);`
	`239`	`+ _override->insertAssetIntoCache(bundle, filename.string(), ctx.params, _hierarchyLevel);`
`240`	`240`	`}`
`241`	`241`	`else if (bundle.getContents().empty())`
`242`	`242`	`{`
`243`	`243`	`bool addToCache;`
`244`	`244`	`bundle = _override->handleLoadFail(addToCache, file.get(), filename.string(), filename.string(), ctx, _hierarchyLevel);`
`245`	`245`	`if (!bundle.getContents().empty() && addToCache)`
`246`		`- _override->insertAssetIntoCache(bundle, filename.string(), ctx, _hierarchyLevel);`
	`246`	`+ _override->insertAssetIntoCache(bundle, filename.string(), ctx.params, _hierarchyLevel);`
`247`	`247`	`}`
`248`	`248`	`return bundle;`
`249`	`249`	`}`