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"
33 #include "vkImageUtil.hpp"
34 #include "vkMemUtil.hpp"
35 #include "vktTestCase.hpp"
36 #include "vktTestCaseUtil.hpp"
37 #include "vkQueryUtil.hpp"
38 #include "vkRefUtil.hpp"
39 #include "vkTypeUtil.hpp"
40 #include "tcuImageCompare.hpp"
41 #include "tcuTexture.hpp"
42 #include "tcuTextureUtil.hpp"
43 #include "tcuVectorType.hpp"
44 #include "tcuTexture.hpp"
45 #include "tcuFloat.hpp"
46 #include "tcuTestLog.hpp"
47 #include "tcuVectorUtil.hpp"
63 VkExtent3D getMipLevelExtent (VkExtent3D baseExtent, const deUint32 mipLevel)
65 baseExtent.width = std::max(baseExtent.width >> mipLevel, 1u);
66 baseExtent.height = std::max(baseExtent.height >> mipLevel, 1u);
67 baseExtent.depth = std::max(baseExtent.depth >> mipLevel, 1u);
71 deUint32 getNumMipLevels (const VkExtent3D& baseExtent, const deUint32 maxMipLevels)
73 const deUint32 widestEdge = std::max(std::max(baseExtent.width, baseExtent.height), baseExtent.depth);
74 return std::min(static_cast<deUint32>(deFloatLog2(static_cast<float>(widestEdge))) + 1u, maxMipLevels);
77 deUint32 greatestCommonDivisor (const deUint32 a, const deUint32 b)
93 deUint32 lowestCommonMultiple (const deUint32 a, const deUint32 b)
95 return (a*b)/greatestCommonDivisor(a,b);
98 std::vector<deUint32> getImageMipLevelSizes (const deUint32 pixelSize, const VkExtent3D& baseExtent, const deUint32 numMipLevels, const deUint32 perLevelAlignment = 1u)
100 std::vector<deUint32> results(numMipLevels);
102 for (deUint32 mipLevel = 0; mipLevel < numMipLevels; ++mipLevel)
104 const VkExtent3D extent = getMipLevelExtent(baseExtent, mipLevel);
105 results[mipLevel] = static_cast<deUint32>(extent.width * extent.height * extent.depth * pixelSize);
106 results[mipLevel] = ((results[mipLevel] + perLevelAlignment-1) / perLevelAlignment) * perLevelAlignment;
112 //! Check if a point lies in a cross-like area.
113 inline bool isInClearRange (const UVec4& clearCoords, const deUint32 x, const deUint32 y)
115 return !((x < clearCoords[0] && y < clearCoords[1]) ||
116 (x < clearCoords[0] && y >= clearCoords[3]) ||
117 (x >= clearCoords[2] && y < clearCoords[1]) ||
118 (x >= clearCoords[2] && y >= clearCoords[3]));
121 // This method is copied from the vktRenderPassTests.cpp. It should be moved to a common place.
122 int calcFloatDiff (float a, float b)
124 const int asign = Float32(a).sign();
125 const int bsign = Float32(a).sign();
127 const deUint32 avalue = (Float32(a).bits() & ((0x1u << 31u) - 1u));
128 const deUint32 bvalue = (Float32(b).bits() & ((0x1u << 31u) - 1u));
131 return avalue + bvalue + 1u;
132 else if (avalue < bvalue)
133 return bvalue - avalue;
135 return avalue - bvalue;
138 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
139 bool comparePixelToDepthClearValue (const ConstPixelBufferAccess& access,
143 std::string& stringResult)
145 const TextureFormat format = getEffectiveDepthStencilTextureFormat(access.getFormat(), Sampler::MODE_DEPTH);
146 const TextureChannelClass channelClass = getTextureChannelClass(format.type);
148 switch (channelClass)
150 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
151 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
153 const int bitDepth = getTextureFormatBitDepth(format).x();
154 const float depth = access.getPixDepth(x, y);
155 const float threshold = 2.0f / (float)((1 << bitDepth) - 1);
156 const bool result = deFloatAbs(depth - ref) <= threshold;
161 s << "Ref:" << ref << " Threshold:" << threshold << " Depth:" << depth;
162 stringResult = s.str();
168 case TEXTURECHANNELCLASS_FLOATING_POINT:
170 const float depth = access.getPixDepth(x, y);
171 const int mantissaBits = getTextureFormatMantissaBitDepth(format).x();
172 const int threshold = 10 * 1 << (23 - mantissaBits);
174 DE_ASSERT(mantissaBits <= 23);
176 const bool result = calcFloatDiff(depth, ref) <= threshold;
180 float floatThreshold = Float32((deUint32)threshold).asFloat();
183 s << "Ref:" << ref << " Threshold:" << floatThreshold << " Depth:" << depth;
184 stringResult = s.str();
191 DE_FATAL("Invalid channel class");
196 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
197 bool comparePixelToStencilClearValue (const ConstPixelBufferAccess& access,
201 std::string& stringResult)
203 const deUint32 stencil = access.getPixStencil(x, y);
204 const bool result = stencil == ref;
209 s << "Ref:" << ref << " Threshold:0" << " Stencil:" << stencil;
210 stringResult = s.str();
216 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
217 bool comparePixelToColorClearValue (const ConstPixelBufferAccess& access,
221 const VkClearColorValue& ref,
222 std::string& stringResult)
224 const TextureFormat format = access.getFormat();
225 const TextureChannelClass channelClass = getTextureChannelClass(format.type);
226 const BVec4 channelMask = getTextureFormatChannelMask(format);
228 switch (channelClass)
230 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
231 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
233 const IVec4 bitDepth (getTextureFormatBitDepth(format));
234 const Vec4 resColor (access.getPixel(x, y, z));
235 Vec4 refColor (ref.float32[0],
239 const int modifier = (channelClass == TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT) ? 0 : 1;
240 const Vec4 threshold (bitDepth[0] > 0 ? 1.0f / ((float)(1 << (bitDepth[0] - modifier)) - 1.0f) : 1.0f,
241 bitDepth[1] > 0 ? 1.0f / ((float)(1 << (bitDepth[1] - modifier)) - 1.0f) : 1.0f,
242 bitDepth[2] > 0 ? 1.0f / ((float)(1 << (bitDepth[2] - modifier)) - 1.0f) : 1.0f,
243 bitDepth[3] > 0 ? 1.0f / ((float)(1 << (bitDepth[3] - modifier)) - 1.0f) : 1.0f);
245 if (isSRGB(access.getFormat()))
246 refColor = linearToSRGB(refColor);
248 const bool result = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold), channelMask), channelMask));
253 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold << " Color:" << resColor;
254 stringResult = s.str();
260 case TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
262 const UVec4 resColor (access.getPixelUint(x, y, z));
263 const UVec4 refColor (ref.uint32[0],
267 const UVec4 threshold (1);
269 const bool result = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold), channelMask), channelMask));
274 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold << " Color:" << resColor;
275 stringResult = s.str();
281 case TEXTURECHANNELCLASS_SIGNED_INTEGER:
283 const IVec4 resColor (access.getPixelInt(x, y, z));
284 const IVec4 refColor (ref.int32[0],
288 const IVec4 threshold (1);
290 const bool result = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold), channelMask), channelMask));
295 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold << " Color:" << resColor;
296 stringResult = s.str();
302 case TEXTURECHANNELCLASS_FLOATING_POINT:
304 const Vec4 resColor (access.getPixel(x, y, z));
305 const Vec4 refColor (ref.float32[0],
309 const IVec4 mantissaBits (getTextureFormatMantissaBitDepth(format));
310 const IVec4 threshold (10 * IVec4(1) << (23 - mantissaBits));
312 DE_ASSERT(allEqual(greaterThanEqual(threshold, IVec4(0)), BVec4(true)));
314 for (int ndx = 0; ndx < 4; ndx++)
316 const bool result = !(calcFloatDiff(resColor[ndx], refColor[ndx]) > threshold[ndx] && channelMask[ndx]);
320 float floatThreshold = Float32((deUint32)(threshold)[0]).asFloat();
321 Vec4 thresholdVec4 (floatThreshold,
326 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << thresholdVec4 << " Color:" << resColor;
327 stringResult = s.str();
337 DE_FATAL("Invalid channel class");
344 bool useSingleMipLevel; //!< only mip level 0, otherwise up to maxMipLevels
345 VkImageType imageType;
346 VkFormat imageFormat;
347 VkExtent3D imageExtent;
348 VkClearValue initValue;
349 VkClearValue clearValue[2]; //!< the second value is used with more than one mip map
352 class ImageClearingTestInstance : public vkt::TestInstance
355 ImageClearingTestInstance (Context& context,
356 const TestParams& testParams);
358 Move<VkCommandPool> createCommandPool (VkCommandPoolCreateFlags commandPoolCreateFlags) const;
359 Move<VkCommandBuffer> allocatePrimaryCommandBuffer (VkCommandPool commandPool) const;
360 Move<VkImage> createImage (VkImageType imageType, VkFormat format, VkExtent3D extent, VkImageUsageFlags usage) const;
361 Move<VkImageView> createImageView (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask) const;
362 Move<VkRenderPass> createRenderPass (VkFormat format) const;
363 Move<VkFramebuffer> createFrameBuffer (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight) const;
365 void beginCommandBuffer (VkCommandBufferUsageFlags usageFlags) const;
366 void endCommandBuffer (void) const;
367 void submitCommandBuffer (void) const;
368 void beginRenderPass (VkSubpassContents content, VkClearValue clearValue) const;
370 void pipelineImageBarrier (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout) const;
371 de::MovePtr<TextureLevelPyramid> readImage (VkImageAspectFlags aspectMask) const;
372 tcu::TestStatus verifyResultImage (const std::string& successMessage, const UVec4& clearCoords = UVec4()) const;
375 VkImageViewType getCorrespondingImageViewType (VkImageType imageType) const;
376 VkImageUsageFlags getImageUsageFlags (VkFormat format) const;
377 VkImageAspectFlags getImageAspectFlags (VkFormat format) const;
378 bool getIsAttachmentFormat (VkFormat format) const;
379 bool getIsStencilFormat (VkFormat format) const;
380 bool getIsDepthFormat (VkFormat format) const;
381 VkImageFormatProperties getImageFormatProperties (void) const;
382 de::MovePtr<Allocation> allocateAndBindImageMemory (VkImage image) const;
384 const TestParams& m_params;
385 const VkDevice m_device;
386 const InstanceInterface& m_vki;
387 const DeviceInterface& m_vkd;
388 const VkQueue m_queue;
389 const deUint32 m_queueFamilyIndex;
390 Allocator& m_allocator;
392 const bool m_isAttachmentFormat;
393 const VkImageUsageFlags m_imageUsageFlags;
394 const VkImageAspectFlags m_imageAspectFlags;
395 const VkImageFormatProperties m_imageFormatProperties;
396 const deUint32 m_imageMipLevels;
397 const deUint32 m_thresholdMipLevel;
399 Unique<VkCommandPool> m_commandPool;
400 Unique<VkCommandBuffer> m_commandBuffer;
402 Unique<VkImage> m_image;
403 de::MovePtr<Allocation> m_imageMemory;
404 Unique<VkImageView> m_imageView;
405 Unique<VkRenderPass> m_renderPass;
406 Unique<VkFramebuffer> m_frameBuffer;
409 ImageClearingTestInstance::ImageClearingTestInstance (Context& context, const TestParams& params)
410 : TestInstance (context)
412 , m_device (context.getDevice())
413 , m_vki (context.getInstanceInterface())
414 , m_vkd (context.getDeviceInterface())
415 , m_queue (context.getUniversalQueue())
416 , m_queueFamilyIndex (context.getUniversalQueueFamilyIndex())
417 , m_allocator (context.getDefaultAllocator())
418 , m_isAttachmentFormat (getIsAttachmentFormat(params.imageFormat))
419 , m_imageUsageFlags (getImageUsageFlags(params.imageFormat))
420 , m_imageAspectFlags (getImageAspectFlags(params.imageFormat))
421 , m_imageFormatProperties (getImageFormatProperties())
422 , m_imageMipLevels (params.useSingleMipLevel ? 1u : getNumMipLevels(params.imageExtent, m_imageFormatProperties.maxMipLevels))
423 , m_thresholdMipLevel (std::max(m_imageMipLevels / 2u, 1u))
424 , m_commandPool (createCommandPool(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT))
425 , m_commandBuffer (allocatePrimaryCommandBuffer(*m_commandPool))
427 , m_image (createImage(params.imageType,
432 , m_imageMemory (allocateAndBindImageMemory(*m_image))
433 , m_imageView (m_isAttachmentFormat ? createImageView(*m_image,
434 getCorrespondingImageViewType(params.imageType),
436 m_imageAspectFlags) : vk::Move<VkImageView>())
438 , m_renderPass (m_isAttachmentFormat ? createRenderPass(params.imageFormat) : vk::Move<vk::VkRenderPass>())
439 , m_frameBuffer (m_isAttachmentFormat ? createFrameBuffer(*m_imageView, *m_renderPass, params.imageExtent.width, params.imageExtent.height) : vk::Move<vk::VkFramebuffer>())
443 VkImageViewType ImageClearingTestInstance::getCorrespondingImageViewType (VkImageType imageType) const
447 case VK_IMAGE_TYPE_1D:
448 return VK_IMAGE_VIEW_TYPE_1D;
449 case VK_IMAGE_TYPE_2D:
450 return VK_IMAGE_VIEW_TYPE_2D;
451 case VK_IMAGE_TYPE_3D:
452 return VK_IMAGE_VIEW_TYPE_3D;
454 DE_FATAL("Unknown image type!");
457 return VK_IMAGE_VIEW_TYPE_2D;
460 VkImageUsageFlags ImageClearingTestInstance::getImageUsageFlags (VkFormat format) const
462 VkImageUsageFlags commonFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
464 if (m_isAttachmentFormat)
466 if (isDepthStencilFormat(format))
467 return commonFlags | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
469 return commonFlags | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
474 VkImageAspectFlags ImageClearingTestInstance::getImageAspectFlags (VkFormat format) const
476 VkImageAspectFlags imageAspectFlags = 0;
478 if (getIsDepthFormat(format))
479 imageAspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
481 if (getIsStencilFormat(format))
482 imageAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
484 if (imageAspectFlags == 0)
485 imageAspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
487 return imageAspectFlags;
490 bool ImageClearingTestInstance::getIsAttachmentFormat (VkFormat format) const
492 const VkFormatProperties props = vk::getPhysicalDeviceFormatProperties(m_vki, m_context.getPhysicalDevice(), format);
494 return (props.optimalTilingFeatures & (vk::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) != 0;
497 bool ImageClearingTestInstance::getIsStencilFormat (VkFormat format) const
499 const TextureFormat tcuFormat = mapVkFormat(format);
501 if (tcuFormat.order == TextureFormat::S || tcuFormat.order == TextureFormat::DS)
507 bool ImageClearingTestInstance::getIsDepthFormat (VkFormat format) const
509 const TextureFormat tcuFormat = mapVkFormat(format);
511 if (tcuFormat.order == TextureFormat::D || tcuFormat.order == TextureFormat::DS)
517 VkImageFormatProperties ImageClearingTestInstance::getImageFormatProperties (void) const
519 VkImageFormatProperties properties;
520 const VkResult result = m_vki.getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(), m_params.imageFormat, m_params.imageType,
521 VK_IMAGE_TILING_OPTIMAL, m_imageUsageFlags, (VkImageCreateFlags)0, &properties);
523 if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
524 TCU_THROW(NotSupportedError, "Format not supported");
529 de::MovePtr<Allocation> ImageClearingTestInstance::allocateAndBindImageMemory (VkImage image) const
531 de::MovePtr<Allocation> imageMemory (m_allocator.allocate(getImageMemoryRequirements(m_vkd, m_device, image), MemoryRequirement::Any));
532 VK_CHECK(m_vkd.bindImageMemory(m_device, image, imageMemory->getMemory(), imageMemory->getOffset()));
536 Move<VkCommandPool> ImageClearingTestInstance::createCommandPool (VkCommandPoolCreateFlags commandPoolCreateFlags) const
538 const VkCommandPoolCreateInfo cmdPoolCreateInfo =
540 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
541 DE_NULL, // const void* pNext;
542 commandPoolCreateFlags, // VkCommandPoolCreateFlags flags;
543 m_queueFamilyIndex // deUint32 queueFamilyIndex;
546 return vk::createCommandPool(m_vkd, m_device, &cmdPoolCreateInfo, DE_NULL);
549 Move<VkCommandBuffer> ImageClearingTestInstance::allocatePrimaryCommandBuffer (VkCommandPool commandPool) const
551 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
553 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
554 DE_NULL, // const void* pNext;
555 commandPool, // VkCommandPool commandPool;
556 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
557 1 // deUint32 commandBufferCount;
560 return vk::allocateCommandBuffer(m_vkd, m_device, &cmdBufferAllocateInfo);
563 Move<VkImage> ImageClearingTestInstance::createImage (VkImageType imageType, VkFormat format, VkExtent3D extent, VkImageUsageFlags usage) const
565 const VkImageCreateInfo imageCreateInfo =
567 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
568 DE_NULL, // const void* pNext;
569 0u, // VkImageCreateFlags flags;
570 imageType, // VkImageType imageType;
571 format, // VkFormat format;
572 extent, // VkExtent3D extent;
573 m_imageMipLevels, // deUint32 mipLevels;
574 1u, // deUint32 arrayLayers;
575 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
576 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
577 usage, // VkImageUsageFlags usage;
578 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
579 1u, // deUint32 queueFamilyIndexCount;
580 &m_queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
581 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
584 return vk::createImage(m_vkd, m_device, &imageCreateInfo, DE_NULL);
587 Move<VkImageView> ImageClearingTestInstance::createImageView (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask) const
589 const VkImageViewCreateInfo imageViewCreateInfo =
591 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
592 DE_NULL, // const void* pNext;
593 0u, // VkImageViewCreateFlags flags;
594 image, // VkImage image;
595 viewType, // VkImageViewType viewType;
596 format, // VkFormat format;
598 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle r;
599 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle g;
600 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle b;
601 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle a;
602 }, // VkComponentMapping components;
604 aspectMask, // VkImageAspectFlags aspectMask;
605 0u, // deUint32 baseMipLevel;
606 1u, // deUint32 mipLevels;
607 0u, // deUint32 baseArrayLayer;
608 1u, // deUint32 arraySize;
609 }, // VkImageSubresourceRange subresourceRange;
612 return vk::createImageView(m_vkd, m_device, &imageViewCreateInfo, DE_NULL);
615 Move<VkRenderPass> ImageClearingTestInstance::createRenderPass (VkFormat format) const
617 VkImageLayout imageLayout;
619 if (isDepthStencilFormat(format))
620 imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
622 imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
624 const VkAttachmentDescription attachmentDesc =
626 0u, // VkAttachmentDescriptionFlags flags;
627 format, // VkFormat format;
628 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
629 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
630 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
631 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp stencilLoadOp;
632 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp;
633 imageLayout, // VkImageLayout initialLayout;
634 imageLayout, // VkImageLayout finalLayout;
637 const VkAttachmentDescription attachments[1] =
642 const VkAttachmentReference attachmentRef =
644 0u, // deUint32 attachment;
645 imageLayout, // VkImageLayout layout;
648 const VkAttachmentReference* pColorAttachments = DE_NULL;
649 const VkAttachmentReference* pDepthStencilAttachment = DE_NULL;
650 deUint32 colorAttachmentCount = 1;
652 if (isDepthStencilFormat(format))
654 colorAttachmentCount = 0;
655 pDepthStencilAttachment = &attachmentRef;
659 colorAttachmentCount = 1;
660 pColorAttachments = &attachmentRef;
663 const VkSubpassDescription subpassDesc[1] =
666 0u, // VkSubpassDescriptionFlags flags;
667 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
668 0u, // deUint32 inputAttachmentCount;
669 DE_NULL, // const VkAttachmentReference* pInputAttachments;
670 colorAttachmentCount, // deUint32 colorAttachmentCount;
671 pColorAttachments, // const VkAttachmentReference* pColorAttachments;
672 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
673 pDepthStencilAttachment, // const VkAttachmentReference* pDepthStencilAttachment;
674 0u, // deUint32 preserveAttachmentCount;
675 DE_NULL, // const VkAttachmentReference* pPreserveAttachments;
679 const VkRenderPassCreateInfo renderPassCreateInfo =
681 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
682 DE_NULL, // const void* pNext;
683 0u, // VkRenderPassCreateFlags flags;
684 1u, // deUint32 attachmentCount;
685 attachments, // const VkAttachmentDescription* pAttachments;
686 1u, // deUint32 subpassCount;
687 subpassDesc, // const VkSubpassDescription* pSubpasses;
688 0u, // deUint32 dependencyCount;
689 DE_NULL, // const VkSubpassDependency* pDependencies;
692 return vk::createRenderPass(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
695 Move<VkFramebuffer> ImageClearingTestInstance::createFrameBuffer (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight) const
697 const VkImageView attachmentViews[1] =
702 const VkFramebufferCreateInfo framebufferCreateInfo =
704 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
705 DE_NULL, // const void* pNext;
706 0u, // VkFramebufferCreateFlags flags;
707 renderPass, // VkRenderPass renderPass;
708 1, // deUint32 attachmentCount;
709 attachmentViews, // const VkImageView* pAttachments;
710 imageWidth, // deUint32 width;
711 imageHeight, // deUint32 height;
712 1u, // deUint32 layers;
715 return createFramebuffer(m_vkd, m_device, &framebufferCreateInfo, DE_NULL);
718 void ImageClearingTestInstance::beginCommandBuffer (VkCommandBufferUsageFlags usageFlags) const
720 const VkCommandBufferBeginInfo commandBufferBeginInfo =
722 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
723 DE_NULL, // const void* pNext;
724 usageFlags, // VkCommandBufferUsageFlags flags;
725 DE_NULL // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
728 VK_CHECK(m_vkd.beginCommandBuffer(*m_commandBuffer, &commandBufferBeginInfo));
731 void ImageClearingTestInstance::endCommandBuffer (void) const
733 VK_CHECK(m_vkd.endCommandBuffer(*m_commandBuffer));
736 void ImageClearingTestInstance::submitCommandBuffer (void) const
738 const VkFenceCreateInfo fenceCreateInfo =
740 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
741 DE_NULL, // const void* pNext;
742 0u // VkFenceCreateFlags flags;
745 const Unique<VkFence> fence (createFence(m_vkd, m_device, &fenceCreateInfo));
747 const VkSubmitInfo submitInfo =
749 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
750 DE_NULL, // const void* pNext;
751 0u, // deUint32 waitSemaphoreCount;
752 DE_NULL, // const VkSemaphore* pWaitSemaphores;
753 DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
754 1u, // deUint32 commandBufferCount;
755 &(*m_commandBuffer), // const VkCommandBuffer* pCommandBuffers;
756 0u, // deUint32 signalSemaphoreCount;
757 DE_NULL // const VkSemaphore* pSignalSemaphores;
760 VK_CHECK(m_vkd.queueSubmit(m_queue, 1, &submitInfo, *fence));
762 VK_CHECK(m_vkd.waitForFences(m_device, 1, &fence.get(), VK_TRUE, ~0ull));
765 void ImageClearingTestInstance::pipelineImageBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout) const
767 const VkImageMemoryBarrier imageBarrier =
769 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
770 DE_NULL, // const void* pNext;
771 srcAccessMask, // VkAccessFlags srcAccessMask;
772 dstAccessMask, // VkAccessFlags dstAccessMask;
773 oldLayout, // VkImageLayout oldLayout;
774 newLayout, // VkImageLayout newLayout;
775 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
776 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
777 *m_image, // VkImage image;
779 m_imageAspectFlags, // VkImageAspectFlags aspectMask;
780 0u, // deUint32 baseMipLevel;
781 VK_REMAINING_MIP_LEVELS, // deUint32 levelCount;
782 0u, // deUint32 baseArrayLayer;
783 1u, // deUint32 layerCount;
784 }, // VkImageSubresourceRange subresourceRange;
787 m_vkd.cmdPipelineBarrier(*m_commandBuffer, srcStageMask, dstStageMask, 0, 0, DE_NULL, 0, DE_NULL, 1, &imageBarrier);
790 de::MovePtr<TextureLevelPyramid> ImageClearingTestInstance::readImage (VkImageAspectFlags aspectMask) const
792 const TextureFormat tcuFormat = aspectMask == VK_IMAGE_ASPECT_COLOR_BIT ? mapVkFormat(m_params.imageFormat) :
793 aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT ? getDepthCopyFormat(m_params.imageFormat) :
794 aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT ? getStencilCopyFormat(m_params.imageFormat) :
796 const deUint32 pixelSize = getPixelSize(tcuFormat);
797 deUint32 alignment = 4; // subsequent mip levels aligned to 4 bytes
799 if (!getIsDepthFormat(m_params.imageFormat) && !getIsStencilFormat(m_params.imageFormat))
800 alignment = lowestCommonMultiple(pixelSize, alignment); // alignment must be multiple of pixel size, if not D/S.
802 const std::vector<deUint32> mipLevelSizes = getImageMipLevelSizes(pixelSize, m_params.imageExtent, m_imageMipLevels, alignment);
803 const VkDeviceSize imageTotalSize = std::accumulate(mipLevelSizes.begin(), mipLevelSizes.end(), 0u);
805 de::MovePtr<TextureLevelPyramid> result (new TextureLevelPyramid(tcuFormat, m_imageMipLevels));
806 Move<VkBuffer> buffer;
807 de::MovePtr<Allocation> bufferAlloc;
809 // Create destination buffer
811 const VkBufferCreateInfo bufferParams =
813 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
814 DE_NULL, // const void* pNext;
815 0u, // VkBufferCreateFlags flags;
816 imageTotalSize, // VkDeviceSize size;
817 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
818 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
819 0u, // deUint32 queueFamilyIndexCount;
820 DE_NULL // const deUint32* pQueueFamilyIndices;
823 buffer = createBuffer(m_vkd, m_device, &bufferParams);
824 bufferAlloc = m_allocator.allocate(getBufferMemoryRequirements(m_vkd, m_device, *buffer), MemoryRequirement::HostVisible);
825 VK_CHECK(m_vkd.bindBufferMemory(m_device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
828 // Barriers for copying image to buffer
830 const VkBufferMemoryBarrier bufferBarrier =
832 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
833 DE_NULL, // const void* pNext;
834 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
835 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
836 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
837 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
838 *buffer, // VkBuffer buffer;
839 0u, // VkDeviceSize offset;
840 imageTotalSize, // VkDeviceSize size;
843 // Copy image to buffer
844 std::vector<VkBufferImageCopy> copyRegions;
846 deUint32 offset = 0u;
847 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
849 const VkExtent3D extent = getMipLevelExtent(m_params.imageExtent, mipLevel);
850 const VkBufferImageCopy region =
852 offset, // VkDeviceSize bufferOffset;
853 0u, // deUint32 bufferRowLength;
854 0u, // deUint32 bufferImageHeight;
855 { aspectMask, mipLevel, 0u, 1u }, // VkImageSubresourceLayers imageSubresource;
856 { 0, 0, 0 }, // VkOffset3D imageOffset;
857 extent // VkExtent3D imageExtent;
859 copyRegions.push_back(region);
860 offset += mipLevelSizes[mipLevel];
864 beginCommandBuffer(0);
866 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
867 VK_PIPELINE_STAGE_TRANSFER_BIT,
868 VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
869 VK_ACCESS_TRANSFER_READ_BIT,
870 VK_IMAGE_LAYOUT_GENERAL,
871 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
873 m_vkd.cmdCopyImageToBuffer(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, static_cast<deUint32>(copyRegions.size()), ©Regions[0]);
874 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);
876 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
877 VK_PIPELINE_STAGE_TRANSFER_BIT,
878 VK_ACCESS_TRANSFER_READ_BIT,
879 VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
880 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
881 VK_IMAGE_LAYOUT_GENERAL);
884 submitCommandBuffer();
886 invalidateMappedMemoryRange(m_vkd, m_device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), imageTotalSize);
889 deUint32 offset = 0u;
890 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
892 const VkExtent3D extent = getMipLevelExtent(m_params.imageExtent, mipLevel);
893 const void* pLevelData = static_cast<const void*>(reinterpret_cast<deUint8*>(bufferAlloc->getHostPtr()) + offset);
895 result->allocLevel(mipLevel, extent.width, extent.height, extent.depth);
896 copy(result->getLevel(mipLevel), ConstPixelBufferAccess(result->getFormat(), result->getLevel(mipLevel).getSize(), pLevelData));
898 offset += mipLevelSizes[mipLevel];
905 tcu::TestStatus ImageClearingTestInstance::verifyResultImage (const std::string& successMessage, const UVec4& clearCoords) const
907 const bool useClearRange = clearCoords != UVec4();
908 DE_ASSERT(!useClearRange || m_params.imageExtent.depth == 1u);
910 if (getIsDepthFormat(m_params.imageFormat))
912 DE_ASSERT(m_imageMipLevels == 1u);
914 de::MovePtr<TextureLevelPyramid> image = readImage(VK_IMAGE_ASPECT_DEPTH_BIT);
918 for (deUint32 y = 0; y < m_params.imageExtent.height; ++y)
919 for (deUint32 x = 0; x < m_params.imageExtent.width; ++x)
921 if (!useClearRange || isInClearRange(clearCoords, x, y))
922 depthValue = m_params.clearValue[0].depthStencil.depth;
924 depthValue = m_params.initValue.depthStencil.depth;
926 if (!comparePixelToDepthClearValue(image->getLevel(0), x, y, depthValue, message))
927 return TestStatus::fail("Depth value mismatch! " + message);
931 if (getIsStencilFormat(m_params.imageFormat))
933 DE_ASSERT(m_imageMipLevels == 1u);
935 de::MovePtr<TextureLevelPyramid> image = readImage(VK_IMAGE_ASPECT_STENCIL_BIT);
937 deUint32 stencilValue;
939 for (deUint32 y = 0; y < m_params.imageExtent.height; ++y)
940 for (deUint32 x = 0; x < m_params.imageExtent.width; ++x)
942 if (!useClearRange || isInClearRange(clearCoords, x, y))
943 stencilValue = m_params.clearValue[0].depthStencil.stencil;
945 stencilValue = m_params.initValue.depthStencil.stencil;
947 if (!comparePixelToStencilClearValue(image->getLevel(0), x, y, stencilValue, message))
948 return TestStatus::fail("Stencil value mismatch! " + message);
952 if (!isDepthStencilFormat(m_params.imageFormat))
954 de::MovePtr<TextureLevelPyramid> image = readImage(VK_IMAGE_ASPECT_COLOR_BIT);
956 const VkClearColorValue* pColorValue;
958 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
960 const int clearColorNdx = (mipLevel < m_thresholdMipLevel ? 0 : 1);
961 const VkExtent3D extent = getMipLevelExtent(m_params.imageExtent, mipLevel);
963 for (deUint32 z = 0; z < extent.depth; ++z)
964 for (deUint32 y = 0; y < extent.height; ++y)
965 for (deUint32 x = 0; x < extent.width; ++x)
967 if (!useClearRange || isInClearRange(clearCoords, x, y))
968 pColorValue = &m_params.clearValue[clearColorNdx].color;
970 pColorValue = &m_params.initValue.color;
972 if (!comparePixelToColorClearValue(image->getLevel(mipLevel), x, y, z, *pColorValue, message))
973 return TestStatus::fail("Color value mismatch! " + message);
978 return TestStatus::pass(successMessage);
981 void ImageClearingTestInstance::beginRenderPass (VkSubpassContents content, VkClearValue clearValue) const
983 const VkRenderPassBeginInfo renderPassBeginInfo =
985 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
986 DE_NULL, // const void* pNext;
987 *m_renderPass, // VkRenderPass renderPass;
988 *m_frameBuffer, // VkFramebuffer framebuffer;
990 { 0, 0 }, // VkOffset2D offset;
992 m_params.imageExtent.width, // deUint32 width;
993 m_params.imageExtent.height // deUint32 height;
994 } // VkExtent2D extent;
995 }, // VkRect2D renderArea;
996 1u, // deUint32 clearValueCount;
997 &clearValue // const VkClearValue* pClearValues;
1000 m_vkd.cmdBeginRenderPass(*m_commandBuffer, &renderPassBeginInfo, content);
1003 class ClearColorImageTestInstance : public ImageClearingTestInstance
1006 ClearColorImageTestInstance (Context& context, const TestParams& testParams) : ImageClearingTestInstance (context, testParams) {}
1007 TestStatus iterate (void);
1010 TestStatus ClearColorImageTestInstance::iterate (void)
1012 std::vector<VkImageSubresourceRange> subresourceRanges;
1014 if (m_imageMipLevels == 1)
1015 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, 0u, 1u, 0u, 1u));
1018 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, 0u, m_thresholdMipLevel, 0u, 1u));
1019 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, m_thresholdMipLevel, VK_REMAINING_MIP_LEVELS, 0u, 1u));
1022 beginCommandBuffer(0);
1024 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1025 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1026 0, // VkAccessFlags srcAccessMask
1027 (m_isAttachmentFormat
1028 ? VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
1029 : VK_ACCESS_TRANSFER_WRITE_BIT), // VkAccessFlags dstAccessMask
1030 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1031 (m_isAttachmentFormat
1032 ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
1033 : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)); // VkImageLayout newLayout;
1035 if (m_isAttachmentFormat)
1037 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1038 m_vkd.cmdEndRenderPass(*m_commandBuffer);
1040 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
1041 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1042 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask
1043 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1044 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
1045 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1048 // Different clear color per range
1049 for (std::size_t i = 0u; i < subresourceRanges.size(); ++i)
1050 m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[i].color, 1, &subresourceRanges[i]);
1052 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1053 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1054 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1055 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1056 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1057 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
1060 submitCommandBuffer();
1062 return verifyResultImage("cmdClearColorImage passed");
1065 class ClearDepthStencilImageTestInstance : public ImageClearingTestInstance
1068 ClearDepthStencilImageTestInstance (Context& context, const TestParams& testParams) : ImageClearingTestInstance (context, testParams) {}
1069 TestStatus iterate (void);
1072 TestStatus ClearDepthStencilImageTestInstance::iterate (void)
1074 const VkImageSubresourceRange subresourceRange = makeImageSubresourceRange(m_imageAspectFlags, 0u, 1u, 0u, 1u);
1076 beginCommandBuffer(0);
1078 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1079 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1080 0, // VkAccessFlags srcAccessMask
1081 (m_isAttachmentFormat
1082 ? VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
1083 : VK_ACCESS_TRANSFER_WRITE_BIT), // VkAccessFlags dstAccessMask
1084 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1085 (m_isAttachmentFormat
1086 ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
1087 : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)); // VkImageLayout newLayout;
1089 if (m_isAttachmentFormat)
1091 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1092 m_vkd.cmdEndRenderPass(*m_commandBuffer);
1094 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
1095 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1096 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask
1097 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1098 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
1099 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1102 m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, 1, &subresourceRange);
1104 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1105 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1106 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1107 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1108 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1109 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
1112 submitCommandBuffer();
1114 return verifyResultImage("cmdClearDepthStencilImage passed");
1117 class ClearAttachmentTestInstance : public ImageClearingTestInstance
1126 ClearAttachmentTestInstance (Context& context, const TestParams& testParams, const ClearType clearType = FULL_CLEAR)
1127 : ImageClearingTestInstance (context, testParams)
1128 , m_clearType (clearType)
1130 if (!m_isAttachmentFormat)
1131 TCU_THROW(NotSupportedError, "Format not renderable");
1134 TestStatus iterate (void)
1136 const VkClearAttachment clearAttachment =
1138 m_imageAspectFlags, // VkImageAspectFlags aspectMask;
1139 0u, // deUint32 colorAttachment;
1140 m_params.clearValue[0] // VkClearValue clearValue;
1144 std::vector<VkClearRect> clearRects;
1146 if (m_clearType == FULL_CLEAR)
1148 const VkClearRect rect =
1151 { 0, 0 }, // VkOffset2D offset;
1152 { m_params.imageExtent.width, m_params.imageExtent.height } // VkExtent2D extent;
1153 }, // VkRect2D rect;
1154 0u, // deUint32 baseArrayLayer;
1155 1u // deUint32 layerCount;
1158 clearRects.push_back(rect);
1162 const deUint32 clearX = m_params.imageExtent.width / 4u;
1163 const deUint32 clearY = m_params.imageExtent.height / 4u;
1164 const deUint32 clearWidth = m_params.imageExtent.width / 2u;
1165 const deUint32 clearHeight = m_params.imageExtent.height / 2u;
1167 clearCoords = UVec4(clearX, clearY,
1168 clearX + clearWidth, clearY + clearHeight);
1170 const VkClearRect rects[2] =
1174 { 0, static_cast<deInt32>(clearY) }, // VkOffset2D offset;
1175 { m_params.imageExtent.width, clearHeight } // VkExtent2D extent;
1176 }, // VkRect2D rect;
1177 0u, // deUint32 baseArrayLayer;
1178 1u // deUint32 layerCount;
1182 { static_cast<deInt32>(clearX), 0 }, // VkOffset2D offset;
1183 { clearWidth, m_params.imageExtent.height } // VkExtent2D extent;
1184 }, // VkRect2D rect;
1185 0u, // deUint32 baseArrayLayer;
1186 1u // deUint32 layerCount;
1190 clearRects.push_back(rects[0]);
1191 clearRects.push_back(rects[1]);
1194 const bool isDepthStencil = isDepthStencilFormat(m_params.imageFormat);
1195 const VkAccessFlags accessMask = (isDepthStencil ? VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT : VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
1196 const VkImageLayout attachmentLayout = (isDepthStencil ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
1198 beginCommandBuffer(0);
1200 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1201 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1202 0, // VkAccessFlags srcAccessMask
1203 accessMask, // VkAccessFlags dstAccessMask
1204 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1205 attachmentLayout); // VkImageLayout newLayout;
1207 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1208 m_vkd.cmdClearAttachments(*m_commandBuffer, 1, &clearAttachment, static_cast<deUint32>(clearRects.size()), &clearRects[0]);
1209 m_vkd.cmdEndRenderPass(*m_commandBuffer);
1211 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
1212 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1213 accessMask, // VkAccessFlags srcAccessMask
1214 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1215 attachmentLayout, // VkImageLayout oldLayout;
1216 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
1219 submitCommandBuffer();
1221 return verifyResultImage("cmdClearAttachments passed", clearCoords);
1225 const ClearType m_clearType;
1228 class PartialClearAttachmentTestInstance : public ClearAttachmentTestInstance
1231 PartialClearAttachmentTestInstance (Context& context, const TestParams& testParams) : ClearAttachmentTestInstance (context, testParams, PARTIAL_CLEAR) {}
1234 VkClearValue makeClearColorValue (VkFormat format, float r, float g, float b, float a)
1236 const TextureFormat tcuFormat = mapVkFormat(format);
1237 VkClearValue clearValue;
1239 if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_FLOATING_POINT
1240 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_FIXED_POINT
1241 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
1243 clearValue.color.float32[0] = r;
1244 clearValue.color.float32[1] = g;
1245 clearValue.color.float32[2] = b;
1246 clearValue.color.float32[3] = a;
1248 else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
1250 UVec4 maxValues = getFormatMaxUintValue(tcuFormat);
1252 clearValue.color.uint32[0] = (deUint32)((float)maxValues[0] * r);
1253 clearValue.color.uint32[1] = (deUint32)((float)maxValues[1] * g);
1254 clearValue.color.uint32[2] = (deUint32)((float)maxValues[2] * b);
1255 clearValue.color.uint32[3] = (deUint32)((float)maxValues[3] * a);
1257 else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_INTEGER)
1259 IVec4 maxValues = getFormatMaxIntValue(tcuFormat);
1261 clearValue.color.int32[0] = (deUint32)((float)maxValues[0] * r);
1262 clearValue.color.int32[1] = (deUint32)((float)maxValues[1] * g);
1263 clearValue.color.int32[2] = (deUint32)((float)maxValues[2] * b);
1264 clearValue.color.int32[3] = (deUint32)((float)maxValues[3] * a);
1267 DE_FATAL("Unknown channel class");
1272 std::string getFormatCaseName (VkFormat format)
1274 return de::toLower(de::toString(getFormatStr(format)).substr(10));
1277 const char* getImageTypeCaseName (VkImageType type)
1279 const char* s_names[] =
1285 return de::getSizedArrayElement<VK_IMAGE_TYPE_LAST>(s_names, type);
1290 TestCaseGroup* createImageClearingTests (TestContext& testCtx)
1293 de::MovePtr<TestCaseGroup> imageClearingTests (new TestCaseGroup(testCtx, "image_clearing", "Image Clearing Tests"));
1295 de::MovePtr<TestCaseGroup> colorImageClearTests (new TestCaseGroup(testCtx, "clear_color_image", "Color Image Clear Tests"));
1296 de::MovePtr<TestCaseGroup> depthStencilImageClearTests (new TestCaseGroup(testCtx, "clear_depth_stencil_image", "Color Depth/Stencil Image Tests"));
1297 de::MovePtr<TestCaseGroup> colorAttachmentClearTests (new TestCaseGroup(testCtx, "clear_color_attachment", "Color Color Attachment Tests"));
1298 de::MovePtr<TestCaseGroup> depthStencilAttachmentClearTests (new TestCaseGroup(testCtx, "clear_depth_stencil_attachment", "Color Depth/Stencil Attachment Tests"));
1299 de::MovePtr<TestCaseGroup> partialColorAttachmentClearTests (new TestCaseGroup(testCtx, "partial_clear_color_attachment", "Clear Partial Color Attachment Tests"));
1300 de::MovePtr<TestCaseGroup> partialDepthStencilAttachmentClearTests (new TestCaseGroup(testCtx, "partial_clear_depth_stencil_attachment", "Clear Partial Depth/Stencil Attachment Tests"));
1302 // Some formats are commented out due to the tcu::TextureFormat does not support them yet.
1303 const VkFormat colorImageFormatsToTest[] =
1305 VK_FORMAT_R4G4_UNORM_PACK8,
1306 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
1307 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
1308 VK_FORMAT_R5G6B5_UNORM_PACK16,
1309 VK_FORMAT_B5G6R5_UNORM_PACK16,
1310 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
1311 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
1312 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
1315 VK_FORMAT_R8_USCALED,
1316 VK_FORMAT_R8_SSCALED,
1320 VK_FORMAT_R8G8_UNORM,
1321 VK_FORMAT_R8G8_SNORM,
1322 VK_FORMAT_R8G8_USCALED,
1323 VK_FORMAT_R8G8_SSCALED,
1324 VK_FORMAT_R8G8_UINT,
1325 VK_FORMAT_R8G8_SINT,
1326 VK_FORMAT_R8G8_SRGB,
1327 VK_FORMAT_R8G8B8_UNORM,
1328 VK_FORMAT_R8G8B8_SNORM,
1329 VK_FORMAT_R8G8B8_USCALED,
1330 VK_FORMAT_R8G8B8_SSCALED,
1331 VK_FORMAT_R8G8B8_UINT,
1332 VK_FORMAT_R8G8B8_SINT,
1333 VK_FORMAT_R8G8B8_SRGB,
1334 VK_FORMAT_B8G8R8_UNORM,
1335 VK_FORMAT_B8G8R8_SNORM,
1336 VK_FORMAT_B8G8R8_USCALED,
1337 VK_FORMAT_B8G8R8_SSCALED,
1338 VK_FORMAT_B8G8R8_UINT,
1339 VK_FORMAT_B8G8R8_SINT,
1340 VK_FORMAT_B8G8R8_SRGB,
1341 VK_FORMAT_R8G8B8A8_UNORM,
1342 VK_FORMAT_R8G8B8A8_SNORM,
1343 VK_FORMAT_R8G8B8A8_USCALED,
1344 VK_FORMAT_R8G8B8A8_SSCALED,
1345 VK_FORMAT_R8G8B8A8_UINT,
1346 VK_FORMAT_R8G8B8A8_SINT,
1347 VK_FORMAT_R8G8B8A8_SRGB,
1348 VK_FORMAT_B8G8R8A8_UNORM,
1349 VK_FORMAT_B8G8R8A8_SNORM,
1350 VK_FORMAT_B8G8R8A8_USCALED,
1351 VK_FORMAT_B8G8R8A8_SSCALED,
1352 VK_FORMAT_B8G8R8A8_UINT,
1353 VK_FORMAT_B8G8R8A8_SINT,
1354 VK_FORMAT_B8G8R8A8_SRGB,
1355 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
1356 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
1357 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
1358 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
1359 VK_FORMAT_A8B8G8R8_UINT_PACK32,
1360 VK_FORMAT_A8B8G8R8_SINT_PACK32,
1361 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
1362 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
1363 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
1364 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
1365 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
1366 VK_FORMAT_A2R10G10B10_UINT_PACK32,
1367 VK_FORMAT_A2R10G10B10_SINT_PACK32,
1368 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
1369 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
1370 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
1371 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
1372 VK_FORMAT_A2B10G10R10_UINT_PACK32,
1373 VK_FORMAT_A2B10G10R10_SINT_PACK32,
1374 VK_FORMAT_R16_UNORM,
1375 VK_FORMAT_R16_SNORM,
1376 VK_FORMAT_R16_USCALED,
1377 VK_FORMAT_R16_SSCALED,
1380 VK_FORMAT_R16_SFLOAT,
1381 VK_FORMAT_R16G16_UNORM,
1382 VK_FORMAT_R16G16_SNORM,
1383 VK_FORMAT_R16G16_USCALED,
1384 VK_FORMAT_R16G16_SSCALED,
1385 VK_FORMAT_R16G16_UINT,
1386 VK_FORMAT_R16G16_SINT,
1387 VK_FORMAT_R16G16_SFLOAT,
1388 VK_FORMAT_R16G16B16_UNORM,
1389 VK_FORMAT_R16G16B16_SNORM,
1390 VK_FORMAT_R16G16B16_USCALED,
1391 VK_FORMAT_R16G16B16_SSCALED,
1392 VK_FORMAT_R16G16B16_UINT,
1393 VK_FORMAT_R16G16B16_SINT,
1394 VK_FORMAT_R16G16B16_SFLOAT,
1395 VK_FORMAT_R16G16B16A16_UNORM,
1396 VK_FORMAT_R16G16B16A16_SNORM,
1397 VK_FORMAT_R16G16B16A16_USCALED,
1398 VK_FORMAT_R16G16B16A16_SSCALED,
1399 VK_FORMAT_R16G16B16A16_UINT,
1400 VK_FORMAT_R16G16B16A16_SINT,
1401 VK_FORMAT_R16G16B16A16_SFLOAT,
1404 VK_FORMAT_R32_SFLOAT,
1405 VK_FORMAT_R32G32_UINT,
1406 VK_FORMAT_R32G32_SINT,
1407 VK_FORMAT_R32G32_SFLOAT,
1408 VK_FORMAT_R32G32B32_UINT,
1409 VK_FORMAT_R32G32B32_SINT,
1410 VK_FORMAT_R32G32B32_SFLOAT,
1411 VK_FORMAT_R32G32B32A32_UINT,
1412 VK_FORMAT_R32G32B32A32_SINT,
1413 VK_FORMAT_R32G32B32A32_SFLOAT,
1414 // VK_FORMAT_R64_UINT,
1415 // VK_FORMAT_R64_SINT,
1416 // VK_FORMAT_R64_SFLOAT,
1417 // VK_FORMAT_R64G64_UINT,
1418 // VK_FORMAT_R64G64_SINT,
1419 // VK_FORMAT_R64G64_SFLOAT,
1420 // VK_FORMAT_R64G64B64_UINT,
1421 // VK_FORMAT_R64G64B64_SINT,
1422 // VK_FORMAT_R64G64B64_SFLOAT,
1423 // VK_FORMAT_R64G64B64A64_UINT,
1424 // VK_FORMAT_R64G64B64A64_SINT,
1425 // VK_FORMAT_R64G64B64A64_SFLOAT,
1426 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
1427 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
1428 // VK_FORMAT_BC1_RGB_UNORM_BLOCK,
1429 // VK_FORMAT_BC1_RGB_SRGB_BLOCK,
1430 // VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
1431 // VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
1432 // VK_FORMAT_BC2_UNORM_BLOCK,
1433 // VK_FORMAT_BC2_SRGB_BLOCK,
1434 // VK_FORMAT_BC3_UNORM_BLOCK,
1435 // VK_FORMAT_BC3_SRGB_BLOCK,
1436 // VK_FORMAT_BC4_UNORM_BLOCK,
1437 // VK_FORMAT_BC4_SNORM_BLOCK,
1438 // VK_FORMAT_BC5_UNORM_BLOCK,
1439 // VK_FORMAT_BC5_SNORM_BLOCK,
1440 // VK_FORMAT_BC6H_UFLOAT_BLOCK,
1441 // VK_FORMAT_BC6H_SFLOAT_BLOCK,
1442 // VK_FORMAT_BC7_UNORM_BLOCK,
1443 // VK_FORMAT_BC7_SRGB_BLOCK,
1444 // VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
1445 // VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
1446 // VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
1447 // VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
1448 // VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
1449 // VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
1450 // VK_FORMAT_EAC_R11_UNORM_BLOCK,
1451 // VK_FORMAT_EAC_R11_SNORM_BLOCK,
1452 // VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
1453 // VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
1454 // VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
1455 // VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
1456 // VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
1457 // VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
1458 // VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
1459 // VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
1460 // VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
1461 // VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
1462 // VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
1463 // VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
1464 // VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
1465 // VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
1466 // VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
1467 // VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
1468 // VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
1469 // VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
1470 // VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
1471 // VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
1472 // VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
1473 // VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
1474 // VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
1475 // VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
1476 // VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
1477 // VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
1478 // VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
1479 // VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
1480 // VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
1481 // VK_FORMAT_ASTC_12x12_SRGB_BLOCK
1483 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
1485 const VkFormat depthStencilImageFormatsToTest[] =
1487 VK_FORMAT_D16_UNORM,
1488 VK_FORMAT_X8_D24_UNORM_PACK32,
1489 VK_FORMAT_D32_SFLOAT,
1491 VK_FORMAT_D16_UNORM_S8_UINT,
1492 VK_FORMAT_D24_UNORM_S8_UINT,
1493 VK_FORMAT_D32_SFLOAT_S8_UINT
1495 const size_t numOfDepthStencilImageFormatsToTest = DE_LENGTH_OF_ARRAY(depthStencilImageFormatsToTest);
1497 // Clear color image
1499 const VkImageType imageTypesToTest[] =
1505 const size_t numOfImageTypesToTest = DE_LENGTH_OF_ARRAY(imageTypesToTest);
1507 const VkExtent3D imageDimensionsByType[] =
1514 for (size_t imageTypeIndex = 0; imageTypeIndex < numOfImageTypesToTest; ++imageTypeIndex)
1515 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
1517 const VkFormat format = colorImageFormatsToTest[imageFormatIndex];
1518 const TestParams testParams =
1520 false, // bool useSingleMipLevel;
1521 imageTypesToTest[imageTypeIndex], // VkImageType imageType;
1522 format, // VkFormat imageFormat;
1523 imageDimensionsByType[imageTypeIndex], // VkExtent3D imageExtent;
1524 makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f), // VkClearValue initValue;
1526 makeClearColorValue(format, 0.1f, 0.5f, 0.3f, 0.9f), // VkClearValue clearValue[0];
1527 makeClearColorValue(format, 0.3f, 0.6f, 0.2f, 0.7f), // VkClearValue clearValue[1];
1531 std::ostringstream testCaseName;
1532 testCaseName << getImageTypeCaseName(testParams.imageType) << "_" << getFormatCaseName(format);
1534 colorImageClearTests->addChild(new InstanceFactory1<ClearColorImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Clear Color Image", testParams));
1537 imageClearingTests->addChild(colorImageClearTests.release());
1540 // Clear depth/stencil image
1542 TestParams testParams =
1544 true, // bool useSingleMipLevel;
1545 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1546 VK_FORMAT_UNDEFINED, // VkFormat format;
1547 { 256, 256, 1 }, // VkExtent3D extent;
1548 makeClearValueDepthStencil(0.5f, 0x03), // VkClearValue initValue
1550 makeClearValueDepthStencil(0.1f, 0x06), // VkClearValue clearValue[0];
1551 makeClearValueDepthStencil(0.3f, 0x04), // VkClearValue clearValue[1];
1555 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
1557 testParams.imageFormat = depthStencilImageFormatsToTest[imageFormatIndex];
1559 std::ostringstream testCaseName;
1560 testCaseName << getImageTypeCaseName(testParams.imageType) << "_" << getFormatCaseName(testParams.imageFormat);
1562 depthStencilImageClearTests->addChild(new InstanceFactory1<ClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Clear Depth/Stencil Image", testParams));
1565 imageClearingTests->addChild(depthStencilImageClearTests.release());
1568 // Clear color attachment
1570 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
1572 const VkFormat format = colorImageFormatsToTest[imageFormatIndex];
1573 const TestParams testParams =
1575 true, // bool useSingleMipLevel;
1576 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1577 format, // VkFormat format;
1578 { 256, 256, 1 }, // VkExtent3D extent;
1579 makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f), // VkClearValue initValue
1581 makeClearColorValue(format, 0.1f, 0.5f, 0.3f, 0.9f), // VkClearValue clearValue[0];
1582 makeClearColorValue(format, 0.3f, 0.6f, 0.2f, 0.7f), // VkClearValue clearValue[1];
1586 std::ostringstream testCaseName;
1587 testCaseName << getImageTypeCaseName(testParams.imageType) << "_" << getFormatCaseName(format);
1589 colorAttachmentClearTests->addChild(new InstanceFactory1<ClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Clear Color Attachment", testParams));
1590 partialColorAttachmentClearTests->addChild(new InstanceFactory1<PartialClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Partial Clear Color Attachment", testParams));
1593 imageClearingTests->addChild(colorAttachmentClearTests.release());
1594 imageClearingTests->addChild(partialColorAttachmentClearTests.release());
1597 // Clear depth/stencil attachment
1599 TestParams testParams =
1601 true, // bool useSingleMipLevel;
1602 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1603 VK_FORMAT_UNDEFINED, // VkFormat format;
1604 { 256, 256, 1 }, // VkExtent3D extent;
1605 makeClearValueDepthStencil(0.5f, 0x03), // VkClearValue initValue
1607 makeClearValueDepthStencil(0.1f, 0x06), // VkClearValue clearValue[0];
1608 makeClearValueDepthStencil(0.3f, 0x04), // VkClearValue clearValue[1];
1612 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
1614 testParams.imageFormat = depthStencilImageFormatsToTest[imageFormatIndex];
1616 std::ostringstream testCaseName;
1617 testCaseName << getImageTypeCaseName(testParams.imageType) << "_" << getFormatCaseName(testParams.imageFormat);
1619 depthStencilAttachmentClearTests->addChild(new InstanceFactory1<ClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Clear Depth/Stencil Attachment", testParams));
1620 partialDepthStencilAttachmentClearTests->addChild(new InstanceFactory1<PartialClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName.str(), "Parital Clear Depth/Stencil Attachment", testParams));
1623 imageClearingTests->addChild(depthStencilAttachmentClearTests.release());
1624 imageClearingTests->addChild(partialDepthStencilAttachmentClearTests.release());
1627 return imageClearingTests.release();