modules/egl/teglGLES2SharingTests.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 EGL gles2 sharing tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglGLES2SharingTests.hpp"
  25
  26 #include "teglGLES2SharingThreadedTests.hpp"
  27
  28 #include "egluNativeWindow.hpp"
  29 #include "egluUtil.hpp"
  30 #include "egluUnique.hpp"
  31
  32 #include "eglwLibrary.hpp"
  33 #include "eglwEnums.hpp"
  34
  35 #include "tcuCommandLine.hpp"
  36 #include "tcuImageCompare.hpp"
  37 #include "tcuSurface.hpp"
  38 #include "tcuTestLog.hpp"
  39 #include "tcuTexture.hpp"
  40 #include "tcuTextureUtil.hpp"
  41
  42 #include "deUniquePtr.hpp"
  43 #include "deRandom.hpp"
  44
  45 #include "deMath.h"
  46 #include "deMemory.h"
  47 #include "deString.h"
  48
  49 #include "gluDefs.hpp"
  50 #include "gluShaderProgram.hpp"
  51
  52 #include "glwFunctions.hpp"
  53 #include "glwEnums.hpp"
  54
  55 #include <memory>
  56 #include <sstream>
  57 #include <vector>
  58
  59 using std::vector;
  60
  61 namespace deqp
  62 {
  63 namespace egl
  64 {
  65
  66 using namespace glw;
  67 using namespace eglw;
  68
  69 class GLES2SharingTest : public TestCase
  70 {
  71 public:
  72         enum ResourceType
  73         {
  74                 BUFFER = 0,
  75                 TEXTURE,
  76                 RENDERBUFFER,
  77                 SHADER_PROGRAM
  78         };
  79
  80         struct TestSpec
  81         {
  82                 ResourceType    type;
  83                 bool                    destroyContextBFirst;
  84                 bool                    useResource;
  85                 bool                    destroyOnContexB;
  86                 bool                    initializeData;
  87                 bool                    renderOnContexA;
  88                 bool                    renderOnContexB;
  89                 bool                    verifyOnContexA;
  90                 bool                    verifyOnContexB;
  91         };
  92
  93                                         GLES2SharingTest        (EglTestContext& eglTestCtx, const char* name , const char* desc, const TestSpec& spec);
  94
  95         void                    init                            (void);
  96
  97         IterateResult   iterate                         (void);
  98
  99 private:
 100         TestSpec                m_spec;
 101
 102         EGLContext              createContext           (EGLDisplay display, EGLContext share, EGLConfig config);
 103         void                    makeCurrent                     (EGLDisplay display, EGLContext context, EGLSurface surface);
 104
 105 protected:
 106         de::Random              m_random;
 107         tcu::TestLog&   m_log;
 108         glw::Functions  m_gl;
 109
 110         virtual void    createResource          (void)  { DE_ASSERT(false); }
 111         virtual void    destroyResource         (void)  { DE_ASSERT(false); }
 112         virtual void    renderResource          (tcu::Surface* screen, tcu::Surface* reference) { DE_UNREF(screen); DE_UNREF(reference); DE_ASSERT(false); }
 113 };
 114
 115 GLES2SharingTest::GLES2SharingTest (EglTestContext& eglTestCtx, const char* name , const char* desc, const TestSpec& spec)
 116         : TestCase      (eglTestCtx, name, desc)
 117         , m_spec        (spec)
 118         , m_random      (deStringHash(name))
 119         , m_log         (eglTestCtx.getTestContext().getLog())
 120 {
 121 }
 122
 123 void GLES2SharingTest::init (void)
 124 {
 125         m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
 126 }
 127
 128 EGLContext GLES2SharingTest::createContext (EGLDisplay display, EGLContext share, EGLConfig config)
 129 {
 130         const Library& egl = m_eglTestCtx.getLibrary();
 131         EGLContext context = EGL_NO_CONTEXT;
 132         const EGLint attriblist[] =
 133         {
 134                 EGL_CONTEXT_CLIENT_VERSION, 2,
 135                 EGL_NONE
 136         };
 137
 138         EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
 139
 140         context = egl.createContext(display, config, share, attriblist);
 141         EGLU_CHECK_MSG(egl, "Failed to create GLES2 context");
 142         TCU_CHECK(context != EGL_NO_CONTEXT);
 143
 144         return context;
 145 }
 146
 147 void GLES2SharingTest::makeCurrent (EGLDisplay display, EGLContext context, EGLSurface surface)
 148 {
 149         const Library& egl = m_eglTestCtx.getLibrary();
 150         EGLU_CHECK_CALL(egl, makeCurrent(display, surface, surface, context));
 151 }
 152
 153 TestCase::IterateResult GLES2SharingTest::iterate (void)
 154 {
 155         const Library&                                          egl                             = m_eglTestCtx.getLibrary();
 156         tcu::TestLog&                                           log                             = m_testCtx.getLog();
 157         eglu::UniqueDisplay                                     display                 (egl, eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay()));
 158         const eglu::NativeWindowFactory&        windowFactory   = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
 159         EGLConfig                                                       config;
 160         bool                                                            isOk                    = true;
 161         EGLContext                                                      contextA                = EGL_NO_CONTEXT;
 162         EGLContext                                                      contextB                = EGL_NO_CONTEXT;
 163
 164         {
 165                 const EGLint attribList[] =
 166                 {
 167                         EGL_RENDERABLE_TYPE,    EGL_OPENGL_ES2_BIT,
 168                         EGL_SURFACE_TYPE,               EGL_WINDOW_BIT,
 169                         EGL_ALPHA_SIZE,                 1,
 170                         EGL_NONE
 171                 };
 172
 173                 config = eglu::chooseSingleConfig(egl, *display, attribList);
 174         }
 175
 176         try
 177         {
 178                 de::UniquePtr<eglu::NativeWindow>       window  (windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), *display, config, DE_NULL, eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine()))));
 179                 eglu::UniqueSurface                                     surface (egl, *display, eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, *display, config, DE_NULL));
 180
 181                 m_log << tcu::TestLog::Message << "Create context A (share_context = EGL_NO_CONTEXT)" << tcu::TestLog::EndMessage;
 182                 contextA = createContext(*display, EGL_NO_CONTEXT, config);
 183
 184                 m_log << tcu::TestLog::Message << "Create context B (share_context = context A)" << tcu::TestLog::EndMessage;
 185                 contextB = createContext(*display, contextA, config);
 186
 187                 if (m_spec.useResource)
 188                 {
 189                         m_log << tcu::TestLog::Message << "Make current context A" << tcu::TestLog::EndMessage;
 190                         makeCurrent(*display, contextA, *surface);
 191                         m_log << tcu::TestLog::Message << "Creating resource" << tcu::TestLog::EndMessage;
 192                         createResource();
 193
 194                         int             width   = 240;
 195                         int             height  = 240;
 196
 197                         if (m_spec.renderOnContexA)
 198                         {
 199                                 m_log << tcu::TestLog::Message << "Render resource" << tcu::TestLog::EndMessage;
 200                                 if (m_spec.verifyOnContexA)
 201                                 {
 202                                         tcu::Surface screen     (width, height);
 203                                         tcu::Surface ref        (width, height);
 204                                         renderResource(&screen, &ref);
 205
 206                                         if (!fuzzyCompare(log, "Rendered image", "Rendering result comparision", ref, screen, 0.05f, tcu::COMPARE_LOG_RESULT))
 207                                                 isOk = false;
 208                                 }
 209                                 else
 210                                 {
 211                                         renderResource(DE_NULL, DE_NULL);
 212                                 }
 213                         }
 214
 215                         if (m_spec.renderOnContexB)
 216                         {
 217                                 m_log << tcu::TestLog::Message << "Make current context B" << tcu::TestLog::EndMessage;
 218                                 makeCurrent(*display, contextB, *surface);
 219                                 m_log << tcu::TestLog::Message << "Render resource" << tcu::TestLog::EndMessage;
 220                                 if (m_spec.verifyOnContexB)
 221                                 {
 222                                         tcu::Surface screen     (width, height);
 223                                         tcu::Surface ref        (width, height);
 224                                         renderResource(&screen, &ref);
 225
 226                                         if (!fuzzyCompare(log, "Rendered image", "Rendering result comparision", ref, screen, 0.05f, tcu::COMPARE_LOG_RESULT))
 227                                                 isOk = false;
 228                                 }
 229                                 else
 230                                 {
 231                                         renderResource(DE_NULL, DE_NULL);
 232                                 }
 233                         }
 234
 235                         if (m_spec.destroyOnContexB)
 236                         {
 237                                 m_log << tcu::TestLog::Message << "Make current context B" << tcu::TestLog::EndMessage;
 238                                 makeCurrent(*display, contextB, *surface);
 239                                 m_log << tcu::TestLog::Message << "Destroy resource" << tcu::TestLog::EndMessage;
 240                                 destroyResource();
 241                         }
 242                         else
 243                         {
 244                                 m_log << tcu::TestLog::Message << "Make current context A" << tcu::TestLog::EndMessage;
 245                                 makeCurrent(*display, contextA, *surface);
 246                                 m_log << tcu::TestLog::Message << "Destroy resource" << tcu::TestLog::EndMessage;
 247                                 destroyResource();
 248                         }
 249                 }
 250
 251                 makeCurrent(*display, EGL_NO_CONTEXT, EGL_NO_SURFACE);
 252
 253                 if (m_spec.destroyContextBFirst)
 254                 {
 255                         m_log << tcu::TestLog::Message << "Destroy context B" << tcu::TestLog::EndMessage;
 256                         egl.destroyContext(*display, contextB);
 257                         contextB = EGL_NO_CONTEXT;
 258
 259                         m_log << tcu::TestLog::Message << "Destroy context A" << tcu::TestLog::EndMessage;
 260                         egl.destroyContext(*display, contextA);
 261                         contextA = EGL_NO_CONTEXT;
 262                 }
 263                 else
 264                 {
 265                         m_log << tcu::TestLog::Message << "Destroy context A" << tcu::TestLog::EndMessage;
 266                         egl.destroyContext(*display, contextA);
 267                         contextA = EGL_NO_CONTEXT;
 268
 269                         m_log << tcu::TestLog::Message << "Destroy context B" << tcu::TestLog::EndMessage;
 270                         egl.destroyContext(*display, contextB);
 271                         contextB = EGL_NO_CONTEXT;
 272                 }
 273
 274                 EGLU_CHECK(egl);
 275         }
 276         catch (...)
 277         {
 278                 egl.makeCurrent(*display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 279                 if (contextA != EGL_NO_CONTEXT)
 280                         egl.destroyContext(*display, contextA);
 281                 if (contextB != EGL_NO_CONTEXT)
 282                         egl.destroyContext(*display, contextB);
 283                 throw;
 284         }
 285
 286         if (isOk)
 287                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 288         else
 289                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
 290
 291         return STOP;
 292 }
 293
 294 class GLES2BufferSharingTest : public GLES2SharingTest
 295 {
 296 public:
 297                                                         GLES2BufferSharingTest  (EglTestContext& eglTestCtx, const char* name, const char* desc, const GLES2SharingTest::TestSpec& spec);
 298
 299 private:
 300         GLuint                                  m_glBuffer;
 301         std::vector<GLubyte>    m_buffer;
 302
 303         virtual void    createResource          (void);
 304         virtual void    destroyResource         (void);
 305         virtual void    renderResource          (tcu::Surface* screen, tcu::Surface* reference);
 306
 307 };
 308
 309 GLES2BufferSharingTest::GLES2BufferSharingTest (EglTestContext& eglTestCtx, const char* name, const char* desc, const GLES2SharingTest::TestSpec& spec)
 310         : GLES2SharingTest      (eglTestCtx, name, desc, spec)
 311         , m_glBuffer            (0)
 312 {
 313 }
 314
 315 void GLES2BufferSharingTest::createResource (void)
 316 {
 317         int                                             size    = 16*16*4;
 318
 319         m_buffer.reserve(size);
 320
 321         for (int i = 0; i < size; i++)
 322                 m_buffer.push_back((GLubyte)m_random.getInt(0, 255));
 323
 324         GLU_CHECK_GLW_CALL(m_gl, genBuffers(1, &m_glBuffer));
 325         GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, m_glBuffer));
 326         GLU_CHECK_GLW_CALL(m_gl, bufferData(GL_ARRAY_BUFFER, (GLsizei)(m_buffer.size() * sizeof(GLubyte)), &(m_buffer[0]), GL_DYNAMIC_DRAW));
 327         GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, 0));
 328 }
 329
 330 void GLES2BufferSharingTest::destroyResource (void)
 331 {
 332         GLU_CHECK_GLW_CALL(m_gl, deleteBuffers(1, &m_glBuffer));
 333         m_buffer.clear();
 334 }
 335
 336 void GLES2BufferSharingTest::renderResource (tcu::Surface* screen, tcu::Surface* reference)
 337 {
 338         DE_ASSERT((screen && reference) || (!screen && !reference));
 339
 340         const char* vertexShader = ""
 341         "attribute mediump vec2 a_pos;\n"
 342         "attribute mediump float a_color;\n"
 343         "varying mediump float v_color;\n"
 344         "void main(void)\n"
 345         "{\n"
 346         "\tv_color = a_color;\n"
 347         "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
 348         "}\n";
 349
 350         const char* fragmentShader = ""
 351         "varying mediump float v_color;\n"
 352         "void main(void)\n"
 353         "{\n"
 354         "\tgl_FragColor = vec4(v_color, v_color, v_color, 1.0);\n"
 355         "}\n";
 356
 357         glu::ShaderProgram program(m_gl, glu::makeVtxFragSources(vertexShader, fragmentShader));
 358
 359         if (!program.isOk())
 360                 TCU_FAIL("Failed to compile shader program");
 361
 362         std::vector<deUint16>   indices;
 363         std::vector<float>              coords;
 364
 365         DE_ASSERT(m_buffer.size() % 4 == 0);
 366
 367         for (int i = 0; i < (int)m_buffer.size() / 4; i++)
 368         {
 369                 indices.push_back((deUint16)(i*4));
 370                 indices.push_back((deUint16)(i*4 + 1));
 371                 indices.push_back((deUint16)(i*4 + 2));
 372                 indices.push_back((deUint16)(i*4 + 2));
 373                 indices.push_back((deUint16)(i*4 + 3));
 374                 indices.push_back((deUint16)(i*4));
 375
 376                 coords.push_back(0.125f * (float)(i % 16) - 1.0f);
 377                 coords.push_back(0.125f * (float)((int)((float)i / 16.0f)) - 1.0f);
 378
 379                 coords.push_back(0.125f * (float)(i % 16) - 1.0f);
 380                 coords.push_back(0.125f * (float)((int)((float)i / 16.0f) + 1) - 1.0f);
 381
 382                 coords.push_back(0.125f * (float)((i % 16) + 1) - 1.0f);
 383                 coords.push_back(0.125f * (float)((int)((float)i / 16.0f) + 1) - 1.0f);
 384
 385                 coords.push_back(0.125f * (float)((i % 16) + 1) - 1.0f);
 386                 coords.push_back(0.125f * (float)((int)((float)i / 16.0f)) - 1.0f);
 387         }
 388
 389         int width = 240;
 390         int height = 240;
 391
 392         if (screen)
 393         {
 394                 width = screen->getWidth();
 395                 height = screen->getHeight();
 396         }
 397
 398         GLU_CHECK_GLW_CALL(m_gl, viewport(0, 0, width, height));
 399
 400         GLU_CHECK_GLW_CALL(m_gl, clearColor(1.0f, 0.0f, 0.0f, 1.0f));
 401         GLU_CHECK_GLW_CALL(m_gl, clear(GL_COLOR_BUFFER_BIT));
 402
 403         GLU_CHECK_GLW_CALL(m_gl, useProgram(program.getProgram()));
 404
 405         GLuint gridLocation = m_gl.getAttribLocation(program.getProgram(), "a_pos");
 406         GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()");
 407         TCU_CHECK(gridLocation != (GLuint)-1);
 408
 409         GLuint colorLocation = m_gl.getAttribLocation(program.getProgram(), "a_color");
 410         GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()");
 411         TCU_CHECK(colorLocation != (GLuint)-1);
 412
 413         GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(colorLocation));
 414         GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(gridLocation));
 415
 416         GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, m_glBuffer));
 417         GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(colorLocation, 1, GL_UNSIGNED_BYTE, GL_TRUE, 0, DE_NULL));
 418         GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, 0));
 419
 420         GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(gridLocation, 2, GL_FLOAT, GL_FALSE, 0, &(coords[0])));
 421
 422         GLU_CHECK_GLW_CALL(m_gl, drawElements(GL_TRIANGLES, (GLsizei)indices.size(), GL_UNSIGNED_SHORT, &(indices[0])));
 423         GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(colorLocation));
 424         GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(gridLocation));
 425
 426         GLU_CHECK_GLW_CALL(m_gl, useProgram(0));
 427
 428         if (screen)
 429         {
 430                 tcu::clear(reference->getAccess(), tcu::IVec4(0xff, 0, 0, 0xff));
 431                 m_gl.readPixels(0, 0, screen->getWidth(), screen->getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen->getAccess().getDataPtr());
 432                 for (int i = 0; i < (int)m_buffer.size() / 4; i++)
 433                 {
 434                         float fx1 = 0.125f * (float)(i % 16) - 1.0f;
 435                         float fy1 = 0.125f * (float)((int)((float)i / 16.0f)) - 1.0f;
 436                         float fx2 = 0.125f * (float)((i % 16) + 1) - 1.0f;
 437                         float fy2 = 0.125f * (float)((int)((float)i / 16.0f) + 1) - 1.0f;
 438
 439                         int ox = deRoundFloatToInt32((float)width       / 2.0f);
 440                         int oy = deRoundFloatToInt32((float)height      / 2.0f);
 441                         int x1 = deRoundFloatToInt32(((float)width       * fx1 / 2.0f) + (float)ox);
 442                         int y1 = deRoundFloatToInt32(((float)height      * fy1 / 2.0f) + (float)oy);
 443                         int x2 = deRoundFloatToInt32(((float)width       * fx2 / 2.0f) + (float)ox);
 444                         int y2 = deRoundFloatToInt32(((float)height      * fy2 / 2.0f) + (float)oy);
 445
 446                         for (int x = x1; x < x2; x++)
 447                         {
 448                                 for (int y = y1; y < y2; y++)
 449                                 {
 450                                         float           xf              = ((float)(x-x1) + 0.5f) / (float)(x2 - x1);
 451                                         float           yf              = ((float)(y-y1) + 0.5f) / (float)(y2 - y1);
 452                                         bool            tri             = yf >= xf;
 453                                         deUint8         a               = m_buffer[i*4 + (tri ? 1 : 3)];
 454                                         deUint8         b               = m_buffer[i*4 + (tri ? 2 : 0)];
 455                                         deUint8         c               = m_buffer[i*4 + (tri ? 0 : 2)];
 456                                         float           s               = tri ? xf : 1.0f-xf;
 457                                         float           t               = tri ? 1.0f-yf : yf;
 458                                         float           val             = (float)a + (float)(b-a)*s + (float)(c-a)*t;
 459
 460                                         reference->setPixel(x, y, tcu::RGBA((deUint8)val, (deUint8)val, (deUint8)val, 255));
 461                                 }
 462                         }
 463                 }
 464         }
 465 }
 466
 467 class GLES2TextureSharingTest : public GLES2SharingTest
 468 {
 469 public:
 470                                                         GLES2TextureSharingTest (EglTestContext& eglTestCtx, const char* name, const char* desc, const GLES2SharingTest::TestSpec& spec);
 471
 472 private:
 473         GLuint                                  m_glTexture;
 474         tcu::Texture2D                  m_texture;
 475
 476         virtual void    createResource          (void);
 477         virtual void    destroyResource         (void);
 478         virtual void    renderResource          (tcu::Surface* screen, tcu::Surface* reference);
 479
 480 };
 481
 482 GLES2TextureSharingTest::GLES2TextureSharingTest (EglTestContext& eglTestCtx, const char* name, const char* desc, const GLES2SharingTest::TestSpec& spec)
 483         : GLES2SharingTest      (eglTestCtx, name, desc, spec)
 484         , m_glTexture           (0)
 485         , m_texture                     (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 1, 1)
 486 {
 487 }
 488
 489 void GLES2TextureSharingTest::createResource (void)
 490 {
 491         int width       = 128;
 492         int     height  = 128;
 493         m_texture = tcu::Texture2D(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), width, height);
 494         m_texture.allocLevel(0);
 495
 496         tcu::fillWithComponentGradients(m_texture.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
 497         GLU_CHECK_GLW_CALL(m_gl, genTextures(1, &m_glTexture));
 498         GLU_CHECK_GLW_CALL(m_gl, bindTexture(GL_TEXTURE_2D, m_glTexture));
 499         GLU_CHECK_GLW_CALL(m_gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT));
 500         GLU_CHECK_GLW_CALL(m_gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT));
 501         GLU_CHECK_GLW_CALL(m_gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
 502         GLU_CHECK_GLW_CALL(m_gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
 503         GLU_CHECK_GLW_CALL(m_gl, texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_texture.getLevel(0).getDataPtr()));
 504         GLU_CHECK_GLW_CALL(m_gl, bindTexture(GL_TEXTURE_2D, 0));
 505 }
 506
 507 void GLES2TextureSharingTest::destroyResource (void)
 508 {
 509         GLU_CHECK_GLW_CALL(m_gl, deleteTextures(1, &m_glTexture));
 510 }
 511
 512 void GLES2TextureSharingTest::renderResource (tcu::Surface* screen, tcu::Surface* reference)
 513 {
 514         DE_ASSERT((screen && reference) || (!screen && !reference));
 515
 516         const char* vertexShader = ""
 517         "attribute mediump vec2 a_pos;\n"
 518         "attribute mediump vec2 a_texCorod;\n"
 519         "varying mediump vec2 v_texCoord;\n"
 520         "void main(void)\n"
 521         "{\n"
 522         "\tv_texCoord = a_texCorod;\n"
 523         "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
 524         "}\n";
 525
 526         const char* fragmentShader = ""
 527         "varying mediump vec2 v_texCoord;\n"
 528         "uniform sampler2D u_sampler;\n"
 529         "void main(void)\n"
 530         "{\n"
 531         "\tgl_FragColor = texture2D(u_sampler, v_texCoord);\n"
 532         "}\n";
 533
 534         glu::ShaderProgram program(m_gl, glu::makeVtxFragSources(vertexShader, fragmentShader));
 535
 536         if (!program.isOk())
 537                 TCU_FAIL("Failed to compile shader program");
 538
 539         int width = 240;
 540         int height = 240;
 541
 542         if (screen)
 543         {
 544                 width = screen->getWidth();
 545                 height = screen->getHeight();
 546         }
 547
 548         static const GLfloat coords[] = {
 549                 -1.0f, -1.0f,
 550                  1.0f, -1.0f,
 551                  1.0f,  1.0f,
 552                 -1.0f,  1.0f
 553         };
 554
 555         static const GLfloat texCoords[] = {
 556                 0.0f, 0.0f,
 557                 1.0f, 0.0f,
 558                 1.0f, 1.0f,
 559                 0.0f, 1.0f
 560         };
 561
 562         static const GLushort indices[] = {
 563                 0, 1, 2,
 564                 2, 3, 0
 565         };
 566
 567         GLU_CHECK_GLW_CALL(m_gl, viewport(0, 0, width, height));
 568
 569         GLU_CHECK_GLW_CALL(m_gl, clearColor(1.0f, 0.0f, 0.0f, 1.0f));
 570         GLU_CHECK_GLW_CALL(m_gl, clear(GL_COLOR_BUFFER_BIT));
 571
 572         GLU_CHECK_GLW_CALL(m_gl, useProgram(program.getProgram()));
 573
 574         GLuint coordLocation = m_gl.getAttribLocation(program.getProgram(), "a_pos");
 575         GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()");
 576         TCU_CHECK(coordLocation != (GLuint)-1);
 577
 578         GLuint texCoordLocation = m_gl.getAttribLocation(program.getProgram(), "a_texCorod");
 579         GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()");
 580         TCU_CHECK(texCoordLocation != (GLuint)-1);
 581
 582
 583         GLuint samplerLocation = m_gl.getUniformLocation(program.getProgram(), "u_sampler");
 584         GLU_CHECK_GLW_MSG(m_gl, "glGetUniformLocation()");
 585         TCU_CHECK(samplerLocation != (GLuint)-1);
 586
 587         GLU_CHECK_GLW_CALL(m_gl, activeTexture(GL_TEXTURE0));
 588         GLU_CHECK_GLW_CALL(m_gl, bindTexture(GL_TEXTURE_2D, m_glTexture));
 589
 590         GLU_CHECK_GLW_CALL(m_gl, uniform1i(samplerLocation, 0));
 591
 592         GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(texCoordLocation));
 593         GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(coordLocation));
 594
 595         GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, texCoords));
 596         GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(coordLocation, 2, GL_FLOAT, GL_FALSE, 0, coords));
 597
 598         GLU_CHECK_GLW_CALL(m_gl, drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices));
 599         GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(coordLocation));
 600         GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(texCoordLocation));
 601
 602         GLU_CHECK_GLW_CALL(m_gl, bindTexture(GL_TEXTURE_2D, 0));
 603         GLU_CHECK_GLW_CALL(m_gl, useProgram(0));
 604
 605         if (screen)
 606         {
 607                 m_gl.readPixels(0, 0, screen->getWidth(), screen->getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen->getAccess().getDataPtr());
 608
 609                 for (int x = 0; x < width; x++)
 610                 {
 611                         for (int y = 0; y < height; y++)
 612                         {
 613                                 float t = ((float)x / ((float)width - 1.0f));
 614                                 float s = ((float)y / ((float)height - 1.0f));
 615                                 float lod = 0.0f;
 616
 617                                 tcu::Vec4 color = m_texture.sample(tcu::Sampler(tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::LINEAR, tcu::Sampler::LINEAR), t, s, lod);
 618
 619                                 int r = deClamp32((int)(255.0f * color.x()), 0, 255);
 620                                 int g = deClamp32((int)(255.0f * color.y()), 0, 255);
 621                                 int b = deClamp32((int)(255.0f * color.z()), 0, 255);
 622                                 int a = deClamp32((int)(255.0f * color.w()), 0, 255);
 623
 624                                 reference->setPixel(x, y, tcu::RGBA(r, g, b, a));
 625                         }
 626                 }
 627         }
 628 }
 629
 630 class GLES2ProgramSharingTest : public GLES2SharingTest
 631 {
 632 public:
 633                                                 GLES2ProgramSharingTest (EglTestContext& eglTestCtx, const char* name, const char* desc, const GLES2SharingTest::TestSpec& spec);
 634
 635 private:
 636         glu::ShaderProgram*     m_program;
 637
 638         virtual void            createResource                  (void);
 639         virtual void            destroyResource                 (void);
 640         virtual void            renderResource                  (tcu::Surface* screen, tcu::Surface* reference);
 641
 642 };
 643
 644 GLES2ProgramSharingTest::GLES2ProgramSharingTest (EglTestContext& eglTestCtx, const char* name, const char* desc, const GLES2SharingTest::TestSpec& spec)
 645         : GLES2SharingTest      (eglTestCtx, name, desc, spec)
 646         , m_program                     (DE_NULL)
 647 {
 648 }
 649
 650 void GLES2ProgramSharingTest::createResource (void)
 651 {
 652         const char* vertexShader = ""
 653         "attribute mediump vec2 a_pos;\n"
 654         "attribute mediump vec4 a_color;\n"
 655         "varying mediump vec4 v_color;\n"
 656         "void main(void)\n"
 657         "{\n"
 658         "\tv_color = a_color;\n"
 659         "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
 660         "}\n";
 661
 662         const char* fragmentShader = ""
 663         "varying mediump vec4 v_color;\n"
 664         "void main(void)\n"
 665         "{\n"
 666         "\tgl_FragColor = v_color;\n"
 667         "}\n";
 668
 669         m_program = new glu::ShaderProgram(m_gl, glu::makeVtxFragSources(vertexShader, fragmentShader));
 670
 671         if (!m_program->isOk())
 672                 TCU_FAIL("Failed to compile shader program");
 673 }
 674
 675 void GLES2ProgramSharingTest::destroyResource (void)
 676 {
 677         delete m_program;
 678 }
 679
 680 void GLES2ProgramSharingTest::renderResource (tcu::Surface* screen, tcu::Surface* reference)
 681 {
 682         DE_ASSERT((screen && reference) || (!screen && !reference));
 683
 684         int width = 240;
 685         int height = 240;
 686
 687         if (screen)
 688         {
 689                 width = screen->getWidth();
 690                 height = screen->getHeight();
 691         }
 692
 693         static const GLfloat coords[] = {
 694                 -0.9f, -0.9f,
 695                  0.9f, -0.9f,
 696                  0.9f,  0.9f,
 697                 -0.9f,  0.9f
 698         };
 699
 700         static const GLfloat colors [] = {
 701                 0.0f, 0.0f, 0.0f, 1.0f,
 702                 1.0f, 0.0f, 0.0f, 1.0f,
 703                 0.0f, 1.0f, 0.0f, 1.0f,
 704                 0.0f, 0.0f, 1.0f, 1.0f
 705         };
 706
 707         static const GLushort indices[] = {
 708                 0, 1, 2,
 709                 2, 3, 0
 710         };
 711
 712         GLU_CHECK_GLW_CALL(m_gl, viewport(0, 0, width, height));
 713
 714         GLU_CHECK_GLW_CALL(m_gl, clearColor(1.0f, 0.0f, 0.0f, 1.0f));
 715         GLU_CHECK_GLW_CALL(m_gl, clear(GL_COLOR_BUFFER_BIT));
 716
 717         GLU_CHECK_GLW_CALL(m_gl, useProgram(m_program->getProgram()));
 718
 719         GLuint coordLocation = m_gl.getAttribLocation(m_program->getProgram(), "a_pos");
 720         GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()");
 721         TCU_CHECK(coordLocation != (GLuint)-1);
 722
 723         GLuint colorLocation = m_gl.getAttribLocation(m_program->getProgram(), "a_color");
 724         GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()");
 725         TCU_CHECK(colorLocation != (GLuint)-1);
 726
 727         GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(colorLocation));
 728         GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(coordLocation));
 729
 730         GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, 0, colors));
 731         GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(coordLocation, 2, GL_FLOAT, GL_FALSE, 0, coords));
 732
 733         GLU_CHECK_GLW_CALL(m_gl, drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices));
 734         GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(coordLocation));
 735         GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(colorLocation));
 736         GLU_CHECK_GLW_CALL(m_gl, useProgram(0));
 737
 738         if (screen)
 739         {
 740                 m_gl.readPixels(0, 0, screen->getWidth(), screen->getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen->getAccess().getDataPtr());
 741
 742                 tcu::clear(reference->getAccess(), tcu::IVec4(0xff, 0, 0, 0xff));
 743
 744                 int x1 = (int)(((float)width/2.0f)  * (-0.9f) + ((float)width/2.0f));
 745                 int x2 = (int)(((float)width/2.0f)  *   0.9f  + ((float)width/2.0f));
 746                 int y1 = (int)(((float)height/2.0f) * (-0.9f) + ((float)height/2.0f));
 747                 int y2 = (int)(((float)height/2.0f) *   0.9f  + ((float)height/2.0f));
 748
 749                 for (int x = x1; x <= x2; x++)
 750                 {
 751                         for (int y = y1; y <= y2; y++)
 752                         {
 753                                 float t = ((float)(x-x1) / (float)(x2-x1));
 754                                 float s = ((float)(y-y1) / (float)(y2-y1));
 755                                 bool isUpper = t > s;
 756
 757                                 tcu::Vec4 a(colors[0],          colors[1],              colors[2],              colors[3]);
 758                                 tcu::Vec4 b(colors[4 + 0],      colors[4 + 1],  colors[4 + 2],  colors[4 + 3]);
 759                                 tcu::Vec4 c(colors[8 + 0],      colors[8 + 1],  colors[8 + 2],  colors[8 + 3]);
 760                                 tcu::Vec4 d(colors[12 + 0],     colors[12 + 1], colors[12 + 2], colors[12 + 3]);
 761
 762
 763                                 tcu::Vec4 color;
 764
 765                                 if (isUpper)
 766                                         color = a * (1.0f - t)  + b * (t - s) + s * c;
 767                                 else
 768                                         color = a * (1.0f - s)  + d * (s - t) + t * c;
 769
 770                                 int red         = deClamp32((int)(255.0f * color.x()), 0, 255);
 771                                 int green       = deClamp32((int)(255.0f * color.y()), 0, 255);
 772                                 int blue        = deClamp32((int)(255.0f * color.z()), 0, 255);
 773                                 int alpha       = deClamp32((int)(255.0f * color.w()), 0, 255);
 774
 775                                 reference->setPixel(x, y, tcu::RGBA(red, green, blue, alpha));
 776                         }
 777                 }
 778         }
 779 }
 780
 781 class GLES2ShaderSharingTest : public GLES2SharingTest
 782 {
 783 public:
 784                                         GLES2ShaderSharingTest  (EglTestContext& eglTestCtx, const char* name, const char* desc, GLenum shaderType, const GLES2SharingTest::TestSpec& spec);
 785
 786 private:
 787         GLuint                  m_shader;
 788         GLenum                  m_shaderType;
 789
 790         virtual void    createResource          (void);
 791         virtual void    destroyResource         (void);
 792         virtual void    renderResource          (tcu::Surface* screen, tcu::Surface* reference);
 793
 794 };
 795
 796 GLES2ShaderSharingTest::GLES2ShaderSharingTest (EglTestContext& eglTestCtx, const char* name, const char* desc, GLenum shaderType, const GLES2SharingTest::TestSpec& spec)
 797         : GLES2SharingTest      (eglTestCtx, name, desc, spec)
 798         , m_shader                      (0)
 799         , m_shaderType          (shaderType)
 800 {
 801 }
 802
 803 void GLES2ShaderSharingTest::createResource (void)
 804 {
 805         const char* vertexShader = ""
 806         "attribute mediump vec2 a_pos;\n"
 807         "attribute mediump vec4 a_color;\n"
 808         "varying mediump vec4 v_color;\n"
 809         "void main(void)\n"
 810         "{\n"
 811         "\tv_color = a_color;\n"
 812         "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
 813         "}\n";
 814
 815         const char* fragmentShader = ""
 816         "varying mediump vec4 v_color;\n"
 817         "void main(void)\n"
 818         "{\n"
 819         "\tgl_FragColor = v_color;\n"
 820         "}\n";
 821
 822
 823         m_shader = m_gl.createShader(m_shaderType);
 824         GLU_CHECK_GLW_MSG(m_gl, "glCreateShader()");
 825
 826         switch (m_shaderType)
 827         {
 828                 case GL_VERTEX_SHADER:
 829                         GLU_CHECK_GLW_CALL(m_gl, shaderSource(m_shader, 1, &vertexShader, DE_NULL));
 830                         break;
 831
 832                 case GL_FRAGMENT_SHADER:
 833                         GLU_CHECK_GLW_CALL(m_gl, shaderSource(m_shader, 1, &fragmentShader, DE_NULL));
 834                         break;
 835
 836                 default:
 837                         DE_ASSERT(false);
 838         }
 839
 840         GLU_CHECK_GLW_CALL(m_gl, compileShader(m_shader));
 841
 842         GLint status = 0;
 843         GLU_CHECK_GLW_CALL(m_gl, getShaderiv(m_shader, GL_COMPILE_STATUS, &status));
 844
 845         if (!status)
 846         {
 847                 char buffer[256];
 848                 GLU_CHECK_GLW_CALL(m_gl, getShaderInfoLog(m_shader, 256, DE_NULL, buffer));
 849
 850                 m_log << tcu::TestLog::Message << "Failed to compile shader" << tcu::TestLog::EndMessage;
 851
 852                 switch (m_shaderType)
 853                 {
 854                         case GL_VERTEX_SHADER:
 855                                 m_log << tcu::TestLog::Message << vertexShader << tcu::TestLog::EndMessage;
 856                                 break;
 857
 858                         case GL_FRAGMENT_SHADER:
 859                                 m_log << tcu::TestLog::Message << fragmentShader << tcu::TestLog::EndMessage;
 860                                 break;
 861
 862                         default:
 863                                 DE_ASSERT(false);
 864                 }
 865
 866                 m_log << tcu::TestLog::Message << buffer << tcu::TestLog::EndMessage;
 867                 TCU_FAIL("Failed to compile shader");
 868         }
 869 }
 870
 871 void GLES2ShaderSharingTest::destroyResource (void)
 872 {
 873         GLU_CHECK_GLW_CALL(m_gl, deleteShader(m_shader));
 874 }
 875
 876 void GLES2ShaderSharingTest::renderResource (tcu::Surface* screen, tcu::Surface* reference)
 877 {
 878         DE_ASSERT((screen && reference) || (!screen && !reference));
 879
 880         int width = 240;
 881         int height = 240;
 882
 883         const char* vertexShader = ""
 884         "attribute mediump vec2 a_pos;\n"
 885         "attribute mediump vec4 a_color;\n"
 886         "varying mediump vec4 v_color;\n"
 887         "void main(void)\n"
 888         "{\n"
 889         "\tv_color = a_color;\n"
 890         "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
 891         "}\n";
 892
 893         const char* fragmentShader = ""
 894         "varying mediump vec4 v_color;\n"
 895         "void main(void)\n"
 896         "{\n"
 897         "\tgl_FragColor = v_color;\n"
 898         "}\n";
 899
 900
 901         GLuint otherShader = (GLuint)-1;
 902
 903         switch (m_shaderType)
 904         {
 905                 case GL_VERTEX_SHADER:
 906                         otherShader = m_gl.createShader(GL_FRAGMENT_SHADER);
 907                         GLU_CHECK_GLW_MSG(m_gl, "glCreateShader()");
 908                         GLU_CHECK_GLW_CALL(m_gl, shaderSource(otherShader, 1, &fragmentShader, DE_NULL));
 909                         break;
 910
 911                 case GL_FRAGMENT_SHADER:
 912                         otherShader = m_gl.createShader(GL_VERTEX_SHADER);
 913                         GLU_CHECK_GLW_MSG(m_gl, "glCreateShader()");
 914                         GLU_CHECK_GLW_CALL(m_gl, shaderSource(otherShader, 1, &vertexShader, DE_NULL));
 915                         break;
 916
 917                 default:
 918                         DE_ASSERT(false);
 919         }
 920
 921         GLU_CHECK_GLW_CALL(m_gl, compileShader(otherShader));
 922
 923         GLint status = 0;
 924         GLU_CHECK_GLW_CALL(m_gl, getShaderiv(otherShader, GL_COMPILE_STATUS, &status));
 925
 926         if (!status)
 927         {
 928                 char buffer[256];
 929                 GLU_CHECK_GLW_CALL(m_gl, getShaderInfoLog(otherShader, 256, DE_NULL, buffer));
 930
 931                 m_log << tcu::TestLog::Message << "Failed to compile shader" << tcu::TestLog::EndMessage;
 932
 933                 switch (m_shaderType)
 934                 {
 935                         case GL_FRAGMENT_SHADER:
 936                                 m_log << tcu::TestLog::Message << vertexShader << tcu::TestLog::EndMessage;
 937                                 break;
 938
 939                         case GL_VERTEX_SHADER:
 940                                 m_log << tcu::TestLog::Message << fragmentShader << tcu::TestLog::EndMessage;
 941                                 break;
 942
 943                         default:
 944                                 DE_ASSERT(false);
 945                 }
 946
 947                 m_log << tcu::TestLog::Message << buffer << tcu::TestLog::EndMessage;
 948                 TCU_FAIL("Failed to compile shader");
 949         }
 950
 951         GLuint program = m_gl.createProgram();
 952         GLU_CHECK_GLW_MSG(m_gl, "glCreateProgram()");
 953
 954         GLU_CHECK_GLW_CALL(m_gl, attachShader(program, m_shader));
 955         GLU_CHECK_GLW_CALL(m_gl, attachShader(program, otherShader));
 956
 957         GLU_CHECK_GLW_CALL(m_gl, linkProgram(program));
 958         GLU_CHECK_GLW_CALL(m_gl, deleteShader(otherShader));
 959
 960         status = 0;
 961         GLU_CHECK_GLW_CALL(m_gl, getProgramiv(program, GL_LINK_STATUS, &status));
 962
 963         if (!status)
 964         {
 965                 char buffer[256];
 966                 GLU_CHECK_GLW_CALL(m_gl, getProgramInfoLog(program, 256, DE_NULL, buffer));
 967
 968                 m_log << tcu::TestLog::Message << "Failed to link program" << tcu::TestLog::EndMessage;
 969
 970                 m_log << tcu::TestLog::Message << vertexShader << tcu::TestLog::EndMessage;
 971                 m_log << tcu::TestLog::Message << fragmentShader << tcu::TestLog::EndMessage;
 972                 m_log << tcu::TestLog::Message << buffer << tcu::TestLog::EndMessage;
 973                 TCU_FAIL("Failed to link program");
 974         }
 975
 976         if (screen)
 977         {
 978                 width = screen->getWidth();
 979                 height = screen->getHeight();
 980         }
 981
 982         static const GLfloat coords[] = {
 983                 -0.9f, -0.9f,
 984                  0.9f, -0.9f,
 985                  0.9f,  0.9f,
 986                 -0.9f,  0.9f
 987         };
 988
 989         static const GLfloat colors [] = {
 990                 0.0f, 0.0f, 0.0f, 1.0f,
 991                 1.0f, 0.0f, 0.0f, 1.0f,
 992                 0.0f, 1.0f, 0.0f, 1.0f,
 993                 0.0f, 0.0f, 1.0f, 1.0f
 994         };
 995
 996         static const GLushort indices[] = {
 997                 0, 1, 2,
 998                 2, 3, 0
 999         };
1000
1001         GLU_CHECK_GLW_CALL(m_gl, viewport(0, 0, width, height));
1002
1003         GLU_CHECK_GLW_CALL(m_gl, clearColor(1.0f, 0.0f, 0.0f, 1.0f));
1004         GLU_CHECK_GLW_CALL(m_gl, clear(GL_COLOR_BUFFER_BIT));
1005
1006         GLU_CHECK_GLW_CALL(m_gl, useProgram(program));
1007
1008         GLuint coordLocation = m_gl.getAttribLocation(program, "a_pos");
1009         GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()");
1010         TCU_CHECK(coordLocation != (GLuint)-1);
1011
1012         GLuint colorLocation = m_gl.getAttribLocation(program, "a_color");
1013         GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()");
1014         TCU_CHECK(colorLocation != (GLuint)-1);
1015
1016         GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(colorLocation));
1017         GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(coordLocation));
1018
1019         GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, 0, colors));
1020         GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(coordLocation, 2, GL_FLOAT, GL_FALSE, 0, coords));
1021
1022         GLU_CHECK_GLW_CALL(m_gl, drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices));
1023         GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(coordLocation));
1024         GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(colorLocation));
1025         GLU_CHECK_GLW_CALL(m_gl, useProgram(0));
1026
1027         if (screen)
1028         {
1029                 m_gl.readPixels(0, 0, screen->getWidth(), screen->getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen->getAccess().getDataPtr());
1030
1031                 tcu::clear(reference->getAccess(), tcu::IVec4(0xff, 0, 0, 0xff));
1032
1033                 int x1 = (int)(((float)width/2.0f)  * (-0.9f) + ((float)width/2.0f));
1034                 int x2 = (int)(((float)width/2.0f)  *   0.9f  + ((float)width/2.0f));
1035                 int y1 = (int)(((float)height/2.0f) * (-0.9f) + ((float)height/2.0f));
1036                 int y2 = (int)(((float)height/2.0f) *   0.9f  + ((float)height/2.0f));
1037
1038                 for (int x = x1; x <= x2; x++)
1039                 {
1040                         for (int y = y1; y <= y2; y++)
1041                         {
1042                                 float t = ((float)(x-x1) / (float)(x2-x1));
1043                                 float s = ((float)(y-y1) / (float)(y2-y1));
1044                                 bool isUpper = t > s;
1045
1046                                 tcu::Vec4 a(colors[0],          colors[1],              colors[2],              colors[3]);
1047                                 tcu::Vec4 b(colors[4 + 0],      colors[4 + 1],  colors[4 + 2],  colors[4 + 3]);
1048                                 tcu::Vec4 c(colors[8 + 0],      colors[8 + 1],  colors[8 + 2],  colors[8 + 3]);
1049                                 tcu::Vec4 d(colors[12 + 0],     colors[12 + 1], colors[12 + 2], colors[12 + 3]);
1050
1051
1052                                 tcu::Vec4 color;
1053
1054                                 if (isUpper)
1055                                         color = a * (1.0f - t)  + b * (t - s) + s * c;
1056                                 else
1057                                         color = a * (1.0f - s)  + d * (s - t) + t * c;
1058
1059                                 int red         = deClamp32((int)(255.0f * color.x()), 0, 255);
1060                                 int green       = deClamp32((int)(255.0f * color.y()), 0, 255);
1061                                 int blue        = deClamp32((int)(255.0f * color.z()), 0, 255);
1062                                 int alpha       = deClamp32((int)(255.0f * color.w()), 0, 255);
1063
1064                                 reference->setPixel(x, y, tcu::RGBA(red, green, blue, alpha));
1065                         }
1066                 }
1067         }
1068 }
1069
1070 SharingTests::SharingTests (EglTestContext& eglTestCtx)
1071         : TestCaseGroup (eglTestCtx, "sharing", "Sharing test cases")
1072 {
1073 }
1074
1075 void SharingTests::init (void)
1076 {
1077         TestCaseGroup* gles2 = new TestCaseGroup(m_eglTestCtx, "gles2", "OpenGL ES 2 sharing test");
1078
1079         TestCaseGroup* context = new TestCaseGroup(m_eglTestCtx, "context", "Context creation and destruction tests");
1080
1081         {
1082                 GLES2SharingTest::TestSpec spec;
1083                 spec.destroyContextBFirst       = false;
1084                 spec.useResource                        = false;
1085                 spec.destroyOnContexB           = false;
1086                 spec.initializeData                     = true;
1087                 spec.renderOnContexA            = true;
1088                 spec.renderOnContexB            = true;
1089                 spec.verifyOnContexA            = true;
1090                 spec.verifyOnContexB            = true;
1091
1092                 context->addChild(new GLES2SharingTest(m_eglTestCtx, "create_destroy", "Simple context creation and destruction", spec));
1093         }
1094         {
1095                 GLES2SharingTest::TestSpec spec;
1096                 spec.destroyContextBFirst       = true;
1097                 spec.useResource                        = false;
1098                 spec.destroyOnContexB           = false;
1099                 spec.initializeData                     = false;
1100                 spec.renderOnContexA            = false;
1101                 spec.renderOnContexB            = false;
1102                 spec.verifyOnContexA            = false;
1103                 spec.verifyOnContexB            = false;
1104
1105                 context->addChild(new GLES2SharingTest(m_eglTestCtx, "create_destroy_mixed", "Simple context creation and destruction test with different destruction order", spec));
1106         }
1107
1108         gles2->addChild(context);
1109
1110         TestCaseGroup* buffer = new TestCaseGroup(m_eglTestCtx, "buffer", "Buffer creation, destruction and rendering test");
1111
1112         {
1113                 GLES2SharingTest::TestSpec spec;
1114                 spec.destroyContextBFirst       = false;
1115                 spec.useResource                        = true;
1116                 spec.destroyOnContexB           = false;
1117                 spec.initializeData                     = true;
1118                 spec.renderOnContexA            = false;
1119                 spec.renderOnContexB            = false;
1120                 spec.verifyOnContexA            = false;
1121                 spec.verifyOnContexB            = false;
1122
1123                 buffer->addChild(new GLES2BufferSharingTest(m_eglTestCtx, "create_delete", "Create and delete on shared context", spec));
1124         }
1125         {
1126                 GLES2SharingTest::TestSpec spec;
1127                 spec.destroyContextBFirst       = false;
1128                 spec.useResource                        = true;
1129                 spec.destroyOnContexB           = true;
1130                 spec.initializeData                     = true;
1131                 spec.renderOnContexA            = false;
1132                 spec.renderOnContexB            = false;
1133                 spec.verifyOnContexA            = false;
1134                 spec.verifyOnContexB            = false;
1135
1136                 buffer->addChild(new GLES2BufferSharingTest(m_eglTestCtx, "create_delete_mixed", "Create and delet on different contexts", spec));
1137         }
1138         {
1139                 GLES2SharingTest::TestSpec spec;
1140                 spec.destroyContextBFirst       = false;
1141                 spec.useResource                        = true;
1142                 spec.destroyOnContexB           = false;
1143                 spec.initializeData                     = true;
1144                 spec.renderOnContexA            = true;
1145                 spec.renderOnContexB            = true;
1146                 spec.verifyOnContexA            = true;
1147                 spec.verifyOnContexB            = true;
1148
1149                 buffer->addChild(new GLES2BufferSharingTest(m_eglTestCtx, "render", "Create, rendering on two different contexts and delete", spec));
1150         }
1151
1152         gles2->addChild(buffer);
1153
1154         TestCaseGroup* texture = new TestCaseGroup(m_eglTestCtx, "texture", "Texture creation, destruction and rendering tests");
1155
1156         {
1157                 GLES2SharingTest::TestSpec spec;
1158                 spec.destroyContextBFirst       = false;
1159                 spec.useResource                        = true;
1160                 spec.destroyOnContexB           = false;
1161                 spec.initializeData                     = true;
1162                 spec.renderOnContexA            = false;
1163                 spec.renderOnContexB            = false;
1164                 spec.verifyOnContexA            = false;
1165                 spec.verifyOnContexB            = false;
1166
1167                 texture->addChild(new GLES2TextureSharingTest(m_eglTestCtx, "create_delete", "Create and delete on shared context", spec));
1168         }
1169         {
1170                 GLES2SharingTest::TestSpec spec;
1171                 spec.destroyContextBFirst       = false;
1172                 spec.useResource                        = true;
1173                 spec.destroyOnContexB           = true;
1174                 spec.initializeData                     = true;
1175                 spec.renderOnContexA            = false;
1176                 spec.renderOnContexB            = false;
1177                 spec.verifyOnContexA            = false;
1178                 spec.verifyOnContexB            = false;
1179
1180                 texture->addChild(new GLES2TextureSharingTest(m_eglTestCtx, "create_delete_mixed", "Create and delete on different contexts", spec));
1181         }
1182         {
1183                 GLES2SharingTest::TestSpec spec;
1184                 spec.destroyContextBFirst       = false;
1185                 spec.useResource                        = true;
1186                 spec.destroyOnContexB           = false;
1187                 spec.initializeData                     = true;
1188                 spec.renderOnContexA            = true;
1189                 spec.renderOnContexB            = true;
1190                 spec.verifyOnContexA            = true;
1191                 spec.verifyOnContexB            = true;
1192
1193                 texture->addChild(new GLES2TextureSharingTest(m_eglTestCtx, "render", "Create, render in two contexts and delete", spec));
1194         }
1195
1196         gles2->addChild(texture);
1197
1198         TestCaseGroup* program = new TestCaseGroup(m_eglTestCtx, "program", "Program creation, destruction and rendering test");
1199
1200         {
1201                 GLES2SharingTest::TestSpec spec;
1202                 spec.destroyContextBFirst       = false;
1203                 spec.useResource                        = true;
1204                 spec.destroyOnContexB           = false;
1205                 spec.initializeData                     = true;
1206                 spec.renderOnContexA            = false;
1207                 spec.renderOnContexB            = false;
1208                 spec.verifyOnContexA            = false;
1209                 spec.verifyOnContexB            = false;
1210
1211                 program->addChild(new GLES2ProgramSharingTest(m_eglTestCtx, "create_delete", "Create and delete on shared context", spec));
1212         }
1213         {
1214                 GLES2SharingTest::TestSpec spec;
1215                 spec.destroyContextBFirst       = false;
1216                 spec.useResource                        = true;
1217                 spec.destroyOnContexB           = true;
1218                 spec.initializeData                     = true;
1219                 spec.renderOnContexA            = false;
1220                 spec.renderOnContexB            = false;
1221                 spec.verifyOnContexA            = false;
1222                 spec.verifyOnContexB            = false;
1223
1224                 program->addChild(new GLES2ProgramSharingTest(m_eglTestCtx, "create_delete_mixed", "Create and delete on different contexts", spec));
1225         }
1226         {
1227                 GLES2SharingTest::TestSpec spec;
1228                 spec.destroyContextBFirst       = false;
1229                 spec.useResource                        = true;
1230                 spec.destroyOnContexB           = false;
1231                 spec.initializeData                     = true;
1232                 spec.renderOnContexA            = true;
1233                 spec.renderOnContexB            = true;
1234                 spec.verifyOnContexA            = true;
1235                 spec.verifyOnContexB            = true;
1236
1237                 program->addChild(new GLES2ProgramSharingTest(m_eglTestCtx, "render", "Create, render in two contexts and delete", spec));
1238         }
1239
1240         gles2->addChild(program);
1241
1242         TestCaseGroup* shader = new TestCaseGroup(m_eglTestCtx, "shader", "Shader creation, destruction and rendering test");
1243
1244         {
1245                 GLES2SharingTest::TestSpec spec;
1246                 spec.destroyContextBFirst       = false;
1247                 spec.useResource                        = true;
1248                 spec.destroyOnContexB           = false;
1249                 spec.initializeData                     = true;
1250                 spec.renderOnContexA            = false;
1251                 spec.renderOnContexB            = false;
1252                 spec.verifyOnContexA            = false;
1253                 spec.verifyOnContexB            = false;
1254
1255                 shader->addChild(new GLES2ShaderSharingTest(m_eglTestCtx, "create_delete_vert", "Create and delete on shared context", GL_VERTEX_SHADER, spec));
1256         }
1257         {
1258                 GLES2SharingTest::TestSpec spec;
1259                 spec.destroyContextBFirst       = false;
1260                 spec.useResource                        = true;
1261                 spec.destroyOnContexB           = true;
1262                 spec.initializeData                     = true;
1263                 spec.renderOnContexA            = false;
1264                 spec.renderOnContexB            = false;
1265                 spec.verifyOnContexA            = false;
1266                 spec.verifyOnContexB            = false;
1267
1268                 shader->addChild(new GLES2ShaderSharingTest(m_eglTestCtx, "create_delete_mixed_vert", "Create and delete on different contexts", GL_VERTEX_SHADER, spec));
1269         }
1270         {
1271                 GLES2SharingTest::TestSpec spec;
1272                 spec.destroyContextBFirst       = false;
1273                 spec.useResource                        = true;
1274                 spec.destroyOnContexB           = false;
1275                 spec.initializeData                     = true;
1276                 spec.renderOnContexA            = true;
1277                 spec.renderOnContexB            = true;
1278                 spec.verifyOnContexA            = true;
1279                 spec.verifyOnContexB            = true;
1280
1281                 shader->addChild(new GLES2ShaderSharingTest(m_eglTestCtx, "render_vert", "Create, render on two contexts and delete", GL_VERTEX_SHADER, spec));
1282         }
1283         {
1284                 GLES2SharingTest::TestSpec spec;
1285                 spec.destroyContextBFirst       = false;
1286                 spec.useResource                        = true;
1287                 spec.destroyOnContexB           = false;
1288                 spec.initializeData                     = true;
1289                 spec.renderOnContexA            = false;
1290                 spec.renderOnContexB            = false;
1291                 spec.verifyOnContexA            = false;
1292                 spec.verifyOnContexB            = false;
1293
1294                 shader->addChild(new GLES2ShaderSharingTest(m_eglTestCtx, "create_delete_frag", "Create and delete on shared context", GL_FRAGMENT_SHADER, spec));
1295         }
1296         {
1297                 GLES2SharingTest::TestSpec spec;
1298                 spec.destroyContextBFirst       = false;
1299                 spec.useResource                        = true;
1300                 spec.destroyOnContexB           = true;
1301                 spec.initializeData                     = true;
1302                 spec.renderOnContexA            = false;
1303                 spec.renderOnContexB            = false;
1304                 spec.verifyOnContexA            = false;
1305                 spec.verifyOnContexB            = false;
1306
1307                 shader->addChild(new GLES2ShaderSharingTest(m_eglTestCtx, "create_delete_mixed_frag", "Create and delete on different contexts", GL_FRAGMENT_SHADER, spec));
1308         }
1309         {
1310                 GLES2SharingTest::TestSpec spec;
1311                 spec.destroyContextBFirst       = false;
1312                 spec.useResource                        = true;
1313                 spec.destroyOnContexB           = false;
1314                 spec.initializeData                     = true;
1315                 spec.renderOnContexA            = true;
1316                 spec.renderOnContexB            = true;
1317                 spec.verifyOnContexA            = true;
1318                 spec.verifyOnContexB            = true;
1319
1320                 shader->addChild(new GLES2ShaderSharingTest(m_eglTestCtx, "render_frag", "Create, render on two contexts and delete", GL_FRAGMENT_SHADER, spec));
1321         }
1322
1323
1324         gles2->addChild(shader);
1325
1326
1327         gles2->addChild(new GLES2SharingThreadedTests(m_eglTestCtx));
1328
1329         addChild(gles2);
1330 }
1331
1332 } // egl
1333 } // deqp