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, const typename INSTANCE_TYPE::ParameterType& testParameters)
64 : TextureTestCase<INSTANCE_TYPE> (context, name, testParameters)
65 {}
66
initPrograms(vk::SourceCollections & programCollection) const67 virtual void initPrograms (vk::SourceCollections& programCollection) const
68 {
69 initializePrograms(programCollection,
70 this->m_testsParameters.texCoordPrecision,
71 this->m_testsParameters.programs,
72 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 deUint8* 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,
116 const ParameterType& testParameters);
117 tcu::TestStatus iterate (void);
118
119 private:
120 Swizzle2DTestInstance (const Swizzle2DTestInstance& other);
121 Swizzle2DTestInstance& operator= (const Swizzle2DTestInstance& other);
122
123 const ParameterType& m_testParameters;
124 const tcu::TextureFormat m_format;
125 const tcu::CompressedTexFormat m_compressedFormat;
126 TestTexture2DSp m_texture;
127 TextureRenderer m_renderer;
128 };
129
Swizzle2DTestInstance(Context & context,const ParameterType & testParameters)130 Swizzle2DTestInstance::Swizzle2DTestInstance (Context& context,
131 const ParameterType& testParameters)
132 : TestInstance (context)
133 , m_testParameters (testParameters)
134 , m_format (isCompressedFormat(m_testParameters.format)
135 ? tcu::TextureFormat() // Unused
136 : mapVkFormat(testParameters.format))
137 , m_compressedFormat (isCompressedFormat(m_testParameters.format)
138 ? mapVkCompressedFormat(testParameters.format)
139 : tcu::CompressedTexFormat()) // Unused
140 , m_texture (TestTexture2DSp(isCompressedFormat(m_testParameters.format)
141 ? new pipeline::TestTexture2D(m_compressedFormat, testParameters.width, testParameters.height)
142 : new pipeline::TestTexture2D(m_format, testParameters.width, testParameters.height)))
143 , m_renderer (context, testParameters.sampleCount, testParameters.width, testParameters.height, testParameters.componentMapping)
144 {
145 m_renderer.add2DTexture(m_texture, testParameters.aspectMask, testParameters.backingMode);
146 }
147
iterate(void)148 tcu::TestStatus Swizzle2DTestInstance::iterate (void)
149 {
150 tcu::TestLog& log = m_context.getTestContext().getLog();
151 const pipeline::TestTexture2D& texture = m_renderer.get2DTexture(0);
152 const tcu::TextureFormat textureFormat = texture.getTextureFormat();
153 const float lookupScale = tcu::getTextureFormatInfo(textureFormat).lookupScale[0];
154 const float lookupBias = tcu::getTextureFormatInfo(textureFormat).lookupBias[0];
155
156 ReferenceParams sampleParams (TEXTURETYPE_2D);
157 tcu::Surface rendered (m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
158 vector<float> texCoord;
159
160 // Params for reference
161 sampleParams.sampler = util::createSampler(m_testParameters.wrapS, m_testParameters.wrapT, 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 = isCompressedFormat(m_testParameters.format) ? SAMPLERTYPE_FLOAT : getSamplerType(m_format);
168 }
169 else if(m_testParameters.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT)
170 {
171 sampleParams.samplerType = SAMPLERTYPE_FLOAT;
172 }
173 else // VK_IMAGE_ASPECT_STENCIL_BIT
174 {
175 sampleParams.samplerType = SAMPLERTYPE_UINT;
176 }
177
178 if (sampleParams.colorBias != tcu::Vec4(0.0f))
179 sampleParams.flags = RenderParams::USE_BIAS;
180
181 log << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage;
182 log << TestLog::Message << "Lookup scale = " << lookupScale << TestLog::EndMessage;
183 log << TestLog::Message << "Lookup bias = " << lookupBias << TestLog::EndMessage;
184
185 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));
186 m_renderer.renderQuad(rendered, 0, &texCoord[0], sampleParams);
187
188 const tcu::IVec4 formatBitDepth = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
189 const tcu::PixelFormat pixelFormat (formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
190 tcu::Surface referenceFrame (m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
191
192 // Render reference (based on sampleTextureNonProjected in gluTextureTestUtil.cpp)
193 {
194 std::vector<tcu::ConstPixelBufferAccess> storage;
195 const tcu::Texture2DView src = getEffectiveTextureView(m_texture->getTexture(), storage, sampleParams.sampler);
196 const tcu::SurfaceAccess dst = tcu::SurfaceAccess(referenceFrame, pixelFormat);
197
198 const tcu::IVec2 dstSize = tcu::IVec2(dst.getWidth(), dst.getHeight());
199 const tcu::IVec2 srcSize = tcu::IVec2(src.getWidth(), src.getHeight());
200
201 const float lodBias = (sampleParams.flags & ReferenceParams::USE_BIAS) ? sampleParams.bias : 0.0f;
202 const tcu::Vec4 sq = tcu::Vec4(texCoord[0+0], texCoord[2+0], texCoord[4+0], texCoord[6+0]);
203 const tcu::Vec4 tq = tcu::Vec4(texCoord[0+1], texCoord[2+1], texCoord[4+1], texCoord[6+1]);
204
205 tcu::Vec3 tri[2][2] =
206 {
207 { sq.swizzle(0, 1, 2), sq.swizzle(3, 2, 1) },
208 { tq.swizzle(0, 1, 2), tq.swizzle(3, 2, 1) }
209 };
210
211 // Swizzle texture coordinates
212 if (m_testParameters.texCoordMapping)
213 {
214 const tcu::Vec3 swz[2][2] =
215 {
216 { tri[m_testParameters.texCoordMapping[0]][0], tri[m_testParameters.texCoordMapping[0]][1] },
217 { tri[m_testParameters.texCoordMapping[1]][0], tri[m_testParameters.texCoordMapping[1]][1] }
218 };
219
220 memcpy(tri, swz, sizeof(tri));
221 }
222
223 // Coordinates and lod per triangle
224 const tcu::Vec3 triS[2] = { tri[0][0], tri[0][1] };
225 const tcu::Vec3 triT[2] = { tri[1][0], tri[1][1] };
226 const float triLod[2] = { de::clamp(computeNonProjectedTriLod(sampleParams.lodMode, dstSize, srcSize, triS[0], triT[0]) + lodBias, sampleParams.minLod, sampleParams.maxLod),
227 de::clamp(computeNonProjectedTriLod(sampleParams.lodMode, dstSize, srcSize, triS[1], triT[1]) + lodBias, sampleParams.minLod, sampleParams.maxLod) };
228
229 for (int y = 0; y < dstSize.y(); y++)
230 for (int x = 0; x < dstSize.x(); x++)
231 {
232 const float yf = ((float)y + 0.5f) / (float)dstSize.y();
233 const float xf = ((float)x + 0.5f) / (float)dstSize.x();
234
235 const int triNdx = xf + yf >= 1.0f ? 1 : 0; // Top left fill rule
236 const float triX = triNdx ? 1.0f-xf : xf;
237 const float triY = triNdx ? 1.0f-yf : yf;
238
239 const float s = triangleInterpolate(triS[triNdx].x(), triS[triNdx].y(), triS[triNdx].z(), triX, triY);
240 const float t = triangleInterpolate(triT[triNdx].x(), triT[triNdx].y(), triT[triNdx].z(), triX, triY);
241 const float lod = triLod[triNdx];
242
243 dst.setPixel(src.sample(sampleParams.sampler, s, t, lod) * sampleParams.colorScale + sampleParams.colorBias, 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(isCompressedFormat(m_testParameters.format)
252 ? getUncompressedFormat(m_compressedFormat)
253 : m_format);
254 const deUint8 one = deUint8(255.0f * (lookupScale + lookupBias));
255 const deUint8 zero = deUint8(255.0f * lookupBias);
256
257 const VkComponentSwizzle swizzle[] =
258 {
259 m_testParameters.componentMapping.r,
260 m_testParameters.componentMapping.g,
261 m_testParameters.componentMapping.b,
262 m_testParameters.componentMapping.a
263 };
264
265 log << TestLog::Message << "Format bit depth = " << bitDepth << TestLog::EndMessage;
266 log << TestLog::Message << "One = " << int(one) << TestLog::EndMessage;
267 log << TestLog::Message << "Zero = " << int(zero) << TestLog::EndMessage;
268
269 for (int y = 0; y < m_testParameters.height; y++)
270 for (int x = 0; x < m_testParameters.width; x++)
271 {
272 const tcu::RGBA original = referenceFrame.getPixel(x, y);
273 tcu::IVec4 swizzled = original.toIVec();
274
275 for (int ndx = 0; ndx < 4; ndx++)
276 {
277 switch (swizzle[ndx])
278 {
279 case VK_COMPONENT_SWIZZLE_ZERO:
280 swizzled[ndx] = zero;
281 break;
282 case VK_COMPONENT_SWIZZLE_ONE:
283 swizzled[ndx] = one;
284 break;
285 case VK_COMPONENT_SWIZZLE_R:
286 swizzled[ndx] = bitDepth[0] ? original.getRed() : zero;
287 break;
288 case VK_COMPONENT_SWIZZLE_G:
289 swizzled[ndx] = bitDepth[1] ? original.getGreen() : zero;
290 break;
291 case VK_COMPONENT_SWIZZLE_B:
292 swizzled[ndx] = bitDepth[2] ? original.getBlue() : zero;
293 break;
294 case VK_COMPONENT_SWIZZLE_A:
295 swizzled[ndx] = bitDepth[3] ? original.getAlpha() : one;
296 break;
297 default:
298 DE_ASSERT(swizzle[ndx] == VK_COMPONENT_SWIZZLE_IDENTITY);
299 }
300 }
301
302 swzSurface.setPixel(x, y, tcu::RGBA(swizzled.x(), swizzled.y(), swizzled.z(), swizzled.w()));
303 }
304
305 referenceFrame = swzSurface;
306 }
307
308 // Compare and log
309 const tcu::RGBA threshold = pixelFormat.getColorThreshold() + tcu::RGBA(2, 2, 2, 2);
310 const bool isOk = compareImages(log, referenceFrame, rendered, threshold);
311
312 return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed");
313 }
314
315 } // anonymous
316
populateTextureSwizzleTests(tcu::TestCaseGroup * textureSwizzleTests)317 void populateTextureSwizzleTests (tcu::TestCaseGroup* textureSwizzleTests)
318 {
319 tcu::TestContext& testCtx = textureSwizzleTests->getTestContext();
320
321 static const struct{
322 const VkFormat format;
323 const Program program;
324 } colorFormats2D[] =
325 {
326 { VK_FORMAT_R4G4_UNORM_PACK8, PROGRAM_2D_FLOAT },
327 { VK_FORMAT_R4G4B4A4_UNORM_PACK16, PROGRAM_2D_FLOAT },
328 { VK_FORMAT_R5G6B5_UNORM_PACK16, PROGRAM_2D_FLOAT },
329 { VK_FORMAT_R5G5B5A1_UNORM_PACK16, PROGRAM_2D_FLOAT },
330 { VK_FORMAT_R8_UNORM, PROGRAM_2D_FLOAT },
331 { VK_FORMAT_R8_SNORM, PROGRAM_2D_FLOAT_BIAS },
332 { VK_FORMAT_R8_USCALED, PROGRAM_2D_UINT },
333 { VK_FORMAT_R8_SSCALED, PROGRAM_2D_INT_BIAS },
334 { VK_FORMAT_R8_UINT, PROGRAM_2D_UINT },
335 { VK_FORMAT_R8_SINT, PROGRAM_2D_INT_BIAS },
336 { VK_FORMAT_R8_SRGB, PROGRAM_2D_FLOAT },
337 { VK_FORMAT_R8G8_UNORM, PROGRAM_2D_FLOAT },
338 { VK_FORMAT_R8G8_SNORM, PROGRAM_2D_FLOAT_BIAS },
339 { VK_FORMAT_R8G8_USCALED, PROGRAM_2D_UINT },
340 { VK_FORMAT_R8G8_SSCALED, PROGRAM_2D_INT_BIAS },
341 { VK_FORMAT_R8G8_UINT, PROGRAM_2D_UINT },
342 { VK_FORMAT_R8G8_SINT, PROGRAM_2D_INT_BIAS },
343 { VK_FORMAT_R8G8_SRGB, PROGRAM_2D_FLOAT },
344 { VK_FORMAT_R8G8B8_UNORM, PROGRAM_2D_FLOAT },
345 { VK_FORMAT_R8G8B8_SNORM, PROGRAM_2D_FLOAT_BIAS },
346 { VK_FORMAT_R8G8B8_USCALED, PROGRAM_2D_UINT },
347 { VK_FORMAT_R8G8B8_SSCALED, PROGRAM_2D_INT_BIAS },
348 { VK_FORMAT_R8G8B8_UINT, PROGRAM_2D_UINT },
349 { VK_FORMAT_R8G8B8_SINT, PROGRAM_2D_INT_BIAS },
350 { VK_FORMAT_R8G8B8_SRGB, PROGRAM_2D_FLOAT },
351 { VK_FORMAT_R8G8B8A8_UNORM, PROGRAM_2D_FLOAT },
352 { VK_FORMAT_R8G8B8A8_SNORM, PROGRAM_2D_FLOAT_BIAS },
353 { VK_FORMAT_R8G8B8A8_USCALED, PROGRAM_2D_UINT },
354 { VK_FORMAT_R8G8B8A8_SSCALED, PROGRAM_2D_INT_BIAS },
355 { VK_FORMAT_R8G8B8A8_UINT, PROGRAM_2D_UINT },
356 { VK_FORMAT_R8G8B8A8_SINT, PROGRAM_2D_INT_BIAS },
357 { VK_FORMAT_R8G8B8A8_SRGB, PROGRAM_2D_FLOAT },
358 { VK_FORMAT_A2R10G10B10_UNORM_PACK32, PROGRAM_2D_FLOAT },
359 { VK_FORMAT_A2R10G10B10_UINT_PACK32, PROGRAM_2D_UINT },
360 { VK_FORMAT_A2B10G10R10_USCALED_PACK32, PROGRAM_2D_UINT },
361 { VK_FORMAT_R16_UNORM, PROGRAM_2D_FLOAT },
362 { VK_FORMAT_R16_SNORM, PROGRAM_2D_FLOAT_BIAS },
363 { VK_FORMAT_R16_USCALED, PROGRAM_2D_UINT },
364 { VK_FORMAT_R16_SSCALED, PROGRAM_2D_INT_BIAS },
365 { VK_FORMAT_R16_UINT, PROGRAM_2D_UINT },
366 { VK_FORMAT_R16_SINT, PROGRAM_2D_INT_BIAS },
367 { VK_FORMAT_R16_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
368 { VK_FORMAT_R16G16_UNORM, PROGRAM_2D_FLOAT },
369 { VK_FORMAT_R16G16_SNORM, PROGRAM_2D_FLOAT_BIAS },
370 { VK_FORMAT_R16G16_USCALED, PROGRAM_2D_UINT },
371 { VK_FORMAT_R16G16_SSCALED, PROGRAM_2D_INT_BIAS },
372 { VK_FORMAT_R16G16_UINT, PROGRAM_2D_UINT },
373 { VK_FORMAT_R16G16_SINT, PROGRAM_2D_INT_BIAS },
374 { VK_FORMAT_R16G16_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
375 { VK_FORMAT_R16G16B16_UNORM, PROGRAM_2D_FLOAT },
376 { VK_FORMAT_R16G16B16_SNORM, PROGRAM_2D_FLOAT_BIAS },
377 { VK_FORMAT_R16G16B16_USCALED, PROGRAM_2D_UINT },
378 { VK_FORMAT_R16G16B16_SSCALED, PROGRAM_2D_INT_BIAS },
379 { VK_FORMAT_R16G16B16_UINT, PROGRAM_2D_UINT },
380 { VK_FORMAT_R16G16B16_SINT, PROGRAM_2D_INT_BIAS },
381 { VK_FORMAT_R16G16B16_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
382 { VK_FORMAT_R16G16B16A16_UNORM, PROGRAM_2D_FLOAT },
383 { VK_FORMAT_R16G16B16A16_SNORM, PROGRAM_2D_FLOAT_BIAS },
384 { VK_FORMAT_R16G16B16A16_USCALED, PROGRAM_2D_UINT },
385 { VK_FORMAT_R16G16B16A16_SSCALED, PROGRAM_2D_INT_BIAS },
386 { VK_FORMAT_R16G16B16A16_UINT, PROGRAM_2D_UINT },
387 { VK_FORMAT_R16G16B16A16_SINT, PROGRAM_2D_INT_BIAS },
388 { VK_FORMAT_R16G16B16A16_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
389 { VK_FORMAT_R32_UINT, PROGRAM_2D_UINT },
390 { VK_FORMAT_R32_SINT, PROGRAM_2D_INT_BIAS },
391 { VK_FORMAT_R32_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
392 { VK_FORMAT_R32G32_UINT, PROGRAM_2D_UINT },
393 { VK_FORMAT_R32G32_SINT, PROGRAM_2D_INT_BIAS },
394 { VK_FORMAT_R32G32_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
395 { VK_FORMAT_R32G32B32_UINT, PROGRAM_2D_UINT },
396 { VK_FORMAT_R32G32B32_SINT, PROGRAM_2D_INT_BIAS },
397 { VK_FORMAT_R32G32B32_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
398 { VK_FORMAT_R32G32B32A32_UINT, PROGRAM_2D_UINT },
399 { VK_FORMAT_R32G32B32A32_SINT, PROGRAM_2D_INT_BIAS },
400 { VK_FORMAT_R32G32B32A32_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
401 { VK_FORMAT_B10G11R11_UFLOAT_PACK32, PROGRAM_2D_FLOAT },
402 { VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, PROGRAM_2D_FLOAT },
403 { VK_FORMAT_B4G4R4A4_UNORM_PACK16, PROGRAM_2D_FLOAT },
404 { VK_FORMAT_B5G5R5A1_UNORM_PACK16, PROGRAM_2D_FLOAT },
405 { VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, PROGRAM_2D_FLOAT },
406 { VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT, PROGRAM_2D_FLOAT },
407
408 // Compressed formats
409 { VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, PROGRAM_2D_FLOAT },
410 { VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, PROGRAM_2D_FLOAT },
411 { VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, PROGRAM_2D_FLOAT },
412 { VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, PROGRAM_2D_FLOAT },
413 { VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, PROGRAM_2D_FLOAT },
414 { VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, PROGRAM_2D_FLOAT },
415 { VK_FORMAT_EAC_R11_UNORM_BLOCK, PROGRAM_2D_FLOAT },
416 { VK_FORMAT_EAC_R11_SNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
417 { VK_FORMAT_EAC_R11G11_UNORM_BLOCK, PROGRAM_2D_FLOAT },
418 { VK_FORMAT_EAC_R11G11_SNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
419 { VK_FORMAT_ASTC_4x4_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
420 { VK_FORMAT_ASTC_4x4_SRGB_BLOCK, PROGRAM_2D_FLOAT },
421 { VK_FORMAT_ASTC_5x4_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
422 { VK_FORMAT_ASTC_5x4_SRGB_BLOCK, PROGRAM_2D_FLOAT },
423 { VK_FORMAT_ASTC_5x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
424 { VK_FORMAT_ASTC_5x5_SRGB_BLOCK, PROGRAM_2D_FLOAT },
425 { VK_FORMAT_ASTC_6x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
426 { VK_FORMAT_ASTC_6x5_SRGB_BLOCK, PROGRAM_2D_FLOAT },
427 { VK_FORMAT_ASTC_6x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
428 { VK_FORMAT_ASTC_6x6_SRGB_BLOCK, PROGRAM_2D_FLOAT },
429 { VK_FORMAT_ASTC_8x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
430 { VK_FORMAT_ASTC_8x5_SRGB_BLOCK, PROGRAM_2D_FLOAT },
431 { VK_FORMAT_ASTC_8x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
432 { VK_FORMAT_ASTC_8x6_SRGB_BLOCK, PROGRAM_2D_FLOAT },
433 { VK_FORMAT_ASTC_8x8_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
434 { VK_FORMAT_ASTC_8x8_SRGB_BLOCK, PROGRAM_2D_FLOAT },
435 { VK_FORMAT_ASTC_10x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
436 { VK_FORMAT_ASTC_10x5_SRGB_BLOCK, PROGRAM_2D_FLOAT },
437 { VK_FORMAT_ASTC_10x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
438 { VK_FORMAT_ASTC_10x6_SRGB_BLOCK, PROGRAM_2D_FLOAT },
439 { VK_FORMAT_ASTC_10x8_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
440 { VK_FORMAT_ASTC_10x8_SRGB_BLOCK, PROGRAM_2D_FLOAT },
441 { VK_FORMAT_ASTC_10x10_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
442 { VK_FORMAT_ASTC_10x10_SRGB_BLOCK, PROGRAM_2D_FLOAT },
443 { VK_FORMAT_ASTC_12x10_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
444 { VK_FORMAT_ASTC_12x10_SRGB_BLOCK, PROGRAM_2D_FLOAT },
445 { VK_FORMAT_ASTC_12x12_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
446 { VK_FORMAT_ASTC_12x12_SRGB_BLOCK, PROGRAM_2D_FLOAT }
447 };
448
449 #ifndef CTS_USES_VULKANSC
450 static const struct {
451 const VkFormat format;
452 const Program program;
453 } depthFormats2D[] =
454 {
455 { VK_FORMAT_D16_UNORM, PROGRAM_2D_FLOAT },
456 { VK_FORMAT_X8_D24_UNORM_PACK32, PROGRAM_2D_FLOAT },
457 { VK_FORMAT_D32_SFLOAT, PROGRAM_2D_FLOAT },
458 { VK_FORMAT_D16_UNORM_S8_UINT, PROGRAM_2D_FLOAT },
459 { VK_FORMAT_D24_UNORM_S8_UINT, PROGRAM_2D_FLOAT },
460 { VK_FORMAT_D32_SFLOAT_S8_UINT, PROGRAM_2D_FLOAT }
461 };
462
463 static const struct {
464 const VkFormat format;
465 const Program program;
466 } stencilFormats2D[] =
467 {
468 { VK_FORMAT_S8_UINT, PROGRAM_2D_UINT },
469 { VK_FORMAT_D16_UNORM_S8_UINT, PROGRAM_2D_UINT },
470 { VK_FORMAT_D24_UNORM_S8_UINT, PROGRAM_2D_UINT },
471 { VK_FORMAT_D32_SFLOAT_S8_UINT, PROGRAM_2D_UINT }
472 };
473 #endif // CTS_USES_VULKANSC
474
475 static const struct {
476 const char* name;
477 const deUint32 width;
478 const deUint32 height;
479 } sizes2D[] =
480 {
481 { "pot", 128, 64, },
482 { "npot", 51, 65 },
483 };
484
485 static const struct {
486 const char* name;
487 const TextureBinding::ImageBackingMode backingMode;
488 } backingModes[] =
489 {
490 { "", TextureBinding::IMAGE_BACKING_MODE_REGULAR },
491 #ifndef CTS_USES_VULKANSC
492 { "_sparse", TextureBinding::IMAGE_BACKING_MODE_SPARSE }
493 #endif // CTS_USES_VULKANSC
494 };
495
496 static const struct {
497 const char* name;
498 const VkComponentMapping componentMapping;
499 } componentMappings[] =
500 {
501 { "zzzz", {VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO} },
502 { "oooo", {VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE} },
503 { "rrrr", {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R} },
504 { "gggg", {VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G} },
505 { "bbbb", {VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B} },
506 { "aaaa", {VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A} },
507 { "rgba", {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A} },
508 { "iiii", {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY} },
509 { "abgr", {VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_R} },
510 };
511
512 static const struct {
513 const char* swizzle;
514 const deUint8 mapping[2];
515 } texCoordSwizzles2d[] =
516 {
517 { "yx", { 1, 0 } },
518 { "xx", { 0, 0 } },
519 { "yy", { 1, 1 } }
520 };
521
522 de::MovePtr<tcu::TestCaseGroup> groupCompMap (new tcu::TestCaseGroup(testCtx, "component_mapping"));
523 de::MovePtr<tcu::TestCaseGroup> groupColor (new tcu::TestCaseGroup(testCtx, "color"));
524 de::MovePtr<tcu::TestCaseGroup> groupDepth (new tcu::TestCaseGroup(testCtx, "depth"));
525 de::MovePtr<tcu::TestCaseGroup> groupStencil (new tcu::TestCaseGroup(testCtx, "stencil"));
526 de::MovePtr<tcu::TestCaseGroup> groupTexCoord (new tcu::TestCaseGroup(testCtx, "texture_coordinate"));
527
528 // 2D Component mapping swizzles for color formats
529 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
530 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats2D); formatNdx++)
531 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
532 for (int mappingNdx = 0; mappingNdx < DE_LENGTH_OF_ARRAY(componentMappings); mappingNdx++)
533 {
534 const string formatStr = de::toString(getFormatStr(colorFormats2D[formatNdx].format));
535 const string caseName = de::toLower(formatStr.substr(10)) + "_2d"
536 + "_" + sizes2D[sizeNdx].name
537 + backingModes[backingNdx].name
538 + "_" + componentMappings[mappingNdx].name;
539
540 Swizzle2DTestParameters testParameters;
541 testParameters.format = colorFormats2D[formatNdx].format;
542 testParameters.backingMode = backingModes[backingNdx].backingMode;
543 testParameters.componentMapping = componentMappings[mappingNdx].componentMapping;
544 testParameters.width = sizes2D[sizeNdx].width;
545 testParameters.height = sizes2D[sizeNdx].height;
546 testParameters.minFilter = tcu::Sampler::NEAREST;
547 testParameters.magFilter = tcu::Sampler::NEAREST;
548 testParameters.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
549 testParameters.programs.push_back(colorFormats2D[formatNdx].program);
550
551 groupColor->addChild(new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), testParameters));
552 }
553 groupCompMap->addChild(groupColor.release());
554
555 #ifndef CTS_USES_VULKANSC
556 // 2D Component mapping swizzles for depth formats
557 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
558 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthFormats2D); formatNdx++)
559 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
560 {
561 const string formatStr = de::toString(getFormatStr(depthFormats2D[formatNdx].format));
562 const string caseName = de::toLower(formatStr.substr(10)) + "_2d"
563 + "_" + sizes2D[sizeNdx].name
564 + backingModes[backingNdx].name
565 + "_" + componentMappings[1].name;
566
567 Swizzle2DTestParameters testParameters;
568 testParameters.format = depthFormats2D[formatNdx].format;
569 testParameters.backingMode = backingModes[backingNdx].backingMode;
570 testParameters.componentMapping = componentMappings[1].componentMapping;
571 testParameters.width = sizes2D[sizeNdx].width;
572 testParameters.height = sizes2D[sizeNdx].height;
573 testParameters.minFilter = tcu::Sampler::NEAREST;
574 testParameters.magFilter = tcu::Sampler::NEAREST;
575 testParameters.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
576 testParameters.programs.push_back(depthFormats2D[formatNdx].program);
577
578 groupDepth->addChild(new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), testParameters));
579 }
580 groupCompMap->addChild(groupDepth.release());
581
582 // 2D Component mapping swizzles for depth formats
583 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
584 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(stencilFormats2D); formatNdx++)
585 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
586 {
587 const string formatStr = de::toString(getFormatStr(stencilFormats2D[formatNdx].format));
588 const string caseName = de::toLower(formatStr.substr(10)) + "_2d"
589 + "_" + sizes2D[sizeNdx].name
590 + backingModes[backingNdx].name
591 + "_" + componentMappings[1].name;
592
593 Swizzle2DTestParameters testParameters;
594 testParameters.format = stencilFormats2D[formatNdx].format;
595 testParameters.backingMode = backingModes[backingNdx].backingMode;
596 testParameters.componentMapping = componentMappings[1].componentMapping;
597 testParameters.width = sizes2D[sizeNdx].width;
598 testParameters.height = sizes2D[sizeNdx].height;
599 testParameters.minFilter = tcu::Sampler::NEAREST;
600 testParameters.magFilter = tcu::Sampler::NEAREST;
601 testParameters.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
602 testParameters.programs.push_back(stencilFormats2D[formatNdx].program);
603
604 groupStencil->addChild(new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), testParameters));
605 }
606 groupCompMap->addChild(groupStencil.release());
607 #endif // CTS_USES_VULKANSC
608
609 // 2D Texture coordinate swizzles
610 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
611 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats2D); formatNdx++)
612 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
613 for (int swizzleNdx = 0; swizzleNdx < DE_LENGTH_OF_ARRAY(texCoordSwizzles2d); swizzleNdx++)
614 {
615 const string formatStr = de::toString(getFormatStr(colorFormats2D[formatNdx].format));
616 const string caseName = de::toLower(formatStr.substr(10)) + "_2d"
617 + "_" + sizes2D[sizeNdx].name
618 + backingModes[backingNdx].name
619 + "_" + texCoordSwizzles2d[swizzleNdx].swizzle;
620
621 Swizzle2DTestParameters testParameters;
622 testParameters.format = colorFormats2D[formatNdx].format;
623 testParameters.backingMode = backingModes[backingNdx].backingMode;
624 testParameters.componentMapping = makeComponentMappingRGBA();
625 testParameters.texCoordSwizzle = texCoordSwizzles2d[swizzleNdx].swizzle;
626 testParameters.texCoordMapping = texCoordSwizzles2d[swizzleNdx].mapping;
627 testParameters.width = sizes2D[sizeNdx].width;
628 testParameters.height = sizes2D[sizeNdx].height;
629 testParameters.minFilter = tcu::Sampler::NEAREST;
630 testParameters.magFilter = tcu::Sampler::NEAREST;
631 testParameters.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
632 testParameters.programs.push_back(colorFormats2D[formatNdx].program);
633
634 groupTexCoord->addChild(new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), testParameters));
635 }
636
637 textureSwizzleTests->addChild(groupCompMap.release());
638 textureSwizzleTests->addChild(groupTexCoord.release());
639 }
640
createTextureSwizzleTests(tcu::TestContext & testCtx)641 tcu::TestCaseGroup* createTextureSwizzleTests (tcu::TestContext& testCtx)
642 {
643 return createTestGroup(testCtx, "swizzle", populateTextureSwizzleTests);
644 }
645
646 } // texture
647 } // vkt
648