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 std::string & description,const typename INSTANCE_TYPE::ParameterType & testParameters)63 SwizzleTestCase (tcu::TestContext& context, const std::string& name, const std::string& description, const typename INSTANCE_TYPE::ParameterType& testParameters)
64 : TextureTestCase<INSTANCE_TYPE> (context, name, description, 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 };
75
76 struct Swizzle2DTestParameters : public Texture2DTestCaseParameters
77 {
78 Swizzle2DTestParameters (void);
79 TextureBinding::ImageBackingMode backingMode;
80 vk::VkComponentMapping componentMapping;
81 const char* texCoordSwizzle;
82 const deUint8* texCoordMapping;
83 };
84
Swizzle2DTestParameters(void)85 Swizzle2DTestParameters::Swizzle2DTestParameters (void)
86 : componentMapping (makeComponentMappingRGBA())
87 , texCoordSwizzle (DE_NULL)
88 , texCoordMapping (DE_NULL)
89 {
90 }
91
92 class Swizzle2DTestInstance : public TestInstance
93 {
94 public:
95 typedef Swizzle2DTestParameters ParameterType;
96
97 Swizzle2DTestInstance (Context& context,
98 const ParameterType& testParameters);
99 tcu::TestStatus iterate (void);
100
101 private:
102 Swizzle2DTestInstance (const Swizzle2DTestInstance& other);
103 Swizzle2DTestInstance& operator= (const Swizzle2DTestInstance& other);
104
105 const ParameterType& m_testParameters;
106 const tcu::TextureFormat m_format;
107 const tcu::CompressedTexFormat m_compressedFormat;
108 TestTexture2DSp m_texture;
109 TextureRenderer m_renderer;
110 };
111
Swizzle2DTestInstance(Context & context,const ParameterType & testParameters)112 Swizzle2DTestInstance::Swizzle2DTestInstance (Context& context,
113 const ParameterType& testParameters)
114 : TestInstance (context)
115 , m_testParameters (testParameters)
116 , m_format (isCompressedFormat(m_testParameters.format)
117 ? tcu::TextureFormat() // Unused
118 : mapVkFormat(testParameters.format))
119 , m_compressedFormat (isCompressedFormat(m_testParameters.format)
120 ? mapVkCompressedFormat(testParameters.format)
121 : tcu::CompressedTexFormat()) // Unused
122 , m_texture (TestTexture2DSp(isCompressedFormat(m_testParameters.format)
123 ? new pipeline::TestTexture2D(m_compressedFormat, testParameters.width, testParameters.height)
124 : new pipeline::TestTexture2D(m_format, testParameters.width, testParameters.height)))
125 , m_renderer (context, testParameters.sampleCount, testParameters.width, testParameters.height, testParameters.componentMapping)
126 {
127 m_renderer.add2DTexture(m_texture, testParameters.aspectMask, testParameters.backingMode);
128 }
129
iterate(void)130 tcu::TestStatus Swizzle2DTestInstance::iterate (void)
131 {
132 tcu::TestLog& log = m_context.getTestContext().getLog();
133 const pipeline::TestTexture2D& texture = m_renderer.get2DTexture(0);
134 const tcu::TextureFormat textureFormat = texture.getTextureFormat();
135 const float lookupScale = tcu::getTextureFormatInfo(textureFormat).lookupScale[0];
136 const float lookupBias = tcu::getTextureFormatInfo(textureFormat).lookupBias[0];
137
138 ReferenceParams sampleParams (TEXTURETYPE_2D);
139 tcu::Surface rendered (m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
140 vector<float> texCoord;
141
142 // Params for reference
143 sampleParams.sampler = util::createSampler(m_testParameters.wrapS, m_testParameters.wrapT, m_testParameters.minFilter, m_testParameters.magFilter);
144 sampleParams.samplerType = isCompressedFormat(m_testParameters.format) ? SAMPLERTYPE_FLOAT : getSamplerType(m_format);
145 sampleParams.lodMode = LODMODE_EXACT;
146 sampleParams.colorBias = tcu::Vec4(lookupBias);
147 sampleParams.colorScale = tcu::Vec4(lookupScale);
148
149 if (sampleParams.colorBias != tcu::Vec4(0.0f))
150 sampleParams.flags = RenderParams::USE_BIAS;
151
152 log << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage;
153 log << TestLog::Message << "Lookup scale = " << lookupScale << TestLog::EndMessage;
154 log << TestLog::Message << "Lookup bias = " << lookupBias << TestLog::EndMessage;
155
156 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));
157 m_renderer.renderQuad(rendered, 0, &texCoord[0], sampleParams);
158
159 const tcu::IVec4 formatBitDepth = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
160 const tcu::PixelFormat pixelFormat (formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
161 tcu::Surface referenceFrame (m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
162
163 // Render reference (based on sampleTextureNonProjected in gluTextureTestUtil.cpp)
164 {
165 std::vector<tcu::ConstPixelBufferAccess> storage;
166 const tcu::Texture2DView src = getEffectiveTextureView(m_texture->getTexture(), storage, sampleParams.sampler);
167 const tcu::SurfaceAccess dst = tcu::SurfaceAccess(referenceFrame, pixelFormat);
168
169 const tcu::IVec2 dstSize = tcu::IVec2(dst.getWidth(), dst.getHeight());
170 const tcu::IVec2 srcSize = tcu::IVec2(src.getWidth(), src.getHeight());
171
172 const float lodBias = (sampleParams.flags & ReferenceParams::USE_BIAS) ? sampleParams.bias : 0.0f;
173 const tcu::Vec4 sq = tcu::Vec4(texCoord[0+0], texCoord[2+0], texCoord[4+0], texCoord[6+0]);
174 const tcu::Vec4 tq = tcu::Vec4(texCoord[0+1], texCoord[2+1], texCoord[4+1], texCoord[6+1]);
175
176 tcu::Vec3 tri[2][2] =
177 {
178 { sq.swizzle(0, 1, 2), sq.swizzle(3, 2, 1) },
179 { tq.swizzle(0, 1, 2), tq.swizzle(3, 2, 1) }
180 };
181
182 // Swizzle texture coordinates
183 if (m_testParameters.texCoordMapping)
184 {
185 const tcu::Vec3 swz[2][2] =
186 {
187 { tri[m_testParameters.texCoordMapping[0]][0], tri[m_testParameters.texCoordMapping[0]][1] },
188 { tri[m_testParameters.texCoordMapping[1]][0], tri[m_testParameters.texCoordMapping[1]][1] }
189 };
190
191 memcpy(tri, swz, sizeof(tri));
192 }
193
194 // Coordinates and lod per triangle
195 const tcu::Vec3 triS[2] = { tri[0][0], tri[0][1] };
196 const tcu::Vec3 triT[2] = { tri[1][0], tri[1][1] };
197 const float triLod[2] = { de::clamp(computeNonProjectedTriLod(sampleParams.lodMode, dstSize, srcSize, triS[0], triT[0]) + lodBias, sampleParams.minLod, sampleParams.maxLod),
198 de::clamp(computeNonProjectedTriLod(sampleParams.lodMode, dstSize, srcSize, triS[1], triT[1]) + lodBias, sampleParams.minLod, sampleParams.maxLod) };
199
200 for (int y = 0; y < dstSize.y(); y++)
201 for (int x = 0; x < dstSize.x(); x++)
202 {
203 const float yf = ((float)y + 0.5f) / (float)dstSize.y();
204 const float xf = ((float)x + 0.5f) / (float)dstSize.x();
205
206 const int triNdx = xf + yf >= 1.0f ? 1 : 0; // Top left fill rule
207 const float triX = triNdx ? 1.0f-xf : xf;
208 const float triY = triNdx ? 1.0f-yf : yf;
209
210 const float s = triangleInterpolate(triS[triNdx].x(), triS[triNdx].y(), triS[triNdx].z(), triX, triY);
211 const float t = triangleInterpolate(triT[triNdx].x(), triT[triNdx].y(), triT[triNdx].z(), triX, triY);
212 const float lod = triLod[triNdx];
213
214 dst.setPixel(src.sample(sampleParams.sampler, s, t, lod) * sampleParams.colorScale + sampleParams.colorBias, x, y);
215 }
216 }
217
218 // Reference component mapping swizzle
219 if (!isDefaultComponentMapping(m_testParameters.componentMapping))
220 {
221 tcu::Surface swzSurface = referenceFrame;
222 const tcu::IVec4 bitDepth = getTextureFormatBitDepth(isCompressedFormat(m_testParameters.format)
223 ? getUncompressedFormat(m_compressedFormat)
224 : m_format);
225 const deUint8 one = deUint8(255.0f * (lookupScale + lookupBias));
226 const deUint8 zero = deUint8(255.0f * lookupBias);
227
228 const VkComponentSwizzle swizzle[] =
229 {
230 m_testParameters.componentMapping.r,
231 m_testParameters.componentMapping.g,
232 m_testParameters.componentMapping.b,
233 m_testParameters.componentMapping.a
234 };
235
236 log << TestLog::Message << "Format bit depth = " << bitDepth << TestLog::EndMessage;
237 log << TestLog::Message << "One = " << int(one) << TestLog::EndMessage;
238 log << TestLog::Message << "Zero = " << int(zero) << TestLog::EndMessage;
239
240 for (int y = 0; y < m_testParameters.height; y++)
241 for (int x = 0; x < m_testParameters.width; x++)
242 {
243 const tcu::RGBA original = referenceFrame.getPixel(x, y);
244 tcu::IVec4 swizzled = original.toIVec();
245
246 for (int ndx = 0; ndx < 4; ndx++)
247 {
248 switch (swizzle[ndx])
249 {
250 case VK_COMPONENT_SWIZZLE_ZERO:
251 swizzled[ndx] = zero;
252 break;
253 case VK_COMPONENT_SWIZZLE_ONE:
254 swizzled[ndx] = one;
255 break;
256 case VK_COMPONENT_SWIZZLE_R:
257 swizzled[ndx] = bitDepth[0] ? original.getRed() : zero;
258 break;
259 case VK_COMPONENT_SWIZZLE_G:
260 swizzled[ndx] = bitDepth[1] ? original.getGreen() : zero;
261 break;
262 case VK_COMPONENT_SWIZZLE_B:
263 swizzled[ndx] = bitDepth[2] ? original.getBlue() : zero;
264 break;
265 case VK_COMPONENT_SWIZZLE_A:
266 swizzled[ndx] = bitDepth[3] ? original.getAlpha() : one;
267 break;
268 default:
269 DE_ASSERT(swizzle[ndx] == VK_COMPONENT_SWIZZLE_IDENTITY);
270 }
271 }
272
273 swzSurface.setPixel(x, y, tcu::RGBA(swizzled.x(), swizzled.y(), swizzled.z(), swizzled.w()));
274 }
275
276 referenceFrame = swzSurface;
277 }
278
279 // Compare and log
280 const tcu::RGBA threshold = pixelFormat.getColorThreshold() + tcu::RGBA(2, 2, 2, 2);
281 const bool isOk = compareImages(log, referenceFrame, rendered, threshold);
282
283 return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed");
284 }
285
populateTextureSwizzleTests(tcu::TestCaseGroup * textureSwizzleTests)286 void populateTextureSwizzleTests (tcu::TestCaseGroup* textureSwizzleTests)
287 {
288 tcu::TestContext& testCtx = textureSwizzleTests->getTestContext();
289
290 static const struct{
291 const VkFormat format;
292 const Program program;
293 } formats2D[] =
294 {
295 { VK_FORMAT_R4G4_UNORM_PACK8, PROGRAM_2D_FLOAT },
296 { VK_FORMAT_R4G4B4A4_UNORM_PACK16, PROGRAM_2D_FLOAT },
297 { VK_FORMAT_R5G6B5_UNORM_PACK16, PROGRAM_2D_FLOAT },
298 { VK_FORMAT_R5G5B5A1_UNORM_PACK16, PROGRAM_2D_FLOAT },
299 { VK_FORMAT_R8_UNORM, PROGRAM_2D_FLOAT },
300 { VK_FORMAT_R8_SNORM, PROGRAM_2D_FLOAT_BIAS },
301 { VK_FORMAT_R8_USCALED, PROGRAM_2D_UINT },
302 { VK_FORMAT_R8_SSCALED, PROGRAM_2D_INT_BIAS },
303 { VK_FORMAT_R8_UINT, PROGRAM_2D_UINT },
304 { VK_FORMAT_R8_SINT, PROGRAM_2D_INT_BIAS },
305 { VK_FORMAT_R8_SRGB, PROGRAM_2D_FLOAT },
306 { VK_FORMAT_R8G8_UNORM, PROGRAM_2D_FLOAT },
307 { VK_FORMAT_R8G8_SNORM, PROGRAM_2D_FLOAT_BIAS },
308 { VK_FORMAT_R8G8_USCALED, PROGRAM_2D_UINT },
309 { VK_FORMAT_R8G8_SSCALED, PROGRAM_2D_INT_BIAS },
310 { VK_FORMAT_R8G8_UINT, PROGRAM_2D_UINT },
311 { VK_FORMAT_R8G8_SINT, PROGRAM_2D_INT_BIAS },
312 { VK_FORMAT_R8G8_SRGB, PROGRAM_2D_FLOAT },
313 { VK_FORMAT_R8G8B8_UNORM, PROGRAM_2D_FLOAT },
314 { VK_FORMAT_R8G8B8_SNORM, PROGRAM_2D_FLOAT_BIAS },
315 { VK_FORMAT_R8G8B8_USCALED, PROGRAM_2D_UINT },
316 { VK_FORMAT_R8G8B8_SSCALED, PROGRAM_2D_INT_BIAS },
317 { VK_FORMAT_R8G8B8_UINT, PROGRAM_2D_UINT },
318 { VK_FORMAT_R8G8B8_SINT, PROGRAM_2D_INT_BIAS },
319 { VK_FORMAT_R8G8B8_SRGB, PROGRAM_2D_FLOAT },
320 { VK_FORMAT_R8G8B8A8_UNORM, PROGRAM_2D_FLOAT },
321 { VK_FORMAT_R8G8B8A8_SNORM, PROGRAM_2D_FLOAT_BIAS },
322 { VK_FORMAT_R8G8B8A8_USCALED, PROGRAM_2D_UINT },
323 { VK_FORMAT_R8G8B8A8_SSCALED, PROGRAM_2D_INT_BIAS },
324 { VK_FORMAT_R8G8B8A8_UINT, PROGRAM_2D_UINT },
325 { VK_FORMAT_R8G8B8A8_SINT, PROGRAM_2D_INT_BIAS },
326 { VK_FORMAT_R8G8B8A8_SRGB, PROGRAM_2D_FLOAT },
327 { VK_FORMAT_A2R10G10B10_UNORM_PACK32, PROGRAM_2D_FLOAT },
328 { VK_FORMAT_A2R10G10B10_UINT_PACK32, PROGRAM_2D_UINT },
329 { VK_FORMAT_A2B10G10R10_USCALED_PACK32, PROGRAM_2D_UINT },
330 { VK_FORMAT_R16_UNORM, PROGRAM_2D_FLOAT },
331 { VK_FORMAT_R16_SNORM, PROGRAM_2D_FLOAT_BIAS },
332 { VK_FORMAT_R16_USCALED, PROGRAM_2D_UINT },
333 { VK_FORMAT_R16_SSCALED, PROGRAM_2D_INT_BIAS },
334 { VK_FORMAT_R16_UINT, PROGRAM_2D_UINT },
335 { VK_FORMAT_R16_SINT, PROGRAM_2D_INT_BIAS },
336 { VK_FORMAT_R16_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
337 { VK_FORMAT_R16G16_UNORM, PROGRAM_2D_FLOAT },
338 { VK_FORMAT_R16G16_SNORM, PROGRAM_2D_FLOAT_BIAS },
339 { VK_FORMAT_R16G16_USCALED, PROGRAM_2D_UINT },
340 { VK_FORMAT_R16G16_SSCALED, PROGRAM_2D_INT_BIAS },
341 { VK_FORMAT_R16G16_UINT, PROGRAM_2D_UINT },
342 { VK_FORMAT_R16G16_SINT, PROGRAM_2D_INT_BIAS },
343 { VK_FORMAT_R16G16_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
344 { VK_FORMAT_R16G16B16_UNORM, PROGRAM_2D_FLOAT },
345 { VK_FORMAT_R16G16B16_SNORM, PROGRAM_2D_FLOAT_BIAS },
346 { VK_FORMAT_R16G16B16_USCALED, PROGRAM_2D_UINT },
347 { VK_FORMAT_R16G16B16_SSCALED, PROGRAM_2D_INT_BIAS },
348 { VK_FORMAT_R16G16B16_UINT, PROGRAM_2D_UINT },
349 { VK_FORMAT_R16G16B16_SINT, PROGRAM_2D_INT_BIAS },
350 { VK_FORMAT_R16G16B16_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
351 { VK_FORMAT_R16G16B16A16_UNORM, PROGRAM_2D_FLOAT },
352 { VK_FORMAT_R16G16B16A16_SNORM, PROGRAM_2D_FLOAT_BIAS },
353 { VK_FORMAT_R16G16B16A16_USCALED, PROGRAM_2D_UINT },
354 { VK_FORMAT_R16G16B16A16_SSCALED, PROGRAM_2D_INT_BIAS },
355 { VK_FORMAT_R16G16B16A16_UINT, PROGRAM_2D_UINT },
356 { VK_FORMAT_R16G16B16A16_SINT, PROGRAM_2D_INT_BIAS },
357 { VK_FORMAT_R16G16B16A16_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
358 { VK_FORMAT_R32_UINT, PROGRAM_2D_UINT },
359 { VK_FORMAT_R32_SINT, PROGRAM_2D_INT_BIAS },
360 { VK_FORMAT_R32_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
361 { VK_FORMAT_R32G32_UINT, PROGRAM_2D_UINT },
362 { VK_FORMAT_R32G32_SINT, PROGRAM_2D_INT_BIAS },
363 { VK_FORMAT_R32G32_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
364 { VK_FORMAT_R32G32B32_UINT, PROGRAM_2D_UINT },
365 { VK_FORMAT_R32G32B32_SINT, PROGRAM_2D_INT_BIAS },
366 { VK_FORMAT_R32G32B32_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
367 { VK_FORMAT_R32G32B32A32_UINT, PROGRAM_2D_UINT },
368 { VK_FORMAT_R32G32B32A32_SINT, PROGRAM_2D_INT_BIAS },
369 { VK_FORMAT_R32G32B32A32_SFLOAT, PROGRAM_2D_FLOAT_BIAS },
370 { VK_FORMAT_B10G11R11_UFLOAT_PACK32, PROGRAM_2D_FLOAT },
371 { VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, PROGRAM_2D_FLOAT },
372 { VK_FORMAT_B4G4R4A4_UNORM_PACK16, PROGRAM_2D_FLOAT },
373 { VK_FORMAT_B5G5R5A1_UNORM_PACK16, PROGRAM_2D_FLOAT },
374
375 // Compressed formats
376 { VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, PROGRAM_2D_FLOAT },
377 { VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, PROGRAM_2D_FLOAT },
378 { VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, PROGRAM_2D_FLOAT },
379 { VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, PROGRAM_2D_FLOAT },
380 { VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, PROGRAM_2D_FLOAT },
381 { VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, PROGRAM_2D_FLOAT },
382 { VK_FORMAT_EAC_R11_UNORM_BLOCK, PROGRAM_2D_FLOAT },
383 { VK_FORMAT_EAC_R11_SNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
384 { VK_FORMAT_EAC_R11G11_UNORM_BLOCK, PROGRAM_2D_FLOAT },
385 { VK_FORMAT_EAC_R11G11_SNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
386 { VK_FORMAT_ASTC_4x4_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
387 { VK_FORMAT_ASTC_4x4_SRGB_BLOCK, PROGRAM_2D_FLOAT },
388 { VK_FORMAT_ASTC_5x4_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
389 { VK_FORMAT_ASTC_5x4_SRGB_BLOCK, PROGRAM_2D_FLOAT },
390 { VK_FORMAT_ASTC_5x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
391 { VK_FORMAT_ASTC_5x5_SRGB_BLOCK, PROGRAM_2D_FLOAT },
392 { VK_FORMAT_ASTC_6x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
393 { VK_FORMAT_ASTC_6x5_SRGB_BLOCK, PROGRAM_2D_FLOAT },
394 { VK_FORMAT_ASTC_6x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
395 { VK_FORMAT_ASTC_6x6_SRGB_BLOCK, PROGRAM_2D_FLOAT },
396 { VK_FORMAT_ASTC_8x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
397 { VK_FORMAT_ASTC_8x5_SRGB_BLOCK, PROGRAM_2D_FLOAT },
398 { VK_FORMAT_ASTC_8x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
399 { VK_FORMAT_ASTC_8x6_SRGB_BLOCK, PROGRAM_2D_FLOAT },
400 { VK_FORMAT_ASTC_8x8_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
401 { VK_FORMAT_ASTC_8x8_SRGB_BLOCK, PROGRAM_2D_FLOAT },
402 { VK_FORMAT_ASTC_10x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
403 { VK_FORMAT_ASTC_10x5_SRGB_BLOCK, PROGRAM_2D_FLOAT },
404 { VK_FORMAT_ASTC_10x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
405 { VK_FORMAT_ASTC_10x6_SRGB_BLOCK, PROGRAM_2D_FLOAT },
406 { VK_FORMAT_ASTC_10x8_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
407 { VK_FORMAT_ASTC_10x8_SRGB_BLOCK, PROGRAM_2D_FLOAT },
408 { VK_FORMAT_ASTC_10x10_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
409 { VK_FORMAT_ASTC_10x10_SRGB_BLOCK, PROGRAM_2D_FLOAT },
410 { VK_FORMAT_ASTC_12x10_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
411 { VK_FORMAT_ASTC_12x10_SRGB_BLOCK, PROGRAM_2D_FLOAT },
412 { VK_FORMAT_ASTC_12x12_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS },
413 { VK_FORMAT_ASTC_12x12_SRGB_BLOCK, PROGRAM_2D_FLOAT }
414 };
415
416 static const struct {
417 const char* name;
418 const deUint32 width;
419 const deUint32 height;
420 } sizes2D[] =
421 {
422 { "pot", 128, 64, },
423 { "npot", 51, 65 },
424 };
425
426 static const struct {
427 const char* name;
428 const TextureBinding::ImageBackingMode backingMode;
429 } backingModes[] =
430 {
431 { "", TextureBinding::IMAGE_BACKING_MODE_REGULAR },
432 { "_sparse", TextureBinding::IMAGE_BACKING_MODE_SPARSE }
433 };
434
435 static const struct {
436 const char* name;
437 const VkComponentMapping componentMapping;
438 } componentMappings[] =
439 {
440 { "zzzz", {VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO} },
441 { "oooo", {VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE} },
442 { "rrrr", {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R} },
443 { "gggg", {VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G} },
444 { "bbbb", {VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B} },
445 { "aaaa", {VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A} }
446 };
447
448 static const struct {
449 const char* swizzle;
450 const deUint8 mapping[2];
451 } texCoordSwizzles2d[] =
452 {
453 { "yx", { 1, 0 } },
454 { "xx", { 0, 0 } },
455 { "yy", { 1, 1 } }
456 };
457
458 de::MovePtr<tcu::TestCaseGroup> groupCompMap (new tcu::TestCaseGroup(testCtx, "component_mapping", "Component mapping swizzles"));
459 de::MovePtr<tcu::TestCaseGroup> groupTexCoord (new tcu::TestCaseGroup(testCtx, "texture_coordinate", "Texture coordinate swizzles"));
460
461 // 2D Component mapping swizzles
462 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
463 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats2D); formatNdx++)
464 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
465 for (int mappingNdx = 0; mappingNdx < DE_LENGTH_OF_ARRAY(componentMappings); mappingNdx++)
466 {
467 const string formatStr = de::toString(getFormatStr(formats2D[formatNdx].format));
468 const string caseDesc = formatStr + ", TEXTURETYPE_2D";
469 const string caseName = de::toLower(formatStr.substr(10)) + "_2d"
470 + "_" + sizes2D[sizeNdx].name
471 + backingModes[backingNdx].name
472 + "_" + componentMappings[mappingNdx].name;
473
474 Swizzle2DTestParameters testParameters;
475 testParameters.format = formats2D[formatNdx].format;
476 testParameters.backingMode = backingModes[backingNdx].backingMode;
477 testParameters.componentMapping = componentMappings[mappingNdx].componentMapping;
478 testParameters.width = sizes2D[sizeNdx].width;
479 testParameters.height = sizes2D[sizeNdx].height;
480 testParameters.minFilter = tcu::Sampler::NEAREST;
481 testParameters.magFilter = tcu::Sampler::NEAREST;
482 testParameters.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
483 testParameters.programs.push_back(formats2D[formatNdx].program);
484
485 groupCompMap->addChild(new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), caseDesc.c_str(), testParameters));
486 }
487
488 // 2D Texture coordinate swizzles
489 for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++)
490 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats2D); formatNdx++)
491 for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
492 for (int swizzleNdx = 0; swizzleNdx < DE_LENGTH_OF_ARRAY(texCoordSwizzles2d); swizzleNdx++)
493 {
494 const string formatStr = de::toString(getFormatStr(formats2D[formatNdx].format));
495 const string caseDesc = formatStr + ", TEXTURETYPE_2D";
496 const string caseName = de::toLower(formatStr.substr(10)) + "_2d"
497 + "_" + sizes2D[sizeNdx].name
498 + backingModes[backingNdx].name
499 + "_" + texCoordSwizzles2d[swizzleNdx].swizzle;
500
501 Swizzle2DTestParameters testParameters;
502 testParameters.format = formats2D[formatNdx].format;
503 testParameters.backingMode = backingModes[backingNdx].backingMode;
504 testParameters.componentMapping = makeComponentMappingRGBA();
505 testParameters.texCoordSwizzle = texCoordSwizzles2d[swizzleNdx].swizzle;
506 testParameters.texCoordMapping = texCoordSwizzles2d[swizzleNdx].mapping;
507 testParameters.width = sizes2D[sizeNdx].width;
508 testParameters.height = sizes2D[sizeNdx].height;
509 testParameters.minFilter = tcu::Sampler::NEAREST;
510 testParameters.magFilter = tcu::Sampler::NEAREST;
511 testParameters.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
512 testParameters.programs.push_back(formats2D[formatNdx].program);
513
514 groupTexCoord->addChild(new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), caseDesc.c_str(), testParameters));
515 }
516
517 textureSwizzleTests->addChild(groupCompMap.release());
518 textureSwizzleTests->addChild(groupTexCoord.release());
519 }
520
521 } // anonymous
522
createTextureSwizzleTests(tcu::TestContext & testCtx)523 tcu::TestCaseGroup* createTextureSwizzleTests (tcu::TestContext& testCtx)
524 {
525 return createTestGroup(testCtx, "swizzle", "Texture swizzle tests.", populateTextureSwizzleTests);
526 }
527
528 } // texture
529 } // vkt
530