1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.0 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 array object tests 22 *//*--------------------------------------------------------------------*/ 23 #include "es3fVertexArrayObjectTests.hpp" 24 25 #include "gluShaderProgram.hpp" 26 #include "gluPixelTransfer.hpp" 27 #include "gluRenderContext.hpp" 28 29 #include "tcuTestLog.hpp" 30 #include "tcuImageCompare.hpp" 31 #include "tcuSurface.hpp" 32 #include "tcuRenderTarget.hpp" 33 34 #include "deRandom.hpp" 35 #include "deString.h" 36 #include "deMemory.h" 37 38 #include <vector> 39 #include <string> 40 #include <memory> 41 42 #include "glw.h" 43 44 using std::vector; 45 using std::string; 46 47 namespace deqp 48 { 49 namespace gles3 50 { 51 namespace Functional 52 { 53 54 namespace 55 { 56 struct Attribute 57 { 58 Attribute (void); 59 GLboolean enabled; 60 GLint size; 61 GLint stride; 62 GLenum type; 63 GLboolean integer; 64 GLint divisor; 65 GLint offset; 66 GLboolean normalized; 67 68 int bufferNdx; 69 }; 70 71 struct VertexArrayState 72 { 73 VertexArrayState (void); 74 75 vector<Attribute> attributes; 76 int elementArrayBuffer; 77 }; 78 79 VertexArrayState::VertexArrayState (void) 80 : elementArrayBuffer(-1) 81 { 82 } 83 84 Attribute::Attribute (void) 85 : enabled (GL_FALSE) 86 , size (1) 87 , stride (0) 88 , type (GL_FLOAT) 89 , integer (GL_FALSE) 90 , divisor (0) 91 , offset (0) 92 , normalized (GL_FALSE) 93 , bufferNdx (0) 94 { 95 } 96 97 struct BufferSpec 98 { 99 int count; 100 int size; 101 int componentCount; 102 int stride; 103 int offset; 104 105 GLenum type; 106 107 int intRangeMin; 108 int intRangeMax; 109 110 float floatRangeMin; 111 float floatRangeMax; 112 }; 113 114 struct Spec 115 { 116 Spec (void); 117 118 int count; 119 int instances; 120 bool useDrawElements; 121 GLenum indexType; 122 int indexOffset; 123 int indexRangeMin; 124 int indexRangeMax; 125 int indexCount; 126 VertexArrayState state; 127 VertexArrayState vao; 128 vector<BufferSpec> buffers; 129 }; 130 131 Spec::Spec (void) 132 : count (-1) 133 , instances (-1) 134 , useDrawElements (false) 135 , indexType (GL_NONE) 136 , indexOffset (-1) 137 , indexRangeMin (-1) 138 , indexRangeMax (-1) 139 , indexCount (-1) 140 { 141 } 142 143 } // anonymous 144 145 class VertexArrayObjectTest : public TestCase 146 { 147 public: 148 149 VertexArrayObjectTest (Context& context, const Spec& spec, const char* name, const char* description); 150 ~VertexArrayObjectTest (void); 151 virtual void init (void); 152 virtual void deinit (void); 153 virtual IterateResult iterate (void); 154 155 private: 156 Spec m_spec; 157 tcu::TestLog& m_log; 158 vector<GLuint> m_buffers; 159 glu::ShaderProgram* m_vaoProgram; 160 glu::ShaderProgram* m_stateProgram; 161 de::Random m_random; 162 deUint8* m_indices; 163 164 void logVertexArrayState (tcu::TestLog& log, const VertexArrayState& state, const std::string& msg); 165 deUint8* createRandomBufferData (const BufferSpec& buffer); 166 deUint8* generateIndices (void); 167 glu::ShaderProgram* createProgram (const VertexArrayState& state); 168 void setState (const VertexArrayState& state); 169 void render (tcu::Surface& vaoResult, tcu::Surface& defaultResult); 170 void makeDrawCall (const VertexArrayState& state); 171 void genReferences (tcu::Surface& vaoRef, tcu::Surface& defaultRef); 172 173 VertexArrayObjectTest (const VertexArrayObjectTest&); 174 VertexArrayObjectTest& operator= (const VertexArrayObjectTest&); 175 }; 176 177 VertexArrayObjectTest::VertexArrayObjectTest (Context& context, const Spec& spec, const char* name, const char* description) 178 : TestCase (context, name, description) 179 , m_spec (spec) 180 , m_log (context.getTestContext().getLog()) 181 , m_vaoProgram (NULL) 182 , m_stateProgram (NULL) 183 , m_random (deStringHash(name)) 184 , m_indices (NULL) 185 { 186 // Makes zero to zero mapping for buffers 187 m_buffers.push_back(0); 188 } 189 190 VertexArrayObjectTest::~VertexArrayObjectTest (void) 191 { 192 } 193 194 void VertexArrayObjectTest::logVertexArrayState (tcu::TestLog& log, const VertexArrayState& state, const std::string& msg) 195 { 196 std::stringstream message; 197 198 message << msg << "\n"; 199 message << "GL_ELEMENT_ARRAY_BUFFER : " << state.elementArrayBuffer << "\n"; 200 201 for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) 202 { 203 message 204 << "attribute : " << attribNdx << "\n" 205 << "\tGL_VERTEX_ATTRIB_ARRAY_ENABLED : " << (state.attributes[attribNdx].enabled ? "GL_TRUE" : "GL_FALSE") << "\n" 206 << "\tGL_VERTEX_ATTRIB_ARRAY_SIZE : " << state.attributes[attribNdx].size << "\n" 207 << "\tGL_VERTEX_ATTRIB_ARRAY_STRIDE : " << state.attributes[attribNdx].stride << "\n" 208 << "\tGL_VERTEX_ATTRIB_ARRAY_TYPE : " << state.attributes[attribNdx].type << "\n" 209 << "\tGL_VERTEX_ATTRIB_ARRAY_NORMALIZED : " << (state.attributes[attribNdx].normalized ? "GL_TRUE" : "GL_FALSE") << "\n" 210 << "\tGL_VERTEX_ATTRIB_ARRAY_INTEGER : " << (state.attributes[attribNdx].integer ? "GL_TRUE" : "GL_FALSE") << "\n" 211 << "\tGL_VERTEX_ATTRIB_ARRAY_DIVISOR : " << state.attributes[attribNdx].divisor << "\n" 212 << "\tGL_VERTEX_ATTRIB_ARRAY_POINTER : " << state.attributes[attribNdx].offset << "\n" 213 << "\tGL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING : " << m_buffers[state.attributes[attribNdx].bufferNdx] << "\n"; 214 } 215 log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage; 216 } 217 218 219 void VertexArrayObjectTest::init (void) 220 { 221 // \note [mika] Index 0 is reserved for 0 buffer 222 for (int bufferNdx = 0; bufferNdx < (int)m_spec.buffers.size(); bufferNdx++) 223 { 224 deUint8* data = createRandomBufferData(m_spec.buffers[bufferNdx]); 225 226 try 227 { 228 GLuint buffer; 229 GLU_CHECK_CALL(glGenBuffers(1, &buffer)); 230 m_buffers.push_back(buffer); 231 232 GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, buffer)); 233 GLU_CHECK_CALL(glBufferData(GL_ARRAY_BUFFER, m_spec.buffers[bufferNdx].size, data, GL_DYNAMIC_DRAW)); 234 GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0)); 235 236 } catch (...) { 237 delete[] data; 238 throw; 239 } 240 241 delete[] data; 242 } 243 244 m_vaoProgram = createProgram(m_spec.vao); 245 m_log << tcu::TestLog::Message << "Program used with Vertex Array Object" << tcu::TestLog::EndMessage; 246 m_log << *m_vaoProgram; 247 m_stateProgram = createProgram(m_spec.state); 248 m_log << tcu::TestLog::Message << "Program used with Vertex Array State" << tcu::TestLog::EndMessage; 249 m_log << *m_stateProgram; 250 251 if (!m_vaoProgram->isOk() || !m_stateProgram->isOk()) 252 TCU_FAIL("Failed to compile shaders"); 253 254 if (m_spec.useDrawElements && (m_spec.vao.elementArrayBuffer == 0 || m_spec.state.elementArrayBuffer == 0)) 255 m_indices = generateIndices(); 256 } 257 258 void VertexArrayObjectTest::deinit (void) 259 { 260 GLU_CHECK_CALL(glDeleteBuffers((GLsizei)m_buffers.size(), &(m_buffers[0]))); 261 m_buffers.clear(); 262 delete m_vaoProgram; 263 delete m_stateProgram; 264 delete[] m_indices; 265 } 266 267 deUint8* VertexArrayObjectTest::generateIndices (void) 268 { 269 int typeSize = 0; 270 switch (m_spec.indexType) 271 { 272 case GL_UNSIGNED_INT: typeSize = sizeof(GLuint); break; 273 case GL_UNSIGNED_SHORT: typeSize = sizeof(GLushort); break; 274 case GL_UNSIGNED_BYTE: typeSize = sizeof(GLubyte); break; 275 default: 276 DE_ASSERT(false); 277 } 278 279 deUint8* indices = new deUint8[m_spec.indexCount * typeSize]; 280 281 for (int i = 0; i < m_spec.indexCount; i++) 282 { 283 deUint8* pos = indices + typeSize * i; 284 285 switch (m_spec.indexType) 286 { 287 case GL_UNSIGNED_INT: 288 { 289 GLuint v = (GLuint)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); 290 deMemcpy(pos, &v, sizeof(v)); 291 break; 292 } 293 294 case GL_UNSIGNED_SHORT: 295 { 296 GLushort v = (GLushort)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); 297 deMemcpy(pos, &v, sizeof(v)); 298 break; 299 } 300 301 case GL_UNSIGNED_BYTE: 302 { 303 GLubyte v = (GLubyte)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); 304 deMemcpy(pos, &v, sizeof(v)); 305 break; 306 } 307 308 default: 309 DE_ASSERT(false); 310 } 311 } 312 313 return indices; 314 } 315 316 deUint8* VertexArrayObjectTest::createRandomBufferData (const BufferSpec& buffer) 317 { 318 deUint8* data = new deUint8[buffer.size]; 319 320 int stride; 321 322 if (buffer.stride != 0) 323 { 324 stride = buffer.stride; 325 } 326 else 327 { 328 switch (buffer.type) 329 { 330 case GL_FLOAT: stride = buffer.componentCount * sizeof(GLfloat); break; 331 case GL_INT: stride = buffer.componentCount * sizeof(GLint); break; 332 case GL_UNSIGNED_INT: stride = buffer.componentCount * sizeof(GLuint); break; 333 case GL_SHORT: stride = buffer.componentCount * sizeof(GLshort); break; 334 case GL_UNSIGNED_SHORT: stride = buffer.componentCount * sizeof(GLushort); break; 335 case GL_BYTE: stride = buffer.componentCount * sizeof(GLbyte); break; 336 case GL_UNSIGNED_BYTE: stride = buffer.componentCount * sizeof(GLubyte); break; 337 338 default: 339 stride = 0; 340 DE_ASSERT(DE_FALSE); 341 } 342 } 343 344 deUint8* itr = data; 345 346 for (int pos = 0; pos < buffer.count; pos++) 347 { 348 deUint8* componentItr = itr; 349 for (int componentNdx = 0; componentNdx < buffer.componentCount; componentNdx++) 350 { 351 switch (buffer.type) 352 { 353 case GL_FLOAT: 354 { 355 float v = buffer.floatRangeMin + (buffer.floatRangeMax - buffer.floatRangeMin) * m_random.getFloat(); 356 deMemcpy(componentItr, &v, sizeof(v)); 357 componentItr += sizeof(v); 358 break; 359 } 360 361 case GL_INT: 362 { 363 GLint v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 364 deMemcpy(componentItr, &v, sizeof(v)); 365 componentItr += sizeof(v); 366 break; 367 } 368 369 case GL_UNSIGNED_INT: 370 { 371 GLuint v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 372 deMemcpy(componentItr, &v, sizeof(v)); 373 componentItr += sizeof(v); 374 break; 375 } 376 377 case GL_SHORT: 378 { 379 GLshort v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 380 deMemcpy(componentItr, &v, sizeof(v)); 381 componentItr += sizeof(v); 382 break; 383 } 384 385 case GL_UNSIGNED_SHORT: 386 { 387 GLushort v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 388 deMemcpy(componentItr, &v, sizeof(v)); 389 componentItr += sizeof(v); 390 break; 391 } 392 393 case GL_BYTE: 394 { 395 GLbyte v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 396 deMemcpy(componentItr, &v, sizeof(v)); 397 componentItr += sizeof(v); 398 break; 399 } 400 401 case GL_UNSIGNED_BYTE: 402 { 403 GLubyte v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 404 deMemcpy(componentItr, &v, sizeof(v)); 405 componentItr += sizeof(v); 406 break; 407 } 408 409 default: 410 DE_ASSERT(false); 411 }; 412 } 413 414 itr += stride; 415 } 416 417 return data; 418 } 419 420 glu::ShaderProgram* VertexArrayObjectTest::createProgram (const VertexArrayState& state) 421 { 422 std::stringstream vertexShaderStream; 423 std::stringstream value; 424 425 vertexShaderStream << "#version 300 es\n"; 426 427 for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) 428 { 429 if (state.attributes[attribNdx].integer) 430 vertexShaderStream << "layout(location = " << attribNdx << ") in mediump ivec4 a_attrib" << attribNdx << ";\n"; 431 else 432 vertexShaderStream << "layout(location = " << attribNdx << ") in mediump vec4 a_attrib" << attribNdx << ";\n"; 433 434 if (state.attributes[attribNdx].integer) 435 { 436 float scale = 0.0f; 437 438 switch (state.attributes[0].type) 439 { 440 case GL_SHORT: scale = (1.0f/((1u<<14)-1)); break; 441 case GL_UNSIGNED_SHORT: scale = (1.0f/((1u<<15)-1)); break; 442 case GL_INT: scale = (1.0f/((1u<<30)-1)); break; 443 case GL_UNSIGNED_INT: scale = (1.0f/((1u<<31)-1)); break; 444 case GL_BYTE: scale = (1.0f/((1u<<6)-1)); break; 445 case GL_UNSIGNED_BYTE: scale = (1.0f/((1u<<7)-1)); break; 446 447 default: 448 DE_ASSERT(DE_FALSE); 449 } 450 value << (attribNdx != 0 ? " + " : "" ) << scale << " * vec4(a_attrib" << attribNdx << ")"; 451 } 452 else if (state.attributes[attribNdx].type != GL_FLOAT && !state.attributes[attribNdx].normalized) 453 { 454 float scale = 0.0f; 455 456 switch (state.attributes[0].type) 457 { 458 case GL_SHORT: scale = (0.5f/((1u<<14)-1)); break; 459 case GL_UNSIGNED_SHORT: scale = (0.5f/((1u<<15)-1)); break; 460 case GL_INT: scale = (0.5f/((1u<<30)-1)); break; 461 case GL_UNSIGNED_INT: scale = (0.5f/((1u<<31)-1)); break; 462 case GL_BYTE: scale = (0.5f/((1u<<6)-1)); break; 463 case GL_UNSIGNED_BYTE: scale = (0.5f/((1u<<7)-1)); break; 464 465 default: 466 DE_ASSERT(DE_FALSE); 467 } 468 value << (attribNdx != 0 ? " + " : "" ) << scale << " * a_attrib" << attribNdx; 469 } 470 else 471 value << (attribNdx != 0 ? " + " : "" ) << "a_attrib" << attribNdx; 472 } 473 474 vertexShaderStream 475 << "out mediump vec4 v_value;\n" 476 << "void main (void)\n" 477 << "{\n" 478 << "\tv_value = " << value.str() << ";\n"; 479 480 if (state.attributes[0].integer) 481 { 482 float scale = 0.0f; 483 484 switch (state.attributes[0].type) 485 { 486 case GL_SHORT: scale = (1.0f/((1u<<14)-1)); break; 487 case GL_UNSIGNED_SHORT: scale = (1.0f/((1u<<15)-1)); break; 488 case GL_INT: scale = (1.0f/((1u<<30)-1)); break; 489 case GL_UNSIGNED_INT: scale = (1.0f/((1u<<31)-1)); break; 490 case GL_BYTE: scale = (1.0f/((1u<<6)-1)); break; 491 case GL_UNSIGNED_BYTE: scale = (1.0f/((1u<<7)-1)); break; 492 493 default: 494 DE_ASSERT(DE_FALSE); 495 } 496 497 vertexShaderStream 498 << "\tgl_Position = vec4(" << scale << " * " << "vec3(a_attrib0.xyz), 1.0);\n" 499 << "}"; 500 } 501 else 502 { 503 if (state.attributes[0].normalized || state.attributes[0].type == GL_FLOAT) 504 { 505 vertexShaderStream 506 << "\tgl_Position = vec4(a_attrib0.xyz, 1.0);\n" 507 << "}"; 508 } 509 else 510 { 511 float scale = 0.0f; 512 513 switch (state.attributes[0].type) 514 { 515 case GL_SHORT: scale = (1.0f/((1u<<14)-1)); break; 516 case GL_UNSIGNED_SHORT: scale = (1.0f/((1u<<15)-1)); break; 517 case GL_INT: scale = (1.0f/((1u<<30)-1)); break; 518 case GL_UNSIGNED_INT: scale = (1.0f/((1u<<31)-1)); break; 519 case GL_BYTE: scale = (1.0f/((1u<<6)-1)); break; 520 case GL_UNSIGNED_BYTE: scale = (1.0f/((1u<<7)-1)); break; 521 522 default: 523 DE_ASSERT(DE_FALSE); 524 } 525 526 scale *= 0.5; 527 528 vertexShaderStream 529 << "\tgl_Position = vec4(" << scale << " * " << "a_attrib0.xyz, 1.0);\n" 530 << "}"; 531 } 532 } 533 534 const char* fragmentShader = 535 "#version 300 es\n" 536 "in mediump vec4 v_value;\n" 537 "layout(location = 0) out mediump vec4 fragColor;\n" 538 "void main (void)\n" 539 "{\n" 540 "\tfragColor = vec4(v_value.xyz, 1.0);\n" 541 "}"; 542 543 return new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderStream.str(), fragmentShader)); 544 } 545 546 void VertexArrayObjectTest::setState (const VertexArrayState& state) 547 { 548 GLU_CHECK_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_buffers[state.elementArrayBuffer])); 549 550 for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) 551 { 552 GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_buffers[state.attributes[attribNdx].bufferNdx])); 553 if (state.attributes[attribNdx].enabled) 554 GLU_CHECK_CALL(glEnableVertexAttribArray(attribNdx)); 555 else 556 GLU_CHECK_CALL(glDisableVertexAttribArray(attribNdx)); 557 558 if (state.attributes[attribNdx].integer) 559 GLU_CHECK_CALL(glVertexAttribIPointer(attribNdx, state.attributes[attribNdx].size, state.attributes[attribNdx].type, state.attributes[attribNdx].stride, (const GLvoid*)((GLintptr)state.attributes[attribNdx].offset))); 560 else 561 GLU_CHECK_CALL(glVertexAttribPointer(attribNdx, state.attributes[attribNdx].size, state.attributes[attribNdx].type, state.attributes[attribNdx].normalized, state.attributes[attribNdx].stride, (const GLvoid*)((GLintptr)state.attributes[attribNdx].offset))); 562 563 GLU_CHECK_CALL(glVertexAttribDivisor(attribNdx, state.attributes[attribNdx].divisor)); 564 } 565 } 566 567 void VertexArrayObjectTest::makeDrawCall (const VertexArrayState& state) 568 { 569 GLU_CHECK_CALL(glClearColor(0.7f, 0.7f, 0.7f, 1.0f)); 570 GLU_CHECK_CALL(glClear(GL_COLOR_BUFFER_BIT)); 571 572 if (m_spec.useDrawElements) 573 { 574 if (state.elementArrayBuffer == 0) 575 { 576 if (m_spec.instances == 0) 577 GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, m_spec.count, m_spec.indexType, m_indices)); 578 else 579 GLU_CHECK_CALL(glDrawElementsInstanced(GL_TRIANGLES, m_spec.count, m_spec.indexType, m_indices, m_spec.instances)); 580 } 581 else 582 { 583 if (m_spec.instances == 0) 584 GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, m_spec.count, m_spec.indexType, (GLvoid*)((GLintptr)m_spec.indexOffset))); 585 else 586 GLU_CHECK_CALL(glDrawElementsInstanced(GL_TRIANGLES, m_spec.count, m_spec.indexType, (GLvoid*)((GLintptr)m_spec.indexOffset), m_spec.instances)); 587 } 588 } 589 else 590 { 591 if (m_spec.instances == 0) 592 GLU_CHECK_CALL(glDrawArrays(GL_TRIANGLES, 0, m_spec.count)); 593 else 594 GLU_CHECK_CALL(glDrawArraysInstanced(GL_TRIANGLES, 0, m_spec.count, m_spec.instances)); 595 } 596 } 597 598 void VertexArrayObjectTest::render (tcu::Surface& vaoResult, tcu::Surface& defaultResult) 599 { 600 GLuint vao = 0; 601 602 GLU_CHECK_CALL(glGenVertexArrays(1, &vao)); 603 GLU_CHECK_CALL(glBindVertexArray(vao)); 604 setState(m_spec.vao); 605 GLU_CHECK_CALL(glBindVertexArray(0)); 606 607 setState(m_spec.state); 608 609 GLU_CHECK_CALL(glBindVertexArray(vao)); 610 GLU_CHECK_CALL(glUseProgram(m_vaoProgram->getProgram())); 611 makeDrawCall(m_spec.vao); 612 glu::readPixels(m_context.getRenderContext(), 0, 0, vaoResult.getAccess()); 613 setState(m_spec.vao); 614 GLU_CHECK_CALL(glBindVertexArray(0)); 615 616 GLU_CHECK_CALL(glUseProgram(m_stateProgram->getProgram())); 617 makeDrawCall(m_spec.state); 618 glu::readPixels(m_context.getRenderContext(), 0, 0, defaultResult.getAccess()); 619 } 620 621 void VertexArrayObjectTest::genReferences (tcu::Surface& vaoRef, tcu::Surface& defaultRef) 622 { 623 setState(m_spec.vao); 624 GLU_CHECK_CALL(glUseProgram(m_vaoProgram->getProgram())); 625 makeDrawCall(m_spec.vao); 626 glu::readPixels(m_context.getRenderContext(), 0, 0, vaoRef.getAccess()); 627 628 setState(m_spec.state); 629 GLU_CHECK_CALL(glUseProgram(m_stateProgram->getProgram())); 630 makeDrawCall(m_spec.state); 631 glu::readPixels(m_context.getRenderContext(), 0, 0, defaultRef.getAccess()); 632 } 633 634 TestCase::IterateResult VertexArrayObjectTest::iterate (void) 635 { 636 tcu::Surface vaoReference (m_context.getRenderContext().getRenderTarget().getWidth(), m_context.getRenderContext().getRenderTarget().getHeight()); 637 tcu::Surface stateReference (m_context.getRenderContext().getRenderTarget().getWidth(), m_context.getRenderContext().getRenderTarget().getHeight()); 638 639 tcu::Surface vaoResult (m_context.getRenderContext().getRenderTarget().getWidth(), m_context.getRenderContext().getRenderTarget().getHeight()); 640 tcu::Surface stateResult (m_context.getRenderContext().getRenderTarget().getWidth(), m_context.getRenderContext().getRenderTarget().getHeight()); 641 642 bool isOk; 643 644 logVertexArrayState(m_log, m_spec.vao, "Vertex Array Object State"); 645 logVertexArrayState(m_log, m_spec.state, "OpenGL Vertex Array State"); 646 genReferences(stateReference, vaoReference); 647 render(stateResult, vaoResult); 648 649 isOk = tcu::pixelThresholdCompare (m_log, "Results", "Comparison result from rendering with Vertex Array State", stateReference, stateResult, tcu::RGBA(0,0,0,0), tcu::COMPARE_LOG_RESULT); 650 isOk = isOk && tcu::pixelThresholdCompare (m_log, "Results", "Comparison result from rendering with Vertex Array Object", vaoReference, vaoResult, tcu::RGBA(0,0,0,0), tcu::COMPARE_LOG_RESULT); 651 652 if (isOk) 653 { 654 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 655 return STOP; 656 } 657 else 658 { 659 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 660 return STOP; 661 } 662 } 663 664 class MultiVertexArrayObjectTest : public TestCase 665 { 666 public: 667 668 MultiVertexArrayObjectTest (Context& context, const char* name, const char* description); 669 ~MultiVertexArrayObjectTest (void); 670 virtual void init (void); 671 virtual void deinit (void); 672 virtual IterateResult iterate (void); 673 674 private: 675 Spec m_spec; 676 tcu::TestLog& m_log; 677 vector<GLuint> m_buffers; 678 glu::ShaderProgram* m_vaoProgram; 679 glu::ShaderProgram* m_stateProgram; 680 de::Random m_random; 681 deUint8* m_indices; 682 683 void logVertexArrayState (tcu::TestLog& log, const VertexArrayState& state, const std::string& msg); 684 deUint8* createRandomBufferData (const BufferSpec& buffer); 685 deUint8* generateIndices (void); 686 glu::ShaderProgram* createProgram (const VertexArrayState& state); 687 void setState (const VertexArrayState& state); 688 void render (tcu::Surface& vaoResult, tcu::Surface& defaultResult); 689 void makeDrawCall (const VertexArrayState& state); 690 void genReferences (tcu::Surface& vaoRef, tcu::Surface& defaultRef); 691 692 MultiVertexArrayObjectTest (const MultiVertexArrayObjectTest&); 693 MultiVertexArrayObjectTest& operator= (const MultiVertexArrayObjectTest&); 694 }; 695 696 MultiVertexArrayObjectTest::MultiVertexArrayObjectTest (Context& context, const char* name, const char* description) 697 : TestCase (context, name, description) 698 , m_log (context.getTestContext().getLog()) 699 , m_vaoProgram (NULL) 700 , m_stateProgram (NULL) 701 , m_random (deStringHash(name)) 702 , m_indices (NULL) 703 { 704 // Makes zero to zero mapping for buffers 705 m_buffers.push_back(0); 706 } 707 708 MultiVertexArrayObjectTest::~MultiVertexArrayObjectTest (void) 709 { 710 } 711 712 void MultiVertexArrayObjectTest::logVertexArrayState (tcu::TestLog& log, const VertexArrayState& state, const std::string& msg) 713 { 714 std::stringstream message; 715 716 message << msg << "\n"; 717 message << "GL_ELEMENT_ARRAY_BUFFER : " << state.elementArrayBuffer << "\n"; 718 719 for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) 720 { 721 message 722 << "attribute : " << attribNdx << "\n" 723 << "\tGL_VERTEX_ATTRIB_ARRAY_ENABLED : " << (state.attributes[attribNdx].enabled ? "GL_TRUE" : "GL_FALSE") << "\n" 724 << "\tGL_VERTEX_ATTRIB_ARRAY_SIZE : " << state.attributes[attribNdx].size << "\n" 725 << "\tGL_VERTEX_ATTRIB_ARRAY_STRIDE : " << state.attributes[attribNdx].stride << "\n" 726 << "\tGL_VERTEX_ATTRIB_ARRAY_TYPE : " << state.attributes[attribNdx].type << "\n" 727 << "\tGL_VERTEX_ATTRIB_ARRAY_NORMALIZED : " << (state.attributes[attribNdx].normalized ? "GL_TRUE" : "GL_FALSE") << "\n" 728 << "\tGL_VERTEX_ATTRIB_ARRAY_INTEGER : " << (state.attributes[attribNdx].integer ? "GL_TRUE" : "GL_FALSE") << "\n" 729 << "\tGL_VERTEX_ATTRIB_ARRAY_DIVISOR : " << state.attributes[attribNdx].divisor << "\n" 730 << "\tGL_VERTEX_ATTRIB_ARRAY_POINTER : " << state.attributes[attribNdx].offset << "\n" 731 << "\t GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING : " << m_buffers[state.attributes[attribNdx].bufferNdx] << "\n"; 732 } 733 log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage; 734 } 735 736 737 void MultiVertexArrayObjectTest::init (void) 738 { 739 GLint attribCount; 740 741 GLU_CHECK_CALL(glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &attribCount)); 742 743 m_spec.useDrawElements = false; 744 m_spec.instances = 0; 745 m_spec.count = 24; 746 m_spec.indexOffset = 0; 747 m_spec.indexRangeMin = 0; 748 m_spec.indexRangeMax = 0; 749 m_spec.indexType = GL_NONE; 750 m_spec.indexCount = 0; 751 m_spec.vao.elementArrayBuffer = 0; 752 m_spec.state.elementArrayBuffer = 0; 753 754 for (int attribNdx = 0; attribNdx < attribCount; attribNdx++) 755 { 756 BufferSpec shortCoordBuffer48 = { 48, 2*384, 4, 0, 0, GL_SHORT, -32768, 32768, 0.0f, 0.0f }; 757 m_spec.buffers.push_back(shortCoordBuffer48); 758 759 m_spec.state.attributes.push_back(Attribute()); 760 m_spec.state.attributes[attribNdx].enabled = (m_random.getInt(0, 4) == 0) ? GL_FALSE : GL_TRUE; 761 m_spec.state.attributes[attribNdx].size = m_random.getInt(2,4); 762 m_spec.state.attributes[attribNdx].stride = 2*m_random.getInt(1, 3); 763 m_spec.state.attributes[attribNdx].type = GL_SHORT; 764 m_spec.state.attributes[attribNdx].integer = m_random.getBool(); 765 m_spec.state.attributes[attribNdx].divisor = m_random.getInt(0, 1); 766 m_spec.state.attributes[attribNdx].offset = 2*m_random.getInt(0, 2); 767 m_spec.state.attributes[attribNdx].normalized = m_random.getBool(); 768 m_spec.state.attributes[attribNdx].bufferNdx = attribNdx+1; 769 770 if (attribNdx == 0) 771 { 772 m_spec.state.attributes[attribNdx].divisor = 0; 773 m_spec.state.attributes[attribNdx].enabled = GL_TRUE; 774 m_spec.state.attributes[attribNdx].size = 2; 775 } 776 777 m_spec.vao.attributes.push_back(Attribute()); 778 m_spec.vao.attributes[attribNdx].enabled = (m_random.getInt(0, 4) == 0) ? GL_FALSE : GL_TRUE; 779 m_spec.vao.attributes[attribNdx].size = m_random.getInt(2,4); 780 m_spec.vao.attributes[attribNdx].stride = 2*m_random.getInt(1, 3); 781 m_spec.vao.attributes[attribNdx].type = GL_SHORT; 782 m_spec.vao.attributes[attribNdx].integer = m_random.getBool(); 783 m_spec.vao.attributes[attribNdx].divisor = m_random.getInt(0, 1); 784 m_spec.vao.attributes[attribNdx].offset = 2*m_random.getInt(0, 2); 785 m_spec.vao.attributes[attribNdx].normalized = m_random.getBool(); 786 m_spec.vao.attributes[attribNdx].bufferNdx = attribCount - attribNdx; 787 788 if (attribNdx == 0) 789 { 790 m_spec.vao.attributes[attribNdx].divisor = 0; 791 m_spec.vao.attributes[attribNdx].enabled = GL_TRUE; 792 m_spec.vao.attributes[attribNdx].size = 2; 793 } 794 795 } 796 797 // \note [mika] Index 0 is reserved for 0 buffer 798 for (int bufferNdx = 0; bufferNdx < (int)m_spec.buffers.size(); bufferNdx++) 799 { 800 deUint8* data = createRandomBufferData(m_spec.buffers[bufferNdx]); 801 802 try 803 { 804 GLuint buffer; 805 GLU_CHECK_CALL(glGenBuffers(1, &buffer)); 806 m_buffers.push_back(buffer); 807 808 GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, buffer)); 809 GLU_CHECK_CALL(glBufferData(GL_ARRAY_BUFFER, m_spec.buffers[bufferNdx].size, data, GL_DYNAMIC_DRAW)); 810 GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0)); 811 812 } catch (...) { 813 delete[] data; 814 throw; 815 } 816 817 delete[] data; 818 } 819 820 m_vaoProgram = createProgram(m_spec.vao); 821 m_log << tcu::TestLog::Message << "Program used with Vertex Array Object" << tcu::TestLog::EndMessage; 822 m_log << *m_vaoProgram; 823 m_stateProgram = createProgram(m_spec.state); 824 m_log << tcu::TestLog::Message << "Program used with Vertex Array State" << tcu::TestLog::EndMessage; 825 m_log << *m_stateProgram; 826 827 if (!m_vaoProgram->isOk() || !m_stateProgram->isOk()) 828 TCU_FAIL("Failed to compile shaders"); 829 830 if (m_spec.useDrawElements && (m_spec.vao.elementArrayBuffer == 0 || m_spec.state.elementArrayBuffer == 0)) 831 m_indices = generateIndices(); 832 } 833 834 void MultiVertexArrayObjectTest::deinit (void) 835 { 836 GLU_CHECK_CALL(glDeleteBuffers((GLsizei)m_buffers.size(), &(m_buffers[0]))); 837 m_buffers.clear(); 838 delete m_vaoProgram; 839 delete m_stateProgram; 840 delete[] m_indices; 841 } 842 843 deUint8* MultiVertexArrayObjectTest::generateIndices (void) 844 { 845 int typeSize = 0; 846 switch (m_spec.indexType) 847 { 848 case GL_UNSIGNED_INT: typeSize = sizeof(GLuint); break; 849 case GL_UNSIGNED_SHORT: typeSize = sizeof(GLushort); break; 850 case GL_UNSIGNED_BYTE: typeSize = sizeof(GLubyte); break; 851 default: 852 DE_ASSERT(false); 853 } 854 855 deUint8* indices = new deUint8[m_spec.indexCount * typeSize]; 856 857 for (int i = 0; i < m_spec.indexCount; i++) 858 { 859 deUint8* pos = indices + typeSize * i; 860 861 switch (m_spec.indexType) 862 { 863 case GL_UNSIGNED_INT: 864 { 865 GLuint v = (GLuint)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); 866 deMemcpy(pos, &v, sizeof(v)); 867 break; 868 } 869 870 case GL_UNSIGNED_SHORT: 871 { 872 GLushort v = (GLushort)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); 873 deMemcpy(pos, &v, sizeof(v)); 874 break; 875 } 876 877 case GL_UNSIGNED_BYTE: 878 { 879 GLubyte v = (GLubyte)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); 880 deMemcpy(pos, &v, sizeof(v)); 881 break; 882 } 883 884 default: 885 DE_ASSERT(false); 886 } 887 } 888 889 return indices; 890 } 891 892 deUint8* MultiVertexArrayObjectTest::createRandomBufferData (const BufferSpec& buffer) 893 { 894 deUint8* data = new deUint8[buffer.size]; 895 896 int stride; 897 898 if (buffer.stride != 0) 899 { 900 stride = buffer.stride; 901 } 902 else 903 { 904 switch (buffer.type) 905 { 906 case GL_FLOAT: stride = buffer.componentCount * sizeof(GLfloat); break; 907 case GL_INT: stride = buffer.componentCount * sizeof(GLint); break; 908 case GL_UNSIGNED_INT: stride = buffer.componentCount * sizeof(GLuint); break; 909 case GL_SHORT: stride = buffer.componentCount * sizeof(GLshort); break; 910 case GL_UNSIGNED_SHORT: stride = buffer.componentCount * sizeof(GLushort); break; 911 case GL_BYTE: stride = buffer.componentCount * sizeof(GLbyte); break; 912 case GL_UNSIGNED_BYTE: stride = buffer.componentCount * sizeof(GLubyte); break; 913 914 default: 915 stride = 0; 916 DE_ASSERT(DE_FALSE); 917 } 918 } 919 920 deUint8* itr = data; 921 922 for (int pos = 0; pos < buffer.count; pos++) 923 { 924 deUint8* componentItr = itr; 925 for (int componentNdx = 0; componentNdx < buffer.componentCount; componentNdx++) 926 { 927 switch (buffer.type) 928 { 929 case GL_FLOAT: 930 { 931 float v = buffer.floatRangeMin + (buffer.floatRangeMax - buffer.floatRangeMin) * m_random.getFloat(); 932 deMemcpy(componentItr, &v, sizeof(v)); 933 componentItr += sizeof(v); 934 break; 935 } 936 937 case GL_INT: 938 { 939 GLint v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 940 deMemcpy(componentItr, &v, sizeof(v)); 941 componentItr += sizeof(v); 942 break; 943 } 944 945 case GL_UNSIGNED_INT: 946 { 947 GLuint v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 948 deMemcpy(componentItr, &v, sizeof(v)); 949 componentItr += sizeof(v); 950 break; 951 } 952 953 case GL_SHORT: 954 { 955 GLshort v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 956 deMemcpy(componentItr, &v, sizeof(v)); 957 componentItr += sizeof(v); 958 break; 959 } 960 961 case GL_UNSIGNED_SHORT: 962 { 963 GLushort v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 964 deMemcpy(componentItr, &v, sizeof(v)); 965 componentItr += sizeof(v); 966 break; 967 } 968 969 case GL_BYTE: 970 { 971 GLbyte v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 972 deMemcpy(componentItr, &v, sizeof(v)); 973 componentItr += sizeof(v); 974 break; 975 } 976 977 case GL_UNSIGNED_BYTE: 978 { 979 GLubyte v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); 980 deMemcpy(componentItr, &v, sizeof(v)); 981 componentItr += sizeof(v); 982 break; 983 } 984 985 default: 986 DE_ASSERT(false); 987 }; 988 } 989 990 itr += stride; 991 } 992 993 return data; 994 } 995 996 glu::ShaderProgram* MultiVertexArrayObjectTest::createProgram (const VertexArrayState& state) 997 { 998 std::stringstream vertexShaderStream; 999 std::stringstream value; 1000 1001 vertexShaderStream << "#version 300 es\n"; 1002 1003 for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) 1004 { 1005 if (state.attributes[attribNdx].integer) 1006 vertexShaderStream << "layout(location = " << attribNdx << ") in mediump ivec4 a_attrib" << attribNdx << ";\n"; 1007 else 1008 vertexShaderStream << "layout(location = " << attribNdx << ") in mediump vec4 a_attrib" << attribNdx << ";\n"; 1009 1010 if (state.attributes[attribNdx].integer) 1011 { 1012 float scale = 0.0f; 1013 1014 switch (state.attributes[0].type) 1015 { 1016 case GL_SHORT: scale = (1.0f/((1u<<14)-1)); break; 1017 case GL_UNSIGNED_SHORT: scale = (1.0f/((1u<<15)-1)); break; 1018 case GL_INT: scale = (1.0f/((1u<<30)-1)); break; 1019 case GL_UNSIGNED_INT: scale = (1.0f/((1u<<31)-1)); break; 1020 case GL_BYTE: scale = (1.0f/((1u<<6)-1)); break; 1021 case GL_UNSIGNED_BYTE: scale = (1.0f/((1u<<7)-1)); break; 1022 1023 default: 1024 DE_ASSERT(DE_FALSE); 1025 } 1026 value << (attribNdx != 0 ? " + " : "" ) << scale << " * vec4(a_attrib" << attribNdx << ")"; 1027 } 1028 else if (state.attributes[attribNdx].type != GL_FLOAT && !state.attributes[attribNdx].normalized) 1029 { 1030 float scale = 0.0f; 1031 1032 switch (state.attributes[0].type) 1033 { 1034 case GL_SHORT: scale = (0.5f/((1u<<14)-1)); break; 1035 case GL_UNSIGNED_SHORT: scale = (0.5f/((1u<<15)-1)); break; 1036 case GL_INT: scale = (0.5f/((1u<<30)-1)); break; 1037 case GL_UNSIGNED_INT: scale = (0.5f/((1u<<31)-1)); break; 1038 case GL_BYTE: scale = (0.5f/((1u<<6)-1)); break; 1039 case GL_UNSIGNED_BYTE: scale = (0.5f/((1u<<7)-1)); break; 1040 1041 default: 1042 DE_ASSERT(DE_FALSE); 1043 } 1044 value << (attribNdx != 0 ? " + " : "" ) << scale << " * a_attrib" << attribNdx; 1045 } 1046 else 1047 value << (attribNdx != 0 ? " + " : "" ) << "a_attrib" << attribNdx; 1048 } 1049 1050 vertexShaderStream 1051 << "out mediump vec4 v_value;\n" 1052 << "void main (void)\n" 1053 << "{\n" 1054 << "\tv_value = " << value.str() << ";\n"; 1055 1056 if (state.attributes[0].integer) 1057 { 1058 float scale = 0.0f; 1059 1060 switch (state.attributes[0].type) 1061 { 1062 case GL_SHORT: scale = (1.0f/((1u<<14)-1)); break; 1063 case GL_UNSIGNED_SHORT: scale = (1.0f/((1u<<15)-1)); break; 1064 case GL_INT: scale = (1.0f/((1u<<30)-1)); break; 1065 case GL_UNSIGNED_INT: scale = (1.0f/((1u<<31)-1)); break; 1066 case GL_BYTE: scale = (1.0f/((1u<<6)-1)); break; 1067 case GL_UNSIGNED_BYTE: scale = (1.0f/((1u<<7)-1)); break; 1068 1069 1070 default: 1071 DE_ASSERT(DE_FALSE); 1072 } 1073 1074 vertexShaderStream 1075 << "\tgl_Position = vec4(" << scale << " * " << "a_attrib0.xyz, 1.0);\n" 1076 << "}"; 1077 } 1078 else 1079 { 1080 if (state.attributes[0].normalized || state.attributes[0].type == GL_FLOAT) 1081 { 1082 vertexShaderStream 1083 << "\tgl_Position = vec4(a_attrib0.xyz, 1.0);\n" 1084 << "}"; 1085 } 1086 else 1087 { 1088 float scale = 0.0f; 1089 1090 switch (state.attributes[0].type) 1091 { 1092 case GL_SHORT: scale = (1.0f/((1u<<14)-1)); break; 1093 case GL_UNSIGNED_SHORT: scale = (1.0f/((1u<<15)-1)); break; 1094 case GL_INT: scale = (1.0f/((1u<<30)-1)); break; 1095 case GL_UNSIGNED_INT: scale = (1.0f/((1u<<31)-1)); break; 1096 case GL_BYTE: scale = (1.0f/((1u<<6)-1)); break; 1097 case GL_UNSIGNED_BYTE: scale = (1.0f/((1u<<7)-1)); break; 1098 1099 default: 1100 DE_ASSERT(DE_FALSE); 1101 } 1102 1103 scale *= 0.5; 1104 1105 vertexShaderStream 1106 << "\tgl_Position = vec4(" << scale << " * " << "vec3(a_attrib0.xyz), 1.0);\n" 1107 << "}"; 1108 } 1109 } 1110 1111 const char* fragmentShader = 1112 "#version 300 es\n" 1113 "in mediump vec4 v_value;\n" 1114 "layout(location = 0) out mediump vec4 fragColor;\n" 1115 "void main (void)\n" 1116 "{\n" 1117 "\tfragColor = vec4(v_value.xyz, 1.0);\n" 1118 "}"; 1119 1120 return new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderStream.str(), fragmentShader)); 1121 } 1122 1123 void MultiVertexArrayObjectTest::setState (const VertexArrayState& state) 1124 { 1125 GLU_CHECK_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_buffers[state.elementArrayBuffer])); 1126 1127 for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) 1128 { 1129 GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_buffers[state.attributes[attribNdx].bufferNdx])); 1130 if (state.attributes[attribNdx].enabled) 1131 GLU_CHECK_CALL(glEnableVertexAttribArray(attribNdx)); 1132 else 1133 GLU_CHECK_CALL(glDisableVertexAttribArray(attribNdx)); 1134 1135 if (state.attributes[attribNdx].integer) 1136 GLU_CHECK_CALL(glVertexAttribIPointer(attribNdx, state.attributes[attribNdx].size, state.attributes[attribNdx].type, state.attributes[attribNdx].stride, (const GLvoid*)((GLintptr)state.attributes[attribNdx].offset))); 1137 else 1138 GLU_CHECK_CALL(glVertexAttribPointer(attribNdx, state.attributes[attribNdx].size, state.attributes[attribNdx].type, state.attributes[attribNdx].normalized, state.attributes[attribNdx].stride, (const GLvoid*)((GLintptr)state.attributes[attribNdx].offset))); 1139 1140 GLU_CHECK_CALL(glVertexAttribDivisor(attribNdx, state.attributes[attribNdx].divisor)); 1141 } 1142 } 1143 1144 void MultiVertexArrayObjectTest::makeDrawCall (const VertexArrayState& state) 1145 { 1146 GLU_CHECK_CALL(glClearColor(0.7f, 0.7f, 0.7f, 1.0f)); 1147 GLU_CHECK_CALL(glClear(GL_COLOR_BUFFER_BIT)); 1148 1149 if (m_spec.useDrawElements) 1150 { 1151 if (state.elementArrayBuffer == 0) 1152 { 1153 if (m_spec.instances == 0) 1154 GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, m_spec.count, m_spec.indexType, m_indices)); 1155 else 1156 GLU_CHECK_CALL(glDrawElementsInstanced(GL_TRIANGLES, m_spec.count, m_spec.indexType, m_indices, m_spec.instances)); 1157 } 1158 else 1159 { 1160 if (m_spec.instances == 0) 1161 GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, m_spec.count, m_spec.indexType, (GLvoid*)((GLintptr)m_spec.indexOffset))); 1162 else 1163 GLU_CHECK_CALL(glDrawElementsInstanced(GL_TRIANGLES, m_spec.count, m_spec.indexType, (GLvoid*)((GLintptr)m_spec.indexOffset), m_spec.instances)); 1164 } 1165 } 1166 else 1167 { 1168 if (m_spec.instances == 0) 1169 GLU_CHECK_CALL(glDrawArrays(GL_TRIANGLES, 0, m_spec.count)); 1170 else 1171 GLU_CHECK_CALL(glDrawArraysInstanced(GL_TRIANGLES, 0, m_spec.count, m_spec.instances)); 1172 } 1173 } 1174 1175 void MultiVertexArrayObjectTest::render (tcu::Surface& vaoResult, tcu::Surface& defaultResult) 1176 { 1177 GLuint vao = 0; 1178 1179 GLU_CHECK_CALL(glGenVertexArrays(1, &vao)); 1180 GLU_CHECK_CALL(glBindVertexArray(vao)); 1181 setState(m_spec.vao); 1182 GLU_CHECK_CALL(glBindVertexArray(0)); 1183 1184 setState(m_spec.state); 1185 1186 GLU_CHECK_CALL(glBindVertexArray(vao)); 1187 GLU_CHECK_CALL(glUseProgram(m_vaoProgram->getProgram())); 1188 makeDrawCall(m_spec.vao); 1189 glu::readPixels(m_context.getRenderContext(), 0, 0, vaoResult.getAccess()); 1190 setState(m_spec.vao); 1191 GLU_CHECK_CALL(glBindVertexArray(0)); 1192 1193 GLU_CHECK_CALL(glUseProgram(m_stateProgram->getProgram())); 1194 makeDrawCall(m_spec.state); 1195 glu::readPixels(m_context.getRenderContext(), 0, 0, defaultResult.getAccess()); 1196 } 1197 1198 void MultiVertexArrayObjectTest::genReferences (tcu::Surface& vaoRef, tcu::Surface& defaultRef) 1199 { 1200 setState(m_spec.vao); 1201 GLU_CHECK_CALL(glUseProgram(m_vaoProgram->getProgram())); 1202 makeDrawCall(m_spec.vao); 1203 glu::readPixels(m_context.getRenderContext(), 0, 0, vaoRef.getAccess()); 1204 1205 setState(m_spec.state); 1206 GLU_CHECK_CALL(glUseProgram(m_stateProgram->getProgram())); 1207 makeDrawCall(m_spec.state); 1208 glu::readPixels(m_context.getRenderContext(), 0, 0, defaultRef.getAccess()); 1209 } 1210 1211 TestCase::IterateResult MultiVertexArrayObjectTest::iterate (void) 1212 { 1213 tcu::Surface vaoReference (m_context.getRenderContext().getRenderTarget().getWidth(), m_context.getRenderContext().getRenderTarget().getHeight()); 1214 tcu::Surface stateReference (m_context.getRenderContext().getRenderTarget().getWidth(), m_context.getRenderContext().getRenderTarget().getHeight()); 1215 1216 tcu::Surface vaoResult (m_context.getRenderContext().getRenderTarget().getWidth(), m_context.getRenderContext().getRenderTarget().getHeight()); 1217 tcu::Surface stateResult (m_context.getRenderContext().getRenderTarget().getWidth(), m_context.getRenderContext().getRenderTarget().getHeight()); 1218 1219 bool isOk; 1220 1221 logVertexArrayState(m_log, m_spec.vao, "Vertex Array Object State"); 1222 logVertexArrayState(m_log, m_spec.state, "OpenGL Vertex Array State"); 1223 genReferences(stateReference, vaoReference); 1224 render(stateResult, vaoResult); 1225 1226 isOk = tcu::pixelThresholdCompare (m_log, "Results", "Comparison result from rendering with Vertex Array State", stateReference, stateResult, tcu::RGBA(0,0,0,0), tcu::COMPARE_LOG_RESULT); 1227 isOk = isOk && tcu::pixelThresholdCompare (m_log, "Results", "Comparison result from rendering with Vertex Array Object", vaoReference, vaoResult, tcu::RGBA(0,0,0,0), tcu::COMPARE_LOG_RESULT); 1228 1229 if (isOk) 1230 { 1231 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1232 return STOP; 1233 } 1234 else 1235 { 1236 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1237 return STOP; 1238 } 1239 } 1240 1241 VertexArrayObjectTestGroup::VertexArrayObjectTestGroup (Context& context) 1242 : TestCaseGroup(context, "vertex_array_objects", "Vertex array object test cases") 1243 { 1244 } 1245 1246 VertexArrayObjectTestGroup::~VertexArrayObjectTestGroup (void) 1247 { 1248 } 1249 1250 void VertexArrayObjectTestGroup::init (void) 1251 { 1252 BufferSpec floatCoordBuffer48_1 = { 48, 384, 2, 0, 0, GL_FLOAT, 0, 0, -1.0f, 1.0f }; 1253 BufferSpec floatCoordBuffer48_2 = { 48, 384, 2, 0, 0, GL_FLOAT, 0, 0, -1.0f, 1.0f }; 1254 1255 BufferSpec shortCoordBuffer48 = { 48, 192, 2, 0, 0, GL_SHORT, -32768, 32768, 0.0f, 0.0f }; 1256 1257 // Different buffer 1258 { 1259 Spec spec; 1260 1261 VertexArrayState state; 1262 1263 state.attributes.push_back(Attribute()); 1264 1265 state.attributes[0].enabled = true; 1266 state.attributes[0].size = 2; 1267 state.attributes[0].stride = 0; 1268 state.attributes[0].type = GL_FLOAT; 1269 state.attributes[0].integer = GL_FALSE; 1270 state.attributes[0].divisor = 0; 1271 state.attributes[0].offset = 0; 1272 state.attributes[0].normalized = GL_FALSE; 1273 1274 state.elementArrayBuffer = 0; 1275 1276 spec.buffers.push_back(floatCoordBuffer48_1); 1277 spec.buffers.push_back(floatCoordBuffer48_2); 1278 1279 spec.useDrawElements = false; 1280 spec.instances = 0; 1281 spec.count = 48; 1282 spec.vao = state; 1283 spec.state = state; 1284 spec.indexOffset = 0; 1285 spec.indexRangeMin = 0; 1286 spec.indexRangeMax = 0; 1287 spec.indexType = GL_NONE; 1288 spec.indexCount = 0; 1289 1290 spec.state.attributes[0].bufferNdx = 1; 1291 spec.vao.attributes[0].bufferNdx = 2; 1292 addChild(new VertexArrayObjectTest(m_context, spec, "diff_buffer", "diff_buffer")); 1293 } 1294 // Different size 1295 { 1296 Spec spec; 1297 1298 VertexArrayState state; 1299 1300 state.attributes.push_back(Attribute()); 1301 1302 state.attributes[0].enabled = true; 1303 state.attributes[0].size = 2; 1304 state.attributes[0].stride = 0; 1305 state.attributes[0].type = GL_FLOAT; 1306 state.attributes[0].integer = GL_FALSE; 1307 state.attributes[0].divisor = 0; 1308 state.attributes[0].offset = 0; 1309 state.attributes[0].normalized = GL_FALSE; 1310 state.attributes[0].bufferNdx = 1; 1311 1312 state.elementArrayBuffer = 0; 1313 1314 spec.buffers.push_back(floatCoordBuffer48_1); 1315 1316 spec.useDrawElements = false; 1317 spec.instances = 0; 1318 spec.count = 24; 1319 spec.vao = state; 1320 spec.state = state; 1321 spec.indexOffset = 0; 1322 spec.indexRangeMin = 0; 1323 spec.indexRangeMax = 0; 1324 spec.indexType = GL_NONE; 1325 spec.indexCount = 0; 1326 1327 spec.state.attributes[0].size = 2; 1328 spec.vao.attributes[0].size = 3; 1329 addChild(new VertexArrayObjectTest(m_context, spec, "diff_size", "diff_size")); 1330 } 1331 1332 // Different stride 1333 { 1334 Spec spec; 1335 1336 VertexArrayState state; 1337 1338 state.attributes.push_back(Attribute()); 1339 1340 state.attributes[0].enabled = true; 1341 state.attributes[0].size = 2; 1342 state.attributes[0].stride = 0; 1343 state.attributes[0].type = GL_SHORT; 1344 state.attributes[0].integer = GL_FALSE; 1345 state.attributes[0].divisor = 0; 1346 state.attributes[0].offset = 0; 1347 state.attributes[0].normalized = GL_TRUE; 1348 state.attributes[0].bufferNdx = 1; 1349 1350 state.elementArrayBuffer = 0; 1351 1352 spec.buffers.push_back(shortCoordBuffer48); 1353 1354 spec.useDrawElements = false; 1355 spec.instances = 0; 1356 spec.count = 24; 1357 spec.vao = state; 1358 spec.state = state; 1359 spec.indexOffset = 0; 1360 spec.indexRangeMin = 0; 1361 spec.indexRangeMax = 0; 1362 spec.indexType = GL_NONE; 1363 spec.indexCount = 0; 1364 1365 spec.vao.attributes[0].stride = 2; 1366 spec.state.attributes[0].stride = 4; 1367 addChild(new VertexArrayObjectTest(m_context, spec, "diff_stride", "diff_stride")); 1368 } 1369 1370 // Different types 1371 { 1372 Spec spec; 1373 1374 VertexArrayState state; 1375 1376 state.attributes.push_back(Attribute()); 1377 1378 state.attributes[0].enabled = true; 1379 state.attributes[0].size = 2; 1380 state.attributes[0].stride = 0; 1381 state.attributes[0].type = GL_SHORT; 1382 state.attributes[0].integer = GL_FALSE; 1383 state.attributes[0].divisor = 0; 1384 state.attributes[0].offset = 0; 1385 state.attributes[0].normalized = GL_TRUE; 1386 state.attributes[0].bufferNdx = 1; 1387 1388 state.elementArrayBuffer = 0; 1389 1390 spec.buffers.push_back(shortCoordBuffer48); 1391 1392 spec.useDrawElements = false; 1393 spec.instances = 0; 1394 spec.count = 24; 1395 spec.vao = state; 1396 spec.state = state; 1397 spec.indexOffset = 0; 1398 spec.indexRangeMin = 0; 1399 spec.indexRangeMax = 0; 1400 spec.indexType = GL_NONE; 1401 spec.indexCount = 0; 1402 1403 spec.vao.attributes[0].type = GL_SHORT; 1404 spec.state.attributes[0].type = GL_BYTE; 1405 addChild(new VertexArrayObjectTest(m_context, spec, "diff_type", "diff_type")); 1406 } 1407 // Different "integer" 1408 { 1409 Spec spec; 1410 1411 VertexArrayState state; 1412 1413 state.attributes.push_back(Attribute()); 1414 1415 state.attributes[0].enabled = true; 1416 state.attributes[0].size = 2; 1417 state.attributes[0].stride = 0; 1418 state.attributes[0].type = GL_BYTE; 1419 state.attributes[0].integer = GL_TRUE; 1420 state.attributes[0].divisor = 0; 1421 state.attributes[0].offset = 0; 1422 state.attributes[0].normalized = GL_FALSE; 1423 state.attributes[0].bufferNdx = 1; 1424 1425 state.elementArrayBuffer = 0; 1426 1427 spec.buffers.push_back(shortCoordBuffer48); 1428 1429 spec.useDrawElements = false; 1430 spec.count = 24; 1431 spec.vao = state; 1432 spec.state = state; 1433 spec.instances = 0; 1434 spec.indexOffset = 0; 1435 spec.indexRangeMin = 0; 1436 spec.indexRangeMax = 0; 1437 spec.indexType = GL_NONE; 1438 spec.indexCount = 0; 1439 1440 spec.state.attributes[0].integer = GL_FALSE; 1441 spec.vao.attributes[0].integer = GL_TRUE; 1442 addChild(new VertexArrayObjectTest(m_context, spec, "diff_integer", "diff_integer")); 1443 } 1444 // Different divisor 1445 { 1446 Spec spec; 1447 1448 VertexArrayState state; 1449 1450 state.attributes.push_back(Attribute()); 1451 state.attributes.push_back(Attribute()); 1452 1453 state.attributes[0].enabled = true; 1454 state.attributes[0].size = 2; 1455 state.attributes[0].stride = 0; 1456 state.attributes[0].type = GL_SHORT; 1457 state.attributes[0].integer = GL_FALSE; 1458 state.attributes[0].divisor = 0; 1459 state.attributes[0].offset = 0; 1460 state.attributes[0].normalized = GL_TRUE; 1461 state.attributes[0].bufferNdx = 1; 1462 1463 state.attributes[1].enabled = true; 1464 state.attributes[1].size = 4; 1465 state.attributes[1].stride = 0; 1466 state.attributes[1].type = GL_FLOAT; 1467 state.attributes[1].integer = GL_FALSE; 1468 state.attributes[1].divisor = 0; 1469 state.attributes[1].offset = 0; 1470 state.attributes[1].normalized = GL_FALSE; 1471 state.attributes[1].bufferNdx = 2; 1472 1473 state.elementArrayBuffer = 0; 1474 1475 spec.buffers.push_back(shortCoordBuffer48); 1476 spec.buffers.push_back(floatCoordBuffer48_1); 1477 1478 spec.useDrawElements = false; 1479 spec.instances = 10; 1480 spec.count = 12; 1481 spec.vao = state; 1482 spec.state = state; 1483 spec.indexOffset = 0; 1484 spec.indexRangeMin = 0; 1485 spec.indexRangeMax = 0; 1486 spec.indexType = GL_NONE; 1487 spec.indexCount = 0; 1488 1489 spec.vao.attributes[1].divisor = 3; 1490 spec.state.attributes[1].divisor = 2; 1491 1492 addChild(new VertexArrayObjectTest(m_context, spec, "diff_divisor", "diff_divisor")); 1493 } 1494 // Different offset 1495 { 1496 Spec spec; 1497 1498 VertexArrayState state; 1499 1500 state.attributes.push_back(Attribute()); 1501 1502 state.attributes[0].enabled = true; 1503 state.attributes[0].size = 2; 1504 state.attributes[0].stride = 0; 1505 state.attributes[0].type = GL_SHORT; 1506 state.attributes[0].integer = GL_FALSE; 1507 state.attributes[0].divisor = 0; 1508 state.attributes[0].offset = 0; 1509 state.attributes[0].normalized = GL_TRUE; 1510 state.attributes[0].bufferNdx = 1; 1511 1512 state.elementArrayBuffer = 0; 1513 1514 spec.buffers.push_back(shortCoordBuffer48); 1515 1516 spec.useDrawElements = false; 1517 spec.instances = 0; 1518 spec.count = 24; 1519 spec.vao = state; 1520 spec.state = state; 1521 spec.indexOffset = 0; 1522 spec.indexRangeMin = 0; 1523 spec.indexRangeMax = 0; 1524 spec.indexType = GL_NONE; 1525 spec.indexCount = 0; 1526 1527 spec.vao.attributes[0].offset = 2; 1528 spec.state.attributes[0].offset = 4; 1529 addChild(new VertexArrayObjectTest(m_context, spec, "diff_offset", "diff_offset")); 1530 } 1531 // Different normalize 1532 { 1533 Spec spec; 1534 1535 VertexArrayState state; 1536 1537 state.attributes.push_back(Attribute()); 1538 1539 state.attributes[0].enabled = true; 1540 state.attributes[0].size = 2; 1541 state.attributes[0].stride = 0; 1542 state.attributes[0].type = GL_SHORT; 1543 state.attributes[0].integer = GL_FALSE; 1544 state.attributes[0].divisor = 0; 1545 state.attributes[0].offset = 0; 1546 state.attributes[0].normalized = GL_TRUE; 1547 state.attributes[0].bufferNdx = 1; 1548 1549 state.elementArrayBuffer = 0; 1550 1551 spec.buffers.push_back(shortCoordBuffer48); 1552 1553 spec.useDrawElements = false; 1554 spec.instances = 0; 1555 spec.count = 48; 1556 spec.vao = state; 1557 spec.state = state; 1558 spec.indexOffset = 0; 1559 spec.indexRangeMin = 0; 1560 spec.indexRangeMax = 0; 1561 spec.indexType = GL_NONE; 1562 spec.indexCount = 0; 1563 1564 spec.vao.attributes[0].normalized = GL_TRUE; 1565 spec.state.attributes[0].normalized = GL_FALSE;; 1566 addChild(new VertexArrayObjectTest(m_context, spec, "diff_normalize", "diff_normalize")); 1567 } 1568 // DrawElements with buffer / Pointer 1569 { 1570 Spec spec; 1571 1572 VertexArrayState state; 1573 1574 state.attributes.push_back(Attribute()); 1575 1576 state.attributes[0].enabled = true; 1577 state.attributes[0].size = 2; 1578 state.attributes[0].stride = 0; 1579 state.attributes[0].type = GL_FLOAT; 1580 state.attributes[0].integer = GL_FALSE; 1581 state.attributes[0].divisor = 0; 1582 state.attributes[0].offset = 0; 1583 state.attributes[0].normalized = GL_TRUE; 1584 state.attributes[0].bufferNdx = 1; 1585 1586 state.elementArrayBuffer = 0; 1587 1588 spec.buffers.push_back(floatCoordBuffer48_1); 1589 1590 BufferSpec indexBuffer = { 24, 192, 1, 0, 0, GL_UNSIGNED_SHORT, 0, 48, 0.0f, 0.0f }; 1591 spec.buffers.push_back(indexBuffer); 1592 1593 spec.useDrawElements = true; 1594 spec.count = 24; 1595 spec.vao = state; 1596 spec.state = state; 1597 spec.instances = 0; 1598 spec.indexOffset = 0; 1599 spec.indexRangeMin = 0; 1600 spec.indexRangeMax = 48; 1601 spec.indexType = GL_UNSIGNED_SHORT; 1602 spec.indexCount = 24; 1603 1604 spec.state.elementArrayBuffer = 0; 1605 spec.vao.elementArrayBuffer = 2; 1606 addChild(new VertexArrayObjectTest(m_context, spec, "diff_indices", "diff_indices")); 1607 } 1608 // Use all attributes 1609 1610 addChild(new MultiVertexArrayObjectTest(m_context, "all_attributes", "all_attributes")); 1611 } 1612 1613 } // Functional 1614 } // gles3 1615 } // deqp 1616
