1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015 The Khronos Group Inc.
6 * Copyright (c) 2015 Imagination Technologies Ltd.
7 * Copyright (c) 2017 Google Inc.
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
23 * \brief Multisample Tests
24 *//*--------------------------------------------------------------------*/
26 #include "vktPipelineMultisampleTests.hpp"
27 #include "vktPipelineMultisampleImageTests.hpp"
28 #include "vktPipelineClearUtil.hpp"
29 #include "vktPipelineImageUtil.hpp"
30 #include "vktPipelineVertexUtil.hpp"
31 #include "vktPipelineReferenceRenderer.hpp"
32 #include "vktTestCase.hpp"
33 #include "vktTestCaseUtil.hpp"
34 #include "vkImageUtil.hpp"
35 #include "vkMemUtil.hpp"
36 #include "vkPrograms.hpp"
37 #include "vkQueryUtil.hpp"
39 #include "vkRefUtil.hpp"
40 #include "tcuImageCompare.hpp"
41 #include "tcuTestLog.hpp"
42 #include "deUniquePtr.hpp"
43 #include "deSharedPtr.hpp"
44 #include "deStringUtil.hpp"
62 GEOMETRY_TYPE_OPAQUE_TRIANGLE,
63 GEOMETRY_TYPE_OPAQUE_LINE,
64 GEOMETRY_TYPE_OPAQUE_POINT,
65 GEOMETRY_TYPE_OPAQUE_QUAD,
66 GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH, //!< placed at z = 0.5
67 GEOMETRY_TYPE_TRANSLUCENT_QUAD,
68 GEOMETRY_TYPE_INVISIBLE_TRIANGLE,
69 GEOMETRY_TYPE_INVISIBLE_QUAD,
70 GEOMETRY_TYPE_GRADIENT_QUAD
75 TEST_MODE_DEPTH_BIT = 1u,
76 TEST_MODE_STENCIL_BIT = 2u,
78 typedef deUint32 TestModeFlags;
82 // resolve multisample rendering to single sampled image
83 RENDER_TYPE_RESOLVE = 0u,
85 // copy samples to an array of single sampled images
86 RENDER_TYPE_COPY_SAMPLES
91 IMAGE_BACKING_MODE_REGULAR = 0u,
92 IMAGE_BACKING_MODE_SPARSE
95 struct MultisampleTestParams
97 GeometryType geometryType;
98 ImageBackingMode backingMode;
101 void initMultisamplePrograms (SourceCollections& sources, MultisampleTestParams params);
102 bool isSupportedSampleCount (const InstanceInterface& instanceInterface, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits rasterizationSamples);
103 bool isSupportedDepthStencilFormat (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkFormat format);
104 VkPipelineColorBlendAttachmentState getDefaultColorBlendAttachmentState (void);
105 deUint32 getUniqueColorsCount (const tcu::ConstPixelBufferAccess& image);
106 VkImageAspectFlags getImageAspectFlags (const VkFormat format);
107 VkPrimitiveTopology getPrimitiveTopology (const GeometryType geometryType);
108 std::vector<Vertex4RGBA> generateVertices (const GeometryType geometryType);
109 VkFormat findSupportedDepthStencilFormat (Context& context, const bool useDepth, const bool useStencil);
111 class MultisampleTest : public vkt::TestCase
115 MultisampleTest (tcu::TestContext& testContext,
116 const std::string& name,
117 const std::string& description,
118 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
119 const VkPipelineColorBlendAttachmentState& blendState,
120 GeometryType geometryType,
121 ImageBackingMode backingMode);
122 virtual ~MultisampleTest (void) {}
124 virtual void initPrograms (SourceCollections& programCollection) const;
125 virtual TestInstance* createInstance (Context& context) const;
128 virtual TestInstance* createMultisampleTestInstance (Context& context,
129 VkPrimitiveTopology topology,
130 const std::vector<Vertex4RGBA>& vertices,
131 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
132 const VkPipelineColorBlendAttachmentState& colorBlendState) const = 0;
133 VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
134 const VkPipelineColorBlendAttachmentState m_colorBlendState;
135 const GeometryType m_geometryType;
136 const ImageBackingMode m_backingMode;
137 std::vector<VkSampleMask> m_sampleMask;
140 class RasterizationSamplesTest : public MultisampleTest
143 RasterizationSamplesTest (tcu::TestContext& testContext,
144 const std::string& name,
145 const std::string& description,
146 VkSampleCountFlagBits rasterizationSamples,
147 GeometryType geometryType,
148 ImageBackingMode backingMode,
149 TestModeFlags modeFlags = 0u);
150 virtual ~RasterizationSamplesTest (void) {}
153 virtual TestInstance* createMultisampleTestInstance (Context& context,
154 VkPrimitiveTopology topology,
155 const std::vector<Vertex4RGBA>& vertices,
156 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
157 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
159 static VkPipelineMultisampleStateCreateInfo getRasterizationSamplesStateParams (VkSampleCountFlagBits rasterizationSamples);
161 const ImageBackingMode m_backingMode;
162 const TestModeFlags m_modeFlags;
165 class MinSampleShadingTest : public MultisampleTest
168 MinSampleShadingTest (tcu::TestContext& testContext,
169 const std::string& name,
170 const std::string& description,
171 VkSampleCountFlagBits rasterizationSamples,
172 float minSampleShading,
173 GeometryType geometryType,
174 ImageBackingMode backingMode);
175 virtual ~MinSampleShadingTest (void) {}
178 virtual void initPrograms (SourceCollections& programCollection) const;
179 virtual TestInstance* createMultisampleTestInstance (Context& context,
180 VkPrimitiveTopology topology,
181 const std::vector<Vertex4RGBA>& vertices,
182 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
183 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
185 static VkPipelineMultisampleStateCreateInfo getMinSampleShadingStateParams (VkSampleCountFlagBits rasterizationSamples, float minSampleShading);
187 const ImageBackingMode m_backingMode;
190 class SampleMaskTest : public MultisampleTest
193 SampleMaskTest (tcu::TestContext& testContext,
194 const std::string& name,
195 const std::string& description,
196 VkSampleCountFlagBits rasterizationSamples,
197 const std::vector<VkSampleMask>& sampleMask,
198 GeometryType geometryType,
199 ImageBackingMode backingMode);
201 virtual ~SampleMaskTest (void) {}
204 virtual TestInstance* createMultisampleTestInstance (Context& context,
205 VkPrimitiveTopology topology,
206 const std::vector<Vertex4RGBA>& vertices,
207 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
208 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
210 static VkPipelineMultisampleStateCreateInfo getSampleMaskStateParams (VkSampleCountFlagBits rasterizationSamples, const std::vector<VkSampleMask>& sampleMask);
212 const ImageBackingMode m_backingMode;
215 class AlphaToOneTest : public MultisampleTest
218 AlphaToOneTest (tcu::TestContext& testContext,
219 const std::string& name,
220 const std::string& description,
221 VkSampleCountFlagBits rasterizationSamples,
222 ImageBackingMode backingMode);
224 virtual ~AlphaToOneTest (void) {}
227 virtual TestInstance* createMultisampleTestInstance (Context& context,
228 VkPrimitiveTopology topology,
229 const std::vector<Vertex4RGBA>& vertices,
230 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
231 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
233 static VkPipelineMultisampleStateCreateInfo getAlphaToOneStateParams (VkSampleCountFlagBits rasterizationSamples);
234 static VkPipelineColorBlendAttachmentState getAlphaToOneBlendState (void);
236 const ImageBackingMode m_backingMode;
239 class AlphaToCoverageTest : public MultisampleTest
242 AlphaToCoverageTest (tcu::TestContext& testContext,
243 const std::string& name,
244 const std::string& description,
245 VkSampleCountFlagBits rasterizationSamples,
246 GeometryType geometryType,
247 ImageBackingMode backingMode);
249 virtual ~AlphaToCoverageTest (void) {}
252 virtual TestInstance* createMultisampleTestInstance (Context& context,
253 VkPrimitiveTopology topology,
254 const std::vector<Vertex4RGBA>& vertices,
255 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
256 const VkPipelineColorBlendAttachmentState& colorBlendState) const;
258 static VkPipelineMultisampleStateCreateInfo getAlphaToCoverageStateParams (VkSampleCountFlagBits rasterizationSamples);
260 GeometryType m_geometryType;
261 const ImageBackingMode m_backingMode;
264 typedef de::SharedPtr<Unique<VkPipeline> > VkPipelineSp;
266 class MultisampleRenderer
269 MultisampleRenderer (Context& context,
270 const VkFormat colorFormat,
271 const tcu::IVec2& renderSize,
272 const VkPrimitiveTopology topology,
273 const std::vector<Vertex4RGBA>& vertices,
274 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
275 const VkPipelineColorBlendAttachmentState& blendState,
276 const RenderType renderType,
277 const ImageBackingMode backingMode);
279 MultisampleRenderer (Context& context,
280 const VkFormat colorFormat,
281 const VkFormat depthStencilFormat,
282 const tcu::IVec2& renderSize,
284 const bool useStencil,
285 const deUint32 numTopologies,
286 const VkPrimitiveTopology* pTopology,
287 const std::vector<Vertex4RGBA>* pVertices,
288 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
289 const VkPipelineColorBlendAttachmentState& blendState,
290 const RenderType renderType,
291 const ImageBackingMode backingMode);
293 virtual ~MultisampleRenderer (void);
295 de::MovePtr<tcu::TextureLevel> render (void);
296 de::MovePtr<tcu::TextureLevel> getSingleSampledImage (deUint32 sampleId);
299 void initialize (Context& context,
300 const deUint32 numTopologies,
301 const VkPrimitiveTopology* pTopology,
302 const std::vector<Vertex4RGBA>* pVertices);
306 const Unique<VkSemaphore> m_bindSemaphore;
308 const VkFormat m_colorFormat;
309 const VkFormat m_depthStencilFormat;
310 tcu::IVec2 m_renderSize;
311 const bool m_useDepth;
312 const bool m_useStencil;
314 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
315 const VkPipelineColorBlendAttachmentState m_colorBlendState;
317 const RenderType m_renderType;
319 Move<VkImage> m_colorImage;
320 de::MovePtr<Allocation> m_colorImageAlloc;
321 Move<VkImageView> m_colorAttachmentView;
323 Move<VkImage> m_resolveImage;
324 de::MovePtr<Allocation> m_resolveImageAlloc;
325 Move<VkImageView> m_resolveAttachmentView;
327 struct PerSampleImage
329 Move<VkImage> m_image;
330 de::MovePtr<Allocation> m_imageAlloc;
331 Move<VkImageView> m_attachmentView;
333 std::vector<de::SharedPtr<PerSampleImage> > m_perSampleImages;
335 Move<VkImage> m_depthStencilImage;
336 de::MovePtr<Allocation> m_depthStencilImageAlloc;
337 Move<VkImageView> m_depthStencilAttachmentView;
339 Move<VkRenderPass> m_renderPass;
340 Move<VkFramebuffer> m_framebuffer;
342 Move<VkShaderModule> m_vertexShaderModule;
343 Move<VkShaderModule> m_fragmentShaderModule;
345 Move<VkShaderModule> m_copySampleVertexShaderModule;
346 Move<VkShaderModule> m_copySampleFragmentShaderModule;
348 Move<VkBuffer> m_vertexBuffer;
349 de::MovePtr<Allocation> m_vertexBufferAlloc;
351 Move<VkPipelineLayout> m_pipelineLayout;
352 std::vector<VkPipelineSp> m_graphicsPipelines;
354 Move<VkDescriptorSetLayout> m_copySampleDesciptorLayout;
355 Move<VkDescriptorPool> m_copySampleDesciptorPool;
356 Move<VkDescriptorSet> m_copySampleDesciptorSet;
358 Move<VkPipelineLayout> m_copySamplePipelineLayout;
359 std::vector<VkPipelineSp> m_copySamplePipelines;
361 Move<VkCommandPool> m_cmdPool;
362 Move<VkCommandBuffer> m_cmdBuffer;
364 Move<VkFence> m_fence;
366 std::vector<de::SharedPtr<Allocation> > m_allocations;
368 ImageBackingMode m_backingMode;
371 class RasterizationSamplesInstance : public vkt::TestInstance
374 RasterizationSamplesInstance (Context& context,
375 VkPrimitiveTopology topology,
376 const std::vector<Vertex4RGBA>& vertices,
377 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
378 const VkPipelineColorBlendAttachmentState& blendState,
379 const TestModeFlags modeFlags,
380 ImageBackingMode backingMode);
381 virtual ~RasterizationSamplesInstance (void) {}
383 virtual tcu::TestStatus iterate (void);
386 virtual tcu::TestStatus verifyImage (const tcu::ConstPixelBufferAccess& result);
388 const VkFormat m_colorFormat;
389 const tcu::IVec2 m_renderSize;
390 const VkPrimitiveTopology m_primitiveTopology;
391 const std::vector<Vertex4RGBA> m_vertices;
392 const std::vector<Vertex4RGBA> m_fullQuadVertices; //!< used by depth/stencil case
393 const TestModeFlags m_modeFlags;
394 de::MovePtr<MultisampleRenderer> m_multisampleRenderer;
397 class MinSampleShadingInstance : public vkt::TestInstance
400 MinSampleShadingInstance (Context& context,
401 VkPrimitiveTopology topology,
402 const std::vector<Vertex4RGBA>& vertices,
403 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
404 const VkPipelineColorBlendAttachmentState& blendState,
405 ImageBackingMode backingMode);
406 virtual ~MinSampleShadingInstance (void) {}
408 virtual tcu::TestStatus iterate (void);
411 virtual tcu::TestStatus verifySampleShadedImage (const std::vector<tcu::TextureLevel>& testShadingImages,
412 const tcu::ConstPixelBufferAccess& noSampleshadingImage);
414 const VkFormat m_colorFormat;
415 const tcu::IVec2 m_renderSize;
416 const VkPrimitiveTopology m_primitiveTopology;
417 const std::vector<Vertex4RGBA> m_vertices;
418 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
419 const VkPipelineColorBlendAttachmentState m_colorBlendState;
420 const ImageBackingMode m_backingMode;
423 class SampleMaskInstance : public vkt::TestInstance
426 SampleMaskInstance (Context& context,
427 VkPrimitiveTopology topology,
428 const std::vector<Vertex4RGBA>& vertices,
429 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
430 const VkPipelineColorBlendAttachmentState& blendState,
431 ImageBackingMode backingMode);
432 virtual ~SampleMaskInstance (void) {}
434 virtual tcu::TestStatus iterate (void);
437 virtual tcu::TestStatus verifyImage (const tcu::ConstPixelBufferAccess& testShadingImage,
438 const tcu::ConstPixelBufferAccess& minShadingImage,
439 const tcu::ConstPixelBufferAccess& maxShadingImage);
440 const VkFormat m_colorFormat;
441 const tcu::IVec2 m_renderSize;
442 const VkPrimitiveTopology m_primitiveTopology;
443 const std::vector<Vertex4RGBA> m_vertices;
444 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
445 const VkPipelineColorBlendAttachmentState m_colorBlendState;
446 const ImageBackingMode m_backingMode;
449 class AlphaToOneInstance : public vkt::TestInstance
452 AlphaToOneInstance (Context& context,
453 VkPrimitiveTopology topology,
454 const std::vector<Vertex4RGBA>& vertices,
455 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
456 const VkPipelineColorBlendAttachmentState& blendState,
457 ImageBackingMode backingMode);
458 virtual ~AlphaToOneInstance (void) {}
460 virtual tcu::TestStatus iterate (void);
463 virtual tcu::TestStatus verifyImage (const tcu::ConstPixelBufferAccess& alphaOneImage,
464 const tcu::ConstPixelBufferAccess& noAlphaOneImage);
465 const VkFormat m_colorFormat;
466 const tcu::IVec2 m_renderSize;
467 const VkPrimitiveTopology m_primitiveTopology;
468 const std::vector<Vertex4RGBA> m_vertices;
469 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
470 const VkPipelineColorBlendAttachmentState m_colorBlendState;
471 const ImageBackingMode m_backingMode;
474 class AlphaToCoverageInstance : public vkt::TestInstance
477 AlphaToCoverageInstance (Context& context,
478 VkPrimitiveTopology topology,
479 const std::vector<Vertex4RGBA>& vertices,
480 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
481 const VkPipelineColorBlendAttachmentState& blendState,
482 GeometryType geometryType,
483 ImageBackingMode backingMode);
484 virtual ~AlphaToCoverageInstance (void) {}
486 virtual tcu::TestStatus iterate (void);
489 virtual tcu::TestStatus verifyImage (const tcu::ConstPixelBufferAccess& result);
490 const VkFormat m_colorFormat;
491 const tcu::IVec2 m_renderSize;
492 const VkPrimitiveTopology m_primitiveTopology;
493 const std::vector<Vertex4RGBA> m_vertices;
494 const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
495 const VkPipelineColorBlendAttachmentState m_colorBlendState;
496 const GeometryType m_geometryType;
497 const ImageBackingMode m_backingMode;
503 void initMultisamplePrograms (SourceCollections& sources, MultisampleTestParams params)
505 std::ostringstream vertexSource;
509 "layout(location = 0) in vec4 position;\n"
510 "layout(location = 1) in vec4 color;\n"
511 "layout(location = 0) out highp vec4 vtxColor;\n"
514 " gl_Position = position;\n"
515 " vtxColor = color;\n"
516 << (params.geometryType == GEOMETRY_TYPE_OPAQUE_POINT ? " gl_PointSize = 3.0f;\n"
520 static const char* fragmentSource =
522 "layout(location = 0) in highp vec4 vtxColor;\n"
523 "layout(location = 0) out highp vec4 fragColor;\n"
526 " fragColor = vtxColor;\n"
529 sources.glslSources.add("color_vert") << glu::VertexSource(vertexSource.str());
530 sources.glslSources.add("color_frag") << glu::FragmentSource(fragmentSource);
533 void initSampleShadingPrograms (SourceCollections& sources, GeometryType geometryType)
536 std::ostringstream vertexSource;
540 "layout(location = 0) in vec4 position;\n"
541 "layout(location = 1) in vec4 color;\n"
544 " gl_Position = position;\n"
545 << (geometryType == GEOMETRY_TYPE_OPAQUE_POINT ? " gl_PointSize = 3.0f;\n"
549 static const char* fragmentSource =
551 "layout(location = 0) out highp vec4 fragColor;\n"
554 " fragColor = vec4(fract(gl_FragCoord.xy), 0.0, 1.0);\n"
557 sources.glslSources.add("color_vert") << glu::VertexSource(vertexSource.str());
558 sources.glslSources.add("color_frag") << glu::FragmentSource(fragmentSource);
562 static const char* vertexSource =
566 " const vec4 positions[4] = vec4[4](\n"
567 " vec4(-1.0, -1.0, 0.0, 1.0),\n"
568 " vec4(-1.0, 1.0, 0.0, 1.0),\n"
569 " vec4( 1.0, -1.0, 0.0, 1.0),\n"
570 " vec4( 1.0, 1.0, 0.0, 1.0)\n"
572 " gl_Position = positions[gl_VertexIndex];\n"
575 static const char* fragmentSource =
577 "precision highp float;\n"
578 "layout(location = 0) out highp vec4 fragColor;\n"
579 "layout(set = 0, binding = 0, input_attachment_index = 0) uniform subpassInputMS imageMS;\n"
580 "layout(push_constant) uniform PushConstantsBlock\n"
586 " fragColor = subpassLoad(imageMS, pushConstants.sampleId);\n"
589 sources.glslSources.add("quad_vert") << glu::VertexSource(vertexSource);
590 sources.glslSources.add("copy_sample_frag") << glu::FragmentSource(fragmentSource);
594 bool isSupportedSampleCount (const InstanceInterface& instanceInterface, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits rasterizationSamples)
596 VkPhysicalDeviceProperties deviceProperties;
598 instanceInterface.getPhysicalDeviceProperties(physicalDevice, &deviceProperties);
600 return !!(deviceProperties.limits.framebufferColorSampleCounts & rasterizationSamples);
603 VkPipelineColorBlendAttachmentState getDefaultColorBlendAttachmentState (void)
605 const VkPipelineColorBlendAttachmentState colorBlendState =
607 false, // VkBool32 blendEnable;
608 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
609 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
610 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
611 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
612 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
613 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
614 VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | // VkColorComponentFlags colorWriteMask;
615 VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
618 return colorBlendState;
621 deUint32 getUniqueColorsCount (const tcu::ConstPixelBufferAccess& image)
623 DE_ASSERT(image.getFormat().getPixelSize() == 4);
625 std::map<deUint32, deUint32> histogram; // map<pixel value, number of occurrences>
626 const deUint32 pixelCount = image.getWidth() * image.getHeight() * image.getDepth();
628 for (deUint32 pixelNdx = 0; pixelNdx < pixelCount; pixelNdx++)
630 const deUint32 pixelValue = *((const deUint32*)image.getDataPtr() + pixelNdx);
632 if (histogram.find(pixelValue) != histogram.end())
633 histogram[pixelValue]++;
635 histogram[pixelValue] = 1;
638 return (deUint32)histogram.size();
641 VkImageAspectFlags getImageAspectFlags (const VkFormat format)
643 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
645 if (tcuFormat.order == tcu::TextureFormat::DS) return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
646 else if (tcuFormat.order == tcu::TextureFormat::D) return VK_IMAGE_ASPECT_DEPTH_BIT;
647 else if (tcuFormat.order == tcu::TextureFormat::S) return VK_IMAGE_ASPECT_STENCIL_BIT;
653 std::vector<Vertex4RGBA> generateVertices (const GeometryType geometryType)
655 std::vector<Vertex4RGBA> vertices;
657 switch (geometryType)
659 case GEOMETRY_TYPE_OPAQUE_TRIANGLE:
660 case GEOMETRY_TYPE_INVISIBLE_TRIANGLE:
662 Vertex4RGBA vertexData[3] =
665 tcu::Vec4(-0.75f, 0.0f, 0.0f, 1.0f),
666 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
669 tcu::Vec4(0.75f, 0.125f, 0.0f, 1.0f),
670 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
673 tcu::Vec4(0.75f, -0.125f, 0.0f, 1.0f),
674 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
678 if (geometryType == GEOMETRY_TYPE_INVISIBLE_TRIANGLE)
680 for (int i = 0; i < 3; i++)
681 vertexData[i].color = tcu::Vec4();
684 vertices = std::vector<Vertex4RGBA>(vertexData, vertexData + 3);
688 case GEOMETRY_TYPE_OPAQUE_LINE:
690 const Vertex4RGBA vertexData[2] =
693 tcu::Vec4(-0.75f, 0.25f, 0.0f, 1.0f),
694 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
697 tcu::Vec4(0.75f, -0.25f, 0.0f, 1.0f),
698 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
702 vertices = std::vector<Vertex4RGBA>(vertexData, vertexData + 2);
706 case GEOMETRY_TYPE_OPAQUE_POINT:
708 const Vertex4RGBA vertex =
710 tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),
711 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
714 vertices = std::vector<Vertex4RGBA>(1, vertex);
718 case GEOMETRY_TYPE_OPAQUE_QUAD:
719 case GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH:
720 case GEOMETRY_TYPE_TRANSLUCENT_QUAD:
721 case GEOMETRY_TYPE_INVISIBLE_QUAD:
722 case GEOMETRY_TYPE_GRADIENT_QUAD:
724 Vertex4RGBA vertexData[4] =
727 tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f),
728 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
731 tcu::Vec4(1.0f, -1.0f, 0.0f, 1.0f),
732 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
735 tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f),
736 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
739 tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),
740 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
744 if (geometryType == GEOMETRY_TYPE_TRANSLUCENT_QUAD)
746 for (int i = 0; i < 4; i++)
747 vertexData[i].color.w() = 0.25f;
749 else if (geometryType == GEOMETRY_TYPE_INVISIBLE_QUAD)
751 for (int i = 0; i < 4; i++)
752 vertexData[i].color.w() = 0.0f;
754 else if (geometryType == GEOMETRY_TYPE_GRADIENT_QUAD)
756 vertexData[0].color.w() = 0.0f;
757 vertexData[2].color.w() = 0.0f;
759 else if (geometryType == GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH)
761 for (int i = 0; i < 4; i++)
762 vertexData[i].position.z() = 0.5f;
765 vertices = std::vector<Vertex4RGBA>(vertexData, vertexData + 4);
775 VkPrimitiveTopology getPrimitiveTopology (const GeometryType geometryType)
777 switch (geometryType)
779 case GEOMETRY_TYPE_OPAQUE_TRIANGLE:
780 case GEOMETRY_TYPE_INVISIBLE_TRIANGLE: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
782 case GEOMETRY_TYPE_OPAQUE_LINE: return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
783 case GEOMETRY_TYPE_OPAQUE_POINT: return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
785 case GEOMETRY_TYPE_OPAQUE_QUAD:
786 case GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH:
787 case GEOMETRY_TYPE_TRANSLUCENT_QUAD:
788 case GEOMETRY_TYPE_INVISIBLE_QUAD:
789 case GEOMETRY_TYPE_GRADIENT_QUAD: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
793 return VK_PRIMITIVE_TOPOLOGY_LAST;
797 bool isSupportedDepthStencilFormat (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkFormat format)
799 VkFormatProperties formatProps;
800 vki.getPhysicalDeviceFormatProperties(physDevice, format, &formatProps);
801 return (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0;
804 VkFormat findSupportedDepthStencilFormat (Context& context, const bool useDepth, const bool useStencil)
806 if (useDepth && !useStencil)
807 return VK_FORMAT_D16_UNORM; // must be supported
809 const InstanceInterface& vki = context.getInstanceInterface();
810 const VkPhysicalDevice physDevice = context.getPhysicalDevice();
812 // One of these formats must be supported.
814 if (isSupportedDepthStencilFormat(vki, physDevice, VK_FORMAT_D24_UNORM_S8_UINT))
815 return VK_FORMAT_D24_UNORM_S8_UINT;
817 if (isSupportedDepthStencilFormat(vki, physDevice, VK_FORMAT_D32_SFLOAT_S8_UINT))
818 return VK_FORMAT_D32_SFLOAT_S8_UINT;
820 return VK_FORMAT_UNDEFINED;
826 MultisampleTest::MultisampleTest (tcu::TestContext& testContext,
827 const std::string& name,
828 const std::string& description,
829 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
830 const VkPipelineColorBlendAttachmentState& blendState,
831 GeometryType geometryType,
832 ImageBackingMode backingMode)
833 : vkt::TestCase (testContext, name, description)
834 , m_multisampleStateParams (multisampleStateParams)
835 , m_colorBlendState (blendState)
836 , m_geometryType (geometryType)
837 , m_backingMode (backingMode)
839 if (m_multisampleStateParams.pSampleMask)
841 // Copy pSampleMask to avoid dependencies with other classes
843 const deUint32 maskCount = deCeilFloatToInt32(float(m_multisampleStateParams.rasterizationSamples) / 32);
845 for (deUint32 maskNdx = 0; maskNdx < maskCount; maskNdx++)
846 m_sampleMask.push_back(m_multisampleStateParams.pSampleMask[maskNdx]);
848 m_multisampleStateParams.pSampleMask = m_sampleMask.data();
852 void MultisampleTest::initPrograms (SourceCollections& programCollection) const
854 MultisampleTestParams params = {m_geometryType, m_backingMode};
855 initMultisamplePrograms(programCollection, params);
858 TestInstance* MultisampleTest::createInstance (Context& context) const
860 return createMultisampleTestInstance(context, getPrimitiveTopology(m_geometryType), generateVertices(m_geometryType), m_multisampleStateParams, m_colorBlendState);
864 // RasterizationSamplesTest
866 RasterizationSamplesTest::RasterizationSamplesTest (tcu::TestContext& testContext,
867 const std::string& name,
868 const std::string& description,
869 VkSampleCountFlagBits rasterizationSamples,
870 GeometryType geometryType,
871 ImageBackingMode backingMode,
872 TestModeFlags modeFlags)
873 : MultisampleTest (testContext, name, description, getRasterizationSamplesStateParams(rasterizationSamples), getDefaultColorBlendAttachmentState(), geometryType, backingMode)
874 , m_backingMode (backingMode)
875 , m_modeFlags (modeFlags)
879 VkPipelineMultisampleStateCreateInfo RasterizationSamplesTest::getRasterizationSamplesStateParams (VkSampleCountFlagBits rasterizationSamples)
881 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
883 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
884 DE_NULL, // const void* pNext;
885 0u, // VkPipelineMultisampleStateCreateFlags flags;
886 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
887 false, // VkBool32 sampleShadingEnable;
888 0.0f, // float minSampleShading;
889 DE_NULL, // const VkSampleMask* pSampleMask;
890 false, // VkBool32 alphaToCoverageEnable;
891 false // VkBool32 alphaToOneEnable;
894 return multisampleStateParams;
897 TestInstance* RasterizationSamplesTest::createMultisampleTestInstance (Context& context,
898 VkPrimitiveTopology topology,
899 const std::vector<Vertex4RGBA>& vertices,
900 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
901 const VkPipelineColorBlendAttachmentState& colorBlendState) const
903 return new RasterizationSamplesInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_modeFlags, m_backingMode);
907 // MinSampleShadingTest
909 MinSampleShadingTest::MinSampleShadingTest (tcu::TestContext& testContext,
910 const std::string& name,
911 const std::string& description,
912 VkSampleCountFlagBits rasterizationSamples,
913 float minSampleShading,
914 GeometryType geometryType,
915 ImageBackingMode backingMode)
916 : MultisampleTest (testContext, name, description, getMinSampleShadingStateParams(rasterizationSamples, minSampleShading), getDefaultColorBlendAttachmentState(), geometryType, backingMode)
917 , m_backingMode (backingMode)
921 void MinSampleShadingTest::initPrograms (SourceCollections& programCollection) const
923 initSampleShadingPrograms(programCollection, m_geometryType);
926 TestInstance* MinSampleShadingTest::createMultisampleTestInstance (Context& context,
927 VkPrimitiveTopology topology,
928 const std::vector<Vertex4RGBA>& vertices,
929 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
930 const VkPipelineColorBlendAttachmentState& colorBlendState) const
932 return new MinSampleShadingInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_backingMode);
935 VkPipelineMultisampleStateCreateInfo MinSampleShadingTest::getMinSampleShadingStateParams (VkSampleCountFlagBits rasterizationSamples, float minSampleShading)
937 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
939 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
940 DE_NULL, // const void* pNext;
941 0u, // VkPipelineMultisampleStateCreateFlags flags;
942 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
943 true, // VkBool32 sampleShadingEnable;
944 minSampleShading, // float minSampleShading;
945 DE_NULL, // const VkSampleMask* pSampleMask;
946 false, // VkBool32 alphaToCoverageEnable;
947 false // VkBool32 alphaToOneEnable;
950 return multisampleStateParams;
956 SampleMaskTest::SampleMaskTest (tcu::TestContext& testContext,
957 const std::string& name,
958 const std::string& description,
959 VkSampleCountFlagBits rasterizationSamples,
960 const std::vector<VkSampleMask>& sampleMask,
961 GeometryType geometryType,
962 ImageBackingMode backingMode)
963 : MultisampleTest (testContext, name, description, getSampleMaskStateParams(rasterizationSamples, sampleMask), getDefaultColorBlendAttachmentState(), geometryType, backingMode)
964 , m_backingMode (backingMode)
968 TestInstance* SampleMaskTest::createMultisampleTestInstance (Context& context,
969 VkPrimitiveTopology topology,
970 const std::vector<Vertex4RGBA>& vertices,
971 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
972 const VkPipelineColorBlendAttachmentState& colorBlendState) const
974 return new SampleMaskInstance(context, topology,vertices, multisampleStateParams, colorBlendState, m_backingMode);
977 VkPipelineMultisampleStateCreateInfo SampleMaskTest::getSampleMaskStateParams (VkSampleCountFlagBits rasterizationSamples, const std::vector<VkSampleMask>& sampleMask)
979 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
981 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
982 DE_NULL, // const void* pNext;
983 0u, // VkPipelineMultisampleStateCreateFlags flags;
984 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
985 false, // VkBool32 sampleShadingEnable;
986 0.0f, // float minSampleShading;
987 sampleMask.data(), // const VkSampleMask* pSampleMask;
988 false, // VkBool32 alphaToCoverageEnable;
989 false // VkBool32 alphaToOneEnable;
992 return multisampleStateParams;
998 AlphaToOneTest::AlphaToOneTest (tcu::TestContext& testContext,
999 const std::string& name,
1000 const std::string& description,
1001 VkSampleCountFlagBits rasterizationSamples,
1002 ImageBackingMode backingMode)
1003 : MultisampleTest (testContext, name, description, getAlphaToOneStateParams(rasterizationSamples), getAlphaToOneBlendState(), GEOMETRY_TYPE_GRADIENT_QUAD, backingMode)
1004 , m_backingMode(backingMode)
1008 TestInstance* AlphaToOneTest::createMultisampleTestInstance (Context& context,
1009 VkPrimitiveTopology topology,
1010 const std::vector<Vertex4RGBA>& vertices,
1011 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1012 const VkPipelineColorBlendAttachmentState& colorBlendState) const
1014 return new AlphaToOneInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_backingMode);
1017 VkPipelineMultisampleStateCreateInfo AlphaToOneTest::getAlphaToOneStateParams (VkSampleCountFlagBits rasterizationSamples)
1019 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
1021 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
1022 DE_NULL, // const void* pNext;
1023 0u, // VkPipelineMultisampleStateCreateFlags flags;
1024 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
1025 false, // VkBool32 sampleShadingEnable;
1026 0.0f, // float minSampleShading;
1027 DE_NULL, // const VkSampleMask* pSampleMask;
1028 false, // VkBool32 alphaToCoverageEnable;
1029 true // VkBool32 alphaToOneEnable;
1032 return multisampleStateParams;
1035 VkPipelineColorBlendAttachmentState AlphaToOneTest::getAlphaToOneBlendState (void)
1037 const VkPipelineColorBlendAttachmentState colorBlendState =
1039 true, // VkBool32 blendEnable;
1040 VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcColorBlendFactor;
1041 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, // VkBlendFactor dstColorBlendFactor;
1042 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
1043 VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcAlphaBlendFactor;
1044 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, // VkBlendFactor dstAlphaBlendFactor;
1045 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
1046 VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | // VkColorComponentFlags colorWriteMask;
1047 VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
1050 return colorBlendState;
1054 // AlphaToCoverageTest
1056 AlphaToCoverageTest::AlphaToCoverageTest (tcu::TestContext& testContext,
1057 const std::string& name,
1058 const std::string& description,
1059 VkSampleCountFlagBits rasterizationSamples,
1060 GeometryType geometryType,
1061 ImageBackingMode backingMode)
1062 : MultisampleTest (testContext, name, description, getAlphaToCoverageStateParams(rasterizationSamples), getDefaultColorBlendAttachmentState(), geometryType, backingMode)
1063 , m_geometryType (geometryType)
1064 , m_backingMode (backingMode)
1068 TestInstance* AlphaToCoverageTest::createMultisampleTestInstance (Context& context,
1069 VkPrimitiveTopology topology,
1070 const std::vector<Vertex4RGBA>& vertices,
1071 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1072 const VkPipelineColorBlendAttachmentState& colorBlendState) const
1074 return new AlphaToCoverageInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_geometryType, m_backingMode);
1077 VkPipelineMultisampleStateCreateInfo AlphaToCoverageTest::getAlphaToCoverageStateParams (VkSampleCountFlagBits rasterizationSamples)
1079 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
1081 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
1082 DE_NULL, // const void* pNext;
1083 0u, // VkPipelineMultisampleStateCreateFlags flags;
1084 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
1085 false, // VkBool32 sampleShadingEnable;
1086 0.0f, // float minSampleShading;
1087 DE_NULL, // const VkSampleMask* pSampleMask;
1088 true, // VkBool32 alphaToCoverageEnable;
1089 false // VkBool32 alphaToOneEnable;
1092 return multisampleStateParams;
1095 // RasterizationSamplesInstance
1097 RasterizationSamplesInstance::RasterizationSamplesInstance (Context& context,
1098 VkPrimitiveTopology topology,
1099 const std::vector<Vertex4RGBA>& vertices,
1100 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1101 const VkPipelineColorBlendAttachmentState& blendState,
1102 const TestModeFlags modeFlags,
1103 ImageBackingMode backingMode)
1104 : vkt::TestInstance (context)
1105 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1106 , m_renderSize (32, 32)
1107 , m_primitiveTopology (topology)
1108 , m_vertices (vertices)
1109 , m_fullQuadVertices (generateVertices(GEOMETRY_TYPE_OPAQUE_QUAD_NONZERO_DEPTH))
1110 , m_modeFlags (modeFlags)
1112 if (m_modeFlags != 0)
1114 const bool useDepth = (m_modeFlags & TEST_MODE_DEPTH_BIT) != 0;
1115 const bool useStencil = (m_modeFlags & TEST_MODE_STENCIL_BIT) != 0;
1116 const VkFormat depthStencilFormat = findSupportedDepthStencilFormat(context, useDepth, useStencil);
1118 if (depthStencilFormat == VK_FORMAT_UNDEFINED)
1119 TCU_THROW(NotSupportedError, "Required depth/stencil format is not supported");
1121 const VkPrimitiveTopology pTopology[2] = { m_primitiveTopology, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP };
1122 const std::vector<Vertex4RGBA> pVertices[2] = { m_vertices, m_fullQuadVertices };
1124 m_multisampleRenderer = de::MovePtr<MultisampleRenderer>(
1125 new MultisampleRenderer(
1126 context, m_colorFormat, depthStencilFormat, m_renderSize, useDepth, useStencil, 2u, pTopology, pVertices, multisampleStateParams, blendState, RENDER_TYPE_RESOLVE, backingMode));
1130 m_multisampleRenderer = de::MovePtr<MultisampleRenderer>(
1131 new MultisampleRenderer(context, m_colorFormat, m_renderSize, topology, vertices, multisampleStateParams, blendState, RENDER_TYPE_RESOLVE, backingMode));
1135 tcu::TestStatus RasterizationSamplesInstance::iterate (void)
1137 de::MovePtr<tcu::TextureLevel> level(m_multisampleRenderer->render());
1138 return verifyImage(level->getAccess());
1141 tcu::TestStatus RasterizationSamplesInstance::verifyImage (const tcu::ConstPixelBufferAccess& result)
1143 // Verify range of unique pixels
1145 const deUint32 numUniqueColors = getUniqueColorsCount(result);
1146 const deUint32 minUniqueColors = 3;
1148 tcu::TestLog& log = m_context.getTestContext().getLog();
1150 log << tcu::TestLog::Message
1151 << "\nMin. unique colors expected: " << minUniqueColors << "\n"
1152 << "Unique colors found: " << numUniqueColors << "\n"
1153 << tcu::TestLog::EndMessage;
1155 if (numUniqueColors < minUniqueColors)
1156 return tcu::TestStatus::fail("Unique colors out of expected bounds");
1159 // Verify shape of the rendered primitive (fuzzy-compare)
1161 const tcu::TextureFormat tcuColorFormat = mapVkFormat(m_colorFormat);
1162 const tcu::TextureFormat tcuDepthFormat = tcu::TextureFormat();
1163 const ColorVertexShader vertexShader;
1164 const ColorFragmentShader fragmentShader (tcuColorFormat, tcuDepthFormat);
1165 const rr::Program program (&vertexShader, &fragmentShader);
1166 ReferenceRenderer refRenderer (m_renderSize.x(), m_renderSize.y(), 1, tcuColorFormat, tcuDepthFormat, &program);
1167 rr::RenderState renderState (refRenderer.getViewportState());
1169 if (m_primitiveTopology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST)
1171 VkPhysicalDeviceProperties deviceProperties;
1173 m_context.getInstanceInterface().getPhysicalDeviceProperties(m_context.getPhysicalDevice(), &deviceProperties);
1175 // gl_PointSize is clamped to pointSizeRange
1176 renderState.point.pointSize = deFloatMin(3.0f, deviceProperties.limits.pointSizeRange[1]);
1179 if (m_modeFlags == 0)
1181 refRenderer.colorClear(tcu::Vec4(0.0f));
1182 refRenderer.draw(renderState, mapVkPrimitiveTopology(m_primitiveTopology), m_vertices);
1186 // For depth/stencil case the primitive is invisible and the surroundings are filled red.
1187 refRenderer.colorClear(tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f));
1188 refRenderer.draw(renderState, mapVkPrimitiveTopology(m_primitiveTopology), m_vertices);
1191 if (!tcu::fuzzyCompare(m_context.getTestContext().getLog(), "FuzzyImageCompare", "Image comparison", refRenderer.getAccess(), result, 0.05f, tcu::COMPARE_LOG_RESULT))
1192 return tcu::TestStatus::fail("Primitive has unexpected shape");
1195 return tcu::TestStatus::pass("Primitive rendered, unique colors within expected bounds");
1199 // MinSampleShadingInstance
1201 MinSampleShadingInstance::MinSampleShadingInstance (Context& context,
1202 VkPrimitiveTopology topology,
1203 const std::vector<Vertex4RGBA>& vertices,
1204 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1205 const VkPipelineColorBlendAttachmentState& colorBlendState,
1206 ImageBackingMode backingMode)
1207 : vkt::TestInstance (context)
1208 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1209 , m_renderSize (32, 32)
1210 , m_primitiveTopology (topology)
1211 , m_vertices (vertices)
1212 , m_multisampleStateParams (multisampleStateParams)
1213 , m_colorBlendState (colorBlendState)
1214 , m_backingMode (backingMode)
1216 VkPhysicalDeviceFeatures deviceFeatures;
1218 m_context.getInstanceInterface().getPhysicalDeviceFeatures(m_context.getPhysicalDevice(), &deviceFeatures);
1220 if (!deviceFeatures.sampleRateShading)
1221 throw tcu::NotSupportedError("Sample shading is not supported");
1224 tcu::TestStatus MinSampleShadingInstance::iterate (void)
1226 de::MovePtr<tcu::TextureLevel> noSampleshadingImage;
1227 std::vector<tcu::TextureLevel> sampleShadedImages;
1229 // Render and resolve without sample shading
1231 VkPipelineMultisampleStateCreateInfo multisampleStateParms = m_multisampleStateParams;
1232 multisampleStateParms.sampleShadingEnable = VK_FALSE;
1233 multisampleStateParms.minSampleShading = 0.0;
1235 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleStateParms, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
1236 noSampleshadingImage = renderer.render();
1239 // Render with test minSampleShading and collect per-sample images
1241 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_COPY_SAMPLES, m_backingMode);
1244 sampleShadedImages.resize(m_multisampleStateParams.rasterizationSamples);
1245 for (deUint32 sampleId = 0; sampleId < sampleShadedImages.size(); sampleId++)
1247 sampleShadedImages[sampleId] = *renderer.getSingleSampledImage(sampleId);
1253 tcu::TestLog& testLog = m_context.getTestContext().getLog();
1255 testLog << tcu::TestLog::ImageSet("Images", "Images")
1256 << tcu::TestLog::Image("noSampleshadingImage", "Image rendered without sample shading", noSampleshadingImage->getAccess());
1258 for (deUint32 sampleId = 0; sampleId < sampleShadedImages.size(); sampleId++)
1260 testLog << tcu::TestLog::Image("sampleShadedImage", "One sample of sample shaded image", sampleShadedImages[sampleId].getAccess());
1262 testLog << tcu::TestLog::EndImageSet;
1265 return verifySampleShadedImage(sampleShadedImages, noSampleshadingImage->getAccess());
1268 tcu::TestStatus MinSampleShadingInstance::verifySampleShadedImage (const std::vector<tcu::TextureLevel>& sampleShadedImages, const tcu::ConstPixelBufferAccess& noSampleshadingImage)
1270 const deUint32 pixelCount = noSampleshadingImage.getWidth() * noSampleshadingImage.getHeight() * noSampleshadingImage.getDepth();
1272 bool anyPixelCovered = false;
1274 for (deUint32 pixelNdx = 0; pixelNdx < pixelCount; pixelNdx++)
1276 const deUint32 noSampleShadingValue = *((const deUint32*)noSampleshadingImage.getDataPtr() + pixelNdx);
1278 if (noSampleShadingValue == 0)
1280 // non-covered pixel, continue
1285 anyPixelCovered = true;
1288 int numNotCoveredSamples = 0;
1290 std::map<deUint32, deUint32> histogram; // map<pixel value, number of occurrences>
1292 // Collect histogram of occurrences or each pixel across all samples
1293 for (size_t i = 0; i < sampleShadedImages.size(); ++i)
1295 const deUint32 sampleShadedValue = *((const deUint32*)sampleShadedImages[i].getAccess().getDataPtr() + pixelNdx);
1297 if (sampleShadedValue == 0)
1299 numNotCoveredSamples++;
1303 if (histogram.find(sampleShadedValue) != histogram.end())
1304 histogram[sampleShadedValue]++;
1306 histogram[sampleShadedValue] = 1;
1309 if (numNotCoveredSamples == static_cast<int>(sampleShadedImages.size()))
1311 return tcu::TestStatus::fail("Got uncovered pixel, where covered samples were expected");
1314 const int uniqueColorsCount = (int)histogram.size();
1315 const int expectedUniqueSamplesCount = static_cast<int>(m_multisampleStateParams.minSampleShading * static_cast<float>(sampleShadedImages.size()) + 0.5f);
1317 if (uniqueColorsCount + numNotCoveredSamples < expectedUniqueSamplesCount)
1319 return tcu::TestStatus::fail("Got less unique colors than requested through minSampleShading");
1323 if (!anyPixelCovered)
1325 return tcu::TestStatus::fail("Did not get any covered pixel, cannot test minSampleShading");
1328 return tcu::TestStatus::pass("Got proper count of unique colors");
1331 SampleMaskInstance::SampleMaskInstance (Context& context,
1332 VkPrimitiveTopology topology,
1333 const std::vector<Vertex4RGBA>& vertices,
1334 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1335 const VkPipelineColorBlendAttachmentState& blendState,
1336 ImageBackingMode backingMode)
1337 : vkt::TestInstance (context)
1338 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1339 , m_renderSize (32, 32)
1340 , m_primitiveTopology (topology)
1341 , m_vertices (vertices)
1342 , m_multisampleStateParams (multisampleStateParams)
1343 , m_colorBlendState (blendState)
1344 , m_backingMode (backingMode)
1348 tcu::TestStatus SampleMaskInstance::iterate (void)
1350 de::MovePtr<tcu::TextureLevel> testSampleMaskImage;
1351 de::MovePtr<tcu::TextureLevel> minSampleMaskImage;
1352 de::MovePtr<tcu::TextureLevel> maxSampleMaskImage;
1354 // Render with test flags
1356 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
1357 testSampleMaskImage = renderer.render();
1360 // Render with all flags off
1362 VkPipelineMultisampleStateCreateInfo multisampleParams = m_multisampleStateParams;
1363 const std::vector<VkSampleMask> sampleMask (multisampleParams.rasterizationSamples / 32, (VkSampleMask)0);
1365 multisampleParams.pSampleMask = sampleMask.data();
1367 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
1368 minSampleMaskImage = renderer.render();
1371 // Render with all flags on
1373 VkPipelineMultisampleStateCreateInfo multisampleParams = m_multisampleStateParams;
1374 const std::vector<VkSampleMask> sampleMask (multisampleParams.rasterizationSamples / 32, ~((VkSampleMask)0));
1376 multisampleParams.pSampleMask = sampleMask.data();
1378 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
1379 maxSampleMaskImage = renderer.render();
1382 return verifyImage(testSampleMaskImage->getAccess(), minSampleMaskImage->getAccess(), maxSampleMaskImage->getAccess());
1385 tcu::TestStatus SampleMaskInstance::verifyImage (const tcu::ConstPixelBufferAccess& testSampleMaskImage,
1386 const tcu::ConstPixelBufferAccess& minSampleMaskImage,
1387 const tcu::ConstPixelBufferAccess& maxSampleMaskImage)
1389 const deUint32 testColorCount = getUniqueColorsCount(testSampleMaskImage);
1390 const deUint32 minColorCount = getUniqueColorsCount(minSampleMaskImage);
1391 const deUint32 maxColorCount = getUniqueColorsCount(maxSampleMaskImage);
1393 tcu::TestLog& log = m_context.getTestContext().getLog();
1395 log << tcu::TestLog::Message
1396 << "\nColors found: " << testColorCount << "\n"
1397 << "Min. colors expected: " << minColorCount << "\n"
1398 << "Max. colors expected: " << maxColorCount << "\n"
1399 << tcu::TestLog::EndMessage;
1401 if (minColorCount > testColorCount || testColorCount > maxColorCount)
1402 return tcu::TestStatus::fail("Unique colors out of expected bounds");
1404 return tcu::TestStatus::pass("Unique colors within expected bounds");
1407 tcu::TestStatus testRasterSamplesConsistency (Context& context, MultisampleTestParams params)
1409 const VkSampleCountFlagBits samples[] =
1411 VK_SAMPLE_COUNT_1_BIT,
1412 VK_SAMPLE_COUNT_2_BIT,
1413 VK_SAMPLE_COUNT_4_BIT,
1414 VK_SAMPLE_COUNT_8_BIT,
1415 VK_SAMPLE_COUNT_16_BIT,
1416 VK_SAMPLE_COUNT_32_BIT,
1417 VK_SAMPLE_COUNT_64_BIT
1420 const Vertex4RGBA vertexData[3] =
1423 tcu::Vec4(-0.75f, 0.0f, 0.0f, 1.0f),
1424 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
1427 tcu::Vec4(0.75f, 0.125f, 0.0f, 1.0f),
1428 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
1431 tcu::Vec4(0.75f, -0.125f, 0.0f, 1.0f),
1432 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)
1436 const std::vector<Vertex4RGBA> vertices (vertexData, vertexData + 3);
1437 deUint32 prevUniqueColors = 2;
1438 int renderCount = 0;
1440 // Do not render with 1 sample (start with samplesNdx = 1).
1441 for (int samplesNdx = 1; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
1443 if (!isSupportedSampleCount(context.getInstanceInterface(), context.getPhysicalDevice(), samples[samplesNdx]))
1446 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
1448 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
1449 DE_NULL, // const void* pNext;
1450 0u, // VkPipelineMultisampleStateCreateFlags flags;
1451 samples[samplesNdx], // VkSampleCountFlagBits rasterizationSamples;
1452 false, // VkBool32 sampleShadingEnable;
1453 0.0f, // float minSampleShading;
1454 DE_NULL, // const VkSampleMask* pSampleMask;
1455 false, // VkBool32 alphaToCoverageEnable;
1456 false // VkBool32 alphaToOneEnable;
1459 MultisampleRenderer renderer (context, VK_FORMAT_R8G8B8A8_UNORM, tcu::IVec2(32, 32), VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, vertices, multisampleStateParams, getDefaultColorBlendAttachmentState(), RENDER_TYPE_RESOLVE, params.backingMode);
1460 de::MovePtr<tcu::TextureLevel> result = renderer.render();
1461 const deUint32 uniqueColors = getUniqueColorsCount(result->getAccess());
1465 if (prevUniqueColors > uniqueColors)
1467 std::ostringstream message;
1469 message << "More unique colors generated with " << samples[samplesNdx - 1] << " than with " << samples[samplesNdx];
1470 return tcu::TestStatus::fail(message.str());
1473 prevUniqueColors = uniqueColors;
1476 if (renderCount == 0)
1477 throw tcu::NotSupportedError("Multisampling is unsupported");
1479 return tcu::TestStatus::pass("Number of unique colors increases as the sample count increases");
1483 // AlphaToOneInstance
1485 AlphaToOneInstance::AlphaToOneInstance (Context& context,
1486 VkPrimitiveTopology topology,
1487 const std::vector<Vertex4RGBA>& vertices,
1488 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1489 const VkPipelineColorBlendAttachmentState& blendState,
1490 ImageBackingMode backingMode)
1491 : vkt::TestInstance (context)
1492 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1493 , m_renderSize (32, 32)
1494 , m_primitiveTopology (topology)
1495 , m_vertices (vertices)
1496 , m_multisampleStateParams (multisampleStateParams)
1497 , m_colorBlendState (blendState)
1498 , m_backingMode (backingMode)
1500 VkPhysicalDeviceFeatures deviceFeatures;
1502 context.getInstanceInterface().getPhysicalDeviceFeatures(context.getPhysicalDevice(), &deviceFeatures);
1504 if (!deviceFeatures.alphaToOne)
1505 throw tcu::NotSupportedError("Alpha-to-one is not supported");
1508 tcu::TestStatus AlphaToOneInstance::iterate (void)
1510 DE_ASSERT(m_multisampleStateParams.alphaToOneEnable);
1511 DE_ASSERT(m_colorBlendState.blendEnable);
1513 de::MovePtr<tcu::TextureLevel> alphaOneImage;
1514 de::MovePtr<tcu::TextureLevel> noAlphaOneImage;
1516 // Render with blend enabled and alpha to one on
1518 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
1519 alphaOneImage = renderer.render();
1522 // Render with blend enabled and alpha to one off
1524 VkPipelineMultisampleStateCreateInfo multisampleParams = m_multisampleStateParams;
1525 multisampleParams.alphaToOneEnable = false;
1527 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
1528 noAlphaOneImage = renderer.render();
1531 return verifyImage(alphaOneImage->getAccess(), noAlphaOneImage->getAccess());
1534 tcu::TestStatus AlphaToOneInstance::verifyImage (const tcu::ConstPixelBufferAccess& alphaOneImage,
1535 const tcu::ConstPixelBufferAccess& noAlphaOneImage)
1537 for (int y = 0; y < m_renderSize.y(); y++)
1539 for (int x = 0; x < m_renderSize.x(); x++)
1541 if (!tcu::boolAll(tcu::greaterThanEqual(alphaOneImage.getPixel(x, y), noAlphaOneImage.getPixel(x, y))))
1543 std::ostringstream message;
1544 message << "Unsatisfied condition: " << alphaOneImage.getPixel(x, y) << " >= " << noAlphaOneImage.getPixel(x, y);
1545 return tcu::TestStatus::fail(message.str());
1550 return tcu::TestStatus::pass("Image rendered with alpha-to-one contains pixels of image rendered with no alpha-to-one");
1554 // AlphaToCoverageInstance
1556 AlphaToCoverageInstance::AlphaToCoverageInstance (Context& context,
1557 VkPrimitiveTopology topology,
1558 const std::vector<Vertex4RGBA>& vertices,
1559 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1560 const VkPipelineColorBlendAttachmentState& blendState,
1561 GeometryType geometryType,
1562 ImageBackingMode backingMode)
1563 : vkt::TestInstance (context)
1564 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1565 , m_renderSize (32, 32)
1566 , m_primitiveTopology (topology)
1567 , m_vertices (vertices)
1568 , m_multisampleStateParams (multisampleStateParams)
1569 , m_colorBlendState (blendState)
1570 , m_geometryType (geometryType)
1571 , m_backingMode (backingMode)
1575 tcu::TestStatus AlphaToCoverageInstance::iterate (void)
1577 DE_ASSERT(m_multisampleStateParams.alphaToCoverageEnable);
1579 de::MovePtr<tcu::TextureLevel> result;
1580 MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
1582 result = renderer.render();
1584 return verifyImage(result->getAccess());
1587 tcu::TestStatus AlphaToCoverageInstance::verifyImage (const tcu::ConstPixelBufferAccess& result)
1589 float maxColorValue;
1591 switch (m_geometryType)
1593 case GEOMETRY_TYPE_OPAQUE_QUAD:
1594 maxColorValue = 1.01f;
1597 case GEOMETRY_TYPE_TRANSLUCENT_QUAD:
1598 maxColorValue = 0.52f;
1601 case GEOMETRY_TYPE_INVISIBLE_QUAD:
1602 maxColorValue = 0.01f;
1606 maxColorValue = 0.0f;
1610 for (int y = 0; y < m_renderSize.y(); y++)
1612 for (int x = 0; x < m_renderSize.x(); x++)
1614 if (result.getPixel(x, y).x() > maxColorValue)
1616 std::ostringstream message;
1617 message << "Pixel is not below the threshold value (" << result.getPixel(x, y).x() << " > " << maxColorValue << ")";
1618 return tcu::TestStatus::fail(message.str());
1623 return tcu::TestStatus::pass("Image matches reference value");
1627 // MultisampleRenderer
1629 MultisampleRenderer::MultisampleRenderer (Context& context,
1630 const VkFormat colorFormat,
1631 const tcu::IVec2& renderSize,
1632 const VkPrimitiveTopology topology,
1633 const std::vector<Vertex4RGBA>& vertices,
1634 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1635 const VkPipelineColorBlendAttachmentState& blendState,
1636 const RenderType renderType,
1637 const ImageBackingMode backingMode)
1638 : m_context (context)
1639 , m_bindSemaphore (createSemaphore(context.getDeviceInterface(), context.getDevice()))
1640 , m_colorFormat (colorFormat)
1641 , m_depthStencilFormat (VK_FORMAT_UNDEFINED)
1642 , m_renderSize (renderSize)
1643 , m_useDepth (false)
1644 , m_useStencil (false)
1645 , m_multisampleStateParams (multisampleStateParams)
1646 , m_colorBlendState (blendState)
1647 , m_renderType (renderType)
1648 , m_backingMode (backingMode)
1650 initialize(context, 1u, &topology, &vertices);
1653 MultisampleRenderer::MultisampleRenderer (Context& context,
1654 const VkFormat colorFormat,
1655 const VkFormat depthStencilFormat,
1656 const tcu::IVec2& renderSize,
1657 const bool useDepth,
1658 const bool useStencil,
1659 const deUint32 numTopologies,
1660 const VkPrimitiveTopology* pTopology,
1661 const std::vector<Vertex4RGBA>* pVertices,
1662 const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
1663 const VkPipelineColorBlendAttachmentState& blendState,
1664 const RenderType renderType,
1665 const ImageBackingMode backingMode)
1666 : m_context (context)
1667 , m_bindSemaphore (createSemaphore(context.getDeviceInterface(), context.getDevice()))
1668 , m_colorFormat (colorFormat)
1669 , m_depthStencilFormat (depthStencilFormat)
1670 , m_renderSize (renderSize)
1671 , m_useDepth (useDepth)
1672 , m_useStencil (useStencil)
1673 , m_multisampleStateParams (multisampleStateParams)
1674 , m_colorBlendState (blendState)
1675 , m_renderType (renderType)
1676 , m_backingMode (backingMode)
1678 initialize(context, numTopologies, pTopology, pVertices);
1681 void MultisampleRenderer::initialize (Context& context,
1682 const deUint32 numTopologies,
1683 const VkPrimitiveTopology* pTopology,
1684 const std::vector<Vertex4RGBA>* pVertices)
1686 if (!isSupportedSampleCount(context.getInstanceInterface(), context.getPhysicalDevice(), m_multisampleStateParams.rasterizationSamples))
1687 throw tcu::NotSupportedError("Unsupported number of rasterization samples");
1689 const DeviceInterface& vk = context.getDeviceInterface();
1690 const VkDevice vkDevice = context.getDevice();
1691 const deUint32 queueFamilyIndices[] = { context.getUniversalQueueFamilyIndex(), context.getSparseQueueFamilyIndex() };
1692 const bool sparse = m_backingMode == IMAGE_BACKING_MODE_SPARSE;
1693 const VkComponentMapping componentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
1694 const VkImageCreateFlags imageCreateFlags = sparse ? (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) : 0u;
1695 const VkSharingMode sharingMode = (sparse && context.getUniversalQueueFamilyIndex() != context.getSparseQueueFamilyIndex()) ? VK_SHARING_MODE_CONCURRENT : VK_SHARING_MODE_EXCLUSIVE;
1696 Allocator& memAlloc = m_context.getDefaultAllocator();
1698 // Create color image
1700 const VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1701 (m_renderType == RENDER_TYPE_COPY_SAMPLES ? VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT : (VkImageUsageFlagBits)0u);
1703 const VkImageCreateInfo colorImageParams =
1705 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1706 DE_NULL, // const void* pNext;
1707 imageCreateFlags, // VkImageCreateFlags flags;
1708 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1709 m_colorFormat, // VkFormat format;
1710 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1711 1u, // deUint32 mipLevels;
1712 1u, // deUint32 arrayLayers;
1713 m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
1714 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1715 imageUsageFlags, // VkImageUsageFlags usage;
1716 sharingMode, // VkSharingMode sharingMode;
1717 sharingMode == VK_SHARING_MODE_CONCURRENT ? 2u : 1u, // deUint32 queueFamilyIndexCount;
1718 queueFamilyIndices, // const deUint32* pQueueFamilyIndices;
1719 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1722 if (sparse && !checkSparseImageFormatSupport(context.getPhysicalDevice(), context.getInstanceInterface(), colorImageParams))
1723 TCU_THROW(NotSupportedError, "The image format does not support sparse operations.");
1725 m_colorImage = createImage(vk, vkDevice, &colorImageParams);
1727 // Allocate and bind color image memory
1730 allocateAndBindSparseImage(vk, vkDevice, context.getPhysicalDevice(), context.getInstanceInterface(), colorImageParams, *m_bindSemaphore, context.getSparseQueue(), memAlloc, m_allocations, mapVkFormat(m_colorFormat), *m_colorImage);
1734 m_colorImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_colorImage), MemoryRequirement::Any);
1735 VK_CHECK(vk.bindImageMemory(vkDevice, *m_colorImage, m_colorImageAlloc->getMemory(), m_colorImageAlloc->getOffset()));
1739 // Create resolve image
1740 if (m_renderType == RENDER_TYPE_RESOLVE)
1742 const VkImageCreateInfo resolveImageParams =
1744 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1745 DE_NULL, // const void* pNext;
1746 0u, // VkImageCreateFlags flags;
1747 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1748 m_colorFormat, // VkFormat format;
1749 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1750 1u, // deUint32 mipLevels;
1751 1u, // deUint32 arrayLayers;
1752 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1753 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1754 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | // VkImageUsageFlags usage;
1755 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1756 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1757 1u, // deUint32 queueFamilyIndexCount;
1758 queueFamilyIndices, // const deUint32* pQueueFamilyIndices;
1759 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1762 m_resolveImage = createImage(vk, vkDevice, &resolveImageParams);
1764 // Allocate and bind resolve image memory
1765 m_resolveImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_resolveImage), MemoryRequirement::Any);
1766 VK_CHECK(vk.bindImageMemory(vkDevice, *m_resolveImage, m_resolveImageAlloc->getMemory(), m_resolveImageAlloc->getOffset()));
1768 // Create resolve attachment view
1770 const VkImageViewCreateInfo resolveAttachmentViewParams =
1772 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1773 DE_NULL, // const void* pNext;
1774 0u, // VkImageViewCreateFlags flags;
1775 *m_resolveImage, // VkImage image;
1776 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1777 m_colorFormat, // VkFormat format;
1778 componentMappingRGBA, // VkComponentMapping components;
1779 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
1782 m_resolveAttachmentView = createImageView(vk, vkDevice, &resolveAttachmentViewParams);
1786 // Create per-sample output images
1787 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
1789 const VkImageCreateInfo perSampleImageParams =
1791 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1792 DE_NULL, // const void* pNext;
1793 0u, // VkImageCreateFlags flags;
1794 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1795 m_colorFormat, // VkFormat format;
1796 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1797 1u, // deUint32 mipLevels;
1798 1u, // deUint32 arrayLayers;
1799 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1800 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1801 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | // VkImageUsageFlags usage;
1802 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1803 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1804 1u, // deUint32 queueFamilyIndexCount;
1805 queueFamilyIndices, // const deUint32* pQueueFamilyIndices;
1806 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1809 m_perSampleImages.resize(static_cast<size_t>(m_multisampleStateParams.rasterizationSamples));
1811 for (size_t i = 0; i < m_perSampleImages.size(); ++i)
1813 m_perSampleImages[i] = de::SharedPtr<PerSampleImage>(new PerSampleImage);
1814 PerSampleImage& image = *m_perSampleImages[i];
1816 image.m_image = createImage(vk, vkDevice, &perSampleImageParams);
1818 // Allocate and bind image memory
1819 image.m_imageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image.m_image), MemoryRequirement::Any);
1820 VK_CHECK(vk.bindImageMemory(vkDevice, *image.m_image, image.m_imageAlloc->getMemory(), image.m_imageAlloc->getOffset()));
1822 // Create per-sample attachment view
1824 const VkImageViewCreateInfo perSampleAttachmentViewParams =
1826 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1827 DE_NULL, // const void* pNext;
1828 0u, // VkImageViewCreateFlags flags;
1829 *image.m_image, // VkImage image;
1830 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1831 m_colorFormat, // VkFormat format;
1832 componentMappingRGBA, // VkComponentMapping components;
1833 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
1836 image.m_attachmentView = createImageView(vk, vkDevice, &perSampleAttachmentViewParams);
1841 // Create a depth/stencil image
1842 if (m_useDepth || m_useStencil)
1844 const VkImageCreateInfo depthStencilImageParams =
1846 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1847 DE_NULL, // const void* pNext;
1848 0u, // VkImageCreateFlags flags;
1849 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1850 m_depthStencilFormat, // VkFormat format;
1851 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1852 1u, // deUint32 mipLevels;
1853 1u, // deUint32 arrayLayers;
1854 m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
1855 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1856 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, // VkImageUsageFlags usage;
1857 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1858 1u, // deUint32 queueFamilyIndexCount;
1859 queueFamilyIndices, // const deUint32* pQueueFamilyIndices;
1860 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1863 m_depthStencilImage = createImage(vk, vkDevice, &depthStencilImageParams);
1865 // Allocate and bind depth/stencil image memory
1866 m_depthStencilImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_depthStencilImage), MemoryRequirement::Any);
1867 VK_CHECK(vk.bindImageMemory(vkDevice, *m_depthStencilImage, m_depthStencilImageAlloc->getMemory(), m_depthStencilImageAlloc->getOffset()));
1870 // Create color attachment view
1872 const VkImageViewCreateInfo colorAttachmentViewParams =
1874 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1875 DE_NULL, // const void* pNext;
1876 0u, // VkImageViewCreateFlags flags;
1877 *m_colorImage, // VkImage image;
1878 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1879 m_colorFormat, // VkFormat format;
1880 componentMappingRGBA, // VkComponentMapping components;
1881 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
1884 m_colorAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams);
1887 VkImageAspectFlags depthStencilAttachmentAspect = (VkImageAspectFlagBits)0;
1889 // Create depth/stencil attachment view
1890 if (m_useDepth || m_useStencil)
1892 depthStencilAttachmentAspect = getImageAspectFlags(m_depthStencilFormat);
1894 const VkImageViewCreateInfo depthStencilAttachmentViewParams =
1896 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1897 DE_NULL, // const void* pNext;
1898 0u, // VkImageViewCreateFlags flags;
1899 *m_depthStencilImage, // VkImage image;
1900 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1901 m_depthStencilFormat, // VkFormat format;
1902 componentMappingRGBA, // VkComponentMapping components;
1903 { depthStencilAttachmentAspect, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
1906 m_depthStencilAttachmentView = createImageView(vk, vkDevice, &depthStencilAttachmentViewParams);
1909 // Create render pass
1911 std::vector<VkAttachmentDescription> attachmentDescriptions;
1913 const VkAttachmentDescription colorAttachmentDescription =
1915 0u, // VkAttachmentDescriptionFlags flags;
1916 m_colorFormat, // VkFormat format;
1917 m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
1918 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
1919 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1920 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1921 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1922 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
1923 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
1925 attachmentDescriptions.push_back(colorAttachmentDescription);
1928 deUint32 resolveAttachmentIndex = VK_ATTACHMENT_UNUSED;
1930 if (m_renderType == RENDER_TYPE_RESOLVE)
1932 resolveAttachmentIndex = static_cast<deUint32>(attachmentDescriptions.size());
1934 const VkAttachmentDescription resolveAttachmentDescription =
1936 0u, // VkAttachmentDescriptionFlags flags;
1937 m_colorFormat, // VkFormat format;
1938 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1939 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
1940 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1941 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1942 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1943 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
1944 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
1946 attachmentDescriptions.push_back(resolveAttachmentDescription);
1949 deUint32 perSampleAttachmentIndex = VK_ATTACHMENT_UNUSED;
1951 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
1953 perSampleAttachmentIndex = static_cast<deUint32>(attachmentDescriptions.size());
1955 const VkAttachmentDescription perSampleAttachmentDescription =
1957 0u, // VkAttachmentDescriptionFlags flags;
1958 m_colorFormat, // VkFormat format;
1959 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1960 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
1961 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1962 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1963 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1964 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
1965 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
1968 for (size_t i = 0; i < m_perSampleImages.size(); ++i)
1970 attachmentDescriptions.push_back(perSampleAttachmentDescription);
1974 deUint32 depthStencilAttachmentIndex = VK_ATTACHMENT_UNUSED;
1976 if (m_useDepth || m_useStencil)
1978 depthStencilAttachmentIndex = static_cast<deUint32>(attachmentDescriptions.size());
1980 const VkAttachmentDescription depthStencilAttachmentDescription =
1982 0u, // VkAttachmentDescriptionFlags flags;
1983 m_depthStencilFormat, // VkFormat format;
1984 m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
1985 (m_useDepth ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_DONT_CARE), // VkAttachmentLoadOp loadOp;
1986 (m_useDepth ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE), // VkAttachmentStoreOp storeOp;
1987 (m_useStencil ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_DONT_CARE), // VkAttachmentStoreOp stencilLoadOp;
1988 (m_useStencil ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE), // VkAttachmentStoreOp stencilStoreOp;
1989 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
1990 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
1992 attachmentDescriptions.push_back(depthStencilAttachmentDescription);
1995 const VkAttachmentReference colorAttachmentReference =
1997 0u, // deUint32 attachment;
1998 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
2001 const VkAttachmentReference inputAttachmentReference =
2003 0u, // deUint32 attachment;
2004 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL // VkImageLayout layout;
2007 const VkAttachmentReference resolveAttachmentReference =
2009 resolveAttachmentIndex, // deUint32 attachment;
2010 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
2013 std::vector<VkAttachmentReference> perSampleAttachmentReferences(m_perSampleImages.size());
2014 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
2016 for (size_t i = 0; i < m_perSampleImages.size(); ++i)
2018 const VkAttachmentReference perSampleAttachmentReference =
2020 perSampleAttachmentIndex + static_cast<deUint32>(i), // deUint32 attachment;
2021 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
2023 perSampleAttachmentReferences[i] = perSampleAttachmentReference;
2027 const VkAttachmentReference depthStencilAttachmentReference =
2029 depthStencilAttachmentIndex, // deUint32 attachment;
2030 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout layout;
2033 std::vector<VkSubpassDescription> subpassDescriptions;
2034 std::vector<VkSubpassDependency> subpassDependencies;
2037 const VkSubpassDescription renderSubpassDescription =
2039 0u, // VkSubpassDescriptionFlags flags;
2040 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
2041 0u, // deUint32 inputAttachmentCount;
2042 DE_NULL, // const VkAttachmentReference* pInputAttachments;
2043 1u, // deUint32 colorAttachmentCount;
2044 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments;
2045 (m_renderType == RENDER_TYPE_RESOLVE) ? &resolveAttachmentReference : DE_NULL, // const VkAttachmentReference* pResolveAttachments;
2046 (m_useDepth || m_useStencil ? &depthStencilAttachmentReference : DE_NULL), // const VkAttachmentReference* pDepthStencilAttachment;
2047 0u, // deUint32 preserveAttachmentCount;
2048 DE_NULL // const VkAttachmentReference* pPreserveAttachments;
2050 subpassDescriptions.push_back(renderSubpassDescription);
2053 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
2056 for (size_t i = 0; i < m_perSampleImages.size(); ++i)
2058 const VkSubpassDescription copySampleSubpassDescription =
2060 0u, // VkSubpassDescriptionFlags flags;
2061 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
2062 1u, // deUint32 inputAttachmentCount;
2063 &inputAttachmentReference, // const VkAttachmentReference* pInputAttachments;
2064 1u, // deUint32 colorAttachmentCount;
2065 &perSampleAttachmentReferences[i], // const VkAttachmentReference* pColorAttachments;
2066 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
2067 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
2068 0u, // deUint32 preserveAttachmentCount;
2069 DE_NULL // const VkAttachmentReference* pPreserveAttachments;
2071 subpassDescriptions.push_back(copySampleSubpassDescription);
2073 const VkSubpassDependency copySampleSubpassDependency =
2075 0u, // deUint32 srcSubpass
2076 1u + static_cast<deUint32>(i), // deUint32 dstSubpass
2077 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
2078 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, // VkPipelineStageFlags dstStageMask
2079 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask
2080 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, // VkAccessFlags dstAccessMask
2081 0u, // VkDependencyFlags dependencyFlags
2083 subpassDependencies.push_back(copySampleSubpassDependency);
2087 const VkRenderPassCreateInfo renderPassParams =
2089 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
2090 DE_NULL, // const void* pNext;
2091 0u, // VkRenderPassCreateFlags flags;
2092 (deUint32)attachmentDescriptions.size(), // deUint32 attachmentCount;
2093 &attachmentDescriptions[0], // const VkAttachmentDescription* pAttachments;
2094 (deUint32)subpassDescriptions.size(), // deUint32 subpassCount;
2095 &subpassDescriptions[0], // const VkSubpassDescription* pSubpasses;
2096 (deUint32)subpassDependencies.size(), // deUint32 dependencyCount;
2097 subpassDependencies.size() != 0 ? &subpassDependencies[0] : DE_NULL
2100 m_renderPass = createRenderPass(vk, vkDevice, &renderPassParams);
2103 // Create framebuffer
2105 std::vector<VkImageView> attachments;
2106 attachments.push_back(*m_colorAttachmentView);
2107 if (m_renderType == RENDER_TYPE_RESOLVE)
2109 attachments.push_back(*m_resolveAttachmentView);
2111 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
2113 for (size_t i = 0; i < m_perSampleImages.size(); ++i)
2115 attachments.push_back(*m_perSampleImages[i]->m_attachmentView);
2119 if (m_useDepth || m_useStencil)
2121 attachments.push_back(*m_depthStencilAttachmentView);
2124 const VkFramebufferCreateInfo framebufferParams =
2126 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
2127 DE_NULL, // const void* pNext;
2128 0u, // VkFramebufferCreateFlags flags;
2129 *m_renderPass, // VkRenderPass renderPass;
2130 (deUint32)attachments.size(), // deUint32 attachmentCount;
2131 &attachments[0], // const VkImageView* pAttachments;
2132 (deUint32)m_renderSize.x(), // deUint32 width;
2133 (deUint32)m_renderSize.y(), // deUint32 height;
2134 1u // deUint32 layers;
2137 m_framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams);
2140 // Create pipeline layout
2142 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
2144 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
2145 DE_NULL, // const void* pNext;
2146 0u, // VkPipelineLayoutCreateFlags flags;
2147 0u, // deUint32 setLayoutCount;
2148 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
2149 0u, // deUint32 pushConstantRangeCount;
2150 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
2153 m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
2155 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
2158 // Create descriptor set layout
2159 const VkDescriptorSetLayoutBinding layoutBinding =
2161 0u, // deUint32 binding;
2162 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, // VkDescriptorType descriptorType;
2163 1u, // deUint32 descriptorCount;
2164 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlags stageFlags;
2165 DE_NULL, // const VkSampler* pImmutableSamplers;
2168 const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutParams =
2170 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType
2171 DE_NULL, // const void* pNext
2172 0u, // VkDescriptorSetLayoutCreateFlags flags
2173 1u, // deUint32 bindingCount
2174 &layoutBinding // const VkDescriptorSetLayoutBinding* pBindings
2176 m_copySampleDesciptorLayout = createDescriptorSetLayout(vk, vkDevice, &descriptorSetLayoutParams);
2178 // Create pipeline layout
2180 const VkPushConstantRange pushConstantRange =
2182 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlags stageFlags;
2183 0u, // deUint32 offset;
2184 sizeof(deInt32) // deUint32 size;
2186 const VkPipelineLayoutCreateInfo copySamplePipelineLayoutParams =
2188 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
2189 DE_NULL, // const void* pNext;
2190 0u, // VkPipelineLayoutCreateFlags flags;
2191 1u, // deUint32 setLayoutCount;
2192 &m_copySampleDesciptorLayout.get(), // const VkDescriptorSetLayout* pSetLayouts;
2193 1u, // deUint32 pushConstantRangeCount;
2194 &pushConstantRange // const VkPushConstantRange* pPushConstantRanges;
2196 m_copySamplePipelineLayout = createPipelineLayout(vk, vkDevice, ©SamplePipelineLayoutParams);
2200 m_vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_vert"), 0);
2201 m_fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_frag"), 0);
2203 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
2205 m_copySampleVertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("quad_vert"), 0);
2206 m_copySampleFragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("copy_sample_frag"), 0);
2211 const VkPipelineShaderStageCreateInfo shaderStageParams[2] =
2214 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2215 DE_NULL, // const void* pNext;
2216 0u, // VkPipelineShaderStageCreateFlags flags;
2217 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
2218 *m_vertexShaderModule, // VkShaderModule module;
2219 "main", // const char* pName;
2220 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2223 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2224 DE_NULL, // const void* pNext;
2225 0u, // VkPipelineShaderStageCreateFlags flags;
2226 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
2227 *m_fragmentShaderModule, // VkShaderModule module;
2228 "main", // const char* pName;
2229 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2233 const VkVertexInputBindingDescription vertexInputBindingDescription =
2235 0u, // deUint32 binding;
2236 sizeof(Vertex4RGBA), // deUint32 stride;
2237 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
2240 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
2243 0u, // deUint32 location;
2244 0u, // deUint32 binding;
2245 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
2246 0u // deUint32 offset;
2249 1u, // deUint32 location;
2250 0u, // deUint32 binding;
2251 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
2252 DE_OFFSET_OF(Vertex4RGBA, color), // deUint32 offset;
2256 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
2258 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
2259 DE_NULL, // const void* pNext;
2260 0u, // VkPipelineVertexInputStateCreateFlags flags;
2261 1u, // deUint32 vertexBindingDescriptionCount;
2262 &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
2263 2u, // deUint32 vertexAttributeDescriptionCount;
2264 vertexInputAttributeDescriptions // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
2267 // Topology is set before the pipeline creation.
2268 VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
2270 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
2271 DE_NULL, // const void* pNext;
2272 0u, // VkPipelineInputAssemblyStateCreateFlags flags;
2273 VK_PRIMITIVE_TOPOLOGY_LAST, // VkPrimitiveTopology topology;
2274 false // VkBool32 primitiveRestartEnable;
2277 const VkViewport viewport =
2281 (float)m_renderSize.x(), // float width;
2282 (float)m_renderSize.y(), // float height;
2283 0.0f, // float minDepth;
2284 1.0f // float maxDepth;
2287 const VkRect2D scissor =
2289 { 0, 0 }, // VkOffset2D offset;
2290 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() } // VkExtent2D extent;
2293 const VkPipelineViewportStateCreateInfo viewportStateParams =
2295 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
2296 DE_NULL, // const void* pNext;
2297 0u, // VkPipelineViewportStateCreateFlags flags;
2298 1u, // deUint32 viewportCount;
2299 &viewport, // const VkViewport* pViewports;
2300 1u, // deUint32 scissorCount;
2301 &scissor // const VkRect2D* pScissors;
2304 const VkPipelineRasterizationStateCreateInfo rasterStateParams =
2306 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
2307 DE_NULL, // const void* pNext;
2308 0u, // VkPipelineRasterizationStateCreateFlags flags;
2309 false, // VkBool32 depthClampEnable;
2310 false, // VkBool32 rasterizerDiscardEnable;
2311 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
2312 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
2313 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
2314 VK_FALSE, // VkBool32 depthBiasEnable;
2315 0.0f, // float depthBiasConstantFactor;
2316 0.0f, // float depthBiasClamp;
2317 0.0f, // float depthBiasSlopeFactor;
2318 1.0f // float lineWidth;
2321 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
2323 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
2324 DE_NULL, // const void* pNext;
2325 0u, // VkPipelineColorBlendStateCreateFlags flags;
2326 false, // VkBool32 logicOpEnable;
2327 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
2328 1u, // deUint32 attachmentCount;
2329 &m_colorBlendState, // const VkPipelineColorBlendAttachmentState* pAttachments;
2330 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4];
2333 const VkStencilOpState stencilOpState =
2335 VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
2336 VK_STENCIL_OP_REPLACE, // VkStencilOp passOp;
2337 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
2338 VK_COMPARE_OP_GREATER, // VkCompareOp compareOp;
2339 1u, // deUint32 compareMask;
2340 1u, // deUint32 writeMask;
2341 1u, // deUint32 reference;
2344 const VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
2346 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
2347 DE_NULL, // const void* pNext;
2348 0u, // VkPipelineDepthStencilStateCreateFlags flags;
2349 m_useDepth, // VkBool32 depthTestEnable;
2350 m_useDepth, // VkBool32 depthWriteEnable;
2351 VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
2352 false, // VkBool32 depthBoundsTestEnable;
2353 m_useStencil, // VkBool32 stencilTestEnable;
2354 stencilOpState, // VkStencilOpState front;
2355 stencilOpState, // VkStencilOpState back;
2356 0.0f, // float minDepthBounds;
2357 1.0f, // float maxDepthBounds;
2360 const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
2362 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
2363 DE_NULL, // const void* pNext;
2364 0u, // VkPipelineCreateFlags flags;
2365 2u, // deUint32 stageCount;
2366 shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages;
2367 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
2368 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
2369 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
2370 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
2371 &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
2372 &m_multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
2373 &depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
2374 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
2375 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
2376 *m_pipelineLayout, // VkPipelineLayout layout;
2377 *m_renderPass, // VkRenderPass renderPass;
2378 0u, // deUint32 subpass;
2379 0u, // VkPipeline basePipelineHandle;
2380 0u // deInt32 basePipelineIndex;
2383 for (deUint32 i = 0u; i < numTopologies; ++i)
2385 inputAssemblyStateParams.topology = pTopology[i];
2386 m_graphicsPipelines.push_back(VkPipelineSp(new Unique<VkPipeline>(createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams))));
2390 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
2392 // Create pipelines for copying samples to single sampled images
2394 const VkPipelineShaderStageCreateInfo shaderStageParams[2] =
2397 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2398 DE_NULL, // const void* pNext;
2399 0u, // VkPipelineShaderStageCreateFlags flags;
2400 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
2401 *m_copySampleVertexShaderModule, // VkShaderModule module;
2402 "main", // const char* pName;
2403 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2406 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2407 DE_NULL, // const void* pNext;
2408 0u, // VkPipelineShaderStageCreateFlags flags;
2409 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
2410 *m_copySampleFragmentShaderModule, // VkShaderModule module;
2411 "main", // const char* pName;
2412 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2416 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
2418 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
2419 DE_NULL, // const void* pNext;
2420 0u, // VkPipelineVertexInputStateCreateFlags flags;
2421 0u, // deUint32 vertexBindingDescriptionCount;
2422 DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
2423 0u, // deUint32 vertexAttributeDescriptionCount;
2424 DE_NULL // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
2427 // Topology is set before the pipeline creation.
2428 VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
2430 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
2431 DE_NULL, // const void* pNext;
2432 0u, // VkPipelineInputAssemblyStateCreateFlags flags;
2433 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology topology;
2434 false // VkBool32 primitiveRestartEnable;
2437 const VkViewport viewport =
2441 (float)m_renderSize.x(), // float width;
2442 (float)m_renderSize.y(), // float height;
2443 0.0f, // float minDepth;
2444 1.0f // float maxDepth;
2447 const VkRect2D scissor =
2449 { 0, 0 }, // VkOffset2D offset;
2450 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() } // VkExtent2D extent;
2453 const VkPipelineViewportStateCreateInfo viewportStateParams =
2455 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
2456 DE_NULL, // const void* pNext;
2457 0u, // VkPipelineViewportStateCreateFlags flags;
2458 1u, // deUint32 viewportCount;
2459 &viewport, // const VkViewport* pViewports;
2460 1u, // deUint32 scissorCount;
2461 &scissor // const VkRect2D* pScissors;
2464 const VkPipelineRasterizationStateCreateInfo rasterStateParams =
2466 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
2467 DE_NULL, // const void* pNext;
2468 0u, // VkPipelineRasterizationStateCreateFlags flags;
2469 false, // VkBool32 depthClampEnable;
2470 false, // VkBool32 rasterizerDiscardEnable;
2471 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
2472 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
2473 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
2474 VK_FALSE, // VkBool32 depthBiasEnable;
2475 0.0f, // float depthBiasConstantFactor;
2476 0.0f, // float depthBiasClamp;
2477 0.0f, // float depthBiasSlopeFactor;
2478 1.0f // float lineWidth;
2481 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
2483 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
2484 DE_NULL, // const void* pNext;
2485 0u, // VkPipelineColorBlendStateCreateFlags flags;
2486 false, // VkBool32 logicOpEnable;
2487 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
2488 1u, // deUint32 attachmentCount;
2489 &m_colorBlendState, // const VkPipelineColorBlendAttachmentState* pAttachments;
2490 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4];
2493 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
2495 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType
2496 DE_NULL, // const void* pNext
2497 0u, // VkPipelineMultisampleStateCreateFlags flags
2498 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples
2499 VK_FALSE, // VkBool32 sampleShadingEnable
2500 0.0f, // float minSampleShading
2501 DE_NULL, // const VkSampleMask* pSampleMask
2502 VK_FALSE, // VkBool32 alphaToCoverageEnable
2503 VK_FALSE, // VkBool32 alphaToOneEnable
2506 const VkGraphicsPipelineCreateInfo graphicsPipelineTemplate =
2508 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
2509 DE_NULL, // const void* pNext;
2510 0u, // VkPipelineCreateFlags flags;
2511 2u, // deUint32 stageCount;
2512 shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages;
2513 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
2514 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
2515 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
2516 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
2517 &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
2518 &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
2519 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
2520 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
2521 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
2522 *m_copySamplePipelineLayout, // VkPipelineLayout layout;
2523 *m_renderPass, // VkRenderPass renderPass;
2524 0u, // deUint32 subpass;
2525 0u, // VkPipeline basePipelineHandle;
2526 0u // deInt32 basePipelineIndex;
2529 for (size_t i = 0; i < m_perSampleImages.size(); ++i)
2531 VkGraphicsPipelineCreateInfo graphicsPipelineParams = graphicsPipelineTemplate;
2533 // Pipeline is to be used in subpasses subsequent to sample-shading subpass
2534 graphicsPipelineParams.subpass = 1u + (deUint32)i;
2536 m_copySamplePipelines.push_back(VkPipelineSp(new Unique<VkPipeline>(createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams))));
2541 const VkDescriptorPoolSize descriptorPoolSize =
2543 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, // VkDescriptorType type;
2544 1u // deUint32 descriptorCount;
2547 const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo =
2549 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType
2550 DE_NULL, // const void* pNext
2551 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, // VkDescriptorPoolCreateFlags flags
2552 1u, // deUint32 maxSets
2553 1u, // deUint32 poolSizeCount
2554 &descriptorPoolSize // const VkDescriptorPoolSize* pPoolSizes
2557 m_copySampleDesciptorPool = createDescriptorPool(vk, vkDevice, &descriptorPoolCreateInfo);
2559 const VkDescriptorSetAllocateInfo descriptorSetAllocateInfo =
2561 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType
2562 DE_NULL, // const void* pNext
2563 *m_copySampleDesciptorPool, // VkDescriptorPool descriptorPool
2564 1u, // deUint32 descriptorSetCount
2565 &m_copySampleDesciptorLayout.get(), // const VkDescriptorSetLayout* pSetLayouts
2568 m_copySampleDesciptorSet = allocateDescriptorSet(vk, vkDevice, &descriptorSetAllocateInfo);
2570 const VkDescriptorImageInfo imageInfo =
2573 *m_colorAttachmentView,
2574 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
2576 const VkWriteDescriptorSet descriptorWrite =
2578 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // VkStructureType sType;
2579 DE_NULL, // const void* pNext;
2580 *m_copySampleDesciptorSet, // VkDescriptorSet dstSet;
2581 0u, // deUint32 dstBinding;
2582 0u, // deUint32 dstArrayElement;
2583 1u, // deUint32 descriptorCount;
2584 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, // VkDescriptorType descriptorType;
2585 &imageInfo, // const VkDescriptorImageInfo* pImageInfo;
2586 DE_NULL, // const VkDescriptorBufferInfo* pBufferInfo;
2587 DE_NULL, // const VkBufferView* pTexelBufferView;
2589 vk.updateDescriptorSets(vkDevice, 1u, &descriptorWrite, 0u, DE_NULL);
2592 // Create vertex buffer
2594 const VkBufferCreateInfo vertexBufferParams =
2596 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
2597 DE_NULL, // const void* pNext;
2598 0u, // VkBufferCreateFlags flags;
2599 1024u, // VkDeviceSize size;
2600 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage;
2601 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2602 1u, // deUint32 queueFamilyIndexCount;
2603 &queueFamilyIndices[0] // const deUint32* pQueueFamilyIndices;
2606 m_vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);
2607 m_vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_vertexBuffer), MemoryRequirement::HostVisible);
2609 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_vertexBuffer, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset()));
2611 // Load vertices into vertex buffer
2613 Vertex4RGBA* pDst = static_cast<Vertex4RGBA*>(m_vertexBufferAlloc->getHostPtr());
2614 for (deUint32 i = 0u; i < numTopologies; ++i)
2616 deMemcpy(pDst, &pVertices[i][0], pVertices[i].size() * sizeof(Vertex4RGBA));
2617 pDst += pVertices[i].size();
2620 flushMappedMemoryRange(vk, vkDevice, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset(), vertexBufferParams.size);
2623 // Create command pool
2624 m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndices[0]);
2626 // Create command buffer
2628 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2630 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2631 DE_NULL, // const void* pNext;
2632 0u, // VkCommandBufferUsageFlags flags;
2633 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2636 VkClearValue colorClearValue;
2637 colorClearValue.color.float32[0] = 0.0f;
2638 colorClearValue.color.float32[1] = 0.0f;
2639 colorClearValue.color.float32[2] = 0.0f;
2640 colorClearValue.color.float32[3] = 0.0f;
2642 VkClearValue depthStencilClearValue;
2643 depthStencilClearValue.depthStencil.depth = 1.0f;
2644 depthStencilClearValue.depthStencil.stencil = 0u;
2646 std::vector<VkClearValue> clearValues;
2647 clearValues.push_back(colorClearValue);
2648 if (m_renderType == RENDER_TYPE_RESOLVE)
2650 clearValues.push_back(colorClearValue);
2652 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
2654 for (size_t i = 0; i < m_perSampleImages.size(); ++i)
2656 clearValues.push_back(colorClearValue);
2659 if (m_useDepth || m_useStencil)
2661 clearValues.push_back(depthStencilClearValue);
2664 const VkRenderPassBeginInfo renderPassBeginInfo =
2666 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
2667 DE_NULL, // const void* pNext;
2668 *m_renderPass, // VkRenderPass renderPass;
2669 *m_framebuffer, // VkFramebuffer framebuffer;
2672 { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() }
2673 }, // VkRect2D renderArea;
2674 (deUint32)clearValues.size(), // deUint32 clearValueCount;
2675 &clearValues[0] // const VkClearValue* pClearValues;
2678 std::vector<VkImageMemoryBarrier> imageLayoutBarriers;
2681 const VkImageMemoryBarrier colorImageBarrier =
2682 // color attachment image
2684 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2685 DE_NULL, // const void* pNext;
2686 0u, // VkAccessFlags srcAccessMask;
2687 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2688 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2689 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2690 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2691 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2692 *m_colorImage, // VkImage image;
2693 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
2695 imageLayoutBarriers.push_back(colorImageBarrier);
2697 if (m_renderType == RENDER_TYPE_RESOLVE)
2699 const VkImageMemoryBarrier resolveImageBarrier =
2700 // resolve attachment image
2702 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2703 DE_NULL, // const void* pNext;
2704 0u, // VkAccessFlags srcAccessMask;
2705 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2706 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2707 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2708 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2709 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2710 *m_resolveImage, // VkImage image;
2711 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
2713 imageLayoutBarriers.push_back(resolveImageBarrier);
2715 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
2717 for (size_t i = 0; i < m_perSampleImages.size(); ++i)
2719 const VkImageMemoryBarrier perSampleImageBarrier =
2720 // resolve attachment image
2722 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2723 DE_NULL, // const void* pNext;
2724 0u, // VkAccessFlags srcAccessMask;
2725 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2726 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2727 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2728 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2729 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2730 *m_perSampleImages[i]->m_image, // VkImage image;
2731 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
2733 imageLayoutBarriers.push_back(perSampleImageBarrier);
2736 if (m_useDepth || m_useStencil)
2738 const VkImageMemoryBarrier depthStencilImageBarrier =
2739 // depth/stencil attachment image
2741 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2742 DE_NULL, // const void* pNext;
2743 0u, // VkAccessFlags srcAccessMask;
2744 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2745 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2746 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2747 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2748 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2749 *m_depthStencilImage, // VkImage image;
2750 { depthStencilAttachmentAspect, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
2752 imageLayoutBarriers.push_back(depthStencilImageBarrier);
2755 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
2757 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2759 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0,
2760 0u, DE_NULL, 0u, DE_NULL, (deUint32)imageLayoutBarriers.size(), &imageLayoutBarriers[0]);
2762 vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
2764 VkDeviceSize vertexBufferOffset = 0u;
2766 for (deUint32 i = 0u; i < numTopologies; ++i)
2768 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, **m_graphicsPipelines[i]);
2769 vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &m_vertexBuffer.get(), &vertexBufferOffset);
2770 vk.cmdDraw(*m_cmdBuffer, (deUint32)pVertices[i].size(), 1, 0, 0);
2772 vertexBufferOffset += static_cast<VkDeviceSize>(pVertices[i].size() * sizeof(Vertex4RGBA));
2775 if (m_renderType == RENDER_TYPE_COPY_SAMPLES)
2777 // Copy each sample id to single sampled image
2778 for (deInt32 sampleId = 0; sampleId < (deInt32)m_perSampleImages.size(); ++sampleId)
2780 vk.cmdNextSubpass(*m_cmdBuffer, VK_SUBPASS_CONTENTS_INLINE);
2781 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, **m_copySamplePipelines[sampleId]);
2782 vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_copySamplePipelineLayout, 0u, 1u, &m_copySampleDesciptorSet.get(), 0u, DE_NULL);
2783 vk.cmdPushConstants(*m_cmdBuffer, *m_copySamplePipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(deInt32), &sampleId);
2784 vk.cmdDraw(*m_cmdBuffer, 4, 1, 0, 0);
2788 vk.cmdEndRenderPass(*m_cmdBuffer);
2790 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2794 m_fence = createFence(vk, vkDevice);
2797 MultisampleRenderer::~MultisampleRenderer (void)
2801 de::MovePtr<tcu::TextureLevel> MultisampleRenderer::render (void)
2803 const DeviceInterface& vk = m_context.getDeviceInterface();
2804 const VkDevice vkDevice = m_context.getDevice();
2805 const VkQueue queue = m_context.getUniversalQueue();
2806 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
2807 const VkSubmitInfo submitInfo =
2809 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
2810 DE_NULL, // const void* pNext;
2811 0u, // deUint32 waitSemaphoreCount;
2812 DE_NULL, // const VkSemaphore* pWaitSemaphores;
2813 (const VkPipelineStageFlags*)DE_NULL,
2814 1u, // deUint32 commandBufferCount;
2815 &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
2816 0u, // deUint32 signalSemaphoreCount;
2817 DE_NULL // const VkSemaphore* pSignalSemaphores;
2820 VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
2821 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
2822 VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
2824 if (m_renderType == RENDER_TYPE_RESOLVE)
2826 return readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, m_context.getDefaultAllocator(), *m_resolveImage, m_colorFormat, m_renderSize.cast<deUint32>());
2830 return de::MovePtr<tcu::TextureLevel>();
2834 de::MovePtr<tcu::TextureLevel> MultisampleRenderer::getSingleSampledImage (deUint32 sampleId)
2836 return readColorAttachment(m_context.getDeviceInterface(), m_context.getDevice(), m_context.getUniversalQueue(), m_context.getUniversalQueueFamilyIndex(), m_context.getDefaultAllocator(), *m_perSampleImages[sampleId]->m_image, m_colorFormat, m_renderSize.cast<deUint32>());
2841 tcu::TestCaseGroup* createMultisampleTests (tcu::TestContext& testCtx)
2843 const VkSampleCountFlagBits samples[] =
2845 VK_SAMPLE_COUNT_2_BIT,
2846 VK_SAMPLE_COUNT_4_BIT,
2847 VK_SAMPLE_COUNT_8_BIT,
2848 VK_SAMPLE_COUNT_16_BIT,
2849 VK_SAMPLE_COUNT_32_BIT,
2850 VK_SAMPLE_COUNT_64_BIT
2853 de::MovePtr<tcu::TestCaseGroup> multisampleTests (new tcu::TestCaseGroup(testCtx, "multisample", ""));
2855 // Rasterization samples tests
2857 de::MovePtr<tcu::TestCaseGroup> rasterizationSamplesTests(new tcu::TestCaseGroup(testCtx, "raster_samples", ""));
2859 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
2861 std::ostringstream caseName;
2862 caseName << "samples_" << samples[samplesNdx];
2864 de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
2866 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_triangle", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR));
2867 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_line", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_REGULAR));
2868 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_point", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_REGULAR));
2870 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR, TEST_MODE_DEPTH_BIT));
2871 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "stencil", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR, TEST_MODE_STENCIL_BIT));
2872 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth_stencil", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR, TEST_MODE_DEPTH_BIT | TEST_MODE_STENCIL_BIT));
2874 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_triangle_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE));
2875 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_line_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_SPARSE));
2876 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_point_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_SPARSE));
2878 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE, TEST_MODE_DEPTH_BIT));
2879 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "stencil_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE, TEST_MODE_STENCIL_BIT));
2880 samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth_stencil_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE, TEST_MODE_DEPTH_BIT | TEST_MODE_STENCIL_BIT));
2882 rasterizationSamplesTests->addChild(samplesTests.release());
2885 multisampleTests->addChild(rasterizationSamplesTests.release());
2888 // Raster samples consistency check
2890 de::MovePtr<tcu::TestCaseGroup> rasterSamplesConsistencyTests (new tcu::TestCaseGroup(testCtx, "raster_samples_consistency", ""));
2891 MultisampleTestParams paramsRegular = {GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR};
2892 MultisampleTestParams paramsSparse = {GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE};
2894 addFunctionCaseWithPrograms(rasterSamplesConsistencyTests.get(),
2895 "unique_colors_check",
2897 initMultisamplePrograms,
2898 testRasterSamplesConsistency,
2901 addFunctionCaseWithPrograms(rasterSamplesConsistencyTests.get(),
2902 "unique_colors_check_sparse",
2904 initMultisamplePrograms,
2905 testRasterSamplesConsistency,
2908 multisampleTests->addChild(rasterSamplesConsistencyTests.release());
2911 // minSampleShading tests
2916 float minSampleShading;
2919 const TestConfig testConfigs[] =
2921 { "min_0_0", 0.0f },
2922 { "min_0_25", 0.25f },
2923 { "min_0_5", 0.5f },
2924 { "min_0_75", 0.75f },
2928 de::MovePtr<tcu::TestCaseGroup> minSampleShadingTests(new tcu::TestCaseGroup(testCtx, "min_sample_shading", ""));
2930 for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(testConfigs); configNdx++)
2932 const TestConfig& testConfig = testConfigs[configNdx];
2933 de::MovePtr<tcu::TestCaseGroup> minShadingValueTests (new tcu::TestCaseGroup(testCtx, testConfigs[configNdx].name, ""));
2935 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
2937 std::ostringstream caseName;
2938 caseName << "samples_" << samples[samplesNdx];
2940 de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
2942 samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_triangle", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR));
2943 samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_line", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_REGULAR));
2944 samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_point", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_REGULAR));
2946 samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_triangle_sparse", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE));
2947 samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_line_sparse", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_SPARSE));
2948 samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_point_sparse", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_SPARSE));
2950 minShadingValueTests->addChild(samplesTests.release());
2953 minSampleShadingTests->addChild(minShadingValueTests.release());
2956 multisampleTests->addChild(minSampleShadingTests.release());
2959 // pSampleMask tests
2964 const char* description;
2965 VkSampleMask sampleMask;
2968 const TestConfig testConfigs[] =
2970 { "mask_all_on", "All mask bits are off", 0x0 },
2971 { "mask_all_off", "All mask bits are on", 0xFFFFFFFF },
2972 { "mask_one", "All mask elements are 0x1", 0x1},
2973 { "mask_random", "All mask elements are 0xAAAAAAAA", 0xAAAAAAAA },
2976 de::MovePtr<tcu::TestCaseGroup> sampleMaskTests(new tcu::TestCaseGroup(testCtx, "sample_mask", ""));
2978 for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(testConfigs); configNdx++)
2980 const TestConfig& testConfig = testConfigs[configNdx];
2981 de::MovePtr<tcu::TestCaseGroup> sampleMaskValueTests (new tcu::TestCaseGroup(testCtx, testConfig.name, testConfig.description));
2983 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
2985 std::ostringstream caseName;
2986 caseName << "samples_" << samples[samplesNdx];
2988 const deUint32 sampleMaskCount = samples[samplesNdx] / 32;
2989 de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
2991 std::vector<VkSampleMask> mask;
2992 for (deUint32 maskNdx = 0; maskNdx < sampleMaskCount; maskNdx++)
2993 mask.push_back(testConfig.sampleMask);
2995 samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_triangle", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR));
2996 samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_line", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_REGULAR));
2997 samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_point", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_REGULAR));
2999 samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_triangle_sparse", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE));
3000 samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_line_sparse", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_SPARSE));
3001 samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_point_sparse", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_SPARSE));
3003 sampleMaskValueTests->addChild(samplesTests.release());
3006 sampleMaskTests->addChild(sampleMaskValueTests.release());
3009 multisampleTests->addChild(sampleMaskTests.release());
3015 de::MovePtr<tcu::TestCaseGroup> alphaToOneTests(new tcu::TestCaseGroup(testCtx, "alpha_to_one", ""));
3017 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
3019 std::ostringstream caseName;
3020 caseName << "samples_" << samples[samplesNdx];
3022 alphaToOneTests->addChild(new AlphaToOneTest(testCtx, caseName.str(), "", samples[samplesNdx], IMAGE_BACKING_MODE_REGULAR));
3024 caseName << "_sparse";
3025 alphaToOneTests->addChild(new AlphaToOneTest(testCtx, caseName.str(), "", samples[samplesNdx], IMAGE_BACKING_MODE_SPARSE));
3028 multisampleTests->addChild(alphaToOneTests.release());
3031 // AlphaToCoverageEnable tests
3033 de::MovePtr<tcu::TestCaseGroup> alphaToCoverageTests (new tcu::TestCaseGroup(testCtx, "alpha_to_coverage", ""));
3035 for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); samplesNdx++)
3037 std::ostringstream caseName;
3038 caseName << "samples_" << samples[samplesNdx];
3040 de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
3042 samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_opaque", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_QUAD, IMAGE_BACKING_MODE_REGULAR));
3043 samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_translucent", "", samples[samplesNdx], GEOMETRY_TYPE_TRANSLUCENT_QUAD, IMAGE_BACKING_MODE_REGULAR));
3044 samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_invisible", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_QUAD, IMAGE_BACKING_MODE_REGULAR));
3046 samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_opaque_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_QUAD, IMAGE_BACKING_MODE_SPARSE));
3047 samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_translucent_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_TRANSLUCENT_QUAD, IMAGE_BACKING_MODE_SPARSE));
3048 samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_invisible_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_QUAD, IMAGE_BACKING_MODE_SPARSE));
3050 alphaToCoverageTests->addChild(samplesTests.release());
3052 multisampleTests->addChild(alphaToCoverageTests.release());
3055 // Sampling from a multisampled image texture (texelFetch)
3057 multisampleTests->addChild(createMultisampleSampledImageTests(testCtx));
3060 // Load/store on a multisampled rendered image (different kinds of access: color attachment write, storage image, etc.)
3062 multisampleTests->addChild(createMultisampleStorageImageTests(testCtx));
3065 return multisampleTests.release();