Merge branch 'shader_caching_fixes' into cad_large_texture_streaming

Author: Erfan-Ahmadi

examples_tests

@@ -182,7 +182,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 			public:
 				// Used to check compatibility of Caches before reading
 				constexpr static inline std::string_view VERSION = "1.0.0";
-        
+
 				using hash_t = std::array<uint64_t,4>;
 				static auto const SHADER_BUFFER_SIZE_BYTES = sizeof(uint64_t) / sizeof(uint8_t); // It's obviously 8
 
@@ -362,7 +362,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 					// Making the copy constructor deep-copy everything but the shader 
 					inline SEntry(const SEntry& other) 
 						: mainFileContents(other.mainFileContents), compilerArgs(other.compilerArgs), hash(other.hash), lookupHash(other.lookupHash), 
-						  dependencies(other.dependencies), value(other.value) {}
+						  dependencies(other.dependencies), cpuShader(other.cpuShader) {}
 
 					inline SEntry& operator=(SEntry& other) = delete;
 					inline SEntry(SEntry&& other) = default;
@@ -375,7 +375,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 					std::array<uint64_t,4> hash;
 					size_t lookupHash;
 					dependency_container_t dependencies;
-					core::smart_refctd_ptr<asset::ICPUShader> value;
+					core::smart_refctd_ptr<asset::ICPUShader> cpuShader;
 				};
 
 				inline void insert(SEntry&& entry)
@@ -399,7 +399,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 					return retVal;
 				}
 
-				NBL_API2 core::smart_refctd_ptr<asset::ICPUShader> find(const SEntry& mainFile, const CIncludeFinder* finder) const;
+				NBL_API2 SEntry find(const SEntry& mainFile, const CIncludeFinder* finder) const;
 
 				inline CCache() {}
 
@@ -433,24 +433,32 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 		{
 			CCache::SEntry entry;
 			std::vector<CCache::SEntry::SPreprocessingDependency> dependencies;
-			if (options.readCache or options.writeCache)
+			if (options.readCache || options.writeCache)
 				entry = std::move(CCache::SEntry(code, options));
+			
 			if (options.readCache)
 			{
 				auto found = options.readCache->find(entry, options.preprocessorOptions.includeFinder);
-				if (found)
-					return found;
+				auto cpuShader = found.cpuShader;
+				if (cpuShader)
+				{
+					if (options.writeCache)
+						options.writeCache->insert(std::move(found));
+					return cpuShader;
+				}
 			}
+
 			auto retVal = compileToSPIRV_impl(code, options, options.writeCache ? &dependencies : nullptr);
 			// compute the SPIR-V shader content hash
 			{
 				auto backingBuffer = retVal->getContent();
 				const_cast<ICPUBuffer*>(backingBuffer)->setContentHash(backingBuffer->computeContentHash());
 			}
+
 			if (options.writeCache)
 			{
 				entry.dependencies = std::move(dependencies);
-				entry.value = retVal;
+				entry.cpuShader = retVal;
 				options.writeCache->insert(std::move(entry));
 			}
 			return retVal;

include/nbl/asset/utils/IShaderCompiler.h

@@ -94,6 +94,9 @@ class NBL_API2 ISystem : public core::IReferenceCounted
 
         // can only perform operations on non-virtual filesystem paths
         bool deleteDirectory(const system::path& p);
+        
+        // can only perform operations on non-virtual filesystem paths
+        bool deleteFile(const system::path& p);
 
         // can only perform operations on non-virtual filesystem paths
         std::error_code moveFileOrDirectory(const system::path& oldPath, const system::path& newPath);

include/nbl/system/ISystem.h

@@ -216,7 +216,7 @@ auto IShaderCompiler::CIncludeFinder::tryIncludeGenerators(const std::string& in
     return {};
 }
 
-core::smart_refctd_ptr<asset::ICPUShader> IShaderCompiler::CCache::find(const SEntry& mainFile, const IShaderCompiler::CIncludeFinder* finder) const
+SEntry IShaderCompiler::CCache::find(const SEntry& mainFile, const IShaderCompiler::CIncludeFinder* finder) const
 {
     auto foundRange = m_container.equal_range(mainFile);
     for (auto& found = foundRange.first; found != foundRange.second; found++)
@@ -240,10 +240,10 @@ core::smart_refctd_ptr<asset::ICPUShader> IShaderCompiler::CCache::find(const SE
             }
         }
         if (allDependenciesMatch) {
-            return found->value;
+            return *found;
         }
     }
-    return nullptr;
+    return SEntry();
 }
 
 core::smart_refctd_ptr<ICPUBuffer> IShaderCompiler::CCache::serialize() const
@@ -263,10 +263,10 @@ core::smart_refctd_ptr<ICPUBuffer> IShaderCompiler::CCache::serialize() const
         // We keep a copy of the offsets and the sizes of each shader. This is so that later on, when we add the shaders to the buffer after json creation
         // (where the params array has been moved) we don't have to read the json to get the offsets again
         offsets[i] = shaderBufferSize;
-        sizes[i] = entry.value->getContent()->getSize();
+        sizes[i] = entry.cpuShader->getContent()->getSize();
 
         // And add the params to the shader creation parameters array
-        shaderCreationParams.emplace_back(entry.value->getStage(), entry.value->getContentType(), entry.value->getFilepathHint(), sizes[i], shaderBufferSize);
+        shaderCreationParams.emplace_back(entry.cpuShader->getStage(), entry.cpuShader->getContentType(), entry.cpuShader->getFilepathHint(), sizes[i], shaderBufferSize);
         // Enlarge the shader buffer by the size of the current shader
         shaderBufferSize += sizes[i];
         i++;
@@ -290,7 +290,7 @@ core::smart_refctd_ptr<ICPUBuffer> IShaderCompiler::CCache::serialize() const
     // Loop over entries again, adding each one's shader to the buffer. 
     i = 0u;
     for (auto& entry : m_container) {
-        memcpy(retVal.data() + SHADER_BUFFER_SIZE_BYTES + offsets[i], entry.value->getContent()->getPointer(), sizes[i]);
+        memcpy(retVal.data() + SHADER_BUFFER_SIZE_BYTES + offsets[i], entry.cpuShader->getContent()->getPointer(), sizes[i]);
         i++;
     }
 
@@ -335,9 +335,7 @@ core::smart_refctd_ptr<IShaderCompiler::CCache> IShaderCompiler::CCache::deseria
         // Copy the shader bytecode into the buffer
         memcpy(code->getPointer(), serializedCache.data() + SHADER_BUFFER_SIZE_BYTES + shaderCreationParams[i].offset, shaderCreationParams[i].codeByteSize);
         // Create the ICPUShader
-        auto value = core::make_smart_refctd_ptr<ICPUShader>(std::move(code), shaderCreationParams[i].stage, shaderCreationParams[i].contentType, std::move(shaderCreationParams[i].filepathHint));
-
-        entries[i].value = std::move(value);
+        entries[i].cpuShader = core::make_smart_refctd_ptr<ICPUShader>(std::move(code), shaderCreationParams[i].stage, shaderCreationParams[i].contentType, std::move(shaderCreationParams[i].filepathHint));
 
         retVal->insert(std::move(entries[i]));
     }

src/nbl/asset/utils/IShaderCompiler.cpp

@@ -192,7 +192,7 @@ inline void from_json(const json& j, SEntry& entry)
     j.at("hash").get_to(entry.hash);
     j.at("lookupHash").get_to(entry.lookupHash);
     j.at("dependencies").get_to(entry.dependencies);
-    entry.value = nullptr;
+    entry.cpuShader = nullptr;
 }
 
 }

src/nbl/asset/utils/shaderCompiler_serialization.h

@@ -120,6 +120,14 @@ bool ISystem::deleteDirectory(const system::path& p)
         return false;
 }
 
+bool nbl::system::ISystem::deleteFile(const system::path& p)
+{
+    if (std::filesystem::exists(p))
+        return std::filesystem::remove(p);
+    else
+        return false;
+}
+
 std::error_code ISystem::moveFileOrDirectory(const system::path& oldPath, const system::path& newPath)
 {
     std::error_code ec;