1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 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 Vertex attribute binding state query tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fVertexAttributeBindingStateQueryTests.hpp" 25 #include "tcuTestLog.hpp" 26 #include "gluCallLogWrapper.hpp" 27 #include "gluRenderContext.hpp" 28 #include "gluObjectWrapper.hpp" 29 #include "gluStrUtil.hpp" 30 #include "glsStateQueryUtil.hpp" 31 #include "glwEnums.hpp" 32 #include "glwFunctions.hpp" 33 #include "glsStateQueryUtil.hpp" 34 #include "deRandom.hpp" 35 36 namespace deqp 37 { 38 namespace gles31 39 { 40 namespace Functional 41 { 42 namespace 43 { 44 45 using namespace gls::StateQueryUtil; 46 47 class AttributeCase : public TestCase 48 { 49 public: 50 AttributeCase (Context& context, const char* name, const char* desc, QueryType verifier); 51 52 IterateResult iterate (void); 53 virtual void test (tcu::ResultCollector& result) = 0; 54 55 protected: 56 const QueryType m_verifier; 57 }; 58 59 AttributeCase::AttributeCase (Context& context, const char* name, const char* desc, QueryType verifier) 60 : TestCase (context, name, desc) 61 , m_verifier (verifier) 62 { 63 } 64 65 AttributeCase::IterateResult AttributeCase::iterate (void) 66 { 67 tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: "); 68 69 test(result); 70 71 result.setTestContextResult(m_testCtx); 72 return STOP; 73 } 74 75 class AttributeBindingCase : public AttributeCase 76 { 77 public: 78 AttributeBindingCase (Context& context, const char* name, const char* desc, QueryType verifier); 79 void test (tcu::ResultCollector& result); 80 }; 81 82 AttributeBindingCase::AttributeBindingCase (Context& context, const char* name, const char* desc, QueryType verifier) 83 : AttributeCase(context, name, desc, verifier) 84 { 85 } 86 87 void AttributeBindingCase::test (tcu::ResultCollector& result) 88 { 89 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 90 glu::VertexArray vao (m_context.getRenderContext()); 91 glw::GLint maxAttrs = -1; 92 93 gl.enableLogging(true); 94 95 gl.glBindVertexArray(*vao); 96 gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttrs); 97 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv"); 98 99 // initial 100 { 101 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values"); 102 103 for (int attr = 0; attr < de::max(16, maxAttrs); ++attr) 104 verifyStateAttributeInteger(result, gl, GL_VERTEX_ATTRIB_BINDING, attr, attr, m_verifier); 105 } 106 107 // is part of vao 108 { 109 const tcu::ScopedLogSection section (m_testCtx.getLog(), "vao", "VAO state"); 110 glu::VertexArray otherVao (m_context.getRenderContext()); 111 112 // set to value A in vao1 113 gl.glVertexAttribBinding(1, 4); 114 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glVertexAttribBinding"); 115 116 // set to value B in vao2 117 gl.glBindVertexArray(*otherVao); 118 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 119 120 gl.glVertexAttribBinding(1, 7); 121 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glVertexAttribBinding"); 122 123 // check value is still ok in original vao 124 gl.glBindVertexArray(*vao); 125 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 126 127 verifyStateAttributeInteger(result, gl, GL_VERTEX_ATTRIB_BINDING, 1, 4, m_verifier); 128 } 129 130 // random values 131 { 132 const tcu::ScopedLogSection section (m_testCtx.getLog(), "random", "Random values"); 133 de::Random rnd (0xabc); 134 const int numRandomTests = 10; 135 136 for (int randomTestNdx = 0; randomTestNdx < numRandomTests; ++randomTestNdx) 137 { 138 // switch random va to random binding 139 const int va = rnd.getInt(0, de::max(16, maxAttrs)-1); 140 const int binding = rnd.getInt(0, 16); 141 142 gl.glVertexAttribBinding(va, binding); 143 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glVertexAttribBinding"); 144 145 verifyStateAttributeInteger(result, gl, GL_VERTEX_ATTRIB_BINDING, va, binding, m_verifier); 146 } 147 } 148 } 149 150 class AttributeRelativeOffsetCase : public AttributeCase 151 { 152 public: 153 AttributeRelativeOffsetCase (Context& context, const char* name, const char* desc, QueryType verifier); 154 void test (tcu::ResultCollector& result); 155 }; 156 157 AttributeRelativeOffsetCase::AttributeRelativeOffsetCase (Context& context, const char* name, const char* desc, QueryType verifier) 158 : AttributeCase(context, name, desc, verifier) 159 { 160 } 161 162 void AttributeRelativeOffsetCase::test (tcu::ResultCollector& result) 163 { 164 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 165 glu::VertexArray vao (m_context.getRenderContext()); 166 glw::GLint maxAttrs = -1; 167 168 gl.enableLogging(true); 169 170 gl.glBindVertexArray(*vao); 171 gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttrs); 172 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv"); 173 174 // initial 175 { 176 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values"); 177 178 for (int attr = 0; attr < de::max(16, maxAttrs); ++attr) 179 verifyStateAttributeInteger(result, gl, GL_VERTEX_ATTRIB_RELATIVE_OFFSET, attr, 0, m_verifier); 180 } 181 182 // is part of vao 183 { 184 const tcu::ScopedLogSection section (m_testCtx.getLog(), "vao", "VAO state"); 185 glu::VertexArray otherVao (m_context.getRenderContext()); 186 187 // set to value A in vao1 188 gl.glVertexAttribFormat(1, 4, GL_FLOAT, GL_FALSE, 9); 189 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glVertexAttribFormat"); 190 191 // set to value B in vao2 192 gl.glBindVertexArray(*otherVao); 193 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 194 195 gl.glVertexAttribFormat(1, 4, GL_FLOAT, GL_FALSE, 21); 196 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glVertexAttribFormat"); 197 198 // check value is still ok in original vao 199 gl.glBindVertexArray(*vao); 200 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 201 202 verifyStateAttributeInteger(result, gl, GL_VERTEX_ATTRIB_RELATIVE_OFFSET, 1, 9, m_verifier); 203 } 204 205 // random values 206 { 207 const tcu::ScopedLogSection section (m_testCtx.getLog(), "random", "Random values"); 208 de::Random rnd (0xabc); 209 const int numRandomTests = 10; 210 211 for (int randomTestNdx = 0; randomTestNdx < numRandomTests; ++randomTestNdx) 212 { 213 const int va = rnd.getInt(0, de::max(16, maxAttrs)-1); 214 const int offset = rnd.getInt(0, 2047); 215 216 gl.glVertexAttribFormat(va, 4, GL_FLOAT, GL_FALSE, offset); 217 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glVertexAttribFormat"); 218 219 verifyStateAttributeInteger(result, gl, GL_VERTEX_ATTRIB_RELATIVE_OFFSET, va, offset, m_verifier); 220 } 221 } 222 } 223 224 class IndexedCase : public TestCase 225 { 226 public: 227 IndexedCase (Context& context, const char* name, const char* desc, QueryType verifier); 228 229 IterateResult iterate (void); 230 virtual void test (tcu::ResultCollector& result) = 0; 231 232 protected: 233 const QueryType m_verifier; 234 }; 235 236 IndexedCase::IndexedCase (Context& context, const char* name, const char* desc, QueryType verifier) 237 : TestCase (context, name, desc) 238 , m_verifier (verifier) 239 { 240 } 241 242 IndexedCase::IterateResult IndexedCase::iterate (void) 243 { 244 tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: "); 245 246 test(result); 247 248 result.setTestContextResult(m_testCtx); 249 return STOP; 250 } 251 252 class VertexBindingDivisorCase : public IndexedCase 253 { 254 public: 255 VertexBindingDivisorCase (Context& context, const char* name, const char* desc, QueryType verifier); 256 void test (tcu::ResultCollector& result); 257 }; 258 259 VertexBindingDivisorCase::VertexBindingDivisorCase (Context& context, const char* name, const char* desc, QueryType verifier) 260 : IndexedCase(context, name, desc, verifier) 261 { 262 } 263 264 void VertexBindingDivisorCase::test (tcu::ResultCollector& result) 265 { 266 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 267 glu::VertexArray vao (m_context.getRenderContext()); 268 glw::GLint reportedMaxBindings = -1; 269 glw::GLint maxBindings; 270 271 gl.enableLogging(true); 272 273 gl.glBindVertexArray(*vao); 274 gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &reportedMaxBindings); 275 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv"); 276 277 maxBindings = de::max(16, reportedMaxBindings); 278 279 // initial 280 { 281 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values"); 282 283 for (int binding = 0; binding < maxBindings; ++binding) 284 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_DIVISOR, binding, 0, m_verifier); 285 } 286 287 // is part of vao 288 { 289 const tcu::ScopedLogSection section (m_testCtx.getLog(), "vao", "VAO state"); 290 glu::VertexArray otherVao (m_context.getRenderContext()); 291 292 // set to value A in vao1 293 gl.glVertexBindingDivisor(1, 4); 294 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glVertexBindingDivisor"); 295 296 // set to value B in vao2 297 gl.glBindVertexArray(*otherVao); 298 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 299 300 gl.glVertexBindingDivisor(1, 9); 301 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glVertexBindingDivisor"); 302 303 // check value is still ok in original vao 304 gl.glBindVertexArray(*vao); 305 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 306 307 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_DIVISOR, 1, 4, m_verifier); 308 } 309 310 // random values 311 { 312 const tcu::ScopedLogSection section (m_testCtx.getLog(), "random", "Random values"); 313 de::Random rnd (0xabc); 314 const int numRandomTests = 10; 315 316 for (int randomTestNdx = 0; randomTestNdx < numRandomTests; ++randomTestNdx) 317 { 318 const int binding = rnd.getInt(0, maxBindings-1); 319 const int divisor = rnd.getInt(0, 2047); 320 321 gl.glVertexBindingDivisor(binding, divisor); 322 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glVertexBindingDivisor"); 323 324 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_DIVISOR, binding, divisor, m_verifier); 325 } 326 } 327 } 328 329 class VertexBindingOffsetCase : public IndexedCase 330 { 331 public: 332 VertexBindingOffsetCase (Context& context, const char* name, const char* desc, QueryType verifier); 333 void test (tcu::ResultCollector& result); 334 }; 335 336 VertexBindingOffsetCase::VertexBindingOffsetCase (Context& context, const char* name, const char* desc, QueryType verifier) 337 : IndexedCase(context, name, desc, verifier) 338 { 339 } 340 341 void VertexBindingOffsetCase::test (tcu::ResultCollector& result) 342 { 343 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 344 glu::VertexArray vao (m_context.getRenderContext()); 345 glu::Buffer buffer (m_context.getRenderContext()); 346 glw::GLint reportedMaxBindings = -1; 347 glw::GLint maxBindings; 348 349 gl.enableLogging(true); 350 351 gl.glBindVertexArray(*vao); 352 gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &reportedMaxBindings); 353 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv"); 354 355 maxBindings = de::max(16, reportedMaxBindings); 356 357 // initial 358 { 359 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values"); 360 361 for (int binding = 0; binding < maxBindings; ++binding) 362 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_OFFSET, binding, 0, m_verifier); 363 } 364 365 // is part of vao 366 { 367 const tcu::ScopedLogSection section (m_testCtx.getLog(), "vao", "VAO state"); 368 glu::VertexArray otherVao (m_context.getRenderContext()); 369 370 // set to value A in vao1 371 gl.glBindVertexBuffer(1, *buffer, 4, 32); 372 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexBuffer"); 373 374 // set to value B in vao2 375 gl.glBindVertexArray(*otherVao); 376 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 377 378 gl.glBindVertexBuffer(1, *buffer, 13, 32); 379 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexBuffer"); 380 381 // check value is still ok in original vao 382 gl.glBindVertexArray(*vao); 383 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 384 385 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_OFFSET, 1, 4, m_verifier); 386 } 387 388 // random values 389 { 390 const tcu::ScopedLogSection section (m_testCtx.getLog(), "random", "Random values"); 391 de::Random rnd (0xabc); 392 const int numRandomTests = 10; 393 394 for (int randomTestNdx = 0; randomTestNdx < numRandomTests; ++randomTestNdx) 395 { 396 const int binding = rnd.getInt(0, maxBindings-1); 397 const int offset = rnd.getInt(0, 4000); 398 399 gl.glBindVertexBuffer(binding, *buffer, offset, 32); 400 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexBuffer"); 401 402 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_OFFSET, binding, offset, m_verifier); 403 } 404 } 405 } 406 407 class VertexBindingStrideCase : public IndexedCase 408 { 409 public: 410 VertexBindingStrideCase (Context& context, const char* name, const char* desc, QueryType verifier); 411 void test (tcu::ResultCollector& result); 412 }; 413 414 VertexBindingStrideCase::VertexBindingStrideCase (Context& context, const char* name, const char* desc, QueryType verifier) 415 : IndexedCase(context, name, desc, verifier) 416 { 417 } 418 419 void VertexBindingStrideCase::test (tcu::ResultCollector& result) 420 { 421 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 422 glu::VertexArray vao (m_context.getRenderContext()); 423 glu::Buffer buffer (m_context.getRenderContext()); 424 glw::GLint reportedMaxBindings = -1; 425 glw::GLint maxBindings; 426 427 gl.enableLogging(true); 428 429 gl.glBindVertexArray(*vao); 430 gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &reportedMaxBindings); 431 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv"); 432 433 maxBindings = de::max(16, reportedMaxBindings); 434 435 // initial 436 { 437 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values"); 438 439 for (int binding = 0; binding < maxBindings; ++binding) 440 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_STRIDE, binding, 16, m_verifier); 441 } 442 443 // is part of vao 444 { 445 const tcu::ScopedLogSection section (m_testCtx.getLog(), "vao", "VAO state"); 446 glu::VertexArray otherVao (m_context.getRenderContext()); 447 448 // set to value A in vao1 449 gl.glBindVertexBuffer(1, *buffer, 0, 32); 450 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexBuffer"); 451 452 // set to value B in vao2 453 gl.glBindVertexArray(*otherVao); 454 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 455 456 gl.glBindVertexBuffer(1, *buffer, 0, 64); 457 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexBuffer"); 458 459 // check value is still ok in original vao 460 gl.glBindVertexArray(*vao); 461 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 462 463 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_STRIDE, 1, 32, m_verifier); 464 } 465 466 // random values 467 { 468 const tcu::ScopedLogSection section (m_testCtx.getLog(), "random", "Random values"); 469 de::Random rnd (0xabc); 470 const int numRandomTests = 10; 471 472 for (int randomTestNdx = 0; randomTestNdx < numRandomTests; ++randomTestNdx) 473 { 474 const int binding = rnd.getInt(0, maxBindings-1); 475 const int stride = rnd.getInt(0, 2048); 476 477 gl.glBindVertexBuffer(binding, *buffer, 0, stride); 478 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexBuffer"); 479 480 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_STRIDE, binding, stride, m_verifier); 481 } 482 } 483 } 484 485 class VertexBindingBufferCase : public IndexedCase 486 { 487 public: 488 VertexBindingBufferCase (Context& context, const char* name, const char* desc, QueryType verifier); 489 void test (tcu::ResultCollector& result); 490 }; 491 492 VertexBindingBufferCase::VertexBindingBufferCase (Context& context, const char* name, const char* desc, QueryType verifier) 493 : IndexedCase(context, name, desc, verifier) 494 { 495 } 496 497 void VertexBindingBufferCase::test (tcu::ResultCollector& result) 498 { 499 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 500 glu::VertexArray vao (m_context.getRenderContext()); 501 glu::Buffer buffer (m_context.getRenderContext()); 502 glw::GLint reportedMaxBindings = -1; 503 glw::GLint maxBindings; 504 505 gl.enableLogging(true); 506 507 gl.glBindVertexArray(*vao); 508 gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &reportedMaxBindings); 509 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv"); 510 511 maxBindings = de::max(16, reportedMaxBindings); 512 513 // initial 514 { 515 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values"); 516 517 for (int binding = 0; binding < maxBindings; ++binding) 518 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_BUFFER, binding, 0, m_verifier); 519 } 520 521 // is part of vao 522 { 523 const tcu::ScopedLogSection section (m_testCtx.getLog(), "vao", "VAO state"); 524 glu::VertexArray otherVao (m_context.getRenderContext()); 525 glu::Buffer otherBuffer (m_context.getRenderContext()); 526 527 // set to value A in vao1 528 gl.glBindVertexBuffer(1, *buffer, 0, 32); 529 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexBuffer"); 530 531 // set to value B in vao2 532 gl.glBindVertexArray(*otherVao); 533 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 534 gl.glBindVertexBuffer(1, *otherBuffer, 0, 32); 535 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexBuffer"); 536 537 // check value is still ok in original vao 538 gl.glBindVertexArray(*vao); 539 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindVertexArray"); 540 541 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_BUFFER, 1, *buffer, m_verifier); 542 } 543 544 // Is detached in delete from active vao and not from deactive 545 { 546 const tcu::ScopedLogSection section (m_testCtx.getLog(), "autoUnbind", "Unbind on delete"); 547 glu::VertexArray otherVao (m_context.getRenderContext()); 548 glw::GLuint otherBuffer = -1; 549 550 gl.glGenBuffers(1, &otherBuffer); 551 552 // set in vao1 and vao2 553 gl.glBindVertexBuffer(1, otherBuffer, 0, 32); 554 gl.glBindVertexArray(*otherVao); 555 gl.glBindVertexBuffer(1, otherBuffer, 0, 32); 556 557 // delete buffer. This unbinds it from active (vao2) but not from unactive 558 gl.glDeleteBuffers(1, &otherBuffer); 559 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_BUFFER, 1, 0, m_verifier); 560 561 gl.glBindVertexArray(*vao); 562 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_BUFFER, 1, otherBuffer, m_verifier); 563 } 564 } 565 566 class MixedVertexBindingDivisorCase : public IndexedCase 567 { 568 public: 569 MixedVertexBindingDivisorCase (Context& context, const char* name, const char* desc); 570 void test (tcu::ResultCollector& result); 571 }; 572 573 MixedVertexBindingDivisorCase::MixedVertexBindingDivisorCase (Context& context, const char* name, const char* desc) 574 : IndexedCase(context, name, desc, QUERY_INDEXED_INTEGER) 575 { 576 } 577 578 void MixedVertexBindingDivisorCase::test (tcu::ResultCollector& result) 579 { 580 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 581 glu::VertexArray vao (m_context.getRenderContext()); 582 583 gl.enableLogging(true); 584 585 gl.glBindVertexArray(*vao); 586 gl.glVertexAttribDivisor(1, 4); 587 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_DIVISOR, 1, 4, m_verifier); 588 } 589 590 class MixedVertexBindingOffsetCase : public IndexedCase 591 { 592 public: 593 MixedVertexBindingOffsetCase (Context& context, const char* name, const char* desc); 594 void test (tcu::ResultCollector& result); 595 }; 596 597 MixedVertexBindingOffsetCase::MixedVertexBindingOffsetCase (Context& context, const char* name, const char* desc) 598 : IndexedCase(context, name, desc, QUERY_INDEXED_INTEGER) 599 { 600 } 601 602 void MixedVertexBindingOffsetCase::test (tcu::ResultCollector& result) 603 { 604 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 605 glu::Buffer buffer (m_context.getRenderContext()); 606 607 gl.enableLogging(true); 608 609 gl.glBindBuffer(GL_ARRAY_BUFFER, *buffer); 610 gl.glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (const deUint8*)DE_NULL + 12); 611 612 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_OFFSET, 1, 12, m_verifier); 613 } 614 615 class MixedVertexBindingStrideCase : public IndexedCase 616 { 617 public: 618 MixedVertexBindingStrideCase (Context& context, const char* name, const char* desc); 619 void test (tcu::ResultCollector& result); 620 }; 621 622 MixedVertexBindingStrideCase::MixedVertexBindingStrideCase (Context& context, const char* name, const char* desc) 623 : IndexedCase(context, name, desc, QUERY_INDEXED_INTEGER) 624 { 625 } 626 627 void MixedVertexBindingStrideCase::test (tcu::ResultCollector& result) 628 { 629 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 630 glu::Buffer buffer (m_context.getRenderContext()); 631 632 gl.enableLogging(true); 633 634 gl.glBindBuffer(GL_ARRAY_BUFFER, *buffer); 635 gl.glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 12, 0); 636 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_STRIDE, 1, 12, m_verifier); 637 638 // test effectiveStride 639 gl.glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0); 640 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_STRIDE, 1, 16, m_verifier); 641 } 642 643 class MixedVertexBindingBufferCase : public IndexedCase 644 { 645 public: 646 MixedVertexBindingBufferCase (Context& context, const char* name, const char* desc); 647 void test (tcu::ResultCollector& result); 648 }; 649 650 MixedVertexBindingBufferCase::MixedVertexBindingBufferCase (Context& context, const char* name, const char* desc) 651 : IndexedCase(context, name, desc, QUERY_INDEXED_INTEGER) 652 { 653 } 654 655 void MixedVertexBindingBufferCase::test (tcu::ResultCollector& result) 656 { 657 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 658 glu::Buffer buffer (m_context.getRenderContext()); 659 660 gl.enableLogging(true); 661 662 gl.glBindBuffer(GL_ARRAY_BUFFER, *buffer); 663 gl.glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0); 664 verifyStateIndexedInteger(result, gl, GL_VERTEX_BINDING_BUFFER, 1, *buffer, m_verifier); 665 } 666 667 } // anonymous 668 669 VertexAttributeBindingStateQueryTests::VertexAttributeBindingStateQueryTests (Context& context) 670 : TestCaseGroup(context, "vertex_attribute_binding", "Query vertex attribute binding state.") 671 { 672 } 673 674 VertexAttributeBindingStateQueryTests::~VertexAttributeBindingStateQueryTests (void) 675 { 676 } 677 678 void VertexAttributeBindingStateQueryTests::init (void) 679 { 680 tcu::TestCaseGroup* const attributeGroup = new TestCaseGroup(m_context, "vertex_attrib", "Vertex attribute state"); 681 tcu::TestCaseGroup* const indexedGroup = new TestCaseGroup(m_context, "indexed", "Indexed state"); 682 683 addChild(attributeGroup); 684 addChild(indexedGroup); 685 686 // .vertex_attrib 687 { 688 static const struct Verifier 689 { 690 const char* suffix; 691 QueryType type; 692 } verifiers[] = 693 { 694 { "", QUERY_ATTRIBUTE_INTEGER }, // avoid renaming tests 695 { "_getvertexattribfv", QUERY_ATTRIBUTE_FLOAT }, 696 { "_getvertexattribiiv", QUERY_ATTRIBUTE_PURE_INTEGER }, 697 { "_getvertexattribiuiv", QUERY_ATTRIBUTE_PURE_UNSIGNED_INTEGER }, 698 }; 699 700 for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) 701 { 702 attributeGroup->addChild(new AttributeBindingCase (m_context, (std::string("vertex_attrib_binding") + verifiers[verifierNdx].suffix).c_str(), "Test VERTEX_ATTRIB_BINDING", verifiers[verifierNdx].type)); 703 attributeGroup->addChild(new AttributeRelativeOffsetCase(m_context, (std::string("vertex_attrib_relative_offset") + verifiers[verifierNdx].suffix).c_str(), "Test VERTEX_ATTRIB_RELATIVE_OFFSET", verifiers[verifierNdx].type)); 704 } 705 } 706 707 // .indexed 708 { 709 static const struct Verifier 710 { 711 const char* name; 712 QueryType type; 713 } verifiers[] = 714 { 715 { "getintegeri", QUERY_INDEXED_INTEGER }, 716 { "getintegeri64", QUERY_INDEXED_INTEGER64 }, 717 { "getboolean", QUERY_INDEXED_BOOLEAN }, 718 }; 719 720 // states 721 722 for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) 723 { 724 indexedGroup->addChild(new VertexBindingDivisorCase (m_context, (std::string("vertex_binding_divisor_") + verifiers[verifierNdx].name).c_str(), "Test VERTEX_BINDING_DIVISOR", verifiers[verifierNdx].type)); 725 indexedGroup->addChild(new VertexBindingOffsetCase (m_context, (std::string("vertex_binding_offset_") + verifiers[verifierNdx].name).c_str(), "Test VERTEX_BINDING_OFFSET", verifiers[verifierNdx].type)); 726 indexedGroup->addChild(new VertexBindingStrideCase (m_context, (std::string("vertex_binding_stride_") + verifiers[verifierNdx].name).c_str(), "Test VERTEX_BINDING_STRIDE", verifiers[verifierNdx].type)); 727 indexedGroup->addChild(new VertexBindingBufferCase (m_context, (std::string("vertex_binding_buffer_") + verifiers[verifierNdx].name).c_str(), "Test VERTEX_BINDING_BUFFER", verifiers[verifierNdx].type)); 728 } 729 730 // mixed apis 731 732 indexedGroup->addChild(new MixedVertexBindingDivisorCase(m_context, "vertex_binding_divisor_mixed", "Test VERTEX_BINDING_DIVISOR")); 733 indexedGroup->addChild(new MixedVertexBindingOffsetCase (m_context, "vertex_binding_offset_mixed", "Test VERTEX_BINDING_OFFSET")); 734 indexedGroup->addChild(new MixedVertexBindingStrideCase (m_context, "vertex_binding_stride_mixed", "Test VERTEX_BINDING_STRIDE")); 735 indexedGroup->addChild(new MixedVertexBindingBufferCase (m_context, "vertex_binding_buffer_mixed", "Test VERTEX_BINDING_BUFFER")); 736 } 737 } 738 739 } // Functional 740 } // gles31 741 } // deqp 742
