1 //
2 // Copyright 2015 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 // Texture upload format tests:
7 // Test all texture unpack/upload formats for sampling correctness.
8 //
9
10 #include "common/mathutil.h"
11 #include "image_util/copyimage.h"
12 #include "test_utils/ANGLETest.h"
13 #include "test_utils/gl_raii.h"
14
15 using namespace angle;
16
17 namespace
18 {
19
20 class TextureUploadFormatTest : public ANGLETest
21 {};
22
23 struct TexFormat final
24 {
25 GLenum internalFormat;
26 GLenum unpackFormat;
27 GLenum unpackType;
28
29 TexFormat() = delete;
30
bytesPerPixel__anon18c49c240111::TexFormat31 uint8_t bytesPerPixel() const
32 {
33 uint8_t bytesPerChannel;
34 switch (unpackType)
35 {
36 case GL_UNSIGNED_SHORT_5_6_5:
37 case GL_UNSIGNED_SHORT_4_4_4_4:
38 case GL_UNSIGNED_SHORT_5_5_5_1:
39 return 2;
40
41 case GL_UNSIGNED_INT_2_10_10_10_REV:
42 case GL_UNSIGNED_INT_24_8:
43 case GL_UNSIGNED_INT_10F_11F_11F_REV:
44 case GL_UNSIGNED_INT_5_9_9_9_REV:
45 return 4;
46
47 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
48 return 8;
49
50 case GL_UNSIGNED_BYTE:
51 case GL_BYTE:
52 bytesPerChannel = 1;
53 break;
54
55 case GL_UNSIGNED_SHORT:
56 case GL_SHORT:
57 case GL_HALF_FLOAT:
58 case GL_HALF_FLOAT_OES:
59 bytesPerChannel = 2;
60 break;
61
62 case GL_UNSIGNED_INT:
63 case GL_INT:
64 case GL_FLOAT:
65 bytesPerChannel = 4;
66 break;
67
68 default:
69 assert(false);
70 return 0;
71 }
72
73 switch (unpackFormat)
74 {
75 case GL_RGBA:
76 case GL_RGBA_INTEGER:
77 return bytesPerChannel * 4;
78
79 case GL_RGB:
80 case GL_RGB_INTEGER:
81 return bytesPerChannel * 3;
82
83 case GL_RG:
84 case GL_RG_INTEGER:
85 case GL_LUMINANCE_ALPHA:
86 return bytesPerChannel * 2;
87
88 case GL_RED:
89 case GL_RED_INTEGER:
90 case GL_LUMINANCE:
91 case GL_ALPHA:
92 case GL_DEPTH_COMPONENT:
93 return bytesPerChannel * 1;
94
95 default:
96 assert(false);
97 return 0;
98 }
99 }
100 };
101
102 template <const uint8_t bits>
EncodeNormUint(const float val)103 constexpr uint32_t EncodeNormUint(const float val)
104 {
105 return static_cast<uint32_t>(val * (UINT32_MAX >> (32 - bits)) + 0.5); // round-half-up
106 }
107
108 } // anonymous namespace
109
110 namespace
111 {
112
113 template <typename DestT, typename SrcT, size_t SrcN>
ZeroAndCopy(DestT & dest,const SrcT (& src)[SrcN])114 void ZeroAndCopy(DestT &dest, const SrcT (&src)[SrcN])
115 {
116 dest.fill(0);
117 memcpy(dest.data(), src, sizeof(SrcT) * SrcN);
118 }
119
EnumStr(const GLenum v)120 std::string EnumStr(const GLenum v)
121 {
122 std::stringstream ret;
123 ret << "0x" << std::hex << v;
124 return ret.str();
125 }
126
127 template <typename ColorT, typename DestT>
EncodeThenZeroAndCopy(DestT & dest,const float srcVals[4])128 void EncodeThenZeroAndCopy(DestT &dest, const float srcVals[4])
129 {
130 ColorF srcValsF(srcVals[0], srcVals[1], srcVals[2], srcVals[3]);
131
132 ColorT encoded;
133 ColorT::writeColor(&encoded, &srcValsF);
134
135 dest.fill(0);
136 memcpy(dest.data(), &encoded, sizeof(ColorT));
137 }
138 } // anonymous namespace
139
140 // Upload (1,2,5,3) to integer formats, and (1,2,5,3)/8.0 to float formats.
141 // Draw a point into a 1x1 renderbuffer and readback the result for comparison with expectations.
142 // Test all internalFormat/unpackFormat/unpackType combinations from ES3.0.
TEST_P(TextureUploadFormatTest,All)143 TEST_P(TextureUploadFormatTest, All)
144 {
145 ANGLE_SKIP_TEST_IF(IsD3D9() || IsD3D11_FL93());
146
147 constexpr char kVertShaderES2[] = R"(
148 void main()
149 {
150 gl_PointSize = 1.0;
151 gl_Position = vec4(0, 0, 0, 1);
152 })";
153 constexpr char kFragShader_Floats[] = R"(
154 precision mediump float;
155 uniform sampler2D uTex;
156
157 void main()
158 {
159 gl_FragColor = texture2D(uTex, vec2(0,0));
160 })";
161 ANGLE_GL_PROGRAM(floatsProg, kVertShaderES2, kFragShader_Floats);
162
163 glDisable(GL_DITHER);
164
165 ASSERT_GL_NO_ERROR();
166
167 // Create the 1x1 framebuffer
168
169 GLRenderbuffer backbufferRB;
170 glBindRenderbuffer(GL_RENDERBUFFER, backbufferRB);
171 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 1, 1);
172 glBindRenderbuffer(GL_RENDERBUFFER, 0);
173
174 GLFramebuffer backbufferFB;
175 glBindFramebuffer(GL_FRAMEBUFFER, backbufferFB);
176 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, backbufferRB);
177 ASSERT_GL_NO_ERROR();
178 ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
179
180 glViewport(0, 0, 1, 1);
181
182 // Create and bind our test texture
183
184 GLTexture testTex;
185 glBindTexture(GL_TEXTURE_2D, testTex);
186 // Must be nearest because some texture formats aren't filterable!
187 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
188 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
189
190 ASSERT_GL_NO_ERROR();
191
192 // Initialize our test variables
193
194 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
195 const bool hasSubrectUploads = !glGetError();
196
197 constexpr uint8_t srcIntVals[4] = {1u, 2u, 5u, 3u};
198 constexpr float srcVals[4] = {srcIntVals[0] / 8.0f, srcIntVals[1] / 8.0f, srcIntVals[2] / 8.0f,
199 srcIntVals[3] / 8.0f};
200 constexpr uint8_t refVals[4] = {static_cast<uint8_t>(EncodeNormUint<8>(srcVals[0])),
201 static_cast<uint8_t>(EncodeNormUint<8>(srcVals[1])),
202 static_cast<uint8_t>(EncodeNormUint<8>(srcVals[2])),
203 static_cast<uint8_t>(EncodeNormUint<8>(srcVals[3]))};
204
205 // Test a format with the specified data
206
207 const auto fnTestData = [&](const TexFormat &format, const void *const data, const GLColor &err,
208 const char *const info) {
209 ASSERT_GL_NO_ERROR();
210 glTexImage2D(GL_TEXTURE_2D, 0, format.internalFormat, 1, 1, 0, format.unpackFormat,
211 format.unpackType, data);
212 const auto uploadErr = glGetError();
213 if (uploadErr) // Format might not be supported. (e.g. on ES2)
214 return;
215
216 glClearColor(1, 0, 1, 1);
217 glClear(GL_COLOR_BUFFER_BIT);
218 glDrawArrays(GL_POINTS, 0, 1);
219
220 const auto actual = ReadColor(0, 0);
221
222 GLColor expected;
223 switch (format.unpackFormat)
224 {
225 case GL_RGBA:
226 case GL_RGBA_INTEGER:
227 expected = {refVals[0], refVals[1], refVals[2], refVals[3]};
228 break;
229 case GL_RGB:
230 expected = {refVals[0], refVals[1], refVals[2], 255};
231 break;
232 case GL_RG:
233 expected = {refVals[0], refVals[1], 0, 255};
234 break;
235 case GL_RED:
236 case GL_DEPTH_COMPONENT:
237 case GL_DEPTH_STENCIL:
238 expected = {refVals[0], 0, 0, 255};
239 break;
240
241 case GL_RGB_INTEGER:
242 expected = {refVals[0], refVals[1], refVals[2], refVals[0]};
243 break;
244 case GL_RG_INTEGER:
245 expected = {refVals[0], refVals[1], 0, refVals[0]};
246 break;
247 case GL_RED_INTEGER:
248 expected = {refVals[0], 0, 0, refVals[0]};
249 break;
250
251 case GL_LUMINANCE_ALPHA:
252 expected = {refVals[0], refVals[0], refVals[0], refVals[1]};
253 break;
254 case GL_LUMINANCE:
255 expected = {refVals[0], refVals[0], refVals[0], 255};
256 break;
257 case GL_ALPHA:
258 expected = {0, 0, 0, refVals[0]};
259 break;
260
261 default:
262 assert(false);
263 }
264
265 ASSERT_GL_NO_ERROR();
266 auto result = actual.ExpectNear(expected, err);
267 if (!result)
268 {
269 result << " [" << EnumStr(format.internalFormat) << "/" << EnumStr(format.unpackFormat)
270 << "/" << EnumStr(format.unpackType) << " " << info << "]";
271 }
272 EXPECT_TRUE(result);
273 };
274
275 // Provide buffers for test data, and a func to run the test on both the data directly, and on
276 // a basic subrect selection to ensure pixel byte size is calculated correctly.
277 // Possible todo here is to add tests to ensure stride calculation.
278
279 std::array<uint8_t, sizeof(float) * 4> srcBuffer;
280
281 std::array<uint8_t, srcBuffer.size() * 2> subrectBuffer;
282 const auto fnTest = [&](const TexFormat &format, const GLColor &err) {
283 fnTestData(format, srcBuffer.data(), err, "simple");
284
285 if (!hasSubrectUploads)
286 return;
287
288 const auto bytesPerPixel = format.bytesPerPixel();
289
290 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 1);
291
292 subrectBuffer.fill(0);
293 memcpy(subrectBuffer.data() + bytesPerPixel, srcBuffer.data(), bytesPerPixel);
294 fnTestData(format, subrectBuffer.data(), err, "subrect");
295
296 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
297 };
298
299 // Test All The Formats, organized by unpack format and type.
300 // (Combos from GLES 3.0.5 p111-112: Table 3.2: "Valid combinations of format, type, and sized
301 // internalformat.")
302
303 // Start with normalized ints
304 glUseProgram(floatsProg);
305
306 // RGBA+UNSIGNED_BYTE
307 {
308 constexpr uint8_t src[] = {static_cast<uint8_t>(EncodeNormUint<8>(srcVals[0])),
309 static_cast<uint8_t>(EncodeNormUint<8>(srcVals[1])),
310 static_cast<uint8_t>(EncodeNormUint<8>(srcVals[2])),
311 static_cast<uint8_t>(EncodeNormUint<8>(srcVals[3]))};
312 ZeroAndCopy(srcBuffer, src);
313
314 fnTest({GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE}, {1, 1, 1, 1});
315 fnTest({GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_BYTE}, {8, 8, 8, 255});
316 fnTest({GL_RGBA4, GL_RGBA, GL_UNSIGNED_BYTE}, {16, 16, 16, 16});
317
318 fnTest({GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE}, {1, 1, 1, 0});
319 fnTest({GL_RGB565, GL_RGB, GL_UNSIGNED_BYTE}, {8, 4, 8, 0});
320
321 fnTest({GL_RG8, GL_RG, GL_UNSIGNED_BYTE}, {1, 1, 0, 0});
322
323 fnTest({GL_R8, GL_RED, GL_UNSIGNED_BYTE}, {1, 0, 0, 0});
324
325 fnTest({GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE}, {1, 1, 1, 1});
326 fnTest({GL_RGB, GL_RGB, GL_UNSIGNED_BYTE}, {1, 1, 1, 0});
327 fnTest({GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE}, {1, 1, 1, 1});
328 fnTest({GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE}, {1, 1, 1, 0});
329 fnTest({GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE}, {0, 0, 0, 1});
330 }
331
332 // RGBA+BYTE
333 {
334 constexpr uint8_t src[] = {static_cast<uint8_t>(EncodeNormUint<7>(srcVals[0])),
335 static_cast<uint8_t>(EncodeNormUint<7>(srcVals[1])),
336 static_cast<uint8_t>(EncodeNormUint<7>(srcVals[2])),
337 static_cast<uint8_t>(EncodeNormUint<7>(srcVals[3]))};
338 ZeroAndCopy(srcBuffer, src);
339
340 fnTest({GL_RGBA8_SNORM, GL_RGBA, GL_BYTE}, {2, 2, 2, 2});
341 fnTest({GL_RGB8_SNORM, GL_RGB, GL_BYTE}, {2, 2, 2, 0});
342 fnTest({GL_RG8_SNORM, GL_RG, GL_BYTE}, {2, 2, 0, 0});
343 fnTest({GL_R8_SNORM, GL_RED, GL_BYTE}, {2, 0, 0, 0});
344 }
345
346 // RGB+UNSIGNED_SHORT_5_6_5
347 {
348 constexpr uint16_t src[] = {static_cast<uint16_t>((EncodeNormUint<5>(srcVals[0]) << 11) |
349 (EncodeNormUint<6>(srcVals[1]) << 5) |
350 (EncodeNormUint<5>(srcVals[2]) << 0))};
351 ZeroAndCopy(srcBuffer, src);
352
353 fnTest({GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5}, {8, 4, 8, 0});
354 fnTest({GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5}, {8, 4, 8, 0});
355 }
356
357 // RGBA+UNSIGNED_SHORT_4_4_4_4
358 {
359 constexpr uint16_t src[] = {static_cast<uint16_t>(
360 (EncodeNormUint<4>(srcVals[0]) << 12) | (EncodeNormUint<4>(srcVals[1]) << 8) |
361 (EncodeNormUint<4>(srcVals[2]) << 4) | (EncodeNormUint<4>(srcVals[3]) << 0))};
362 ZeroAndCopy(srcBuffer, src);
363
364 fnTest({GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4}, {16, 16, 16, 16});
365 fnTest({GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4}, {16, 16, 16, 16});
366 }
367
368 // RGBA+UNSIGNED_SHORT_5_5_5_1
369 {
370 constexpr uint16_t src[] = {static_cast<uint16_t>(
371 (EncodeNormUint<5>(srcVals[0]) << 11) | (EncodeNormUint<5>(srcVals[1]) << 6) |
372 (EncodeNormUint<5>(srcVals[2]) << 1) | (EncodeNormUint<1>(srcVals[3]) << 0))};
373 ZeroAndCopy(srcBuffer, src);
374
375 fnTest({GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1}, {8, 8, 8, 255});
376 }
377
378 // RGBA+UNSIGNED_INT_2_10_10_10_REV
379 {
380 constexpr uint32_t src[] = {
381 (EncodeNormUint<10>(srcVals[0]) << 0) | (EncodeNormUint<10>(srcVals[1]) << 10) |
382 (EncodeNormUint<10>(srcVals[2]) << 20) | (EncodeNormUint<2>(srcVals[3]) << 30)};
383 ZeroAndCopy(srcBuffer, src);
384
385 fnTest({GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV}, {1, 1, 1, 128});
386 fnTest({GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV}, {8, 8, 8, 255});
387 fnTest({GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV}, {1, 1, 1, 128});
388 }
389
390 // RGB+UNSIGNED_INT_2_10_10_10_REV
391 {
392 constexpr uint32_t src[] = {
393 (EncodeNormUint<10>(srcVals[0]) << 0) | (EncodeNormUint<10>(srcVals[1]) << 10) |
394 (EncodeNormUint<10>(srcVals[2]) << 20) | (EncodeNormUint<2>(srcVals[3]) << 30)};
395 ZeroAndCopy(srcBuffer, src);
396
397 fnTest({GL_RGB, GL_RGB, GL_UNSIGNED_INT_2_10_10_10_REV}, {1, 1, 1, 0});
398 }
399
400 // DEPTH_COMPONENT+UNSIGNED_SHORT
401 {
402 const uint16_t src[] = {static_cast<uint16_t>(EncodeNormUint<16>(srcVals[0]))};
403 ZeroAndCopy(srcBuffer, src);
404
405 fnTest({GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}, {1, 0, 0, 0});
406 }
407
408 // DEPTH_COMPONENT+UNSIGNED_INT
409 {
410 constexpr uint32_t src[] = {EncodeNormUint<32>(srcVals[0])};
411 ZeroAndCopy(srcBuffer, src);
412
413 fnTest({GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT}, {1, 0, 0, 0});
414 fnTest({GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT}, {1, 0, 0, 0});
415 }
416
417 // DEPTH_STENCIL+UNSIGNED_INT_24_8
418 {
419 // Drop stencil.
420 constexpr uint32_t src[] = {EncodeNormUint<24>(srcVals[0]) << 8};
421 ZeroAndCopy(srcBuffer, src);
422
423 fnTest({GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8}, {1, 0, 0, 0});
424 }
425
426 if (getClientMajorVersion() < 3)
427 return;
428
429 constexpr char kVertShaderES3[] = R"(#version 300 es
430 void main()
431 {
432 gl_PointSize = 1.0;
433 gl_Position = vec4(0, 0, 0, 1);
434 })";
435 constexpr char kFragShader_Ints[] = R"(#version 300 es
436 precision mediump float;
437 uniform highp isampler2D uTex;
438 out vec4 oFragColor;
439
440 void main()
441 {
442 oFragColor = vec4(texture(uTex, vec2(0,0))) / 8.0;
443 })";
444 constexpr char kFragShader_Uints[] = R"(#version 300 es
445 precision mediump float;
446 uniform highp usampler2D uTex;
447 out vec4 oFragColor;
448
449 void main()
450 {
451 oFragColor = vec4(texture(uTex, vec2(0,0))) / 8.0;
452 })";
453 ANGLE_GL_PROGRAM(intsProg, kVertShaderES3, kFragShader_Ints);
454 ANGLE_GL_PROGRAM(uintsProg, kVertShaderES3, kFragShader_Uints);
455
456 // Non-normalized ints
457 glUseProgram(intsProg);
458
459 // RGBA_INTEGER+UNSIGNED_BYTE
460 {
461 constexpr uint8_t src[4] = {srcIntVals[0], srcIntVals[1], srcIntVals[2], srcIntVals[3]};
462 ZeroAndCopy(srcBuffer, src);
463
464 fnTest({GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE}, {1, 1, 1, 1});
465 fnTest({GL_RGB8I, GL_RGB_INTEGER, GL_BYTE}, {1, 1, 1, 1});
466 fnTest({GL_RG8I, GL_RG_INTEGER, GL_BYTE}, {1, 1, 1, 1});
467 fnTest({GL_R8I, GL_RED_INTEGER, GL_BYTE}, {1, 1, 1, 1});
468 }
469
470 // RGBA_INTEGER+UNSIGNED_SHORT
471 {
472 constexpr uint16_t src[4] = {srcIntVals[0], srcIntVals[1], srcIntVals[2], srcIntVals[3]};
473 ZeroAndCopy(srcBuffer, src);
474
475 fnTest({GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT}, {1, 1, 1, 1});
476 fnTest({GL_RGB16I, GL_RGB_INTEGER, GL_SHORT}, {1, 1, 1, 1});
477 fnTest({GL_RG16I, GL_RG_INTEGER, GL_SHORT}, {1, 1, 1, 1});
478 fnTest({GL_R16I, GL_RED_INTEGER, GL_SHORT}, {1, 1, 1, 1});
479 }
480
481 // RGBA_INTEGER+UNSIGNED_INT
482 {
483 constexpr uint32_t src[4] = {srcIntVals[0], srcIntVals[1], srcIntVals[2], srcIntVals[3]};
484 ZeroAndCopy(srcBuffer, src);
485
486 fnTest({GL_RGBA32I, GL_RGBA_INTEGER, GL_INT}, {1, 1, 1, 1});
487 fnTest({GL_RGB32I, GL_RGB_INTEGER, GL_INT}, {1, 1, 1, 1});
488 fnTest({GL_RG32I, GL_RG_INTEGER, GL_INT}, {1, 1, 1, 1});
489 fnTest({GL_R32I, GL_RED_INTEGER, GL_INT}, {1, 1, 1, 1});
490 }
491
492 // Non-normalized uints
493 glUseProgram(uintsProg);
494
495 // RGBA_INTEGER+UNSIGNED_BYTE
496 {
497 constexpr uint8_t src[4] = {srcIntVals[0], srcIntVals[1], srcIntVals[2], srcIntVals[3]};
498 ZeroAndCopy(srcBuffer, src);
499
500 fnTest({GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE}, {1, 1, 1, 1});
501 fnTest({GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE}, {1, 1, 1, 1});
502 fnTest({GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE}, {1, 1, 1, 1});
503 fnTest({GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE}, {1, 1, 1, 1});
504 }
505
506 // RGBA_INTEGER+UNSIGNED_SHORT
507 {
508 constexpr uint16_t src[4] = {srcIntVals[0], srcIntVals[1], srcIntVals[2], srcIntVals[3]};
509 ZeroAndCopy(srcBuffer, src);
510
511 fnTest({GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT}, {1, 1, 1, 1});
512 fnTest({GL_RGB16UI, GL_RGB_INTEGER, GL_UNSIGNED_SHORT}, {1, 1, 1, 1});
513 fnTest({GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT}, {1, 1, 1, 1});
514 fnTest({GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT}, {1, 1, 1, 1});
515 }
516
517 // RGBA_INTEGER+UNSIGNED_INT
518 {
519 constexpr uint32_t src[4] = {srcIntVals[0], srcIntVals[1], srcIntVals[2], srcIntVals[3]};
520 ZeroAndCopy(srcBuffer, src);
521
522 fnTest({GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT}, {1, 1, 1, 1});
523 fnTest({GL_RGB32UI, GL_RGB_INTEGER, GL_UNSIGNED_INT}, {1, 1, 1, 1});
524 fnTest({GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT}, {1, 1, 1, 1});
525 fnTest({GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT}, {1, 1, 1, 1});
526 }
527
528 // RGBA_INTEGER+UNSIGNED_INT_2_10_10_10_REV
529 {
530 constexpr uint32_t src[] = {static_cast<uint32_t>(srcIntVals[0] << 0) |
531 static_cast<uint32_t>(srcIntVals[1] << 10) |
532 static_cast<uint32_t>(srcIntVals[2] << 20) |
533 static_cast<uint32_t>(srcIntVals[3] << 30)};
534 ZeroAndCopy(srcBuffer, src);
535
536 fnTest({GL_RGB10_A2UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV}, {1, 1, 1, 1});
537 }
538
539 // True floats
540 glUseProgram(floatsProg);
541
542 // RGBA+HALF_FLOAT
543 {
544 EncodeThenZeroAndCopy<R16G16B16A16F>(srcBuffer, srcVals);
545
546 fnTest({GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT}, {1, 1, 1, 1});
547
548 fnTest({GL_RGB16F, GL_RGB, GL_HALF_FLOAT}, {1, 1, 1, 0});
549 fnTest({GL_R11F_G11F_B10F, GL_RGB, GL_HALF_FLOAT}, {1, 1, 1, 0});
550 fnTest({GL_RGB9_E5, GL_RGB, GL_HALF_FLOAT}, {1, 1, 1, 0});
551
552 fnTest({GL_RG16F, GL_RG, GL_HALF_FLOAT}, {1, 1, 0, 0});
553
554 fnTest({GL_R16F, GL_RED, GL_HALF_FLOAT}, {1, 0, 0, 0});
555
556 fnTest({GL_RGBA, GL_RGBA, GL_HALF_FLOAT_OES}, {1, 1, 1, 1});
557 fnTest({GL_RGB, GL_RGB, GL_HALF_FLOAT_OES}, {1, 1, 1, 0});
558 fnTest({GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES}, {1, 1, 1, 1});
559 fnTest({GL_LUMINANCE, GL_LUMINANCE, GL_HALF_FLOAT_OES}, {1, 1, 1, 0});
560 fnTest({GL_ALPHA, GL_ALPHA, GL_HALF_FLOAT_OES}, {0, 0, 0, 1});
561 }
562
563 // RGBA+FLOAT
564 {
565 ZeroAndCopy(srcBuffer, srcVals);
566
567 fnTest({GL_RGBA32F, GL_RGBA, GL_FLOAT}, {1, 1, 1, 1});
568 fnTest({GL_RGBA16F, GL_RGBA, GL_FLOAT}, {1, 1, 1, 1});
569
570 fnTest({GL_RGB32F, GL_RGB, GL_FLOAT}, {1, 1, 1, 0});
571 fnTest({GL_RGB16F, GL_RGB, GL_FLOAT}, {1, 1, 1, 0});
572 fnTest({GL_R11F_G11F_B10F, GL_RGB, GL_FLOAT}, {1, 1, 1, 0});
573 fnTest({GL_RGB9_E5, GL_RGB, GL_FLOAT}, {1, 1, 1, 0});
574
575 fnTest({GL_RG32F, GL_RG, GL_FLOAT}, {1, 1, 0, 0});
576 fnTest({GL_RG16F, GL_RG, GL_FLOAT}, {1, 1, 0, 0});
577
578 fnTest({GL_R32F, GL_RED, GL_FLOAT}, {1, 0, 0, 0});
579 fnTest({GL_R16F, GL_RED, GL_FLOAT}, {1, 0, 0, 0});
580 }
581
582 // UNSIGNED_INT_10F_11F_11F_REV
583 {
584 EncodeThenZeroAndCopy<R11G11B10F>(srcBuffer, srcVals);
585
586 fnTest({GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV}, {1, 1, 1, 0});
587 }
588
589 // UNSIGNED_INT_5_9_9_9_REV
590 {
591 EncodeThenZeroAndCopy<R9G9B9E5>(srcBuffer, srcVals);
592
593 fnTest({GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV}, {1, 1, 1, 0});
594 }
595
596 // DEPTH_COMPONENT+FLOAT
597 {
598 // Skip stencil.
599 constexpr float src[] = {srcVals[0], 0};
600 ZeroAndCopy(srcBuffer, src);
601
602 fnTest({GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT}, {1, 0, 0, 0});
603 fnTest({GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV},
604 {1, 0, 0, 0});
605 }
606
607 EXPECT_GL_NO_ERROR();
608 }
609
610 ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(TextureUploadFormatTest);
611