1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program EGL 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 Rendering tests for different config and api combinations. 22 * \todo [2013-03-19 pyry] GLES1 and VG support. 23 *//*--------------------------------------------------------------------*/ 24 25 #include "teglRenderTests.hpp" 26 #include "teglRenderCase.hpp" 27 28 #include "tcuRenderTarget.hpp" 29 #include "tcuTestLog.hpp" 30 #include "tcuImageCompare.hpp" 31 #include "tcuTextureUtil.hpp" 32 #include "tcuSurface.hpp" 33 34 #include "egluDefs.hpp" 35 #include "egluUtil.hpp" 36 37 #include "eglwLibrary.hpp" 38 #include "eglwEnums.hpp" 39 40 #include "gluShaderProgram.hpp" 41 42 #include "glwFunctions.hpp" 43 #include "glwEnums.hpp" 44 45 #include "deRandom.hpp" 46 #include "deSharedPtr.hpp" 47 #include "deSemaphore.hpp" 48 #include "deThread.hpp" 49 #include "deString.h" 50 51 #include "rrRenderer.hpp" 52 #include "rrFragmentOperations.hpp" 53 54 #include <algorithm> 55 #include <iterator> 56 #include <memory> 57 #include <set> 58 59 namespace deqp 60 { 61 namespace egl 62 { 63 64 using std::string; 65 using std::vector; 66 using std::set; 67 68 using tcu::Vec4; 69 70 using tcu::TestLog; 71 72 using namespace glw; 73 using namespace eglw; 74 75 static const tcu::Vec4 CLEAR_COLOR = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); 76 static const float CLEAR_DEPTH = 1.0f; 77 static const int CLEAR_STENCIL = 0; 78 79 namespace 80 { 81 82 enum PrimitiveType 83 { 84 PRIMITIVETYPE_TRIANGLE = 0, //!< Triangles, requires 3 coordinates per primitive 85 // PRIMITIVETYPE_POINT, //!< Points, requires 1 coordinate per primitive (w is used as size) 86 // PRIMITIVETYPE_LINE, //!< Lines, requires 2 coordinates per primitive 87 88 PRIMITIVETYPE_LAST 89 }; 90 91 enum BlendMode 92 { 93 BLENDMODE_NONE = 0, //!< No blending 94 BLENDMODE_ADDITIVE, //!< Blending with ONE, ONE 95 BLENDMODE_SRC_OVER, //!< Blending with SRC_ALPHA, ONE_MINUS_SRC_ALPHA 96 97 BLENDMODE_LAST 98 }; 99 100 enum DepthMode 101 { 102 DEPTHMODE_NONE = 0, //!< No depth test or depth writes 103 DEPTHMODE_LESS, //!< Depth test with less & depth write 104 105 DEPTHMODE_LAST 106 }; 107 108 enum StencilMode 109 { 110 STENCILMODE_NONE = 0, //!< No stencil test or write 111 STENCILMODE_LEQUAL_INC, //!< Stencil test with LEQUAL, increment on pass 112 113 STENCILMODE_LAST 114 }; 115 116 struct DrawPrimitiveOp 117 { 118 PrimitiveType type; 119 int count; 120 vector<Vec4> positions; 121 vector<Vec4> colors; 122 BlendMode blend; 123 DepthMode depth; 124 StencilMode stencil; 125 int stencilRef; 126 }; 127 128 static bool isANarrowScreenSpaceTriangle (const tcu::Vec4& p0, const tcu::Vec4& p1, const tcu::Vec4& p2) 129 { 130 // to clip space 131 const tcu::Vec2 csp0 = p0.swizzle(0, 1) / p0.w(); 132 const tcu::Vec2 csp1 = p1.swizzle(0, 1) / p1.w(); 133 const tcu::Vec2 csp2 = p2.swizzle(0, 1) / p2.w(); 134 135 const tcu::Vec2 e01 = (csp1 - csp0); 136 const tcu::Vec2 e02 = (csp2 - csp0); 137 138 const float minimumVisibleArea = 0.4f; // must cover at least 10% of the surface 139 const float visibleArea = de::abs(e01.x() * e02.y() - e02.x() * e01.y()) * 0.5f; 140 141 return visibleArea < minimumVisibleArea; 142 } 143 144 void randomizeDrawOp (de::Random& rnd, DrawPrimitiveOp& drawOp, const bool alphaZeroOrOne) 145 { 146 const int minStencilRef = 0; 147 const int maxStencilRef = 8; 148 const int minPrimitives = 2; 149 const int maxPrimitives = 4; 150 151 const float maxTriOffset = 1.0f; 152 const float minDepth = -1.0f; // \todo [pyry] Reference doesn't support Z clipping yet 153 const float maxDepth = 1.0f; 154 155 const float minRGB = 0.2f; 156 const float maxRGB = 0.9f; 157 const float minAlpha = 0.3f; 158 const float maxAlpha = 1.0f; 159 160 drawOp.type = (PrimitiveType)rnd.getInt(0, PRIMITIVETYPE_LAST-1); 161 drawOp.count = rnd.getInt(minPrimitives, maxPrimitives); 162 drawOp.blend = (BlendMode)rnd.getInt(0, BLENDMODE_LAST-1); 163 drawOp.depth = (DepthMode)rnd.getInt(0, DEPTHMODE_LAST-1); 164 drawOp.stencil = (StencilMode)rnd.getInt(0, STENCILMODE_LAST-1); 165 drawOp.stencilRef = rnd.getInt(minStencilRef, maxStencilRef); 166 167 if (drawOp.type == PRIMITIVETYPE_TRIANGLE) 168 { 169 drawOp.positions.resize(drawOp.count*3); 170 drawOp.colors.resize(drawOp.count*3); 171 172 for (int triNdx = 0; triNdx < drawOp.count; triNdx++) 173 { 174 const float cx = rnd.getFloat(-1.0f, 1.0f); 175 const float cy = rnd.getFloat(-1.0f, 1.0f); 176 const float flatAlpha = (rnd.getFloat(minAlpha, maxAlpha) > 0.5f) ? 1.0f : 0.0f; 177 178 for (int coordNdx = 0; coordNdx < 3; coordNdx++) 179 { 180 tcu::Vec4& position = drawOp.positions[triNdx*3 + coordNdx]; 181 tcu::Vec4& color = drawOp.colors[triNdx*3 + coordNdx]; 182 183 position.x() = cx + rnd.getFloat(-maxTriOffset, maxTriOffset); 184 position.y() = cy + rnd.getFloat(-maxTriOffset, maxTriOffset); 185 position.z() = rnd.getFloat(minDepth, maxDepth); 186 position.w() = 1.0f; 187 188 color.x() = rnd.getFloat(minRGB, maxRGB); 189 color.y() = rnd.getFloat(minRGB, maxRGB); 190 color.z() = rnd.getFloat(minRGB, maxRGB); 191 color.w() = rnd.getFloat(minAlpha, maxAlpha); 192 193 if (alphaZeroOrOne) 194 { 195 color.w() = flatAlpha; 196 } 197 } 198 199 // avoid generating narrow triangles 200 { 201 const int maxAttempts = 100; 202 int numAttempts = 0; 203 tcu::Vec4& p0 = drawOp.positions[triNdx*3 + 0]; 204 tcu::Vec4& p1 = drawOp.positions[triNdx*3 + 1]; 205 tcu::Vec4& p2 = drawOp.positions[triNdx*3 + 2]; 206 207 while (isANarrowScreenSpaceTriangle(p0, p1, p2)) 208 { 209 p1.x() = cx + rnd.getFloat(-maxTriOffset, maxTriOffset); 210 p1.y() = cy + rnd.getFloat(-maxTriOffset, maxTriOffset); 211 p1.z() = rnd.getFloat(minDepth, maxDepth); 212 p1.w() = 1.0f; 213 214 p2.x() = cx + rnd.getFloat(-maxTriOffset, maxTriOffset); 215 p2.y() = cy + rnd.getFloat(-maxTriOffset, maxTriOffset); 216 p2.z() = rnd.getFloat(minDepth, maxDepth); 217 p2.w() = 1.0f; 218 219 if (++numAttempts > maxAttempts) 220 { 221 DE_ASSERT(false); 222 break; 223 } 224 } 225 } 226 } 227 } 228 else 229 DE_ASSERT(false); 230 } 231 232 // Reference rendering code 233 234 class ReferenceShader : public rr::VertexShader, public rr::FragmentShader 235 { 236 public: 237 enum 238 { 239 VaryingLoc_Color = 0 240 }; 241 242 ReferenceShader () 243 : rr::VertexShader (2, 1) // color and pos in => color out 244 , rr::FragmentShader(1, 1) // color in => color out 245 { 246 this->rr::VertexShader::m_inputs[0].type = rr::GENERICVECTYPE_FLOAT; 247 this->rr::VertexShader::m_inputs[1].type = rr::GENERICVECTYPE_FLOAT; 248 249 this->rr::VertexShader::m_outputs[0].type = rr::GENERICVECTYPE_FLOAT; 250 this->rr::VertexShader::m_outputs[0].flatshade = false; 251 252 this->rr::FragmentShader::m_inputs[0].type = rr::GENERICVECTYPE_FLOAT; 253 this->rr::FragmentShader::m_inputs[0].flatshade = false; 254 255 this->rr::FragmentShader::m_outputs[0].type = rr::GENERICVECTYPE_FLOAT; 256 } 257 258 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const 259 { 260 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 261 { 262 const int positionAttrLoc = 0; 263 const int colorAttrLoc = 1; 264 265 rr::VertexPacket& packet = *packets[packetNdx]; 266 267 // Transform to position 268 packet.position = rr::readVertexAttribFloat(inputs[positionAttrLoc], packet.instanceNdx, packet.vertexNdx); 269 270 // Pass color to FS 271 packet.outputs[VaryingLoc_Color] = rr::readVertexAttribFloat(inputs[colorAttrLoc], packet.instanceNdx, packet.vertexNdx); 272 } 273 } 274 275 void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const 276 { 277 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 278 { 279 rr::FragmentPacket& packet = packets[packetNdx]; 280 281 for (int fragNdx = 0; fragNdx < 4; ++fragNdx) 282 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, rr::readVarying<float>(packet, context, VaryingLoc_Color, fragNdx)); 283 } 284 } 285 }; 286 287 void toReferenceRenderState (rr::RenderState& state, const DrawPrimitiveOp& drawOp) 288 { 289 state.cullMode = rr::CULLMODE_NONE; 290 291 if (drawOp.blend != BLENDMODE_NONE) 292 { 293 state.fragOps.blendMode = rr::BLENDMODE_STANDARD; 294 295 switch (drawOp.blend) 296 { 297 case BLENDMODE_ADDITIVE: 298 state.fragOps.blendRGBState.srcFunc = rr::BLENDFUNC_ONE; 299 state.fragOps.blendRGBState.dstFunc = rr::BLENDFUNC_ONE; 300 state.fragOps.blendRGBState.equation = rr::BLENDEQUATION_ADD; 301 state.fragOps.blendAState = state.fragOps.blendRGBState; 302 break; 303 304 case BLENDMODE_SRC_OVER: 305 state.fragOps.blendRGBState.srcFunc = rr::BLENDFUNC_SRC_ALPHA; 306 state.fragOps.blendRGBState.dstFunc = rr::BLENDFUNC_ONE_MINUS_SRC_ALPHA; 307 state.fragOps.blendRGBState.equation = rr::BLENDEQUATION_ADD; 308 state.fragOps.blendAState = state.fragOps.blendRGBState; 309 break; 310 311 default: 312 DE_ASSERT(false); 313 } 314 } 315 316 if (drawOp.depth != DEPTHMODE_NONE) 317 { 318 state.fragOps.depthTestEnabled = true; 319 320 DE_ASSERT(drawOp.depth == DEPTHMODE_LESS); 321 state.fragOps.depthFunc = rr::TESTFUNC_LESS; 322 } 323 324 if (drawOp.stencil != STENCILMODE_NONE) 325 { 326 state.fragOps.stencilTestEnabled = true; 327 328 DE_ASSERT(drawOp.stencil == STENCILMODE_LEQUAL_INC); 329 state.fragOps.stencilStates[0].func = rr::TESTFUNC_LEQUAL; 330 state.fragOps.stencilStates[0].sFail = rr::STENCILOP_KEEP; 331 state.fragOps.stencilStates[0].dpFail = rr::STENCILOP_INCR; 332 state.fragOps.stencilStates[0].dpPass = rr::STENCILOP_INCR; 333 state.fragOps.stencilStates[0].ref = drawOp.stencilRef; 334 state.fragOps.stencilStates[1] = state.fragOps.stencilStates[0]; 335 } 336 } 337 338 tcu::TextureFormat getColorFormat (const tcu::PixelFormat& colorBits) 339 { 340 using tcu::TextureFormat; 341 342 DE_ASSERT(de::inBounds(colorBits.redBits, 0, 0xff) && 343 de::inBounds(colorBits.greenBits, 0, 0xff) && 344 de::inBounds(colorBits.blueBits, 0, 0xff) && 345 de::inBounds(colorBits.alphaBits, 0, 0xff)); 346 347 #define PACK_FMT(R, G, B, A) (((R) << 24) | ((G) << 16) | ((B) << 8) | (A)) 348 349 // \note [pyry] This may not hold true on some implementations - best effort guess only. 350 switch (PACK_FMT(colorBits.redBits, colorBits.greenBits, colorBits.blueBits, colorBits.alphaBits)) 351 { 352 case PACK_FMT(8,8,8,8): return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); 353 case PACK_FMT(8,8,8,0): return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8); 354 case PACK_FMT(4,4,4,4): return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_4444); 355 case PACK_FMT(5,5,5,1): return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551); 356 case PACK_FMT(5,6,5,0): return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565); 357 358 // \note Defaults to RGBA8 359 default: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); 360 } 361 362 #undef PACK_FMT 363 } 364 365 /* 366 The getColorThreshold function is used to obtain a 367 threshold usable for the fuzzyCompare function. 368 369 For 8bit color depths a value of 0.02 should provide 370 a good metric for rejecting images above this level. 371 For other bit depths other thresholds should be selected. 372 Ideally this function would take advantage of the 373 getColorThreshold function provided by the PixelFormat class 374 as this would also allow setting per channel thresholds. 375 However using the PixelFormat provided function can result 376 in too strict thresholds for 8bit bit depths (compared to 377 the current default of 0.02) or too relaxed for lower bit 378 depths if scaled proportionally to the 8bit default. 379 */ 380 381 float getColorThreshold (const tcu::PixelFormat& colorBits) 382 { 383 if ((colorBits.redBits > 0 && colorBits.redBits < 8) || 384 (colorBits.greenBits > 0 && colorBits.greenBits < 8) || 385 (colorBits.blueBits > 0 && colorBits.blueBits < 8) || 386 (colorBits.alphaBits > 0 && colorBits.alphaBits < 8)) 387 { 388 return 0.05f; 389 } 390 else 391 { 392 return 0.02f; 393 } 394 } 395 396 tcu::TextureFormat getDepthFormat (const int depthBits) 397 { 398 switch (depthBits) 399 { 400 case 0: return tcu::TextureFormat(); 401 case 8: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT8); 402 case 16: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT16); 403 case 24: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT24); 404 case 32: 405 default: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::FLOAT); 406 } 407 } 408 409 tcu::TextureFormat getStencilFormat (int stencilBits) 410 { 411 switch (stencilBits) 412 { 413 case 0: return tcu::TextureFormat(); 414 case 8: 415 default: return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT8); 416 } 417 } 418 419 void renderReference (const tcu::PixelBufferAccess& dst, const vector<DrawPrimitiveOp>& drawOps, const tcu::PixelFormat& colorBits, const int depthBits, const int stencilBits, const int numSamples) 420 { 421 const int width = dst.getWidth(); 422 const int height = dst.getHeight(); 423 424 tcu::TextureLevel colorBuffer; 425 tcu::TextureLevel depthBuffer; 426 tcu::TextureLevel stencilBuffer; 427 428 rr::Renderer referenceRenderer; 429 rr::VertexAttrib attributes[2]; 430 const ReferenceShader shader; 431 432 attributes[0].type = rr::VERTEXATTRIBTYPE_FLOAT; 433 attributes[0].size = 4; 434 attributes[0].stride = 0; 435 attributes[0].instanceDivisor = 0; 436 437 attributes[1].type = rr::VERTEXATTRIBTYPE_FLOAT; 438 attributes[1].size = 4; 439 attributes[1].stride = 0; 440 attributes[1].instanceDivisor = 0; 441 442 // Initialize buffers. 443 colorBuffer.setStorage(getColorFormat(colorBits), numSamples, width, height); 444 rr::clearMultisampleColorBuffer(colorBuffer, CLEAR_COLOR, rr::WindowRectangle(0, 0, width, height)); 445 446 if (depthBits > 0) 447 { 448 depthBuffer.setStorage(getDepthFormat(depthBits), numSamples, width, height); 449 rr::clearMultisampleDepthBuffer(depthBuffer, CLEAR_DEPTH, rr::WindowRectangle(0, 0, width, height)); 450 } 451 452 if (stencilBits > 0) 453 { 454 stencilBuffer.setStorage(getStencilFormat(stencilBits), numSamples, width, height); 455 rr::clearMultisampleStencilBuffer(stencilBuffer, CLEAR_STENCIL, rr::WindowRectangle(0, 0, width, height)); 456 } 457 458 const rr::RenderTarget renderTarget(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer.getAccess()), 459 rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthBuffer.getAccess()), 460 rr::MultisamplePixelBufferAccess::fromMultisampleAccess(stencilBuffer.getAccess())); 461 462 for (vector<DrawPrimitiveOp>::const_iterator drawOp = drawOps.begin(); drawOp != drawOps.end(); drawOp++) 463 { 464 // Translate state 465 rr::RenderState renderState((rr::ViewportState)(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer.getAccess()))); 466 toReferenceRenderState(renderState, *drawOp); 467 468 DE_ASSERT(drawOp->type == PRIMITIVETYPE_TRIANGLE); 469 470 attributes[0].pointer = &drawOp->positions[0]; 471 attributes[1].pointer = &drawOp->colors[0]; 472 473 referenceRenderer.draw( 474 rr::DrawCommand( 475 renderState, 476 renderTarget, 477 rr::Program(static_cast<const rr::VertexShader*>(&shader), static_cast<const rr::FragmentShader*>(&shader)), 478 2, 479 attributes, 480 rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, drawOp->count * 3, 0))); 481 } 482 483 rr::resolveMultisampleColorBuffer(dst, rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer.getAccess())); 484 } 485 486 // API rendering code 487 488 class Program 489 { 490 public: 491 Program (void) {} 492 virtual ~Program (void) {} 493 494 virtual void setup (void) const = DE_NULL; 495 }; 496 497 typedef de::SharedPtr<Program> ProgramSp; 498 499 static glu::ProgramSources getProgramSourcesES2 (void) 500 { 501 static const char* s_vertexSrc = 502 "attribute highp vec4 a_position;\n" 503 "attribute mediump vec4 a_color;\n" 504 "varying mediump vec4 v_color;\n" 505 "void main (void)\n" 506 "{\n" 507 " gl_Position = a_position;\n" 508 " v_color = a_color;\n" 509 "}\n"; 510 511 static const char* s_fragmentSrc = 512 "varying mediump vec4 v_color;\n" 513 "void main (void)\n" 514 "{\n" 515 " gl_FragColor = v_color;\n" 516 "}\n"; 517 518 return glu::ProgramSources() << glu::VertexSource(s_vertexSrc) << glu::FragmentSource(s_fragmentSrc); 519 } 520 521 class GLES2Program : public Program 522 { 523 public: 524 GLES2Program (const glw::Functions& gl) 525 : m_gl (gl) 526 , m_program (gl, getProgramSourcesES2()) 527 , m_positionLoc (0) 528 , m_colorLoc (0) 529 { 530 531 m_positionLoc = m_gl.getAttribLocation(m_program.getProgram(), "a_position"); 532 m_colorLoc = m_gl.getAttribLocation(m_program.getProgram(), "a_color"); 533 } 534 535 ~GLES2Program (void) 536 { 537 } 538 539 void setup (void) const 540 { 541 m_gl.useProgram(m_program.getProgram()); 542 m_gl.enableVertexAttribArray(m_positionLoc); 543 m_gl.enableVertexAttribArray(m_colorLoc); 544 GLU_CHECK_GLW_MSG(m_gl, "Program setup failed"); 545 } 546 547 int getPositionLoc (void) const { return m_positionLoc; } 548 int getColorLoc (void) const { return m_colorLoc; } 549 550 private: 551 const glw::Functions& m_gl; 552 glu::ShaderProgram m_program; 553 int m_positionLoc; 554 int m_colorLoc; 555 }; 556 557 void clearGLES2 (const glw::Functions& gl, const tcu::Vec4& color, const float depth, const int stencil) 558 { 559 gl.clearColor(color.x(), color.y(), color.z(), color.w()); 560 gl.clearDepthf(depth); 561 gl.clearStencil(stencil); 562 gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 563 } 564 565 void drawGLES2 (const glw::Functions& gl, const Program& program, const DrawPrimitiveOp& drawOp) 566 { 567 const GLES2Program& gles2Program = dynamic_cast<const GLES2Program&>(program); 568 569 switch (drawOp.blend) 570 { 571 case BLENDMODE_NONE: 572 gl.disable(GL_BLEND); 573 break; 574 575 case BLENDMODE_ADDITIVE: 576 gl.enable(GL_BLEND); 577 gl.blendFunc(GL_ONE, GL_ONE); 578 break; 579 580 case BLENDMODE_SRC_OVER: 581 gl.enable(GL_BLEND); 582 gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 583 break; 584 585 default: 586 DE_ASSERT(false); 587 } 588 589 switch (drawOp.depth) 590 { 591 case DEPTHMODE_NONE: 592 gl.disable(GL_DEPTH_TEST); 593 break; 594 595 case DEPTHMODE_LESS: 596 gl.enable(GL_DEPTH_TEST); 597 break; 598 599 default: 600 DE_ASSERT(false); 601 } 602 603 switch (drawOp.stencil) 604 { 605 case STENCILMODE_NONE: 606 gl.disable(GL_STENCIL_TEST); 607 break; 608 609 case STENCILMODE_LEQUAL_INC: 610 gl.enable(GL_STENCIL_TEST); 611 gl.stencilFunc(GL_LEQUAL, drawOp.stencilRef, ~0u); 612 gl.stencilOp(GL_KEEP, GL_INCR, GL_INCR); 613 break; 614 615 default: 616 DE_ASSERT(false); 617 } 618 619 gl.disable(GL_DITHER); 620 621 gl.vertexAttribPointer(gles2Program.getPositionLoc(), 4, GL_FLOAT, GL_FALSE, 0, &drawOp.positions[0]); 622 gl.vertexAttribPointer(gles2Program.getColorLoc(), 4, GL_FLOAT, GL_FALSE, 0, &drawOp.colors[0]); 623 624 DE_ASSERT(drawOp.type == PRIMITIVETYPE_TRIANGLE); 625 gl.drawArrays(GL_TRIANGLES, 0, drawOp.count*3); 626 } 627 628 static void readPixelsGLES2 (const glw::Functions& gl, tcu::Surface& dst) 629 { 630 gl.readPixels(0, 0, dst.getWidth(), dst.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, dst.getAccess().getDataPtr()); 631 } 632 633 Program* createProgram (const glw::Functions& gl, EGLint api) 634 { 635 switch (api) 636 { 637 case EGL_OPENGL_ES2_BIT: return new GLES2Program(gl); 638 case EGL_OPENGL_ES3_BIT_KHR: return new GLES2Program(gl); 639 default: 640 throw tcu::NotSupportedError("Unsupported API"); 641 } 642 } 643 644 void draw (const glw::Functions& gl, EGLint api, const Program& program, const DrawPrimitiveOp& drawOp) 645 { 646 switch (api) 647 { 648 case EGL_OPENGL_ES2_BIT: drawGLES2(gl, program, drawOp); break; 649 case EGL_OPENGL_ES3_BIT_KHR: drawGLES2(gl, program, drawOp); break; 650 default: 651 throw tcu::NotSupportedError("Unsupported API"); 652 } 653 } 654 655 void clear (const glw::Functions& gl, EGLint api, const tcu::Vec4& color, const float depth, const int stencil) 656 { 657 switch (api) 658 { 659 case EGL_OPENGL_ES2_BIT: clearGLES2(gl, color, depth, stencil); break; 660 case EGL_OPENGL_ES3_BIT_KHR: clearGLES2(gl, color, depth, stencil); break; 661 default: 662 throw tcu::NotSupportedError("Unsupported API"); 663 } 664 } 665 666 static void readPixels (const glw::Functions& gl, EGLint api, tcu::Surface& dst) 667 { 668 switch (api) 669 { 670 case EGL_OPENGL_ES2_BIT: readPixelsGLES2(gl, dst); break; 671 case EGL_OPENGL_ES3_BIT_KHR: readPixelsGLES2(gl, dst); break; 672 default: 673 throw tcu::NotSupportedError("Unsupported API"); 674 } 675 } 676 677 static void finish (const glw::Functions& gl, EGLint api) 678 { 679 switch (api) 680 { 681 case EGL_OPENGL_ES2_BIT: 682 case EGL_OPENGL_ES3_BIT_KHR: 683 gl.finish(); 684 break; 685 686 default: 687 throw tcu::NotSupportedError("Unsupported API"); 688 } 689 } 690 691 tcu::PixelFormat getPixelFormat (const Library& egl, EGLDisplay display, EGLConfig config) 692 { 693 tcu::PixelFormat fmt; 694 fmt.redBits = eglu::getConfigAttribInt(egl, display, config, EGL_RED_SIZE); 695 fmt.greenBits = eglu::getConfigAttribInt(egl, display, config, EGL_GREEN_SIZE); 696 fmt.blueBits = eglu::getConfigAttribInt(egl, display, config, EGL_BLUE_SIZE); 697 fmt.alphaBits = eglu::getConfigAttribInt(egl, display, config, EGL_ALPHA_SIZE); 698 return fmt; 699 } 700 701 } // anonymous 702 703 // SingleThreadRenderCase 704 705 class SingleThreadRenderCase : public MultiContextRenderCase 706 { 707 public: 708 SingleThreadRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const eglu::FilterList& filters, int numContextsPerApi); 709 710 void init (void); 711 712 private: 713 virtual void executeForContexts (EGLDisplay display, EGLSurface surface, const Config& config, const std::vector<std::pair<EGLint, EGLContext> >& contexts); 714 715 glw::Functions m_gl; 716 }; 717 718 // SingleThreadColorClearCase 719 720 SingleThreadRenderCase::SingleThreadRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const eglu::FilterList& filters, int numContextsPerApi) 721 : MultiContextRenderCase(eglTestCtx, name, description, api, surfaceType, filters, numContextsPerApi) 722 { 723 } 724 725 void SingleThreadRenderCase::init (void) 726 { 727 MultiContextRenderCase::init(); 728 m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0)); 729 } 730 731 void SingleThreadRenderCase::executeForContexts (EGLDisplay display, EGLSurface surface, const Config& config, const std::vector<std::pair<EGLint, EGLContext> >& contexts) 732 { 733 const Library& egl = m_eglTestCtx.getLibrary(); 734 const int width = eglu::querySurfaceInt(egl, display, surface, EGL_WIDTH); 735 const int height = eglu::querySurfaceInt(egl, display, surface, EGL_HEIGHT); 736 const int numContexts = (int)contexts.size(); 737 const int drawsPerCtx = 2; 738 const int numIters = 2; 739 const tcu::PixelFormat pixelFmt = getPixelFormat(egl, display, config.config); 740 const float threshold = getColorThreshold(pixelFmt); 741 742 const int depthBits = eglu::getConfigAttribInt(egl, display, config.config, EGL_DEPTH_SIZE); 743 const int stencilBits = eglu::getConfigAttribInt(egl, display, config.config, EGL_STENCIL_SIZE); 744 const int numSamples = eglu::getConfigAttribInt(egl, display, config.config, EGL_SAMPLES); 745 746 TestLog& log = m_testCtx.getLog(); 747 748 tcu::Surface refFrame (width, height); 749 tcu::Surface frame (width, height); 750 751 de::Random rnd (deStringHash(getName()) ^ deInt32Hash(numContexts)); 752 vector<ProgramSp> programs (contexts.size()); 753 vector<DrawPrimitiveOp> drawOps; 754 755 // Log basic information about config. 756 log << TestLog::Message << "EGL_RED_SIZE = " << pixelFmt.redBits << TestLog::EndMessage; 757 log << TestLog::Message << "EGL_GREEN_SIZE = " << pixelFmt.greenBits << TestLog::EndMessage; 758 log << TestLog::Message << "EGL_BLUE_SIZE = " << pixelFmt.blueBits << TestLog::EndMessage; 759 log << TestLog::Message << "EGL_ALPHA_SIZE = " << pixelFmt.alphaBits << TestLog::EndMessage; 760 log << TestLog::Message << "EGL_DEPTH_SIZE = " << depthBits << TestLog::EndMessage; 761 log << TestLog::Message << "EGL_STENCIL_SIZE = " << stencilBits << TestLog::EndMessage; 762 log << TestLog::Message << "EGL_SAMPLES = " << numSamples << TestLog::EndMessage; 763 764 // Generate draw ops. 765 drawOps.resize(numContexts*drawsPerCtx*numIters); 766 for (vector<DrawPrimitiveOp>::iterator drawOp = drawOps.begin(); drawOp != drawOps.end(); ++drawOp) 767 randomizeDrawOp(rnd, *drawOp, (pixelFmt.alphaBits == 1)); 768 769 // Create and setup programs per context 770 for (int ctxNdx = 0; ctxNdx < numContexts; ctxNdx++) 771 { 772 EGLint api = contexts[ctxNdx].first; 773 EGLContext context = contexts[ctxNdx].second; 774 775 EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context)); 776 777 programs[ctxNdx] = ProgramSp(createProgram(m_gl, api)); 778 programs[ctxNdx]->setup(); 779 } 780 781 // Clear to black using first context. 782 { 783 EGLint api = contexts[0].first; 784 EGLContext context = contexts[0].second; 785 786 EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context)); 787 788 clear(m_gl, api, CLEAR_COLOR, CLEAR_DEPTH, CLEAR_STENCIL); 789 finish(m_gl, api); 790 } 791 792 // Render. 793 for (int iterNdx = 0; iterNdx < numIters; iterNdx++) 794 { 795 for (int ctxNdx = 0; ctxNdx < numContexts; ctxNdx++) 796 { 797 EGLint api = contexts[ctxNdx].first; 798 EGLContext context = contexts[ctxNdx].second; 799 800 EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context)); 801 802 for (int drawNdx = 0; drawNdx < drawsPerCtx; drawNdx++) 803 { 804 const DrawPrimitiveOp& drawOp = drawOps[iterNdx*numContexts*drawsPerCtx + ctxNdx*drawsPerCtx + drawNdx]; 805 draw(m_gl, api, *programs[ctxNdx], drawOp); 806 } 807 808 finish(m_gl, api); 809 } 810 } 811 812 // Read pixels using first context. \todo [pyry] Randomize? 813 { 814 EGLint api = contexts[0].first; 815 EGLContext context = contexts[0].second; 816 817 EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context)); 818 819 readPixels(m_gl, api, frame); 820 } 821 822 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 823 824 // Render reference. 825 // \note Reference image is always generated using single-sampling. 826 renderReference(refFrame.getAccess(), drawOps, pixelFmt, depthBits, stencilBits, 1); 827 828 // Compare images 829 { 830 bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, frame, threshold, tcu::COMPARE_LOG_RESULT); 831 832 if (!imagesOk) 833 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 834 } 835 } 836 837 // MultiThreadRenderCase 838 839 class MultiThreadRenderCase : public MultiContextRenderCase 840 { 841 public: 842 MultiThreadRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const eglu::FilterList& filters, int numContextsPerApi); 843 844 void init (void); 845 846 private: 847 virtual void executeForContexts (EGLDisplay display, EGLSurface surface, const Config& config, const std::vector<std::pair<EGLint, EGLContext> >& contexts); 848 849 glw::Functions m_gl; 850 }; 851 852 class RenderTestThread; 853 854 typedef de::SharedPtr<RenderTestThread> RenderTestThreadSp; 855 typedef de::SharedPtr<de::Semaphore> SemaphoreSp; 856 857 struct DrawOpPacket 858 { 859 DrawOpPacket (void) 860 : drawOps (DE_NULL) 861 , numOps (0) 862 { 863 } 864 865 const DrawPrimitiveOp* drawOps; 866 int numOps; 867 SemaphoreSp wait; 868 SemaphoreSp signal; 869 }; 870 871 class RenderTestThread : public de::Thread 872 { 873 public: 874 RenderTestThread (const Library& egl, EGLDisplay display, EGLSurface surface, EGLContext context, EGLint api, const glw::Functions& gl, const Program& program, const std::vector<DrawOpPacket>& packets) 875 : m_egl (egl) 876 , m_display (display) 877 , m_surface (surface) 878 , m_context (context) 879 , m_api (api) 880 , m_gl (gl) 881 , m_program (program) 882 , m_packets (packets) 883 { 884 } 885 886 void run (void) 887 { 888 for (std::vector<DrawOpPacket>::const_iterator packetIter = m_packets.begin(); packetIter != m_packets.end(); packetIter++) 889 { 890 // Wait until it is our turn. 891 packetIter->wait->decrement(); 892 893 // Acquire context. 894 EGLU_CHECK_CALL(m_egl, makeCurrent(m_display, m_surface, m_surface, m_context)); 895 896 // Execute rendering. 897 for (int ndx = 0; ndx < packetIter->numOps; ndx++) 898 draw(m_gl, m_api, m_program, packetIter->drawOps[ndx]); 899 900 finish(m_gl, m_api); 901 902 // Release context. 903 EGLU_CHECK_CALL(m_egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 904 905 // Signal completion. 906 packetIter->signal->increment(); 907 } 908 m_egl.releaseThread(); 909 } 910 911 private: 912 const Library& m_egl; 913 EGLDisplay m_display; 914 EGLSurface m_surface; 915 EGLContext m_context; 916 EGLint m_api; 917 const glw::Functions& m_gl; 918 const Program& m_program; 919 const std::vector<DrawOpPacket>& m_packets; 920 }; 921 922 MultiThreadRenderCase::MultiThreadRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const eglu::FilterList& filters, int numContextsPerApi) 923 : MultiContextRenderCase(eglTestCtx, name, description, api, surfaceType, filters, numContextsPerApi) 924 { 925 } 926 927 void MultiThreadRenderCase::init (void) 928 { 929 MultiContextRenderCase::init(); 930 m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0)); 931 } 932 933 void MultiThreadRenderCase::executeForContexts (EGLDisplay display, EGLSurface surface, const Config& config, const std::vector<std::pair<EGLint, EGLContext> >& contexts) 934 { 935 const Library& egl = m_eglTestCtx.getLibrary(); 936 const int width = eglu::querySurfaceInt(egl, display, surface, EGL_WIDTH); 937 const int height = eglu::querySurfaceInt(egl, display, surface, EGL_HEIGHT); 938 const int numContexts = (int)contexts.size(); 939 const int opsPerPacket = 2; 940 const int packetsPerThread = 2; 941 const int numThreads = numContexts; 942 const int numPackets = numThreads * packetsPerThread; 943 const tcu::PixelFormat pixelFmt = getPixelFormat(egl, display, config.config); 944 const float threshold = getColorThreshold(pixelFmt); 945 946 const int depthBits = eglu::getConfigAttribInt(egl, display, config.config, EGL_DEPTH_SIZE); 947 const int stencilBits = eglu::getConfigAttribInt(egl, display, config.config, EGL_STENCIL_SIZE); 948 const int numSamples = eglu::getConfigAttribInt(egl, display, config.config, EGL_SAMPLES); 949 950 TestLog& log = m_testCtx.getLog(); 951 952 tcu::Surface refFrame (width, height); 953 tcu::Surface frame (width, height); 954 955 de::Random rnd (deStringHash(getName()) ^ deInt32Hash(numContexts)); 956 957 // Resources that need cleanup 958 vector<ProgramSp> programs (numContexts); 959 vector<SemaphoreSp> semaphores (numPackets+1); 960 vector<DrawPrimitiveOp> drawOps (numPackets*opsPerPacket); 961 vector<vector<DrawOpPacket> > packets (numThreads); 962 vector<RenderTestThreadSp> threads (numThreads); 963 964 // Log basic information about config. 965 log << TestLog::Message << "EGL_RED_SIZE = " << pixelFmt.redBits << TestLog::EndMessage; 966 log << TestLog::Message << "EGL_GREEN_SIZE = " << pixelFmt.greenBits << TestLog::EndMessage; 967 log << TestLog::Message << "EGL_BLUE_SIZE = " << pixelFmt.blueBits << TestLog::EndMessage; 968 log << TestLog::Message << "EGL_ALPHA_SIZE = " << pixelFmt.alphaBits << TestLog::EndMessage; 969 log << TestLog::Message << "EGL_DEPTH_SIZE = " << depthBits << TestLog::EndMessage; 970 log << TestLog::Message << "EGL_STENCIL_SIZE = " << stencilBits << TestLog::EndMessage; 971 log << TestLog::Message << "EGL_SAMPLES = " << numSamples << TestLog::EndMessage; 972 973 // Initialize semaphores. 974 for (vector<SemaphoreSp>::iterator sem = semaphores.begin(); sem != semaphores.end(); ++sem) 975 *sem = SemaphoreSp(new de::Semaphore(0)); 976 977 // Create draw ops. 978 for (vector<DrawPrimitiveOp>::iterator drawOp = drawOps.begin(); drawOp != drawOps.end(); ++drawOp) 979 randomizeDrawOp(rnd, *drawOp, (pixelFmt.alphaBits == 1)); 980 981 // Create packets. 982 for (int threadNdx = 0; threadNdx < numThreads; threadNdx++) 983 { 984 packets[threadNdx].resize(packetsPerThread); 985 986 for (int packetNdx = 0; packetNdx < packetsPerThread; packetNdx++) 987 { 988 DrawOpPacket& packet = packets[threadNdx][packetNdx]; 989 990 // Threads take turns with packets. 991 packet.wait = semaphores[packetNdx*numThreads + threadNdx]; 992 packet.signal = semaphores[packetNdx*numThreads + threadNdx + 1]; 993 packet.numOps = opsPerPacket; 994 packet.drawOps = &drawOps[(packetNdx*numThreads + threadNdx)*opsPerPacket]; 995 } 996 } 997 998 // Create and setup programs per context 999 for (int ctxNdx = 0; ctxNdx < numContexts; ctxNdx++) 1000 { 1001 EGLint api = contexts[ctxNdx].first; 1002 EGLContext context = contexts[ctxNdx].second; 1003 1004 EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context)); 1005 1006 programs[ctxNdx] = ProgramSp(createProgram(m_gl, api)); 1007 programs[ctxNdx]->setup(); 1008 1009 // Release context 1010 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 1011 } 1012 1013 // Clear to black using first context. 1014 { 1015 EGLint api = contexts[0].first; 1016 EGLContext context = contexts[0].second; 1017 1018 EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context)); 1019 1020 clear(m_gl, api, CLEAR_COLOR, CLEAR_DEPTH, CLEAR_STENCIL); 1021 finish(m_gl, api); 1022 1023 // Release context 1024 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 1025 } 1026 1027 // Create and launch threads (actual rendering starts once first semaphore is signaled). 1028 for (int threadNdx = 0; threadNdx < numThreads; threadNdx++) 1029 { 1030 threads[threadNdx] = RenderTestThreadSp(new RenderTestThread(egl, display, surface, contexts[threadNdx].second, contexts[threadNdx].first, m_gl, *programs[threadNdx], packets[threadNdx])); 1031 threads[threadNdx]->start(); 1032 } 1033 1034 // Signal start and wait until complete. 1035 semaphores.front()->increment(); 1036 semaphores.back()->decrement(); 1037 1038 // Read pixels using first context. \todo [pyry] Randomize? 1039 { 1040 EGLint api = contexts[0].first; 1041 EGLContext context = contexts[0].second; 1042 1043 EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context)); 1044 1045 readPixels(m_gl, api, frame); 1046 } 1047 1048 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 1049 1050 // Join threads. 1051 for (int threadNdx = 0; threadNdx < numThreads; threadNdx++) 1052 threads[threadNdx]->join(); 1053 1054 // Render reference. 1055 renderReference(refFrame.getAccess(), drawOps, pixelFmt, depthBits, stencilBits, 1); 1056 1057 // Compare images 1058 { 1059 bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, frame, threshold, tcu::COMPARE_LOG_RESULT); 1060 1061 if (!imagesOk) 1062 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 1063 } 1064 } 1065 1066 RenderTests::RenderTests (EglTestContext& eglTestCtx) 1067 : TestCaseGroup(eglTestCtx, "render", "Basic rendering with different client APIs") 1068 { 1069 } 1070 1071 RenderTests::~RenderTests (void) 1072 { 1073 } 1074 1075 struct RenderGroupSpec 1076 { 1077 const char* name; 1078 const char* desc; 1079 EGLint apiBits; 1080 eglu::ConfigFilter baseFilter; 1081 int numContextsPerApi; 1082 }; 1083 1084 template <deUint32 Bits> 1085 static bool renderable (const eglu::CandidateConfig& c) 1086 { 1087 return (c.renderableType() & Bits) == Bits; 1088 } 1089 1090 template <class RenderClass> 1091 static void createRenderGroups (EglTestContext& eglTestCtx, tcu::TestCaseGroup* group, const RenderGroupSpec* first, const RenderGroupSpec* last) 1092 { 1093 for (const RenderGroupSpec* groupIter = first; groupIter != last; groupIter++) 1094 { 1095 tcu::TestCaseGroup* configGroup = new tcu::TestCaseGroup(eglTestCtx.getTestContext(), groupIter->name, groupIter->desc); 1096 group->addChild(configGroup); 1097 1098 vector<RenderFilterList> filterLists; 1099 eglu::FilterList baseFilters; 1100 baseFilters << groupIter->baseFilter; 1101 getDefaultRenderFilterLists(filterLists, baseFilters); 1102 1103 for (vector<RenderFilterList>::const_iterator listIter = filterLists.begin(); listIter != filterLists.end(); listIter++) 1104 configGroup->addChild(new RenderClass(eglTestCtx, listIter->getName(), "", groupIter->apiBits, listIter->getSurfaceTypeMask(), *listIter, groupIter->numContextsPerApi)); 1105 } 1106 } 1107 1108 void RenderTests::init (void) 1109 { 1110 static const RenderGroupSpec singleContextCases[] = 1111 { 1112 { 1113 "gles2", 1114 "Primitive rendering using GLES2", 1115 EGL_OPENGL_ES2_BIT, 1116 renderable<EGL_OPENGL_ES2_BIT>, 1117 1 1118 }, 1119 { 1120 "gles3", 1121 "Primitive rendering using GLES3", 1122 EGL_OPENGL_ES3_BIT, 1123 renderable<EGL_OPENGL_ES3_BIT>, 1124 1 1125 }, 1126 }; 1127 1128 static const RenderGroupSpec multiContextCases[] = 1129 { 1130 { 1131 "gles2", 1132 "Primitive rendering using multiple GLES2 contexts to shared surface", 1133 EGL_OPENGL_ES2_BIT, 1134 renderable<EGL_OPENGL_ES2_BIT>, 1135 3 1136 }, 1137 { 1138 "gles3", 1139 "Primitive rendering using multiple GLES3 contexts to shared surface", 1140 EGL_OPENGL_ES3_BIT, 1141 renderable<EGL_OPENGL_ES3_BIT>, 1142 3 1143 }, 1144 { 1145 "gles2_gles3", 1146 "Primitive rendering using multiple APIs to shared surface", 1147 EGL_OPENGL_ES2_BIT|EGL_OPENGL_ES3_BIT, 1148 renderable<EGL_OPENGL_ES2_BIT|EGL_OPENGL_ES3_BIT>, 1149 1 1150 }, 1151 }; 1152 1153 tcu::TestCaseGroup* singleContextGroup = new tcu::TestCaseGroup(m_testCtx, "single_context", "Single-context rendering"); 1154 addChild(singleContextGroup); 1155 createRenderGroups<SingleThreadRenderCase>(m_eglTestCtx, singleContextGroup, &singleContextCases[0], &singleContextCases[DE_LENGTH_OF_ARRAY(singleContextCases)]); 1156 1157 tcu::TestCaseGroup* multiContextGroup = new tcu::TestCaseGroup(m_testCtx, "multi_context", "Multi-context rendering with shared surface"); 1158 addChild(multiContextGroup); 1159 createRenderGroups<SingleThreadRenderCase>(m_eglTestCtx, multiContextGroup, &multiContextCases[0], &multiContextCases[DE_LENGTH_OF_ARRAY(multiContextCases)]); 1160 1161 tcu::TestCaseGroup* multiThreadGroup = new tcu::TestCaseGroup(m_testCtx, "multi_thread", "Multi-thread rendering with shared surface"); 1162 addChild(multiThreadGroup); 1163 createRenderGroups<MultiThreadRenderCase>(m_eglTestCtx, multiThreadGroup, &multiContextCases[0], &multiContextCases[DE_LENGTH_OF_ARRAY(multiContextCases)]); 1164 } 1165 1166 } // egl 1167 } // deqp 1168
