Add include session cache plumbing

AnastaZIuk · AnastaZIuk · commit daf1fe39a433 · 2026-03-26T06:24:48.000+01:00
diff --git a/include/nbl/asset/utils/IShaderCompiler.h b/include/nbl/asset/utils/IShaderCompiler.h
@@ -17,6 +17,8 @@
 #include "nbl/builtin/hlsl/enums.hlsl"
 
 #include <functional>
+#include <mutex>
+#include <unordered_set>
 
 namespace nbl::asset
 {
@@ -74,17 +76,39 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 		class NBL_API2 CIncludeFinder : public core::IReferenceCounted
 		{
 			public:
+				struct SSessionCache
+				{
+					enum class E_LOOKUP_RESULT : uint8_t
+					{
+						Miss,
+						Missing,
+						Found
+					};
+
+					explicit SSessionCache(const bool threadSafe = false) : threadSafe(threadSafe) {}
+
+					void clear();
+					E_LOOKUP_RESULT lookup(const std::string& key, IIncludeLoader::found_t& result) const;
+					void store(const std::string& key, IIncludeLoader::found_t result);
+
+					bool threadSafe = false;
+
+					mutable std::mutex mutex;
+					core::unordered_map<std::string, IIncludeLoader::found_t> found;
+					core::unordered_set<std::string> missing;
+				};
+
 				CIncludeFinder(core::smart_refctd_ptr<system::ISystem>&& system);
 
 				// ! includes within <>
 				// @param requestingSourceDir: the directory where the incude was requested
 				// @param includeName: the string within <> of the include preprocessing directive
-				IIncludeLoader::found_t getIncludeStandard(const system::path& requestingSourceDir, const std::string& includeName, bool needHash = true) const;
+				IIncludeLoader::found_t getIncludeStandard(const system::path& requestingSourceDir, const std::string& includeName, bool needHash = true, SSessionCache* sessionCache = nullptr) const;
 
 				// ! includes within ""
 				// @param requestingSourceDir: the directory where the incude was requested
 				// @param includeName: the string within "" of the include preprocessing directive
-				IIncludeLoader::found_t getIncludeRelative(const system::path& requestingSourceDir, const std::string& includeName, bool needHash = true) const;
+				IIncludeLoader::found_t getIncludeRelative(const system::path& requestingSourceDir, const std::string& includeName, bool needHash = true, SSessionCache* sessionCache = nullptr) const;
 
 				inline core::smart_refctd_ptr<CFileSystemIncludeLoader> getDefaultFileSystemLoader() const { return m_defaultFileSystemLoader; }
 
@@ -134,6 +158,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 			std::string_view sourceIdentifier = "";
 			system::logger_opt_ptr logger = nullptr;
 			const CIncludeFinder* includeFinder = nullptr;
+			mutable CIncludeFinder::SSessionCache* includeSessionCache = nullptr;
 			std::span<const SMacroDefinition> extraDefines = {};
 			E_SPIRV_VERSION targetSpirvVersion = E_SPIRV_VERSION::ESV_1_6;
 			bool depfile = false;
diff --git a/src/nbl/asset/utils/CGLSLCompiler.cpp b/src/nbl/asset/utils/CGLSLCompiler.cpp
@@ -44,11 +44,12 @@ namespace nbl::asset::impl
     class Includer : public shaderc::CompileOptions::IncluderInterface
     {
         const IShaderCompiler::CIncludeFinder* m_defaultIncludeFinder;
+        IShaderCompiler::CIncludeFinder::SSessionCache* m_includeSessionCache;
         const system::ISystem* m_system;
         const uint32_t m_maxInclCnt;
 
     public:
-        Includer(const IShaderCompiler::CIncludeFinder* _inclFinder, const system::ISystem* _fs, uint32_t _maxInclCnt) : m_defaultIncludeFinder(_inclFinder), m_system(_fs), m_maxInclCnt{ _maxInclCnt } {}
+        Includer(const IShaderCompiler::CIncludeFinder* _inclFinder, IShaderCompiler::CIncludeFinder::SSessionCache* _includeSessionCache, const system::ISystem* _fs, uint32_t _maxInclCnt) : m_defaultIncludeFinder(_inclFinder), m_includeSessionCache(_includeSessionCache), m_system(_fs), m_maxInclCnt{ _maxInclCnt } {}
 
         //_requesting_source in top level #include's is what shaderc::Compiler's compiling functions get as `input_file_name` parameter
         //so in order for properly working relative #include's (""-type) `input_file_name` has to be path to file from which the GLSL source really come from
@@ -81,11 +82,11 @@ namespace nbl::asset::impl
             IShaderCompiler::IIncludeLoader::found_t result;
             if (_type == shaderc_include_type_relative)
             {
-                result = m_defaultIncludeFinder->getIncludeRelative(relDir, _requested_source);
+                result = m_defaultIncludeFinder->getIncludeRelative(relDir, _requested_source, true, m_includeSessionCache);
             }
             else //shaderc_include_type_standard
             {
-                result = m_defaultIncludeFinder->getIncludeStandard(relDir, _requested_source);
+                result = m_defaultIncludeFinder->getIncludeStandard(relDir, _requested_source, true, m_includeSessionCache);
             }
 
             if (!result)
@@ -136,10 +137,15 @@ CGLSLCompiler::CGLSLCompiler(core::smart_refctd_ptr<system::ISystem>&& system)
 
 std::string CGLSLCompiler::preprocessShader(std::string&& code, IShader::E_SHADER_STAGE& stage, const SPreprocessorOptions& preprocessOptions, std::vector<CCache::SEntry::SPreprocessingDependency>* dependencies) const
 {
+    auto effectiveOptions = preprocessOptions;
+    IShaderCompiler::CIncludeFinder::SSessionCache localIncludeSessionCache;
+    if (effectiveOptions.includeFinder && !effectiveOptions.includeSessionCache)
+        effectiveOptions.includeSessionCache = &localIncludeSessionCache;
+
     if (!preprocessOptions.extraDefines.empty())
     {
         std::ostringstream insertion;
-        for (const auto& define : preprocessOptions.extraDefines)
+        for (const auto& define : effectiveOptions.extraDefines)
             insertion << "#define " << define.identifier << " " << define.definition << "\n";
         insertIntoStart(code,std::move(insertion));
     }
@@ -149,15 +155,15 @@ std::string CGLSLCompiler::preprocessShader(std::string&& code, IShader::E_SHADE
     shaderc::CompileOptions options;
     options.SetTargetSpirv(shaderc_spirv_version_1_6);
 
-    if (preprocessOptions.includeFinder != nullptr)
+    if (effectiveOptions.includeFinder != nullptr)
     {
-        options.SetIncluder(std::make_unique<impl::Includer>(preprocessOptions.includeFinder, m_system.get(), /*maxSelfInclusionCount*/5));//custom #include handler
+        options.SetIncluder(std::make_unique<impl::Includer>(effectiveOptions.includeFinder, effectiveOptions.includeSessionCache, m_system.get(), /*maxSelfInclusionCount*/5));//custom #include handler
     }
     const shaderc_shader_kind scstage = stage == IShader::E_SHADER_STAGE::ESS_UNKNOWN ? shaderc_glsl_infer_from_source : ESStoShadercEnum(stage);
-    auto res = comp.PreprocessGlsl(code, scstage, preprocessOptions.sourceIdentifier.data(), options);
+    auto res = comp.PreprocessGlsl(code, scstage, effectiveOptions.sourceIdentifier.data(), options);
 
     if (res.GetCompilationStatus() != shaderc_compilation_status_success) {
-        preprocessOptions.logger.log("%s\n", system::ILogger::ELL_ERROR, res.GetErrorMessage().c_str());
+        effectiveOptions.logger.log("%s\n", system::ILogger::ELL_ERROR, res.GetErrorMessage().c_str());
         return nullptr;
     }
 
diff --git a/src/nbl/asset/utils/CHLSLCompiler.cpp b/src/nbl/asset/utils/CHLSLCompiler.cpp
@@ -454,12 +454,17 @@ static std::string preprocessShaderImpl(
     std::vector<IShaderCompiler::CCache::SEntry::SPreprocessingDependency>* dependencies,
     system::ISystem* system)
 {
-    const bool depfileEnabled = preprocessOptions.depfile;
+    auto effectiveOptions = preprocessOptions;
+    IShaderCompiler::CIncludeFinder::SSessionCache localIncludeSessionCache;
+    if (effectiveOptions.includeFinder && !effectiveOptions.includeSessionCache)
+        effectiveOptions.includeSessionCache = &localIncludeSessionCache;
+
+    const bool depfileEnabled = effectiveOptions.depfile;
     if (depfileEnabled)
     {
-        if (preprocessOptions.depfilePath.empty())
+        if (effectiveOptions.depfilePath.empty())
         {
-            preprocessOptions.logger.log("Depfile path is empty.", system::ILogger::ELL_ERROR);
+            effectiveOptions.logger.log("Depfile path is empty.", system::ILogger::ELL_ERROR);
             return {};
         }
     }
@@ -473,7 +478,7 @@ static std::string preprocessShaderImpl(
     ensureTrailingNewline(code);
 
     // preprocess
-    core::string resolvedString = nbl::wave::preprocess(code, preprocessOptions, bool(dependenciesOut),
+    core::string resolvedString = nbl::wave::preprocess(code, effectiveOptions, bool(dependenciesOut),
         [&dxc_compile_flags_override, &stage, &dependenciesOut](nbl::wave::context& context) -> void
         {
             if (context.get_hooks().m_dxc_compile_flags_override.size() != 0)
@@ -494,13 +499,13 @@ static std::string preprocessShaderImpl(
     if (depfileEnabled)
     {
         IShaderCompiler::DepfileWriteParams params = {};
-        const std::string depfilePathString = preprocessOptions.depfilePath.generic_string();
+        const std::string depfilePathString = effectiveOptions.depfilePath.generic_string();
         params.depfilePath = depfilePathString;
-        params.sourceIdentifier = preprocessOptions.sourceIdentifier;
+        params.sourceIdentifier = effectiveOptions.sourceIdentifier;
         if (!params.sourceIdentifier.empty())
             params.workingDirectory = std::filesystem::path(std::string(params.sourceIdentifier)).parent_path();
         params.system = system;
-        if (!IShaderCompiler::writeDepfile(params, *dependenciesOut, preprocessOptions.includeFinder, preprocessOptions.logger))
+        if (!IShaderCompiler::writeDepfile(params, *dependenciesOut, effectiveOptions.includeFinder, effectiveOptions.logger))
             return {};
     }
 
diff --git a/src/nbl/asset/utils/IShaderCompiler.cpp b/src/nbl/asset/utils/IShaderCompiler.cpp
@@ -651,6 +651,68 @@ std::string normalizeIncludeLookupName(const std::string& includeName)
     return includeName.substr(1ull);
 }
 
+template<typename Func>
+auto withSessionCacheLock(IShaderCompiler::CIncludeFinder::SSessionCache* cache, Func&& func) -> decltype(func())
+{
+    if (cache && cache->threadSafe)
+    {
+        std::lock_guard lock(cache->mutex);
+        return func();
+    }
+    return func();
+}
+
+std::string makeIncludeSessionCacheKey(const system::path& requestingSourceDir, std::string_view includeName, const bool needHash, const char mode)
+{
+    const auto requestingDir = requestingSourceDir.generic_string();
+    std::string key;
+    key.reserve(requestingDir.size() + includeName.size() + 4ull);
+    key.push_back(mode);
+    key.push_back('\n');
+    key.push_back(needHash ? 'H' : 'N');
+    key.push_back('\n');
+    key.append(requestingDir);
+    key.push_back('\n');
+    key.append(includeName.data(), includeName.size());
+    return key;
+}
+
+}
+
+void IShaderCompiler::CIncludeFinder::SSessionCache::clear()
+{
+    withSessionCacheLock(this, [&]()
+    {
+        found.clear();
+        missing.clear();
+    });
+}
+
+auto IShaderCompiler::CIncludeFinder::SSessionCache::lookup(const std::string& key, IIncludeLoader::found_t& result) const -> E_LOOKUP_RESULT
+{
+    return withSessionCacheLock(const_cast<SSessionCache*>(this), [&]() -> E_LOOKUP_RESULT
+    {
+        if (const auto foundIt = found.find(key); foundIt != found.end())
+        {
+            result = foundIt->second;
+            return E_LOOKUP_RESULT::Found;
+        }
+        if (missing.contains(key))
+            return E_LOOKUP_RESULT::Missing;
+        return E_LOOKUP_RESULT::Miss;
+    });
+}
+
+void IShaderCompiler::CIncludeFinder::SSessionCache::store(const std::string& key, IIncludeLoader::found_t result)
+{
+    withSessionCacheLock(this, [&]()
+    {
+        missing.erase(key);
+        if (result)
+            found.insert_or_assign(key, std::move(result));
+        else
+            missing.insert(key);
+    });
 }
 
 IShaderCompiler::CIncludeFinder::CIncludeFinder(core::smart_refctd_ptr<system::ISystem>&& system)
@@ -663,10 +725,21 @@ IShaderCompiler::CIncludeFinder::CIncludeFinder(core::smart_refctd_ptr<system::I
 // @param requestingSourceDir: the directory where the incude was requested
 // @param includeName: the string within <> of the include preprocessing directive
 // @param 
-auto IShaderCompiler::CIncludeFinder::getIncludeStandard(const system::path& requestingSourceDir, const std::string& includeName, bool needHash) const -> IIncludeLoader::found_t
+auto IShaderCompiler::CIncludeFinder::getIncludeStandard(const system::path& requestingSourceDir, const std::string& includeName, bool needHash, SSessionCache* sessionCache) const -> IIncludeLoader::found_t
 {
     const auto lookupName = normalizeIncludeLookupName(includeName);
+    const auto cacheKey = makeIncludeSessionCacheKey(requestingSourceDir, lookupName, needHash, 'S');
     IShaderCompiler::IIncludeLoader::found_t retVal;
+    switch (sessionCache ? sessionCache->lookup(cacheKey, retVal) : SSessionCache::E_LOOKUP_RESULT::Miss)
+    {
+        case SSessionCache::E_LOOKUP_RESULT::Found:
+            return retVal;
+        case SSessionCache::E_LOOKUP_RESULT::Missing:
+            return {};
+        case SSessionCache::E_LOOKUP_RESULT::Miss:
+            break;
+    }
+
     if (auto contents = tryIncludeGenerators(lookupName))
         retVal = std::move(contents);
     else if (auto contents = trySearchPaths(lookupName, needHash))
@@ -680,16 +753,29 @@ auto IShaderCompiler::CIncludeFinder::getIncludeStandard(const system::path& req
         hasher.update(reinterpret_cast<uint8_t*>(retVal.contents.data()), retVal.contents.size() * (sizeof(char) / sizeof(uint8_t)));
         retVal.hash = static_cast<core::blake3_hash_t>(hasher);
     }
+    if (sessionCache)
+        sessionCache->store(cacheKey, retVal);
     return retVal;
 }
 
 // ! includes within ""
 // @param requestingSourceDir: the directory where the incude was requested
 // @param includeName: the string within "" of the include preprocessing directive
-auto IShaderCompiler::CIncludeFinder::getIncludeRelative(const system::path& requestingSourceDir, const std::string& includeName, bool needHash) const -> IIncludeLoader::found_t
+auto IShaderCompiler::CIncludeFinder::getIncludeRelative(const system::path& requestingSourceDir, const std::string& includeName, bool needHash, SSessionCache* sessionCache) const -> IIncludeLoader::found_t
 {
     const auto lookupName = normalizeIncludeLookupName(includeName);
+    const auto cacheKey = makeIncludeSessionCacheKey(requestingSourceDir, lookupName, needHash, 'R');
     IShaderCompiler::IIncludeLoader::found_t retVal;
+    switch (sessionCache ? sessionCache->lookup(cacheKey, retVal) : SSessionCache::E_LOOKUP_RESULT::Miss)
+    {
+        case SSessionCache::E_LOOKUP_RESULT::Found:
+            return retVal;
+        case SSessionCache::E_LOOKUP_RESULT::Missing:
+            return {};
+        case SSessionCache::E_LOOKUP_RESULT::Miss:
+            break;
+    }
+
     if (auto contents = m_defaultFileSystemLoader->getInclude(requestingSourceDir.string(), lookupName, needHash))
         retVal = std::move(contents);
     else retVal = std::move(trySearchPaths(lookupName, needHash));
@@ -700,6 +786,8 @@ auto IShaderCompiler::CIncludeFinder::getIncludeRelative(const system::path& req
         hasher.update(reinterpret_cast<uint8_t*>(retVal.contents.data()), retVal.contents.size() * (sizeof(char) / sizeof(uint8_t)));
         retVal.hash = static_cast<core::blake3_hash_t>(hasher);
     }
+    if (sessionCache)
+        sessionCache->store(cacheKey, retVal);
     return retVal;
 }
 
diff --git a/src/nbl/asset/utils/waveContext.h b/src/nbl/asset/utils/waveContext.h
@@ -275,7 +275,7 @@ struct load_to_string final
 struct preprocessing_hooks final : public boost::wave::context_policies::default_preprocessing_hooks
 {
     preprocessing_hooks(const nbl::asset::IShaderCompiler::SPreprocessorOptions& _preprocessOptions)
-        : m_includeFinder(_preprocessOptions.includeFinder), m_logger(_preprocessOptions.logger), m_preserveComments(_preprocessOptions.preserveComments), m_pragmaStage(nbl::asset::IShader::E_SHADER_STAGE::ESS_UNKNOWN), m_dxc_compile_flags_override()
+        : m_includeFinder(_preprocessOptions.includeFinder), m_includeSessionCache(_preprocessOptions.includeSessionCache), m_logger(_preprocessOptions.logger), m_preserveComments(_preprocessOptions.preserveComments), m_pragmaStage(nbl::asset::IShader::E_SHADER_STAGE::ESS_UNKNOWN), m_dxc_compile_flags_override()
     {
         hash_token_occurences = 0;
     }
@@ -382,6 +382,7 @@ struct preprocessing_hooks final : public boost::wave::context_policies::default
     }
 
     const asset::IShaderCompiler::CIncludeFinder* m_includeFinder;
+    asset::IShaderCompiler::CIncludeFinder::SSessionCache* m_includeSessionCache;
     system::logger_opt_ptr m_logger;
     bool m_preserveComments;
     asset::IShader::E_SHADER_STAGE m_pragmaStage;
@@ -832,11 +833,11 @@ template<> inline bool boost::wave::impl::pp_iterator_functor<nbl::wave::context
         if (perfStats.enabled)
             ++perfStats.includeLookupCount;
         if (is_system) {
-            result = includeFinder->getIncludeStandard(ctx.get_current_directory(), file_path, needHash);
+            result = includeFinder->getIncludeStandard(ctx.get_current_directory(), file_path, needHash, ctx.get_hooks().m_includeSessionCache);
             standardInclude = true;
         }
         else {
-            result = includeFinder->getIncludeRelative(ctx.get_current_directory(), file_path, needHash);
+            result = includeFinder->getIncludeRelative(ctx.get_current_directory(), file_path, needHash, ctx.get_hooks().m_includeSessionCache);
             standardInclude = false;
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -44,11 +44,12 @@ namespace nbl::asset::impl`
`44`	`44`	`class Includer : public shaderc::CompileOptions::IncluderInterface`
`45`	`45`	`{`
`46`	`46`	`const IShaderCompiler::CIncludeFinder* m_defaultIncludeFinder;`
	`47`	`+ IShaderCompiler::CIncludeFinder::SSessionCache* m_includeSessionCache;`
`47`	`48`	`const system::ISystem* m_system;`
`48`	`49`	`const uint32_t m_maxInclCnt;`
`49`	`50`
`50`	`51`	`public:`
`51`		`- Includer(const IShaderCompiler::CIncludeFinder* _inclFinder, const system::ISystem* _fs, uint32_t _maxInclCnt) : m_defaultIncludeFinder(_inclFinder), m_system(_fs), m_maxInclCnt{ _maxInclCnt } {}`
	`52`	`+ Includer(const IShaderCompiler::CIncludeFinder* _inclFinder, IShaderCompiler::CIncludeFinder::SSessionCache* _includeSessionCache, const system::ISystem* _fs, uint32_t _maxInclCnt) : m_defaultIncludeFinder(_inclFinder), m_includeSessionCache(_includeSessionCache), m_system(_fs), m_maxInclCnt{ _maxInclCnt } {}`
`52`	`53`
`53`	`54`	//_requesting_source in top level #include's is what shaderc::Compiler's compiling functions get as `input_file_name` parameter
`54`	`55`	//so in order for properly working relative #include's (""-type) `input_file_name` has to be path to file from which the GLSL source really come from
`@@ -81,11 +82,11 @@ namespace nbl::asset::impl`
`81`	`82`	`IShaderCompiler::IIncludeLoader::found_t result;`
`82`	`83`	`if (_type == shaderc_include_type_relative)`
`83`	`84`	`{`
`84`		`- result = m_defaultIncludeFinder->getIncludeRelative(relDir, _requested_source);`
	`85`	`+ result = m_defaultIncludeFinder->getIncludeRelative(relDir, _requested_source, true, m_includeSessionCache);`
`85`	`86`	`}`
`86`	`87`	`else //shaderc_include_type_standard`
`87`	`88`	`{`
`88`		`- result = m_defaultIncludeFinder->getIncludeStandard(relDir, _requested_source);`
	`89`	`+ result = m_defaultIncludeFinder->getIncludeStandard(relDir, _requested_source, true, m_includeSessionCache);`
`89`	`90`	`}`
`90`	`91`
`91`	`92`	`if (!result)`
`@@ -136,10 +137,15 @@ CGLSLCompiler::CGLSLCompiler(core::smart_refctd_ptr<system::ISystem>&& system)`
`136`	`137`
`137`	`138`	`std::string CGLSLCompiler::preprocessShader(std::string&& code, IShader::E_SHADER_STAGE& stage, const SPreprocessorOptions& preprocessOptions, std::vector<CCache::SEntry::SPreprocessingDependency>* dependencies) const`
`138`	`139`	`{`
	`140`	`+ auto effectiveOptions = preprocessOptions;`
	`141`	`+ IShaderCompiler::CIncludeFinder::SSessionCache localIncludeSessionCache;`
	`142`	`+ if (effectiveOptions.includeFinder && !effectiveOptions.includeSessionCache)`
	`143`	`+ effectiveOptions.includeSessionCache = &localIncludeSessionCache;`
	`144`	`+`
`139`	`145`	`if (!preprocessOptions.extraDefines.empty())`
`140`	`146`	`{`
`141`	`147`	`std::ostringstream insertion;`
`142`		`- for (const auto& define : preprocessOptions.extraDefines)`
	`148`	`+ for (const auto& define : effectiveOptions.extraDefines)`
`143`	`149`	`insertion << "#define " << define.identifier << " " << define.definition << "\n";`
`144`	`150`	`insertIntoStart(code,std::move(insertion));`
`145`	`151`	`}`
`@@ -149,15 +155,15 @@ std::string CGLSLCompiler::preprocessShader(std::string&& code, IShader::E_SHADE`
`149`	`155`	`shaderc::CompileOptions options;`
`150`	`156`	`options.SetTargetSpirv(shaderc_spirv_version_1_6);`
`151`	`157`
`152`		`- if (preprocessOptions.includeFinder != nullptr)`
	`158`	`+ if (effectiveOptions.includeFinder != nullptr)`
`153`	`159`	`{`
`154`		`- options.SetIncluder(std::make_unique<impl::Includer>(preprocessOptions.includeFinder, m_system.get(), /maxSelfInclusionCount/5));//custom #include handler`
	`160`	`+ options.SetIncluder(std::make_unique<impl::Includer>(effectiveOptions.includeFinder, effectiveOptions.includeSessionCache, m_system.get(), /maxSelfInclusionCount/5));//custom #include handler`
`155`	`161`	`}`
`156`	`162`	`const shaderc_shader_kind scstage = stage == IShader::E_SHADER_STAGE::ESS_UNKNOWN ? shaderc_glsl_infer_from_source : ESStoShadercEnum(stage);`
`157`		`- auto res = comp.PreprocessGlsl(code, scstage, preprocessOptions.sourceIdentifier.data(), options);`
	`163`	`+ auto res = comp.PreprocessGlsl(code, scstage, effectiveOptions.sourceIdentifier.data(), options);`
`158`	`164`
`159`	`165`	`if (res.GetCompilationStatus() != shaderc_compilation_status_success) {`
`160`		`- preprocessOptions.logger.log("%s\n", system::ILogger::ELL_ERROR, res.GetErrorMessage().c_str());`
	`166`	`+ effectiveOptions.logger.log("%s\n", system::ILogger::ELL_ERROR, res.GetErrorMessage().c_str());`
`161`	`167`	`return nullptr;`
`162`	`168`	`}`
`163`	`169`
Original file line number	Diff line number	Diff line change
`@@ -454,12 +454,17 @@ static std::string preprocessShaderImpl(`
`454`	`454`	`std::vector<IShaderCompiler::CCache::SEntry::SPreprocessingDependency>* dependencies,`
`455`	`455`	`system::ISystem* system)`
`456`	`456`	`{`
`457`		`- const bool depfileEnabled = preprocessOptions.depfile;`
	`457`	`+ auto effectiveOptions = preprocessOptions;`
	`458`	`+ IShaderCompiler::CIncludeFinder::SSessionCache localIncludeSessionCache;`
	`459`	`+ if (effectiveOptions.includeFinder && !effectiveOptions.includeSessionCache)`
	`460`	`+ effectiveOptions.includeSessionCache = &localIncludeSessionCache;`
	`461`	`+`
	`462`	`+ const bool depfileEnabled = effectiveOptions.depfile;`
`458`	`463`	`if (depfileEnabled)`
`459`	`464`	`{`
`460`		`- if (preprocessOptions.depfilePath.empty())`
	`465`	`+ if (effectiveOptions.depfilePath.empty())`
`461`	`466`	`{`
`462`		`- preprocessOptions.logger.log("Depfile path is empty.", system::ILogger::ELL_ERROR);`
	`467`	`+ effectiveOptions.logger.log("Depfile path is empty.", system::ILogger::ELL_ERROR);`
`463`	`468`	`return {};`
`464`	`469`	`}`
`465`	`470`	`}`
`@@ -473,7 +478,7 @@ static std::string preprocessShaderImpl(`
`473`	`478`	`ensureTrailingNewline(code);`
`474`	`479`
`475`	`480`	`// preprocess`
`476`		`- core::string resolvedString = nbl::wave::preprocess(code, preprocessOptions, bool(dependenciesOut),`
	`481`	`+ core::string resolvedString = nbl::wave::preprocess(code, effectiveOptions, bool(dependenciesOut),`
`477`	`482`	`[&dxc_compile_flags_override, &stage, &dependenciesOut](nbl::wave::context& context) -> void`
`478`	`483`	`{`
`479`	`484`	`if (context.get_hooks().m_dxc_compile_flags_override.size() != 0)`
`@@ -494,13 +499,13 @@ static std::string preprocessShaderImpl(`
`494`	`499`	`if (depfileEnabled)`
`495`	`500`	`{`
`496`	`501`	`IShaderCompiler::DepfileWriteParams params = {};`
`497`		`- const std::string depfilePathString = preprocessOptions.depfilePath.generic_string();`
	`502`	`+ const std::string depfilePathString = effectiveOptions.depfilePath.generic_string();`
`498`	`503`	`params.depfilePath = depfilePathString;`
`499`		`- params.sourceIdentifier = preprocessOptions.sourceIdentifier;`
	`504`	`+ params.sourceIdentifier = effectiveOptions.sourceIdentifier;`
`500`	`505`	`if (!params.sourceIdentifier.empty())`
`501`	`506`	`params.workingDirectory = std::filesystem::path(std::string(params.sourceIdentifier)).parent_path();`
`502`	`507`	`params.system = system;`
`503`		`- if (!IShaderCompiler::writeDepfile(params, *dependenciesOut, preprocessOptions.includeFinder, preprocessOptions.logger))`
	`508`	`+ if (!IShaderCompiler::writeDepfile(params, *dependenciesOut, effectiveOptions.includeFinder, effectiveOptions.logger))`
`504`	`509`	`return {};`
`505`	`510`	`}`
`506`	`511`
Original file line number	Diff line number	Diff line change
`@@ -275,7 +275,7 @@ struct load_to_string final`
`275`	`275`	`struct preprocessing_hooks final : public boost::wave::context_policies::default_preprocessing_hooks`
`276`	`276`	`{`
`277`	`277`	`preprocessing_hooks(const nbl::asset::IShaderCompiler::SPreprocessorOptions& _preprocessOptions)`
`278`		`- : m_includeFinder(_preprocessOptions.includeFinder), m_logger(_preprocessOptions.logger), m_preserveComments(_preprocessOptions.preserveComments), m_pragmaStage(nbl::asset::IShader::E_SHADER_STAGE::ESS_UNKNOWN), m_dxc_compile_flags_override()`
	`278`	`+ : m_includeFinder(_preprocessOptions.includeFinder), m_includeSessionCache(_preprocessOptions.includeSessionCache), m_logger(_preprocessOptions.logger), m_preserveComments(_preprocessOptions.preserveComments), m_pragmaStage(nbl::asset::IShader::E_SHADER_STAGE::ESS_UNKNOWN), m_dxc_compile_flags_override()`
`279`	`279`	`{`
`280`	`280`	`hash_token_occurences = 0;`
`281`	`281`	`}`
`@@ -382,6 +382,7 @@ struct preprocessing_hooks final : public boost::wave::context_policies::default`
`382`	`382`	`}`
`383`	`383`
`384`	`384`	`const asset::IShaderCompiler::CIncludeFinder* m_includeFinder;`
	`385`	`+ asset::IShaderCompiler::CIncludeFinder::SSessionCache* m_includeSessionCache;`
`385`	`386`	`system::logger_opt_ptr m_logger;`
`386`	`387`	`bool m_preserveComments;`
`387`	`388`	`asset::IShader::E_SHADER_STAGE m_pragmaStage;`
`@@ -832,11 +833,11 @@ template<> inline bool boost::wave::impl::pp_iterator_functor<nbl::wave::context`
`832`	`833`	`if (perfStats.enabled)`
`833`	`834`	`++perfStats.includeLookupCount;`
`834`	`835`	`if (is_system) {`
`835`		`- result = includeFinder->getIncludeStandard(ctx.get_current_directory(), file_path, needHash);`
	`836`	`+ result = includeFinder->getIncludeStandard(ctx.get_current_directory(), file_path, needHash, ctx.get_hooks().m_includeSessionCache);`
`836`	`837`	`standardInclude = true;`
`837`	`838`	`}`
`838`	`839`	`else {`
`839`		`- result = includeFinder->getIncludeRelative(ctx.get_current_directory(), file_path, needHash);`
	`840`	`+ result = includeFinder->getIncludeRelative(ctx.get_current_directory(), file_path, needHash, ctx.get_hooks().m_includeSessionCache);`
`840`	`841`	`standardInclude = false;`
`841`	`842`	`}`
`842`	`843`	`}`