1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL (ES) Module
3 * -----------------------------------------------
4 *
5 * Copyright 2015 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Texture State Query tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "glsTextureStateQueryTests.hpp"
25 #include "gluStrUtil.hpp"
26 #include "gluObjectWrapper.hpp"
27 #include "gluCallLogWrapper.hpp"
28 #include "gluContextInfo.hpp"
29 #include "gluTextureUtil.hpp"
30 #include "glwEnums.hpp"
31 #include "deUniquePtr.hpp"
32 #include "deRandom.hpp"
33 #include "deStringUtil.hpp"
34
35 namespace deqp
36 {
37 namespace gls
38 {
39 namespace TextureStateQueryTests
40 {
41 namespace
42 {
43
44 using namespace glw;
45 using namespace gls::StateQueryUtil;
46
mapTesterToPname(TesterType tester)47 static glw::GLenum mapTesterToPname (TesterType tester)
48 {
49
50 #define CASE_ALL_SETTERS(X) case X: case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
51
52 switch (tester)
53 {
54 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R): return GL_TEXTURE_SWIZZLE_R;
55 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G): return GL_TEXTURE_SWIZZLE_G;
56 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B): return GL_TEXTURE_SWIZZLE_B;
57 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A): return GL_TEXTURE_SWIZZLE_A;
58
59 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S):
60 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER: return GL_TEXTURE_WRAP_S;
61
62 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T):
63 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER: return GL_TEXTURE_WRAP_T;
64
65 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R):
66 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER: return GL_TEXTURE_WRAP_R;
67
68 CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER): return GL_TEXTURE_MAG_FILTER;
69 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER): return GL_TEXTURE_MIN_FILTER;
70 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD): return GL_TEXTURE_MIN_LOD;
71 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD): return GL_TEXTURE_MAX_LOD;
72 CASE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL): return GL_TEXTURE_BASE_LEVEL;
73 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL): return GL_TEXTURE_MAX_LEVEL;
74 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE): return GL_TEXTURE_COMPARE_MODE;
75 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC): return GL_TEXTURE_COMPARE_FUNC;
76 case TESTER_TEXTURE_IMMUTABLE_LEVELS: return GL_TEXTURE_IMMUTABLE_LEVELS;
77 case TESTER_TEXTURE_IMMUTABLE_FORMAT: return GL_TEXTURE_IMMUTABLE_FORMAT;
78 CASE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE): return GL_DEPTH_STENCIL_TEXTURE_MODE;
79 CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT): return GL_TEXTURE_SRGB_DECODE_EXT;
80 case TESTER_TEXTURE_BORDER_COLOR: return GL_TEXTURE_BORDER_COLOR;
81
82 default:
83 DE_ASSERT(false);
84 return -1;
85 }
86
87 #undef CASE_PURE_SETTERS
88 }
89
querySupportsSigned(QueryType type)90 static bool querySupportsSigned (QueryType type)
91 {
92 return type != QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER &&
93 type != QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER;
94 }
95
isPureIntTester(TesterType tester)96 static bool isPureIntTester (TesterType tester)
97 {
98 #define HANDLE_ALL_SETTERS(X) \
99 case X: \
100 case X ## _SET_PURE_UINT: return false; \
101 case X ## _SET_PURE_INT: return true;
102
103 switch (tester)
104 {
105 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
106 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
107 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B)
108 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A)
109 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S)
110 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T)
111 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R)
112 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER)
113 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER)
114 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD)
115 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD)
116 HANDLE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL)
117 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL)
118 HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE)
119 HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC)
120 HANDLE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE)
121 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT)
122
123 case TESTER_TEXTURE_IMMUTABLE_LEVELS:
124 case TESTER_TEXTURE_IMMUTABLE_FORMAT:
125 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
126 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
127 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
128 case TESTER_TEXTURE_BORDER_COLOR:
129 return false;
130
131 default:
132 DE_ASSERT(false);
133 return false;
134 }
135
136 #undef HANDLE_ALL_SETTERS
137 }
138
isPureUintTester(TesterType tester)139 static bool isPureUintTester (TesterType tester)
140 {
141 #define HANDLE_ALL_SETTERS(X) \
142 case X: \
143 case X ## _SET_PURE_INT: return false; \
144 case X ## _SET_PURE_UINT: return true;
145
146 switch (tester)
147 {
148 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
149 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
150 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B)
151 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A)
152 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S)
153 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T)
154 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R)
155 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER)
156 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER)
157 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD)
158 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD)
159 HANDLE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL)
160 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL)
161 HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE)
162 HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC)
163 HANDLE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE)
164 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT)
165
166 case TESTER_TEXTURE_IMMUTABLE_LEVELS:
167 case TESTER_TEXTURE_IMMUTABLE_FORMAT:
168 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
169 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
170 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
171 case TESTER_TEXTURE_BORDER_COLOR:
172 return false;
173
174 default:
175 DE_ASSERT(false);
176 return false;
177 }
178
179 #undef HANDLE_ALL_SETTERS
180 }
181
182 class RequiredExtensions
183 {
184 public:
RequiredExtensions(void)185 RequiredExtensions (void) { }
RequiredExtensions(const char * ext)186 explicit RequiredExtensions (const char* ext) { add(ext); }
RequiredExtensions(const char * extA,const char * extB)187 RequiredExtensions (const char* extA, const char* extB) { add(extA); add(extB); }
188
189 void add (const char* ext);
190 void add (const RequiredExtensions& other);
191 void check (const glu::ContextInfo&) const;
192
193 private:
194 std::vector<const char*> m_extensions;
195 };
196
add(const char * ext)197 void RequiredExtensions::add (const char* ext)
198 {
199 for (int ndx = 0; ndx < (int)m_extensions.size(); ++ndx)
200 if (deStringEqual(m_extensions[ndx], ext) == DE_TRUE)
201 return;
202 m_extensions.push_back(ext);
203 }
204
add(const RequiredExtensions & other)205 void RequiredExtensions::add (const RequiredExtensions& other)
206 {
207 for (int ndx = 0; ndx < (int)other.m_extensions.size(); ++ndx)
208 add(other.m_extensions[ndx]);
209 }
210
check(const glu::ContextInfo & ctxInfo) const211 void RequiredExtensions::check (const glu::ContextInfo& ctxInfo) const
212 {
213 std::vector<const char*> failedExtensions;
214
215 for (int ndx = 0; ndx < (int)m_extensions.size(); ++ndx)
216 if (!ctxInfo.isExtensionSupported(m_extensions[ndx]))
217 failedExtensions.push_back(m_extensions[ndx]);
218
219 if (!failedExtensions.empty())
220 {
221 std::ostringstream buf;
222 buf << "Test requires extension: ";
223
224 for (int ndx = 0; ndx < (int)failedExtensions.size(); ++ndx)
225 {
226 if (ndx)
227 buf << ", ";
228 buf << failedExtensions[ndx];
229 }
230
231 throw tcu::NotSupportedError(buf.str());
232 }
233 }
234
235 namespace es30
236 {
237
isCoreTextureTarget(glw::GLenum target)238 static bool isCoreTextureTarget (glw::GLenum target)
239 {
240 return target == GL_TEXTURE_2D ||
241 target == GL_TEXTURE_3D ||
242 target == GL_TEXTURE_2D_ARRAY ||
243 target == GL_TEXTURE_CUBE_MAP;
244 }
245
getTextureTargetExtension(glw::GLenum target)246 static RequiredExtensions getTextureTargetExtension (glw::GLenum target)
247 {
248 DE_UNREF(target);
249 DE_ASSERT(false);
250 return RequiredExtensions();
251 }
252
isCoreTextureParam(glw::GLenum pname)253 static bool isCoreTextureParam (glw::GLenum pname)
254 {
255 return pname == GL_TEXTURE_BASE_LEVEL ||
256 pname == GL_TEXTURE_COMPARE_MODE ||
257 pname == GL_TEXTURE_COMPARE_FUNC ||
258 pname == GL_TEXTURE_MAG_FILTER ||
259 pname == GL_TEXTURE_MAX_LEVEL ||
260 pname == GL_TEXTURE_MAX_LOD ||
261 pname == GL_TEXTURE_MIN_FILTER ||
262 pname == GL_TEXTURE_MIN_LOD ||
263 pname == GL_TEXTURE_SWIZZLE_R ||
264 pname == GL_TEXTURE_SWIZZLE_G ||
265 pname == GL_TEXTURE_SWIZZLE_B ||
266 pname == GL_TEXTURE_SWIZZLE_A ||
267 pname == GL_TEXTURE_WRAP_S ||
268 pname == GL_TEXTURE_WRAP_T ||
269 pname == GL_TEXTURE_WRAP_R ||
270 pname == GL_TEXTURE_IMMUTABLE_FORMAT ||
271 pname == GL_TEXTURE_IMMUTABLE_LEVELS;
272 }
273
getTextureParamExtension(glw::GLenum pname)274 static RequiredExtensions getTextureParamExtension (glw::GLenum pname)
275 {
276 DE_UNREF(pname);
277 DE_ASSERT(false);
278 return RequiredExtensions();
279 }
280
isCoreQuery(QueryType query)281 static bool isCoreQuery (QueryType query)
282 {
283 return query == QUERY_TEXTURE_PARAM_INTEGER ||
284 query == QUERY_TEXTURE_PARAM_FLOAT ||
285 query == QUERY_TEXTURE_PARAM_INTEGER_VEC4 ||
286 query == QUERY_TEXTURE_PARAM_FLOAT_VEC4 ||
287 query == QUERY_SAMPLER_PARAM_INTEGER ||
288 query == QUERY_SAMPLER_PARAM_FLOAT ||
289 query == QUERY_SAMPLER_PARAM_INTEGER_VEC4 ||
290 query == QUERY_SAMPLER_PARAM_FLOAT_VEC4;
291 }
292
getQueryExtension(QueryType query)293 static RequiredExtensions getQueryExtension (QueryType query)
294 {
295 DE_UNREF(query);
296 DE_ASSERT(false);
297 return RequiredExtensions();
298 }
299
isCoreTester(TesterType tester)300 static bool isCoreTester (TesterType tester)
301 {
302 return tester == TESTER_TEXTURE_SWIZZLE_R ||
303 tester == TESTER_TEXTURE_SWIZZLE_G ||
304 tester == TESTER_TEXTURE_SWIZZLE_B ||
305 tester == TESTER_TEXTURE_SWIZZLE_A ||
306 tester == TESTER_TEXTURE_WRAP_S ||
307 tester == TESTER_TEXTURE_WRAP_T ||
308 tester == TESTER_TEXTURE_WRAP_R ||
309 tester == TESTER_TEXTURE_MAG_FILTER ||
310 tester == TESTER_TEXTURE_MIN_FILTER ||
311 tester == TESTER_TEXTURE_MIN_LOD ||
312 tester == TESTER_TEXTURE_MAX_LOD ||
313 tester == TESTER_TEXTURE_BASE_LEVEL ||
314 tester == TESTER_TEXTURE_MAX_LEVEL ||
315 tester == TESTER_TEXTURE_COMPARE_MODE ||
316 tester == TESTER_TEXTURE_COMPARE_FUNC ||
317 tester == TESTER_TEXTURE_IMMUTABLE_LEVELS ||
318 tester == TESTER_TEXTURE_IMMUTABLE_FORMAT;
319 }
320
getTesterExtension(TesterType tester)321 static RequiredExtensions getTesterExtension (TesterType tester)
322 {
323 DE_UNREF(tester);
324 DE_ASSERT(false);
325 return RequiredExtensions();
326 }
327
328 } // es30
329
330 namespace es31
331 {
332
isCoreTextureTarget(glw::GLenum target)333 static bool isCoreTextureTarget (glw::GLenum target)
334 {
335 return es30::isCoreTextureTarget(target) ||
336 target == GL_TEXTURE_2D_MULTISAMPLE;
337 }
338
getTextureTargetExtension(glw::GLenum target)339 static RequiredExtensions getTextureTargetExtension (glw::GLenum target)
340 {
341 switch (target)
342 {
343 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY: return RequiredExtensions("GL_OES_texture_storage_multisample_2d_array");
344 case GL_TEXTURE_BUFFER: return RequiredExtensions("GL_EXT_texture_buffer");
345 case GL_TEXTURE_CUBE_MAP_ARRAY: return RequiredExtensions("GL_EXT_texture_cube_map_array");
346 default:
347 DE_ASSERT(false);
348 return RequiredExtensions();
349 }
350 }
351
isCoreTextureParam(glw::GLenum pname)352 static bool isCoreTextureParam (glw::GLenum pname)
353 {
354 return es30::isCoreTextureParam(pname) ||
355 pname == GL_DEPTH_STENCIL_TEXTURE_MODE;
356 }
357
getTextureParamExtension(glw::GLenum pname)358 static RequiredExtensions getTextureParamExtension (glw::GLenum pname)
359 {
360 switch (pname)
361 {
362 case GL_TEXTURE_SRGB_DECODE_EXT: return RequiredExtensions("GL_EXT_texture_sRGB_decode");
363 case GL_TEXTURE_BORDER_COLOR: return RequiredExtensions("GL_EXT_texture_border_clamp");
364 default:
365 DE_ASSERT(false);
366 return RequiredExtensions();
367 }
368 }
369
isCoreQuery(QueryType query)370 static bool isCoreQuery (QueryType query)
371 {
372 return es30::isCoreQuery(query);
373 }
374
getQueryExtension(QueryType query)375 static RequiredExtensions getQueryExtension (QueryType query)
376 {
377 switch (query)
378 {
379 case QUERY_TEXTURE_PARAM_PURE_INTEGER:
380 case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER:
381 case QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4:
382 case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4:
383 case QUERY_SAMPLER_PARAM_PURE_INTEGER:
384 case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER:
385 case QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4:
386 case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4:
387 return RequiredExtensions("GL_EXT_texture_border_clamp");
388
389 default:
390 DE_ASSERT(false);
391 return RequiredExtensions();
392 }
393 }
394
isCoreTester(TesterType tester)395 static bool isCoreTester (TesterType tester)
396 {
397 return es30::isCoreTester(tester) ||
398 tester == TESTER_DEPTH_STENCIL_TEXTURE_MODE;
399 }
400
getTesterExtension(TesterType tester)401 static RequiredExtensions getTesterExtension (TesterType tester)
402 {
403 #define CASE_PURE_SETTERS(X) case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
404
405 switch (tester)
406 {
407 CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_R):
408 CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_G):
409 CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_B):
410 CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_A):
411 CASE_PURE_SETTERS(TESTER_TEXTURE_WRAP_S):
412 CASE_PURE_SETTERS(TESTER_TEXTURE_WRAP_T):
413 CASE_PURE_SETTERS(TESTER_TEXTURE_WRAP_R):
414 CASE_PURE_SETTERS(TESTER_TEXTURE_MAG_FILTER):
415 CASE_PURE_SETTERS(TESTER_TEXTURE_MIN_FILTER):
416 CASE_PURE_SETTERS(TESTER_TEXTURE_MIN_LOD):
417 CASE_PURE_SETTERS(TESTER_TEXTURE_MAX_LOD):
418 CASE_PURE_SETTERS(TESTER_TEXTURE_BASE_LEVEL):
419 CASE_PURE_SETTERS(TESTER_TEXTURE_MAX_LEVEL):
420 CASE_PURE_SETTERS(TESTER_TEXTURE_COMPARE_MODE):
421 CASE_PURE_SETTERS(TESTER_TEXTURE_COMPARE_FUNC):
422 CASE_PURE_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE):
423 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
424 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
425 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
426 case TESTER_TEXTURE_BORDER_COLOR:
427 return RequiredExtensions("GL_EXT_texture_border_clamp");
428
429 case TESTER_TEXTURE_SRGB_DECODE_EXT:
430 return RequiredExtensions("GL_EXT_texture_sRGB_decode");
431
432 CASE_PURE_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):
433 return RequiredExtensions("GL_EXT_texture_sRGB_decode", "GL_EXT_texture_border_clamp");
434
435 default:
436 DE_ASSERT(false);
437 return RequiredExtensions();
438 }
439
440 #undef CASE_PURE_SETTERS
441 }
442
443 } // es31
444
445 namespace es32
446 {
447
isCoreTextureTarget(glw::GLenum target)448 static bool isCoreTextureTarget (glw::GLenum target)
449 {
450 return es31::isCoreTextureTarget(target) ||
451 target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY ||
452 target == GL_TEXTURE_BUFFER ||
453 target == GL_TEXTURE_CUBE_MAP_ARRAY;
454 }
455
getTextureTargetExtension(glw::GLenum target)456 static RequiredExtensions getTextureTargetExtension (glw::GLenum target)
457 {
458 DE_UNREF(target);
459 DE_ASSERT(false);
460 return RequiredExtensions();
461 }
462
isCoreTextureParam(glw::GLenum pname)463 static bool isCoreTextureParam (glw::GLenum pname)
464 {
465 return es31::isCoreTextureParam(pname) ||
466 pname == GL_TEXTURE_BORDER_COLOR;
467 }
468
getTextureParamExtension(glw::GLenum pname)469 static RequiredExtensions getTextureParamExtension (glw::GLenum pname)
470 {
471 switch (pname)
472 {
473 case GL_TEXTURE_SRGB_DECODE_EXT: return RequiredExtensions("GL_EXT_texture_sRGB_decode");
474 default:
475 DE_ASSERT(false);
476 return RequiredExtensions();
477 }
478 }
479
isCoreQuery(QueryType query)480 static bool isCoreQuery (QueryType query)
481 {
482 return es31::isCoreQuery(query) ||
483 query == QUERY_TEXTURE_PARAM_PURE_INTEGER ||
484 query == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER ||
485 query == QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4 ||
486 query == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4 ||
487 query == QUERY_SAMPLER_PARAM_PURE_INTEGER ||
488 query == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER ||
489 query == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4 ||
490 query == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4;
491 }
492
getQueryExtension(QueryType query)493 static RequiredExtensions getQueryExtension (QueryType query)
494 {
495 DE_UNREF(query);
496 DE_ASSERT(false);
497 return RequiredExtensions();
498 }
499
isCoreTester(TesterType tester)500 static bool isCoreTester (TesterType tester)
501 {
502 #define COMPARE_PURE_SETTERS(TESTER, X) ((TESTER) == X ## _SET_PURE_INT) || ((TESTER) == X ## _SET_PURE_UINT)
503
504 return es31::isCoreTester(tester) ||
505 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_SWIZZLE_R) ||
506 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_SWIZZLE_G) ||
507 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_SWIZZLE_B) ||
508 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_SWIZZLE_A) ||
509 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_WRAP_S) ||
510 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_WRAP_T) ||
511 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_WRAP_R) ||
512 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MAG_FILTER) ||
513 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MIN_FILTER) ||
514 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MIN_LOD) ||
515 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MAX_LOD) ||
516 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_BASE_LEVEL) ||
517 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MAX_LEVEL) ||
518 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_COMPARE_MODE) ||
519 COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_COMPARE_FUNC) ||
520 COMPARE_PURE_SETTERS(tester, TESTER_DEPTH_STENCIL_TEXTURE_MODE) ||
521 tester == TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER ||
522 tester == TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER ||
523 tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER ||
524 tester == TESTER_TEXTURE_BORDER_COLOR;
525
526 #undef COMPARE_PURE_SETTERS
527 }
528
getTesterExtension(TesterType tester)529 static RequiredExtensions getTesterExtension (TesterType tester)
530 {
531 #define CASE_PURE_SETTERS(X) case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
532
533 switch (tester)
534 {
535 CASE_PURE_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):
536 case TESTER_TEXTURE_SRGB_DECODE_EXT:
537 return RequiredExtensions("GL_EXT_texture_sRGB_decode");
538
539 default:
540 DE_ASSERT(false);
541 return RequiredExtensions();
542 }
543
544 #undef CASE_PURE_SETTERS
545 }
546
547 } // es32
548
549 namespace gl45
550 {
551
isCoreTextureTarget(glw::GLenum target)552 static bool isCoreTextureTarget (glw::GLenum target)
553 {
554 return es31::isCoreTextureTarget(target);
555 }
556
getTextureTargetExtension(glw::GLenum target)557 static RequiredExtensions getTextureTargetExtension (glw::GLenum target)
558 {
559 DE_UNREF(target);
560 return RequiredExtensions();
561 }
562
isCoreTextureParam(glw::GLenum pname)563 static bool isCoreTextureParam (glw::GLenum pname)
564 {
565 return es31::isCoreTextureParam(pname);
566 }
567
getTextureParamExtension(glw::GLenum pname)568 static RequiredExtensions getTextureParamExtension (glw::GLenum pname)
569 {
570 DE_UNREF(pname);
571 return RequiredExtensions();
572 }
573
isCoreQuery(QueryType query)574 static bool isCoreQuery (QueryType query)
575 {
576 return es31::isCoreQuery(query);
577 }
578
getQueryExtension(QueryType query)579 static RequiredExtensions getQueryExtension (QueryType query)
580 {
581 DE_UNREF(query);
582 return RequiredExtensions();
583 }
584
isCoreTester(TesterType tester)585 static bool isCoreTester (TesterType tester)
586 {
587 return es31::isCoreTester(tester);
588 }
589
getTesterExtension(TesterType tester)590 static RequiredExtensions getTesterExtension (TesterType tester)
591 {
592 DE_UNREF(tester);
593 return RequiredExtensions();
594 }
595
596 } // gl45
597
isCoreTextureTarget(const glu::ContextType & contextType,glw::GLenum target)598 static bool isCoreTextureTarget (const glu::ContextType& contextType, glw::GLenum target)
599 {
600 if (contextSupports(contextType, glu::ApiType::core(4,5)))
601 return gl45::isCoreTextureTarget(target);
602 else if (contextSupports(contextType, glu::ApiType::es(3,2)))
603 return es32::isCoreTextureTarget(target);
604 else if (contextSupports(contextType, glu::ApiType::es(3,1)))
605 return es31::isCoreTextureTarget(target);
606 else if (contextSupports(contextType, glu::ApiType::es(3,0)))
607 return es30::isCoreTextureTarget(target);
608 else
609 {
610 DE_ASSERT(false);
611 return DE_NULL;
612 }
613 }
614
isCoreTextureParam(const glu::ContextType & contextType,glw::GLenum pname)615 static bool isCoreTextureParam (const glu::ContextType& contextType, glw::GLenum pname)
616 {
617 if (contextSupports(contextType, glu::ApiType::core(4,5)))
618 return gl45::isCoreTextureParam(pname);
619 else if (contextSupports(contextType, glu::ApiType::es(3,2)))
620 return es32::isCoreTextureParam(pname);
621 else if (contextSupports(contextType, glu::ApiType::es(3,1)))
622 return es31::isCoreTextureParam(pname);
623 else if (contextSupports(contextType, glu::ApiType::es(3,0)))
624 return es30::isCoreTextureParam(pname);
625 else
626 {
627 DE_ASSERT(false);
628 return DE_NULL;
629 }
630 }
631
isCoreQuery(const glu::ContextType & contextType,QueryType query)632 static bool isCoreQuery (const glu::ContextType& contextType, QueryType query)
633 {
634 if (contextSupports(contextType, glu::ApiType::core(4,5)))
635 return gl45::isCoreQuery(query);
636 else if (contextSupports(contextType, glu::ApiType::es(3,2)))
637 return es32::isCoreQuery(query);
638 else if (contextSupports(contextType, glu::ApiType::es(3,1)))
639 return es31::isCoreQuery(query);
640 else if (contextSupports(contextType, glu::ApiType::es(3,0)))
641 return es30::isCoreQuery(query);
642 else
643 {
644 DE_ASSERT(false);
645 return DE_NULL;
646 }
647 }
648
isCoreTester(const glu::ContextType & contextType,TesterType tester)649 static bool isCoreTester (const glu::ContextType& contextType, TesterType tester)
650 {
651 if (contextSupports(contextType, glu::ApiType::core(4,5)))
652 return gl45::isCoreTester(tester);
653 else if (contextSupports(contextType, glu::ApiType::es(3,2)))
654 return es32::isCoreTester(tester);
655 else if (contextSupports(contextType, glu::ApiType::es(3,1)))
656 return es31::isCoreTester(tester);
657 else if (contextSupports(contextType, glu::ApiType::es(3,0)))
658 return es30::isCoreTester(tester);
659 else
660 {
661 DE_ASSERT(false);
662 return DE_NULL;
663 }
664 }
665
getTextureTargetExtension(const glu::ContextType & contextType,glw::GLenum target)666 static RequiredExtensions getTextureTargetExtension (const glu::ContextType& contextType, glw::GLenum target)
667 {
668 DE_ASSERT(!isCoreTextureTarget(contextType, target));
669
670 if (contextSupports(contextType, glu::ApiType::core(4,5)))
671 return gl45::getTextureTargetExtension(target);
672 else if (contextSupports(contextType, glu::ApiType::es(3,2)))
673 return es32::getTextureTargetExtension(target);
674 else if (contextSupports(contextType, glu::ApiType::es(3,1)))
675 return es31::getTextureTargetExtension(target);
676 else if (contextSupports(contextType, glu::ApiType::es(3,0)))
677 return es30::getTextureTargetExtension(target);
678 else
679 {
680 DE_ASSERT(false);
681 return RequiredExtensions();
682 }
683 }
684
getTextureParamExtension(const glu::ContextType & contextType,glw::GLenum pname)685 static RequiredExtensions getTextureParamExtension (const glu::ContextType& contextType, glw::GLenum pname)
686 {
687 DE_ASSERT(!isCoreTextureParam(contextType, pname));
688
689 if (contextSupports(contextType, glu::ApiType::core(4,5)))
690 return gl45::getTextureParamExtension(pname);
691 else if (contextSupports(contextType, glu::ApiType::es(3,2)))
692 return es32::getTextureParamExtension(pname);
693 else if (contextSupports(contextType, glu::ApiType::es(3,1)))
694 return es31::getTextureParamExtension(pname);
695 else if (contextSupports(contextType, glu::ApiType::es(3,0)))
696 return es30::getTextureParamExtension(pname);
697 else
698 {
699 DE_ASSERT(false);
700 return RequiredExtensions();
701 }
702 }
703
getQueryExtension(const glu::ContextType & contextType,QueryType query)704 static RequiredExtensions getQueryExtension (const glu::ContextType& contextType, QueryType query)
705 {
706 DE_ASSERT(!isCoreQuery(contextType, query));
707
708 if (contextSupports(contextType, glu::ApiType::core(4,5)))
709 return gl45::getQueryExtension(query);
710 else if (contextSupports(contextType, glu::ApiType::es(3,2)))
711 return es32::getQueryExtension(query);
712 else if (contextSupports(contextType, glu::ApiType::es(3,1)))
713 return es31::getQueryExtension(query);
714 else if (contextSupports(contextType, glu::ApiType::es(3,0)))
715 return es30::getQueryExtension(query);
716 else
717 {
718 DE_ASSERT(false);
719 return RequiredExtensions();
720 }
721 }
722
getTesterExtension(const glu::ContextType & contextType,TesterType tester)723 static RequiredExtensions getTesterExtension (const glu::ContextType& contextType, TesterType tester)
724 {
725 DE_ASSERT(!isCoreTester(contextType, tester));
726
727 if (contextSupports(contextType, glu::ApiType::core(4,5)))
728 return gl45::getTesterExtension(tester);
729 else if (contextSupports(contextType, glu::ApiType::es(3,2)))
730 return es32::getTesterExtension(tester);
731 else if (contextSupports(contextType, glu::ApiType::es(3,1)))
732 return es31::getTesterExtension(tester);
733 else if (contextSupports(contextType, glu::ApiType::es(3,0)))
734 return es30::getTesterExtension(tester);
735 else
736 {
737 DE_ASSERT(false);
738 return RequiredExtensions();
739 }
740 }
741
742 class TextureTest : public tcu::TestCase
743 {
744 public:
745 TextureTest (tcu::TestContext& testCtx,
746 const glu::RenderContext& renderCtx,
747 const char* name,
748 const char* desc,
749 glw::GLenum target,
750 TesterType tester,
751 QueryType type);
752
753 void init (void);
754 IterateResult iterate (void);
755
756 virtual void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const = 0;
757
758 protected:
759 const glu::RenderContext& m_renderCtx;
760 const glw::GLenum m_target;
761 const glw::GLenum m_pname;
762 const TesterType m_tester;
763 const QueryType m_type;
764 };
765
TextureTest(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)766 TextureTest::TextureTest (tcu::TestContext& testCtx,
767 const glu::RenderContext& renderCtx,
768 const char* name,
769 const char* desc,
770 glw::GLenum target,
771 TesterType tester,
772 QueryType type)
773 : TestCase (testCtx, name, desc)
774 , m_renderCtx (renderCtx)
775 , m_target (target)
776 , m_pname (mapTesterToPname(tester))
777 , m_tester (tester)
778 , m_type (type)
779 {
780 }
781
init(void)782 void TextureTest::init (void)
783 {
784 const de::UniquePtr<glu::ContextInfo> ctxInfo (glu::ContextInfo::create(m_renderCtx));
785 RequiredExtensions extensions;
786
787 // target
788 if (!isCoreTextureTarget(m_renderCtx.getType(), m_target))
789 extensions.add(getTextureTargetExtension(m_renderCtx.getType(), m_target));
790
791 // param
792 if (!isCoreTextureParam(m_renderCtx.getType(), m_pname))
793 extensions.add(getTextureParamExtension(m_renderCtx.getType(), m_pname));
794
795 // query
796 if (!isCoreQuery(m_renderCtx.getType(), m_type))
797 extensions.add(getQueryExtension(m_renderCtx.getType(), m_type));
798
799 // test type
800 if (!isCoreTester(m_renderCtx.getType(), m_tester))
801 extensions.add(getTesterExtension(m_renderCtx.getType(), m_tester));
802
803 extensions.check(*ctxInfo);
804 }
805
iterate(void)806 TextureTest::IterateResult TextureTest::iterate (void)
807 {
808 glu::CallLogWrapper gl (m_renderCtx.getFunctions(), m_testCtx.getLog());
809 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
810
811 gl.enableLogging(true);
812 test(gl, result);
813
814 result.setTestContextResult(m_testCtx);
815 return STOP;
816 }
817
818 class IsTextureCase : public tcu::TestCase
819 {
820 public:
821 IsTextureCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target);
822
823 void init (void);
824 IterateResult iterate (void);
825
826 protected:
827 const glu::RenderContext& m_renderCtx;
828 const glw::GLenum m_target;
829 };
830
IsTextureCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target)831 IsTextureCase::IsTextureCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target)
832 : tcu::TestCase (testCtx, name, desc)
833 , m_renderCtx (renderCtx)
834 , m_target (target)
835 {
836 }
837
init(void)838 void IsTextureCase::init (void)
839 {
840 const de::UniquePtr<glu::ContextInfo> ctxInfo (glu::ContextInfo::create(m_renderCtx));
841 RequiredExtensions extensions;
842
843 // target
844 if (!isCoreTextureTarget(m_renderCtx.getType(), m_target))
845 extensions.add(getTextureTargetExtension(m_renderCtx.getType(), m_target));
846
847 extensions.check(*ctxInfo);
848 }
849
iterate(void)850 IsTextureCase::IterateResult IsTextureCase::iterate (void)
851 {
852 glu::CallLogWrapper gl (m_renderCtx.getFunctions(), m_testCtx.getLog());
853 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
854 glw::GLuint textureId = 0;
855
856 gl.enableLogging(true);
857
858 gl.glGenTextures(1, &textureId);
859 gl.glBindTexture(m_target, textureId);
860 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
861
862 verifyStateObjectBoolean(result, gl, textureId, true, QUERY_ISTEXTURE);
863
864 gl.glDeleteTextures(1, &textureId);
865 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
866
867 verifyStateObjectBoolean(result, gl, textureId, false, QUERY_ISTEXTURE);
868
869 result.setTestContextResult(m_testCtx);
870 return STOP;
871 }
872
873 class DepthStencilModeCase : public TextureTest
874 {
875 public:
876 DepthStencilModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
877 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
878 };
879
DepthStencilModeCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)880 DepthStencilModeCase::DepthStencilModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
881 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
882 {
883 }
884
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const885 void DepthStencilModeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
886 {
887 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
888 glu::Texture texture (m_renderCtx);
889
890 gl.glBindTexture(m_target, *texture);
891 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind");
892
893 if (!isPureCase)
894 {
895 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
896 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
897 }
898
899 if (!isPureCase)
900 {
901 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Toggle", "Toggle");
902 const glw::GLint depthComponentInt = GL_DEPTH_COMPONENT;
903 const glw::GLfloat depthComponentFloat = (glw::GLfloat)GL_DEPTH_COMPONENT;
904
905 gl.glTexParameteri(m_target, m_pname, GL_STENCIL_INDEX);
906 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
907 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);
908
909 gl.glTexParameteriv(m_target, m_pname, &depthComponentInt);
910 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
911 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
912
913 gl.glTexParameterf(m_target, m_pname, GL_STENCIL_INDEX);
914 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
915 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);
916
917 gl.glTexParameterfv(m_target, m_pname, &depthComponentFloat);
918 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
919 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
920 }
921
922 if (isPureIntTester(m_tester))
923 {
924 const glw::GLint depthComponent = GL_DEPTH_COMPONENT;
925 const glw::GLint stencilIndex = GL_STENCIL_INDEX;
926
927 gl.glTexParameterIiv(m_target, m_pname, &stencilIndex);
928 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
929 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);
930
931 gl.glTexParameterIiv(m_target, m_pname, &depthComponent);
932 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
933 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
934 }
935
936 if (isPureUintTester(m_tester))
937 {
938 const glw::GLuint depthComponent = GL_DEPTH_COMPONENT;
939 const glw::GLuint stencilIndex = GL_STENCIL_INDEX;
940
941 gl.glTexParameterIuiv(m_target, m_pname, &stencilIndex);
942 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
943 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);
944
945 gl.glTexParameterIuiv(m_target, m_pname, &depthComponent);
946 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
947 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
948 }
949 }
950
951 class TextureSRGBDecodeCase : public TextureTest
952 {
953 public:
954 TextureSRGBDecodeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
955 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
956 };
957
TextureSRGBDecodeCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)958 TextureSRGBDecodeCase::TextureSRGBDecodeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
959 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
960 {
961 }
962
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const963 void TextureSRGBDecodeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
964 {
965 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
966 glu::Texture texture (m_renderCtx);
967
968 gl.glBindTexture(m_target, *texture);
969 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind");
970
971 if (!isPureCase)
972 {
973 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
974 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
975 }
976
977 if (!isPureCase)
978 {
979 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Toggle", "Toggle");
980 const glw::GLint decodeInt = GL_DECODE_EXT;
981 const glw::GLfloat decodeFloat = (glw::GLfloat)GL_DECODE_EXT;
982
983 gl.glTexParameteri(m_target, m_pname, GL_SKIP_DECODE_EXT);
984 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
985 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
986
987 gl.glTexParameteriv(m_target, m_pname, &decodeInt);
988 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
989 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
990
991 gl.glTexParameterf(m_target, m_pname, GL_SKIP_DECODE_EXT);
992 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
993 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
994
995 gl.glTexParameterfv(m_target, m_pname, &decodeFloat);
996 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
997 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
998 }
999
1000 if (isPureIntTester(m_tester))
1001 {
1002 const glw::GLint skipDecode = GL_SKIP_DECODE_EXT;
1003 const glw::GLint decode = GL_DECODE_EXT;
1004
1005 gl.glTexParameterIiv(m_target, m_pname, &skipDecode);
1006 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1007 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
1008
1009 gl.glTexParameterIiv(m_target, m_pname, &decode);
1010 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1011 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
1012 }
1013
1014 if (isPureUintTester(m_tester))
1015 {
1016 const glw::GLuint skipDecode = GL_SKIP_DECODE_EXT;
1017 const glw::GLuint decode = GL_DECODE_EXT;
1018
1019 gl.glTexParameterIuiv(m_target, m_pname, &skipDecode);
1020 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1021 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
1022
1023 gl.glTexParameterIuiv(m_target, m_pname, &decode);
1024 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1025 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
1026 }
1027 }
1028
1029 class TextureSwizzleCase : public TextureTest
1030 {
1031 public:
1032 TextureSwizzleCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1033 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1034 };
1035
TextureSwizzleCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1036 TextureSwizzleCase::TextureSwizzleCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1037 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1038 {
1039 }
1040
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1041 void TextureSwizzleCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1042 {
1043 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1044 const int initialValue = (m_pname == GL_TEXTURE_SWIZZLE_R) ? (GL_RED) :
1045 (m_pname == GL_TEXTURE_SWIZZLE_G) ? (GL_GREEN) :
1046 (m_pname == GL_TEXTURE_SWIZZLE_B) ? (GL_BLUE) :
1047 (m_pname == GL_TEXTURE_SWIZZLE_A) ? (GL_ALPHA) :
1048 (-1);
1049
1050 if (!isPureCase)
1051 {
1052 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1053 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
1054 }
1055
1056 {
1057 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1058 const GLenum swizzleValues[] = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_ZERO, GL_ONE};
1059
1060 if (isPureCase)
1061 {
1062 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(swizzleValues); ++ndx)
1063 {
1064 if (isPureIntTester(m_tester))
1065 {
1066 const glw::GLint value = (glw::GLint)swizzleValues[ndx];
1067 gl.glTexParameterIiv(m_target, m_pname, &value);
1068 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1069 }
1070 else
1071 {
1072 DE_ASSERT(isPureUintTester(m_tester));
1073
1074 const glw::GLuint value = swizzleValues[ndx];
1075 gl.glTexParameterIuiv(m_target, m_pname, &value);
1076 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1077 }
1078
1079 verifyStateTextureParamInteger(result, gl, m_target, m_pname, swizzleValues[ndx], m_type);
1080 }
1081 }
1082 else
1083 {
1084 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(swizzleValues); ++ndx)
1085 {
1086 gl.glTexParameteri(m_target, m_pname, swizzleValues[ndx]);
1087 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1088
1089 verifyStateTextureParamInteger(result, gl, m_target, m_pname, swizzleValues[ndx], m_type);
1090 }
1091
1092 //check unit conversions with float
1093
1094 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(swizzleValues); ++ndx)
1095 {
1096 gl.glTexParameterf(m_target, m_pname, (GLfloat)swizzleValues[ndx]);
1097 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1098
1099 verifyStateTextureParamInteger(result, gl, m_target, m_pname, swizzleValues[ndx], m_type);
1100 }
1101 }
1102 }
1103 }
1104
1105 class TextureWrapCase : public TextureTest
1106 {
1107 public:
1108 TextureWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1109 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1110 };
1111
TextureWrapCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1112 TextureWrapCase::TextureWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1113 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1114 {
1115 }
1116
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1117 void TextureWrapCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1118 {
1119 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1120
1121 if (!isPureCase)
1122 {
1123 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1124 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_REPEAT, m_type);
1125 }
1126
1127 {
1128 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1129 const GLenum wrapValues[] = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT};
1130
1131 if (isPureCase)
1132 {
1133 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
1134 {
1135 if (isPureIntTester(m_tester))
1136 {
1137 const glw::GLint value = (glw::GLint)wrapValues[ndx];
1138 gl.glTexParameterIiv(m_target, m_pname, &value);
1139 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1140 }
1141 else
1142 {
1143 DE_ASSERT(isPureUintTester(m_tester));
1144
1145 const glw::GLuint value = wrapValues[ndx];
1146 gl.glTexParameterIuiv(m_target, m_pname, &value);
1147 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1148 }
1149
1150 verifyStateTextureParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
1151 }
1152 }
1153 else
1154 {
1155 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
1156 {
1157 gl.glTexParameteri(m_target, m_pname, wrapValues[ndx]);
1158 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1159
1160 verifyStateTextureParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
1161 }
1162
1163 //check unit conversions with float
1164
1165 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
1166 {
1167 gl.glTexParameterf(m_target, m_pname, (GLfloat)wrapValues[ndx]);
1168 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1169
1170 verifyStateTextureParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
1171 }
1172 }
1173 }
1174 }
1175
1176 class TextureFilterCase : public TextureTest
1177 {
1178 public:
1179 TextureFilterCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1180 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1181 };
1182
TextureFilterCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1183 TextureFilterCase::TextureFilterCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1184 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1185 {
1186 }
1187
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1188 void TextureFilterCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1189 {
1190 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1191 glw::GLenum initial = (m_pname == GL_TEXTURE_MAG_FILTER) ? (GL_LINEAR)
1192 : (m_pname == GL_TEXTURE_MIN_FILTER) ? (GL_NEAREST_MIPMAP_LINEAR)
1193 : (0);
1194
1195 const glu::ContextType& contextType = m_renderCtx.getType();
1196 const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5));
1197
1198 /* Update initial values to match desktop context. */
1199 if (isCoreGL45)
1200 {
1201 GLenum initialMin = (m_target == GL_TEXTURE_CUBE_MAP_ARRAY) ?
1202 GL_NEAREST_MIPMAP_LINEAR : GL_LINEAR_MIPMAP_NEAREST;
1203
1204 if (m_pname == GL_TEXTURE_MIN_FILTER)
1205 {
1206 initial = initialMin;
1207 }
1208 else if (m_pname == GL_TEXTURE_MAG_FILTER)
1209 {
1210 initial = GL_LINEAR;
1211 }
1212 }
1213
1214 if (!isPureCase)
1215 {
1216 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1217 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initial, m_type);
1218 }
1219
1220 {
1221 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1222 std::vector<GLenum> values;
1223
1224 values.push_back(GL_NEAREST);
1225 values.push_back(GL_LINEAR);
1226 if (m_pname == GL_TEXTURE_MIN_FILTER)
1227 {
1228 values.push_back(GL_NEAREST_MIPMAP_NEAREST);
1229 values.push_back(GL_NEAREST_MIPMAP_LINEAR);
1230 values.push_back(GL_LINEAR_MIPMAP_NEAREST);
1231 values.push_back(GL_LINEAR_MIPMAP_LINEAR);
1232 }
1233
1234 if (isPureCase)
1235 {
1236 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1237 {
1238 if (isPureIntTester(m_tester))
1239 {
1240 const glw::GLint value = (glw::GLint)values[ndx];
1241 gl.glTexParameterIiv(m_target, m_pname, &value);
1242 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1243 }
1244 else
1245 {
1246 DE_ASSERT(isPureUintTester(m_tester));
1247
1248 const glw::GLuint value = values[ndx];
1249 gl.glTexParameterIuiv(m_target, m_pname, &value);
1250 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1251 }
1252
1253 verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1254 }
1255 }
1256 else
1257 {
1258 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1259 {
1260 gl.glTexParameteri(m_target, m_pname, values[ndx]);
1261 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1262
1263 verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1264 }
1265
1266 //check unit conversions with float
1267
1268 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1269 {
1270 gl.glTexParameterf(m_target, m_pname, (GLfloat)values[ndx]);
1271 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1272
1273 verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1274 }
1275 }
1276 }
1277 }
1278
1279 class TextureLODCase : public TextureTest
1280 {
1281 public:
1282 TextureLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1283 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1284 };
1285
TextureLODCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1286 TextureLODCase::TextureLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1287 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1288 {
1289 }
1290
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1291 void TextureLODCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1292 {
1293 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1294 const int initialValue = (m_pname == GL_TEXTURE_MIN_LOD) ? (-1000)
1295 : (m_pname == GL_TEXTURE_MAX_LOD) ? (1000)
1296 : (-1);
1297
1298 if ((querySupportsSigned(m_type) || initialValue >= 0) && !isPureCase)
1299 {
1300 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1301 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
1302 }
1303
1304 {
1305 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1306 const int numIterations = 20;
1307 de::Random rnd (0xabcdef);
1308
1309 if (isPureCase)
1310 {
1311 if (isPureIntTester(m_tester))
1312 {
1313 for (int ndx = 0; ndx < numIterations; ++ndx)
1314 {
1315 const GLint ref = rnd.getInt(-1000, 1000);
1316
1317 gl.glTexParameterIiv(m_target, m_pname, &ref);
1318 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1319
1320 verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1321 }
1322 }
1323 else
1324 {
1325 DE_ASSERT(isPureUintTester(m_tester));
1326
1327 for (int ndx = 0; ndx < numIterations; ++ndx)
1328 {
1329 const GLuint ref = (glw::GLuint)rnd.getInt(0, 1000);
1330
1331 gl.glTexParameterIuiv(m_target, m_pname, &ref);
1332 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1333
1334 verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1335 }
1336 }
1337 }
1338 else
1339 {
1340 const int minLimit = (querySupportsSigned(m_type)) ? (-1000) : (0);
1341
1342 for (int ndx = 0; ndx < numIterations; ++ndx)
1343 {
1344 const GLfloat ref = rnd.getFloat((float)minLimit, 1000.f);
1345
1346 gl.glTexParameterf(m_target, m_pname, ref);
1347 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1348
1349 verifyStateTextureParamFloat(result, gl, m_target, m_pname, ref, m_type);
1350 }
1351
1352 // check unit conversions with int
1353
1354 for (int ndx = 0; ndx < numIterations; ++ndx)
1355 {
1356 const GLint ref = rnd.getInt(minLimit, 1000);
1357
1358 gl.glTexParameteri(m_target, m_pname, ref);
1359 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1360
1361 verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1362 }
1363 }
1364 }
1365 }
1366
1367 class TextureLevelCase : public TextureTest
1368 {
1369 public:
1370 TextureLevelCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1371 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1372 };
1373
TextureLevelCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1374 TextureLevelCase::TextureLevelCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1375 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1376 {
1377 }
1378
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1379 void TextureLevelCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1380 {
1381 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1382 const int initialValue = (m_pname == GL_TEXTURE_BASE_LEVEL) ? (0)
1383 : (m_pname == GL_TEXTURE_MAX_LEVEL) ? (1000)
1384 : (-1);
1385
1386 if (!isPureCase)
1387 {
1388 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1389 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
1390 }
1391
1392 if (m_target == GL_TEXTURE_2D_MULTISAMPLE ||
1393 m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1394 {
1395 // only 0 allowed
1396 {
1397 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
1398
1399 gl.glTexParameteri(m_target, m_pname, 0);
1400 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1401 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1402
1403 gl.glTexParameterf(m_target, m_pname, 0.0f);
1404 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1405 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1406 }
1407 }
1408 else
1409 {
1410 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1411 const int numIterations = 20;
1412 de::Random rnd (0xabcdef);
1413
1414 if (isPureCase)
1415 {
1416 for (int ndx = 0; ndx < numIterations; ++ndx)
1417 {
1418 const GLint ref = rnd.getInt(0, 64000);
1419 const GLuint uRef = (glw::GLuint)ref;
1420
1421 if (isPureIntTester(m_tester))
1422 {
1423 gl.glTexParameterIiv(m_target, m_pname, &ref);
1424 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1425 }
1426 else
1427 {
1428 DE_ASSERT(isPureUintTester(m_tester));
1429 gl.glTexParameterIuiv(m_target, m_pname, &uRef);
1430 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1431 }
1432
1433 verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
1434 }
1435 }
1436 else
1437 {
1438 for (int ndx = 0; ndx < numIterations; ++ndx)
1439 {
1440 const GLint ref = rnd.getInt(0, 64000);
1441
1442 gl.glTexParameteri(m_target, m_pname, ref);
1443 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1444
1445 verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
1446 }
1447
1448 // check unit conversions with float
1449
1450 const float nonSignificantOffsets[] = {-0.45f, -0.25f, 0, 0.45f}; // offsets O so that for any integers z in Z, o in O roundToClosestInt(z+o)==z
1451
1452 const int numConversionIterations = 30;
1453 for (int ndx = 0; ndx < numConversionIterations; ++ndx)
1454 {
1455 const GLint ref = rnd.getInt(1, 64000);
1456
1457 for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(nonSignificantOffsets); ++offsetNdx)
1458 {
1459 gl.glTexParameterf(m_target, m_pname, ((GLfloat)ref) + nonSignificantOffsets[offsetNdx]);
1460 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1461
1462 verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
1463 }
1464 }
1465 }
1466 }
1467 }
1468
1469 class TextureCompareModeCase : public TextureTest
1470 {
1471 public:
1472 TextureCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1473 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1474 };
1475
TextureCompareModeCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1476 TextureCompareModeCase::TextureCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1477 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1478 {
1479 }
1480
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1481 void TextureCompareModeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1482 {
1483 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1484
1485 if (!isPureCase)
1486 {
1487 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1488 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_NONE, m_type);
1489 }
1490
1491 {
1492 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1493 const GLenum modes[] = {GL_COMPARE_REF_TO_TEXTURE, GL_NONE};
1494
1495 if (isPureCase)
1496 {
1497 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
1498 {
1499 if (isPureIntTester(m_tester))
1500 {
1501 const glw::GLint value = (glw::GLint)modes[ndx];
1502 gl.glTexParameterIiv(m_target, m_pname, &value);
1503 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1504 }
1505 else
1506 {
1507 DE_ASSERT(isPureUintTester(m_tester));
1508
1509 const glw::GLuint value = modes[ndx];
1510 gl.glTexParameterIuiv(m_target, m_pname, &value);
1511 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1512 }
1513
1514 verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
1515 }
1516 }
1517 else
1518 {
1519 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
1520 {
1521 gl.glTexParameteri(m_target, m_pname, modes[ndx]);
1522 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1523
1524 verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
1525 }
1526
1527 //check unit conversions with float
1528
1529 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
1530 {
1531 gl.glTexParameterf(m_target, m_pname, (GLfloat)modes[ndx]);
1532 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1533
1534 verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
1535 }
1536 }
1537 }
1538 }
1539
1540 class TextureCompareFuncCase : public TextureTest
1541 {
1542 public:
1543 TextureCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1544 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1545 };
1546
TextureCompareFuncCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1547 TextureCompareFuncCase::TextureCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1548 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1549 {
1550 }
1551
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1552 void TextureCompareFuncCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1553 {
1554 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1555
1556 if (!isPureCase)
1557 {
1558 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1559 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_LEQUAL, m_type);
1560 }
1561
1562 {
1563 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1564 const GLenum compareFuncs[] = {GL_LEQUAL, GL_GEQUAL, GL_LESS, GL_GREATER, GL_EQUAL, GL_NOTEQUAL, GL_ALWAYS, GL_NEVER};
1565
1566 if (isPureCase)
1567 {
1568 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
1569 {
1570 if (isPureIntTester(m_tester))
1571 {
1572 const glw::GLint value = (glw::GLint)compareFuncs[ndx];
1573 gl.glTexParameterIiv(m_target, m_pname, &value);
1574 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1575 }
1576 else
1577 {
1578 DE_ASSERT(isPureUintTester(m_tester));
1579
1580 const glw::GLuint value = compareFuncs[ndx];
1581 gl.glTexParameterIuiv(m_target, m_pname, &value);
1582 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1583 }
1584
1585 verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
1586 }
1587 }
1588 else
1589 {
1590 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
1591 {
1592 gl.glTexParameteri(m_target, m_pname, compareFuncs[ndx]);
1593 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1594
1595 verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
1596 }
1597
1598 //check unit conversions with float
1599
1600 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
1601 {
1602 gl.glTexParameterf(m_target, m_pname, (GLfloat)compareFuncs[ndx]);
1603 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1604
1605 verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
1606 }
1607 }
1608 }
1609 }
1610
1611 class TextureImmutableLevelsCase : public TextureTest
1612 {
1613 public:
1614 TextureImmutableLevelsCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, QueryType type);
1615 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1616 };
1617
TextureImmutableLevelsCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,QueryType type)1618 TextureImmutableLevelsCase::TextureImmutableLevelsCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, QueryType type)
1619 : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_IMMUTABLE_LEVELS, type)
1620 {
1621 }
1622
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1623 void TextureImmutableLevelsCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1624 {
1625 {
1626 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1627 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1628 }
1629
1630 if (m_target == GL_TEXTURE_2D_MULTISAMPLE ||
1631 m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1632 {
1633 // no levels
1634 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Level", "Level");
1635 GLuint textureID = 0;
1636
1637 gl.glGenTextures(1, &textureID);
1638 gl.glBindTexture(m_target, textureID);
1639 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1640
1641 if (m_target == GL_TEXTURE_2D_MULTISAMPLE)
1642 gl.glTexStorage2DMultisample(m_target, 2, GL_RGB8, 64, 64, GL_FALSE);
1643 else if (m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1644 gl.glTexStorage3DMultisample(m_target, 2, GL_RGB8, 64, 64, 2, GL_FALSE);
1645 else
1646 DE_ASSERT(false);
1647 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexStorage");
1648
1649 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 1, m_type);
1650
1651 gl.glDeleteTextures(1, &textureID);
1652 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1653 }
1654 else
1655 {
1656 for (int level = 1; level <= 7; ++level)
1657 {
1658 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Levels", "Levels = " + de::toString(level));
1659 GLuint textureID = 0;
1660
1661 gl.glGenTextures(1, &textureID);
1662 gl.glBindTexture(m_target, textureID);
1663 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1664
1665 if (m_target == GL_TEXTURE_2D || m_target == GL_TEXTURE_CUBE_MAP)
1666 gl.glTexStorage2D(m_target, level, GL_RGB8, 64, 64);
1667 else if (m_target == GL_TEXTURE_2D_ARRAY || m_target == GL_TEXTURE_3D)
1668 gl.glTexStorage3D(m_target, level, GL_RGB8, 64, 64, 64);
1669 else if (m_target == GL_TEXTURE_CUBE_MAP_ARRAY)
1670 gl.glTexStorage3D(m_target, level, GL_RGB8, 64, 64, 6 * 2);
1671 else
1672 DE_ASSERT(false);
1673 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexStorage");
1674
1675 verifyStateTextureParamInteger(result, gl, m_target, m_pname, level, m_type);
1676
1677 gl.glDeleteTextures(1, &textureID);
1678 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1679 }
1680 }
1681 }
1682
1683 class TextureImmutableFormatCase : public TextureTest
1684 {
1685 public:
1686 TextureImmutableFormatCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, QueryType type);
1687 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1688 };
1689
TextureImmutableFormatCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,QueryType type)1690 TextureImmutableFormatCase::TextureImmutableFormatCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, QueryType type)
1691 : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_IMMUTABLE_FORMAT, type)
1692 {
1693 }
1694
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1695 void TextureImmutableFormatCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1696 {
1697 {
1698 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1699 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1700 }
1701
1702 {
1703 const tcu::ScopedLogSection subsection (m_testCtx.getLog(), "Immutable", "Immutable");
1704 GLuint textureID = 0;
1705
1706 gl.glGenTextures(1, &textureID);
1707 gl.glBindTexture(m_target, textureID);
1708 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1709
1710 switch (m_target)
1711 {
1712 case GL_TEXTURE_2D:
1713 case GL_TEXTURE_CUBE_MAP:
1714 {
1715 gl.glTexStorage2D(m_target, 1, GL_RGBA8, 32, 32);
1716 break;
1717 }
1718 case GL_TEXTURE_2D_ARRAY:
1719 case GL_TEXTURE_3D:
1720 {
1721 gl.glTexStorage3D(m_target, 1, GL_RGBA8, 32, 32, 8);
1722 break;
1723 }
1724 case GL_TEXTURE_2D_MULTISAMPLE:
1725 {
1726 gl.glTexStorage2DMultisample(m_target, 2, GL_RGB8, 64, 64, GL_FALSE);
1727 break;
1728 }
1729 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
1730 {
1731 gl.glTexStorage3DMultisample(m_target, 2, GL_RGB8, 64, 64, 2, GL_FALSE);
1732 break;
1733 }
1734 case GL_TEXTURE_CUBE_MAP_ARRAY:
1735 {
1736 gl.glTexStorage3D(m_target, 1, GL_RGBA8, 32, 32, 6 * 2);
1737 break;
1738 }
1739 default:
1740 DE_ASSERT(false);
1741 }
1742 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup texture");
1743
1744 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 1, m_type);
1745
1746 gl.glDeleteTextures(1, &textureID);
1747 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1748 }
1749
1750 // no mutable
1751 if (m_target == GL_TEXTURE_2D_MULTISAMPLE ||
1752 m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1753 return;
1754
1755 // test mutable
1756 {
1757 const tcu::ScopedLogSection subsection (m_testCtx.getLog(), "Mutable", "Mutable");
1758 GLuint textureID = 0;
1759
1760 gl.glGenTextures(1, &textureID);
1761 gl.glBindTexture(m_target, textureID);
1762 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1763
1764 switch (m_target)
1765 {
1766 case GL_TEXTURE_2D:
1767 {
1768 gl.glTexImage2D(m_target, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1769 break;
1770 }
1771 case GL_TEXTURE_CUBE_MAP:
1772 {
1773 gl.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1774 break;
1775 }
1776 case GL_TEXTURE_2D_ARRAY:
1777 case GL_TEXTURE_3D:
1778 {
1779 gl.glTexImage3D(m_target, 0, GL_RGBA8, 32, 32, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1780 break;
1781 }
1782 case GL_TEXTURE_CUBE_MAP_ARRAY:
1783 {
1784 gl.glTexImage3D(m_target, 0, GL_RGBA8, 32, 32, 6 * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1785 break;
1786 }
1787 default:
1788 DE_ASSERT(false);
1789 }
1790 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup texture");
1791
1792 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1793
1794 gl.glDeleteTextures(1, &textureID);
1795 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1796 }
1797 }
1798
1799 class TextureWrapClampToBorderCase : public TextureTest
1800 {
1801 public:
1802 TextureWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1803 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1804 };
1805
TextureWrapClampToBorderCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1806 TextureWrapClampToBorderCase::TextureWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1807 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1808 {
1809 }
1810
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1811 void TextureWrapClampToBorderCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1812 {
1813 gl.glTexParameteri(m_target, m_pname, GL_CLAMP_TO_BORDER_EXT);
1814 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1815 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
1816
1817 gl.glTexParameteri(m_target, m_pname, GL_REPEAT);
1818 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1819
1820 gl.glTexParameterf(m_target, m_pname, (GLfloat)GL_CLAMP_TO_BORDER_EXT);
1821 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1822
1823 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
1824 }
1825
1826 class TextureBorderColorCase : public TextureTest
1827 {
1828 public:
1829 TextureBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, QueryType type);
1830 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1831 };
1832
TextureBorderColorCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,QueryType type)1833 TextureBorderColorCase::TextureBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, QueryType type)
1834 : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_BORDER_COLOR, type)
1835 {
1836 }
1837
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1838 void TextureBorderColorCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1839 {
1840 // border color is undefined if queried with pure type and was not set to pure value
1841 if (m_type == QUERY_TEXTURE_PARAM_INTEGER_VEC4 || m_type == QUERY_TEXTURE_PARAM_FLOAT_VEC4)
1842 {
1843 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1844 verifyStateTextureParamFloatVec4(result, gl, m_target, m_pname, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), m_type);
1845 }
1846
1847 if (m_type == QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4)
1848 {
1849 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1850 const tcu::IVec4 color (0x7FFFFFFF, -2, 3, -128);
1851
1852 gl.glTexParameterIiv(m_target, m_pname, color.getPtr());
1853 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1854
1855 verifyStateTextureParamIntegerVec4(result, gl, m_target, m_pname, color, m_type);
1856 }
1857 else if (m_type == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4)
1858 {
1859 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1860 const tcu::UVec4 color (0x8000000ul, 2, 3, 128);
1861
1862 gl.glTexParameterIuiv(m_target, m_pname, color.getPtr());
1863 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1864
1865 verifyStateTextureParamUnsignedIntegerVec4(result, gl, m_target, m_pname, color, m_type);
1866 }
1867 else
1868 {
1869 DE_ASSERT(m_type == QUERY_TEXTURE_PARAM_INTEGER_VEC4 || m_type == QUERY_TEXTURE_PARAM_FLOAT_VEC4);
1870
1871 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1872 const tcu::Vec4 color (0.25f, 1.0f, 0.0f, 0.77f);
1873 const tcu::IVec4 icolor (0x8000000ul, 0x7FFFFFFF, 0, 0x0FFFFFFF);
1874
1875 gl.glTexParameterfv(m_target, m_pname, color.getPtr());
1876 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterfv");
1877
1878 verifyStateTextureParamFloatVec4(result, gl, m_target, m_pname, color, m_type);
1879
1880 gl.glTexParameteriv(m_target, m_pname, icolor.getPtr());
1881 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteriv");
1882
1883 verifyStateTextureParamNormalizedI32Vec4(result, gl, m_target, m_pname, icolor, m_type);
1884 }
1885 }
1886
1887 class SamplerTest : public tcu::TestCase
1888 {
1889 public:
1890 SamplerTest (tcu::TestContext& testCtx,
1891 const glu::RenderContext& renderCtx,
1892 const char* name,
1893 const char* desc,
1894 TesterType tester,
1895 QueryType type);
1896
1897 void init (void);
1898 IterateResult iterate (void);
1899
1900 virtual void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const = 0;
1901
1902 protected:
1903 const glu::RenderContext& m_renderCtx;
1904 const glw::GLenum m_pname;
1905 const TesterType m_tester;
1906 const QueryType m_type;
1907 glw::GLuint m_target;
1908 };
1909
SamplerTest(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)1910 SamplerTest::SamplerTest (tcu::TestContext& testCtx,
1911 const glu::RenderContext& renderCtx,
1912 const char* name,
1913 const char* desc,
1914 TesterType tester,
1915 QueryType type)
1916 : TestCase (testCtx, name, desc)
1917 , m_renderCtx (renderCtx)
1918 , m_pname (mapTesterToPname(tester))
1919 , m_tester (tester)
1920 , m_type (type)
1921 , m_target (0)
1922 {
1923 }
1924
init(void)1925 void SamplerTest::init (void)
1926 {
1927 const de::UniquePtr<glu::ContextInfo> ctxInfo (glu::ContextInfo::create(m_renderCtx));
1928 RequiredExtensions extensions;
1929
1930 // param
1931 if (!isCoreTextureParam(m_renderCtx.getType(), m_pname))
1932 extensions.add(getTextureParamExtension(m_renderCtx.getType(), m_pname));
1933
1934 // query
1935 if (!isCoreQuery(m_renderCtx.getType(), m_type))
1936 extensions.add(getQueryExtension(m_renderCtx.getType(), m_type));
1937
1938 // test type
1939 if (!isCoreTester(m_renderCtx.getType(), m_tester))
1940 extensions.add(getTesterExtension(m_renderCtx.getType(), m_tester));
1941
1942 extensions.check(*ctxInfo);
1943 }
1944
iterate(void)1945 SamplerTest::IterateResult SamplerTest::iterate (void)
1946 {
1947 glu::CallLogWrapper gl (m_renderCtx.getFunctions(), m_testCtx.getLog());
1948 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
1949 glu::Sampler sampler (m_renderCtx);
1950
1951 gl.enableLogging(true);
1952
1953 m_target = *sampler;
1954 test(gl, result);
1955 m_target = 0;
1956
1957 result.setTestContextResult(m_testCtx);
1958 return STOP;
1959 }
1960
1961 class SamplerWrapCase : public SamplerTest
1962 {
1963 public:
1964 SamplerWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
1965 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1966 };
1967
SamplerWrapCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)1968 SamplerWrapCase::SamplerWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
1969 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
1970 {
1971 }
1972
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1973 void SamplerWrapCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1974 {
1975 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1976
1977 if (!isPureCase)
1978 {
1979 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1980 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_REPEAT, m_type);
1981 }
1982
1983 {
1984 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1985 const GLenum wrapValues[] = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT};
1986
1987 if (isPureCase)
1988 {
1989 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
1990 {
1991 if (isPureIntTester(m_tester))
1992 {
1993 const glw::GLint value = (glw::GLint)wrapValues[ndx];
1994 gl.glSamplerParameterIiv(m_target, m_pname, &value);
1995 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
1996 }
1997 else
1998 {
1999 DE_ASSERT(isPureUintTester(m_tester));
2000
2001 const glw::GLuint value = wrapValues[ndx];
2002 gl.glSamplerParameterIuiv(m_target, m_pname, &value);
2003 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2004 }
2005
2006 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
2007 }
2008 }
2009 else
2010 {
2011 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
2012 {
2013 gl.glSamplerParameteri(m_target, m_pname, wrapValues[ndx]);
2014 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2015
2016 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
2017 }
2018
2019 //check unit conversions with float
2020
2021 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
2022 {
2023 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)wrapValues[ndx]);
2024 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2025
2026 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
2027 }
2028 }
2029 }
2030 }
2031
2032 class SamplerFilterCase : public SamplerTest
2033 {
2034 public:
2035 SamplerFilterCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2036 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2037 };
2038
SamplerFilterCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2039 SamplerFilterCase::SamplerFilterCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2040 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2041 {
2042 }
2043
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2044 void SamplerFilterCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2045 {
2046 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2047 const glw::GLenum initial = (m_pname == GL_TEXTURE_MAG_FILTER) ? (GL_LINEAR)
2048 : (m_pname == GL_TEXTURE_MIN_FILTER) ? (GL_NEAREST_MIPMAP_LINEAR)
2049 : (0);
2050
2051 if (!isPureCase)
2052 {
2053 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2054 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, initial, m_type);
2055 }
2056
2057 {
2058 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2059 std::vector<GLenum> values;
2060
2061 values.push_back(GL_NEAREST);
2062 values.push_back(GL_LINEAR);
2063 if (m_pname == GL_TEXTURE_MIN_FILTER)
2064 {
2065 values.push_back(GL_NEAREST_MIPMAP_NEAREST);
2066 values.push_back(GL_NEAREST_MIPMAP_LINEAR);
2067 values.push_back(GL_LINEAR_MIPMAP_NEAREST);
2068 values.push_back(GL_LINEAR_MIPMAP_LINEAR);
2069 }
2070
2071 if (isPureCase)
2072 {
2073 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
2074 {
2075 if (isPureIntTester(m_tester))
2076 {
2077 const glw::GLint value = (glw::GLint)values[ndx];
2078 gl.glSamplerParameterIiv(m_target, m_pname, &value);
2079 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2080 }
2081 else
2082 {
2083 DE_ASSERT(isPureUintTester(m_tester));
2084
2085 const glw::GLuint value = values[ndx];
2086 gl.glSamplerParameterIuiv(m_target, m_pname, &value);
2087 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2088 }
2089
2090 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
2091 }
2092 }
2093 else
2094 {
2095 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
2096 {
2097 gl.glSamplerParameteri(m_target, m_pname, values[ndx]);
2098 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2099
2100 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
2101 }
2102
2103 //check unit conversions with float
2104
2105 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
2106 {
2107 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)values[ndx]);
2108 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2109
2110 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
2111 }
2112 }
2113 }
2114 }
2115
2116 class SamplerLODCase : public SamplerTest
2117 {
2118 public:
2119 SamplerLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2120 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2121 };
2122
SamplerLODCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2123 SamplerLODCase::SamplerLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2124 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2125 {
2126 }
2127
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2128 void SamplerLODCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2129 {
2130 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2131 const int initialValue = (m_pname == GL_TEXTURE_MIN_LOD) ? (-1000)
2132 : (m_pname == GL_TEXTURE_MAX_LOD) ? (1000)
2133 : (-1);
2134
2135 if ((querySupportsSigned(m_type) || initialValue >= 0) && !isPureCase)
2136 {
2137 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2138 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
2139 }
2140
2141 {
2142 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2143 const int numIterations = 20;
2144 de::Random rnd (0xabcdef);
2145
2146 if (isPureCase)
2147 {
2148 if (isPureIntTester(m_tester))
2149 {
2150 for (int ndx = 0; ndx < numIterations; ++ndx)
2151 {
2152 const GLint ref = rnd.getInt(-1000, 1000);
2153
2154 gl.glSamplerParameterIiv(m_target, m_pname, &ref);
2155 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2156
2157 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
2158 }
2159 }
2160 else
2161 {
2162 DE_ASSERT(isPureUintTester(m_tester));
2163
2164 for (int ndx = 0; ndx < numIterations; ++ndx)
2165 {
2166 const GLuint ref = (glw::GLuint)rnd.getInt(0, 1000);
2167
2168 gl.glSamplerParameterIuiv(m_target, m_pname, &ref);
2169 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2170
2171 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
2172 }
2173 }
2174 }
2175 else
2176 {
2177 const int minLimit = (querySupportsSigned(m_type)) ? (-1000) : (0);
2178
2179 for (int ndx = 0; ndx < numIterations; ++ndx)
2180 {
2181 const GLfloat ref = rnd.getFloat((float)minLimit, 1000.f);
2182
2183 gl.glSamplerParameterf(m_target, m_pname, ref);
2184 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2185
2186 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, ref, m_type);
2187 }
2188
2189 // check unit conversions with int
2190
2191 for (int ndx = 0; ndx < numIterations; ++ndx)
2192 {
2193 const GLint ref = rnd.getInt(minLimit, 1000);
2194
2195 gl.glSamplerParameteri(m_target, m_pname, ref);
2196 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2197
2198 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
2199 }
2200 }
2201 }
2202 }
2203
2204 class SamplerCompareModeCase : public SamplerTest
2205 {
2206 public:
2207 SamplerCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2208 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2209 };
2210
SamplerCompareModeCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2211 SamplerCompareModeCase::SamplerCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2212 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2213 {
2214 }
2215
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2216 void SamplerCompareModeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2217 {
2218 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2219
2220 if (!isPureCase)
2221 {
2222 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2223 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_NONE, m_type);
2224 }
2225
2226 {
2227 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2228 const GLenum modes[] = {GL_COMPARE_REF_TO_TEXTURE, GL_NONE};
2229
2230 if (isPureCase)
2231 {
2232 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
2233 {
2234 if (isPureIntTester(m_tester))
2235 {
2236 const glw::GLint value = (glw::GLint)modes[ndx];
2237 gl.glSamplerParameterIiv(m_target, m_pname, &value);
2238 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2239 }
2240 else
2241 {
2242 DE_ASSERT(isPureUintTester(m_tester));
2243
2244 const glw::GLuint value = modes[ndx];
2245 gl.glSamplerParameterIuiv(m_target, m_pname, &value);
2246 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2247 }
2248
2249 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
2250 }
2251 }
2252 else
2253 {
2254 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
2255 {
2256 gl.glSamplerParameteri(m_target, m_pname, modes[ndx]);
2257 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2258
2259 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
2260 }
2261
2262 //check unit conversions with float
2263
2264 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
2265 {
2266 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)modes[ndx]);
2267 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2268
2269 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
2270 }
2271 }
2272 }
2273 }
2274
2275 class SamplerCompareFuncCase : public SamplerTest
2276 {
2277 public:
2278 SamplerCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2279 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2280 };
2281
SamplerCompareFuncCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2282 SamplerCompareFuncCase::SamplerCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2283 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2284 {
2285 }
2286
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2287 void SamplerCompareFuncCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2288 {
2289 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2290
2291 if (!isPureCase)
2292 {
2293 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2294 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_LEQUAL, m_type);
2295 }
2296
2297 {
2298 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2299 const GLenum compareFuncs[] = {GL_LEQUAL, GL_GEQUAL, GL_LESS, GL_GREATER, GL_EQUAL, GL_NOTEQUAL, GL_ALWAYS, GL_NEVER};
2300
2301 if (isPureCase)
2302 {
2303 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
2304 {
2305 if (isPureIntTester(m_tester))
2306 {
2307 const glw::GLint value = (glw::GLint)compareFuncs[ndx];
2308 gl.glSamplerParameterIiv(m_target, m_pname, &value);
2309 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2310 }
2311 else
2312 {
2313 DE_ASSERT(isPureUintTester(m_tester));
2314
2315 const glw::GLuint value = compareFuncs[ndx];
2316 gl.glSamplerParameterIuiv(m_target, m_pname, &value);
2317 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2318 }
2319
2320 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
2321 }
2322 }
2323 else
2324 {
2325 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
2326 {
2327 gl.glSamplerParameteri(m_target, m_pname, compareFuncs[ndx]);
2328 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2329
2330 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
2331 }
2332
2333 //check unit conversions with float
2334
2335 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
2336 {
2337 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)compareFuncs[ndx]);
2338 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2339
2340 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
2341 }
2342 }
2343 }
2344 }
2345
2346 class SamplerWrapClampToBorderCase : public SamplerTest
2347 {
2348 public:
2349 SamplerWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2350 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2351 };
2352
SamplerWrapClampToBorderCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2353 SamplerWrapClampToBorderCase::SamplerWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2354 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2355 {
2356 }
2357
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2358 void SamplerWrapClampToBorderCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2359 {
2360 gl.glSamplerParameteri(m_target, m_pname, GL_CLAMP_TO_BORDER_EXT);
2361 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2362 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
2363
2364 gl.glSamplerParameteri(m_target, m_pname, GL_REPEAT);
2365 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2366
2367 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)GL_CLAMP_TO_BORDER_EXT);
2368 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2369
2370 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
2371 }
2372
2373 class SamplerSRGBDecodeCase : public SamplerTest
2374 {
2375 public:
2376 SamplerSRGBDecodeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2377 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2378 };
2379
SamplerSRGBDecodeCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2380 SamplerSRGBDecodeCase::SamplerSRGBDecodeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2381 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2382 {
2383 }
2384
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2385 void SamplerSRGBDecodeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2386 {
2387 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2388
2389 if (!isPureCase)
2390 {
2391 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2392 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2393 }
2394
2395 {
2396 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Toggle", "Toggle");
2397 const glw::GLint decodeInt = GL_DECODE_EXT;
2398 const glw::GLfloat decodeFloat = (glw::GLfloat)GL_DECODE_EXT;
2399
2400 gl.glSamplerParameteri(m_target, m_pname, GL_SKIP_DECODE_EXT);
2401 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2402 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2403
2404 gl.glSamplerParameteriv(m_target, m_pname, &decodeInt);
2405 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2406 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2407
2408 gl.glSamplerParameterf(m_target, m_pname, GL_SKIP_DECODE_EXT);
2409 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2410 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2411
2412 gl.glSamplerParameterfv(m_target, m_pname, &decodeFloat);
2413 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2414 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2415 }
2416
2417 if (isPureIntTester(m_tester))
2418 {
2419 const glw::GLint skipDecode = GL_SKIP_DECODE_EXT;
2420 const glw::GLint decode = GL_DECODE_EXT;
2421
2422 gl.glSamplerParameterIiv(m_target, m_pname, &skipDecode);
2423 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2424 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2425
2426 gl.glSamplerParameterIiv(m_target, m_pname, &decode);
2427 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2428 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2429 }
2430
2431 if (isPureUintTester(m_tester))
2432 {
2433 const glw::GLuint skipDecode = GL_SKIP_DECODE_EXT;
2434 const glw::GLuint decode = GL_DECODE_EXT;
2435
2436 gl.glSamplerParameterIuiv(m_target, m_pname, &skipDecode);
2437 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2438 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2439
2440 gl.glSamplerParameterIuiv(m_target, m_pname, &decode);
2441 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2442 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2443 }
2444 }
2445
2446 class SamplerBorderColorCase : public SamplerTest
2447 {
2448 public:
2449 SamplerBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, QueryType type);
2450 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2451 };
2452
SamplerBorderColorCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,QueryType type)2453 SamplerBorderColorCase::SamplerBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, QueryType type)
2454 : SamplerTest(testCtx, renderCtx, name, desc, TESTER_TEXTURE_BORDER_COLOR, type)
2455 {
2456 DE_ASSERT(m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 ||
2457 m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4 ||
2458 m_type == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4 ||
2459 m_type == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4);
2460 }
2461
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2462 void SamplerBorderColorCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2463 {
2464 // border color is undefined if queried with pure type and was not set to pure value
2465 if (m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4)
2466 {
2467 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2468 verifyStateSamplerParamFloatVec4(result, gl, m_target, m_pname, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), m_type);
2469 }
2470
2471 if (m_type == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4)
2472 {
2473 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2474 const tcu::IVec4 color (0x7FFFFFFF, -2, 3, -128);
2475
2476 gl.glSamplerParameterIiv(m_target, m_pname, color.getPtr());
2477 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2478
2479 verifyStateSamplerParamIntegerVec4(result, gl, m_target, m_pname, color, m_type);
2480 }
2481 else if (m_type == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4)
2482 {
2483 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2484 const tcu::UVec4 color (0x8000000ul, 2, 3, 128);
2485
2486 gl.glSamplerParameterIuiv(m_target, m_pname, color.getPtr());
2487 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2488
2489 verifyStateSamplerParamUnsignedIntegerVec4(result, gl, m_target, m_pname, color, m_type);
2490 }
2491 else
2492 {
2493 DE_ASSERT(m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4);
2494
2495 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2496 const tcu::Vec4 color (0.25f, 1.0f, 0.0f, 0.77f);
2497 const tcu::IVec4 icolor (0x8000000ul, 0x7FFFFFFF, 0, 0x0FFFFFFF);
2498
2499 gl.glSamplerParameterfv(m_target, m_pname, color.getPtr());
2500 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterfv");
2501
2502 verifyStateSamplerParamFloatVec4(result, gl, m_target, m_pname, color, m_type);
2503
2504 gl.glSamplerParameteriv(m_target, m_pname, icolor.getPtr());
2505 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteriv");
2506
2507 verifyStateSamplerParamNormalizedI32Vec4(result, gl, m_target, m_pname, icolor, m_type);
2508 }
2509 }
2510
2511 } // anonymous
2512
isLegalTesterForTarget(glw::GLenum target,TesterType tester)2513 bool isLegalTesterForTarget (glw::GLenum target, TesterType tester)
2514 {
2515 // no 3d filtering on 2d targets
2516 if ((tester == TESTER_TEXTURE_WRAP_R || tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER) && target != GL_TEXTURE_3D)
2517 return false;
2518
2519 // no sampling on multisample
2520 if (isMultisampleTarget(target) && isSamplerStateTester(tester))
2521 return false;
2522
2523 // no states in buffer
2524 if (target == GL_TEXTURE_BUFFER)
2525 return false;
2526
2527 return true;
2528 }
2529
isMultisampleTarget(glw::GLenum target)2530 bool isMultisampleTarget (glw::GLenum target)
2531 {
2532 return target == GL_TEXTURE_2D_MULTISAMPLE ||
2533 target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
2534 }
2535
isSamplerStateTester(TesterType tester)2536 bool isSamplerStateTester (TesterType tester)
2537 {
2538 return tester == TESTER_TEXTURE_WRAP_S ||
2539 tester == TESTER_TEXTURE_WRAP_T ||
2540 tester == TESTER_TEXTURE_WRAP_R ||
2541 tester == TESTER_TEXTURE_MAG_FILTER ||
2542 tester == TESTER_TEXTURE_MIN_FILTER ||
2543 tester == TESTER_TEXTURE_MIN_LOD ||
2544 tester == TESTER_TEXTURE_MAX_LOD ||
2545 tester == TESTER_TEXTURE_COMPARE_MODE ||
2546 tester == TESTER_TEXTURE_COMPARE_FUNC ||
2547 tester == TESTER_TEXTURE_SRGB_DECODE_EXT ||
2548 tester == TESTER_TEXTURE_BORDER_COLOR ||
2549 tester == TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER ||
2550 tester == TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER ||
2551 tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER;
2552 }
2553
createIsTextureTest(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const std::string & name,const std::string & description,glw::GLenum target)2554 tcu::TestCase* createIsTextureTest (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const std::string& name, const std::string& description, glw::GLenum target)
2555 {
2556 return new IsTextureCase(testCtx, renderCtx, name.c_str(), description.c_str(), target);
2557 }
2558
createTexParamTest(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const std::string & name,const std::string & description,QueryType queryType,glw::GLenum target,TesterType tester)2559 tcu::TestCase* createTexParamTest (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const std::string& name, const std::string& description, QueryType queryType, glw::GLenum target, TesterType tester)
2560 {
2561 if (isMultisampleTarget(target) && isSamplerStateTester(tester))
2562 {
2563 DE_FATAL("Multisample textures have no sampler state");
2564 return DE_NULL;
2565 }
2566 if (target == GL_TEXTURE_BUFFER)
2567 {
2568 DE_FATAL("Buffer textures have no texture state");
2569 return DE_NULL;
2570 }
2571 if (target != GL_TEXTURE_3D && mapTesterToPname(tester) == GL_TEXTURE_WRAP_R)
2572 {
2573 DE_FATAL("Only 3D textures have wrap r filter");
2574 return DE_NULL;
2575 }
2576
2577 #define CASE_ALL_SETTERS(X) case X: case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
2578
2579 switch (tester)
2580 {
2581 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R):
2582 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G):
2583 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B):
2584 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A):
2585 return new TextureSwizzleCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2586
2587 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S):
2588 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T):
2589 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R):
2590 return new TextureWrapCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2591
2592 CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER):
2593 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER):
2594 return new TextureFilterCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2595
2596 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD):
2597 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD):
2598 return new TextureLODCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2599
2600 CASE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL):
2601 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL):
2602 return new TextureLevelCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2603
2604 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE):
2605 return new TextureCompareModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2606
2607 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC):
2608 return new TextureCompareFuncCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2609
2610 case TESTER_TEXTURE_IMMUTABLE_LEVELS:
2611 return new TextureImmutableLevelsCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);
2612
2613 case TESTER_TEXTURE_IMMUTABLE_FORMAT:
2614 return new TextureImmutableFormatCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);
2615
2616 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
2617 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
2618 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
2619 return new TextureWrapClampToBorderCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2620
2621 CASE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE):
2622 return new DepthStencilModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2623
2624 CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):
2625 return new TextureSRGBDecodeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2626
2627 case TESTER_TEXTURE_BORDER_COLOR:
2628 return new TextureBorderColorCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);
2629
2630 default:
2631 break;
2632 }
2633
2634 #undef CASE_ALL_SETTERS
2635
2636 DE_ASSERT(false);
2637 return DE_NULL;
2638 }
2639
createSamplerParamTest(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const std::string & name,const std::string & description,StateQueryUtil::QueryType queryType,TesterType tester)2640 tcu::TestCase* createSamplerParamTest (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const std::string& name, const std::string& description, StateQueryUtil::QueryType queryType, TesterType tester)
2641 {
2642 #define CASE_ALL_SETTERS(X) case X: case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
2643
2644 switch (tester)
2645 {
2646 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S):
2647 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T):
2648 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R):
2649 return new SamplerWrapCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2650
2651 CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER):
2652 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER):
2653 return new SamplerFilterCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2654
2655 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD):
2656 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD):
2657 return new SamplerLODCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2658
2659 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE):
2660 return new SamplerCompareModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2661
2662 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC):
2663 return new SamplerCompareFuncCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2664
2665 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
2666 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
2667 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
2668 return new SamplerWrapClampToBorderCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2669
2670 CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):
2671 return new SamplerSRGBDecodeCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2672
2673 case TESTER_TEXTURE_BORDER_COLOR:
2674 return new SamplerBorderColorCase(testCtx, renderCtx, name.c_str(), description.c_str(), queryType);
2675
2676 default:
2677 break;
2678 }
2679
2680 #undef CASE_ALL_SETTERS
2681
2682 DE_ASSERT(false);
2683 return DE_NULL;
2684 }
2685
2686 } // TextureStateQueryTests
2687 } // gls
2688 } // deqp
2689