1 /*-------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015 Google Inc.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
21 * \brief RenderPass tests
22 *//*--------------------------------------------------------------------*/
24 #include "vktRenderPassTests.hpp"
25 #include "vktRenderPassTestsUtil.hpp"
27 #include "vktRenderPassMultisampleTests.hpp"
28 #include "vktRenderPassMultisampleResolveTests.hpp"
29 #include "vktRenderPassSampleReadTests.hpp"
30 #include "vktRenderPassSparseRenderTargetTests.hpp"
31 #include "vktRenderPassSubpassDependencyTests.hpp"
32 #include "vktRenderPassUnusedAttachmentTests.hpp"
33 #include "vktRenderPassUnusedClearAttachmentTests.hpp"
34 #include "vktRenderPassDepthStencilResolveTests.hpp"
35 #include "vktRenderPassUnusedAttachmentSparseFillingTests.hpp"
36 #include "vktRenderPassFragmentDensityMapTests.hpp"
37 #include "vktRenderPassMultipleSubpassesMultipleCommandBuffersTests.hpp"
38 #include "vktRenderPassLoadStoreOpNoneTests.hpp"
39 #include "vktDynamicRenderingTests.hpp"
41 #include "vktTestCaseUtil.hpp"
42 #include "vktTestGroupUtil.hpp"
45 #include "vkDeviceUtil.hpp"
46 #include "vkImageUtil.hpp"
47 #include "vkMemUtil.hpp"
48 #include "vkPlatform.hpp"
49 #include "vkPrograms.hpp"
50 #include "vkQueryUtil.hpp"
52 #include "vkRefUtil.hpp"
53 #include "vkStrUtil.hpp"
54 #include "vkTypeUtil.hpp"
55 #include "vkCmdUtil.hpp"
56 #include "vkObjUtil.hpp"
58 #include "tcuFloat.hpp"
59 #include "tcuFormatUtil.hpp"
60 #include "tcuMaybe.hpp"
61 #include "tcuResultCollector.hpp"
62 #include "tcuTestLog.hpp"
63 #include "tcuTextureUtil.hpp"
64 #include "tcuVectorUtil.hpp"
66 #include "deRandom.hpp"
67 #include "deSTLUtil.hpp"
68 #include "deSharedPtr.hpp"
69 #include "deStringUtil.hpp"
70 #include "deUniquePtr.hpp"
91 using tcu::ConstPixelBufferAccess;
92 using tcu::PixelBufferAccess;
107 using namespace renderpass;
109 typedef vector<deUint8> DepthValuesArray;
111 static const deUint8 DEPTH_VALUES[] = { 0u, 255u, 1u };
115 ALLOCATION_KIND_SUBALLOCATED,
116 ALLOCATION_KIND_DEDICATED,
119 struct TestConfigExternal
121 TestConfigExternal (AllocationKind allocationKind_,
122 RenderingType renderingType_)
123 : allocationKind (allocationKind_)
124 , renderingType (renderingType_)
128 AllocationKind allocationKind;
129 RenderingType renderingType;
132 de::MovePtr<Allocation> allocateBuffer (const InstanceInterface& vki,
133 const DeviceInterface& vkd,
134 const VkPhysicalDevice& physDevice,
135 const VkDevice device,
136 const VkBuffer& buffer,
137 const MemoryRequirement requirement,
138 Allocator& allocator,
139 AllocationKind allocationKind)
141 switch (allocationKind)
143 case ALLOCATION_KIND_SUBALLOCATED:
145 const VkMemoryRequirements memoryRequirements = getBufferMemoryRequirements(vkd, device, buffer);
147 return allocator.allocate(memoryRequirements, requirement);
150 case ALLOCATION_KIND_DEDICATED:
152 return allocateDedicated(vki, vkd, physDevice, device, buffer, requirement);
157 TCU_THROW(InternalError, "Invalid allocation kind");
162 de::MovePtr<Allocation> allocateImage (const InstanceInterface& vki,
163 const DeviceInterface& vkd,
164 const VkPhysicalDevice& physDevice,
165 const VkDevice device,
166 const VkImage& image,
167 const MemoryRequirement requirement,
168 Allocator& allocator,
169 AllocationKind allocationKind)
171 switch (allocationKind)
173 case ALLOCATION_KIND_SUBALLOCATED:
175 const VkMemoryRequirements memoryRequirements = getImageMemoryRequirements(vkd, device, image);
177 return allocator.allocate(memoryRequirements, requirement);
180 case ALLOCATION_KIND_DEDICATED:
182 return allocateDedicated(vki, vkd, physDevice, device, image, requirement);
187 TCU_THROW(InternalError, "Invalid allocation kind");
200 const char* boolOpToString (BoolOp op)
217 DE_FATAL("Unknown boolean operation.");
222 bool performBoolOp (BoolOp op, bool a, bool b)
239 DE_FATAL("Unknown boolean operation.");
244 BoolOp boolOpFromIndex (size_t index)
254 return ops[index % DE_LENGTH_OF_ARRAY(ops)];
257 static float requiredDepthEpsilon(VkFormat format)
259 // Possible precision loss in the unorm depth pipeline means that we need to check depths
260 // that go in and back out of the depth buffer with an epsilon rather than an exact match
261 deUint32 unormBits = 0;
265 case VK_FORMAT_D16_UNORM:
268 case VK_FORMAT_X8_D24_UNORM_PACK32:
269 case VK_FORMAT_D24_UNORM_S8_UINT:
272 case VK_FORMAT_D32_SFLOAT:
273 case VK_FORMAT_D32_SFLOAT_S8_UINT:
280 return 1.0f / (float)((1 << unormBits) - 1);
282 return 0.0f; // Require exact match
285 static bool depthsEqual(float a, float b, float epsilon)
287 return fabs(a - b) <= epsilon;
290 Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk,
292 VkFramebufferCreateFlags pCreateInfo_flags,
293 VkRenderPass pCreateInfo_renderPass,
294 deUint32 pCreateInfo_attachmentCount,
295 const VkImageView* pCreateInfo_pAttachments,
296 deUint32 pCreateInfo_width,
297 deUint32 pCreateInfo_height,
298 deUint32 pCreateInfo_layers)
300 const VkFramebufferCreateInfo pCreateInfo =
302 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
305 pCreateInfo_renderPass,
306 pCreateInfo_attachmentCount,
307 pCreateInfo_pAttachments,
312 return createFramebuffer(vk, device, &pCreateInfo);
315 Move<VkImage> createImage (const DeviceInterface& vk,
317 VkImageCreateFlags pCreateInfo_flags,
318 VkImageType pCreateInfo_imageType,
319 VkFormat pCreateInfo_format,
320 VkExtent3D pCreateInfo_extent,
321 deUint32 pCreateInfo_mipLevels,
322 deUint32 pCreateInfo_arrayLayers,
323 VkSampleCountFlagBits pCreateInfo_samples,
324 VkImageTiling pCreateInfo_tiling,
325 VkImageUsageFlags pCreateInfo_usage,
326 VkSharingMode pCreateInfo_sharingMode,
327 deUint32 pCreateInfo_queueFamilyCount,
328 const deUint32* pCreateInfo_pQueueFamilyIndices,
329 VkImageLayout pCreateInfo_initialLayout)
331 const VkImageCreateInfo pCreateInfo =
333 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
336 pCreateInfo_imageType,
339 pCreateInfo_mipLevels,
340 pCreateInfo_arrayLayers,
344 pCreateInfo_sharingMode,
345 pCreateInfo_queueFamilyCount,
346 pCreateInfo_pQueueFamilyIndices,
347 pCreateInfo_initialLayout
349 return createImage(vk, device, &pCreateInfo);
352 void bindBufferMemory (const DeviceInterface& vk, VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset)
354 VK_CHECK(vk.bindBufferMemory(device, buffer, mem, memOffset));
357 void bindImageMemory (const DeviceInterface& vk, VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset)
359 VK_CHECK(vk.bindImageMemory(device, image, mem, memOffset));
362 Move<VkImageView> createImageView (const DeviceInterface& vk,
364 VkImageViewCreateFlags pCreateInfo_flags,
365 VkImage pCreateInfo_image,
366 VkImageViewType pCreateInfo_viewType,
367 VkFormat pCreateInfo_format,
368 VkComponentMapping pCreateInfo_components,
369 VkImageSubresourceRange pCreateInfo_subresourceRange)
371 const VkImageViewCreateInfo pCreateInfo =
373 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
377 pCreateInfo_viewType,
379 pCreateInfo_components,
380 pCreateInfo_subresourceRange,
382 return createImageView(vk, device, &pCreateInfo);
385 Move<VkBuffer> createBuffer (const DeviceInterface& vk,
387 VkBufferCreateFlags pCreateInfo_flags,
388 VkDeviceSize pCreateInfo_size,
389 VkBufferUsageFlags pCreateInfo_usage,
390 VkSharingMode pCreateInfo_sharingMode,
391 deUint32 pCreateInfo_queueFamilyCount,
392 const deUint32* pCreateInfo_pQueueFamilyIndices)
394 const VkBufferCreateInfo pCreateInfo =
396 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
401 pCreateInfo_sharingMode,
402 pCreateInfo_queueFamilyCount,
403 pCreateInfo_pQueueFamilyIndices,
405 return createBuffer(vk, device, &pCreateInfo);
408 VkRenderPassBeginInfo createRenderPassBeginInfo (VkRenderPass pRenderPassBegin_renderPass,
409 VkFramebuffer pRenderPassBegin_framebuffer,
410 VkRect2D pRenderPassBegin_renderArea,
411 deUint32 pRenderPassBegin_clearValueCount,
412 const VkClearValue* pRenderPassBegin_pAttachmentClearValues)
414 const VkRenderPassBeginInfo renderPassBeginInfo =
416 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
418 pRenderPassBegin_renderPass,
419 pRenderPassBegin_framebuffer,
420 pRenderPassBegin_renderArea,
421 pRenderPassBegin_clearValueCount,
422 pRenderPassBegin_pAttachmentClearValues,
425 return renderPassBeginInfo;
428 void queueSubmit (const DeviceInterface& vk, VkQueue queue, deUint32 cmdBufferCount, const VkCommandBuffer* pCmdBuffers, VkFence fence)
430 const VkSubmitInfo submitInfo =
432 VK_STRUCTURE_TYPE_SUBMIT_INFO,
434 0u, // waitSemaphoreCount
435 (const VkSemaphore*)DE_NULL, // pWaitSemaphores
436 (const VkPipelineStageFlags*)DE_NULL,
437 cmdBufferCount, // commandBufferCount
439 0u, // signalSemaphoreCount
440 (const VkSemaphore*)DE_NULL, // pSignalSemaphores
442 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence));
445 void waitForFences (const DeviceInterface& vk, VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout)
447 VK_CHECK(vk.waitForFences(device, fenceCount, pFences, waitAll, timeout));
450 VkImageAspectFlags getImageAspectFlags (VkFormat vkFormat)
452 const tcu::TextureFormat format = mapVkFormat(vkFormat);
454 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 22);
456 switch (format.order)
458 case tcu::TextureFormat::DS:
459 return VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT;
461 case tcu::TextureFormat::D:
462 return VK_IMAGE_ASPECT_DEPTH_BIT;
464 case tcu::TextureFormat::S:
465 return VK_IMAGE_ASPECT_STENCIL_BIT;
468 return VK_IMAGE_ASPECT_COLOR_BIT;
472 VkAccessFlags getAllMemoryReadFlags (void)
474 return VK_ACCESS_TRANSFER_READ_BIT
475 | VK_ACCESS_UNIFORM_READ_BIT
476 | VK_ACCESS_HOST_READ_BIT
477 | VK_ACCESS_INDEX_READ_BIT
478 | VK_ACCESS_SHADER_READ_BIT
479 | VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
480 | VK_ACCESS_INDIRECT_COMMAND_READ_BIT
481 | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
482 | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT
483 | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
486 VkAccessFlags getAllMemoryWriteFlags (void)
488 return VK_ACCESS_TRANSFER_WRITE_BIT
489 | VK_ACCESS_HOST_WRITE_BIT
490 | VK_ACCESS_SHADER_WRITE_BIT
491 | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
492 | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
495 VkAccessFlags getMemoryFlagsForLayout (const VkImageLayout layout)
499 case VK_IMAGE_LAYOUT_GENERAL: return getAllMemoryReadFlags() | getAllMemoryWriteFlags();
500 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
501 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
502 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
503 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: return VK_ACCESS_SHADER_READ_BIT;
504 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: return VK_ACCESS_TRANSFER_READ_BIT;
505 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: return VK_ACCESS_TRANSFER_WRITE_BIT;
506 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
507 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
509 return (VkAccessFlags)0;
513 VkPipelineStageFlags getAllPipelineStageFlags (void)
515 /* All relevant flags for a pipeline containing VS+PS. */
516 return VK_PIPELINE_STAGE_TRANSFER_BIT
517 | VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
518 | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
519 | VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
520 | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
521 | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
522 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
523 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
524 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
525 | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
526 | VK_PIPELINE_STAGE_HOST_BIT;
529 class AttachmentReference
532 AttachmentReference (deUint32 attachment,
533 VkImageLayout layout,
534 VkImageAspectFlags aspectMask = static_cast<VkImageAspectFlags>(0u))
535 : m_attachment (attachment)
537 , m_aspectMask (aspectMask)
541 deUint32 getAttachment (void) const { return m_attachment; }
542 VkImageLayout getImageLayout (void) const { return m_layout; }
543 VkImageAspectFlags getAspectMask (void) const { return m_aspectMask; }
544 void setImageLayout (VkImageLayout layout) { m_layout = layout; }
547 deUint32 m_attachment;
548 VkImageLayout m_layout;
549 VkImageAspectFlags m_aspectMask;
555 Subpass (VkPipelineBindPoint pipelineBindPoint,
556 VkSubpassDescriptionFlags flags,
557 const vector<AttachmentReference>& inputAttachments,
558 const vector<AttachmentReference>& colorAttachments,
559 const vector<AttachmentReference>& resolveAttachments,
560 AttachmentReference depthStencilAttachment,
561 const vector<deUint32>& preserveAttachments,
562 bool omitBlendState = false)
563 : m_pipelineBindPoint (pipelineBindPoint)
565 , m_inputAttachments (inputAttachments)
566 , m_colorAttachments (colorAttachments)
567 , m_resolveAttachments (resolveAttachments)
568 , m_depthStencilAttachment (depthStencilAttachment)
569 , m_preserveAttachments (preserveAttachments)
570 , m_omitBlendState (omitBlendState)
574 VkPipelineBindPoint getPipelineBindPoint (void) const { return m_pipelineBindPoint; }
575 VkSubpassDescriptionFlags getFlags (void) const { return m_flags; }
576 const vector<AttachmentReference>& getInputAttachments (void) const { return m_inputAttachments; }
577 const vector<AttachmentReference>& getColorAttachments (void) const { return m_colorAttachments; }
578 const vector<AttachmentReference>& getResolveAttachments (void) const { return m_resolveAttachments; }
579 const AttachmentReference& getDepthStencilAttachment (void) const { return m_depthStencilAttachment; }
580 const vector<deUint32>& getPreserveAttachments (void) const { return m_preserveAttachments; }
581 bool getOmitBlendState (void) const { return m_omitBlendState; }
584 VkPipelineBindPoint m_pipelineBindPoint;
585 VkSubpassDescriptionFlags m_flags;
587 vector<AttachmentReference> m_inputAttachments;
588 vector<AttachmentReference> m_colorAttachments;
589 vector<AttachmentReference> m_resolveAttachments;
590 AttachmentReference m_depthStencilAttachment;
592 vector<deUint32> m_preserveAttachments;
593 bool m_omitBlendState;
596 class SubpassDependency
599 SubpassDependency (deUint32 srcPass,
602 VkPipelineStageFlags srcStageMask,
603 VkPipelineStageFlags dstStageMask,
605 VkAccessFlags srcAccessMask,
606 VkAccessFlags dstAccessMask,
608 VkDependencyFlags flags)
609 : m_srcPass (srcPass)
610 , m_dstPass (dstPass)
612 , m_srcStageMask (srcStageMask)
613 , m_dstStageMask (dstStageMask)
615 , m_srcAccessMask (srcAccessMask)
616 , m_dstAccessMask (dstAccessMask)
621 deUint32 getSrcPass (void) const { return m_srcPass; }
622 deUint32 getDstPass (void) const { return m_dstPass; }
624 VkPipelineStageFlags getSrcStageMask (void) const { return m_srcStageMask; }
625 VkPipelineStageFlags getDstStageMask (void) const { return m_dstStageMask; }
627 VkAccessFlags getSrcAccessMask (void) const { return m_srcAccessMask; }
628 VkAccessFlags getDstAccessMask (void) const { return m_dstAccessMask; }
630 VkDependencyFlags getFlags (void) const { return m_flags; }
632 void setSrcAccessMask (const VkAccessFlags& flags) { m_srcAccessMask = flags; }
633 void setDstAccessMask (const VkAccessFlags& flags) { m_dstAccessMask = flags; }
639 VkPipelineStageFlags m_srcStageMask;
640 VkPipelineStageFlags m_dstStageMask;
642 VkAccessFlags m_srcAccessMask;
643 VkAccessFlags m_dstAccessMask;
644 VkDependencyFlags m_flags;
650 Attachment (VkFormat format,
651 VkSampleCountFlagBits samples,
653 VkAttachmentLoadOp loadOp,
654 VkAttachmentStoreOp storeOp,
656 VkAttachmentLoadOp stencilLoadOp,
657 VkAttachmentStoreOp stencilStoreOp,
659 VkImageLayout initialLayout,
660 VkImageLayout finalLayout)
662 , m_samples (samples)
665 , m_storeOp (storeOp)
667 , m_stencilLoadOp (stencilLoadOp)
668 , m_stencilStoreOp (stencilStoreOp)
670 , m_initialLayout (initialLayout)
671 , m_finalLayout (finalLayout)
675 VkFormat getFormat (void) const { return m_format; }
676 VkSampleCountFlagBits getSamples (void) const { return m_samples; }
678 VkAttachmentLoadOp getLoadOp (void) const { return m_loadOp; }
679 VkAttachmentStoreOp getStoreOp (void) const { return m_storeOp; }
682 VkAttachmentLoadOp getStencilLoadOp (void) const { return m_stencilLoadOp; }
683 VkAttachmentStoreOp getStencilStoreOp (void) const { return m_stencilStoreOp; }
685 VkImageLayout getInitialLayout (void) const { return m_initialLayout; }
686 VkImageLayout getFinalLayout (void) const { return m_finalLayout; }
690 VkSampleCountFlagBits m_samples;
692 VkAttachmentLoadOp m_loadOp;
693 VkAttachmentStoreOp m_storeOp;
695 VkAttachmentLoadOp m_stencilLoadOp;
696 VkAttachmentStoreOp m_stencilStoreOp;
698 VkImageLayout m_initialLayout;
699 VkImageLayout m_finalLayout;
705 RenderPass (const vector<Attachment>& attachments,
706 const vector<Subpass>& subpasses,
707 const vector<SubpassDependency>& dependencies,
708 const vector<VkInputAttachmentAspectReference> inputAspects = vector<VkInputAttachmentAspectReference>())
709 : m_attachments (attachments)
710 , m_subpasses (subpasses)
711 , m_dependencies (dependencies)
712 , m_inputAspects (inputAspects)
716 const vector<Attachment>& getAttachments (void) const { return m_attachments; }
717 const vector<Subpass>& getSubpasses (void) const { return m_subpasses; }
718 const vector<SubpassDependency>& getDependencies (void) const { return m_dependencies; }
719 const vector<VkInputAttachmentAspectReference>& getInputAspects (void) const { return m_inputAspects; }
722 const vector<Attachment> m_attachments;
723 const vector<Subpass> m_subpasses;
724 const vector<SubpassDependency> m_dependencies;
725 const vector<VkInputAttachmentAspectReference> m_inputAspects;
732 RENDERTYPES_NONE = 0,
733 RENDERTYPES_CLEAR = (1<<1),
734 RENDERTYPES_DRAW = (1<<2)
737 enum CommandBufferTypes
739 COMMANDBUFFERTYPES_INLINE = (1<<0),
740 COMMANDBUFFERTYPES_SECONDARY = (1<<1)
745 IMAGEMEMORY_STRICT = (1<<0),
746 IMAGEMEMORY_LAZY = (1<<1)
749 TestConfig (const RenderPass& renderPass_,
750 RenderTypes renderTypes_,
751 CommandBufferTypes commandBufferTypes_,
752 ImageMemory imageMemory_,
753 const UVec2& targetSize_,
754 const UVec2& renderPos_,
755 const UVec2& renderSize_,
756 deBool useFormatCompCount_,
758 deUint32 drawStartNdx_,
759 AllocationKind allocationKind_,
760 RenderingType renderingType_,
761 vector<DeviceCoreFeature> requiredFeatures_ = vector<DeviceCoreFeature>())
762 : renderPass (renderPass_)
763 , renderTypes (renderTypes_)
764 , commandBufferTypes (commandBufferTypes_)
765 , imageMemory (imageMemory_)
766 , targetSize (targetSize_)
767 , renderPos (renderPos_)
768 , renderSize (renderSize_)
769 , useFormatCompCount (useFormatCompCount_)
771 , drawStartNdx (drawStartNdx_)
772 , allocationKind (allocationKind_)
773 , renderingType (renderingType_)
774 , requiredFeatures (requiredFeatures_)
776 DepthValuesArray shuffledDepthValues (&DEPTH_VALUES[0], &DEPTH_VALUES[DE_LENGTH_OF_ARRAY(DEPTH_VALUES)]);
777 de::Random rng (seed + 1);
779 rng.shuffle(shuffledDepthValues.begin(), shuffledDepthValues.end());
781 depthValues.push_back(shuffledDepthValues[0]);
782 depthValues.push_back(shuffledDepthValues[1]);
785 RenderPass renderPass;
786 RenderTypes renderTypes;
787 CommandBufferTypes commandBufferTypes;
788 ImageMemory imageMemory;
792 deBool useFormatCompCount;
794 deUint32 drawStartNdx;
795 AllocationKind allocationKind;
796 RenderingType renderingType;
797 vector<DeviceCoreFeature> requiredFeatures;
798 DepthValuesArray depthValues;
801 TestConfig::RenderTypes operator| (TestConfig::RenderTypes a, TestConfig::RenderTypes b)
803 return (TestConfig::RenderTypes)(((deUint32)a) | ((deUint32)b));
806 TestConfig::CommandBufferTypes operator| (TestConfig::CommandBufferTypes a, TestConfig::CommandBufferTypes b)
808 return (TestConfig::CommandBufferTypes)(((deUint32)a) | ((deUint32)b));
811 TestConfig::ImageMemory operator| (TestConfig::ImageMemory a, TestConfig::ImageMemory b)
813 return (TestConfig::ImageMemory)(((deUint32)a) | ((deUint32)b));
816 void checkSupport (Context& context, TestConfig config)
818 for (size_t featureNdx = 0; featureNdx < config.requiredFeatures.size(); featureNdx++)
819 context.requireDeviceCoreFeature(config.requiredFeatures[featureNdx]);
822 void logRenderPassInfo (TestLog& log,
823 const RenderPass& renderPass)
825 const bool useExternalInputAspect = !renderPass.getInputAspects().empty();
826 const tcu::ScopedLogSection section (log, "RenderPass", "RenderPass");
829 const tcu::ScopedLogSection attachmentsSection (log, "Attachments", "Attachments");
830 const vector<Attachment>& attachments = renderPass.getAttachments();
832 for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
834 const tcu::ScopedLogSection attachmentSection (log, "Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx));
835 const Attachment& attachment = attachments[attachmentNdx];
837 log << TestLog::Message << "Format: " << attachment.getFormat() << TestLog::EndMessage;
838 log << TestLog::Message << "Samples: " << attachment.getSamples() << TestLog::EndMessage;
840 log << TestLog::Message << "LoadOp: " << attachment.getLoadOp() << TestLog::EndMessage;
841 log << TestLog::Message << "StoreOp: " << attachment.getStoreOp() << TestLog::EndMessage;
843 log << TestLog::Message << "StencilLoadOp: " << attachment.getStencilLoadOp() << TestLog::EndMessage;
844 log << TestLog::Message << "StencilStoreOp: " << attachment.getStencilStoreOp() << TestLog::EndMessage;
846 log << TestLog::Message << "InitialLayout: " << attachment.getInitialLayout() << TestLog::EndMessage;
847 log << TestLog::Message << "FinalLayout: " << attachment.getFinalLayout() << TestLog::EndMessage;
851 if (useExternalInputAspect)
853 const tcu::ScopedLogSection inputAspectSection (log, "InputAspects", "InputAspects");
855 for (size_t aspectNdx = 0; aspectNdx < renderPass.getInputAspects().size(); aspectNdx++)
857 const VkInputAttachmentAspectReference& inputAspect (renderPass.getInputAspects()[aspectNdx]);
859 log << TestLog::Message << "Subpass: " << inputAspect.subpass << TestLog::EndMessage;
860 log << TestLog::Message << "InputAttachmentIndex: " << inputAspect.inputAttachmentIndex << TestLog::EndMessage;
861 log << TestLog::Message << "AspectFlags: " << getImageAspectFlagsStr(inputAspect.aspectMask) << TestLog::EndMessage;
866 const tcu::ScopedLogSection subpassesSection (log, "Subpasses", "Subpasses");
867 const vector<Subpass>& subpasses = renderPass.getSubpasses();
869 for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
871 const tcu::ScopedLogSection subpassSection (log, "Subpass" + de::toString(subpassNdx), "Subpass " + de::toString(subpassNdx));
872 const Subpass& subpass = subpasses[subpassNdx];
874 const vector<AttachmentReference>& inputAttachments = subpass.getInputAttachments();
875 const vector<AttachmentReference>& colorAttachments = subpass.getColorAttachments();
876 const vector<AttachmentReference>& resolveAttachments = subpass.getResolveAttachments();
877 const vector<deUint32>& preserveAttachments = subpass.getPreserveAttachments();
879 if (!inputAttachments.empty())
881 const tcu::ScopedLogSection inputAttachmentsSection (log, "Inputs", "Inputs");
883 for (size_t inputNdx = 0; inputNdx < inputAttachments.size(); inputNdx++)
885 const tcu::ScopedLogSection inputAttachmentSection (log, "Input" + de::toString(inputNdx), "Input " + de::toString(inputNdx));
886 const AttachmentReference& inputAttachment = inputAttachments[inputNdx];
888 log << TestLog::Message << "Attachment: " << inputAttachment.getAttachment() << TestLog::EndMessage;
889 log << TestLog::Message << "Layout: " << inputAttachment.getImageLayout() << TestLog::EndMessage;
890 if (!useExternalInputAspect)
891 log << TestLog::Message << "AspectMask: " << inputAttachment.getAspectMask() << TestLog::EndMessage;
895 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
897 const tcu::ScopedLogSection depthStencilAttachmentSection (log, "DepthStencil", "DepthStencil");
898 const AttachmentReference& depthStencilAttachment = subpass.getDepthStencilAttachment();
900 log << TestLog::Message << "Attachment: " << depthStencilAttachment.getAttachment() << TestLog::EndMessage;
901 log << TestLog::Message << "Layout: " << depthStencilAttachment.getImageLayout() << TestLog::EndMessage;
904 if (!colorAttachments.empty())
906 const tcu::ScopedLogSection colorAttachmentsSection (log, "Colors", "Colors");
908 for (size_t colorNdx = 0; colorNdx < colorAttachments.size(); colorNdx++)
910 const tcu::ScopedLogSection colorAttachmentSection (log, "Color" + de::toString(colorNdx), "Color " + de::toString(colorNdx));
911 const AttachmentReference& colorAttachment = colorAttachments[colorNdx];
913 log << TestLog::Message << "Attachment: " << colorAttachment.getAttachment() << TestLog::EndMessage;
914 log << TestLog::Message << "Layout: " << colorAttachment.getImageLayout() << TestLog::EndMessage;
918 if (!resolveAttachments.empty())
920 const tcu::ScopedLogSection resolveAttachmentsSection (log, "Resolves", "Resolves");
922 for (size_t resolveNdx = 0; resolveNdx < resolveAttachments.size(); resolveNdx++)
924 const tcu::ScopedLogSection resolveAttachmentSection (log, "Resolve" + de::toString(resolveNdx), "Resolve " + de::toString(resolveNdx));
925 const AttachmentReference& resolveAttachment = resolveAttachments[resolveNdx];
927 log << TestLog::Message << "Attachment: " << resolveAttachment.getAttachment() << TestLog::EndMessage;
928 log << TestLog::Message << "Layout: " << resolveAttachment.getImageLayout() << TestLog::EndMessage;
932 if (!preserveAttachments.empty())
934 const tcu::ScopedLogSection preserveAttachmentsSection (log, "Preserves", "Preserves");
936 for (size_t preserveNdx = 0; preserveNdx < preserveAttachments.size(); preserveNdx++)
938 const tcu::ScopedLogSection preserveAttachmentSection (log, "Preserve" + de::toString(preserveNdx), "Preserve " + de::toString(preserveNdx));
939 const deUint32 preserveAttachment = preserveAttachments[preserveNdx];
941 log << TestLog::Message << "Attachment: " << preserveAttachment << TestLog::EndMessage;
948 if (!renderPass.getDependencies().empty())
950 const tcu::ScopedLogSection dependenciesSection (log, "Dependencies", "Dependencies");
952 for (size_t depNdx = 0; depNdx < renderPass.getDependencies().size(); depNdx++)
954 const tcu::ScopedLogSection dependencySection (log, "Dependency" + de::toString(depNdx), "Dependency " + de::toString(depNdx));
955 const SubpassDependency& dep = renderPass.getDependencies()[depNdx];
957 log << TestLog::Message << "Source: " << dep.getSrcPass() << TestLog::EndMessage;
958 log << TestLog::Message << "Destination: " << dep.getDstPass() << TestLog::EndMessage;
960 log << TestLog::Message << "Source Stage Mask: " << dep.getSrcStageMask() << TestLog::EndMessage;
961 log << TestLog::Message << "Destination Stage Mask: " << dep.getDstStageMask() << TestLog::EndMessage;
963 log << TestLog::Message << "Input Mask: " << dep.getDstAccessMask() << TestLog::EndMessage;
964 log << TestLog::Message << "Output Mask: " << dep.getSrcAccessMask() << TestLog::EndMessage;
965 log << TestLog::Message << "Dependency Flags: " << getDependencyFlagsStr(dep.getFlags()) << TestLog::EndMessage;
970 std::string clearColorToString (VkFormat vkFormat, VkClearColorValue value, deBool useFormatCompCount)
972 const tcu::TextureFormat format = mapVkFormat(vkFormat);
973 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type);
974 const tcu::BVec4 channelMask = tcu::getTextureFormatChannelMask(format);
975 const deUint32 componentCount = (useFormatCompCount ? (deUint32)tcu::getNumUsedChannels(format.order) : 4);
977 std::ostringstream stream;
981 switch (channelClass)
983 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
984 for (deUint32 i = 0; i < componentCount; i++)
990 stream << value.int32[i];
996 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
997 for (deUint32 i = 0; i < componentCount; i++)
1003 stream << value.uint32[i];
1009 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1010 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1011 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1012 for (deUint32 i = 0; i < componentCount; i++)
1018 stream << value.float32[i];
1025 DE_FATAL("Unknown channel class");
1030 return stream.str();
1033 std::string clearValueToString (VkFormat vkFormat, VkClearValue value, deBool useFormatCompCount)
1035 const tcu::TextureFormat format = mapVkFormat(vkFormat);
1037 if (tcu::hasStencilComponent(format.order) || tcu::hasDepthComponent(format.order))
1039 std::ostringstream stream;
1043 if (tcu::hasStencilComponent(format.order))
1044 stream << "stencil: " << value.depthStencil.stencil;
1046 if (tcu::hasStencilComponent(format.order) && tcu::hasDepthComponent(format.order))
1049 if (tcu::hasDepthComponent(format.order))
1050 stream << "depth: " << value.depthStencil.depth;
1054 return stream.str();
1057 return clearColorToString(vkFormat, value.color, useFormatCompCount);
1060 VkClearColorValue randomColorClearValue (const Attachment& attachment, de::Random& rng, deBool useFormatCompCount)
1062 const float clearNan = tcu::Float32::nan().asFloat();
1063 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
1064 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type);
1065 const tcu::BVec4 channelMask = tcu::getTextureFormatChannelMask(format);
1066 const deUint32 componentCount = (useFormatCompCount ? (deUint32)tcu::getNumUsedChannels(format.order) : 4);
1067 VkClearColorValue clearColor;
1069 switch (channelClass)
1071 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1073 for (deUint32 ndx = 0; ndx < componentCount; ndx++)
1075 if (!channelMask[ndx])
1076 clearColor.int32[ndx] = std::numeric_limits<deInt32>::min();
1078 clearColor.uint32[ndx] = rng.getBool() ? 1u : 0u;
1083 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1085 for (deUint32 ndx = 0; ndx < componentCount; ndx++)
1087 if (!channelMask[ndx])
1088 clearColor.uint32[ndx] = std::numeric_limits<deUint32>::max();
1090 clearColor.uint32[ndx] = rng.getBool() ? 1u : 0u;
1095 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1096 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1097 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1099 for (deUint32 ndx = 0; ndx < componentCount; ndx++)
1101 if (!channelMask[ndx])
1102 clearColor.float32[ndx] = clearNan;
1104 clearColor.float32[ndx] = rng.getBool() ? 1.0f : 0.0f;
1110 DE_FATAL("Unknown channel class");
1116 template <typename AttachmentDesc>
1117 AttachmentDesc createAttachmentDescription (const Attachment& attachment)
1119 const AttachmentDesc attachmentDescription // VkAttachmentDescription || VkAttachmentDescription2KHR
1121 // || VkStructureType sType;
1122 DE_NULL, // || const void* pNext;
1123 0u, // VkAttachmentDescriptionFlags flags; || VkAttachmentDescriptionFlags flags;
1124 attachment.getFormat(), // VkFormat format; || VkFormat format;
1125 attachment.getSamples(), // VkSampleCountFlagBits samples; || VkSampleCountFlagBits samples;
1126 attachment.getLoadOp(), // VkAttachmentLoadOp loadOp; || VkAttachmentLoadOp loadOp;
1127 attachment.getStoreOp(), // VkAttachmentStoreOp storeOp; || VkAttachmentStoreOp storeOp;
1128 attachment.getStencilLoadOp(), // VkAttachmentLoadOp stencilLoadOp; || VkAttachmentLoadOp stencilLoadOp;
1129 attachment.getStencilStoreOp(), // VkAttachmentStoreOp stencilStoreOp; || VkAttachmentStoreOp stencilStoreOp;
1130 attachment.getInitialLayout(), // VkImageLayout initialLayout; || VkImageLayout initialLayout;
1131 attachment.getFinalLayout() // VkImageLayout finalLayout; || VkImageLayout finalLayout;
1134 return attachmentDescription;
1137 template <typename AttachmentRef>
1138 AttachmentRef createAttachmentReference (const AttachmentReference& referenceInfo)
1140 const AttachmentRef reference // VkAttachmentReference || VkAttachmentReference2KHR
1142 // || VkStructureType sType;
1143 DE_NULL, // || const void* pNext;
1144 referenceInfo.getAttachment(), // deUint32 attachment; || deUint32 attachment;
1145 referenceInfo.getImageLayout(), // VkImageLayout layout; || VkImageLayout layout;
1146 referenceInfo.getAspectMask() // || VkImageAspectFlags aspectMask;
1152 template <typename SubpassDesc, typename AttachmentRef>
1153 SubpassDesc createSubpassDescription (const Subpass& subpass,
1154 vector<AttachmentRef>* attachmentReferenceLists,
1155 vector<deUint32>* preserveAttachmentReferences)
1157 vector<AttachmentRef>& inputAttachmentReferences = attachmentReferenceLists[0];
1158 vector<AttachmentRef>& colorAttachmentReferences = attachmentReferenceLists[1];
1159 vector<AttachmentRef>& resolveAttachmentReferences = attachmentReferenceLists[2];
1160 vector<AttachmentRef>& depthStencilAttachmentReferences = attachmentReferenceLists[3];
1162 for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
1163 colorAttachmentReferences.push_back(createAttachmentReference<AttachmentRef>(subpass.getColorAttachments()[attachmentNdx]));
1165 for (size_t attachmentNdx = 0; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
1166 inputAttachmentReferences.push_back(createAttachmentReference<AttachmentRef>(subpass.getInputAttachments()[attachmentNdx]));
1168 for (size_t attachmentNdx = 0; attachmentNdx < subpass.getResolveAttachments().size(); attachmentNdx++)
1169 resolveAttachmentReferences.push_back(createAttachmentReference<AttachmentRef>(subpass.getResolveAttachments()[attachmentNdx]));
1171 depthStencilAttachmentReferences.push_back(createAttachmentReference<AttachmentRef>(subpass.getDepthStencilAttachment()));
1173 for (size_t attachmentNdx = 0; attachmentNdx < subpass.getPreserveAttachments().size(); attachmentNdx++)
1174 preserveAttachmentReferences->push_back(subpass.getPreserveAttachments()[attachmentNdx]);
1176 DE_ASSERT(resolveAttachmentReferences.empty() || colorAttachmentReferences.size() == resolveAttachmentReferences.size());
1179 const SubpassDesc subpassDescription // VkSubpassDescription || VkSubpassDescription2KHR
1181 // || VkStructureType sType;
1182 DE_NULL, // || const void* pNext;
1183 subpass.getFlags(), // VkSubpassDescriptionFlags flags; || VkSubpassDescriptionFlags flags;
1184 subpass.getPipelineBindPoint(), // VkPipelineBindPoint pipelineBindPoint; || VkPipelineBindPoint pipelineBindPoint;
1185 0u, // || deUint32 viewMask;
1186 (deUint32)inputAttachmentReferences.size(), // deUint32 inputAttachmentCount; || deUint32 inputAttachmentCount;
1187 inputAttachmentReferences.empty() ? DE_NULL : &inputAttachmentReferences[0], // const VkAttachmentReference* pInputAttachments; || const VkAttachmentReference2KHR* pInputAttachments;
1188 (deUint32)colorAttachmentReferences.size(), // deUint32 colorAttachmentCount; || deUint32 colorAttachmentCount;
1189 colorAttachmentReferences.empty() ? DE_NULL : &colorAttachmentReferences[0], // const VkAttachmentReference* pColorAttachments; || const VkAttachmentReference2KHR* pColorAttachments;
1190 resolveAttachmentReferences.empty() ? DE_NULL : &resolveAttachmentReferences[0], // const VkAttachmentReference* pResolveAttachments; || const VkAttachmentReference2KHR* pResolveAttachments;
1191 &depthStencilAttachmentReferences[0], // const VkAttachmentReference* pDepthStencilAttachment; || const VkAttachmentReference2KHR* pDepthStencilAttachment;
1192 (deUint32)preserveAttachmentReferences->size(), // deUint32 preserveAttachmentCount; || deUint32 preserveAttachmentCount;
1193 preserveAttachmentReferences->empty() ? DE_NULL : &(*preserveAttachmentReferences)[0] // const deUint32* pPreserveAttachments; || const deUint32* pPreserveAttachments;
1196 return subpassDescription;
1200 template <typename SubpassDep>
1201 SubpassDep createSubpassDependency (const SubpassDependency& dependencyInfo)
1203 const SubpassDep dependency // VkSubpassDependency || VkSubpassDependency2KHR
1205 // || VkStructureType sType;
1206 DE_NULL, // || const void* pNext;
1207 dependencyInfo.getSrcPass(), // deUint32 srcSubpass; || deUint32 srcSubpass;
1208 dependencyInfo.getDstPass(), // deUint32 dstSubpass; || deUint32 dstSubpass;
1209 dependencyInfo.getSrcStageMask(), // VkPipelineStageFlags srcStageMask; || VkPipelineStageFlags srcStageMask;
1210 dependencyInfo.getDstStageMask(), // VkPipelineStageFlags dstStageMask; || VkPipelineStageFlags dstStageMask;
1211 dependencyInfo.getSrcAccessMask(), // VkAccessFlags srcAccessMask; || VkAccessFlags srcAccessMask;
1212 dependencyInfo.getDstAccessMask(), // VkAccessFlags dstAccessMask; || VkAccessFlags dstAccessMask;
1213 dependencyInfo.getFlags(), // VkDependencyFlags dependencyFlags; || VkDependencyFlags dependencyFlags;
1214 0u // || deInt32 viewOffset;
1220 de::MovePtr<VkRenderPassInputAttachmentAspectCreateInfo> createRenderPassInputAttachmentAspectCreateInfo(const RenderPass& renderPassInfo)
1222 de::MovePtr<VkRenderPassInputAttachmentAspectCreateInfo> result (DE_NULL);
1224 if (!renderPassInfo.getInputAspects().empty())
1226 const VkRenderPassInputAttachmentAspectCreateInfo inputAspectCreateInfo =
1228 VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
1231 (deUint32)renderPassInfo.getInputAspects().size(),
1232 renderPassInfo.getInputAspects().data(),
1235 result = de::MovePtr<VkRenderPassInputAttachmentAspectCreateInfo>(new VkRenderPassInputAttachmentAspectCreateInfo(inputAspectCreateInfo));
1241 template<typename AttachmentDesc, typename AttachmentRef, typename SubpassDesc, typename SubpassDep, typename RenderPassCreateInfo>
1242 Move<VkRenderPass> createRenderPass (const DeviceInterface& vk,
1244 const RenderPass& renderPassInfo)
1246 const size_t perSubpassAttachmentReferenceLists = 4;
1247 vector<AttachmentDesc> attachments;
1248 vector<SubpassDesc> subpasses;
1249 vector<SubpassDep> dependencies;
1250 vector<vector<AttachmentRef> > attachmentReferenceLists(renderPassInfo.getSubpasses().size() * perSubpassAttachmentReferenceLists);
1251 vector<vector<deUint32> > preserveAttachments(renderPassInfo.getSubpasses().size());
1252 de::MovePtr<VkRenderPassInputAttachmentAspectCreateInfo> inputAspectCreateInfo(createRenderPassInputAttachmentAspectCreateInfo(renderPassInfo));
1254 for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
1255 attachments.push_back(createAttachmentDescription<AttachmentDesc>(renderPassInfo.getAttachments()[attachmentNdx]));
1257 for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
1258 subpasses.push_back(createSubpassDescription<SubpassDesc>(renderPassInfo.getSubpasses()[subpassNdx], &(attachmentReferenceLists[subpassNdx * perSubpassAttachmentReferenceLists]), &preserveAttachments[subpassNdx]));
1260 for (size_t depNdx = 0; depNdx < renderPassInfo.getDependencies().size(); depNdx++)
1261 dependencies.push_back(createSubpassDependency<SubpassDep>(renderPassInfo.getDependencies()[depNdx]));
1263 const RenderPassCreateInfo renderPassCreator // VkRenderPassCreateInfo || VkRenderPassCreateInfo2KHR
1265 // VkStructureType sType; || VkStructureType sType;
1266 inputAspectCreateInfo.get(), // const void* pNext; || const void* pNext;
1267 (VkRenderPassCreateFlags)0u, // VkRenderPassCreateFlags flags; || VkRenderPassCreateFlags flags;
1268 (deUint32)attachments.size(), // deUint32 attachmentCount; || deUint32 attachmentCount;
1269 (attachments.empty() ? DE_NULL : &attachments[0]), // const VkAttachmentDescription* pAttachments; || const VkAttachmentDescription2KHR* pAttachments;
1270 (deUint32)subpasses.size(), // deUint32 subpassCount; || deUint32 subpassCount;
1271 (subpasses.empty() ? DE_NULL : &subpasses[0]), // const VkSubpassDescription* pSubpasses; || const VkSubpassDescription2KHR* pSubpasses;
1272 (deUint32)dependencies.size(), // deUint32 dependencyCount; || deUint32 dependencyCount;
1273 (dependencies.empty() ? DE_NULL : &dependencies[0]), // const VkSubpassDependency* pDependencies; || const VkSubpassDependency2KHR* pDependencies;
1274 0u, // || deUint32 correlatedViewMaskCount;
1275 DE_NULL // || const deUint32* pCorrelatedViewMasks;
1278 return renderPassCreator.createRenderPass(vk, device);
1281 Move<VkRenderPass> createRenderPass (const DeviceInterface& vk,
1283 const RenderPass& renderPassInfo,
1284 const RenderingType renderPassType)
1286 switch (renderPassType)
1288 case RENDERING_TYPE_RENDERPASS_LEGACY:
1289 return createRenderPass<AttachmentDescription1, AttachmentReference1, SubpassDescription1, SubpassDependency1, RenderPassCreateInfo1>(vk, device, renderPassInfo);
1290 case RENDERING_TYPE_RENDERPASS2:
1291 return createRenderPass<AttachmentDescription2, AttachmentReference2, SubpassDescription2, SubpassDependency2, RenderPassCreateInfo2>(vk, device, renderPassInfo);
1293 TCU_THROW(InternalError, "Impossible");
1297 Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk,
1299 VkRenderPass renderPass,
1301 const vector<VkImageView>& attachments)
1303 return createFramebuffer(vk, device, 0u, renderPass, (deUint32)attachments.size(), attachments.empty() ? DE_NULL : &attachments[0], size.x(), size.y(), 1u);
1306 Move<VkImage> createAttachmentImage (const DeviceInterface& vk,
1308 deUint32 queueIndex,
1311 VkSampleCountFlagBits samples,
1312 VkImageUsageFlags usageFlags,
1313 VkImageLayout layout)
1315 VkImageUsageFlags targetUsageFlags = 0;
1316 const tcu::TextureFormat textureFormat = mapVkFormat(format);
1318 DE_ASSERT(!(tcu::hasDepthComponent(vk::mapVkFormat(format).order) || tcu::hasStencilComponent(vk::mapVkFormat(format).order))
1319 || ((usageFlags & vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) == 0));
1321 DE_ASSERT((tcu::hasDepthComponent(vk::mapVkFormat(format).order) || tcu::hasStencilComponent(vk::mapVkFormat(format).order))
1322 || ((usageFlags & vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0));
1324 if (tcu::hasDepthComponent(textureFormat.order) || tcu::hasStencilComponent(textureFormat.order))
1325 targetUsageFlags |= vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
1327 targetUsageFlags |= vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
1329 return createImage(vk, device,
1330 (VkImageCreateFlags)0,
1333 vk::makeExtent3D(size.x(), size.y(), 1u),
1337 VK_IMAGE_TILING_OPTIMAL,
1338 usageFlags | targetUsageFlags,
1339 VK_SHARING_MODE_EXCLUSIVE,
1345 de::MovePtr<Allocation> createImageMemory (const InstanceInterface& vki,
1346 const VkPhysicalDevice& vkd,
1347 const DeviceInterface& vk,
1349 Allocator& allocator,
1352 AllocationKind allocationKind)
1354 const MemoryRequirement memoryRequirement = lazy ? MemoryRequirement::LazilyAllocated : MemoryRequirement::Any;
1355 de::MovePtr<Allocation> allocation = allocateImage(vki, vk, vkd, device, image, memoryRequirement, allocator, allocationKind);
1357 bindImageMemory(vk, device, image, allocation->getMemory(), allocation->getOffset());
1362 Move<VkImageView> createImageAttachmentView (const DeviceInterface& vk,
1366 VkImageAspectFlags aspect)
1368 const VkImageSubresourceRange range =
1377 return createImageView(vk, device, 0u, image, VK_IMAGE_VIEW_TYPE_2D, format, makeComponentMappingRGBA(), range);
1380 VkClearValue randomClearValue (const Attachment& attachment, de::Random& rng, deBool useFormatCompCount, const DepthValuesArray& depthValues)
1382 const float clearNan = tcu::Float32::nan().asFloat();
1383 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
1385 if (tcu::hasStencilComponent(format.order) || tcu::hasDepthComponent(format.order))
1387 VkClearValue clearValue;
1389 clearValue.depthStencil.depth = clearNan;
1390 clearValue.depthStencil.stencil = 0xCDu;
1392 if (tcu::hasStencilComponent(format.order))
1393 clearValue.depthStencil.stencil = rng.getBool()
1397 if (tcu::hasDepthComponent(format.order))
1398 clearValue.depthStencil.depth = float(depthValues[rng.getBool() ? 1 : 0]) / 255.0f;
1404 VkClearValue clearValue;
1406 clearValue.color = randomColorClearValue(attachment, rng, useFormatCompCount);
1412 class AttachmentResources
1415 AttachmentResources (const InstanceInterface& vki,
1416 const VkPhysicalDevice& physDevice,
1417 const DeviceInterface& vk,
1419 Allocator& allocator,
1420 deUint32 queueIndex,
1422 const Attachment& attachmentInfo,
1423 VkImageUsageFlags usageFlags,
1424 const AllocationKind allocationKind)
1425 : m_image (createAttachmentImage(vk, device, queueIndex, size, attachmentInfo.getFormat(), attachmentInfo.getSamples(), usageFlags, VK_IMAGE_LAYOUT_UNDEFINED))
1426 , m_imageMemory (createImageMemory(vki, physDevice, vk, device, allocator, *m_image, ((usageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) != 0), allocationKind))
1427 , m_attachmentView (createImageAttachmentView(vk, device, *m_image, attachmentInfo.getFormat(), getImageAspectFlags(attachmentInfo.getFormat())))
1429 const tcu::TextureFormat format = mapVkFormat(attachmentInfo.getFormat());
1430 const bool isDepthFormat = tcu::hasDepthComponent(format.order);
1431 const bool isStencilFormat = tcu::hasStencilComponent(format.order);
1433 if (isDepthFormat && isStencilFormat)
1435 m_depthInputAttachmentView = createImageAttachmentView(vk, device, *m_image, attachmentInfo.getFormat(), VK_IMAGE_ASPECT_DEPTH_BIT);
1436 m_stencilInputAttachmentView = createImageAttachmentView(vk, device, *m_image, attachmentInfo.getFormat(), VK_IMAGE_ASPECT_STENCIL_BIT);
1438 m_inputAttachmentViews = std::make_pair(*m_depthInputAttachmentView, *m_stencilInputAttachmentView);
1441 m_inputAttachmentViews = std::make_pair(*m_attachmentView, (vk::VkImageView)0u);
1443 if ((usageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) == 0)
1445 if (tcu::hasDepthComponent(format.order) && tcu::hasStencilComponent(format.order))
1447 const tcu::TextureFormat depthFormat = getDepthCopyFormat(attachmentInfo.getFormat());
1448 const tcu::TextureFormat stencilFormat = getStencilCopyFormat(attachmentInfo.getFormat());
1450 m_bufferSize = size.x() * size.y() * depthFormat.getPixelSize();
1451 m_secondaryBufferSize = size.x() * size.y() * stencilFormat.getPixelSize();
1453 m_buffer = createBuffer(vk, device, 0, m_bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 1, &queueIndex);
1454 m_bufferMemory = allocateBuffer(vki, vk, physDevice, device, *m_buffer, MemoryRequirement::HostVisible, allocator, allocationKind);
1456 bindBufferMemory(vk, device, *m_buffer, m_bufferMemory->getMemory(), m_bufferMemory->getOffset());
1458 m_secondaryBuffer = createBuffer(vk, device, 0, m_secondaryBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 1, &queueIndex);
1459 m_secondaryBufferMemory = allocateBuffer(vki, vk, physDevice, device, *m_secondaryBuffer, MemoryRequirement::HostVisible, allocator, allocationKind);
1461 bindBufferMemory(vk, device, *m_secondaryBuffer, m_secondaryBufferMemory->getMemory(), m_secondaryBufferMemory->getOffset());
1465 m_bufferSize = size.x() * size.y() * format.getPixelSize();
1467 m_buffer = createBuffer(vk, device, 0, m_bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 1, &queueIndex);
1468 m_bufferMemory = allocateBuffer(vki, vk, physDevice, device, *m_buffer, MemoryRequirement::HostVisible, allocator, allocationKind);
1470 bindBufferMemory(vk, device, *m_buffer, m_bufferMemory->getMemory(), m_bufferMemory->getOffset());
1475 const pair<VkImageView, VkImageView>& getInputAttachmentViews (void) const
1477 return m_inputAttachmentViews;
1480 ~AttachmentResources (void)
1484 VkImageView getAttachmentView (void) const
1486 return *m_attachmentView;
1489 VkImage getImage (void) const
1494 VkBuffer getBuffer (void) const
1496 DE_ASSERT(*m_buffer != DE_NULL);
1500 VkDeviceSize getBufferSize (void) const
1502 DE_ASSERT(*m_buffer != DE_NULL);
1503 return m_bufferSize;
1506 const Allocation& getResultMemory (void) const
1508 DE_ASSERT(m_bufferMemory);
1509 return *m_bufferMemory;
1512 VkBuffer getSecondaryBuffer (void) const
1514 DE_ASSERT(*m_secondaryBuffer != DE_NULL);
1515 return *m_secondaryBuffer;
1518 VkDeviceSize getSecondaryBufferSize (void) const
1520 DE_ASSERT(*m_secondaryBuffer != DE_NULL);
1521 return m_secondaryBufferSize;
1524 const Allocation& getSecondaryResultMemory (void) const
1526 DE_ASSERT(m_secondaryBufferMemory);
1527 return *m_secondaryBufferMemory;
1531 const Unique<VkImage> m_image;
1532 const UniquePtr<Allocation> m_imageMemory;
1533 const Unique<VkImageView> m_attachmentView;
1535 Move<VkImageView> m_depthInputAttachmentView;
1536 Move<VkImageView> m_stencilInputAttachmentView;
1537 pair<VkImageView, VkImageView> m_inputAttachmentViews;
1539 Move<VkBuffer> m_buffer;
1540 VkDeviceSize m_bufferSize;
1541 de::MovePtr<Allocation> m_bufferMemory;
1543 Move<VkBuffer> m_secondaryBuffer;
1544 VkDeviceSize m_secondaryBufferSize;
1545 de::MovePtr<Allocation> m_secondaryBufferMemory;
1548 void uploadBufferData (const DeviceInterface& vk,
1550 const Allocation& memory,
1553 VkDeviceSize nonCoherentAtomSize)
1555 // Expand the range to flush to account for the nonCoherentAtomSize
1556 const VkDeviceSize roundedOffset = de::roundDown(memory.getOffset(), nonCoherentAtomSize);
1557 const VkDeviceSize roundedSize = de::roundUp(memory.getOffset() - roundedOffset + static_cast<VkDeviceSize>(size), nonCoherentAtomSize);
1559 const VkMappedMemoryRange range =
1561 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, // sType;
1563 memory.getMemory(), // mem;
1564 roundedOffset, // offset;
1565 roundedSize, // size;
1567 void* const ptr = memory.getHostPtr();
1569 deMemcpy(ptr, data, size);
1570 VK_CHECK(vk.flushMappedMemoryRanges(device, 1, &range));
1573 VkImageAspectFlagBits getPrimaryImageAspect (tcu::TextureFormat::ChannelOrder order)
1575 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 22);
1579 case tcu::TextureFormat::D:
1580 case tcu::TextureFormat::DS:
1581 return VK_IMAGE_ASPECT_DEPTH_BIT;
1583 case tcu::TextureFormat::S:
1584 return VK_IMAGE_ASPECT_STENCIL_BIT;
1587 return VK_IMAGE_ASPECT_COLOR_BIT;
1591 deUint32 getAttachmentNdx (const vector<AttachmentReference>& colorAttachments, size_t ndx)
1593 return (colorAttachments[ndx].getAttachment() == VK_ATTACHMENT_UNUSED) ? (deUint32)ndx : colorAttachments[ndx].getAttachment();
1599 RenderQuad (const Vec2& posA, const Vec2& posB)
1602 m_vertices[0] = posA;
1603 m_vertices[1] = Vec2(posA[0], posB[1]);
1604 m_vertices[2] = posB;
1606 m_vertices[3] = posB;
1607 m_vertices[4] = Vec2(posB[0], posA[1]);
1608 m_vertices[5] = posA;
1611 const Vec2& getCornerA (void) const
1613 return m_vertices[0];
1616 const Vec2& getCornerB (void) const
1618 return m_vertices[2];
1621 const void* getVertexPointer (void) const
1623 return &m_vertices[0];
1626 size_t getVertexDataSize (void) const
1628 return sizeof(Vec2) * m_vertices.size();
1632 vector<Vec2> m_vertices;
1638 ColorClear (const UVec2& offset,
1640 const VkClearColorValue& color)
1647 const UVec2& getOffset (void) const { return m_offset; }
1648 const UVec2& getSize (void) const { return m_size; }
1649 const VkClearColorValue& getColor (void) const { return m_color; }
1654 VkClearColorValue m_color;
1657 class DepthStencilClear
1660 DepthStencilClear (const UVec2& offset,
1667 , m_stencil (stencil)
1671 const UVec2& getOffset (void) const { return m_offset; }
1672 const UVec2& getSize (void) const { return m_size; }
1673 float getDepth (void) const { return m_depth; }
1674 deUint32 getStencil (void) const { return m_stencil; }
1677 const UVec2 m_offset;
1680 const float m_depth;
1681 const deUint32 m_stencil;
1684 class SubpassRenderInfo
1687 SubpassRenderInfo (const RenderPass& renderPass,
1688 deUint32 subpassIndex,
1689 deUint32 drawStartNdx,
1692 bool omitBlendState_,
1694 const UVec2& viewportOffset,
1695 const UVec2& viewportSize,
1697 const Maybe<RenderQuad>& renderQuad,
1698 const vector<ColorClear>& colorClears,
1699 const Maybe<DepthStencilClear>& depthStencilClear)
1700 : m_viewportOffset (viewportOffset)
1701 , m_viewportSize (viewportSize)
1702 , m_subpassIndex (subpassIndex)
1703 , m_drawStartNdx (drawStartNdx)
1704 , m_isSecondary (isSecondary_)
1705 , m_omitBlendState (omitBlendState_)
1706 , m_flags (renderPass.getSubpasses()[subpassIndex].getFlags())
1707 , m_renderQuad (renderQuad)
1708 , m_colorClears (colorClears)
1709 , m_depthStencilClear (depthStencilClear)
1710 , m_colorAttachments (renderPass.getSubpasses()[subpassIndex].getColorAttachments())
1711 , m_inputAttachments (renderPass.getSubpasses()[subpassIndex].getInputAttachments())
1713 for (deUint32 attachmentNdx = 0; attachmentNdx < (deUint32)m_colorAttachments.size(); attachmentNdx++)
1714 m_colorAttachmentInfo.push_back(renderPass.getAttachments()[getAttachmentNdx(m_colorAttachments, attachmentNdx)]);
1716 if (renderPass.getSubpasses()[subpassIndex].getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
1718 m_depthStencilAttachment = tcu::just(renderPass.getSubpasses()[subpassIndex].getDepthStencilAttachment());
1719 m_depthStencilAttachmentInfo = tcu::just(renderPass.getAttachments()[renderPass.getSubpasses()[subpassIndex].getDepthStencilAttachment().getAttachment()]);
1723 const UVec2& getViewportOffset (void) const { return m_viewportOffset; }
1724 const UVec2& getViewportSize (void) const { return m_viewportSize; }
1726 deUint32 getSubpassIndex (void) const { return m_subpassIndex; }
1727 deUint32 getDrawStartNdx (void) const { return m_drawStartNdx; }
1728 bool isSecondary (void) const { return m_isSecondary; }
1729 bool getOmitBlendState (void) const { return m_omitBlendState; }
1731 const Maybe<RenderQuad>& getRenderQuad (void) const { return m_renderQuad; }
1732 const vector<ColorClear>& getColorClears (void) const { return m_colorClears; }
1733 const Maybe<DepthStencilClear>& getDepthStencilClear (void) const { return m_depthStencilClear; }
1735 deUint32 getInputAttachmentCount (void) const { return (deUint32)m_inputAttachments.size(); }
1736 deUint32 getInputAttachmentIndex (deUint32 attachmentNdx) const { return m_inputAttachments[attachmentNdx].getAttachment(); }
1737 VkImageLayout getInputAttachmentLayout (deUint32 attachmentNdx) const { return m_inputAttachments[attachmentNdx].getImageLayout(); }
1739 deUint32 getColorAttachmentCount (void) const { return (deUint32)m_colorAttachments.size(); }
1740 VkImageLayout getColorAttachmentLayout (deUint32 attachmentNdx) const { return m_colorAttachments[attachmentNdx].getImageLayout(); }
1741 deUint32 getColorAttachmentIndex (deUint32 attachmentNdx) const { return m_colorAttachments[attachmentNdx].getAttachment(); }
1742 const Attachment& getColorAttachment (deUint32 attachmentNdx) const { return m_colorAttachmentInfo[attachmentNdx]; }
1743 Maybe<VkImageLayout> getDepthStencilAttachmentLayout (void) const { return m_depthStencilAttachment ? tcu::just(m_depthStencilAttachment->getImageLayout()) : tcu::Nothing; }
1744 Maybe<deUint32> getDepthStencilAttachmentIndex (void) const { return m_depthStencilAttachment ? tcu::just(m_depthStencilAttachment->getAttachment()) : tcu::Nothing; }
1745 const Maybe<Attachment>& getDepthStencilAttachment (void) const { return m_depthStencilAttachmentInfo; }
1746 VkSubpassDescriptionFlags getSubpassFlags (void) const { return m_flags; }
1749 UVec2 m_viewportOffset;
1750 UVec2 m_viewportSize;
1752 deUint32 m_subpassIndex;
1753 deUint32 m_drawStartNdx;
1755 bool m_omitBlendState;
1756 VkSubpassDescriptionFlags m_flags;
1758 Maybe<RenderQuad> m_renderQuad;
1759 vector<ColorClear> m_colorClears;
1760 Maybe<DepthStencilClear> m_depthStencilClear;
1762 vector<AttachmentReference> m_colorAttachments;
1763 vector<Attachment> m_colorAttachmentInfo;
1765 Maybe<AttachmentReference> m_depthStencilAttachment;
1766 Maybe<Attachment> m_depthStencilAttachmentInfo;
1768 vector<AttachmentReference> m_inputAttachments;
1771 void beginCommandBuffer (const DeviceInterface& vk,
1772 VkCommandBuffer cmdBuffer,
1773 VkCommandBufferUsageFlags pBeginInfo_flags,
1774 VkRenderPass pInheritanceInfo_renderPass,
1775 deUint32 pInheritanceInfo_subpass,
1776 VkFramebuffer pInheritanceInfo_framebuffer,
1777 VkBool32 pInheritanceInfo_occlusionQueryEnable,
1778 VkQueryControlFlags pInheritanceInfo_queryFlags,
1779 VkQueryPipelineStatisticFlags pInheritanceInfo_pipelineStatistics,
1780 const SubpassRenderInfo* pRenderInfo = 0,
1781 bool dynamicRenderPass = false )
1783 VkCommandBufferInheritanceInfo pInheritanceInfo =
1785 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
1787 pInheritanceInfo_renderPass,
1788 pInheritanceInfo_subpass,
1789 pInheritanceInfo_framebuffer,
1790 pInheritanceInfo_occlusionQueryEnable,
1791 pInheritanceInfo_queryFlags,
1792 pInheritanceInfo_pipelineStatistics,
1794 std::vector<vk::VkFormat> colorAttachmentFormats;
1795 VkCommandBufferInheritanceRenderingInfoKHR inheritanceRenderingInfo
1797 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR,
1803 VK_FORMAT_UNDEFINED,
1804 VK_FORMAT_UNDEFINED,
1805 VK_SAMPLE_COUNT_1_BIT,
1809 for (deUint32 i = 0; i < pRenderInfo->getColorAttachmentCount(); ++i)
1810 colorAttachmentFormats.push_back(pRenderInfo->getColorAttachment(i).getFormat());
1812 inheritanceRenderingInfo.colorAttachmentCount = static_cast<deUint32>(colorAttachmentFormats.size());
1813 inheritanceRenderingInfo.pColorAttachmentFormats = colorAttachmentFormats.data();
1814 if (pRenderInfo->getDepthStencilAttachment())
1816 inheritanceRenderingInfo.depthAttachmentFormat = pRenderInfo->getDepthStencilAttachment()->getFormat();
1817 inheritanceRenderingInfo.stencilAttachmentFormat = pRenderInfo->getDepthStencilAttachment()->getFormat();
1819 if (pRenderInfo->getColorAttachmentCount())
1820 inheritanceRenderingInfo.rasterizationSamples = pRenderInfo->getColorAttachment(0).getSamples();
1821 else if (pRenderInfo->getDepthStencilAttachment())
1822 inheritanceRenderingInfo.rasterizationSamples = pRenderInfo->getDepthStencilAttachment()->getSamples();
1824 if (dynamicRenderPass)
1825 pInheritanceInfo.pNext = &inheritanceRenderingInfo;
1827 const VkCommandBufferBeginInfo pBeginInfo =
1829 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1834 VK_CHECK(vk.beginCommandBuffer(cmdBuffer, &pBeginInfo));
1837 Move<VkPipeline> createSubpassPipeline (const DeviceInterface& vk,
1839 VkRenderPass renderPass,
1840 VkShaderModule vertexShaderModule,
1841 VkShaderModule fragmentShaderModule,
1842 VkPipelineLayout pipelineLayout,
1843 const SubpassRenderInfo& renderInfo)
1845 Maybe<VkSampleCountFlagBits> rasterSamples;
1846 vector<VkPipelineColorBlendAttachmentState> attachmentBlendStates;
1848 for (deUint32 attachmentNdx = 0; attachmentNdx < renderInfo.getColorAttachmentCount(); attachmentNdx++)
1850 const Attachment& attachment = renderInfo.getColorAttachment(attachmentNdx);
1852 DE_ASSERT(!rasterSamples || *rasterSamples == attachment.getSamples());
1854 rasterSamples = attachment.getSamples();
1857 const VkPipelineColorBlendAttachmentState attachmentBlendState =
1859 VK_FALSE, // blendEnable
1860 VK_BLEND_FACTOR_SRC_ALPHA, // srcBlendColor
1861 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, // destBlendColor
1862 VK_BLEND_OP_ADD, // blendOpColor
1863 VK_BLEND_FACTOR_ONE, // srcBlendAlpha
1864 VK_BLEND_FACTOR_ONE, // destBlendAlpha
1865 VK_BLEND_OP_ADD, // blendOpAlpha
1866 (attachmentNdx < renderInfo.getDrawStartNdx() ? (deUint32)0 :
1867 VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT) // channelWriteMask
1870 attachmentBlendStates.push_back(attachmentBlendState);
1874 if (renderInfo.getDepthStencilAttachment())
1876 const Attachment& attachment = *renderInfo.getDepthStencilAttachment();
1878 DE_ASSERT(!rasterSamples || *rasterSamples == attachment.getSamples());
1879 rasterSamples = attachment.getSamples();
1882 // If there are no attachment use single sample
1884 rasterSamples = VK_SAMPLE_COUNT_1_BIT;
1886 const VkVertexInputBindingDescription vertexBinding =
1889 (deUint32)sizeof(tcu::Vec2), // strideInBytes
1890 VK_VERTEX_INPUT_RATE_VERTEX, // stepRate
1893 const VkVertexInputAttributeDescription vertexAttrib =
1897 VK_FORMAT_R32G32_SFLOAT, // format
1898 0u, // offsetInBytes
1901 const VkPipelineVertexInputStateCreateInfo vertexInputState =
1903 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // sType
1905 (VkPipelineVertexInputStateCreateFlags)0u,
1907 &vertexBinding, // pVertexBindingDescriptions
1908 1u, // attributeCount
1909 &vertexAttrib, // pVertexAttributeDescriptions
1912 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
1914 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType
1915 DE_NULL, // const void* pNext
1916 0u, // VkPipelineInputAssemblyStateCreateFlags flags
1917 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology
1918 VK_FALSE // VkBool32 primitiveRestartEnable
1921 const VkViewport viewport =
1923 (float)renderInfo.getViewportOffset().x(), (float)renderInfo.getViewportOffset().y(),
1924 (float)renderInfo.getViewportSize().x(), (float)renderInfo.getViewportSize().y(),
1928 const VkRect2D scissor =
1930 { (deInt32)renderInfo.getViewportOffset().x(), (deInt32)renderInfo.getViewportOffset().y() },
1931 { renderInfo.getViewportSize().x(), renderInfo.getViewportSize().y() }
1934 const VkPipelineViewportStateCreateInfo viewportState =
1936 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType
1937 DE_NULL, // const void* pNext
1938 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags
1939 1u, // deUint32 viewportCount
1940 &viewport, // const VkViewport* pViewports
1941 1u, // deUint32 scissorCount
1942 &scissor // const VkRect2D* pScissors
1945 const VkPipelineRasterizationStateCreateInfo rasterizationState =
1947 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType
1948 DE_NULL, // const void* pNext
1949 0u, // VkPipelineRasterizationStateCreateFlags flags
1950 VK_FALSE, // VkBool32 depthClampEnable
1951 VK_FALSE, // VkBool32 rasterizerDiscardEnable
1952 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode
1953 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode
1954 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace
1955 VK_FALSE, // VkBool32 depthBiasEnable
1956 0.0f, // float depthBiasConstantFactor
1957 0.0f, // float depthBiasClamp
1958 0.0f, // float depthBiasSlopeFactor
1959 1.0f // float lineWidth
1962 const VkPipelineMultisampleStateCreateInfo multisampleState =
1964 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // sType
1966 (VkPipelineMultisampleStateCreateFlags)0u,
1967 *rasterSamples, // rasterSamples
1968 VK_FALSE, // sampleShadingEnable
1969 0.0f, // minSampleShading
1970 DE_NULL, // pSampleMask
1971 VK_FALSE, // alphaToCoverageEnable
1972 VK_FALSE, // alphaToOneEnable
1974 const size_t stencilIndex = renderInfo.getSubpassIndex();
1976 const VkBool32 writeDepth = renderInfo.getDepthStencilAttachmentLayout()
1977 && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
1978 && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
1982 const VkBool32 writeStencil = renderInfo.getDepthStencilAttachmentLayout()
1983 && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
1984 && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
1988 const VkPipelineDepthStencilStateCreateInfo depthStencilState =
1990 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // sType
1992 (VkPipelineDepthStencilStateCreateFlags)0u,
1993 writeDepth, // depthTestEnable
1994 writeDepth, // depthWriteEnable
1995 VK_COMPARE_OP_ALWAYS, // depthCompareOp
1996 VK_FALSE, // depthBoundsEnable
1997 writeStencil, // stencilTestEnable
1999 VK_STENCIL_OP_REPLACE, // stencilFailOp
2000 VK_STENCIL_OP_REPLACE, // stencilPassOp
2001 VK_STENCIL_OP_REPLACE, // stencilDepthFailOp
2002 VK_COMPARE_OP_ALWAYS, // stencilCompareOp
2003 ~0u, // stencilCompareMask
2004 ~0u, // stencilWriteMask
2005 ((stencilIndex % 2) == 0) ? ~0x0u : 0x0u // stencilReference
2008 VK_STENCIL_OP_REPLACE, // stencilFailOp
2009 VK_STENCIL_OP_REPLACE, // stencilPassOp
2010 VK_STENCIL_OP_REPLACE, // stencilDepthFailOp
2011 VK_COMPARE_OP_ALWAYS, // stencilCompareOp
2012 ~0u, // stencilCompareMask
2013 ~0u, // stencilWriteMask
2014 ((stencilIndex % 2) == 0) ? ~0x0u : 0x0u // stencilReference
2017 0.0f, // minDepthBounds;
2018 1.0f // maxDepthBounds;
2021 const VkPipelineColorBlendStateCreateInfo blendState =
2023 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // sType
2025 (VkPipelineColorBlendStateCreateFlags)0u,
2026 VK_FALSE, // logicOpEnable
2027 VK_LOGIC_OP_COPY, // logicOp
2028 (deUint32)attachmentBlendStates.size(), // attachmentCount
2029 attachmentBlendStates.empty() ? DE_NULL : &attachmentBlendStates[0],// pAttachments
2030 { 0.0f, 0.0f, 0.0f, 0.0f } // blendConst
2033 std::vector<vk::VkFormat> colorAttachmentFormats;
2034 for (deUint32 i = 0; i < renderInfo.getColorAttachmentCount(); ++i)
2035 colorAttachmentFormats.push_back(renderInfo.getColorAttachment(i).getFormat());
2037 vk::VkFormat depthStencilFormat = VK_FORMAT_UNDEFINED;
2038 if (renderInfo.getDepthStencilAttachment())
2040 const Attachment& attachment = *renderInfo.getDepthStencilAttachment();
2041 depthStencilFormat = attachment.getFormat();
2044 VkPipelineRenderingCreateInfoKHR renderingCreateInfo
2046 VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
2049 static_cast<deUint32>(colorAttachmentFormats.size()),
2050 colorAttachmentFormats.data(),
2055 return makeGraphicsPipeline(vk, // const DeviceInterface& vk
2056 device, // const VkDevice device
2057 pipelineLayout, // const VkPipelineLayout pipelineLayout
2058 vertexShaderModule, // const VkShaderModule vertexShaderModule
2059 DE_NULL, // const VkShaderModule tessellationControlShaderModule
2060 DE_NULL, // const VkShaderModule tessellationEvalShaderModule
2061 DE_NULL, // const VkShaderModule geometryShaderModule
2062 fragmentShaderModule, // const VkShaderModule fragmentShaderModule
2063 renderPass, // const VkRenderPass renderPass
2064 renderInfo.getSubpassIndex(), // const deUint32 subpass
2065 &vertexInputState, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo
2066 &inputAssemblyState, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
2067 DE_NULL, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo
2068 &viewportState, // const VkPipelineViewportStateCreateInfo* pViewportStat;
2069 &rasterizationState, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState
2070 &multisampleState, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo
2071 &depthStencilState, // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo
2072 renderInfo.getOmitBlendState()
2073 ? DE_NULL : &blendState, // const VkPipelineColorBlendStateCreateInfo* colorBlendStateCreateInfo
2074 DE_NULL, // const VkPipelineDynamicStateCreateInfo* dynamicStateCreateInfo
2075 (renderPass == DE_NULL)
2076 ? &renderingCreateInfo : DE_NULL); // const void* pNext)
2079 class SubpassRenderer
2082 SubpassRenderer (Context& context,
2083 const DeviceInterface& vk,
2085 Allocator& allocator,
2086 VkRenderPass renderPass,
2087 VkFramebuffer framebuffer,
2088 VkCommandPool commandBufferPool,
2089 deUint32 queueFamilyIndex,
2090 const vector<VkImage>& attachmentImages,
2091 const vector<pair<VkImageView, VkImageView> >& attachmentViews,
2092 const SubpassRenderInfo& renderInfo,
2093 const vector<Attachment>& attachmentInfos,
2094 const AllocationKind allocationKind,
2095 const bool dynamicRendering)
2096 : m_renderInfo (renderInfo)
2098 const InstanceInterface& vki = context.getInstanceInterface();
2099 const VkPhysicalDevice& physDevice = context.getPhysicalDevice();
2100 const deUint32 subpassIndex = renderInfo.getSubpassIndex();
2101 vector<VkDescriptorSetLayoutBinding> bindings;
2103 for (deUint32 colorAttachmentNdx = 0; colorAttachmentNdx < renderInfo.getColorAttachmentCount(); colorAttachmentNdx++)
2105 const deUint32 attachmentNdx = (renderInfo.getColorAttachmentIndex(colorAttachmentNdx) == VK_ATTACHMENT_UNUSED) ? colorAttachmentNdx
2106 : renderInfo.getColorAttachmentIndex(colorAttachmentNdx);
2108 m_colorAttachmentImages.push_back(attachmentImages[attachmentNdx]);
2111 if (renderInfo.getDepthStencilAttachmentIndex())
2112 m_depthStencilAttachmentImage = attachmentImages[*renderInfo.getDepthStencilAttachmentIndex()];
2114 if (renderInfo.getRenderQuad())
2116 const RenderQuad& renderQuad = *renderInfo.getRenderQuad();
2118 if (renderInfo.getInputAttachmentCount() > 0)
2120 deUint32 bindingIndex = 0;
2122 for (deUint32 inputAttachmentNdx = 0; inputAttachmentNdx < renderInfo.getInputAttachmentCount(); inputAttachmentNdx++)
2124 const Attachment attachmentInfo = attachmentInfos[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)];
2125 const VkImageLayout layout = renderInfo.getInputAttachmentLayout(inputAttachmentNdx);
2126 const tcu::TextureFormat format = mapVkFormat(attachmentInfo.getFormat());
2127 const bool isDepthFormat = tcu::hasDepthComponent(format.order);
2128 const bool isStencilFormat = tcu::hasStencilComponent(format.order);
2129 const deUint32 bindingCount = (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
2130 && (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
2134 for (deUint32 bindingNdx = 0; bindingNdx < bindingCount; bindingNdx++)
2136 const VkDescriptorSetLayoutBinding binding =
2139 vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2141 vk::VK_SHADER_STAGE_FRAGMENT_BIT,
2145 bindings.push_back(binding);
2150 const VkDescriptorSetLayoutCreateInfo createInfo =
2152 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
2156 (deUint32)bindings.size(),
2160 m_descriptorSetLayout = vk::createDescriptorSetLayout(vk, device, &createInfo);
2163 const VkDescriptorSetLayout descriptorSetLayout = *m_descriptorSetLayout;
2164 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
2166 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType;
2168 (vk::VkPipelineLayoutCreateFlags)0,
2169 m_descriptorSetLayout ? 1u :0u , // setLayoutCount;
2170 m_descriptorSetLayout ? &descriptorSetLayout : DE_NULL, // pSetLayouts;
2171 0u, // pushConstantRangeCount;
2172 DE_NULL, // pPushConstantRanges;
2175 m_vertexShaderModule = createShaderModule(vk, device, context.getBinaryCollection().get(de::toString(subpassIndex) + "-vert"), 0u);
2176 m_fragmentShaderModule = createShaderModule(vk, device, context.getBinaryCollection().get(de::toString(subpassIndex) + "-frag"), 0u);
2177 m_pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutParams);
2178 m_pipeline = createSubpassPipeline(vk, device, renderPass, *m_vertexShaderModule, *m_fragmentShaderModule, *m_pipelineLayout, m_renderInfo);
2180 // Round up the vertex buffer size to honor nonCoherentAtomSize.
2181 const auto properties = vk::getPhysicalDeviceProperties(context.getInstanceInterface(), context.getPhysicalDevice());
2182 const auto vertexBufferSize = de::roundUp(static_cast<VkDeviceSize>(renderQuad.getVertexDataSize()), properties.limits.nonCoherentAtomSize);
2184 m_vertexBuffer = createBuffer(vk, device, 0u, vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_SHARING_MODE_EXCLUSIVE, 1u, &queueFamilyIndex);
2185 m_vertexBufferMemory = allocateBuffer(vki, vk, physDevice, device, *m_vertexBuffer, MemoryRequirement::HostVisible, allocator, allocationKind);
2187 bindBufferMemory(vk, device, *m_vertexBuffer, m_vertexBufferMemory->getMemory(), m_vertexBufferMemory->getOffset());
2189 uploadBufferData(vk, device, *m_vertexBufferMemory, renderQuad.getVertexDataSize(), renderQuad.getVertexPointer(), properties.limits.nonCoherentAtomSize);
2191 if (renderInfo.getInputAttachmentCount() > 0)
2194 const VkDescriptorPoolSize poolSize =
2196 vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2197 // \note Reserve 2 per input attachment since depthStencil attachments require 2.
2198 renderInfo.getInputAttachmentCount() * 2u
2200 const VkDescriptorPoolCreateInfo createInfo =
2202 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
2204 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
2206 // \note Reserve 2 per input attachment since depthStencil attachments require 2.
2207 renderInfo.getInputAttachmentCount() * 2u,
2212 m_descriptorPool = vk::createDescriptorPool(vk, device, &createInfo);
2215 const VkDescriptorSetAllocateInfo allocateInfo =
2217 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
2222 &descriptorSetLayout
2225 m_descriptorSet = vk::allocateDescriptorSet(vk, device, &allocateInfo);
2228 vector<VkWriteDescriptorSet> writes (bindings.size());
2229 vector<VkDescriptorImageInfo> imageInfos (bindings.size());
2230 deUint32 bindingIndex = 0;
2232 for (deUint32 inputAttachmentNdx = 0; inputAttachmentNdx < renderInfo.getInputAttachmentCount(); inputAttachmentNdx++)
2234 const Attachment attachmentInfo = attachmentInfos[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)];
2235 const tcu::TextureFormat format = mapVkFormat(attachmentInfo.getFormat());
2236 const bool isDepthFormat = tcu::hasDepthComponent(format.order);
2237 const bool isStencilFormat = tcu::hasStencilComponent(format.order);
2238 const VkImageLayout inputAttachmentLayout = renderInfo.getInputAttachmentLayout(inputAttachmentNdx);
2241 if (isDepthFormat && isStencilFormat)
2243 if (inputAttachmentLayout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
2245 const VkDescriptorImageInfo imageInfo =
2248 attachmentViews[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)].first,
2249 inputAttachmentLayout
2251 imageInfos[bindingIndex] = imageInfo;
2254 const VkWriteDescriptorSet write =
2256 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2263 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2264 &imageInfos[bindingIndex],
2268 writes[bindingIndex] = write;
2274 if (inputAttachmentLayout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
2276 const VkDescriptorImageInfo imageInfo =
2279 attachmentViews[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)].second,
2280 inputAttachmentLayout
2282 imageInfos[bindingIndex] = imageInfo;
2285 const VkWriteDescriptorSet write =
2287 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2294 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2295 &imageInfos[bindingIndex],
2299 writes[bindingIndex] = write;
2307 const VkDescriptorImageInfo imageInfo =
2310 attachmentViews[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)].first,
2311 inputAttachmentLayout
2313 imageInfos[bindingIndex] = imageInfo;
2316 const VkWriteDescriptorSet write =
2318 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2325 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2326 &imageInfos[bindingIndex],
2330 writes[bindingIndex] = write;
2337 vk.updateDescriptorSets(device, (deUint32)writes.size(), &writes[0], 0u, DE_NULL);
2342 if (renderInfo.isSecondary())
2344 m_commandBuffer = allocateCommandBuffer(vk, device, commandBufferPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
2346 beginCommandBuffer(vk, *m_commandBuffer, vk::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, renderPass, subpassIndex, framebuffer, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0, &renderInfo, dynamicRendering);
2347 pushRenderCommands(vk, *m_commandBuffer);
2348 endCommandBuffer(vk, *m_commandBuffer);
2352 bool isSecondary (void) const
2354 return m_commandBuffer;
2357 VkCommandBuffer getCommandBuffer (void) const
2359 DE_ASSERT(isSecondary());
2360 return *m_commandBuffer;
2363 void pushRenderCommands (const DeviceInterface& vk,
2364 VkCommandBuffer commandBuffer)
2366 if (!m_renderInfo.getColorClears().empty())
2368 const vector<ColorClear>& colorClears (m_renderInfo.getColorClears());
2370 for (deUint32 attachmentNdx = 0; attachmentNdx < m_renderInfo.getColorAttachmentCount(); attachmentNdx++)
2372 const ColorClear& colorClear = colorClears[attachmentNdx];
2373 const VkClearAttachment attachment =
2375 VK_IMAGE_ASPECT_COLOR_BIT,
2377 makeClearValue(colorClear.getColor()),
2379 const VkClearRect rect =
2382 { (deInt32)colorClear.getOffset().x(), (deInt32)colorClear.getOffset().y() },
2383 { colorClear.getSize().x(), colorClear.getSize().y() }
2385 0u, // baseArrayLayer
2389 vk.cmdClearAttachments(commandBuffer, 1u, &attachment, 1u, &rect);
2393 if (m_renderInfo.getDepthStencilClear())
2395 const DepthStencilClear& depthStencilClear = *m_renderInfo.getDepthStencilClear();
2396 const deUint32 attachmentNdx = m_renderInfo.getColorAttachmentCount();
2397 tcu::TextureFormat format = mapVkFormat(m_renderInfo.getDepthStencilAttachment()->getFormat());
2398 const VkImageLayout layout = *m_renderInfo.getDepthStencilAttachmentLayout();
2399 const VkClearAttachment attachment =
2401 (VkImageAspectFlags)((hasDepthComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL ? VK_IMAGE_ASPECT_DEPTH_BIT : 0)
2402 | (hasStencilComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL ? VK_IMAGE_ASPECT_STENCIL_BIT : 0)),
2404 makeClearValueDepthStencil(depthStencilClear.getDepth(), depthStencilClear.getStencil())
2406 const VkClearRect rect =
2409 { (deInt32)depthStencilClear.getOffset().x(), (deInt32)depthStencilClear.getOffset().y() },
2410 { depthStencilClear.getSize().x(), depthStencilClear.getSize().y() }
2412 0u, // baseArrayLayer
2416 if ((tcu::hasDepthComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
2417 || (tcu::hasStencilComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL))
2419 vk.cmdClearAttachments(commandBuffer, 1u, &attachment, 1u, &rect);
2423 vector<VkImageMemoryBarrier> selfDeps;
2424 VkPipelineStageFlags srcStages = 0;
2425 VkPipelineStageFlags dstStages = 0;
2427 for (deUint32 inputAttachmentNdx = 0; inputAttachmentNdx < m_renderInfo.getInputAttachmentCount(); inputAttachmentNdx++)
2429 for (deUint32 colorAttachmentNdx = 0; colorAttachmentNdx < m_renderInfo.getColorAttachmentCount(); colorAttachmentNdx++)
2431 if (m_renderInfo.getInputAttachmentIndex(inputAttachmentNdx) == m_renderInfo.getColorAttachmentIndex(colorAttachmentNdx))
2433 const VkImageMemoryBarrier barrier =
2435 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
2438 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // srcAccessMask
2439 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, // dstAccessMask
2441 VK_IMAGE_LAYOUT_GENERAL, // oldLayout
2442 VK_IMAGE_LAYOUT_GENERAL, // newLayout
2444 VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
2445 VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
2447 m_colorAttachmentImages[colorAttachmentNdx], // image
2448 { // subresourceRange
2449 VK_IMAGE_ASPECT_COLOR_BIT, // aspect
2452 0, // baseArraySlice
2457 srcStages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
2458 dstStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
2460 selfDeps.push_back(barrier);
2464 if (m_renderInfo.getDepthStencilAttachmentIndex() && (m_renderInfo.getInputAttachmentIndex(inputAttachmentNdx) == *m_renderInfo.getDepthStencilAttachmentIndex()))
2466 const tcu::TextureFormat format = mapVkFormat(m_renderInfo.getDepthStencilAttachment()->getFormat());
2467 const bool hasDepth = hasDepthComponent(format.order);
2468 const bool hasStencil = hasStencilComponent(format.order);
2469 const VkImageMemoryBarrier barrier =
2471 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType;
2474 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // srcAccessMask
2475 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, // dstAccessMask
2477 m_renderInfo.getInputAttachmentLayout(inputAttachmentNdx), // oldLayout
2478 m_renderInfo.getInputAttachmentLayout(inputAttachmentNdx), // newLayout;
2480 VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex;
2481 VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex;
2483 m_depthStencilAttachmentImage, // image;
2484 { // subresourceRange;
2485 (hasDepth ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
2486 | (hasStencil ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u), // aspect;
2489 0, // baseArraySlice;
2494 srcStages |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
2495 dstStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
2497 selfDeps.push_back(barrier);
2501 if (!selfDeps.empty())
2503 DE_ASSERT(srcStages != 0);
2504 DE_ASSERT(dstStages != 0);
2505 vk.cmdPipelineBarrier(commandBuffer, srcStages, dstStages, VK_DEPENDENCY_BY_REGION_BIT, 0, DE_NULL, 0, DE_NULL, (deUint32)selfDeps.size(), &selfDeps[0]);
2508 if (m_renderInfo.getRenderQuad())
2510 const VkDeviceSize offset = 0;
2511 const VkBuffer vertexBuffer = *m_vertexBuffer;
2513 vk.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
2515 if (m_descriptorSet)
2517 const VkDescriptorSet descriptorSet = *m_descriptorSet;
2518 vk.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelineLayout, 0u, 1u, &descriptorSet, 0u, NULL);
2521 vk.cmdBindVertexBuffers(commandBuffer, 0u, 1u, &vertexBuffer, &offset);
2522 vk.cmdDraw(commandBuffer, 6u, 1u, 0u, 0u);
2527 const SubpassRenderInfo m_renderInfo;
2528 Move<VkCommandBuffer> m_commandBuffer;
2529 Move<VkPipeline> m_pipeline;
2530 Move<VkDescriptorSetLayout> m_descriptorSetLayout;
2531 Move<VkPipelineLayout> m_pipelineLayout;
2533 Move<VkShaderModule> m_vertexShaderModule;
2534 Move<VkShaderModule> m_fragmentShaderModule;
2536 Move<VkDescriptorPool> m_descriptorPool;
2537 Move<VkDescriptorSet> m_descriptorSet;
2538 Move<VkBuffer> m_vertexBuffer;
2539 de::MovePtr<Allocation> m_vertexBufferMemory;
2540 vector<VkImage> m_colorAttachmentImages;
2541 VkImage m_depthStencilAttachmentImage;
2544 void pushImageInitializationCommands (const DeviceInterface& vk,
2545 VkCommandBuffer commandBuffer,
2546 const vector<Attachment>& attachmentInfo,
2547 const vector<de::SharedPtr<AttachmentResources> >& attachmentResources,
2548 deUint32 queueIndex,
2549 const vector<Maybe<VkClearValue> >& clearValues)
2552 vector<VkImageMemoryBarrier> initializeLayouts;
2554 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
2556 if (!clearValues[attachmentNdx])
2559 const VkImageMemoryBarrier barrier =
2561 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType;
2564 (VkAccessFlags)0, // srcAccessMask
2565 getAllMemoryReadFlags() | VK_ACCESS_TRANSFER_WRITE_BIT, // dstAccessMask
2567 VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
2568 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // newLayout;
2570 queueIndex, // srcQueueFamilyIndex;
2571 queueIndex, // destQueueFamilyIndex;
2573 attachmentResources[attachmentNdx]->getImage(), // image;
2574 { // subresourceRange;
2575 getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()), // aspect;
2578 0, // baseArraySlice;
2583 initializeLayouts.push_back(barrier);
2586 if (!initializeLayouts.empty())
2587 vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
2588 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0,
2589 0, (const VkMemoryBarrier*)DE_NULL,
2590 0, (const VkBufferMemoryBarrier*)DE_NULL,
2591 (deUint32)initializeLayouts.size(), &initializeLayouts[0]);
2594 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
2596 if (!clearValues[attachmentNdx])
2599 const tcu::TextureFormat format = mapVkFormat(attachmentInfo[attachmentNdx].getFormat());
2601 if (hasStencilComponent(format.order) || hasDepthComponent(format.order))
2603 const float clearNan = tcu::Float32::nan().asFloat();
2604 const float clearDepth = hasDepthComponent(format.order) ? clearValues[attachmentNdx]->depthStencil.depth : clearNan;
2605 const deUint32 clearStencil = hasStencilComponent(format.order) ? clearValues[attachmentNdx]->depthStencil.stencil : 0xDEu;
2606 const VkClearDepthStencilValue depthStencil =
2611 const VkImageSubresourceRange range =
2613 (VkImageAspectFlags)((hasDepthComponent(format.order) ? VK_IMAGE_ASPECT_DEPTH_BIT : 0)
2614 | (hasStencilComponent(format.order) ? VK_IMAGE_ASPECT_STENCIL_BIT : 0)),
2621 vk.cmdClearDepthStencilImage(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &depthStencil, 1, &range);
2625 const VkImageSubresourceRange range =
2627 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask;
2630 0, // baseArrayLayer;
2633 const VkClearColorValue clearColor = clearValues[attachmentNdx]->color;
2635 vk.cmdClearColorImage(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColor, 1, &range);
2640 vector<VkImageMemoryBarrier> renderPassLayouts;
2642 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
2644 const VkImageLayout oldLayout = clearValues[attachmentNdx] ? VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
2645 const VkImageMemoryBarrier barrier =
2647 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType;
2650 getMemoryFlagsForLayout(oldLayout), // srcAccessMask
2651 getAllMemoryReadFlags() | getMemoryFlagsForLayout(attachmentInfo[attachmentNdx].getInitialLayout()), // dstAccessMask
2653 oldLayout, // oldLayout
2654 attachmentInfo[attachmentNdx].getInitialLayout(), // newLayout;
2656 queueIndex, // srcQueueFamilyIndex;
2657 queueIndex, // destQueueFamilyIndex;
2659 attachmentResources[attachmentNdx]->getImage(), // image;
2660 { // subresourceRange;
2661 getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()), // aspect;
2664 0, // baseArraySlice;
2669 renderPassLayouts.push_back(barrier);
2672 if (!renderPassLayouts.empty())
2673 vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
2674 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0,
2675 0, (const VkMemoryBarrier*)DE_NULL,
2676 0, (const VkBufferMemoryBarrier*)DE_NULL,
2677 (deUint32)renderPassLayouts.size(), &renderPassLayouts[0]);
2681 template<typename RenderpassSubpass>
2682 void pushRenderPassCommands (const DeviceInterface& vk,
2683 VkCommandBuffer commandBuffer,
2684 VkRenderPass renderPass,
2685 VkFramebuffer framebuffer,
2686 const vector<de::SharedPtr<SubpassRenderer> >& subpassRenderers,
2687 const UVec2& renderPos,
2688 const UVec2& renderSize,
2689 const vector<Maybe<VkClearValue> >& renderPassClearValues,
2690 TestConfig::RenderTypes render)
2692 const float clearNan = tcu::Float32::nan().asFloat();
2693 vector<VkClearValue> attachmentClearValues;
2694 const typename RenderpassSubpass::SubpassEndInfo subpassEndInfo (DE_NULL);
2696 for (size_t attachmentNdx = 0; attachmentNdx < renderPassClearValues.size(); attachmentNdx++)
2698 if (renderPassClearValues[attachmentNdx])
2699 attachmentClearValues.push_back(*renderPassClearValues[attachmentNdx]);
2701 attachmentClearValues.push_back(makeClearValueColorF32(clearNan, clearNan, clearNan, clearNan));
2705 const VkRect2D renderArea =
2707 { (deInt32)renderPos.x(), (deInt32)renderPos.y() },
2708 { renderSize.x(), renderSize.y() }
2711 for (size_t subpassNdx = 0; subpassNdx < subpassRenderers.size(); subpassNdx++)
2713 const VkSubpassContents contents = subpassRenderers[subpassNdx]->isSecondary() ? VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS : VK_SUBPASS_CONTENTS_INLINE;
2714 const typename RenderpassSubpass::SubpassBeginInfo subpassBeginInfo (DE_NULL, contents);
2715 const VkRenderPassBeginInfo renderPassBeginInfo = createRenderPassBeginInfo(renderPass,
2718 (deUint32)attachmentClearValues.size(),
2719 attachmentClearValues.empty() ? DE_NULL : &attachmentClearValues[0]);
2721 if (subpassNdx == 0)
2722 RenderpassSubpass::cmdBeginRenderPass(vk, commandBuffer, &renderPassBeginInfo, &subpassBeginInfo);
2724 RenderpassSubpass::cmdNextSubpass(vk, commandBuffer, &subpassBeginInfo, &subpassEndInfo);
2728 if (contents == VK_SUBPASS_CONTENTS_INLINE)
2730 subpassRenderers[subpassNdx]->pushRenderCommands(vk, commandBuffer);
2732 else if (contents == VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS)
2734 const VkCommandBuffer cmd = subpassRenderers[subpassNdx]->getCommandBuffer();
2735 vk.cmdExecuteCommands(commandBuffer, 1, &cmd);
2738 DE_FATAL("Invalid contents");
2742 RenderpassSubpass::cmdEndRenderPass(vk, commandBuffer, &subpassEndInfo);
2746 void pushDynamicRenderingCommands (const DeviceInterface& vk,
2747 VkCommandBuffer commandBuffer,
2748 const RenderPass& renderPassInfo,
2749 const vector<de::SharedPtr<AttachmentResources> >& attachmentResources,
2750 const vector<de::SharedPtr<SubpassRenderer> >& subpassRenderers,
2751 const UVec2& renderPos,
2752 const UVec2& renderSize,
2753 const vector<Maybe<VkClearValue> >& renderPassClearValues,
2754 deUint32 queueIndex,
2755 TestConfig::RenderTypes render)
2757 const float clearNan = tcu::Float32::nan().asFloat();
2758 const VkClearValue clearValueNan = makeClearValueColorF32(clearNan, clearNan, clearNan, clearNan);
2760 DE_ASSERT(subpassRenderers.size() == 1);
2762 VkRenderingFlagsKHR renderingFlags = 0u;
2763 if (subpassRenderers[0]->isSecondary())
2764 renderingFlags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR;
2766 const VkRect2D renderArea
2768 { (deInt32)renderPos.x(), (deInt32)renderPos.y() },
2769 { renderSize.x(), renderSize.y() }
2772 // translate structures that were prepared to construct renderpass to structures needed for dynamic rendering
2774 vector<VkImageMemoryBarrier> imageBarriersBeforeRendering;
2775 vector<VkImageMemoryBarrier> imageBarriersAfterRendering;
2776 std::vector<vk::VkRenderingAttachmentInfoKHR> colorAttachmentVect;
2777 const Subpass& subpassInfo = renderPassInfo.getSubpasses()[0];
2778 const vector<AttachmentReference>& colorAttachmentsInfo = subpassInfo.getColorAttachments();
2779 const vector<AttachmentReference>& resolveAttachmentsInfo = subpassInfo.getResolveAttachments();
2781 for (deUint32 i = 0 ; i < colorAttachmentsInfo.size() ; ++i)
2783 const AttachmentReference& colorAttachmentReference = colorAttachmentsInfo[i];
2784 const deUint32 colorAttachmentIndex = colorAttachmentReference.getAttachment();
2785 const Attachment& colorAttachmentInfo = renderPassInfo.getAttachments()[colorAttachmentIndex];
2787 VkResolveModeFlagBits resolveMode = VK_RESOLVE_MODE_NONE;
2788 VkImageView resolveImageView = DE_NULL;
2789 VkImageLayout resolveImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
2791 // handle resolve attachments if they were specified
2792 if (!resolveAttachmentsInfo.empty())
2794 const AttachmentReference& resolveAttachmentReference = resolveAttachmentsInfo[i];
2795 const deUint32 resolveAttachmentIndex = resolveAttachmentReference.getAttachment();
2796 const Attachment& resolveAttachmentInfo = renderPassInfo.getAttachments()[resolveAttachmentIndex];
2798 resolveMode = VK_RESOLVE_MODE_AVERAGE_BIT;
2799 resolveImageView = attachmentResources[resolveAttachmentIndex]->getAttachmentView();
2800 resolveImageLayout = resolveAttachmentInfo.getInitialLayout();
2803 colorAttachmentVect.push_back({
2804 vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType
2805 DE_NULL, // const void* pNext
2806 attachmentResources[colorAttachmentIndex]->getAttachmentView(), // VkImageView imageView
2807 colorAttachmentReference.getImageLayout(), // VkImageLayout imageLayout
2808 resolveMode, // VkResolveModeFlagBits resolveMode
2809 resolveImageView, // VkImageView resolveImageView
2810 resolveImageLayout, // VkImageLayout resolveImageLayout
2811 colorAttachmentInfo.getLoadOp(), // VkAttachmentLoadOp loadOp
2812 colorAttachmentInfo.getStoreOp(), // VkAttachmentStoreOp storeOp
2813 (renderPassClearValues[colorAttachmentIndex] ?
2814 *renderPassClearValues[colorAttachmentIndex] :
2815 clearValueNan) // VkClearValue clearValue
2818 const VkImageLayout initialLayout = colorAttachmentInfo.getInitialLayout();
2819 const VkImageLayout renderingLayout = colorAttachmentReference.getImageLayout();
2820 const VkImageLayout finalLayout = colorAttachmentInfo.getFinalLayout();
2822 const VkImageMemoryBarrier barrierBeforeRendering
2824 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
2827 getAllMemoryWriteFlags() | getMemoryFlagsForLayout(initialLayout), // srcAccessMask
2828 getMemoryFlagsForLayout(renderingLayout), // dstAccessMask
2830 initialLayout, // oldLayout
2831 renderingLayout, // newLayout
2833 queueIndex, // srcQueueFamilyIndex
2834 queueIndex, // destQueueFamilyIndex
2836 attachmentResources[colorAttachmentIndex]->getImage(), // image
2837 { // subresourceRange
2838 getImageAspectFlags(colorAttachmentInfo.getFormat()), // aspect;
2841 0, // baseArraySlice
2845 imageBarriersBeforeRendering.push_back(barrierBeforeRendering);
2847 const VkImageMemoryBarrier barrierAfterRendering
2849 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
2852 getMemoryFlagsForLayout(renderingLayout), // srcAccessMask
2853 getAllMemoryReadFlags() | getMemoryFlagsForLayout(finalLayout), // dstAccessMask
2855 renderingLayout, // oldLayout
2856 finalLayout, // newLayout
2858 queueIndex, // srcQueueFamilyIndex
2859 queueIndex, // destQueueFamilyIndex
2861 attachmentResources[colorAttachmentIndex]->getImage(), // image
2862 { // subresourceRange
2863 getImageAspectFlags(colorAttachmentInfo.getFormat()), // aspect;
2866 0, // baseArraySlice
2870 imageBarriersAfterRendering.push_back(barrierAfterRendering);
2873 VkRenderingAttachmentInfoKHR* pDepthAttachment = DE_NULL;
2874 VkRenderingAttachmentInfoKHR* pStencilAttachment = DE_NULL;
2875 VkRenderingAttachmentInfoKHR depthAttachment
2877 vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
2878 DE_NULL, // const void* pNext;
2879 DE_NULL, // VkImageView imageView;
2880 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout imageLayout;
2881 VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode;
2882 DE_NULL, // VkImageView resolveImageView;
2883 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout;
2884 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
2885 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
2886 clearValueNan // VkClearValue clearValue;
2888 VkRenderingAttachmentInfoKHR stencilAttachment = depthAttachment;
2889 const AttachmentReference& depthStencilAttachmentReference = subpassInfo.getDepthStencilAttachment();
2890 const deUint32 dsAttachmentIndex = depthStencilAttachmentReference.getAttachment();
2892 if (dsAttachmentIndex != VK_ATTACHMENT_UNUSED)
2894 const Attachment& dsAttachmentInfo = renderPassInfo.getAttachments()[dsAttachmentIndex];
2895 const tcu::TextureFormat format = mapVkFormat(dsAttachmentInfo.getFormat());
2897 if (tcu::hasDepthComponent(format.order))
2899 depthAttachment.imageView = attachmentResources[dsAttachmentIndex]->getAttachmentView();
2900 depthAttachment.imageLayout = depthStencilAttachmentReference.getImageLayout();
2901 depthAttachment.loadOp = dsAttachmentInfo.getLoadOp();
2902 depthAttachment.storeOp = dsAttachmentInfo.getStoreOp();
2904 if (renderPassClearValues[dsAttachmentIndex])
2905 depthAttachment.clearValue = *renderPassClearValues[dsAttachmentIndex];
2907 pDepthAttachment = &depthAttachment;
2910 if (tcu::hasStencilComponent(format.order))
2912 stencilAttachment.imageView = attachmentResources[dsAttachmentIndex]->getAttachmentView();
2913 stencilAttachment.imageLayout = depthStencilAttachmentReference.getImageLayout();
2914 stencilAttachment.loadOp = dsAttachmentInfo.getStencilLoadOp();
2915 stencilAttachment.storeOp = dsAttachmentInfo.getStencilStoreOp();
2917 if (renderPassClearValues[dsAttachmentIndex])
2918 stencilAttachment.clearValue = *renderPassClearValues[dsAttachmentIndex];
2920 pStencilAttachment = &stencilAttachment;
2923 const VkImageLayout initialLayout = dsAttachmentInfo.getInitialLayout();
2924 const VkImageLayout renderingLayout = depthStencilAttachmentReference.getImageLayout();
2925 const VkImageLayout finalLayout = dsAttachmentInfo.getFinalLayout();
2927 const VkImageMemoryBarrier barrierBeforeRendering
2929 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
2932 getAllMemoryWriteFlags() | getMemoryFlagsForLayout(initialLayout), // srcAccessMask
2933 getMemoryFlagsForLayout(renderingLayout), // dstAccessMask
2935 initialLayout, // oldLayout
2936 renderingLayout, // newLayout
2938 queueIndex, // srcQueueFamilyIndex
2939 queueIndex, // destQueueFamilyIndex
2941 attachmentResources[dsAttachmentIndex]->getImage(), // image
2942 { // subresourceRange
2943 getImageAspectFlags(dsAttachmentInfo.getFormat()), // aspect;
2946 0, // baseArraySlice
2950 imageBarriersBeforeRendering.push_back(barrierBeforeRendering);
2952 const VkImageMemoryBarrier barrierAfterRendering
2954 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
2957 getMemoryFlagsForLayout(renderingLayout), // srcAccessMask
2958 getAllMemoryReadFlags() | getMemoryFlagsForLayout(finalLayout), // dstAccessMask
2960 renderingLayout, // oldLayout
2961 finalLayout, // newLayout
2963 queueIndex, // srcQueueFamilyIndex
2964 queueIndex, // destQueueFamilyIndex
2966 attachmentResources[dsAttachmentIndex]->getImage(), // image
2967 { // subresourceRange
2968 getImageAspectFlags(dsAttachmentInfo.getFormat()), // aspect;
2971 0, // baseArraySlice
2975 imageBarriersAfterRendering.push_back(barrierAfterRendering);
2978 if (!imageBarriersBeforeRendering.empty())
2979 vk.cmdPipelineBarrier(commandBuffer,
2980 getAllPipelineStageFlags(),
2981 getAllPipelineStageFlags(),
2982 (VkDependencyFlags)0,
2983 0, (const VkMemoryBarrier*)DE_NULL,
2984 0, (const VkBufferMemoryBarrier*)DE_NULL,
2985 (deUint32)imageBarriersBeforeRendering.size(),
2986 &imageBarriersBeforeRendering[0]);
2988 vk::VkRenderingInfoKHR renderingInfo
2990 vk::VK_STRUCTURE_TYPE_RENDERING_INFO_KHR,
2992 renderingFlags, // VkRenderingFlagsKHR flags;
2993 renderArea, // VkRect2D renderArea;
2994 1u, // deUint32 layerCount;
2995 0u, // deUint32 viewMask;
2996 static_cast<deUint32>(colorAttachmentVect.size()), // deUint32 colorAttachmentCount;
2997 colorAttachmentVect.empty() ? DE_NULL : &colorAttachmentVect[0], // const VkRenderingAttachmentInfoKHR* pColorAttachments;
2998 pDepthAttachment, // const VkRenderingAttachmentInfoKHR* pDepthAttachment;
2999 pStencilAttachment // const VkRenderingAttachmentInfoKHR* pStencilAttachment;
3002 vk.cmdBeginRenderingKHR(commandBuffer, &renderingInfo);
3006 if (subpassRenderers[0]->isSecondary())
3008 const VkCommandBuffer cmd = subpassRenderers[0]->getCommandBuffer();
3009 vk.cmdExecuteCommands(commandBuffer, 1, &cmd);
3012 subpassRenderers[0]->pushRenderCommands(vk, commandBuffer);
3015 vk.cmdEndRenderingKHR(commandBuffer);
3017 if (!imageBarriersAfterRendering.empty())
3018 vk.cmdPipelineBarrier(commandBuffer,
3019 getAllPipelineStageFlags(),
3020 getAllPipelineStageFlags(),
3021 (VkDependencyFlags)0,
3022 0, (const VkMemoryBarrier*)DE_NULL,
3023 0, (const VkBufferMemoryBarrier*)DE_NULL,
3024 (deUint32)imageBarriersAfterRendering.size(),
3025 &imageBarriersAfterRendering[0]);
3028 void pushRenderPassCommands (const DeviceInterface& vk,
3029 VkCommandBuffer commandBuffer,
3030 VkRenderPass renderPass,
3031 const RenderPass& renderPassInfo,
3032 const vector<de::SharedPtr<AttachmentResources> >& attachmentResources,
3033 VkFramebuffer framebuffer,
3034 const vector<de::SharedPtr<SubpassRenderer> >& subpassRenderers,
3035 const UVec2& renderPos,
3036 const UVec2& renderSize,
3037 const vector<Maybe<VkClearValue> >& renderPassClearValues,
3038 deUint32 queueIndex,
3039 TestConfig::RenderTypes render,
3040 RenderingType renderingType)
3042 switch (renderingType)
3044 case RENDERING_TYPE_RENDERPASS_LEGACY:
3045 return pushRenderPassCommands<RenderpassSubpass1>(vk, commandBuffer, renderPass, framebuffer, subpassRenderers, renderPos, renderSize, renderPassClearValues, render);
3046 case RENDERING_TYPE_RENDERPASS2:
3047 return pushRenderPassCommands<RenderpassSubpass2>(vk, commandBuffer, renderPass, framebuffer, subpassRenderers, renderPos, renderSize, renderPassClearValues, render);
3048 case RENDERING_TYPE_DYNAMIC_RENDERING:
3049 return pushDynamicRenderingCommands(vk, commandBuffer, renderPassInfo, attachmentResources, subpassRenderers, renderPos, renderSize, renderPassClearValues, queueIndex, render);
3051 TCU_THROW(InternalError, "Impossible");
3055 void pushReadImagesToBuffers (const DeviceInterface& vk,
3056 VkCommandBuffer commandBuffer,
3057 deUint32 queueIndex,
3059 const vector<de::SharedPtr<AttachmentResources> >& attachmentResources,
3060 const vector<Attachment>& attachmentInfo,
3061 const vector<bool>& isLazy,
3063 const UVec2& targetSize)
3066 vector<VkImageMemoryBarrier> imageBarriers;
3068 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
3070 if (isLazy[attachmentNdx])
3073 const VkImageLayout oldLayout = attachmentInfo[attachmentNdx].getFinalLayout();
3074 const VkImageMemoryBarrier barrier =
3076 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
3079 getAllMemoryWriteFlags() | getMemoryFlagsForLayout(oldLayout), // srcAccessMask
3080 getAllMemoryReadFlags(), // dstAccessMask
3082 oldLayout, // oldLayout
3083 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // newLayout
3085 queueIndex, // srcQueueFamilyIndex
3086 queueIndex, // destQueueFamilyIndex
3088 attachmentResources[attachmentNdx]->getImage(), // image
3089 { // subresourceRange
3090 getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()), // aspect;
3093 0, // baseArraySlice
3098 imageBarriers.push_back(barrier);
3101 if (!imageBarriers.empty())
3102 vk.cmdPipelineBarrier(commandBuffer,
3103 getAllPipelineStageFlags(),
3104 getAllPipelineStageFlags(),
3105 (VkDependencyFlags)0,
3106 0, (const VkMemoryBarrier*)DE_NULL,
3107 0, (const VkBufferMemoryBarrier*)DE_NULL,
3108 (deUint32)imageBarriers.size(), &imageBarriers[0]);
3111 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
3113 if (isLazy[attachmentNdx])
3116 const tcu::TextureFormat::ChannelOrder order = mapVkFormat(attachmentInfo[attachmentNdx].getFormat()).order;
3117 const VkBufferImageCopy rect =
3120 0, // bufferRowLength
3121 0, // bufferImageHeight
3122 { // imageSubresource
3123 (vk::VkImageAspectFlags)getPrimaryImageAspect(mapVkFormat(attachmentInfo[attachmentNdx].getFormat()).order), // aspect
3128 { 0, 0, 0 }, // imageOffset
3129 { targetSize.x(), targetSize.y(), 1u } // imageExtent
3132 vk.cmdCopyImageToBuffer(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, attachmentResources[attachmentNdx]->getBuffer(), 1, &rect);
3134 if (tcu::TextureFormat::DS == order)
3136 const VkBufferImageCopy stencilRect =
3139 0, // bufferRowLength
3140 0, // bufferImageHeight
3141 { // imageSubresource
3142 VK_IMAGE_ASPECT_STENCIL_BIT, // aspect
3147 { 0, 0, 0 }, // imageOffset
3148 { targetSize.x(), targetSize.y(), 1u } // imageExtent
3151 vk.cmdCopyImageToBuffer(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, attachmentResources[attachmentNdx]->getSecondaryBuffer(), 1, &stencilRect);
3156 vector<VkBufferMemoryBarrier> bufferBarriers;
3158 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
3160 if (isLazy[attachmentNdx])
3163 const tcu::TextureFormat::ChannelOrder order = mapVkFormat(attachmentInfo[attachmentNdx].getFormat()).order;
3164 const VkBufferMemoryBarrier bufferBarrier =
3166 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
3169 getAllMemoryWriteFlags(),
3170 getAllMemoryReadFlags(),
3175 attachmentResources[attachmentNdx]->getBuffer(),
3177 attachmentResources[attachmentNdx]->getBufferSize()
3180 bufferBarriers.push_back(bufferBarrier);
3182 if (tcu::TextureFormat::DS == order)
3184 const VkBufferMemoryBarrier secondaryBufferBarrier =
3186 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
3189 getAllMemoryWriteFlags(),
3190 getAllMemoryReadFlags(),
3195 attachmentResources[attachmentNdx]->getSecondaryBuffer(),
3197 attachmentResources[attachmentNdx]->getSecondaryBufferSize()
3200 bufferBarriers.push_back(secondaryBufferBarrier);
3204 if (!bufferBarriers.empty())
3205 vk.cmdPipelineBarrier(commandBuffer,
3206 getAllPipelineStageFlags(),
3207 getAllPipelineStageFlags(),
3208 (VkDependencyFlags)0,
3209 0, (const VkMemoryBarrier*)DE_NULL,
3210 (deUint32)bufferBarriers.size(), &bufferBarriers[0],
3211 0, (const VkImageMemoryBarrier*)DE_NULL);
3218 PixelValue (const Maybe<bool>& x = tcu::Nothing,
3219 const Maybe<bool>& y = tcu::Nothing,
3220 const Maybe<bool>& z = tcu::Nothing,
3221 const Maybe<bool>& w = tcu::Nothing);
3223 void setUndefined (size_t ndx);
3224 void setValue (size_t ndx, bool value);
3225 Maybe<bool> getValue (size_t ndx) const;
3231 PixelValue::PixelValue (const Maybe<bool>& x,
3232 const Maybe<bool>& y,
3233 const Maybe<bool>& z,
3234 const Maybe<bool>& w)
3237 const Maybe<bool> values[] =
3242 for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(values); ndx++)
3245 setValue(ndx, *values[ndx]);
3250 DE_ASSERT(m_status <= 0xFFu);
3253 void PixelValue::setUndefined (size_t ndx)
3256 DE_ASSERT(m_status <= 0xFFu);
3258 m_status &= (deUint16)~(0x1u << (deUint16)(ndx * 2));
3259 DE_ASSERT(m_status <= 0xFFu);
3262 void PixelValue::setValue (size_t ndx, bool value)
3265 DE_ASSERT(m_status <= 0xFFu);
3267 m_status = (deUint16)(m_status | (deUint16)(0x1u << (ndx * 2)));
3270 m_status = (deUint16)(m_status | (deUint16)(0x1u << (ndx * 2 + 1)));
3272 m_status &= (deUint16)~(0x1u << (deUint16)(ndx * 2 + 1));
3274 DE_ASSERT(m_status <= 0xFFu);
3277 Maybe<bool> PixelValue::getValue (size_t ndx) const
3280 DE_ASSERT(m_status <= 0xFFu);
3282 if ((m_status & (0x1u << (deUint16)(ndx * 2))) != 0)
3284 return just((m_status & (0x1u << (deUint32)(ndx * 2 + 1))) != 0);
3287 return tcu::Nothing;
3290 void clearReferenceValues (vector<PixelValue>& values,
3291 const UVec2& targetSize,
3292 const UVec2& offset,
3295 const PixelValue& value)
3297 DE_ASSERT(targetSize.x() * targetSize.y() == (deUint32)values.size());
3298 DE_ASSERT(offset.x() + size.x() <= targetSize.x());
3299 DE_ASSERT(offset.y() + size.y() <= targetSize.y());
3301 for (deUint32 y = offset.y(); y < offset.y() + size.y(); y++)
3302 for (deUint32 x = offset.x(); x < offset.x() + size.x(); x++)
3304 for (int compNdx = 0; compNdx < 4; compNdx++)
3308 if (value.getValue(compNdx))
3309 values[x + y * targetSize.x()].setValue(compNdx, *value.getValue(compNdx));
3311 values[x + y * targetSize.x()].setUndefined(compNdx);
3317 void markUndefined (vector<PixelValue>& values,
3319 const UVec2& targetSize,
3320 const UVec2& offset,
3323 DE_ASSERT(targetSize.x() * targetSize.y() == (deUint32)values.size());
3325 for (deUint32 y = offset.y(); y < offset.y() + size.y(); y++)
3326 for (deUint32 x = offset.x(); x < offset.x() + size.x(); x++)
3328 for (int compNdx = 0; compNdx < 4; compNdx++)
3331 values[x + y * targetSize.x()].setUndefined(compNdx);
3336 PixelValue clearValueToPixelValue (const VkClearValue& value,
3337 const tcu::TextureFormat& format,
3338 const DepthValuesArray& depthValues)
3340 const bool isDepthAttachment = hasDepthComponent(format.order);
3341 const bool isStencilAttachment = hasStencilComponent(format.order);
3342 const bool isDepthOrStencilAttachment = isDepthAttachment || isStencilAttachment;
3343 PixelValue pixelValue;
3345 if (isDepthOrStencilAttachment)
3347 if (isDepthAttachment)
3349 if (value.depthStencil.depth == float(depthValues[1]) / 255.0f)
3350 pixelValue.setValue(0, true);
3351 else if (value.depthStencil.depth == float(depthValues[0]) / 255.0f)
3352 pixelValue.setValue(0, false);
3354 DE_FATAL("Unknown depth value");
3357 if (isStencilAttachment)
3359 if (value.depthStencil.stencil == 0xFFu)
3360 pixelValue.setValue(1, true);
3361 else if (value.depthStencil.stencil == 0x0u)
3362 pixelValue.setValue(1, false);
3364 DE_FATAL("Unknown stencil value");
3369 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type);
3370 const tcu::BVec4 channelMask = tcu::getTextureFormatChannelMask(format);
3372 switch (channelClass)
3374 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
3375 for (int i = 0; i < 4; i++)
3379 if (value.color.int32[i] == 1)
3380 pixelValue.setValue(i, true);
3381 else if (value.color.int32[i] == 0)
3382 pixelValue.setValue(i, false);
3384 DE_FATAL("Unknown clear color value");
3389 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
3390 for (int i = 0; i < 4; i++)
3394 if (value.color.uint32[i] == 1u)
3395 pixelValue.setValue(i, true);
3396 else if (value.color.uint32[i] == 0u)
3397 pixelValue.setValue(i, false);
3399 DE_FATAL("Unknown clear color value");
3404 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
3405 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
3406 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
3407 for (int i = 0; i < 4; i++)
3411 if (value.color.float32[i] == 1.0f)
3412 pixelValue.setValue(i, true);
3413 else if (value.color.float32[i] == 0.0f)
3414 pixelValue.setValue(i, false);
3416 DE_FATAL("Unknown clear color value");
3422 DE_FATAL("Unknown channel class");
3429 void renderReferenceValues (vector<vector<PixelValue> >& referenceAttachments,
3430 const RenderPass& renderPassInfo,
3431 const UVec2& targetSize,
3432 const vector<Maybe<VkClearValue> >& imageClearValues,
3433 const vector<Maybe<VkClearValue> >& renderPassClearValues,
3434 const vector<SubpassRenderInfo>& subpassRenderInfo,
3435 const UVec2& renderPos,
3436 const UVec2& renderSize,
3437 const deUint32 drawStartNdx,
3438 const DepthValuesArray& depthValues)
3440 const vector<Subpass>& subpasses = renderPassInfo.getSubpasses();
3441 vector<bool> attachmentUsed (renderPassInfo.getAttachments().size(), false);
3443 referenceAttachments.resize(renderPassInfo.getAttachments().size());
3445 for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
3447 const Attachment attachment = renderPassInfo.getAttachments()[attachmentNdx];
3448 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3449 vector<PixelValue>& reference = referenceAttachments[attachmentNdx];
3451 reference.resize(targetSize.x() * targetSize.y());
3453 if (imageClearValues[attachmentNdx])
3454 clearReferenceValues(reference, targetSize, UVec2(0, 0), targetSize, BVec4(true), clearValueToPixelValue(*imageClearValues[attachmentNdx], format, depthValues));
3457 for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
3459 const Subpass& subpass = subpasses[subpassNdx];
3460 const SubpassRenderInfo& renderInfo = subpassRenderInfo[subpassNdx];
3461 const vector<AttachmentReference>& colorAttachments = subpass.getColorAttachments();
3463 // Apply load op if attachment was used for the first time
3464 for (size_t attachmentNdx = 0; attachmentNdx < colorAttachments.size(); attachmentNdx++)
3466 const deUint32 attachmentIndex = getAttachmentNdx(colorAttachments, attachmentNdx);
3468 if (!attachmentUsed[attachmentIndex] && colorAttachments[attachmentNdx].getAttachment() != VK_ATTACHMENT_UNUSED)
3470 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3471 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3472 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3474 DE_ASSERT(!tcu::hasDepthComponent(format.order));
3475 DE_ASSERT(!tcu::hasStencilComponent(format.order));
3477 if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
3478 clearReferenceValues(reference, targetSize, renderPos, renderSize, BVec4(true), clearValueToPixelValue(*renderPassClearValues[attachmentIndex], format, depthValues));
3479 else if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
3480 markUndefined(reference, BVec4(true), targetSize, renderPos, renderSize);
3482 attachmentUsed[attachmentIndex] = true;
3486 // Apply load op to depth/stencil attachment if it was used for the first time
3487 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
3489 const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3491 // Apply load op if attachment was used for the first time
3492 if (!attachmentUsed[attachmentIndex])
3494 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3495 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3496 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3498 if (tcu::hasDepthComponent(format.order))
3500 if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
3501 clearReferenceValues(reference, targetSize, renderPos, renderSize, BVec4(true, false, false, false), clearValueToPixelValue(*renderPassClearValues[attachmentIndex], format, depthValues));
3502 else if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
3503 markUndefined(reference, BVec4(true, false, false, false), targetSize, renderPos, renderSize);
3506 if (tcu::hasStencilComponent(format.order))
3508 if (attachment.getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
3509 clearReferenceValues(reference, targetSize, renderPos, renderSize, BVec4(false, true, false, false), clearValueToPixelValue(*renderPassClearValues[attachmentIndex], format, depthValues));
3510 else if (attachment.getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
3511 markUndefined(reference, BVec4(false, true, false, false), targetSize, renderPos, renderSize);
3514 attachmentUsed[attachmentIndex] = true;
3518 for (size_t colorClearNdx = 0; colorClearNdx < renderInfo.getColorClears().size(); colorClearNdx++)
3520 const ColorClear& colorClear = renderInfo.getColorClears()[colorClearNdx];
3521 const UVec2 offset = colorClear.getOffset();
3522 const UVec2 size = colorClear.getSize();
3523 const deUint32 attachmentIndex = subpass.getColorAttachments()[colorClearNdx].getAttachment();
3524 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3525 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3526 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3529 value.color = colorClear.getColor();
3531 clearReferenceValues(reference, targetSize, offset, size, BVec4(true), clearValueToPixelValue(value, format, depthValues));
3534 if (renderInfo.getDepthStencilClear())
3536 const DepthStencilClear& dsClear = *renderInfo.getDepthStencilClear();
3537 const UVec2 offset = dsClear.getOffset();
3538 const UVec2 size = dsClear.getSize();
3539 const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3540 const VkImageLayout layout = subpass.getDepthStencilAttachment().getImageLayout();
3541 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3542 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3543 const bool hasStencil = tcu::hasStencilComponent(format.order)
3544 && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
3545 const bool hasDepth = tcu::hasDepthComponent(format.order)
3546 && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
3547 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3550 value.depthStencil.depth = dsClear.getDepth();
3551 value.depthStencil.stencil = dsClear.getStencil();
3553 clearReferenceValues(reference, targetSize, offset, size, BVec4(hasDepth, hasStencil, false, false), clearValueToPixelValue(value, format, depthValues));
3556 if (renderInfo.getRenderQuad())
3558 const RenderQuad& renderQuad = *renderInfo.getRenderQuad();
3559 const Vec2 posA = renderQuad.getCornerA();
3560 const Vec2 posB = renderQuad.getCornerB();
3561 const Vec2 origin = Vec2((float)renderInfo.getViewportOffset().x(), (float)renderInfo.getViewportOffset().y()) + Vec2((float)renderInfo.getViewportSize().x(), (float)renderInfo.getViewportSize().y()) / Vec2(2.0f);
3562 const Vec2 p = Vec2((float)renderInfo.getViewportSize().x(), (float)renderInfo.getViewportSize().y()) / Vec2(2.0f);
3563 const IVec2 posAI (deRoundFloatToInt32(origin.x() + (p.x() * posA.x())),
3564 deRoundFloatToInt32(origin.y() + (p.y() * posA.y())));
3565 const IVec2 posBI (deRoundFloatToInt32(origin.x() + (p.x() * posB.x())),
3566 deRoundFloatToInt32(origin.y() + (p.y() * posB.y())));
3568 DE_ASSERT(posAI.x() < posBI.x());
3569 DE_ASSERT(posAI.y() < posBI.y());
3571 if (subpass.getInputAttachments().empty())
3573 for (size_t attachmentRefNdx = drawStartNdx; attachmentRefNdx < subpass.getColorAttachments().size(); attachmentRefNdx++)
3575 const deUint32 attachmentIndex = subpass.getColorAttachments()[attachmentRefNdx].getAttachment();
3577 if (attachmentIndex == VK_ATTACHMENT_UNUSED)
3580 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3581 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3582 const tcu::BVec4 channelMask = tcu::getTextureFormatChannelMask(format);
3583 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3585 for (int y = posAI.y(); y < (int)posBI.y(); y++)
3586 for (int x = posAI.x(); x < (int)posBI.x(); x++)
3588 for (int compNdx = 0; compNdx < 4; compNdx++)
3590 const size_t index = subpassNdx + attachmentIndex + compNdx;
3591 const BoolOp op = boolOpFromIndex(index);
3592 const bool boolX = x % 2 == (int)(index % 2);
3593 const bool boolY = y % 2 == (int)((index / 2) % 2);
3595 if (channelMask[compNdx])
3596 reference[x + y * targetSize.x()].setValue(compNdx, performBoolOp(op, boolX, boolY));
3601 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
3603 const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3604 const VkImageLayout layout = subpass.getDepthStencilAttachment().getImageLayout();
3605 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3606 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3607 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3609 for (int y = posAI.y(); y < (int)posBI.y(); y++)
3610 for (int x = posAI.x(); x < (int)posBI.x(); x++)
3612 if (tcu::hasDepthComponent(format.order)
3613 && layout != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3614 && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3616 const size_t index = subpassNdx + 1;
3617 const BoolOp op = boolOpFromIndex(index);
3618 const bool boolX = x % 2 == (int)(index % 2);
3619 const bool boolY = y % 2 == (int)((index / 2) % 2);
3621 reference[x + y * targetSize.x()].setValue(0, performBoolOp(op, boolX, boolY));
3624 if (tcu::hasStencilComponent(format.order)
3625 && layout != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3626 && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
3628 const size_t index = subpassNdx;
3629 reference[x + y * targetSize.x()].setValue(1, (index % 2) == 0);
3636 size_t outputComponentCount = 0;
3637 vector<Maybe<bool> > inputs;
3639 DE_ASSERT(posAI.x() < posBI.x());
3640 DE_ASSERT(posAI.y() < posBI.y());
3642 for (size_t attachmentRefNdx = 0; attachmentRefNdx < subpass.getColorAttachments().size(); attachmentRefNdx++)
3644 const deUint32 attachmentIndex = subpass.getColorAttachments()[attachmentRefNdx].getAttachment();
3645 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3646 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3647 const int componentCount = tcu::getNumUsedChannels(format.order);
3649 outputComponentCount += (size_t)componentCount;
3652 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
3653 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3654 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3656 const Attachment& attachment (renderPassInfo.getAttachments()[subpass.getDepthStencilAttachment().getAttachment()]);
3657 const tcu::TextureFormat format (mapVkFormat(attachment.getFormat()));
3659 if (tcu::hasDepthComponent(format.order))
3660 outputComponentCount++;
3663 if (outputComponentCount > 0)
3665 for (int y = posAI.y(); y < (int)posBI.y(); y++)
3666 for (int x = posAI.x(); x < (int)posBI.x(); x++)
3668 for (size_t inputAttachmentNdx = 0; inputAttachmentNdx < subpass.getInputAttachments().size(); inputAttachmentNdx++)
3670 const deUint32 attachmentIndex = subpass.getInputAttachments()[inputAttachmentNdx].getAttachment();
3671 const VkImageLayout layout = subpass.getInputAttachments()[inputAttachmentNdx].getImageLayout();
3672 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3673 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3674 const int componentCount = tcu::getNumUsedChannels(format.order);
3676 for (int compNdx = 0; compNdx < componentCount; compNdx++)
3678 if ((compNdx != 0 || layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
3679 && (compNdx != 1 || layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL))
3681 inputs.push_back(referenceAttachments[attachmentIndex][x + y * targetSize.x()].getValue(compNdx));
3686 const size_t inputsPerOutput = inputs.size() >= outputComponentCount
3687 ? ((inputs.size() / outputComponentCount)
3688 + ((inputs.size() % outputComponentCount) != 0 ? 1 : 0))
3691 size_t outputValueNdx = 0;
3693 for (size_t attachmentRefNdx = 0; attachmentRefNdx < subpass.getColorAttachments().size(); attachmentRefNdx++)
3695 const deUint32 attachmentIndex = subpass.getColorAttachments()[attachmentRefNdx].getAttachment();
3696 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3697 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3698 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3699 const int componentCount = tcu::getNumUsedChannels(format.order);
3701 for (int compNdx = 0; compNdx < componentCount; compNdx++)
3703 const size_t index = subpassNdx + attachmentIndex + outputValueNdx;
3704 const BoolOp op = boolOpFromIndex(index);
3705 const bool boolX = x % 2 == (int)(index % 2);
3706 const bool boolY = y % 2 == (int)((index / 2) % 2);
3707 Maybe<bool> output = tcu::just(performBoolOp(op, boolX, boolY));
3709 for (size_t i = 0; i < inputsPerOutput; i++)
3713 else if (!inputs[((outputValueNdx + compNdx) * inputsPerOutput + i) % inputs.size()])
3714 output = tcu::Nothing;
3716 output = (*output) == (*inputs[((outputValueNdx + compNdx) * inputsPerOutput + i) % inputs.size()]);
3720 reference[x + y * targetSize.x()].setValue(compNdx, *output);
3722 reference[x + y * targetSize.x()].setUndefined(compNdx);
3725 outputValueNdx += componentCount;
3728 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
3729 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3730 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3732 const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3733 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3734 const size_t index = subpassNdx + attachmentIndex;
3735 const BoolOp op = boolOpFromIndex(index);
3736 const bool boolX = x % 2 == (int)(index % 2);
3737 const bool boolY = y % 2 == (int)((index / 2) % 2);
3738 Maybe<bool> output = tcu::just(performBoolOp(op, boolX, boolY));
3740 for (size_t i = 0; i < inputsPerOutput; i++)
3744 else if (inputs[(outputValueNdx * inputsPerOutput + i) % inputs.size()])
3745 output = (*output) == (*inputs[(outputValueNdx * inputsPerOutput + i) % inputs.size()]);
3747 output = tcu::Nothing;
3751 reference[x + y * targetSize.x()].setValue(0, *output);
3753 reference[x + y * targetSize.x()].setUndefined(0);
3760 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
3761 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3762 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
3764 const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3765 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
3766 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3767 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3769 if (tcu::hasStencilComponent(format.order))
3771 for (int y = posAI.y(); y < (int)posBI.y(); y++)
3772 for (int x = posAI.x(); x < (int)posBI.x(); x++)
3774 const size_t index = subpassNdx;
3775 reference[x + y * targetSize.x()].setValue(1, (index % 2) == 0);
3783 // Mark all attachments that were used but not stored as undefined
3784 for (size_t attachmentIndex = 0; attachmentIndex < renderPassInfo.getAttachments().size(); attachmentIndex++)
3786 const Attachment attachment = renderPassInfo.getAttachments()[attachmentIndex];
3787 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3788 vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
3789 const bool isStencilAttachment = hasStencilComponent(format.order);
3790 const bool isDepthOrStencilAttachment = hasDepthComponent(format.order) || isStencilAttachment;
3792 if (attachmentUsed[attachmentIndex] && renderPassInfo.getAttachments()[attachmentIndex].getStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)
3794 if (isDepthOrStencilAttachment)
3795 markUndefined(reference, BVec4(true, false, false, false), targetSize, renderPos, renderSize);
3797 markUndefined(reference, BVec4(true), targetSize, renderPos, renderSize);
3800 if (attachmentUsed[attachmentIndex] && isStencilAttachment && renderPassInfo.getAttachments()[attachmentIndex].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)
3801 markUndefined(reference, BVec4(false, true, false, false), targetSize, renderPos, renderSize);
3805 void renderReferenceImagesFromValues (vector<tcu::TextureLevel>& referenceImages,
3806 const vector<vector<PixelValue> >& referenceValues,
3807 const UVec2& targetSize,
3808 const RenderPass& renderPassInfo,
3809 const DepthValuesArray& depthValues)
3811 referenceImages.resize(referenceValues.size());
3813 for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
3815 const Attachment attachment = renderPassInfo.getAttachments()[attachmentNdx];
3816 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
3817 const vector<PixelValue>& reference = referenceValues[attachmentNdx];
3818 const bool hasDepth = tcu::hasDepthComponent(format.order);
3819 const bool hasStencil = tcu::hasStencilComponent(format.order);
3820 const bool hasDepthOrStencil = hasDepth || hasStencil;
3821 tcu::TextureLevel& referenceImage = referenceImages[attachmentNdx];
3823 referenceImage.setStorage(format, targetSize.x(), targetSize.y());
3825 if (hasDepthOrStencil)
3829 const PixelBufferAccess depthAccess (tcu::getEffectiveDepthStencilAccess(referenceImage.getAccess(), tcu::Sampler::MODE_DEPTH));
3831 for (deUint32 y = 0; y < targetSize.y(); y++)
3832 for (deUint32 x = 0; x < targetSize.x(); x++)
3834 if (reference[x + y * targetSize.x()].getValue(0))
3836 if (*reference[x + y * targetSize.x()].getValue(0))
3837 depthAccess.setPixDepth(float(depthValues[1]) / 255.0f, x, y);
3839 depthAccess.setPixDepth(float(depthValues[0]) / 255.0f, x, y);
3841 else // Fill with 3x3 grid
3842 depthAccess.setPixDepth(((x / 3) % 2) == ((y / 3) % 2) ? 0.33f : 0.66f, x, y);
3848 const PixelBufferAccess stencilAccess (tcu::getEffectiveDepthStencilAccess(referenceImage.getAccess(), tcu::Sampler::MODE_STENCIL));
3850 for (deUint32 y = 0; y < targetSize.y(); y++)
3851 for (deUint32 x = 0; x < targetSize.x(); x++)
3853 if (reference[x + y * targetSize.x()].getValue(1))
3855 if (*reference[x + y * targetSize.x()].getValue(1))
3856 stencilAccess.setPixStencil(0xFFu, x, y);
3858 stencilAccess.setPixStencil(0x0u, x, y);
3860 else // Fill with 3x3 grid
3861 stencilAccess.setPixStencil(((x / 3) % 2) == ((y / 3) % 2) ? 85 : 170, x, y);
3867 for (deUint32 y = 0; y < targetSize.y(); y++)
3868 for (deUint32 x = 0; x < targetSize.x(); x++)
3872 for (int compNdx = 0; compNdx < 4; compNdx++)
3874 if (reference[x + y * targetSize.x()].getValue(compNdx))
3876 if (*reference[x + y * targetSize.x()].getValue(compNdx))
3877 color[compNdx] = 1.0f;
3879 color[compNdx] = 0.0f;
3881 else // Fill with 3x3 grid
3882 color[compNdx] = ((compNdx + (x / 3)) % 2) == ((y / 3) % 2) ? 0.33f : 0.66f;
3885 referenceImage.getAccess().setPixel(color, x, y);
3891 bool verifyColorAttachment (const vector<PixelValue>& reference,
3892 const ConstPixelBufferAccess& result,
3893 const PixelBufferAccess& errorImage,
3894 const deBool useFormatCompCount)
3896 const Vec4 red (1.0f, 0.0f, 0.0f, 1.0f);
3897 const Vec4 green (0.0f, 1.0f, 0.0f, 1.0f);
3900 DE_ASSERT(result.getWidth() * result.getHeight() == (int)reference.size());
3901 DE_ASSERT(result.getWidth() == errorImage.getWidth());
3902 DE_ASSERT(result.getHeight() == errorImage.getHeight());
3904 for (int y = 0; y < result.getHeight(); y++)
3905 for (int x = 0; x < result.getWidth(); x++)
3907 const Vec4 resultColor = result.getPixel(x, y);
3908 const PixelValue& referenceValue = reference[x + y * result.getWidth()];
3909 bool pixelOk = true;
3910 const deUint32 componentCount = useFormatCompCount ? (deUint32)tcu::getNumUsedChannels(result.getFormat().order) : 4;
3912 for (deUint32 compNdx = 0; compNdx < componentCount; compNdx++)
3914 const Maybe<bool> maybeValue = referenceValue.getValue(compNdx);
3918 const bool value = *maybeValue;
3920 if ((value && (resultColor[compNdx] != 1.0f))
3921 || (!value && resultColor[compNdx] != 0.0f))
3928 errorImage.setPixel(red, x, y);
3932 errorImage.setPixel(green, x, y);
3938 // Setting the alpha value to 1.0f by default helps visualization when the alpha channel is not used.
3939 const tcu::Vec4 kDefaultColorForLog {0.0f, 0.0f, 0.0f, 1.0f};
3940 const float kTrueComponent = 1.0f;
3941 const float kFalseComponent = 0.5f;
3942 const float kUnsetComponentLow = 0.0f;
3943 const float kUnsetComponentHigh = 0.25f;
3945 std::unique_ptr<tcu::TextureLevel> renderColorImageForLog (const ConstPixelBufferAccess& image, int numChannels)
3947 // Same channel order, but using UNORM_INT8 for the color format.
3948 const auto order = image.getFormat().order;
3949 const tcu::TextureFormat loggableFormat {order, tcu::TextureFormat::UNORM_INT8};
3950 const int width = image.getWidth();
3951 const int height = image.getHeight();
3952 std::unique_ptr<tcu::TextureLevel> result {new tcu::TextureLevel{loggableFormat, width, height}};
3953 auto access = result->getAccess();
3954 tcu::Vec4 outColor = kDefaultColorForLog;
3956 for (int x = 0; x < width; ++x)
3957 for (int y = 0; y < height; ++y)
3959 const auto value = image.getPixel(x, y);
3960 for (int c = 0; c < numChannels; ++c)
3962 if (value[c] == 0.0f)
3963 outColor[c] = kFalseComponent;
3964 else if (value[c] == 1.0f)
3965 outColor[c] = kTrueComponent;
3969 access.setPixel(outColor, x, y);
3975 std::unique_ptr<tcu::TextureLevel> renderColorImageForLog (const vector<PixelValue>& reference, const UVec2& targetSize, int numChannels)
3977 const tcu::TextureFormat loggableFormat {tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8};
3978 const int width = static_cast<int>(targetSize.x());
3979 const int height = static_cast<int>(targetSize.y());
3980 std::unique_ptr<tcu::TextureLevel> result {new tcu::TextureLevel{loggableFormat, width, height}};
3981 auto access = result->getAccess();
3982 tcu::Vec4 outColor = kDefaultColorForLog;
3984 for (int x = 0; x < width; ++x)
3985 for (int y = 0; y < height; ++y)
3987 const int index = x + y * width;
3988 for (int c = 0; c < numChannels; ++c)
3990 const auto maybeValue = reference[index].getValue(c);
3992 outColor[c] = ((*maybeValue) ? kTrueComponent : kFalseComponent);
3994 outColor[c] = ((((x / 3) % 2) == ((y / 3) % 2)) ? kUnsetComponentLow : kUnsetComponentHigh);
3996 access.setPixel(outColor, x, y);
4002 bool verifyDepthAttachment (const vector<PixelValue>& reference,
4003 const ConstPixelBufferAccess& result,
4004 const PixelBufferAccess& errorImage,
4005 const DepthValuesArray& depthValues,
4008 const Vec4 red (1.0f, 0.0f, 0.0f, 1.0f);
4009 const Vec4 green (0.0f, 1.0f, 0.0f, 1.0f);
4012 DE_ASSERT(result.getWidth() * result.getHeight() == (int)reference.size());
4013 DE_ASSERT(result.getWidth() == errorImage.getWidth());
4014 DE_ASSERT(result.getHeight() == errorImage.getHeight());
4016 for (int y = 0; y < result.getHeight(); y++)
4017 for (int x = 0; x < result.getWidth(); x++)
4019 bool pixelOk = true;
4021 const float resultDepth = result.getPixDepth(x, y);
4022 const PixelValue& referenceValue = reference[x + y * result.getWidth()];
4023 const Maybe<bool> maybeValue = referenceValue.getValue(0);
4027 const bool value = *maybeValue;
4029 if ((value && !depthsEqual(resultDepth, float(depthValues[1]) / 255.0f, epsilon))
4030 || (!value && !depthsEqual(resultDepth, float(depthValues[0]) / 255.0f, epsilon)))
4036 errorImage.setPixel(red, x, y);
4040 errorImage.setPixel(green, x, y);
4046 bool verifyStencilAttachment (const vector<PixelValue>& reference,
4047 const ConstPixelBufferAccess& result,
4048 const PixelBufferAccess& errorImage)
4050 const Vec4 red (1.0f, 0.0f, 0.0f, 1.0f);
4051 const Vec4 green (0.0f, 1.0f, 0.0f, 1.0f);
4054 DE_ASSERT(result.getWidth() * result.getHeight() == (int)reference.size());
4055 DE_ASSERT(result.getWidth() == errorImage.getWidth());
4056 DE_ASSERT(result.getHeight() == errorImage.getHeight());
4058 for (int y = 0; y < result.getHeight(); y++)
4059 for (int x = 0; x < result.getWidth(); x++)
4061 bool pixelOk = true;
4063 const deUint32 resultStencil = result.getPixStencil(x, y);
4064 const PixelValue& referenceValue = reference[x + y * result.getWidth()];
4065 const Maybe<bool> maybeValue = referenceValue.getValue(1);
4069 const bool value = *maybeValue;
4071 if ((value && (resultStencil != 0xFFu))
4072 || (!value && resultStencil != 0x0u))
4078 errorImage.setPixel(red, x, y);
4082 errorImage.setPixel(green, x, y);
4088 bool logAndVerifyImages (TestLog& log,
4089 const DeviceInterface& vk,
4091 const vector<de::SharedPtr<AttachmentResources> >& attachmentResources,
4092 const vector<bool>& attachmentIsLazy,
4093 const RenderPass& renderPassInfo,
4094 const vector<Maybe<VkClearValue> >& renderPassClearValues,
4095 const vector<Maybe<VkClearValue> >& imageClearValues,
4096 const vector<SubpassRenderInfo>& subpassRenderInfo,
4097 const UVec2& targetSize,
4098 const TestConfig& config)
4100 vector<vector<PixelValue> > referenceValues;
4101 vector<tcu::TextureLevel> referenceAttachments;
4104 log << TestLog::Message << "Reference images fill undefined pixels with 3x3 grid pattern." << TestLog::EndMessage;
4106 renderReferenceValues(referenceValues, renderPassInfo, targetSize, imageClearValues, renderPassClearValues, subpassRenderInfo, config.renderPos, config.renderSize, config.drawStartNdx, config.depthValues);
4107 renderReferenceImagesFromValues(referenceAttachments, referenceValues, targetSize, renderPassInfo, config.depthValues);
4109 for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
4111 if (!attachmentIsLazy[attachmentNdx])
4113 bool attachmentOK = true;
4114 const Attachment attachment = renderPassInfo.getAttachments()[attachmentNdx];
4115 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
4117 if (tcu::hasDepthComponent(format.order) && tcu::hasStencilComponent(format.order))
4119 const tcu::TextureFormat depthFormat = getDepthCopyFormat(attachment.getFormat());
4120 void* const depthPtr = attachmentResources[attachmentNdx]->getResultMemory().getHostPtr();
4122 const tcu::TextureFormat stencilFormat = getStencilCopyFormat(attachment.getFormat());
4123 void* const stencilPtr = attachmentResources[attachmentNdx]->getSecondaryResultMemory().getHostPtr();
4125 invalidateAlloc(vk, device, attachmentResources[attachmentNdx]->getResultMemory());
4126 invalidateAlloc(vk, device, attachmentResources[attachmentNdx]->getSecondaryResultMemory());
4129 bool depthOK = true;
4130 bool stencilOK = true;
4131 const ConstPixelBufferAccess depthAccess (depthFormat, targetSize.x(), targetSize.y(), 1, depthPtr);
4132 const ConstPixelBufferAccess stencilAccess (stencilFormat, targetSize.x(), targetSize.y(), 1, stencilPtr);
4133 tcu::TextureLevel depthErrorImage (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
4134 tcu::TextureLevel stencilErrorImage (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
4136 if (renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE
4137 && !verifyDepthAttachment(referenceValues[attachmentNdx], depthAccess, depthErrorImage.getAccess(), config.depthValues, requiredDepthEpsilon(attachment.getFormat())))
4142 if (renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE
4143 && !verifyStencilAttachment(referenceValues[attachmentNdx], stencilAccess, stencilErrorImage.getAccess()))
4148 if (!depthOK || !stencilOK)
4150 const auto attachmentNdxStr = de::toString(attachmentNdx);
4153 log << TestLog::ImageSet("OutputAttachments" + attachmentNdxStr, "Output depth and stencil attachments " + attachmentNdxStr);
4154 log << TestLog::Image("Attachment" + attachmentNdxStr + "Depth", "Attachment " + attachmentNdxStr + " Depth", depthAccess);
4155 log << TestLog::Image("Attachment" + attachmentNdxStr + "Stencil", "Attachment " + attachmentNdxStr + " Stencil", stencilAccess);
4156 log << TestLog::EndImageSet;
4158 // Reference images. These will be logged as image sets due to having depth and stencil aspects.
4159 log << TestLog::Image("AttachmentReferences" + attachmentNdxStr, "Reference images " + attachmentNdxStr, referenceAttachments[attachmentNdx].getAccess());
4162 log << TestLog::ImageSet("ErrorMasks" + attachmentNdxStr, "Error masks " + attachmentNdxStr);
4164 log << TestLog::Image("DepthAttachmentError" + attachmentNdxStr, "Depth Attachment Error " + attachmentNdxStr, depthErrorImage.getAccess());
4166 log << TestLog::Image("StencilAttachmentError" + attachmentNdxStr, "Stencil Attachment Error " + attachmentNdxStr, stencilErrorImage.getAccess());
4167 log << TestLog::EndImageSet;
4169 attachmentOK = false;
4175 void* const ptr = attachmentResources[attachmentNdx]->getResultMemory().getHostPtr();
4177 invalidateAlloc(vk, device, attachmentResources[attachmentNdx]->getResultMemory());
4179 bool depthOK = true;
4180 bool stencilOK = true;
4181 bool colorOK = true;
4182 const ConstPixelBufferAccess access (format, targetSize.x(), targetSize.y(), 1, ptr);
4183 tcu::TextureLevel errorImage (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
4185 if (tcu::hasDepthComponent(format.order))
4187 if ((renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE || renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE)
4188 && !verifyDepthAttachment(referenceValues[attachmentNdx], access, errorImage.getAccess(), config.depthValues, requiredDepthEpsilon(attachment.getFormat())))
4193 else if (tcu::hasStencilComponent(format.order))
4195 if ((renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE || renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE)
4196 && !verifyStencilAttachment(referenceValues[attachmentNdx], access, errorImage.getAccess()))
4203 if ((renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE || renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE)
4204 && !verifyColorAttachment(referenceValues[attachmentNdx], access, errorImage.getAccess(), config.useFormatCompCount))
4210 if (!depthOK || !stencilOK || !colorOK)
4212 log << TestLog::ImageSet("TestImages", "Output attachment, reference image and error mask");
4213 if (!depthOK || !stencilOK)
4215 // Log without conversions.
4216 log << TestLog::Image("Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx), access);
4217 log << TestLog::Image("AttachmentReference" + de::toString(attachmentNdx), "Attachment reference " + de::toString(attachmentNdx), referenceAttachments[attachmentNdx].getAccess());
4221 // Convert color images to better reflect test status and output in any format.
4222 const auto numChannels = tcu::getNumUsedChannels(access.getFormat().order);
4223 const auto attachmentForLog = renderColorImageForLog(access, numChannels);
4224 const auto referenceForLog = renderColorImageForLog(referenceValues[attachmentNdx], targetSize, numChannels);
4226 log << TestLog::Message << "Check the attachment formats and test data to verify which components affect the test result." << TestLog::EndMessage;
4227 log << TestLog::Message << "In the reference image, unset pixel components are marked with a 3x3 grid storing values 0.0 and 0.25, pixel components set to false are stored as 0.5 and pixel components set to true are stored as 1.0." << TestLog::EndMessage;
4228 log << TestLog::Message << "Output attachment pixel components are always set to 0.5 or 1.0 but may not be taken into account if not set in the reference image." << TestLog::EndMessage;
4230 log << TestLog::Image("Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx), attachmentForLog->getAccess());
4231 log << TestLog::Image("AttachmentReference" + de::toString(attachmentNdx), "Attachment reference " + de::toString(attachmentNdx), referenceForLog->getAccess());
4233 log << TestLog::Image("AttachmentError" + de::toString(attachmentNdx), "Attachment Error " + de::toString(attachmentNdx), errorImage.getAccess());
4234 log << TestLog::EndImageSet;
4236 attachmentOK = false;
4248 std::string getInputAttachmentType (VkFormat vkFormat)
4250 const tcu::TextureFormat format = mapVkFormat(vkFormat);
4251 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type);
4253 switch (channelClass)
4255 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
4256 return "isubpassInput";
4258 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
4259 return "usubpassInput";
4261 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
4262 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
4263 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
4264 return "subpassInput";
4267 DE_FATAL("Unknown channel class");
4272 std::string getAttachmentType (VkFormat vkFormat, deBool useFormatCompCount)
4274 const tcu::TextureFormat format = mapVkFormat(vkFormat);
4275 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type);
4276 const size_t componentCount = (size_t)tcu::getNumUsedChannels(format.order);
4278 switch (channelClass)
4280 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
4281 if (useFormatCompCount)
4282 return (componentCount == 1 ? "int" : "ivec" + de::toString(componentCount));
4286 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
4287 if (useFormatCompCount)
4288 return (componentCount == 1 ? "uint" : "uvec" + de::toString(componentCount));
4292 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
4293 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
4294 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
4295 if (useFormatCompCount)
4296 return (componentCount == 1 ? "float" : "vec" + de::toString(componentCount));
4301 DE_FATAL("Unknown channel class");
4306 void createTestShaders (SourceCollections& dst, TestConfig config)
4308 if (config.renderTypes & TestConfig::RENDERTYPES_DRAW)
4310 const vector<Subpass>& subpasses = config.renderPass.getSubpasses();
4312 for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
4314 const Subpass& subpass = subpasses[subpassNdx];
4315 deUint32 inputAttachmentBinding = 0;
4316 std::ostringstream vertexShader;
4317 std::ostringstream fragmentShader;
4319 vertexShader << "#version 310 es\n"
4320 << "layout(location = 0) in highp vec2 a_position;\n"
4321 << "void main (void) {\n"
4322 << "\tgl_Position = vec4(a_position, 1.0, 1.0);\n"
4325 fragmentShader << "#version 310 es\n"
4326 << "precision highp float;\n";
4328 bool hasAnyDepthFormats = false;
4330 for (size_t attachmentNdx = config.drawStartNdx; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
4332 const deUint32 attachmentIndex = subpass.getInputAttachments()[attachmentNdx].getAttachment();
4333 const VkImageLayout layout = subpass.getInputAttachments()[attachmentNdx].getImageLayout();
4334 const Attachment attachment = config.renderPass.getAttachments()[attachmentIndex];
4335 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
4336 const bool isDepthFormat = tcu::hasDepthComponent(format.order);
4337 const bool isStencilFormat = tcu::hasStencilComponent(format.order);
4339 if (isDepthFormat || isStencilFormat)
4341 if (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
4343 hasAnyDepthFormats = true;
4344 fragmentShader << "layout(input_attachment_index = " << attachmentNdx << ", set=0, binding=" << inputAttachmentBinding << ") uniform highp subpassInput i_depth" << attachmentNdx << ";\n";
4345 inputAttachmentBinding++;
4348 if (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4350 fragmentShader << "layout(input_attachment_index = " << attachmentNdx << ", set=0, binding=" << inputAttachmentBinding << ") uniform highp usubpassInput i_stencil" << attachmentNdx << ";\n";
4351 inputAttachmentBinding++;
4356 const std::string attachmentType = getInputAttachmentType(attachment.getFormat());
4358 fragmentShader << "layout(input_attachment_index = " << attachmentNdx << ", set=0, binding=" << inputAttachmentBinding << ") uniform highp " << attachmentType << " i_color" << attachmentNdx << ";\n";
4359 inputAttachmentBinding++;
4363 for (size_t attachmentNdx = config.drawStartNdx; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
4365 const std::string attachmentType = getAttachmentType(config.renderPass.getAttachments()[getAttachmentNdx(subpass.getColorAttachments(), attachmentNdx)].getFormat(), config.useFormatCompCount);
4366 fragmentShader << "layout(location = " << attachmentNdx << ") out highp " << attachmentType << " o_color" << attachmentNdx << ";\n";
4369 if (hasAnyDepthFormats)
4370 fragmentShader << "\nbool depthsEqual(float a, float b, float epsilon) {\n"
4371 << "\treturn abs(a - b) <= epsilon;\n}\n\n";
4373 fragmentShader << "void main (void) {\n";
4375 if (subpass.getInputAttachments().empty())
4377 for (size_t attachmentNdx = config.drawStartNdx; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
4379 const deUint32 attachmentIndex = subpass.getColorAttachments()[attachmentNdx].getAttachment();
4381 if (attachmentIndex == VK_ATTACHMENT_UNUSED)
4384 const Attachment attachment = config.renderPass.getAttachments()[attachmentIndex];
4385 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
4386 const size_t componentCount = config.useFormatCompCount ? (size_t)tcu::getNumUsedChannels(format.order) : 4;
4387 const std::string attachmentType = getAttachmentType(attachment.getFormat(), config.useFormatCompCount);
4389 fragmentShader << "\to_color" << attachmentNdx << " = " << attachmentType << "(" << attachmentType + "(";
4391 for (size_t compNdx = 0; compNdx < componentCount; compNdx++)
4393 const size_t index = subpassNdx + attachmentIndex + compNdx;
4394 const BoolOp op = boolOpFromIndex(index);
4397 fragmentShader << ",\n\t\t";
4399 fragmentShader << "((int(gl_FragCoord.x) % 2 == " << (index % 2)
4400 << ") " << boolOpToString(op) << " ("
4401 << "int(gl_FragCoord.y) % 2 == " << ((index / 2) % 2)
4402 << ") ? 1.0 : 0.0)";
4405 fragmentShader << "));\n";
4408 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
4409 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
4410 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4412 const size_t index = subpassNdx + 1;
4413 const BoolOp op = boolOpFromIndex(index);
4415 fragmentShader << "\tgl_FragDepth = ((int(gl_FragCoord.x) % 2 == " << (index % 2)
4416 << ") " << boolOpToString(op) << " ("
4417 << "int(gl_FragCoord.y) % 2 == " << ((index / 2) % 2)
4418 << ") ? " << deUint32(config.depthValues[1]) << ".0f/255.0f : " << deUint32(config.depthValues[0]) << ".0f/255.0f);\n";
4423 size_t inputComponentCount = 0;
4424 size_t outputComponentCount = 0;
4426 for (size_t attachmentNdx = config.drawStartNdx; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
4428 const deUint32 attachmentIndex = subpass.getInputAttachments()[attachmentNdx].getAttachment();
4429 const VkImageLayout layout = subpass.getInputAttachments()[attachmentNdx].getImageLayout();
4430 const Attachment attachment = config.renderPass.getAttachments()[attachmentIndex];
4431 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
4432 const size_t componentCount = (size_t)tcu::getNumUsedChannels(format.order);
4434 if (layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4435 inputComponentCount += 1;
4436 else if (layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
4437 inputComponentCount += 1;
4439 inputComponentCount += componentCount;
4442 for (size_t attachmentNdx = config.drawStartNdx; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
4444 const deUint32 attachmentIndex = subpass.getColorAttachments()[attachmentNdx].getAttachment();
4445 const Attachment attachment = config.renderPass.getAttachments()[attachmentIndex];
4446 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
4447 const size_t componentCount = (size_t)tcu::getNumUsedChannels(format.order);
4449 outputComponentCount += componentCount;
4452 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
4453 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
4454 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4456 outputComponentCount++;
4459 if (outputComponentCount > 0)
4461 const size_t inputsPerOutput = inputComponentCount >= outputComponentCount
4462 ? ((inputComponentCount / outputComponentCount)
4463 + ((inputComponentCount % outputComponentCount) != 0 ? 1 : 0))
4466 fragmentShader << "\tbool inputs[" << inputComponentCount << "];\n";
4468 if (outputComponentCount > 0)
4469 fragmentShader << "\tbool outputs[" << outputComponentCount << "];\n";
4471 size_t inputValueNdx = 0;
4473 for (size_t attachmentNdx = config.drawStartNdx; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
4475 const char* const components[] =
4479 const deUint32 attachmentIndex = subpass.getInputAttachments()[attachmentNdx].getAttachment();
4480 const VkImageLayout layout = subpass.getInputAttachments()[attachmentNdx].getImageLayout();
4481 const Attachment attachment = config.renderPass.getAttachments()[attachmentIndex];
4482 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
4483 const size_t componentCount = (size_t)tcu::getNumUsedChannels(format.order);
4484 const bool isDepthFormat = tcu::hasDepthComponent(format.order);
4485 const bool isStencilFormat = tcu::hasStencilComponent(format.order);
4487 if (isDepthFormat || isStencilFormat)
4489 if (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
4491 fragmentShader << "\tinputs[" << inputValueNdx << "] = depthsEqual(" << deUint32(config.depthValues[1]) <<
4492 ".0f/255.0f, float(subpassLoad(i_depth" << attachmentNdx << ").x), " <<
4493 std::fixed << std::setprecision(12) << requiredDepthEpsilon(attachment.getFormat()) << ");\n";
4497 if (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4499 fragmentShader << "\tinputs[" << inputValueNdx << "] = 255u == subpassLoad(i_stencil" << attachmentNdx << ").x;\n";
4505 for (size_t compNdx = 0; compNdx < componentCount; compNdx++)
4507 fragmentShader << "\tinputs[" << inputValueNdx << "] = 1.0 == float(subpassLoad(i_color" << attachmentNdx << ")." << components[compNdx] << ");\n";
4513 size_t outputValueNdx = 0;
4515 for (size_t attachmentNdx = config.drawStartNdx; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
4517 const deUint32 attachmentIndex = subpass.getColorAttachments()[attachmentNdx].getAttachment();
4518 const Attachment attachment = config.renderPass.getAttachments()[attachmentIndex];
4519 const std::string attachmentType = getAttachmentType(config.renderPass.getAttachments()[attachmentIndex].getFormat(), config.useFormatCompCount);
4520 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
4521 const size_t componentCount = (size_t)tcu::getNumUsedChannels(format.order);
4523 for (size_t compNdx = 0; compNdx < componentCount; compNdx++)
4525 const size_t index = subpassNdx + attachmentIndex + outputValueNdx;
4526 const BoolOp op = boolOpFromIndex(index);
4528 fragmentShader << "\toutputs[" << outputValueNdx + compNdx << "] = "
4529 << "(int(gl_FragCoord.x) % 2 == " << (index % 2)
4530 << ") " << boolOpToString(op) << " ("
4531 << "int(gl_FragCoord.y) % 2 == " << ((index / 2) % 2)
4534 for (size_t i = 0; i < inputsPerOutput; i++)
4535 fragmentShader << "\toutputs[" << outputValueNdx + compNdx << "] = outputs[" << outputValueNdx + compNdx << "] == inputs[" << ((outputValueNdx + compNdx) * inputsPerOutput + i) % inputComponentCount << "];\n";
4538 fragmentShader << "\to_color" << attachmentNdx << " = " << attachmentType << "(";
4540 for (size_t compNdx = 0; compNdx < (config.useFormatCompCount ? componentCount : 4); compNdx++)
4543 fragmentShader << ", ";
4545 if (compNdx < componentCount)
4546 fragmentShader << "outputs[" << outputValueNdx + compNdx << "]";
4548 fragmentShader << "0";
4551 outputValueNdx += componentCount;
4553 fragmentShader << ");\n";
4556 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
4557 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
4558 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4560 const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
4561 const size_t index = subpassNdx + attachmentIndex;
4562 const BoolOp op = boolOpFromIndex(index);
4564 fragmentShader << "\toutputs[" << outputValueNdx << "] = "
4565 << "(int(gl_FragCoord.x) % 2 == " << (index % 2)
4566 << ") " << boolOpToString(op) << " ("
4567 << "int(gl_FragCoord.y) % 2 == " << ((index / 2) % 2)
4570 for (size_t i = 0; i < inputsPerOutput; i++)
4571 fragmentShader << "\toutputs[" << outputValueNdx << "] = outputs[" << outputValueNdx << "] == inputs[" << (outputValueNdx * inputsPerOutput + i) % inputComponentCount << "];\n";
4573 fragmentShader << "\tgl_FragDepth = outputs[" << outputValueNdx << "] ? " << deUint32(config.depthValues[1]) << ".0f/255.0f : " << deUint32(config.depthValues[0]) << ".0f/255.0f;\n";
4578 fragmentShader << "}\n";
4580 dst.glslSources.add(de::toString(subpassNdx) + "-vert") << glu::VertexSource(vertexShader.str());
4581 dst.glslSources.add(de::toString(subpassNdx) + "-frag") << glu::FragmentSource(fragmentShader.str());
4586 void initializeAttachmentIsLazy (vector<bool>& attachmentIsLazy, const vector<Attachment>& attachments, TestConfig::ImageMemory imageMemory)
4588 bool lastAttachmentWasLazy = false;
4590 for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
4592 if (attachments[attachmentNdx].getLoadOp() != VK_ATTACHMENT_LOAD_OP_LOAD
4593 && attachments[attachmentNdx].getStoreOp() != VK_ATTACHMENT_STORE_OP_STORE
4594 && attachments[attachmentNdx].getStencilLoadOp() != VK_ATTACHMENT_LOAD_OP_LOAD
4595 && attachments[attachmentNdx].getStencilStoreOp() != VK_ATTACHMENT_STORE_OP_STORE)
4597 if (imageMemory == TestConfig::IMAGEMEMORY_LAZY || (imageMemory & TestConfig::IMAGEMEMORY_LAZY && !lastAttachmentWasLazy))
4599 attachmentIsLazy.push_back(true);
4601 lastAttachmentWasLazy = true;
4603 else if (imageMemory & TestConfig::IMAGEMEMORY_STRICT)
4605 attachmentIsLazy.push_back(false);
4606 lastAttachmentWasLazy = false;
4609 DE_FATAL("Unknown imageMemory");
4612 attachmentIsLazy.push_back(false);
4616 enum AttachmentRefType
4618 ATTACHMENTREFTYPE_COLOR,
4619 ATTACHMENTREFTYPE_DEPTH_STENCIL,
4620 ATTACHMENTREFTYPE_INPUT,
4621 ATTACHMENTREFTYPE_RESOLVE,
4624 VkImageUsageFlags getImageUsageFromLayout (VkImageLayout layout)
4628 case VK_IMAGE_LAYOUT_GENERAL:
4629 case VK_IMAGE_LAYOUT_PREINITIALIZED:
4632 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
4633 return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4635 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
4636 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
4637 return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
4639 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
4640 return VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
4642 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
4643 return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
4645 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
4646 return VK_IMAGE_USAGE_TRANSFER_DST_BIT;
4649 DE_FATAL("Unexpected image layout");
4654 void getImageUsageFromAttachmentReferences(vector<VkImageUsageFlags>& attachmentImageUsage, AttachmentRefType refType, size_t count, const AttachmentReference* references)
4656 for (size_t referenceNdx = 0; referenceNdx < count; ++referenceNdx)
4658 const deUint32 attachment = references[referenceNdx].getAttachment();
4660 if (attachment != VK_ATTACHMENT_UNUSED)
4662 VkImageUsageFlags usage;
4666 case ATTACHMENTREFTYPE_COLOR:
4667 case ATTACHMENTREFTYPE_RESOLVE:
4668 usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4671 case ATTACHMENTREFTYPE_DEPTH_STENCIL:
4672 usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
4675 case ATTACHMENTREFTYPE_INPUT:
4676 usage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
4680 DE_FATAL("Unexpected attachment reference type");
4685 attachmentImageUsage[attachment] |= usage;
4690 void getImageUsageFromAttachmentReferences(vector<VkImageUsageFlags>& attachmentImageUsage, AttachmentRefType refType, const vector<AttachmentReference>& references)
4692 if (!references.empty())
4694 getImageUsageFromAttachmentReferences(attachmentImageUsage, refType, references.size(), &references[0]);
4698 void initializeAttachmentImageUsage (Context &context, vector<VkImageUsageFlags>& attachmentImageUsage, const RenderPass& renderPassInfo, const vector<bool>& attachmentIsLazy, const vector<Maybe<VkClearValue> >& clearValues)
4700 attachmentImageUsage.resize(renderPassInfo.getAttachments().size(), VkImageUsageFlags(0));
4702 for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); ++subpassNdx)
4704 const Subpass& subpass = renderPassInfo.getSubpasses()[subpassNdx];
4706 getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_COLOR, subpass.getColorAttachments());
4707 getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_DEPTH_STENCIL, 1, &subpass.getDepthStencilAttachment());
4708 getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_INPUT, subpass.getInputAttachments());
4709 getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_RESOLVE, subpass.getResolveAttachments());
4712 for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
4714 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentNdx];
4715 const VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), attachment.getFormat());
4716 const VkFormatFeatureFlags supportedFeatures = formatProperties.optimalTilingFeatures;
4718 if ((supportedFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
4719 attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_SAMPLED_BIT;
4721 if ((supportedFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0)
4722 attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_STORAGE_BIT;
4724 attachmentImageUsage[attachmentNdx] |= getImageUsageFromLayout(attachment.getInitialLayout());
4725 attachmentImageUsage[attachmentNdx] |= getImageUsageFromLayout(attachment.getFinalLayout());
4727 if (!attachmentIsLazy[attachmentNdx])
4729 if (clearValues[attachmentNdx])
4730 attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
4732 attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
4736 const VkImageUsageFlags allowedTransientBits = static_cast<VkImageUsageFlags>(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT);
4738 attachmentImageUsage[attachmentNdx] &= allowedTransientBits;
4739 attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
4744 void initializeSubpassIsSecondary (vector<bool>& subpassIsSecondary, const vector<Subpass>& subpasses, TestConfig::CommandBufferTypes commandBuffer)
4746 bool lastSubpassWasSecondary = false;
4748 for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
4750 if (commandBuffer == TestConfig::COMMANDBUFFERTYPES_SECONDARY || (commandBuffer & TestConfig::COMMANDBUFFERTYPES_SECONDARY && !lastSubpassWasSecondary))
4752 subpassIsSecondary.push_back(true);
4753 lastSubpassWasSecondary = true;
4755 else if (commandBuffer & TestConfig::COMMANDBUFFERTYPES_INLINE)
4757 subpassIsSecondary.push_back(false);
4758 lastSubpassWasSecondary = false;
4761 DE_FATAL("Unknown commandBuffer");
4765 void initializeImageClearValues (de::Random& rng, vector<Maybe<VkClearValue> >& clearValues, const vector<Attachment>& attachments, const vector<bool>& isLazy, deBool useFormatCompCount, const DepthValuesArray& depthValues)
4767 for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
4769 if (!isLazy[attachmentNdx])
4770 clearValues.push_back(just(randomClearValue(attachments[attachmentNdx], rng, useFormatCompCount, depthValues)));
4772 clearValues.push_back(tcu::Nothing);
4776 void initializeRenderPassClearValues (de::Random& rng, vector<Maybe<VkClearValue> >& clearValues, const vector<Attachment>& attachments, deBool useFormatCompCount, const DepthValuesArray& depthValues)
4778 for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
4780 if (attachments[attachmentNdx].getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR
4781 || attachments[attachmentNdx].getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
4783 clearValues.push_back(just(randomClearValue(attachments[attachmentNdx], rng, useFormatCompCount, depthValues)));
4786 clearValues.push_back(tcu::Nothing);
4790 void logSubpassRenderInfo (TestLog& log, const SubpassRenderInfo& info, TestConfig config)
4792 log << TestLog::Message << "Viewport, offset: " << info.getViewportOffset() << ", size: " << info.getViewportSize() << TestLog::EndMessage;
4794 if (info.isSecondary())
4795 log << TestLog::Message << "Subpass uses secondary command buffers" << TestLog::EndMessage;
4797 log << TestLog::Message << "Subpass uses inlined commands" << TestLog::EndMessage;
4799 for (deUint32 attachmentNdx = 0; attachmentNdx < info.getColorClears().size(); attachmentNdx++)
4801 const ColorClear& colorClear = info.getColorClears()[attachmentNdx];
4803 log << TestLog::Message << "Clearing color attachment " << attachmentNdx
4804 << ". Offset: " << colorClear.getOffset()
4805 << ", Size: " << colorClear.getSize()
4806 << ", Color: " << clearColorToString(info.getColorAttachment(attachmentNdx).getFormat(), colorClear.getColor(), config.useFormatCompCount) << TestLog::EndMessage;
4809 if (info.getDepthStencilClear())
4811 const DepthStencilClear& depthStencilClear = *info.getDepthStencilClear();
4813 log << TestLog::Message << "Clearing depth stencil attachment"
4814 << ". Offset: " << depthStencilClear.getOffset()
4815 << ", Size: " << depthStencilClear.getSize()
4816 << ", Depth: " << depthStencilClear.getDepth()
4817 << ", Stencil: " << depthStencilClear.getStencil() << TestLog::EndMessage;
4820 if (info.getRenderQuad())
4822 const RenderQuad& renderQuad = *info.getRenderQuad();
4824 log << TestLog::Message << "Rendering grid quad to " << renderQuad.getCornerA() << " -> " << renderQuad.getCornerB() << TestLog::EndMessage;
4828 void logTestCaseInfo (TestLog& log,
4829 const TestConfig& config,
4830 const vector<bool>& attachmentIsLazy,
4831 const vector<Maybe<VkClearValue> >& imageClearValues,
4832 const vector<Maybe<VkClearValue> >& renderPassClearValues,
4833 const vector<SubpassRenderInfo>& subpassRenderInfo)
4835 const RenderPass& renderPass = config.renderPass;
4837 logRenderPassInfo(log, renderPass);
4839 DE_ASSERT(attachmentIsLazy.size() == renderPass.getAttachments().size());
4840 DE_ASSERT(imageClearValues.size() == renderPass.getAttachments().size());
4841 DE_ASSERT(renderPassClearValues.size() == renderPass.getAttachments().size());
4843 log << TestLog::Message << "TargetSize: " << config.targetSize << TestLog::EndMessage;
4844 log << TestLog::Message << "Render area, Offset: " << config.renderPos << ", Size: " << config.renderSize << TestLog::EndMessage;
4846 for (size_t attachmentNdx = 0; attachmentNdx < attachmentIsLazy.size(); attachmentNdx++)
4848 const tcu::ScopedLogSection section (log, "Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx));
4850 if (attachmentIsLazy[attachmentNdx])
4851 log << TestLog::Message << "Is lazy." << TestLog::EndMessage;
4853 if (imageClearValues[attachmentNdx])
4854 log << TestLog::Message << "Image is cleared to " << clearValueToString(renderPass.getAttachments()[attachmentNdx].getFormat(),
4855 *imageClearValues[attachmentNdx], config.useFormatCompCount) << " before rendering." << TestLog::EndMessage;
4857 if (renderPass.getAttachments()[attachmentNdx].getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR && renderPassClearValues[attachmentNdx])
4858 log << TestLog::Message << "Attachment is cleared to " << clearValueToString(renderPass.getAttachments()[attachmentNdx].getFormat(),
4859 *renderPassClearValues[attachmentNdx], config.useFormatCompCount) << " in the beginning of the render pass." << TestLog::EndMessage;
4862 for (size_t subpassNdx = 0; subpassNdx < renderPass.getSubpasses().size(); subpassNdx++)
4864 const tcu::ScopedLogSection section (log, "Subpass" + de::toString(subpassNdx), "Subpass " + de::toString(subpassNdx));
4866 logSubpassRenderInfo(log, subpassRenderInfo[subpassNdx], config);
4870 float roundToViewport (float x, deUint32 offset, deUint32 size)
4872 const float origin = (float)(offset) + ((float(size) / 2.0f));
4873 const float p = (float)(size) / 2.0f;
4874 const deInt32 xi = deRoundFloatToInt32(origin + (p * x));
4876 return (((float)xi) - origin) / p;
4879 void initializeSubpassRenderInfo (vector<SubpassRenderInfo>& renderInfos, de::Random& rng, const RenderPass& renderPass, const TestConfig& config)
4881 const TestConfig::CommandBufferTypes commandBuffer = config.commandBufferTypes;
4882 const vector<Subpass>& subpasses = renderPass.getSubpasses();
4883 bool lastSubpassWasSecondary = false;
4885 for (deUint32 subpassNdx = 0; subpassNdx < (deUint32)subpasses.size(); subpassNdx++)
4887 const Subpass& subpass = subpasses[subpassNdx];
4888 const bool subpassIsSecondary = commandBuffer == TestConfig::COMMANDBUFFERTYPES_SECONDARY
4889 || (commandBuffer & TestConfig::COMMANDBUFFERTYPES_SECONDARY && !lastSubpassWasSecondary) ? true : false;
4890 const bool omitBlendState = subpass.getOmitBlendState();
4891 const UVec2 viewportSize ((config.renderSize * UVec2(2)) / UVec2(3));
4892 const UVec2 viewportOffset (config.renderPos.x() + (subpassNdx % 2) * (config.renderSize.x() / 3),
4893 config.renderPos.y() + ((subpassNdx / 2) % 2) * (config.renderSize.y() / 3));
4895 vector<ColorClear> colorClears;
4896 Maybe<DepthStencilClear> depthStencilClear;
4897 Maybe<RenderQuad> renderQuad;
4899 lastSubpassWasSecondary = subpassIsSecondary;
4901 if (config.renderTypes & TestConfig::RENDERTYPES_CLEAR)
4903 const vector<AttachmentReference>& colorAttachments = subpass.getColorAttachments();
4905 for (size_t attachmentRefNdx = 0; attachmentRefNdx < colorAttachments.size(); attachmentRefNdx++)
4907 const AttachmentReference& attachmentRef = colorAttachments[attachmentRefNdx];
4908 const Attachment& attachment = renderPass.getAttachments()[attachmentRef.getAttachment()];
4909 const UVec2 size ((viewportSize * UVec2(2)) / UVec2(3));
4910 const UVec2 offset (viewportOffset.x() + ((deUint32)attachmentRefNdx % 2u) * (viewportSize.x() / 3u),
4911 viewportOffset.y() + (((deUint32)attachmentRefNdx / 2u) % 2u) * (viewportSize.y() / 3u));
4912 const VkClearColorValue color = randomColorClearValue(attachment, rng, config.useFormatCompCount);
4914 colorClears.push_back(ColorClear(offset, size, color));
4917 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
4919 const Attachment& attachment = renderPass.getAttachments()[subpass.getDepthStencilAttachment().getAttachment()];
4920 const UVec2 size ((viewportSize * UVec2(2)) / UVec2(3));
4921 const UVec2 offset (viewportOffset.x() + ((deUint32)colorAttachments.size() % 2u) * (viewportSize.x() / 3u),
4922 viewportOffset.y() + (((deUint32)colorAttachments.size() / 2u) % 2u) * (viewportSize.y() / 3u));
4923 const VkClearValue value = randomClearValue(attachment, rng, config.useFormatCompCount, config.depthValues);
4925 depthStencilClear = tcu::just(DepthStencilClear(offset, size, value.depthStencil.depth, value.depthStencil.stencil));
4929 if (config.renderTypes & TestConfig::RENDERTYPES_DRAW)
4931 const float w = (subpassNdx % 2) == 0 ? 1.0f : 1.25f;
4932 const float h = (subpassNdx % 2) == 0 ? 1.25f : 1.0f;
4934 const float x0 = roundToViewport((subpassNdx % 2) == 0 ? 1.0f - w : -1.0f, viewportOffset.x(), viewportSize.x());
4935 const float x1 = roundToViewport((subpassNdx % 2) == 0 ? 1.0f : -1.0f + w, viewportOffset.x(), viewportSize.x());
4937 const float y0 = roundToViewport(((subpassNdx / 2) % 2) == 0 ? 1.0f - h : -1.0f, viewportOffset.y(), viewportSize.y());
4938 const float y1 = roundToViewport(((subpassNdx / 2) % 2) == 0 ? 1.0f : -1.0f + h, viewportOffset.y(), viewportSize.y());
4940 renderQuad = tcu::just(RenderQuad(tcu::Vec2(x0, y0), tcu::Vec2(x1, y1)));
4943 renderInfos.push_back(SubpassRenderInfo(renderPass, subpassNdx, config.drawStartNdx, subpassIsSecondary, omitBlendState, viewportOffset, viewportSize, renderQuad, colorClears, depthStencilClear));
4947 void checkTextureFormatSupport (TestLog& log,
4948 const InstanceInterface& vk,
4949 VkPhysicalDevice device,
4950 const vector<Attachment>& attachments)
4952 bool supported = true;
4954 for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
4956 const Attachment& attachment = attachments[attachmentNdx];
4957 const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
4958 const bool isDepthOrStencilAttachment = hasDepthComponent(format.order) || hasStencilComponent(format.order);
4959 const VkFormatFeatureFlags flags = isDepthOrStencilAttachment? VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT : VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
4960 VkFormatProperties properties;
4962 vk.getPhysicalDeviceFormatProperties(device, attachment.getFormat(), &properties);
4964 if ((properties.optimalTilingFeatures & flags) != flags)
4967 log << TestLog::Message << "Format: " << attachment.getFormat() << " not supported as " << (isDepthOrStencilAttachment ? "depth stencil attachment" : "color attachment") << TestLog::EndMessage;
4972 TCU_THROW(NotSupportedError, "Format not supported");
4975 tcu::TestStatus renderPassTest (Context& context, TestConfig config)
4977 const UVec2 targetSize = config.targetSize;
4978 const UVec2 renderPos = config.renderPos;
4979 const UVec2 renderSize = config.renderSize;
4980 const RenderPass& renderPassInfo = config.renderPass;
4982 TestLog& log = context.getTestContext().getLog();
4983 de::Random rng (config.seed);
4985 vector<bool> attachmentIsLazy;
4986 vector<VkImageUsageFlags> attachmentImageUsage;
4987 vector<Maybe<VkClearValue> > imageClearValues;
4988 vector<Maybe<VkClearValue> > renderPassClearValues;
4990 vector<bool> subpassIsSecondary;
4991 vector<SubpassRenderInfo> subpassRenderInfo;
4993 if (config.renderingType == RENDERING_TYPE_RENDERPASS2)
4994 context.requireDeviceFunctionality("VK_KHR_create_renderpass2");
4996 if (config.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING)
4997 context.requireDeviceFunctionality("VK_KHR_dynamic_rendering");
4999 if (config.allocationKind == ALLOCATION_KIND_DEDICATED)
5001 if (!context.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation"))
5002 TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
5005 if (!renderPassInfo.getInputAspects().empty())
5007 if (!context.isDeviceFunctionalitySupported("VK_KHR_maintenance2"))
5008 TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported.");
5012 bool requireDepthStencilLayout = false;
5014 for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
5016 if (renderPassInfo.getAttachments()[attachmentNdx].getInitialLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
5017 || renderPassInfo.getAttachments()[attachmentNdx].getInitialLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
5018 || renderPassInfo.getAttachments()[attachmentNdx].getFinalLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
5019 || renderPassInfo.getAttachments()[attachmentNdx].getFinalLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
5021 requireDepthStencilLayout = true;
5026 for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size() && !requireDepthStencilLayout; subpassNdx++)
5028 const Subpass& subpass (renderPassInfo.getSubpasses()[subpassNdx]);
5030 for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
5032 if (subpass.getColorAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
5033 || subpass.getColorAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
5035 requireDepthStencilLayout = true;
5040 for (size_t attachmentNdx = 0; !requireDepthStencilLayout && attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
5042 if (subpass.getInputAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
5043 || subpass.getInputAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
5045 requireDepthStencilLayout = true;
5050 for (size_t attachmentNdx = 0; !requireDepthStencilLayout && attachmentNdx < subpass.getResolveAttachments().size(); attachmentNdx++)
5052 if (subpass.getResolveAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
5053 || subpass.getResolveAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
5055 requireDepthStencilLayout = true;
5060 if (subpass.getDepthStencilAttachment().getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
5061 || subpass.getDepthStencilAttachment().getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
5063 requireDepthStencilLayout = true;
5068 if (requireDepthStencilLayout && !context.isDeviceFunctionalitySupported("VK_KHR_maintenance2"))
5069 TCU_THROW(NotSupportedError, "VK_KHR_maintenance2 is not supported");
5072 initializeAttachmentIsLazy(attachmentIsLazy, renderPassInfo.getAttachments(), config.imageMemory);
5073 initializeImageClearValues(rng, imageClearValues, renderPassInfo.getAttachments(), attachmentIsLazy, config.useFormatCompCount, config.depthValues);
5074 initializeAttachmentImageUsage(context, attachmentImageUsage, renderPassInfo, attachmentIsLazy, imageClearValues);
5075 initializeRenderPassClearValues(rng, renderPassClearValues, renderPassInfo.getAttachments(), config.useFormatCompCount, config.depthValues);
5077 initializeSubpassIsSecondary(subpassIsSecondary, renderPassInfo.getSubpasses(), config.commandBufferTypes);
5078 initializeSubpassRenderInfo(subpassRenderInfo, rng, renderPassInfo, config);
5080 logTestCaseInfo(log, config, attachmentIsLazy, imageClearValues, renderPassClearValues, subpassRenderInfo);
5082 checkTextureFormatSupport(log, context.getInstanceInterface(), context.getPhysicalDevice(), config.renderPass.getAttachments());
5085 const vk::VkPhysicalDeviceProperties properties = vk::getPhysicalDeviceProperties(context.getInstanceInterface(), context.getPhysicalDevice());
5087 log << TestLog::Message << "Max color attachments: " << properties.limits.maxColorAttachments << TestLog::EndMessage;
5089 for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
5091 if (renderPassInfo.getSubpasses()[subpassNdx].getColorAttachments().size() > (size_t)properties.limits.maxColorAttachments)
5092 TCU_THROW(NotSupportedError, "Subpass uses more than maxColorAttachments.");
5097 const InstanceInterface& vki = context.getInstanceInterface();
5098 const VkPhysicalDevice& physDevice = context.getPhysicalDevice();
5099 const VkDevice device = context.getDevice();
5100 const DeviceInterface& vk = context.getDeviceInterface();
5101 const VkQueue queue = context.getUniversalQueue();
5102 const deUint32 queueIndex = context.getUniversalQueueFamilyIndex();
5103 Allocator& allocator = context.getDefaultAllocator();
5105 const Unique<VkCommandPool> commandBufferPool (createCommandPool(vk, device, 0, queueIndex));
5106 const Unique<VkCommandBuffer> initializeImagesCommandBuffer (allocateCommandBuffer(vk, device, *commandBufferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
5107 const Unique<VkCommandBuffer> renderCommandBuffer (allocateCommandBuffer(vk, device, *commandBufferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
5108 const Unique<VkCommandBuffer> readImagesToBuffersCommandBuffer (allocateCommandBuffer(vk, device, *commandBufferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
5110 vector<de::SharedPtr<AttachmentResources> > attachmentResources;
5111 vector<de::SharedPtr<SubpassRenderer> > subpassRenderers;
5112 vector<VkImage> attachmentImages;
5113 vector<VkImageView> attachmentViews;
5114 vector<pair<VkImageView, VkImageView> > inputAttachmentViews;
5116 Move<VkRenderPass> renderPass;
5117 if (config.renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
5118 renderPass = createRenderPass(vk, device, renderPassInfo, config.renderingType);
5120 for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
5122 const Attachment& attachmentInfo = renderPassInfo.getAttachments()[attachmentNdx];
5124 attachmentResources.push_back(de::SharedPtr<AttachmentResources>(new AttachmentResources(vki, physDevice, vk, device, allocator, queueIndex, targetSize, attachmentInfo, attachmentImageUsage[attachmentNdx], config.allocationKind)));
5125 attachmentViews.push_back(attachmentResources[attachmentNdx]->getAttachmentView());
5126 attachmentImages.push_back(attachmentResources[attachmentNdx]->getImage());
5128 inputAttachmentViews.push_back(attachmentResources[attachmentNdx]->getInputAttachmentViews());
5131 beginCommandBuffer(vk, *initializeImagesCommandBuffer, (VkCommandBufferUsageFlags)0, DE_NULL, 0, DE_NULL, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
5132 pushImageInitializationCommands(vk, *initializeImagesCommandBuffer, renderPassInfo.getAttachments(), attachmentResources, queueIndex, imageClearValues);
5133 endCommandBuffer(vk, *initializeImagesCommandBuffer);
5136 Move<VkFramebuffer> framebuffer;
5137 if (config.renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
5138 framebuffer = createFramebuffer(vk, device, *renderPass, targetSize, attachmentViews);
5140 for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
5141 subpassRenderers.push_back(de::SharedPtr<SubpassRenderer>(new SubpassRenderer(context, vk, device, allocator, *renderPass, *framebuffer, *commandBufferPool, queueIndex, attachmentImages, inputAttachmentViews, subpassRenderInfo[subpassNdx], config.renderPass.getAttachments(), config.allocationKind, config.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING)));
5143 beginCommandBuffer(vk, *renderCommandBuffer, (VkCommandBufferUsageFlags)0, DE_NULL, 0, DE_NULL, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
5144 pushRenderPassCommands(vk, *renderCommandBuffer, *renderPass, renderPassInfo, attachmentResources, *framebuffer, subpassRenderers, renderPos, renderSize, renderPassClearValues, queueIndex, config.renderTypes, config.renderingType);
5145 endCommandBuffer(vk, *renderCommandBuffer);
5147 beginCommandBuffer(vk, *readImagesToBuffersCommandBuffer, (VkCommandBufferUsageFlags)0, DE_NULL, 0, DE_NULL, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
5148 pushReadImagesToBuffers(vk, *readImagesToBuffersCommandBuffer, queueIndex, attachmentResources, renderPassInfo.getAttachments(), attachmentIsLazy, targetSize);
5149 endCommandBuffer(vk, *readImagesToBuffersCommandBuffer);
5151 const VkCommandBuffer commandBuffers[] =
5153 *initializeImagesCommandBuffer,
5154 *renderCommandBuffer,
5155 *readImagesToBuffersCommandBuffer
5157 const Unique<VkFence> fence (createFence(vk, device, 0u));
5159 queueSubmit(vk, queue, DE_LENGTH_OF_ARRAY(commandBuffers), commandBuffers, *fence);
5160 waitForFences(vk, device, 1, &fence.get(), VK_TRUE, ~0ull);
5164 if (logAndVerifyImages(log, vk, device, attachmentResources, attachmentIsLazy, renderPassInfo, renderPassClearValues, imageClearValues, subpassRenderInfo, targetSize, config))
5165 return tcu::TestStatus::pass("Pass");
5167 return tcu::TestStatus::fail("Result verification failed");
5171 static const VkFormat s_coreColorFormats[] =
5173 VK_FORMAT_R5G6B5_UNORM_PACK16,
5178 VK_FORMAT_R8G8_UNORM,
5179 VK_FORMAT_R8G8_SNORM,
5180 VK_FORMAT_R8G8_UINT,
5181 VK_FORMAT_R8G8_SINT,
5182 VK_FORMAT_R8G8B8A8_UNORM,
5183 VK_FORMAT_R8G8B8A8_SNORM,
5184 VK_FORMAT_R8G8B8A8_UINT,
5185 VK_FORMAT_R8G8B8A8_SINT,
5186 VK_FORMAT_R8G8B8A8_SRGB,
5187 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
5188 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
5189 VK_FORMAT_A8B8G8R8_UINT_PACK32,
5190 VK_FORMAT_A8B8G8R8_SINT_PACK32,
5191 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
5192 VK_FORMAT_B8G8R8A8_UNORM,
5193 VK_FORMAT_B8G8R8A8_SRGB,
5194 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
5195 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
5196 VK_FORMAT_A2B10G10R10_UINT_PACK32,
5197 VK_FORMAT_R16_UNORM,
5198 VK_FORMAT_R16_SNORM,
5201 VK_FORMAT_R16_SFLOAT,
5202 VK_FORMAT_R16G16_UNORM,
5203 VK_FORMAT_R16G16_SNORM,
5204 VK_FORMAT_R16G16_UINT,
5205 VK_FORMAT_R16G16_SINT,
5206 VK_FORMAT_R16G16_SFLOAT,
5207 VK_FORMAT_R16G16B16A16_UNORM,
5208 VK_FORMAT_R16G16B16A16_SNORM,
5209 VK_FORMAT_R16G16B16A16_UINT,
5210 VK_FORMAT_R16G16B16A16_SINT,
5211 VK_FORMAT_R16G16B16A16_SFLOAT,
5214 VK_FORMAT_R32_SFLOAT,
5215 VK_FORMAT_R32G32_UINT,
5216 VK_FORMAT_R32G32_SINT,
5217 VK_FORMAT_R32G32_SFLOAT,
5218 VK_FORMAT_R32G32B32A32_UINT,
5219 VK_FORMAT_R32G32B32A32_SINT,
5220 VK_FORMAT_R32G32B32A32_SFLOAT
5223 static const VkFormat s_coreDepthStencilFormats[] =
5225 VK_FORMAT_D16_UNORM,
5227 VK_FORMAT_X8_D24_UNORM_PACK32,
5228 VK_FORMAT_D32_SFLOAT,
5230 VK_FORMAT_D24_UNORM_S8_UINT,
5231 VK_FORMAT_D32_SFLOAT_S8_UINT
5234 void addAttachmentTests (tcu::TestCaseGroup* group, const TestConfigExternal testConfigExternal)
5236 const deUint32 attachmentCounts[] = { 1, 3, 4, 8 };
5237 const VkAttachmentLoadOp loadOps[] =
5239 VK_ATTACHMENT_LOAD_OP_LOAD,
5240 VK_ATTACHMENT_LOAD_OP_CLEAR,
5241 VK_ATTACHMENT_LOAD_OP_DONT_CARE
5244 const VkAttachmentStoreOp storeOps[] =
5246 VK_ATTACHMENT_STORE_OP_STORE,
5247 VK_ATTACHMENT_STORE_OP_DONT_CARE
5250 const VkImageLayout initialAndFinalColorLayouts[] =
5252 VK_IMAGE_LAYOUT_GENERAL,
5253 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5254 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
5255 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
5256 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
5259 const VkImageLayout initialAndFinalColorLayoutsLazy[] =
5261 VK_IMAGE_LAYOUT_GENERAL,
5262 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5263 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
5266 const VkImageLayout initialAndFinalDepthStencilLayouts[] =
5268 VK_IMAGE_LAYOUT_GENERAL,
5269 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5270 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
5271 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
5272 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
5273 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
5276 const VkImageLayout initialAndFinalDepthStencilLayoutsLazy[] =
5278 VK_IMAGE_LAYOUT_GENERAL,
5279 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5280 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
5281 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
5284 const VkImageLayout subpassLayouts[] =
5286 VK_IMAGE_LAYOUT_GENERAL,
5287 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
5290 const VkImageLayout depthStencilLayouts[] =
5292 VK_IMAGE_LAYOUT_GENERAL,
5293 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
5296 const TestConfig::RenderTypes renderCommands[] =
5298 TestConfig::RENDERTYPES_NONE,
5299 TestConfig::RENDERTYPES_CLEAR,
5300 TestConfig::RENDERTYPES_DRAW,
5301 TestConfig::RENDERTYPES_CLEAR|TestConfig::RENDERTYPES_DRAW,
5304 const TestConfig::CommandBufferTypes commandBuffers[] =
5306 TestConfig::COMMANDBUFFERTYPES_INLINE,
5307 TestConfig::COMMANDBUFFERTYPES_SECONDARY,
5308 TestConfig::COMMANDBUFFERTYPES_INLINE|TestConfig::COMMANDBUFFERTYPES_SECONDARY
5311 const TestConfig::ImageMemory imageMemories[] =
5313 TestConfig::IMAGEMEMORY_STRICT,
5314 TestConfig::IMAGEMEMORY_LAZY,
5315 TestConfig::IMAGEMEMORY_STRICT|TestConfig::IMAGEMEMORY_LAZY
5318 const UVec2 targetSizes[] =
5324 const UVec2 renderPositions[] =
5330 const UVec2 renderSizes[] =
5336 tcu::TestContext& testCtx (group->getTestContext());
5337 bool useDynamicRendering (testConfigExternal.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING);
5338 de::Random rng (1433774382u);
5340 for (size_t attachmentCountNdx = 0; attachmentCountNdx < DE_LENGTH_OF_ARRAY(attachmentCounts); attachmentCountNdx++)
5342 const deUint32 attachmentCount = attachmentCounts[attachmentCountNdx];
5343 const deUint32 testCaseCount = (attachmentCount == 1 ? 100 : 200);
5344 de::MovePtr<tcu::TestCaseGroup> attachmentCountGroup (new tcu::TestCaseGroup(testCtx, de::toString(attachmentCount).c_str(), de::toString(attachmentCount).c_str()));
5346 for (size_t testCaseNdx = 0; testCaseNdx < testCaseCount; testCaseNdx++)
5348 const bool useDepthStencil = rng.getBool();
5349 const TestConfig::ImageMemory imageMemory = rng.choose<TestConfig::ImageMemory>(DE_ARRAY_BEGIN(imageMemories), DE_ARRAY_END(imageMemories));
5350 VkImageLayout depthStencilLayout = VK_IMAGE_LAYOUT_GENERAL;
5351 vector<Attachment> attachments;
5352 vector<AttachmentReference> colorAttachmentReferences;
5354 // we want to make sure that dynamic rendering test cases have corresponding renderpass
5355 // cases as this will allow drivers to easily compare GPU batches; since configurations
5356 // for those tests are generated we need to generate configurations for all cases
5357 // even when we know earlier that for dynamic rendering we will skip it
5358 bool executeForDynamicRendering = true;
5360 for (size_t attachmentNdx = 0; attachmentNdx < attachmentCount; attachmentNdx++)
5362 const VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
5363 const VkFormat format = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreColorFormats), DE_ARRAY_END(s_coreColorFormats));
5364 const VkAttachmentLoadOp loadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
5365 const VkAttachmentStoreOp storeOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
5367 const VkImageLayout initialLayout = (imageMemory == TestConfig::IMAGEMEMORY_STRICT)
5368 ? rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts))
5369 : rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayoutsLazy), DE_ARRAY_END(initialAndFinalColorLayoutsLazy));
5370 VkImageLayout finalizeLayout = (imageMemory == TestConfig::IMAGEMEMORY_STRICT)
5371 ? rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts))
5372 : rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayoutsLazy), DE_ARRAY_END(initialAndFinalColorLayoutsLazy));
5373 const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
5375 const VkAttachmentLoadOp stencilLoadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
5376 const VkAttachmentStoreOp stencilStoreOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
5378 if (useDynamicRendering)
5380 // with renderpass we can have automatic layout transitions; to do the same with dynamic rendering cases
5381 // we would need to add addtional barries but since those tests won't add coverage we are skipping them
5382 if ((initialLayout == VK_IMAGE_LAYOUT_GENERAL) ||
5383 (initialLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL))
5384 finalizeLayout = initialLayout;
5386 executeForDynamicRendering = false;
5389 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
5390 colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
5393 if (useDepthStencil)
5395 const VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
5396 const VkFormat format = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreDepthStencilFormats), DE_ARRAY_END(s_coreDepthStencilFormats));
5397 const VkAttachmentLoadOp loadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
5398 const VkAttachmentStoreOp storeOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
5400 const VkImageLayout initialLayout = (imageMemory == TestConfig::IMAGEMEMORY_STRICT)
5401 ? rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts))
5402 : rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayoutsLazy), DE_ARRAY_END(initialAndFinalDepthStencilLayoutsLazy));
5403 VkImageLayout finalizeLayout = (imageMemory == TestConfig::IMAGEMEMORY_STRICT)
5404 ? rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts))
5405 : rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayoutsLazy), DE_ARRAY_END(initialAndFinalDepthStencilLayoutsLazy));
5407 const VkAttachmentLoadOp stencilLoadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
5408 const VkAttachmentStoreOp stencilStoreOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
5410 if (useDynamicRendering)
5412 if ((initialLayout == VK_IMAGE_LAYOUT_GENERAL) ||
5413 (initialLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) ||
5414 (initialLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL))
5415 finalizeLayout = initialLayout;
5417 executeForDynamicRendering = false;
5420 depthStencilLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(depthStencilLayouts), DE_ARRAY_END(depthStencilLayouts));
5421 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
5425 const TestConfig::RenderTypes render = rng.choose<TestConfig::RenderTypes>(DE_ARRAY_BEGIN(renderCommands), DE_ARRAY_END(renderCommands));
5426 const TestConfig::CommandBufferTypes commandBuffer = rng.choose<TestConfig::CommandBufferTypes>(DE_ARRAY_BEGIN(commandBuffers), DE_ARRAY_END(commandBuffers));
5427 const vector<Subpass> subpasses (1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector<AttachmentReference>(), colorAttachmentReferences, vector<AttachmentReference>(), AttachmentReference((useDepthStencil ? (deUint32)(attachments.size() - 1) : VK_ATTACHMENT_UNUSED), depthStencilLayout), vector<deUint32>()));
5428 const vector<SubpassDependency> deps;
5429 const string testCaseName = de::toString(attachmentCountNdx * testCaseCount + testCaseNdx);
5430 const RenderPass renderPass (attachments, subpasses, deps);
5431 const UVec2 targetSize = rng.choose<UVec2>(DE_ARRAY_BEGIN(targetSizes), DE_ARRAY_END(targetSizes));
5432 const UVec2 renderPos = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderPositions), DE_ARRAY_END(renderPositions));
5433 const UVec2 renderSize = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderSizes), DE_ARRAY_END(renderSizes));
5435 // skip dynamic rendering cases (that don't add coverage)
5436 // this can be done not earlier than after grabbing all random numbers as
5437 // we need to make sure that those tests that will be created for dynamic
5438 // rendering have corresponding renderpass tests with the same name
5439 if (useDynamicRendering && !executeForDynamicRendering)
5442 const TestConfig testConfig (renderPass,
5452 testConfigExternal.allocationKind,
5453 testConfigExternal.renderingType);
5455 addFunctionCaseWithPrograms<TestConfig>(attachmentCountGroup.get(), testCaseName.c_str(), testCaseName.c_str(), createTestShaders, renderPassTest, testConfig);
5459 group->addChild(attachmentCountGroup.release());
5463 void addAttachmentWriteMaskTests (tcu::TestCaseGroup* group, const TestConfigExternal testConfigExternal)
5465 const deUint32 attachmentCounts[] = { 1, 2, 3, 4, 8 };
5467 const VkFormat attachmentFormats[] =
5469 VK_FORMAT_R8G8B8A8_UINT,
5470 VK_FORMAT_R8G8B8A8_UNORM,
5471 VK_FORMAT_R5G6B5_UNORM_PACK16,
5472 VK_FORMAT_R8G8_UNORM
5475 tcu::TestContext& testCtx = group->getTestContext();
5477 for (deUint32 attachmentCountNdx = 0; attachmentCountNdx < DE_LENGTH_OF_ARRAY(attachmentCounts); attachmentCountNdx++)
5479 const deUint32 attachmentCount = attachmentCounts[attachmentCountNdx];
5480 const string groupName = "attachment_count_" + de::toString(attachmentCount);
5482 de::MovePtr<tcu::TestCaseGroup> attachmentCountGroup(new tcu::TestCaseGroup(testCtx, groupName.c_str(), de::toString(attachmentCount).c_str()));
5484 for (deUint32 drawStartNdx = 0; drawStartNdx < (attachmentCount); drawStartNdx++)
5486 deUint32 formatNdx = 0;
5487 vector<Attachment> attachments;
5488 vector<AttachmentReference> colorAttachmentReferences;
5490 for (deUint32 attachmentNdx = 0; attachmentNdx < attachmentCount; attachmentNdx++)
5492 const VkFormat format = attachmentFormats[formatNdx];
5493 const VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
5494 const VkAttachmentLoadOp loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
5495 const VkAttachmentStoreOp storeOp = VK_ATTACHMENT_STORE_OP_STORE;
5496 const VkAttachmentLoadOp stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
5497 const VkAttachmentStoreOp stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
5498 const VkImageLayout initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
5499 const VkImageLayout finalizeLayout = (testConfigExternal.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING)
5500 ? initialLayout : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
5501 const VkImageLayout subpassLayout = VK_IMAGE_LAYOUT_GENERAL;
5503 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
5504 colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
5506 if (++formatNdx == DE_LENGTH_OF_ARRAY(attachmentFormats))
5511 const VkImageLayout depthStencilLayout = VK_IMAGE_LAYOUT_GENERAL;
5512 const vector<Subpass> subpass (1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector<AttachmentReference>(), colorAttachmentReferences, vector<AttachmentReference>(), AttachmentReference(VK_ATTACHMENT_UNUSED, depthStencilLayout), vector<deUint32>()));
5513 const vector<SubpassDependency> deps;
5515 const string testCaseName = "start_index_" + de::toString(drawStartNdx);
5516 const RenderPass renderPass (attachments, subpass, deps);
5518 const TestConfig::RenderTypes render = TestConfig::RENDERTYPES_DRAW;
5519 const TestConfig::CommandBufferTypes commandBuffer = TestConfig::COMMANDBUFFERTYPES_INLINE;
5520 const TestConfig::ImageMemory imageMemory = TestConfig::IMAGEMEMORY_LAZY;
5521 const UVec2 targetSize = UVec2(64, 64);
5522 const UVec2 renderPos = UVec2(0, 0);
5523 const UVec2 renderSize = UVec2(64, 64);
5524 const deBool useFormatCompCount = DE_TRUE;
5525 const vector<DeviceCoreFeature> requiredFeatures = {DEVICE_CORE_FEATURE_INDEPENDENT_BLEND};
5526 const TestConfig testConfig (renderPass,
5536 testConfigExternal.allocationKind,
5537 testConfigExternal.renderingType,
5540 addFunctionCaseWithPrograms<TestConfig>(attachmentCountGroup.get(), testCaseName.c_str(), testCaseName.c_str(), checkSupport, createTestShaders, renderPassTest, testConfig);
5544 group->addChild(attachmentCountGroup.release());
5548 template<typename T>
5549 T chooseRandom (de::Random& rng, const set<T>& values)
5551 size_t ndx = ((size_t)rng.getUint32()) % values.size();
5552 typename set<T>::const_iterator iter = values.begin();
5554 for (; ndx > 0; ndx--)
5560 void addAttachmentAllocationTests (tcu::TestCaseGroup* group, const TestConfigExternal testConfigExternal)
5562 const deUint32 attachmentCounts[] = { 4, 8 };
5563 const VkAttachmentLoadOp loadOps[] =
5565 VK_ATTACHMENT_LOAD_OP_LOAD,
5566 VK_ATTACHMENT_LOAD_OP_CLEAR,
5567 VK_ATTACHMENT_LOAD_OP_DONT_CARE
5570 const VkAttachmentStoreOp storeOps[] =
5572 VK_ATTACHMENT_STORE_OP_STORE,
5573 VK_ATTACHMENT_STORE_OP_DONT_CARE
5576 const VkImageLayout initialAndFinalColorLayouts[] =
5578 VK_IMAGE_LAYOUT_GENERAL,
5579 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5580 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
5581 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
5582 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
5585 const VkImageLayout initialAndFinalDepthStencilLayouts[] =
5587 VK_IMAGE_LAYOUT_GENERAL,
5588 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5589 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
5590 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
5591 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
5592 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
5595 const VkImageLayout subpassLayoutsColor[] =
5597 VK_IMAGE_LAYOUT_GENERAL,
5598 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
5601 const VkImageLayout subpassLayoutsDepthStencil[] =
5603 VK_IMAGE_LAYOUT_GENERAL,
5604 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
5607 const VkImageLayout subpassLayoutsInput[] =
5609 VK_IMAGE_LAYOUT_GENERAL,
5610 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
5615 // Each pass uses one more attachmen than previous one
5616 ALLOCATIONTYPE_GROW,
5617 // Each pass uses one less attachment than previous one
5618 ALLOCATIONTYPE_SHRINK,
5619 // Each pass drops one attachment and picks up new one
5620 ALLOCATIONTYPE_ROLL,
5621 // Start by growing and end by shrinking
5622 ALLOCATIONTYPE_GROW_SHRINK,
5623 // Each subpass has single input and single output attachment
5624 ALLOCATIONTYPE_IO_CHAIN,
5625 // Each subpass has multiple inputs and multiple outputs attachment
5626 ALLOCATIONTYPE_IO_GENERIC
5629 const AllocationType allocationTypes[] =
5631 ALLOCATIONTYPE_GROW,
5632 ALLOCATIONTYPE_SHRINK,
5633 ALLOCATIONTYPE_ROLL,
5634 ALLOCATIONTYPE_GROW_SHRINK,
5635 ALLOCATIONTYPE_IO_CHAIN,
5636 ALLOCATIONTYPE_IO_GENERIC
5639 const char* const allocationTypeStr[] =
5645 "input_output_chain",
5649 const TestConfig::RenderTypes renderCommands[] =
5651 TestConfig::RENDERTYPES_NONE,
5652 TestConfig::RENDERTYPES_CLEAR,
5653 TestConfig::RENDERTYPES_DRAW,
5654 TestConfig::RENDERTYPES_CLEAR|TestConfig::RENDERTYPES_DRAW,
5657 const TestConfig::CommandBufferTypes commandBuffers[] =
5659 TestConfig::COMMANDBUFFERTYPES_INLINE,
5660 TestConfig::COMMANDBUFFERTYPES_SECONDARY,
5661 TestConfig::COMMANDBUFFERTYPES_INLINE|TestConfig::COMMANDBUFFERTYPES_SECONDARY
5664 const TestConfig::ImageMemory imageMemories[] =
5666 TestConfig::IMAGEMEMORY_STRICT,
5667 TestConfig::IMAGEMEMORY_LAZY,
5668 TestConfig::IMAGEMEMORY_STRICT|TestConfig::IMAGEMEMORY_LAZY
5671 const UVec2 targetSizes[] =
5677 const UVec2 renderPositions[] =
5683 const UVec2 renderSizes[] =
5689 tcu::TestContext& testCtx = group->getTestContext();
5690 de::Random rng (3700649827u);
5692 for (size_t allocationTypeNdx = 0; allocationTypeNdx < DE_LENGTH_OF_ARRAY(allocationTypes); allocationTypeNdx++)
5694 const AllocationType allocationType = allocationTypes[allocationTypeNdx];
5695 const size_t testCaseCount = 100;
5696 de::MovePtr<tcu::TestCaseGroup> allocationTypeGroup (new tcu::TestCaseGroup(testCtx, allocationTypeStr[allocationTypeNdx], allocationTypeStr[allocationTypeNdx]));
5698 for (size_t testCaseNdx = 0; testCaseNdx < testCaseCount; testCaseNdx++)
5700 if (allocationType == ALLOCATIONTYPE_IO_GENERIC)
5702 const deUint32 attachmentCount = 4u + rng.getUint32() % 31u;
5703 const deUint32 subpassCount = 4u + rng.getUint32() % 31u;
5704 vector<Attachment> attachments;
5706 set<deUint32> definedAttachments;
5708 vector<Subpass> subpasses;
5709 set<deUint32> colorAttachments;
5710 set<deUint32> depthStencilAttachments;
5712 for (deUint32 attachmentIndex = 0; attachmentIndex < attachmentCount; attachmentIndex++)
5714 const bool isDepthStencilAttachment = rng.getFloat() < 0.01f;
5715 const VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
5716 const VkAttachmentLoadOp loadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
5717 const VkAttachmentStoreOp storeOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
5719 const VkImageLayout initialLayout = isDepthStencilAttachment
5720 ? rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts))
5721 : rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
5722 const VkImageLayout finalizeLayout = isDepthStencilAttachment
5723 ? rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts))
5724 : rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
5726 const VkAttachmentLoadOp stencilLoadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
5727 const VkAttachmentStoreOp stencilStoreOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
5729 if (isDepthStencilAttachment)
5731 const VkFormat format = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreDepthStencilFormats), DE_ARRAY_END(s_coreDepthStencilFormats));
5733 if (loadOp == VK_ATTACHMENT_LOAD_OP_LOAD || loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR
5734 || stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD || stencilLoadOp == VK_ATTACHMENT_LOAD_OP_CLEAR)
5735 definedAttachments.insert(attachmentIndex);
5737 depthStencilAttachments.insert(attachmentIndex);
5739 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
5743 const VkFormat format = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreColorFormats), DE_ARRAY_END(s_coreColorFormats));
5745 if (loadOp == VK_ATTACHMENT_LOAD_OP_LOAD || loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR)
5746 definedAttachments.insert(attachmentIndex);
5748 colorAttachments.insert(attachmentIndex);
5750 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
5753 vector<Maybe<deUint32> > lastUseOfAttachment (attachments.size(), tcu::Nothing);
5754 vector<SubpassDependency> deps;
5756 for (deUint32 subpassIndex = 0; subpassIndex < subpassCount; subpassIndex++)
5758 const deUint32 colorAttachmentCount = depthStencilAttachments.empty()
5759 ? 1 + rng.getUint32() % de::min(4u, (deUint32)colorAttachments.size())
5760 : rng.getUint32() % (de::min(4u, (deUint32)colorAttachments.size()) + 1u);
5761 const deUint32 inputAttachmentCount = rng.getUint32() % (deUint32)(de::min<size_t>(4, definedAttachments.size()) + 1);
5762 const bool useDepthStencilAttachment = !depthStencilAttachments.empty() && (colorAttachmentCount == 0 || rng.getBool());
5763 std::vector<deUint32> subpassColorAttachments (colorAttachmentCount);
5764 std::vector<deUint32> subpassInputAttachments (inputAttachmentCount);
5765 Maybe<deUint32> depthStencilAttachment (useDepthStencilAttachment
5766 ? just(chooseRandom(rng, depthStencilAttachments))
5768 std::vector<deUint32> subpassPreserveAttachments;
5770 rng.choose(colorAttachments.begin(), colorAttachments.end(), subpassColorAttachments.begin(), colorAttachmentCount);
5771 rng.choose(definedAttachments.begin(), definedAttachments.end(), subpassInputAttachments.begin(), inputAttachmentCount);
5773 for (size_t colorAttachmentNdx = 0; colorAttachmentNdx < subpassColorAttachments.size(); colorAttachmentNdx++)
5774 definedAttachments.insert(subpassColorAttachments[colorAttachmentNdx]);
5776 if (depthStencilAttachment)
5777 definedAttachments.insert(*depthStencilAttachment);
5780 std::vector<AttachmentReference> inputAttachmentReferences;
5781 std::vector<AttachmentReference> colorAttachmentReferences;
5782 AttachmentReference depthStencilAttachmentReference (VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL);
5784 for (size_t colorAttachmentNdx = 0; colorAttachmentNdx < subpassColorAttachments.size(); colorAttachmentNdx++)
5786 const deUint32 colorAttachmentIndex = subpassColorAttachments[colorAttachmentNdx];
5788 if (lastUseOfAttachment[colorAttachmentIndex])
5790 deBool foundDuplicate = false;
5792 const deUint32 srcPass = *lastUseOfAttachment[colorAttachmentIndex];
5793 const deUint32 dstPass = subpassIndex;
5794 const VkDependencyFlags dependencyFlags = rng.getBool() ? (VkDependencyFlags) VK_DEPENDENCY_BY_REGION_BIT : 0u;
5796 const SubpassDependency newDependency(srcPass, dstPass,
5797 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5798 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5799 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5800 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5802 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5803 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5804 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5805 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5807 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
5808 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
5812 for (SubpassDependency& dependency : deps)
5814 if (dependency.getSrcPass() == srcPass && dependency.getDstPass() == dstPass)
5816 const VkAccessFlags newDstFlags = dependency.getDstAccessMask() | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
5817 dependency.setDstAccessMask(newDstFlags);
5818 foundDuplicate = true;
5823 if (!foundDuplicate)
5825 deps.push_back(newDependency);
5829 lastUseOfAttachment[colorAttachmentIndex] = just(subpassIndex);
5831 colorAttachmentReferences.push_back(AttachmentReference((deUint32)subpassColorAttachments[colorAttachmentNdx], VK_IMAGE_LAYOUT_GENERAL));
5834 for (size_t inputAttachmentNdx = 0; inputAttachmentNdx < subpassInputAttachments.size(); inputAttachmentNdx++)
5836 const deUint32 inputAttachmentIndex = subpassInputAttachments[inputAttachmentNdx];
5838 if(lastUseOfAttachment[inputAttachmentIndex])
5840 deBool foundDuplicate = false;
5842 const deUint32 srcPass = *lastUseOfAttachment[inputAttachmentIndex];
5843 const deUint32 dstPass = subpassIndex;
5844 const VkDependencyFlags dependencyFlags = ((srcPass == subpassIndex) || rng.getBool()) ? (VkDependencyFlags)VK_DEPENDENCY_BY_REGION_BIT : 0u;
5846 const SubpassDependency newDependency(srcPass, dstPass,
5847 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5848 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5849 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5850 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5852 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5853 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5854 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5855 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5857 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
5858 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
5861 for (SubpassDependency& dependency : deps)
5863 if (dependency.getSrcPass() == srcPass && dependency.getDstPass() == dstPass)
5865 const VkAccessFlags newSrcFlags = dependency.getSrcAccessMask() | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
5866 const VkAccessFlags newDstFlags = dependency.getDstAccessMask() | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
5867 dependency.setDstAccessMask(newSrcFlags);
5868 dependency.setDstAccessMask(newDstFlags);
5869 foundDuplicate = true;
5874 if (!foundDuplicate)
5876 deps.push_back(newDependency);
5879 lastUseOfAttachment[inputAttachmentIndex] = just(subpassIndex);
5881 VkImageAspectFlags aspect = 0u;
5882 if (testConfigExternal.renderingType == RENDERING_TYPE_RENDERPASS2)
5884 bool col = colorAttachments.find(inputAttachmentIndex) != colorAttachments.end();
5885 aspect = col ? VK_IMAGE_ASPECT_COLOR_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
5887 inputAttachmentReferences.push_back(AttachmentReference((deUint32)subpassInputAttachments[inputAttachmentNdx], VK_IMAGE_LAYOUT_GENERAL, aspect));
5891 if (depthStencilAttachment)
5893 if (lastUseOfAttachment[*depthStencilAttachment])
5895 deBool foundDuplicate = false;
5897 const deUint32 srcPass = *lastUseOfAttachment[*depthStencilAttachment];
5898 const deUint32 dstPass = subpassIndex;
5899 const VkDependencyFlags dependencyFlags = ((srcPass == subpassIndex) || rng.getBool()) ? (VkDependencyFlags)VK_DEPENDENCY_BY_REGION_BIT : 0u;
5901 const SubpassDependency newDependency(srcPass, dstPass,
5902 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5903 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5904 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5905 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5907 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5908 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5909 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5910 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5912 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
5913 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
5916 for (SubpassDependency& dependency : deps)
5918 if (dependency.getSrcPass() == srcPass && dependency.getDstPass() == dstPass)
5920 const VkAccessFlags newSrcFlags = dependency.getSrcAccessMask() | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
5921 const VkAccessFlags newDstFlags = dependency.getDstAccessMask() | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
5922 dependency.setDstAccessMask(newSrcFlags);
5923 dependency.setDstAccessMask(newDstFlags);
5924 foundDuplicate = true;
5929 if (!foundDuplicate)
5931 deps.push_back(newDependency);
5935 lastUseOfAttachment[*depthStencilAttachment] = just(subpassIndex);
5937 depthStencilAttachmentReference = AttachmentReference(*depthStencilAttachment, VK_IMAGE_LAYOUT_GENERAL);
5940 depthStencilAttachmentReference = AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL);
5942 vector<deUint32> preserveAttachments;
5943 for (deUint32 attachmentIndex = 0; attachmentIndex < (deUint32)attachments.size(); attachmentIndex++)
5945 if (lastUseOfAttachment[attachmentIndex] && (*lastUseOfAttachment[attachmentIndex]) != subpassIndex)
5946 preserveAttachments.push_back(attachmentIndex);
5949 // Use random image layout when possible
5950 for (size_t colorRefIdx = 0; colorRefIdx < colorAttachmentReferences.size(); ++colorRefIdx)
5952 bool usedAsInput = false;
5953 for (size_t inputRefIdx = 0; inputRefIdx < inputAttachmentReferences.size(); ++inputRefIdx)
5954 if (colorAttachmentReferences[colorRefIdx].getAttachment() == inputAttachmentReferences[inputRefIdx].getAttachment())
5958 colorAttachmentReferences[colorRefIdx].setImageLayout(rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsColor), DE_ARRAY_END(subpassLayoutsColor)));
5960 for (size_t inputRefIdx = 0; inputRefIdx < inputAttachmentReferences.size(); ++inputRefIdx)
5962 bool usedAsDepthStencil = inputAttachmentReferences[inputRefIdx].getAttachment() == depthStencilAttachmentReference.getAttachment();
5963 bool usedAsColor = false;
5964 for (size_t colorRefIdx = 0; colorRefIdx < colorAttachmentReferences.size(); ++colorRefIdx)
5965 if (inputAttachmentReferences[inputRefIdx].getAttachment() == colorAttachmentReferences[colorRefIdx].getAttachment())
5968 if (!usedAsColor && !usedAsDepthStencil)
5969 inputAttachmentReferences[inputRefIdx].setImageLayout(rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsInput), DE_ARRAY_END(subpassLayoutsInput)));
5972 bool usedAsInput = false;
5973 for (size_t inputRefIdx = 0; inputRefIdx < inputAttachmentReferences.size(); ++inputRefIdx)
5974 if (depthStencilAttachmentReference.getAttachment() == inputAttachmentReferences[inputRefIdx].getAttachment())
5978 depthStencilAttachmentReference.setImageLayout(rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsDepthStencil), DE_ARRAY_END(subpassLayoutsDepthStencil)));
5981 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
5982 inputAttachmentReferences,
5983 colorAttachmentReferences,
5984 vector<AttachmentReference>(),
5985 depthStencilAttachmentReference,
5986 preserveAttachments));
5990 const TestConfig::RenderTypes render = rng.choose<TestConfig::RenderTypes>(DE_ARRAY_BEGIN(renderCommands), DE_ARRAY_END(renderCommands));
5991 const TestConfig::CommandBufferTypes commandBuffer = rng.choose<TestConfig::CommandBufferTypes>(DE_ARRAY_BEGIN(commandBuffers), DE_ARRAY_END(commandBuffers));
5992 const TestConfig::ImageMemory imageMemory = rng.choose<TestConfig::ImageMemory>(DE_ARRAY_BEGIN(imageMemories), DE_ARRAY_END(imageMemories));
5994 const string testCaseName = de::toString(testCaseNdx);
5995 const UVec2 targetSize = rng.choose<UVec2>(DE_ARRAY_BEGIN(targetSizes), DE_ARRAY_END(targetSizes));
5996 const UVec2 renderPos = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderPositions), DE_ARRAY_END(renderPositions));
5997 const UVec2 renderSize = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderSizes), DE_ARRAY_END(renderSizes));
5999 const RenderPass renderPass (attachments, subpasses, deps);
6000 const TestConfig testConfig (renderPass,
6010 testConfigExternal.allocationKind,
6011 testConfigExternal.renderingType);
6013 addFunctionCaseWithPrograms<TestConfig>(allocationTypeGroup.get(), testCaseName.c_str(), testCaseName.c_str(), createTestShaders, renderPassTest, testConfig);
6018 const deUint32 attachmentCount = rng.choose<deUint32>(DE_ARRAY_BEGIN(attachmentCounts), DE_ARRAY_END(attachmentCounts));
6019 vector<Attachment> attachments;
6020 vector<Subpass> subpasses;
6022 for (size_t attachmentNdx = 0; attachmentNdx < attachmentCount; attachmentNdx++)
6024 const VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
6025 const VkFormat format = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreColorFormats), DE_ARRAY_END(s_coreColorFormats));
6026 const VkAttachmentLoadOp loadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
6027 const VkAttachmentStoreOp storeOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
6029 const VkImageLayout initialLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
6030 const VkImageLayout finalizeLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
6032 const VkAttachmentLoadOp stencilLoadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
6033 const VkAttachmentStoreOp stencilStoreOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
6035 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
6038 if (allocationType == ALLOCATIONTYPE_GROW)
6040 for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
6042 vector<AttachmentReference> colorAttachmentReferences;
6044 for (size_t attachmentNdx = 0; attachmentNdx < subpassNdx + 1; attachmentNdx++)
6046 const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsColor), DE_ARRAY_END(subpassLayoutsColor));
6048 colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
6051 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
6052 vector<AttachmentReference>(),
6053 colorAttachmentReferences,
6054 vector<AttachmentReference>(),
6055 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6056 vector<deUint32>()));
6059 else if (allocationType == ALLOCATIONTYPE_SHRINK)
6061 for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
6063 vector<AttachmentReference> colorAttachmentReferences;
6065 for (size_t attachmentNdx = 0; attachmentNdx < (attachmentCount - subpassNdx); attachmentNdx++)
6067 const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsColor), DE_ARRAY_END(subpassLayoutsColor));
6069 colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
6072 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
6073 vector<AttachmentReference>(),
6074 colorAttachmentReferences,
6075 vector<AttachmentReference>(),
6076 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6077 vector<deUint32>()));
6080 else if (allocationType == ALLOCATIONTYPE_ROLL)
6082 for (size_t subpassNdx = 0; subpassNdx < attachmentCount / 2; subpassNdx++)
6084 vector<AttachmentReference> colorAttachmentReferences;
6086 for (size_t attachmentNdx = 0; attachmentNdx < attachmentCount / 2; attachmentNdx++)
6088 const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsColor), DE_ARRAY_END(subpassLayoutsColor));
6090 colorAttachmentReferences.push_back(AttachmentReference((deUint32)(subpassNdx + attachmentNdx), subpassLayout));
6093 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
6094 vector<AttachmentReference>(),
6095 colorAttachmentReferences,
6096 vector<AttachmentReference>(),
6097 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6098 vector<deUint32>()));
6101 else if (allocationType == ALLOCATIONTYPE_GROW_SHRINK)
6103 for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
6105 vector<AttachmentReference> colorAttachmentReferences;
6107 for (size_t attachmentNdx = 0; attachmentNdx < subpassNdx + 1; attachmentNdx++)
6109 const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsColor), DE_ARRAY_END(subpassLayoutsColor));
6111 colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
6114 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
6115 vector<AttachmentReference>(),
6116 colorAttachmentReferences,
6117 vector<AttachmentReference>(),
6118 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6119 vector<deUint32>()));
6121 for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
6123 vector<AttachmentReference> colorAttachmentReferences;
6125 for (size_t attachmentNdx = 0; attachmentNdx < (attachmentCount - subpassNdx); attachmentNdx++)
6127 const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsColor), DE_ARRAY_END(subpassLayoutsColor));
6129 colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
6132 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
6133 vector<AttachmentReference>(),
6134 colorAttachmentReferences,
6135 vector<AttachmentReference>(),
6136 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6137 vector<deUint32>()));
6140 else if (allocationType == ALLOCATIONTYPE_IO_CHAIN)
6142 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
6143 vector<AttachmentReference>(),
6144 vector<AttachmentReference>(1, AttachmentReference(0, rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsColor), DE_ARRAY_END(subpassLayoutsColor)))),
6145 vector<AttachmentReference>(),
6146 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6147 vector<deUint32>()));
6149 for (size_t subpassNdx = 1; subpassNdx < attachmentCount; subpassNdx++)
6151 const VkImageAspectFlags inputAttachmentAspectMask = (testConfigExternal.renderingType == RENDERING_TYPE_RENDERPASS2) ? VK_IMAGE_ASPECT_COLOR_BIT : static_cast<VkImageAspectFlagBits>(0);
6152 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
6153 vector<AttachmentReference>(1, AttachmentReference((deUint32)(subpassNdx - 1), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, inputAttachmentAspectMask)),
6154 vector<AttachmentReference>(1, AttachmentReference((deUint32)(subpassNdx), rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayoutsColor), DE_ARRAY_END(subpassLayoutsColor)))),
6155 vector<AttachmentReference>(),
6156 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6157 vector<deUint32>()));
6161 DE_FATAL("Unknown allocation type");
6164 const TestConfig::RenderTypes render = rng.choose<TestConfig::RenderTypes>(DE_ARRAY_BEGIN(renderCommands), DE_ARRAY_END(renderCommands));
6165 const TestConfig::CommandBufferTypes commandBuffer = rng.choose<TestConfig::CommandBufferTypes>(DE_ARRAY_BEGIN(commandBuffers), DE_ARRAY_END(commandBuffers));
6166 const TestConfig::ImageMemory imageMemory = rng.choose<TestConfig::ImageMemory>(DE_ARRAY_BEGIN(imageMemories), DE_ARRAY_END(imageMemories));
6168 const string testCaseName = de::toString(testCaseNdx);
6169 const UVec2 targetSize = rng.choose<UVec2>(DE_ARRAY_BEGIN(targetSizes), DE_ARRAY_END(targetSizes));
6170 const UVec2 renderPos = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderPositions), DE_ARRAY_END(renderPositions));
6171 const UVec2 renderSize = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderSizes), DE_ARRAY_END(renderSizes));
6173 vector<SubpassDependency> deps;
6175 for (size_t subpassNdx = 0; subpassNdx < subpasses.size() - 1; subpassNdx++)
6177 const bool byRegion = rng.getBool();
6178 deps.push_back(SubpassDependency((deUint32)subpassNdx, (deUint32)subpassNdx + 1,
6179 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
6180 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
6181 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
6182 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
6184 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
6185 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
6186 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
6187 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
6189 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
6190 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
6192 byRegion ? (VkDependencyFlags)VK_DEPENDENCY_BY_REGION_BIT : 0u));
6195 const RenderPass renderPass (attachments, subpasses, deps);
6196 const TestConfig testConfig (renderPass,
6206 testConfigExternal.allocationKind,
6207 testConfigExternal.renderingType);
6209 addFunctionCaseWithPrograms<TestConfig>(allocationTypeGroup.get(), testCaseName.c_str(), testCaseName.c_str(), createTestShaders, renderPassTest, testConfig);
6213 group->addChild(allocationTypeGroup.release());
6217 void addSimpleTests (tcu::TestCaseGroup* group, const TestConfigExternal testConfigExternal)
6219 const UVec2 targetSize (64, 64);
6220 const UVec2 renderPos (0, 0);
6221 const UVec2 renderSize (64, 64);
6225 const RenderPass renderPass (vector<Attachment>(1, Attachment(VK_FORMAT_R8G8B8A8_UNORM,
6226 VK_SAMPLE_COUNT_1_BIT,
6227 VK_ATTACHMENT_LOAD_OP_CLEAR,
6228 VK_ATTACHMENT_STORE_OP_STORE,
6229 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6230 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6231 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6232 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6233 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6235 vector<AttachmentReference>(),
6236 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6237 vector<AttachmentReference>(),
6238 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6239 vector<deUint32>())),
6240 vector<SubpassDependency>());
6241 const TestConfig testConfig (renderPass,
6242 TestConfig::RENDERTYPES_DRAW,
6243 TestConfig::COMMANDBUFFERTYPES_INLINE,
6244 TestConfig::IMAGEMEMORY_STRICT,
6251 testConfigExternal.allocationKind,
6252 testConfigExternal.renderingType);
6254 addFunctionCaseWithPrograms<TestConfig>(group, "color", "Single color attachment case.", createTestShaders, renderPassTest, testConfig);
6259 const RenderPass renderPass (vector<Attachment>(1, Attachment(VK_FORMAT_X8_D24_UNORM_PACK32,
6260 VK_SAMPLE_COUNT_1_BIT,
6261 VK_ATTACHMENT_LOAD_OP_CLEAR,
6262 VK_ATTACHMENT_STORE_OP_STORE,
6263 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6264 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6265 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6266 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
6267 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6269 vector<AttachmentReference>(),
6270 vector<AttachmentReference>(),
6271 vector<AttachmentReference>(),
6272 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6273 vector<deUint32>())),
6274 vector<SubpassDependency>());
6275 const TestConfig testConfig (renderPass,
6276 TestConfig::RENDERTYPES_DRAW,
6277 TestConfig::COMMANDBUFFERTYPES_INLINE,
6278 TestConfig::IMAGEMEMORY_STRICT,
6285 testConfigExternal.allocationKind,
6286 testConfigExternal.renderingType);
6288 addFunctionCaseWithPrograms<TestConfig>(group, "depth", "Single depth attachment case.", createTestShaders, renderPassTest, testConfig);
6293 const RenderPass renderPass (vector<Attachment>(1, Attachment(VK_FORMAT_S8_UINT,
6294 VK_SAMPLE_COUNT_1_BIT,
6295 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6296 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6297 VK_ATTACHMENT_LOAD_OP_CLEAR,
6298 VK_ATTACHMENT_STORE_OP_STORE,
6299 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6300 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
6301 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6303 vector<AttachmentReference>(),
6304 vector<AttachmentReference>(),
6305 vector<AttachmentReference>(),
6306 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6307 vector<deUint32>())),
6308 vector<SubpassDependency>());
6309 const TestConfig testConfig (renderPass,
6310 TestConfig::RENDERTYPES_DRAW,
6311 TestConfig::COMMANDBUFFERTYPES_INLINE,
6312 TestConfig::IMAGEMEMORY_STRICT,
6319 testConfigExternal.allocationKind,
6320 testConfigExternal.renderingType);
6322 addFunctionCaseWithPrograms<TestConfig>(group, "stencil", "Single stencil attachment case.", createTestShaders, renderPassTest, testConfig);
6327 const RenderPass renderPass (vector<Attachment>(1, Attachment(VK_FORMAT_D24_UNORM_S8_UINT,
6328 VK_SAMPLE_COUNT_1_BIT,
6329 VK_ATTACHMENT_LOAD_OP_CLEAR,
6330 VK_ATTACHMENT_STORE_OP_STORE,
6331 VK_ATTACHMENT_LOAD_OP_CLEAR,
6332 VK_ATTACHMENT_STORE_OP_STORE,
6333 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6334 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
6335 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6337 vector<AttachmentReference>(),
6338 vector<AttachmentReference>(),
6339 vector<AttachmentReference>(),
6340 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6341 vector<deUint32>())),
6342 vector<SubpassDependency>());
6343 const TestConfig testConfig (renderPass,
6344 TestConfig::RENDERTYPES_DRAW,
6345 TestConfig::COMMANDBUFFERTYPES_INLINE,
6346 TestConfig::IMAGEMEMORY_STRICT,
6353 testConfigExternal.allocationKind,
6354 testConfigExternal.renderingType);
6356 addFunctionCaseWithPrograms<TestConfig>(group, "depth_stencil", "Single depth stencil attachment case.", createTestShaders, renderPassTest, testConfig);
6361 const Attachment attachments[] =
6363 Attachment(VK_FORMAT_R8G8B8A8_UNORM,
6364 VK_SAMPLE_COUNT_1_BIT,
6365 VK_ATTACHMENT_LOAD_OP_CLEAR,
6366 VK_ATTACHMENT_STORE_OP_STORE,
6367 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6368 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6369 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6370 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL),
6371 Attachment(VK_FORMAT_X8_D24_UNORM_PACK32,
6372 VK_SAMPLE_COUNT_1_BIT,
6373 VK_ATTACHMENT_LOAD_OP_CLEAR,
6374 VK_ATTACHMENT_STORE_OP_STORE,
6375 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6376 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6377 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6378 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6381 const RenderPass renderPass (vector<Attachment>(DE_ARRAY_BEGIN(attachments), DE_ARRAY_END(attachments)),
6382 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6384 vector<AttachmentReference>(),
6385 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6386 vector<AttachmentReference>(),
6387 AttachmentReference(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6388 vector<deUint32>())),
6389 vector<SubpassDependency>());
6390 const TestConfig testConfig (renderPass,
6391 TestConfig::RENDERTYPES_DRAW,
6392 TestConfig::COMMANDBUFFERTYPES_INLINE,
6393 TestConfig::IMAGEMEMORY_STRICT,
6400 testConfigExternal.allocationKind,
6401 testConfigExternal.renderingType);
6403 addFunctionCaseWithPrograms<TestConfig>(group, "color_depth", "Color and depth attachment case.", createTestShaders, renderPassTest, testConfig);
6408 const Attachment attachments[] =
6410 Attachment(VK_FORMAT_R8G8B8A8_UNORM,
6411 VK_SAMPLE_COUNT_1_BIT,
6412 VK_ATTACHMENT_LOAD_OP_CLEAR,
6413 VK_ATTACHMENT_STORE_OP_STORE,
6414 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6415 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6416 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6417 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL),
6418 Attachment(VK_FORMAT_S8_UINT,
6419 VK_SAMPLE_COUNT_1_BIT,
6420 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6421 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6422 VK_ATTACHMENT_LOAD_OP_CLEAR,
6423 VK_ATTACHMENT_STORE_OP_STORE,
6424 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6425 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6428 const RenderPass renderPass (vector<Attachment>(DE_ARRAY_BEGIN(attachments), DE_ARRAY_END(attachments)),
6429 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6431 vector<AttachmentReference>(),
6432 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6433 vector<AttachmentReference>(),
6434 AttachmentReference(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6435 vector<deUint32>())),
6436 vector<SubpassDependency>());
6437 const TestConfig testConfig (renderPass,
6438 TestConfig::RENDERTYPES_DRAW,
6439 TestConfig::COMMANDBUFFERTYPES_INLINE,
6440 TestConfig::IMAGEMEMORY_STRICT,
6447 testConfigExternal.allocationKind,
6448 testConfigExternal.renderingType);
6450 addFunctionCaseWithPrograms<TestConfig>(group, "color_stencil", "Color and stencil attachment case.", createTestShaders, renderPassTest, testConfig);
6453 // color_depth_stencil
6455 const Attachment attachments[] =
6457 Attachment(VK_FORMAT_R8G8B8A8_UNORM,
6458 VK_SAMPLE_COUNT_1_BIT,
6459 VK_ATTACHMENT_LOAD_OP_CLEAR,
6460 VK_ATTACHMENT_STORE_OP_STORE,
6461 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6462 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6463 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6464 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL),
6465 Attachment(VK_FORMAT_D24_UNORM_S8_UINT,
6466 VK_SAMPLE_COUNT_1_BIT,
6467 VK_ATTACHMENT_LOAD_OP_CLEAR,
6468 VK_ATTACHMENT_STORE_OP_STORE,
6469 VK_ATTACHMENT_LOAD_OP_CLEAR,
6470 VK_ATTACHMENT_STORE_OP_STORE,
6471 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6472 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6475 const RenderPass renderPass (vector<Attachment>(DE_ARRAY_BEGIN(attachments), DE_ARRAY_END(attachments)),
6476 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6478 vector<AttachmentReference>(),
6479 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6480 vector<AttachmentReference>(),
6481 AttachmentReference(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6482 vector<deUint32>())),
6483 vector<SubpassDependency>());
6484 const TestConfig testConfig (renderPass,
6485 TestConfig::RENDERTYPES_DRAW,
6486 TestConfig::COMMANDBUFFERTYPES_INLINE,
6487 TestConfig::IMAGEMEMORY_STRICT,
6494 testConfigExternal.allocationKind,
6495 testConfigExternal.renderingType);
6497 addFunctionCaseWithPrograms<TestConfig>(group, "color_depth_stencil", "Color, depth and stencil attachment case.", createTestShaders, renderPassTest, testConfig);
6502 const RenderPass renderPass (vector<Attachment>(),
6503 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6505 vector<AttachmentReference>(),
6506 vector<AttachmentReference>(),
6507 vector<AttachmentReference>(),
6508 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6509 vector<deUint32>())),
6510 vector<SubpassDependency>());
6511 const TestConfig testConfig (renderPass,
6512 TestConfig::RENDERTYPES_DRAW,
6513 TestConfig::COMMANDBUFFERTYPES_INLINE,
6514 TestConfig::IMAGEMEMORY_STRICT,
6521 testConfigExternal.allocationKind,
6522 testConfigExternal.renderingType);
6524 addFunctionCaseWithPrograms<TestConfig>(group, "no_attachments", "No attachments case.", createTestShaders, renderPassTest, testConfig);
6527 // color_unused_omit_blend_state
6528 if (testConfigExternal.renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
6530 vector<Subpass> subpasses;
6532 // First subpass: use color attachment, create pipeline with color blend state
6533 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6535 vector<AttachmentReference>(),
6536 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6537 vector<AttachmentReference>(),
6538 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6542 // Second subpass: don't use color attachment, create pipeline without color blend state
6543 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6545 vector<AttachmentReference>(),
6546 vector<AttachmentReference>(1, AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6547 vector<AttachmentReference>(),
6548 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6552 const RenderPass renderPass (vector<Attachment>(1, Attachment(VK_FORMAT_R8G8B8A8_UNORM,
6553 VK_SAMPLE_COUNT_1_BIT,
6554 VK_ATTACHMENT_LOAD_OP_CLEAR,
6555 VK_ATTACHMENT_STORE_OP_STORE,
6556 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6557 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6558 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6559 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6561 vector<SubpassDependency>());
6563 const TestConfig testConfig (renderPass,
6564 TestConfig::RENDERTYPES_DRAW,
6565 TestConfig::COMMANDBUFFERTYPES_INLINE,
6566 TestConfig::IMAGEMEMORY_STRICT,
6573 testConfigExternal.allocationKind,
6574 testConfigExternal.renderingType);
6575 addFunctionCaseWithPrograms<TestConfig>(group, "color_unused_omit_blend_state", "Two unused color attachment case without blend state", createTestShaders, renderPassTest, testConfig);
6579 std::string formatToName (VkFormat format)
6581 const std::string formatStr = de::toString(format);
6582 const std::string prefix = "VK_FORMAT_";
6584 DE_ASSERT(formatStr.substr(0, prefix.length()) == prefix);
6586 return de::toLower(formatStr.substr(prefix.length()));
6589 void addFormatTests (tcu::TestCaseGroup* group, const TestConfigExternal testConfigExternal)
6591 tcu::TestContext& testCtx = group->getTestContext();
6593 const UVec2 targetSize (64, 64);
6594 const UVec2 renderPos (0, 0);
6595 const UVec2 renderSize (64, 64);
6599 const char* const str;
6600 const VkAttachmentStoreOp op;
6603 { "store", VK_ATTACHMENT_STORE_OP_STORE },
6604 { "dont_care", VK_ATTACHMENT_STORE_OP_DONT_CARE }
6609 const char* const str;
6610 const VkAttachmentLoadOp op;
6613 { "clear", VK_ATTACHMENT_LOAD_OP_CLEAR },
6614 { "load", VK_ATTACHMENT_LOAD_OP_LOAD },
6615 { "dont_care", VK_ATTACHMENT_LOAD_OP_DONT_CARE }
6620 const char* const str;
6621 const TestConfig::RenderTypes types;
6624 { "clear", TestConfig::RENDERTYPES_CLEAR },
6625 { "draw", TestConfig::RENDERTYPES_DRAW },
6626 { "clear_draw", TestConfig::RENDERTYPES_CLEAR|TestConfig::RENDERTYPES_DRAW }
6630 for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_coreColorFormats); formatNdx++)
6632 const VkFormat format = s_coreColorFormats[formatNdx];
6633 de::MovePtr<tcu::TestCaseGroup> formatGroup (new tcu::TestCaseGroup(testCtx, formatToName(format).c_str(), de::toString(format).c_str()));
6635 for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
6637 const VkAttachmentLoadOp loadOp = loadOps[loadOpNdx].op;
6638 de::MovePtr<tcu::TestCaseGroup> loadOpGroup (new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
6640 for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
6642 const RenderPass renderPass (vector<Attachment>(1, Attachment(format,
6643 VK_SAMPLE_COUNT_1_BIT,
6645 VK_ATTACHMENT_STORE_OP_STORE,
6646 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6647 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6648 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6649 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6650 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6652 vector<AttachmentReference>(),
6653 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6654 vector<AttachmentReference>(),
6655 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6656 vector<deUint32>())),
6657 vector<SubpassDependency>());
6658 const TestConfig testConfig (renderPass,
6659 renderTypes[renderTypeNdx].types,
6660 TestConfig::COMMANDBUFFERTYPES_INLINE,
6661 TestConfig::IMAGEMEMORY_STRICT,
6668 testConfigExternal.allocationKind,
6669 testConfigExternal.renderingType);
6671 addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), renderTypes[renderTypeNdx].str, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
6674 formatGroup->addChild(loadOpGroup.release());
6677 if (testConfigExternal.renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
6679 de::MovePtr<tcu::TestCaseGroup> inputGroup (new tcu::TestCaseGroup(testCtx, "input", "Test attachment format as input"));
6681 for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
6683 const VkAttachmentLoadOp loadOp = loadOps[loadOpNdx].op;
6684 de::MovePtr<tcu::TestCaseGroup> loadOpGroup (new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
6686 for (size_t storeOpNdx = 0; storeOpNdx < DE_LENGTH_OF_ARRAY(storeOps); storeOpNdx++)
6688 const VkImageAspectFlags inputAttachmentAspectMask = (testConfigExternal.renderingType == RENDERING_TYPE_RENDERPASS2)
6689 ? static_cast<VkImageAspectFlags>(VK_IMAGE_ASPECT_COLOR_BIT)
6690 : static_cast<VkImageAspectFlags>(0);
6691 const VkAttachmentStoreOp storeOp = storeOps[storeOpNdx].op;
6692 de::MovePtr<tcu::TestCaseGroup> storeOpGroup (new tcu::TestCaseGroup(testCtx, storeOps[storeOpNdx].str, storeOps[storeOpNdx].str));
6694 for (size_t useInputAspectNdx = 0; useInputAspectNdx < 2; useInputAspectNdx++)
6696 const bool useInputAspect = useInputAspectNdx != 0;
6698 if (testConfigExternal.renderingType == RENDERING_TYPE_RENDERPASS2 && useInputAspect)
6701 for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
6704 vector<Attachment> attachments;
6705 vector<Subpass> subpasses;
6706 vector<SubpassDependency> deps;
6707 vector<VkInputAttachmentAspectReference> inputAspects;
6709 attachments.push_back(Attachment(format,
6710 VK_SAMPLE_COUNT_1_BIT,
6713 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6714 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6715 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6716 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
6718 attachments.push_back(Attachment(vk::VK_FORMAT_R8G8B8A8_UNORM,
6719 VK_SAMPLE_COUNT_1_BIT,
6720 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6721 VK_ATTACHMENT_STORE_OP_STORE,
6722 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6723 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6724 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6725 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
6727 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6729 vector<AttachmentReference>(),
6730 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6731 vector<AttachmentReference>(),
6732 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6733 vector<deUint32>()));
6734 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6736 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, inputAttachmentAspectMask)),
6737 vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6738 vector<AttachmentReference>(),
6739 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6740 vector<deUint32>()));
6742 deps.push_back(SubpassDependency(0, 1,
6744 vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
6745 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6747 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
6748 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6749 vk::VK_DEPENDENCY_BY_REGION_BIT));
6753 const VkInputAttachmentAspectReference inputAspect =
6757 VK_IMAGE_ASPECT_COLOR_BIT
6760 inputAspects.push_back(inputAspect);
6764 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
6765 const TestConfig testConfig (renderPass,
6766 renderTypes[renderTypeNdx].types,
6767 TestConfig::COMMANDBUFFERTYPES_INLINE,
6768 TestConfig::IMAGEMEMORY_STRICT,
6775 testConfigExternal.allocationKind,
6776 testConfigExternal.renderingType);
6777 const string testName (renderTypes[renderTypeNdx].str + string(useInputAspect ? "_use_input_aspect" : ""));
6779 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), testName, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
6783 vector<Attachment> attachments;
6784 vector<Subpass> subpasses;
6785 vector<SubpassDependency> deps;
6786 vector<VkInputAttachmentAspectReference> inputAspects;
6788 attachments.push_back(Attachment(format,
6789 VK_SAMPLE_COUNT_1_BIT,
6792 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6793 VK_ATTACHMENT_STORE_OP_DONT_CARE,
6794 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6795 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
6797 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6799 vector<AttachmentReference>(),
6800 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6801 vector<AttachmentReference>(),
6802 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6803 vector<deUint32>()));
6804 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6806 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_GENERAL, inputAttachmentAspectMask)),
6807 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_GENERAL)),
6808 vector<AttachmentReference>(),
6809 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6810 vector<deUint32>()));
6812 deps.push_back(SubpassDependency(0, 1,
6813 vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
6814 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6816 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
6817 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6818 vk::VK_DEPENDENCY_BY_REGION_BIT));
6820 deps.push_back(SubpassDependency(1, 1,
6821 vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
6822 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6824 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
6825 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6826 vk::VK_DEPENDENCY_BY_REGION_BIT));
6830 const VkInputAttachmentAspectReference inputAspect =
6834 VK_IMAGE_ASPECT_COLOR_BIT
6837 inputAspects.push_back(inputAspect);
6841 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
6842 const TestConfig testConfig (renderPass,
6843 renderTypes[renderTypeNdx].types,
6844 TestConfig::COMMANDBUFFERTYPES_INLINE,
6845 TestConfig::IMAGEMEMORY_STRICT,
6852 testConfigExternal.allocationKind,
6853 testConfigExternal.renderingType);
6854 const string testName (string("self_dep_") + renderTypes[renderTypeNdx].str + (useInputAspect ? "_use_input_aspect" : ""));
6856 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), testName, string("self_dep_") + renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
6862 loadOpGroup->addChild(storeOpGroup.release());
6865 inputGroup->addChild(loadOpGroup.release());
6868 formatGroup->addChild(inputGroup.release());
6871 group->addChild(formatGroup.release());
6874 // Depth stencil formats
6875 for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_coreDepthStencilFormats); formatNdx++)
6877 const VkFormat vkFormat = s_coreDepthStencilFormats[formatNdx];
6878 const tcu::TextureFormat format = mapVkFormat(vkFormat);
6879 const bool isStencilAttachment = hasStencilComponent(format.order);
6880 const bool isDepthAttachment = hasDepthComponent(format.order);
6881 const VkImageAspectFlags formatAspectFlags = (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
6882 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u);
6883 de::MovePtr<tcu::TestCaseGroup> formatGroup (new tcu::TestCaseGroup(testCtx, formatToName(vkFormat).c_str(), de::toString(vkFormat).c_str()));
6885 for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
6887 const VkAttachmentLoadOp loadOp = loadOps[loadOpNdx].op;
6888 de::MovePtr<tcu::TestCaseGroup> loadOpGroup (new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
6890 for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
6893 const RenderPass renderPass (vector<Attachment>(1, Attachment(vkFormat,
6894 VK_SAMPLE_COUNT_1_BIT,
6895 isDepthAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6896 isDepthAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
6897 isStencilAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6898 isStencilAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
6899 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6900 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
6901 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6903 vector<AttachmentReference>(),
6904 vector<AttachmentReference>(),
6905 vector<AttachmentReference>(),
6906 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6907 vector<deUint32>())),
6908 vector<SubpassDependency>());
6909 const TestConfig testConfig (renderPass,
6910 renderTypes[renderTypeNdx].types,
6911 TestConfig::COMMANDBUFFERTYPES_INLINE,
6912 TestConfig::IMAGEMEMORY_STRICT,
6919 testConfigExternal.allocationKind,
6920 testConfigExternal.renderingType);
6922 addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), renderTypes[renderTypeNdx].str, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
6925 if (isStencilAttachment && isDepthAttachment && loadOp != VK_ATTACHMENT_LOAD_OP_CLEAR)
6928 const RenderPass renderPass (vector<Attachment>(1, Attachment(vkFormat,
6929 VK_SAMPLE_COUNT_1_BIT,
6930 isDepthAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6931 isDepthAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
6932 isStencilAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6933 isStencilAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
6934 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6935 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
6936 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6938 vector<AttachmentReference>(),
6939 vector<AttachmentReference>(),
6940 vector<AttachmentReference>(),
6941 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL),
6942 vector<deUint32>())),
6943 vector<SubpassDependency>());
6944 const TestConfig testConfig (renderPass,
6945 renderTypes[renderTypeNdx].types,
6946 TestConfig::COMMANDBUFFERTYPES_INLINE,
6947 TestConfig::IMAGEMEMORY_STRICT,
6954 testConfigExternal.allocationKind,
6955 testConfigExternal.renderingType);
6956 const string testName (string(renderTypes[renderTypeNdx].str) + "_depth_read_only");
6958 addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), testName, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
6962 const RenderPass renderPass (vector<Attachment>(1, Attachment(vkFormat,
6963 VK_SAMPLE_COUNT_1_BIT,
6964 isDepthAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6965 isDepthAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
6966 isStencilAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6967 isStencilAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
6968 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6969 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
6970 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6972 vector<AttachmentReference>(),
6973 vector<AttachmentReference>(),
6974 vector<AttachmentReference>(),
6975 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL),
6976 vector<deUint32>())),
6977 vector<SubpassDependency>());
6978 const TestConfig testConfig (renderPass,
6979 renderTypes[renderTypeNdx].types,
6980 TestConfig::COMMANDBUFFERTYPES_INLINE,
6981 TestConfig::IMAGEMEMORY_STRICT,
6988 testConfigExternal.allocationKind,
6989 testConfigExternal.renderingType);
6990 const string testName (string(renderTypes[renderTypeNdx].str) + "_stencil_read_only");
6992 addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), testName, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
6997 formatGroup->addChild(loadOpGroup.release());
7000 if (testConfigExternal.renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
7002 de::MovePtr<tcu::TestCaseGroup> inputGroup (new tcu::TestCaseGroup(testCtx, "input", "Test attachment format as input"));
7004 for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
7006 const VkAttachmentLoadOp loadOp = loadOps[loadOpNdx].op;
7007 de::MovePtr<tcu::TestCaseGroup> loadOpGroup (new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
7009 for (size_t storeOpNdx = 0; storeOpNdx < DE_LENGTH_OF_ARRAY(storeOps); storeOpNdx++)
7011 const VkImageAspectFlags inputAttachmentAspectMask = (testConfigExternal.renderingType == RENDERING_TYPE_RENDERPASS2)
7013 : static_cast<VkImageAspectFlags>(0);
7014 const VkAttachmentStoreOp storeOp = storeOps[storeOpNdx].op;
7015 de::MovePtr<tcu::TestCaseGroup> storeOpGroup (new tcu::TestCaseGroup(testCtx, storeOps[storeOpNdx].str, storeOps[storeOpNdx].str));
7017 for (size_t useInputAspectNdx = 0; useInputAspectNdx < 2; useInputAspectNdx++)
7019 const bool useInputAspect = useInputAspectNdx != 0;
7021 if (testConfigExternal.renderingType == RENDERING_TYPE_RENDERPASS2 && useInputAspect)
7024 for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
7027 vector<Attachment> attachments;
7028 vector<Subpass> subpasses;
7029 vector<SubpassDependency> deps;
7030 vector<VkInputAttachmentAspectReference> inputAspects;
7032 attachments.push_back(Attachment(vkFormat,
7033 VK_SAMPLE_COUNT_1_BIT,
7038 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
7039 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
7041 attachments.push_back(Attachment(vk::VK_FORMAT_R8G8B8A8_UNORM,
7042 VK_SAMPLE_COUNT_1_BIT,
7043 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
7044 VK_ATTACHMENT_STORE_OP_STORE,
7045 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
7046 VK_ATTACHMENT_STORE_OP_DONT_CARE,
7047 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
7048 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
7050 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7052 vector<AttachmentReference>(),
7053 vector<AttachmentReference>(),
7054 vector<AttachmentReference>(),
7055 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
7056 vector<deUint32>()));
7057 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7059 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, inputAttachmentAspectMask)),
7060 vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
7061 vector<AttachmentReference>(),
7062 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
7063 vector<deUint32>()));
7065 deps.push_back(SubpassDependency(0, 1,
7066 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
7067 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7069 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
7070 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
7075 const VkInputAttachmentAspectReference inputAspect =
7079 (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
7080 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
7083 inputAspects.push_back(inputAspect);
7087 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
7088 const TestConfig testConfig (renderPass,
7089 renderTypes[renderTypeNdx].types,
7090 TestConfig::COMMANDBUFFERTYPES_INLINE,
7091 TestConfig::IMAGEMEMORY_STRICT,
7098 testConfigExternal.allocationKind,
7099 testConfigExternal.renderingType);
7100 const string testName (renderTypes[renderTypeNdx].str + string(useInputAspect ? "_use_input_aspect" : ""));
7102 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), testName, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
7106 vector<Attachment> attachments;
7107 vector<Subpass> subpasses;
7108 vector<SubpassDependency> deps;
7109 vector<VkInputAttachmentAspectReference> inputAspects;
7111 attachments.push_back(Attachment(vkFormat,
7112 VK_SAMPLE_COUNT_1_BIT,
7115 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
7116 VK_ATTACHMENT_STORE_OP_DONT_CARE,
7117 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
7118 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
7120 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7122 vector<AttachmentReference>(),
7123 vector<AttachmentReference>(),
7124 vector<AttachmentReference>(),
7125 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
7126 vector<deUint32>()));
7127 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7129 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_GENERAL, inputAttachmentAspectMask)),
7130 vector<AttachmentReference>(),
7131 vector<AttachmentReference>(),
7132 AttachmentReference(0, VK_IMAGE_LAYOUT_GENERAL),
7133 vector<deUint32>()));
7135 deps.push_back(SubpassDependency(0, 1,
7136 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
7137 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7139 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
7140 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
7141 vk::VK_DEPENDENCY_BY_REGION_BIT));
7143 deps.push_back(SubpassDependency(1, 1,
7144 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
7145 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7146 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
7147 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
7148 vk::VK_DEPENDENCY_BY_REGION_BIT));
7153 const VkInputAttachmentAspectReference inputAspect =
7158 (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
7159 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
7162 inputAspects.push_back(inputAspect);
7166 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
7167 const TestConfig testConfig (renderPass,
7168 renderTypes[renderTypeNdx].types,
7169 TestConfig::COMMANDBUFFERTYPES_INLINE,
7170 TestConfig::IMAGEMEMORY_STRICT,
7177 testConfigExternal.allocationKind,
7178 testConfigExternal.renderingType);
7179 const string testName (string("self_dep_") + renderTypes[renderTypeNdx].str + (useInputAspect ? "_use_input_aspect" : ""));
7181 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), testName, string("self_dep_") + renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
7185 if (isStencilAttachment && isDepthAttachment)
7189 vector<Attachment> attachments;
7190 vector<Subpass> subpasses;
7191 vector<SubpassDependency> deps;
7192 vector<VkInputAttachmentAspectReference> inputAspects;
7194 attachments.push_back(Attachment(vkFormat,
7195 VK_SAMPLE_COUNT_1_BIT,
7200 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
7201 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
7203 attachments.push_back(Attachment(vk::VK_FORMAT_R8G8B8A8_UNORM,
7204 VK_SAMPLE_COUNT_1_BIT,
7205 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
7206 VK_ATTACHMENT_STORE_OP_STORE,
7207 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
7208 VK_ATTACHMENT_STORE_OP_DONT_CARE,
7209 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
7210 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
7212 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7214 vector<AttachmentReference>(),
7215 vector<AttachmentReference>(),
7216 vector<AttachmentReference>(),
7217 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
7218 vector<deUint32>()));
7219 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7221 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, inputAttachmentAspectMask)),
7222 vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
7223 vector<AttachmentReference>(),
7224 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
7225 vector<deUint32>()));
7227 deps.push_back(SubpassDependency(0, 1,
7228 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
7229 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7231 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
7232 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
7237 const VkInputAttachmentAspectReference inputAspect =
7242 (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
7243 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
7246 inputAspects.push_back(inputAspect);
7250 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
7251 const TestConfig testConfig (renderPass,
7252 renderTypes[renderTypeNdx].types,
7253 TestConfig::COMMANDBUFFERTYPES_INLINE,
7254 TestConfig::IMAGEMEMORY_STRICT,
7261 testConfigExternal.allocationKind,
7262 testConfigExternal.renderingType);
7263 const string testName (renderTypes[renderTypeNdx].str + string(useInputAspect ? "_use_input_aspect" : "") + "_depth_read_only");
7265 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), testName, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
7269 vector<Attachment> attachments;
7270 vector<Subpass> subpasses;
7271 vector<SubpassDependency> deps;
7272 vector<VkInputAttachmentAspectReference> inputAspects;
7274 attachments.push_back(Attachment(vkFormat,
7275 VK_SAMPLE_COUNT_1_BIT,
7280 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
7281 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
7283 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7285 vector<AttachmentReference>(),
7286 vector<AttachmentReference>(),
7287 vector<AttachmentReference>(),
7288 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
7289 vector<deUint32>()));
7290 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7292 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, inputAttachmentAspectMask)),
7293 vector<AttachmentReference>(),
7294 vector<AttachmentReference>(),
7295 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL),
7296 vector<deUint32>()));
7298 deps.push_back(SubpassDependency(0, 1,
7299 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
7300 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7302 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
7303 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
7304 vk::VK_DEPENDENCY_BY_REGION_BIT));
7306 deps.push_back(SubpassDependency(1, 1,
7307 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
7308 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7310 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
7311 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
7312 vk::VK_DEPENDENCY_BY_REGION_BIT));
7316 const VkInputAttachmentAspectReference inputAspect =
7321 (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
7322 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
7325 inputAspects.push_back(inputAspect);
7329 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
7330 const TestConfig testConfig (renderPass,
7331 renderTypes[renderTypeNdx].types,
7332 TestConfig::COMMANDBUFFERTYPES_INLINE,
7333 TestConfig::IMAGEMEMORY_STRICT,
7340 testConfigExternal.allocationKind,
7341 testConfigExternal.renderingType);
7342 const string testName (string("self_dep_") + renderTypes[renderTypeNdx].str + (useInputAspect ? "_use_input_aspect" : "") + "_depth_read_only");
7344 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), testName, string("self_dep_") + renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
7347 // Stencil read only
7349 vector<Attachment> attachments;
7350 vector<Subpass> subpasses;
7351 vector<SubpassDependency> deps;
7352 vector<VkInputAttachmentAspectReference> inputAspects;
7354 attachments.push_back(Attachment(vkFormat,
7355 VK_SAMPLE_COUNT_1_BIT,
7360 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
7361 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
7363 attachments.push_back(Attachment(vk::VK_FORMAT_R8G8B8A8_UNORM,
7364 VK_SAMPLE_COUNT_1_BIT,
7365 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
7366 VK_ATTACHMENT_STORE_OP_STORE,
7367 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
7368 VK_ATTACHMENT_STORE_OP_DONT_CARE,
7369 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
7370 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
7372 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7374 vector<AttachmentReference>(),
7375 vector<AttachmentReference>(),
7376 vector<AttachmentReference>(),
7377 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
7378 vector<deUint32>()));
7379 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7381 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, inputAttachmentAspectMask)),
7382 vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
7383 vector<AttachmentReference>(),
7384 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
7385 vector<deUint32>()));
7387 deps.push_back(SubpassDependency(0, 1,
7388 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
7389 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7391 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
7392 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
7397 const VkInputAttachmentAspectReference inputAspect =
7402 (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
7403 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
7406 inputAspects.push_back(inputAspect);
7410 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
7411 const TestConfig testConfig (renderPass,
7412 renderTypes[renderTypeNdx].types,
7413 TestConfig::COMMANDBUFFERTYPES_INLINE,
7414 TestConfig::IMAGEMEMORY_STRICT,
7421 testConfigExternal.allocationKind,
7422 testConfigExternal.renderingType);
7423 const string testName (renderTypes[renderTypeNdx].str + string(useInputAspect ? "_use_input_aspect" : "") + "_stencil_read_only");
7425 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), testName, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
7429 vector<Attachment> attachments;
7430 vector<Subpass> subpasses;
7431 vector<SubpassDependency> deps;
7432 vector<VkInputAttachmentAspectReference> inputAspects;
7434 attachments.push_back(Attachment(vkFormat,
7435 VK_SAMPLE_COUNT_1_BIT,
7440 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
7441 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
7443 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7445 vector<AttachmentReference>(),
7446 vector<AttachmentReference>(),
7447 vector<AttachmentReference>(),
7448 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
7449 vector<deUint32>()));
7450 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
7452 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, inputAttachmentAspectMask)),
7453 vector<AttachmentReference>(),
7454 vector<AttachmentReference>(),
7455 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL),
7456 vector<deUint32>()));
7458 deps.push_back(SubpassDependency(0, 1,
7459 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
7460 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7462 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
7463 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
7464 vk::VK_DEPENDENCY_BY_REGION_BIT));
7466 deps.push_back(SubpassDependency(1, 1,
7467 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
7468 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7470 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
7471 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
7472 vk::VK_DEPENDENCY_BY_REGION_BIT));
7477 const VkInputAttachmentAspectReference inputAspect =
7482 (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
7483 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
7486 inputAspects.push_back(inputAspect);
7490 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
7491 const TestConfig testConfig (renderPass,
7492 renderTypes[renderTypeNdx].types,
7493 TestConfig::COMMANDBUFFERTYPES_INLINE,
7494 TestConfig::IMAGEMEMORY_STRICT,
7501 testConfigExternal.allocationKind,
7502 testConfigExternal.renderingType);
7503 const string testName (string("self_dep_") + renderTypes[renderTypeNdx].str + (useInputAspect ? "_use_input_aspect" : "") + "_stencil_read_only");
7505 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), testName, string("self_dep_") + renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, testConfig);
7512 loadOpGroup->addChild(storeOpGroup.release());
7515 inputGroup->addChild(loadOpGroup.release());
7518 formatGroup->addChild(inputGroup.release());
7521 group->addChild(formatGroup.release());
7525 void addRenderPassTests (tcu::TestCaseGroup* group, const AllocationKind allocationKind, const RenderingType renderingType)
7527 const TestConfigExternal testConfigExternal (allocationKind, renderingType);
7529 addTestGroup(group, "simple", "Simple basic render pass tests", addSimpleTests, testConfigExternal);
7530 addTestGroup(group, "formats", "Tests for different image formats.", addFormatTests, testConfigExternal);
7531 addTestGroup(group, "attachment", "Attachment format and count tests with load and store ops and image layouts", addAttachmentTests, testConfigExternal);
7532 addTestGroup(group, "attachment_write_mask", "Attachment write mask tests", addAttachmentWriteMaskTests, testConfigExternal);
7534 if (renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
7535 addTestGroup(group, "attachment_allocation", "Attachment allocation tests", addAttachmentAllocationTests, testConfigExternal);
7538 de::MovePtr<tcu::TestCaseGroup> createSuballocationTests(tcu::TestContext& testCtx, RenderingType renderingType)
7540 de::MovePtr<tcu::TestCaseGroup> suballocationTestsGroup(new tcu::TestCaseGroup(testCtx, "suballocation", "Suballocation RenderPass Tests"));
7542 addRenderPassTests(suballocationTestsGroup.get(), ALLOCATION_KIND_SUBALLOCATED, renderingType);
7544 return suballocationTestsGroup;
7547 de::MovePtr<tcu::TestCaseGroup> createDedicatedAllocationTests(tcu::TestContext& testCtx, RenderingType renderingType)
7549 de::MovePtr<tcu::TestCaseGroup> dedicatedAllocationTestsGroup(new tcu::TestCaseGroup(testCtx, "dedicated_allocation", "RenderPass Tests For Dedicated Allocation"));
7551 addRenderPassTests(dedicatedAllocationTestsGroup.get(), ALLOCATION_KIND_DEDICATED, renderingType);
7553 return dedicatedAllocationTestsGroup;
7556 tcu::TestCaseGroup* createRenderPassTestsInternal (tcu::TestContext& testCtx, RenderingType renderingType)
7558 const char* renderingTestsGroupName = (renderingType == RENDERING_TYPE_RENDERPASS_LEGACY) ? "renderpass" :
7559 (renderingType == RENDERING_TYPE_RENDERPASS2) ? "renderpass2" :
7560 (renderingType == RENDERING_TYPE_DYNAMIC_RENDERING) ? "dynamic_rendering" :
7562 const char* renderingTestsGroupDescription = (renderingType == RENDERING_TYPE_RENDERPASS_LEGACY) ? "RenderPass Tests" :
7563 (renderingType == RENDERING_TYPE_RENDERPASS2) ? "RenderPass2 Tests" :
7564 (renderingType == RENDERING_TYPE_DYNAMIC_RENDERING) ? "Dynamic Rendering Tests" :
7567 de::MovePtr<tcu::TestCaseGroup> renderingTests (new tcu::TestCaseGroup(testCtx, renderingTestsGroupName, renderingTestsGroupDescription));
7568 de::MovePtr<tcu::TestCaseGroup> suballocationTestGroup = createSuballocationTests(testCtx, renderingType);
7569 de::MovePtr<tcu::TestCaseGroup> dedicatedAllocationTestGroup = createDedicatedAllocationTests(testCtx, renderingType);
7571 switch (renderingType)
7573 case RENDERING_TYPE_RENDERPASS_LEGACY:
7574 suballocationTestGroup->addChild(createRenderPassMultisampleTests(testCtx));
7575 suballocationTestGroup->addChild(createRenderPassMultisampleResolveTests(testCtx));
7576 suballocationTestGroup->addChild(createRenderPassSubpassDependencyTests(testCtx));
7577 suballocationTestGroup->addChild(createRenderPassSampleReadTests(testCtx));
7578 suballocationTestGroup->addChild(createRenderPassSparseRenderTargetTests(testCtx));
7580 renderingTests->addChild(createRenderPassMultipleSubpassesMultipleCommandBuffersTests(testCtx));
7583 case RENDERING_TYPE_RENDERPASS2:
7584 suballocationTestGroup->addChild(createRenderPass2MultisampleTests(testCtx));
7585 suballocationTestGroup->addChild(createRenderPass2MultisampleResolveTests(testCtx));
7586 suballocationTestGroup->addChild(createRenderPass2SubpassDependencyTests(testCtx));
7587 suballocationTestGroup->addChild(createRenderPass2SampleReadTests(testCtx));
7588 suballocationTestGroup->addChild(createRenderPass2SparseRenderTargetTests(testCtx));
7590 renderingTests->addChild(createRenderPass2DepthStencilResolveTests(testCtx));
7593 case RENDERING_TYPE_DYNAMIC_RENDERING:
7594 suballocationTestGroup->addChild(createDynamicRenderingMultisampleResolveTests(testCtx));
7595 suballocationTestGroup->addChild(createDynamicRenderingSparseRenderTargetTests(testCtx));
7597 renderingTests->addChild(createDynamicRenderingBasicTests(testCtx));
7601 if (renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
7603 suballocationTestGroup->addChild(createRenderPassUnusedAttachmentTests(testCtx, renderingType));
7604 suballocationTestGroup->addChild(createRenderPassUnusedAttachmentSparseFillingTests(testCtx, renderingType));
7607 suballocationTestGroup->addChild(createRenderPassUnusedClearAttachmentTests(testCtx, renderingType));
7608 suballocationTestGroup->addChild(createRenderPassLoadStoreOpNoneTests(testCtx, renderingType));
7610 renderingTests->addChild(suballocationTestGroup.release());
7611 renderingTests->addChild(dedicatedAllocationTestGroup.release());
7612 renderingTests->addChild(createFragmentDensityMapTests(testCtx, renderingType));
7614 return renderingTests.release();
7619 tcu::TestCaseGroup* createRenderPassTests (tcu::TestContext& testCtx)
7621 return createRenderPassTestsInternal(testCtx, RENDERING_TYPE_RENDERPASS_LEGACY);
7624 tcu::TestCaseGroup* createRenderPass2Tests (tcu::TestContext& testCtx)
7626 return createRenderPassTestsInternal(testCtx, RENDERING_TYPE_RENDERPASS2);
7629 tcu::TestCaseGroup* createDynamicRenderingTests(tcu::TestContext& testCtx)
7631 return createRenderPassTestsInternal(testCtx, RENDERING_TYPE_DYNAMIC_RENDERING);