Asset restore impl and used where needed, fixed ex18, new class CDerivativeMapCreator

Crisspl · Crisspl · commit 88e2e2b3c1c9 · 2021-02-10T17:33:35.000+01:00
diff --git a/examples_tests/18.MitsubaLoader/main.cpp b/examples_tests/18.MitsubaLoader/main.cpp
@@ -213,8 +213,6 @@ int main()
 
 		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);
-		serializedLoader->initialize();
-		mitsubaLoader->initialize();
 		am->addAssetLoader(std::move(serializedLoader));
 		am->addAssetLoader(std::move(mitsubaLoader));
 
@@ -324,6 +322,7 @@ int main()
 
 	video::IVideoDriver* driver = device->getVideoDriver();
 	asset::IAssetManager* am = device->getAssetManager();
+	io::IFileSystem* fs = device->getFileSystem();
 
 	// look out for this!!!
 	// when added, CMitsubaLoader inserts its own include loader into GLSLCompiler
diff --git a/include/nbl/asset/IAsset.h b/include/nbl/asset/IAsset.h
@@ -177,6 +177,7 @@ class IAsset : virtual public core::IReferenceCounted
 				return false;
 
 			restoreFromDummy_impl(_other, _levelsBelow);
+			isDummyObjectForCacheAliasing = false;
 			return true;
 		}
 
diff --git a/include/nbl/asset/IAssetManager.h b/include/nbl/asset/IAssetManager.h
@@ -574,6 +574,7 @@ class IAssetManager : public core::IReferenceCounted, public core::QuitSignallin
         //! @returns 0xdeadbeefu on failure or 0-based index on success.
         uint32_t addAssetLoader(core::smart_refctd_ptr<IAssetLoader>&& _loader)
         {
+            _loader->initialize();
             // there's no way it ever fails, so no 0xdeadbeef return
             const char** exts = _loader->getAssociatedFileExtensions();
             size_t extIx = 0u;
diff --git a/include/nbl/asset/interchange/IAssetLoader.h b/include/nbl/asset/interchange/IAssetLoader.h
@@ -289,6 +289,42 @@ class IAssetLoader : public virtual core::IReferenceCounted
 	SAssetBundle interm_getAssetInHierarchy(IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override);
 	SAssetBundle interm_getAssetInHierarchy(IAssetManager* _mgr, io::IReadFile* _file, const std::string& _supposedFilename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel);
 	SAssetBundle interm_getAssetInHierarchy(IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel);
+	//! ECF_DUPLICATE_* flags are ignored (since there's no point in **restoring** if we're not even looking into the cache) -- only ECF_DONT_CACHE_* are honored
+	//! `Args` ought to be same parameter types as interm_getAssetInHierarchy(...) overloads offer
+	template <typename ...Args>
+	SAssetBundle interm_getRestoredAssetInHierarchy(uint32_t _restoreLevels, Args&&... args)
+	{
+		if (_restoreLevels == 0u)
+			return interm_getAssetInHierarchy(std::forward<Args>(args)...);
+
+		auto any_dummy = [](const SAssetBundle& b) {
+			for (const auto& a : b.getContents())
+				if (a->isADummyObjectForCache())
+					return true;
+		};
+
+		auto bundle = interm_getAssetInHierarchy_find(std::forward<Args>(args)...);
+
+		if (bundle.getContents().empty() || !any_dummy(bundle))
+			return bundle;
+		auto reloadedBundle = interm_getAssetInHierarchy_reload(_restoreLevels, std::forward<Args>(args)...);
+
+		assert(bundle.getContents().size() == reloadedBundle.getContents().size());
+
+		const uint32_t count = bundle.getContents().size();
+		auto* dummies = bundle.getContents().begin();
+		auto* reloaded = reloadedBundle.getContents().begin();
+		for (uint32_t i = 0u; i < count; ++i)
+			if (dummies[i]->isADummyObjectForCache() && !dummies[i]->canBeRestoredFrom(reloaded[i].get()))
+				return {}; // return empty bundle
+
+		for (uint32_t i = 0u; i < count; ++i)
+			if (dummies[i]->isADummyObjectForCache())
+				dummies[i]->restoreFromDummy(reloaded[i].get(), _restoreLevels);
+
+		return bundle;
+	}
+
     void interm_setAssetMutability(const IAssetManager* _mgr, IAsset* _asset, IAsset::E_MUTABILITY _val);
 	//void interm_restoreDummyAsset(IAssetManager* _mgr, SAssetBundle& _bundle);
 	//void interm_restoreDummyAsset(IAssetManager* _mgr, IAsset* _asset, const std::string _path);
@@ -301,6 +337,50 @@ class IAssetLoader : public virtual core::IReferenceCounted
 	{
 		bundle.setAsset(offset,std::move(_asset));
 	}
+
+private:
+	static IAssetLoader::SAssetLoadParams getFindParams(IAssetLoader::SAssetLoadParams _params)
+	{
+		_params.cacheFlags = static_cast<E_CACHING_FLAGS>(_params.cacheFlags & ECF_DONT_CACHE_REFERENCES);
+		return _params;
+	}
+	SAssetBundle interm_getAssetInHierarchy_find(IAssetManager* _mgr, io::IReadFile* _file, const std::string& _supposedFilename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
+	{
+		return interm_getAssetInHierarchy(_mgr, _file, _supposedFilename, getFindParams(_params), _hierarchyLevel);
+	}
+	SAssetBundle interm_getAssetInHierarchy_find(IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
+	{
+		return interm_getAssetInHierarchy(_mgr, _filename, getFindParams(_params), _hierarchyLevel, _override);
+	}
+	SAssetBundle interm_getAssetInHierarchy_find(IAssetManager* _mgr, io::IReadFile* _file, const std::string& _supposedFilename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel)
+	{
+		return interm_getAssetInHierarchy(_mgr, _file, _supposedFilename, getFindParams(_params), _hierarchyLevel);
+	}
+	SAssetBundle interm_getAssetInHierarchy_find(IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel)
+	{
+		return interm_getAssetInHierarchy(_mgr, _filename, getFindParams(_params), _hierarchyLevel);
+	}
+	static IAssetLoader::SAssetLoadParams getReloadParams(IAssetLoader::SAssetLoadParams _params, uint32_t _restoreLevels, uint32_t _hierLevel)
+	{
+		_params.cacheFlags = ECF_DUPLICATE_UNTIL_LEVEL(_restoreLevels + _hierLevel);
+		return _params;
+	}
+	SAssetBundle interm_getAssetInHierarchy_reload(uint32_t _restoreLevels, IAssetManager* _mgr, io::IReadFile* _file, const std::string& _supposedFilename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
+	{
+		return interm_getAssetInHierarchy(_mgr, _file, _supposedFilename, getReloadParams(_params, _restoreLevels, _hierarchyLevel), _hierarchyLevel);
+	}
+	SAssetBundle interm_getAssetInHierarchy_reload(uint32_t _restoreLevels, IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel, IAssetLoader::IAssetLoaderOverride* _override)
+	{
+		return interm_getAssetInHierarchy(_mgr, _filename, getReloadParams(_params, _restoreLevels, _hierarchyLevel), _hierarchyLevel);
+	}
+	SAssetBundle interm_getAssetInHierarchy_reload(uint32_t _restoreLevels, IAssetManager* _mgr, io::IReadFile* _file, const std::string& _supposedFilename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel)
+	{
+		return interm_getAssetInHierarchy(_mgr, _file, _supposedFilename, getReloadParams(_params, _restoreLevels, _hierarchyLevel), _hierarchyLevel);
+	}
+	SAssetBundle interm_getAssetInHierarchy_reload(uint32_t _restoreLevels, IAssetManager* _mgr, const std::string& _filename, const IAssetLoader::SAssetLoadParams& _params, uint32_t _hierarchyLevel)
+	{
+		return interm_getAssetInHierarchy(_mgr, _filename, getReloadParams(_params, _restoreLevels, _hierarchyLevel), _hierarchyLevel);
+	}
 };
 
 }
diff --git a/include/nbl/asset/interchange/SAssetBundle.h b/include/nbl/asset/interchange/SAssetBundle.h
@@ -61,6 +61,10 @@ class SAssetBundle
 		{
 			return core::SRange<const core::smart_refctd_ptr<IAsset>>(m_contents->begin(),m_contents->end());
 		}
+		inline core::SRange<core::smart_refctd_ptr<IAsset>> getContents()
+		{
+			return core::SRange<core::smart_refctd_ptr<IAsset>>(m_contents->begin(), m_contents->end());
+		}
 
 		//! Whether this asset bundle is in a cache and should be removed from cache to destroy
 		inline bool isInAResourceCache() const { return m_isCached; }
diff --git a/include/nbl/asset/utils/CDerivativeMapCreator.h b/include/nbl/asset/utils/CDerivativeMapCreator.h
@@ -0,0 +1,24 @@
+#ifndef __NBL_I_DERIVATIVE_MAP_CREATOR_H_INCLUDED__
+#define __NBL_I_DERIVATIVE_MAP_CREATOR_H_INCLUDED__
+
+#include "nbl/asset/ICPUImage.h"
+#include "nbl/asset/ICPUImageView.h"
+
+namespace nbl {
+namespace asset
+{
+
+class CDerivativeMapCreator
+{
+public:
+    CDerivativeMapCreator() = delete;
+    ~CDerivativeMapCreator() = delete;
+
+    static core::smart_refctd_ptr<asset::ICPUImage> createDerivativeMapFromHeightMap(asset::ICPUImage* _inImg, asset::ISampler::E_TEXTURE_CLAMP _uwrap, asset::ISampler::E_TEXTURE_CLAMP _vwrap, asset::ISampler::E_TEXTURE_BORDER_COLOR _borderColor);
+    static core::smart_refctd_ptr<asset::ICPUImageView> createDerivativeMapViewFromHeightMap(asset::ICPUImage* _inImg, asset::ISampler::E_TEXTURE_CLAMP _uwrap, asset::ISampler::E_TEXTURE_CLAMP _vwrap, asset::ISampler::E_TEXTURE_BORDER_COLOR _borderColor);
+};
+
+}
+}
+
+#endif
diff --git a/include/nbl/builtin/glsl/format/decode.glsl b/include/nbl/builtin/glsl/format/decode.glsl
@@ -2,6 +2,7 @@
 #define _NBL_BUILTIN_GLSL_FORMAT_DECODE_INCLUDED_
 
 #include <nbl/builtin/glsl/format/constants.glsl>
+#include <nbl/builtin/glsl/math/quaternions.glsl>
 
 vec3 nbl_glsl_decodeRGB19E7(in uvec2 x)
 {
@@ -32,7 +33,7 @@ vec4 nbl_glsl_decodeRGB10A2(in uint x)
 nbl_glsl_quaternion_t nbl_glsl_decode8888Quaternion(in uint x)
 {
 	nbl_glsl_quaternion_t quat;
-	quat.data = normalize(unpackSnorm4x8(compressedQuatUint));
+	quat.data = normalize(unpackSnorm4x8(x));
 	return quat;
 }
 
diff --git a/include/nbl/builtin/glsl/math/quaternions.glsl b/include/nbl/builtin/glsl/math/quaternions.glsl
@@ -49,7 +49,7 @@ nbl_glsl_quaternion_t nbl_glsl_quaternion_t_flerp(in nbl_glsl_quaternion_t start
 
     const float interpolantPrecalcTerm = fraction-0.5f;
     const float interpolantPrecalcTerm3 = fraction*interpolantPrecalcTerm*(fraction-1.f);
-    const float adjFrac = nbl_glsl_quaternion_t_flerp_adjustedinterpolant(abs(pseudoAngle),fraction,interpolantPrecalcTerm*interpolantPrecalcTerm,interpolantPrecalcTerm3);
+    const float adjFrac = nbl_glsl_quaternion_t_flerp_impl_adj_interpolant(abs(pseudoAngle),fraction,interpolantPrecalcTerm*interpolantPrecalcTerm,interpolantPrecalcTerm3);
     nbl_glsl_quaternion_t quat = nbl_glsl_quaternion_t_lerp(start,end,adjFrac,pseudoAngle);
     quat.data = normalize(quat.data);
     return quat;
diff --git a/include/nbl/builtin/shader/loader/mtl/fragment_impl.glsl b/include/nbl/builtin/shader/loader/mtl/fragment_impl.glsl
@@ -166,10 +166,9 @@ vec3 nbl_computeLighting(out nbl_glsl_IsotropicViewSurfaceInteraction out_intera
     {
         interaction.N = normalize(interaction.N);
 
-        float h = nbl_sample_bump(UV, dUV).x;
+        vec2 dh = nbl_sample_bump(UV, dUV).xy;
 
-        vec2 dHdScreen = vec2(dFdx(h), dFdy(h));
-        interaction.N = nbl_glsl_perturbNormal_heightMap(interaction.N, interaction.V.dPosdScreen, dHdScreen);
+        interaction.N = nbl_glsl_perturbNormal_derivativeMap(interaction.N, dh, interaction.V.dPosdScreen, dUV);
     }
 #endif
     const vec3 L = -ViewPos;
diff --git a/include/nbl/ext/MitsubaLoader/CMitsubaLoader.h b/include/nbl/ext/MitsubaLoader/CMitsubaLoader.h
@@ -48,7 +48,7 @@ class CMitsubaLoader : public asset::IRenderpassIndependentPipelineLoader
 		core::vector<SContext::shape_ass_type>	loadShapeGroup(SContext& ctx, uint32_t hierarchyLevel, const CElementShape::ShapeGroup* shapegroup, const core::matrix3x4SIMD& relTform);
 		SContext::shape_ass_type				loadBasicShape(SContext& ctx, uint32_t hierarchyLevel, CElementShape* shape, const core::matrix3x4SIMD& relTform);
 		
-		SContext::tex_ass_type					cacheTexture(SContext& ctx, uint32_t hierarchyLevel, const CElementTexture* texture);
+		SContext::tex_ass_type					cacheTexture(SContext& ctx, uint32_t hierarchyLevel, const CElementTexture* texture, bool _restore = false);
 
 		SContext::bsdf_type getBSDFtreeTraversal(SContext& ctx, const CElementBSDF* bsdf);
 		SContext::bsdf_type genBSDFtreeTraversal(SContext& ctx, const CElementBSDF* bsdf);
diff --git a/src/nbl/CMakeLists.txt b/src/nbl/CMakeLists.txt
@@ -182,6 +182,7 @@ set(NBL_ASSET_SOURCES
 # Images
 	${NBL_ROOT_PATH}/src/nbl/asset/interchange/IImageAssetHandlerBase.cpp
 	${NBL_ROOT_PATH}/src/nbl/asset/filters/CBasicImageFilterCommon.cpp
+	${NBL_ROOT_PATH}/src/nbl/asset/utils/CDerivativeMapCreator.cpp
 
 # Image loaders
 	${NBL_ROOT_PATH}/src/nbl/asset/interchange/IImageLoader.cpp
diff --git a/src/nbl/asset/IAssetManager.cpp b/src/nbl/asset/IAssetManager.cpp
@@ -185,9 +185,6 @@ void IAssetManager::addLoadersAndWriters()
 #ifdef _NBL_COMPILE_WITH_GLI_WRITER_
 	addAssetWriter(core::make_smart_refctd_ptr<asset::CGLIWriter>());
 #endif
-
-    for (auto& loader : m_loaders.vector)
-        loader->initialize();
 }
 
 
diff --git a/src/nbl/asset/interchange/CGraphicsPipelineLoaderMTL.cpp b/src/nbl/asset/interchange/CGraphicsPipelineLoaderMTL.cpp
@@ -12,6 +12,7 @@
 #include "nbl/asset/asset.h"
 #include "nbl/asset/interchange/CGraphicsPipelineLoaderMTL.h"
 #include "nbl/asset/utils/IGLSLEmbeddedIncludeLoader.h"
+#include "nbl/asset/utils/CDerivativeMapCreator.h"
 
 #include "nbl/builtin/MTLdefaults.h"
 
@@ -521,7 +522,15 @@ CGraphicsPipelineLoaderMTL::image_views_set_t CGraphicsPipelineLoaderMTL::loadIm
         SAssetLoadParams lp;
         if (_mtl.maps[i].size() )
         {
-            auto bundle = interm_getAssetInHierarchy(m_assetMgr, relDir+_mtl.maps[i], lp, _ctx.topHierarchyLevel+ICPURenderpassIndependentPipeline::IMAGE_HIERARCHYLEVELS_BELOW, _ctx.loaderOverride);
+            SAssetBundle bundle;
+            if (i != CMTLMetadata::CRenderpassIndependentPipeline::EMP_BUMP)
+                bundle = interm_getAssetInHierarchy(m_assetMgr, relDir+_mtl.maps[i], lp, _ctx.topHierarchyLevel+ICPURenderpassIndependentPipeline::IMAGE_HIERARCHYLEVELS_BELOW, _ctx.loaderOverride);
+            else
+            {
+                // we need bumpmap restored to create derivative map from it
+                const uint32_t restoreLevels = 3u; // 2 in case of image (image, texel buffer) and 3 in case of image view (view, image, texel buffer)
+                bundle = interm_getRestoredAssetInHierarchy(restoreLevels, m_assetMgr, relDir+_mtl.maps[i], lp, _ctx.topHierarchyLevel+ICPURenderpassIndependentPipeline::IMAGE_HIERARCHYLEVELS_BELOW, _ctx.loaderOverride);
+            }
             auto asset = _ctx.loaderOverride->chooseDefaultAsset(bundle,_ctx.inner);
             if (asset)
             switch (bundle.getAssetType())
@@ -617,7 +626,10 @@ CGraphicsPipelineLoaderMTL::image_views_set_t CGraphicsPipelineLoaderMTL::loadIm
 
     for (uint32_t i = 0u; i < views.size(); ++i)
     {
-        if (!images[i])
+        core::smart_refctd_ptr<ICPUImage> image = images[i];
+        if (i == CMTLMetadata::CRenderpassIndependentPipeline::EMP_BUMP && views[i])
+            image = views[i]->getCreationParameters().image;
+        if (!image)
             continue;
 
         const std::string viewCacheKey = _mtl.maps[i] + "?view";
@@ -631,20 +643,26 @@ CGraphicsPipelineLoaderMTL::image_views_set_t CGraphicsPipelineLoaderMTL::loadIm
             }
         }
 
+        if (i == CMTLMetadata::CRenderpassIndependentPipeline::EMP_BUMP)
+        {
+            const ISampler::E_TEXTURE_CLAMP wrap = _mtl.isClampToBorder(CMTLMetadata::CRenderpassIndependentPipeline::EMP_BUMP) ? ISampler::ETC_CLAMP_TO_BORDER : ISampler::ETC_REPEAT;
+            image = CDerivativeMapCreator::createDerivativeMapFromHeightMap(image.get(), wrap, wrap, ISampler::ETBC_FLOAT_OPAQUE_BLACK);
+        }
+
         constexpr IImageView<ICPUImage>::E_TYPE viewType[2]{ IImageView<ICPUImage>::ET_2D, IImageView<ICPUImage>::ET_CUBE_MAP };
         constexpr uint32_t layerCount[2]{ 1u, 6u };
 
         const bool isCubemap = (i == CMTLMetadata::CRenderpassIndependentPipeline::EMP_REFL_POSX);
 
         ICPUImageView::SCreationParams viewParams;
         viewParams.flags = static_cast<ICPUImageView::E_CREATE_FLAGS>(0u);
-        viewParams.format = images[i]->getCreationParameters().format;
+        viewParams.format = image->getCreationParameters().format;
         viewParams.viewType = viewType[isCubemap];
         viewParams.subresourceRange.baseArrayLayer = 0u;
         viewParams.subresourceRange.layerCount = layerCount[isCubemap];
         viewParams.subresourceRange.baseMipLevel = 0u;
         viewParams.subresourceRange.levelCount = 1u;
-        viewParams.image = std::move(images[i]);
+        viewParams.image = std::move(image);
 
         views[i] = ICPUImageView::create(std::move(viewParams));
         _ctx.loaderOverride->insertAssetIntoCache(SAssetBundle(nullptr,{ views[i] }), viewCacheKey, _ctx.inner, _ctx.topHierarchyLevel+ICPURenderpassIndependentPipeline::IMAGEVIEW_HIERARCHYLEVELS_BELOW);
diff --git a/src/nbl/asset/interchange/CGraphicsPipelineLoaderMTL.h b/src/nbl/asset/interchange/CGraphicsPipelineLoaderMTL.h
@@ -24,6 +24,8 @@ class CGraphicsPipelineLoaderMTL final : public asset::IRenderpassIndependentPip
             //-clamp
             uint32_t clamp;
             static_assert(sizeof(clamp) * 8ull >= CMTLMetadata::CRenderpassIndependentPipeline::EMP_COUNT, "SMtl::clamp is too small!");
+
+            inline bool isClampToBorder(CMTLMetadata::CRenderpassIndependentPipeline::E_MAP_TYPE m) const { return (clamp >> m) & 1u; }
         };
 
         struct SContext
diff --git a/src/nbl/asset/utils/CDerivativeMapCreator.cpp b/src/nbl/asset/utils/CDerivativeMapCreator.cpp
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
`@@ -177,6 +177,7 @@ class IAsset : virtual public core::IReferenceCounted`
`177`	`177`	`return false;`
`178`	`178`
`179`	`179`	`restoreFromDummy_impl(_other, _levelsBelow);`
	`180`	`+ isDummyObjectForCacheAliasing = false;`
`180`	`181`	`return true;`
`181`	`182`	`}`
`182`	`183`
Original file line number	Diff line number	Diff line change
`@@ -574,6 +574,7 @@ class IAssetManager : public core::IReferenceCounted, public core::QuitSignallin`
`574`	`574`	`//! @returns 0xdeadbeefu on failure or 0-based index on success.`
`575`	`575`	`uint32_t addAssetLoader(core::smart_refctd_ptr<IAssetLoader>&& _loader)`
`576`	`576`	`{`
	`577`	`+ _loader->initialize();`
`577`	`578`	`// there's no way it ever fails, so no 0xdeadbeef return`
`578`	`579`	`const char** exts = _loader->getAssociatedFileExtensions();`
`579`	`580`	`size_t extIx = 0u;`
Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,10 @@ class SAssetBundle`
`61`	`61`	`{`
`62`	`62`	`return core::SRange<const core::smart_refctd_ptr<IAsset>>(m_contents->begin(),m_contents->end());`
`63`	`63`	`}`
	`64`	`+ inline core::SRange<core::smart_refctd_ptr<IAsset>> getContents()`
	`65`	`+ {`
	`66`	`+ return core::SRange<core::smart_refctd_ptr<IAsset>>(m_contents->begin(), m_contents->end());`
	`67`	`+ }`
`64`	`68`
`65`	`69`	`//! Whether this asset bundle is in a cache and should be removed from cache to destroy`
`66`	`70`	`inline bool isInAResourceCache() const { return m_isCached; }`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`#define _NBL_BUILTIN_GLSL_FORMAT_DECODE_INCLUDED_`
`3`	`3`
`4`	`4`	`#include <nbl/builtin/glsl/format/constants.glsl>`
	`5`	`+#include <nbl/builtin/glsl/math/quaternions.glsl>`
`5`	`6`
`6`	`7`	`vec3 nbl_glsl_decodeRGB19E7(in uvec2 x)`
`7`	`8`	`{`
`@@ -32,7 +33,7 @@ vec4 nbl_glsl_decodeRGB10A2(in uint x)`
`32`	`33`	`nbl_glsl_quaternion_t nbl_glsl_decode8888Quaternion(in uint x)`
`33`	`34`	`{`
`34`	`35`	`nbl_glsl_quaternion_t quat;`
`35`		`- quat.data = normalize(unpackSnorm4x8(compressedQuatUint));`
	`36`	`+ quat.data = normalize(unpackSnorm4x8(x));`
`36`	`37`	`return quat;`
`37`	`38`	`}`
`38`	`39`
Original file line number	Diff line number	Diff line change
`@@ -166,10 +166,9 @@ vec3 nbl_computeLighting(out nbl_glsl_IsotropicViewSurfaceInteraction out_intera`
`166`	`166`	`{`
`167`	`167`	`interaction.N = normalize(interaction.N);`
`168`	`168`
`169`		`- float h = nbl_sample_bump(UV, dUV).x;`
	`169`	`+ vec2 dh = nbl_sample_bump(UV, dUV).xy;`
`170`	`170`
`171`		`- vec2 dHdScreen = vec2(dFdx(h), dFdy(h));`
`172`		`- interaction.N = nbl_glsl_perturbNormal_heightMap(interaction.N, interaction.V.dPosdScreen, dHdScreen);`
	`171`	`+ interaction.N = nbl_glsl_perturbNormal_derivativeMap(interaction.N, dh, interaction.V.dPosdScreen, dUV);`
`173`	`172`	`}`
`174`	`173`	`#endif`
`175`	`174`	`const vec3 L = -ViewPos;`