1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2016 The Khronos Group Inc.
6 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
22 * \brief Vulkan Image Clearing Tests
23 *//*--------------------------------------------------------------------*/
25 #include "vktApiImageClearingTests.hpp"
27 #include "deRandom.hpp"
29 #include "deStringUtil.hpp"
30 #include "deUniquePtr.hpp"
31 #include "deArrayUtil.hpp"
32 #include "vkImageUtil.hpp"
33 #include "vkMemUtil.hpp"
34 #include "vktTestCase.hpp"
35 #include "vktTestCaseUtil.hpp"
36 #include "vkQueryUtil.hpp"
37 #include "vkRefUtil.hpp"
38 #include "vkTypeUtil.hpp"
39 #include "tcuImageCompare.hpp"
40 #include "tcuTexture.hpp"
41 #include "tcuTextureUtil.hpp"
42 #include "tcuVectorType.hpp"
43 #include "tcuTexture.hpp"
44 #include "tcuFloat.hpp"
45 #include "tcuTestLog.hpp"
46 #include "tcuVectorUtil.hpp"
61 // This method is copied from the vktRenderPassTests.cpp. It should be moved to a common place.
62 int calcFloatDiff (float a, float b)
64 const int asign = Float32(a).sign();
65 const int bsign = Float32(a).sign();
67 const deUint32 avalue = (Float32(a).bits() & ((0x1u << 31u) - 1u));
68 const deUint32 bvalue = (Float32(b).bits() & ((0x1u << 31u) - 1u));
71 return avalue + bvalue + 1u;
72 else if (avalue < bvalue)
73 return bvalue - avalue;
75 return avalue - bvalue;
78 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
79 bool comparePixelToDepthClearValue (const ConstPixelBufferAccess& access,
83 std::string& stringResult)
85 const TextureFormat format = getEffectiveDepthStencilTextureFormat(access.getFormat(), Sampler::MODE_DEPTH);
86 const TextureChannelClass channelClass = getTextureChannelClass(format.type);
90 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
91 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
93 const int bitDepth = getTextureFormatBitDepth(format).x();
94 const float depth = access.getPixDepth(x, y);
95 const float threshold = 2.0f / (float)((1 << bitDepth) - 1);
96 const bool result = deFloatAbs(depth - ref) <= threshold;
101 s << "Ref:" << ref << " Threshold:" << threshold << " Depth:" << depth;
102 stringResult = s.str();
108 case TEXTURECHANNELCLASS_FLOATING_POINT:
110 const float depth = access.getPixDepth(x, y);
111 const int mantissaBits = getTextureFormatMantissaBitDepth(format).x();
112 const int threshold = 10 * 1 << (23 - mantissaBits);
114 DE_ASSERT(mantissaBits <= 23);
116 const bool result = calcFloatDiff(depth, ref) <= threshold;
120 float floatThreshold = Float32((deUint32)threshold).asFloat();
123 s << "Ref:" << ref << " Threshold:" << floatThreshold << " Depth:" << depth;
124 stringResult = s.str();
131 DE_FATAL("Invalid channel class");
136 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
137 bool comparePixelToStencilClearValue (const ConstPixelBufferAccess& access,
141 std::string& stringResult)
143 const deUint32 stencil = access.getPixStencil(x, y);
144 const bool result = stencil == ref;
149 s << "Ref:" << ref << " Threshold:0" << " Stencil:" << stencil;
150 stringResult = s.str();
156 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
157 bool comparePixelToColorClearValue (const ConstPixelBufferAccess& access,
161 const VkClearColorValue& ref,
162 std::string& stringResult)
164 const TextureFormat format = access.getFormat();
165 const TextureChannelClass channelClass = getTextureChannelClass(format.type);
166 const BVec4 channelMask = getTextureFormatChannelMask(format);
168 switch (channelClass)
170 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
171 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
173 const IVec4 bitDepth (getTextureFormatBitDepth(format));
174 const Vec4 resColor (access.getPixel(x, y, z));
175 Vec4 refColor (ref.float32[0],
179 const int modifier = (channelClass == TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT) ? 0 : 1;
180 const Vec4 threshold (bitDepth[0] > 0 ? 1.0f / ((float)(1 << (bitDepth[0] - modifier)) - 1.0f) : 1.0f,
181 bitDepth[1] > 0 ? 1.0f / ((float)(1 << (bitDepth[1] - modifier)) - 1.0f) : 1.0f,
182 bitDepth[2] > 0 ? 1.0f / ((float)(1 << (bitDepth[2] - modifier)) - 1.0f) : 1.0f,
183 bitDepth[3] > 0 ? 1.0f / ((float)(1 << (bitDepth[3] - modifier)) - 1.0f) : 1.0f);
185 if (isSRGB(access.getFormat()))
186 refColor = linearToSRGB(refColor);
188 const bool result = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold), channelMask), channelMask));
193 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold << " Color:" << resColor;
194 stringResult = s.str();
200 case TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
202 const UVec4 resColor (access.getPixelUint(x, y, z));
203 const UVec4 refColor (ref.uint32[0],
207 const UVec4 threshold (1);
209 const bool result = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold), channelMask), channelMask));
214 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold << " Color:" << resColor;
215 stringResult = s.str();
221 case TEXTURECHANNELCLASS_SIGNED_INTEGER:
223 const IVec4 resColor (access.getPixelInt(x, y, z));
224 const IVec4 refColor (ref.int32[0],
228 const IVec4 threshold (1);
230 const bool result = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold), channelMask), channelMask));
235 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold << " Color:" << resColor;
236 stringResult = s.str();
242 case TEXTURECHANNELCLASS_FLOATING_POINT:
244 const Vec4 resColor (access.getPixel(x, y, z));
245 const Vec4 refColor (ref.float32[0],
249 const IVec4 mantissaBits (getTextureFormatMantissaBitDepth(format));
250 const IVec4 threshold (10 * IVec4(1) << (23 - mantissaBits));
252 DE_ASSERT(allEqual(greaterThanEqual(threshold, IVec4(0)), BVec4(true)));
254 for (int ndx = 0; ndx < 4; ndx++)
256 const bool result = !(calcFloatDiff(resColor[ndx], refColor[ndx]) > threshold[ndx] && channelMask[ndx]);
260 float floatThreshold = Float32((deUint32)(threshold)[0]).asFloat();
261 Vec4 thresholdVec4 (floatThreshold,
266 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << thresholdVec4 << " Color:" << resColor;
267 stringResult = s.str();
277 DE_FATAL("Invalid channel class");
284 VkImageType imageType;
285 VkFormat imageFormat;
286 VkExtent3D imageExtent;
287 VkClearValue initValue;
288 VkClearValue clearValue;
291 class ImageClearingTestInstance : public vkt::TestInstance
294 ImageClearingTestInstance (Context& context,
295 const TestParams& testParams);
297 Move<VkCommandPool> createCommandPool (VkCommandPoolCreateFlags commandPoolCreateFlags) const;
298 Move<VkCommandBuffer> allocatePrimaryCommandBuffer (VkCommandPool commandPool) const;
299 Move<VkImage> createImage (VkImageType imageType, VkFormat format, VkExtent3D extent, VkImageUsageFlags usage) const;
300 Move<VkImageView> createImageView (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask) const;
301 Move<VkRenderPass> createRenderPass (VkFormat format) const;
302 Move<VkFramebuffer> createFrameBuffer (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight) const;
304 void beginCommandBuffer (VkCommandBufferUsageFlags usageFlags) const;
305 void endCommandBuffer (void) const;
306 void submitCommandBuffer (void) const;
307 void beginRenderPass (VkSubpassContents content, VkClearValue clearValue) const;
309 void pipelineImageBarrier (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout) const;
310 de::MovePtr<TextureLevel> readImage (VkImageAspectFlags aspectMask) const;
313 VkImageViewType getCorrespondingImageViewType (VkImageType imageType) const;
314 VkImageUsageFlags getImageUsageFlags (VkFormat format) const;
315 VkImageAspectFlags getImageAspectFlags (VkFormat format) const;
316 bool getIsAttachmentFormat (VkFormat format) const;
317 bool getIsStencilFormat (VkFormat format) const;
318 bool getIsDepthFormat (VkFormat format) const;
319 de::MovePtr<Allocation> allocateAndBindImageMemory (VkImage image) const;
321 const TestParams& m_params;
322 const VkDevice m_device;
323 const InstanceInterface& m_vki;
324 const DeviceInterface& m_vkd;
325 const VkQueue m_queue;
326 const deUint32 m_queueFamilyIndex;
327 Allocator& m_allocator;
329 const bool m_isAttachmentFormat;
330 const VkImageUsageFlags m_imageUsageFlags;
331 const VkImageAspectFlags m_imageAspectFlags;
333 Unique<VkCommandPool> m_commandPool;
334 Unique<VkCommandBuffer> m_commandBuffer;
336 Unique<VkImage> m_image;
337 de::MovePtr<Allocation> m_imageMemory;
338 Unique<VkImageView> m_imageView;
339 Unique<VkRenderPass> m_renderPass;
340 Unique<VkFramebuffer> m_frameBuffer;
343 ImageClearingTestInstance::ImageClearingTestInstance (Context& context, const TestParams& params)
344 : TestInstance (context)
346 , m_device (context.getDevice())
347 , m_vki (context.getInstanceInterface())
348 , m_vkd (context.getDeviceInterface())
349 , m_queue (context.getUniversalQueue())
350 , m_queueFamilyIndex (context.getUniversalQueueFamilyIndex())
351 , m_allocator (context.getDefaultAllocator())
352 , m_isAttachmentFormat (getIsAttachmentFormat(params.imageFormat))
353 , m_imageUsageFlags (getImageUsageFlags(params.imageFormat))
354 , m_imageAspectFlags (getImageAspectFlags(params.imageFormat))
355 , m_commandPool (createCommandPool(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT))
356 , m_commandBuffer (allocatePrimaryCommandBuffer(*m_commandPool))
358 , m_image (createImage(params.imageType,
363 , m_imageMemory (allocateAndBindImageMemory(*m_image))
364 , m_imageView (m_isAttachmentFormat ? createImageView(*m_image,
365 getCorrespondingImageViewType(params.imageType),
367 m_imageAspectFlags) : vk::Move<VkImageView>())
369 , m_renderPass (m_isAttachmentFormat ? createRenderPass(params.imageFormat) : vk::Move<vk::VkRenderPass>())
370 , m_frameBuffer (m_isAttachmentFormat ? createFrameBuffer(*m_imageView, *m_renderPass, params.imageExtent.width, params.imageExtent.height) : vk::Move<vk::VkFramebuffer>())
374 VkImageViewType ImageClearingTestInstance::getCorrespondingImageViewType (VkImageType imageType) const
378 case VK_IMAGE_TYPE_1D:
379 return VK_IMAGE_VIEW_TYPE_1D;
380 case VK_IMAGE_TYPE_2D:
381 return VK_IMAGE_VIEW_TYPE_2D;
382 case VK_IMAGE_TYPE_3D:
383 return VK_IMAGE_VIEW_TYPE_3D;
385 DE_FATAL("Unknown image type!");
388 return VK_IMAGE_VIEW_TYPE_2D;
391 VkImageUsageFlags ImageClearingTestInstance::getImageUsageFlags (VkFormat format) const
393 VkImageUsageFlags commonFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
395 if (m_isAttachmentFormat)
397 if (isDepthStencilFormat(format))
398 return commonFlags | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
400 return commonFlags | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
405 VkImageAspectFlags ImageClearingTestInstance::getImageAspectFlags (VkFormat format) const
407 VkImageAspectFlags imageAspectFlags = 0;
409 if (getIsDepthFormat(format))
410 imageAspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
412 if (getIsStencilFormat(format))
413 imageAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
415 if (imageAspectFlags == 0)
416 imageAspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
418 return imageAspectFlags;
421 bool ImageClearingTestInstance::getIsAttachmentFormat (VkFormat format) const
423 const VkFormatProperties props = vk::getPhysicalDeviceFormatProperties(m_vki, m_context.getPhysicalDevice(), format);
425 return (props.optimalTilingFeatures & (vk::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) != 0;
428 bool ImageClearingTestInstance::getIsStencilFormat (VkFormat format) const
430 const TextureFormat tcuFormat = mapVkFormat(format);
432 if (tcuFormat.order == TextureFormat::S || tcuFormat.order == TextureFormat::DS)
438 bool ImageClearingTestInstance::getIsDepthFormat (VkFormat format) const
440 const TextureFormat tcuFormat = mapVkFormat(format);
442 if (tcuFormat.order == TextureFormat::D || tcuFormat.order == TextureFormat::DS)
448 de::MovePtr<Allocation> ImageClearingTestInstance::allocateAndBindImageMemory (VkImage image) const
450 de::MovePtr<Allocation> imageMemory (m_allocator.allocate(getImageMemoryRequirements(m_vkd, m_device, image), MemoryRequirement::Any));
451 VK_CHECK(m_vkd.bindImageMemory(m_device, image, imageMemory->getMemory(), imageMemory->getOffset()));
455 Move<VkCommandPool> ImageClearingTestInstance::createCommandPool (VkCommandPoolCreateFlags commandPoolCreateFlags) const
457 const VkCommandPoolCreateInfo cmdPoolCreateInfo =
459 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
460 DE_NULL, // const void* pNext;
461 commandPoolCreateFlags, // VkCommandPoolCreateFlags flags;
462 m_queueFamilyIndex // deUint32 queueFamilyIndex;
465 return vk::createCommandPool(m_vkd, m_device, &cmdPoolCreateInfo, DE_NULL);
468 Move<VkCommandBuffer> ImageClearingTestInstance::allocatePrimaryCommandBuffer (VkCommandPool commandPool) const
470 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
472 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
473 DE_NULL, // const void* pNext;
474 commandPool, // VkCommandPool commandPool;
475 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
476 1 // deUint32 commandBufferCount;
479 return vk::allocateCommandBuffer(m_vkd, m_device, &cmdBufferAllocateInfo);
482 Move<VkImage> ImageClearingTestInstance::createImage (VkImageType imageType, VkFormat format, VkExtent3D extent, VkImageUsageFlags usage) const
484 VkImageFormatProperties properties;
485 if ((m_context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(),
488 VK_IMAGE_TILING_OPTIMAL,
490 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
492 TCU_THROW(NotSupportedError, "Format not supported");
495 const VkImageCreateInfo imageCreateInfo =
497 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
498 DE_NULL, // const void* pNext;
499 0u, // VkImageCreateFlags flags;
500 imageType, // VkImageType imageType;
501 format, // VkFormat format;
502 extent, // VkExtent3D extent;
503 1, // deUint32 mipLevels;
504 1, // deUint32 arrayLayers;
505 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
506 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
507 usage, // VkImageUsageFlags usage;
508 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
509 1, // deUint32 queueFamilyIndexCount;
510 &m_queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
511 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
514 return vk::createImage(m_vkd, m_device, &imageCreateInfo, DE_NULL);
517 Move<VkImageView> ImageClearingTestInstance::createImageView (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask) const
519 const VkImageViewCreateInfo imageViewCreateInfo =
521 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
522 DE_NULL, // const void* pNext;
523 0u, // VkImageViewCreateFlags flags;
524 image, // VkImage image;
525 viewType, // VkImageViewType viewType;
526 format, // VkFormat format;
528 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle r;
529 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle g;
530 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle b;
531 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle a;
532 }, // VkComponentMapping components;
534 aspectMask, // VkImageAspectFlags aspectMask;
535 0u, // deUint32 baseMipLevel;
536 1u, // deUint32 mipLevels;
537 0u, // deUint32 baseArrayLayer;
538 1u, // deUint32 arraySize;
539 }, // VkImageSubresourceRange subresourceRange;
542 return vk::createImageView(m_vkd, m_device, &imageViewCreateInfo, DE_NULL);
545 Move<VkRenderPass> ImageClearingTestInstance::createRenderPass (VkFormat format) const
547 VkImageLayout imageLayout;
549 if (isDepthStencilFormat(format))
550 imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
552 imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
554 const VkAttachmentDescription attachmentDesc =
556 0u, // VkAttachmentDescriptionFlags flags;
557 format, // VkFormat format;
558 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
559 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
560 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
561 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp stencilLoadOp;
562 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp;
563 imageLayout, // VkImageLayout initialLayout;
564 imageLayout, // VkImageLayout finalLayout;
567 const VkAttachmentDescription attachments[1] =
572 const VkAttachmentReference attachmentRef =
574 0u, // deUint32 attachment;
575 imageLayout, // VkImageLayout layout;
578 const VkAttachmentReference* pColorAttachments = DE_NULL;
579 const VkAttachmentReference* pDepthStencilAttachment = DE_NULL;
580 deUint32 colorAttachmentCount = 1;
582 if (isDepthStencilFormat(format))
584 colorAttachmentCount = 0;
585 pDepthStencilAttachment = &attachmentRef;
589 colorAttachmentCount = 1;
590 pColorAttachments = &attachmentRef;
593 const VkSubpassDescription subpassDesc[1] =
596 0u, // VkSubpassDescriptionFlags flags;
597 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
598 0u, // deUint32 inputAttachmentCount;
599 DE_NULL, // const VkAttachmentReference* pInputAttachments;
600 colorAttachmentCount, // deUint32 colorAttachmentCount;
601 pColorAttachments, // const VkAttachmentReference* pColorAttachments;
602 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
603 pDepthStencilAttachment, // const VkAttachmentReference* pDepthStencilAttachment;
604 0u, // deUint32 preserveAttachmentCount;
605 DE_NULL, // const VkAttachmentReference* pPreserveAttachments;
609 const VkRenderPassCreateInfo renderPassCreateInfo =
611 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
612 DE_NULL, // const void* pNext;
613 0u, // VkRenderPassCreateFlags flags;
614 1u, // deUint32 attachmentCount;
615 attachments, // const VkAttachmentDescription* pAttachments;
616 1u, // deUint32 subpassCount;
617 subpassDesc, // const VkSubpassDescription* pSubpasses;
618 0u, // deUint32 dependencyCount;
619 DE_NULL, // const VkSubpassDependency* pDependencies;
622 return vk::createRenderPass(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
625 Move<VkFramebuffer> ImageClearingTestInstance::createFrameBuffer (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight) const
627 const VkImageView attachmentViews[1] =
632 const VkFramebufferCreateInfo framebufferCreateInfo =
634 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
635 DE_NULL, // const void* pNext;
636 0u, // VkFramebufferCreateFlags flags;
637 renderPass, // VkRenderPass renderPass;
638 1, // deUint32 attachmentCount;
639 attachmentViews, // const VkImageView* pAttachments;
640 imageWidth, // deUint32 width;
641 imageHeight, // deUint32 height;
642 1u, // deUint32 layers;
645 return createFramebuffer(m_vkd, m_device, &framebufferCreateInfo, DE_NULL);
648 void ImageClearingTestInstance::beginCommandBuffer (VkCommandBufferUsageFlags usageFlags) const
650 const VkCommandBufferBeginInfo commandBufferBeginInfo =
652 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
653 DE_NULL, // const void* pNext;
654 usageFlags, // VkCommandBufferUsageFlags flags;
655 DE_NULL // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
658 VK_CHECK(m_vkd.beginCommandBuffer(*m_commandBuffer, &commandBufferBeginInfo));
661 void ImageClearingTestInstance::endCommandBuffer (void) const
663 VK_CHECK(m_vkd.endCommandBuffer(*m_commandBuffer));
666 void ImageClearingTestInstance::submitCommandBuffer (void) const
668 const VkFenceCreateInfo fenceCreateInfo =
670 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
671 DE_NULL, // const void* pNext;
672 0u // VkFenceCreateFlags flags;
675 const Unique<VkFence> fence (createFence(m_vkd, m_device, &fenceCreateInfo));
677 const VkSubmitInfo submitInfo =
679 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
680 DE_NULL, // const void* pNext;
681 0u, // deUint32 waitSemaphoreCount;
682 DE_NULL, // const VkSemaphore* pWaitSemaphores;
683 DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
684 1u, // deUint32 commandBufferCount;
685 &(*m_commandBuffer), // const VkCommandBuffer* pCommandBuffers;
686 0u, // deUint32 signalSemaphoreCount;
687 DE_NULL // const VkSemaphore* pSignalSemaphores;
690 VK_CHECK(m_vkd.queueSubmit(m_queue, 1, &submitInfo, *fence));
692 VK_CHECK(m_vkd.waitForFences(m_device, 1, &fence.get(), VK_TRUE, ~0ull));
696 void ImageClearingTestInstance::pipelineImageBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout) const
699 const VkImageSubresourceRange subResourcerange =
701 m_imageAspectFlags, // VkImageAspectFlags aspectMask;
702 0, // deUint32 baseMipLevel;
703 1, // deUint32 levelCount;
704 0, // deUint32 baseArrayLayer;
705 1 // deUint32 layerCount;
708 const VkImageMemoryBarrier imageBarrier =
710 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
711 DE_NULL, // const void* pNext;
712 srcAccessMask, // VkAccessFlags srcAccessMask;
713 dstAccessMask, // VkAccessFlags dstAccessMask;
714 oldLayout, // VkImageLayout oldLayout;
715 newLayout, // VkImageLayout newLayout;
716 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
717 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
718 *m_image, // VkImage image;
719 subResourcerange // VkImageSubresourceRange subresourceRange;
722 m_vkd.cmdPipelineBarrier(*m_commandBuffer, srcStageMask, dstStageMask, 0, 0, DE_NULL, 0, DE_NULL, 1, &imageBarrier);
726 de::MovePtr<TextureLevel> ImageClearingTestInstance::readImage (VkImageAspectFlags aspectMask) const
728 Move<VkBuffer> buffer;
729 de::MovePtr<Allocation> bufferAlloc;
731 const TextureFormat tcuFormat = aspectMask == VK_IMAGE_ASPECT_COLOR_BIT ? mapVkFormat(m_params.imageFormat) :
732 aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT ? getDepthCopyFormat(m_params.imageFormat) :
733 aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT ? getStencilCopyFormat(m_params.imageFormat) :
736 const VkDeviceSize pixelDataSize = m_params.imageExtent.width * m_params.imageExtent.height * m_params.imageExtent.depth * tcuFormat.getPixelSize();
737 de::MovePtr<TextureLevel> result (new TextureLevel(tcuFormat, m_params.imageExtent.width, m_params.imageExtent.height, m_params.imageExtent.depth));
739 // Create destination buffer
741 const VkBufferCreateInfo bufferParams =
743 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
744 DE_NULL, // const void* pNext;
745 0u, // VkBufferCreateFlags flags;
746 pixelDataSize, // VkDeviceSize size;
747 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
748 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
749 0u, // deUint32 queueFamilyIndexCount;
750 DE_NULL // const deUint32* pQueueFamilyIndices;
753 buffer = createBuffer(m_vkd, m_device, &bufferParams);
754 bufferAlloc = m_allocator.allocate(getBufferMemoryRequirements(m_vkd, m_device, *buffer), MemoryRequirement::HostVisible);
755 VK_CHECK(m_vkd.bindBufferMemory(m_device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
758 // Barriers for copying image to buffer
760 const VkBufferMemoryBarrier bufferBarrier =
762 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
763 DE_NULL, // const void* pNext;
764 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
765 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
766 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
767 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
768 *buffer, // VkBuffer buffer;
769 0u, // VkDeviceSize offset;
770 pixelDataSize // VkDeviceSize size;
773 // Copy image to buffer
775 const VkBufferImageCopy copyRegion =
777 0u, // VkDeviceSize bufferOffset;
778 m_params.imageExtent.width, // deUint32 bufferRowLength;
779 m_params.imageExtent.height, // deUint32 bufferImageHeight;
780 { aspectMask, 0u, 0u, 1u }, // VkImageSubresourceLayers imageSubresource;
781 { 0, 0, 0 }, // VkOffset3D imageOffset;
782 m_params.imageExtent // VkExtent3D imageExtent;
785 beginCommandBuffer(0);
787 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
788 VK_PIPELINE_STAGE_TRANSFER_BIT,
789 VK_ACCESS_TRANSFER_WRITE_BIT |
790 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
791 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
792 VK_ACCESS_TRANSFER_READ_BIT,
793 VK_IMAGE_LAYOUT_GENERAL,
794 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
796 m_vkd.cmdCopyImageToBuffer(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1, ©Region);
797 m_vkd.cmdPipelineBarrier(*m_commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
799 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
800 VK_PIPELINE_STAGE_TRANSFER_BIT,
802 VK_ACCESS_TRANSFER_READ_BIT |
803 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
804 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
806 VK_ACCESS_TRANSFER_READ_BIT |
807 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
808 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
809 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
810 VK_IMAGE_LAYOUT_GENERAL);
814 submitCommandBuffer();
816 invalidateMappedMemoryRange(m_vkd, m_device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
818 copy(*result, ConstPixelBufferAccess(result->getFormat(), result->getSize(), bufferAlloc->getHostPtr()));
823 void ImageClearingTestInstance::beginRenderPass (VkSubpassContents content, VkClearValue clearValue) const
825 const VkRenderPassBeginInfo renderPassBeginInfo =
827 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
828 DE_NULL, // const void* pNext;
829 *m_renderPass, // VkRenderPass renderPass;
830 *m_frameBuffer, // VkFramebuffer framebuffer;
832 { 0, 0 }, // VkOffset2D offset;
834 m_params.imageExtent.width, // deUint32 width;
835 m_params.imageExtent.height // deUint32 height;
836 } // VkExtent2D extent;
837 }, // VkRect2D renderArea;
838 1u, // deUint32 clearValueCount;
839 &clearValue // const VkClearValue* pClearValues;
842 m_vkd.cmdBeginRenderPass(*m_commandBuffer, &renderPassBeginInfo, content);
845 class ClearColorImageTestInstance : public ImageClearingTestInstance
848 ClearColorImageTestInstance (Context& context,
849 const TestParams& testParams)
850 : ImageClearingTestInstance(context, testParams)
853 virtual TestStatus iterate (void);
856 TestStatus ClearColorImageTestInstance::iterate (void)
858 const VkImageSubresourceRange subResourcerange =
860 m_imageAspectFlags, // VkImageAspectFlags aspectMask;
861 0, // deUint32 baseMipLevel;
862 1, // deUint32 levelCount;
863 0, // deUint32 baseArrayLayer;
864 1 // deUint32 layerCount;
867 beginCommandBuffer(0);
869 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
870 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
871 0, // VkAccessFlags srcAccessMask
872 (m_isAttachmentFormat
873 ? VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
874 : VK_ACCESS_TRANSFER_WRITE_BIT), // VkAccessFlags dstAccessMask
875 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
876 (m_isAttachmentFormat
877 ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
878 : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)); // VkImageLayout newLayout;
880 if (m_isAttachmentFormat)
882 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
883 m_vkd.cmdEndRenderPass(*m_commandBuffer);
885 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
886 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
887 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask
888 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
889 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
890 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
894 m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue.color, 1, &subResourcerange);
896 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
897 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
898 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
899 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
900 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
901 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
904 submitCommandBuffer();
906 de::MovePtr<TextureLevel> result = readImage(VK_IMAGE_ASPECT_COLOR_BIT);
907 std::string compareResult;
909 for (deUint32 z = 0; z < m_params.imageExtent.depth; z++)
911 for (deUint32 y = 0; y < m_params.imageExtent.height; y++)
913 for (deUint32 x = 0; x < m_params.imageExtent.width; x++)
915 if (!comparePixelToColorClearValue(result->getAccess(), x, y, z, m_params.clearValue.color, compareResult))
916 return TestStatus::fail("Color value mismatch! " + compareResult);
921 return TestStatus::pass("cmdClearColorImage passed");
924 class ClearDepthStencilImageTestInstance : public ImageClearingTestInstance
927 ClearDepthStencilImageTestInstance (Context& context,
928 const TestParams& testParams)
929 : ImageClearingTestInstance (context, testParams)
932 virtual TestStatus iterate (void);
935 TestStatus ClearDepthStencilImageTestInstance::iterate (void)
937 const VkImageSubresourceRange subResourcerange =
939 m_imageAspectFlags, // VkImageAspectFlags aspectMask;
940 0, // deUint32 baseMipLevel;
941 1, // deUint32 levelCount;
942 0, // deUint32 baseArrayLayer;
943 1 // deUint32 layerCount;
946 beginCommandBuffer(0);
948 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
949 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
950 0, // VkAccessFlags srcAccessMask
951 (m_isAttachmentFormat
952 ? VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
953 : VK_ACCESS_TRANSFER_WRITE_BIT), // VkAccessFlags dstAccessMask
954 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
955 (m_isAttachmentFormat
956 ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
957 : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)); // VkImageLayout newLayout;
959 if (m_isAttachmentFormat)
961 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
962 m_vkd.cmdEndRenderPass(*m_commandBuffer);
964 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
965 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
966 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask
967 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
968 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
969 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
972 m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue.depthStencil, 1, &subResourcerange);
974 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
975 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
976 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
977 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
978 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
979 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
982 submitCommandBuffer();
984 de::MovePtr<TextureLevel> depthResult;
985 de::MovePtr<TextureLevel> stencilResult;
986 bool isDepthFormat = getIsDepthFormat(m_params.imageFormat);
989 depthResult = readImage(VK_IMAGE_ASPECT_DEPTH_BIT);
991 const bool isStencilFormat = getIsStencilFormat(m_params.imageFormat);
995 stencilResult = readImage(VK_IMAGE_ASPECT_STENCIL_BIT);
998 std::string compareResult;
1000 for (deUint32 y = 0; y < m_params.imageExtent.height; ++y)
1002 for (deUint32 x = 0; x < m_params.imageExtent.width; ++x)
1004 if (isDepthFormat && !comparePixelToDepthClearValue(depthResult->getAccess(), x, y, m_params.clearValue.depthStencil.depth, compareResult))
1005 return TestStatus::fail("Depth value mismatch! " + compareResult);
1007 if (isStencilFormat && !comparePixelToStencilClearValue(stencilResult->getAccess(), x, y, m_params.clearValue.depthStencil.stencil, compareResult))
1008 return TestStatus::fail("Stencil value mismatch! " + compareResult);
1012 return TestStatus::pass("cmdClearDepthStencilImage passed");
1015 class ClearColorAttachmentTestInstance : public ImageClearingTestInstance
1018 ClearColorAttachmentTestInstance (Context& context,
1019 const TestParams& testParams)
1020 : ImageClearingTestInstance(context, testParams)
1022 if (!m_isAttachmentFormat)
1024 TCU_THROW(NotSupportedError, "Format not renderable");
1028 virtual TestStatus iterate (void);
1031 TestStatus ClearColorAttachmentTestInstance::iterate (void)
1033 const VkClearAttachment clearAttachment =
1035 VK_IMAGE_ASPECT_COLOR_BIT, // kImageAspectFlags aspectMask;
1036 0u, // deUint32 colorAttachment;
1037 m_params.clearValue // VkClearValue clearValue;
1040 const VkClearRect clearRect =
1044 { m_params.imageExtent.width, m_params.imageExtent.height }
1045 }, // VkRect2D rect;
1046 0u, // deUint32 baseArrayLayer;
1047 1u // deUint32 layerCount;
1050 beginCommandBuffer(0);
1052 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1053 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1054 0, // VkAccessFlags srcAccessMask
1055 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
1056 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1057 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1058 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); // VkImageLayout newLayout;
1060 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1061 m_vkd.cmdClearAttachments(*m_commandBuffer, 1, &clearAttachment, 1, &clearRect);
1062 m_vkd.cmdEndRenderPass(*m_commandBuffer);
1064 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
1065 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1066 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
1067 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1068 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1069 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
1070 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
1073 submitCommandBuffer();
1075 de::MovePtr<TextureLevel> result = readImage(VK_IMAGE_ASPECT_COLOR_BIT);
1076 std::string compareResult;
1078 for (deUint32 y = 0; y < m_params.imageExtent.height; y++)
1080 for (deUint32 x = 0; x < m_params.imageExtent.width; x++)
1082 if (!comparePixelToColorClearValue(result->getAccess(), x, y, 0, m_params.clearValue.color, compareResult))
1083 return TestStatus::fail("Color value mismatch" + compareResult);
1087 return TestStatus::pass("cmdClearAttachments passed");
1090 class ClearDepthStencilAttachmentTestInstance : public ImageClearingTestInstance
1093 ClearDepthStencilAttachmentTestInstance (Context& context,
1094 const TestParams& testParams)
1095 : ImageClearingTestInstance(context, testParams)
1097 if (!m_isAttachmentFormat)
1099 TCU_THROW(NotSupportedError, "Format not renderable");
1103 virtual TestStatus iterate (void);
1106 TestStatus ClearDepthStencilAttachmentTestInstance::iterate (void)
1108 const VkClearAttachment clearAttachment =
1110 VK_IMAGE_ASPECT_DEPTH_BIT |
1111 VK_IMAGE_ASPECT_STENCIL_BIT, // kImageAspectFlags aspectMask;
1112 0u, // deUint32 colorAttachment;
1113 m_params.clearValue // VkClearValue clearValue;
1116 const VkClearRect clearRect =
1120 { m_params.imageExtent.width, m_params.imageExtent.height }
1121 }, // VkRect2D rect;
1122 0u, // deUint32 baseArrayLayer;
1123 1u // deUint32 layerCount;
1126 beginCommandBuffer(0);
1128 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1129 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1130 0, // VkAccessFlags srcAccessMask
1131 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
1132 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1133 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1134 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); // VkImageLayout newLayout;
1136 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1137 m_vkd.cmdClearAttachments(*m_commandBuffer, 1, &clearAttachment, 1, &clearRect);
1138 m_vkd.cmdEndRenderPass(*m_commandBuffer);
1140 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
1141 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1142 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
1143 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1144 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1145 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
1146 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
1149 submitCommandBuffer();
1151 de::MovePtr<TextureLevel> depthResult;
1152 de::MovePtr<TextureLevel> stencilResult;
1153 bool isDepthFormat = getIsDepthFormat(m_params.imageFormat);
1156 depthResult = readImage(VK_IMAGE_ASPECT_DEPTH_BIT);
1158 const bool isStencilFormat = getIsStencilFormat(m_params.imageFormat);
1160 if (isStencilFormat)
1162 stencilResult = readImage(VK_IMAGE_ASPECT_STENCIL_BIT);
1166 std::string compareResult;
1168 for (deUint32 y = 0; y < m_params.imageExtent.height; y++)
1170 for (deUint32 x = 0; x < m_params.imageExtent.width; x++)
1172 if (isDepthFormat && !comparePixelToDepthClearValue(depthResult->getAccess(), x, y, m_params.clearValue.depthStencil.depth, compareResult))
1173 return TestStatus::fail("Depth value mismatch! " + compareResult);
1175 if (isStencilFormat && !comparePixelToStencilClearValue(stencilResult->getAccess(), x, y, m_params.clearValue.depthStencil.stencil, compareResult))
1176 return TestStatus::fail("Stencil value mismatch! " + compareResult);
1180 return TestStatus::pass("cmdClearAttachments passed");
1183 class PartialClearColorAttachmentTestInstance : public ImageClearingTestInstance
1186 PartialClearColorAttachmentTestInstance (Context& context,
1187 const TestParams& testParams)
1188 : ImageClearingTestInstance(context, testParams)
1190 if (!m_isAttachmentFormat)
1192 TCU_THROW(NotSupportedError, "Format not renderable");
1196 virtual TestStatus iterate (void);
1199 TestStatus PartialClearColorAttachmentTestInstance::iterate (void)
1201 const VkClearAttachment clearAttachment =
1203 VK_IMAGE_ASPECT_COLOR_BIT, // kImageAspectFlags aspectMask;
1204 0u, // deUint32 colorAttachment;
1205 m_params.clearValue // VkClearValue clearValue;
1208 const VkClearRect clearRects[2] =
1212 { 0, (deInt32)(m_params.imageExtent.height / 4) },
1213 { m_params.imageExtent.width, m_params.imageExtent.height / 2}
1214 }, // VkRect2D rect;
1215 0u, // deUint32 baseArrayLayer;
1216 1u // deUint32 layerCount;
1220 { (deInt32)(m_params.imageExtent.width / 4), 0 },
1221 { m_params.imageExtent.width / 2, m_params.imageExtent.height}
1222 }, // VkRect2D rect;
1223 0u, // deUint32 baseArrayLayer;
1224 1u // deUint32 layerCount;
1228 beginCommandBuffer(0);
1230 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1231 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1232 0, // VkAccessFlags srcAccessMask
1233 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask
1234 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1235 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); // VkImageLayout newLayout;
1237 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1238 m_vkd.cmdClearAttachments(*m_commandBuffer, 1, &clearAttachment, 2, clearRects);
1239 m_vkd.cmdEndRenderPass(*m_commandBuffer);
1241 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
1242 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1243 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
1244 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1245 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1246 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
1247 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
1251 submitCommandBuffer();
1253 de::MovePtr<TextureLevel> result = readImage(VK_IMAGE_ASPECT_COLOR_BIT);
1254 std::string compareResult;
1256 for (deUint32 y = 0; y < m_params.imageExtent.height; y++)
1258 for (deUint32 x = 0; x < m_params.imageExtent.width; x++)
1260 if (((x < m_params.imageExtent.width / 4) && (y < m_params.imageExtent.height / 4)) ||
1261 ((x < m_params.imageExtent.width / 4) && (y >= (m_params.imageExtent.height * 3) / 4)) ||
1262 ((x >= (m_params.imageExtent.width * 3) / 4) && (y < m_params.imageExtent.height / 4)) ||
1263 ((x >= (m_params.imageExtent.width * 3) / 4) && (y >= (m_params.imageExtent.height * 3) / 4)))
1265 if (!comparePixelToColorClearValue(result->getAccess(), x, y, 0, m_params.initValue.color, compareResult))
1266 return TestStatus::fail("Color value mismatch! " + compareResult);
1268 else if (!comparePixelToColorClearValue(result->getAccess(), x, y, 0, m_params.clearValue.color, compareResult))
1269 return TestStatus::fail("Color value mismatch! " + compareResult);
1273 return TestStatus::pass("cmdClearAttachments passed");
1276 class PartialClearDepthStencilAttachmentTestInstance : public ImageClearingTestInstance
1279 PartialClearDepthStencilAttachmentTestInstance (Context& context,
1280 const TestParams& testParams)
1281 : ImageClearingTestInstance(context, testParams)
1283 if (!m_isAttachmentFormat)
1285 TCU_THROW(NotSupportedError, "Format not renderable");
1289 virtual TestStatus iterate (void);
1292 TestStatus PartialClearDepthStencilAttachmentTestInstance::iterate (void)
1294 const VkClearAttachment clearAttachment =
1296 VK_IMAGE_ASPECT_DEPTH_BIT |
1297 VK_IMAGE_ASPECT_STENCIL_BIT, // kImageAspectFlags aspectMask;
1298 0u, // deUint32 colorAttachment;
1299 m_params.clearValue // VkClearValue clearValue;
1302 const VkClearRect clearRects[2] =
1306 { 0, (deInt32)(m_params.imageExtent.height / 4) },
1307 { m_params.imageExtent.width, m_params.imageExtent.height / 2}
1308 }, // VkRect2D rect;
1309 0u, // deUint32 baseArrayLayer;
1310 1u // deUint32 layerCount;
1314 { (deInt32)(m_params.imageExtent.width / 4), 0 },
1315 { m_params.imageExtent.width / 2, m_params.imageExtent.height}
1316 }, // VkRect2D rect;
1317 0u, // deUint32 baseArrayLayer;
1318 1u // deUint32 layerCount;
1322 beginCommandBuffer(0);
1324 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1325 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1326 0, // VkAccessFlags srcAccessMask
1327 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask
1328 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1329 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); // VkImageLayout newLayout;
1331 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1332 m_vkd.cmdClearAttachments(*m_commandBuffer, 1, &clearAttachment, 2, clearRects);
1333 m_vkd.cmdEndRenderPass(*m_commandBuffer);
1335 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
1336 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1337 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
1338 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1339 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1340 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
1341 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
1345 submitCommandBuffer();
1347 de::MovePtr<TextureLevel> depthResult;
1348 de::MovePtr<TextureLevel> stencilResult;
1349 bool isDepthFormat = getIsDepthFormat(m_params.imageFormat);
1352 depthResult = readImage(VK_IMAGE_ASPECT_DEPTH_BIT);
1354 const bool isStencilFormat = getIsStencilFormat(m_params.imageFormat);
1356 if (isStencilFormat)
1358 stencilResult = readImage(VK_IMAGE_ASPECT_STENCIL_BIT);
1361 std::string compareResult;
1363 for (deUint32 y = 0; y < m_params.imageExtent.height; y++)
1365 for (deUint32 x = 0; x < m_params.imageExtent.width; x++)
1367 if (((x < m_params.imageExtent.width / 4) && (y < m_params.imageExtent.height / 4)) ||
1368 ((x < m_params.imageExtent.width / 4) && (y >= (m_params.imageExtent.height * 3) / 4)) ||
1369 ((x >= (m_params.imageExtent.width * 3) / 4) && (y < m_params.imageExtent.height / 4)) ||
1370 ((x >= (m_params.imageExtent.width * 3) / 4) && (y >= (m_params.imageExtent.height * 3) / 4)))
1372 if (isDepthFormat && !comparePixelToDepthClearValue(depthResult->getAccess(), x, y, m_params.initValue.depthStencil.depth, compareResult))
1373 return TestStatus::fail("Depth value mismatch! " + compareResult);
1375 if (isStencilFormat && !comparePixelToStencilClearValue(stencilResult->getAccess(), x, y, m_params.initValue.depthStencil.stencil, compareResult))
1376 return TestStatus::fail("Stencil value mismatch! " + compareResult);
1380 if (isDepthFormat && !comparePixelToDepthClearValue(depthResult->getAccess(), x, y, m_params.clearValue.depthStencil.depth, compareResult))
1381 return TestStatus::fail("Depth value mismatch! " + compareResult);
1383 if (isStencilFormat && !comparePixelToStencilClearValue(stencilResult->getAccess(), x, y, m_params.clearValue.depthStencil.stencil, compareResult))
1384 return TestStatus::fail("Stencil value mismatch! " + compareResult);
1389 return TestStatus::pass("cmdClearAttachments passed");
1392 VkClearValue makeClearColorValue (VkFormat format, float r, float g, float b, float a)
1394 const TextureFormat tcuFormat = mapVkFormat(format);
1395 VkClearValue clearValue;
1397 if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_FLOATING_POINT
1398 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_FIXED_POINT
1399 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
1401 clearValue.color.float32[0] = r;
1402 clearValue.color.float32[1] = g;
1403 clearValue.color.float32[2] = b;
1404 clearValue.color.float32[3] = a;
1406 else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
1408 UVec4 maxValues = getFormatMaxUintValue(tcuFormat);
1410 clearValue.color.uint32[0] = (deUint32)((float)maxValues[0] * r);
1411 clearValue.color.uint32[1] = (deUint32)((float)maxValues[1] * g);
1412 clearValue.color.uint32[2] = (deUint32)((float)maxValues[2] * b);
1413 clearValue.color.uint32[3] = (deUint32)((float)maxValues[3] * a);
1415 else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_INTEGER)
1417 IVec4 maxValues = getFormatMaxIntValue(tcuFormat);
1419 clearValue.color.int32[0] = (deUint32)((float)maxValues[0] * r);
1420 clearValue.color.int32[1] = (deUint32)((float)maxValues[1] * g);
1421 clearValue.color.int32[2] = (deUint32)((float)maxValues[2] * b);
1422 clearValue.color.int32[3] = (deUint32)((float)maxValues[3] * a);
1425 DE_FATAL("Unknown channel class");
1430 std::string getFormatCaseName (VkFormat format)
1432 return de::toLower(de::toString(getFormatStr(format)).substr(10));
1435 const char* getImageTypeCaseName (VkImageType type)
1437 const char* s_names[] =
1443 return de::getSizedArrayElement<VK_IMAGE_TYPE_LAST>(s_names, type);
1448 TestCaseGroup* createImageClearingTests (TestContext& testCtx)
1451 de::MovePtr<TestCaseGroup> imageClearingTests (new TestCaseGroup(testCtx, "image_clearing", "Image Clearing Tests"));
1453 de::MovePtr<TestCaseGroup> colorImageClearTests (new TestCaseGroup(testCtx, "clear_color_image", "Color Image Clear Tests"));
1454 de::MovePtr<TestCaseGroup> depthStencilImageClearTests (new TestCaseGroup(testCtx, "clear_depth_stencil_image", "Color Depth/Stencil Image Tests"));
1455 de::MovePtr<TestCaseGroup> colorAttachmentClearTests (new TestCaseGroup(testCtx, "clear_color_attachment", "Color Color Attachment Tests"));
1456 de::MovePtr<TestCaseGroup> depthStencilAttachmentClearTests (new TestCaseGroup(testCtx, "clear_depth_stencil_attachment", "Color Depth/Stencil Attachment Tests"));
1457 de::MovePtr<TestCaseGroup> partialColorAttachmentClearTests (new TestCaseGroup(testCtx, "partial_clear_color_attachment", "Clear Partial Color Attachment Tests"));
1458 de::MovePtr<TestCaseGroup> partialDepthStencilAttachmentClearTests (new TestCaseGroup(testCtx, "partial_clear_depth_stencil_attachment", "Clear Partial Depth/Stencil Attachment Tests"));
1460 // Some formats are commented out due to the tcu::TextureFormat does not support them yet.
1461 const VkFormat colorImageFormatsToTest[] =
1463 VK_FORMAT_R4G4_UNORM_PACK8,
1464 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
1465 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
1466 VK_FORMAT_R5G6B5_UNORM_PACK16,
1467 VK_FORMAT_B5G6R5_UNORM_PACK16,
1468 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
1469 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
1470 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
1473 VK_FORMAT_R8_USCALED,
1474 VK_FORMAT_R8_SSCALED,
1478 VK_FORMAT_R8G8_UNORM,
1479 VK_FORMAT_R8G8_SNORM,
1480 VK_FORMAT_R8G8_USCALED,
1481 VK_FORMAT_R8G8_SSCALED,
1482 VK_FORMAT_R8G8_UINT,
1483 VK_FORMAT_R8G8_SINT,
1484 VK_FORMAT_R8G8_SRGB,
1485 VK_FORMAT_R8G8B8_UNORM,
1486 VK_FORMAT_R8G8B8_SNORM,
1487 VK_FORMAT_R8G8B8_USCALED,
1488 VK_FORMAT_R8G8B8_SSCALED,
1489 VK_FORMAT_R8G8B8_UINT,
1490 VK_FORMAT_R8G8B8_SINT,
1491 VK_FORMAT_R8G8B8_SRGB,
1492 VK_FORMAT_B8G8R8_UNORM,
1493 VK_FORMAT_B8G8R8_SNORM,
1494 VK_FORMAT_B8G8R8_USCALED,
1495 VK_FORMAT_B8G8R8_SSCALED,
1496 VK_FORMAT_B8G8R8_UINT,
1497 VK_FORMAT_B8G8R8_SINT,
1498 VK_FORMAT_B8G8R8_SRGB,
1499 VK_FORMAT_R8G8B8A8_UNORM,
1500 VK_FORMAT_R8G8B8A8_SNORM,
1501 VK_FORMAT_R8G8B8A8_USCALED,
1502 VK_FORMAT_R8G8B8A8_SSCALED,
1503 VK_FORMAT_R8G8B8A8_UINT,
1504 VK_FORMAT_R8G8B8A8_SINT,
1505 VK_FORMAT_R8G8B8A8_SRGB,
1506 VK_FORMAT_B8G8R8A8_UNORM,
1507 VK_FORMAT_B8G8R8A8_SNORM,
1508 VK_FORMAT_B8G8R8A8_USCALED,
1509 VK_FORMAT_B8G8R8A8_SSCALED,
1510 VK_FORMAT_B8G8R8A8_UINT,
1511 VK_FORMAT_B8G8R8A8_SINT,
1512 VK_FORMAT_B8G8R8A8_SRGB,
1513 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
1514 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
1515 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
1516 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
1517 VK_FORMAT_A8B8G8R8_UINT_PACK32,
1518 VK_FORMAT_A8B8G8R8_SINT_PACK32,
1519 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
1520 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
1521 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
1522 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
1523 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
1524 VK_FORMAT_A2R10G10B10_UINT_PACK32,
1525 VK_FORMAT_A2R10G10B10_SINT_PACK32,
1526 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
1527 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
1528 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
1529 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
1530 VK_FORMAT_A2B10G10R10_UINT_PACK32,
1531 VK_FORMAT_A2B10G10R10_SINT_PACK32,
1532 VK_FORMAT_R16_UNORM,
1533 VK_FORMAT_R16_SNORM,
1534 VK_FORMAT_R16_USCALED,
1535 VK_FORMAT_R16_SSCALED,
1538 VK_FORMAT_R16_SFLOAT,
1539 VK_FORMAT_R16G16_UNORM,
1540 VK_FORMAT_R16G16_SNORM,
1541 VK_FORMAT_R16G16_USCALED,
1542 VK_FORMAT_R16G16_SSCALED,
1543 VK_FORMAT_R16G16_UINT,
1544 VK_FORMAT_R16G16_SINT,
1545 VK_FORMAT_R16G16_SFLOAT,
1546 VK_FORMAT_R16G16B16_UNORM,
1547 VK_FORMAT_R16G16B16_SNORM,
1548 VK_FORMAT_R16G16B16_USCALED,
1549 VK_FORMAT_R16G16B16_SSCALED,
1550 VK_FORMAT_R16G16B16_UINT,
1551 VK_FORMAT_R16G16B16_SINT,
1552 VK_FORMAT_R16G16B16_SFLOAT,
1553 VK_FORMAT_R16G16B16A16_UNORM,
1554 VK_FORMAT_R16G16B16A16_SNORM,
1555 VK_FORMAT_R16G16B16A16_USCALED,
1556 VK_FORMAT_R16G16B16A16_SSCALED,
1557 VK_FORMAT_R16G16B16A16_UINT,
1558 VK_FORMAT_R16G16B16A16_SINT,
1559 VK_FORMAT_R16G16B16A16_SFLOAT,
1562 VK_FORMAT_R32_SFLOAT,
1563 VK_FORMAT_R32G32_UINT,
1564 VK_FORMAT_R32G32_SINT,
1565 VK_FORMAT_R32G32_SFLOAT,
1566 VK_FORMAT_R32G32B32_UINT,
1567 VK_FORMAT_R32G32B32_SINT,
1568 VK_FORMAT_R32G32B32_SFLOAT,
1569 VK_FORMAT_R32G32B32A32_UINT,
1570 VK_FORMAT_R32G32B32A32_SINT,
1571 VK_FORMAT_R32G32B32A32_SFLOAT,
1572 // VK_FORMAT_R64_UINT,
1573 // VK_FORMAT_R64_SINT,
1574 // VK_FORMAT_R64_SFLOAT,
1575 // VK_FORMAT_R64G64_UINT,
1576 // VK_FORMAT_R64G64_SINT,
1577 // VK_FORMAT_R64G64_SFLOAT,
1578 // VK_FORMAT_R64G64B64_UINT,
1579 // VK_FORMAT_R64G64B64_SINT,
1580 // VK_FORMAT_R64G64B64_SFLOAT,
1581 // VK_FORMAT_R64G64B64A64_UINT,
1582 // VK_FORMAT_R64G64B64A64_SINT,
1583 // VK_FORMAT_R64G64B64A64_SFLOAT,
1584 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
1585 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
1586 // VK_FORMAT_BC1_RGB_UNORM_BLOCK,
1587 // VK_FORMAT_BC1_RGB_SRGB_BLOCK,
1588 // VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
1589 // VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
1590 // VK_FORMAT_BC2_UNORM_BLOCK,
1591 // VK_FORMAT_BC2_SRGB_BLOCK,
1592 // VK_FORMAT_BC3_UNORM_BLOCK,
1593 // VK_FORMAT_BC3_SRGB_BLOCK,
1594 // VK_FORMAT_BC4_UNORM_BLOCK,
1595 // VK_FORMAT_BC4_SNORM_BLOCK,
1596 // VK_FORMAT_BC5_UNORM_BLOCK,
1597 // VK_FORMAT_BC5_SNORM_BLOCK,
1598 // VK_FORMAT_BC6H_UFLOAT_BLOCK,
1599 // VK_FORMAT_BC6H_SFLOAT_BLOCK,
1600 // VK_FORMAT_BC7_UNORM_BLOCK,
1601 // VK_FORMAT_BC7_SRGB_BLOCK,
1602 // VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
1603 // VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
1604 // VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
1605 // VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
1606 // VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
1607 // VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
1608 // VK_FORMAT_EAC_R11_UNORM_BLOCK,
1609 // VK_FORMAT_EAC_R11_SNORM_BLOCK,
1610 // VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
1611 // VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
1612 // VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
1613 // VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
1614 // VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
1615 // VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
1616 // VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
1617 // VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
1618 // VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
1619 // VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
1620 // VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
1621 // VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
1622 // VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
1623 // VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
1624 // VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
1625 // VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
1626 // VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
1627 // VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
1628 // VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
1629 // VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
1630 // VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
1631 // VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
1632 // VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
1633 // VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
1634 // VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
1635 // VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
1636 // VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
1637 // VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
1638 // VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
1639 // VK_FORMAT_ASTC_12x12_SRGB_BLOCK
1641 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
1643 const VkFormat depthStencilImageFormatsToTest[] =
1645 VK_FORMAT_D16_UNORM,
1646 VK_FORMAT_X8_D24_UNORM_PACK32,
1647 VK_FORMAT_D32_SFLOAT,
1649 VK_FORMAT_D16_UNORM_S8_UINT,
1650 VK_FORMAT_D24_UNORM_S8_UINT,
1651 VK_FORMAT_D32_SFLOAT_S8_UINT
1653 const size_t numOfDepthStencilImageFormatsToTest = DE_LENGTH_OF_ARRAY(depthStencilImageFormatsToTest);
1656 const VkImageType imageTypesToTest[] =
1662 const size_t numOfImageTypesToTest = DE_LENGTH_OF_ARRAY(imageTypesToTest);
1664 const VkExtent3D imageDimensionsByType[] =
1671 TestParams colorImageTestParams;
1673 for (size_t imageTypeIndex = 0; imageTypeIndex < numOfImageTypesToTest; ++imageTypeIndex)
1675 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
1677 colorImageTestParams.imageType = imageTypesToTest[imageTypeIndex];
1678 colorImageTestParams.imageFormat = colorImageFormatsToTest[imageFormatIndex];
1679 colorImageTestParams.imageExtent = imageDimensionsByType[imageTypeIndex];
1680 colorImageTestParams.initValue = makeClearColorValue(colorImageTestParams.imageFormat, 0.2f, 0.1f, 0.7f, 0.8f);
1681 colorImageTestParams.clearValue = makeClearColorValue(colorImageTestParams.imageFormat, 0.1f, 0.5f, 0.3f, 0.9f);
1683 std::ostringstream testCaseName;
1684 testCaseName << getImageTypeCaseName(colorImageTestParams.imageType);
1685 testCaseName << "_" << getFormatCaseName(colorImageTestParams.imageFormat);
1687 colorImageClearTests->addChild(new InstanceFactory1<ClearColorImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Clear Color Image", colorImageTestParams));
1691 imageClearingTests->addChild(colorImageClearTests.release());
1695 TestParams depthStencilImageTestParams =
1697 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1698 depthStencilImageFormatsToTest[0], // VkFormat format;
1699 { 256, 256, 1 }, // VkExtent3D extent;
1700 makeClearValueDepthStencil(0.5f, 0x03), // VkClearValue initValue
1701 makeClearValueDepthStencil(0.1f, 0x06) // VkClearValue clearValue
1704 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
1706 depthStencilImageTestParams.imageFormat = depthStencilImageFormatsToTest[imageFormatIndex];
1708 std::ostringstream testCaseName;
1709 testCaseName << getImageTypeCaseName(depthStencilImageTestParams.imageType);
1710 testCaseName << "_" << getFormatCaseName(depthStencilImageTestParams.imageFormat);
1712 depthStencilImageClearTests->addChild(new InstanceFactory1<ClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Clear Depth/Stencil Image", depthStencilImageTestParams));
1715 imageClearingTests->addChild(depthStencilImageClearTests.release());
1719 TestParams colorAttachmentTestParams =
1721 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1722 colorImageFormatsToTest[0], // VkFormat format;
1723 { 256, 256, 1 }, // VkExtent3D extent;
1724 makeClearValueColorU32(0, 0, 0, 0), // VkClearValue initValue
1725 makeClearValueColorU32(0, 0, 0, 0) // VkClearValue clearValue
1728 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
1730 colorAttachmentTestParams.imageFormat = colorImageFormatsToTest[imageFormatIndex];
1731 colorAttachmentTestParams.initValue = makeClearColorValue(colorAttachmentTestParams.imageFormat, 0.2f, 0.1f, 0.7f, 0.8f);
1732 colorAttachmentTestParams.clearValue = makeClearColorValue(colorAttachmentTestParams.imageFormat, 0.1f, 0.5f, 0.3f, 0.9f);
1734 std::ostringstream testCaseName;
1735 testCaseName << getImageTypeCaseName(colorAttachmentTestParams.imageType);
1736 testCaseName << "_" << getFormatCaseName(colorAttachmentTestParams.imageFormat);
1738 colorAttachmentClearTests->addChild(new InstanceFactory1<ClearColorAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Clear Color Attachment", colorAttachmentTestParams));
1741 imageClearingTests->addChild(colorAttachmentClearTests.release());
1745 TestParams depthStencilAttachmentTestParams =
1747 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1748 depthStencilImageFormatsToTest[0], // VkFormat format;
1749 { 256, 256, 1 }, // VkExtent3D extent;
1750 makeClearValueDepthStencil(0.5f, 0x03), // VkClearValue initValue
1751 makeClearValueDepthStencil(0.1f, 0x06) // VkClearValue clearValue
1754 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
1756 depthStencilAttachmentTestParams.imageFormat = depthStencilImageFormatsToTest[imageFormatIndex];
1758 std::ostringstream testCaseName;
1759 testCaseName << getImageTypeCaseName(depthStencilAttachmentTestParams.imageType);
1760 testCaseName << "_" << getFormatCaseName(depthStencilAttachmentTestParams.imageFormat);
1762 depthStencilAttachmentClearTests->addChild(new InstanceFactory1<ClearDepthStencilAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Clear Depth/Stencil Attachment", depthStencilAttachmentTestParams));
1765 imageClearingTests->addChild(depthStencilAttachmentClearTests.release());
1769 TestParams colorAttachmentTestParams =
1771 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1772 colorImageFormatsToTest[0], // VkFormat format;
1773 { 256, 256, 1 }, // VkExtent3D extent;
1774 makeClearValueColorU32(0, 0, 0, 0), // VkClearValue initValue
1775 makeClearValueColorU32(0, 0, 0, 0) // VkClearValue clearValue
1778 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
1780 colorAttachmentTestParams.imageFormat = colorImageFormatsToTest[imageFormatIndex];
1781 colorAttachmentTestParams.initValue = makeClearColorValue(colorAttachmentTestParams.imageFormat, 0.2f, 0.1f, 0.7f, 0.8f);
1782 colorAttachmentTestParams.clearValue = makeClearColorValue(colorAttachmentTestParams.imageFormat, 0.1f, 0.5f, 0.3f, 0.9f);
1784 std::ostringstream testCaseName;
1785 testCaseName << getImageTypeCaseName(colorAttachmentTestParams.imageType);
1786 testCaseName << "_" << getFormatCaseName(colorAttachmentTestParams.imageFormat);
1788 partialColorAttachmentClearTests->addChild(new InstanceFactory1<PartialClearColorAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Partial Clear Color Attachment", colorAttachmentTestParams));
1791 imageClearingTests->addChild(partialColorAttachmentClearTests.release());
1795 TestParams depthStencilAttachmentTestParams =
1797 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1798 depthStencilImageFormatsToTest[0], // VkFormat format;
1799 { 256, 256, 1 }, // VkExtent3D extent;
1800 makeClearValueDepthStencil(0.5f, 0x03), // VkClearValue initValue
1801 makeClearValueDepthStencil(0.1f, 0x06) // VkClearValue clearValue
1804 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
1806 depthStencilAttachmentTestParams.imageFormat = depthStencilImageFormatsToTest[imageFormatIndex];
1808 std::ostringstream testCaseName;
1809 testCaseName << getImageTypeCaseName(depthStencilAttachmentTestParams.imageType);
1810 testCaseName << "_" << getFormatCaseName(depthStencilAttachmentTestParams.imageFormat);
1812 partialDepthStencilAttachmentClearTests->addChild(new InstanceFactory1<PartialClearDepthStencilAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Parital Clear Depth/Stencil Attachment", depthStencilAttachmentTestParams));
1815 imageClearingTests->addChild(partialDepthStencilAttachmentClearTests.release());
1818 return imageClearingTests.release();