1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015 The Khronos Group Inc.
6 * Copyright (c) 2015 Imagination Technologies Ltd.
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
22 * \brief Multisample Tests
23 *//*--------------------------------------------------------------------*/
25 #include "vktPipelineMultisampleTests.hpp"
26 #include "vktPipelineMultisampleImageTests.hpp"
27 #include "vktPipelineClearUtil.hpp"
28 #include "vktPipelineImageUtil.hpp"
29 #include "vktPipelineVertexUtil.hpp"
30 #include "vktPipelineReferenceRenderer.hpp"
31 #include "vktTestCase.hpp"
32 #include "vktTestCaseUtil.hpp"
33 #include "vkImageUtil.hpp"
34 #include "vkMemUtil.hpp"
35 #include "vkPrograms.hpp"
36 #include "vkQueryUtil.hpp"
38 #include "vkRefUtil.hpp"
39 #include "tcuImageCompare.hpp"
40 #include "deUniquePtr.hpp"
41 #include "deSharedPtr.hpp"
42 #include "deStringUtil.hpp"
60 GEOMETRY_TYPE_OPAQUE_TRIANGLE,
61 GEOMETRY_TYPE_OPAQUE_LINE,
62 GEOMETRY_TYPE_OPAQUE_POINT,
63 GEOMETRY_TYPE_OPAQUE_QUAD,
64 GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH, //!< placed at z = 0.5
65 GEOMETRY_TYPE_TRANSLUCENT_QUAD,
66 GEOMETRY_TYPE_INVISIBLE_TRIANGLE,
67 GEOMETRY_TYPE_INVISIBLE_QUAD,
68 GEOMETRY_TYPE_GRADIENT_QUAD
73 TEST_MODE_DEPTH_BIT = 1u,
74 TEST_MODE_STENCIL_BIT = 2u,
76 typedef deUint32 TestModeFlags;
78 void initMultisamplePrograms (SourceCollections& sources, GeometryType geometryType);
79 bool isSupportedSampleCount (const InstanceInterface& instanceInterface, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits rasterizationSamples);
80 bool isSupportedDepthStencilFormat (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkFormat format);
81 VkPipelineColorBlendAttachmentState getDefaultColorBlendAttachmentState (void);
82 deUint32 getUniqueColorsCount (const tcu::ConstPixelBufferAccess& image);
83 VkImageAspectFlags getImageAspectFlags (const VkFormat format);
84 VkPrimitiveTopology getPrimitiveTopology (const GeometryType geometryType);
85 std::vector<Vertex4RGBA> generateVertices (const GeometryType geometryType);
86 VkFormat findSupportedDepthStencilFormat (Context& context, const bool useDepth, const bool useStencil);
88 class MultisampleTest : public vkt::TestCase
92 MultisampleTest (tcu::TestContext& testContext,
93 const std::string& name,
94 const std::string& description,
95 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
96 const VkPipelineColorBlendAttachmentState& blendState,
97 GeometryType geometryType);
98 virtual ~MultisampleTest (void) {}
100 virtual void initPrograms (SourceCollections& programCollection) const;
101 virtual TestInstance* createInstance (Context& context) const;
104 virtual TestInstance* createMultisampleTestInstance (Context& context,
105 VkPrimitiveTopology topology,
106 const std::vector<Vertex4RGBA>& vertices,
107 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
108 const VkPipelineColorBlendAttachmentState& colorBlendState) const = 0;
109 VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
110 const VkPipelineColorBlendAttachmentState m_colorBlendState;
111 const GeometryType m_geometryType;
112 std::vector<VkSampleMask> m_sampleMask;
115 class RasterizationSamplesTest : public MultisampleTest
118 RasterizationSamplesTest (tcu::TestContext& testContext,
119 const std::string& name,
120 const std::string& description,
121 VkSampleCountFlagBits rasterizationSamples,
122 GeometryType geometryType,
123 TestModeFlags modeFlags = 0u);
124 virtual ~RasterizationSamplesTest (void) {}
127 virtual TestInstance* createMultisampleTestInstance (Context& context,
128 VkPrimitiveTopology topology,
129 const std::vector<Vertex4RGBA>& vertices,
130 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
131 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
133 static VkPipelineMultisampleStateCreateInfo getRasterizationSamplesStateParams (VkSampleCountFlagBits rasterizationSamples);
135 const TestModeFlags m_modeFlags;
138 class MinSampleShadingTest : public MultisampleTest
141 MinSampleShadingTest (tcu::TestContext& testContext,
142 const std::string& name,
143 const std::string& description,
144 VkSampleCountFlagBits rasterizationSamples,
145 float minSampleShading,
146 GeometryType geometryType);
147 virtual ~MinSampleShadingTest (void) {}
150 virtual TestInstance* createMultisampleTestInstance (Context& context,
151 VkPrimitiveTopology topology,
152 const std::vector<Vertex4RGBA>& vertices,
153 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
154 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
156 static VkPipelineMultisampleStateCreateInfo getMinSampleShadingStateParams (VkSampleCountFlagBits rasterizationSamples, float minSampleShading);
159 class SampleMaskTest : public MultisampleTest
162 SampleMaskTest (tcu::TestContext& testContext,
163 const std::string& name,
164 const std::string& description,
165 VkSampleCountFlagBits rasterizationSamples,
166 const std::vector<VkSampleMask>& sampleMask,
167 GeometryType geometryType);
169 virtual ~SampleMaskTest (void) {}
172 virtual TestInstance* createMultisampleTestInstance (Context& context,
173 VkPrimitiveTopology topology,
174 const std::vector<Vertex4RGBA>& vertices,
175 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
176 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
178 static VkPipelineMultisampleStateCreateInfo getSampleMaskStateParams (VkSampleCountFlagBits rasterizationSamples, const std::vector<VkSampleMask>& sampleMask);
181 class AlphaToOneTest : public MultisampleTest
184 AlphaToOneTest (tcu::TestContext& testContext,
185 const std::string& name,
186 const std::string& description,
187 VkSampleCountFlagBits rasterizationSamples);
189 virtual ~AlphaToOneTest (void) {}
192 virtual TestInstance* createMultisampleTestInstance (Context& context,
193 VkPrimitiveTopology topology,
194 const std::vector<Vertex4RGBA>& vertices,
195 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
196 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
198 static VkPipelineMultisampleStateCreateInfo getAlphaToOneStateParams (VkSampleCountFlagBits rasterizationSamples);
199 static VkPipelineColorBlendAttachmentState getAlphaToOneBlendState (void);
202 class AlphaToCoverageTest : public MultisampleTest
205 AlphaToCoverageTest (tcu::TestContext& testContext,
206 const std::string& name,
207 const std::string& description,
208 VkSampleCountFlagBits rasterizationSamples,
209 GeometryType geometryType);
211 virtual ~AlphaToCoverageTest (void) {}
214 virtual TestInstance* createMultisampleTestInstance (Context& context,
215 VkPrimitiveTopology topology,
216 const std::vector<Vertex4RGBA>& vertices,
217 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
218 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
220 static VkPipelineMultisampleStateCreateInfo getAlphaToCoverageStateParams (VkSampleCountFlagBits rasterizationSamples);
222 GeometryType m_geometryType;
225 typedef de::SharedPtr<Unique<VkPipeline> > VkPipelineSp;
227 class MultisampleRenderer
230 MultisampleRenderer (Context& context,
231 const VkFormat colorFormat,
232 const tcu::IVec2& renderSize,
233 const VkPrimitiveTopology topology,
234 const std::vector<Vertex4RGBA>& vertices,
235 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
236 const VkPipelineColorBlendAttachmentState& blendState);
238 MultisampleRenderer (Context& context,
239 const VkFormat colorFormat,
240 const VkFormat depthStencilFormat,
241 const tcu::IVec2& renderSize,
243 const bool useStencil,
244 const deUint32 numTopologies,
245 const VkPrimitiveTopology* pTopology,
246 const std::vector<Vertex4RGBA>* pVertices,
247 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
248 const VkPipelineColorBlendAttachmentState& blendState);
250 virtual ~MultisampleRenderer (void);
252 de::MovePtr<tcu::TextureLevel> render (void);
255 void initialize (Context& context,
256 const deUint32 numTopologies,
257 const VkPrimitiveTopology* pTopology,
258 const std::vector<Vertex4RGBA>* pVertices);
262 const VkFormat m_colorFormat;
263 const VkFormat m_depthStencilFormat;
264 tcu::IVec2 m_renderSize;
265 const bool m_useDepth;
266 const bool m_useStencil;
268 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
269 const VkPipelineColorBlendAttachmentState m_colorBlendState;
271 Move<VkImage> m_colorImage;
272 de::MovePtr<Allocation> m_colorImageAlloc;
273 Move<VkImageView> m_colorAttachmentView;
275 Move<VkImage> m_resolveImage;
276 de::MovePtr<Allocation> m_resolveImageAlloc;
277 Move<VkImageView> m_resolveAttachmentView;
279 Move<VkImage> m_depthStencilImage;
280 de::MovePtr<Allocation> m_depthStencilImageAlloc;
281 Move<VkImageView> m_depthStencilAttachmentView;
283 Move<VkRenderPass> m_renderPass;
284 Move<VkFramebuffer> m_framebuffer;
286 Move<VkShaderModule> m_vertexShaderModule;
287 Move<VkShaderModule> m_fragmentShaderModule;
289 Move<VkBuffer> m_vertexBuffer;
290 de::MovePtr<Allocation> m_vertexBufferAlloc;
292 Move<VkPipelineLayout> m_pipelineLayout;
293 std::vector<VkPipelineSp> m_graphicsPipelines;
295 Move<VkCommandPool> m_cmdPool;
296 Move<VkCommandBuffer> m_cmdBuffer;
298 Move<VkFence> m_fence;
301 class RasterizationSamplesInstance : public vkt::TestInstance
304 RasterizationSamplesInstance (Context& context,
305 VkPrimitiveTopology topology,
306 const std::vector<Vertex4RGBA>& vertices,
307 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
308 const VkPipelineColorBlendAttachmentState& blendState,
309 const TestModeFlags modeFlags);
310 virtual ~RasterizationSamplesInstance (void) {}
312 virtual tcu::TestStatus iterate (void);
315 virtual tcu::TestStatus verifyImage (const tcu::ConstPixelBufferAccess& result);
317 const VkFormat m_colorFormat;
318 const tcu::IVec2 m_renderSize;
319 const VkPrimitiveTopology m_primitiveTopology;
320 const std::vector<Vertex4RGBA> m_vertices;
321 const std::vector<Vertex4RGBA> m_fullQuadVertices; //!< used by depth/stencil case
322 const TestModeFlags m_modeFlags;
323 de::MovePtr<MultisampleRenderer> m_multisampleRenderer;
326 class MinSampleShadingInstance : public vkt::TestInstance
329 MinSampleShadingInstance (Context& context,
330 VkPrimitiveTopology topology,
331 const std::vector<Vertex4RGBA>& vertices,
332 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
333 const VkPipelineColorBlendAttachmentState& blendState);
334 virtual ~MinSampleShadingInstance (void) {}
336 virtual tcu::TestStatus iterate (void);
339 virtual tcu::TestStatus verifyImage (const tcu::ConstPixelBufferAccess& testShadingImage,
340 const tcu::ConstPixelBufferAccess& minShadingImage,
341 const tcu::ConstPixelBufferAccess& maxShadingImage);
342 const VkFormat m_colorFormat;
343 const tcu::IVec2 m_renderSize;
344 const VkPrimitiveTopology m_primitiveTopology;
345 const std::vector<Vertex4RGBA> m_vertices;
346 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
347 const VkPipelineColorBlendAttachmentState m_colorBlendState;
350 class SampleMaskInstance : public vkt::TestInstance
353 SampleMaskInstance (Context& context,
354 VkPrimitiveTopology topology,
355 const std::vector<Vertex4RGBA>& vertices,
356 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
357 const VkPipelineColorBlendAttachmentState& blendState);
358 virtual ~SampleMaskInstance (void) {}
360 virtual tcu::TestStatus iterate (void);
363 virtual tcu::TestStatus verifyImage (const tcu::ConstPixelBufferAccess& testShadingImage,
364 const tcu::ConstPixelBufferAccess& minShadingImage,
365 const tcu::ConstPixelBufferAccess& maxShadingImage);
366 const VkFormat m_colorFormat;
367 const tcu::IVec2 m_renderSize;
368 const VkPrimitiveTopology m_primitiveTopology;
369 const std::vector<Vertex4RGBA> m_vertices;
370 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
371 const VkPipelineColorBlendAttachmentState m_colorBlendState;
374 class AlphaToOneInstance : public vkt::TestInstance
377 AlphaToOneInstance (Context& context,
378 VkPrimitiveTopology topology,
379 const std::vector<Vertex4RGBA>& vertices,
380 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
381 const VkPipelineColorBlendAttachmentState& blendState);
382 virtual ~AlphaToOneInstance (void) {}
384 virtual tcu::TestStatus iterate (void);
387 virtual tcu::TestStatus verifyImage (const tcu::ConstPixelBufferAccess& alphaOneImage,
388 const tcu::ConstPixelBufferAccess& noAlphaOneImage);
389 const VkFormat m_colorFormat;
390 const tcu::IVec2 m_renderSize;
391 const VkPrimitiveTopology m_primitiveTopology;
392 const std::vector<Vertex4RGBA> m_vertices;
393 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
394 const VkPipelineColorBlendAttachmentState m_colorBlendState;
397 class AlphaToCoverageInstance : public vkt::TestInstance
400 AlphaToCoverageInstance (Context& context,
401 VkPrimitiveTopology topology,
402 const std::vector<Vertex4RGBA>& vertices,
403 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
404 const VkPipelineColorBlendAttachmentState& blendState,
405 GeometryType geometryType);
406 virtual ~AlphaToCoverageInstance (void) {}
408 virtual tcu::TestStatus iterate (void);
411 virtual tcu::TestStatus verifyImage (const tcu::ConstPixelBufferAccess& result);
412 const VkFormat m_colorFormat;
413 const tcu::IVec2 m_renderSize;
414 const VkPrimitiveTopology m_primitiveTopology;
415 const std::vector<Vertex4RGBA> m_vertices;
416 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
417 const VkPipelineColorBlendAttachmentState m_colorBlendState;
418 const GeometryType m_geometryType;
424 void initMultisamplePrograms (SourceCollections& sources, GeometryType geometryType)
426 std::ostringstream vertexSource;
430 "layout(location = 0) in vec4 position;\n"
431 "layout(location = 1) in vec4 color;\n"
432 "layout(location = 0) out highp vec4 vtxColor;\n"
435 " gl_Position = position;\n"
436 " vtxColor = color;\n"
437 << (geometryType == GEOMETRY_TYPE_OPAQUE_POINT ? " gl_PointSize = 3.0f;\n"
441 static const char* fragmentSource =
443 "layout(location = 0) in highp vec4 vtxColor;\n"
444 "layout(location = 0) out highp vec4 fragColor;\n"
447 " fragColor = vtxColor;\n"
450 sources.glslSources.add("color_vert") << glu::VertexSource(vertexSource.str());
451 sources.glslSources.add("color_frag") << glu::FragmentSource(fragmentSource);
454 bool isSupportedSampleCount (const InstanceInterface& instanceInterface, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits rasterizationSamples)
456 VkPhysicalDeviceProperties deviceProperties;
458 instanceInterface.getPhysicalDeviceProperties(physicalDevice, &deviceProperties);
460 return !!(deviceProperties.limits.framebufferColorSampleCounts & rasterizationSamples);
463 VkPipelineColorBlendAttachmentState getDefaultColorBlendAttachmentState (void)
465 const VkPipelineColorBlendAttachmentState colorBlendState =
467 false, // VkBool32 blendEnable;
468 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
469 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
470 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
471 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
472 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
473 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
474 VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | // VkColorComponentFlags colorWriteMask;
475 VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
478 return colorBlendState;
481 deUint32 getUniqueColorsCount (const tcu::ConstPixelBufferAccess& image)
483 DE_ASSERT(image.getFormat().getPixelSize() == 4);
485 std::map<deUint32, deUint32> histogram; // map<pixel value, number of occurrences>
486 const deUint32 pixelCount = image.getWidth() * image.getHeight() * image.getDepth();
488 for (deUint32 pixelNdx = 0; pixelNdx < pixelCount; pixelNdx++)
490 const deUint32 pixelValue = *((const deUint32*)image.getDataPtr() + pixelNdx);
492 if (histogram.find(pixelValue) != histogram.end())
493 histogram[pixelValue]++;
495 histogram[pixelValue] = 1;
498 return (deUint32)histogram.size();
501 VkImageAspectFlags getImageAspectFlags (const VkFormat format)
503 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
505 if (tcuFormat.order == tcu::TextureFormat::DS) return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
506 else if (tcuFormat.order == tcu::TextureFormat::D) return VK_IMAGE_ASPECT_DEPTH_BIT;
507 else if (tcuFormat.order == tcu::TextureFormat::S) return VK_IMAGE_ASPECT_STENCIL_BIT;
513 std::vector<Vertex4RGBA> generateVertices (const GeometryType geometryType)
515 std::vector<Vertex4RGBA> vertices;
517 switch (geometryType)
519 case GEOMETRY_TYPE_OPAQUE_TRIANGLE:
520 case GEOMETRY_TYPE_INVISIBLE_TRIANGLE:
522 Vertex4RGBA vertexData[3] =
525 tcu::Vec4(-0.75f, 0.0f, 0.0f, 1.0f),
526 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
529 tcu::Vec4(0.75f, 0.125f, 0.0f, 1.0f),
530 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
533 tcu::Vec4(0.75f, -0.125f, 0.0f, 1.0f),
534 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
538 if (geometryType == GEOMETRY_TYPE_INVISIBLE_TRIANGLE)
540 for (int i = 0; i < 3; i++)
541 vertexData[i].color = tcu::Vec4();
544 vertices = std::vector<Vertex4RGBA>(vertexData, vertexData + 3);
548 case GEOMETRY_TYPE_OPAQUE_LINE:
550 const Vertex4RGBA vertexData[2] =
553 tcu::Vec4(-0.75f, 0.25f, 0.0f, 1.0f),
554 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
557 tcu::Vec4(0.75f, -0.25f, 0.0f, 1.0f),
558 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
562 vertices = std::vector<Vertex4RGBA>(vertexData, vertexData + 2);
566 case GEOMETRY_TYPE_OPAQUE_POINT:
568 const Vertex4RGBA vertex =
570 tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),
571 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
574 vertices = std::vector<Vertex4RGBA>(1, vertex);
578 case GEOMETRY_TYPE_OPAQUE_QUAD:
579 case GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH:
580 case GEOMETRY_TYPE_TRANSLUCENT_QUAD:
581 case GEOMETRY_TYPE_INVISIBLE_QUAD:
582 case GEOMETRY_TYPE_GRADIENT_QUAD:
584 Vertex4RGBA vertexData[4] =
587 tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f),
588 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
591 tcu::Vec4(1.0f, -1.0f, 0.0f, 1.0f),
592 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
595 tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f),
596 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
599 tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),
600 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
604 if (geometryType == GEOMETRY_TYPE_TRANSLUCENT_QUAD)
606 for (int i = 0; i < 4; i++)
607 vertexData[i].color.w() = 0.25f;
609 else if (geometryType == GEOMETRY_TYPE_INVISIBLE_QUAD)
611 for (int i = 0; i < 4; i++)
612 vertexData[i].color.w() = 0.0f;
614 else if (geometryType == GEOMETRY_TYPE_GRADIENT_QUAD)
616 vertexData[0].color.w() = 0.0f;
617 vertexData[2].color.w() = 0.0f;
619 else if (geometryType == GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH)
621 for (int i = 0; i < 4; i++)
622 vertexData[i].position.z() = 0.5f;
625 vertices = std::vector<Vertex4RGBA>(vertexData, vertexData + 4);
635 VkPrimitiveTopology getPrimitiveTopology (const GeometryType geometryType)
637 switch (geometryType)
639 case GEOMETRY_TYPE_OPAQUE_TRIANGLE:
640 case GEOMETRY_TYPE_INVISIBLE_TRIANGLE: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
642 case GEOMETRY_TYPE_OPAQUE_LINE: return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
643 case GEOMETRY_TYPE_OPAQUE_POINT: return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
645 case GEOMETRY_TYPE_OPAQUE_QUAD:
646 case GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH:
647 case GEOMETRY_TYPE_TRANSLUCENT_QUAD:
648 case GEOMETRY_TYPE_INVISIBLE_QUAD:
649 case GEOMETRY_TYPE_GRADIENT_QUAD: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
653 return VK_PRIMITIVE_TOPOLOGY_LAST;
657 bool isSupportedDepthStencilFormat (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkFormat format)
659 VkFormatProperties formatProps;
660 vki.getPhysicalDeviceFormatProperties(physDevice, format, &formatProps);
661 return (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0;
664 VkFormat findSupportedDepthStencilFormat (Context& context, const bool useDepth, const bool useStencil)
666 if (useDepth && !useStencil)
667 return VK_FORMAT_D16_UNORM; // must be supported
669 const InstanceInterface& vki = context.getInstanceInterface();
670 const VkPhysicalDevice physDevice = context.getPhysicalDevice();
672 // One of these formats must be supported.
674 if (isSupportedDepthStencilFormat(vki, physDevice, VK_FORMAT_D24_UNORM_S8_UINT))
675 return VK_FORMAT_D24_UNORM_S8_UINT;
677 if (isSupportedDepthStencilFormat(vki, physDevice, VK_FORMAT_D32_SFLOAT_S8_UINT))
678 return VK_FORMAT_D32_SFLOAT_S8_UINT;
680 return VK_FORMAT_UNDEFINED;
686 MultisampleTest::MultisampleTest (tcu::TestContext& testContext,
687 const std::string& name,
688 const std::string& description,
689 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
690 const VkPipelineColorBlendAttachmentState& blendState,
691 GeometryType geometryType)
692 : vkt::TestCase (testContext, name, description)
693 , m_multisampleStateParams (multisampleStateParams)
694 , m_colorBlendState (blendState)
695 , m_geometryType (geometryType)
697 if (m_multisampleStateParams.pSampleMask)
699 // Copy pSampleMask to avoid dependencies with other classes
701 const deUint32 maskCount = deCeilFloatToInt32(float(m_multisampleStateParams.rasterizationSamples) / 32);
703 for (deUint32 maskNdx = 0; maskNdx < maskCount; maskNdx++)
704 m_sampleMask.push_back(m_multisampleStateParams.pSampleMask[maskNdx]);
706 m_multisampleStateParams.pSampleMask = m_sampleMask.data();
710 void MultisampleTest::initPrograms (SourceCollections& programCollection) const
712 initMultisamplePrograms(programCollection, m_geometryType);
715 TestInstance* MultisampleTest::createInstance (Context& context) const
717 return createMultisampleTestInstance(context, getPrimitiveTopology(m_geometryType), generateVertices(m_geometryType), m_multisampleStateParams, m_colorBlendState);
721 // RasterizationSamplesTest
723 RasterizationSamplesTest::RasterizationSamplesTest (tcu::TestContext& testContext,
724 const std::string& name,
725 const std::string& description,
726 VkSampleCountFlagBits rasterizationSamples,
727 GeometryType geometryType,
728 TestModeFlags modeFlags)
729 : MultisampleTest (testContext, name, description, getRasterizationSamplesStateParams(rasterizationSamples), getDefaultColorBlendAttachmentState(), geometryType)
730 , m_modeFlags (modeFlags)
734 VkPipelineMultisampleStateCreateInfo RasterizationSamplesTest::getRasterizationSamplesStateParams (VkSampleCountFlagBits rasterizationSamples)
736 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
738 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
739 DE_NULL, // const void* pNext;
740 0u, // VkPipelineMultisampleStateCreateFlags flags;
741 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
742 false, // VkBool32 sampleShadingEnable;
743 0.0f, // float minSampleShading;
744 DE_NULL, // const VkSampleMask* pSampleMask;
745 false, // VkBool32 alphaToCoverageEnable;
746 false // VkBool32 alphaToOneEnable;
749 return multisampleStateParams;
752 TestInstance* RasterizationSamplesTest::createMultisampleTestInstance (Context& context,
753 VkPrimitiveTopology topology,
754 const std::vector<Vertex4RGBA>& vertices,
755 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
756 const VkPipelineColorBlendAttachmentState& colorBlendState) const
758 return new RasterizationSamplesInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_modeFlags);
762 // MinSampleShadingTest
764 MinSampleShadingTest::MinSampleShadingTest (tcu::TestContext& testContext,
765 const std::string& name,
766 const std::string& description,
767 VkSampleCountFlagBits rasterizationSamples,
768 float minSampleShading,
769 GeometryType geometryType)
770 : MultisampleTest (testContext, name, description, getMinSampleShadingStateParams(rasterizationSamples, minSampleShading), getDefaultColorBlendAttachmentState(), geometryType)
774 TestInstance* MinSampleShadingTest::createMultisampleTestInstance (Context& context,
775 VkPrimitiveTopology topology,
776 const std::vector<Vertex4RGBA>& vertices,
777 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
778 const VkPipelineColorBlendAttachmentState& colorBlendState) const
780 return new MinSampleShadingInstance(context, topology, vertices, multisampleStateParams, colorBlendState);
783 VkPipelineMultisampleStateCreateInfo MinSampleShadingTest::getMinSampleShadingStateParams (VkSampleCountFlagBits rasterizationSamples, float minSampleShading)
785 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
787 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
788 DE_NULL, // const void* pNext;
789 0u, // VkPipelineMultisampleStateCreateFlags flags;
790 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
791 true, // VkBool32 sampleShadingEnable;
792 minSampleShading, // float minSampleShading;
793 DE_NULL, // const VkSampleMask* pSampleMask;
794 false, // VkBool32 alphaToCoverageEnable;
795 false // VkBool32 alphaToOneEnable;
798 return multisampleStateParams;
804 SampleMaskTest::SampleMaskTest (tcu::TestContext& testContext,
805 const std::string& name,
806 const std::string& description,
807 VkSampleCountFlagBits rasterizationSamples,
808 const std::vector<VkSampleMask>& sampleMask,
809 GeometryType geometryType)
810 : MultisampleTest (testContext, name, description, getSampleMaskStateParams(rasterizationSamples, sampleMask), getDefaultColorBlendAttachmentState(), geometryType)
814 TestInstance* SampleMaskTest::createMultisampleTestInstance (Context& context,
815 VkPrimitiveTopology topology,
816 const std::vector<Vertex4RGBA>& vertices,
817 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
818 const VkPipelineColorBlendAttachmentState& colorBlendState) const
820 return new SampleMaskInstance(context, topology,vertices, multisampleStateParams, colorBlendState);
823 VkPipelineMultisampleStateCreateInfo SampleMaskTest::getSampleMaskStateParams (VkSampleCountFlagBits rasterizationSamples, const std::vector<VkSampleMask>& sampleMask)
825 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
827 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
828 DE_NULL, // const void* pNext;
829 0u, // VkPipelineMultisampleStateCreateFlags flags;
830 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
831 false, // VkBool32 sampleShadingEnable;
832 0.0f, // float minSampleShading;
833 sampleMask.data(), // const VkSampleMask* pSampleMask;
834 false, // VkBool32 alphaToCoverageEnable;
835 false // VkBool32 alphaToOneEnable;
838 return multisampleStateParams;
844 AlphaToOneTest::AlphaToOneTest (tcu::TestContext& testContext,
845 const std::string& name,
846 const std::string& description,
847 VkSampleCountFlagBits rasterizationSamples)
848 : MultisampleTest (testContext, name, description, getAlphaToOneStateParams(rasterizationSamples), getAlphaToOneBlendState(), GEOMETRY_TYPE_GRADIENT_QUAD)
852 TestInstance* AlphaToOneTest::createMultisampleTestInstance (Context& context,
853 VkPrimitiveTopology topology,
854 const std::vector<Vertex4RGBA>& vertices,
855 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
856 const VkPipelineColorBlendAttachmentState& colorBlendState) const
858 return new AlphaToOneInstance(context, topology, vertices, multisampleStateParams, colorBlendState);
861 VkPipelineMultisampleStateCreateInfo AlphaToOneTest::getAlphaToOneStateParams (VkSampleCountFlagBits rasterizationSamples)
863 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
865 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
866 DE_NULL, // const void* pNext;
867 0u, // VkPipelineMultisampleStateCreateFlags flags;
868 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
869 false, // VkBool32 sampleShadingEnable;
870 0.0f, // float minSampleShading;
871 DE_NULL, // const VkSampleMask* pSampleMask;
872 false, // VkBool32 alphaToCoverageEnable;
873 true // VkBool32 alphaToOneEnable;
876 return multisampleStateParams;
879 VkPipelineColorBlendAttachmentState AlphaToOneTest::getAlphaToOneBlendState (void)
881 const VkPipelineColorBlendAttachmentState colorBlendState =
883 true, // VkBool32 blendEnable;
884 VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcColorBlendFactor;
885 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, // VkBlendFactor dstColorBlendFactor;
886 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
887 VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcAlphaBlendFactor;
888 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, // VkBlendFactor dstAlphaBlendFactor;
889 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
890 VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | // VkColorComponentFlags colorWriteMask;
891 VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
894 return colorBlendState;
898 // AlphaToCoverageTest
900 AlphaToCoverageTest::AlphaToCoverageTest (tcu::TestContext& testContext,
901 const std::string& name,
902 const std::string& description,
903 VkSampleCountFlagBits rasterizationSamples,
904 GeometryType geometryType)
905 : MultisampleTest (testContext, name, description, getAlphaToCoverageStateParams(rasterizationSamples), getDefaultColorBlendAttachmentState(), geometryType)
906 , m_geometryType (geometryType)
910 TestInstance* AlphaToCoverageTest::createMultisampleTestInstance (Context& context,
911 VkPrimitiveTopology topology,
912 const std::vector<Vertex4RGBA>& vertices,
913 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
914 const VkPipelineColorBlendAttachmentState& colorBlendState) const
916 return new AlphaToCoverageInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_geometryType);
919 VkPipelineMultisampleStateCreateInfo AlphaToCoverageTest::getAlphaToCoverageStateParams (VkSampleCountFlagBits rasterizationSamples)
921 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
923 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
924 DE_NULL, // const void* pNext;
925 0u, // VkPipelineMultisampleStateCreateFlags flags;
926 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
927 false, // VkBool32 sampleShadingEnable;
928 0.0f, // float minSampleShading;
929 DE_NULL, // const VkSampleMask* pSampleMask;
930 true, // VkBool32 alphaToCoverageEnable;
931 false // VkBool32 alphaToOneEnable;
934 return multisampleStateParams;
937 // RasterizationSamplesInstance
939 RasterizationSamplesInstance::RasterizationSamplesInstance (Context& context,
940 VkPrimitiveTopology topology,
941 const std::vector<Vertex4RGBA>& vertices,
942 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
943 const VkPipelineColorBlendAttachmentState& blendState,
944 const TestModeFlags modeFlags)
945 : vkt::TestInstance (context)
946 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
947 , m_renderSize (32, 32)
948 , m_primitiveTopology (topology)
949 , m_vertices (vertices)
950 , m_fullQuadVertices (generateVertices(GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH))
951 , m_modeFlags (modeFlags)
953 if (m_modeFlags != 0)
955 const bool useDepth = (m_modeFlags & TEST_MODE_DEPTH_BIT) != 0;
956 const bool useStencil = (m_modeFlags & TEST_MODE_STENCIL_BIT) != 0;
957 const VkFormat depthStencilFormat = findSupportedDepthStencilFormat(context, useDepth, useStencil);
959 if (depthStencilFormat == VK_FORMAT_UNDEFINED)
960 TCU_THROW(NotSupportedError, "Required depth/stencil format is not supported");
962 const VkPrimitiveTopology pTopology[2] = { m_primitiveTopology, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP };
963 const std::vector<Vertex4RGBA> pVertices[2] = { m_vertices, m_fullQuadVertices };
965 m_multisampleRenderer = de::MovePtr<MultisampleRenderer>(
966 new MultisampleRenderer(
967 context, m_colorFormat, depthStencilFormat, m_renderSize, useDepth, useStencil, 2u, pTopology, pVertices, multisampleStateParams, blendState));
971 m_multisampleRenderer = de::MovePtr<MultisampleRenderer>(
972 new MultisampleRenderer(context, m_colorFormat, m_renderSize, topology, vertices, multisampleStateParams, blendState));
976 tcu::TestStatus RasterizationSamplesInstance::iterate (void)
978 de::MovePtr<tcu::TextureLevel> level(m_multisampleRenderer->render());
979 return verifyImage(level->getAccess());
982 tcu::TestStatus RasterizationSamplesInstance::verifyImage (const tcu::ConstPixelBufferAccess& result)
984 // Verify range of unique pixels
986 const deUint32 numUniqueColors = getUniqueColorsCount(result);
987 const deUint32 minUniqueColors = 3;
989 tcu::TestLog& log = m_context.getTestContext().getLog();
991 log << tcu::TestLog::Message
992 << "\nMin. unique colors expected: " << minUniqueColors << "\n"
993 << "Unique colors found: " << numUniqueColors << "\n"
994 << tcu::TestLog::EndMessage;
996 if (numUniqueColors < minUniqueColors)
997 return tcu::TestStatus::fail("Unique colors out of expected bounds");
1000 // Verify shape of the rendered primitive (fuzzy-compare)
1002 const tcu::TextureFormat tcuColorFormat = mapVkFormat(m_colorFormat);
1003 const tcu::TextureFormat tcuDepthFormat = tcu::TextureFormat();
1004 const ColorVertexShader vertexShader;
1005 const ColorFragmentShader fragmentShader (tcuColorFormat, tcuDepthFormat);
1006 const rr::Program program (&vertexShader, &fragmentShader);
1007 ReferenceRenderer refRenderer (m_renderSize.x(), m_renderSize.y(), 1, tcuColorFormat, tcuDepthFormat, &program);
1008 rr::RenderState renderState (refRenderer.getViewportState());
1010 if (m_primitiveTopology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST)
1012 VkPhysicalDeviceProperties deviceProperties;
1014 m_context.getInstanceInterface().getPhysicalDeviceProperties(m_context.getPhysicalDevice(), &deviceProperties);
1016 // gl_PointSize is clamped to pointSizeRange
1017 renderState.point.pointSize = deFloatMin(3.0f, deviceProperties.limits.pointSizeRange[1]);
1020 if (m_modeFlags == 0)
1022 refRenderer.colorClear(tcu::Vec4(0.0f));
1023 refRenderer.draw(renderState, mapVkPrimitiveTopology(m_primitiveTopology), m_vertices);
1027 // For depth/stencil case the primitive is invisible and the surroundings are filled red.
1028 refRenderer.colorClear(tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f));
1029 refRenderer.draw(renderState, mapVkPrimitiveTopology(m_primitiveTopology), m_vertices);
1032 if (!tcu::fuzzyCompare(m_context.getTestContext().getLog(), "FuzzyImageCompare", "Image comparison", refRenderer.getAccess(), result, 0.05f, tcu::COMPARE_LOG_RESULT))
1033 return tcu::TestStatus::fail("Primitive has unexpected shape");
1036 return tcu::TestStatus::pass("Primitive rendered, unique colors within expected bounds");
1040 // MinSampleShadingInstance
1042 MinSampleShadingInstance::MinSampleShadingInstance (Context& context,
1043 VkPrimitiveTopology topology,
1044 const std::vector<Vertex4RGBA>& vertices,
1045 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1046 const VkPipelineColorBlendAttachmentState& colorBlendState)
1047 : vkt::TestInstance (context)
1048 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1049 , m_renderSize (32, 32)
1050 , m_primitiveTopology (topology)
1051 , m_vertices (vertices)
1052 , m_multisampleStateParams (multisampleStateParams)
1053 , m_colorBlendState (colorBlendState)
1055 VkPhysicalDeviceFeatures deviceFeatures;
1057 m_context.getInstanceInterface().getPhysicalDeviceFeatures(m_context.getPhysicalDevice(), &deviceFeatures);
1059 if (!deviceFeatures.sampleRateShading)
1060 throw tcu::NotSupportedError("Sample shading is not supported");
1063 tcu::TestStatus MinSampleShadingInstance::iterate (void)
1065 de::MovePtr<tcu::TextureLevel> testShadingImage;
1066 de::MovePtr<tcu::TextureLevel> minShadingImage;
1067 de::MovePtr<tcu::TextureLevel> maxShadingImage;
1069 // Render with test minSampleShading
1071 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState);
1072 testShadingImage = renderer.render();
1075 // Render with minSampleShading = 0.0f
1077 VkPipelineMultisampleStateCreateInfo multisampleParams = m_multisampleStateParams;
1078 multisampleParams.minSampleShading = 0.0f;
1080 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState);
1081 minShadingImage = renderer.render();
1084 // Render with minSampleShading = 1.0f
1086 VkPipelineMultisampleStateCreateInfo multisampleParams = m_multisampleStateParams;
1087 multisampleParams.minSampleShading = 1.0f;
1089 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState);
1090 maxShadingImage = renderer.render();
1093 return verifyImage(testShadingImage->getAccess(), minShadingImage->getAccess(), maxShadingImage->getAccess());
1096 tcu::TestStatus MinSampleShadingInstance::verifyImage (const tcu::ConstPixelBufferAccess& testShadingImage, const tcu::ConstPixelBufferAccess& minShadingImage, const tcu::ConstPixelBufferAccess& maxShadingImage)
1098 const deUint32 testColorCount = getUniqueColorsCount(testShadingImage);
1099 const deUint32 minColorCount = getUniqueColorsCount(minShadingImage);
1100 const deUint32 maxColorCount = getUniqueColorsCount(maxShadingImage);
1102 tcu::TestLog& log = m_context.getTestContext().getLog();
1104 log << tcu::TestLog::Message
1105 << "\nColors found: " << testColorCount << "\n"
1106 << "Min. colors expected: " << minColorCount << "\n"
1107 << "Max. colors expected: " << maxColorCount << "\n"
1108 << tcu::TestLog::EndMessage;
1110 if (minColorCount > testColorCount || testColorCount > maxColorCount)
1111 return tcu::TestStatus::fail("Unique colors out of expected bounds");
1113 return tcu::TestStatus::pass("Unique colors within expected bounds");
1116 SampleMaskInstance::SampleMaskInstance (Context& context,
1117 VkPrimitiveTopology topology,
1118 const std::vector<Vertex4RGBA>& vertices,
1119 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1120 const VkPipelineColorBlendAttachmentState& blendState)
1121 : vkt::TestInstance (context)
1122 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1123 , m_renderSize (32, 32)
1124 , m_primitiveTopology (topology)
1125 , m_vertices (vertices)
1126 , m_multisampleStateParams (multisampleStateParams)
1127 , m_colorBlendState (blendState)
1131 tcu::TestStatus SampleMaskInstance::iterate (void)
1133 de::MovePtr<tcu::TextureLevel> testSampleMaskImage;
1134 de::MovePtr<tcu::TextureLevel> minSampleMaskImage;
1135 de::MovePtr<tcu::TextureLevel> maxSampleMaskImage;
1137 // Render with test flags
1139 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState);
1140 testSampleMaskImage = renderer.render();
1143 // Render with all flags off
1145 VkPipelineMultisampleStateCreateInfo multisampleParams = m_multisampleStateParams;
1146 const std::vector<VkSampleMask> sampleMask (multisampleParams.rasterizationSamples / 32, (VkSampleMask)0);
1148 multisampleParams.pSampleMask = sampleMask.data();
1150 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState);
1151 minSampleMaskImage = renderer.render();
1154 // Render with all flags on
1156 VkPipelineMultisampleStateCreateInfo multisampleParams = m_multisampleStateParams;
1157 const std::vector<VkSampleMask> sampleMask (multisampleParams.rasterizationSamples / 32, ~((VkSampleMask)0));
1159 multisampleParams.pSampleMask = sampleMask.data();
1161 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState);
1162 maxSampleMaskImage = renderer.render();
1165 return verifyImage(testSampleMaskImage->getAccess(), minSampleMaskImage->getAccess(), maxSampleMaskImage->getAccess());
1168 tcu::TestStatus SampleMaskInstance::verifyImage (const tcu::ConstPixelBufferAccess& testSampleMaskImage,
1169 const tcu::ConstPixelBufferAccess& minSampleMaskImage,
1170 const tcu::ConstPixelBufferAccess& maxSampleMaskImage)
1172 const deUint32 testColorCount = getUniqueColorsCount(testSampleMaskImage);
1173 const deUint32 minColorCount = getUniqueColorsCount(minSampleMaskImage);
1174 const deUint32 maxColorCount = getUniqueColorsCount(maxSampleMaskImage);
1176 tcu::TestLog& log = m_context.getTestContext().getLog();
1178 log << tcu::TestLog::Message
1179 << "\nColors found: " << testColorCount << "\n"
1180 << "Min. colors expected: " << minColorCount << "\n"
1181 << "Max. colors expected: " << maxColorCount << "\n"
1182 << tcu::TestLog::EndMessage;
1184 if (minColorCount > testColorCount || testColorCount > maxColorCount)
1185 return tcu::TestStatus::fail("Unique colors out of expected bounds");
1187 return tcu::TestStatus::pass("Unique colors within expected bounds");
1190 tcu::TestStatus testRasterSamplesConsistency (Context& context, GeometryType geometryType)
1192 // Use triangle only.
1193 DE_UNREF(geometryType);
1195 const VkSampleCountFlagBits samples[] =
1197 VK_SAMPLE_COUNT_1_BIT,
1198 VK_SAMPLE_COUNT_2_BIT,
1199 VK_SAMPLE_COUNT_4_BIT,
1200 VK_SAMPLE_COUNT_8_BIT,
1201 VK_SAMPLE_COUNT_16_BIT,
1202 VK_SAMPLE_COUNT_32_BIT,
1203 VK_SAMPLE_COUNT_64_BIT
1206 const Vertex4RGBA vertexData[3] =
1209 tcu::Vec4(-0.75f, 0.0f, 0.0f, 1.0f),
1210 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
1213 tcu::Vec4(0.75f, 0.125f, 0.0f, 1.0f),
1214 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
1217 tcu::Vec4(0.75f, -0.125f, 0.0f, 1.0f),
1218 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
1222 const std::vector<Vertex4RGBA> vertices (vertexData, vertexData + 3);
1223 deUint32 prevUniqueColors = 2;
1224 int renderCount = 0;
1226 // Do not render with 1 sample (start with samplesNdx = 1).
1227 for (int samplesNdx = 1; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
1229 if (!isSupportedSampleCount(context.getInstanceInterface(), context.getPhysicalDevice(), samples[samplesNdx]))
1232 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
1234 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
1235 DE_NULL, // const void* pNext;
1236 0u, // VkPipelineMultisampleStateCreateFlags flags;
1237 samples[samplesNdx], // VkSampleCountFlagBits rasterizationSamples;
1238 false, // VkBool32 sampleShadingEnable;
1239 0.0f, // float minSampleShading;
1240 DE_NULL, // const VkSampleMask* pSampleMask;
1241 false, // VkBool32 alphaToCoverageEnable;
1242 false // VkBool32 alphaToOneEnable;
1245 MultisampleRenderer renderer (context, VK_FORMAT_R8G8B8A8_UNORM, tcu::IVec2(32, 32), VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, vertices, multisampleStateParams, getDefaultColorBlendAttachmentState());
1246 de::MovePtr<tcu::TextureLevel> result = renderer.render();
1247 const deUint32 uniqueColors = getUniqueColorsCount(result->getAccess());
1251 if (prevUniqueColors > uniqueColors)
1253 std::ostringstream message;
1255 message << "More unique colors generated with " << samples[samplesNdx - 1] << " than with " << samples[samplesNdx];
1256 return tcu::TestStatus::fail(message.str());
1259 prevUniqueColors = uniqueColors;
1262 if (renderCount == 0)
1263 throw tcu::NotSupportedError("Multisampling is unsupported");
1265 return tcu::TestStatus::pass("Number of unique colors increases as the sample count increases");
1269 // AlphaToOneInstance
1271 AlphaToOneInstance::AlphaToOneInstance (Context& context,
1272 VkPrimitiveTopology topology,
1273 const std::vector<Vertex4RGBA>& vertices,
1274 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1275 const VkPipelineColorBlendAttachmentState& blendState)
1276 : vkt::TestInstance (context)
1277 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1278 , m_renderSize (32, 32)
1279 , m_primitiveTopology (topology)
1280 , m_vertices (vertices)
1281 , m_multisampleStateParams (multisampleStateParams)
1282 , m_colorBlendState (blendState)
1284 VkPhysicalDeviceFeatures deviceFeatures;
1286 context.getInstanceInterface().getPhysicalDeviceFeatures(context.getPhysicalDevice(), &deviceFeatures);
1288 if (!deviceFeatures.alphaToOne)
1289 throw tcu::NotSupportedError("Alpha-to-one is not supported");
1292 tcu::TestStatus AlphaToOneInstance::iterate (void)
1294 DE_ASSERT(m_multisampleStateParams.alphaToOneEnable);
1295 DE_ASSERT(m_colorBlendState.blendEnable);
1297 de::MovePtr<tcu::TextureLevel> alphaOneImage;
1298 de::MovePtr<tcu::TextureLevel> noAlphaOneImage;
1300 // Render with blend enabled and alpha to one on
1302 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState);
1303 alphaOneImage = renderer.render();
1306 // Render with blend enabled and alpha to one off
1308 VkPipelineMultisampleStateCreateInfo multisampleParams = m_multisampleStateParams;
1309 multisampleParams.alphaToOneEnable = false;
1311 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState);
1312 noAlphaOneImage = renderer.render();
1315 return verifyImage(alphaOneImage->getAccess(), noAlphaOneImage->getAccess());
1318 tcu::TestStatus AlphaToOneInstance::verifyImage (const tcu::ConstPixelBufferAccess& alphaOneImage,
1319 const tcu::ConstPixelBufferAccess& noAlphaOneImage)
1321 for (int y = 0; y < m_renderSize.y(); y++)
1323 for (int x = 0; x < m_renderSize.x(); x++)
1325 if (!tcu::boolAll(tcu::greaterThanEqual(alphaOneImage.getPixel(x, y), noAlphaOneImage.getPixel(x, y))))
1327 std::ostringstream message;
1328 message << "Unsatisfied condition: " << alphaOneImage.getPixel(x, y) << " >= " << noAlphaOneImage.getPixel(x, y);
1329 return tcu::TestStatus::fail(message.str());
1334 return tcu::TestStatus::pass("Image rendered with alpha-to-one contains pixels of image rendered with no alpha-to-one");
1338 // AlphaToCoverageInstance
1340 AlphaToCoverageInstance::AlphaToCoverageInstance (Context& context,
1341 VkPrimitiveTopology topology,
1342 const std::vector<Vertex4RGBA>& vertices,
1343 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1344 const VkPipelineColorBlendAttachmentState& blendState,
1345 GeometryType geometryType)
1346 : vkt::TestInstance (context)
1347 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1348 , m_renderSize (32, 32)
1349 , m_primitiveTopology (topology)
1350 , m_vertices (vertices)
1351 , m_multisampleStateParams (multisampleStateParams)
1352 , m_colorBlendState (blendState)
1353 , m_geometryType (geometryType)
1357 tcu::TestStatus AlphaToCoverageInstance::iterate (void)
1359 DE_ASSERT(m_multisampleStateParams.alphaToCoverageEnable);
1361 de::MovePtr<tcu::TextureLevel> result;
1362 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState);
1364 result = renderer.render();
1366 return verifyImage(result->getAccess());
1369 tcu::TestStatus AlphaToCoverageInstance::verifyImage (const tcu::ConstPixelBufferAccess& result)
1371 float maxColorValue;
1373 switch (m_geometryType)
1375 case GEOMETRY_TYPE_OPAQUE_QUAD:
1376 maxColorValue = 1.01f;
1379 case GEOMETRY_TYPE_TRANSLUCENT_QUAD:
1380 maxColorValue = 0.52f;
1383 case GEOMETRY_TYPE_INVISIBLE_QUAD:
1384 maxColorValue = 0.01f;
1388 maxColorValue = 0.0f;
1392 for (int y = 0; y < m_renderSize.y(); y++)
1394 for (int x = 0; x < m_renderSize.x(); x++)
1396 if (result.getPixel(x, y).x() > maxColorValue)
1398 std::ostringstream message;
1399 message << "Pixel is not below the threshold value (" << result.getPixel(x, y).x() << " > " << maxColorValue << ")";
1400 return tcu::TestStatus::fail(message.str());
1405 return tcu::TestStatus::pass("Image matches reference value");
1409 // MultisampleRenderer
1411 MultisampleRenderer::MultisampleRenderer (Context& context,
1412 const VkFormat colorFormat,
1413 const tcu::IVec2& renderSize,
1414 const VkPrimitiveTopology topology,
1415 const std::vector<Vertex4RGBA>& vertices,
1416 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1417 const VkPipelineColorBlendAttachmentState& blendState)
1418 : m_context (context)
1419 , m_colorFormat (colorFormat)
1420 , m_depthStencilFormat (VK_FORMAT_UNDEFINED)
1421 , m_renderSize (renderSize)
1422 , m_useDepth (false)
1423 , m_useStencil (false)
1424 , m_multisampleStateParams (multisampleStateParams)
1425 , m_colorBlendState (blendState)
1427 initialize(context, 1u, &topology, &vertices);
1430 MultisampleRenderer::MultisampleRenderer (Context& context,
1431 const VkFormat colorFormat,
1432 const VkFormat depthStencilFormat,
1433 const tcu::IVec2& renderSize,
1434 const bool useDepth,
1435 const bool useStencil,
1436 const deUint32 numTopologies,
1437 const VkPrimitiveTopology* pTopology,
1438 const std::vector<Vertex4RGBA>* pVertices,
1439 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1440 const VkPipelineColorBlendAttachmentState& blendState)
1441 : m_context (context)
1442 , m_colorFormat (colorFormat)
1443 , m_depthStencilFormat (depthStencilFormat)
1444 , m_renderSize (renderSize)
1445 , m_useDepth (useDepth)
1446 , m_useStencil (useStencil)
1447 , m_multisampleStateParams (multisampleStateParams)
1448 , m_colorBlendState (blendState)
1450 initialize(context, numTopologies, pTopology, pVertices);
1453 void MultisampleRenderer::initialize (Context& context,
1454 const deUint32 numTopologies,
1455 const VkPrimitiveTopology* pTopology,
1456 const std::vector<Vertex4RGBA>* pVertices)
1458 if (!isSupportedSampleCount(context.getInstanceInterface(), context.getPhysicalDevice(), m_multisampleStateParams.rasterizationSamples))
1459 throw tcu::NotSupportedError("Unsupported number of rasterization samples");
1461 const DeviceInterface& vk = context.getDeviceInterface();
1462 const VkDevice vkDevice = context.getDevice();
1463 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1464 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
1465 const VkComponentMapping componentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
1467 // Create color image
1469 const VkImageCreateInfo colorImageParams =
1471 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1472 DE_NULL, // const void* pNext;
1473 0u, // VkImageCreateFlags flags;
1474 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1475 m_colorFormat, // VkFormat format;
1476 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1477 1u, // deUint32 mipLevels;
1478 1u, // deUint32 arrayLayers;
1479 m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
1480 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1481 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // VkImageUsageFlags usage;
1482 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1483 1u, // deUint32 queueFamilyIndexCount;
1484 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1485 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1488 m_colorImage = createImage(vk, vkDevice, &colorImageParams);
1490 // Allocate and bind color image memory
1491 m_colorImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_colorImage), MemoryRequirement::Any);
1492 VK_CHECK(vk.bindImageMemory(vkDevice, *m_colorImage, m_colorImageAlloc->getMemory(), m_colorImageAlloc->getOffset()));
1495 // Create resolve image
1497 const VkImageCreateInfo resolveImageParams =
1499 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1500 DE_NULL, // const void* pNext;
1501 0u, // VkImageCreateFlags flags;
1502 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1503 m_colorFormat, // VkFormat format;
1504 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1505 1u, // deUint32 mipLevels;
1506 1u, // deUint32 arrayLayers;
1507 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1508 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1509 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | // VkImageUsageFlags usage;
1510 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1511 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1512 1u, // deUint32 queueFamilyIndexCount;
1513 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1514 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1517 m_resolveImage = createImage(vk, vkDevice, &resolveImageParams);
1519 // Allocate and bind resolve image memory
1520 m_resolveImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_resolveImage), MemoryRequirement::Any);
1521 VK_CHECK(vk.bindImageMemory(vkDevice, *m_resolveImage, m_resolveImageAlloc->getMemory(), m_resolveImageAlloc->getOffset()));
1524 // Create a depth/stencil image
1525 if (m_useDepth || m_useStencil)
1527 const VkImageCreateInfo depthStencilImageParams =
1529 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1530 DE_NULL, // const void* pNext;
1531 0u, // VkImageCreateFlags flags;
1532 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1533 m_depthStencilFormat, // VkFormat format;
1534 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1535 1u, // deUint32 mipLevels;
1536 1u, // deUint32 arrayLayers;
1537 m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
1538 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1539 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, // VkImageUsageFlags usage;
1540 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1541 1u, // deUint32 queueFamilyIndexCount;
1542 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1543 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1546 m_depthStencilImage = createImage(vk, vkDevice, &depthStencilImageParams);
1548 // Allocate and bind depth/stencil image memory
1549 m_depthStencilImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_depthStencilImage), MemoryRequirement::Any);
1550 VK_CHECK(vk.bindImageMemory(vkDevice, *m_depthStencilImage, m_depthStencilImageAlloc->getMemory(), m_depthStencilImageAlloc->getOffset()));
1553 // Create color attachment view
1555 const VkImageViewCreateInfo colorAttachmentViewParams =
1557 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1558 DE_NULL, // const void* pNext;
1559 0u, // VkImageViewCreateFlags flags;
1560 *m_colorImage, // VkImage image;
1561 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1562 m_colorFormat, // VkFormat format;
1563 componentMappingRGBA, // VkComponentMapping components;
1564 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
1567 m_colorAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams);
1570 // Create resolve attachment view
1572 const VkImageViewCreateInfo resolveAttachmentViewParams =
1574 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1575 DE_NULL, // const void* pNext;
1576 0u, // VkImageViewCreateFlags flags;
1577 *m_resolveImage, // VkImage image;
1578 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1579 m_colorFormat, // VkFormat format;
1580 componentMappingRGBA, // VkComponentMapping components;
1581 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
1584 m_resolveAttachmentView = createImageView(vk, vkDevice, &resolveAttachmentViewParams);
1587 VkImageAspectFlags depthStencilAttachmentAspect = (VkImageAspectFlagBits)0;
1588 const deUint32 numUsedAttachments = (m_useDepth || m_useStencil ? 3u : 2u);
1590 // Create depth/stencil attachment view
1591 if (m_useDepth || m_useStencil)
1593 depthStencilAttachmentAspect = getImageAspectFlags(m_depthStencilFormat);
1595 const VkImageViewCreateInfo depthStencilAttachmentViewParams =
1597 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1598 DE_NULL, // const void* pNext;
1599 0u, // VkImageViewCreateFlags flags;
1600 *m_depthStencilImage, // VkImage image;
1601 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1602 m_depthStencilFormat, // VkFormat format;
1603 componentMappingRGBA, // VkComponentMapping components;
1604 { depthStencilAttachmentAspect, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
1607 m_depthStencilAttachmentView = createImageView(vk, vkDevice, &depthStencilAttachmentViewParams);
1610 // Create render pass
1612 const VkAttachmentDescription attachmentDescriptions[3] =
1615 0u, // VkAttachmentDescriptionFlags flags;
1616 m_colorFormat, // VkFormat format;
1617 m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
1618 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
1619 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1620 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1621 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1622 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
1623 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
1626 0u, // VkAttachmentDescriptionFlags flags;
1627 m_colorFormat, // VkFormat format;
1628 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1629 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
1630 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1631 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1632 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1633 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
1634 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
1637 0u, // VkAttachmentDescriptionFlags flags;
1638 m_depthStencilFormat, // VkFormat format;
1639 m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
1640 (m_useDepth ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_DONT_CARE), // VkAttachmentLoadOp loadOp;
1641 (m_useDepth ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE), // VkAttachmentStoreOp storeOp;
1642 (m_useStencil ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_DONT_CARE), // VkAttachmentStoreOp stencilLoadOp;
1643 (m_useStencil ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE), // VkAttachmentStoreOp stencilStoreOp;
1644 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
1645 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
1649 const VkAttachmentReference colorAttachmentReference =
1651 0u, // deUint32 attachment;
1652 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
1655 const VkAttachmentReference resolveAttachmentReference =
1657 1u, // deUint32 attachment;
1658 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
1661 const VkAttachmentReference depthStencilAttachmentReference =
1663 2u, // deUint32 attachment;
1664 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout layout;
1667 const VkSubpassDescription subpassDescription =
1669 0u, // VkSubpassDescriptionFlags flags;
1670 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
1671 0u, // deUint32 inputAttachmentCount;
1672 DE_NULL, // const VkAttachmentReference* pInputAttachments;
1673 1u, // deUint32 colorAttachmentCount;
1674 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments;
1675 &resolveAttachmentReference, // const VkAttachmentReference* pResolveAttachments;
1676 (m_useDepth || m_useStencil ? &depthStencilAttachmentReference : DE_NULL), // const VkAttachmentReference* pDepthStencilAttachment;
1677 0u, // deUint32 preserveAttachmentCount;
1678 DE_NULL // const VkAttachmentReference* pPreserveAttachments;
1681 const VkRenderPassCreateInfo renderPassParams =
1683 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
1684 DE_NULL, // const void* pNext;
1685 0u, // VkRenderPassCreateFlags flags;
1686 numUsedAttachments, // deUint32 attachmentCount;
1687 attachmentDescriptions, // const VkAttachmentDescription* pAttachments;
1688 1u, // deUint32 subpassCount;
1689 &subpassDescription, // const VkSubpassDescription* pSubpasses;
1690 0u, // deUint32 dependencyCount;
1691 DE_NULL // const VkSubpassDependency* pDependencies;
1694 m_renderPass = createRenderPass(vk, vkDevice, &renderPassParams);
1697 // Create framebuffer
1699 const VkImageView attachments[3] =
1701 *m_colorAttachmentView,
1702 *m_resolveAttachmentView,
1703 *m_depthStencilAttachmentView
1706 const VkFramebufferCreateInfo framebufferParams =
1708 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
1709 DE_NULL, // const void* pNext;
1710 0u, // VkFramebufferCreateFlags flags;
1711 *m_renderPass, // VkRenderPass renderPass;
1712 numUsedAttachments, // deUint32 attachmentCount;
1713 attachments, // const VkImageView* pAttachments;
1714 (deUint32)m_renderSize.x(), // deUint32 width;
1715 (deUint32)m_renderSize.y(), // deUint32 height;
1716 1u // deUint32 layers;
1719 m_framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams);
1722 // Create pipeline layout
1724 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
1726 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
1727 DE_NULL, // const void* pNext;
1728 0u, // VkPipelineLayoutCreateFlags flags;
1729 0u, // deUint32 setLayoutCount;
1730 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
1731 0u, // deUint32 pushConstantRangeCount;
1732 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
1735 m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
1738 m_vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_vert"), 0);
1739 m_fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_frag"), 0);
1743 const VkPipelineShaderStageCreateInfo shaderStageParams[2] =
1746 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1747 DE_NULL, // const void* pNext;
1748 0u, // VkPipelineShaderStageCreateFlags flags;
1749 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
1750 *m_vertexShaderModule, // VkShaderModule module;
1751 "main", // const char* pName;
1752 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
1755 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1756 DE_NULL, // const void* pNext;
1757 0u, // VkPipelineShaderStageCreateFlags flags;
1758 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
1759 *m_fragmentShaderModule, // VkShaderModule module;
1760 "main", // const char* pName;
1761 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
1765 const VkVertexInputBindingDescription vertexInputBindingDescription =
1767 0u, // deUint32 binding;
1768 sizeof(Vertex4RGBA), // deUint32 stride;
1769 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
1772 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
1775 0u, // deUint32 location;
1776 0u, // deUint32 binding;
1777 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
1778 0u // deUint32 offset;
1781 1u, // deUint32 location;
1782 0u, // deUint32 binding;
1783 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
1784 DE_OFFSET_OF(Vertex4RGBA, color), // deUint32 offset;
1788 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
1790 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
1791 DE_NULL, // const void* pNext;
1792 0u, // VkPipelineVertexInputStateCreateFlags flags;
1793 1u, // deUint32 vertexBindingDescriptionCount;
1794 &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1795 2u, // deUint32 vertexAttributeDescriptionCount;
1796 vertexInputAttributeDescriptions // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1799 // Topology is set before the pipeline creation.
1800 VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
1802 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
1803 DE_NULL, // const void* pNext;
1804 0u, // VkPipelineInputAssemblyStateCreateFlags flags;
1805 VK_PRIMITIVE_TOPOLOGY_LAST, // VkPrimitiveTopology topology;
1806 false // VkBool32 primitiveRestartEnable;
1809 const VkViewport viewport =
1813 (float)m_renderSize.x(), // float width;
1814 (float)m_renderSize.y(), // float height;
1815 0.0f, // float minDepth;
1816 1.0f // float maxDepth;
1819 const VkRect2D scissor =
1821 { 0, 0 }, // VkOffset2D offset;
1822 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() } // VkExtent2D extent;
1825 const VkPipelineViewportStateCreateInfo viewportStateParams =
1827 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
1828 DE_NULL, // const void* pNext;
1829 0u, // VkPipelineViewportStateCreateFlags flags;
1830 1u, // deUint32 viewportCount;
1831 &viewport, // const VkViewport* pViewports;
1832 1u, // deUint32 scissorCount;
1833 &scissor // const VkRect2D* pScissors;
1836 const VkPipelineRasterizationStateCreateInfo rasterStateParams =
1838 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
1839 DE_NULL, // const void* pNext;
1840 0u, // VkPipelineRasterizationStateCreateFlags flags;
1841 false, // VkBool32 depthClampEnable;
1842 false, // VkBool32 rasterizerDiscardEnable;
1843 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
1844 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
1845 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
1846 VK_FALSE, // VkBool32 depthBiasEnable;
1847 0.0f, // float depthBiasConstantFactor;
1848 0.0f, // float depthBiasClamp;
1849 0.0f, // float depthBiasSlopeFactor;
1850 1.0f // float lineWidth;
1853 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
1855 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
1856 DE_NULL, // const void* pNext;
1857 0u, // VkPipelineColorBlendStateCreateFlags flags;
1858 false, // VkBool32 logicOpEnable;
1859 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
1860 1u, // deUint32 attachmentCount;
1861 &m_colorBlendState, // const VkPipelineColorBlendAttachmentState* pAttachments;
1862 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4];
1865 const VkStencilOpState stencilOpState =
1867 VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
1868 VK_STENCIL_OP_REPLACE, // VkStencilOp passOp;
1869 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
1870 VK_COMPARE_OP_GREATER, // VkCompareOp compareOp;
1871 1u, // deUint32 compareMask;
1872 1u, // deUint32 writeMask;
1873 1u, // deUint32 reference;
1876 const VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
1878 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
1879 DE_NULL, // const void* pNext;
1880 0u, // VkPipelineDepthStencilStateCreateFlags flags;
1881 m_useDepth, // VkBool32 depthTestEnable;
1882 m_useDepth, // VkBool32 depthWriteEnable;
1883 VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
1884 false, // VkBool32 depthBoundsTestEnable;
1885 m_useStencil, // VkBool32 stencilTestEnable;
1886 stencilOpState, // VkStencilOpState front;
1887 stencilOpState, // VkStencilOpState back;
1888 0.0f, // float minDepthBounds;
1889 1.0f, // float maxDepthBounds;
1892 const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
1894 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
1895 DE_NULL, // const void* pNext;
1896 0u, // VkPipelineCreateFlags flags;
1897 2u, // deUint32 stageCount;
1898 shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages;
1899 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
1900 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
1901 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
1902 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
1903 &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
1904 &m_multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
1905 &depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
1906 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
1907 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
1908 *m_pipelineLayout, // VkPipelineLayout layout;
1909 *m_renderPass, // VkRenderPass renderPass;
1910 0u, // deUint32 subpass;
1911 0u, // VkPipeline basePipelineHandle;
1912 0u // deInt32 basePipelineIndex;
1915 for (deUint32 i = 0u; i < numTopologies; ++i)
1917 inputAssemblyStateParams.topology = pTopology[i];
1918 m_graphicsPipelines.push_back(VkPipelineSp(new Unique<VkPipeline>(createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams))));
1922 // Create vertex buffer
1924 const VkBufferCreateInfo vertexBufferParams =
1926 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1927 DE_NULL, // const void* pNext;
1928 0u, // VkBufferCreateFlags flags;
1929 1024u, // VkDeviceSize size;
1930 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage;
1931 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1932 1u, // deUint32 queueFamilyIndexCount;
1933 &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
1936 m_vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);
1937 m_vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_vertexBuffer), MemoryRequirement::HostVisible);
1939 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_vertexBuffer, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset()));
1941 // Load vertices into vertex buffer
1943 Vertex4RGBA* pDst = static_cast<Vertex4RGBA*>(m_vertexBufferAlloc->getHostPtr());
1944 for (deUint32 i = 0u; i < numTopologies; ++i)
1946 deMemcpy(pDst, &pVertices[i][0], pVertices[i].size() * sizeof(Vertex4RGBA));
1947 pDst += pVertices[i].size();
1950 flushMappedMemoryRange(vk, vkDevice, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset(), vertexBufferParams.size);
1953 // Create command pool
1955 const VkCommandPoolCreateInfo cmdPoolParams =
1957 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
1958 DE_NULL, // const void* pNext;
1959 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, // VkCommandPoolCreateFlags flags;
1960 queueFamilyIndex, // deUint32 queueFamilyIndex;
1963 m_cmdPool = createCommandPool(vk, vkDevice, &cmdPoolParams);
1966 // Create command buffer
1968 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
1970 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
1971 DE_NULL, // const void* pNext;
1972 *m_cmdPool, // VkCommandPool commandPool;
1973 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
1974 1u // deUint32 bufferCount;
1977 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1979 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1980 DE_NULL, // const void* pNext;
1981 0u, // VkCommandBufferUsageFlags flags;
1982 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1985 VkClearValue colorClearValue;
1986 colorClearValue.color.float32[0] = 0.0f;
1987 colorClearValue.color.float32[1] = 0.0f;
1988 colorClearValue.color.float32[2] = 0.0f;
1989 colorClearValue.color.float32[3] = 0.0f;
1991 VkClearValue depthStencilClearValue;
1992 depthStencilClearValue.depthStencil.depth = 1.0f;
1993 depthStencilClearValue.depthStencil.stencil = 0u;
1995 const VkClearValue clearValues[3] =
1999 depthStencilClearValue
2002 const VkRenderPassBeginInfo renderPassBeginInfo =
2004 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
2005 DE_NULL, // const void* pNext;
2006 *m_renderPass, // VkRenderPass renderPass;
2007 *m_framebuffer, // VkFramebuffer framebuffer;
2010 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() }
2011 }, // VkRect2D renderArea;
2012 numUsedAttachments, // deUint32 clearValueCount;
2013 clearValues // const VkClearValue* pClearValues;
2016 const VkImageMemoryBarrier imageLayoutBarriers[] =
2018 // color attachment image
2020 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2021 DE_NULL, // const void* pNext;
2022 0u, // VkAccessFlags srcAccessMask;
2023 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2024 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2025 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2026 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2027 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2028 *m_colorImage, // VkImage image;
2029 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
2031 // resolve attachment image
2033 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2034 DE_NULL, // const void* pNext;
2035 0u, // VkAccessFlags srcAccessMask;
2036 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2037 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2038 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2039 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2040 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2041 *m_resolveImage, // VkImage image;
2042 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
2044 // depth/stencil attachment image
2046 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2047 DE_NULL, // const void* pNext;
2048 0u, // VkAccessFlags srcAccessMask;
2049 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2050 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2051 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2052 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2053 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2054 *m_depthStencilImage, // VkImage image;
2055 { depthStencilAttachmentAspect, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
2059 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo);
2061 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2063 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0,
2064 0u, DE_NULL, 0u, DE_NULL, numUsedAttachments, imageLayoutBarriers);
2066 vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
2068 VkDeviceSize vertexBufferOffset = 0u;
2070 for (deUint32 i = 0u; i < numTopologies; ++i)
2072 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, **m_graphicsPipelines[i]);
2073 vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &m_vertexBuffer.get(), &vertexBufferOffset);
2074 vk.cmdDraw(*m_cmdBuffer, (deUint32)pVertices[i].size(), 1, 0, 0);
2076 vertexBufferOffset += static_cast<VkDeviceSize>(pVertices[i].size() * sizeof(Vertex4RGBA));
2079 vk.cmdEndRenderPass(*m_cmdBuffer);
2081 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2086 const VkFenceCreateInfo fenceParams =
2088 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
2089 DE_NULL, // const void* pNext;
2090 0u // VkFenceCreateFlags flags;
2093 m_fence = createFence(vk, vkDevice, &fenceParams);
2097 MultisampleRenderer::~MultisampleRenderer (void)
2101 de::MovePtr<tcu::TextureLevel> MultisampleRenderer::render (void)
2103 const DeviceInterface& vk = m_context.getDeviceInterface();
2104 const VkDevice vkDevice = m_context.getDevice();
2105 const VkQueue queue = m_context.getUniversalQueue();
2106 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
2107 SimpleAllocator allocator (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
2108 const VkSubmitInfo submitInfo =
2110 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
2111 DE_NULL, // const void* pNext;
2112 0u, // deUint32 waitSemaphoreCount;
2113 DE_NULL, // const VkSemaphore* pWaitSemaphores;
2114 (const VkPipelineStageFlags*)DE_NULL,
2115 1u, // deUint32 commandBufferCount;
2116 &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
2117 0u, // deUint32 signalSemaphoreCount;
2118 DE_NULL // const VkSemaphore* pSignalSemaphores;
2121 VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
2122 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
2123 VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
2125 return readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_resolveImage, m_colorFormat, m_renderSize.cast<deUint32>());
2130 tcu::TestCaseGroup* createMultisampleTests (tcu::TestContext& testCtx)
2132 const VkSampleCountFlagBits samples[] =
2134 VK_SAMPLE_COUNT_2_BIT,
2135 VK_SAMPLE_COUNT_4_BIT,
2136 VK_SAMPLE_COUNT_8_BIT,
2137 VK_SAMPLE_COUNT_16_BIT,
2138 VK_SAMPLE_COUNT_32_BIT,
2139 VK_SAMPLE_COUNT_64_BIT
2142 de::MovePtr<tcu::TestCaseGroup> multisampleTests (new tcu::TestCaseGroup(testCtx, "multisample", ""));
2144 // Rasterization samples tests
2146 de::MovePtr<tcu::TestCaseGroup> rasterizationSamplesTests(new tcu::TestCaseGroup(testCtx, "raster_samples", ""));
2148 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
2150 std::ostringstream caseName;
2151 caseName << "samples_" << samples[samplesNdx];
2153 de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
2155 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_triangle", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_TRIANGLE));
2156 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_line", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_LINE));
2157 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_point", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_POINT));
2159 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, TEST_MODE_DEPTH_BIT));
2160 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "stencil", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, TEST_MODE_STENCIL_BIT));
2161 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth_stencil", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, TEST_MODE_DEPTH_BIT | TEST_MODE_STENCIL_BIT));
2163 rasterizationSamplesTests->addChild(samplesTests.release());
2166 multisampleTests->addChild(rasterizationSamplesTests.release());
2169 // Raster samples consistency check
2171 de::MovePtr<tcu::TestCaseGroup> rasterSamplesConsistencyTests(new tcu::TestCaseGroup(testCtx, "raster_samples_consistency", ""));
2173 addFunctionCaseWithPrograms(rasterSamplesConsistencyTests.get(),
2174 "unique_colors_check",
2176 initMultisamplePrograms,
2177 testRasterSamplesConsistency,
2178 GEOMETRY_TYPE_OPAQUE_TRIANGLE);
2180 multisampleTests->addChild(rasterSamplesConsistencyTests.release());
2183 // minSampleShading tests
2188 float minSampleShading;
2191 const TestConfig testConfigs[] =
2193 { "min_0_0", 0.0f },
2194 { "min_0_25", 0.25f },
2195 { "min_0_5", 0.5f },
2196 { "min_0_75", 0.75f },
2200 de::MovePtr<tcu::TestCaseGroup> minSampleShadingTests(new tcu::TestCaseGroup(testCtx, "min_sample_shading", ""));
2202 for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(testConfigs); configNdx++)
2204 const TestConfig& testConfig = testConfigs[configNdx];
2205 de::MovePtr<tcu::TestCaseGroup> minShadingValueTests (new tcu::TestCaseGroup(testCtx, testConfigs[configNdx].name, ""));
2207 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
2209 std::ostringstream caseName;
2210 caseName << "samples_" << samples[samplesNdx];
2212 de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
2214 samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_triangle", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_TRIANGLE));
2215 samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_line", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_LINE));
2216 samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_point", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_POINT));
2218 minShadingValueTests->addChild(samplesTests.release());
2221 minSampleShadingTests->addChild(minShadingValueTests.release());
2224 multisampleTests->addChild(minSampleShadingTests.release());
2227 // pSampleMask tests
2232 const char* description;
2233 VkSampleMask sampleMask;
2236 const TestConfig testConfigs[] =
2238 { "mask_all_on", "All mask bits are off", 0x0 },
2239 { "mask_all_off", "All mask bits are on", 0xFFFFFFFF },
2240 { "mask_one", "All mask elements are 0x1", 0x1},
2241 { "mask_random", "All mask elements are 0xAAAAAAAA", 0xAAAAAAAA },
2244 de::MovePtr<tcu::TestCaseGroup> sampleMaskTests(new tcu::TestCaseGroup(testCtx, "sample_mask", ""));
2246 for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(testConfigs); configNdx++)
2248 const TestConfig& testConfig = testConfigs[configNdx];
2249 de::MovePtr<tcu::TestCaseGroup> sampleMaskValueTests (new tcu::TestCaseGroup(testCtx, testConfig.name, testConfig.description));
2251 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
2253 std::ostringstream caseName;
2254 caseName << "samples_" << samples[samplesNdx];
2256 const deUint32 sampleMaskCount = samples[samplesNdx] / 32;
2257 de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
2259 std::vector<VkSampleMask> mask;
2260 for (deUint32 maskNdx = 0; maskNdx < sampleMaskCount; maskNdx++)
2261 mask.push_back(testConfig.sampleMask);
2263 samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_triangle", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_TRIANGLE));
2264 samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_line", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_LINE));
2265 samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_point", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_POINT));
2267 sampleMaskValueTests->addChild(samplesTests.release());
2270 sampleMaskTests->addChild(sampleMaskValueTests.release());
2273 multisampleTests->addChild(sampleMaskTests.release());
2279 de::MovePtr<tcu::TestCaseGroup> alphaToOneTests(new tcu::TestCaseGroup(testCtx, "alpha_to_one", ""));
2281 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
2283 std::ostringstream caseName;
2284 caseName << "samples_" << samples[samplesNdx];
2286 alphaToOneTests->addChild(new AlphaToOneTest(testCtx, caseName.str(), "", samples[samplesNdx]));
2289 multisampleTests->addChild(alphaToOneTests.release());
2292 // AlphaToCoverageEnable tests
2294 de::MovePtr<tcu::TestCaseGroup> alphaToCoverageTests (new tcu::TestCaseGroup(testCtx, "alpha_to_coverage", ""));
2296 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
2298 std::ostringstream caseName;
2299 caseName << "samples_" << samples[samplesNdx];
2301 de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
2303 samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_opaque", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_QUAD));
2304 samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_translucent", "", samples[samplesNdx], GEOMETRY_TYPE_TRANSLUCENT_QUAD));
2305 samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_invisible", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_QUAD));
2307 alphaToCoverageTests->addChild(samplesTests.release());
2309 multisampleTests->addChild(alphaToCoverageTests.release());
2312 // Sampling from a multisampled image texture (texelFetch)
2314 multisampleTests->addChild(createMultisampleSampledImageTests(testCtx));
2317 // Load/store on a multisampled rendered image (different kinds of access: color attachment write, storage image, etc.)
2319 multisampleTests->addChild(createMultisampleStorageImageTests(testCtx));
2322 return multisampleTests.release();