1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2018 Google Inc.
6 * Copyright (c) 2018 The Khronos Group Inc.
7 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
8 * Copyright (c) 2014 The Android Open Source Project
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
21 *
22 *//*!
23 * \file
24 * \brief Texture swizzle tests.
25 *//*--------------------------------------------------------------------*/
26
27 #include "vktTextureSwizzleTests.hpp"
28
29 #include "vkImageUtil.hpp"
30 #include "vktTestGroupUtil.hpp"
31 #include "vktTextureTestUtil.hpp"
32
33 namespace vkt
34 {
35 namespace texture
36 {
37 namespace
38 {
39
40 using namespace vk;
41 using namespace glu::TextureTestUtil;
42 using namespace texture::util;
43
44 using std::string;
45 using std::vector;
46 using tcu::TestLog;
47
isDefaultComponentMapping(VkComponentMapping mapping)48 bool isDefaultComponentMapping(VkComponentMapping mapping)
49 {
50 if ((mapping.r == VK_COMPONENT_SWIZZLE_R || mapping.r == VK_COMPONENT_SWIZZLE_IDENTITY) &&
51 (mapping.g == VK_COMPONENT_SWIZZLE_G || mapping.g == VK_COMPONENT_SWIZZLE_IDENTITY) &&
52 (mapping.b == VK_COMPONENT_SWIZZLE_B || mapping.b == VK_COMPONENT_SWIZZLE_IDENTITY) &&
53 (mapping.a == VK_COMPONENT_SWIZZLE_A || mapping.a == VK_COMPONENT_SWIZZLE_IDENTITY))
54 return true;
55 else
56 return false;
57 }
58
59 template <typename INSTANCE_TYPE>
60 class SwizzleTestCase : public TextureTestCase<INSTANCE_TYPE>
61 {
62 public:
SwizzleTestCase(tcu::TestContext & context,const std::string & name,const typename INSTANCE_TYPE::ParameterType & testParameters)63 SwizzleTestCase(tcu::TestContext &context, const std::string &name,
64 const typename INSTANCE_TYPE::ParameterType &testParameters)
65 : TextureTestCase<INSTANCE_TYPE>(context, name, testParameters)
66 {
67 }
68
initPrograms(vk::SourceCollections & programCollection) const69 virtual void initPrograms(vk::SourceCollections &programCollection) const
70 {
71 initializePrograms(programCollection, this->m_testsParameters.texCoordPrecision,
72 this->m_testsParameters.programs, this->m_testsParameters.texCoordSwizzle);
73 }
74
checkSupport(Context & context) const75 virtual void checkSupport(Context &context) const
76 {
77 checkTextureSupport(context, this->m_testsParameters);
78
79 #ifndef CTS_USES_VULKANSC
80 if ((this->m_testsParameters.aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) ||
81 (this->m_testsParameters.aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT))
82 {
83 if (!context.isDeviceFunctionalitySupported("VK_KHR_maintenance5"))
84 TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance5 not supported");
85
86 if (!context.getMaintenance5Properties().depthStencilSwizzleOneSupport)
87 TCU_THROW(NotSupportedError, "Property depthStencilSwizzleOneSupport is not supported");
88 }
89 #endif // CTS_USES_VULKANSC
90 }
91 };
92
93 struct Swizzle2DTestParameters : public Texture2DTestCaseParameters
94 {
95 Swizzle2DTestParameters(void);
96 TextureBinding::ImageBackingMode backingMode;
97 vk::VkComponentMapping componentMapping;
98 const char *texCoordSwizzle;
99 const uint8_t *texCoordMapping;
100 };
101
Swizzle2DTestParameters(void)102 Swizzle2DTestParameters::Swizzle2DTestParameters(void)
103 : backingMode(TextureBinding::IMAGE_BACKING_MODE_LAST)
104 , componentMapping(makeComponentMappingRGBA())
105 , texCoordSwizzle(DE_NULL)
106 , texCoordMapping(DE_NULL)
107 {
108 }
109
110 class Swizzle2DTestInstance : public TestInstance
111 {
112 public:
113 typedef Swizzle2DTestParameters ParameterType;
114
115 Swizzle2DTestInstance(Context &context, const ParameterType &testParameters);
116 tcu::TestStatus iterate(void);
117
118 private:
119 Swizzle2DTestInstance(const Swizzle2DTestInstance &other);
120 Swizzle2DTestInstance &operator=(const Swizzle2DTestInstance &other);
121
122 const ParameterType &m_testParameters;
123 const tcu::TextureFormat m_format;
124 const tcu::CompressedTexFormat m_compressedFormat;
125 TestTexture2DSp m_texture;
126 TextureRenderer m_renderer;
127 };
128
Swizzle2DTestInstance(Context & context,const ParameterType & testParameters)129 Swizzle2DTestInstance::Swizzle2DTestInstance(Context &context, const ParameterType &testParameters)
130 : TestInstance(context)
131 , m_testParameters(testParameters)
132 , m_format(isCompressedFormat(m_testParameters.format) ? tcu::TextureFormat() // Unused
133 :
134 mapVkFormat(testParameters.format))
135 , m_compressedFormat(isCompressedFormat(m_testParameters.format) ? mapVkCompressedFormat(testParameters.format) :
136 tcu::CompressedTexFormat()) // Unused
137 , m_texture(TestTexture2DSp(
138 isCompressedFormat(m_testParameters.format) ?
139 new pipeline::TestTexture2D(m_compressedFormat, testParameters.width, testParameters.height) :
140 new pipeline::TestTexture2D(m_format, testParameters.width, testParameters.height)))
141 , m_renderer(context, testParameters.sampleCount, testParameters.width, testParameters.height,
142 testParameters.componentMapping)
143 {
144 m_renderer.add2DTexture(m_texture, testParameters.aspectMask, testParameters.backingMode);
145 }
146
iterate(void)147 tcu::TestStatus Swizzle2DTestInstance::iterate(void)
148 {
149 tcu::TestLog &log = m_context.getTestContext().getLog();
150 const pipeline::TestTexture2D &texture = m_renderer.get2DTexture(0);
151 const tcu::TextureFormat textureFormat = texture.getTextureFormat();
152 const float lookupScale = tcu::getTextureFormatInfo(textureFormat).lookupScale[0];
153 const float lookupBias = tcu::getTextureFormatInfo(textureFormat).lookupBias[0];
154
155 ReferenceParams sampleParams(TEXTURETYPE_2D);
156 tcu::Surface rendered(m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
157 vector<float> texCoord;
158
159 // Params for reference
160 sampleParams.sampler = util::createSampler(m_testParameters.wrapS, m_testParameters.wrapT,
161 m_testParameters.minFilter, m_testParameters.magFilter);
162 sampleParams.lodMode = LODMODE_EXACT;
163 sampleParams.colorBias = tcu::Vec4(lookupBias);
164 sampleParams.colorScale = tcu::Vec4(lookupScale);
165 if (m_testParameters.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT)
166 {
167 sampleParams.samplerType =
168 isCompressedFormat(m_testParameters.format) ? SAMPLERTYPE_FLOAT : getSamplerType(m_format);
169 }
170 else if (m_testParameters.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT)
171 {
172 sampleParams.samplerType = SAMPLERTYPE_FLOAT;
173 }
174 else // VK_IMAGE_ASPECT_STENCIL_BIT
175 {
176 sampleParams.samplerType = SAMPLERTYPE_UINT;
177 }
178
179 if (sampleParams.colorBias != tcu::Vec4(0.0f))
180 sampleParams.flags = RenderParams::USE_BIAS;
181
182 log << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage;
183 log << TestLog::Message << "Lookup scale = " << lookupScale << TestLog::EndMessage;
184 log << TestLog::Message << "Lookup bias = " << lookupBias << TestLog::EndMessage;
185
186 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));
187 m_renderer.renderQuad(rendered, 0, &texCoord[0], sampleParams);
188
189 const tcu::IVec4 formatBitDepth = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
190 const tcu::PixelFormat pixelFormat(formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
191 tcu::Surface referenceFrame(m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
192
193 // Render reference (based on sampleTextureNonProjected in gluTextureTestUtil.cpp)
194 {
195 std::vector<tcu::ConstPixelBufferAccess> storage;
196 const tcu::Texture2DView src = getEffectiveTextureView(m_texture->getTexture(), storage, sampleParams.sampler);
197 const tcu::SurfaceAccess dst = tcu::SurfaceAccess(referenceFrame, pixelFormat);
198
199 const tcu::IVec2 dstSize = tcu::IVec2(dst.getWidth(), dst.getHeight());
200 const tcu::IVec2 srcSize = tcu::IVec2(src.getWidth(), src.getHeight());
201
202 const float lodBias = (sampleParams.flags & ReferenceParams::USE_BIAS) ? sampleParams.bias : 0.0f;
203 const tcu::Vec4 sq = tcu::Vec4(texCoord[0 + 0], texCoord[2 + 0], texCoord[4 + 0], texCoord[6 + 0]);
204 const tcu::Vec4 tq = tcu::Vec4(texCoord[0 + 1], texCoord[2 + 1], texCoord[4 + 1], texCoord[6 + 1]);
205
206 tcu::Vec3 tri[2][2] = {{sq.swizzle(0, 1, 2), sq.swizzle(3, 2, 1)}, {tq.swizzle(0, 1, 2), tq.swizzle(3, 2, 1)}};
207
208 // Swizzle texture coordinates
209 if (m_testParameters.texCoordMapping)
210 {
211 const tcu::Vec3 swz[2][2] = {
212 {tri[m_testParameters.texCoordMapping[0]][0], tri[m_testParameters.texCoordMapping[0]][1]},
213 {tri[m_testParameters.texCoordMapping[1]][0], tri[m_testParameters.texCoordMapping[1]][1]}};
214
215 memcpy(tri, swz, sizeof(tri));
216 }
217
218 // Coordinates and lod per triangle
219 const tcu::Vec3 triS[2] = {tri[0][0], tri[0][1]};
220 const tcu::Vec3 triT[2] = {tri[1][0], tri[1][1]};
221 const float triLod[2] = {
222 de::clamp(computeNonProjectedTriLod(sampleParams.lodMode, dstSize, srcSize, triS[0], triT[0]) + lodBias,
223 sampleParams.minLod, sampleParams.maxLod),
224 de::clamp(computeNonProjectedTriLod(sampleParams.lodMode, dstSize, srcSize, triS[1], triT[1]) + lodBias,
225 sampleParams.minLod, sampleParams.maxLod)};
226
227 for (int y = 0; y < dstSize.y(); y++)
228 for (int x = 0; x < dstSize.x(); x++)
229 {
230 const float yf = ((float)y + 0.5f) / (float)dstSize.y();
231 const float xf = ((float)x + 0.5f) / (float)dstSize.x();
232
233 const int triNdx = xf + yf >= 1.0f ? 1 : 0; // Top left fill rule
234 const float triX = triNdx ? 1.0f - xf : xf;
235 const float triY = triNdx ? 1.0f - yf : yf;
236
237 const float s = triangleInterpolate(triS[triNdx].x(), triS[triNdx].y(), triS[triNdx].z(), triX, triY);
238 const float t = triangleInterpolate(triT[triNdx].x(), triT[triNdx].y(), triT[triNdx].z(), triX, triY);
239 const float lod = triLod[triNdx];
240
241 dst.setPixel(src.sample(sampleParams.sampler, s, t, lod) * sampleParams.colorScale +
242 sampleParams.colorBias,
243 x, y);
244 }
245 }
246
247 // Reference component mapping swizzle
248 if (!isDefaultComponentMapping(m_testParameters.componentMapping))
249 {
250 tcu::Surface swzSurface = referenceFrame;
251 const tcu::IVec4 bitDepth = getTextureFormatBitDepth(
252 isCompressedFormat(m_testParameters.format) ? getUncompressedFormat(m_compressedFormat) : m_format);
253 const uint8_t one = uint8_t(255.0f * (lookupScale + lookupBias));
254 const uint8_t zero = uint8_t(255.0f * lookupBias);
255
256 const VkComponentSwizzle swizzle[] = {m_testParameters.componentMapping.r, m_testParameters.componentMapping.g,
257 m_testParameters.componentMapping.b, m_testParameters.componentMapping.a};
258
259 log << TestLog::Message << "Format bit depth = " << bitDepth << TestLog::EndMessage;
260 log << TestLog::Message << "One = " << int(one) << TestLog::EndMessage;
261 log << TestLog::Message << "Zero = " << int(zero) << TestLog::EndMessage;
262
263 for (int y = 0; y < m_testParameters.height; y++)
264 for (int x = 0; x < m_testParameters.width; x++)
265 {
266 const tcu::RGBA original = referenceFrame.getPixel(x, y);
267 tcu::IVec4 swizzled = original.toIVec();
268
269 for (int ndx = 0; ndx < 4; ndx++)
270 {
271 switch (swizzle[ndx])
272 {
273 case VK_COMPONENT_SWIZZLE_ZERO:
274 swizzled[ndx] = zero;
275 break;
276 case VK_COMPONENT_SWIZZLE_ONE:
277 swizzled[ndx] = one;
278 break;
279 case VK_COMPONENT_SWIZZLE_R:
280 swizzled[ndx] = bitDepth[0] ? original.getRed() : zero;
281 break;
282 case VK_COMPONENT_SWIZZLE_G:
283 swizzled[ndx] = bitDepth[1] ? original.getGreen() : zero;
284 break;
285 case VK_COMPONENT_SWIZZLE_B:
286 swizzled[ndx] = bitDepth[2] ? original.getBlue() : zero;
287 break;
288 case VK_COMPONENT_SWIZZLE_A:
289 swizzled[ndx] = bitDepth[3] ? original.getAlpha() : one;
290 break;
291 default:
292 DE_ASSERT(swizzle[ndx] == VK_COMPONENT_SWIZZLE_IDENTITY);
293 }
294 }
295
296 swzSurface.setPixel(x, y, tcu::RGBA(swizzled.x(), swizzled.y(), swizzled.z(), swizzled.w()));
297 }
298
299 referenceFrame = swzSurface;
300 }
301
302 // Compare and log
303 const tcu::RGBA threshold = pixelFormat.getColorThreshold() + tcu::RGBA(2, 2, 2, 2);
304 const bool isOk = compareImages(log, referenceFrame, rendered, threshold);
305
306 return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed");
307 }
308
309 } // namespace
310
populateTextureSwizzleTests(tcu::TestCaseGroup * textureSwizzleTests)311 void populateTextureSwizzleTests(tcu::TestCaseGroup *textureSwizzleTests)
312 {
313 tcu::TestContext &testCtx = textureSwizzleTests->getTestContext();
314
315 static const struct
316 {
317 const VkFormat format;
318 const Program program;
319 } colorFormats2D[] = {{VK_FORMAT_R4G4_UNORM_PACK8, PROGRAM_2D_FLOAT},
320 {VK_FORMAT_R4G4B4A4_UNORM_PACK16, PROGRAM_2D_FLOAT},
321 {VK_FORMAT_R5G6B5_UNORM_PACK16, PROGRAM_2D_FLOAT},
322 {VK_FORMAT_R5G5B5A1_UNORM_PACK16, PROGRAM_2D_FLOAT},
323 {VK_FORMAT_R8_UNORM, PROGRAM_2D_FLOAT},
324 {VK_FORMAT_R8_SNORM, PROGRAM_2D_FLOAT_BIAS},
325 {VK_FORMAT_R8_USCALED, PROGRAM_2D_UINT},
326 {VK_FORMAT_R8_SSCALED, PROGRAM_2D_INT_BIAS},
327 {VK_FORMAT_R8_UINT, PROGRAM_2D_UINT},
328 {VK_FORMAT_R8_SINT, PROGRAM_2D_INT_BIAS},
329 {VK_FORMAT_R8_SRGB, PROGRAM_2D_FLOAT},
330 {VK_FORMAT_R8G8_UNORM, PROGRAM_2D_FLOAT},
331 {VK_FORMAT_R8G8_SNORM, PROGRAM_2D_FLOAT_BIAS},
332 {VK_FORMAT_R8G8_USCALED, PROGRAM_2D_UINT},
333 {VK_FORMAT_R8G8_SSCALED, PROGRAM_2D_INT_BIAS},
334 {VK_FORMAT_R8G8_UINT, PROGRAM_2D_UINT},
335 {VK_FORMAT_R8G8_SINT, PROGRAM_2D_INT_BIAS},
336 {VK_FORMAT_R8G8_SRGB, PROGRAM_2D_FLOAT},
337 {VK_FORMAT_R8G8B8_UNORM, PROGRAM_2D_FLOAT},
338 {VK_FORMAT_R8G8B8_SNORM, PROGRAM_2D_FLOAT_BIAS},
339 {VK_FORMAT_R8G8B8_USCALED, PROGRAM_2D_UINT},
340 {VK_FORMAT_R8G8B8_SSCALED, PROGRAM_2D_INT_BIAS},
341 {VK_FORMAT_R8G8B8_UINT, PROGRAM_2D_UINT},
342 {VK_FORMAT_R8G8B8_SINT, PROGRAM_2D_INT_BIAS},
343 {VK_FORMAT_R8G8B8_SRGB, PROGRAM_2D_FLOAT},
344 {VK_FORMAT_R8G8B8A8_UNORM, PROGRAM_2D_FLOAT},
345 {VK_FORMAT_R8G8B8A8_SNORM, PROGRAM_2D_FLOAT_BIAS},
346 {VK_FORMAT_R8G8B8A8_USCALED, PROGRAM_2D_UINT},
347 {VK_FORMAT_R8G8B8A8_SSCALED, PROGRAM_2D_INT_BIAS},
348 {VK_FORMAT_R8G8B8A8_UINT, PROGRAM_2D_UINT},
349 {VK_FORMAT_R8G8B8A8_SINT, PROGRAM_2D_INT_BIAS},
350 {VK_FORMAT_R8G8B8A8_SRGB, PROGRAM_2D_FLOAT},
351 {VK_FORMAT_A2R10G10B10_UNORM_PACK32, PROGRAM_2D_FLOAT},
352 {VK_FORMAT_A2R10G10B10_UINT_PACK32, PROGRAM_2D_UINT},
353 {VK_FORMAT_A2B10G10R10_USCALED_PACK32, PROGRAM_2D_UINT},
354 {VK_FORMAT_R16_UNORM, PROGRAM_2D_FLOAT},
355 {VK_FORMAT_R16_SNORM, PROGRAM_2D_FLOAT_BIAS},
356 {VK_FORMAT_R16_USCALED, PROGRAM_2D_UINT},
357 {VK_FORMAT_R16_SSCALED, PROGRAM_2D_INT_BIAS},
358 {VK_FORMAT_R16_UINT, PROGRAM_2D_UINT},
359 {VK_FORMAT_R16_SINT, PROGRAM_2D_INT_BIAS},
360 {VK_FORMAT_R16_SFLOAT, PROGRAM_2D_FLOAT_BIAS},
361 {VK_FORMAT_R16G16_UNORM, PROGRAM_2D_FLOAT},
362 {VK_FORMAT_R16G16_SNORM, PROGRAM_2D_FLOAT_BIAS},
363 {VK_FORMAT_R16G16_USCALED, PROGRAM_2D_UINT},
364 {VK_FORMAT_R16G16_SSCALED, PROGRAM_2D_INT_BIAS},
365 {VK_FORMAT_R16G16_UINT, PROGRAM_2D_UINT},
366 {VK_FORMAT_R16G16_SINT, PROGRAM_2D_INT_BIAS},
367 {VK_FORMAT_R16G16_SFLOAT, PROGRAM_2D_FLOAT_BIAS},
368 {VK_FORMAT_R16G16B16_UNORM, PROGRAM_2D_FLOAT},
369 {VK_FORMAT_R16G16B16_SNORM, PROGRAM_2D_FLOAT_BIAS},
370 {VK_FORMAT_R16G16B16_USCALED, PROGRAM_2D_UINT},
371 {VK_FORMAT_R16G16B16_SSCALED, PROGRAM_2D_INT_BIAS},
372 {VK_FORMAT_R16G16B16_UINT, PROGRAM_2D_UINT},
373 {VK_FORMAT_R16G16B16_SINT, PROGRAM_2D_INT_BIAS},
374 {VK_FORMAT_R16G16B16_SFLOAT, PROGRAM_2D_FLOAT_BIAS},
375 {VK_FORMAT_R16G16B16A16_UNORM, PROGRAM_2D_FLOAT},
376 {VK_FORMAT_R16G16B16A16_SNORM, PROGRAM_2D_FLOAT_BIAS},
377 {VK_FORMAT_R16G16B16A16_USCALED, PROGRAM_2D_UINT},
378 {VK_FORMAT_R16G16B16A16_SSCALED, PROGRAM_2D_INT_BIAS},
379 {VK_FORMAT_R16G16B16A16_UINT, PROGRAM_2D_UINT},
380 {VK_FORMAT_R16G16B16A16_SINT, PROGRAM_2D_INT_BIAS},
381 {VK_FORMAT_R16G16B16A16_SFLOAT, PROGRAM_2D_FLOAT_BIAS},
382 {VK_FORMAT_R32_UINT, PROGRAM_2D_UINT},
383 {VK_FORMAT_R32_SINT, PROGRAM_2D_INT_BIAS},
384 {VK_FORMAT_R32_SFLOAT, PROGRAM_2D_FLOAT_BIAS},
385 {VK_FORMAT_R32G32_UINT, PROGRAM_2D_UINT},
386 {VK_FORMAT_R32G32_SINT, PROGRAM_2D_INT_BIAS},
387 {VK_FORMAT_R32G32_SFLOAT, PROGRAM_2D_FLOAT_BIAS},
388 {VK_FORMAT_R32G32B32_UINT, PROGRAM_2D_UINT},
389 {VK_FORMAT_R32G32B32_SINT, PROGRAM_2D_INT_BIAS},
390 {VK_FORMAT_R32G32B32_SFLOAT, PROGRAM_2D_FLOAT_BIAS},
391 {VK_FORMAT_R32G32B32A32_UINT, PROGRAM_2D_UINT},
392 {VK_FORMAT_R32G32B32A32_SINT, PROGRAM_2D_INT_BIAS},
393 {VK_FORMAT_R32G32B32A32_SFLOAT, PROGRAM_2D_FLOAT_BIAS},
394 {VK_FORMAT_B10G11R11_UFLOAT_PACK32, PROGRAM_2D_FLOAT},
395 {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, PROGRAM_2D_FLOAT},
396 {VK_FORMAT_B4G4R4A4_UNORM_PACK16, PROGRAM_2D_FLOAT},
397 {VK_FORMAT_B5G5R5A1_UNORM_PACK16, PROGRAM_2D_FLOAT},
398 {VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, PROGRAM_2D_FLOAT},
399 {VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT, PROGRAM_2D_FLOAT},
400
401 // Compressed formats
402 {VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, PROGRAM_2D_FLOAT},
403 {VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, PROGRAM_2D_FLOAT},
404 {VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, PROGRAM_2D_FLOAT},
405 {VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, PROGRAM_2D_FLOAT},
406 {VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, PROGRAM_2D_FLOAT},
407 {VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, PROGRAM_2D_FLOAT},
408 {VK_FORMAT_EAC_R11_UNORM_BLOCK, PROGRAM_2D_FLOAT},
409 {VK_FORMAT_EAC_R11_SNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
410 {VK_FORMAT_EAC_R11G11_UNORM_BLOCK, PROGRAM_2D_FLOAT},
411 {VK_FORMAT_EAC_R11G11_SNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
412 {VK_FORMAT_ASTC_4x4_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
413 {VK_FORMAT_ASTC_4x4_SRGB_BLOCK, PROGRAM_2D_FLOAT},
414 {VK_FORMAT_ASTC_5x4_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
415 {VK_FORMAT_ASTC_5x4_SRGB_BLOCK, PROGRAM_2D_FLOAT},
416 {VK_FORMAT_ASTC_5x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
417 {VK_FORMAT_ASTC_5x5_SRGB_BLOCK, PROGRAM_2D_FLOAT},
418 {VK_FORMAT_ASTC_6x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
419 {VK_FORMAT_ASTC_6x5_SRGB_BLOCK, PROGRAM_2D_FLOAT},
420 {VK_FORMAT_ASTC_6x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
421 {VK_FORMAT_ASTC_6x6_SRGB_BLOCK, PROGRAM_2D_FLOAT},
422 {VK_FORMAT_ASTC_8x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
423 {VK_FORMAT_ASTC_8x5_SRGB_BLOCK, PROGRAM_2D_FLOAT},
424 {VK_FORMAT_ASTC_8x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
425 {VK_FORMAT_ASTC_8x6_SRGB_BLOCK, PROGRAM_2D_FLOAT},
426 {VK_FORMAT_ASTC_8x8_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
427 {VK_FORMAT_ASTC_8x8_SRGB_BLOCK, PROGRAM_2D_FLOAT},
428 {VK_FORMAT_ASTC_10x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
429 {VK_FORMAT_ASTC_10x5_SRGB_BLOCK, PROGRAM_2D_FLOAT},
430 {VK_FORMAT_ASTC_10x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
431 {VK_FORMAT_ASTC_10x6_SRGB_BLOCK, PROGRAM_2D_FLOAT},
432 {VK_FORMAT_ASTC_10x8_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
433 {VK_FORMAT_ASTC_10x8_SRGB_BLOCK, PROGRAM_2D_FLOAT},
434 {VK_FORMAT_ASTC_10x10_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
435 {VK_FORMAT_ASTC_10x10_SRGB_BLOCK, PROGRAM_2D_FLOAT},
436 {VK_FORMAT_ASTC_12x10_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
437 {VK_FORMAT_ASTC_12x10_SRGB_BLOCK, PROGRAM_2D_FLOAT},
438 {VK_FORMAT_ASTC_12x12_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS},
439 {VK_FORMAT_ASTC_12x12_SRGB_BLOCK, PROGRAM_2D_FLOAT}};
440
441 #ifndef CTS_USES_VULKANSC
442 static const struct
443 {
444 const VkFormat format;
445 const Program program;
446 } depthFormats2D[] = {
447 {VK_FORMAT_D16_UNORM, PROGRAM_2D_FLOAT}, {VK_FORMAT_X8_D24_UNORM_PACK32, PROGRAM_2D_FLOAT},
448 {VK_FORMAT_D32_SFLOAT, PROGRAM_2D_FLOAT}, {VK_FORMAT_D16_UNORM_S8_UINT, PROGRAM_2D_FLOAT},
449 {VK_FORMAT_D24_UNORM_S8_UINT, PROGRAM_2D_FLOAT}, {VK_FORMAT_D32_SFLOAT_S8_UINT, PROGRAM_2D_FLOAT}};
450
451 static const struct
452 {
453 const VkFormat format;
454 const Program program;
455 } stencilFormats2D[] = {{VK_FORMAT_S8_UINT, PROGRAM_2D_UINT},
456 {VK_FORMAT_D16_UNORM_S8_UINT, PROGRAM_2D_UINT},
457 {VK_FORMAT_D24_UNORM_S8_UINT, PROGRAM_2D_UINT},
458 {VK_FORMAT_D32_SFLOAT_S8_UINT, PROGRAM_2D_UINT}};
459 #endif // CTS_USES_VULKANSC
460
461 static const struct
462 {
463 const char *name;
464 const uint32_t width;
465 const uint32_t height;
466 } sizes2D[] = {
467 {
468 "pot",
469 128,
470 64,
471 },
472 {"npot", 51, 65},
473 };
474
475 static const struct
476 {
477 const char *name;
478 const TextureBinding::ImageBackingMode backingMode;
479 } backingModes[] = {{"", TextureBinding::IMAGE_BACKING_MODE_REGULAR},
480 #ifndef CTS_USES_VULKANSC
481 {"_sparse", TextureBinding::IMAGE_BACKING_MODE_SPARSE}
482 #endif // CTS_USES_VULKANSC
483 };
484
485 static const struct
486 {
487 const char *name;
488 const VkComponentMapping componentMapping;
489 } componentMappings[] = {
490 {"zzzz",
491 {VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO}},
492 {"oooo",
493 {VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE}},
494 {"rrrr", {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R}},
495 {"gggg", {VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G}},
496 {"bbbb", {VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B}},
497 {"aaaa", {VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A}},
498 {"rgba", {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A}},
499 {"iiii",
500 {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
501 VK_COMPONENT_SWIZZLE_IDENTITY}},
502 {"abgr", {VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_R}},
503 };
504
505 static const struct
506 {
507 const char *swizzle;
508 const uint8_t mapping[2];
509 } texCoordSwizzles2d[] = {{"yx", {1, 0}}, {"xx", {0, 0}}, {"yy", {1, 1}}};
510
511 de::MovePtr<tcu::TestCaseGroup> groupCompMap(new tcu::TestCaseGroup(testCtx, "component_mapping"));
512 de::MovePtr<tcu::TestCaseGroup> groupColor(new tcu::TestCaseGroup(testCtx, "color"));
513 de::MovePtr<tcu::TestCaseGroup> groupDepth(new tcu::TestCaseGroup(testCtx, "depth"));
514 de::MovePtr<tcu::TestCaseGroup> groupStencil(new tcu::TestCaseGroup(testCtx, "stencil"));
515 de::MovePtr<tcu::TestCaseGroup> groupTexCoord(new tcu::TestCaseGroup(testCtx, "texture_coordinate"));
516
517 // 2D Component mapping swizzles for color formats
518 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
519 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats2D); formatNdx++)
520 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
521 for (int mappingNdx = 0; mappingNdx < DE_LENGTH_OF_ARRAY(componentMappings); mappingNdx++)
522 {
523 const string formatStr = de::toString(getFormatStr(colorFormats2D[formatNdx].format));
524 const string caseName = de::toLower(formatStr.substr(10)) + "_2d" + "_" + sizes2D[sizeNdx].name +
525 backingModes[backingNdx].name + "_" + componentMappings[mappingNdx].name;
526
527 Swizzle2DTestParameters testParameters;
528 testParameters.format = colorFormats2D[formatNdx].format;
529 testParameters.backingMode = backingModes[backingNdx].backingMode;
530 testParameters.componentMapping = componentMappings[mappingNdx].componentMapping;
531 testParameters.width = sizes2D[sizeNdx].width;
532 testParameters.height = sizes2D[sizeNdx].height;
533 testParameters.minFilter = tcu::Sampler::NEAREST;
534 testParameters.magFilter = tcu::Sampler::NEAREST;
535 testParameters.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
536 testParameters.programs.push_back(colorFormats2D[formatNdx].program);
537
538 groupColor->addChild(
539 new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), testParameters));
540 }
541 groupCompMap->addChild(groupColor.release());
542
543 #ifndef CTS_USES_VULKANSC
544 // 2D Component mapping swizzles for depth formats
545 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
546 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthFormats2D); formatNdx++)
547 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
548 {
549 const string formatStr = de::toString(getFormatStr(depthFormats2D[formatNdx].format));
550 const string caseName = de::toLower(formatStr.substr(10)) + "_2d" + "_" + sizes2D[sizeNdx].name +
551 backingModes[backingNdx].name + "_" + componentMappings[1].name;
552
553 Swizzle2DTestParameters testParameters;
554 testParameters.format = depthFormats2D[formatNdx].format;
555 testParameters.backingMode = backingModes[backingNdx].backingMode;
556 testParameters.componentMapping = componentMappings[1].componentMapping;
557 testParameters.width = sizes2D[sizeNdx].width;
558 testParameters.height = sizes2D[sizeNdx].height;
559 testParameters.minFilter = tcu::Sampler::NEAREST;
560 testParameters.magFilter = tcu::Sampler::NEAREST;
561 testParameters.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
562 testParameters.programs.push_back(depthFormats2D[formatNdx].program);
563
564 groupDepth->addChild(
565 new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), testParameters));
566 }
567 groupCompMap->addChild(groupDepth.release());
568
569 // 2D Component mapping swizzles for depth formats
570 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
571 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(stencilFormats2D); formatNdx++)
572 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
573 {
574 const string formatStr = de::toString(getFormatStr(stencilFormats2D[formatNdx].format));
575 const string caseName = de::toLower(formatStr.substr(10)) + "_2d" + "_" + sizes2D[sizeNdx].name +
576 backingModes[backingNdx].name + "_" + componentMappings[1].name;
577
578 Swizzle2DTestParameters testParameters;
579 testParameters.format = stencilFormats2D[formatNdx].format;
580 testParameters.backingMode = backingModes[backingNdx].backingMode;
581 testParameters.componentMapping = componentMappings[1].componentMapping;
582 testParameters.width = sizes2D[sizeNdx].width;
583 testParameters.height = sizes2D[sizeNdx].height;
584 testParameters.minFilter = tcu::Sampler::NEAREST;
585 testParameters.magFilter = tcu::Sampler::NEAREST;
586 testParameters.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
587 testParameters.programs.push_back(stencilFormats2D[formatNdx].program);
588
589 groupStencil->addChild(
590 new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), testParameters));
591 }
592 groupCompMap->addChild(groupStencil.release());
593 #endif // CTS_USES_VULKANSC
594
595 // 2D Texture coordinate swizzles
596 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
597 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats2D); formatNdx++)
598 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
599 for (int swizzleNdx = 0; swizzleNdx < DE_LENGTH_OF_ARRAY(texCoordSwizzles2d); swizzleNdx++)
600 {
601 const string formatStr = de::toString(getFormatStr(colorFormats2D[formatNdx].format));
602 const string caseName = de::toLower(formatStr.substr(10)) + "_2d" + "_" + sizes2D[sizeNdx].name +
603 backingModes[backingNdx].name + "_" +
604 texCoordSwizzles2d[swizzleNdx].swizzle;
605
606 Swizzle2DTestParameters testParameters;
607 testParameters.format = colorFormats2D[formatNdx].format;
608 testParameters.backingMode = backingModes[backingNdx].backingMode;
609 testParameters.componentMapping = makeComponentMappingRGBA();
610 testParameters.texCoordSwizzle = texCoordSwizzles2d[swizzleNdx].swizzle;
611 testParameters.texCoordMapping = texCoordSwizzles2d[swizzleNdx].mapping;
612 testParameters.width = sizes2D[sizeNdx].width;
613 testParameters.height = sizes2D[sizeNdx].height;
614 testParameters.minFilter = tcu::Sampler::NEAREST;
615 testParameters.magFilter = tcu::Sampler::NEAREST;
616 testParameters.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
617 testParameters.programs.push_back(colorFormats2D[formatNdx].program);
618
619 groupTexCoord->addChild(
620 new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), testParameters));
621 }
622
623 textureSwizzleTests->addChild(groupCompMap.release());
624 textureSwizzleTests->addChild(groupTexCoord.release());
625 }
626
createTextureSwizzleTests(tcu::TestContext & testCtx)627 tcu::TestCaseGroup *createTextureSwizzleTests(tcu::TestContext &testCtx)
628 {
629 return createTestGroup(testCtx, "swizzle", populateTextureSwizzleTests);
630 }
631
632 } // namespace texture
633 } // namespace vkt
634