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