Fixed VT to work with textures smaller than page size (all mips being miptail)

Crisspl · Crisspl · commit 29eb064df702 · 2021-07-08T14:19:15.000+02:00
But need to upscale them to at half page size, provided a function for this
diff --git a/examples_tests/22.RaytracedAO/Renderer.cpp b/examples_tests/22.RaytracedAO/Renderer.cpp
@@ -5,6 +5,7 @@
 #include "nbl/ext/ScreenShot/ScreenShot.h"
 
 #include "../source/Nabla/COpenCLHandler.h"
+#include "COpenGLDriver.h"
 
 
 #ifndef _NBL_BUILD_OPTIX_
diff --git a/include/nbl/asset/material_compiler/CMaterialCompilerGLSLBackendCommon.h b/include/nbl/asset/material_compiler/CMaterialCompilerGLSLBackendCommon.h
@@ -632,7 +632,7 @@ class CMaterialCompilerGLSLBackendCommon
 
 			bool commit(const commit_t& cm)
 			{
-				auto texture = asset::ICPUVirtualTexture::createPoTPaddedSquareImageWithMipLevels(cm.image.get(), cm.uwrap, cm.vwrap, cm.border).first;
+				auto texture = vt->createPoTPaddedSquareImageWithMipLevels(cm.image.get(), cm.uwrap, cm.vwrap, cm.border).first;
 				return vt->commit(cm.addr, texture.get(), cm.subresource, cm.uwrap, cm.vwrap, cm.border);
 			}
 			//! @returns if all commits succeeded
diff --git a/include/nbl/asset/utils/ICPUVirtualTexture.h b/include/nbl/asset/utils/ICPUVirtualTexture.h
@@ -86,8 +86,79 @@ class ICPUVirtualTexture final : public IVirtualTexture<ICPUImageView, ICPUSampl
         }
     };
 
-    static auto createPoTPaddedSquareImageWithMipLevels(const ICPUImage* _img, ISampler::E_TEXTURE_CLAMP _wrapu, ISampler::E_TEXTURE_CLAMP _wrapv, ISampler::E_TEXTURE_BORDER_COLOR _borderColor)
+    //! If there's a need, creates an image upscaled to half page size
+    //! Otherwise returns `_img`
+    //! Always call this before alloc()
+    core::smart_refctd_ptr<asset::ICPUImage> createUpscaledImage(const ICPUImage* _img)
     {
+        if (!_img)
+            return nullptr;
+
+        const auto& params = _img->getCreationParameters();
+        const uint32_t halfPage = m_pgSzxy / 2u;
+
+        if (params.extent.width >= halfPage || params.extent.height >= halfPage)
+        {
+            asset::ICPUImage* img = const_cast<asset::ICPUImage*>(_img);
+            return core::smart_refctd_ptr<asset::ICPUImage>(img);
+        }
+
+        const uint32_t min_extent = std::min(params.extent.width, params.extent.height);
+        const float upscale_factor = static_cast<float>(halfPage) / static_cast<float>(min_extent);
+
+        asset::VkExtent3D extent_upscaled;
+        extent_upscaled.depth = 1u;
+        extent_upscaled.width = static_cast<uint32_t>(params.extent.width * upscale_factor + 0.5f);
+        extent_upscaled.height = static_cast<uint32_t>(params.extent.height * upscale_factor + 0.5f);
+
+        asset::ICPUImage::SCreationParams new_params = params;
+        new_params.extent = extent_upscaled;
+        new_params.mipLevels = 1u;
+
+        auto upscaled_img = asset::ICPUImage::create(std::move(new_params));
+        const size_t bufsz = upscaled_img->getImageDataSizeInBytes();
+        auto buf = core::make_smart_refctd_ptr<asset::ICPUBuffer>(bufsz);
+        auto regions = core::make_refctd_dynamic_array<core::smart_refctd_dynamic_array<asset::IImage::SBufferCopy>>(1u);
+        auto& region = regions->operator[](0u);
+        region.bufferOffset = 0u;
+        region.bufferRowLength = extent_upscaled.width;
+        region.bufferImageHeight = 0u;
+        region.imageOffset = { 0,0,0 };
+        region.imageExtent = extent_upscaled;
+        region.imageSubresource.baseArrayLayer = 0u;
+        region.imageSubresource.layerCount = 1u;
+        region.imageSubresource.mipLevel = 0u;
+        region.imageSubresource.aspectMask = _img->getRegion(0u, core::vectorSIMDu32(0u, 0u, 0u, 0u))->imageSubresource.aspectMask;
+
+        upscaled_img->setBufferAndRegions(std::move(buf), std::move(regions));
+
+        using blit_filter_t = asset::CBlitImageFilter<false, false, asset::VoidSwizzle, asset::IdentityDither, asset::CMitchellImageFilterKernel<>>;
+        blit_filter_t::state_type blit;
+        blit.inOffsetBaseLayer = core::vectorSIMDu32(0u, 0u, 0u, 0u);
+        blit.inExtent = params.extent;
+        blit.inLayerCount = 1u;
+        blit.outOffsetBaseLayer = core::vectorSIMDu32(0u, 0u, 0u, 0u);
+        blit.outExtent = extent_upscaled;
+        blit.outLayerCount = 1u;
+        blit.inImage = const_cast<asset::ICPUImage*>(_img);
+        blit.outImage = upscaled_img.get();
+        blit.scratchMemoryByteSize = blit_filter_t::getRequiredScratchByteSize(&blit);
+        blit.scratchMemory = reinterpret_cast<uint8_t*>(_NBL_ALIGNED_MALLOC(blit.scratchMemoryByteSize, _NBL_SIMD_ALIGNMENT));
+
+        const bool blit_succeeded = blit_filter_t::execute(&blit);
+        _NBL_ALIGNED_FREE(blit.scratchMemory);
+        if (!blit_succeeded)
+            return nullptr;
+
+        return upscaled_img;
+    }
+
+    //! Always call this before commit()
+    static std::pair<core::smart_refctd_ptr<asset::ICPUImage>, asset::VkExtent3D> createPoTPaddedSquareImageWithMipLevels(const ICPUImage* _img, ISampler::E_TEXTURE_CLAMP _wrapu, ISampler::E_TEXTURE_CLAMP _wrapv, ISampler::E_TEXTURE_BORDER_COLOR _borderColor)
+    {
+        if (!_img)
+            return { nullptr, asset::VkExtent3D{0u,0u,0u} };
+
         const auto& params = _img->getCreationParameters();
         const auto originalExtent = params.extent;
         const uint32_t paddedExtent = core::roundUpToPoT(std::max<uint32_t>(params.extent.width,params.extent.height));
@@ -222,6 +293,19 @@ class ICPUVirtualTexture final : public IVirtualTexture<ICPUImageView, ICPUSampl
         uint32_t miptailPgAddr = SPhysPgOffset::invalid_addr;
 
         using phys_pg_addr_alctr_t = ICPUVTResidentStorage::phys_pg_addr_alctr_t;
+
+        if (levelsTakingAtLeastOnePageCount < _subres.levelCount)
+        {
+            uint32_t miptailPgAddr_tmp = phys_pg_addr_alctr_t::invalid_address;
+            const uint32_t szAndAlignment = 1u;
+            core::address_allocator_traits<phys_pg_addr_alctr_t>::multi_alloc_addr(storage->tileAlctr, 1u, &miptailPgAddr_tmp, &szAndAlignment, &szAndAlignment, nullptr);
+            miptailPgAddr_tmp = (miptailPgAddr_tmp == phys_pg_addr_alctr_t::invalid_address) ? SPhysPgOffset::invalid_addr : storage->encodePageAddress(miptailPgAddr_tmp);
+
+            miptailPgAddr = miptailPgAddr_tmp;
+        }
+
+        const bool wholeTexGoesToMiptailPage = (levelsTakingAtLeastOnePageCount == 0u);
+
         //TODO up to this line, it's kinda common code for CPU and GPU, refactor later
 
         // TODO: parallelize over all 3 for loops
@@ -234,7 +318,7 @@ class ICPUVirtualTexture final : public IVirtualTexture<ICPUImageView, ICPUSampl
                 for (uint32_t x = 0u; x < w; ++x)
                 {
                     uint32_t physPgAddr = phys_pg_addr_alctr_t::invalid_address;
-                    if (i>=levelsTakingAtLeastOnePageCount)
+                    if (i>=levelsTakingAtLeastOnePageCount) // this `if` always executes in case of whole texture going into miptail page
                         physPgAddr = miptailPgAddr;
                     else
                     {
@@ -249,24 +333,22 @@ class ICPUVirtualTexture final : public IVirtualTexture<ICPUImageView, ICPUSampl
                     if (i==(levelsTakingAtLeastOnePageCount-1u) && levelsTakingAtLeastOnePageCount<_subres.levelCount)
                     {
                         assert(w==1u && h==1u);
-                        uint32_t miptailPgAddr_tmp = phys_pg_addr_alctr_t::invalid_address;
-                        const uint32_t szAndAlignment = 1u;
-                        core::address_allocator_traits<phys_pg_addr_alctr_t>::multi_alloc_addr(storage->tileAlctr, 1u, &miptailPgAddr_tmp, &szAndAlignment, &szAndAlignment, nullptr);
-                        miptailPgAddr_tmp = (miptailPgAddr_tmp==phys_pg_addr_alctr_t::invalid_address) ? SPhysPgOffset::invalid_addr : storage->encodePageAddress(miptailPgAddr_tmp);
-                        
-                        physPgAddr |= (miptailPgAddr_tmp<<SPhysPgOffset::PAGE_ADDR_BITLENGTH);
-
-                        miptailPgAddr = miptailPgAddr_tmp;
+     
+                        physPgAddr |= (miptailPgAddr<<SPhysPgOffset::PAGE_ADDR_BITLENGTH);
                     }
-                    else 
+                    else  // this `else` always executes in case of whole texture going into miptail page
                         physPgAddr |= (SPhysPgOffset::invalid_addr<<SPhysPgOffset::PAGE_ADDR_BITLENGTH);
+
                     if (i < levelsTakingAtLeastOnePageCount)
                     {
+                        // physical double-address to write into page table
+                        const uint32_t physAddrToWrite = physPgAddr;
+
                         const auto texelPos = core::vectorSIMDu32(pgtOffset.x>>i, pgtOffset.y>>i, 0u, pgtOffset.z) + core::vectorSIMDu32(x, y, 0u, 0u);
                         const auto* region = m_pageTable->getRegion(i, texelPos);
                         const uint64_t byteoffset = region->getByteOffset(texelPos, region->getByteStrides(m_pageTable->getTexelBlockInfo()));
                         uint8_t* bufptr = reinterpret_cast<uint8_t*>(m_pageTable->getBuffer()->getPointer()) + byteoffset;
-                        reinterpret_cast<uint32_t*>(bufptr)[0] = physPgAddr;
+                        reinterpret_cast<uint32_t*>(bufptr)[0] = physAddrToWrite;
                     }
 
                     if (!SPhysPgOffset(physPgAddr).valid())
@@ -319,6 +401,18 @@ class ICPUVirtualTexture final : public IVirtualTexture<ICPUImageView, ICPUSampl
                 }
         }
 
+        if (wholeTexGoesToMiptailPage)
+        {
+            // physical double-address to write into page table
+            uint32_t physAddrToWrite = SPhysPgOffset::invalid_addr | (miptailPgAddr << SPhysPgOffset::PAGE_ADDR_BITLENGTH);
+
+            const auto texelPos = core::vectorSIMDu32(pgtOffset.x, pgtOffset.y, 0u, pgtOffset.z);
+            const auto* region = m_pageTable->getRegion(0u, texelPos);
+            const uint64_t byteoffset = region->getByteOffset(texelPos, region->getByteStrides(m_pageTable->getTexelBlockInfo()));
+            uint8_t* bufptr = reinterpret_cast<uint8_t*>(m_pageTable->getBuffer()->getPointer()) + byteoffset;
+            reinterpret_cast<uint32_t*>(bufptr)[0] = physAddrToWrite;
+        }
+
         return true;
     }
 
diff --git a/include/nbl/asset/utils/IVirtualTexture.h b/include/nbl/asset/utils/IVirtualTexture.h
@@ -139,7 +139,7 @@ class IVirtualTexture : public core::IReferenceCounted, public IVirtualTextureBa
         uint64_t pgTab_x : 8;
         uint64_t pgTab_y : 8;
         uint64_t pgTab_layer : 8;
-        uint64_t maxMip : 4;
+        uint64_t maxMip : 4; // value 0x0fu means, the texture takes only 1 page of physical storage (miptail)
         uint64_t wrap_x : 2;
         uint64_t wrap_y : 2;
 
@@ -210,7 +210,9 @@ class IVirtualTexture : public core::IReferenceCounted, public IVirtualTextureBa
 		texData.pgTab_y = _offset.y;
         texData.pgTab_layer = _offset.z;
 
-        texData.maxMip = _mipCount-1u-m_pgSzxy_log2;
+        const uint32_t maxMip = _mipCount - 1u - m_pgSzxy_log2;
+        assert(static_cast<int32_t>(maxMip) >= -1); // only textures of size at least half page size must be packed
+        texData.maxMip = maxMip;
 
         texData.wrap_x = SMasterTextureData::ETC_to_EWM(_wrapu);
         texData.wrap_y = SMasterTextureData::ETC_to_EWM(_wrapv);
diff --git a/include/nbl/builtin/glsl/virtual_texturing/impl_functions.glsl b/include/nbl/builtin/glsl/virtual_texturing/impl_functions.glsl
@@ -26,9 +26,10 @@ uvec2 nbl_glsl_unpackWrapModes(in uvec2 texData)
 {
     return (texData >> uvec2(28u, 30u))& uvec2(0x03u);
 }
-uint nbl_glsl_unpackMaxMipInVT(in uvec2 texData)
+int nbl_glsl_unpackMaxMipInVT(in uvec2 texData)
 {
-    return (texData.y >> 24) & 0x0fu;
+    uint mm = (texData.y >> 24) & 0x0fu;
+    return mm == 0x0fu ? -1 : int(mm);
 }
 vec3 nbl_glsl_unpackVirtualUV(in uvec2 texData)
 {
@@ -118,13 +119,15 @@ vec4 nbl_glsl_vTextureGrad_impl(in uint formatID, in vec3 virtualUV, in mat2 dOr
 	// are we performing minification
 	bool positiveLoD = LoD>0.0;
 	// magnification samples LoD 0, else clip to max representable in VT
-	int clippedLoD = positiveLoD ? min(LoD_high,originalMaxFullMip):0;
+	int clippedLoD = positiveLoD ? min(LoD_high,originalMaxFullMip):0; // originalMaxFullMip is always -1 in case of no miplevel taking at least 1 full page
+    clippedLoD = originalMaxFullMip < 0 ? 0 : clippedLoD;
 
 	// if minification is being performaed then get tail position
 	int levelInTail = LoD_high-clippedLoD;
 	// have to do trilinear only if doing minification AND larger than 1x1 footprint
 	bool haveToDoTrilinear = levelInTail<int(_NBL_VT_IMPL_PAGE_SZ_LOG2) && positiveLoD;
 	levelInTail = haveToDoTrilinear ? levelInTail:(positiveLoD ? int(_NBL_VT_IMPL_PAGE_SZ_LOG2):0);
+    levelInTail += (originalMaxFullMip < 0) ? 1 : 0;
 
 	// get the higher resolution mip-map level
 	vec3 hiPhysCoord = nbl_glsl_vTexture_helper(formatID,virtualUV,clippedLoD,levelInTail);
@@ -133,9 +136,10 @@ vec4 nbl_glsl_vTextureGrad_impl(in uint formatID, in vec3 virtualUV, in mat2 dOr
 	// speculative if (haveToDoTrilinear)
 	{
 		// now we have absolute guarantees that both LoD_high and LoD_low are in the valid original mip range
-		bool highNotInLastFull = LoD_high<originalMaxFullMip;
+		bool highNotInLastFull = originalMaxFullMip>=0 && LoD_high<originalMaxFullMip;
 		clippedLoD = highNotInLastFull ? (clippedLoD+1):clippedLoD;
 		levelInTail = highNotInLastFull ? levelInTail:(levelInTail+1);
+        levelInTail = min(levelInTail, int(_NBL_VT_IMPL_PAGE_SZ_LOG2));
 		loPhysCoord = nbl_glsl_vTexture_helper(formatID,virtualUV,clippedLoD,levelInTail);
 	}
 
@@ -184,7 +188,7 @@ vec4 nbl_glsl_vTextureGrad(in uvec2 _texData, in vec2 uv, in mat2 dUV)
     virtualUV.xy += uv*originalSz;
     virtualUV.xy *= nbl_glsl_VT_getVTexSzRcp();
 
-    return nbl_glsl_vTextureGrad_impl(formatID, virtualUV, dUV, int(nbl_glsl_unpackMaxMipInVT(_texData)));
+    return nbl_glsl_vTextureGrad_impl(formatID, virtualUV, dUV, nbl_glsl_unpackMaxMipInVT(_texData));
 }
 #endif //_NBL_VT_FLOAT_VIEWS_COUNT
 
@@ -226,7 +230,7 @@ ivec4 nbl_glsl_iVTextureLod(in uvec2 _texData, in vec2 uv, in uint lod)
     virtualUV.xy += uv * originalSz;
     virtualUV.xy *= nbl_glsl_VT_getVTexSzRcp();
 	
-    return nbl_glsl_iVTextureLod_impl(formatID, virtualUV, lod, int(nbl_glsl_unpackMaxMipInVT(_texData)));
+    return nbl_glsl_iVTextureLod_impl(formatID, virtualUV, lod, nbl_glsl_unpackMaxMipInVT(_texData));
 }
 #endif //_NBL_VT_INT_VIEWS_COUNT
 
@@ -268,7 +272,7 @@ uvec4 nbl_glsl_uVTextureLod(in uvec2 _texData, in vec2 uv, in uint lod)
     virtualUV.xy += uv * originalSz;
     virtualUV.xy *= nbl_glsl_VT_getVTexSzRcp();
 	
-    return nbl_glsl_uVTextureLod_impl(formatID, virtualUV, lod, int(nbl_glsl_unpackMaxMipInVT(_texData)));
+    return nbl_glsl_uVTextureLod_impl(formatID, virtualUV, lod, nbl_glsl_unpackMaxMipInVT(_texData));
 }
 #endif //_NBL_VT_UINT_VIEWS_COUNT
 
@@ -314,7 +318,7 @@ retval_t funcName(in uvec2 _texData, in vec2 uv, in uint lod) \
     virtualUV.xy += uv * originalSz; \
     virtualUV.xy *= nbl_glsl_VT_getVTexSzRcp(); \
 	\
-    return nbl_glsl_vTextureLod_impl(formatID, virtualUV, lod, int(nbl_glsl_unpackMaxMipInVT(_texData))); \
+    return nbl_glsl_vTextureLod_impl(formatID, virtualUV, lod, nbl_glsl_unpackMaxMipInVT(_texData)); \
 }
 
 _NBL_DEFINE_VT_INTEGER_FUNCTIONS(nbl_glsl_iVTextureLod, nbl_glsl_iVTextureLod_impl, ivec4, iphysicalTileStorageFormatView)
diff --git a/src/nbl/asset/material_compiler/CMaterialCompilerGLSLBackendCommon.cpp b/src/nbl/asset/material_compiler/CMaterialCompilerGLSLBackendCommon.cpp
@@ -279,6 +279,7 @@ namespace material_compiler
 				return found->second;
 
 			auto img = tex.image->getCreationParameters().image;
+			img = m_ctx->vt.vt->createUpscaledImage(img.get());
 			auto* sampler = tex.sampler.get();
 
 			const auto& extent = img->getCreationParameters().extent;
@@ -302,6 +303,10 @@ namespace material_compiler
 			alloc.uwrap = uwrap;
 			alloc.vwrap = vwrap;
 			auto addr = m_ctx->vt.alloc(alloc, std::move(img), border);
+			/*if (alloc.extent.width == 64u && alloc.extent.height == 64u)
+			{
+				printf("allocated 64x64: %u, %u, %u, maxmip=%u\n", (uint32_t)addr.pgTab_x, (uint32_t)addr.pgTab_y, (uint32_t)addr.pgTab_layer, (uint32_t) addr.maxMip);
+			}*/
 
 			std::pair<SContext::VTallocKey, instr_stream::VTID> item{{tex.image.get(),tex.sampler.get()}, addr};
 			m_ctx->VTallocMap.insert(item);

Original file line number	Diff line number	Diff line change
`@@ -632,7 +632,7 @@ class CMaterialCompilerGLSLBackendCommon`
`632`	`632`
`633`	`633`	`bool commit(const commit_t& cm)`
`634`	`634`	`{`
`635`		`- auto texture = asset::ICPUVirtualTexture::createPoTPaddedSquareImageWithMipLevels(cm.image.get(), cm.uwrap, cm.vwrap, cm.border).first;`
	`635`	`+ auto texture = vt->createPoTPaddedSquareImageWithMipLevels(cm.image.get(), cm.uwrap, cm.vwrap, cm.border).first;`
`636`	`636`	`return vt->commit(cm.addr, texture.get(), cm.subresource, cm.uwrap, cm.vwrap, cm.border);`
`637`	`637`	`}`
`638`	`638`	`//! @returns if all commits succeeded`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,10 @@ uvec2 nbl_glsl_unpackWrapModes(in uvec2 texData)`
`26`	`26`	`{`
`27`	`27`	`return (texData >> uvec2(28u, 30u))& uvec2(0x03u);`
`28`	`28`	`}`
`29`		`-uint nbl_glsl_unpackMaxMipInVT(in uvec2 texData)`
	`29`	`+int nbl_glsl_unpackMaxMipInVT(in uvec2 texData)`
`30`	`30`	`{`
`31`		`- return (texData.y >> 24) & 0x0fu;`
	`31`	`+ uint mm = (texData.y >> 24) & 0x0fu;`
	`32`	`+ return mm == 0x0fu ? -1 : int(mm);`
`32`	`33`	`}`
`33`	`34`	`vec3 nbl_glsl_unpackVirtualUV(in uvec2 texData)`
`34`	`35`	`{`
`@@ -118,13 +119,15 @@ vec4 nbl_glsl_vTextureGrad_impl(in uint formatID, in vec3 virtualUV, in mat2 dOr`
`118`	`119`	`// are we performing minification`
`119`	`120`	`bool positiveLoD = LoD>0.0;`
`120`	`121`	`// magnification samples LoD 0, else clip to max representable in VT`
`121`		`- int clippedLoD = positiveLoD ? min(LoD_high,originalMaxFullMip):0;`
	`122`	`+ int clippedLoD = positiveLoD ? min(LoD_high,originalMaxFullMip):0; // originalMaxFullMip is always -1 in case of no miplevel taking at least 1 full page`
	`123`	`+ clippedLoD = originalMaxFullMip < 0 ? 0 : clippedLoD;`
`122`	`124`
`123`	`125`	`// if minification is being performaed then get tail position`
`124`	`126`	`int levelInTail = LoD_high-clippedLoD;`
`125`	`127`	`// have to do trilinear only if doing minification AND larger than 1x1 footprint`
`126`	`128`	`bool haveToDoTrilinear = levelInTail<int(_NBL_VT_IMPL_PAGE_SZ_LOG2) && positiveLoD;`
`127`	`129`	`levelInTail = haveToDoTrilinear ? levelInTail:(positiveLoD ? int(_NBL_VT_IMPL_PAGE_SZ_LOG2):0);`
	`130`	`+ levelInTail += (originalMaxFullMip < 0) ? 1 : 0;`
`128`	`131`
`129`	`132`	`// get the higher resolution mip-map level`
`130`	`133`	`vec3 hiPhysCoord = nbl_glsl_vTexture_helper(formatID,virtualUV,clippedLoD,levelInTail);`
`@@ -133,9 +136,10 @@ vec4 nbl_glsl_vTextureGrad_impl(in uint formatID, in vec3 virtualUV, in mat2 dOr`
`133`	`136`	`// speculative if (haveToDoTrilinear)`
`134`	`137`	`{`
`135`	`138`	`// now we have absolute guarantees that both LoD_high and LoD_low are in the valid original mip range`
`136`		`- bool highNotInLastFull = LoD_high<originalMaxFullMip;`
	`139`	`+ bool highNotInLastFull = originalMaxFullMip>=0 && LoD_high<originalMaxFullMip;`
`137`	`140`	`clippedLoD = highNotInLastFull ? (clippedLoD+1):clippedLoD;`
`138`	`141`	`levelInTail = highNotInLastFull ? levelInTail:(levelInTail+1);`
	`142`	`+ levelInTail = min(levelInTail, int(_NBL_VT_IMPL_PAGE_SZ_LOG2));`
`139`	`143`	`loPhysCoord = nbl_glsl_vTexture_helper(formatID,virtualUV,clippedLoD,levelInTail);`
`140`	`144`	`}`
`141`	`145`
`@@ -184,7 +188,7 @@ vec4 nbl_glsl_vTextureGrad(in uvec2 _texData, in vec2 uv, in mat2 dUV)`
`184`	`188`	`virtualUV.xy += uv*originalSz;`
`185`	`189`	`virtualUV.xy *= nbl_glsl_VT_getVTexSzRcp();`
`186`	`190`
`187`		`- return nbl_glsl_vTextureGrad_impl(formatID, virtualUV, dUV, int(nbl_glsl_unpackMaxMipInVT(_texData)));`
	`191`	`+ return nbl_glsl_vTextureGrad_impl(formatID, virtualUV, dUV, nbl_glsl_unpackMaxMipInVT(_texData));`
`188`	`192`	`}`
`189`	`193`	`#endif //_NBL_VT_FLOAT_VIEWS_COUNT`
`190`	`194`
`@@ -226,7 +230,7 @@ ivec4 nbl_glsl_iVTextureLod(in uvec2 _texData, in vec2 uv, in uint lod)`
`226`	`230`	`virtualUV.xy += uv * originalSz;`
`227`	`231`	`virtualUV.xy *= nbl_glsl_VT_getVTexSzRcp();`
`228`	`232`
`229`		`- return nbl_glsl_iVTextureLod_impl(formatID, virtualUV, lod, int(nbl_glsl_unpackMaxMipInVT(_texData)));`
	`233`	`+ return nbl_glsl_iVTextureLod_impl(formatID, virtualUV, lod, nbl_glsl_unpackMaxMipInVT(_texData));`
`230`	`234`	`}`
`231`	`235`	`#endif //_NBL_VT_INT_VIEWS_COUNT`
`232`	`236`
`@@ -268,7 +272,7 @@ uvec4 nbl_glsl_uVTextureLod(in uvec2 _texData, in vec2 uv, in uint lod)`
`268`	`272`	`virtualUV.xy += uv * originalSz;`
`269`	`273`	`virtualUV.xy *= nbl_glsl_VT_getVTexSzRcp();`
`270`	`274`
`271`		`- return nbl_glsl_uVTextureLod_impl(formatID, virtualUV, lod, int(nbl_glsl_unpackMaxMipInVT(_texData)));`
	`275`	`+ return nbl_glsl_uVTextureLod_impl(formatID, virtualUV, lod, nbl_glsl_unpackMaxMipInVT(_texData));`
`272`	`276`	`}`
`273`	`277`	`#endif //_NBL_VT_UINT_VIEWS_COUNT`
`274`	`278`
`@@ -314,7 +318,7 @@ retval_t funcName(in uvec2 _texData, in vec2 uv, in uint lod) \`
`314`	`318`	`virtualUV.xy += uv * originalSz; \`
`315`	`319`	`virtualUV.xy *= nbl_glsl_VT_getVTexSzRcp(); \`
`316`	`320`	`\`
`317`		`- return nbl_glsl_vTextureLod_impl(formatID, virtualUV, lod, int(nbl_glsl_unpackMaxMipInVT(_texData))); \`
	`321`	`+ return nbl_glsl_vTextureLod_impl(formatID, virtualUV, lod, nbl_glsl_unpackMaxMipInVT(_texData)); \`
`318`	`322`	`}`
`319`	`323`
`320`	`324`	`_NBL_DEFINE_VT_INTEGER_FUNCTIONS(nbl_glsl_iVTextureLod, nbl_glsl_iVTextureLod_impl, ivec4, iphysicalTileStorageFormatView)`