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