From 3fabf9547b3e2113a74936b196c69f101ce0851b Mon Sep 17 00:00:00 2001 From: Gabor Abraham Date: Wed, 25 May 2016 17:15:44 +0200 Subject: [PATCH] Add OpImageSparse* instruction tests --- .../vulkan/shaderrender/vktShaderRender.cpp | 725 +++++- .../vulkan/shaderrender/vktShaderRender.hpp | 52 +- .../vktShaderRenderTextureFunctionTests.cpp | 306 ++- .../vktShaderRenderTextureGatherTests.cpp | 159 +- .../mustpass/1.0.1/com.drawelements.deqp.vk.xml | 2475 +++++++++++++++++++- .../mustpass/1.0.1/src/excluded-tests.txt | 188 ++ external/vulkancts/mustpass/1.0.1/vk-default.txt | 823 +++++++ 7 files changed, 4617 insertions(+), 111 deletions(-) diff --git a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp index 6c5eced..4abd838 100644 --- a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp +++ b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp @@ -544,6 +544,7 @@ ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context& context) , m_evaluator (DE_NULL) , m_uniformSetup (DE_NULL) , m_attribFunc (DE_NULL) + , m_sparseContext (createSparseContext()) , m_sampleCount (VK_SAMPLE_COUNT_1_BIT) { } @@ -553,7 +554,8 @@ ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context& context, const bool isVertexCase, const ShaderEvaluator& evaluator, const UniformSetup& uniformSetup, - const AttributeSetupFunc attribFunc) + const AttributeSetupFunc attribFunc, + const ImageBackingMode imageBackingMode) : vkt::TestInstance (context) , m_memAlloc (context.getDefaultAllocator()) , m_clearColor (DEFAULT_CLEAR_COLOR) @@ -562,9 +564,11 @@ ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context& context, , m_fragmentShaderName ("frag") , m_renderSize (128, 128) , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM) + , m_imageBackingMode (imageBackingMode) , m_evaluator (&evaluator) , m_uniformSetup (&uniformSetup) , m_attribFunc (attribFunc) + , m_sparseContext (createSparseContext()) , m_sampleCount (VK_SAMPLE_COUNT_1_BIT) { } @@ -573,7 +577,8 @@ ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context& context, const bool isVertexCase, const ShaderEvaluator* evaluator, const UniformSetup* uniformSetup, - const AttributeSetupFunc attribFunc) + const AttributeSetupFunc attribFunc, + const ImageBackingMode imageBackingMode) : vkt::TestInstance (context) , m_memAlloc (context.getDefaultAllocator()) , m_clearColor (DEFAULT_CLEAR_COLOR) @@ -582,17 +587,118 @@ ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context& context, , m_fragmentShaderName ("frag") , m_renderSize (128, 128) , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM) + , m_imageBackingMode (imageBackingMode) , m_evaluator (evaluator) , m_uniformSetup (uniformSetup) , m_attribFunc (attribFunc) + , m_sparseContext (createSparseContext()) , m_sampleCount (VK_SAMPLE_COUNT_1_BIT) { } +static deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps) +{ + const std::vector queueProps = getPhysicalDeviceQueueFamilyProperties(vkInstance, physicalDevice); + + for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++) + { + if ((queueProps[queueNdx].queueFlags & requiredCaps) == requiredCaps) + return (deUint32)queueNdx; + } + + TCU_THROW(NotSupportedError, "No matching queue found"); +} + +ShaderRenderCaseInstance::SparseContext* ShaderRenderCaseInstance::createSparseContext (void) const +{ + if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE) + { + const InstanceInterface& vk = getInstanceInterface(); + const VkPhysicalDevice physicalDevice = getPhysicalDevice(); + const VkPhysicalDeviceFeatures deviceFeatures = getPhysicalDeviceFeatures(vk, physicalDevice); + + const deUint32 queueIndex = findQueueFamilyIndexWithCaps(vk, physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_SPARSE_BINDING_BIT); + + VkDeviceQueueCreateInfo queueInfo; + VkDeviceCreateInfo deviceInfo; + const float queuePriority = 1.0f; + + deMemset(&queueInfo, 0, sizeof(queueInfo)); + deMemset(&deviceInfo, 0, sizeof(deviceInfo)); + + queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + queueInfo.pNext = DE_NULL; + queueInfo.flags = (VkDeviceQueueCreateFlags)0u; + queueInfo.queueFamilyIndex = queueIndex; + queueInfo.queueCount = 1u; + queueInfo.pQueuePriorities = &queuePriority; + + deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + deviceInfo.pNext = DE_NULL; + deviceInfo.queueCreateInfoCount = 1u; + deviceInfo.pQueueCreateInfos = &queueInfo; + deviceInfo.enabledExtensionCount = 0u; + deviceInfo.ppEnabledExtensionNames = DE_NULL; + deviceInfo.enabledLayerCount = 0u; + deviceInfo.ppEnabledLayerNames = DE_NULL; + deviceInfo.pEnabledFeatures = &deviceFeatures; + + Move device = createDevice(vk, physicalDevice, &deviceInfo); + + return new SparseContext(device, queueIndex, vk); + } + + return DE_NULL; +} + ShaderRenderCaseInstance::~ShaderRenderCaseInstance (void) { } +VkDevice ShaderRenderCaseInstance::getDevice (void) const +{ + if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE) + return *m_sparseContext->m_device; + + return m_context.getDevice(); +} + +deUint32 ShaderRenderCaseInstance::getUniversalQueueFamilyIndex (void) const +{ + if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE) + return m_sparseContext->m_universalQueueFamilyIndex; + + return m_context.getUniversalQueueFamilyIndex(); +} + +const DeviceInterface& ShaderRenderCaseInstance::getDeviceInterface (void) const +{ + if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE) + return m_sparseContext->m_deviceInterface; + + return m_context.getDeviceInterface(); +} + +VkQueue ShaderRenderCaseInstance::getUniversalQueue (void) const +{ + if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE) + return m_sparseContext->m_queue; + + return m_context.getUniversalQueue(); +} + +VkPhysicalDevice ShaderRenderCaseInstance::getPhysicalDevice (void) const +{ + // Same in sparse and regular case + return m_context.getPhysicalDevice(); +} + +const InstanceInterface& ShaderRenderCaseInstance::getInstanceInterface (void) const +{ + // Same in sparse and regular case + return m_context.getInstanceInterface(); +} + tcu::TestStatus ShaderRenderCaseInstance::iterate (void) { setup(); @@ -642,9 +748,9 @@ void ShaderRenderCaseInstance::setup (void) void ShaderRenderCaseInstance::setupUniformData (deUint32 bindingLocation, size_t size, const void* dataPtr) { - const VkDevice vkDevice = m_context.getDevice(); - const DeviceInterface& vk = m_context.getDeviceInterface(); - const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); + const VkDevice vkDevice = getDevice(); + const DeviceInterface& vk = getDeviceInterface(); + const deUint32 queueFamilyIndex = getUniversalQueueFamilyIndex(); const VkBufferCreateInfo uniformBufferParams = { @@ -712,9 +818,9 @@ void ShaderRenderCaseInstance::addAttribute (deUint32 bindingLocation, m_vertexAttributeDescription.push_back(attributeDescription); // Upload data to buffer - const VkDevice vkDevice = m_context.getDevice(); - const DeviceInterface& vk = m_context.getDeviceInterface(); - const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); + const VkDevice vkDevice = getDevice(); + const DeviceInterface& vk = getDeviceInterface(); + const deUint32 queueFamilyIndex = getUniversalQueueFamilyIndex(); const VkDeviceSize inputSize = sizePerElement * count; const VkBufferCreateInfo vertexBufferParams = @@ -890,10 +996,10 @@ void ShaderRenderCaseInstance::uploadImage (const tcu::TextureFormat& texForma deUint32 arrayLayers, VkImage destImage) { - const VkDevice vkDevice = m_context.getDevice(); - const DeviceInterface& vk = m_context.getDeviceInterface(); - const VkQueue queue = m_context.getUniversalQueue(); - const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); + const VkDevice vkDevice = getDevice(); + const DeviceInterface& vk = getDeviceInterface(); + const VkQueue queue = getUniversalQueue(); + const deUint32 queueFamilyIndex = getUniversalQueueFamilyIndex(); const bool isShadowSampler = refSampler.compare != tcu::Sampler::COMPAREMODE_NONE; const VkImageAspectFlags aspectMask = isShadowSampler ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT; @@ -1107,6 +1213,506 @@ void ShaderRenderCaseInstance::uploadImage (const tcu::TextureFormat& texForma VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity */)); } +// Sparse utility function +Move makeSemaphore (const DeviceInterface& vk, const VkDevice device) +{ + const VkSemaphoreCreateInfo semaphoreCreateInfo = + { + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, + DE_NULL, + 0u + }; + + return createSemaphore(vk, device, &semaphoreCreateInfo); +} + +VkExtent3D mipLevelExtents (const VkExtent3D& baseExtents, const deUint32 mipLevel) +{ + VkExtent3D result; + + result.width = std::max(baseExtents.width >> mipLevel, 1u); + result.height = std::max(baseExtents.height >> mipLevel, 1u); + result.depth = std::max(baseExtents.depth >> mipLevel, 1u); + + return result; +} + +tcu::UVec3 alignedDivide (const VkExtent3D& extent, const VkExtent3D& divisor) +{ + tcu::UVec3 result; + + result.x() = extent.width / divisor.width + ((extent.width % divisor.width != 0) ? 1u : 0u); + result.y() = extent.height / divisor.height + ((extent.height % divisor.height != 0) ? 1u : 0u); + result.z() = extent.depth / divisor.depth + ((extent.depth % divisor.depth != 0) ? 1u : 0u); + + return result; +} + +bool isImageSizeSupported (const VkImageType imageType, const tcu::UVec3& imageSize, const vk::VkPhysicalDeviceLimits& limits) +{ + switch (imageType) + { + case VK_IMAGE_TYPE_1D: + return (imageSize.x() <= limits.maxImageDimension1D + && imageSize.y() == 1 + && imageSize.z() == 1); + case VK_IMAGE_TYPE_2D: + return (imageSize.x() <= limits.maxImageDimension2D + && imageSize.y() <= limits.maxImageDimension2D + && imageSize.z() == 1); + case VK_IMAGE_TYPE_3D: + return (imageSize.x() <= limits.maxImageDimension3D + && imageSize.y() <= limits.maxImageDimension3D + && imageSize.z() <= limits.maxImageDimension3D); + default: + DE_FATAL("Unknown image type"); + return false; + } +} + +void ShaderRenderCaseInstance::checkSparseSupport (const VkImageType imageType) const +{ + const InstanceInterface& instance = getInstanceInterface(); + const VkPhysicalDevice physicalDevice = getPhysicalDevice(); + const VkPhysicalDeviceFeatures deviceFeatures = getPhysicalDeviceFeatures(instance, physicalDevice); + + if (!deviceFeatures.shaderResourceResidency) + TCU_THROW(NotSupportedError, "Required feature: shaderResourceResidency."); + + if (!deviceFeatures.sparseBinding) + TCU_THROW(NotSupportedError, "Required feature: sparseBinding."); + + if (imageType == VK_IMAGE_TYPE_2D && !deviceFeatures.sparseResidencyImage2D) + TCU_THROW(NotSupportedError, "Required feature: sparseResidencyImage2D."); + + if (imageType == VK_IMAGE_TYPE_3D && !deviceFeatures.sparseResidencyImage3D) + TCU_THROW(NotSupportedError, "Required feature: sparseResidencyImage3D."); +} + +void ShaderRenderCaseInstance::uploadSparseImage (const tcu::TextureFormat& texFormat, + const TextureData& textureData, + const tcu::Sampler& refSampler, + const deUint32 mipLevels, + const deUint32 arrayLayers, + const VkImage sparseImage, + const VkImageCreateInfo& imageCreateInfo, + const tcu::UVec3 texSize) +{ + const VkDevice vkDevice = getDevice(); + const DeviceInterface& vk = getDeviceInterface(); + const VkPhysicalDevice physicalDevice = getPhysicalDevice(); + const VkQueue queue = getUniversalQueue(); + const deUint32 queueFamilyIndex = getUniversalQueueFamilyIndex(); + const InstanceInterface& instance = getInstanceInterface(); + const VkPhysicalDeviceProperties deviceProperties = getPhysicalDeviceProperties(instance, physicalDevice); + const VkPhysicalDeviceMemoryProperties deviceMemoryProperties = getPhysicalDeviceMemoryProperties(instance, physicalDevice); + const bool isShadowSampler = refSampler.compare != tcu::Sampler::COMPAREMODE_NONE; + const VkImageAspectFlags aspectMask = isShadowSampler ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT; + + const Unique imageMemoryBindSemaphore(makeSemaphore(vk, vkDevice)); + deUint32 bufferSize = 0u; + std::vector offsetMultiples; + offsetMultiples.push_back(4u); + offsetMultiples.push_back(texFormat.getPixelSize()); + + if (isImageSizeSupported(imageCreateInfo.imageType, texSize, deviceProperties.limits) == false) + TCU_THROW(NotSupportedError, "Image size not supported for device."); + + // Calculate buffer size + for (TextureData::const_iterator mit = textureData.begin(); mit != textureData.end(); ++mit) + { + for (TextureLayerData::const_iterator lit = mit->begin(); lit != mit->end(); ++lit) + { + const tcu::ConstPixelBufferAccess& access = *lit; + + bufferSize = getNextMultiple(offsetMultiples, bufferSize); + bufferSize += access.getWidth() * access.getHeight() * access.getDepth() * access.getFormat().getPixelSize(); + } + } + + { + deUint32 sparseMemoryReqCount = 0; + + vk.getImageSparseMemoryRequirements(vkDevice, sparseImage, &sparseMemoryReqCount, DE_NULL); + + DE_ASSERT(sparseMemoryReqCount != 0); + + std::vector sparseImageMemoryRequirements; + sparseImageMemoryRequirements.resize(sparseMemoryReqCount); + + vk.getImageSparseMemoryRequirements(vkDevice, sparseImage, &sparseMemoryReqCount, &sparseImageMemoryRequirements[0]); + + const deUint32 noMatchFound = ~((deUint32)0); + + deUint32 colorAspectIndex = noMatchFound; + for (deUint32 memoryReqNdx = 0; memoryReqNdx < sparseMemoryReqCount; ++memoryReqNdx) + { + if (sparseImageMemoryRequirements[memoryReqNdx].formatProperties.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) + { + colorAspectIndex = memoryReqNdx; + break; + } + } + + if (colorAspectIndex == noMatchFound) + TCU_THROW(NotSupportedError, "Not supported image aspect - the test supports currently only VK_IMAGE_ASPECT_COLOR_BIT."); + + const VkMemoryRequirements memoryRequirements = getImageMemoryRequirements(vk, vkDevice, sparseImage); + + deUint32 memoryType = noMatchFound; + for (deUint32 memoryTypeNdx = 0; memoryTypeNdx < deviceMemoryProperties.memoryTypeCount; ++memoryTypeNdx) + { + if ((memoryRequirements.memoryTypeBits & (1u << memoryTypeNdx)) != 0 && + MemoryRequirement::Any.matchesHeap(deviceMemoryProperties.memoryTypes[memoryTypeNdx].propertyFlags)) + { + memoryType = memoryTypeNdx; + break; + } + } + + if (memoryType == noMatchFound) + TCU_THROW(NotSupportedError, "No matching memory type found."); + + if (memoryRequirements.size > deviceProperties.limits.sparseAddressSpaceSize) + TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits."); + + // Check if the image format supports sparse oprerations + const std::vector sparseImageFormatPropVec = + getPhysicalDeviceSparseImageFormatProperties(instance, physicalDevice, imageCreateInfo.format, imageCreateInfo.imageType, imageCreateInfo.samples, imageCreateInfo.usage, imageCreateInfo.tiling); + + if (sparseImageFormatPropVec.size() == 0) + TCU_THROW(NotSupportedError, "The image format does not support sparse operations."); + + const VkSparseImageMemoryRequirements aspectRequirements = sparseImageMemoryRequirements[colorAspectIndex]; + const VkExtent3D imageGranularity = aspectRequirements.formatProperties.imageGranularity; + + std::vector imageResidencyMemoryBinds; + std::vector imageMipTailMemoryBinds; + std::vector< de::SharedPtr > allocations; + + for (deUint32 layerNdx = 0; layerNdx < arrayLayers; ++ layerNdx) + { + for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx) + { + const VkExtent3D mipExtent = mipLevelExtents(imageCreateInfo.extent, mipLevelNdx); + const tcu::UVec3 numSparseBinds = alignedDivide(mipExtent, imageGranularity); + const tcu::UVec3 lastBlockExtent = tcu::UVec3(mipExtent.width % imageGranularity.width ? mipExtent.width % imageGranularity.width : imageGranularity.width, + mipExtent.height % imageGranularity.height ? mipExtent.height % imageGranularity.height : imageGranularity.height, + mipExtent.depth % imageGranularity.depth ? mipExtent.depth % imageGranularity.depth : imageGranularity.depth ); + + for (deUint32 z = 0; z < numSparseBinds.z(); ++z) + for (deUint32 y = 0; y < numSparseBinds.y(); ++y) + for (deUint32 x = 0; x < numSparseBinds.x(); ++x) + { + const deUint32 linearIndex = x + y*numSparseBinds.x() + z*numSparseBinds.x()*numSparseBinds.y() + layerNdx*numSparseBinds.x()*numSparseBinds.y()*numSparseBinds.z(); + + if (linearIndex % 2 == 1) + { + continue; + } + + const VkMemoryRequirements allocRequirements = + { + // 28.7.5 alignment shows the block size in bytes + memoryRequirements.alignment, // VkDeviceSize size; + memoryRequirements.alignment, // VkDeviceSize alignment; + memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits; + }; + + de::SharedPtr allocation(m_memAlloc.allocate(allocRequirements, MemoryRequirement::Any).release()); + + allocations.push_back(allocation); + + VkOffset3D offset; + offset.x = x*imageGranularity.width; + offset.y = y*imageGranularity.height; + offset.z = z*imageGranularity.depth; + + VkExtent3D extent; + extent.width = (x == numSparseBinds.x() - 1) ? lastBlockExtent.x() : imageGranularity.width; + extent.height = (y == numSparseBinds.y() - 1) ? lastBlockExtent.y() : imageGranularity.height; + extent.depth = (z == numSparseBinds.z() - 1) ? lastBlockExtent.z() : imageGranularity.depth; + + const VkSparseImageMemoryBind imageMemoryBind = + { + { + aspectMask, // VkImageAspectFlags aspectMask; + mipLevelNdx,// uint32_t mipLevel; + layerNdx, // uint32_t arrayLayer; + }, // VkImageSubresource subresource; + offset, // VkOffset3D offset; + extent, // VkExtent3D extent; + allocation->getMemory(), // VkDeviceMemory memory; + allocation->getOffset(), // VkDeviceSize memoryOffset; + 0u, // VkSparseMemoryBindFlags flags; + }; + + imageResidencyMemoryBinds.push_back(imageMemoryBind); + } + } + + // Handle MIP tail for each layer + { + const VkMemoryRequirements allocRequirements = + { + aspectRequirements.imageMipTailSize, // VkDeviceSize size; + memoryRequirements.alignment, // VkDeviceSize alignment; + memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits; + }; + + const de::SharedPtr allocation(m_memAlloc.allocate(allocRequirements, MemoryRequirement::Any).release()); + + const VkSparseMemoryBind imageMipTailMemoryBind = + { + aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride, // VkDeviceSize resourceOffset; + aspectRequirements.imageMipTailSize, // VkDeviceSize size; + allocation->getMemory(), // VkDeviceMemory memory; + allocation->getOffset(), // VkDeviceSize memoryOffset; + 0u, // VkSparseMemoryBindFlags flags; + }; + + allocations.push_back(allocation); + imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind); + } + } + + VkBindSparseInfo bindSparseInfo = + { + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType; + DE_NULL, //const void* pNext; + 0u, //deUint32 waitSemaphoreCount; + DE_NULL, //const VkSemaphore* pWaitSemaphores; + 0u, //deUint32 bufferBindCount; + DE_NULL, //const VkSparseBufferMemoryBindInfo* pBufferBinds; + 0u, //deUint32 imageOpaqueBindCount; + DE_NULL, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + 0u, //deUint32 imageBindCount; + DE_NULL, //const VkSparseImageMemoryBindInfo* pImageBinds; + 1u, //deUint32 signalSemaphoreCount; + &imageMemoryBindSemaphore.get() //const VkSemaphore* pSignalSemaphores; + }; + + VkSparseImageMemoryBindInfo imageResidencyBindInfo; + VkSparseImageOpaqueMemoryBindInfo imageMipTailBindInfo; + + if (imageResidencyMemoryBinds.size() > 0) + { + imageResidencyBindInfo.image = sparseImage; + imageResidencyBindInfo.bindCount = static_cast(imageResidencyMemoryBinds.size()); + imageResidencyBindInfo.pBinds = &imageResidencyMemoryBinds[0]; + + bindSparseInfo.imageBindCount = 1u; + bindSparseInfo.pImageBinds = &imageResidencyBindInfo; + } + + if (imageMipTailMemoryBinds.size() > 0) + { + imageMipTailBindInfo.image = sparseImage; + imageMipTailBindInfo.bindCount = static_cast(imageMipTailMemoryBinds.size()); + imageMipTailBindInfo.pBinds = &imageMipTailMemoryBinds[0]; + + bindSparseInfo.imageOpaqueBindCount = 1u; + bindSparseInfo.pImageOpaqueBinds = &imageMipTailBindInfo; + } + + VK_CHECK(vk.queueBindSparse(queue, 1u, &bindSparseInfo, DE_NULL)); + } + + Move cmdPool; + Move cmdBuffer; + // Create command pool + { + const VkCommandPoolCreateInfo cmdPoolParams = + { + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, // VkCommandPoolCreateFlags flags; + queueFamilyIndex, // deUint32 queueFamilyIndex; + }; + + cmdPool = createCommandPool(vk, vkDevice, &cmdPoolParams); + } + + { + // Create command buffer + const VkCommandBufferAllocateInfo cmdBufferAllocateInfo = + { + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *cmdPool, // VkCommandPool commandPool; + VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level; + 1u, // deUint32 bufferCount; + }; + + cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo); + } + + // Create source buffer + const VkBufferCreateInfo bufferParams = + { + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkBufferCreateFlags flags; + bufferSize, // VkDeviceSize size; + VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage; + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; + 0u, // deUint32 queueFamilyIndexCount; + DE_NULL, // const deUint32* pQueueFamilyIndices; + }; + + Move buffer = createBuffer(vk, vkDevice, &bufferParams); + de::MovePtr bufferAlloc = m_memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible); + VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset())); + + // Barriers for copying buffer to image + const VkBufferMemoryBarrier preBufferBarrier = + { + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask; + VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask; + VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; + VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex; + *buffer, // VkBuffer buffer; + 0u, // VkDeviceSize offset; + bufferSize // VkDeviceSize size; + }; + + const VkImageMemoryBarrier preImageBarrier = + { + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkAccessFlags srcAccessMask; + VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask; + VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout; + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout; + VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; + VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex; + sparseImage, // VkImage image; + { // VkImageSubresourceRange subresourceRange; + aspectMask, // VkImageAspect aspect; + 0u, // deUint32 baseMipLevel; + mipLevels, // deUint32 mipLevels; + 0u, // deUint32 baseArraySlice; + arrayLayers // deUint32 arraySize; + } + }; + + const VkImageMemoryBarrier postImageBarrier = + { + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask; + VK_ACCESS_SHADER_READ_BIT, // VkAccessFlags dstAccessMask; + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout; + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, // VkImageLayout newLayout; + VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; + VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex; + sparseImage, // VkImage image; + { // VkImageSubresourceRange subresourceRange; + aspectMask, // VkImageAspect aspect; + 0u, // deUint32 baseMipLevel; + mipLevels, // deUint32 mipLevels; + 0u, // deUint32 baseArraySlice; + arrayLayers // deUint32 arraySize; + } + }; + + const VkCommandBufferBeginInfo cmdBufferBeginInfo = + { + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags; + (const VkCommandBufferInheritanceInfo*)DE_NULL, + }; + + std::vector copyRegions; + // Get copy regions and write buffer data + { + deUint32 layerDataOffset = 0; + deUint8* destPtr = (deUint8*)bufferAlloc->getHostPtr(); + + for (size_t levelNdx = 0; levelNdx < textureData.size(); levelNdx++) + { + const TextureLayerData& layerData = textureData[levelNdx]; + + for (size_t layerNdx = 0; layerNdx < layerData.size(); layerNdx++) + { + layerDataOffset = getNextMultiple(offsetMultiples, layerDataOffset); + + const tcu::ConstPixelBufferAccess& access = layerData[layerNdx]; + const tcu::PixelBufferAccess destAccess (access.getFormat(), access.getSize(), destPtr + layerDataOffset); + + const VkBufferImageCopy layerRegion = + { + layerDataOffset, // VkDeviceSize bufferOffset; + (deUint32)access.getWidth(), // deUint32 bufferRowLength; + (deUint32)access.getHeight(), // deUint32 bufferImageHeight; + { // VkImageSubresourceLayers imageSubresource; + aspectMask, // VkImageAspectFlags aspectMask; + (deUint32)levelNdx, // uint32_t mipLevel; + (deUint32)layerNdx, // uint32_t baseArrayLayer; + 1u // uint32_t layerCount; + }, + { 0u, 0u, 0u }, // VkOffset3D imageOffset; + { // VkExtent3D imageExtent; + (deUint32)access.getWidth(), + (deUint32)access.getHeight(), + (deUint32)access.getDepth() + } + }; + + copyRegions.push_back(layerRegion); + tcu::copy(destAccess, access); + + layerDataOffset += access.getWidth() * access.getHeight() * access.getDepth() * access.getFormat().getPixelSize(); + } + } + } + + // Copy buffer to image + VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo)); + vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier); + vk.cmdCopyBufferToImage(*cmdBuffer, *buffer, sparseImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)copyRegions.size(), copyRegions.data()); + vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier); + VK_CHECK(vk.endCommandBuffer(*cmdBuffer)); + + const VkPipelineStageFlags pipelineStageFlags = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT; + + const VkSubmitInfo submitInfo = + { + VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 1u, // deUint32 waitSemaphoreCount; + &imageMemoryBindSemaphore.get(), // const VkSemaphore* pWaitSemaphores; + &pipelineStageFlags, // const VkPipelineStageFlags* pWaitDstStageMask; + 1u, // deUint32 commandBufferCount; + &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; + 0u, // deUint32 signalSemaphoreCount; + DE_NULL // const VkSemaphore* pSignalSemaphores; + }; + + const VkFenceCreateInfo fenceParams = + { + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u // VkFenceCreateFlags flags; + }; + + Move fence = createFence(vk, vkDevice, &fenceParams); + + try + { + VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence)); + VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity */)); + } + catch (...) + { + VK_CHECK(vk.deviceWaitIdle(vkDevice)); + throw; + } +} + void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 textureId) { DE_ASSERT(textureId < m_textures.size()); @@ -1119,7 +1725,7 @@ void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 te deUint32 mipLevels = 1u; deUint32 arrayLayers = 1u; tcu::TextureFormat texFormat; - tcu::IVec3 texSize; + tcu::UVec3 texSize; TextureData textureData; if (textureType == TextureBinding::TYPE_2D) @@ -1127,8 +1733,8 @@ void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 te const tcu::Texture2D& texture = textureBinding.get2D(); texFormat = texture.getFormat(); - texSize = tcu::IVec3(texture.getWidth(), texture.getHeight(), 1u); - mipLevels = isMSTexture ? 1u : (deUint32)texture.getNumLevels(); + texSize = tcu::UVec3(texture.getWidth(), texture.getHeight(), 1u); + mipLevels = (deUint32)texture.getNumLevels(); arrayLayers = 1u; textureData.resize(mipLevels); @@ -1146,8 +1752,8 @@ void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 te const tcu::TextureCube& texture = textureBinding.getCube(); texFormat = texture.getFormat(); - texSize = tcu::IVec3(texture.getSize(), texture.getSize(), 1u); - mipLevels = isMSTexture ? 1u : (deUint32)texture.getNumLevels(); + texSize = tcu::UVec3(texture.getSize(), texture.getSize(), 1u); + mipLevels = (deUint32)texture.getNumLevels(); arrayLayers = 6u; static const tcu::CubeFace cubeFaceMapping[tcu::CUBEFACE_LAST] = @@ -1180,8 +1786,8 @@ void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 te const tcu::Texture2DArray& texture = textureBinding.get2DArray(); texFormat = texture.getFormat(); - texSize = tcu::IVec3(texture.getWidth(), texture.getHeight(), 1u); - mipLevels = isMSTexture ? 1u : (deUint32)texture.getNumLevels(); + texSize = tcu::UVec3(texture.getWidth(), texture.getHeight(), 1u); + mipLevels = (deUint32)texture.getNumLevels(); arrayLayers = (deUint32)texture.getNumLayers(); textureData.resize(mipLevels); @@ -1207,8 +1813,8 @@ void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 te const tcu::Texture3D& texture = textureBinding.get3D(); texFormat = texture.getFormat(); - texSize = tcu::IVec3(texture.getWidth(), texture.getHeight(), texture.getDepth()); - mipLevels = isMSTexture ? 1u : (deUint32)texture.getNumLevels(); + texSize = tcu::UVec3(texture.getWidth(), texture.getHeight(), texture.getDepth()); + mipLevels = (deUint32)texture.getNumLevels(); arrayLayers = 1u; textureData.resize(mipLevels); @@ -1226,7 +1832,7 @@ void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 te const tcu::Texture1D& texture = textureBinding.get1D(); texFormat = texture.getFormat(); - texSize = tcu::IVec3(texture.getWidth(), 1, 1); + texSize = tcu::UVec3(texture.getWidth(), 1, 1); mipLevels = isMSTexture ? 1u : (deUint32)texture.getNumLevels(); arrayLayers = 1u; @@ -1245,7 +1851,7 @@ void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 te const tcu::Texture1DArray& texture = textureBinding.get1DArray(); texFormat = texture.getFormat(); - texSize = tcu::IVec3(texture.getWidth(), 1, 1); + texSize = tcu::UVec3(texture.getWidth(), 1, 1); mipLevels = isMSTexture ? 1u : (deUint32)texture.getNumLevels(); arrayLayers = (deUint32)texture.getNumLayers(); @@ -1271,7 +1877,7 @@ void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 te { const tcu::TextureCubeArray& texture = textureBinding.getCubeArray(); texFormat = texture.getFormat(); - texSize = tcu::IVec3(texture.getSize(), texture.getSize(), 1); + texSize = tcu::UVec3(texture.getSize(), texture.getSize(), 1); mipLevels = isMSTexture ? 1u : (deUint32)texture.getNumLevels(); arrayLayers = texture.getDepth(); @@ -1304,16 +1910,16 @@ void ShaderRenderCaseInstance::useSampler (deUint32 bindingLocation, deUint32 te void ShaderRenderCaseInstance::createSamplerUniform (deUint32 bindingLocation, TextureBinding::Type textureType, const tcu::TextureFormat& texFormat, - const tcu::IVec3 texSize, + const tcu::UVec3 texSize, const TextureData& textureData, const tcu::Sampler& refSampler, deUint32 mipLevels, deUint32 arrayLayers, TextureBinding::Parameters textureParams) { - const VkDevice vkDevice = m_context.getDevice(); - const DeviceInterface& vk = m_context.getDeviceInterface(); - const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); + const VkDevice vkDevice = getDevice(); + const DeviceInterface& vk = getDeviceInterface(); + const deUint32 queueFamilyIndex = getUniversalQueueFamilyIndex(); const bool isShadowSampler = refSampler.compare != tcu::Sampler::COMPAREMODE_NONE; const VkImageAspectFlags aspectMask = isShadowSampler ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT; @@ -1321,7 +1927,7 @@ void ShaderRenderCaseInstance::createSamplerUniform (deUint32 bindingLocati const VkImageType imageType = viewTypeToImageType(imageViewType); const VkFormat format = mapTextureFormat(texFormat); const bool isCube = imageViewType == VK_IMAGE_VIEW_TYPE_CUBE || imageViewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; - const VkImageCreateFlags imageCreateFlags = isCube ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : (VkImageCreateFlags)0; + VkImageCreateFlags imageCreateFlags = isCube ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : (VkImageCreateFlags)0; VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; Move vkTexture; de::MovePtr allocation; @@ -1329,6 +1935,12 @@ void ShaderRenderCaseInstance::createSamplerUniform (deUint32 bindingLocati if (isShadowSampler) imageUsageFlags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; + if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE) + { + checkSparseSupport(imageType); + imageCreateFlags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT; + } + // Create image const VkImageCreateInfo imageParams = { @@ -1338,9 +1950,9 @@ void ShaderRenderCaseInstance::createSamplerUniform (deUint32 bindingLocati imageType, // VkImageType imageType; format, // VkFormat format; { // VkExtent3D extent; - (deUint32)texSize.x(), - (deUint32)texSize.y(), - (deUint32)texSize.z() + texSize.x(), + texSize.y(), + texSize.z() }, mipLevels, // deUint32 mipLevels; arrayLayers, // deUint32 arrayLayers; @@ -1355,10 +1967,17 @@ void ShaderRenderCaseInstance::createSamplerUniform (deUint32 bindingLocati vkTexture = createImage(vk, vkDevice, &imageParams); allocation = m_memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *vkTexture), MemoryRequirement::Any); - VK_CHECK(vk.bindImageMemory(vkDevice, *vkTexture, allocation->getMemory(), allocation->getOffset())); - // Upload texture data - uploadImage(texFormat, textureData, refSampler, mipLevels, arrayLayers, *vkTexture); + if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE) + { + uploadSparseImage(texFormat, textureData, refSampler, mipLevels, arrayLayers, *vkTexture, imageParams, texSize); + } + else + { + // Upload texture data + VK_CHECK(vk.bindImageMemory(vkDevice, *vkTexture, allocation->getMemory(), allocation->getOffset())); + uploadImage(texFormat, textureData, refSampler, mipLevels, arrayLayers, *vkTexture); + } // Create sampler const VkSamplerCreateInfo samplerParams = mapSampler(refSampler, texFormat); @@ -1487,10 +2106,10 @@ void ShaderRenderCaseInstance::render (deUint32 numVertices, const deUint16* indices, const tcu::Vec4& constCoords) { - const VkDevice vkDevice = m_context.getDevice(); - const DeviceInterface& vk = m_context.getDeviceInterface(); - const VkQueue queue = m_context.getUniversalQueue(); - const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); + const VkDevice vkDevice = getDevice(); + const DeviceInterface& vk = getDeviceInterface(); + const VkQueue queue = getUniversalQueue(); + const deUint32 queueFamilyIndex = getUniversalQueueFamilyIndex(); vk::Move colorImage; de::MovePtr colorImageAlloc; @@ -1518,13 +2137,13 @@ void ShaderRenderCaseInstance::render (deUint32 numVertices, const VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; VkImageFormatProperties properties; - if ((m_context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(), - m_colorFormat, - VK_IMAGE_TYPE_2D, - VK_IMAGE_TILING_OPTIMAL, - imageUsage, - 0u, - &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED)) + if ((getInstanceInterface().getPhysicalDeviceImageFormatProperties(getPhysicalDevice(), + m_colorFormat, + VK_IMAGE_TYPE_2D, + VK_IMAGE_TILING_OPTIMAL, + imageUsage, + 0u, + &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED)) { TCU_THROW(NotSupportedError, "Format not supported"); } @@ -1595,13 +2214,13 @@ void ShaderRenderCaseInstance::render (deUint32 numVertices, const VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VkImageFormatProperties properties; - if ((m_context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(), - m_colorFormat, - VK_IMAGE_TYPE_2D, - VK_IMAGE_TILING_OPTIMAL, - imageUsage, - 0, - &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED)) + if ((getInstanceInterface().getPhysicalDeviceImageFormatProperties(getPhysicalDevice(), + m_colorFormat, + VK_IMAGE_TYPE_2D, + VK_IMAGE_TILING_OPTIMAL, + imageUsage, + 0, + &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED)) { TCU_THROW(NotSupportedError, "Format not supported"); } diff --git a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.hpp b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.hpp index f84fc92..c0cc791 100644 --- a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.hpp +++ b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.hpp @@ -419,12 +419,19 @@ enum BaseAttributeType class ShaderRenderCaseInstance : public vkt::TestInstance { public: + enum ImageBackingMode + { + IMAGE_BACKING_MODE_REGULAR = 0, + IMAGE_BACKING_MODE_SPARSE, + }; + ShaderRenderCaseInstance (Context& context); ShaderRenderCaseInstance (Context& context, const bool isVertexCase, const ShaderEvaluator& evaluator, const UniformSetup& uniformSetup, - const AttributeSetupFunc attribFunc); + const AttributeSetupFunc attribFunc, + const ImageBackingMode imageBackingMode = IMAGE_BACKING_MODE_REGULAR); virtual ~ShaderRenderCaseInstance (void); virtual tcu::TestStatus iterate (void); @@ -457,7 +464,8 @@ protected: const bool isVertexCase, const ShaderEvaluator* evaluator, const UniformSetup* uniformSetup, - const AttributeSetupFunc attribFunc); + const AttributeSetupFunc attribFunc, + const ImageBackingMode imageBackingMode = IMAGE_BACKING_MODE_REGULAR); virtual void setup (void); virtual void setupUniforms (const tcu::Vec4& constCoords); @@ -487,6 +495,7 @@ protected: std::string m_fragmentShaderName; tcu::UVec2 m_renderSize; vk::VkFormat m_colorFormat; + ImageBackingMode m_imageBackingMode; private: typedef std::vector TextureLayerData; @@ -499,10 +508,21 @@ private: deUint32 arrayLayers, vk::VkImage destImage); + void checkSparseSupport (const vk::VkImageType imageType) const; + + void uploadSparseImage (const tcu::TextureFormat& texFormat, + const TextureData& textureData, + const tcu::Sampler& refSampler, + const deUint32 mipLevels, + const deUint32 arrayLayers, + const vk::VkImage sparseImage, + const vk::VkImageCreateInfo& imageCreateInfo, + const tcu::UVec3 texSize); + void createSamplerUniform (deUint32 bindingLocation, TextureBinding::Type textureType, const tcu::TextureFormat& texFormat, - const tcu::IVec3 texSize, + const tcu::UVec3 texSize, const TextureData& textureData, const tcu::Sampler& refSampler, deUint32 mipLevels, @@ -522,6 +542,23 @@ private: const UniformSetup* m_uniformSetup; const AttributeSetupFunc m_attribFunc; + struct SparseContext + { + SparseContext (vk::Move& device, const deUint32 universalQueueFamilyIndex, const vk::InstanceInterface& interface) + : m_device (device) + , m_universalQueueFamilyIndex (universalQueueFamilyIndex) + , m_deviceInterface (interface, *m_device) + { + m_deviceInterface.getDeviceQueue(*m_device, m_universalQueueFamilyIndex, 0, &m_queue); + } + + vk::Unique m_device; + const deUint32 m_universalQueueFamilyIndex; + vk::DeviceDriver m_deviceInterface; + vk::VkQueue m_queue; + }; + + de::UniquePtr m_sparseContext; de::MovePtr m_quadGrid; tcu::TextureLevel m_resultImage; @@ -586,6 +623,15 @@ private: std::vector m_vertexBufferAllocs; vk::VkSampleCountFlagBits m_sampleCount; + + // Wrapper functions around m_context calls to support sparse cases. + vk::VkDevice getDevice (void) const; + deUint32 getUniversalQueueFamilyIndex (void) const; + const vk::DeviceInterface& getDeviceInterface (void) const; + vk::VkQueue getUniversalQueue (void) const; + vk::VkPhysicalDevice getPhysicalDevice (void) const; + const vk::InstanceInterface& getInstanceInterface (void) const; + SparseContext* createSparseContext (void) const; }; template diff --git a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderTextureFunctionTests.cpp b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderTextureFunctionTests.cpp index 57913e0..ab6a6d9 100644 --- a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderTextureFunctionTests.cpp +++ b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderTextureFunctionTests.cpp @@ -39,6 +39,7 @@ #include "glwEnums.hpp" #include "deMath.h" #include "vkImageUtil.hpp" +#include "vkQueryUtil.hpp" namespace vkt { @@ -540,13 +541,13 @@ public: const UniformSetup& uniformSetup, const TextureLookupSpec& lookupSpec, const TextureSpec& textureSpec, - const TexLookupParams& lookupParams); + const TexLookupParams& lookupParams, + const ImageBackingMode imageBackingMode = IMAGE_BACKING_MODE_REGULAR); virtual ~ShaderTextureFunctionInstance (void); protected: virtual void setupUniforms (const tcu::Vec4&); void initTexture (void); - private: const TextureLookupSpec& m_lookupSpec; const TextureSpec& m_textureSpec; @@ -559,8 +560,9 @@ ShaderTextureFunctionInstance::ShaderTextureFunctionInstance (Context& cont const UniformSetup& uniformSetup, const TextureLookupSpec& lookupSpec, const TextureSpec& textureSpec, - const TexLookupParams& lookupParams) - : ShaderRenderCaseInstance (context, isVertexCase, evaluator, uniformSetup, DE_NULL) + const TexLookupParams& lookupParams, + const ImageBackingMode imageBackingMode) + : ShaderRenderCaseInstance (context, isVertexCase, evaluator, uniformSetup, DE_NULL, imageBackingMode) , m_lookupSpec (lookupSpec) , m_textureSpec (textureSpec) , m_lookupParams (lookupParams) @@ -854,12 +856,12 @@ public: virtual TestInstance* createInstance (Context& context) const; -private: - void initShaderSources (void); +protected: + const TextureLookupSpec m_lookupSpec; + const TextureSpec m_textureSpec; + const TexLookupParams m_lookupParams; - TextureLookupSpec m_lookupSpec; - TextureSpec m_textureSpec; - TexLookupParams m_lookupParams; + void initShaderSources (void); }; ShaderTextureFunctionCase::ShaderTextureFunctionCase (tcu::TestContext& testCtx, @@ -2484,6 +2486,283 @@ struct TexFuncCaseSpec #define GRAD_CASE_SPEC(NAME, FUNC, MINCOORD, MAXCOORD, MINDX, MAXDX, MINDY, MAXDY, USEOFFSET, OFFSET, TEXSPEC, EVALFUNC, FLAGS) \ { #NAME, TextureLookupSpec(FUNC, MINCOORD, MAXCOORD, false, 0.0f, 0.0f, MINDX, MAXDX, MINDY, MAXDY, USEOFFSET, OFFSET), TEXSPEC, EVALFUNC, FLAGS } +class SparseShaderTextureFunctionInstance : public ShaderTextureFunctionInstance +{ +public: + SparseShaderTextureFunctionInstance (Context& context, + const bool isVertexCase, + const ShaderEvaluator& evaluator, + const UniformSetup& uniformSetup, + const TextureLookupSpec& lookupSpec, + const TextureSpec& textureSpec, + const TexLookupParams& lookupParams, + const ImageBackingMode imageBackingMode = IMAGE_BACKING_MODE_SPARSE); + virtual ~SparseShaderTextureFunctionInstance (void); +}; + +SparseShaderTextureFunctionInstance::SparseShaderTextureFunctionInstance (Context& context, + const bool isVertexCase, + const ShaderEvaluator& evaluator, + const UniformSetup& uniformSetup, + const TextureLookupSpec& lookupSpec, + const TextureSpec& textureSpec, + const TexLookupParams& lookupParams, + const ImageBackingMode imageBackingMode) + : ShaderTextureFunctionInstance (context, isVertexCase, evaluator, uniformSetup, lookupSpec, textureSpec, lookupParams, imageBackingMode) +{ +} + +SparseShaderTextureFunctionInstance::~SparseShaderTextureFunctionInstance (void) +{ +} + +class SparseShaderTextureFunctionCase : public ShaderTextureFunctionCase +{ +public: + SparseShaderTextureFunctionCase (tcu::TestContext& testCtx, + const std::string& name, + const std::string& desc, + const TextureLookupSpec& lookup, + const TextureSpec& texture, + TexEvalFunc evalFunc, + bool isVertexCase); + + virtual ~SparseShaderTextureFunctionCase (void); + + virtual TestInstance* createInstance (Context& context) const; +protected: + void initShaderSources (void); +}; + +SparseShaderTextureFunctionCase::SparseShaderTextureFunctionCase (tcu::TestContext& testCtx, + const std::string& name, + const std::string& desc, + const TextureLookupSpec& lookup, + const TextureSpec& texture, + TexEvalFunc evalFunc, + bool isVertexCase) + : ShaderTextureFunctionCase (testCtx, name, desc, lookup, texture, evalFunc, isVertexCase) +{ + initShaderSources(); +} + +void SparseShaderTextureFunctionCase::initShaderSources (void) +{ + const Function function = m_lookupSpec.function; + const bool isVtxCase = m_isVertexCase; + const bool isProj = functionHasProj(function); + const bool isGrad = functionHasGrad(function); + const bool isShadow = m_textureSpec.sampler.compare != tcu::Sampler::COMPAREMODE_NONE; + const bool is2DProj4 = !isShadow && m_textureSpec.type == TEXTURETYPE_2D && (function == FUNCTION_TEXTUREPROJ || function == FUNCTION_TEXTUREPROJLOD || function == FUNCTION_TEXTUREPROJGRAD); + const bool isIntCoord = function == FUNCTION_TEXELFETCH; + const bool hasLodBias = functionHasLod(m_lookupSpec.function) || m_lookupSpec.useBias; + const int texCoordComps = m_textureSpec.type == TEXTURETYPE_2D ? 2 : 3; + const int extraCoordComps = (isProj ? (is2DProj4 ? 2 : 1) : 0) + (isShadow ? 1 : 0); + const glu::DataType coordType = glu::getDataTypeFloatVec(texCoordComps+extraCoordComps); + const glu::Precision coordPrec = glu::PRECISION_HIGHP; + const char* coordTypeName = glu::getDataTypeName(coordType); + const char* coordPrecName = glu::getPrecisionName(coordPrec); + const tcu::TextureFormat texFmt = glu::mapGLInternalFormat(m_textureSpec.format); + glu::DataType samplerType = glu::TYPE_LAST; + const glu::DataType gradType = (m_textureSpec.type == TEXTURETYPE_CUBE_MAP || m_textureSpec.type == TEXTURETYPE_3D) ? glu::TYPE_FLOAT_VEC3 : glu::TYPE_FLOAT_VEC2; + const char* gradTypeName = glu::getDataTypeName(gradType); + const char* baseFuncName = DE_NULL; + + DE_ASSERT(!isGrad || !hasLodBias); + + switch (m_textureSpec.type) + { + case TEXTURETYPE_2D: samplerType = isShadow ? glu::TYPE_SAMPLER_2D_SHADOW : glu::getSampler2DType(texFmt); break; + case TEXTURETYPE_CUBE_MAP: samplerType = isShadow ? glu::TYPE_SAMPLER_CUBE_SHADOW : glu::getSamplerCubeType(texFmt); break; + case TEXTURETYPE_2D_ARRAY: samplerType = isShadow ? glu::TYPE_SAMPLER_2D_ARRAY_SHADOW : glu::getSampler2DArrayType(texFmt); break; + case TEXTURETYPE_3D: DE_ASSERT(!isShadow); samplerType = glu::getSampler3DType(texFmt); break; + default: + DE_ASSERT(DE_FALSE); + } + + // Not supported cases + switch (m_lookupSpec.function) + { + case FUNCTION_TEXTURE: baseFuncName = "sparseTexture"; break; + case FUNCTION_TEXTURELOD: baseFuncName = "sparseTextureLod"; break; + case FUNCTION_TEXTUREGRAD: baseFuncName = "sparseTextureGrad"; break; + case FUNCTION_TEXELFETCH: baseFuncName = "sparseTexelFetch"; break; + default: + DE_ASSERT(DE_FALSE); + } + + std::ostringstream vert; + std::ostringstream frag; + std::ostringstream& op = isVtxCase ? vert : frag; + + vert << "#version 450\n" + << "#extension GL_ARB_sparse_texture2 : require\n" + << "layout(location = 0) in highp vec4 a_position;\n" + << "layout(location = 4) in " << coordPrecName << " " << coordTypeName << " a_in0;\n"; + + if (isGrad) + { + vert << "layout(location = 5) in " << coordPrecName << " " << gradTypeName << " a_in1;\n"; + vert << "layout(location = 6) in " << coordPrecName << " " << gradTypeName << " a_in2;\n"; + } + else if (hasLodBias) + vert << "layout(location = 5) in " << coordPrecName << " float a_in1;\n"; + + frag << "#version 450\n" + << "#extension GL_ARB_sparse_texture2 : require\n" + << "layout(location = 0) out mediump vec4 o_color;\n"; + + if (isVtxCase) + { + vert << "layout(location = 0) out mediump vec4 v_color;\n"; + frag << "layout(location = 0) in mediump vec4 v_color;\n"; + } + else + { + vert << "layout(location = 0) out " << coordPrecName << " " << coordTypeName << " v_texCoord;\n"; + frag << "layout(location = 0) in " << coordPrecName << " " << coordTypeName << " v_texCoord;\n"; + + if (isGrad) + { + vert << "layout(location = 1) out " << coordPrecName << " " << gradTypeName << " v_gradX;\n"; + vert << "layout(location = 2) out " << coordPrecName << " " << gradTypeName << " v_gradY;\n"; + frag << "layout(location = 1) in " << coordPrecName << " " << gradTypeName << " v_gradX;\n"; + frag << "layout(location = 2) in " << coordPrecName << " " << gradTypeName << " v_gradY;\n"; + } + else if (hasLodBias) + { + vert << "layout(location = 1) out " << coordPrecName << " float v_lodBias;\n"; + frag << "layout(location = 1) in " << coordPrecName << " float v_lodBias;\n"; + } + } + + // Uniforms + op << "layout(set = 0, binding = 0) uniform highp " << glu::getDataTypeName(samplerType) << " u_sampler;\n" + << "layout(set = 0, binding = 1) uniform buf0 { highp vec4 u_scale; };\n" + << "layout(set = 0, binding = 2) uniform buf1 { highp vec4 u_bias; };\n"; + + vert << "out gl_PerVertex {\n" + << " vec4 gl_Position;\n" + << "};\n"; + vert << "\nvoid main()\n{\n" + << "\tgl_Position = a_position;\n"; + frag << "\nvoid main()\n{\n"; + + // Op. + { + // Texel declaration + if (isShadow) + op << "\tfloat texel;\n"; + else + op << "\tvec4 texel;\n"; + + const char* const texCoord = isVtxCase ? "a_in0" : "v_texCoord"; + const char* const gradX = isVtxCase ? "a_in1" : "v_gradX"; + const char* const gradY = isVtxCase ? "a_in2" : "v_gradY"; + const char* const lodBias = isVtxCase ? "a_in1" : "v_lodBias"; + + op << "\tint success = " << baseFuncName; + + if (m_lookupSpec.useOffset) + op << "Offset"; + + op << "ARB(u_sampler, "; + + if (isIntCoord) + op << "ivec" << (texCoordComps+extraCoordComps) << "("; + + op << texCoord; + + if (isIntCoord) + op << ")"; + + if (isGrad) + op << ", " << gradX << ", " << gradY; + + if (functionHasLod(function)) + { + if (isIntCoord) + op << ", int(" << lodBias << ")"; + else + op << ", " << lodBias; + } + + if (m_lookupSpec.useOffset) + { + int offsetComps = m_textureSpec.type == TEXTURETYPE_3D ? 3 : 2; + + op << ", ivec" << offsetComps << "("; + for (int ndx = 0; ndx < offsetComps; ndx++) + { + if (ndx != 0) + op << ", "; + op << m_lookupSpec.offset[ndx]; + } + op << ")"; + } + + op << ", texel"; + + if (m_lookupSpec.useBias) + op << ", " << lodBias; + + op << ");\n"; + + // Check sparse validity, and handle each case + op << "\tif (sparseTexelsResidentARB(success))\n"; + + if (isVtxCase) + vert << "\t\tv_color = "; + else + frag << "\t\to_color = "; + + if (isShadow) + op << "vec4(texel, 0.0, 0.0, 1.0);\n"; + else + op << "vec4(texel * u_scale + u_bias);\n"; + + op << "\telse\n"; + + // This color differs from the used colors + if (isVtxCase) + vert << "\t\tv_color = vec4(0.54117647058, 0.16862745098, 0.8862745098, 1.0);\n"; + else + frag << "\t\to_color = vec4(0.54117647058, 0.16862745098, 0.8862745098, 1.0);\n"; + } + + if (isVtxCase) + frag << "\to_color = v_color;\n"; + else + { + vert << "\tv_texCoord = a_in0;\n"; + + if (isGrad) + { + vert << "\tv_gradX = a_in1;\n"; + vert << "\tv_gradY = a_in2;\n"; + } + else if (hasLodBias) + vert << "\tv_lodBias = a_in1;\n"; + } + + vert << "}\n"; + frag << "}\n"; + + m_vertShaderSource = vert.str(); + m_fragShaderSource = frag.str(); +} + +SparseShaderTextureFunctionCase::~SparseShaderTextureFunctionCase () +{ +} + +TestInstance* SparseShaderTextureFunctionCase::createInstance (Context& context) const +{ + DE_ASSERT(m_evaluator != DE_NULL); + DE_ASSERT(m_uniformSetup != DE_NULL); + return new SparseShaderTextureFunctionInstance(context, m_isVertexCase, *m_evaluator, *m_uniformSetup, m_lookupSpec, m_textureSpec, m_lookupParams); +} + static void createCaseGroup (tcu::TestCaseGroup* parent, const char* groupName, const char* groupDesc, const TexFuncCaseSpec* cases, int numCases) { de::MovePtr group (new tcu::TestCaseGroup(parent->getTestContext(), groupName, groupDesc)); @@ -2506,9 +2785,18 @@ static void createCaseGroup (tcu::TestCaseGroup* parent, const char* groupName, std::string name = cases[ndx].name; if (cases[ndx].flags & VERTEX) + { + if (!functionHasProj(cases[ndx].lookupSpec.function)) + group->addChild(new SparseShaderTextureFunctionCase(parent->getTestContext(), ("sparse_" + name + "_vertex"), "", cases[ndx].lookupSpec, cases[ndx].texSpec, cases[ndx].evalFunc, true )); group->addChild(new ShaderTextureFunctionCase(parent->getTestContext(), (name + "_vertex"), "", cases[ndx].lookupSpec, cases[ndx].texSpec, cases[ndx].evalFunc, true )); + } + if (cases[ndx].flags & FRAGMENT) + { + if (!functionHasProj(cases[ndx].lookupSpec.function)) + group->addChild(new SparseShaderTextureFunctionCase(parent->getTestContext(), ("sparse_" + name + "_fragment"), "", cases[ndx].lookupSpec, cases[ndx].texSpec, cases[ndx].evalFunc, false)); group->addChild(new ShaderTextureFunctionCase(parent->getTestContext(), (name + "_fragment"), "", cases[ndx].lookupSpec, cases[ndx].texSpec, cases[ndx].evalFunc, false)); + } } parent->addChild(group.release()); diff --git a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderTextureGatherTests.cpp b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderTextureGatherTests.cpp index 4ac0d01..4bc20c4 100644 --- a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderTextureGatherTests.cpp +++ b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderTextureGatherTests.cpp @@ -62,6 +62,8 @@ namespace sr namespace { +typedef ShaderRenderCaseInstance::ImageBackingMode ImageBackingMode; + enum { SPEC_MAX_MIN_OFFSET = -8, @@ -999,6 +1001,7 @@ struct GatherCaseBaseParams int baseLevel; deUint32 flags; TextureType textureType; + ImageBackingMode sparseCase; GatherCaseBaseParams (const TextureType textureType_, const GatherType gatherType_, @@ -1011,7 +1014,8 @@ struct GatherCaseBaseParams const tcu::Sampler::FilterMode minFilter_, const tcu::Sampler::FilterMode magFilter_, const int baseLevel_, - const deUint32 flags_) + const deUint32 flags_, + const ImageBackingMode sparseCase_) : gatherType (gatherType_) , offsetSize (offsetSize_) , textureFormat (textureFormat_) @@ -1024,6 +1028,7 @@ struct GatherCaseBaseParams , baseLevel (baseLevel_) , flags (flags_) , textureType (textureType_) + , sparseCase (sparseCase_) {} GatherCaseBaseParams (void) @@ -1039,6 +1044,7 @@ struct GatherCaseBaseParams , baseLevel (0) , flags (0) , textureType (TEXTURETYPE_LAST) + , sparseCase (ShaderRenderCaseInstance::IMAGE_BACKING_MODE_REGULAR) {} }; @@ -1126,7 +1132,7 @@ const IVec2 TextureGatherInstance::RENDER_SIZE = IVec2(64, 64); TextureGatherInstance::TextureGatherInstance (Context& context, const GatherCaseBaseParams& baseParams) - : ShaderRenderCaseInstance (context, false, DE_NULL, DE_NULL, DE_NULL) + : ShaderRenderCaseInstance (context, false, DE_NULL, DE_NULL, DE_NULL, baseParams.sparseCase) , m_baseParams (baseParams) , m_colorBufferFormat (tcu::TextureFormat(tcu::TextureFormat::RGBA, isDepthFormat(baseParams.textureFormat) ? tcu::TextureFormat::UNORM_INT8 : baseParams.textureFormat.type)) @@ -1441,13 +1447,14 @@ glu::VertexSource genVertexShaderSource (bool requireGpuShader5, int numTexCoord return glu::VertexSource(vert.str()); } -glu::FragmentSource genFragmentShaderSource (bool requireGpuShader5, - int numTexCoordComponents, - glu::DataType samplerType, - const string& funcCall, - bool useNormalizedCoordInput, - bool usePixCoord, - OffsetSize offsetSize) +glu::FragmentSource genFragmentShaderSource (bool requireGpuShader5, + int numTexCoordComponents, + glu::DataType samplerType, + const string& funcCall, + bool useNormalizedCoordInput, + bool usePixCoord, + OffsetSize offsetSize, + const ImageBackingMode sparseCase) { DE_ASSERT(glu::isDataTypeSampler(samplerType)); DE_ASSERT(de::inRange(numTexCoordComponents, 2, 3)); @@ -1456,14 +1463,19 @@ glu::FragmentSource genFragmentShaderSource (bool requireGpuShader5, const string texCoordType = "vec" + de::toString(numTexCoordComponents); deUint32 binding = 0; std::ostringstream frag; + const string outType = glu::getDataTypeName(getSamplerGatherResultType(samplerType)); - frag << "#version 310 es\n"; + if (sparseCase == ShaderRenderCaseInstance::IMAGE_BACKING_MODE_SPARSE) + frag << "#version 450\n" + << "#extension GL_ARB_sparse_texture2 : require\n"; + else + frag << "#version 310 es\n"; if (requireGpuShader5) frag << "#extension GL_EXT_gpu_shader5 : require\n"; frag << "\n" - "layout (location = 0) out mediump " << glu::getDataTypeName(getSamplerGatherResultType(samplerType)) << " o_color;\n" + "layout (location = 0) out mediump " << outType << " o_color;\n" "\n" "layout (location = 0) in highp " << texCoordType << " v_texCoord;\n"; @@ -1486,8 +1498,24 @@ glu::FragmentSource genFragmentShaderSource (bool requireGpuShader5, if (usePixCoord) frag << " ivec2 pixCoord = ivec2(v_normalizedCoord*u_viewportSize);\n"; - frag << " o_color = " << funcCall << ";\n" - "}\n"; + if (sparseCase == ShaderRenderCaseInstance::IMAGE_BACKING_MODE_SPARSE) + { + // Texel declaration + frag << "\t" << outType << " texel;\n"; + frag << "\tint success = " << funcCall << ";\n"; + + // Check sparse validity, and handle each case + frag << "\tif (sparseTexelsResidentARB(success))\n" + << "\t\to_color = texel;\n" + << "\telse\n" + << "\t\to_color = " << outType << "(0.0, 0.0, 0.0, 1.0);\n"; + } + else + { + frag << "\t\to_color = " << funcCall << ";\n"; + } + + frag << "}\n"; return glu::FragmentSource(frag.str()); } @@ -1498,26 +1526,48 @@ string genGatherFuncCall (GatherType gatherType, const string& refZExpr, const IVec2& offsetRange, int indentationDepth, - OffsetSize offsetSize) + OffsetSize offsetSize, + const ImageBackingMode sparseCase) { string result; - switch (gatherType) + if (sparseCase == ShaderRenderCaseInstance::IMAGE_BACKING_MODE_SPARSE) { - case GATHERTYPE_BASIC: - result += "textureGather"; - break; - case GATHERTYPE_OFFSET: // \note Fallthrough. - case GATHERTYPE_OFFSET_DYNAMIC: - result += "textureGatherOffset"; - break; - case GATHERTYPE_OFFSETS: - result += "textureGatherOffsets"; - break; - default: - DE_ASSERT(false); + switch (gatherType) + { + case GATHERTYPE_BASIC: + result += "sparseTextureGatherARB"; + break; + case GATHERTYPE_OFFSET: // \note Fallthrough. + case GATHERTYPE_OFFSET_DYNAMIC: + result += "sparseTextureGatherOffsetARB"; + break; + case GATHERTYPE_OFFSETS: + result += "sparseTextureGatherOffsetsARB"; + break; + default: + DE_ASSERT(false); + } } - + else + { + switch (gatherType) + { + case GATHERTYPE_BASIC: + result += "textureGather"; + break; + case GATHERTYPE_OFFSET: // \note Fallthrough. + case GATHERTYPE_OFFSET_DYNAMIC: + result += "textureGatherOffset"; + break; + case GATHERTYPE_OFFSETS: + result += "textureGatherOffsets"; + break; + default: + DE_ASSERT(false); + } + } + result += "(u_sampler, v_texCoord"; if (isDepthFormat(textureFormat)) @@ -1562,6 +1612,9 @@ string genGatherFuncCall (GatherType gatherType, } } + if (sparseCase == ShaderRenderCaseInstance::IMAGE_BACKING_MODE_SPARSE) + result += ", texel"; + if (gatherArgs.componentNdx >= 0) { DE_ASSERT(gatherArgs.componentNdx < 4); @@ -1593,8 +1646,8 @@ void genGatherPrograms (vk::SourceCollections& programCollection, const GatherCa for (int iterNdx = 0; iterNdx < numIterations; iterNdx++) { const GatherArgs& gatherArgs = iterations[iterNdx]; - const string funcCall = genGatherFuncCall(baseParams.gatherType, baseParams.textureFormat, gatherArgs, refZExpr, offsetRange, 1, baseParams.offsetSize); - glu::FragmentSource frag = genFragmentShaderSource(requireGpuShader5(baseParams.gatherType, baseParams.offsetSize), numDims, samplerType, funcCall, useNormalizedCoord, usePixCoord, baseParams.offsetSize); + const string funcCall = genGatherFuncCall(baseParams.gatherType, baseParams.textureFormat, gatherArgs, refZExpr, offsetRange, 1, baseParams.offsetSize, baseParams.sparseCase); + glu::FragmentSource frag = genFragmentShaderSource(requireGpuShader5(baseParams.gatherType, baseParams.offsetSize), numDims, samplerType, funcCall, useNormalizedCoord, usePixCoord, baseParams.offsetSize, baseParams.sparseCase); programCollection.glslSources.add("frag_" + de::toString(iterNdx)) << frag; } @@ -1702,7 +1755,8 @@ public: const tcu::Sampler::FilterMode magFilter, const int baseLevel, const deUint32 flags, - const IVec2& textureSize); + const IVec2& textureSize, + const ImageBackingMode sparseCase); virtual ~TextureGather2DCase (void); virtual void initPrograms (vk::SourceCollections& dst) const; @@ -1727,9 +1781,10 @@ TextureGather2DCase::TextureGather2DCase (tcu::TestContext& testCtx, const tcu::Sampler::FilterMode magFilter, const int baseLevel, const deUint32 flags, - const IVec2& textureSize) + const IVec2& textureSize, + const ImageBackingMode sparseCase) : TestCase (testCtx, name, description) - , m_baseParams (TEXTURETYPE_2D, gatherType, offsetSize, textureFormat, shadowCompareMode, wrapS, wrapT, textureSwizzle, minFilter, magFilter, baseLevel, flags) + , m_baseParams (TEXTURETYPE_2D, gatherType, offsetSize, textureFormat, shadowCompareMode, wrapS, wrapT, textureSwizzle, minFilter, magFilter, baseLevel, flags, sparseCase) , m_textureSize (textureSize) { } @@ -1912,7 +1967,8 @@ public: const tcu::Sampler::FilterMode magFilter, const int baseLevel, const deUint32 flags, - const IVec3& textureSize); + const IVec3& textureSize, + const ImageBackingMode sparseCase); virtual ~TextureGather2DArrayCase (void); virtual void initPrograms (vk::SourceCollections& dst) const; @@ -1937,9 +1993,10 @@ TextureGather2DArrayCase::TextureGather2DArrayCase (tcu::TestContext& testCt const tcu::Sampler::FilterMode magFilter, const int baseLevel, const deUint32 flags, - const IVec3& textureSize) + const IVec3& textureSize, + const ImageBackingMode sparseCase) : TestCase (testCtx, name, description) - , m_baseParams (TEXTURETYPE_2D_ARRAY, gatherType, offsetSize, textureFormat, shadowCompareMode, wrapS, wrapT, textureSwizzle, minFilter, magFilter, baseLevel, flags) + , m_baseParams (TEXTURETYPE_2D_ARRAY, gatherType, offsetSize, textureFormat, shadowCompareMode, wrapS, wrapT, textureSwizzle, minFilter, magFilter, baseLevel, flags, sparseCase) , m_textureSize (textureSize) { } @@ -2128,7 +2185,8 @@ public: const tcu::Sampler::FilterMode magFilter, const int baseLevel, const deUint32 flags, - const int textureSize); + const int textureSize, + const ImageBackingMode sparseCase); virtual ~TextureGatherCubeCase (void); virtual void initPrograms (vk::SourceCollections& dst) const; @@ -2151,9 +2209,10 @@ TextureGatherCubeCase::TextureGatherCubeCase (tcu::TestContext& testCtx, const tcu::Sampler::FilterMode magFilter, const int baseLevel, const deUint32 flags, - const int textureSize) + const int textureSize, + const ImageBackingMode sparseCase) : TestCase (testCtx, name, description) - , m_baseParams (TEXTURETYPE_CUBE, GATHERTYPE_BASIC, OFFSETSIZE_NONE, textureFormat, shadowCompareMode, wrapS, wrapT, textureSwizzle, minFilter, magFilter, baseLevel, flags) + , m_baseParams (TEXTURETYPE_CUBE, GATHERTYPE_BASIC, OFFSETSIZE_NONE, textureFormat, shadowCompareMode, wrapS, wrapT, textureSwizzle, minFilter, magFilter, baseLevel, flags, sparseCase) , m_textureSize (textureSize) { } @@ -2216,23 +2275,24 @@ static inline TestCase* makeTextureGatherCase (TextureType textureType, tcu::Sampler::FilterMode magFilter, int baseLevel, const IVec3& textureSize, - deUint32 flags = 0) + deUint32 flags = 0, + const ImageBackingMode sparseCase = ShaderRenderCaseInstance::IMAGE_BACKING_MODE_REGULAR) { switch (textureType) { case TEXTURETYPE_2D: return new TextureGather2DCase(testCtx, name, description, gatherType, offsetSize, textureFormat, shadowCompareMode, - wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags, textureSize.swizzle(0, 1)); + wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags, textureSize.swizzle(0, 1), sparseCase); case TEXTURETYPE_2D_ARRAY: return new TextureGather2DArrayCase(testCtx, name, description, gatherType, offsetSize, textureFormat, shadowCompareMode, - wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags, textureSize); + wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags, textureSize, sparseCase); case TEXTURETYPE_CUBE: DE_ASSERT(gatherType == GATHERTYPE_BASIC); DE_ASSERT(offsetSize == OFFSETSIZE_NONE); return new TextureGatherCubeCase(testCtx, name, description, textureFormat, shadowCompareMode, - wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags, textureSize.x()); + wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags, textureSize.x(), sparseCase); default: DE_ASSERT(false); @@ -2394,6 +2454,9 @@ void TextureGatherTests::init (void) compareModeGroup->addChild(makeTextureGatherCase(textureType, m_testCtx, caseName.c_str(), "", gatherType, offsetSize, format, compareMode, wrapS, wrapT, MaybeTextureSwizzle::createNoneTextureSwizzle(), tcu::Sampler::NEAREST, tcu::Sampler::NEAREST, 0, textureSize, noCorners ? GATHERCASE_DONT_SAMPLE_CUBE_CORNERS : 0)); + compareModeGroup->addChild(makeTextureGatherCase(textureType, m_testCtx, "sparse_" + caseName, "", gatherType, offsetSize, format, compareMode, wrapS, wrapT, + MaybeTextureSwizzle::createNoneTextureSwizzle(), tcu::Sampler::NEAREST, tcu::Sampler::NEAREST, 0, textureSize, + noCorners ? GATHERCASE_DONT_SAMPLE_CUBE_CORNERS : 0, ShaderRenderCaseInstance::IMAGE_BACKING_MODE_SPARSE)); } } } @@ -2421,6 +2484,9 @@ void TextureGatherTests::init (void) swizzleGroup->addChild(makeTextureGatherCase(textureType, m_testCtx, caseName.c_str(), "", gatherType, offsetSize, format, tcu::Sampler::COMPAREMODE_NONE, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, swizzle, tcu::Sampler::NEAREST, tcu::Sampler::NEAREST, 0, IVec3(64, 64, 3))); + swizzleGroup->addChild(makeTextureGatherCase(textureType, m_testCtx, "sparse_" + caseName, "", gatherType, offsetSize, format, + tcu::Sampler::COMPAREMODE_NONE, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, + swizzle, tcu::Sampler::NEAREST, tcu::Sampler::NEAREST, 0, IVec3(64, 64, 3), 0, ShaderRenderCaseInstance::IMAGE_BACKING_MODE_SPARSE)); } } @@ -2470,6 +2536,9 @@ void TextureGatherTests::init (void) filterModeGroup->addChild(makeTextureGatherCase(textureType, m_testCtx, caseName.c_str(), "", gatherType, offsetSize, format, compareMode, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, MaybeTextureSwizzle::createNoneTextureSwizzle(), minFilter, magFilter, 0, IVec3(64, 64, 3))); + filterModeGroup->addChild(makeTextureGatherCase(textureType, m_testCtx, "sparse_" + caseName, "", gatherType, offsetSize, format, compareMode, + tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, MaybeTextureSwizzle::createNoneTextureSwizzle(), + minFilter, magFilter, 0, IVec3(64, 64, 3), 0, ShaderRenderCaseInstance::IMAGE_BACKING_MODE_SPARSE)); } } @@ -2485,6 +2554,10 @@ void TextureGatherTests::init (void) compareMode, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, MaybeTextureSwizzle::createNoneTextureSwizzle(), tcu::Sampler::NEAREST, tcu::Sampler::NEAREST, baseLevel, IVec3(64, 64, 3))); + baseLevelGroup->addChild(makeTextureGatherCase(textureType, m_testCtx, "sparse_" + caseName, "", gatherType, offsetSize, format, + compareMode, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, + MaybeTextureSwizzle::createNoneTextureSwizzle(), tcu::Sampler::NEAREST, tcu::Sampler::NEAREST, + baseLevel, IVec3(64, 64, 3), 0, ShaderRenderCaseInstance::IMAGE_BACKING_MODE_SPARSE)); } } } diff --git a/external/vulkancts/mustpass/1.0.1/com.drawelements.deqp.vk.xml b/external/vulkancts/mustpass/1.0.1/com.drawelements.deqp.vk.xml index a2dd098..47352e7 100644 --- a/external/vulkancts/mustpass/1.0.1/com.drawelements.deqp.vk.xml +++ b/external/vulkancts/mustpass/1.0.1/com.drawelements.deqp.vk.xml @@ -243258,27 +243258,42 @@ + + + + + + + + + + + + + + + @@ -243294,6 +243309,9 @@ + + + @@ -243306,6 +243324,9 @@ + + + @@ -243330,24 +243351,36 @@ + + + + + + + + + + + + @@ -243366,24 +243399,36 @@ + + + + + + + + + + + + @@ -243399,24 +243444,45 @@ + + + + + + + + + + + + + + + + + + + + + @@ -243425,24 +243491,36 @@ + + + + + + + + + + + + @@ -243461,24 +243539,36 @@ + + + + + + + + + + + + @@ -243515,12 +243605,21 @@ + + + + + + + + + @@ -243686,9 +243785,15 @@ + + + + + + @@ -243698,9 +243803,15 @@ + + + + + + @@ -243758,9 +243869,15 @@ + + + + + + @@ -243832,9 +243949,15 @@ + + + + + + @@ -243958,9 +244081,15 @@ + + + + + + @@ -243978,9 +244107,15 @@ + + + + + + @@ -244038,9 +244173,15 @@ + + + + + + @@ -244158,15 +244299,27 @@ + + + + + + + + + + + + @@ -244176,21 +244329,39 @@ + + + + + + + + + + + + + + + + + + @@ -244200,15 +244371,27 @@ + + + + + + + + + + + + @@ -244784,68 +244967,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -244853,56 +245093,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -244910,56 +245195,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -244968,23 +245298,41 @@ + + + + + + + + + + + + + + + + + + @@ -244992,49 +245340,88 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -245044,68 +245431,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -245113,56 +245557,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -245170,56 +245659,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -245228,23 +245762,41 @@ + + + + + + + + + + + + + + + + + + @@ -245252,49 +245804,88 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -245304,92 +245895,167 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -245397,80 +246063,143 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -245478,80 +246207,143 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -245560,23 +246352,41 @@ + + + + + + + + + + + + + + + + + + @@ -245584,23 +246394,41 @@ + + + + + + + + + + + + + + + + + + @@ -245609,23 +246437,41 @@ + + + + + + + + + + + + + + + + + + @@ -245633,23 +246479,41 @@ + + + + + + + + + + + + + + + + + + @@ -245657,26 +246521,47 @@ + + + + + + + + + + + + + + + + + + + + + @@ -245689,23 +246574,41 @@ + + + + + + + + + + + + + + + + + + @@ -245713,23 +246616,41 @@ + + + + + + + + + + + + + + + + + + @@ -245737,23 +246658,41 @@ + + + + + + + + + + + + + + + + + + @@ -245762,23 +246701,41 @@ + + + + + + + + + + + + + + + + + + @@ -245786,23 +246743,41 @@ + + + + + + + + + + + + + + + + + + @@ -245813,23 +246788,41 @@ + + + + + + + + + + + + + + + + + + @@ -245837,23 +246830,41 @@ + + + + + + + + + + + + + + + + + + @@ -245861,23 +246872,41 @@ + + + + + + + + + + + + + + + + + + @@ -245886,23 +246915,41 @@ + + + + + + + + + + + + + + + + + + @@ -245910,23 +246957,41 @@ + + + + + + + + + + + + + + + + + + @@ -245939,68 +247004,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246008,41 +247130,77 @@ + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + + + + + + + + + + + + + @@ -246050,14 +247208,23 @@ + + + + + + + + + @@ -246065,56 +247232,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246123,23 +247335,41 @@ + + + + + + + + + + + + + + + + + + @@ -246147,49 +247377,88 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246199,68 +247468,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246268,56 +247594,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246325,56 +247696,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246383,23 +247799,41 @@ + + + + + + + + + + + + + + + + + + @@ -246407,49 +247841,88 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246463,23 +247936,41 @@ + + + + + + + + + + + + + + + + + + @@ -246487,23 +247978,41 @@ + + + + + + + + + + + + + + + + + + @@ -246511,23 +248020,41 @@ + + + + + + + + + + + + + + + + + + @@ -246536,23 +248063,41 @@ + + + + + + + + + + + + + + + + + + @@ -246560,23 +248105,41 @@ + + + + + + + + + + + + + + + + + + @@ -246587,23 +248150,41 @@ + + + + + + + + + + + + + + + + + + @@ -246611,23 +248192,41 @@ + + + + + + + + + + + + + + + + + + @@ -246635,23 +248234,41 @@ + + + + + + + + + + + + + + + + + + @@ -246660,23 +248277,41 @@ + + + + + + + + + + + + + + + + + + @@ -246684,23 +248319,41 @@ + + + + + + + + + + + + + + + + + + @@ -246713,68 +248366,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246782,56 +248492,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246839,56 +248594,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246897,23 +248697,41 @@ + + + + + + + + + + + + + + + + + + @@ -246921,49 +248739,88 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -246973,68 +248830,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247042,56 +248956,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247099,56 +249058,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247157,23 +249161,41 @@ + + + + + + + + + + + + + + + + + + @@ -247181,49 +249203,88 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247237,68 +249298,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247306,56 +249424,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247363,56 +249526,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247421,23 +249629,41 @@ + + + + + + + + + + + + + + + + + + @@ -247445,49 +249671,88 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247497,68 +249762,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247566,56 +249888,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247623,56 +249990,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -247681,23 +250093,41 @@ + + + + + + + + + + + + + + + + + + @@ -247705,49 +250135,88 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/external/vulkancts/mustpass/1.0.1/src/excluded-tests.txt b/external/vulkancts/mustpass/1.0.1/src/excluded-tests.txt index d0d4d3c..95c4318 100644 --- a/external/vulkancts/mustpass/1.0.1/src/excluded-tests.txt +++ b/external/vulkancts/mustpass/1.0.1/src/excluded-tests.txt @@ -85,3 +85,191 @@ dEQP-VK.glsl.texture_functions.query.texturequerylod.sampler3d_fixed_fragment dEQP-VK.glsl.texture_functions.query.texturequerylod.sampler3d_float_fragment dEQP-VK.glsl.texture_functions.query.texturequerylod.isampler3d_fragment dEQP-VK.glsl.texture_functions.query.texturequerylod.usampler3d_fragment + +# Excluded sparse version of the above texture function tests +dEQP-VK.glsl.texture_functions.texturegrad.sparse_isamplercube_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_samplercubeshadow_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_samplercubeshadow_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler3d_float_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_usampler3d_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_isampler3d_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_isampler3d_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler3d_fixed_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler3d_float_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_usampler3d_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2darrayshadow_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2darrayshadow_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2darrayshadow_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2darrayshadow_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2darrayshadow_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_isampler2d_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_isampler2d_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_usampler2d_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_usampler2d_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_samplercube_fixed_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_samplercube_fixed_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_samplercube_float_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_samplercube_float_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_isamplercube_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_usamplercube_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_usamplercube_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_isampler2darray_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_isampler2darray_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_usampler2darray_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_usampler2darray_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler3d_float_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_isampler3d_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_isampler3d_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_usampler3d_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_usampler3d_fragment + +# Issue 419: Failing sparse tests (Image mismatch) +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2d_fixed_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2d_float_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_isampler2d_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_usampler2d_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2d_bias_float_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_isampler2d_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_usampler2d_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_samplercube_fixed_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_samplercube_float_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_samplercube_float_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_isamplercube_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_usamplercube_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_usamplercube_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_samplercube_bias_fixed_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_samplercube_bias_float_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_isamplercube_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_usamplercube_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2darray_fixed_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2darray_float_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_isampler2darray_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_usampler2darray_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2darray_bias_fixed_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2darray_bias_float_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_isampler2darray_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_usampler2darray_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_sampler3d_fixed_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler3d_float_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_isampler3d_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_usampler3d_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler3d_bias_fixed_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_sampler3d_bias_float_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_isampler3d_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_usampler3d_bias_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2d_fixed_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2d_float_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_isampler2d_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_usampler2d_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2d_bias_fixed_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2d_bias_float_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_isampler2d_bias_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_usampler2d_bias_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2darray_fixed_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2darray_float_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_isampler2darray_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_usampler2darray_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2darray_bias_fixed_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2darray_bias_float_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_isampler2darray_bias_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_usampler2darray_bias_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler3d_fixed_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler3d_float_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_usampler3d_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler3d_bias_fixed_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler3d_bias_float_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_isampler3d_bias_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_usampler3d_bias_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2d_fixed_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2d_fixed_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2d_float_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2d_float_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_isampler2d_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_isampler2d_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_usampler2d_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_usampler2d_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_samplercube_float_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_samplercube_float_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_usamplercube_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_usamplercube_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2darray_fixed_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2darray_fixed_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2darray_float_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2darray_float_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_isampler2darray_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_isampler2darray_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_usampler2darray_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_usampler2darray_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler3d_fixed_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler3d_fixed_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler3d_float_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler3d_float_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_isampler3d_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_isampler3d_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_usampler3d_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_usampler3d_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2d_fixed_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2d_fixed_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2d_float_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2d_float_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_isampler2d_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_isampler2d_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_usampler2d_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_usampler2d_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2darray_fixed_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2darray_fixed_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2darray_float_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2darray_float_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_isampler2darray_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_isampler2darray_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_usampler2darray_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_usampler2darray_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler3d_fixed_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler3d_fixed_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler3d_float_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_isampler3d_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_isampler3d_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_usampler3d_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2d_fixed_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2d_fixed_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2d_float_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2d_float_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2darray_fixed_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2darray_fixed_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2darray_float_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2darray_float_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler3d_fixed_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler3d_fixed_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler3d_float_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2d_fixed_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2d_fixed_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2d_float_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2d_float_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_usampler2d_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_usampler2d_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2darray_fixed_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2darray_fixed_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2darray_float_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2darray_float_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_isampler2darray_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_isampler2darray_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_usampler2darray_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_usampler2darray_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler3d_fixed_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler3d_fixed_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler3d_float_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler3d_float_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_isampler3d_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_isampler3d_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_usampler3d_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_usampler3d_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler2d_fixed_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler2d_fixed_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler2d_float_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler2d_float_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler2darray_fixed_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler2darray_fixed_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler3d_fixed_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler3d_fixed_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_usampler3d_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_usampler3d_fragment diff --git a/external/vulkancts/mustpass/1.0.1/vk-default.txt b/external/vulkancts/mustpass/1.0.1/vk-default.txt index 7f3505d..540149c 100644 --- a/external/vulkancts/mustpass/1.0.1/vk-default.txt +++ b/external/vulkancts/mustpass/1.0.1/vk-default.txt @@ -75434,22 +75434,29 @@ dEQP-VK.glsl.switch.switch_in_switch_uniform_fragment dEQP-VK.glsl.switch.switch_in_switch_dynamic_vertex dEQP-VK.glsl.switch.switch_in_switch_dynamic_fragment dEQP-VK.glsl.texture_functions.texture.sampler2d_fixed_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2d_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler2d_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler2d_float_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2d_float_fragment dEQP-VK.glsl.texture_functions.texture.sampler2d_float_fragment dEQP-VK.glsl.texture_functions.texture.isampler2d_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_isampler2d_fragment dEQP-VK.glsl.texture_functions.texture.isampler2d_fragment dEQP-VK.glsl.texture_functions.texture.usampler2d_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_usampler2d_fragment dEQP-VK.glsl.texture_functions.texture.usampler2d_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2d_bias_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler2d_bias_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler2d_bias_float_fragment dEQP-VK.glsl.texture_functions.texture.isampler2d_bias_fragment dEQP-VK.glsl.texture_functions.texture.usampler2d_bias_fragment dEQP-VK.glsl.texture_functions.texture.samplercube_fixed_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_samplercube_fixed_fragment dEQP-VK.glsl.texture_functions.texture.samplercube_fixed_fragment dEQP-VK.glsl.texture_functions.texture.samplercube_float_vertex dEQP-VK.glsl.texture_functions.texture.samplercube_float_fragment dEQP-VK.glsl.texture_functions.texture.isamplercube_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_isamplercube_fragment dEQP-VK.glsl.texture_functions.texture.isamplercube_fragment dEQP-VK.glsl.texture_functions.texture.usamplercube_vertex dEQP-VK.glsl.texture_functions.texture.usamplercube_fragment @@ -75458,55 +75465,78 @@ dEQP-VK.glsl.texture_functions.texture.samplercube_bias_float_fragment dEQP-VK.glsl.texture_functions.texture.isamplercube_bias_fragment dEQP-VK.glsl.texture_functions.texture.usamplercube_bias_fragment dEQP-VK.glsl.texture_functions.texture.sampler2darray_fixed_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2darray_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler2darray_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler2darray_float_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2darray_float_fragment dEQP-VK.glsl.texture_functions.texture.sampler2darray_float_fragment dEQP-VK.glsl.texture_functions.texture.isampler2darray_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_isampler2darray_fragment dEQP-VK.glsl.texture_functions.texture.isampler2darray_fragment dEQP-VK.glsl.texture_functions.texture.usampler2darray_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_usampler2darray_fragment dEQP-VK.glsl.texture_functions.texture.usampler2darray_fragment dEQP-VK.glsl.texture_functions.texture.sampler2darray_bias_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler2darray_bias_float_fragment dEQP-VK.glsl.texture_functions.texture.isampler2darray_bias_fragment dEQP-VK.glsl.texture_functions.texture.usampler2darray_bias_fragment dEQP-VK.glsl.texture_functions.texture.sampler3d_fixed_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler3d_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler3d_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler3d_float_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler3d_float_fragment dEQP-VK.glsl.texture_functions.texture.sampler3d_float_fragment dEQP-VK.glsl.texture_functions.texture.isampler3d_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_isampler3d_fragment dEQP-VK.glsl.texture_functions.texture.isampler3d_fragment dEQP-VK.glsl.texture_functions.texture.usampler3d_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_usampler3d_fragment dEQP-VK.glsl.texture_functions.texture.usampler3d_fragment dEQP-VK.glsl.texture_functions.texture.sampler3d_bias_fixed_fragment dEQP-VK.glsl.texture_functions.texture.sampler3d_bias_float_fragment dEQP-VK.glsl.texture_functions.texture.isampler3d_bias_fragment dEQP-VK.glsl.texture_functions.texture.usampler3d_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2dshadow_vertex dEQP-VK.glsl.texture_functions.texture.sampler2dshadow_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.texture.sampler2dshadow_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2dshadow_bias_fragment dEQP-VK.glsl.texture_functions.texture.sampler2dshadow_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_samplercubeshadow_vertex dEQP-VK.glsl.texture_functions.texture.samplercubeshadow_vertex +dEQP-VK.glsl.texture_functions.texture.sparse_samplercubeshadow_fragment dEQP-VK.glsl.texture_functions.texture.samplercubeshadow_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_samplercubeshadow_bias_fragment dEQP-VK.glsl.texture_functions.texture.samplercubeshadow_bias_fragment +dEQP-VK.glsl.texture_functions.texture.sparse_sampler2darrayshadow_fragment dEQP-VK.glsl.texture_functions.texture.sampler2darrayshadow_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2d_fixed_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2d_fixed_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2d_fixed_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2d_float_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2d_float_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2d_float_fragment dEQP-VK.glsl.texture_functions.textureoffset.isampler2d_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_isampler2d_fragment dEQP-VK.glsl.texture_functions.textureoffset.isampler2d_fragment dEQP-VK.glsl.texture_functions.textureoffset.usampler2d_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_usampler2d_fragment dEQP-VK.glsl.texture_functions.textureoffset.usampler2d_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2d_bias_fixed_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2d_bias_float_fragment dEQP-VK.glsl.texture_functions.textureoffset.isampler2d_bias_fragment dEQP-VK.glsl.texture_functions.textureoffset.usampler2d_bias_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2darray_fixed_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2darray_fixed_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2darray_fixed_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2darray_float_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2darray_float_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2darray_float_fragment dEQP-VK.glsl.texture_functions.textureoffset.isampler2darray_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_isampler2darray_fragment dEQP-VK.glsl.texture_functions.textureoffset.isampler2darray_fragment dEQP-VK.glsl.texture_functions.textureoffset.usampler2darray_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_usampler2darray_fragment dEQP-VK.glsl.texture_functions.textureoffset.usampler2darray_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2darray_bias_fixed_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2darray_bias_float_fragment @@ -75519,8 +75549,11 @@ dEQP-VK.glsl.texture_functions.textureoffset.sampler3d_bias_fixed_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler3d_bias_float_fragment dEQP-VK.glsl.texture_functions.textureoffset.isampler3d_bias_fragment dEQP-VK.glsl.texture_functions.textureoffset.usampler3d_bias_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2dshadow_vertex dEQP-VK.glsl.texture_functions.textureoffset.sampler2dshadow_vertex +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2dshadow_fragment +dEQP-VK.glsl.texture_functions.textureoffset.sparse_sampler2dshadow_bias_fragment dEQP-VK.glsl.texture_functions.textureoffset.sampler2dshadow_bias_fragment dEQP-VK.glsl.texture_functions.textureproj.sampler2d_vec4_fixed_vertex dEQP-VK.glsl.texture_functions.textureproj.sampler2d_vec4_fixed_fragment @@ -75574,11 +75607,15 @@ dEQP-VK.glsl.texture_functions.texturelod.isampler2d_vertex dEQP-VK.glsl.texture_functions.texturelod.isampler2d_fragment dEQP-VK.glsl.texture_functions.texturelod.usampler2d_vertex dEQP-VK.glsl.texture_functions.texturelod.usampler2d_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_samplercube_fixed_vertex dEQP-VK.glsl.texture_functions.texturelod.samplercube_fixed_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_samplercube_fixed_fragment dEQP-VK.glsl.texture_functions.texturelod.samplercube_fixed_fragment dEQP-VK.glsl.texture_functions.texturelod.samplercube_float_vertex dEQP-VK.glsl.texture_functions.texturelod.samplercube_float_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_isamplercube_vertex dEQP-VK.glsl.texture_functions.texturelod.isamplercube_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_isamplercube_fragment dEQP-VK.glsl.texture_functions.texturelod.isamplercube_fragment dEQP-VK.glsl.texture_functions.texturelod.usamplercube_vertex dEQP-VK.glsl.texture_functions.texturelod.usamplercube_fragment @@ -75598,7 +75635,9 @@ dEQP-VK.glsl.texture_functions.texturelod.isampler3d_vertex dEQP-VK.glsl.texture_functions.texturelod.isampler3d_fragment dEQP-VK.glsl.texture_functions.texturelod.usampler3d_vertex dEQP-VK.glsl.texture_functions.texturelod.usampler3d_fragment +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2dshadow_vertex dEQP-VK.glsl.texture_functions.texturelod.sampler2dshadow_vertex +dEQP-VK.glsl.texture_functions.texturelod.sparse_sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.texturelod.sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.texturelodoffset.sampler2d_fixed_vertex dEQP-VK.glsl.texture_functions.texturelodoffset.sampler2d_fixed_fragment @@ -75622,7 +75661,9 @@ dEQP-VK.glsl.texture_functions.texturelodoffset.sampler3d_float_fragment dEQP-VK.glsl.texture_functions.texturelodoffset.isampler3d_vertex dEQP-VK.glsl.texture_functions.texturelodoffset.isampler3d_fragment dEQP-VK.glsl.texture_functions.texturelodoffset.usampler3d_fragment +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2dshadow_vertex dEQP-VK.glsl.texture_functions.texturelodoffset.sampler2dshadow_vertex +dEQP-VK.glsl.texture_functions.texturelodoffset.sparse_sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.texturelodoffset.sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.textureprojlod.sampler2d_vec4_fixed_vertex dEQP-VK.glsl.texture_functions.textureprojlod.sampler2d_vec4_fixed_fragment @@ -75662,13 +75703,17 @@ dEQP-VK.glsl.texture_functions.texturegrad.sampler2darray_float_fragment dEQP-VK.glsl.texture_functions.texturegrad.sampler3d_fixed_vertex dEQP-VK.glsl.texture_functions.texturegrad.sampler3d_fixed_fragment dEQP-VK.glsl.texture_functions.texturegrad.sampler3d_float_fragment +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2dshadow_vertex dEQP-VK.glsl.texture_functions.texturegrad.sampler2dshadow_vertex +dEQP-VK.glsl.texture_functions.texturegrad.sparse_sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.texturegrad.sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.texturegradoffset.sampler2d_fixed_vertex dEQP-VK.glsl.texture_functions.texturegradoffset.sampler2d_fixed_fragment dEQP-VK.glsl.texture_functions.texturegradoffset.sampler2d_float_vertex dEQP-VK.glsl.texture_functions.texturegradoffset.sampler2d_float_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_isampler2d_vertex dEQP-VK.glsl.texture_functions.texturegradoffset.isampler2d_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_isampler2d_fragment dEQP-VK.glsl.texture_functions.texturegradoffset.isampler2d_fragment dEQP-VK.glsl.texture_functions.texturegradoffset.usampler2d_vertex dEQP-VK.glsl.texture_functions.texturegradoffset.usampler2d_fragment @@ -75688,7 +75733,9 @@ dEQP-VK.glsl.texture_functions.texturegradoffset.isampler3d_vertex dEQP-VK.glsl.texture_functions.texturegradoffset.isampler3d_fragment dEQP-VK.glsl.texture_functions.texturegradoffset.usampler3d_vertex dEQP-VK.glsl.texture_functions.texturegradoffset.usampler3d_fragment +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2dshadow_vertex dEQP-VK.glsl.texture_functions.texturegradoffset.sampler2dshadow_vertex +dEQP-VK.glsl.texture_functions.texturegradoffset.sparse_sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.texturegradoffset.sampler2dshadow_fragment dEQP-VK.glsl.texture_functions.textureprojgrad.sampler2d_vec4_fixed_vertex dEQP-VK.glsl.texture_functions.textureprojgrad.sampler2d_vec4_fixed_fragment @@ -75726,23 +75773,37 @@ dEQP-VK.glsl.texture_functions.texelfetch.sampler2d_fixed_vertex dEQP-VK.glsl.texture_functions.texelfetch.sampler2d_fixed_fragment dEQP-VK.glsl.texture_functions.texelfetch.sampler2d_float_vertex dEQP-VK.glsl.texture_functions.texelfetch.sampler2d_float_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_isampler2d_vertex dEQP-VK.glsl.texture_functions.texelfetch.isampler2d_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_isampler2d_fragment dEQP-VK.glsl.texture_functions.texelfetch.isampler2d_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_usampler2d_vertex dEQP-VK.glsl.texture_functions.texelfetch.usampler2d_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_usampler2d_fragment dEQP-VK.glsl.texture_functions.texelfetch.usampler2d_fragment dEQP-VK.glsl.texture_functions.texelfetch.sampler2darray_fixed_vertex dEQP-VK.glsl.texture_functions.texelfetch.sampler2darray_fixed_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler2darray_float_vertex dEQP-VK.glsl.texture_functions.texelfetch.sampler2darray_float_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler2darray_float_fragment dEQP-VK.glsl.texture_functions.texelfetch.sampler2darray_float_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_isampler2darray_vertex dEQP-VK.glsl.texture_functions.texelfetch.isampler2darray_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_isampler2darray_fragment dEQP-VK.glsl.texture_functions.texelfetch.isampler2darray_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_usampler2darray_vertex dEQP-VK.glsl.texture_functions.texelfetch.usampler2darray_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_usampler2darray_fragment dEQP-VK.glsl.texture_functions.texelfetch.usampler2darray_fragment dEQP-VK.glsl.texture_functions.texelfetch.sampler3d_fixed_vertex dEQP-VK.glsl.texture_functions.texelfetch.sampler3d_fixed_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler3d_float_vertex dEQP-VK.glsl.texture_functions.texelfetch.sampler3d_float_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_sampler3d_float_fragment dEQP-VK.glsl.texture_functions.texelfetch.sampler3d_float_fragment +dEQP-VK.glsl.texture_functions.texelfetch.sparse_isampler3d_vertex dEQP-VK.glsl.texture_functions.texelfetch.isampler3d_vertex +dEQP-VK.glsl.texture_functions.texelfetch.sparse_isampler3d_fragment dEQP-VK.glsl.texture_functions.texelfetch.isampler3d_fragment dEQP-VK.glsl.texture_functions.texelfetch.usampler3d_vertex dEQP-VK.glsl.texture_functions.texelfetch.usampler3d_fragment @@ -75929,767 +75990,1529 @@ dEQP-VK.glsl.texture_functions.query.texturequerylod.isampler1darray_fragment dEQP-VK.glsl.texture_functions.query.texturequerylod.usampler1darray_fragment dEQP-VK.glsl.texture_functions.query.texturequerylod.sampler1darrayshadow_fragment dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.rgba8.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.2d.rgba8.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.2d.rgba8.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.2d.rgba8ui.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.2d.rgba8i.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d.depth32f.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.2d.depth32f.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.2d.depth32f.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8ui.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.2d_array.rgba8i.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.2d_array.depth32f.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.no_corners.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.rgba8.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.cube.rgba8.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.cube.rgba8.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.no_corners.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.cube.rgba8ui.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.no_corners.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.level_1 +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.level_2 +dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d_array.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8ui.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.rgba8i.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d.depth32f.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8ui.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.rgba8i.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset.implementation_offset.2d_array.depth32f.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.min_required_offset.2d_array.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8ui.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.rgba8i.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d.depth32f.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8ui.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.rgba8i.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.base_level.level_1 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.base_level.level_2 +dEQP-VK.glsl.texture_gather.offset_dynamic.implementation_offset.2d_array.depth32f.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.base_level.level_1 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.base_level.level_2 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.base_level.level_1 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.base_level.level_2 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8ui.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.base_level.level_1 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.base_level.level_2 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.rgba8i.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.base_level.level_1 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.base_level.level_2 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d.depth32f.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.base_level.level_1 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.base_level.level_2 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.base_level.level_1 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.base_level.level_2 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8ui.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_pot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_pot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_pot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_pot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_pot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_pot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_npot.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_npot.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_npot.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_npot.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_npot.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.size_npot.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.red_green_blue_alpha +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.sparse_red_green_blue_alpha dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.green_blue_alpha_zero +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.sparse_green_blue_alpha_zero dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.blue_alpha_zero_one +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.sparse_blue_alpha_zero_one dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.alpha_zero_one_red +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.sparse_alpha_zero_one_red dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.zero_one_red_green +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.sparse_zero_one_red_green dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.one_red_green_blue +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.texture_swizzle.sparse_one_red_green_blue dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.filter_mode.min_nearest_mipmap_nearest_mag_nearest +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.filter_mode.sparse_min_nearest_mipmap_nearest_mag_nearest dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.base_level.level_1 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.base_level.level_2 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.rgba8i.base_level.sparse_level_2 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_less.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_less.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_greater.clamp_to_edge_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_greater.repeat_mirrored_repeat +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.min_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.sparse_min_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.base_level.level_1 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.base_level.sparse_level_1 dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.base_level.level_2 +dEQP-VK.glsl.texture_gather.offsets.min_required_offset.2d_array.depth32f.base_level.sparse_level_2 dEQP-VK.glsl.builtin_var.gl_frontfacing dEQP-VK.glsl.builtin.function.common.abs.float_mediump_vertex dEQP-VK.glsl.builtin.function.common.abs.float_mediump_fragment -- 2.7.4