From dff48e37c7fbb98c14528f8a580058f81b6763e6 Mon Sep 17 00:00:00 2001 From: Juha Heiskanen Date: Thu, 17 Feb 2022 08:11:22 +0200 Subject: [PATCH] InterpolateAt{Offset, Sample} with linear interpolation tests This CL adds interpolateAtOffset and interpolateAtSample with linear interpolation tests for Vulkan. These new tests can also be run by using dynamic rendering. Components: Vulkan VK-GL-CTS Issue: 3191 New tests: dEQP-VK.draw.*.linear_interpolation.* Change-Id: I9a5d39d1c7cf2d1101dd380e481b155265793c25 --- AndroidGen.mk | 1 + android/cts/main/vk-master-2022-03-01/draw.txt | 42 ++ android/cts/main/vk-master/draw.txt | 42 ++ .../vulkancts/modules/vulkan/draw/CMakeLists.txt | 2 + .../vktDrawMultisampleLinearInterpolationTests.cpp | 614 +++++++++++++++++++++ .../vktDrawMultisampleLinearInterpolationTests.hpp | 40 ++ .../vulkancts/modules/vulkan/draw/vktDrawTests.cpp | 42 +- .../vulkancts/mustpass/main/vk-default/draw.txt | 42 ++ 8 files changed, 805 insertions(+), 20 deletions(-) create mode 100644 external/vulkancts/modules/vulkan/draw/vktDrawMultisampleLinearInterpolationTests.cpp create mode 100644 external/vulkancts/modules/vulkan/draw/vktDrawMultisampleLinearInterpolationTests.hpp diff --git a/AndroidGen.mk b/AndroidGen.mk index eca587a..2514402 100644 --- a/AndroidGen.mk +++ b/AndroidGen.mk @@ -142,6 +142,7 @@ LOCAL_SRC_FILES := \ external/vulkancts/modules/vulkan/draw/vktDrawMultiExtTests.cpp \ external/vulkancts/modules/vulkan/draw/vktDrawMultipleClearsWithinRenderPass.cpp \ external/vulkancts/modules/vulkan/draw/vktDrawMultipleInterpolationTests.cpp \ + external/vulkancts/modules/vulkan/draw/vktDrawMultisampleLinearInterpolationTests.cpp \ external/vulkancts/modules/vulkan/draw/vktDrawNegativeViewportHeightTests.cpp \ external/vulkancts/modules/vulkan/draw/vktDrawOutputLocationTests.cpp \ external/vulkancts/modules/vulkan/draw/vktDrawScissorTests.cpp \ diff --git a/android/cts/main/vk-master-2022-03-01/draw.txt b/android/cts/main/vk-master-2022-03-01/draw.txt index ae0d4f9..293bc37 100644 --- a/android/cts/main/vk-master-2022-03-01/draw.txt +++ b/android/cts/main/vk-master-2022-03-01/draw.txt @@ -324,6 +324,27 @@ dEQP-VK.draw.renderpass.multiple_interpolation.structured.no_sample_decoration.8 dEQP-VK.draw.renderpass.multiple_interpolation.structured.no_sample_decoration.16_samples dEQP-VK.draw.renderpass.multiple_interpolation.structured.no_sample_decoration.32_samples dEQP-VK.draw.renderpass.multiple_interpolation.structured.no_sample_decoration.64_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_1_sample +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_2_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_4_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_8_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_16_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_32_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_64_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_1_sample +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_2_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_4_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_8_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_16_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_32_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_64_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_1_sample +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_2_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_4_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_8_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_16_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_32_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_64_samples dEQP-VK.draw.renderpass.depth_clamp.d32_sfloat_clamp_four_viewports dEQP-VK.draw.renderpass.depth_clamp.d32_sfloat_s8_uint_clamp_four_viewports dEQP-VK.draw.renderpass.multi_draw.mosaic.normal.no_draws.stride_zero.no_instances.vert_only.single_view.no_offset @@ -6627,6 +6648,27 @@ dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_dec dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_decoration.16_samples dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_decoration.32_samples dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_decoration.64_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_1_sample +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_2_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_4_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_8_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_16_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_32_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_64_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_1_sample +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_2_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_4_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_8_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_16_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_32_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_64_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_1_sample +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_2_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_4_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_8_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_16_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_32_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_64_samples dEQP-VK.draw.dynamic_rendering.discard_rectangles.inclusive_rect_1 dEQP-VK.draw.dynamic_rendering.discard_rectangles.inclusive_rect_2 dEQP-VK.draw.dynamic_rendering.discard_rectangles.inclusive_rect_3 diff --git a/android/cts/main/vk-master/draw.txt b/android/cts/main/vk-master/draw.txt index a00cf05..eec15a2 100644 --- a/android/cts/main/vk-master/draw.txt +++ b/android/cts/main/vk-master/draw.txt @@ -1037,6 +1037,27 @@ dEQP-VK.draw.renderpass.multiple_interpolation.structured.with_sample_decoration dEQP-VK.draw.renderpass.multiple_interpolation.structured.with_sample_decoration.16_samples dEQP-VK.draw.renderpass.multiple_interpolation.structured.with_sample_decoration.32_samples dEQP-VK.draw.renderpass.multiple_interpolation.structured.with_sample_decoration.64_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_1_sample +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_2_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_4_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_8_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_16_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_32_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_64_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_1_sample +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_2_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_4_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_8_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_16_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_32_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_64_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_1_sample +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_2_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_4_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_8_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_16_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_32_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_64_samples dEQP-VK.draw.renderpass.discard_rectangles.inclusive_rect_1 dEQP-VK.draw.renderpass.discard_rectangles.inclusive_rect_2 dEQP-VK.draw.renderpass.discard_rectangles.inclusive_rect_3 @@ -7662,6 +7683,27 @@ dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_dec dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_decoration.16_samples dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_decoration.32_samples dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_decoration.64_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_1_sample +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_2_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_4_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_8_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_16_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_32_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_64_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_1_sample +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_2_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_4_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_8_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_16_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_32_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_64_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_1_sample +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_2_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_4_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_8_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_16_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_32_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_64_samples dEQP-VK.draw.dynamic_rendering.discard_rectangles.inclusive_rect_1 dEQP-VK.draw.dynamic_rendering.discard_rectangles.inclusive_rect_2 dEQP-VK.draw.dynamic_rendering.discard_rectangles.inclusive_rect_3 diff --git a/external/vulkancts/modules/vulkan/draw/CMakeLists.txt b/external/vulkancts/modules/vulkan/draw/CMakeLists.txt index 6aedceb..c01a8a9 100644 --- a/external/vulkancts/modules/vulkan/draw/CMakeLists.txt +++ b/external/vulkancts/modules/vulkan/draw/CMakeLists.txt @@ -45,6 +45,8 @@ set(DEQP_VK_DRAW_SRCS vktDrawScissorTests.cpp vktDrawMultipleInterpolationTests.hpp vktDrawMultipleInterpolationTests.cpp + vktDrawMultisampleLinearInterpolationTests.hpp + vktDrawMultisampleLinearInterpolationTests.cpp vktDrawDiscardRectanglesTests.hpp vktDrawDiscardRectanglesTests.cpp vktDrawExplicitVertexParameterTests.cpp diff --git a/external/vulkancts/modules/vulkan/draw/vktDrawMultisampleLinearInterpolationTests.cpp b/external/vulkancts/modules/vulkan/draw/vktDrawMultisampleLinearInterpolationTests.cpp new file mode 100644 index 0000000..d3753b0 --- /dev/null +++ b/external/vulkancts/modules/vulkan/draw/vktDrawMultisampleLinearInterpolationTests.cpp @@ -0,0 +1,614 @@ +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2022 The Khronos Group Inc. + * Copyright (c) 2022 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file vktDrawMultisampleLinearInterpolationTests.cpp + * \brief InterpolateAt tests with linear interpolation + *//*--------------------------------------------------------------------*/ + +#include "vktDrawMultisampleLinearInterpolationTests.hpp" + +#include "vktDrawBaseClass.hpp" +#include "vkQueryUtil.hpp" +#include "vkCmdUtil.hpp" +#include "vkTypeUtil.hpp" +#include "vktTestGroupUtil.hpp" + +namespace vkt +{ +namespace Draw +{ +namespace +{ +using namespace vk; + +class MultisampleLinearInterpolationTestInstance : public TestInstance +{ +public: + MultisampleLinearInterpolationTestInstance (Context& context, + const tcu::IVec2 renderSize, + const float interpolationRange, + const VkSampleCountFlagBits sampleCountFlagBits, + const bool useDynamicRendering) + : vkt::TestInstance (context) + , m_renderSize (renderSize) + , m_interpolationRange (interpolationRange) + , m_sampleCountFlagBits (sampleCountFlagBits) + , m_useDynamicRendering (useDynamicRendering) + {} + + ~MultisampleLinearInterpolationTestInstance (void) + {} + + tcu::TestStatus iterate (void); + +private: + const tcu::IVec2 m_renderSize; + const float m_interpolationRange; + const VkSampleCountFlagBits m_sampleCountFlagBits; + const bool m_useDynamicRendering; +}; + +tcu::TestStatus MultisampleLinearInterpolationTestInstance::iterate (void) +{ + const DeviceInterface& vk = m_context.getDeviceInterface(); + const VkDevice device = m_context.getDevice(); + + tcu::ConstPixelBufferAccess resultPixelBufferAccesses[2]; + de::SharedPtr colorTargetImages[2]; + de::SharedPtr multisampleImages[2]; + + const VkFormat imageColorFormat = VK_FORMAT_R8G8B8A8_UNORM; + + const std::string vertShadernames[2] = { "vertRef", "vertNoPer" }; + const std::string fragShadernames[2] = { "fragRef", "fragNoPer" }; + + tcu::TestLog& log = m_context.getTestContext().getLog(); + + const bool useMultisampling = m_sampleCountFlagBits == VK_SAMPLE_COUNT_1_BIT ? false : true; + + for (int draw = 0; draw < 2; draw++) + { + const Unique vs (createShaderModule(vk, device, m_context.getBinaryCollection().get(vertShadernames[draw].c_str()), 0)); + const Unique fs (createShaderModule(vk, device, m_context.getBinaryCollection().get(fragShadernames[draw].c_str()), 0)); + + de::SharedPtr vertexBuffer; + + const CmdPoolCreateInfo cmdPoolCreateInfo (m_context.getUniversalQueueFamilyIndex()); + Move cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo); + Move cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); + + Move renderPass; + + std::vector> colorTargetViews; + std::vector> multisampleViews; + + Move framebuffer; + + Move pipeline; + const PipelineLayoutCreateInfo pipelineLayoutCreateInfo; + Move pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo); + + const VkVertexInputAttributeDescription vertInAttrDescs[2] = + { + { 0u, 0u, VK_FORMAT_R32G32B32A32_SFLOAT, 0u }, + { 1u, 0u, VK_FORMAT_R32G32B32A32_SFLOAT, static_cast(sizeof(float) * 4) } + }; + + // Create color buffer images + { + const VkExtent3D targetImageExtent = { static_cast(m_renderSize.x()), static_cast(m_renderSize.y()), 1u }; + const VkImageUsageFlags usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; + const ImageCreateInfo targetImageCreateInfo (VK_IMAGE_TYPE_2D, + imageColorFormat, + targetImageExtent, + 1u, + 1u, + VK_SAMPLE_COUNT_1_BIT, + VK_IMAGE_TILING_OPTIMAL, + usage); + + colorTargetImages[draw] = Image::createAndAlloc(vk, device, targetImageCreateInfo, + m_context.getDefaultAllocator(), + m_context.getUniversalQueueFamilyIndex()); + + if (useMultisampling) + { + const ImageCreateInfo multisampleImageCreateInfo (VK_IMAGE_TYPE_2D, + imageColorFormat, + targetImageExtent, + 1u, + 1u, + m_sampleCountFlagBits, + VK_IMAGE_TILING_OPTIMAL, + usage); + + multisampleImages[draw] = Image::createAndAlloc(vk, device, multisampleImageCreateInfo, + m_context.getDefaultAllocator(), + m_context.getUniversalQueueFamilyIndex()); + } + } + + { + const ImageViewCreateInfo colorTargetViewInfo(colorTargetImages[draw]->object(), + VK_IMAGE_VIEW_TYPE_2D, + imageColorFormat); + + colorTargetViews.push_back(createImageView(vk, device, &colorTargetViewInfo)); + + if (useMultisampling) + { + const ImageViewCreateInfo multisamplingTargetViewInfo(multisampleImages[draw]->object(), + VK_IMAGE_VIEW_TYPE_2D, + imageColorFormat); + + multisampleViews.push_back(createImageView(vk, device, &multisamplingTargetViewInfo)); + } + } + + // Create render pass and frame buffer. + if (!m_useDynamicRendering) + { + RenderPassCreateInfo renderPassCreateInfo; + std::vector attachments; + std::vector colorAttachmentRefs; + std::vector multisampleAttachmentRefs; + deUint32 attachmentNdx = 0; + + { + const VkAttachmentReference colorAttachmentReference = + { + attachmentNdx++, // uint32_t attachment; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; + }; + + colorAttachmentRefs.push_back(colorAttachmentReference); + + renderPassCreateInfo.addAttachment(AttachmentDescription(imageColorFormat, + VK_SAMPLE_COUNT_1_BIT, + VK_ATTACHMENT_LOAD_OP_CLEAR, + VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_LOAD_OP_DONT_CARE, + VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)); + + if (useMultisampling) + { + const VkAttachmentReference multiSampleAttachmentReference = + { + attachmentNdx++, // uint32_t attachment; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; + }; + + multisampleAttachmentRefs.push_back(multiSampleAttachmentReference); + + renderPassCreateInfo.addAttachment(AttachmentDescription(imageColorFormat, + m_sampleCountFlagBits, + VK_ATTACHMENT_LOAD_OP_CLEAR, + VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_ATTACHMENT_LOAD_OP_DONT_CARE, + VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)); + } + } + + renderPassCreateInfo.addSubpass(SubpassDescription(VK_PIPELINE_BIND_POINT_GRAPHICS, + 0, + 0, + DE_NULL, + (deUint32)colorAttachmentRefs.size(), + useMultisampling ? &multisampleAttachmentRefs[0] : &colorAttachmentRefs[0], + useMultisampling ? &colorAttachmentRefs[0] : DE_NULL, + AttachmentReference(), + 0, + DE_NULL)); + + renderPass = createRenderPass(vk, device, &renderPassCreateInfo); + + for (deUint32 frameNdx = 0; frameNdx < colorTargetViews.size(); frameNdx++) + { + attachments.push_back(*colorTargetViews[frameNdx]); + + if (useMultisampling) + attachments.push_back(*multisampleViews[frameNdx]); + } + + const VkFramebufferCreateInfo framebufferCreateInfo = + { + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkFramebufferCreateFlags flags; + *renderPass, // VkRenderPass renderPass; + static_cast(attachments.size()), // uint32_t attachmentCount; + &attachments[0], // const VkImageView* pAttachments; + static_cast(m_renderSize.x()), // uint32_t width; + static_cast(m_renderSize.y()), // uint32_t height; + 1u // uint32_t layers; + }; + + framebuffer = createFramebuffer(vk, device, &framebufferCreateInfo); + } + + // Create vertex buffer. + { + const PositionColorVertex vertices[] = + { + // The first draw is for reference image. + /* ____ ____ */ + /* / \ | | */ + /* / \ |____| */ + /* / \ */ + /* /__________\ */ + /* */ + /* result reference */ + /* */ + // In result shape the bottom vertices are deeper. When the drawn result image is a perfect square, + // and color comparison with reference image is easy to make. + PositionColorVertex(tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), tcu::Vec4(0.0f, m_interpolationRange, 0.0f, m_interpolationRange)), // Top Right + PositionColorVertex(tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), tcu::Vec4(m_interpolationRange * 0.5f, m_interpolationRange * 0.5f, 0.0f, m_interpolationRange)), // Top Left + PositionColorVertex(tcu::Vec4( draw == 0 ? 1.0f : 2.0f, draw == 0 ? 1.0f : 2.0f, 0.0f, draw == 0 ? 1.0f : 2.0f), tcu::Vec4(m_interpolationRange * 0.5f, m_interpolationRange * 0.5f, 0.0f, m_interpolationRange)), // Bottom Right + PositionColorVertex(tcu::Vec4( draw == 0 ? -1.0f : -2.0f, draw == 0 ? 1.0f : 2.0f, 0.0f, draw == 0 ? 1.0f : 2.0f), tcu::Vec4(m_interpolationRange, 0.0f, 0.0f, m_interpolationRange)), // Bottom Left + PositionColorVertex(tcu::Vec4( draw == 0 ? 1.0f : 2.0f, draw == 0 ? 1.0f : 2.0f, 0.0f, draw == 0 ? 1.0f : 2.0f), tcu::Vec4(m_interpolationRange * 0.5f, m_interpolationRange * 0.5f, 0.0f, m_interpolationRange)), // Bottom Right + PositionColorVertex(tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), tcu::Vec4(m_interpolationRange * 0.5f, m_interpolationRange * 0.5f, 0.0f, m_interpolationRange)) // Top Left + }; + + const VkDeviceSize dataSize = sizeof(vertices); + vertexBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(dataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible); + deUint8* ptr = static_cast(vertexBuffer->getBoundMemory().getHostPtr()); + + deMemcpy(ptr, vertices, static_cast(dataSize)); + flushMappedMemoryRange(vk, device, vertexBuffer->getBoundMemory().getMemory(), vertexBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE); + } + + // Create pipeline. + { + const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState; + + VkViewport viewport = makeViewport(m_renderSize.x(), m_renderSize.y()); + VkRect2D scissor = makeRect2D(m_renderSize.x(), m_renderSize.y()); + + const std::vector sampleMask = { 0xfffffff, 0xfffffff }; + + const VkVertexInputBindingDescription vertexInputBindingDescription = { 0, (deUint32)sizeof(tcu::Vec4) * 2, VK_VERTEX_INPUT_RATE_VERTEX }; + PipelineCreateInfo::VertexInputState vertexInputState = PipelineCreateInfo::VertexInputState(1, &vertexInputBindingDescription, 2, vertInAttrDescs); + + PipelineCreateInfo pipelineCreateInfo(*pipelineLayout, *renderPass, 0, 0); + + pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", VK_SHADER_STAGE_VERTEX_BIT)); + pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", VK_SHADER_STAGE_FRAGMENT_BIT)); + pipelineCreateInfo.addState(PipelineCreateInfo::VertexInputState(vertexInputState)); + pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)); + pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &vkCbAttachmentState)); + pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1, std::vector(1, viewport), std::vector(1, scissor))); + pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState()); + pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState()); + pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState(m_sampleCountFlagBits, false, 0.0f, sampleMask)); + + VkPipelineRenderingCreateInfo renderingCreateInfo + { + VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR, + DE_NULL, + 0u, + 1u, + &imageColorFormat, + VK_FORMAT_UNDEFINED, + VK_FORMAT_UNDEFINED + }; + + if (m_useDynamicRendering) + pipelineCreateInfo.pNext = &renderingCreateInfo; + + pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo); + } + + // Draw quad and read results. + { + const VkQueue queue = m_context.getUniversalQueue(); + const VkClearValue clearColor = { { { 0.0f, 0.0f, 0.0f, 1.0f } } }; + const ImageSubresourceRange subresourceRange (VK_IMAGE_ASPECT_COLOR_BIT); + const VkRect2D renderArea = makeRect2D(m_renderSize.x(), m_renderSize.y()); + const VkDeviceSize vertexBufferOffset = 0; + const VkBuffer buffer = vertexBuffer->object(); + const VkOffset3D zeroOffset = { 0, 0, 0 }; + + std::vector clearValues (2, clearColor); + + clearColorImage(vk, device, queue, m_context.getUniversalQueueFamilyIndex(), + colorTargetImages[draw]->object(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f), + VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u, 1u); + + beginCommandBuffer(vk, *cmdBuffer, 0u); + + if (m_useDynamicRendering) + { + const deUint32 imagesCount = static_cast(colorTargetViews.size()); + + std::vector colorAttachments(imagesCount, + { + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType; + DE_NULL, // const void* pNext; + DE_NULL, // VkImageView imageView; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout imageLayout; + VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode; + DE_NULL, // VkImageView resolveImageView; + VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout resolveImageLayout; + VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; + VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; + clearColor // VkClearValue clearValue; + }); + + for (deUint32 i = 0; i < imagesCount; ++i) + { + if (useMultisampling) + { + colorAttachments[i].imageView = *multisampleViews[i]; + colorAttachments[i].resolveMode = VK_RESOLVE_MODE_AVERAGE_BIT; + colorAttachments[i].resolveImageView = *colorTargetViews[i]; + } + else + { + colorAttachments[i].imageView = *colorTargetViews[i]; + } + } + + VkRenderingInfo renderingInfo + { + VK_STRUCTURE_TYPE_RENDERING_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0, // VkRenderingFlagsKHR flags; + renderArea, // VkRect2D renderArea; + 1u, // deUint32 layerCount; + 0u, // deUint32 viewMask; + imagesCount, // deUint32 colorAttachmentCount; + colorAttachments.data(), // const VkRenderingAttachmentInfoKHR* pColorAttachments; + DE_NULL, // const VkRenderingAttachmentInfoKHR* pDepthAttachment; + DE_NULL, // const VkRenderingAttachmentInfoKHR* pStencilAttachment; + }; + + // Transition Images + initialTransitionColor2DImage(vk, *cmdBuffer, colorTargetImages[draw]->object(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT); + + if (useMultisampling) + { + initialTransitionColor2DImage(vk, *cmdBuffer, multisampleImages[draw]->object(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT); + } + + vk.cmdBeginRendering(*cmdBuffer, &renderingInfo); + } + else + { + const deUint32 imagesCount = static_cast(colorTargetViews.size() + multisampleViews.size()); + beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, imagesCount, &clearValues[0]); + } + + vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &buffer, &vertexBufferOffset); + vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); + vk.cmdDraw(*cmdBuffer, 6u, 1u, 0u, 0u); + + if (m_useDynamicRendering) + endRendering(vk, *cmdBuffer); + else + endRenderPass(vk, *cmdBuffer); + + endCommandBuffer(vk, *cmdBuffer); + + submitCommandsAndWait(vk, device, queue, cmdBuffer.get()); + + resultPixelBufferAccesses[draw] = colorTargetImages[draw]->readSurface(queue, m_context.getDefaultAllocator(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, zeroOffset, m_renderSize.x(), m_renderSize.y(), VK_IMAGE_ASPECT_COLOR_BIT); + } + } + + if (!tcu::floatThresholdCompare(log, "Result", "Image comparison result", resultPixelBufferAccesses[0], resultPixelBufferAccesses[1], tcu::Vec4(0.005f), tcu::COMPARE_LOG_RESULT)) + return tcu::TestStatus::fail("Rendered color image is not correct"); + + return tcu::TestStatus::pass("Success"); +} + +class MultisampleLinearInterpolationTestCase : public TestCase +{ + public: + MultisampleLinearInterpolationTestCase (tcu::TestContext& context, + const char* name, + const char* desc, + const tcu::IVec2 renderSize, + const float interpolationRange, + const tcu::Vec2 offset, + const VkSampleCountFlagBits sampleCountFlagBits, + const bool useDynamicRendering) + : vkt::TestCase(context, name, desc) + , m_renderSize (renderSize) + , m_interpolationRange (interpolationRange) + , m_offset (offset) + , m_sampleCountFlagBits (sampleCountFlagBits) + , m_useDynamicRendering (useDynamicRendering) + {} + + ~MultisampleLinearInterpolationTestCase (void) + {} + + virtual void initPrograms (SourceCollections& programCollection) const; + virtual void checkSupport (Context& context) const; + virtual TestInstance* createInstance (Context& context) const; + +private: + const tcu::IVec2 m_renderSize; + const float m_interpolationRange; + const tcu::Vec2 m_offset; + const VkSampleCountFlagBits m_sampleCountFlagBits; + const bool m_useDynamicRendering; +}; + +void MultisampleLinearInterpolationTestCase::initPrograms (SourceCollections& programCollection) const +{ + // Reference vertex shader. + { + std::ostringstream vrt; + + vrt << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" + << "\n" + << "layout(location = 0) in vec4 in_position;\n" + << "layout(location = 1) in vec4 in_color;\n" + << "layout(location = 0) out vec4 out_color;\n" + << "\n" + << "void main()\n" + << "{\n" + << " gl_PointSize = 1.0;\n" + << " gl_Position = in_position;\n" + << " out_color = in_color;\n" + << "}\n"; + + programCollection.glslSources.add("vertRef") << glu::VertexSource(vrt.str()); + } + + // Noperspective vertex shader. + { + std::ostringstream vrt; + + vrt << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" + << "\n" + << "layout(location = 0) in vec4 in_position;\n" + << "layout(location = 1) in vec4 in_color;\n" + << "layout(location = 0) noperspective out vec4 out_color;\n" + << "\n" + << "void main()\n" + << "{\n" + << " gl_PointSize = 1.0;\n" + << " gl_Position = in_position;\n" + << " out_color = in_color;\n" + << "}\n"; + + programCollection.glslSources.add("vertNoPer") << glu::VertexSource(vrt.str()); + } + + // Reference fragment shader. + { + std::ostringstream frg; + + frg << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" + << "layout(location = 0) in vec4 in_color;\n" + << "layout(location = 0) out vec4 out_color;\n" + << "void main()\n" + << "{\n" + << " vec4 out_color_y = mix(vec4(0.0, 1.0, 0.0, 1.0), vec4(1.0, 0.0, 0.0, 1.0), gl_FragCoord.y / " << static_cast(m_renderSize.y()) << " + " << m_offset.y() / static_cast(m_renderSize.y()) << ");\n" + << " vec4 out_color_x = mix(vec4(1.0, 0.0, 0.0, 1.0), vec4(0.0, 1.0, 0.0, 1.0), gl_FragCoord.x / " << static_cast(m_renderSize.x()) << " + " << m_offset.x() / static_cast(m_renderSize.x()) << ");\n" + << " out_color = 0.5 * (out_color_y + out_color_x);\n" + << "}\n"; + + programCollection.glslSources.add("fragRef") << glu::FragmentSource(frg.str()); + } + + // Noperspective fragment shader. + { + std::ostringstream frg; + + frg << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" + << "layout(location = 0) noperspective in vec4 in_color;\n" + << "layout(location = 0) out vec4 out_color;\n" + << "void main()\n" + << "{\n" + << " vec4 out_color_offset = interpolateAtOffset(in_color, vec2(" << m_offset.x() << ", " << m_offset.y() << "));\n" + << " vec4 out_color_sample = interpolateAtSample(in_color, gl_SampleID);\n" + << " out_color = (0.5 * (out_color_offset + out_color_sample));\n" + << " out_color /= " << m_interpolationRange << ";\n"; + + // Run additional sample comparison test. If it fails, we write 1.0 to blue color channel. + frg << " if (out_color_sample != interpolateAtOffset(in_color, gl_SamplePosition - vec2(0.5)))\n" + << " {\n" + << " out_color.z = 1.0;\n" + << " }\n"; + + frg << "}\n"; + + programCollection.glslSources.add("fragNoPer") << glu::FragmentSource(frg.str()); + } +} + +void MultisampleLinearInterpolationTestCase::checkSupport (Context& context) const +{ + if (!(m_sampleCountFlagBits & context.getDeviceProperties().limits.framebufferColorSampleCounts)) + TCU_THROW(NotSupportedError, "Multisampling with " + de::toString(m_sampleCountFlagBits) + " samples not supported"); + + if (m_useDynamicRendering) + context.requireDeviceFunctionality("VK_KHR_dynamic_rendering"); + + if (context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") && + !context.getPortabilitySubsetFeatures().shaderSampleRateInterpolationFunctions) + { + TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Shader sample rate interpolation functions are not supported by this implementation"); + } +} + +TestInstance* MultisampleLinearInterpolationTestCase::createInstance (Context& context) const +{ + return new MultisampleLinearInterpolationTestInstance(context, m_renderSize, m_interpolationRange, m_sampleCountFlagBits, m_useDynamicRendering); +} + +void createTests (tcu::TestCaseGroup* testGroup, bool useDynamicRendering) +{ + tcu::TestContext& testCtx = testGroup->getTestContext(); + + struct + { + const std::string name; + const tcu::Vec2 value; + } offsets[] = + { + { "no_offset", tcu::Vec2(0.0f, 0.0f) }, + { "offset_min", tcu::Vec2(-0.5f, -0.5f) }, + { "offset_max", tcu::Vec2(0.4375f, 0.4375f) } + }; + + struct + { + const std::string name; + VkSampleCountFlagBits value; + } flagBits[] = + { + { "1_sample", VK_SAMPLE_COUNT_1_BIT }, + { "2_samples", VK_SAMPLE_COUNT_2_BIT }, + { "4_samples", VK_SAMPLE_COUNT_4_BIT }, + { "8_samples", VK_SAMPLE_COUNT_8_BIT }, + { "16_samples", VK_SAMPLE_COUNT_16_BIT }, + { "32_samples", VK_SAMPLE_COUNT_32_BIT }, + { "64_samples", VK_SAMPLE_COUNT_64_BIT } + }; + + for (const auto& offset : offsets) + { + for (const auto& flagBit : flagBits) + { + testGroup->addChild(new MultisampleLinearInterpolationTestCase(testCtx, (offset.name + "_" + flagBit.name).c_str(), ".", tcu::IVec2(16, 16), 1.0f, offset.value, flagBit.value, useDynamicRendering)); + } + } +} + +} // anonymous + +tcu::TestCaseGroup* createMultisampleLinearInterpolationTests (tcu::TestContext& testCtx, bool useDynamicRendering) +{ + return createTestGroup(testCtx, "linear_interpolation", "Tests for linear interpolation decorations.", createTests, useDynamicRendering); +} + +} // Draw +} // vkt diff --git a/external/vulkancts/modules/vulkan/draw/vktDrawMultisampleLinearInterpolationTests.hpp b/external/vulkancts/modules/vulkan/draw/vktDrawMultisampleLinearInterpolationTests.hpp new file mode 100644 index 0000000..a613e16 --- /dev/null +++ b/external/vulkancts/modules/vulkan/draw/vktDrawMultisampleLinearInterpolationTests.hpp @@ -0,0 +1,40 @@ +#ifndef _VKTDRAWMULTISAMPLELINEARINTERPOLATIONTESTS_HPP +#define _VKTDRAWMULTISAMPLELINEARINTERPOLATIONTESTS_HPP +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2022 The Khronos Group Inc. + * Copyright (c) 2022 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file vktDrawMultisampleLinearInterpolationTests.hpp + * \brief InterpolateAt tests with linear interpolation + *//*--------------------------------------------------------------------*/ + +#include "vkDefs.hpp" +#include "vktTestCase.hpp" + +namespace vkt +{ +namespace Draw +{ + +tcu::TestCaseGroup* createMultisampleLinearInterpolationTests (tcu::TestContext& testCtx, bool useDynamicRendering); + +} // Draw +} // vkt + +#endif // _VKTDRAWMULTISAMPLELINEARINTERPOLATIONTESTS_HPP diff --git a/external/vulkancts/modules/vulkan/draw/vktDrawTests.cpp b/external/vulkancts/modules/vulkan/draw/vktDrawTests.cpp index 0c78d8c..a214f79 100644 --- a/external/vulkancts/modules/vulkan/draw/vktDrawTests.cpp +++ b/external/vulkancts/modules/vulkan/draw/vktDrawTests.cpp @@ -39,6 +39,7 @@ #include "vktDrawShaderViewportIndexTests.hpp" #include "vktDrawScissorTests.hpp" #include "vktDrawMultipleInterpolationTests.hpp" +#include "vktDrawMultisampleLinearInterpolationTests.hpp" #include "vktDrawDiscardRectanglesTests.hpp" #include "vktDrawExplicitVertexParameterTests.hpp" #include "vktDrawOutputLocationTests.hpp" @@ -58,26 +59,27 @@ namespace void createChildren (tcu::TestContext& testCtx, tcu::TestCaseGroup* group, bool useDynamicRendering) { - group->addChild(new ConcurrentDrawTests (testCtx, useDynamicRendering)); - group->addChild(new SimpleDrawTests (testCtx, useDynamicRendering)); - group->addChild(new DrawIndexedTests (testCtx, useDynamicRendering)); - group->addChild(new IndirectDrawTests (testCtx, useDynamicRendering)); - group->addChild(createBasicDrawTests (testCtx, useDynamicRendering)); - group->addChild(new InstancedTests (testCtx, useDynamicRendering)); - group->addChild(new ShaderDrawParametersTests (testCtx, useDynamicRendering)); - group->addChild(createNegativeViewportHeightTests (testCtx, useDynamicRendering)); - group->addChild(createZeroViewportHeightTests (testCtx, useDynamicRendering)); - group->addChild(createInvertedDepthRangesTests (testCtx, useDynamicRendering)); - group->addChild(createDifferingInterpolationTests (testCtx, useDynamicRendering)); - group->addChild(createShaderLayerTests (testCtx, useDynamicRendering)); - group->addChild(createShaderViewportIndexTests (testCtx, useDynamicRendering)); - group->addChild(createScissorTests (testCtx, useDynamicRendering)); - group->addChild(createMultipleInterpolationTests (testCtx, useDynamicRendering)); - group->addChild(createDiscardRectanglesTests (testCtx, useDynamicRendering)); - group->addChild(createExplicitVertexParameterTests (testCtx, useDynamicRendering)); - group->addChild(createDepthClampTests (testCtx, useDynamicRendering)); - group->addChild(new MultipleClearsWithinRenderPassTests (testCtx, useDynamicRendering)); - group->addChild(createDrawMultiExtTests (testCtx, useDynamicRendering)); + group->addChild(new ConcurrentDrawTests (testCtx, useDynamicRendering)); + group->addChild(new SimpleDrawTests (testCtx, useDynamicRendering)); + group->addChild(new DrawIndexedTests (testCtx, useDynamicRendering)); + group->addChild(new IndirectDrawTests (testCtx, useDynamicRendering)); + group->addChild(createBasicDrawTests (testCtx, useDynamicRendering)); + group->addChild(new InstancedTests (testCtx, useDynamicRendering)); + group->addChild(new ShaderDrawParametersTests (testCtx, useDynamicRendering)); + group->addChild(createNegativeViewportHeightTests (testCtx, useDynamicRendering)); + group->addChild(createZeroViewportHeightTests (testCtx, useDynamicRendering)); + group->addChild(createInvertedDepthRangesTests (testCtx, useDynamicRendering)); + group->addChild(createDifferingInterpolationTests (testCtx, useDynamicRendering)); + group->addChild(createShaderLayerTests (testCtx, useDynamicRendering)); + group->addChild(createShaderViewportIndexTests (testCtx, useDynamicRendering)); + group->addChild(createScissorTests (testCtx, useDynamicRendering)); + group->addChild(createMultipleInterpolationTests (testCtx, useDynamicRendering)); + group->addChild(createMultisampleLinearInterpolationTests (testCtx, useDynamicRendering)); + group->addChild(createDiscardRectanglesTests (testCtx, useDynamicRendering)); + group->addChild(createExplicitVertexParameterTests (testCtx, useDynamicRendering)); + group->addChild(createDepthClampTests (testCtx, useDynamicRendering)); + group->addChild(new MultipleClearsWithinRenderPassTests (testCtx, useDynamicRendering)); + group->addChild(createDrawMultiExtTests (testCtx, useDynamicRendering)); if (!useDynamicRendering) { diff --git a/external/vulkancts/mustpass/main/vk-default/draw.txt b/external/vulkancts/mustpass/main/vk-default/draw.txt index bbb8270..5ccbcbc 100644 --- a/external/vulkancts/mustpass/main/vk-default/draw.txt +++ b/external/vulkancts/mustpass/main/vk-default/draw.txt @@ -1038,6 +1038,27 @@ dEQP-VK.draw.renderpass.multiple_interpolation.structured.with_sample_decoration dEQP-VK.draw.renderpass.multiple_interpolation.structured.with_sample_decoration.16_samples dEQP-VK.draw.renderpass.multiple_interpolation.structured.with_sample_decoration.32_samples dEQP-VK.draw.renderpass.multiple_interpolation.structured.with_sample_decoration.64_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_1_sample +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_2_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_4_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_8_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_16_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_32_samples +dEQP-VK.draw.renderpass.linear_interpolation.no_offset_64_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_1_sample +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_2_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_4_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_8_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_16_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_32_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_min_64_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_1_sample +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_2_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_4_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_8_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_16_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_32_samples +dEQP-VK.draw.renderpass.linear_interpolation.offset_max_64_samples dEQP-VK.draw.renderpass.discard_rectangles.inclusive_rect_1 dEQP-VK.draw.renderpass.discard_rectangles.inclusive_rect_2 dEQP-VK.draw.renderpass.discard_rectangles.inclusive_rect_3 @@ -7664,6 +7685,27 @@ dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_dec dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_decoration.16_samples dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_decoration.32_samples dEQP-VK.draw.dynamic_rendering.multiple_interpolation.structured.with_sample_decoration.64_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_1_sample +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_2_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_4_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_8_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_16_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_32_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.no_offset_64_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_1_sample +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_2_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_4_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_8_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_16_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_32_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_min_64_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_1_sample +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_2_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_4_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_8_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_16_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_32_samples +dEQP-VK.draw.dynamic_rendering.linear_interpolation.offset_max_64_samples dEQP-VK.draw.dynamic_rendering.discard_rectangles.inclusive_rect_1 dEQP-VK.draw.dynamic_rendering.discard_rectangles.inclusive_rect_2 dEQP-VK.draw.dynamic_rendering.discard_rectangles.inclusive_rect_3 -- 2.7.4