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