1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2016 The Khronos Group Inc.
6 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
7 *
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
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
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.
19 *
20 *//*!
21 * \file
22 * \brief Vulkan Image Clearing Tests
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktApiImageClearingTests.hpp"
26
27 #include "deRandom.hpp"
28 #include "deMath.h"
29 #include "deSTLUtil.hpp"
30 #include "deStringUtil.hpp"
31 #include "deUniquePtr.hpp"
32 #include "deArrayUtil.hpp"
33 #include "deInt32.h"
34 #include "vkImageUtil.hpp"
35 #include "vkMemUtil.hpp"
36 #include "vktTestCase.hpp"
37 #include "vktTestCaseUtil.hpp"
38 #include "vktTestGroupUtil.hpp"
39 #include "vkQueryUtil.hpp"
40 #include "vkRefUtil.hpp"
41 #include "vkTypeUtil.hpp"
42 #include "vkCmdUtil.hpp"
43 #include "tcuImageCompare.hpp"
44 #include "tcuTexture.hpp"
45 #include "tcuTextureUtil.hpp"
46 #include "tcuVectorType.hpp"
47 #include "tcuTexture.hpp"
48 #include "tcuFloat.hpp"
49 #include "tcuTestLog.hpp"
50 #include "tcuVectorUtil.hpp"
51 #include <sstream>
52 #include <numeric>
53
54 namespace vkt
55 {
56
57 namespace api
58 {
59
60 using namespace vk;
61 using namespace tcu;
62
63 namespace
64 {
65
66 enum AllocationKind
67 {
68 ALLOCATION_KIND_SUBALLOCATED = 0,
69 ALLOCATION_KIND_DEDICATED,
70
71 ALLOCATION_KIND_LAST,
72 };
73
74 union Threshold {
75 Vec4 vec4;
76 IVec4 ivec4;
77 UVec4 uvec4;
78 };
79
is64Format(const tcu::TextureFormat tcuFormat)80 bool is64Format (const tcu::TextureFormat tcuFormat)
81 {
82 const auto bitDepths = getTextureFormatBitDepth(tcuFormat);
83 const bool is64Bit = tcu::boolAny(tcu::equal(bitDepths, tcu::IVec4(64,64,64,64)));
84
85 return is64Bit;
86 }
87
allocateBuffer(const InstanceInterface & vki,const DeviceInterface & vkd,const VkPhysicalDevice & physDevice,const VkDevice device,const VkBuffer & buffer,const MemoryRequirement requirement,Allocator & allocator,AllocationKind allocationKind)88 de::MovePtr<Allocation> allocateBuffer (const InstanceInterface& vki,
89 const DeviceInterface& vkd,
90 const VkPhysicalDevice& physDevice,
91 const VkDevice device,
92 const VkBuffer& buffer,
93 const MemoryRequirement requirement,
94 Allocator& allocator,
95 AllocationKind allocationKind)
96 {
97 switch (allocationKind)
98 {
99 case ALLOCATION_KIND_SUBALLOCATED:
100 {
101 const VkMemoryRequirements memoryRequirements = getBufferMemoryRequirements(vkd, device, buffer);
102
103 return allocator.allocate(memoryRequirements, requirement);
104 }
105
106 case ALLOCATION_KIND_DEDICATED:
107 {
108 return allocateDedicated(vki, vkd, physDevice, device, buffer, requirement);
109 }
110
111 default:
112 {
113 TCU_THROW(InternalError, "Invalid allocation kind");
114 }
115 }
116 }
117
allocateImage(const InstanceInterface & vki,const DeviceInterface & vkd,const VkPhysicalDevice & physDevice,const VkDevice device,const VkImage & image,const MemoryRequirement requirement,Allocator & allocator,AllocationKind allocationKind)118 de::MovePtr<Allocation> allocateImage (const InstanceInterface& vki,
119 const DeviceInterface& vkd,
120 const VkPhysicalDevice& physDevice,
121 const VkDevice device,
122 const VkImage& image,
123 const MemoryRequirement requirement,
124 Allocator& allocator,
125 AllocationKind allocationKind)
126 {
127 switch (allocationKind)
128 {
129 case ALLOCATION_KIND_SUBALLOCATED:
130 {
131 const VkMemoryRequirements memoryRequirements = getImageMemoryRequirements(vkd, device, image);
132
133 return allocator.allocate(memoryRequirements, requirement);
134 }
135
136 case ALLOCATION_KIND_DEDICATED:
137 {
138 return allocateDedicated(vki, vkd, physDevice, device, image, requirement);
139 }
140
141 default:
142 {
143 TCU_THROW(InternalError, "Invalid allocation kind");
144 }
145 }
146 }
147
getMipLevelExtent(VkExtent3D baseExtent,const deUint32 mipLevel)148 VkExtent3D getMipLevelExtent (VkExtent3D baseExtent, const deUint32 mipLevel)
149 {
150 baseExtent.width = std::max(baseExtent.width >> mipLevel, 1u);
151 baseExtent.height = std::max(baseExtent.height >> mipLevel, 1u);
152 baseExtent.depth = std::max(baseExtent.depth >> mipLevel, 1u);
153 return baseExtent;
154 }
155
getNumMipLevels(const VkExtent3D & baseExtent,const deUint32 maxMipLevels)156 deUint32 getNumMipLevels (const VkExtent3D& baseExtent, const deUint32 maxMipLevels)
157 {
158 const deUint32 widestEdge = std::max(std::max(baseExtent.width, baseExtent.height), baseExtent.depth);
159 return std::min(static_cast<deUint32>(deFloatLog2(static_cast<float>(widestEdge))) + 1u, maxMipLevels);
160 }
161
greatestCommonDivisor(const deUint32 a,const deUint32 b)162 deUint32 greatestCommonDivisor (const deUint32 a, const deUint32 b)
163 {
164 /* Find GCD */
165 deUint32 temp;
166 deUint32 x=a;
167 deUint32 y=b;
168
169 while (x%y != 0)
170 {
171 temp = y;
172 y = x%y;
173 x = temp;
174 }
175 return y;
176 }
177
lowestCommonMultiple(const deUint32 a,const deUint32 b)178 deUint32 lowestCommonMultiple (const deUint32 a, const deUint32 b)
179 {
180 return (a*b)/greatestCommonDivisor(a,b);
181 }
182
getImageMipLevelSizes(const deUint32 pixelSize,const VkExtent3D & baseExtent,const deUint32 numMipLevels,const deUint32 perLevelAlignment=1u)183 std::vector<deUint32> getImageMipLevelSizes (const deUint32 pixelSize, const VkExtent3D& baseExtent, const deUint32 numMipLevels, const deUint32 perLevelAlignment = 1u)
184 {
185 std::vector<deUint32> results(numMipLevels);
186
187 for (deUint32 mipLevel = 0; mipLevel < numMipLevels; ++mipLevel)
188 {
189 const VkExtent3D extent = getMipLevelExtent(baseExtent, mipLevel);
190 results[mipLevel] = static_cast<deUint32>(extent.width * extent.height * extent.depth * pixelSize);
191 results[mipLevel] = ((results[mipLevel] + perLevelAlignment-1) / perLevelAlignment) * perLevelAlignment;
192 }
193
194 return results;
195 }
196
197 struct LayerRange
198 {
199 deUint32 baseArrayLayer;
200 deUint32 layerCount;
201 };
202
isInClearRange(const UVec4 & clearCoords,const deUint32 x,const deUint32 y,deUint32 arrayLayer=0,tcu::Maybe<LayerRange> imageViewLayerRange=tcu::Maybe<LayerRange> (),tcu::Maybe<LayerRange> attachmentClearLayerRange=tcu::Maybe<LayerRange> ())203 inline bool isInClearRange (const UVec4& clearCoords, const deUint32 x, const deUint32 y, deUint32 arrayLayer = 0, tcu::Maybe<LayerRange> imageViewLayerRange = tcu::Maybe<LayerRange>(), tcu::Maybe<LayerRange> attachmentClearLayerRange = tcu::Maybe<LayerRange>())
204 {
205 if (attachmentClearLayerRange)
206 {
207 // Only layers in range passed to clear command are cleared
208
209 const deUint32 clearBaseLayer = (imageViewLayerRange ? imageViewLayerRange->baseArrayLayer : 0) + attachmentClearLayerRange->baseArrayLayer;
210 const deUint32 clearLayerCount = (attachmentClearLayerRange->layerCount == VK_REMAINING_ARRAY_LAYERS) ? imageViewLayerRange->layerCount : clearBaseLayer + attachmentClearLayerRange->layerCount;
211
212 if ((arrayLayer < clearBaseLayer) || (arrayLayer >= (clearLayerCount)))
213 {
214 return false;
215 }
216 }
217
218 if (clearCoords == UVec4())
219 {
220 return true;
221 }
222
223 //! Check if a point lies in a cross-like area.
224 return !((x < clearCoords[0] && y < clearCoords[1]) ||
225 (x < clearCoords[0] && y >= clearCoords[3]) ||
226 (x >= clearCoords[2] && y < clearCoords[1]) ||
227 (x >= clearCoords[2] && y >= clearCoords[3]));
228 }
229
isInInitialClearRange(deUint32 mipLevel,deUint32 arrayLayer,LayerRange imageViewLayerRange)230 inline bool isInInitialClearRange (deUint32 mipLevel, deUint32 arrayLayer, LayerRange imageViewLayerRange)
231 {
232 if (mipLevel > 0)
233 {
234 // intial clear is done using FB bound to level 0 only
235 return false;
236 }
237
238 // Only layers in range bound to framebuffer are cleared to initial color
239 if ((arrayLayer < imageViewLayerRange.baseArrayLayer) || (arrayLayer >= (imageViewLayerRange.baseArrayLayer + imageViewLayerRange.layerCount)))
240 {
241 return false;
242 }
243
244 return true;
245 }
246
247 // This method is copied from the vktRenderPassTests.cpp. It should be moved to a common place.
calcFloatDiff(float a,float b)248 int calcFloatDiff (float a, float b)
249 {
250 const int asign = Float32(a).sign();
251 const int bsign = Float32(b).sign();
252
253 const deUint32 avalue = (Float32(a).bits() & ((0x1u << 31u) - 1u));
254 const deUint32 bvalue = (Float32(b).bits() & ((0x1u << 31u) - 1u));
255
256 if (asign != bsign)
257 return avalue + bvalue + 1u;
258 else if (avalue < bvalue)
259 return bvalue - avalue;
260 else
261 return avalue - bvalue;
262 }
263
264 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
comparePixelToDepthClearValue(const ConstPixelBufferAccess & access,int x,int y,int z,float ref,std::string & stringResult)265 bool comparePixelToDepthClearValue (const ConstPixelBufferAccess& access,
266 int x,
267 int y,
268 int z,
269 float ref,
270 std::string& stringResult)
271 {
272 const TextureFormat format = getEffectiveDepthStencilTextureFormat(access.getFormat(), Sampler::MODE_DEPTH);
273 const TextureChannelClass channelClass = getTextureChannelClass(format.type);
274
275 switch (channelClass)
276 {
277 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
278 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
279 {
280 const int bitDepth = getTextureFormatBitDepth(format).x();
281 const float depth = access.getPixDepth(x, y, z);
282 const float threshold = 2.0f / (float)((1 << bitDepth) - 1);
283 const bool result = deFloatAbs(depth - ref) <= threshold;
284
285 if (!result)
286 {
287 std::stringstream s;
288 s << "Ref:" << ref << " Threshold:" << threshold << " Depth:" << depth;
289 stringResult = s.str();
290 }
291
292 return result;
293 }
294
295 case TEXTURECHANNELCLASS_FLOATING_POINT:
296 {
297 const float depth = access.getPixDepth(x, y, z);
298 const int mantissaBits = getTextureFormatMantissaBitDepth(format).x();
299 const int threshold = (10 * 1) << (23 - mantissaBits);
300
301 DE_ASSERT(mantissaBits <= 23);
302
303 const bool result = calcFloatDiff(depth, ref) <= threshold;
304
305 if (!result)
306 {
307 float floatThreshold = Float32((deUint32)threshold).asFloat();
308 std::stringstream s;
309
310 s << "Ref:" << ref << " Threshold:" << floatThreshold << " Depth:" << depth;
311 stringResult = s.str();
312 }
313
314 return result;
315 }
316
317 default:
318 DE_FATAL("Invalid channel class");
319 return false;
320 }
321 }
322
323 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
comparePixelToStencilClearValue(const ConstPixelBufferAccess & access,int x,int y,int z,deUint32 ref,std::string & stringResult)324 bool comparePixelToStencilClearValue (const ConstPixelBufferAccess& access,
325 int x,
326 int y,
327 int z,
328 deUint32 ref,
329 std::string& stringResult)
330 {
331 const deUint32 stencil = access.getPixStencil(x, y, z);
332 const bool result = stencil == ref;
333
334 if (!result)
335 {
336 std::stringstream s;
337 s << "Ref:" << ref << " Threshold:0" << " Stencil:" << stencil;
338 stringResult = s.str();
339 }
340
341 return result;
342 }
343
344 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
comparePixelToColorClearValue(const ConstPixelBufferAccess & access,int x,int y,int z,const VkClearColorValue & ref,std::string & stringResult,const Threshold & threshold,const BVec4 & channelMask,const TextureChannelClass & channelClass)345 bool comparePixelToColorClearValue (const ConstPixelBufferAccess& access,
346 int x,
347 int y,
348 int z,
349 const VkClearColorValue& ref,
350 std::string& stringResult,
351 const Threshold& threshold,
352 const BVec4& channelMask,
353 const TextureChannelClass& channelClass)
354 {
355 const bool is64Bit = is64Format(access.getFormat());
356
357 switch (channelClass)
358 {
359 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
360 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
361 {
362 DE_ASSERT(!is64Bit); // There are no 64-bit fixed point formats.
363
364 const Vec4 resColor (access.getPixel(x, y, z));
365 Vec4 refColor (ref.float32[0],
366 ref.float32[1],
367 ref.float32[2],
368 ref.float32[3]);
369
370 if (isSRGB(access.getFormat()))
371 refColor = linearToSRGB(refColor);
372
373 const bool result = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold.vec4), channelMask), channelMask));
374
375 if (!result)
376 {
377 std::stringstream s;
378 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold.vec4 << " Color:" << resColor;
379 stringResult = s.str();
380 }
381
382 return result;
383 }
384
385 case TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
386 {
387 uint64_t packed[2] { 0ull, 0ull };
388
389 deMemcpy(packed+0, ref.uint32+0, sizeof(uint64_t));
390 deMemcpy(packed+1, ref.uint32+2, sizeof(uint64_t));
391
392 const U64Vec4 resColor (access.getPixelUint64(x, y, z));
393 const U64Vec4 refColor ((is64Bit ? packed[0] : static_cast<uint64_t>(ref.uint32[0])),
394 (is64Bit ? packed[1] : static_cast<uint64_t>(ref.uint32[1])),
395 static_cast<uint64_t>(is64Bit ? 0u : ref.uint32[2]),
396 static_cast<uint64_t>(is64Bit ? 0u : ref.uint32[3]));
397 const U64Vec4 threshold64 (threshold.uvec4[0], threshold.uvec4[1], threshold.uvec4[2], threshold.uvec4[3]);
398 const bool result = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold64), channelMask), channelMask));
399
400 if (!result)
401 {
402 std::stringstream s;
403 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold64 << " Color:" << resColor;
404 stringResult = s.str();
405 }
406
407 return result;
408 }
409
410 case TEXTURECHANNELCLASS_SIGNED_INTEGER:
411 {
412 int64_t packed[2] { 0ll, 0ll };
413
414 deMemcpy(packed+0, ref.int32+0, sizeof(int64_t));
415 deMemcpy(packed+1, ref.int32+2, sizeof(int64_t));
416
417 const I64Vec4 resColor (access.getPixelInt64(x, y, z));
418 const I64Vec4 refColor ((is64Bit ? packed[0] : static_cast<int64_t>(ref.int32[0])),
419 (is64Bit ? packed[1] : static_cast<int64_t>(ref.int32[1])),
420 static_cast<int64_t>(is64Bit ? 0 : ref.int32[2]),
421 static_cast<int64_t>(is64Bit ? 0 : ref.int32[3]));
422 const I64Vec4 threshold64 (threshold.ivec4[0], threshold.ivec4[1], threshold.ivec4[2], threshold.ivec4[3]);
423 const bool result = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold64), channelMask), channelMask));
424
425 if (!result)
426 {
427 std::stringstream s;
428 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold64 << " Color:" << resColor;
429 stringResult = s.str();
430 }
431
432 return result;
433 }
434
435 case TEXTURECHANNELCLASS_FLOATING_POINT:
436 {
437 // Not supported so far. The threshold calculation would need to be adjusted, and the framework currently does not
438 // support reading 64-bit floats from pixel buffer accesses (see getPixel below).
439 DE_ASSERT(!is64Bit);
440
441 const Vec4 resColor (access.getPixel(x, y, z));
442 const Vec4 refColor (ref.float32[0],
443 ref.float32[1],
444 ref.float32[2],
445 ref.float32[3]);
446 DE_ASSERT(allEqual(greaterThanEqual(threshold.ivec4, IVec4(0)), BVec4(true)));
447
448 for (int ndx = 0; ndx < 4; ndx++)
449 {
450 const bool result = !(calcFloatDiff(resColor[ndx], refColor[ndx]) > threshold.ivec4[ndx] && channelMask[ndx]);
451
452 if (!result)
453 {
454 float floatThreshold = Float32((deUint32)(threshold).ivec4[0]).asFloat();
455 Vec4 thresholdVec4 (floatThreshold,
456 floatThreshold,
457 floatThreshold,
458 floatThreshold);
459 std::stringstream s;
460 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << thresholdVec4 << " Color:" << resColor;
461 stringResult = s.str();
462
463 return false;
464 }
465 }
466
467 return true;
468 }
469
470 default:
471 DE_FATAL("Invalid channel class");
472 return false;
473 }
474 }
475
extentToString(VkExtent3D extent,VkImageType imageType)476 std::string extentToString (VkExtent3D extent, VkImageType imageType)
477 {
478 // Don't append image dimensions when using the dimensions found in original test cases. This avoids name clashing with the old versions.
479 if (imageType == VK_IMAGE_TYPE_1D && extent.width == 256u) return "";
480 if (imageType == VK_IMAGE_TYPE_2D && extent.width == 256u && extent.height == 256u) return "";
481 if (imageType == VK_IMAGE_TYPE_3D && extent.width == 256u && extent.height == 256u && extent.depth == 16u) return "";
482
483 return (std::string("_") + de::toString(extent.width) + std::string("x") + de::toString(extent.height) + (extent.depth != 1 ? (std::string("x") + de::toString(extent.depth)) : ""));
484 }
485
486 enum SeparateDepthStencilLayoutMode
487 {
488 SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE = 0,
489 SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH,
490 SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL,
491 };
492
493 struct TestParams
494 {
495 bool useSingleMipLevel; //!< only mip level 0, otherwise up to maxMipLevels
496 VkImageType imageType;
497 VkFormat imageFormat;
498 VkImageTiling imageTiling;
499 VkExtent3D imageExtent;
500 deUint32 imageLayerCount;
501 LayerRange imageViewLayerRange;
502 VkClearValue initValue;
503 VkClearValue clearValue[2]; //!< the second value is used with more than one mip map
504 bool useSeparateExpectedClearValue;
505 VkClearValue expectedClearValue[2];
506 LayerRange clearLayerRange;
507 AllocationKind allocationKind;
508 bool isCube;
509 SeparateDepthStencilLayoutMode separateDepthStencilLayoutMode;
510 bool isColorMultipleSubresourceRangeTest;
511 VkSampleCountFlagBits imageSampleCount;
512 };
513
514 template <typename T>
515 class ImageClearingTestCase : public vkt::TestCase
516 {
517 public:
ImageClearingTestCase(tcu::TestContext & testCtx,const std::string & name,TestParams params)518 ImageClearingTestCase(tcu::TestContext& testCtx, const std::string& name, TestParams params)
519 : vkt::TestCase(testCtx, name)
520 , m_params(params)
521 { }
522
523
createInstance(Context & context) const524 TestInstance* createInstance (Context& context) const override
525 {
526 return new T(context, m_params);
527 }
528
checkSupport(Context & context) const529 void checkSupport (Context& context) const override
530 {
531 #ifndef CTS_USES_VULKANSC
532 if (m_params.imageFormat == VK_FORMAT_A8_UNORM_KHR || m_params.imageFormat == VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR)
533 context.requireDeviceFunctionality("VK_KHR_maintenance5");
534 #endif // CTS_USES_VULKANSC
535
536 if (m_params.allocationKind == ALLOCATION_KIND_DEDICATED)
537 context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
538
539 if (m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
540 context.requireDeviceFunctionality("VK_KHR_separate_depth_stencil_layouts");
541 }
542
543 private:
544 TestParams m_params;
545 };
546
547 class ImageClearingTestInstance : public vkt::TestInstance
548 {
549 public:
550 ImageClearingTestInstance (Context& context,
551 const TestParams& testParams);
552
553 Move<VkCommandPool> createCommandPool (VkCommandPoolCreateFlags commandPoolCreateFlags) const;
554 Move<VkCommandBuffer> allocatePrimaryCommandBuffer (VkCommandPool commandPool) const;
555 Move<VkImage> createImage (VkImageType imageType, VkFormat format, VkImageTiling tiling, VkExtent3D extent, deUint32 arrayLayerCount, VkImageUsageFlags usage, VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT) const;
556 Move<VkImageView> createImageView (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask, LayerRange layerRange) const;
557 Move<VkRenderPass> createRenderPass (VkFormat format, VkSampleCountFlagBits sampleCount) const;
558 Move<VkFramebuffer> createFrameBuffer (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight, deUint32 imageLayersCount, VkSampleCountFlagBits sampleCount) const;
559 void beginCommandBuffer (VkCommandBufferUsageFlags usageFlags) const;
560 void endCommandBuffer (void) const;
561 void submitCommandBuffer (void) const;
562 void beginRenderPass (VkSubpassContents content, VkClearValue clearValue) const;
563 void preClearImage (const deUint32 imageMipLevels, VkExtent3D imageExtent, deUint32 imageLayerCount, Unique<VkCommandBuffer>& commandBuffer) const;
564 Move<VkBuffer> createImageClearingBuffer (const DeviceInterface& vkd, const VkDevice device);
565
566 void pipelineImageBarrier (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask = 0u) const;
567 void pipelineMultisampleImageBarrier (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask = 0u) const;
568
569 de::MovePtr<TextureLevelPyramid> readImage (VkImageAspectFlags aspectMask, deUint32 baseLayer) const;
570 tcu::TestStatus verifyResultImage (const std::string& successMessage, const UVec4& clearCoords = UVec4()) const;
571
572 protected:
573 enum ViewType
574 {
575 VIEW_TYPE_SINGLE,
576 VIEW_TYPE_ARRAY,
577 VIEW_TYPE_CUBE
578 };
579 VkImageViewType getCorrespondingImageViewType (VkImageType imageType, ViewType viewType) const;
580 VkImageUsageFlags getImageUsageFlags (VkFormat format) const;
581 VkImageAspectFlags getImageAspectFlags (VkFormat format) const;
582 bool getIsAttachmentFormat (VkFormat format, VkImageTiling tiling) const;
583 bool getIs3DFormat (VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags) const;
584 bool getIsStencilFormat (VkFormat format) const;
585 bool getIsDepthFormat (VkFormat format) const;
586 VkImageFormatProperties getImageFormatProperties (void) const;
587 VkImageCreateFlags getImageCreateFlags (void) const;
588 ViewType getViewType (deUint32 imageLayerCount) const;
589 de::MovePtr<Allocation> allocateAndBindImageMemory (VkImage image) const;
590 de::MovePtr<Allocation> allocateAndBindBufferMemory (VkBuffer buffer) const;
591 void pipelineImageBarrierGen (VkImage image, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask = 0u) const;
592
593 const TestParams& m_params;
594 const VkDevice m_device;
595 const InstanceInterface& m_vki;
596 const DeviceInterface& m_vkd;
597 const VkQueue m_queue;
598 const deUint32 m_queueFamilyIndex;
599 Allocator& m_allocator;
600
601 const bool m_isAttachmentFormat;
602 const VkImageUsageFlags m_imageUsageFlags;
603 const VkImageAspectFlags m_imageAspectFlags;
604 const VkImageFormatProperties m_imageFormatProperties;
605 const deUint32 m_imageMipLevels;
606 const deUint32 m_thresholdMipLevel;
607
608 Unique<VkCommandPool> m_commandPool;
609 Unique<VkCommandBuffer> m_commandBuffer;
610
611 const bool m_is3DFormat;
612 Unique<VkImage> m_image;
613 Move<VkBuffer> m_stagingBuffer;
614 de::MovePtr<Allocation> m_stagingBufferMemory;
615 de::MovePtr<Allocation> m_imageMemory;
616 Unique<VkImageView> m_imageView;
617 Unique<VkImage> m_multisampleImage;
618 de::MovePtr<Allocation> m_multisampleImageMemory;
619 Unique<VkImageView> m_multisampleImageView;
620 Move<VkRenderPass> m_renderPass;
621 Move<VkFramebuffer> m_frameBuffer;
622 };
623
ImageClearingTestInstance(Context & context,const TestParams & params)624 ImageClearingTestInstance::ImageClearingTestInstance (Context& context, const TestParams& params)
625 : TestInstance (context)
626 , m_params (params)
627 , m_device (context.getDevice())
628 , m_vki (context.getInstanceInterface())
629 , m_vkd (context.getDeviceInterface())
630 , m_queue (context.getUniversalQueue())
631 , m_queueFamilyIndex (context.getUniversalQueueFamilyIndex())
632 , m_allocator (context.getDefaultAllocator())
633 , m_isAttachmentFormat (getIsAttachmentFormat(params.imageFormat, params.imageTiling))
634 , m_imageUsageFlags (getImageUsageFlags(params.imageFormat))
635 , m_imageAspectFlags (getImageAspectFlags(params.imageFormat))
636 , m_imageFormatProperties (getImageFormatProperties())
637 , m_imageMipLevels (params.useSingleMipLevel ? 1u : getNumMipLevels(params.imageExtent, m_imageFormatProperties.maxMipLevels))
638 , m_thresholdMipLevel (std::max(m_imageMipLevels / 2u, 1u))
639 , m_commandPool (createCommandPool(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT))
640 , m_commandBuffer (allocatePrimaryCommandBuffer(*m_commandPool))
641 , m_is3DFormat (getIs3DFormat(params.imageFormat, params.imageType, params.imageTiling, getImageUsageFlags(params.imageFormat), 0u))
642
643 , m_image (createImage(params.imageType,
644 params.imageFormat,
645 params.imageTiling,
646 params.imageExtent,
647 params.imageLayerCount,
648 m_imageUsageFlags,
649 VK_SAMPLE_COUNT_1_BIT))
650
651 , m_stagingBuffer (createImageClearingBuffer(m_vkd, m_device))
652 , m_stagingBufferMemory (allocateAndBindBufferMemory(*m_stagingBuffer))
653
654 , m_imageMemory (allocateAndBindImageMemory(*m_image))
655 , m_imageView (m_isAttachmentFormat ? createImageView(*m_image,
656 getCorrespondingImageViewType(params.imageType, getViewType(params.imageLayerCount)),
657 params.imageFormat,
658 m_imageAspectFlags,
659 params.imageViewLayerRange) : vk::Move<VkImageView>())
660 , m_multisampleImage ((params.imageSampleCount > VK_SAMPLE_COUNT_1_BIT) ? createImage(params.imageType,
661 params.imageFormat,
662 params.imageTiling,
663 params.imageExtent,
664 params.imageLayerCount,
665 m_imageUsageFlags,
666 params.imageSampleCount) : vk::Move<VkImage>())
667 , m_multisampleImageMemory ((params.imageSampleCount > VK_SAMPLE_COUNT_1_BIT) ? allocateAndBindImageMemory(*m_multisampleImage) : de::MovePtr<Allocation>())
668 , m_multisampleImageView ((m_isAttachmentFormat && (params.imageSampleCount > VK_SAMPLE_COUNT_1_BIT)) ? createImageView(*m_multisampleImage,
669 getCorrespondingImageViewType(params.imageType, getViewType(params.imageLayerCount)),
670 params.imageFormat,
671 m_imageAspectFlags,
672 params.imageViewLayerRange) : vk::Move<VkImageView>())
673
674 {
675 if (!m_is3DFormat)
676 {
677 if (m_isAttachmentFormat)
678 {
679 m_renderPass = createRenderPass(params.imageFormat, params.imageSampleCount);
680
681 m_frameBuffer = createFrameBuffer(*m_imageView, *m_renderPass, params.imageExtent.width, params.imageExtent.height, params.imageViewLayerRange.layerCount, m_params.imageSampleCount);
682 }
683 }
684
685 }
686
getViewType(deUint32 imageLayerCount) const687 ImageClearingTestInstance::ViewType ImageClearingTestInstance::getViewType (deUint32 imageLayerCount) const
688 {
689 if (imageLayerCount > 1u)
690 return m_params.isCube ? VIEW_TYPE_CUBE : VIEW_TYPE_ARRAY;
691 else
692 return VIEW_TYPE_SINGLE;
693 }
694
getCorrespondingImageViewType(VkImageType imageType,ViewType viewType) const695 VkImageViewType ImageClearingTestInstance::getCorrespondingImageViewType (VkImageType imageType, ViewType viewType) const
696 {
697 switch (imageType)
698 {
699 case VK_IMAGE_TYPE_1D:
700 return (viewType == VIEW_TYPE_ARRAY) ? VK_IMAGE_VIEW_TYPE_1D_ARRAY : VK_IMAGE_VIEW_TYPE_1D;
701 case VK_IMAGE_TYPE_2D:
702 if (viewType == VIEW_TYPE_ARRAY)
703 return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
704 else if (viewType == VIEW_TYPE_CUBE)
705 return VK_IMAGE_VIEW_TYPE_CUBE;
706 else
707 return VK_IMAGE_VIEW_TYPE_2D;
708 case VK_IMAGE_TYPE_3D:
709 if (viewType != VIEW_TYPE_SINGLE)
710 {
711 DE_FATAL("Cannot have 3D image array");
712 }
713 return VK_IMAGE_VIEW_TYPE_3D;
714 default:
715 DE_FATAL("Unknown image type!");
716 }
717
718 return VK_IMAGE_VIEW_TYPE_2D;
719 }
720
getImageUsageFlags(VkFormat format) const721 VkImageUsageFlags ImageClearingTestInstance::getImageUsageFlags (VkFormat format) const
722 {
723 VkImageUsageFlags commonFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
724
725 if (m_isAttachmentFormat)
726 {
727 if (isDepthStencilFormat(format))
728 return commonFlags | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
729
730 return commonFlags | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
731 }
732 return commonFlags;
733 }
734
getImageAspectFlags(VkFormat format) const735 VkImageAspectFlags ImageClearingTestInstance::getImageAspectFlags (VkFormat format) const
736 {
737 VkImageAspectFlags imageAspectFlags = 0;
738
739 if (getIsDepthFormat(format))
740 imageAspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
741
742 if (getIsStencilFormat(format))
743 imageAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
744
745 if (imageAspectFlags == 0)
746 imageAspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
747
748 return imageAspectFlags;
749 }
750
getIs3DFormat(VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags) const751 bool ImageClearingTestInstance::getIs3DFormat (VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags) const
752 {
753 const VkImageFormatProperties props = vk::getPhysicalDeviceImageFormatProperties(m_vki, m_context.getPhysicalDevice(), format, type, tiling, usage, flags);
754
755 return props.maxExtent.depth > 1u;
756 }
757
getIsAttachmentFormat(VkFormat format,VkImageTiling tiling) const758 bool ImageClearingTestInstance::getIsAttachmentFormat (VkFormat format, VkImageTiling tiling) const
759 {
760 const VkFormatProperties props = vk::getPhysicalDeviceFormatProperties(m_vki, m_context.getPhysicalDevice(), format);
761 const VkFormatFeatureFlags features = tiling == VK_IMAGE_TILING_OPTIMAL ? props.optimalTilingFeatures : props.linearTilingFeatures;
762
763 return (features & (vk::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) != 0;
764 }
765
getIsStencilFormat(VkFormat format) const766 bool ImageClearingTestInstance::getIsStencilFormat (VkFormat format) const
767 {
768 const TextureFormat tcuFormat = mapVkFormat(format);
769
770 if (tcuFormat.order == TextureFormat::S || tcuFormat.order == TextureFormat::DS)
771 return true;
772
773 return false;
774 }
775
getIsDepthFormat(VkFormat format) const776 bool ImageClearingTestInstance::getIsDepthFormat (VkFormat format) const
777 {
778 const TextureFormat tcuFormat = mapVkFormat(format);
779
780 if (tcuFormat.order == TextureFormat::D || tcuFormat.order == TextureFormat::DS)
781 return true;
782
783 return false;
784 }
785
getImageCreateFlags(void) const786 VkImageCreateFlags ImageClearingTestInstance::getImageCreateFlags (void) const
787 {
788 return m_params.isCube ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : (VkImageCreateFlags)0;
789 }
790
getImageFormatProperties(void) const791 VkImageFormatProperties ImageClearingTestInstance::getImageFormatProperties (void) const
792 {
793 VkImageFormatProperties properties;
794 const VkResult result = m_vki.getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(), m_params.imageFormat, m_params.imageType,
795 m_params.imageTiling, m_imageUsageFlags, getImageCreateFlags(), &properties);
796
797 if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
798 TCU_THROW(NotSupportedError, "Format not supported");
799 else
800 return properties;
801 }
802
allocateAndBindImageMemory(VkImage image) const803 de::MovePtr<Allocation> ImageClearingTestInstance::allocateAndBindImageMemory (VkImage image) const
804 {
805 de::MovePtr<Allocation> imageMemory (allocateImage(m_vki, m_vkd, m_context.getPhysicalDevice(), m_device, image, MemoryRequirement::Any, m_allocator, m_params.allocationKind));
806 VK_CHECK(m_vkd.bindImageMemory(m_device, image, imageMemory->getMemory(), imageMemory->getOffset()));
807 return imageMemory;
808 }
809
allocateAndBindBufferMemory(VkBuffer buffer) const810 de::MovePtr<Allocation> ImageClearingTestInstance::allocateAndBindBufferMemory (VkBuffer buffer) const
811 {
812 de::MovePtr<Allocation> stagingBufferMemory = allocateBuffer(m_vki, m_vkd, m_context.getPhysicalDevice(), m_device, buffer, MemoryRequirement::HostVisible, m_allocator, m_params.allocationKind);
813 VK_CHECK(m_vkd.bindBufferMemory(m_device, buffer, stagingBufferMemory->getMemory(), stagingBufferMemory->getOffset()));
814 return stagingBufferMemory;
815 }
816
createCommandPool(VkCommandPoolCreateFlags commandPoolCreateFlags) const817 Move<VkCommandPool> ImageClearingTestInstance::createCommandPool (VkCommandPoolCreateFlags commandPoolCreateFlags) const
818 {
819 return vk::createCommandPool(m_vkd, m_device, commandPoolCreateFlags, m_queueFamilyIndex);
820 }
821
allocatePrimaryCommandBuffer(VkCommandPool commandPool) const822 Move<VkCommandBuffer> ImageClearingTestInstance::allocatePrimaryCommandBuffer (VkCommandPool commandPool) const
823 {
824 return vk::allocateCommandBuffer(m_vkd, m_device, commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
825 }
826
createImage(VkImageType imageType,VkFormat format,VkImageTiling tiling,VkExtent3D extent,deUint32 arrayLayerCount,VkImageUsageFlags usage,VkSampleCountFlagBits sampleCount) const827 Move<VkImage> ImageClearingTestInstance::createImage (VkImageType imageType, VkFormat format, VkImageTiling tiling, VkExtent3D extent, deUint32 arrayLayerCount, VkImageUsageFlags usage, VkSampleCountFlagBits sampleCount) const
828 {
829 if (arrayLayerCount > m_imageFormatProperties.maxArrayLayers)
830 TCU_THROW(NotSupportedError, "Device does not support enough image array layers");
831
832 if ((sampleCount & m_imageFormatProperties.sampleCounts) == 0)
833 TCU_THROW(NotSupportedError, "Device does not support sample count under test");
834
835 const VkImageCreateInfo imageCreateInfo =
836 {
837 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
838 DE_NULL, // const void* pNext;
839 getImageCreateFlags(), // VkImageCreateFlags flags;
840 imageType, // VkImageType imageType;
841 format, // VkFormat format;
842 extent, // VkExtent3D extent;
843 m_imageMipLevels, // deUint32 mipLevels;
844 arrayLayerCount, // deUint32 arrayLayers;
845 sampleCount, // VkSampleCountFlagBits samples;
846 tiling, // VkImageTiling tiling;
847 usage, // VkImageUsageFlags usage;
848 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
849 1u, // deUint32 queueFamilyIndexCount;
850 &m_queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
851 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
852 };
853
854 return vk::createImage(m_vkd, m_device, &imageCreateInfo, DE_NULL);
855 }
856
createImageView(VkImage image,VkImageViewType viewType,VkFormat format,VkImageAspectFlags aspectMask,LayerRange layerRange) const857 Move<VkImageView> ImageClearingTestInstance::createImageView (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask, LayerRange layerRange) const
858 {
859 const VkImageViewCreateInfo imageViewCreateInfo =
860 {
861 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
862 DE_NULL, // const void* pNext;
863 0u, // VkImageViewCreateFlags flags;
864 image, // VkImage image;
865 viewType, // VkImageViewType viewType;
866 format, // VkFormat format;
867 {
868 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle r;
869 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle g;
870 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle b;
871 VK_COMPONENT_SWIZZLE_IDENTITY, // VkComponentSwizzle a;
872 }, // VkComponentMapping components;
873 {
874 aspectMask, // VkImageAspectFlags aspectMask;
875 0u, // deUint32 baseMipLevel;
876 1u, // deUint32 mipLevels;
877 layerRange.baseArrayLayer, // deUint32 baseArrayLayer;
878 layerRange.layerCount, // deUint32 arraySize;
879 }, // VkImageSubresourceRange subresourceRange;
880 };
881
882 return vk::createImageView(m_vkd, m_device, &imageViewCreateInfo, DE_NULL);
883 }
884
createRenderPass(VkFormat format,VkSampleCountFlagBits sampleCount) const885 Move<VkRenderPass> ImageClearingTestInstance::createRenderPass (VkFormat format, VkSampleCountFlagBits sampleCount) const
886 {
887 if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
888 {
889 VkImageLayout imageLayout;
890
891 if (isDepthStencilFormat(format))
892 imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
893 else
894 imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
895
896 const VkAttachmentDescription attachmentDesc =
897 {
898 0u, // VkAttachmentDescriptionFlags flags;
899 format, // VkFormat format;
900 sampleCount, // VkSampleCountFlagBits samples;
901 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
902 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
903 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp stencilLoadOp;
904 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp;
905 imageLayout, // VkImageLayout initialLayout;
906 imageLayout, // VkImageLayout finalLayout;
907 };
908
909 const VkAttachmentDescription attachmentResolveDesc =
910 {
911 0u, // VkAttachmentDescriptionFlags flags;
912 format, // VkFormat format;
913 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
914 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp;
915 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
916 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
917 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
918 imageLayout, // VkImageLayout initialLayout;
919 imageLayout, // VkImageLayout finalLayout;
920 };
921
922 const VkAttachmentDescription attachments[2] =
923 {
924 attachmentDesc,
925 attachmentResolveDesc
926 };
927
928 uint32_t attachmentCount = 1;
929 if (sampleCount > VK_SAMPLE_COUNT_1_BIT)
930 attachmentCount++;
931
932 const VkAttachmentReference attachmentRef =
933 {
934 0u, // deUint32 attachment;
935 imageLayout, // VkImageLayout layout;
936 };
937
938 const VkAttachmentReference attachmentResolveRef =
939 {
940 1u, // deUint32 attachment;
941 imageLayout, // VkImageLayout layout;
942 };
943
944 const VkAttachmentReference* pColorAttachments = DE_NULL;
945 const VkAttachmentReference* pDepthStencilAttachment = DE_NULL;
946 const VkAttachmentReference* pResolveAttachments = DE_NULL;
947 deUint32 colorAttachmentCount = 1;
948
949 if (isDepthStencilFormat(format))
950 {
951 colorAttachmentCount = 0;
952 pDepthStencilAttachment = &attachmentRef;
953 }
954 else
955 {
956 colorAttachmentCount = 1;
957 pColorAttachments = &attachmentRef;
958 if (sampleCount > VK_SAMPLE_COUNT_1_BIT)
959 pResolveAttachments = &attachmentResolveRef;
960 }
961
962 const VkSubpassDescription subpassDesc[1] =
963 {
964 {
965 0u, // VkSubpassDescriptionFlags flags;
966 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
967 0u, // deUint32 inputAttachmentCount;
968 DE_NULL, // const VkAttachmentReference* pInputAttachments;
969 colorAttachmentCount, // deUint32 colorAttachmentCount;
970 pColorAttachments, // const VkAttachmentReference* pColorAttachments;
971 pResolveAttachments, // const VkAttachmentReference* pResolveAttachments;
972 pDepthStencilAttachment, // const VkAttachmentReference* pDepthStencilAttachment;
973 0u, // deUint32 preserveAttachmentCount;
974 DE_NULL, // const VkAttachmentReference* pPreserveAttachments;
975 }
976 };
977
978 const VkRenderPassCreateInfo renderPassCreateInfo =
979 {
980 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
981 DE_NULL, // const void* pNext;
982 0u, // VkRenderPassCreateFlags flags;
983 attachmentCount, // deUint32 attachmentCount;
984 attachments, // const VkAttachmentDescription* pAttachments;
985 1u, // deUint32 subpassCount;
986 subpassDesc, // const VkSubpassDescription* pSubpasses;
987 0u, // deUint32 dependencyCount;
988 DE_NULL, // const VkSubpassDependency* pDependencies;
989 };
990
991 return vk::createRenderPass(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
992 }
993 else
994 {
995 // Make sure VK_KHR_create_renderpass2 is supported. Due to InstanceFactory1 being used and the render pass being created in
996 // the instance constructor and not every time, this is the best moment to check.
997 m_context.requireDeviceFunctionality("VK_KHR_create_renderpass2");
998
999 VkImageLayout initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
1000 VkImageLayout finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
1001 VkAttachmentDescriptionStencilLayout stencilLayouts =
1002 {
1003 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
1004 DE_NULL,
1005 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1006 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1007 };
1008
1009 VkImageLayout imageLayout;
1010 VkAttachmentReferenceStencilLayout stencilLayoutRef =
1011 {
1012 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
1013 DE_NULL,
1014 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1015 };
1016
1017 if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1018 {
1019 initialLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
1020 finalLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
1021 stencilLayouts.stencilInitialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
1022 stencilLayouts.stencilFinalLayout = VK_IMAGE_LAYOUT_GENERAL;
1023 imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
1024 stencilLayoutRef.stencilLayout = VK_IMAGE_LAYOUT_GENERAL;
1025 }
1026 else
1027 {
1028 initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
1029 finalLayout = VK_IMAGE_LAYOUT_GENERAL;
1030 stencilLayouts.stencilInitialLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
1031 stencilLayouts.stencilFinalLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
1032 imageLayout = VK_IMAGE_LAYOUT_GENERAL;
1033 stencilLayoutRef.stencilLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
1034 }
1035
1036 const VkAttachmentDescription2 attachmentDesc =
1037 {
1038 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1039 &stencilLayouts, // const void* pNext;
1040 0u, // VkAttachmentDescriptionFlags flags;
1041 format, // VkFormat format;
1042 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1043 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
1044 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1045 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp stencilLoadOp;
1046 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp;
1047 initialLayout, // VkImageLayout initialLayout;
1048 finalLayout, // VkImageLayout finalLayout;
1049 };
1050
1051 const VkAttachmentReference2 attachmentRef =
1052 {
1053 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // VkStructureType sType;
1054 &stencilLayoutRef, // const void* pNext;
1055 0u, // deUint32 attachment;
1056 imageLayout, // VkImageLayout layout;
1057 0u, // VkImageAspectFlags aspectMask;
1058 };
1059
1060 const VkSubpassDescription2 subpassDesc =
1061 {
1062 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, // VkStructureType sType;
1063 DE_NULL, // const void* pNext;
1064 0u, // VkSubpassDescriptionFlags flags;
1065 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
1066 0u, // deUint32 viewMask;
1067 0u, // deUint32 inputAttachmentCount;
1068 DE_NULL, // const VkAttachmentReference2KHR* pInputAttachments;
1069 0u, // deUint32 colorAttachmentCount;
1070 DE_NULL, // const VkAttachmentReference2KHR* pColorAttachments;
1071 DE_NULL, // const VkAttachmentReference2KHR* pResolveAttachments;
1072 &attachmentRef, // const VkAttachmentReference2KHR* pDepthStencilAttachment;
1073 0u, // deUint32 preserveAttachmentCount;
1074 DE_NULL, // const VkAttachmentReference2KHR* pPreserveAttachments;
1075 };
1076
1077 const VkRenderPassCreateInfo2 renderPassCreateInfo =
1078 {
1079 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, // VkStructureType sType;
1080 DE_NULL, // const void* pNext;
1081 0u, // VkRenderPassCreateFlags flags;
1082 1u, // deUint32 attachmentCount;
1083 &attachmentDesc, // const VkAttachmentDescription* pAttachments;
1084 1u, // deUint32 subpassCount;
1085 &subpassDesc, // const VkSubpassDescription* pSubpasses;
1086 0u, // deUint32 dependencyCount;
1087 DE_NULL, // const VkSubpassDependency* pDependencies;
1088 0u, // deUint32 correlatedViewMaskCount;
1089 DE_NULL, // const deUint32* pCorrelatedViewMasks;
1090 };
1091
1092 return vk::createRenderPass2(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
1093 }
1094 }
1095
createFrameBuffer(VkImageView imageView,VkRenderPass renderPass,deUint32 imageWidth,deUint32 imageHeight,deUint32 imageLayersCount,VkSampleCountFlagBits sampleCount) const1096 Move<VkFramebuffer> ImageClearingTestInstance::createFrameBuffer (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight, deUint32 imageLayersCount, VkSampleCountFlagBits sampleCount) const
1097 {
1098 std::vector<VkImageView> attachmentViews;
1099
1100 if (sampleCount > VK_SAMPLE_COUNT_1_BIT)
1101 attachmentViews.push_back(*m_multisampleImageView);
1102
1103 attachmentViews.push_back(imageView);
1104
1105 const VkFramebufferCreateInfo framebufferCreateInfo =
1106 {
1107 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
1108 DE_NULL, // const void* pNext;
1109 0u, // VkFramebufferCreateFlags flags;
1110 renderPass, // VkRenderPass renderPass;
1111 de::sizeU32(attachmentViews), // deUint32 attachmentCount;
1112 de::dataOrNull(attachmentViews), // const VkImageView* pAttachments;
1113 imageWidth, // deUint32 width;
1114 imageHeight, // deUint32 height;
1115 imageLayersCount, // deUint32 layers;
1116 };
1117
1118 return createFramebuffer(m_vkd, m_device, &framebufferCreateInfo, DE_NULL);
1119 }
1120
beginCommandBuffer(VkCommandBufferUsageFlags usageFlags) const1121 void ImageClearingTestInstance::beginCommandBuffer (VkCommandBufferUsageFlags usageFlags) const
1122 {
1123 vk::beginCommandBuffer(m_vkd, *m_commandBuffer, usageFlags);
1124 }
1125
endCommandBuffer(void) const1126 void ImageClearingTestInstance::endCommandBuffer (void) const
1127 {
1128 vk::endCommandBuffer(m_vkd, *m_commandBuffer);
1129 }
1130
submitCommandBuffer(void) const1131 void ImageClearingTestInstance::submitCommandBuffer (void) const
1132 {
1133 submitCommandsAndWait(m_vkd, m_device, m_queue, m_commandBuffer.get());
1134 m_context.resetCommandPoolForVKSC(m_device, *m_commandPool);
1135 }
1136
pipelineImageBarrierGen(VkImage image,VkPipelineStageFlags srcStageMask,VkPipelineStageFlags dstStageMask,VkAccessFlags srcAccessMask,VkAccessFlags dstAccessMask,VkImageLayout oldLayout,VkImageLayout newLayout,VkImageAspectFlags aspectMask) const1137 void ImageClearingTestInstance::pipelineImageBarrierGen(VkImage image, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask) const
1138 {
1139 if (!aspectMask || m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
1140 aspectMask = m_imageAspectFlags;
1141
1142 const VkImageMemoryBarrier imageBarrier =
1143 {
1144 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1145 DE_NULL, // const void* pNext;
1146 srcAccessMask, // VkAccessFlags srcAccessMask;
1147 dstAccessMask, // VkAccessFlags dstAccessMask;
1148 oldLayout, // VkImageLayout oldLayout;
1149 newLayout, // VkImageLayout newLayout;
1150 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1151 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
1152 image, // VkImage image;
1153 {
1154 aspectMask, // VkImageAspectFlags aspectMask;
1155 0u, // deUint32 baseMipLevel;
1156 VK_REMAINING_MIP_LEVELS, // deUint32 levelCount;
1157 0u, // deUint32 baseArrayLayer;
1158 VK_REMAINING_ARRAY_LAYERS, // deUint32 layerCount;
1159 }, // VkImageSubresourceRange subresourceRange;
1160 };
1161
1162 m_vkd.cmdPipelineBarrier(*m_commandBuffer, srcStageMask, dstStageMask, 0, 0, DE_NULL, 0, DE_NULL, 1, &imageBarrier);
1163 }
1164
pipelineImageBarrier(VkPipelineStageFlags srcStageMask,VkPipelineStageFlags dstStageMask,VkAccessFlags srcAccessMask,VkAccessFlags dstAccessMask,VkImageLayout oldLayout,VkImageLayout newLayout,VkImageAspectFlags aspectMask) const1165 void ImageClearingTestInstance::pipelineImageBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask) const
1166 {
1167 pipelineImageBarrierGen(*m_image,
1168 srcStageMask,
1169 dstStageMask,
1170 srcAccessMask,
1171 dstAccessMask,
1172 oldLayout,
1173 newLayout,
1174 aspectMask);
1175 }
1176
pipelineMultisampleImageBarrier(VkPipelineStageFlags srcStageMask,VkPipelineStageFlags dstStageMask,VkAccessFlags srcAccessMask,VkAccessFlags dstAccessMask,VkImageLayout oldLayout,VkImageLayout newLayout,VkImageAspectFlags aspectMask) const1177 void ImageClearingTestInstance::pipelineMultisampleImageBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask) const
1178 {
1179 pipelineImageBarrierGen(*m_multisampleImage,
1180 srcStageMask,
1181 dstStageMask,
1182 srcAccessMask,
1183 dstAccessMask,
1184 oldLayout,
1185 newLayout,
1186 aspectMask);
1187 }
1188
readImage(VkImageAspectFlags aspectMask,deUint32 arrayLayer) const1189 de::MovePtr<TextureLevelPyramid> ImageClearingTestInstance::readImage (VkImageAspectFlags aspectMask, deUint32 arrayLayer) const
1190 {
1191 const TextureFormat tcuFormat = aspectMask == VK_IMAGE_ASPECT_COLOR_BIT ? mapVkFormat(m_params.imageFormat) :
1192 aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT ? getDepthCopyFormat(m_params.imageFormat) :
1193 aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT ? getStencilCopyFormat(m_params.imageFormat) :
1194 TextureFormat();
1195 const deUint32 pixelSize = getPixelSize(tcuFormat);
1196 deUint32 alignment = 4; // subsequent mip levels aligned to 4 bytes
1197
1198 if (!getIsDepthFormat(m_params.imageFormat) && !getIsStencilFormat(m_params.imageFormat))
1199 alignment = lowestCommonMultiple(pixelSize, alignment); // alignment must be multiple of pixel size, if not D/S.
1200
1201 const std::vector<deUint32> mipLevelSizes = getImageMipLevelSizes(pixelSize, m_params.imageExtent, m_imageMipLevels, alignment);
1202 const VkDeviceSize imageTotalSize = std::accumulate(mipLevelSizes.begin(), mipLevelSizes.end(), 0u);
1203
1204 de::MovePtr<TextureLevelPyramid> result (new TextureLevelPyramid(tcuFormat, m_imageMipLevels));
1205 Move<VkBuffer> buffer;
1206 de::MovePtr<Allocation> bufferAlloc;
1207
1208 // Create destination buffer
1209 {
1210 const VkBufferCreateInfo bufferParams =
1211 {
1212 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1213 DE_NULL, // const void* pNext;
1214 0u, // VkBufferCreateFlags flags;
1215 imageTotalSize, // VkDeviceSize size;
1216 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
1217 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1218 0u, // deUint32 queueFamilyIndexCount;
1219 DE_NULL // const deUint32* pQueueFamilyIndices;
1220 };
1221
1222 buffer = createBuffer(m_vkd, m_device, &bufferParams);
1223 bufferAlloc = allocateBuffer(m_vki, m_vkd, m_context.getPhysicalDevice(), m_device, *buffer, MemoryRequirement::HostVisible, m_allocator, m_params.allocationKind);
1224 VK_CHECK(m_vkd.bindBufferMemory(m_device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
1225 }
1226
1227 // Barriers for copying image to buffer
1228
1229 const VkBufferMemoryBarrier bufferBarrier =
1230 {
1231 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1232 DE_NULL, // const void* pNext;
1233 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1234 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1235 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1236 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1237 *buffer, // VkBuffer buffer;
1238 0u, // VkDeviceSize offset;
1239 imageTotalSize, // VkDeviceSize size;
1240 };
1241
1242 // Copy image to buffer
1243 std::vector<VkBufferImageCopy> copyRegions;
1244 {
1245 deUint32 offset = 0u;
1246 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
1247 {
1248 const VkExtent3D extent = getMipLevelExtent(m_params.imageExtent, mipLevel);
1249 const VkBufferImageCopy region =
1250 {
1251 offset, // VkDeviceSize bufferOffset;
1252 0u, // deUint32 bufferRowLength;
1253 0u, // deUint32 bufferImageHeight;
1254 { aspectMask, mipLevel, arrayLayer, 1u }, // VkImageSubresourceLayers imageSubresource;
1255 { 0, 0, 0 }, // VkOffset3D imageOffset;
1256 extent // VkExtent3D imageExtent;
1257 };
1258 copyRegions.push_back(region);
1259 offset += mipLevelSizes[mipLevel];
1260 }
1261 }
1262
1263 beginCommandBuffer(0);
1264
1265 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
1266 VK_PIPELINE_STAGE_TRANSFER_BIT,
1267 VK_ACCESS_TRANSFER_WRITE_BIT,
1268 VK_ACCESS_TRANSFER_READ_BIT,
1269 VK_IMAGE_LAYOUT_GENERAL,
1270 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1271 aspectMask);
1272
1273 m_vkd.cmdCopyImageToBuffer(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, static_cast<deUint32>(copyRegions.size()), ©Regions[0]);
1274 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);
1275
1276 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
1277 VK_PIPELINE_STAGE_TRANSFER_BIT,
1278 VK_ACCESS_TRANSFER_READ_BIT,
1279 VK_ACCESS_TRANSFER_READ_BIT,
1280 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1281 VK_IMAGE_LAYOUT_GENERAL,
1282 aspectMask);
1283
1284 endCommandBuffer();
1285 submitCommandBuffer();
1286
1287 invalidateAlloc(m_vkd, m_device, *bufferAlloc);
1288
1289 {
1290 deUint32 offset = 0u;
1291 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
1292 {
1293 const VkExtent3D extent = getMipLevelExtent(m_params.imageExtent, mipLevel);
1294 const void* pLevelData = static_cast<const void*>(reinterpret_cast<deUint8*>(bufferAlloc->getHostPtr()) + offset);
1295
1296 result->allocLevel(mipLevel, extent.width, extent.height, extent.depth);
1297 copy(result->getLevel(mipLevel), ConstPixelBufferAccess(result->getFormat(), result->getLevel(mipLevel).getSize(), pLevelData));
1298
1299 offset += mipLevelSizes[mipLevel];
1300 }
1301 }
1302
1303 return result;
1304 }
1305
verifyResultImage(const std::string & successMessage,const UVec4 & clearCoords) const1306 tcu::TestStatus ImageClearingTestInstance::verifyResultImage (const std::string& successMessage, const UVec4& clearCoords) const
1307 {
1308 DE_ASSERT((clearCoords == UVec4()) || m_params.imageExtent.depth == 1u);
1309
1310 tcu::TestStatus result = tcu::TestStatus::pass(successMessage);
1311 bool errorsPresent = false;
1312
1313 if (getIsDepthFormat(m_params.imageFormat) && m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
1314 {
1315 DE_ASSERT(m_imageMipLevels == 1u);
1316
1317 for (deUint32 arrayLayer = 0; arrayLayer < m_params.imageLayerCount && !errorsPresent; ++arrayLayer)
1318 {
1319 de::MovePtr<TextureLevelPyramid> image = readImage(VK_IMAGE_ASPECT_DEPTH_BIT, arrayLayer);
1320 std::string message;
1321 float depthValue;
1322
1323 #ifdef CTS_USES_VULKANSC
1324 if (!m_context.getTestContext().getCommandLine().isSubProcess())
1325 continue;
1326 #endif // CTS_USES_VULKANSC
1327
1328 for (deUint32 z = 0; z < m_params.imageExtent.depth && !errorsPresent; ++z)
1329 for (deUint32 y = 0; y < m_params.imageExtent.height && !errorsPresent; ++y)
1330 for (deUint32 x = 0; x < m_params.imageExtent.width && !errorsPresent; ++x)
1331 {
1332 if (isInClearRange(clearCoords, x, y, arrayLayer, m_params.imageViewLayerRange, m_params.clearLayerRange))
1333 depthValue = m_params.clearValue[0].depthStencil.depth;
1334 else
1335 if (isInInitialClearRange(0u /* mipLevel */, arrayLayer, m_params.imageViewLayerRange))
1336 {
1337 depthValue = m_params.initValue.depthStencil.depth;
1338 }
1339 else
1340 continue;
1341
1342 if (!comparePixelToDepthClearValue(image->getLevel(0), x, y, z, depthValue, message))
1343 {
1344 result = TestStatus::fail("Depth value mismatch! " + message);
1345 errorsPresent = true;
1346 }
1347 }
1348 }
1349 }
1350
1351 if (getIsStencilFormat(m_params.imageFormat) && m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1352 {
1353 DE_ASSERT(m_imageMipLevels == 1u);
1354
1355 for (deUint32 arrayLayer = 0; arrayLayer < m_params.imageLayerCount && !errorsPresent; ++arrayLayer)
1356 {
1357 de::MovePtr<TextureLevelPyramid> image = readImage(VK_IMAGE_ASPECT_STENCIL_BIT, arrayLayer);
1358 std::string message;
1359 deUint32 stencilValue;
1360
1361 #ifdef CTS_USES_VULKANSC
1362 if (!m_context.getTestContext().getCommandLine().isSubProcess())
1363 continue;
1364 #endif // CTS_USES_VULKANSC
1365
1366 for (deUint32 z = 0; z < m_params.imageExtent.depth && !errorsPresent; ++z)
1367 for (deUint32 y = 0; y < m_params.imageExtent.height && !errorsPresent; ++y)
1368 for (deUint32 x = 0; x < m_params.imageExtent.width && !errorsPresent; ++x)
1369 {
1370 if (isInClearRange(clearCoords, x, y, arrayLayer, m_params.imageViewLayerRange, m_params.clearLayerRange))
1371 stencilValue = m_params.clearValue[0].depthStencil.stencil;
1372 else
1373 if (isInInitialClearRange(0u /* mipLevel */, arrayLayer, m_params.imageViewLayerRange))
1374 {
1375 stencilValue = m_params.initValue.depthStencil.stencil;
1376 }
1377 else
1378 continue;
1379
1380 if (!comparePixelToStencilClearValue(image->getLevel(0), x, y, z, stencilValue, message))
1381 {
1382 result = TestStatus::fail("Stencil value mismatch! " + message);
1383 errorsPresent = true;
1384 }
1385 }
1386 }
1387 }
1388
1389 if (!isDepthStencilFormat(m_params.imageFormat))
1390 {
1391 const TextureFormat format = mapVkFormat(m_params.imageFormat);
1392 const TextureChannelClass channelClass = getTextureChannelClass(format.type);
1393 const BVec4 channelMask = getTextureFormatChannelMask(format);
1394 Threshold threshold {Vec4 (0)};
1395 switch (channelClass)
1396 {
1397 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1398 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1399 {
1400 const IVec4 formatDepth = getTextureFormatBitDepth(format);
1401 const int modifier = (channelClass == TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT) ? 0 : 1;
1402 threshold.vec4 = {formatDepth[0] > 0 ? 1.0f / ((float)(1 << (formatDepth[0] - modifier)) - 1.0f) : 1.0f,
1403 formatDepth[1] > 0 ? 1.0f / ((float)(1 << (formatDepth[1] - modifier)) - 1.0f) : 1.0f,
1404 formatDepth[2] > 0 ? 1.0f / ((float)(1 << (formatDepth[2] - modifier)) - 1.0f) : 1.0f,
1405 formatDepth[3] > 0 ? 1.0f / ((float)(1 << (formatDepth[3] - modifier)) - 1.0f) : 1.0f};
1406 break;
1407 }
1408 case TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1409 {
1410 threshold.uvec4 = UVec4(1U);
1411 break;
1412 }
1413 case TEXTURECHANNELCLASS_SIGNED_INTEGER:
1414 {
1415 threshold.ivec4 = IVec4(1);
1416 break;
1417 }
1418 case TEXTURECHANNELCLASS_FLOATING_POINT:
1419 {
1420 const IVec4& mantissaBits = getTextureFormatMantissaBitDepth(format);
1421 threshold.ivec4 = IVec4(10 * IVec4(1) << (23 - mantissaBits));
1422 break;
1423 }
1424 default:
1425 DE_FATAL("Invalid channel class");
1426 }
1427
1428 for (deUint32 arrayLayer = 0; arrayLayer < m_params.imageLayerCount && !errorsPresent; ++arrayLayer)
1429 {
1430 de::MovePtr<TextureLevelPyramid> image = readImage(VK_IMAGE_ASPECT_COLOR_BIT, arrayLayer);
1431 std::string message;
1432 const VkClearColorValue* pColorValue;
1433
1434 #ifdef CTS_USES_VULKANSC
1435 if (!m_context.getTestContext().getCommandLine().isSubProcess())
1436 continue;
1437 #endif // CTS_USES_VULKANSC
1438
1439 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels && !errorsPresent; ++mipLevel)
1440 {
1441 const int clearColorNdx = ((mipLevel < m_thresholdMipLevel || m_params.isColorMultipleSubresourceRangeTest) ? 0 : 1);
1442 const VkExtent3D extent = getMipLevelExtent(m_params.imageExtent, mipLevel);
1443 const VkClearColorValue* pExpectedColorValue = &(m_params.useSeparateExpectedClearValue ? m_params.expectedClearValue : m_params.clearValue)[clearColorNdx].color;
1444 const auto& pixelBufferAccess = image->getLevel(mipLevel);
1445
1446 for (deUint32 z = 0; z < extent.depth && !errorsPresent; ++z)
1447 for (deUint32 y = 0; y < extent.height && !errorsPresent; ++y)
1448 for (deUint32 x = 0; x < extent.width && !errorsPresent; ++x)
1449 {
1450 if (isInClearRange(clearCoords, x, y, arrayLayer, m_params.imageViewLayerRange, m_params.clearLayerRange))
1451 {
1452 pColorValue = pExpectedColorValue;
1453 }
1454 else
1455 {
1456 if (isInInitialClearRange(mipLevel, arrayLayer, m_params.imageViewLayerRange))
1457 {
1458 pColorValue = &m_params.initValue.color;
1459 }
1460 else
1461 {
1462 continue;
1463 }
1464 }
1465 if (!comparePixelToColorClearValue(pixelBufferAccess, x, y, z, *pColorValue, message, threshold, channelMask, channelClass))
1466 {
1467 errorsPresent = true;
1468 result = TestStatus::fail("Color value mismatch! " + message);
1469 }
1470 }
1471 }
1472 }
1473 }
1474
1475 return result;
1476 }
1477
createImageClearingBuffer(const DeviceInterface & vkd,const VkDevice device)1478 Move<VkBuffer> ImageClearingTestInstance::createImageClearingBuffer(const DeviceInterface& vkd, const VkDevice device)
1479 {
1480 Move<VkBuffer> stagingBuffer;
1481 de::MovePtr<Allocation> stagingBufferAlloc;
1482 const VkDeviceSize stagingBufferSize = m_params.imageExtent.width * m_params.imageExtent.height * m_params.imageExtent.depth
1483 * getPixelSize(mapVkFormat(m_params.imageFormat)) * m_params.imageLayerCount;
1484 // Create image clearing buffer
1485 {
1486 const VkBufferCreateInfo bufferParams =
1487 {
1488 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1489 DE_NULL, // const void* pNext;
1490 0u, // VkBufferCreateFlags flags;
1491 stagingBufferSize, // VkDeviceSize size;
1492 VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
1493 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1494 0u, // deUint32 queueFamilyIndexCount;
1495 DE_NULL // const deUint32* pQueueFamilyIndices;
1496 };
1497 stagingBuffer = createBuffer(vkd, device, &bufferParams);
1498 }
1499 return stagingBuffer;
1500 }
1501
preClearImage(const deUint32 imageMipLevels,VkExtent3D imageExtent,deUint32 imageLayerCount,Unique<VkCommandBuffer> & commandBuffer) const1502 void ImageClearingTestInstance::preClearImage (const deUint32 imageMipLevels, VkExtent3D imageExtent, deUint32 imageLayerCount, Unique<VkCommandBuffer>& commandBuffer) const
1503 {
1504 std::vector<VkBufferImageCopy> copyRegions;
1505 std::vector<VkImageAspectFlags> aspectMasks;
1506
1507 if (getIsDepthFormat(m_params.imageFormat))
1508 aspectMasks.push_back(VK_IMAGE_ASPECT_DEPTH_BIT);
1509 if (getIsStencilFormat(m_params.imageFormat))
1510 aspectMasks.push_back(VK_IMAGE_ASPECT_STENCIL_BIT);
1511 if (aspectMasks.empty())
1512 aspectMasks.push_back(VK_IMAGE_ASPECT_COLOR_BIT);
1513
1514 for (deUint32 mipLevel = 0; mipLevel < imageMipLevels; ++mipLevel)
1515 {
1516 const VkExtent3D extent = getMipLevelExtent(imageExtent, mipLevel);
1517 for (auto mask : aspectMasks)
1518 {
1519 const VkImageSubresourceLayers imageSubResource =
1520 {
1521 mask, // VkImageAspectFlags aspectMask
1522 mipLevel, // uint32_t mipLevel
1523 0u, // uint32_t baseArrayLayer
1524 imageLayerCount // uint32_t layerCount
1525 };
1526 const VkBufferImageCopy region =
1527 {
1528 0u, // VkDeviceSize bufferOffset;
1529 0u, // deUint32 bufferRowLength;
1530 0u, // deUint32 bufferImageHeight;
1531 imageSubResource, // VkImageSubresourceLayers imageSubresource;
1532 {0, 0, 0}, // VkOffset3D imageOffset;
1533 extent // VkExtent3D imageExtent;
1534 };
1535 copyRegions.push_back(region);
1536 }
1537 }
1538
1539 m_vkd.cmdFillBuffer(*commandBuffer, *m_stagingBuffer, 0u, VK_WHOLE_SIZE, 0u);
1540
1541 const vk::VkBufferMemoryBarrier copyBufferBarrier =
1542 {
1543 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
1544 DE_NULL, // const void* pNext
1545 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1546 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1547 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
1548 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
1549 *m_stagingBuffer, // VkBuffer buffer
1550 0u, // VkDeviceSize offset
1551 VK_WHOLE_SIZE, // VkDeviceSize size
1552 };
1553
1554 m_vkd.cmdPipelineBarrier(*commandBuffer,
1555 VK_PIPELINE_STAGE_TRANSFER_BIT,
1556 VK_PIPELINE_STAGE_TRANSFER_BIT,
1557 (VkDependencyFlags)0,
1558 0, (const vk::VkMemoryBarrier*)DE_NULL,
1559 1, ©BufferBarrier,
1560 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
1561
1562 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1563 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1564 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1565 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1566 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1567 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1568
1569 m_vkd.cmdCopyBufferToImage(*commandBuffer, *m_stagingBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(copyRegions.size()), ©Regions[0]);
1570 }
1571
beginRenderPass(VkSubpassContents content,VkClearValue clearValue) const1572 void ImageClearingTestInstance::beginRenderPass (VkSubpassContents content, VkClearValue clearValue) const
1573 {
1574 vk::beginRenderPass(m_vkd, *m_commandBuffer, *m_renderPass, *m_frameBuffer, makeRect2D(0, 0, m_params.imageExtent.width, m_params.imageExtent.height), clearValue, content);
1575 }
1576
1577 class ClearColorImageTestInstance : public ImageClearingTestInstance
1578 {
1579 public:
ClearColorImageTestInstance(Context & context,const TestParams & testParams,bool twoStep=false)1580 ClearColorImageTestInstance (Context& context, const TestParams& testParams, bool twoStep = false) : ImageClearingTestInstance (context, testParams), m_twoStep(twoStep) {}
1581 virtual TestStatus iterate (void);
1582 protected:
1583 bool m_twoStep;
1584 };
1585
1586 class TwoStepClearColorImageTestInstance : public ClearColorImageTestInstance
1587 {
1588 public:
TwoStepClearColorImageTestInstance(Context & context,const TestParams & testParams)1589 TwoStepClearColorImageTestInstance (Context& context, const TestParams& testParams) : ClearColorImageTestInstance(context, testParams, true) {}
1590 };
1591
1592 class ClearColorImageMultipleSubresourceRangeTestInstance : public ClearColorImageTestInstance
1593 {
1594 public:
ClearColorImageMultipleSubresourceRangeTestInstance(Context & context,const TestParams & testParams)1595 ClearColorImageMultipleSubresourceRangeTestInstance (Context& context, const TestParams& testParams) : ClearColorImageTestInstance(context, testParams, false) {}
1596 virtual TestStatus iterate (void);
1597 };
1598
iterate(void)1599 TestStatus ClearColorImageMultipleSubresourceRangeTestInstance::iterate(void)
1600 {
1601 std::vector<VkImageSubresourceRange> subresourceRanges;
1602
1603 DE_ASSERT(m_imageMipLevels > 1u);
1604
1605 deUint32 mipLevel = 0u;
1606 // Create a subresource range per mipmap level.
1607 do {
1608 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, mipLevel++, 1u, m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1609 } while (mipLevel < m_imageMipLevels);
1610
1611 beginCommandBuffer(0);
1612
1613 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1614 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1615 0, // VkAccessFlags srcAccessMask
1616 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1617 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1618 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1619
1620 preClearImage(m_imageMipLevels, m_params.imageExtent, m_params.imageLayerCount, m_commandBuffer);
1621
1622 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1623 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1624 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1625 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1626 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1627 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1628
1629 // Test clear color in all ranges
1630 m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].color, static_cast<deUint32>(subresourceRanges.size()), subresourceRanges.data());
1631
1632 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1633 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1634 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1635 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1636 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1637 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
1638
1639 endCommandBuffer();
1640 submitCommandBuffer();
1641
1642 return verifyResultImage("cmdClearColorImage passed");
1643 }
1644
iterate(void)1645 TestStatus ClearColorImageTestInstance::iterate (void)
1646 {
1647 std::vector<VkImageSubresourceRange> subresourceRanges;
1648 std::vector<VkImageSubresourceRange> steptwoRanges;
1649
1650 if (m_imageMipLevels == 1)
1651 {
1652 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, 0u, 1u, m_params.clearLayerRange.baseArrayLayer, m_twoStep ? 1 : m_params.clearLayerRange.layerCount));
1653 steptwoRanges.push_back( makeImageSubresourceRange(m_imageAspectFlags, 0u, VK_REMAINING_MIP_LEVELS, m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS));
1654 }
1655 else
1656 {
1657 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, 0u, m_thresholdMipLevel, m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1658 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, m_thresholdMipLevel, VK_REMAINING_MIP_LEVELS, m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1659 steptwoRanges.push_back( makeImageSubresourceRange(m_imageAspectFlags, 0u, m_thresholdMipLevel, m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS));
1660 steptwoRanges.push_back( makeImageSubresourceRange(m_imageAspectFlags, m_thresholdMipLevel, VK_REMAINING_MIP_LEVELS, m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS));
1661 }
1662
1663 beginCommandBuffer(0);
1664
1665 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1666 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1667 0, // VkAccessFlags srcAccessMask
1668 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1669 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1670 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1671
1672 preClearImage(m_imageMipLevels, m_params.imageExtent, m_params.imageLayerCount, m_commandBuffer);
1673
1674 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1675 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1676 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1677 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1678 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1679 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1680
1681 // Different clear color per range
1682 for (std::size_t i = 0u; i < subresourceRanges.size(); ++i)
1683 {
1684 m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[i].color, 1, &subresourceRanges[i]);
1685
1686 if (m_twoStep)
1687 {
1688 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1689 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1690 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1691 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1692 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1693 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1694
1695 m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[i].color, 1, &steptwoRanges[i]);
1696 }
1697 }
1698
1699 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1700 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1701 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1702 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1703 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1704 VK_IMAGE_LAYOUT_GENERAL); // VkImageLayout newLayout;
1705
1706 endCommandBuffer();
1707 submitCommandBuffer();
1708
1709 return verifyResultImage("cmdClearColorImage passed");
1710 }
1711
1712 class ClearDepthStencilImageTestInstance : public ImageClearingTestInstance
1713 {
1714 public:
ClearDepthStencilImageTestInstance(Context & context,const TestParams & testParams,bool twoStep=false)1715 ClearDepthStencilImageTestInstance (Context& context, const TestParams& testParams, bool twoStep = false) : ImageClearingTestInstance (context, testParams), m_twoStep(twoStep) {}
1716 virtual TestStatus iterate (void);
1717 protected:
1718 bool m_twoStep;
1719 };
1720
1721 class TwoStepClearDepthStencilImageTestInstance : public ClearDepthStencilImageTestInstance
1722 {
1723 public:
TwoStepClearDepthStencilImageTestInstance(Context & context,const TestParams & testParams)1724 TwoStepClearDepthStencilImageTestInstance (Context& context, const TestParams& testParams) : ClearDepthStencilImageTestInstance (context, testParams, true) { }
1725 };
1726
1727 class ClearDepthStencilImageMultipleSubresourceRangeTestInstance : public ClearDepthStencilImageTestInstance
1728 {
1729 public:
ClearDepthStencilImageMultipleSubresourceRangeTestInstance(Context & context,const TestParams & testParams)1730 ClearDepthStencilImageMultipleSubresourceRangeTestInstance (Context& context, const TestParams& testParams) : ClearDepthStencilImageTestInstance(context, testParams, false) { }
1731 virtual TestStatus iterate (void);
1732 };
1733
iterate(void)1734 TestStatus ClearDepthStencilImageMultipleSubresourceRangeTestInstance::iterate (void)
1735 {
1736 VkImageAspectFlags aspectMask = m_imageAspectFlags;
1737
1738 // Depth/Stencil formats only. No separate layout modes.
1739 DE_ASSERT(m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE);
1740
1741 std::vector<VkImageSubresourceRange> subresourceRanges;
1742
1743 subresourceRanges.push_back(makeImageSubresourceRange(VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 1u, m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1744 subresourceRanges.push_back(makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1745
1746 beginCommandBuffer(0);
1747
1748 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1749 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1750 0, // VkAccessFlags srcAccessMask
1751 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1752 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1753 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1754
1755 preClearImage(m_imageMipLevels, m_params.imageExtent, m_params.imageLayerCount, m_commandBuffer);
1756
1757 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1758 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1759 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1760 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1761 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1762 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1763
1764 m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, static_cast<deUint32>(subresourceRanges.size()), subresourceRanges.data());
1765
1766 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1767 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1768 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1769 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1770 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1771 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout newLayout;
1772 aspectMask); // VkImageAspectFlags aspectMask;
1773
1774 endCommandBuffer();
1775 submitCommandBuffer();
1776
1777 return verifyResultImage("cmdClearDepthStencilImage passed");
1778 }
1779
iterate(void)1780 TestStatus ClearDepthStencilImageTestInstance::iterate (void)
1781 {
1782 VkImageAspectFlags aspectMask = m_imageAspectFlags;
1783 if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1784 {
1785 aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
1786 }
1787 else if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
1788 {
1789 aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
1790 }
1791
1792 const VkImageSubresourceRange subresourceRange = makeImageSubresourceRange(aspectMask, 0u, 1u, m_params.clearLayerRange.baseArrayLayer, m_twoStep ? 1 : m_params.clearLayerRange.layerCount);
1793 const VkImageSubresourceRange steptwoRange = makeImageSubresourceRange(aspectMask, 0u, VK_REMAINING_MIP_LEVELS, m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS);
1794
1795 beginCommandBuffer(0);
1796
1797 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1798 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1799 0, // VkAccessFlags srcAccessMask
1800 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1801 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1802 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1803
1804 preClearImage(m_imageMipLevels, m_params.imageExtent, m_params.imageLayerCount, m_commandBuffer);
1805
1806 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1807 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1808 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1809 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1810 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1811 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1812
1813 m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, 1, &subresourceRange);
1814
1815 if (m_twoStep) {
1816 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1817 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1818 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1819 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1820 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1821 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
1822
1823 m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, 1, &steptwoRange);
1824 }
1825
1826 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1827 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1828 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1829 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1830 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1831 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout newLayout;
1832 aspectMask); // VkImageAspectFlags aspectMask;
1833
1834 endCommandBuffer();
1835 submitCommandBuffer();
1836
1837 return verifyResultImage("cmdClearDepthStencilImage passed");
1838 }
1839
1840 class ClearAttachmentTestInstance : public ImageClearingTestInstance
1841 {
1842 public:
1843 enum ClearType
1844 {
1845 FULL_CLEAR,
1846 PARTIAL_CLEAR,
1847 };
1848
ClearAttachmentTestInstance(Context & context,const TestParams & testParams,const ClearType clearType=FULL_CLEAR)1849 ClearAttachmentTestInstance (Context& context, const TestParams& testParams, const ClearType clearType = FULL_CLEAR)
1850 : ImageClearingTestInstance (context, testParams)
1851 , m_clearType (clearType)
1852 {
1853 if (!m_isAttachmentFormat)
1854 TCU_THROW(NotSupportedError, "Format not renderable");
1855 }
1856
iterate(void)1857 TestStatus iterate (void)
1858 {
1859 const bool isDepthStencil = isDepthStencilFormat(m_params.imageFormat);
1860 const VkAccessFlags accessMask = (isDepthStencil ? VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT : VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
1861 VkImageLayout attachmentLayout = (isDepthStencil ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
1862 VkImageAspectFlags aspectMask = m_imageAspectFlags;
1863
1864 if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1865 {
1866 attachmentLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
1867 aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
1868 }
1869 else if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
1870 {
1871 attachmentLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
1872 aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
1873 }
1874
1875 const VkClearAttachment clearAttachment =
1876 {
1877 aspectMask, // VkImageAspectFlags aspectMask;
1878 0u, // deUint32 colorAttachment;
1879 m_params.clearValue[0] // VkClearValue clearValue;
1880 };
1881
1882 UVec4 clearCoords;
1883 std::vector<VkClearRect> clearRects;
1884
1885 if (m_clearType == FULL_CLEAR)
1886 {
1887 const VkClearRect rect =
1888 {
1889 {
1890 { 0, 0 }, // VkOffset2D offset;
1891 { m_params.imageExtent.width, m_params.imageExtent.height } // VkExtent2D extent;
1892 }, // VkRect2D rect;
1893 m_params.clearLayerRange.baseArrayLayer, // deUint32 baseArrayLayer;
1894 m_params.clearLayerRange.layerCount, // deUint32 layerCount;
1895 };
1896
1897 clearRects.push_back(rect);
1898 }
1899 else
1900 {
1901 const deUint32 clearX = m_params.imageExtent.width / 8u;
1902 const deUint32 clearY = m_params.imageExtent.height / 8u;
1903 const deUint32 clearWidth = m_params.imageExtent.width / 2u;
1904 const deUint32 clearHeight = m_params.imageExtent.height / 2u;
1905
1906 clearCoords = UVec4(clearX, clearY,
1907 clearX + clearWidth, clearY + clearHeight);
1908
1909 const VkClearRect rects[2] =
1910 {
1911 {
1912 {
1913 { 0, static_cast<deInt32>(clearY) }, // VkOffset2D offset;
1914 { m_params.imageExtent.width, clearHeight } // VkExtent2D extent;
1915 }, // VkRect2D rect;
1916 m_params.clearLayerRange.baseArrayLayer, // deUint32 baseArrayLayer;
1917 m_params.clearLayerRange.layerCount // deUint32 layerCount;
1918 },
1919 {
1920 {
1921 { static_cast<deInt32>(clearX), 0 }, // VkOffset2D offset;
1922 { clearWidth, m_params.imageExtent.height } // VkExtent2D extent;
1923 }, // VkRect2D rect;
1924 m_params.clearLayerRange.baseArrayLayer, // deUint32 baseArrayLayer;
1925 m_params.clearLayerRange.layerCount // deUint32 layerCount;
1926 }
1927 };
1928
1929 clearRects.push_back(rects[0]);
1930 clearRects.push_back(rects[1]);
1931 }
1932
1933 beginCommandBuffer(0);
1934
1935 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1936 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1937 0, // VkAccessFlags srcAccessMask
1938 accessMask, // VkAccessFlags dstAccessMask
1939 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1940 attachmentLayout, // VkImageLayout newLayout;
1941 aspectMask); // VkImageAspectFlags aspectMask;
1942
1943
1944 if (!isDepthStencil && (m_params.imageSampleCount > VK_SAMPLE_COUNT_1_BIT))
1945 pipelineMultisampleImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
1946 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
1947 0, // VkAccessFlags srcAccessMask
1948 accessMask, // VkAccessFlags dstAccessMask
1949 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
1950 attachmentLayout, // VkImageLayout newLayout;
1951 aspectMask); // VkImageAspectFlags aspectMask;
1952
1953 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1954 m_vkd.cmdClearAttachments(*m_commandBuffer, 1, &clearAttachment, static_cast<deUint32>(clearRects.size()), &clearRects[0]);
1955 endRenderPass(m_vkd, *m_commandBuffer);
1956
1957 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // VkPipelineStageFlags srcStageMask
1958 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1959 accessMask, // VkAccessFlags srcAccessMask
1960 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1961 attachmentLayout, // VkImageLayout oldLayout;
1962 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout newLayout;
1963 aspectMask); // VkImageAspectFlags aspectMask;
1964
1965 endCommandBuffer();
1966 submitCommandBuffer();
1967
1968 return verifyResultImage("cmdClearAttachments passed", clearCoords);
1969 }
1970
1971 private:
1972 const ClearType m_clearType;
1973 };
1974
1975 class PartialClearAttachmentTestInstance : public ClearAttachmentTestInstance
1976 {
1977 public:
PartialClearAttachmentTestInstance(Context & context,const TestParams & testParams)1978 PartialClearAttachmentTestInstance (Context& context, const TestParams& testParams) : ClearAttachmentTestInstance (context, testParams, PARTIAL_CLEAR) {}
1979 };
1980
makeClearColorValue(VkFormat format,float r,float g,float b,float a)1981 VkClearValue makeClearColorValue (VkFormat format, float r, float g, float b, float a)
1982 {
1983 const TextureFormat tcuFormat = mapVkFormat(format);
1984 VkClearValue clearValue;
1985
1986 if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_FLOATING_POINT
1987 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_FIXED_POINT
1988 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
1989 {
1990 clearValue.color.float32[0] = r;
1991 clearValue.color.float32[1] = g;
1992 clearValue.color.float32[2] = b;
1993 clearValue.color.float32[3] = a;
1994 }
1995 else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
1996 {
1997 UVec4 maxValues = getFormatMaxUintValue(tcuFormat);
1998
1999 clearValue.color.uint32[0] = (deUint32)((float)maxValues[0] * r);
2000 clearValue.color.uint32[1] = (deUint32)((float)maxValues[1] * g);
2001 clearValue.color.uint32[2] = (deUint32)((float)maxValues[2] * b);
2002 clearValue.color.uint32[3] = (deUint32)((float)maxValues[3] * a);
2003 }
2004 else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_INTEGER)
2005 {
2006 IVec4 maxValues = getFormatMaxIntValue(tcuFormat);
2007
2008 clearValue.color.int32[0] = (deUint32)((float)maxValues[0] * r);
2009 clearValue.color.int32[1] = (deUint32)((float)maxValues[1] * g);
2010 clearValue.color.int32[2] = (deUint32)((float)maxValues[2] * b);
2011 clearValue.color.int32[3] = (deUint32)((float)maxValues[3] * a);
2012 }
2013 else
2014 DE_FATAL("Unknown channel class");
2015
2016 return clearValue;
2017 }
2018
2019 enum class ClearColor64BitCase
2020 {
2021 PACK,
2022 INIT,
2023 };
2024
2025 // The expected value will always use the packed format, for clarity. We will handle it that way when verifying values.
makeClearColorValue64(uint32_t level,ClearColor64BitCase case64,VkClearValue * clear,VkClearValue * expected=nullptr)2026 void makeClearColorValue64 (uint32_t level, ClearColor64BitCase case64, VkClearValue* clear, VkClearValue* expected = nullptr)
2027 {
2028 DE_ASSERT(level <= 1u);
2029
2030 if (case64 == ClearColor64BitCase::PACK)
2031 {
2032 // We can pack 2 colors in the 4 elements.
2033 const uint32_t lsb[2] = { 0x7FFFFFFFu - level, 0x7FFFFFF7u - level }; // Low bits for each number.
2034 const uint32_t msb[2] = { 0xFFFFFFFFu, 0xFFFFFFFFu }; // High bits for each number.
2035
2036 const uint64_t colors[2] =
2037 {
2038 ((static_cast<uint64_t>(msb[0]) << 32u) | static_cast<uint64_t>(lsb[0])),
2039 ((static_cast<uint64_t>(msb[1]) << 32u) | static_cast<uint64_t>(lsb[1])),
2040 };
2041
2042 deMemcpy(&(clear->color.uint32[0]), &(colors[0]), sizeof(uint64_t));
2043 deMemcpy(&(clear->color.uint32[2]), &(colors[1]), sizeof(uint64_t));
2044
2045 if (expected)
2046 {
2047 *expected = *clear;
2048 }
2049 }
2050 else if (case64 == ClearColor64BitCase::INIT)
2051 {
2052 deMemset(clear, 0, sizeof(*clear));
2053 if (expected)
2054 *expected = *clear;
2055 }
2056 else
2057 DE_ASSERT(false);
2058 }
2059
getFormatCaseName(VkFormat format)2060 std::string getFormatCaseName (VkFormat format)
2061 {
2062 return de::toLower(de::toString(getFormatStr(format)).substr(10));
2063 }
2064
getImageTypeCaseName(VkImageType type)2065 const char* getImageTypeCaseName (VkImageType type)
2066 {
2067 const char* s_names[] =
2068 {
2069 "1d",
2070 "2d",
2071 "3d"
2072 };
2073 return de::getSizedArrayElement<VK_CORE_IMAGE_TYPE_LAST>(s_names, type);
2074 }
2075
getImageTilingCaseName(VkImageTiling tiling)2076 const char* getImageTilingCaseName (VkImageTiling tiling)
2077 {
2078 const char* s_names[] =
2079 {
2080 "optimal",
2081 "linear",
2082 };
2083 return de::getSizedArrayElement<VK_CORE_IMAGE_TILING_LAST>(s_names, tiling);
2084 }
2085
getSampleCountName(VkSampleCountFlagBits count)2086 std::string getSampleCountName (VkSampleCountFlagBits count)
2087 {
2088 return "sample_count_" + std::to_string(static_cast<int>(count));
2089 }
2090
createImageClearingTestsCommon(TestContext & testCtx,tcu::TestCaseGroup * imageClearingTests,AllocationKind allocationKind)2091 TestCaseGroup* createImageClearingTestsCommon (TestContext& testCtx, tcu::TestCaseGroup* imageClearingTests, AllocationKind allocationKind)
2092 {
2093 de::MovePtr<TestCaseGroup> colorImageClearTests (new TestCaseGroup(testCtx, "clear_color_image"));
2094 de::MovePtr<TestCaseGroup> depthStencilImageClearTests (new TestCaseGroup(testCtx, "clear_depth_stencil_image"));
2095 de::MovePtr<TestCaseGroup> colorAttachmentClearTests (new TestCaseGroup(testCtx, "clear_color_attachment"));
2096 de::MovePtr<TestCaseGroup> depthStencilAttachmentClearTests (new TestCaseGroup(testCtx, "clear_depth_stencil_attachment"));
2097 de::MovePtr<TestCaseGroup> partialColorAttachmentClearTests (new TestCaseGroup(testCtx, "partial_clear_color_attachment"));
2098 de::MovePtr<TestCaseGroup> partialDepthStencilAttachmentClearTests (new TestCaseGroup(testCtx, "partial_clear_depth_stencil_attachment"));
2099
2100 // Some formats are commented out due to the tcu::TextureFormat does not support them yet.
2101 const VkFormat colorImageFormatsToTest[] =
2102 {
2103 VK_FORMAT_R4G4_UNORM_PACK8,
2104 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
2105 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
2106 VK_FORMAT_R5G6B5_UNORM_PACK16,
2107 VK_FORMAT_B5G6R5_UNORM_PACK16,
2108 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
2109 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
2110 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
2111 #ifndef CTS_USES_VULKANSC
2112 VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR,
2113 #endif // CTS_USES_VULKANSC
2114 VK_FORMAT_R8_UNORM,
2115 VK_FORMAT_R8_SNORM,
2116 VK_FORMAT_R8_USCALED,
2117 VK_FORMAT_R8_SSCALED,
2118 VK_FORMAT_R8_UINT,
2119 VK_FORMAT_R8_SINT,
2120 VK_FORMAT_R8_SRGB,
2121 #ifndef CTS_USES_VULKANSC
2122 VK_FORMAT_A8_UNORM_KHR,
2123 #endif // CTS_USES_VULKANSC
2124 VK_FORMAT_R8G8_UNORM,
2125 VK_FORMAT_R8G8_SNORM,
2126 VK_FORMAT_R8G8_USCALED,
2127 VK_FORMAT_R8G8_SSCALED,
2128 VK_FORMAT_R8G8_UINT,
2129 VK_FORMAT_R8G8_SINT,
2130 VK_FORMAT_R8G8_SRGB,
2131 VK_FORMAT_R8G8B8_UNORM,
2132 VK_FORMAT_R8G8B8_SNORM,
2133 VK_FORMAT_R8G8B8_USCALED,
2134 VK_FORMAT_R8G8B8_SSCALED,
2135 VK_FORMAT_R8G8B8_UINT,
2136 VK_FORMAT_R8G8B8_SINT,
2137 VK_FORMAT_R8G8B8_SRGB,
2138 VK_FORMAT_B8G8R8_UNORM,
2139 VK_FORMAT_B8G8R8_SNORM,
2140 VK_FORMAT_B8G8R8_USCALED,
2141 VK_FORMAT_B8G8R8_SSCALED,
2142 VK_FORMAT_B8G8R8_UINT,
2143 VK_FORMAT_B8G8R8_SINT,
2144 VK_FORMAT_B8G8R8_SRGB,
2145 VK_FORMAT_R8G8B8A8_UNORM,
2146 VK_FORMAT_R8G8B8A8_SNORM,
2147 VK_FORMAT_R8G8B8A8_USCALED,
2148 VK_FORMAT_R8G8B8A8_SSCALED,
2149 VK_FORMAT_R8G8B8A8_UINT,
2150 VK_FORMAT_R8G8B8A8_SINT,
2151 VK_FORMAT_R8G8B8A8_SRGB,
2152 VK_FORMAT_B8G8R8A8_UNORM,
2153 VK_FORMAT_B8G8R8A8_SNORM,
2154 VK_FORMAT_B8G8R8A8_USCALED,
2155 VK_FORMAT_B8G8R8A8_SSCALED,
2156 VK_FORMAT_B8G8R8A8_UINT,
2157 VK_FORMAT_B8G8R8A8_SINT,
2158 VK_FORMAT_B8G8R8A8_SRGB,
2159 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
2160 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
2161 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
2162 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
2163 VK_FORMAT_A8B8G8R8_UINT_PACK32,
2164 VK_FORMAT_A8B8G8R8_SINT_PACK32,
2165 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
2166 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
2167 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
2168 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
2169 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
2170 VK_FORMAT_A2R10G10B10_UINT_PACK32,
2171 VK_FORMAT_A2R10G10B10_SINT_PACK32,
2172 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
2173 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
2174 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
2175 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
2176 VK_FORMAT_A2B10G10R10_UINT_PACK32,
2177 VK_FORMAT_A2B10G10R10_SINT_PACK32,
2178 VK_FORMAT_R16_UNORM,
2179 VK_FORMAT_R16_SNORM,
2180 VK_FORMAT_R16_USCALED,
2181 VK_FORMAT_R16_SSCALED,
2182 VK_FORMAT_R16_UINT,
2183 VK_FORMAT_R16_SINT,
2184 VK_FORMAT_R16_SFLOAT,
2185 VK_FORMAT_R16G16_UNORM,
2186 VK_FORMAT_R16G16_SNORM,
2187 VK_FORMAT_R16G16_USCALED,
2188 VK_FORMAT_R16G16_SSCALED,
2189 VK_FORMAT_R16G16_UINT,
2190 VK_FORMAT_R16G16_SINT,
2191 VK_FORMAT_R16G16_SFLOAT,
2192 VK_FORMAT_R16G16B16_UNORM,
2193 VK_FORMAT_R16G16B16_SNORM,
2194 VK_FORMAT_R16G16B16_USCALED,
2195 VK_FORMAT_R16G16B16_SSCALED,
2196 VK_FORMAT_R16G16B16_UINT,
2197 VK_FORMAT_R16G16B16_SINT,
2198 VK_FORMAT_R16G16B16_SFLOAT,
2199 VK_FORMAT_R16G16B16A16_UNORM,
2200 VK_FORMAT_R16G16B16A16_SNORM,
2201 VK_FORMAT_R16G16B16A16_USCALED,
2202 VK_FORMAT_R16G16B16A16_SSCALED,
2203 VK_FORMAT_R16G16B16A16_UINT,
2204 VK_FORMAT_R16G16B16A16_SINT,
2205 VK_FORMAT_R16G16B16A16_SFLOAT,
2206 VK_FORMAT_R32_UINT,
2207 VK_FORMAT_R32_SINT,
2208 VK_FORMAT_R32_SFLOAT,
2209 VK_FORMAT_R32G32_UINT,
2210 VK_FORMAT_R32G32_SINT,
2211 VK_FORMAT_R32G32_SFLOAT,
2212 VK_FORMAT_R32G32B32_UINT,
2213 VK_FORMAT_R32G32B32_SINT,
2214 VK_FORMAT_R32G32B32_SFLOAT,
2215 VK_FORMAT_R32G32B32A32_UINT,
2216 VK_FORMAT_R32G32B32A32_SINT,
2217 VK_FORMAT_R32G32B32A32_SFLOAT,
2218 VK_FORMAT_R64_UINT,
2219 VK_FORMAT_R64_SINT,
2220 // VK_FORMAT_R64_SFLOAT,
2221 VK_FORMAT_R64G64_UINT,
2222 VK_FORMAT_R64G64_SINT,
2223 // VK_FORMAT_R64G64_SFLOAT,
2224 // VK_FORMAT_R64G64B64_UINT,
2225 // VK_FORMAT_R64G64B64_SINT,
2226 // VK_FORMAT_R64G64B64_SFLOAT,
2227 // VK_FORMAT_R64G64B64A64_UINT,
2228 // VK_FORMAT_R64G64B64A64_SINT,
2229 // VK_FORMAT_R64G64B64A64_SFLOAT,
2230 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
2231 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
2232 // VK_FORMAT_BC1_RGB_UNORM_BLOCK,
2233 // VK_FORMAT_BC1_RGB_SRGB_BLOCK,
2234 // VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
2235 // VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
2236 // VK_FORMAT_BC2_UNORM_BLOCK,
2237 // VK_FORMAT_BC2_SRGB_BLOCK,
2238 // VK_FORMAT_BC3_UNORM_BLOCK,
2239 // VK_FORMAT_BC3_SRGB_BLOCK,
2240 // VK_FORMAT_BC4_UNORM_BLOCK,
2241 // VK_FORMAT_BC4_SNORM_BLOCK,
2242 // VK_FORMAT_BC5_UNORM_BLOCK,
2243 // VK_FORMAT_BC5_SNORM_BLOCK,
2244 // VK_FORMAT_BC6H_UFLOAT_BLOCK,
2245 // VK_FORMAT_BC6H_SFLOAT_BLOCK,
2246 // VK_FORMAT_BC7_UNORM_BLOCK,
2247 // VK_FORMAT_BC7_SRGB_BLOCK,
2248 // VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
2249 // VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
2250 // VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
2251 // VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
2252 // VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
2253 // VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
2254 // VK_FORMAT_EAC_R11_UNORM_BLOCK,
2255 // VK_FORMAT_EAC_R11_SNORM_BLOCK,
2256 // VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
2257 // VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
2258 // VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
2259 // VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
2260 // VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
2261 // VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
2262 // VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
2263 // VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
2264 // VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
2265 // VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
2266 // VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
2267 // VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
2268 // VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
2269 // VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
2270 // VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
2271 // VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
2272 // VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
2273 // VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
2274 // VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
2275 // VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
2276 // VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
2277 // VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
2278 // VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
2279 // VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
2280 // VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
2281 // VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
2282 // VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
2283 // VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
2284 // VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
2285 // VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
2286
2287 VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT,
2288 VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT,
2289 };
2290 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
2291
2292 const VkFormat depthStencilImageFormatsToTest[] =
2293 {
2294 VK_FORMAT_D16_UNORM,
2295 VK_FORMAT_X8_D24_UNORM_PACK32,
2296 VK_FORMAT_D32_SFLOAT,
2297 VK_FORMAT_S8_UINT,
2298 VK_FORMAT_D16_UNORM_S8_UINT,
2299 VK_FORMAT_D24_UNORM_S8_UINT,
2300 VK_FORMAT_D32_SFLOAT_S8_UINT
2301 };
2302 const size_t numOfDepthStencilImageFormatsToTest = DE_LENGTH_OF_ARRAY(depthStencilImageFormatsToTest);
2303
2304 struct ClearTestColorParams
2305 {
2306 bool matchTextureChannelClass;
2307 TextureChannelClass textureChannelClass;
2308 const char* testNameSuffix;
2309 float clearColors[2][4];
2310 bool useSeparateExpectedColors;
2311 float expectedColors[2][4];
2312 };
2313 const ClearTestColorParams clearColorsToTest[] =
2314 {
2315 {
2316 false, // matchTextureChannelClass
2317 TEXTURECHANNELCLASS_LAST, // textureChannelClass
2318 "", // testNameSuffix
2319 {
2320 { 0.1f, 0.5f, 0.3f, 0.9f }, // clearColors[0]
2321 { 0.3f, 0.6f, 0.2f, 0.7f }, // clearColors[1]
2322 },
2323 false, // useSeparateExpectedColors
2324 { } // expectedColors
2325 },
2326 {
2327 true, // matchTextureChannelClass
2328 TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT, // textureChannelClass
2329 "_clamp_input", // testNameSuffix
2330 {
2331 { -0.1f, -1e6f, -0.3f, -1.5f }, // clearColors[0]
2332 { -1.5f, -0.6f, -1e6f, -0.7f }, // clearColors[1]
2333 },
2334 true, // useSeparateExpectedColors
2335 {
2336 { 0.0f, 0.0f, 0.0f, 0.0f }, // expectedColors[0]
2337 { 0.0f, 0.0f, 0.0f, 0.0f }, // expectedColors[1]
2338 }
2339 }
2340 };
2341 const size_t numOfClearColorsToTest = DE_LENGTH_OF_ARRAY(clearColorsToTest);
2342
2343 std::vector<VkSampleCountFlagBits> sampleCountsToTest =
2344 {
2345 VK_SAMPLE_COUNT_2_BIT,
2346 VK_SAMPLE_COUNT_4_BIT,
2347 VK_SAMPLE_COUNT_8_BIT,
2348 VK_SAMPLE_COUNT_16_BIT,
2349 VK_SAMPLE_COUNT_32_BIT,
2350 VK_SAMPLE_COUNT_64_BIT
2351 };
2352
2353 struct ImageLayerParams
2354 {
2355 deUint32 imageLayerCount;
2356 LayerRange imageViewRange;
2357 LayerRange clearLayerRange;
2358 bool twoStep;
2359 const char* testName;
2360 bool isCube;
2361 };
2362 const ImageLayerParams imageLayerParamsToTest[] =
2363 {
2364 {
2365 1u, // imageLayerCount
2366 {0u, 1u}, // imageViewRange
2367 {0u, 1u}, // clearLayerRange
2368 false, // twoStep
2369 "single_layer", // testName
2370 false // isCube
2371 },
2372 {
2373 16u, // imageLayerCount
2374 {3u, 12u}, // imageViewRange
2375 {2u, 5u}, // clearLayerRange
2376 false, // twoStep
2377 "multiple_layers", // testName
2378 false // isCube
2379 },
2380 {
2381 15u, // imageLayerCount
2382 { 3u, 6u }, // imageViewRange
2383 { 2u, 1u }, // clearLayerRange
2384 false, // twoStep
2385 "cube_layers", // testName
2386 true // isCube
2387 },
2388 {
2389 16u, // imageLayerCount
2390 { 3u, 12u }, // imageViewRange
2391 { 8u, VK_REMAINING_ARRAY_LAYERS }, // clearLayerRange
2392 false, // twoStep
2393 "remaining_array_layers", // testName
2394 false // isCube
2395 },
2396 {
2397 16u, // imageLayerCount
2398 { 3u, 12u }, // imageViewRange
2399 { 8u, VK_REMAINING_ARRAY_LAYERS }, // clearLayerRange
2400 true, // twoStep
2401 "remaining_array_layers_twostep", // testName
2402 false // isCube
2403 }
2404 };
2405
2406 // Include test cases with VK_REMAINING_ARRAY_LAYERS when using vkCmdClearColorImage
2407 const size_t numOfImageLayerParamsToTest = DE_LENGTH_OF_ARRAY(imageLayerParamsToTest);
2408
2409 // Exclude test cases with VK_REMAINING_ARRAY_LAYERS when using vkCmdClearAttachments
2410 const size_t numOfAttachmentLayerParamsToTest = numOfImageLayerParamsToTest - 2;
2411
2412 const VkExtent3D imageDimensions[] =
2413 {
2414 { 256, 1, 1},
2415 { 256, 256, 1},
2416 { 256, 256, 16},
2417 { 200, 1, 1},
2418 { 200, 180, 1},
2419 { 200, 180, 16},
2420 { 71, 1, 1},
2421 { 1, 33, 1},
2422 { 55, 21, 11},
2423 { 64, 11, 1},
2424 { 33, 128, 1},
2425 { 32, 29, 3}
2426 };
2427
2428 // Clear color image
2429 {
2430 const VkImageType imageTypesToTest[] =
2431 {
2432 VK_IMAGE_TYPE_1D,
2433 VK_IMAGE_TYPE_2D,
2434 VK_IMAGE_TYPE_3D
2435 };
2436 const size_t numOfImageTypesToTest = DE_LENGTH_OF_ARRAY(imageTypesToTest);
2437
2438 const VkImageTiling imageTilingsToTest[] =
2439 {
2440 VK_IMAGE_TILING_OPTIMAL,
2441 VK_IMAGE_TILING_LINEAR,
2442 };
2443 const size_t numOfImageTilingsToTest = DE_LENGTH_OF_ARRAY(imageTilingsToTest);
2444
2445 for (size_t imageTypeIndex = 0; imageTypeIndex < numOfImageTypesToTest; ++imageTypeIndex)
2446 {
2447 de::MovePtr<TestCaseGroup> imageTypeGroup(new TestCaseGroup(testCtx, getImageTypeCaseName(imageTypesToTest[imageTypeIndex])));
2448
2449 for (size_t imageTilingIndex = 0; imageTilingIndex < numOfImageTilingsToTest; ++imageTilingIndex)
2450 {
2451 de::MovePtr<TestCaseGroup> imageTilingGroup(new TestCaseGroup(testCtx, getImageTilingCaseName(imageTilingsToTest[imageTilingIndex])));
2452
2453 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfImageLayerParamsToTest; ++imageLayerParamsIndex)
2454 {
2455 // 3D ARRAY images are not supported
2456 if (imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount > 1u && imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_3D)
2457 continue;
2458
2459 // CUBE images are not tested in clear image tests (they are tested in clear attachment tests)
2460 if (imageLayerParamsToTest[imageLayerParamsIndex].isCube)
2461 continue;
2462
2463 de::MovePtr<TestCaseGroup> imageLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName));
2464
2465 for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2466 {
2467 const VkExtent3D dimensions = imageDimensions[imageDimensionsIndex];
2468 const std::string dimensionsString = extentToString(dimensions, imageTypesToTest[imageTypeIndex]);
2469
2470 if (imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_1D && dimensions.height > 1)
2471 continue;
2472 if (imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_2D && (dimensions.depth > 1 || dimensions.height == 1))
2473 continue;
2474 if (imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_3D && dimensions.depth == 1)
2475 continue;
2476
2477 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
2478 {
2479 const VkFormat format = colorImageFormatsToTest[imageFormatIndex];
2480 const TextureFormat tcuFormat = mapVkFormat(format);
2481 const TextureChannelClass channelClass = getTextureChannelClass(tcuFormat.type);
2482 const bool is64Bit = is64Format(tcuFormat);
2483
2484 if (!is64Bit)
2485 {
2486 for (size_t clearColorIndex = 0; clearColorIndex < numOfClearColorsToTest; ++clearColorIndex)
2487 {
2488 const ClearTestColorParams& colorParams = clearColorsToTest[clearColorIndex];
2489
2490 if (colorParams.matchTextureChannelClass && channelClass != colorParams.textureChannelClass)
2491 continue;
2492
2493 VkClearValue clearColors[2] =
2494 {
2495 makeClearColorValue(format, colorParams.clearColors[0][0], colorParams.clearColors[0][1], colorParams.clearColors[0][2], colorParams.clearColors[0][3]),
2496 makeClearColorValue(format, colorParams.clearColors[1][0], colorParams.clearColors[1][1], colorParams.clearColors[1][2], colorParams.clearColors[1][3]),
2497 };
2498 VkClearValue expectedColors[2];
2499 if (clearColorsToTest[clearColorIndex].useSeparateExpectedColors)
2500 {
2501 expectedColors[0] = makeClearColorValue(format, colorParams.expectedColors[0][0], colorParams.expectedColors[0][1], colorParams.expectedColors[0][2], colorParams.expectedColors[0][3]);
2502 expectedColors[1] = makeClearColorValue(format, colorParams.expectedColors[1][0], colorParams.expectedColors[1][1], colorParams.expectedColors[1][2], colorParams.expectedColors[1][3]);
2503 }
2504 else
2505 {
2506 expectedColors[0] = clearColors[0];
2507 expectedColors[1] = clearColors[1];
2508 }
2509
2510 std::string testCaseName = getFormatCaseName(format) + dimensionsString + colorParams.testNameSuffix;
2511 TestParams testParams =
2512 {
2513 false, // bool useSingleMipLevel;
2514 imageTypesToTest[imageTypeIndex], // VkImageType imageType;
2515 format, // VkFormat imageFormat;
2516 imageTilingsToTest[imageTilingIndex], // VkImageTiling imageTiling;
2517 dimensions, // VkExtent3D imageExtent;
2518 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount, // deUint32 imageLayerCount;
2519 {
2520 0u,
2521 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
2522 }, // LayerRange imageViewLayerRange;
2523 makeClearColorValue(format, 0.0f, 0.0f, 0.0f, 0.0f), // VkClearValue initValue;
2524 {
2525 clearColors[0], // VkClearValue clearValue[0];
2526 clearColors[1], // VkClearValue clearValue[1];
2527 },
2528 clearColorsToTest[clearColorIndex].useSeparateExpectedColors, // bool useSeparateExpectedClearValue;
2529 {
2530 expectedColors[0], // VkClearValue expectedClearValue[0];
2531 expectedColors[1], // VkClearValue expectedClearValue[1];
2532 },
2533 imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange, // LayerRange clearLayerRange;
2534 allocationKind, // AllocationKind allocationKind;
2535 false, // bool isCube;
2536 SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE, // SeparateDepthStencilLayoutMode separateDepthStencilLayoutMode;
2537 false, // bool isColorMultipleSubresourceRangeTest;
2538 VK_SAMPLE_COUNT_1_BIT // VkSampleCountFlagBits imageSampleCount
2539 };
2540
2541 if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2542 {
2543 // Clear Color Image
2544 imageLayersGroup->addChild(new ImageClearingTestCase<ClearColorImageTestInstance>(testCtx, testCaseName, testParams));
2545
2546 // Removing linear images as the miplevels may be 1
2547 if (imageTilingsToTest[imageTilingIndex] == VK_IMAGE_TILING_OPTIMAL)
2548 {
2549 testParams.isColorMultipleSubresourceRangeTest = true;
2550 testCaseName += "_multiple_subresourcerange";
2551 // Clear Color Image with two ranges
2552 imageLayersGroup->addChild(new ImageClearingTestCase<ClearColorImageMultipleSubresourceRangeTestInstance>(testCtx, testCaseName, testParams));
2553 }
2554 }
2555 else
2556 {
2557 // Clear Color Image
2558 imageLayersGroup->addChild(new ImageClearingTestCase<TwoStepClearColorImageTestInstance>(testCtx, testCaseName, testParams));
2559 }
2560 }
2561 }
2562 else
2563 {
2564 {
2565 // The expected values will be packed, so we cannot verify more than 2 channels.
2566 const auto numUsedChannels = tcu::getNumUsedChannels(tcuFormat.order);
2567 DE_UNREF(numUsedChannels); // For release builds.
2568 DE_ASSERT(numUsedChannels <= 2);
2569 }
2570
2571 {
2572 VkClearValue initValue;
2573 deMemset(&initValue, 0, sizeof(initValue));
2574 makeClearColorValue64(0u, ClearColor64BitCase::INIT, &initValue);
2575
2576 VkClearValue clearColors[2];
2577 VkClearValue expectedColors[2];
2578
2579 deMemset(clearColors, 0, sizeof(clearColors));
2580 deMemset(expectedColors, 0, sizeof(expectedColors));
2581
2582 for (size_t i = 0; i < de::arrayLength(clearColors); ++i)
2583 makeClearColorValue64(static_cast<uint32_t>(i), ClearColor64BitCase::PACK, clearColors+i, expectedColors+i);
2584
2585 std::string testCaseName = getFormatCaseName(format) + dimensionsString;
2586 TestParams testParams =
2587 {
2588 false, // bool useSingleMipLevel;
2589 imageTypesToTest[imageTypeIndex], // VkImageType imageType;
2590 format, // VkFormat imageFormat;
2591 imageTilingsToTest[imageTilingIndex], // VkImageTiling imageTiling;
2592 dimensions, // VkExtent3D imageExtent;
2593 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount, // deUint32 imageLayerCount;
2594 {
2595 0u,
2596 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
2597 }, // LayerRange imageViewLayerRange;
2598 initValue, // VkClearValue initValue;
2599 {
2600 clearColors[0], // VkClearValue clearValue[0];
2601 clearColors[1], // VkClearValue clearValue[1];
2602 },
2603 true, // bool useSeparateExpectedClearValue;
2604 {
2605 expectedColors[0], // VkClearValue expectedClearValue[0];
2606 expectedColors[1], // VkClearValue expectedClearValue[1];
2607 },
2608 imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange, // LayerRange clearLayerRange;
2609 allocationKind, // AllocationKind allocationKind;
2610 false, // bool isCube;
2611 SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE, // SeparateDepthStencilLayoutMode separateDepthStencilLayoutMode;
2612 false, // bool isColorMultipleSubresourceRangeTest;
2613 VK_SAMPLE_COUNT_1_BIT // VkSampleCountFlagBits imageSampleCount
2614 };
2615
2616 if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2617 {
2618 // Clear Color Image
2619 imageLayersGroup->addChild(new ImageClearingTestCase<ClearColorImageTestInstance>(testCtx, testCaseName, testParams));
2620
2621 // Removing linear images as the miplevels may be 1
2622 if (imageTilingsToTest[imageTilingIndex] == VK_IMAGE_TILING_OPTIMAL)
2623 {
2624 testParams.isColorMultipleSubresourceRangeTest = true;
2625 testCaseName += "_multiple_subresourcerange";
2626 // Clear Color Image with two ranges
2627 imageLayersGroup->addChild(new ImageClearingTestCase<ClearColorImageMultipleSubresourceRangeTestInstance>(testCtx, testCaseName, testParams));
2628 }
2629 }
2630 else
2631 {
2632 // Clear Color Image
2633 imageLayersGroup->addChild(new ImageClearingTestCase<TwoStepClearColorImageTestInstance>(testCtx, testCaseName, testParams));
2634 }
2635 }
2636 }
2637 }
2638 }
2639 imageTilingGroup->addChild(imageLayersGroup.release());
2640 }
2641 imageTypeGroup->addChild(imageTilingGroup.release());
2642 }
2643 colorImageClearTests->addChild(imageTypeGroup.release());
2644 }
2645 imageClearingTests->addChild(colorImageClearTests.release());
2646 }
2647
2648 // Clear depth/stencil image
2649 {
2650 const VkImageType imageTypesToTest[]
2651 {
2652 VK_IMAGE_TYPE_2D,
2653 VK_IMAGE_TYPE_3D
2654 };
2655 const size_t numOfImageTypesToTest = DE_LENGTH_OF_ARRAY(imageTypesToTest);
2656
2657 for (size_t imageTypeIndex = 0; imageTypeIndex < numOfImageTypesToTest; ++imageTypeIndex)
2658 {
2659 de::MovePtr<TestCaseGroup> imageTypeGroup(new TestCaseGroup(testCtx, getImageTypeCaseName(imageTypesToTest[imageTypeIndex])));
2660
2661 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfImageLayerParamsToTest; ++imageLayerParamsIndex)
2662 {
2663 // CUBE images are not tested in clear image tests (they are tested in clear attachment tests)
2664 if (imageLayerParamsToTest[imageLayerParamsIndex].isCube)
2665 continue;
2666
2667 de::MovePtr<TestCaseGroup> imageLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName));
2668
2669 for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2670 {
2671 const VkImageType imageType = imageTypesToTest[imageTypeIndex];
2672 const VkExtent3D dimensions = imageDimensions[imageDimensionsIndex];
2673 const std::string dimensionsString = extentToString(dimensions, imageType);
2674
2675 if (imageType == VK_IMAGE_TYPE_2D && (dimensions.depth > 1 || dimensions.height == 1))
2676 continue;
2677 if (imageType == VK_IMAGE_TYPE_3D && dimensions.depth == 1)
2678 continue;
2679
2680 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
2681 {
2682 const VkFormat format = depthStencilImageFormatsToTest[imageFormatIndex];
2683 const bool hasDepth = tcu::hasDepthComponent(mapVkFormat(format).order);
2684 const bool hasStencil = tcu::hasStencilComponent(mapVkFormat(format).order);
2685 const int separateLayoutsLoopCount = (hasDepth && hasStencil) ? 3 : 1;
2686
2687 for (int separateDepthStencilLayoutMode = 0; separateDepthStencilLayoutMode < separateLayoutsLoopCount; ++separateDepthStencilLayoutMode)
2688 {
2689 const std::string testCaseName = getFormatCaseName(format) +
2690 ((separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH) ? "_separate_layouts_depth" :
2691 (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL) ? "_separate_layouts_stencil" :
2692 "")
2693 + dimensionsString;
2694 TestParams testParams
2695 {
2696 true, // bool useSingleMipLevel;
2697 imageType, // VkImageType imageType;
2698 format, // VkFormat format;
2699 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
2700 dimensions, // VkExtent3D extent;
2701 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount, // deUint32 imageLayerCount;
2702 {
2703 0u,
2704 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
2705 }, // LayerRange imageViewLayerRange;
2706 makeClearValueDepthStencil(0.0f, 0u), // VkClearValue initValue
2707 {
2708 makeClearValueDepthStencil(0.1f, 0x06), // VkClearValue clearValue[0];
2709 makeClearValueDepthStencil(0.3f, 0x04), // VkClearValue clearValue[1];
2710 },
2711 false, // bool useSeparateExpectedClearValue;
2712 { }, // VkClearValue[2] expectedClearValue;
2713 imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange, // LayerRange clearLayerRange;
2714 allocationKind, // AllocationKind allocationKind;
2715 false, // bool isCube;
2716 SeparateDepthStencilLayoutMode(separateDepthStencilLayoutMode), // SeparateDepthStencilLayoutMode separateDepthStencilLayoutMode;
2717 false, // bool isColorMultipleSubresourceRangeTest;
2718 VK_SAMPLE_COUNT_1_BIT // VkSampleCountFlagBits imageSampleCount
2719 };
2720
2721 if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2722 {
2723 // Clear Depth/Stencil Image
2724 imageLayersGroup->addChild(new ImageClearingTestCase<ClearDepthStencilImageTestInstance>(testCtx, testCaseName, testParams));
2725
2726 if (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE && hasDepth && hasStencil)
2727 {
2728 const std::string testCaseNameRanges = getFormatCaseName(format) + dimensionsString + "_multiple_subresourcerange";
2729 // Clear Depth/Stencil Image with ranges
2730 imageLayersGroup->addChild(new ImageClearingTestCase<ClearDepthStencilImageMultipleSubresourceRangeTestInstance>(testCtx, testCaseNameRanges, testParams));
2731 }
2732 }
2733 else
2734 {
2735 // Clear Depth/Stencil Image
2736 imageLayersGroup->addChild(new ImageClearingTestCase<TwoStepClearDepthStencilImageTestInstance>(testCtx, testCaseName, testParams));
2737 }
2738 }
2739 }
2740 }
2741 imageTypeGroup->addChild(imageLayersGroup.release());
2742 }
2743 depthStencilImageClearTests->addChild(imageTypeGroup.release());
2744 }
2745 imageClearingTests->addChild(depthStencilImageClearTests.release());
2746 }
2747
2748 // Clear color attachment
2749 {
2750 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfAttachmentLayerParamsToTest; ++imageLayerParamsIndex)
2751 {
2752 if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2753 {
2754 de::MovePtr<TestCaseGroup> colorAttachmentClearLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName));
2755 de::MovePtr<TestCaseGroup> partialColorAttachmentClearLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName));
2756
2757 for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2758 {
2759 const VkExtent3D dimensions = imageDimensions[imageDimensionsIndex];
2760 const std::string dimensionsString = extentToString(dimensions, VK_IMAGE_TYPE_2D);
2761
2762 if (dimensions.height == 1 || dimensions.depth > 1)
2763 continue;
2764
2765 if (imageLayerParamsToTest[imageLayerParamsIndex].isCube && dimensions.width != dimensions.height)
2766 continue;
2767
2768 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
2769 {
2770 const VkFormat format = colorImageFormatsToTest[imageFormatIndex];
2771 const TextureFormat tcuFormat = mapVkFormat(format);
2772 const TextureChannelClass channelClass = getTextureChannelClass(tcuFormat.type);
2773 const bool is64Bit = is64Format(tcuFormat);
2774
2775 // We will not check color attachments.
2776 if (is64Bit)
2777 continue;
2778
2779 for (size_t clearColorIndex = 0; clearColorIndex < numOfClearColorsToTest; ++clearColorIndex)
2780 {
2781 const ClearTestColorParams& colorParams = clearColorsToTest[clearColorIndex];
2782
2783 if (colorParams.matchTextureChannelClass && channelClass != colorParams.textureChannelClass)
2784 continue;
2785
2786 VkClearValue clearColors[2] =
2787 {
2788 makeClearColorValue(format, colorParams.clearColors[0][0], colorParams.clearColors[0][1], colorParams.clearColors[0][2], colorParams.clearColors[0][3]),
2789 makeClearColorValue(format, colorParams.clearColors[1][0], colorParams.clearColors[1][1], colorParams.clearColors[1][2], colorParams.clearColors[1][3]),
2790 };
2791 VkClearValue expectedColors[2];
2792 if (clearColorsToTest[clearColorIndex].useSeparateExpectedColors)
2793 {
2794 expectedColors[0] = makeClearColorValue(format, colorParams.expectedColors[0][0], colorParams.expectedColors[0][1], colorParams.expectedColors[0][2], colorParams.expectedColors[0][3]);
2795 expectedColors[1] = makeClearColorValue(format, colorParams.expectedColors[1][0], colorParams.expectedColors[1][1], colorParams.expectedColors[1][2], colorParams.expectedColors[1][3]);
2796 }
2797 else
2798 {
2799 expectedColors[0] = clearColors[0];
2800 expectedColors[1] = clearColors[1];
2801 }
2802
2803 std::string testCaseName = getFormatCaseName(format) + dimensionsString + colorParams.testNameSuffix;
2804 TestParams testParams =
2805 {
2806 true, // bool useSingleMipLevel;
2807 VK_IMAGE_TYPE_2D, // VkImageType imageType;
2808 format, // VkFormat format;
2809 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
2810 dimensions, // VkExtent3D extent;
2811 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount, // deUint32 imageLayerCount;
2812 imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange, // LayerRange imageViewLayerRange;
2813 makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f), // VkClearValue initValue
2814 {
2815 clearColors[0], // VkClearValue clearValue[0];
2816 clearColors[1] // VkClearValue clearValue[1];
2817 },
2818 colorParams.useSeparateExpectedColors, // bool useSeparateExpectedClearValue;
2819 {
2820 expectedColors[0], // VkClearValue expectedClearValue[0];
2821 expectedColors[1] // VkClearValue expectedClearValue[1];
2822 },
2823 imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange, // LayerRange clearLayerRange;
2824 allocationKind, // AllocationKind allocationKind;
2825 imageLayerParamsToTest[imageLayerParamsIndex].isCube, // bool isCube;
2826 SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE, // SeparateDepthStencilLayoutMode separateDepthStencilLayoutMode;
2827 false, // bool isColorMultipleSubresourceRangeTest;
2828 VK_SAMPLE_COUNT_1_BIT // VkSampleCountFlagBits imageSampleCount
2829 };
2830 // Clear Color Attachment
2831 colorAttachmentClearLayersGroup->addChild(new ImageClearingTestCase<ClearAttachmentTestInstance>(testCtx, testCaseName, testParams));
2832 if (dimensions.width > 1)
2833 // Partial Clear Color Attachment
2834 partialColorAttachmentClearLayersGroup->addChild(new ImageClearingTestCase<PartialClearAttachmentTestInstance>(testCtx, testCaseName, testParams));
2835
2836 if (!imageLayerParamsToTest[imageLayerParamsIndex].isCube && !(imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange.layerCount == VK_REMAINING_ARRAY_LAYERS) && (dimensions.width > dimensions.height))
2837 {
2838 for (const auto& sampleCount : sampleCountsToTest)
2839 {
2840 const std::string msaaTestCaseName = testCaseName + "_" + getSampleCountName(sampleCount);
2841 testParams.imageSampleCount = sampleCount;
2842 // Clear Multisample Color Attachment
2843 colorAttachmentClearLayersGroup->addChild(new ImageClearingTestCase<ClearAttachmentTestInstance>(testCtx, msaaTestCaseName, testParams));
2844 }
2845 }
2846 }
2847 }
2848 }
2849 colorAttachmentClearTests->addChild(colorAttachmentClearLayersGroup.release());
2850 partialColorAttachmentClearTests->addChild(partialColorAttachmentClearLayersGroup.release());
2851 }
2852 }
2853 imageClearingTests->addChild(colorAttachmentClearTests.release());
2854 imageClearingTests->addChild(partialColorAttachmentClearTests.release());
2855 }
2856
2857 // Clear depth/stencil attachment
2858 {
2859 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfAttachmentLayerParamsToTest; ++imageLayerParamsIndex)
2860 {
2861 if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2862 {
2863 de::MovePtr<TestCaseGroup> depthStencilLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName));
2864 de::MovePtr<TestCaseGroup> partialDepthStencilLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName));
2865
2866 for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2867 {
2868 const VkExtent3D dimensions = imageDimensions[imageDimensionsIndex];
2869 const std::string dimensionsString = extentToString(dimensions, VK_IMAGE_TYPE_2D);
2870
2871 if (dimensions.height == 1 || dimensions.depth > 1)
2872 continue;
2873
2874 if (imageLayerParamsToTest[imageLayerParamsIndex].isCube && dimensions.width != dimensions.height)
2875 continue;
2876
2877 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
2878 {
2879 const VkFormat format = depthStencilImageFormatsToTest[imageFormatIndex];
2880 const bool hasDepth = tcu::hasDepthComponent(mapVkFormat(format).order);
2881 const bool hasStencil = tcu::hasStencilComponent(mapVkFormat(format).order);
2882 const int separateLayoutsLoopCount = (hasDepth && hasStencil) ? 3 : 1;
2883
2884 for (int separateDepthStencilLayoutMode = 0; separateDepthStencilLayoutMode < separateLayoutsLoopCount; ++separateDepthStencilLayoutMode)
2885 {
2886 const std::string testCaseName = getFormatCaseName(format) +
2887 ((separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH) ? "_separate_layouts_depth" :
2888 (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL) ? "_separate_layouts_stencil" :
2889 "")
2890 + dimensionsString;
2891
2892 const TestParams testParams =
2893 {
2894 true, // bool useSingleMipLevel;
2895 VK_IMAGE_TYPE_2D, // VkImageType imageType;
2896 format, // VkFormat format;
2897 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
2898 dimensions, // VkExtent3D extent;
2899 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount, // deUint32 imageLayerCount;
2900 imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange, // LayerRange imageViewLayerRange;
2901 makeClearValueDepthStencil(0.0f, 0u), // VkClearValue initValue
2902 {
2903 makeClearValueDepthStencil(0.1f, 0x06), // VkClearValue clearValue[0];
2904 makeClearValueDepthStencil(0.3f, 0x04), // VkClearValue clearValue[1];
2905 },
2906 false, // bool useSeparateExpectedClearValue;
2907 { }, // VkClearValue[2] expectedClearValue;
2908 imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange, // LayerRange clearLayerRange;
2909 allocationKind, // AllocationKind allocationKind;
2910 imageLayerParamsToTest[imageLayerParamsIndex].isCube, // bool isCube;
2911 SeparateDepthStencilLayoutMode(separateDepthStencilLayoutMode), // SeparateDepthStencilLayoutMode separateDepthStencilLayoutMode;
2912 false, // bool isColorMultipleSubresourceRangeTest;
2913 VK_SAMPLE_COUNT_1_BIT // VkSampleCountFlagBits imageSampleCount
2914 };
2915 // Clear Depth/Stencil Attachment
2916 depthStencilLayersGroup->addChild(new ImageClearingTestCase<ClearAttachmentTestInstance>(testCtx, testCaseName, testParams));
2917 if (dimensions.width > 1)
2918 // Partial Clear Depth/Stencil Attachment
2919 partialDepthStencilLayersGroup->addChild(new ImageClearingTestCase<PartialClearAttachmentTestInstance>(testCtx, testCaseName, testParams));
2920 }
2921 }
2922 }
2923 depthStencilAttachmentClearTests->addChild(depthStencilLayersGroup.release());
2924 partialDepthStencilAttachmentClearTests->addChild(partialDepthStencilLayersGroup.release());
2925 }
2926 }
2927 imageClearingTests->addChild(depthStencilAttachmentClearTests.release());
2928 imageClearingTests->addChild(partialDepthStencilAttachmentClearTests.release());
2929 }
2930
2931 return imageClearingTests;
2932 }
2933
createCoreImageClearingTests(tcu::TestCaseGroup * group)2934 void createCoreImageClearingTests (tcu::TestCaseGroup* group)
2935 {
2936 createImageClearingTestsCommon(group->getTestContext(), group, ALLOCATION_KIND_SUBALLOCATED);
2937 }
2938
createDedicatedAllocationImageClearingTests(tcu::TestCaseGroup * group)2939 void createDedicatedAllocationImageClearingTests (tcu::TestCaseGroup* group)
2940 {
2941 createImageClearingTestsCommon(group->getTestContext(), group, ALLOCATION_KIND_DEDICATED);
2942 }
2943
2944 } // anonymous
2945
createImageClearingTests(TestContext & testCtx)2946 TestCaseGroup* createImageClearingTests (TestContext& testCtx)
2947 {
2948 de::MovePtr<TestCaseGroup> imageClearingTests (new TestCaseGroup(testCtx, "image_clearing"));
2949
2950 // Core Image Clearing Tests
2951 imageClearingTests->addChild(createTestGroup(testCtx, "core", createCoreImageClearingTests));
2952 // Image Clearing Tests For Dedicated Memory Allocation
2953 imageClearingTests->addChild(createTestGroup(testCtx, "dedicated_allocation", createDedicatedAllocationImageClearingTests));
2954
2955 return imageClearingTests.release();
2956 }
2957
2958 } // api
2959 } // vkt
2960