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