Add support for VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT

Author: squidbus

Docs/MoltenVK_Configuration_Parameters.md

@@ -680,6 +680,9 @@ allocate textures and buffers from general device memory.
 Vulkan extension `VK_EXT_image_2d_view_of_3d` requires this parameter to be active, 
 to allow aliasing of texture memory between the 3D image and the 2D view.
 
+`VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT` also requires this parameter to be active,
+to allow aliasing of texture memory between the compressed image and the uncompressed view.
+
 To force `MTLHeap` to be used on AMD GPUs, set this parameter to `2`. 
 To disable the use of `MTLHeap` on any GPU, set this parameter to `0`.
 

MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm

@@ -1521,9 +1521,12 @@
 		}
 	}
 
-	// Metal does not support creating uncompressed views of compressed formats.
+	// Metal does not support creating uncompressed views of compressed formats without aliasing with MTLHeap.
+	if (mvkIsAnyFlagEnabled(flags, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT) && !getMVKConfig().useMTLHeap) {
+		return VK_ERROR_FORMAT_NOT_SUPPORTED;
+	}
 	// Metal does not support split-instance images.
-	if (mvkIsAnyFlagEnabled(flags, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT | VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT)) {
+	if (mvkIsAnyFlagEnabled(flags, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT)) {
 		return VK_ERROR_FORMAT_NOT_SUPPORTED;
 	}
 

MoltenVK/MoltenVK/GPUObjects/MVKImage.h

@@ -402,6 +402,7 @@ class MVKImage : public MVKVulkanAPIDeviceObject {
 	bool _shouldSupportAtomics;
 	bool _isLinearForAtomics;
 	bool _is2DViewOn3DImageCompatible = false;
+	bool _isBlockTexelViewCompatible = false;
 };
 
 
@@ -597,6 +598,8 @@ class MVKImageView : public MVKVulkanAPIDeviceObject {
 	/** Return the underlying image. */
 	MVKImage* getImage() { return _image; }
 
+	bool getIsCompressed() { return getPixelFormats()->getFormatType(_vkFormat) == kMVKFormatCompressed; }
+
 #pragma mark Metal
 
 	/** Returns the Metal texture underlying this image view.  */
@@ -653,6 +656,7 @@ class MVKImageView : public MVKVulkanAPIDeviceObject {
     VkImageUsageFlags _usage;
 	std::mutex _lock;
 	MTLTextureType _mtlTextureType;
+	VkFormat _vkFormat;
 };
 
 

MoltenVK/MoltenVK/GPUObjects/MVKImage.mm

@@ -51,6 +51,9 @@
         if (_image->_is2DViewOn3DImageCompatible && !dvcMem->ensureMTLHeap()) {
             MVKAssert(0, "Creating a 2D view of a 3D texture currently requires a placement heap, which is not available.");
         }
+        if (_image->_isBlockTexelViewCompatible && !dvcMem->ensureMTLHeap()) {
+            MVKAssert(0, "Creating an uncompressed view of a compressed texture currently requires a placement heap, which is not available.");
+        }
 
         // Use imported texture if we are binding to a VkDeviceMemory that was created with an import operation
         if (dvcMem && (dvcMem->_externalMemoryHandleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT) && dvcMem->_mtlTexture) {
@@ -1138,13 +1141,16 @@ static MTLRegion getMTLRegion(const ImgRgn& imgRgn) {
 
 	// Metal before 3.0 doesn't support 3D compressed textures, so we'll
 	// decompress the texture ourselves, and we need to be able to write to it.
-	// Additionally, the ability to create 2D alias over 3D image is dependent
-	// on write capability to synchronize correctly.
-	bool makeWritable = (MVK_MACOS && _is3DCompressed) || _is2DViewOn3DImageCompatible;
-	if (makeWritable) {
+	if (MVK_MACOS && _is3DCompressed) {
 		mvkEnableFlags(mtlUsage, MTLTextureUsageShaderWrite);
 	}
 
+	// For 2D views of 3D and block texel views, set pixel format view usage to ensure
+	// that Metal does not apply lossless compression so we can alias the underlying memory.
+	if (_is2DViewOn3DImageCompatible || _isBlockTexelViewCompatible) {
+		mvkEnableFlags(mtlUsage, MTLTextureUsagePixelFormatView);
+	}
+
 	return mtlUsage;
 }
 
@@ -1306,6 +1312,7 @@ static MTLRegion getMTLRegion(const ImgRgn& imgRgn) {
 	}
 
 	_is2DViewOn3DImageCompatible = mvkIsAnyFlagEnabled(pCreateInfo->flags, VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT);
+	_isBlockTexelViewCompatible = mvkIsAnyFlagEnabled(pCreateInfo->flags, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT);
 }
 
 VkSampleCountFlagBits MVKImage::validateSamples(const VkImageCreateInfo* pCreateInfo, bool isAttachment) {
@@ -1358,8 +1365,8 @@ static MTLRegion getMTLRegion(const ImgRgn& imgRgn) {
 	if (isAttachment && (getImageType() == VK_IMAGE_TYPE_1D)) {
 		setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCreateImage() : Metal does not support rendering to native 1D attachments. Consider enabling MVK_CONFIG_TEXTURE_1D_AS_2D."));
 	}
-	if (mvkIsAnyFlagEnabled(pCreateInfo->flags, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT)) {
-		setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCreateImage() : Metal does not allow uncompressed views of compressed images."));
+	if (mvkIsAnyFlagEnabled(pCreateInfo->flags, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT) && !getMVKConfig().useMTLHeap) {
+		setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCreateImage() : MTLHeap must be enabled to create uncompressed views of compressed images."));
 	}
 	if (mvkIsAnyFlagEnabled(pCreateInfo->flags, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT)) {
 		setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCreateImage() : Metal does not support split-instance memory binding."));
@@ -1860,33 +1867,50 @@ static void signalAndUntrack(const MVKSwapchainSignaler& signaler) {
 id<MTLTexture> MVKImageViewPlane::newMTLTexture() {
     MTLTextureType mtlTextureType = _imageView->_mtlTextureType;
     NSRange sliceRange = NSMakeRange(_imageView->_subresourceRange.baseArrayLayer, _imageView->_subresourceRange.layerCount);
-    // Fake support for 2D views of 3D textures.
+    // Fake support for 2D views of 3D textures and block texel views
     id<MTLTexture> aliasTex = nil;
     auto* image = _imageView->_image;
     id<MTLTexture> mtlTex = image->getMTLTexture(_planeIndex);
-    if (image->getImageType() == VK_IMAGE_TYPE_3D &&
-        (mtlTextureType == MTLTextureType2D || mtlTextureType == MTLTextureType2DArray)) {
-        if (image->_is2DViewOn3DImageCompatible) {
+    const bool is2dViewOf3d = image->getImageType() == VK_IMAGE_TYPE_3D &&
+        (mtlTextureType == MTLTextureType2D || mtlTextureType == MTLTextureType2DArray);
+    const bool isBlockTexelView = image->getIsCompressed() != _imageView->getIsCompressed();
+    if (is2dViewOf3d || isBlockTexelView) {
+        const bool alias2dViewOf3d = is2dViewOf3d && image->_is2DViewOn3DImageCompatible;
+        const bool aliasBlockTexelView = isBlockTexelView && image->_isBlockTexelViewCompatible;
+        if (alias2dViewOf3d || aliasBlockTexelView) {
             const auto heapAllocation = image->getHeapAllocation(_planeIndex);
-            MVKAssert(heapAllocation, "Attempting to create a 2D view of a 3D texture without a placement heap");
+            MVKAssert(heapAllocation, "Attempting to create a memory-aliased texture without a placement heap");
 
-            const auto relativeSliceOffset = _imageView->_subresourceRange.baseArrayLayer * (heapAllocation->size / image->_extent.depth);
             MTLTextureDescriptor* mtlTexDesc = image->newMTLTextureDescriptor(_planeIndex); // temp retain
 
-            mtlTexDesc.depth = 1;
-            mtlTexDesc.arrayLength = _imageView->_subresourceRange.layerCount;
-            mtlTexDesc.textureType = mtlTextureType;
+            size_t relativeSliceOffset = 0;
+            if (alias2dViewOf3d) {
+                // Update descriptor and slice info with correct attributes and offsets for 2D view.
+                mtlTexDesc.depth = 1;
+                mtlTexDesc.arrayLength = _imageView->_subresourceRange.layerCount;
+                mtlTexDesc.textureType = mtlTextureType;
+                sliceRange = NSMakeRange(0, _imageView->_subresourceRange.layerCount);
+                relativeSliceOffset = _imageView->_subresourceRange.baseArrayLayer * (heapAllocation->size / image->_extent.depth);
+            }
+            if (aliasBlockTexelView) {
+                // Update pixel format and dimensions to match uncompressed view format.
+                // TODO: dEQP-VK.image.texel_view_compatible.graphic.extended.*
+                const VkExtent2D fmtBlockSize = getPixelFormats()->getBlockTexelSize(image->getVkFormat());
+                mtlTexDesc.pixelFormat = _mtlPixFmt;
+                mtlTexDesc.width = (mtlTexDesc.width + fmtBlockSize.width - 1) / fmtBlockSize.width;
+                mtlTexDesc.height = (mtlTexDesc.height + fmtBlockSize.height - 1) / fmtBlockSize.height;
+            }
 
-            // Create a temporary texture that is backed by the 3D texture's memory
+            // Create a temporary texture that is backed by the original texture's memory
             aliasTex = [heapAllocation->heap
                               newTextureWithDescriptor: mtlTexDesc
                               offset: heapAllocation->offset + relativeSliceOffset];
 
             [mtlTexDesc release]; // temp release
 
             mtlTex = aliasTex;
-            sliceRange = NSMakeRange(0, _imageView->_subresourceRange.layerCount);
-        } else {
+        }
+        if (is2dViewOf3d && !alias2dViewOf3d) {
             mtlTextureType = MTLTextureType3D;
             sliceRange = NSMakeRange(0, 1);
         }
@@ -2294,6 +2318,7 @@ static void signalAndUntrack(const MVKSwapchainSignaler& signaler) {
 
     _mtlTextureType = mvkMTLTextureTypeFromVkImageViewType(pCreateInfo->viewType,
 														   _image->getSampleCount() != VK_SAMPLE_COUNT_1_BIT);
+    _vkFormat = pCreateInfo->format;
 
 	// Per spec, for depth/stencil formats, determine the appropriate usage
 	// based on whether stencil or depth or both aspects are being used.