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 const 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 if (!isPureCase)
1196 {
1197 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1198 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initial, m_type);
1199 }
1200
1201 {
1202 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1203 std::vector<GLenum> values;
1204
1205 values.push_back(GL_NEAREST);
1206 values.push_back(GL_LINEAR);
1207 if (m_pname == GL_TEXTURE_MIN_FILTER)
1208 {
1209 values.push_back(GL_NEAREST_MIPMAP_NEAREST);
1210 values.push_back(GL_NEAREST_MIPMAP_LINEAR);
1211 values.push_back(GL_LINEAR_MIPMAP_NEAREST);
1212 values.push_back(GL_LINEAR_MIPMAP_LINEAR);
1213 }
1214
1215 if (isPureCase)
1216 {
1217 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1218 {
1219 if (isPureIntTester(m_tester))
1220 {
1221 const glw::GLint value = (glw::GLint)values[ndx];
1222 gl.glTexParameterIiv(m_target, m_pname, &value);
1223 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1224 }
1225 else
1226 {
1227 DE_ASSERT(isPureUintTester(m_tester));
1228
1229 const glw::GLuint value = values[ndx];
1230 gl.glTexParameterIuiv(m_target, m_pname, &value);
1231 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1232 }
1233
1234 verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1235 }
1236 }
1237 else
1238 {
1239 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1240 {
1241 gl.glTexParameteri(m_target, m_pname, values[ndx]);
1242 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1243
1244 verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1245 }
1246
1247 //check unit conversions with float
1248
1249 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1250 {
1251 gl.glTexParameterf(m_target, m_pname, (GLfloat)values[ndx]);
1252 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1253
1254 verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1255 }
1256 }
1257 }
1258 }
1259
1260 class TextureLODCase : public TextureTest
1261 {
1262 public:
1263 TextureLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1264 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1265 };
1266
TextureLODCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1267 TextureLODCase::TextureLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1268 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1269 {
1270 }
1271
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1272 void TextureLODCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1273 {
1274 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1275 const int initialValue = (m_pname == GL_TEXTURE_MIN_LOD) ? (-1000)
1276 : (m_pname == GL_TEXTURE_MAX_LOD) ? (1000)
1277 : (-1);
1278
1279 if ((querySupportsSigned(m_type) || initialValue >= 0) && !isPureCase)
1280 {
1281 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1282 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
1283 }
1284
1285 {
1286 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1287 const int numIterations = 20;
1288 de::Random rnd (0xabcdef);
1289
1290 if (isPureCase)
1291 {
1292 if (isPureIntTester(m_tester))
1293 {
1294 for (int ndx = 0; ndx < numIterations; ++ndx)
1295 {
1296 const GLint ref = rnd.getInt(-1000, 1000);
1297
1298 gl.glTexParameterIiv(m_target, m_pname, &ref);
1299 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1300
1301 verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1302 }
1303 }
1304 else
1305 {
1306 DE_ASSERT(isPureUintTester(m_tester));
1307
1308 for (int ndx = 0; ndx < numIterations; ++ndx)
1309 {
1310 const GLuint ref = (glw::GLuint)rnd.getInt(0, 1000);
1311
1312 gl.glTexParameterIuiv(m_target, m_pname, &ref);
1313 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1314
1315 verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1316 }
1317 }
1318 }
1319 else
1320 {
1321 const int minLimit = (querySupportsSigned(m_type)) ? (-1000) : (0);
1322
1323 for (int ndx = 0; ndx < numIterations; ++ndx)
1324 {
1325 const GLfloat ref = rnd.getFloat((float)minLimit, 1000.f);
1326
1327 gl.glTexParameterf(m_target, m_pname, ref);
1328 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1329
1330 verifyStateTextureParamFloat(result, gl, m_target, m_pname, ref, m_type);
1331 }
1332
1333 // check unit conversions with int
1334
1335 for (int ndx = 0; ndx < numIterations; ++ndx)
1336 {
1337 const GLint ref = rnd.getInt(minLimit, 1000);
1338
1339 gl.glTexParameteri(m_target, m_pname, ref);
1340 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1341
1342 verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1343 }
1344 }
1345 }
1346 }
1347
1348 class TextureLevelCase : public TextureTest
1349 {
1350 public:
1351 TextureLevelCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1352 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1353 };
1354
TextureLevelCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1355 TextureLevelCase::TextureLevelCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1356 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1357 {
1358 }
1359
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1360 void TextureLevelCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1361 {
1362 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1363 const int initialValue = (m_pname == GL_TEXTURE_BASE_LEVEL) ? (0)
1364 : (m_pname == GL_TEXTURE_MAX_LEVEL) ? (1000)
1365 : (-1);
1366
1367 if (!isPureCase)
1368 {
1369 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1370 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
1371 }
1372
1373 if (m_target == GL_TEXTURE_2D_MULTISAMPLE ||
1374 m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1375 {
1376 // only 0 allowed
1377 {
1378 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
1379
1380 gl.glTexParameteri(m_target, m_pname, 0);
1381 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1382 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1383
1384 gl.glTexParameterf(m_target, m_pname, 0.0f);
1385 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1386 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1387 }
1388 }
1389 else
1390 {
1391 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1392 const int numIterations = 20;
1393 de::Random rnd (0xabcdef);
1394
1395 if (isPureCase)
1396 {
1397 for (int ndx = 0; ndx < numIterations; ++ndx)
1398 {
1399 const GLint ref = rnd.getInt(0, 64000);
1400 const GLuint uRef = (glw::GLuint)ref;
1401
1402 if (isPureIntTester(m_tester))
1403 {
1404 gl.glTexParameterIiv(m_target, m_pname, &ref);
1405 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1406 }
1407 else
1408 {
1409 DE_ASSERT(isPureUintTester(m_tester));
1410 gl.glTexParameterIuiv(m_target, m_pname, &uRef);
1411 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1412 }
1413
1414 verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
1415 }
1416 }
1417 else
1418 {
1419 for (int ndx = 0; ndx < numIterations; ++ndx)
1420 {
1421 const GLint ref = rnd.getInt(0, 64000);
1422
1423 gl.glTexParameteri(m_target, m_pname, ref);
1424 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1425
1426 verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
1427 }
1428
1429 // check unit conversions with float
1430
1431 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
1432
1433 const int numConversionIterations = 30;
1434 for (int ndx = 0; ndx < numConversionIterations; ++ndx)
1435 {
1436 const GLint ref = rnd.getInt(1, 64000);
1437
1438 for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(nonSignificantOffsets); ++offsetNdx)
1439 {
1440 gl.glTexParameterf(m_target, m_pname, ((GLfloat)ref) + nonSignificantOffsets[offsetNdx]);
1441 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1442
1443 verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
1444 }
1445 }
1446 }
1447 }
1448 }
1449
1450 class TextureCompareModeCase : public TextureTest
1451 {
1452 public:
1453 TextureCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1454 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1455 };
1456
TextureCompareModeCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1457 TextureCompareModeCase::TextureCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1458 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1459 {
1460 }
1461
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1462 void TextureCompareModeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1463 {
1464 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1465
1466 if (!isPureCase)
1467 {
1468 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1469 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_NONE, m_type);
1470 }
1471
1472 {
1473 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1474 const GLenum modes[] = {GL_COMPARE_REF_TO_TEXTURE, GL_NONE};
1475
1476 if (isPureCase)
1477 {
1478 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
1479 {
1480 if (isPureIntTester(m_tester))
1481 {
1482 const glw::GLint value = (glw::GLint)modes[ndx];
1483 gl.glTexParameterIiv(m_target, m_pname, &value);
1484 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1485 }
1486 else
1487 {
1488 DE_ASSERT(isPureUintTester(m_tester));
1489
1490 const glw::GLuint value = modes[ndx];
1491 gl.glTexParameterIuiv(m_target, m_pname, &value);
1492 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1493 }
1494
1495 verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
1496 }
1497 }
1498 else
1499 {
1500 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
1501 {
1502 gl.glTexParameteri(m_target, m_pname, modes[ndx]);
1503 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1504
1505 verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
1506 }
1507
1508 //check unit conversions with float
1509
1510 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
1511 {
1512 gl.glTexParameterf(m_target, m_pname, (GLfloat)modes[ndx]);
1513 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1514
1515 verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
1516 }
1517 }
1518 }
1519 }
1520
1521 class TextureCompareFuncCase : public TextureTest
1522 {
1523 public:
1524 TextureCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1525 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1526 };
1527
TextureCompareFuncCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1528 TextureCompareFuncCase::TextureCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1529 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1530 {
1531 }
1532
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1533 void TextureCompareFuncCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1534 {
1535 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1536
1537 if (!isPureCase)
1538 {
1539 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1540 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_LEQUAL, m_type);
1541 }
1542
1543 {
1544 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1545 const GLenum compareFuncs[] = {GL_LEQUAL, GL_GEQUAL, GL_LESS, GL_GREATER, GL_EQUAL, GL_NOTEQUAL, GL_ALWAYS, GL_NEVER};
1546
1547 if (isPureCase)
1548 {
1549 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
1550 {
1551 if (isPureIntTester(m_tester))
1552 {
1553 const glw::GLint value = (glw::GLint)compareFuncs[ndx];
1554 gl.glTexParameterIiv(m_target, m_pname, &value);
1555 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1556 }
1557 else
1558 {
1559 DE_ASSERT(isPureUintTester(m_tester));
1560
1561 const glw::GLuint value = compareFuncs[ndx];
1562 gl.glTexParameterIuiv(m_target, m_pname, &value);
1563 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1564 }
1565
1566 verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
1567 }
1568 }
1569 else
1570 {
1571 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
1572 {
1573 gl.glTexParameteri(m_target, m_pname, compareFuncs[ndx]);
1574 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1575
1576 verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
1577 }
1578
1579 //check unit conversions with float
1580
1581 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
1582 {
1583 gl.glTexParameterf(m_target, m_pname, (GLfloat)compareFuncs[ndx]);
1584 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1585
1586 verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
1587 }
1588 }
1589 }
1590 }
1591
1592 class TextureImmutableLevelsCase : public TextureTest
1593 {
1594 public:
1595 TextureImmutableLevelsCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, QueryType type);
1596 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1597 };
1598
TextureImmutableLevelsCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,QueryType type)1599 TextureImmutableLevelsCase::TextureImmutableLevelsCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, QueryType type)
1600 : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_IMMUTABLE_LEVELS, type)
1601 {
1602 }
1603
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1604 void TextureImmutableLevelsCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1605 {
1606 {
1607 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1608 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1609 }
1610
1611 if (m_target == GL_TEXTURE_2D_MULTISAMPLE ||
1612 m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1613 {
1614 // no levels
1615 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Level", "Level");
1616 GLuint textureID = 0;
1617
1618 gl.glGenTextures(1, &textureID);
1619 gl.glBindTexture(m_target, textureID);
1620 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1621
1622 if (m_target == GL_TEXTURE_2D_MULTISAMPLE)
1623 gl.glTexStorage2DMultisample(m_target, 2, GL_RGB8, 64, 64, GL_FALSE);
1624 else if (m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1625 gl.glTexStorage3DMultisample(m_target, 2, GL_RGB8, 64, 64, 2, GL_FALSE);
1626 else
1627 DE_ASSERT(false);
1628 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexStorage");
1629
1630 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 1, m_type);
1631
1632 gl.glDeleteTextures(1, &textureID);
1633 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1634 }
1635 else
1636 {
1637 for (int level = 1; level <= 7; ++level)
1638 {
1639 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Levels", "Levels = " + de::toString(level));
1640 GLuint textureID = 0;
1641
1642 gl.glGenTextures(1, &textureID);
1643 gl.glBindTexture(m_target, textureID);
1644 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1645
1646 if (m_target == GL_TEXTURE_2D || m_target == GL_TEXTURE_CUBE_MAP)
1647 gl.glTexStorage2D(m_target, level, GL_RGB8, 64, 64);
1648 else if (m_target == GL_TEXTURE_2D_ARRAY || m_target == GL_TEXTURE_3D)
1649 gl.glTexStorage3D(m_target, level, GL_RGB8, 64, 64, 64);
1650 else if (m_target == GL_TEXTURE_CUBE_MAP_ARRAY)
1651 gl.glTexStorage3D(m_target, level, GL_RGB8, 64, 64, 6 * 2);
1652 else
1653 DE_ASSERT(false);
1654 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexStorage");
1655
1656 verifyStateTextureParamInteger(result, gl, m_target, m_pname, level, m_type);
1657
1658 gl.glDeleteTextures(1, &textureID);
1659 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1660 }
1661 }
1662 }
1663
1664 class TextureImmutableFormatCase : public TextureTest
1665 {
1666 public:
1667 TextureImmutableFormatCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, QueryType type);
1668 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1669 };
1670
TextureImmutableFormatCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,QueryType type)1671 TextureImmutableFormatCase::TextureImmutableFormatCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, QueryType type)
1672 : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_IMMUTABLE_FORMAT, type)
1673 {
1674 }
1675
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1676 void TextureImmutableFormatCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1677 {
1678 {
1679 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1680 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1681 }
1682
1683 {
1684 const tcu::ScopedLogSection subsection (m_testCtx.getLog(), "Immutable", "Immutable");
1685 GLuint textureID = 0;
1686
1687 gl.glGenTextures(1, &textureID);
1688 gl.glBindTexture(m_target, textureID);
1689 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1690
1691 switch (m_target)
1692 {
1693 case GL_TEXTURE_2D:
1694 case GL_TEXTURE_CUBE_MAP:
1695 {
1696 gl.glTexStorage2D(m_target, 1, GL_RGBA8, 32, 32);
1697 break;
1698 }
1699 case GL_TEXTURE_2D_ARRAY:
1700 case GL_TEXTURE_3D:
1701 {
1702 gl.glTexStorage3D(m_target, 1, GL_RGBA8, 32, 32, 8);
1703 break;
1704 }
1705 case GL_TEXTURE_2D_MULTISAMPLE:
1706 {
1707 gl.glTexStorage2DMultisample(m_target, 2, GL_RGB8, 64, 64, GL_FALSE);
1708 break;
1709 }
1710 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
1711 {
1712 gl.glTexStorage3DMultisample(m_target, 2, GL_RGB8, 64, 64, 2, GL_FALSE);
1713 break;
1714 }
1715 case GL_TEXTURE_CUBE_MAP_ARRAY:
1716 {
1717 gl.glTexStorage3D(m_target, 1, GL_RGBA8, 32, 32, 6 * 2);
1718 break;
1719 }
1720 default:
1721 DE_ASSERT(false);
1722 }
1723 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup texture");
1724
1725 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 1, m_type);
1726
1727 gl.glDeleteTextures(1, &textureID);
1728 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1729 }
1730
1731 // no mutable
1732 if (m_target == GL_TEXTURE_2D_MULTISAMPLE ||
1733 m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1734 return;
1735
1736 // test mutable
1737 {
1738 const tcu::ScopedLogSection subsection (m_testCtx.getLog(), "Mutable", "Mutable");
1739 GLuint textureID = 0;
1740
1741 gl.glGenTextures(1, &textureID);
1742 gl.glBindTexture(m_target, textureID);
1743 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1744
1745 switch (m_target)
1746 {
1747 case GL_TEXTURE_2D:
1748 {
1749 gl.glTexImage2D(m_target, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1750 break;
1751 }
1752 case GL_TEXTURE_CUBE_MAP:
1753 {
1754 gl.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1755 break;
1756 }
1757 case GL_TEXTURE_2D_ARRAY:
1758 case GL_TEXTURE_3D:
1759 {
1760 gl.glTexImage3D(m_target, 0, GL_RGBA8, 32, 32, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1761 break;
1762 }
1763 case GL_TEXTURE_CUBE_MAP_ARRAY:
1764 {
1765 gl.glTexImage3D(m_target, 0, GL_RGBA8, 32, 32, 6 * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1766 break;
1767 }
1768 default:
1769 DE_ASSERT(false);
1770 }
1771 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup texture");
1772
1773 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1774
1775 gl.glDeleteTextures(1, &textureID);
1776 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1777 }
1778 }
1779
1780 class TextureWrapClampToBorderCase : public TextureTest
1781 {
1782 public:
1783 TextureWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1784 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1785 };
1786
TextureWrapClampToBorderCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,TesterType tester,QueryType type)1787 TextureWrapClampToBorderCase::TextureWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1788 : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1789 {
1790 }
1791
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1792 void TextureWrapClampToBorderCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1793 {
1794 gl.glTexParameteri(m_target, m_pname, GL_CLAMP_TO_BORDER_EXT);
1795 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1796 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
1797
1798 gl.glTexParameteri(m_target, m_pname, GL_REPEAT);
1799 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1800
1801 gl.glTexParameterf(m_target, m_pname, (GLfloat)GL_CLAMP_TO_BORDER_EXT);
1802 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1803
1804 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
1805 }
1806
1807 class TextureBorderColorCase : public TextureTest
1808 {
1809 public:
1810 TextureBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, QueryType type);
1811 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1812 };
1813
TextureBorderColorCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,glw::GLenum target,QueryType type)1814 TextureBorderColorCase::TextureBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, QueryType type)
1815 : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_BORDER_COLOR, type)
1816 {
1817 }
1818
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1819 void TextureBorderColorCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1820 {
1821 // border color is undefined if queried with pure type and was not set to pure value
1822 if (m_type == QUERY_TEXTURE_PARAM_INTEGER_VEC4 || m_type == QUERY_TEXTURE_PARAM_FLOAT_VEC4)
1823 {
1824 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1825 verifyStateTextureParamFloatVec4(result, gl, m_target, m_pname, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), m_type);
1826 }
1827
1828 if (m_type == QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4)
1829 {
1830 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1831 const tcu::IVec4 color (0x7FFFFFFF, -2, 3, -128);
1832
1833 gl.glTexParameterIiv(m_target, m_pname, color.getPtr());
1834 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1835
1836 verifyStateTextureParamIntegerVec4(result, gl, m_target, m_pname, color, m_type);
1837 }
1838 else if (m_type == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4)
1839 {
1840 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1841 const tcu::UVec4 color (0x8000000ul, 2, 3, 128);
1842
1843 gl.glTexParameterIuiv(m_target, m_pname, color.getPtr());
1844 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1845
1846 verifyStateTextureParamUnsignedIntegerVec4(result, gl, m_target, m_pname, color, m_type);
1847 }
1848 else
1849 {
1850 DE_ASSERT(m_type == QUERY_TEXTURE_PARAM_INTEGER_VEC4 || m_type == QUERY_TEXTURE_PARAM_FLOAT_VEC4);
1851
1852 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1853 const tcu::Vec4 color (0.25f, 1.0f, 0.0f, 0.77f);
1854 const tcu::IVec4 icolor (0x8000000ul, 0x7FFFFFFF, 0, 0x0FFFFFFF);
1855
1856 gl.glTexParameterfv(m_target, m_pname, color.getPtr());
1857 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterfv");
1858
1859 verifyStateTextureParamFloatVec4(result, gl, m_target, m_pname, color, m_type);
1860
1861 gl.glTexParameteriv(m_target, m_pname, icolor.getPtr());
1862 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteriv");
1863
1864 verifyStateTextureParamNormalizedI32Vec4(result, gl, m_target, m_pname, icolor, m_type);
1865 }
1866 }
1867
1868 class SamplerTest : public tcu::TestCase
1869 {
1870 public:
1871 SamplerTest (tcu::TestContext& testCtx,
1872 const glu::RenderContext& renderCtx,
1873 const char* name,
1874 const char* desc,
1875 TesterType tester,
1876 QueryType type);
1877
1878 void init (void);
1879 IterateResult iterate (void);
1880
1881 virtual void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const = 0;
1882
1883 protected:
1884 const glu::RenderContext& m_renderCtx;
1885 const glw::GLenum m_pname;
1886 const TesterType m_tester;
1887 const QueryType m_type;
1888 glw::GLuint m_target;
1889 };
1890
SamplerTest(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)1891 SamplerTest::SamplerTest (tcu::TestContext& testCtx,
1892 const glu::RenderContext& renderCtx,
1893 const char* name,
1894 const char* desc,
1895 TesterType tester,
1896 QueryType type)
1897 : TestCase (testCtx, name, desc)
1898 , m_renderCtx (renderCtx)
1899 , m_pname (mapTesterToPname(tester))
1900 , m_tester (tester)
1901 , m_type (type)
1902 , m_target (0)
1903 {
1904 }
1905
init(void)1906 void SamplerTest::init (void)
1907 {
1908 const de::UniquePtr<glu::ContextInfo> ctxInfo (glu::ContextInfo::create(m_renderCtx));
1909 RequiredExtensions extensions;
1910
1911 // param
1912 if (!isCoreTextureParam(m_renderCtx.getType(), m_pname))
1913 extensions.add(getTextureParamExtension(m_renderCtx.getType(), m_pname));
1914
1915 // query
1916 if (!isCoreQuery(m_renderCtx.getType(), m_type))
1917 extensions.add(getQueryExtension(m_renderCtx.getType(), m_type));
1918
1919 // test type
1920 if (!isCoreTester(m_renderCtx.getType(), m_tester))
1921 extensions.add(getTesterExtension(m_renderCtx.getType(), m_tester));
1922
1923 extensions.check(*ctxInfo);
1924 }
1925
iterate(void)1926 SamplerTest::IterateResult SamplerTest::iterate (void)
1927 {
1928 glu::CallLogWrapper gl (m_renderCtx.getFunctions(), m_testCtx.getLog());
1929 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
1930 glu::Sampler sampler (m_renderCtx);
1931
1932 gl.enableLogging(true);
1933
1934 m_target = *sampler;
1935 test(gl, result);
1936 m_target = 0;
1937
1938 result.setTestContextResult(m_testCtx);
1939 return STOP;
1940 }
1941
1942 class SamplerWrapCase : public SamplerTest
1943 {
1944 public:
1945 SamplerWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
1946 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1947 };
1948
SamplerWrapCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)1949 SamplerWrapCase::SamplerWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
1950 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
1951 {
1952 }
1953
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const1954 void SamplerWrapCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1955 {
1956 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1957
1958 if (!isPureCase)
1959 {
1960 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1961 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_REPEAT, m_type);
1962 }
1963
1964 {
1965 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
1966 const GLenum wrapValues[] = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT};
1967
1968 if (isPureCase)
1969 {
1970 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
1971 {
1972 if (isPureIntTester(m_tester))
1973 {
1974 const glw::GLint value = (glw::GLint)wrapValues[ndx];
1975 gl.glSamplerParameterIiv(m_target, m_pname, &value);
1976 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
1977 }
1978 else
1979 {
1980 DE_ASSERT(isPureUintTester(m_tester));
1981
1982 const glw::GLuint value = wrapValues[ndx];
1983 gl.glSamplerParameterIuiv(m_target, m_pname, &value);
1984 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
1985 }
1986
1987 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
1988 }
1989 }
1990 else
1991 {
1992 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
1993 {
1994 gl.glSamplerParameteri(m_target, m_pname, wrapValues[ndx]);
1995 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
1996
1997 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
1998 }
1999
2000 //check unit conversions with float
2001
2002 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
2003 {
2004 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)wrapValues[ndx]);
2005 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2006
2007 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
2008 }
2009 }
2010 }
2011 }
2012
2013 class SamplerFilterCase : public SamplerTest
2014 {
2015 public:
2016 SamplerFilterCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2017 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2018 };
2019
SamplerFilterCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2020 SamplerFilterCase::SamplerFilterCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2021 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2022 {
2023 }
2024
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2025 void SamplerFilterCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2026 {
2027 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2028 const glw::GLenum initial = (m_pname == GL_TEXTURE_MAG_FILTER) ? (GL_LINEAR)
2029 : (m_pname == GL_TEXTURE_MIN_FILTER) ? (GL_NEAREST_MIPMAP_LINEAR)
2030 : (0);
2031
2032 if (!isPureCase)
2033 {
2034 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2035 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, initial, m_type);
2036 }
2037
2038 {
2039 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2040 std::vector<GLenum> values;
2041
2042 values.push_back(GL_NEAREST);
2043 values.push_back(GL_LINEAR);
2044 if (m_pname == GL_TEXTURE_MIN_FILTER)
2045 {
2046 values.push_back(GL_NEAREST_MIPMAP_NEAREST);
2047 values.push_back(GL_NEAREST_MIPMAP_LINEAR);
2048 values.push_back(GL_LINEAR_MIPMAP_NEAREST);
2049 values.push_back(GL_LINEAR_MIPMAP_LINEAR);
2050 }
2051
2052 if (isPureCase)
2053 {
2054 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
2055 {
2056 if (isPureIntTester(m_tester))
2057 {
2058 const glw::GLint value = (glw::GLint)values[ndx];
2059 gl.glSamplerParameterIiv(m_target, m_pname, &value);
2060 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2061 }
2062 else
2063 {
2064 DE_ASSERT(isPureUintTester(m_tester));
2065
2066 const glw::GLuint value = values[ndx];
2067 gl.glSamplerParameterIuiv(m_target, m_pname, &value);
2068 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2069 }
2070
2071 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
2072 }
2073 }
2074 else
2075 {
2076 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
2077 {
2078 gl.glSamplerParameteri(m_target, m_pname, values[ndx]);
2079 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2080
2081 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
2082 }
2083
2084 //check unit conversions with float
2085
2086 for (int ndx = 0; ndx < (int)values.size(); ++ndx)
2087 {
2088 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)values[ndx]);
2089 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2090
2091 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
2092 }
2093 }
2094 }
2095 }
2096
2097 class SamplerLODCase : public SamplerTest
2098 {
2099 public:
2100 SamplerLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2101 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2102 };
2103
SamplerLODCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2104 SamplerLODCase::SamplerLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2105 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2106 {
2107 }
2108
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2109 void SamplerLODCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2110 {
2111 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2112 const int initialValue = (m_pname == GL_TEXTURE_MIN_LOD) ? (-1000)
2113 : (m_pname == GL_TEXTURE_MAX_LOD) ? (1000)
2114 : (-1);
2115
2116 if ((querySupportsSigned(m_type) || initialValue >= 0) && !isPureCase)
2117 {
2118 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2119 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
2120 }
2121
2122 {
2123 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2124 const int numIterations = 20;
2125 de::Random rnd (0xabcdef);
2126
2127 if (isPureCase)
2128 {
2129 if (isPureIntTester(m_tester))
2130 {
2131 for (int ndx = 0; ndx < numIterations; ++ndx)
2132 {
2133 const GLint ref = rnd.getInt(-1000, 1000);
2134
2135 gl.glSamplerParameterIiv(m_target, m_pname, &ref);
2136 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2137
2138 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
2139 }
2140 }
2141 else
2142 {
2143 DE_ASSERT(isPureUintTester(m_tester));
2144
2145 for (int ndx = 0; ndx < numIterations; ++ndx)
2146 {
2147 const GLuint ref = (glw::GLuint)rnd.getInt(0, 1000);
2148
2149 gl.glSamplerParameterIuiv(m_target, m_pname, &ref);
2150 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2151
2152 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
2153 }
2154 }
2155 }
2156 else
2157 {
2158 const int minLimit = (querySupportsSigned(m_type)) ? (-1000) : (0);
2159
2160 for (int ndx = 0; ndx < numIterations; ++ndx)
2161 {
2162 const GLfloat ref = rnd.getFloat((float)minLimit, 1000.f);
2163
2164 gl.glSamplerParameterf(m_target, m_pname, ref);
2165 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2166
2167 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, ref, m_type);
2168 }
2169
2170 // check unit conversions with int
2171
2172 for (int ndx = 0; ndx < numIterations; ++ndx)
2173 {
2174 const GLint ref = rnd.getInt(minLimit, 1000);
2175
2176 gl.glSamplerParameteri(m_target, m_pname, ref);
2177 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2178
2179 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
2180 }
2181 }
2182 }
2183 }
2184
2185 class SamplerCompareModeCase : public SamplerTest
2186 {
2187 public:
2188 SamplerCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2189 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2190 };
2191
SamplerCompareModeCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2192 SamplerCompareModeCase::SamplerCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2193 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2194 {
2195 }
2196
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2197 void SamplerCompareModeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2198 {
2199 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2200
2201 if (!isPureCase)
2202 {
2203 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2204 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_NONE, m_type);
2205 }
2206
2207 {
2208 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2209 const GLenum modes[] = {GL_COMPARE_REF_TO_TEXTURE, GL_NONE};
2210
2211 if (isPureCase)
2212 {
2213 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
2214 {
2215 if (isPureIntTester(m_tester))
2216 {
2217 const glw::GLint value = (glw::GLint)modes[ndx];
2218 gl.glSamplerParameterIiv(m_target, m_pname, &value);
2219 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2220 }
2221 else
2222 {
2223 DE_ASSERT(isPureUintTester(m_tester));
2224
2225 const glw::GLuint value = modes[ndx];
2226 gl.glSamplerParameterIuiv(m_target, m_pname, &value);
2227 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2228 }
2229
2230 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
2231 }
2232 }
2233 else
2234 {
2235 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
2236 {
2237 gl.glSamplerParameteri(m_target, m_pname, modes[ndx]);
2238 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2239
2240 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
2241 }
2242
2243 //check unit conversions with float
2244
2245 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
2246 {
2247 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)modes[ndx]);
2248 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2249
2250 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
2251 }
2252 }
2253 }
2254 }
2255
2256 class SamplerCompareFuncCase : public SamplerTest
2257 {
2258 public:
2259 SamplerCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2260 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2261 };
2262
SamplerCompareFuncCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2263 SamplerCompareFuncCase::SamplerCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2264 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2265 {
2266 }
2267
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2268 void SamplerCompareFuncCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2269 {
2270 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2271
2272 if (!isPureCase)
2273 {
2274 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2275 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_LEQUAL, m_type);
2276 }
2277
2278 {
2279 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2280 const GLenum compareFuncs[] = {GL_LEQUAL, GL_GEQUAL, GL_LESS, GL_GREATER, GL_EQUAL, GL_NOTEQUAL, GL_ALWAYS, GL_NEVER};
2281
2282 if (isPureCase)
2283 {
2284 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
2285 {
2286 if (isPureIntTester(m_tester))
2287 {
2288 const glw::GLint value = (glw::GLint)compareFuncs[ndx];
2289 gl.glSamplerParameterIiv(m_target, m_pname, &value);
2290 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2291 }
2292 else
2293 {
2294 DE_ASSERT(isPureUintTester(m_tester));
2295
2296 const glw::GLuint value = compareFuncs[ndx];
2297 gl.glSamplerParameterIuiv(m_target, m_pname, &value);
2298 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2299 }
2300
2301 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
2302 }
2303 }
2304 else
2305 {
2306 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
2307 {
2308 gl.glSamplerParameteri(m_target, m_pname, compareFuncs[ndx]);
2309 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2310
2311 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
2312 }
2313
2314 //check unit conversions with float
2315
2316 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
2317 {
2318 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)compareFuncs[ndx]);
2319 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2320
2321 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
2322 }
2323 }
2324 }
2325 }
2326
2327 class SamplerWrapClampToBorderCase : public SamplerTest
2328 {
2329 public:
2330 SamplerWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2331 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2332 };
2333
SamplerWrapClampToBorderCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2334 SamplerWrapClampToBorderCase::SamplerWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2335 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2336 {
2337 }
2338
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2339 void SamplerWrapClampToBorderCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2340 {
2341 gl.glSamplerParameteri(m_target, m_pname, GL_CLAMP_TO_BORDER_EXT);
2342 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2343 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
2344
2345 gl.glSamplerParameteri(m_target, m_pname, GL_REPEAT);
2346 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2347
2348 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)GL_CLAMP_TO_BORDER_EXT);
2349 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2350
2351 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
2352 }
2353
2354 class SamplerSRGBDecodeCase : public SamplerTest
2355 {
2356 public:
2357 SamplerSRGBDecodeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2358 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2359 };
2360
SamplerSRGBDecodeCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,TesterType tester,QueryType type)2361 SamplerSRGBDecodeCase::SamplerSRGBDecodeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2362 : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2363 {
2364 }
2365
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2366 void SamplerSRGBDecodeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2367 {
2368 const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2369
2370 if (!isPureCase)
2371 {
2372 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2373 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2374 }
2375
2376 {
2377 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Toggle", "Toggle");
2378 const glw::GLint decodeInt = GL_DECODE_EXT;
2379 const glw::GLfloat decodeFloat = (glw::GLfloat)GL_DECODE_EXT;
2380
2381 gl.glSamplerParameteri(m_target, m_pname, GL_SKIP_DECODE_EXT);
2382 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2383 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2384
2385 gl.glSamplerParameteriv(m_target, m_pname, &decodeInt);
2386 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2387 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2388
2389 gl.glSamplerParameterf(m_target, m_pname, GL_SKIP_DECODE_EXT);
2390 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2391 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2392
2393 gl.glSamplerParameterfv(m_target, m_pname, &decodeFloat);
2394 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2395 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2396 }
2397
2398 if (isPureIntTester(m_tester))
2399 {
2400 const glw::GLint skipDecode = GL_SKIP_DECODE_EXT;
2401 const glw::GLint decode = GL_DECODE_EXT;
2402
2403 gl.glSamplerParameterIiv(m_target, m_pname, &skipDecode);
2404 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2405 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2406
2407 gl.glSamplerParameterIiv(m_target, m_pname, &decode);
2408 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2409 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2410 }
2411
2412 if (isPureUintTester(m_tester))
2413 {
2414 const glw::GLuint skipDecode = GL_SKIP_DECODE_EXT;
2415 const glw::GLuint decode = GL_DECODE_EXT;
2416
2417 gl.glSamplerParameterIuiv(m_target, m_pname, &skipDecode);
2418 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2419 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2420
2421 gl.glSamplerParameterIuiv(m_target, m_pname, &decode);
2422 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2423 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2424 }
2425 }
2426
2427 class SamplerBorderColorCase : public SamplerTest
2428 {
2429 public:
2430 SamplerBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, QueryType type);
2431 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2432 };
2433
SamplerBorderColorCase(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const char * name,const char * desc,QueryType type)2434 SamplerBorderColorCase::SamplerBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, QueryType type)
2435 : SamplerTest(testCtx, renderCtx, name, desc, TESTER_TEXTURE_BORDER_COLOR, type)
2436 {
2437 DE_ASSERT(m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 ||
2438 m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4 ||
2439 m_type == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4 ||
2440 m_type == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4);
2441 }
2442
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2443 void SamplerBorderColorCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2444 {
2445 // border color is undefined if queried with pure type and was not set to pure value
2446 if (m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4)
2447 {
2448 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2449 verifyStateSamplerParamFloatVec4(result, gl, m_target, m_pname, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), m_type);
2450 }
2451
2452 if (m_type == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4)
2453 {
2454 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2455 const tcu::IVec4 color (0x7FFFFFFF, -2, 3, -128);
2456
2457 gl.glSamplerParameterIiv(m_target, m_pname, color.getPtr());
2458 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2459
2460 verifyStateSamplerParamIntegerVec4(result, gl, m_target, m_pname, color, m_type);
2461 }
2462 else if (m_type == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4)
2463 {
2464 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2465 const tcu::UVec4 color (0x8000000ul, 2, 3, 128);
2466
2467 gl.glSamplerParameterIuiv(m_target, m_pname, color.getPtr());
2468 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2469
2470 verifyStateSamplerParamUnsignedIntegerVec4(result, gl, m_target, m_pname, color, m_type);
2471 }
2472 else
2473 {
2474 DE_ASSERT(m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4);
2475
2476 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Set", "Set");
2477 const tcu::Vec4 color (0.25f, 1.0f, 0.0f, 0.77f);
2478 const tcu::IVec4 icolor (0x8000000ul, 0x7FFFFFFF, 0, 0x0FFFFFFF);
2479
2480 gl.glSamplerParameterfv(m_target, m_pname, color.getPtr());
2481 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterfv");
2482
2483 verifyStateSamplerParamFloatVec4(result, gl, m_target, m_pname, color, m_type);
2484
2485 gl.glSamplerParameteriv(m_target, m_pname, icolor.getPtr());
2486 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteriv");
2487
2488 verifyStateSamplerParamNormalizedI32Vec4(result, gl, m_target, m_pname, icolor, m_type);
2489 }
2490 }
2491
2492 } // anonymous
2493
isLegalTesterForTarget(glw::GLenum target,TesterType tester)2494 bool isLegalTesterForTarget (glw::GLenum target, TesterType tester)
2495 {
2496 // no 3d filtering on 2d targets
2497 if ((tester == TESTER_TEXTURE_WRAP_R || tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER) && target != GL_TEXTURE_3D)
2498 return false;
2499
2500 // no sampling on multisample
2501 if (isMultisampleTarget(target) && isSamplerStateTester(tester))
2502 return false;
2503
2504 // no states in buffer
2505 if (target == GL_TEXTURE_BUFFER)
2506 return false;
2507
2508 return true;
2509 }
2510
isMultisampleTarget(glw::GLenum target)2511 bool isMultisampleTarget (glw::GLenum target)
2512 {
2513 return target == GL_TEXTURE_2D_MULTISAMPLE ||
2514 target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
2515 }
2516
isSamplerStateTester(TesterType tester)2517 bool isSamplerStateTester (TesterType tester)
2518 {
2519 return tester == TESTER_TEXTURE_WRAP_S ||
2520 tester == TESTER_TEXTURE_WRAP_T ||
2521 tester == TESTER_TEXTURE_WRAP_R ||
2522 tester == TESTER_TEXTURE_MAG_FILTER ||
2523 tester == TESTER_TEXTURE_MIN_FILTER ||
2524 tester == TESTER_TEXTURE_MIN_LOD ||
2525 tester == TESTER_TEXTURE_MAX_LOD ||
2526 tester == TESTER_TEXTURE_COMPARE_MODE ||
2527 tester == TESTER_TEXTURE_COMPARE_FUNC ||
2528 tester == TESTER_TEXTURE_SRGB_DECODE_EXT ||
2529 tester == TESTER_TEXTURE_BORDER_COLOR ||
2530 tester == TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER ||
2531 tester == TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER ||
2532 tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER;
2533 }
2534
createIsTextureTest(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const std::string & name,const std::string & description,glw::GLenum target)2535 tcu::TestCase* createIsTextureTest (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const std::string& name, const std::string& description, glw::GLenum target)
2536 {
2537 return new IsTextureCase(testCtx, renderCtx, name.c_str(), description.c_str(), target);
2538 }
2539
createTexParamTest(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const std::string & name,const std::string & description,QueryType queryType,glw::GLenum target,TesterType tester)2540 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)
2541 {
2542 if (isMultisampleTarget(target) && isSamplerStateTester(tester))
2543 {
2544 DE_FATAL("Multisample textures have no sampler state");
2545 return DE_NULL;
2546 }
2547 if (target == GL_TEXTURE_BUFFER)
2548 {
2549 DE_FATAL("Buffer textures have no texture state");
2550 return DE_NULL;
2551 }
2552 if (target != GL_TEXTURE_3D && mapTesterToPname(tester) == GL_TEXTURE_WRAP_R)
2553 {
2554 DE_FATAL("Only 3D textures have wrap r filter");
2555 return DE_NULL;
2556 }
2557
2558 #define CASE_ALL_SETTERS(X) case X: case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
2559
2560 switch (tester)
2561 {
2562 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R):
2563 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G):
2564 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B):
2565 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A):
2566 return new TextureSwizzleCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2567
2568 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S):
2569 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T):
2570 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R):
2571 return new TextureWrapCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2572
2573 CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER):
2574 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER):
2575 return new TextureFilterCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2576
2577 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD):
2578 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD):
2579 return new TextureLODCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2580
2581 CASE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL):
2582 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL):
2583 return new TextureLevelCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2584
2585 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE):
2586 return new TextureCompareModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2587
2588 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC):
2589 return new TextureCompareFuncCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2590
2591 case TESTER_TEXTURE_IMMUTABLE_LEVELS:
2592 return new TextureImmutableLevelsCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);
2593
2594 case TESTER_TEXTURE_IMMUTABLE_FORMAT:
2595 return new TextureImmutableFormatCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);
2596
2597 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
2598 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
2599 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
2600 return new TextureWrapClampToBorderCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2601
2602 CASE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE):
2603 return new DepthStencilModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2604
2605 CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):
2606 return new TextureSRGBDecodeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2607
2608 case TESTER_TEXTURE_BORDER_COLOR:
2609 return new TextureBorderColorCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);
2610
2611 default:
2612 break;
2613 }
2614
2615 #undef CASE_ALL_SETTERS
2616
2617 DE_ASSERT(false);
2618 return DE_NULL;
2619 }
2620
createSamplerParamTest(tcu::TestContext & testCtx,const glu::RenderContext & renderCtx,const std::string & name,const std::string & description,StateQueryUtil::QueryType queryType,TesterType tester)2621 tcu::TestCase* createSamplerParamTest (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const std::string& name, const std::string& description, StateQueryUtil::QueryType queryType, TesterType tester)
2622 {
2623 #define CASE_ALL_SETTERS(X) case X: case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
2624
2625 switch (tester)
2626 {
2627 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S):
2628 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T):
2629 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R):
2630 return new SamplerWrapCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2631
2632 CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER):
2633 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER):
2634 return new SamplerFilterCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2635
2636 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD):
2637 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD):
2638 return new SamplerLODCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2639
2640 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE):
2641 return new SamplerCompareModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2642
2643 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC):
2644 return new SamplerCompareFuncCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2645
2646 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
2647 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
2648 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
2649 return new SamplerWrapClampToBorderCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2650
2651 CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):
2652 return new SamplerSRGBDecodeCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2653
2654 case TESTER_TEXTURE_BORDER_COLOR:
2655 return new SamplerBorderColorCase(testCtx, renderCtx, name.c_str(), description.c_str(), queryType);
2656
2657 default:
2658 break;
2659 }
2660
2661 #undef CASE_ALL_SETTERS
2662
2663 DE_ASSERT(false);
2664 return DE_NULL;
2665 }
2666
2667 } // TextureStateQueryTests
2668 } // gls
2669 } // deqp
2670