es31fIndexedStateQueryTests.cpp revision 012f21ddfb2c86a2960edd65a3f0ea8f1fcd7832
1/*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 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 Indexed state query tests 22 *//*--------------------------------------------------------------------*/ 23 24#include "es31fIndexedStateQueryTests.hpp" 25#include "tcuTestLog.hpp" 26#include "tcuFormatUtil.hpp" 27#include "gluRenderContext.hpp" 28#include "gluCallLogWrapper.hpp" 29#include "gluStrUtil.hpp" 30#include "gluContextInfo.hpp" 31#include "gluObjectWrapper.hpp" 32#include "glwFunctions.hpp" 33#include "glwEnums.hpp" 34#include "glsStateQueryUtil.hpp" 35#include "deRandom.hpp" 36#include "deStringUtil.hpp" 37 38namespace deqp 39{ 40namespace gles31 41{ 42namespace Functional 43{ 44namespace 45{ 46 47using namespace gls::StateQueryUtil; 48 49static const char* getVerifierSuffix (QueryType type) 50{ 51 switch (type) 52 { 53 case QUERY_INDEXED_BOOLEAN: return "getbooleani_v"; 54 case QUERY_INDEXED_INTEGER: return "getintegeri_v"; 55 case QUERY_INDEXED_INTEGER64: return "getinteger64i_v"; 56 case QUERY_INDEXED_BOOLEAN_VEC4: return "getbooleani_v"; 57 case QUERY_INDEXED_INTEGER_VEC4: return "getintegeri_v"; 58 case QUERY_INDEXED_INTEGER64_VEC4: return "getinteger64i_v"; 59 case QUERY_INDEXED_ISENABLED: return "isenabledi"; 60 default: 61 DE_ASSERT(DE_FALSE); 62 return DE_NULL; 63 } 64} 65 66class SampleMaskCase : public TestCase 67{ 68public: 69 SampleMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType); 70 71private: 72 void init (void); 73 IterateResult iterate (void); 74 75 const QueryType m_verifierType; 76 int m_maxSampleMaskWords; 77}; 78 79SampleMaskCase::SampleMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType) 80 : TestCase (context, name, desc) 81 , m_verifierType (verifierType) 82 , m_maxSampleMaskWords (-1) 83{ 84} 85 86void SampleMaskCase::init (void) 87{ 88 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 89 90 gl.getIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &m_maxSampleMaskWords); 91 GLU_EXPECT_NO_ERROR(gl.getError(), "query sample mask words"); 92 93 // mask word count ok? 94 if (m_maxSampleMaskWords <= 0) 95 throw tcu::TestError("Minimum value of GL_MAX_SAMPLE_MASK_WORDS is 1. Got " + de::toString(m_maxSampleMaskWords)); 96 97 m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_SAMPLE_MASK_WORDS = " << m_maxSampleMaskWords << tcu::TestLog::EndMessage; 98} 99 100SampleMaskCase::IterateResult SampleMaskCase::iterate (void) 101{ 102 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 103 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 104 105 gl.enableLogging(true); 106 107 // initial values 108 { 109 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values"); 110 111 for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx) 112 verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, -1, m_verifierType); 113 } 114 115 // fixed values 116 { 117 const tcu::ScopedLogSection section(m_testCtx.getLog(), "fixed", "Fixed values"); 118 119 for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx) 120 { 121 gl.glSampleMaski(ndx, 0); 122 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski"); 123 124 verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, 0, m_verifierType); 125 } 126 } 127 128 // random masks 129 { 130 const int numRandomTest = 20; 131 const tcu::ScopedLogSection section (m_testCtx.getLog(), "random", "Random values"); 132 de::Random rnd (0x4312); 133 134 for (int testNdx = 0; testNdx < numRandomTest; ++testNdx) 135 { 136 const glw::GLint maskIndex = (glw::GLint)(rnd.getUint32() % m_maxSampleMaskWords); 137 glw::GLint mask = (glw::GLint)(rnd.getUint32()); 138 139 gl.glSampleMaski(maskIndex, mask); 140 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski"); 141 142 verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, maskIndex, mask, m_verifierType); 143 } 144 } 145 146 result.setTestContextResult(m_testCtx); 147 return STOP; 148} 149 150class MinValueIndexed3Case : public TestCase 151{ 152public: 153 MinValueIndexed3Case (Context& context, const char* name, const char* desc, glw::GLenum target, const tcu::IVec3& ref, QueryType verifierType); 154 155private: 156 IterateResult iterate (void); 157 158 const glw::GLenum m_target; 159 const tcu::IVec3 m_ref; 160 const QueryType m_verifierType; 161}; 162 163MinValueIndexed3Case::MinValueIndexed3Case (Context& context, const char* name, const char* desc, glw::GLenum target, const tcu::IVec3& ref, QueryType verifierType) 164 : TestCase (context, name, desc) 165 , m_target (target) 166 , m_ref (ref) 167 , m_verifierType (verifierType) 168{ 169} 170 171MinValueIndexed3Case::IterateResult MinValueIndexed3Case::iterate (void) 172{ 173 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 174 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 175 176 gl.enableLogging(true); 177 178 for (int ndx = 0; ndx < 3; ++ndx) 179 { 180 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Element", "Element " + de::toString(ndx)); 181 182 verifyStateIndexedIntegerMin(result, gl, m_target, ndx, m_ref[ndx], m_verifierType); 183 } 184 185 result.setTestContextResult(m_testCtx); 186 return STOP; 187} 188 189class BufferBindingCase : public TestCase 190{ 191public: 192 BufferBindingCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType); 193 194private: 195 IterateResult iterate (void); 196 197 const glw::GLenum m_queryTarget; 198 const glw::GLenum m_bufferTarget; 199 const glw::GLenum m_numBindingsTarget; 200 const QueryType m_verifierType; 201}; 202 203BufferBindingCase::BufferBindingCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType) 204 : TestCase (context, name, desc) 205 , m_queryTarget (queryTarget) 206 , m_bufferTarget (bufferTarget) 207 , m_numBindingsTarget (numBindingsTarget) 208 , m_verifierType (verifierType) 209{ 210} 211 212BufferBindingCase::IterateResult BufferBindingCase::iterate (void) 213{ 214 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 215 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 216 int maxBindings = -1; 217 218 gl.enableLogging(true); 219 220 gl.glGetIntegerv(m_numBindingsTarget, &maxBindings); 221 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 222 223 { 224 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 225 226 for (int ndx = 0; ndx < maxBindings; ++ndx) 227 verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType); 228 } 229 230 { 231 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting"); 232 glu::Buffer bufferA (m_context.getRenderContext()); 233 glu::Buffer bufferB (m_context.getRenderContext()); 234 const int ndxA = 0; 235 const int ndxB = maxBindings / 2; 236 237 { 238 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point"); 239 240 gl.glBindBuffer(m_bufferTarget, *bufferA); 241 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBuffer"); 242 243 verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType); 244 } 245 { 246 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase"); 247 248 gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA); 249 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferBase"); 250 251 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType); 252 } 253 { 254 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange"); 255 256 gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8); 257 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferRange"); 258 259 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, *bufferB, m_verifierType); 260 } 261 if (ndxA != ndxB) 262 { 263 const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change"); 264 265 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType); 266 } 267 } 268 269 result.setTestContextResult(m_testCtx); 270 return STOP; 271} 272 273class BufferStartCase : public TestCase 274{ 275public: 276 BufferStartCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType); 277 278private: 279 IterateResult iterate (void); 280 281 const glw::GLenum m_queryTarget; 282 const glw::GLenum m_bufferTarget; 283 const glw::GLenum m_numBindingsTarget; 284 const QueryType m_verifierType; 285}; 286 287BufferStartCase::BufferStartCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType) 288 : TestCase (context, name, desc) 289 , m_queryTarget (queryTarget) 290 , m_bufferTarget (bufferTarget) 291 , m_numBindingsTarget (numBindingsTarget) 292 , m_verifierType (verifierType) 293{ 294} 295 296BufferStartCase::IterateResult BufferStartCase::iterate (void) 297{ 298 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 299 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 300 int maxBindings = -1; 301 302 gl.enableLogging(true); 303 304 gl.glGetIntegerv(m_numBindingsTarget, &maxBindings); 305 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 306 307 { 308 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 309 310 for (int ndx = 0; ndx < maxBindings; ++ndx) 311 verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType); 312 } 313 314 315 { 316 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting"); 317 glu::Buffer bufferA (m_context.getRenderContext()); 318 glu::Buffer bufferB (m_context.getRenderContext()); 319 const int ndxA = 0; 320 const int ndxB = maxBindings / 2; 321 int offset = -1; 322 323 if (m_bufferTarget == GL_ATOMIC_COUNTER_BUFFER) 324 offset = 4; 325 else if (m_bufferTarget == GL_SHADER_STORAGE_BUFFER) 326 { 327 gl.glGetIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &offset); 328 GLU_EXPECT_NO_ERROR(gl.glGetError(), "get align"); 329 } 330 else 331 DE_ASSERT(false); 332 333 TCU_CHECK(offset >= 0); 334 335 { 336 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point"); 337 338 gl.glBindBuffer(m_bufferTarget, *bufferA); 339 gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ); 340 gl.glBindBuffer(m_bufferTarget, *bufferB); 341 gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ); 342 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs"); 343 344 verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType); 345 } 346 { 347 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase"); 348 349 gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA); 350 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf"); 351 352 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType); 353 } 354 { 355 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange"); 356 357 gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, offset, 8); 358 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf"); 359 360 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, offset, m_verifierType); 361 } 362 if (ndxA != ndxB) 363 { 364 const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change"); 365 366 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType); 367 } 368 } 369 370 result.setTestContextResult(m_testCtx); 371 return STOP; 372} 373 374class BufferSizeCase : public TestCase 375{ 376public: 377 BufferSizeCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType); 378 379private: 380 IterateResult iterate (void); 381 382 const glw::GLenum m_queryTarget; 383 const glw::GLenum m_bufferTarget; 384 const glw::GLenum m_numBindingsTarget; 385 const QueryType m_verifierType; 386}; 387 388BufferSizeCase::BufferSizeCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType) 389 : TestCase (context, name, desc) 390 , m_queryTarget (queryTarget) 391 , m_bufferTarget (bufferTarget) 392 , m_numBindingsTarget (numBindingsTarget) 393 , m_verifierType (verifierType) 394{ 395} 396 397BufferSizeCase::IterateResult BufferSizeCase::iterate (void) 398{ 399 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 400 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 401 int maxBindings = -1; 402 403 gl.enableLogging(true); 404 405 gl.glGetIntegerv(m_numBindingsTarget, &maxBindings); 406 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 407 408 { 409 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 410 411 for (int ndx = 0; ndx < maxBindings; ++ndx) 412 verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType); 413 } 414 415 { 416 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting"); 417 glu::Buffer bufferA (m_context.getRenderContext()); 418 glu::Buffer bufferB (m_context.getRenderContext()); 419 const int ndxA = 0; 420 const int ndxB = maxBindings / 2; 421 422 { 423 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point"); 424 425 gl.glBindBuffer(m_bufferTarget, *bufferA); 426 gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ); 427 gl.glBindBuffer(m_bufferTarget, *bufferB); 428 gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ); 429 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs"); 430 431 verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType); 432 } 433 { 434 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase"); 435 436 gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA); 437 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf"); 438 439 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType); 440 } 441 { 442 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange"); 443 444 gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8); 445 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf"); 446 447 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, 8, m_verifierType); 448 } 449 if (ndxA != ndxB) 450 { 451 const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change"); 452 453 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType); 454 } 455 } 456 457 result.setTestContextResult(m_testCtx); 458 return STOP; 459} 460 461class ImageBindingNameCase : public TestCase 462{ 463public: 464 ImageBindingNameCase (Context& context, const char* name, const char* desc, QueryType verifierType); 465 466private: 467 IterateResult iterate (void); 468 469 const QueryType m_verifierType; 470}; 471 472ImageBindingNameCase::ImageBindingNameCase (Context& context, const char* name, const char* desc, QueryType verifierType) 473 : TestCase (context, name, desc) 474 , m_verifierType (verifierType) 475{ 476} 477 478ImageBindingNameCase::IterateResult ImageBindingNameCase::iterate (void) 479{ 480 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 481 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 482 int maxImages = -1; 483 484 gl.enableLogging(true); 485 486 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages); 487 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 488 489 { 490 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 491 492 for (int ndx = 0; ndx < maxImages; ++ndx) 493 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndx, 0, m_verifierType); 494 } 495 496 { 497 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting"); 498 glu::Texture textureA (m_context.getRenderContext()); 499 glu::Texture textureB (m_context.getRenderContext()); 500 const int ndxA = 0; 501 const int ndxB = maxImages / 2; 502 503 gl.glBindTexture(GL_TEXTURE_2D, *textureA); 504 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32); 505 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 506 507 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI); 508 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 509 510 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB); 511 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4); 512 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 513 514 gl.glBindImageTexture(ndxB, *textureB, 0, GL_FALSE, 2, GL_READ_ONLY, GL_RGBA8UI); 515 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 516 517 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxA, *textureA, m_verifierType); 518 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxB, *textureB, m_verifierType); 519 } 520 521 result.setTestContextResult(m_testCtx); 522 return STOP; 523} 524 525class ImageBindingLevelCase : public TestCase 526{ 527public: 528 ImageBindingLevelCase (Context& context, const char* name, const char* desc, QueryType verifierType); 529 530private: 531 IterateResult iterate (void); 532 533 const QueryType m_verifierType; 534}; 535 536ImageBindingLevelCase::ImageBindingLevelCase (Context& context, const char* name, const char* desc, QueryType verifierType) 537 : TestCase (context, name, desc) 538 , m_verifierType (verifierType) 539{ 540} 541 542ImageBindingLevelCase::IterateResult ImageBindingLevelCase::iterate (void) 543{ 544 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 545 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 546 int maxImages = -1; 547 548 gl.enableLogging(true); 549 550 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages); 551 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 552 553 { 554 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 555 556 for (int ndx = 0; ndx < maxImages; ++ndx) 557 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndx, 0, m_verifierType); 558 } 559 560 { 561 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting"); 562 glu::Texture textureA (m_context.getRenderContext()); 563 glu::Texture textureB (m_context.getRenderContext()); 564 const int ndxA = 0; 565 const int ndxB = maxImages / 2; 566 567 gl.glBindTexture(GL_TEXTURE_2D, *textureA); 568 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32); 569 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 570 571 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI); 572 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 573 574 gl.glBindTexture(GL_TEXTURE_2D, *textureB); 575 gl.glTexStorage2D(GL_TEXTURE_2D, 3, GL_RGBA8, 32, 32); 576 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 577 578 gl.glBindImageTexture(ndxB, *textureB, 2, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI); 579 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 580 581 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxA, 0, m_verifierType); 582 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxB, 2, m_verifierType); 583 } 584 585 result.setTestContextResult(m_testCtx); 586 return STOP; 587} 588 589class ImageBindingLayeredCase : public TestCase 590{ 591public: 592 ImageBindingLayeredCase (Context& context, const char* name, const char* desc, QueryType verifierType); 593 594private: 595 IterateResult iterate (void); 596 597 const QueryType m_verifierType; 598}; 599 600ImageBindingLayeredCase::ImageBindingLayeredCase (Context& context, const char* name, const char* desc, QueryType verifierType) 601 : TestCase (context, name, desc) 602 , m_verifierType (verifierType) 603{ 604} 605 606ImageBindingLayeredCase::IterateResult ImageBindingLayeredCase::iterate (void) 607{ 608 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 609 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 610 int maxImages = -1; 611 612 gl.enableLogging(true); 613 614 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages); 615 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 616 617 { 618 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 619 620 for (int ndx = 0; ndx < maxImages; ++ndx) 621 verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndx, false, m_verifierType); 622 } 623 624 { 625 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting"); 626 glu::Texture textureA (m_context.getRenderContext()); 627 glu::Texture textureB (m_context.getRenderContext()); 628 const int ndxA = 0; 629 const int ndxB = maxImages / 2; 630 631 gl.glBindTexture(GL_TEXTURE_2D, *textureA); 632 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32); 633 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 634 635 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI); 636 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 637 638 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB); 639 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4); 640 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 641 642 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI); 643 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 644 645 verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxA, false, m_verifierType); 646 verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxB, true, m_verifierType); 647 } 648 649 result.setTestContextResult(m_testCtx); 650 return STOP; 651} 652 653class ImageBindingLayerCase : public TestCase 654{ 655public: 656 ImageBindingLayerCase (Context& context, const char* name, const char* desc, QueryType verifierType); 657 658private: 659 IterateResult iterate (void); 660 661 const QueryType m_verifierType; 662}; 663 664ImageBindingLayerCase::ImageBindingLayerCase (Context& context, const char* name, const char* desc, QueryType verifierType) 665 : TestCase (context, name, desc) 666 , m_verifierType (verifierType) 667{ 668} 669 670ImageBindingLayerCase::IterateResult ImageBindingLayerCase::iterate (void) 671{ 672 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 673 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 674 int maxImages = -1; 675 676 gl.enableLogging(true); 677 678 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages); 679 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 680 681 { 682 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 683 684 for (int ndx = 0; ndx < maxImages; ++ndx) 685 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndx, 0, m_verifierType); 686 } 687 688 { 689 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting"); 690 glu::Texture textureA (m_context.getRenderContext()); 691 glu::Texture textureB (m_context.getRenderContext()); 692 const int ndxA = 0; 693 const int ndxB = maxImages / 2; 694 695 gl.glBindTexture(GL_TEXTURE_2D, *textureA); 696 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32); 697 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 698 699 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI); 700 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 701 702 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB); 703 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4); 704 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 705 706 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI); 707 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 708 709 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxA, 0, m_verifierType); 710 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxB, 2, m_verifierType); 711 } 712 713 result.setTestContextResult(m_testCtx); 714 return STOP; 715} 716 717class ImageBindingAccessCase : public TestCase 718{ 719public: 720 ImageBindingAccessCase (Context& context, const char* name, const char* desc, QueryType verifierType); 721 722private: 723 IterateResult iterate (void); 724 725 const QueryType m_verifierType; 726}; 727 728ImageBindingAccessCase::ImageBindingAccessCase (Context& context, const char* name, const char* desc, QueryType verifierType) 729 : TestCase (context, name, desc) 730 , m_verifierType (verifierType) 731{ 732} 733 734ImageBindingAccessCase::IterateResult ImageBindingAccessCase::iterate (void) 735{ 736 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 737 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 738 int maxImages = -1; 739 740 gl.enableLogging(true); 741 742 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages); 743 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 744 745 { 746 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 747 748 for (int ndx = 0; ndx < maxImages; ++ndx) 749 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndx, GL_READ_ONLY, m_verifierType); 750 } 751 752 { 753 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting"); 754 glu::Texture textureA (m_context.getRenderContext()); 755 glu::Texture textureB (m_context.getRenderContext()); 756 const int ndxA = 0; 757 const int ndxB = maxImages / 2; 758 759 gl.glBindTexture(GL_TEXTURE_2D, *textureA); 760 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32); 761 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 762 763 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI); 764 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 765 766 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB); 767 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4); 768 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 769 770 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_RGBA8UI); 771 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 772 773 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxA, GL_READ_ONLY, m_verifierType); 774 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxB, GL_READ_WRITE, m_verifierType); 775 } 776 777 result.setTestContextResult(m_testCtx); 778 return STOP; 779} 780 781class ImageBindingFormatCase : public TestCase 782{ 783public: 784 ImageBindingFormatCase (Context& context, const char* name, const char* desc, QueryType verifierType); 785 786private: 787 IterateResult iterate (void); 788 789 const QueryType m_verifierType; 790}; 791 792ImageBindingFormatCase::ImageBindingFormatCase (Context& context, const char* name, const char* desc, QueryType verifierType) 793 : TestCase (context, name, desc) 794 , m_verifierType (verifierType) 795{ 796} 797 798ImageBindingFormatCase::IterateResult ImageBindingFormatCase::iterate (void) 799{ 800 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 801 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 802 int maxImages = -1; 803 804 gl.enableLogging(true); 805 806 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages); 807 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 808 809 { 810 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 811 812 for (int ndx = 0; ndx < maxImages; ++ndx) 813 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndx, GL_R32UI, m_verifierType); 814 } 815 816 { 817 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting"); 818 glu::Texture textureA (m_context.getRenderContext()); 819 glu::Texture textureB (m_context.getRenderContext()); 820 const int ndxA = 0; 821 const int ndxB = maxImages / 2; 822 823 gl.glBindTexture(GL_TEXTURE_2D, *textureA); 824 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32); 825 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 826 827 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI); 828 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 829 830 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB); 831 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_R32F, 32, 32, 4); 832 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex"); 833 834 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_R32F); 835 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit"); 836 837 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxA, GL_RGBA8UI, m_verifierType); 838 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxB, GL_R32F, m_verifierType); 839 } 840 841 result.setTestContextResult(m_testCtx); 842 return STOP; 843} 844 845class EnableBlendCase : public TestCase 846{ 847public: 848 EnableBlendCase (Context& context, const char* name, const char* desc, QueryType verifierType); 849 850 void init (void); 851private: 852 IterateResult iterate (void); 853 854 const QueryType m_verifierType; 855}; 856 857EnableBlendCase::EnableBlendCase (Context& context, const char* name, const char* desc, QueryType verifierType) 858 : TestCase (context, name, desc) 859 , m_verifierType (verifierType) 860{ 861} 862 863void EnableBlendCase::init (void) 864{ 865 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed")) 866 throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__); 867} 868 869EnableBlendCase::IterateResult EnableBlendCase::iterate (void) 870{ 871 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 872 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 873 deInt32 maxDrawBuffers = 0; 874 875 gl.enableLogging(true); 876 877 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 878 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 879 880 { 881 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 882 883 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 884 verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, false, m_verifierType); 885 } 886 { 887 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSettingCommon", "After setting common"); 888 889 gl.glEnable(GL_BLEND); 890 891 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 892 verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, true, m_verifierType); 893 894 } 895 { 896 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed"); 897 898 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 899 { 900 if (ndx % 2 == 0) 901 gl.glEnablei(GL_BLEND, ndx); 902 else 903 gl.glDisablei(GL_BLEND, ndx); 904 } 905 906 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 907 verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, (ndx % 2 == 0), m_verifierType); 908 } 909 { 910 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common"); 911 912 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 913 { 914 if (ndx % 2 == 0) 915 gl.glEnablei(GL_BLEND, ndx); 916 else 917 gl.glDisablei(GL_BLEND, ndx); 918 } 919 920 gl.glEnable(GL_BLEND); 921 922 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 923 verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, true, m_verifierType); 924 } 925 926 result.setTestContextResult(m_testCtx); 927 return STOP; 928} 929 930class ColorMaskCase : public TestCase 931{ 932public: 933 ColorMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType); 934 935 void init (void); 936private: 937 IterateResult iterate (void); 938 939 const QueryType m_verifierType; 940}; 941 942ColorMaskCase::ColorMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType) 943 : TestCase (context, name, desc) 944 , m_verifierType (verifierType) 945{ 946} 947 948void ColorMaskCase::init (void) 949{ 950 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed")) 951 throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__); 952} 953 954ColorMaskCase::IterateResult ColorMaskCase::iterate (void) 955{ 956 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 957 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 958 deInt32 maxDrawBuffers = 0; 959 960 gl.enableLogging(true); 961 962 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 963 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 964 965 { 966 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 967 968 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 969 verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(true), m_verifierType); 970 } 971 { 972 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common"); 973 974 gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE); 975 976 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 977 verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false), m_verifierType); 978 } 979 { 980 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed"); 981 982 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 983 gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE), (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE)); 984 985 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 986 verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, (ndx % 2 == 0 ? tcu::BVec4(true, false, true, false) : tcu::BVec4(false, true, false, true)), m_verifierType); 987 } 988 { 989 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common"); 990 991 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 992 gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE), (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE)); 993 994 gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE); 995 996 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 997 verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false), m_verifierType); 998 } 999 1000 result.setTestContextResult(m_testCtx); 1001 return STOP; 1002} 1003 1004class BlendFuncCase : public TestCase 1005{ 1006public: 1007 BlendFuncCase (Context& context, const char* name, const char* desc, QueryType verifierType); 1008 1009 void init (void); 1010private: 1011 IterateResult iterate (void); 1012 1013 const QueryType m_verifierType; 1014}; 1015 1016BlendFuncCase::BlendFuncCase (Context& context, const char* name, const char* desc, QueryType verifierType) 1017 : TestCase (context, name, desc) 1018 , m_verifierType (verifierType) 1019{ 1020} 1021 1022void BlendFuncCase::init (void) 1023{ 1024 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed")) 1025 throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__); 1026} 1027 1028BlendFuncCase::IterateResult BlendFuncCase::iterate (void) 1029{ 1030 const deUint32 blendFuncs[] = 1031 { 1032 GL_ZERO, 1033 GL_ONE, 1034 GL_SRC_COLOR, 1035 GL_ONE_MINUS_SRC_COLOR, 1036 GL_DST_COLOR, 1037 GL_ONE_MINUS_DST_COLOR, 1038 GL_SRC_ALPHA, 1039 GL_ONE_MINUS_SRC_ALPHA, 1040 GL_DST_ALPHA, 1041 GL_ONE_MINUS_DST_ALPHA, 1042 GL_CONSTANT_COLOR, 1043 GL_ONE_MINUS_CONSTANT_COLOR, 1044 GL_CONSTANT_ALPHA, 1045 GL_ONE_MINUS_CONSTANT_ALPHA, 1046 GL_SRC_ALPHA_SATURATE 1047 }; 1048 1049 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 1050 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 1051 deInt32 maxDrawBuffers = 0; 1052 1053 gl.enableLogging(true); 1054 1055 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 1056 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 1057 1058 { 1059 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 1060 1061 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1062 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_ONE, m_verifierType); 1063 1064 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1065 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ZERO, m_verifierType); 1066 1067 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1068 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_ONE, m_verifierType); 1069 1070 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1071 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ZERO, m_verifierType); 1072 } 1073 { 1074 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common"); 1075 1076 gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA); 1077 1078 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1079 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType); 1080 1081 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1082 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType); 1083 1084 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1085 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType); 1086 1087 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1088 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType); 1089 } 1090 { 1091 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommonSeparate", "After setting common separate"); 1092 1093 gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA); 1094 1095 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1096 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType); 1097 1098 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1099 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType); 1100 1101 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1102 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType); 1103 1104 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1105 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType); 1106 } 1107 { 1108 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed"); 1109 1110 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1111 gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]); 1112 1113 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1114 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType); 1115 1116 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1117 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType); 1118 1119 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1120 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType); 1121 1122 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1123 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType); 1124 } 1125 { 1126 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexedSeparate", "After setting indexed separate"); 1127 1128 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1129 gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)], 1130 blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)], 1131 blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], 1132 blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]); 1133 1134 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1135 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType); 1136 1137 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1138 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType); 1139 1140 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1141 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType); 1142 1143 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1144 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType); 1145 1146 } 1147 { 1148 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common"); 1149 1150 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1151 gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]); 1152 1153 gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA); 1154 1155 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1156 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType); 1157 1158 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1159 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType); 1160 1161 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1162 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType); 1163 1164 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1165 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType); 1166 } 1167 { 1168 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate", "After resetting indexed with common separate"); 1169 1170 gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA); 1171 1172 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1173 gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)], 1174 blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)], 1175 blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], 1176 blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]); 1177 1178 gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA); 1179 1180 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1181 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType); 1182 1183 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1184 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType); 1185 1186 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1187 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType); 1188 1189 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1190 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType); 1191 } 1192 1193 result.setTestContextResult(m_testCtx); 1194 return STOP; 1195} 1196 1197class BlendEquationCase : public TestCase 1198{ 1199public: 1200 BlendEquationCase (Context& context, const char* name, const char* desc, QueryType verifierType); 1201 1202 void init (void); 1203private: 1204 IterateResult iterate (void); 1205 1206 const QueryType m_verifierType; 1207}; 1208 1209BlendEquationCase::BlendEquationCase (Context& context, const char* name, const char* desc, QueryType verifierType) 1210 : TestCase (context, name, desc) 1211 , m_verifierType (verifierType) 1212{ 1213} 1214 1215void BlendEquationCase::init (void) 1216{ 1217 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed")) 1218 throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__); 1219} 1220 1221BlendEquationCase::IterateResult BlendEquationCase::iterate (void) 1222{ 1223 const deUint32 blendEquations[] = 1224 { 1225 GL_FUNC_ADD, 1226 GL_FUNC_SUBTRACT, 1227 GL_FUNC_REVERSE_SUBTRACT, 1228 GL_MIN, 1229 GL_MAX 1230 }; 1231 1232 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 1233 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 1234 deInt32 maxDrawBuffers = 0; 1235 1236 gl.enableLogging(true); 1237 1238 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 1239 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 1240 1241 { 1242 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value"); 1243 1244 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1245 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_ADD, m_verifierType); 1246 1247 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1248 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_ADD, m_verifierType); 1249 } 1250 { 1251 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common"); 1252 1253 gl.glBlendEquation(GL_FUNC_SUBTRACT); 1254 1255 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1256 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType); 1257 1258 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1259 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType); 1260 } 1261 { 1262 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommonSeparate", "After setting common separate"); 1263 1264 gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT); 1265 1266 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1267 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType); 1268 1269 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1270 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType); 1271 } 1272 { 1273 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed"); 1274 1275 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1276 gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]); 1277 1278 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1279 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType); 1280 1281 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1282 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType); 1283 } 1284 { 1285 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexedSeparate", "After setting indexed separate"); 1286 1287 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1288 gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]); 1289 1290 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1291 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType); 1292 1293 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1294 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType); 1295 } 1296 { 1297 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common"); 1298 1299 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1300 gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]); 1301 1302 gl.glBlendEquation(GL_FUNC_SUBTRACT); 1303 1304 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1305 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType); 1306 1307 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1308 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType); 1309 } 1310 { 1311 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate", "After resetting indexed with common separate"); 1312 1313 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1314 gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]); 1315 1316 gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT); 1317 1318 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1319 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType); 1320 1321 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1322 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType); 1323 } 1324 1325 result.setTestContextResult(m_testCtx); 1326 return STOP; 1327} 1328 1329class BlendEquationAdvancedCase : public TestCase 1330{ 1331public: 1332 BlendEquationAdvancedCase (Context& context, const char* name, const char* desc, QueryType verifierType); 1333 1334 void init (void); 1335private: 1336 IterateResult iterate (void); 1337 1338 const QueryType m_verifierType; 1339}; 1340 1341BlendEquationAdvancedCase::BlendEquationAdvancedCase (Context& context, const char* name, const char* desc, QueryType verifierType) 1342 : TestCase (context, name, desc) 1343 , m_verifierType (verifierType) 1344{ 1345} 1346 1347void BlendEquationAdvancedCase::init (void) 1348{ 1349 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed")) 1350 throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__); 1351 1352 if (!m_context.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced")) 1353 throw tcu::NotSupportedError("Extension GL_KHR_blend_equation_advanced not supported", "", __FILE__, __LINE__); 1354} 1355 1356BlendEquationAdvancedCase::IterateResult BlendEquationAdvancedCase::iterate (void) 1357{ 1358 const deUint32 blendEquations[] = 1359 { 1360 GL_FUNC_ADD, 1361 GL_FUNC_SUBTRACT, 1362 GL_FUNC_REVERSE_SUBTRACT, 1363 GL_MIN, 1364 GL_MAX 1365 }; 1366 1367 const deUint32 blendEquationAdvanced[] = 1368 { 1369 GL_MULTIPLY_KHR, 1370 GL_SCREEN_KHR, 1371 GL_OVERLAY_KHR, 1372 GL_DARKEN_KHR, 1373 GL_LIGHTEN_KHR, 1374 GL_COLORDODGE_KHR, 1375 GL_COLORBURN_KHR, 1376 GL_HARDLIGHT_KHR, 1377 GL_SOFTLIGHT_KHR, 1378 GL_DIFFERENCE_KHR, 1379 GL_EXCLUSION_KHR, 1380 GL_HSL_HUE_KHR, 1381 GL_HSL_SATURATION_KHR, 1382 GL_HSL_COLOR_KHR, 1383 GL_HSL_LUMINOSITY_KHR 1384 }; 1385 1386 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 1387 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 1388 deInt32 maxDrawBuffers = 0; 1389 1390 gl.enableLogging(true); 1391 1392 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); 1393 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); 1394 1395 { 1396 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common"); 1397 1398 gl.glBlendEquation(GL_SCREEN_KHR); 1399 1400 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1401 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_SCREEN_KHR, m_verifierType); 1402 1403 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1404 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_SCREEN_KHR, m_verifierType); 1405 } 1406 { 1407 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed"); 1408 1409 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1410 gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]); 1411 1412 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1413 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)], m_verifierType); 1414 1415 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1416 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)], m_verifierType); 1417 } 1418 { 1419 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common"); 1420 1421 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1422 gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]); 1423 1424 gl.glBlendEquation(GL_MULTIPLY_KHR); 1425 1426 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1427 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_MULTIPLY_KHR, m_verifierType); 1428 1429 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1430 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_MULTIPLY_KHR, m_verifierType); 1431 } 1432 { 1433 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedSeparateWithCommon", "After resetting indexed separate with common"); 1434 1435 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1436 gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]); 1437 1438 gl.glBlendEquation(GL_LIGHTEN_KHR); 1439 1440 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1441 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_LIGHTEN_KHR, m_verifierType); 1442 1443 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx) 1444 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_LIGHTEN_KHR, m_verifierType); 1445 } 1446 1447 result.setTestContextResult(m_testCtx); 1448 return STOP; 1449} 1450 1451} // anonymous 1452 1453IndexedStateQueryTests::IndexedStateQueryTests (Context& context) 1454 : TestCaseGroup(context, "indexed", "Indexed state queries") 1455{ 1456} 1457 1458IndexedStateQueryTests::~IndexedStateQueryTests (void) 1459{ 1460} 1461 1462void IndexedStateQueryTests::init (void) 1463{ 1464 static const QueryType verifiers[] = { QUERY_INDEXED_BOOLEAN, QUERY_INDEXED_INTEGER, QUERY_INDEXED_INTEGER64 }; 1465 static const QueryType vec4Verifiers[] = { QUERY_INDEXED_BOOLEAN_VEC4, QUERY_INDEXED_INTEGER_VEC4, QUERY_INDEXED_INTEGER64_VEC4 }; 1466 1467#define FOR_EACH_VERIFIER(X) \ 1468 for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \ 1469 { \ 1470 const QueryType verifier = verifiers[verifierNdx]; \ 1471 const char* verifierSuffix = getVerifierSuffix(verifier); \ 1472 this->addChild(X); \ 1473 } 1474 1475#define FOR_EACH_VEC4_VERIFIER(X) \ 1476 for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(vec4Verifiers); ++verifierNdx) \ 1477 { \ 1478 const QueryType verifier = vec4Verifiers[verifierNdx]; \ 1479 const char* verifierSuffix = getVerifierSuffix(verifier); \ 1480 this->addChild(X); \ 1481 } 1482 1483 FOR_EACH_VERIFIER(new SampleMaskCase (m_context, (std::string() + "sample_mask_value_" + verifierSuffix).c_str(), "Test SAMPLE_MASK_VALUE", verifier)) 1484 1485 FOR_EACH_VERIFIER(new MinValueIndexed3Case (m_context, (std::string() + "max_compute_work_group_count_" + verifierSuffix).c_str(), "Test MAX_COMPUTE_WORK_GROUP_COUNT", GL_MAX_COMPUTE_WORK_GROUP_COUNT, tcu::IVec3(65535,65535,65535), verifier)) 1486 FOR_EACH_VERIFIER(new MinValueIndexed3Case (m_context, (std::string() + "max_compute_work_group_size_" + verifierSuffix).c_str(), "Test MAX_COMPUTE_WORK_GROUP_SIZE", GL_MAX_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(128, 128, 64), verifier)) 1487 1488 FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "atomic_counter_buffer_binding_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_BINDING", GL_ATOMIC_COUNTER_BUFFER_BINDING, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier)) 1489 FOR_EACH_VERIFIER(new BufferStartCase (m_context, (std::string() + "atomic_counter_buffer_start_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_START", GL_ATOMIC_COUNTER_BUFFER_START, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier)) 1490 FOR_EACH_VERIFIER(new BufferSizeCase (m_context, (std::string() + "atomic_counter_buffer_size_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_SIZE", GL_ATOMIC_COUNTER_BUFFER_SIZE, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier)) 1491 1492 FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "shader_storager_buffer_binding_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_BINDING", GL_SHADER_STORAGE_BUFFER_BINDING, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier)) 1493 FOR_EACH_VERIFIER(new BufferStartCase (m_context, (std::string() + "shader_storager_buffer_start_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_START", GL_SHADER_STORAGE_BUFFER_START, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier)) 1494 FOR_EACH_VERIFIER(new BufferSizeCase (m_context, (std::string() + "shader_storager_buffer_size_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_SIZE", GL_SHADER_STORAGE_BUFFER_SIZE, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier)) 1495 1496 FOR_EACH_VERIFIER(new ImageBindingNameCase (m_context, (std::string() + "image_binding_name_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_NAME", verifier)) 1497 FOR_EACH_VERIFIER(new ImageBindingLevelCase (m_context, (std::string() + "image_binding_level_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LEVEL", verifier)) 1498 FOR_EACH_VERIFIER(new ImageBindingLayeredCase (m_context, (std::string() + "image_binding_layered_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LAYERED", verifier)) 1499 FOR_EACH_VERIFIER(new ImageBindingLayerCase (m_context, (std::string() + "image_binding_layer_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LAYER", verifier)) 1500 FOR_EACH_VERIFIER(new ImageBindingAccessCase (m_context, (std::string() + "image_binding_access_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_ACCESS", verifier)) 1501 FOR_EACH_VERIFIER(new ImageBindingFormatCase (m_context, (std::string() + "image_binding_format_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_FORMAT", verifier)) 1502 1503 { 1504 const QueryType verifier = QUERY_INDEXED_ISENABLED; 1505 const char* verifierSuffix = getVerifierSuffix(verifier); 1506 this->addChild(new EnableBlendCase (m_context, (std::string() + "blend_" + verifierSuffix).c_str(), "BLEND", verifier)); 1507 } 1508 FOR_EACH_VEC4_VERIFIER(new ColorMaskCase (m_context, (std::string() + "color_mask_" + verifierSuffix).c_str(), "COLOR_WRITEMASK", verifier)) 1509 FOR_EACH_VERIFIER(new BlendFuncCase (m_context, (std::string() + "blend_func_" + verifierSuffix).c_str(), "BLEND_SRC and BLEND_DST", verifier)) 1510 FOR_EACH_VERIFIER(new BlendEquationCase (m_context, (std::string() + "blend_equation_" + verifierSuffix).c_str(), "BLEND_EQUATION_RGB and BLEND_DST", verifier)) 1511 FOR_EACH_VERIFIER(new BlendEquationAdvancedCase (m_context, (std::string() + "blend_equation_advanced_" + verifierSuffix).c_str(), "BLEND_EQUATION_RGB and BLEND_DST", verifier)) 1512 1513#undef FOR_EACH_VEC4_VERIFIER 1514#undef FOR_EACH_VERIFIER 1515} 1516 1517} // Functional 1518} // gles31 1519} // deqp 1520