diff --git a/Docs/Whats_New.md b/Docs/Whats_New.md
index 18dd946..22a63de 100644
--- a/Docs/Whats_New.md
+++ b/Docs/Whats_New.md
@@ -30,6 +30,10 @@
 - Separate `SPIRVToMSLConverterContext` into input config and output results.
 - Fix pipeline cache lookups.
 - Fix race condition between swapchain image destruction and presentation completion callback.
+- Set Metal texture usage to allow texture copy via view.
+- `vkCmdCopyImage()` support copying between compressed and uncompressed formats
+  and validate that formats are compatible for copying.
+- `vkCmdBufferImageCopy()` fix crash when setting bytes per image in non-arrayed images. 
 - Document that the functions in `vk_mvk_moltenvk.h` cannot be used with objects 
   retrieved through the *Vulkan SDK Loader and Layers* framework.
 - Update `VK_MVK_MOLTENVK_SPEC_VERSION` to 21.
diff --git a/MoltenVK/MoltenVK/Commands/MVKCmdPipeline.mm b/MoltenVK/MoltenVK/Commands/MVKCmdPipeline.mm
index 5eff3e4..b8e106b 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCmdPipeline.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKCmdPipeline.mm
@@ -209,7 +209,7 @@
         VK_SHADER_STAGE_COMPUTE_BIT
     };
     for (auto stage : stages) {
-        if (mvkAreFlagsEnabled(_stageFlags, stage)) {
+        if (mvkAreAllFlagsEnabled(_stageFlags, stage)) {
             cmdEncoder->getPushConstants(stage)->setPushConstants(_offset, _pushConstants);
         }
     }
diff --git a/MoltenVK/MoltenVK/Commands/MVKCmdTransfer.h b/MoltenVK/MoltenVK/Commands/MVKCmdTransfer.h
index 3e3b007..bd7110a 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCmdTransfer.h
+++ b/MoltenVK/MoltenVK/Commands/MVKCmdTransfer.h
@@ -33,17 +33,6 @@
 #pragma mark -
 #pragma mark MVKCmdCopyImage
 
-/** Describes the Metal texture copying parameters. */
-typedef struct {
-	uint32_t	srcLevel;
-	uint32_t	srcSlice;
-	MTLOrigin	srcOrigin;
-	MTLSize		srcSize;
-	uint32_t	dstLevel;
-	uint32_t	dstSlice;
-	MTLOrigin	dstOrigin;
-} MVKMetalCopyTextureRegion;
-
 /** Vulkan command to copy image regions. */
 class MVKCmdCopyImage : public MVKCommand {
 
@@ -62,14 +51,29 @@
 		MVKCommand::MVKCommand((MVKCommandTypePool<MVKCommand>*)pool) {}
 
 protected:
-    void addMetalCopyRegions(const VkImageCopy* pRegion);
+	void setContent(VkImage srcImage, VkImageLayout srcImageLayout,
+					VkImage dstImage, VkImageLayout dstImageLayout, MVKCommandUse commandUse);
+	void addImageCopyRegion(const VkImageCopy& region);
+	void addTempBufferImageCopyRegion(const VkImageCopy& region);
 
 	MVKImage* _srcImage;
 	VkImageLayout _srcLayout;
 	MVKImage* _dstImage;
 	VkImageLayout _dstLayout;
-	std::vector<MVKMetalCopyTextureRegion> _mtlTexCopyRegions;
-    MVKCommandUse _commandUse = kMVKCommandUseNone;
+	MTLPixelFormat _srcMTLPixFmt;
+	MTLPixelFormat _dstMTLPixFmt;
+	uint32_t _srcSampleCount;
+	uint32_t _dstSampleCount;
+	bool _isSrcCompressed;
+	bool _isDstCompressed;
+	bool _canCopyFormats;
+	bool _shouldUseTextureView;
+	bool _shouldUseTempBuffer;
+	std::vector<VkImageCopy> _imageCopyRegions;
+	std::vector<VkBufferImageCopy> _srcTmpBuffImgCopies;
+	std::vector<VkBufferImageCopy> _dstTmpBuffImgCopies;
+	size_t _tmpBuffSize;
+    MVKCommandUse _commandUse;
 };
 
 
@@ -79,14 +83,11 @@
 /** Number of vertices in a BLIT rectangle. */
 #define kMVKBlitVertexCount		4
 
-/** Describes Metal texture rendering parameters. */
+/** Combines a VkImageBlit with vertices to render it. */
 typedef struct {
-	uint32_t	srcLevel;
-	uint32_t	srcSlice;
-	uint32_t	dstLevel;
-	uint32_t	dstSlice;
+	VkImageBlit region;
 	MVKVertexPosTex vertices[kMVKBlitVertexCount];
-} MVKMetalBlitTextureRender;
+} MVKImageBlitRender;
 
 /** Vulkan command to BLIT image regions. */
 class MVKCmdBlitImage : public MVKCmdCopyImage {
@@ -108,17 +109,16 @@
 	~MVKCmdBlitImage() override;
 
 protected:
-	bool canCopy(const VkImageBlit* pRegion);
-    void addMetalCopyRegions(const VkImageBlit* pRegion);
-    void addMetalBlitRenders(const VkImageBlit* pRegion);
-	void populateVertices(MVKVertexPosTex* vertices, const VkImageBlit* pRegion);
+	bool canCopy(const VkImageBlit& region);
+	void addImageBlitRegion(const VkImageBlit& region);
+	void addImageCopyRegionFromBlitRegion(const VkImageBlit& region);
+	void populateVertices(MVKVertexPosTex* vertices, const VkImageBlit& region);
     void initMTLRenderPassDescriptor();
 
 	MTLRenderPassDescriptor* _mtlRenderPassDescriptor;
 	MTLSamplerMinMagFilter _mtlFilter;
-    MTLPixelFormat _mtlPixFmt;
 	MVKRPSKeyBlitImg _blitKey;
-	std::vector<MVKMetalBlitTextureRender> _mtlTexBlitRenders;
+	std::vector<MVKImageBlitRender> _mvkImageBlitRenders;
 };
 
 
@@ -211,10 +211,12 @@
 		MVKCommand::MVKCommand((MVKCommandTypePool<MVKCommand>*)pool) {}
 
 protected:
+	bool isArrayTexture();
+
     MVKBuffer* _buffer;
     MVKImage* _image;
     VkImageLayout _imageLayout;
-    std::vector<VkBufferImageCopy> _mtlBuffImgCopyRegions;
+    std::vector<VkBufferImageCopy> _bufferImageCopyRegions;
     bool _toImage = false;
 };
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKCmdTransfer.mm b/MoltenVK/MoltenVK/Commands/MVKCmdTransfer.mm
index db6c561..56ef128 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCmdTransfer.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKCmdTransfer.mm
@@ -38,81 +38,169 @@
 								 VkImage dstImage,
 								 VkImageLayout dstImageLayout,
 								 uint32_t regionCount,
-                                 const VkImageCopy* pRegions,
-                                 MVKCommandUse commandUse) {
-	_srcImage = (MVKImage*)srcImage;
-	_srcLayout = srcImageLayout;
-	_dstImage = (MVKImage*)dstImage;
-	_dstLayout = dstImageLayout;
-    _commandUse = commandUse;
+								 const VkImageCopy* pRegions,
+								 MVKCommandUse commandUse) {
 
-    // Deterine the total number of texture layers being affected
-    uint32_t layerCnt = 0;
-    for (uint32_t i = 0; i < regionCount; i++) {
-        layerCnt += pRegions[i].srcSubresource.layerCount;
-    }
+	setContent(srcImage, srcImageLayout, dstImage, dstImageLayout, commandUse);
 
-	// Add image regions
-    _mtlTexCopyRegions.clear();     // Clear for reuse
-    _mtlTexCopyRegions.reserve(layerCnt);
 	for (uint32_t i = 0; i < regionCount; i++) {
-		addMetalCopyRegions(&pRegions[i]);
+		addImageCopyRegion(pRegions[i]);
 	}
 
-    // Validate
-    if ((_srcImage->getMTLTextureType() == MTLTextureType3D) != (_dstImage->getMTLTextureType() == MTLTextureType3D)) {
-        setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCmdCopyImage(): Metal does not support copying to or from slices of a 3D texture."));
-    }
+	// Validate
+	if ( !_canCopyFormats ) {
+		setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCmdCopyImage(): Cannot copy between incompatible formats, such as formats of different pixel sizes."));
+	}
+	if ((_srcImage->getMTLTextureType() == MTLTextureType3D) != (_dstImage->getMTLTextureType() == MTLTextureType3D)) {
+		setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCmdCopyImage(): Metal does not support copying to or from slices of a 3D texture."));
+	}
 }
 
-// Adds a Metal copy region structure for each layer in the specified copy region.
-void MVKCmdCopyImage::addMetalCopyRegions(const VkImageCopy* pRegion) {
+// Sets basic content for use by this class and subclasses
+void MVKCmdCopyImage::setContent(VkImage srcImage,
+								 VkImageLayout srcImageLayout,
+								 VkImage dstImage,
+								 VkImageLayout dstImageLayout,
+								 MVKCommandUse commandUse) {
+	_srcImage = (MVKImage*)srcImage;
+	_srcLayout = srcImageLayout;
+	_srcMTLPixFmt = _srcImage->getMTLPixelFormat();
+	_srcSampleCount = mvkSampleCountFromVkSampleCountFlagBits(_srcImage->getSampleCount());
+	_isSrcCompressed = _srcImage->getIsCompressed();
+	uint32_t srcBytesPerBlock = mvkMTLPixelFormatBytesPerBlock(_srcMTLPixFmt);
 
-    MVKMetalCopyTextureRegion mtlImgRgn;
-    mtlImgRgn.srcOrigin = mvkMTLOriginFromVkOffset3D(pRegion->srcOffset);
-    mtlImgRgn.dstOrigin = mvkMTLOriginFromVkOffset3D(pRegion->dstOffset);
-    mtlImgRgn.srcSize = mvkMTLSizeFromVkExtent3D(pRegion->extent);
-    mtlImgRgn.srcLevel = pRegion->srcSubresource.mipLevel;
-    mtlImgRgn.dstLevel = pRegion->dstSubresource.mipLevel;
+	_dstImage = (MVKImage*)dstImage;
+	_dstLayout = dstImageLayout;
+	_dstMTLPixFmt = _dstImage->getMTLPixelFormat();
+	_dstSampleCount = mvkSampleCountFromVkSampleCountFlagBits(_dstImage->getSampleCount());
+	_isDstCompressed = _dstImage->getIsCompressed();
+	uint32_t dstBytesPerBlock = mvkMTLPixelFormatBytesPerBlock(_dstMTLPixFmt);
 
-    uint32_t srcBaseLayer = pRegion->srcSubresource.baseArrayLayer;
-    uint32_t dstBaseLayer = pRegion->dstSubresource.baseArrayLayer;
-    uint32_t layCnt = pRegion->srcSubresource.layerCount;
+	_canCopyFormats = (srcBytesPerBlock == dstBytesPerBlock) && (_srcSampleCount == _dstSampleCount);
+	_shouldUseTextureView = (_srcMTLPixFmt != _dstMTLPixFmt) && !(_isSrcCompressed || _isDstCompressed);	// Different formats and neither is compressed
+	_shouldUseTempBuffer = (_srcMTLPixFmt != _dstMTLPixFmt) && (_isSrcCompressed || _isDstCompressed);		// Different formats and at least one is compressed
 
-    for (uint32_t layIdx = 0; layIdx < layCnt; layIdx++) {
-		mtlImgRgn.srcSlice = srcBaseLayer + layIdx;
-		mtlImgRgn.dstSlice = dstBaseLayer + layIdx;
-        _mtlTexCopyRegions.push_back(mtlImgRgn);
+	_commandUse = commandUse;
+	_tmpBuffSize = 0;
+
+	_imageCopyRegions.clear();		// Clear for reuse
+	_srcTmpBuffImgCopies.clear();	// Clear for reuse
+	_dstTmpBuffImgCopies.clear();	// Clear for reuse
+}
+
+void MVKCmdCopyImage::addImageCopyRegion(const VkImageCopy& region) {
+	if (_shouldUseTempBuffer) {
+		addTempBufferImageCopyRegion(region);	// Convert to image->buffer->image copies
+	} else {
+		_imageCopyRegions.push_back(region);
 	}
 }
 
+// Add an image->buffer copy and buffer->image copy to replace the image->image copy
+void MVKCmdCopyImage::addTempBufferImageCopyRegion(const VkImageCopy& region) {
+	VkBufferImageCopy buffImgCpy;
+
+	// Add copy from source image to temp buffer.
+	buffImgCpy.bufferOffset = _tmpBuffSize;
+	buffImgCpy.bufferRowLength = 0;
+	buffImgCpy.bufferImageHeight = 0;
+	buffImgCpy.imageSubresource = region.srcSubresource;
+	buffImgCpy.imageOffset = region.srcOffset;
+	buffImgCpy.imageExtent = region.extent;
+	_srcTmpBuffImgCopies.push_back(buffImgCpy);
+
+	// Add copy from temp buffer to destination image.
+	// Extent is provided in source texels. If the source is compressed but the
+	// destination is not, each destination pixel will consume an entire source block,
+	// so we must downscale the destination extent by the size of the source block.
+	VkExtent3D dstExtent = region.extent;
+	if (_isSrcCompressed && !_isDstCompressed) {
+		VkExtent2D srcBlockExtent = mvkMTLPixelFormatBlockTexelSize(_srcMTLPixFmt);
+		dstExtent.width /= srcBlockExtent.width;
+		dstExtent.height /= srcBlockExtent.height;
+	}
+	buffImgCpy.bufferOffset = _tmpBuffSize;
+	buffImgCpy.bufferRowLength = 0;
+	buffImgCpy.bufferImageHeight = 0;
+	buffImgCpy.imageSubresource = region.dstSubresource;
+	buffImgCpy.imageOffset = region.dstOffset;
+	buffImgCpy.imageExtent = dstExtent;
+	_dstTmpBuffImgCopies.push_back(buffImgCpy);
+
+	NSUInteger bytesPerRow = mvkMTLPixelFormatBytesPerRow(_srcMTLPixFmt, region.extent.width);
+	NSUInteger bytesPerRegion = mvkMTLPixelFormatBytesPerLayer(_srcMTLPixFmt, bytesPerRow, region.extent.height);
+	_tmpBuffSize += bytesPerRegion;
+}
+
 void MVKCmdCopyImage::encode(MVKCommandEncoder* cmdEncoder) {
-    id<MTLTexture> srcMTLTex = _srcImage->getMTLTexture();
-    id<MTLTexture> dstMTLTex = _dstImage->getMTLTexture();
-    if ( !srcMTLTex || !dstMTLTex ) { return; }
+	id<MTLTexture> srcMTLTex = _srcImage->getMTLTexture();
+	id<MTLTexture> dstMTLTex = _dstImage->getMTLTexture();
+	if ( !srcMTLTex || !dstMTLTex ) { return; }
 
-    if (srcMTLTex.pixelFormat != dstMTLTex.pixelFormat &&
-        mvkFormatTypeFromVkFormat(_dstImage->getVkFormat()) != kMVKFormatCompressed &&
-        mvkFormatTypeFromVkFormat(_srcImage->getVkFormat()) != kMVKFormatCompressed) {
-        // If the pixel formats don't match, Metal won't abort, but it won't
-        // do the copy either. But we can easily work around that... unless the
-        // source format is compressed.
-        srcMTLTex = [[srcMTLTex newTextureViewWithPixelFormat: dstMTLTex.pixelFormat] autorelease];
-    }
+	// If the pixel formats are different but mappable, use a texture view on the source texture
+	if (_shouldUseTextureView) {
+		srcMTLTex = [[srcMTLTex newTextureViewWithPixelFormat: _dstMTLPixFmt] autorelease];
+	}
 
-    id<MTLBlitCommandEncoder> mtlBlitEnc = cmdEncoder->getMTLBlitEncoder(_commandUse);
+	id<MTLBlitCommandEncoder> mtlBlitEnc = cmdEncoder->getMTLBlitEncoder(_commandUse);
 
-    for (auto& cpyRgn : _mtlTexCopyRegions) {
-        [mtlBlitEnc copyFromTexture: srcMTLTex
-                        sourceSlice: cpyRgn.srcSlice
-                        sourceLevel: cpyRgn.srcLevel
-                       sourceOrigin: cpyRgn.srcOrigin
-                         sourceSize: cpyRgn.srcSize
-                          toTexture: dstMTLTex
-                   destinationSlice: cpyRgn.dstSlice
-                   destinationLevel: cpyRgn.dstLevel
-                  destinationOrigin: cpyRgn.dstOrigin];
-    }
+	// If copies can be performed using direct texture-texture copying, do so
+	for (auto& cpyRgn : _imageCopyRegions) {
+		uint32_t	srcLevel = cpyRgn.srcSubresource.mipLevel;;
+		MTLOrigin	srcOrigin = mvkMTLOriginFromVkOffset3D(cpyRgn.srcOffset);;
+		MTLSize		srcSize = mvkMTLSizeFromVkExtent3D(cpyRgn.extent);
+		uint32_t	dstLevel = cpyRgn.dstSubresource.mipLevel;
+		MTLOrigin	dstOrigin = mvkMTLOriginFromVkOffset3D(cpyRgn.dstOffset);
+
+		uint32_t srcBaseLayer = cpyRgn.srcSubresource.baseArrayLayer;
+		uint32_t dstBaseLayer = cpyRgn.dstSubresource.baseArrayLayer;
+		uint32_t layCnt = cpyRgn.srcSubresource.layerCount;
+
+		for (uint32_t layIdx = 0; layIdx < layCnt; layIdx++) {
+			[mtlBlitEnc copyFromTexture: srcMTLTex
+							sourceSlice: srcBaseLayer + layIdx
+							sourceLevel: srcLevel
+						   sourceOrigin: srcOrigin
+							 sourceSize: srcSize
+							  toTexture: dstMTLTex
+					   destinationSlice: dstBaseLayer + layIdx
+					   destinationLevel: dstLevel
+					  destinationOrigin: dstOrigin];
+		}
+	}
+
+	// If copies could not be performed directly between images,
+	// use a temporary buffer acting as a waystation between the images.
+	if ( !_srcTmpBuffImgCopies.empty() ) {
+		MVKBufferDescriptorData tempBuffData;
+		tempBuffData.size = _tmpBuffSize;
+		tempBuffData.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+		MVKBuffer* tempBuff = getCommandEncodingPool()->getTransferMVKBuffer(tempBuffData);
+
+		MVKCmdBufferImageCopy cpyCmd(&getCommandPool()->_cmdBufferImageCopyPool);
+
+		// Copy from source image to buffer
+		// Create and execute a temporary buffer image command.
+		// To be threadsafe...do NOT acquire and return the command from the pool.
+		cpyCmd.setContent((VkBuffer) tempBuff,
+						  (VkImage) _srcImage,
+						  _srcLayout,
+						  (uint32_t)_srcTmpBuffImgCopies.size(),
+						  _srcTmpBuffImgCopies.data(),
+						  false);
+		cpyCmd.encode(cmdEncoder);
+
+		// Copy from buffer to destination image
+		// Create and execute a temporary buffer image command.
+		// To be threadsafe...do NOT acquire and return the command from the pool.
+		cpyCmd.setContent((VkBuffer) tempBuff,
+						  (VkImage) _dstImage,
+						  _dstLayout,
+						  (uint32_t)_dstTmpBuffImgCopies.size(),
+						  _dstTmpBuffImgCopies.data(),
+						  true);
+		cpyCmd.encode(cmdEncoder);
+	}
 }
 
 
@@ -125,134 +213,87 @@
 								 VkImageLayout dstImageLayout,
 								 uint32_t regionCount,
 								 const VkImageBlit* pRegions,
-                                 VkFilter filter,
-                                 MVKCommandUse commandUse) {
-	_srcImage = (MVKImage*)srcImage;
-	_srcLayout = srcImageLayout;
-	_dstImage = (MVKImage*)dstImage;
-	_dstLayout = dstImageLayout;
+								 VkFilter filter,
+								 MVKCommandUse commandUse) {
 
-    _mtlPixFmt = _dstImage->getMTLPixelFormat();
-    _mtlFilter = mvkMTLSamplerMinMagFilterFromVkFilter(filter);
+	MVKCmdCopyImage::setContent(srcImage, srcImageLayout, dstImage, dstImageLayout, commandUse);
 
-	_blitKey.mtlPixFmt = (uint32_t)_mtlPixFmt;
-	_blitKey.mtlTexType = (uint32_t)_srcImage->getMTLTextureType();
+	_mtlFilter = mvkMTLSamplerMinMagFilterFromVkFilter(filter);
 
-    _commandUse = commandUse;
-
-	// Determine which regions can be copied and which must be rendered to the destination texture
-	bool canCopyRegion[regionCount];
-	uint32_t copyRegionCount = 0;
-	uint32_t renderRegionCount = 0;
-	for (uint32_t i = 0; i < regionCount; i++) {
-		const VkImageBlit* pRegion = &pRegions[i];
-		uint32_t layCnt = pRegion->srcSubresource.layerCount;
-		if ( canCopy(pRegion) && (_srcImage->getMTLPixelFormat() == _mtlPixFmt) ) {
-			canCopyRegion[i] = true;
-			copyRegionCount += layCnt;
-		} else {
-			canCopyRegion[i] = false;
-			renderRegionCount += layCnt;
-		}
-	}
-
-	// Add copy and BLIT regions accordingly
-    _mtlTexCopyRegions.clear();     // Clear for reuse
-	_mtlTexCopyRegions.reserve(copyRegionCount);
-    _mtlTexBlitRenders.clear();     // Clear for reuse
-	_mtlTexBlitRenders.reserve(renderRegionCount);
+	_blitKey.srcMTLPixelFormat = (uint32_t)_srcMTLPixFmt;
+	_blitKey.srcMTLTextureType = (uint32_t)_srcImage->getMTLTextureType();
+	_blitKey.dstMTLPixelFormat = (uint32_t)_dstMTLPixFmt;
+	_blitKey.dstSampleCount = _dstSampleCount;
 
 	for (uint32_t i = 0; i < regionCount; i++) {
-		const VkImageBlit* pRegion = &pRegions[i];
-		if (canCopyRegion[i]) {
-			addMetalCopyRegions(pRegion);
-		} else {
-			addMetalBlitRenders(pRegion);
-		}
+		addImageBlitRegion(pRegions[i]);
 	}
 
-    // Validate
-    if (_blitKey.isDepthFormat() && renderRegionCount > 0) {
-        setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCmdBlitImage(): Scaling of depth/stencil images is not supported."));
-    }
-    if ( !_mtlTexBlitRenders.empty() && mvkMTLPixelFormatIsStencilFormat(_mtlPixFmt)) {
-        setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCmdBlitImage(): Stencil image formats cannot be scaled or inverted."));
-    }
+	// Validate
+	if ( !_mvkImageBlitRenders.empty() &&
+		(mvkMTLPixelFormatIsDepthFormat(_srcMTLPixFmt) ||
+		 mvkMTLPixelFormatIsStencilFormat(_srcMTLPixFmt)) ) {
+
+		setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCmdBlitImage(): Scaling or inverting depth/stencil images is not supported."));
+		_mvkImageBlitRenders.clear();
+	}
 }
 
-bool MVKCmdBlitImage::canCopy(const VkImageBlit* pRegion) {
-	VkOffset3D srcSize = mvkVkOffset3DDifference(pRegion->srcOffsets[1], pRegion->srcOffsets[0]);
-	VkOffset3D dstSize = mvkVkOffset3DDifference(pRegion->dstOffsets[1], pRegion->dstOffsets[0]);
+void MVKCmdBlitImage::addImageBlitRegion(const VkImageBlit& region) {
+	if (_canCopyFormats && canCopy(region)) {
+		addImageCopyRegionFromBlitRegion(region);	// Convert to image copy
+	} else {
+		MVKImageBlitRender blitRender;
+		blitRender.region = region;
+		populateVertices(blitRender.vertices, region);
+		_mvkImageBlitRenders.push_back(blitRender);
+	}
+}
 
-	// The source and destination sizes must be equal and not be negative in any direction
+// The source and destination sizes must be equal and not be negative in any direction
+bool MVKCmdBlitImage::canCopy(const VkImageBlit& region) {
+	VkOffset3D srcSize = mvkVkOffset3DDifference(region.srcOffsets[1], region.srcOffsets[0]);
+	VkOffset3D dstSize = mvkVkOffset3DDifference(region.dstOffsets[1], region.dstOffsets[0]);
 	return (mvkVkOffset3DsAreEqual(srcSize, dstSize) &&
 			(srcSize.x >= 0) && (srcSize.y >= 0) && (srcSize.z >= 0));
 }
 
-// Adds a Metal copy region structure for each layer in the specified BLIT region.
-void MVKCmdBlitImage::addMetalCopyRegions(const VkImageBlit* pRegion) {
+void MVKCmdBlitImage::addImageCopyRegionFromBlitRegion(const VkImageBlit& region) {
+	const VkOffset3D& so0 = region.srcOffsets[0];
+	const VkOffset3D& so1 = region.srcOffsets[1];
 
-    const VkOffset3D* pSo0 = &pRegion->srcOffsets[0];
-    const VkOffset3D* pSo1 = &pRegion->srcOffsets[1];
+	VkImageCopy cpyRgn;
+	cpyRgn.srcSubresource = region.srcSubresource;
+	cpyRgn.srcOffset = region.srcOffsets[0];
+	cpyRgn.dstSubresource = region.dstSubresource;
+	cpyRgn.dstOffset = region.dstOffsets[0];
+	cpyRgn.extent.width = so1.x - so0.x;
+	cpyRgn.extent.height = so1.y - so0.y;
+	cpyRgn.extent.depth = so1.z - so0.z;
 
-    MVKMetalCopyTextureRegion mtlImgRgn;
-    mtlImgRgn.srcOrigin = mvkMTLOriginFromVkOffset3D(*pSo0);
-    mtlImgRgn.dstOrigin = mvkMTLOriginFromVkOffset3D(pRegion->dstOffsets[0]);
-    mtlImgRgn.srcSize = MTLSizeMake((pSo1->x - pSo0->x), (pSo1->y - pSo0->y), (pSo1->z - pSo0->z));
-    mtlImgRgn.srcLevel = pRegion->srcSubresource.mipLevel;
-    mtlImgRgn.dstLevel = pRegion->dstSubresource.mipLevel;
-
-    uint32_t srcBaseLayer = pRegion->srcSubresource.baseArrayLayer;
-    uint32_t dstBaseLayer = pRegion->dstSubresource.baseArrayLayer;
-	uint32_t layCnt = pRegion->srcSubresource.layerCount;
-
-    for (uint32_t layIdx = 0; layIdx < layCnt; layIdx++) {
-		mtlImgRgn.srcSlice = srcBaseLayer + layIdx;
-		mtlImgRgn.dstSlice = dstBaseLayer + layIdx;
-        _mtlTexCopyRegions.push_back(mtlImgRgn);
-	}
+	MVKCmdCopyImage::addImageCopyRegion(cpyRgn);
 }
 
-// Adds a Metal BLIT render region structure for each layer in the specified BLIT region.
-void MVKCmdBlitImage::addMetalBlitRenders(const VkImageBlit* pRegion) {
-
-    MVKMetalBlitTextureRender mtlBlitRndr;
-    mtlBlitRndr.srcLevel = pRegion->srcSubresource.mipLevel;
-    mtlBlitRndr.dstLevel = pRegion->dstSubresource.mipLevel;
-    populateVertices(mtlBlitRndr.vertices, pRegion);
-
-    uint32_t srcBaseLayer = pRegion->srcSubresource.baseArrayLayer;
-	uint32_t dstBaseLayer = pRegion->dstSubresource.baseArrayLayer;
-	uint32_t layCnt = pRegion->srcSubresource.layerCount;
-
-	for (uint32_t layIdx = 0; layIdx < layCnt; layIdx++) {
-		mtlBlitRndr.srcSlice = srcBaseLayer + layIdx;
-		mtlBlitRndr.dstSlice = dstBaseLayer + layIdx;
-        _mtlTexBlitRenders.push_back(mtlBlitRndr);
-	}
-}
-
-// Populates the vertices in the specified array from the specified region.
-void MVKCmdBlitImage::populateVertices(MVKVertexPosTex* vertices, const VkImageBlit* pRegion) {
-    const VkOffset3D* pSo0 = &pRegion->srcOffsets[0];
-    const VkOffset3D* pSo1 = &pRegion->srcOffsets[1];
-    const VkOffset3D* pDo0 = &pRegion->dstOffsets[0];
-    const VkOffset3D* pDo1 = &pRegion->dstOffsets[1];
+void MVKCmdBlitImage::populateVertices(MVKVertexPosTex* vertices, const VkImageBlit& region) {
+    const VkOffset3D& so0 = region.srcOffsets[0];
+    const VkOffset3D& so1 = region.srcOffsets[1];
+    const VkOffset3D& do0 = region.dstOffsets[0];
+    const VkOffset3D& do1 = region.dstOffsets[1];
 
     // Get the extents of the source and destination textures.
-    VkExtent3D srcExtent = _srcImage->getExtent3D(pRegion->srcSubresource.mipLevel);
-    VkExtent3D dstExtent = _dstImage->getExtent3D(pRegion->dstSubresource.mipLevel);
+    VkExtent3D srcExtent = _srcImage->getExtent3D(region.srcSubresource.mipLevel);
+    VkExtent3D dstExtent = _dstImage->getExtent3D(region.dstSubresource.mipLevel);
 
     // Determine the bottom-left and top-right corners of the source and destination
     // texture regions, each as a fraction of the corresponding texture size.
-    CGPoint srcBL = CGPointMake((CGFloat)(pSo0->x) / (CGFloat)srcExtent.width,
-                                (CGFloat)(srcExtent.height - pSo1->y) / (CGFloat)srcExtent.height);
-    CGPoint srcTR = CGPointMake((CGFloat)(pSo1->x) / (CGFloat)srcExtent.width,
-                                (CGFloat)(srcExtent.height - pSo0->y) / (CGFloat)srcExtent.height);
-    CGPoint dstBL = CGPointMake((CGFloat)(pDo0->x) / (CGFloat)dstExtent.width,
-                                (CGFloat)(dstExtent.height - pDo1->y) / (CGFloat)dstExtent.height);
-    CGPoint dstTR = CGPointMake((CGFloat)(pDo1->x) / (CGFloat)dstExtent.width,
-                                (CGFloat)(dstExtent.height - pDo0->y) / (CGFloat)dstExtent.height);
+    CGPoint srcBL = CGPointMake((CGFloat)(so0.x) / (CGFloat)srcExtent.width,
+                                (CGFloat)(srcExtent.height - so1.y) / (CGFloat)srcExtent.height);
+    CGPoint srcTR = CGPointMake((CGFloat)(so1.x) / (CGFloat)srcExtent.width,
+                                (CGFloat)(srcExtent.height - so0.y) / (CGFloat)srcExtent.height);
+    CGPoint dstBL = CGPointMake((CGFloat)(do0.x) / (CGFloat)dstExtent.width,
+                                (CGFloat)(dstExtent.height - do1.y) / (CGFloat)dstExtent.height);
+    CGPoint dstTR = CGPointMake((CGFloat)(do1.x) / (CGFloat)dstExtent.width,
+                                (CGFloat)(dstExtent.height - do0.y) / (CGFloat)dstExtent.height);
 
     // The destination region is used for vertex positions,
     // which are bounded by (-1.0 < p < 1.0) in clip-space.
@@ -282,7 +323,7 @@
     pVtx->position.y = dstTR.y;
     pVtx->texCoord.x = srcBL.x;
     pVtx->texCoord.y = (1.0 - srcTR.y);
-    
+
     // Top right vertex
     pVtx = &vertices[3];
     pVtx->position.x = dstTR.x;
@@ -293,50 +334,56 @@
 
 void MVKCmdBlitImage::encode(MVKCommandEncoder* cmdEncoder) {
 
-    // Perform those BLITs that can be covered by simple texture copying.
-    if ( !_mtlTexCopyRegions.empty() ) {
-        MVKCmdCopyImage::encode(cmdEncoder);
-    }
+	// Perform those BLITs that can be covered by simple texture copying.
+	if ( !_imageCopyRegions.empty() ) {
+		MVKCmdCopyImage::encode(cmdEncoder);
+	}
 
-    // Perform those BLITs that require rendering to destination texture.
-    if ( !_mtlTexBlitRenders.empty() && !_blitKey.isDepthFormat() ) {
+	// Perform those BLITs that require rendering to destination texture.
+	if ( !_mvkImageBlitRenders.empty() ) {
 
-        cmdEncoder->endCurrentMetalEncoding();
+		cmdEncoder->endCurrentMetalEncoding();
 
-        id<MTLTexture> srcMTLTex = _srcImage->getMTLTexture();
-        id<MTLTexture> dstMTLTex = _dstImage->getMTLTexture();
-        if ( !srcMTLTex || !dstMTLTex ) { return; }
+		id<MTLTexture> srcMTLTex = _srcImage->getMTLTexture();
+		id<MTLTexture> dstMTLTex = _dstImage->getMTLTexture();
+		if ( !srcMTLTex || !dstMTLTex ) { return; }
 
-		bool isArrayType = _blitKey.isArrayType();
+		MTLRenderPassColorAttachmentDescriptor* mtlColorAttDesc = _mtlRenderPassDescriptor.colorAttachments[0];
+		mtlColorAttDesc.texture = dstMTLTex;
 
-        MTLRenderPassColorAttachmentDescriptor* mtlColorAttDesc = _mtlRenderPassDescriptor.colorAttachments[0];
-        mtlColorAttDesc.texture = dstMTLTex;
+		uint32_t vtxBuffIdx = getDevice()->getMetalBufferIndexForVertexAttributeBinding(kMVKVertexContentBufferIndex);
 
-        uint32_t vtxBuffIdx = getDevice()->getMetalBufferIndexForVertexAttributeBinding(kMVKVertexContentBufferIndex);
+		MVKCommandEncodingPool* cmdEncPool = getCommandEncodingPool();
 
-        MVKCommandEncodingPool* cmdEncPool = getCommandEncodingPool();
+		for (auto& bltRend : _mvkImageBlitRenders) {
 
-        for (auto& bltRend : _mtlTexBlitRenders) {
+			mtlColorAttDesc.level = bltRend.region.dstSubresource.mipLevel;
 
-            // Update the render pass descriptor for the texture level and slice, and create a render encoder.
-            mtlColorAttDesc.level = bltRend.dstLevel;
-            mtlColorAttDesc.slice = bltRend.dstSlice;
-            id<MTLRenderCommandEncoder> mtlRendEnc = [cmdEncoder->_mtlCmdBuffer renderCommandEncoderWithDescriptor: _mtlRenderPassDescriptor];
-			setLabelIfNotNil(mtlRendEnc, mvkMTLRenderCommandEncoderLabel(_commandUse));
+			uint32_t srcBaseLayer = bltRend.region.srcSubresource.baseArrayLayer;
+			uint32_t dstBaseLayer = bltRend.region.dstSubresource.baseArrayLayer;
 
-            [mtlRendEnc pushDebugGroup: @"vkCmdBlitImage"];
-            [mtlRendEnc setRenderPipelineState: cmdEncPool->getCmdBlitImageMTLRenderPipelineState(_blitKey)];
-            cmdEncoder->setVertexBytes(mtlRendEnc, bltRend.vertices, sizeof(bltRend.vertices), vtxBuffIdx);
-			[mtlRendEnc setFragmentTexture: srcMTLTex atIndex: 0];
-			[mtlRendEnc setFragmentSamplerState: cmdEncPool->getCmdBlitImageMTLSamplerState(_mtlFilter) atIndex: 0];
-			if (isArrayType) {
-				cmdEncoder->setFragmentBytes(mtlRendEnc, &bltRend, sizeof(bltRend), 0);
+			uint32_t layCnt = bltRend.region.srcSubresource.layerCount;
+			for (uint32_t layIdx = 0; layIdx < layCnt; layIdx++) {
+				// Update the render pass descriptor for the texture level and slice, and create a render encoder.
+				mtlColorAttDesc.slice = dstBaseLayer + layIdx;
+				id<MTLRenderCommandEncoder> mtlRendEnc = [cmdEncoder->_mtlCmdBuffer renderCommandEncoderWithDescriptor: _mtlRenderPassDescriptor];
+				setLabelIfNotNil(mtlRendEnc, mvkMTLRenderCommandEncoderLabel(_commandUse));
+
+				[mtlRendEnc pushDebugGroup: @"vkCmdBlitImage"];
+				[mtlRendEnc setRenderPipelineState: cmdEncPool->getCmdBlitImageMTLRenderPipelineState(_blitKey)];
+				cmdEncoder->setVertexBytes(mtlRendEnc, bltRend.vertices, sizeof(bltRend.vertices), vtxBuffIdx);
+
+				[mtlRendEnc setFragmentTexture: srcMTLTex atIndex: 0];
+				[mtlRendEnc setFragmentSamplerState: cmdEncPool->getCmdBlitImageMTLSamplerState(_mtlFilter) atIndex: 0];
+				uint32_t srcSlice = srcBaseLayer + layIdx;
+				cmdEncoder->setFragmentBytes(mtlRendEnc, &srcSlice, sizeof(srcSlice), 0);
+
+				[mtlRendEnc drawPrimitives: MTLPrimitiveTypeTriangleStrip vertexStart: 0 vertexCount: kMVKBlitVertexCount];
+				[mtlRendEnc popDebugGroup];
+				[mtlRendEnc endEncoding];
 			}
-            [mtlRendEnc drawPrimitives: MTLPrimitiveTypeTriangleStrip vertexStart: 0 vertexCount: kMVKBlitVertexCount];
-            [mtlRendEnc popDebugGroup];
-            [mtlRendEnc endEncoding];
-        }
-    }
+		}
+	}
 }
 
 
@@ -397,7 +444,8 @@
         addResolveSlices(rslvRgn);
     }
 
-    _srcImage->getTransferDescriptorData(_transferImageData);
+    _dstImage->getTransferDescriptorData(_transferImageData);
+	_transferImageData.samples = _srcImage->getSampleCount();
 }
 
 /**
@@ -487,7 +535,7 @@
     if (expRgnCnt > 0) {
         MVKCmdBlitImage expandCmd(&getCommandPool()->_cmdBlitImagePool);
         expandCmd.setContent((VkImage)_dstImage, _dstLayout, (VkImage)xfrImage, _dstLayout,
-                             uint32_t(_expansionRegions.size()), _expansionRegions.data(),
+                             expRgnCnt, _expansionRegions.data(),
                              VK_FILTER_LINEAR, kMVKCommandUseResolveExpandImage);
         expandCmd.encode(cmdEncoder);
     }
@@ -499,7 +547,7 @@
     if (cpyRgnCnt > 0) {
         MVKCmdCopyImage copyCmd(&getCommandPool()->_cmdCopyImagePool);
         copyCmd.setContent((VkImage)_srcImage, _srcLayout, (VkImage)xfrImage, _dstLayout,
-                           uint32_t(_copyRegions.size()), _copyRegions.data(), kMVKCommandUseResolveCopyImage);
+                           cpyRgnCnt, _copyRegions.data(), kMVKCommandUseResolveCopyImage);
         copyCmd.encode(cmdEncoder);
     }
 
@@ -641,10 +689,10 @@
     _toImage = toImage;
 
     // Add buffer regions
-    _mtlBuffImgCopyRegions.clear();     // Clear for reuse
-    _mtlBuffImgCopyRegions.reserve(regionCount);
+    _bufferImageCopyRegions.clear();     // Clear for reuse
+    _bufferImageCopyRegions.reserve(regionCount);
     for (uint32_t i = 0; i < regionCount; i++) {
-        _mtlBuffImgCopyRegions.push_back(pRegions[i]);
+        _bufferImageCopyRegions.push_back(pRegions[i]);
     }
 
     // Validate
@@ -663,7 +711,7 @@
     MTLPixelFormat mtlPixFmt = _image->getMTLPixelFormat();
     MVKCommandUse cmdUse = _toImage ? kMVKCommandUseCopyBufferToImage : kMVKCommandUseCopyImageToBuffer;
 
-    for (auto& cpyRgn : _mtlBuffImgCopyRegions) {
+    for (auto& cpyRgn : _bufferImageCopyRegions) {
 
         MTLOrigin mtlTxtOrigin = mvkMTLOriginFromVkOffset3D(cpyRgn.imageOffset);
         MTLSize mtlTxtSize = mvkMTLSizeFromVkExtent3D(cpyRgn.imageExtent);
@@ -683,8 +731,8 @@
         MTLBlitOption blitOptions = MTLBlitOptionNone;
         if (mvkMTLPixelFormatIsDepthFormat(mtlPixFmt) && mvkMTLPixelFormatIsStencilFormat(mtlPixFmt)) {
             VkImageAspectFlags imgFlags = cpyRgn.imageSubresource.aspectMask;
-            bool wantDepth = mvkAreFlagsEnabled(imgFlags, VK_IMAGE_ASPECT_DEPTH_BIT);
-            bool wantStencil = mvkAreFlagsEnabled(imgFlags, VK_IMAGE_ASPECT_STENCIL_BIT);
+            bool wantDepth = mvkAreAllFlagsEnabled(imgFlags, VK_IMAGE_ASPECT_DEPTH_BIT);
+            bool wantStencil = mvkAreAllFlagsEnabled(imgFlags, VK_IMAGE_ASPECT_STENCIL_BIT);
 
             // The stencil component is always 1 byte per pixel.
 			// Don't reduce depths of 32-bit depth/stencil formats.
@@ -708,12 +756,10 @@
 #endif
 
 #if MVK_MACOS
-        if (_toImage && mvkFormatTypeFromMTLPixelFormat(mtlPixFmt) == kMVKFormatCompressed &&
-            mtlTexture.textureType == MTLTextureType3D) {
-            // If we're copying to a compressed 3D image, the image data need to be decompressed.
-            // If we're copying to mip level 0, we can skip the copy and just decode
-            // directly into the image. Otherwise, we need to use an intermediate
-            // buffer.
+		// If we're copying to a compressed 3D image, the image data need to be decompressed.
+		// If we're copying to mip level 0, we can skip the copy and just decode
+		// directly into the image. Otherwise, we need to use an intermediate buffer.
+        if (_toImage && _image->getIsCompressed() && mtlTexture.textureType == MTLTextureType3D) {
             MVKCmdCopyBufferToImageInfo info;
             info.srcRowStride = bytesPerRow & 0xffffffff;
             info.srcRowStrideHigh = bytesPerRow >> 32;
@@ -778,6 +824,10 @@
             if (!needsTempBuff) { continue; }
         }
 #endif
+
+		// Don't supply bytes per image if not an arrayed texture
+		if ( !isArrayTexture() ) { bytesPerImg = 0; }
+
         id<MTLBlitCommandEncoder> mtlBlitEnc = cmdEncoder->getMTLBlitEncoder(cmdUse);
 
         for (uint32_t lyrIdx = 0; lyrIdx < cpyRgn.imageSubresource.layerCount; lyrIdx++) {
@@ -808,6 +858,16 @@
     }
 }
 
+bool MVKCmdBufferImageCopy::isArrayTexture() {
+	MTLTextureType mtlTexType = _image->getMTLTextureType();
+	return (mtlTexType == MTLTextureType3D ||
+			mtlTexType == MTLTextureType2DArray ||
+#if MVK_MACOS
+			mtlTexType == MTLTextureType2DMultisampleArray ||
+#endif
+			mtlTexType == MTLTextureType1DArray);
+}
+
 
 #pragma mark -
 #pragma mark MVKCmdClearAttachments
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.mm b/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.mm
index 48fdab7..40dfbd9 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.mm
@@ -42,14 +42,14 @@
 	_canAcceptCommands = true;
 
 	VkCommandBufferUsageFlags usage = pBeginInfo->flags;
-	_isReusable = !mvkAreFlagsEnabled(usage, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
-	_supportsConcurrentExecution = mvkAreFlagsEnabled(usage, VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT);
+	_isReusable = !mvkAreAllFlagsEnabled(usage, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
+	_supportsConcurrentExecution = mvkAreAllFlagsEnabled(usage, VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT);
 
 	// If this is a secondary command buffer, and contains inheritance info, set the inheritance info and determine
 	// whether it contains render pass continuation info. Otherwise, clear the inheritance info, and ignore it.
 	const VkCommandBufferInheritanceInfo* pInheritInfo = (_isSecondary ? pBeginInfo->pInheritanceInfo : NULL);
 	bool hasInheritInfo = mvkSetOrClear(&_secondaryInheritanceInfo, pInheritInfo);
-	_doesContinueRenderPass = mvkAreFlagsEnabled(usage, VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) && hasInheritInfo;
+	_doesContinueRenderPass = mvkAreAllFlagsEnabled(usage, VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) && hasInheritInfo;
 
 	return getConfigurationResult();
 }
@@ -76,7 +76,7 @@
 	_initialVisibilityResultMTLBuffer = nil;		// not retained
 	setConfigurationResult(VK_NOT_READY);
 
-	if (mvkAreFlagsEnabled(flags, VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT)) {
+	if (mvkAreAllFlagsEnabled(flags, VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT)) {
 		// TODO: what are we releasing or returning here?
 	}
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm
index 328ff5c..033f613 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm
@@ -272,10 +272,10 @@
     if ( !(_cmdEncoder->supportsDynamicState(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK) &&
            mvkIsAnyFlagEnabled(faceMask, VK_STENCIL_FRONT_AND_BACK)) ) { return; }
 
-    if (mvkAreFlagsEnabled(faceMask, VK_STENCIL_FACE_FRONT_BIT)) {
+    if (mvkAreAllFlagsEnabled(faceMask, VK_STENCIL_FACE_FRONT_BIT)) {
         _depthStencilData.frontFaceStencilData.readMask = stencilCompareMask;
     }
-    if (mvkAreFlagsEnabled(faceMask, VK_STENCIL_FACE_BACK_BIT)) {
+    if (mvkAreAllFlagsEnabled(faceMask, VK_STENCIL_FACE_BACK_BIT)) {
         _depthStencilData.backFaceStencilData.readMask = stencilCompareMask;
     }
 
@@ -289,10 +289,10 @@
     if ( !(_cmdEncoder->supportsDynamicState(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK) &&
            mvkIsAnyFlagEnabled(faceMask, VK_STENCIL_FRONT_AND_BACK)) ) { return; }
 
-    if (mvkAreFlagsEnabled(faceMask, VK_STENCIL_FACE_FRONT_BIT)) {
+    if (mvkAreAllFlagsEnabled(faceMask, VK_STENCIL_FACE_FRONT_BIT)) {
         _depthStencilData.frontFaceStencilData.writeMask = stencilWriteMask;
     }
-    if (mvkAreFlagsEnabled(faceMask, VK_STENCIL_FACE_BACK_BIT)) {
+    if (mvkAreAllFlagsEnabled(faceMask, VK_STENCIL_FACE_BACK_BIT)) {
         _depthStencilData.backFaceStencilData.writeMask = stencilWriteMask;
     }
 
@@ -342,10 +342,10 @@
     if ( !(_cmdEncoder->supportsDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE) &&
            mvkIsAnyFlagEnabled(faceMask, VK_STENCIL_FRONT_AND_BACK)) ) { return; }
 
-    if (mvkAreFlagsEnabled(faceMask, VK_STENCIL_FACE_FRONT_BIT)) {
+    if (mvkAreAllFlagsEnabled(faceMask, VK_STENCIL_FACE_FRONT_BIT)) {
         _frontFaceValue = stencilReference;
     }
-    if (mvkAreFlagsEnabled(faceMask, VK_STENCIL_FACE_BACK_BIT)) {
+    if (mvkAreAllFlagsEnabled(faceMask, VK_STENCIL_FACE_BACK_BIT)) {
         _backFaceValue = stencilReference;
     }
 
@@ -793,7 +793,7 @@
     NSUInteger offset = pQueryPool->getVisibilityResultOffset(query);
     NSUInteger maxOffset = _cmdEncoder->_pDeviceMetalFeatures->maxQueryBufferSize - kMVKQuerySlotSizeInBytes;
 
-    bool shouldCount = _cmdEncoder->_pDeviceFeatures->occlusionQueryPrecise && mvkAreFlagsEnabled(flags, VK_QUERY_CONTROL_PRECISE_BIT);
+    bool shouldCount = _cmdEncoder->_pDeviceFeatures->occlusionQueryPrecise && mvkAreAllFlagsEnabled(flags, VK_QUERY_CONTROL_PRECISE_BIT);
     _mtlVisibilityResultMode = shouldCount ? MTLVisibilityResultModeCounting : MTLVisibilityResultModeBoolean;
     _mtlVisibilityResultOffset = min(offset, maxOffset);
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandPool.mm b/MoltenVK/MoltenVK/Commands/MVKCommandPool.mm
index 3bdb118..1c5d51e 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandPool.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandPool.mm
@@ -33,7 +33,7 @@
 
 // Reset all of the command buffers
 VkResult MVKCommandPool::reset(VkCommandPoolResetFlags flags) {
-	bool releaseRez = mvkAreFlagsEnabled(flags, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT);
+	bool releaseRez = mvkAreAllFlagsEnabled(flags, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT);
 
 	VkCommandBufferResetFlags cmdBuffFlags = releaseRez ? VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT : 0;
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandResourceFactory.h b/MoltenVK/MoltenVK/Commands/MVKCommandResourceFactory.h
index 55bef82..0749be9 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandResourceFactory.h
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandResourceFactory.h
@@ -35,25 +35,38 @@
  * This structure can be used as a key in a std::map and std::unordered_map.
  */
 typedef struct MVKRPSKeyBlitImg_t {
-	uint16_t mtlPixFmt = 0;			/**< MTLPixelFormat */
-	uint16_t mtlTexType = 0;		/**< MTLTextureType */
+	uint16_t srcMTLPixelFormat = 0;			/**< as MTLPixelFormat */
+	uint16_t srcMTLTextureType = 0;			/**< as MTLTextureType */
+	uint16_t dstMTLPixelFormat = 0;			/**< as MTLPixelFormat */
+	uint16_t dstSampleCount = 0;
 
 	bool operator==(const MVKRPSKeyBlitImg_t& rhs) const {
-		return ((mtlPixFmt == rhs.mtlPixFmt) && (mtlTexType == rhs.mtlTexType));
+		if (srcMTLPixelFormat != rhs.srcMTLPixelFormat) { return false; }
+		if (srcMTLTextureType != rhs.srcMTLTextureType) { return false; }
+		if (dstMTLPixelFormat != rhs.dstMTLPixelFormat) { return false; }
+		if (dstSampleCount != rhs.dstSampleCount) { return false; }
+		return true;
 	}
 
-	inline MTLPixelFormat getMTLPixelFormat() { return (MTLPixelFormat)mtlPixFmt; }
+	inline MTLPixelFormat getSrcMTLPixelFormat() { return (MTLPixelFormat)srcMTLPixelFormat; }
 
-	inline bool isDepthFormat() { return mvkMTLPixelFormatIsDepthFormat(getMTLPixelFormat()); }
+	inline MTLPixelFormat getDstMTLPixelFormat() { return (MTLPixelFormat)dstMTLPixelFormat; }
 
-	inline MTLTextureType getMTLTextureType() { return (MTLTextureType)mtlTexType; }
-
-	inline bool isArrayType() { return (mtlTexType == MTLTextureType2DArray) || (mtlTexType == MTLTextureType1DArray); }
+	inline bool isSrcArrayType() {
+		return (srcMTLTextureType == MTLTextureType2DArray ||
+#if MVK_MACOS
+				srcMTLTextureType == MTLTextureType2DMultisampleArray ||
+#endif
+				srcMTLTextureType == MTLTextureType1DArray); }
 
 	std::size_t hash() const {
-		std::size_t hash = mtlTexType;
+		std::size_t hash = srcMTLPixelFormat;
 		hash <<= 16;
-		hash |= mtlPixFmt;
+		hash |= srcMTLTextureType;
+		hash <<= 16;
+		hash |= dstMTLPixelFormat;
+		hash <<= 16;
+		hash |= dstSampleCount;
 		return hash;
 	}
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandResourceFactory.mm b/MoltenVK/MoltenVK/Commands/MVKCommandResourceFactory.mm
index 29d56a7..bf86b8f 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandResourceFactory.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandResourceFactory.mm
@@ -38,8 +38,9 @@
 
 	plDesc.vertexFunction = getFunctionNamed("vtxCmdBlitImage");
     plDesc.fragmentFunction = getBlitFragFunction(blitKey);
+	plDesc.sampleCount = blitKey.dstSampleCount;
 
-	plDesc.colorAttachments[0].pixelFormat = blitKey.getMTLPixelFormat();
+	plDesc.colorAttachments[0].pixelFormat = blitKey.getDstMTLPixelFormat();
 
     MTLVertexDescriptor* vtxDesc = plDesc.vertexDescriptor;
 
@@ -132,11 +133,11 @@
 id<MTLFunction> MVKCommandResourceFactory::getBlitFragFunction(MVKRPSKeyBlitImg& blitKey) {
 	id<MTLFunction> mtlFunc = nil;
 
-	NSString* typeStr = getMTLFormatTypeString(blitKey.getMTLPixelFormat());
+	NSString* typeStr = getMTLFormatTypeString(blitKey.getSrcMTLPixelFormat());
 
-	bool isArrayType = blitKey.isArrayType();
+	bool isArrayType = blitKey.isSrcArrayType();
 	NSString* arraySuffix = isArrayType ? @"_array" : @"";
-	NSString* sliceArg = isArrayType ? @", blitInfo.srcSlice" : @"";
+	NSString* sliceArg = isArrayType ? @", srcSlice" : @"";
 
 	@autoreleasepool {
 		NSMutableString* msl = [NSMutableString stringWithCapacity: (2 * KIBI) ];
@@ -148,27 +149,14 @@
 		[msl appendLineMVK: @"    float2 v_texCoord;"];
 		[msl appendLineMVK: @"} VaryingsPosTex;"];
 		[msl appendLineMVK];
-		if (isArrayType) {
-			[msl appendLineMVK: @"typedef struct {"];
-			[msl appendLineMVK: @"    uint srcLevel;"];
-			[msl appendLineMVK: @"    uint srcSlice;"];
-			[msl appendLineMVK: @"    uint dstLevel;"];
-			[msl appendLineMVK: @"    uint dstSlice;"];
-			[msl appendLineMVK: @"} BlitInfo;"];
-			[msl appendLineMVK];
-		}
 
 		NSString* funcName = @"fragBlit";
 		[msl appendFormat: @"fragment %@4 %@(VaryingsPosTex varyings [[stage_in]],", typeStr, funcName];
 		[msl appendLineMVK];
 		[msl appendFormat: @"                         texture2d%@<%@> texture [[texture(0)]],", arraySuffix, typeStr];
 		[msl appendLineMVK];
-		if (isArrayType) {
-			[msl appendLineMVK: @"                         sampler sampler [[sampler(0)]],"];
-			[msl appendLineMVK: @"                         constant BlitInfo& blitInfo [[buffer(0)]]) {"];
-		} else {
-			[msl appendLineMVK: @"                         sampler sampler [[sampler(0)]]) {"];
-		}
+		[msl appendLineMVK: @"                         sampler sampler [[sampler(0)]],"];
+		[msl appendLineMVK: @"                         constant uint& srcSlice [[buffer(0)]]) {"];
 		[msl appendFormat: @"    return texture.sample(sampler, varyings.v_texCoord%@);", sliceArg];
 		[msl appendLineMVK];
 		[msl appendLineMVK: @"}"];
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm
index 832f460..1396bac 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm
@@ -409,7 +409,7 @@
 
 	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
         // Determine if this binding is used by this shader stage
-        _applyToStage[i] = mvkAreFlagsEnabled(pBinding->stageFlags, mvkVkShaderStageFlagBitsFromMVKShaderStage(MVKShaderStage(i)));
+        _applyToStage[i] = mvkAreAllFlagsEnabled(pBinding->stageFlags, mvkVkShaderStageFlagBitsFromMVKShaderStage(MVKShaderStage(i)));
 	    // If this binding is used by the shader, set the Metal resource index
         if (_applyToStage[i]) {
             initMetalResourceIndexOffsets(&_mtlResourceIndexOffsets.stages[i],
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm b/MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm
index 58647c0..e697ab8 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm
@@ -221,6 +221,7 @@
 		return VK_ERROR_FORMAT_NOT_SUPPORTED;
 	}
 
+	MVKFormatType mvkFmt = mvkFormatTypeFromVkFormat(format);
 	bool hasAttachmentUsage = mvkIsAnyFlagEnabled(usage, (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
 														  VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
 														  VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
@@ -241,8 +242,7 @@
 			if (tiling == VK_IMAGE_TILING_LINEAR) { return VK_ERROR_FORMAT_NOT_SUPPORTED; }
 
 			// Metal does not allow compressed or depth/stencil formats on 1D textures
-			if (mvkFormatTypeFromVkFormat(format) == kMVKFormatDepthStencil ||
-				mvkFormatTypeFromVkFormat(format) == kMVKFormatCompressed) {
+			if (mvkFmt == kMVKFormatDepthStencil || mvkFmt == kMVKFormatCompressed) {
 				return VK_ERROR_FORMAT_NOT_SUPPORTED;
 			}
             maxExt.width = pLimits->maxImageDimension1D;
@@ -263,8 +263,7 @@
 			if (tiling == VK_IMAGE_TILING_LINEAR) {
 				// Linear textures have additional restrictions under Metal:
 				// - They may not be depth/stencil or compressed textures.
-				if (mvkFormatTypeFromVkFormat(format) == kMVKFormatDepthStencil ||
-					mvkFormatTypeFromVkFormat(format) == kMVKFormatCompressed) {
+				if (mvkFmt == kMVKFormatDepthStencil || mvkFmt == kMVKFormatCompressed) {
 					return VK_ERROR_FORMAT_NOT_SUPPORTED;
 				}
 #if MVK_MACOS
@@ -281,7 +280,7 @@
 				// Compressed multisampled textures aren't supported.
 				// Multisampled cube textures aren't supported.
 				// Non-renderable multisampled textures aren't supported.
-				if (mvkFormatTypeFromVkFormat(format) == kMVKFormatCompressed ||
+				if (mvkFmt == kMVKFormatCompressed ||
 					mvkIsAnyFlagEnabled(flags, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) ||
 					!mvkIsAnyFlagEnabled(fmtProps.optimalTilingFeatures, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT|VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) ) {
 					sampleCounts = VK_SAMPLE_COUNT_1_BIT;
@@ -295,18 +294,17 @@
                 return VK_ERROR_FORMAT_NOT_SUPPORTED;
             }
 			// Metal does not allow compressed or depth/stencil formats on 3D textures
-			if (mvkFormatTypeFromVkFormat(format) == kMVKFormatDepthStencil
+			if (mvkFmt == kMVKFormatDepthStencil
 #if MVK_IOS
-				|| mvkFormatTypeFromVkFormat(format) == kMVKFormatCompressed
+				|| mvkFmt == kMVKFormatCompressed
 #endif
 				) {
 				return VK_ERROR_FORMAT_NOT_SUPPORTED;
 			}
 #if MVK_MACOS
-			if (mvkFormatTypeFromVkFormat(format) == kMVKFormatCompressed) {
-				// If this is a compressed format and there's no codec, it isn't
-				// supported.
-				if (!mvkCanDecodeFormat(format) ) { return VK_ERROR_FORMAT_NOT_SUPPORTED; }
+			// If this is a compressed format and there's no codec, it isn't supported.
+			if ((mvkFmt == kMVKFormatCompressed) && !mvkCanDecodeFormat(format)) {
+				return VK_ERROR_FORMAT_NOT_SUPPORTED;
 			}
 #endif
             maxExt.width = pLimits->maxImageDimension3D;
@@ -321,8 +319,7 @@
 			if (tiling == VK_IMAGE_TILING_LINEAR) { return VK_ERROR_FORMAT_NOT_SUPPORTED; }
 
 			// Metal does not allow compressed or depth/stencil formats on anything but 2D textures
-			if (mvkFormatTypeFromVkFormat(format) == kMVKFormatDepthStencil ||
-				mvkFormatTypeFromVkFormat(format) == kMVKFormatCompressed) {
+			if (mvkFmt == kMVKFormatDepthStencil || mvkFmt == kMVKFormatCompressed) {
 				return VK_ERROR_FORMAT_NOT_SUPPORTED;
 			}
             maxExt = { 1, 1, 1};
@@ -1814,7 +1811,7 @@
         // See if this pipeline has a parent. This can come either directly
         // via basePipelineHandle or indirectly via basePipelineIndex.
         MVKPipeline* parentPL = VK_NULL_HANDLE;
-        if ( mvkAreFlagsEnabled(pCreateInfo->flags, VK_PIPELINE_CREATE_DERIVATIVE_BIT) ) {
+        if ( mvkAreAllFlagsEnabled(pCreateInfo->flags, VK_PIPELINE_CREATE_DERIVATIVE_BIT) ) {
             VkPipeline vkParentPL = pCreateInfo->basePipelineHandle;
             int32_t parentPLIdx = pCreateInfo->basePipelineIndex;
             if ( !vkParentPL && (parentPLIdx >= 0)) { vkParentPL = pPipelines[parentPLIdx]; }
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKImage.h b/MoltenVK/MoltenVK/GPUObjects/MVKImage.h
index db47a1d..7403d03 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKImage.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKImage.h
@@ -61,6 +61,9 @@
     /** Returns the Vulkan image format of this image. */
     VkFormat getVkFormat();
 
+	/** Returns whether this texture is compressed. */
+	bool getIsCompressed();
+
 	/** 
 	 * Returns the 3D extent of this image at the base mipmap level.
 	 * For 2D or cube images, the Z component will be 1.  
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm b/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm
index cc977a5..c08c036 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm
@@ -41,6 +41,10 @@
 
 VkFormat MVKImage::getVkFormat() { return mvkVkFormatFromMTLPixelFormat(_mtlPixelFormat); }
 
+bool MVKImage::getIsCompressed() {
+	return mvkFormatTypeFromMTLPixelFormat(_mtlPixelFormat) == kMVKFormatCompressed;
+}
+
 VkExtent3D MVKImage::getExtent3D(uint32_t mipLevel) {
 	return mvkMipmapLevelSizeFromBaseSize3D(_extent, mipLevel);
 }
@@ -163,7 +167,7 @@
 #endif
 #if MVK_IOS
 	// Only transient attachments may use memoryless storage
-	if (!mvkAreFlagsEnabled(_usage, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) ) {
+	if (!mvkAreAllFlagsEnabled(_usage, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) ) {
 		mvkDisableFlag(pMemoryRequirements->memoryTypeBits, _device->getPhysicalDevice()->getLazilyAllocatedMemoryTypes());
 	}
 #endif
@@ -373,16 +377,15 @@
 }
 
 MTLTextureUsage MVKImage::getMTLTextureUsage() {
+
 	MTLTextureUsage usage = mvkMTLTextureUsageFromVkImageUsageFlags(_usage);
 
-	// If this is a depth/stencil texture, and the device supports it, tell
-	// Metal we may create texture views of this, too.
-	if ((_mtlPixelFormat == MTLPixelFormatDepth32Float_Stencil8
-#if MVK_MACOS
-		 || _mtlPixelFormat == MTLPixelFormatDepth24Unorm_Stencil8
-#endif
-		) && _device->_pMetalFeatures->stencilViews) {
-		mvkEnableFlag(usage, MTLTextureUsagePixelFormatView);
+	// Remove view usage from D/S if Metal doesn't support it
+	if ( !_device->_pMetalFeatures->stencilViews &&
+		mvkMTLPixelFormatIsDepthFormat(_mtlPixelFormat) &&
+		mvkMTLPixelFormatIsStencilFormat(_mtlPixelFormat)) {
+
+		mvkDisableFlag(usage, MTLTextureUsagePixelFormatView);
 	}
 
 	// If this format doesn't support being blitted to, and the usage
@@ -390,7 +393,7 @@
 	// MTLTextureUsageRenderTarget.
 	VkFormatProperties props;
 	_device->getPhysicalDevice()->getFormatProperties(getVkFormat(), &props);
-	if (!mvkAreFlagsEnabled(_isLinear ? props.linearTilingFeatures : props.optimalTilingFeatures, VK_FORMAT_FEATURE_BLIT_DST_BIT) &&
+	if (!mvkAreAllFlagsEnabled(_isLinear ? props.linearTilingFeatures : props.optimalTilingFeatures, VK_FORMAT_FEATURE_BLIT_DST_BIT) &&
 		!mvkIsAnyFlagEnabled(_usage, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
 		mvkDisableFlag(usage, MTLTextureUsageRenderTarget);
 	}
@@ -579,8 +582,8 @@
 	_usage = pCreateInfo->usage;
 
 	_is3DCompressed = (pCreateInfo->imageType == VK_IMAGE_TYPE_3D) && (mvkFormatTypeFromVkFormat(pCreateInfo->format) == kMVKFormatCompressed);
-	_isDepthStencilAttachment = (mvkAreFlagsEnabled(pCreateInfo->usage, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ||
-								 mvkAreFlagsEnabled(mvkVkFormatProperties(pCreateInfo->format).optimalTilingFeatures, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT));
+	_isDepthStencilAttachment = (mvkAreAllFlagsEnabled(pCreateInfo->usage, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ||
+								 mvkAreAllFlagsEnabled(mvkVkFormatProperties(pCreateInfo->format).optimalTilingFeatures, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT));
 	_canSupportMTLTextureView = !_isDepthStencilAttachment || _device->_pMetalFeatures->stencilViews;
 	_hasExpectedTexelSize = (mvkMTLPixelFormatBytesPerBlock(_mtlPixelFormat) == mvkVkFormatBytesPerBlock(pCreateInfo->format));
 
@@ -890,7 +893,7 @@
 		if (pCreateInfo->subresourceRange.layerCount != image->_extent.depth) {
 			reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCreateImageView(): Metal does not fully support views on a subset of a 3D texture.");
 		}
-		if (!mvkAreFlagsEnabled(_usage, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) {
+		if (!mvkAreAllFlagsEnabled(_usage, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) {
 			setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCreateImageView(): 2D views on 3D images are only supported for color attachments."));
 		} else if (mvkIsAnyFlagEnabled(_usage, ~VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) {
 			reportError(VK_ERROR_FEATURE_NOT_PRESENT, "vkCreateImageView(): 2D views on 3D images are only supported for color attachments.");
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
index 237b1b0..d3978df 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
@@ -1309,7 +1309,7 @@
 MVKMTLFunction MVKComputePipeline::getMTLFunction(const VkComputePipelineCreateInfo* pCreateInfo) {
 
     const VkPipelineShaderStageCreateInfo* pSS = &pCreateInfo->stage;
-    if ( !mvkAreFlagsEnabled(pSS->stage, VK_SHADER_STAGE_COMPUTE_BIT) ) { return MVKMTLFunctionNull; }
+    if ( !mvkAreAllFlagsEnabled(pSS->stage, VK_SHADER_STAGE_COMPUTE_BIT) ) { return MVKMTLFunctionNull; }
 
     SPIRVToMSLConversionConfiguration shaderContext;
 	shaderContext.options.entryPointName = pCreateInfo->stage.pName;
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKQueryPool.mm b/MoltenVK/MoltenVK/GPUObjects/MVKQueryPool.mm
index 1b5e77b..0090244 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKQueryPool.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKQueryPool.mm
@@ -71,7 +71,7 @@
 
 	uint32_t endQuery = firstQuery + queryCount;
 
-	if (mvkAreFlagsEnabled(flags, VK_QUERY_RESULT_WAIT_BIT)) {
+	if (mvkAreAllFlagsEnabled(flags, VK_QUERY_RESULT_WAIT_BIT)) {
 		_availabilityBlocker.wait(lock, [this, firstQuery, endQuery]{
 			return areQueriesHostAvailable(firstQuery, endQuery);
 		});
@@ -104,14 +104,14 @@
 VkResult MVKQueryPool::getResult(uint32_t query, void* pQryData, VkQueryResultFlags flags) {
 
 	bool isAvailable = _availability[query] == Available;
-	bool shouldOutput = (isAvailable || mvkAreFlagsEnabled(flags, VK_QUERY_RESULT_PARTIAL_BIT));
-	bool shouldOutput64Bit = mvkAreFlagsEnabled(flags, VK_QUERY_RESULT_64_BIT);
+	bool shouldOutput = (isAvailable || mvkAreAllFlagsEnabled(flags, VK_QUERY_RESULT_PARTIAL_BIT));
+	bool shouldOutput64Bit = mvkAreAllFlagsEnabled(flags, VK_QUERY_RESULT_64_BIT);
 
 	// Output the results of this query
 	if (shouldOutput) { getResult(query, pQryData, shouldOutput64Bit); }
 
 	// If requested, output the availability bit
-	if (mvkAreFlagsEnabled(flags, VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)) {
+	if (mvkAreAllFlagsEnabled(flags, VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)) {
 		if (shouldOutput64Bit) {
 			uintptr_t pAvailability = (uintptr_t)pQryData + (_queryElementCount * sizeof(uint64_t));
 			*(uint64_t*)pAvailability = isAvailable;
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKSwapchain.mm b/MoltenVK/MoltenVK/GPUObjects/MVKSwapchain.mm
index 42a3b8b..992f1cb 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKSwapchain.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKSwapchain.mm
@@ -268,7 +268,7 @@
         .flags = 0,
     };
 
-	if (mvkAreFlagsEnabled(pCreateInfo->flags, VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR)) {
+	if (mvkAreAllFlagsEnabled(pCreateInfo->flags, VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR)) {
 		mvkEnableFlag(imgInfo.flags, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT);
 	}
 
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKSync.h b/MoltenVK/MoltenVK/GPUObjects/MVKSync.h
index 1fa52cf..fa5f647 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKSync.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKSync.h
@@ -197,7 +197,7 @@
 #pragma mark Construction
 
     MVKFence(MVKDevice* device, const VkFenceCreateInfo* pCreateInfo) :
-		MVKVulkanAPIDeviceObject(device), _isSignaled(mvkAreFlagsEnabled(pCreateInfo->flags, VK_FENCE_CREATE_SIGNALED_BIT)) {}
+		MVKVulkanAPIDeviceObject(device), _isSignaled(mvkAreAllFlagsEnabled(pCreateInfo->flags, VK_FENCE_CREATE_SIGNALED_BIT)) {}
 
 protected:
 	void propogateDebugName() override {}
diff --git a/MoltenVK/MoltenVK/Utility/MVKFoundation.h b/MoltenVK/MoltenVK/Utility/MVKFoundation.h
index f6c123b..0fddedd 100644
--- a/MoltenVK/MoltenVK/Utility/MVKFoundation.h
+++ b/MoltenVK/MoltenVK/Utility/MVKFoundation.h
@@ -472,19 +472,19 @@
 template<typename T1, typename T2>
 void mvkDisableFlag(T1& value, const T2 bitMask) { value &= ~bitMask; }
 
-/** Returns whether the specified value has ALL of the flags specified in bitMask enabled (set to 1). */
-template<typename T1, typename T2>
-bool mvkAreFlagsEnabled(T1 value, const T2 bitMask) { return ((value & bitMask) == bitMask); }
-
 /** Returns whether the specified value has ANY of the flags specified in bitMask enabled (set to 1). */
 template<typename T1, typename T2>
 bool mvkIsAnyFlagEnabled(T1 value, const T2 bitMask) { return !!(value & bitMask); }
 
-/** Returns whether the specified value has ONLY ALL of the flags specified in bitMask enabled (set to 1), and none others. */
+/** Returns whether the specified value has ALL of the flags specified in bitMask enabled (set to 1). */
 template<typename T1, typename T2>
-bool mvkAreOnlyAllFlagsEnabled(T1 value, const T2 bitMask) { return (value == bitMask); }
+bool mvkAreAllFlagsEnabled(T1 value, const T2 bitMask) { return ((value & bitMask) == bitMask); }
 
 /** Returns whether the specified value has ONLY one or more of the flags specified in bitMask enabled (set to 1), and none others. */
 template<typename T1, typename T2>
-bool mvkAreOnlyAnyFlagsEnabled(T1 value, const T2 bitMask) { return (mvkIsAnyFlagEnabled(value, bitMask) && ((value | bitMask) == bitMask)); }
+bool mvkIsOnlyAnyFlagEnabled(T1 value, const T2 bitMask) { return (mvkIsAnyFlagEnabled(value, bitMask) && ((value | bitMask) == bitMask)); }
+
+/** Returns whether the specified value has ONLY ALL of the flags specified in bitMask enabled (set to 1), and none others. */
+template<typename T1, typename T2>
+bool mvkAreOnlyAllFlagsEnabled(T1 value, const T2 bitMask) { return (value == bitMask); }
 
diff --git a/MoltenVK/MoltenVK/Vulkan/mvk_datatypes.mm b/MoltenVK/MoltenVK/Vulkan/mvk_datatypes.mm
index 0cdf559..4e4390e 100644
--- a/MoltenVK/MoltenVK/Vulkan/mvk_datatypes.mm
+++ b/MoltenVK/MoltenVK/Vulkan/mvk_datatypes.mm
@@ -809,64 +809,67 @@
 }
 
 MVK_PUBLIC_SYMBOL VkImageType mvkVkImageTypeFromMTLTextureType(MTLTextureType mtlTextureType) {
-    switch (mtlTextureType) {
-        case MTLTextureType1D:          return VK_IMAGE_TYPE_1D;
-        case MTLTextureType1DArray:     return VK_IMAGE_TYPE_1D;
-        case MTLTextureType3D:          return VK_IMAGE_TYPE_3D;
-        default:                        return VK_IMAGE_TYPE_2D;
-    }
+	switch (mtlTextureType) {
+		case MTLTextureType1D:
+		case MTLTextureType1DArray:
+			return VK_IMAGE_TYPE_1D;
+		case MTLTextureType3D:
+			return VK_IMAGE_TYPE_3D;
+		default:
+			return VK_IMAGE_TYPE_2D;
+	}
 }
 
 MVK_PUBLIC_SYMBOL MTLTextureType mvkMTLTextureTypeFromVkImageViewType(VkImageViewType vkImageViewType,
-                                                                      bool isMultisample) {
-    switch (vkImageViewType) {
-        case VK_IMAGE_VIEW_TYPE_1D:             return MTLTextureType1D;
-        case VK_IMAGE_VIEW_TYPE_1D_ARRAY:       return MTLTextureType1DArray;
-        case VK_IMAGE_VIEW_TYPE_2D:             return (isMultisample ? MTLTextureType2DMultisample : MTLTextureType2D);
-        case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
+																	  bool isMultisample) {
+	switch (vkImageViewType) {
+		case VK_IMAGE_VIEW_TYPE_1D:				return MTLTextureType1D;
+		case VK_IMAGE_VIEW_TYPE_1D_ARRAY:		return MTLTextureType1DArray;
+		case VK_IMAGE_VIEW_TYPE_2D:				return (isMultisample ? MTLTextureType2DMultisample : MTLTextureType2D);
+		case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 #if MVK_MACOS
-            if (isMultisample) {
-                return MTLTextureType2DMultisampleArray;
-            }
+			if (isMultisample) { return MTLTextureType2DMultisampleArray; }
 #endif
-            return MTLTextureType2DArray;
-        case VK_IMAGE_VIEW_TYPE_3D:             return MTLTextureType3D;
-        case VK_IMAGE_VIEW_TYPE_CUBE:           return MTLTextureTypeCube;
-        case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:    return MTLTextureTypeCubeArray;
-        default:                            return MTLTextureType2D;
-    }
+			return MTLTextureType2DArray;
+		case VK_IMAGE_VIEW_TYPE_3D:				return MTLTextureType3D;
+		case VK_IMAGE_VIEW_TYPE_CUBE:			return MTLTextureTypeCube;
+		case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:		return MTLTextureTypeCubeArray;
+		default:                            	return MTLTextureType2D;
+	}
 }
 
 MVK_PUBLIC_SYMBOL MTLTextureUsage mvkMTLTextureUsageFromVkImageUsageFlags(VkImageUsageFlags vkImageUsageFlags) {
     MTLTextureUsage mtlUsage = MTLTextureUsageUnknown;
 
-    if ( mvkAreFlagsEnabled(vkImageUsageFlags, VK_IMAGE_USAGE_TRANSFER_SRC_BIT) ) {
-        mvkEnableFlag(mtlUsage, MTLTextureUsageShaderRead);
-    }
-    if ( mvkAreFlagsEnabled(vkImageUsageFlags, VK_IMAGE_USAGE_TRANSFER_DST_BIT) ) {
-        mvkEnableFlag(mtlUsage, MTLTextureUsageRenderTarget);
-    }
-    if ( mvkAreFlagsEnabled(vkImageUsageFlags, VK_IMAGE_USAGE_SAMPLED_BIT) ) {
-        mvkEnableFlag(mtlUsage, MTLTextureUsageShaderRead);
-        mvkEnableFlag(mtlUsage, MTLTextureUsagePixelFormatView);
-    }
-    if ( mvkAreFlagsEnabled(vkImageUsageFlags, VK_IMAGE_USAGE_STORAGE_BIT) ) {
-        mvkEnableFlag(mtlUsage, MTLTextureUsageShaderRead);
-        mvkEnableFlag(mtlUsage, MTLTextureUsageShaderWrite);
-        mvkEnableFlag(mtlUsage, MTLTextureUsagePixelFormatView);
-    }
-    if ( mvkAreFlagsEnabled(vkImageUsageFlags, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) ) {
-        mvkEnableFlag(mtlUsage, MTLTextureUsageShaderRead);
-        mvkEnableFlag(mtlUsage, MTLTextureUsagePixelFormatView);
-    }
-    if ( mvkAreFlagsEnabled(vkImageUsageFlags, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) ) {
-        mvkEnableFlag(mtlUsage, MTLTextureUsageRenderTarget);
-        mvkEnableFlag(mtlUsage, MTLTextureUsagePixelFormatView);
-    }
-    if ( mvkAreFlagsEnabled(vkImageUsageFlags, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ) {
-        mvkEnableFlag(mtlUsage, MTLTextureUsageRenderTarget);
-        mvkDisableFlag(mtlUsage, MTLTextureUsagePixelFormatView);        // Clears bit. Do this last.
-    }
+	// Read from...
+	if (mvkIsAnyFlagEnabled(vkImageUsageFlags, (VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+												VK_IMAGE_USAGE_SAMPLED_BIT |
+												VK_IMAGE_USAGE_STORAGE_BIT |
+												VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT))) {
+		mvkEnableFlag(mtlUsage, MTLTextureUsageShaderRead);
+	}
+
+	// Write to...
+	if (mvkIsAnyFlagEnabled(vkImageUsageFlags, (VK_IMAGE_USAGE_STORAGE_BIT))) {
+		mvkEnableFlag(mtlUsage, MTLTextureUsageShaderWrite);
+	}
+
+	// Render to...
+	if (mvkIsAnyFlagEnabled(vkImageUsageFlags, (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+												VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
+												VK_IMAGE_USAGE_TRANSFER_DST_BIT))) {				// Scaling a BLIT may use rendering.
+		mvkEnableFlag(mtlUsage, MTLTextureUsageRenderTarget);
+	}
+
+	// Create view on...
+	if (mvkIsAnyFlagEnabled(vkImageUsageFlags, (VK_IMAGE_USAGE_TRANSFER_SRC_BIT |	 				// May use temp view if transfer involves format change
+												VK_IMAGE_USAGE_SAMPLED_BIT |
+												VK_IMAGE_USAGE_STORAGE_BIT |
+												VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
+												VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+												VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT))) {	// D/S may be filtered out after device check
+		mvkEnableFlag(mtlUsage, MTLTextureUsagePixelFormatView);
+	}
 
     return mtlUsage;
 }
@@ -874,12 +877,12 @@
 MVK_PUBLIC_SYMBOL VkImageUsageFlags mvkVkImageUsageFlagsFromMTLTextureUsage(MTLTextureUsage mtlUsage, MTLPixelFormat mtlFormat) {
     VkImageUsageFlags vkImageUsageFlags = 0;
 
-    if ( mvkAreFlagsEnabled(mtlUsage, MTLTextureUsageShaderRead) ) {
+    if ( mvkAreAllFlagsEnabled(mtlUsage, MTLTextureUsageShaderRead) ) {
         mvkEnableFlag(vkImageUsageFlags, VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
         mvkEnableFlag(vkImageUsageFlags, VK_IMAGE_USAGE_SAMPLED_BIT);
         mvkEnableFlag(vkImageUsageFlags, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT);
     }
-    if ( mvkAreFlagsEnabled(mtlUsage, MTLTextureUsageRenderTarget) ) {
+    if ( mvkAreAllFlagsEnabled(mtlUsage, MTLTextureUsageRenderTarget) ) {
         mvkEnableFlag(vkImageUsageFlags, VK_IMAGE_USAGE_TRANSFER_DST_BIT);
         if (mvkMTLPixelFormatIsDepthFormat(mtlFormat) || mvkMTLPixelFormatIsStencilFormat(mtlFormat)) {
             mvkEnableFlag(vkImageUsageFlags, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
@@ -887,7 +890,7 @@
             mvkEnableFlag(vkImageUsageFlags, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
         }
     }
-    if ( mvkAreFlagsEnabled(mtlUsage, MTLTextureUsageShaderWrite) ) {
+    if ( mvkAreAllFlagsEnabled(mtlUsage, MTLTextureUsageShaderWrite) ) {
         mvkEnableFlag(vkImageUsageFlags, VK_IMAGE_USAGE_STORAGE_BIT);
     }
 
@@ -1003,10 +1006,10 @@
 
 MVK_PUBLIC_SYMBOL MTLColorWriteMask mvkMTLColorWriteMaskFromVkChannelFlags(VkColorComponentFlags vkWriteFlags) {
 	MTLColorWriteMask mtlWriteMask = MTLColorWriteMaskNone;
-	if (mvkAreFlagsEnabled(vkWriteFlags, VK_COLOR_COMPONENT_R_BIT)) { mvkEnableFlag(mtlWriteMask, MTLColorWriteMaskRed); }
-	if (mvkAreFlagsEnabled(vkWriteFlags, VK_COLOR_COMPONENT_G_BIT)) { mvkEnableFlag(mtlWriteMask, MTLColorWriteMaskGreen); }
-	if (mvkAreFlagsEnabled(vkWriteFlags, VK_COLOR_COMPONENT_B_BIT)) { mvkEnableFlag(mtlWriteMask, MTLColorWriteMaskBlue); }
-	if (mvkAreFlagsEnabled(vkWriteFlags, VK_COLOR_COMPONENT_A_BIT)) { mvkEnableFlag(mtlWriteMask, MTLColorWriteMaskAlpha); }
+	if (mvkAreAllFlagsEnabled(vkWriteFlags, VK_COLOR_COMPONENT_R_BIT)) { mvkEnableFlag(mtlWriteMask, MTLColorWriteMaskRed); }
+	if (mvkAreAllFlagsEnabled(vkWriteFlags, VK_COLOR_COMPONENT_G_BIT)) { mvkEnableFlag(mtlWriteMask, MTLColorWriteMaskGreen); }
+	if (mvkAreAllFlagsEnabled(vkWriteFlags, VK_COLOR_COMPONENT_B_BIT)) { mvkEnableFlag(mtlWriteMask, MTLColorWriteMaskBlue); }
+	if (mvkAreAllFlagsEnabled(vkWriteFlags, VK_COLOR_COMPONENT_A_BIT)) { mvkEnableFlag(mtlWriteMask, MTLColorWriteMaskAlpha); }
 	return mtlWriteMask;
 }
 
@@ -1325,14 +1328,14 @@
 	// barrier is to be placed before the render stages, it should come before the vertex stage, otherwise
 	// if the barrier is to be placed after the render stages, it should come after the fragment stage.
 	if (placeBarrierBefore) {
-		bool placeBeforeFragment = mvkAreOnlyAnyFlagsEnabled(vkStages, (VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+		bool placeBeforeFragment = mvkIsOnlyAnyFlagEnabled(vkStages, (VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
 																		VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
 																		VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
 																		VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
 																		VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT));
 		return placeBeforeFragment ? MTLRenderStageFragment : MTLRenderStageVertex;
 	} else {
-		bool placeAfterVertex = mvkAreOnlyAnyFlagsEnabled(vkStages, (VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT |
+		bool placeAfterVertex = mvkIsOnlyAnyFlagEnabled(vkStages, (VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT |
 																	 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT |
 																	 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT |
 																	 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
@@ -1365,10 +1368,10 @@
 MVK_PUBLIC_SYMBOL MTLStorageMode mvkMTLStorageModeFromVkMemoryPropertyFlags(VkMemoryPropertyFlags vkFlags) {
 
 	// If not visible to the host: Private
-	if ( !mvkAreFlagsEnabled(vkFlags, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) ) {
+	if ( !mvkAreAllFlagsEnabled(vkFlags, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) ) {
 #if MVK_IOS
 		// iOS: If lazily allocated, Memoryless
-		if (mvkAreFlagsEnabled(vkFlags, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)) {
+		if (mvkAreAllFlagsEnabled(vkFlags, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)) {
 			return MTLStorageModeMemoryless;
 		}
 #endif
@@ -1376,7 +1379,7 @@
 	}
 
 	// If visible to the host and coherent: Shared
-	if (mvkAreFlagsEnabled(vkFlags, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
+	if (mvkAreAllFlagsEnabled(vkFlags, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
 		return MTLStorageModeShared;
 	}