modules/gles3/performance/es3pStateChangeTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.0 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief State change performance tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3pStateChangeTests.hpp"
  25 #include "glsStateChangePerfTestCases.hpp"
  26 #include "gluShaderProgram.hpp"
  27 #include "glwFunctions.hpp"
  28 #include "glwEnums.hpp"
  29
  30 namespace deqp
  31 {
  32 namespace gles3
  33 {
  34 namespace Performance
  35 {
  36
  37 using namespace glw; // GL types
  38
  39 namespace
  40 {
  41
  42 enum
  43 {
  44         VIEWPORT_WIDTH  = 24,
  45         VIEWPORT_HEIGHT = 24
  46 };
  47
  48 class StateChangeCase : public gls::StateChangePerformanceCase
  49 {
  50 public:
  51                                         StateChangeCase                 (Context& context, int drawCallCount, int triangleCount, bool drawArrays, bool useIndexBuffer, const char* name, const char* description);
  52                                         ~StateChangeCase                (void);
  53
  54 protected:
  55         virtual void    renderTest                              (const glw::Functions& gl);
  56         virtual void    renderReference                 (const glw::Functions& gl);
  57
  58         virtual void    changeState                             (const glw::Functions& gl, int stateId) = 0;
  59 };
  60
  61 StateChangeCase::StateChangeCase (Context& context, int drawCallCount, int triangleCount, bool drawArrays, bool useIndexBuffer, const char* name, const char* description)
  62         : gls::StateChangePerformanceCase(context.getTestContext(), context.getRenderContext(), name, description,
  63                                                                           (useIndexBuffer       ? DRAWTYPE_INDEXED_BUFFER       :
  64                                                                            drawArrays           ? DRAWTYPE_NOT_INDEXED          :
  65                                                                                                                   DRAWTYPE_INDEXED_USER_PTR), drawCallCount, triangleCount)
  66 {
  67         DE_ASSERT(!useIndexBuffer || !drawArrays);
  68 }
  69
  70 StateChangeCase::~StateChangeCase (void)
  71 {
  72 }
  73
  74 void StateChangeCase::renderTest (const glw::Functions& gl)
  75 {
  76         for (int callNdx = 0; callNdx < m_callCount; callNdx++)
  77         {
  78                 changeState(gl, 0);
  79                 callDraw(gl);
  80
  81                 changeState(gl, 1);
  82                 callDraw(gl);
  83         }
  84 }
  85
  86 void StateChangeCase::renderReference (const glw::Functions& gl)
  87 {
  88         changeState(gl, 0);
  89
  90         for (int callNdx = 0; callNdx < m_callCount; callNdx++)
  91                 callDraw(gl);
  92
  93         changeState(gl, 1);
  94
  95         for (int callNdx = 0; callNdx < m_callCount; callNdx++)
  96                 callDraw(gl);
  97 }
  98
  99 } // anonymous
 100
 101 StateChangeTests::StateChangeTests (Context& context)
 102         : TestCaseGroup(context, "state_change_draw", "Test state change perfomance with draw calls.")
 103 {
 104 }
 105
 106 StateChangeTests::~StateChangeTests (void)
 107 {
 108 }
 109
 110 #define MACRO_BLOCK(...) __VA_ARGS__
 111
 112 #define ADD_TESTCASE(NAME, DESC, DRAWARRAYS, INDEXBUFFER, INIT_FUNC, CHANGE_FUNC)\
 113 do {\
 114         class StateChangeCase_ ## NAME : public StateChangeCase\
 115         {\
 116         public:\
 117                         StateChangeCase_ ## NAME (Context& context, int drawCallCount, int triangleCount, const char* name, const char* description)\
 118                                 : StateChangeCase(context, drawCallCount, triangleCount, (DRAWARRAYS), (INDEXBUFFER), name, description)\
 119                         {}\
 120                 virtual void setupInitialState (const glw::Functions& gl)\
 121                 {\
 122                         INIT_FUNC\
 123                 }\
 124                 virtual void changeState (const glw::Functions& gl, int stateId)\
 125                 {\
 126                         CHANGE_FUNC\
 127                 }\
 128         };\
 129         manySmallCallsGroup->addChild   (new StateChangeCase_ ## NAME (m_context,1000,2,#NAME,(DESC)));\
 130         fewBigCallsGroup->addChild              (new StateChangeCase_ ## NAME (m_context,10,200,#NAME,(DESC)));\
 131 } while (0);
 132
 133 void StateChangeTests::init (void)
 134 {
 135         tcu::TestCaseGroup* const       manySmallCallsGroup     = new tcu::TestCaseGroup(m_testCtx, "many_small_calls", "1000 calls, 2 triangles in each");
 136         tcu::TestCaseGroup* const       fewBigCallsGroup        = new tcu::TestCaseGroup(m_testCtx, "few_big_calls",    "10 calls, 200 triangles in each");
 137
 138         addChild(manySmallCallsGroup);
 139         addChild(fewBigCallsGroup);
 140
 141         ADD_TESTCASE(blend, "Enable/Disable blending.",
 142                 true,
 143                 false,
 144                 MACRO_BLOCK({
 145                         requireCoordBuffers(1);
 146                         requireTextures(1);
 147                         requirePrograms(1);
 148
 149                         gl.useProgram(m_programs[0]->getProgram());
 150                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 151                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 152                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 153
 154                         gl.enableVertexAttribArray(coordLoc);
 155                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 156                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 157                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 158                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 159                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 160
 161                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 162                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 163
 164                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 165                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 166
 167                         gl.uniform1i(samplerLoc, 0);
 168                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 169
 170                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 171                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 172                 }),
 173                 MACRO_BLOCK({
 174                         if (stateId == 0)
 175                                 gl.enable(GL_BLEND);
 176                         else if (stateId == 1)
 177                                 gl.disable(GL_BLEND);
 178                         else
 179                                 DE_ASSERT(false);
 180                 })
 181         )
 182
 183         ADD_TESTCASE(depth_test, "Enable/Disable depth test.",
 184                 true,
 185                 false,
 186                 MACRO_BLOCK({
 187                         requireCoordBuffers(1);
 188                         requireTextures(1);
 189                         requirePrograms(1);
 190
 191                         gl.useProgram(m_programs[0]->getProgram());
 192                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 193
 194                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 195                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 196
 197                         gl.enableVertexAttribArray(coordLoc);
 198                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 199
 200                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 201                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 202                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 203                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 204
 205                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 206                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 207
 208                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 209                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 210
 211                         gl.uniform1i(samplerLoc, 0);
 212                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 213
 214                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 215                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 216
 217                         gl.depthFunc(GL_LEQUAL);
 218                         GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthFunc()");
 219                 }),
 220                 MACRO_BLOCK({
 221                         if (stateId == 0)
 222                                 gl.enable(GL_DEPTH_TEST);
 223                         else if (stateId == 1)
 224                                 gl.disable(GL_DEPTH_TEST);
 225                         else
 226                                 DE_ASSERT(false);
 227                 })
 228         )
 229
 230         ADD_TESTCASE(stencil_test, "Enable/Disable stencil test.",
 231                 true,
 232                 false,
 233                 MACRO_BLOCK({
 234                         requireCoordBuffers(1);
 235                         requireTextures(1);
 236                         requirePrograms(1);
 237
 238                         gl.useProgram(m_programs[0]->getProgram());
 239                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 240                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 241                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 242
 243                         gl.enableVertexAttribArray(coordLoc);
 244                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 245                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 246                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 247                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 248                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 249
 250                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 251                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 252
 253                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 254                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 255
 256                         gl.uniform1i(samplerLoc, 0);
 257                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 258
 259                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 260                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 261
 262                         gl.stencilFunc(GL_LEQUAL, 0, 0);
 263                         GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
 264
 265                         gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
 266                         GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
 267
 268                         gl.clearStencil(0);
 269                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
 270                         gl.clear(GL_STENCIL_BUFFER_BIT);
 271
 272                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
 273                 }),
 274                 MACRO_BLOCK({
 275                         if (stateId == 0)
 276                                 gl.enable(GL_STENCIL_TEST);
 277                         else if (stateId == 1)
 278                                 gl.disable(GL_STENCIL_TEST);
 279                         else
 280                                 DE_ASSERT(false);
 281                 })
 282         )
 283
 284         ADD_TESTCASE(scissor_test, "Enable/Disable scissor test.",
 285                 true,
 286                 false,
 287                 MACRO_BLOCK({
 288                         requireCoordBuffers(1);
 289                         requireTextures(1);
 290                         requirePrograms(1);
 291
 292                         gl.useProgram(m_programs[0]->getProgram());
 293                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 294                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 295                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 296
 297                         gl.enableVertexAttribArray(coordLoc);
 298                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 299                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 300                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 301                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 302                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 303
 304                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 305                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 306
 307                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 308                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 309
 310                         gl.uniform1i(samplerLoc, 0);
 311                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 312
 313                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 314                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 315
 316                         gl.scissor(2, 3, 12, 13);
 317                         GLU_EXPECT_NO_ERROR(gl.getError(), "glScissor()");
 318                 }),
 319                 MACRO_BLOCK({
 320                         if (stateId == 0)
 321                                 gl.enable(GL_SCISSOR_TEST);
 322                         else if (stateId == 1)
 323                                 gl.disable(GL_SCISSOR_TEST);
 324                         else
 325                                 DE_ASSERT(false);
 326                 })
 327         )
 328
 329         ADD_TESTCASE(dither, "Enable/Disable dithering.",
 330                 true,
 331                 false,
 332                 MACRO_BLOCK({
 333                         requireCoordBuffers(1);
 334                         requireTextures(1);
 335                         requirePrograms(1);
 336
 337                         gl.useProgram(m_programs[0]->getProgram());
 338                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 339                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 340                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 341
 342                         gl.enableVertexAttribArray(coordLoc);
 343                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 344                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 345                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 346                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 347                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 348
 349                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 350                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 351
 352                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 353                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 354
 355                         gl.uniform1i(samplerLoc, 0);
 356                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 357
 358                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 359                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 360                 }),
 361                 MACRO_BLOCK({
 362                         if (stateId == 0)
 363                                 gl.enable(GL_DITHER);
 364                         else if (stateId == 1)
 365                                 gl.disable(GL_DITHER);
 366                         else
 367                                 DE_ASSERT(false);
 368                 })
 369         )
 370
 371         ADD_TESTCASE(culling, "Enable/Disable culling.",
 372                 true,
 373                 false,
 374                 MACRO_BLOCK({
 375                         requireCoordBuffers(1);
 376                         requireTextures(1);
 377                         requirePrograms(1);
 378
 379                         gl.useProgram(m_programs[0]->getProgram());
 380                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 381                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 382                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 383
 384                         gl.enableVertexAttribArray(coordLoc);
 385                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 386                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 387                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 388                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 389                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 390
 391                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 392                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 393
 394                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 395                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 396
 397                         gl.uniform1i(samplerLoc, 0);
 398                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 399
 400                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 401                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 402
 403                         gl.frontFace(GL_CW);
 404                         GLU_EXPECT_NO_ERROR(gl.getError(), "glFrontFace()");
 405
 406                         gl.cullFace(GL_FRONT);
 407                         GLU_EXPECT_NO_ERROR(gl.getError(), "glCullFace()");
 408                 }),
 409                 MACRO_BLOCK({
 410                         if (stateId == 0)
 411                                 gl.enable(GL_CULL_FACE);
 412                         else if (stateId == 1)
 413                                 gl.disable(GL_CULL_FACE);
 414                         else
 415                                 DE_ASSERT(false);
 416                 })
 417         )
 418
 419         ADD_TESTCASE(rasterizer_discard, "Enable/Disable RASTERIZER_DISCARD.",
 420                 true,
 421                 false,
 422                 MACRO_BLOCK({
 423                         requireCoordBuffers(1);
 424                         requireTextures(1);
 425                         requirePrograms(1);
 426
 427                         gl.useProgram(m_programs[0]->getProgram());
 428                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 429                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 430                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 431
 432                         gl.enableVertexAttribArray(coordLoc);
 433                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 434                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 435                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 436                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 437                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 438
 439                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 440                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 441
 442                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 443                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 444
 445                         gl.uniform1i(samplerLoc, 0);
 446                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 447
 448                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 449                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 450                 }),
 451                 MACRO_BLOCK({
 452                         if (stateId == 0)
 453                                 gl.enable(GL_RASTERIZER_DISCARD);
 454                         else if (stateId == 1)
 455                                 gl.disable(GL_RASTERIZER_DISCARD);
 456                         else
 457                                 DE_ASSERT(false);
 458                 })
 459         )
 460
 461         ADD_TESTCASE(primitive_restart_fixed_index, "Enable/Disable PRIMITIVE_RESTART_FIXED_INDEX.",
 462                 true,
 463                 false,
 464                 MACRO_BLOCK({
 465                         requireCoordBuffers(1);
 466                         requireTextures(1);
 467                         requirePrograms(1);
 468
 469                         gl.useProgram(m_programs[0]->getProgram());
 470                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 471                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 472                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 473
 474                         gl.enableVertexAttribArray(coordLoc);
 475                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 476                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 477                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 478                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 479                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 480
 481                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 482                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 483
 484                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 485                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 486
 487                         gl.uniform1i(samplerLoc, 0);
 488                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 489
 490                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 491                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 492                 }),
 493                 MACRO_BLOCK({
 494                         if (stateId == 0)
 495                                 gl.enable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
 496                         else if (stateId == 1)
 497                                 gl.disable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
 498                         else
 499                                 DE_ASSERT(false);
 500                 })
 501         )
 502
 503         ADD_TESTCASE(depth_func, "Change depth func.",
 504                 true,
 505                 false,
 506                 MACRO_BLOCK({
 507                         requireCoordBuffers(1);
 508                         requireTextures(1);
 509                         requirePrograms(1);
 510
 511                         gl.useProgram(m_programs[0]->getProgram());
 512                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 513                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 514                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 515
 516                         gl.enableVertexAttribArray(coordLoc);
 517                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 518                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 519                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 520                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 521                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 522
 523                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 524                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 525
 526                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 527                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 528
 529                         gl.uniform1i(samplerLoc, 0);
 530                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 531
 532                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 533                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 534
 535                         gl.enable(GL_DEPTH_TEST);
 536                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
 537                 }),
 538                 MACRO_BLOCK({
 539                         if (stateId == 0)
 540                                 gl.depthFunc(GL_GEQUAL);
 541                         else if (stateId == 1)
 542                                 gl.depthFunc(GL_LEQUAL);
 543                         else
 544                                 DE_ASSERT(false);
 545                 })
 546         )
 547
 548
 549         ADD_TESTCASE(depth_mask, "Toggle depth mask.",
 550                 true,
 551                 false,
 552                 MACRO_BLOCK({
 553                         requireCoordBuffers(1);
 554                         requireTextures(1);
 555                         requirePrograms(1);
 556
 557                         gl.useProgram(m_programs[0]->getProgram());
 558                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 559                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 560                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 561
 562                         gl.enableVertexAttribArray(coordLoc);
 563                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 564                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 565                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 566                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 567                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 568
 569                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 570                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 571
 572                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 573                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 574
 575                         gl.uniform1i(samplerLoc, 0);
 576                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 577
 578                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 579                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 580
 581                         gl.enable(GL_DEPTH_TEST);
 582                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
 583
 584                         gl.depthFunc(GL_LEQUAL);
 585                         GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthFunc()");
 586                 }),
 587                 MACRO_BLOCK({
 588                         if (stateId == 0)
 589                                 gl.depthMask(GL_FALSE);
 590                         else if (stateId == 1)
 591                                 gl.depthMask(GL_TRUE);
 592                         else
 593                                 DE_ASSERT(false);
 594                 })
 595         )
 596
 597         ADD_TESTCASE(depth_rangef, "Change depth range.",
 598                 true,
 599                 false,
 600                 MACRO_BLOCK({
 601                         requireCoordBuffers(1);
 602                         requireTextures(1);
 603                         requirePrograms(1);
 604
 605                         gl.useProgram(m_programs[0]->getProgram());
 606                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 607                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 608                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 609
 610                         gl.enableVertexAttribArray(coordLoc);
 611                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 612                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 613                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 614                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 615                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 616
 617                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 618                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 619
 620                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 621                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 622
 623                         gl.uniform1i(samplerLoc, 0);
 624                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 625
 626                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 627                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 628                 }),
 629                 MACRO_BLOCK({
 630                         if (stateId == 0)
 631                                 gl.depthRangef(0.0f, 1.0f);
 632                         else if (stateId == 1)
 633                                 gl.depthRangef(0.25f, 0.75f);
 634                         else
 635                                 DE_ASSERT(false);
 636                 })
 637         )
 638
 639         ADD_TESTCASE(blend_equation, "Change blend equation.",
 640                 true,
 641                 false,
 642                 MACRO_BLOCK({
 643                         requireCoordBuffers(1);
 644                         requireTextures(1);
 645                         requirePrograms(1);
 646
 647                         gl.useProgram(m_programs[0]->getProgram());
 648                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 649                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 650                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 651
 652                         gl.enableVertexAttribArray(coordLoc);
 653                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 654                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 655                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 656                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 657                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 658
 659                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 660                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 661
 662                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 663                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 664
 665                         gl.uniform1i(samplerLoc, 0);
 666                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 667
 668                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 669                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 670
 671                         gl.enable(GL_BLEND);
 672                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
 673                 }),
 674                 MACRO_BLOCK({
 675                         if (stateId == 0)
 676                                 gl.blendEquation(GL_FUNC_SUBTRACT);
 677                         else if (stateId == 1)
 678                                 gl.blendEquation(GL_FUNC_ADD);
 679                         else
 680                                 DE_ASSERT(false);
 681                 })
 682         )
 683
 684         ADD_TESTCASE(blend_func, "Change blend function.",
 685                 true,
 686                 false,
 687                 MACRO_BLOCK({
 688                         requireCoordBuffers(1);
 689                         requireTextures(1);
 690                         requirePrograms(1);
 691
 692                         gl.useProgram(m_programs[0]->getProgram());
 693                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 694                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 695                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 696
 697                         gl.enableVertexAttribArray(coordLoc);
 698                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 699                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 700                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 701                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 702                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 703
 704                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 705                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 706
 707                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 708                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 709
 710                         gl.uniform1i(samplerLoc, 0);
 711                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 712
 713                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 714                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 715
 716                         gl.enable(GL_BLEND);
 717                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
 718                 }),
 719                 MACRO_BLOCK({
 720                         if (stateId == 0)
 721                                 gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 722                         else if (stateId == 1)
 723                                 gl.blendFunc(GL_ONE, GL_ONE);
 724                         else
 725                                 DE_ASSERT(false);
 726                 })
 727         )
 728
 729         ADD_TESTCASE(polygon_offset, "Change polygon offset.",
 730                 true,
 731                 false,
 732                 MACRO_BLOCK({
 733                         requireCoordBuffers(1);
 734                         requireTextures(1);
 735                         requirePrograms(1);
 736
 737                         gl.useProgram(m_programs[0]->getProgram());
 738                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 739                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 740                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 741
 742                         gl.enableVertexAttribArray(coordLoc);
 743                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 744                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 745                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 746                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 747                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 748
 749                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 750                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 751
 752                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 753                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 754
 755                         gl.uniform1i(samplerLoc, 0);
 756                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 757
 758                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 759                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 760
 761                         gl.enable(GL_POLYGON_OFFSET_FILL);
 762                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
 763                 }),
 764                 MACRO_BLOCK({
 765                         if (stateId == 0)
 766                                 gl.polygonOffset(0.0f, 0.0f);
 767                         else if (stateId == 1)
 768                                 gl.polygonOffset(0.1f, 0.1f);
 769                         else
 770                                 DE_ASSERT(false);
 771                 })
 772         )
 773
 774         ADD_TESTCASE(sample_coverage, "Sample coverage.",
 775                 true,
 776                 false,
 777                 MACRO_BLOCK({
 778                         requireCoordBuffers(1);
 779                         requireTextures(1);
 780                         requirePrograms(1);
 781
 782                         gl.useProgram(m_programs[0]->getProgram());
 783                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 784                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 785                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 786
 787                         gl.enableVertexAttribArray(coordLoc);
 788                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 789                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 790                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 791                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 792                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 793
 794                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 795                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 796
 797                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 798                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 799
 800                         gl.uniform1i(samplerLoc, 0);
 801                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 802
 803                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 804                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 805                 }),
 806                 MACRO_BLOCK({
 807                         if (stateId == 0)
 808                                 gl.sampleCoverage(0.25f, GL_TRUE);
 809                         else if (stateId == 1)
 810                                 gl.sampleCoverage(0.75f, GL_FALSE);
 811                         else
 812                                 DE_ASSERT(false);
 813                 })
 814         )
 815
 816         ADD_TESTCASE(viewport, "Change viewport.",
 817                 true,
 818                 false,
 819                 MACRO_BLOCK({
 820                         requireCoordBuffers(1);
 821                         requireTextures(1);
 822                         requirePrograms(1);
 823
 824                         gl.useProgram(m_programs[0]->getProgram());
 825                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 826                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 827                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 828
 829                         gl.enableVertexAttribArray(coordLoc);
 830                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 831                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 832                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 833                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 834                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 835
 836                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 837                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 838
 839                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 840                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 841
 842                         gl.uniform1i(samplerLoc, 0);
 843                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 844
 845                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 846                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 847                 }),
 848                 MACRO_BLOCK({
 849                         if (stateId == 0)
 850                                 gl.viewport(10, 11, 5, 6);
 851                         else if (stateId == 1)
 852                                 gl.viewport(2, 3, 17, 14);
 853                         else
 854                                 DE_ASSERT(false);
 855                 })
 856         )
 857
 858         ADD_TESTCASE(scissor, "Change scissor box.",
 859                 true,
 860                 false,
 861                 MACRO_BLOCK({
 862                         requireCoordBuffers(1);
 863                         requireTextures(1);
 864                         requirePrograms(1);
 865
 866                         gl.useProgram(m_programs[0]->getProgram());
 867                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 868                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 869                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 870
 871                         gl.enableVertexAttribArray(coordLoc);
 872                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 873                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 874                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 875                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 876                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 877
 878                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 879                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 880
 881                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 882                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 883
 884                         gl.uniform1i(samplerLoc, 0);
 885                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 886
 887                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 888                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 889
 890                         gl.enable(GL_SCISSOR_TEST);
 891                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
 892                 }),
 893                 MACRO_BLOCK({
 894                         if (stateId == 0)
 895                                 gl.scissor(17, 13, 5, 8);
 896                         else if (stateId == 1)
 897                                 gl.scissor(7, 3, 13, 13);
 898                         else
 899                                 DE_ASSERT(false);
 900                 })
 901         )
 902
 903         ADD_TESTCASE(color_mask, "Change color mask.",
 904                 true,
 905                 false,
 906                 MACRO_BLOCK({
 907                         requireCoordBuffers(1);
 908                         requireTextures(1);
 909                         requirePrograms(1);
 910
 911                         gl.useProgram(m_programs[0]->getProgram());
 912                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 913                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 914                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 915
 916                         gl.enableVertexAttribArray(coordLoc);
 917                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 918                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 919                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 920                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 921                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 922
 923                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 924                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 925
 926                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 927                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 928
 929                         gl.uniform1i(samplerLoc, 0);
 930                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 931
 932                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 933                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 934                 }),
 935                 MACRO_BLOCK({
 936                         if (stateId == 0)
 937                                 gl.colorMask(GL_TRUE, GL_FALSE, GL_TRUE, GL_FALSE);
 938                         else if (stateId == 1)
 939                                 gl.colorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE);
 940                         else
 941                                 DE_ASSERT(false);
 942                 })
 943         )
 944
 945         ADD_TESTCASE(cull_face, "Change culling mode.",
 946                 true,
 947                 false,
 948                 MACRO_BLOCK({
 949                         requireCoordBuffers(1);
 950                         requireTextures(1);
 951                         requirePrograms(1);
 952
 953                         gl.useProgram(m_programs[0]->getProgram());
 954                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 955                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
 956                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
 957
 958                         gl.enableVertexAttribArray(coordLoc);
 959                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
 960                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
 961                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 962                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
 963                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
 964
 965                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
 966                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
 967
 968                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
 969                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 970
 971                         gl.uniform1i(samplerLoc, 0);
 972                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
 973
 974                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 975                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
 976
 977                         gl.enable(GL_CULL_FACE);
 978                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
 979                 }),
 980                 MACRO_BLOCK({
 981                         if (stateId == 0)
 982                                 gl.cullFace(GL_FRONT);
 983                         else if (stateId == 1)
 984                                 gl.cullFace(GL_BACK);
 985                         else
 986                                 DE_ASSERT(false);
 987                 })
 988         )
 989
 990         ADD_TESTCASE(front_face, "Change front face.",
 991                 true,
 992                 false,
 993                 MACRO_BLOCK({
 994                         requireCoordBuffers(1);
 995                         requireTextures(1);
 996                         requirePrograms(1);
 997
 998                         gl.useProgram(m_programs[0]->getProgram());
 999                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1000                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1001                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1002
1003                         gl.enableVertexAttribArray(coordLoc);
1004                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1005                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1006                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1007                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1008                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1009
1010                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1011                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1012
1013                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1014                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1015
1016                         gl.uniform1i(samplerLoc, 0);
1017                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1018
1019                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1020                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1021
1022                         gl.enable(GL_CULL_FACE);
1023                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1024                 }),
1025                 MACRO_BLOCK({
1026                         if (stateId == 0)
1027                                 gl.frontFace(GL_CCW);
1028                         else if (stateId == 1)
1029                                 gl.frontFace(GL_CW);
1030                         else
1031                                 DE_ASSERT(false);
1032                 })
1033         )
1034
1035         ADD_TESTCASE(stencil_mask, "Change stencil mask.",
1036                 true,
1037                 false,
1038                 MACRO_BLOCK({
1039                         requireCoordBuffers(1);
1040                         requireTextures(1);
1041                         requirePrograms(1);
1042
1043                         gl.useProgram(m_programs[0]->getProgram());
1044                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1045                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1046                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1047
1048                         gl.enableVertexAttribArray(coordLoc);
1049                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1050                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1051                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1052                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1053                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1054
1055                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1056                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1057
1058                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1059                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1060
1061                         gl.uniform1i(samplerLoc, 0);
1062                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1063
1064                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1065                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1066
1067                         gl.enable(GL_STENCIL_TEST);
1068                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1069
1070                         gl.stencilFunc(GL_LEQUAL, 0, 0);
1071                         GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
1072
1073                         gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
1074                         GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
1075
1076                         gl.clearStencil(0);
1077                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
1078                         gl.clear(GL_STENCIL_BUFFER_BIT);
1079                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
1080                 }),
1081                 MACRO_BLOCK({
1082                         if (stateId == 0)
1083                                 gl.stencilMask(0xDD);
1084                         else if (stateId == 1)
1085                                 gl.stencilMask(~0xDD);
1086                         else
1087                                 DE_ASSERT(false);
1088                 })
1089         )
1090
1091         ADD_TESTCASE(stencil_func, "Change stencil func.",
1092                 true,
1093                 false,
1094                 MACRO_BLOCK({
1095                         requireCoordBuffers(1);
1096                         requireTextures(1);
1097                         requirePrograms(1);
1098
1099                         gl.useProgram(m_programs[0]->getProgram());
1100                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1101                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1102                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1103
1104                         gl.enableVertexAttribArray(coordLoc);
1105                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1106                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1107                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1108                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1109                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1110
1111                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1112                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1113
1114                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1115                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1116
1117                         gl.uniform1i(samplerLoc, 0);
1118                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1119
1120                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1121                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1122
1123                         gl.enable(GL_STENCIL_TEST);
1124                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1125
1126                         gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
1127                         GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
1128                         gl.clearStencil(0);
1129                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
1130                         gl.clear(GL_STENCIL_BUFFER_BIT);
1131                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
1132                 }),
1133                 MACRO_BLOCK({
1134                         if (stateId == 0)
1135                                 gl.stencilFunc(GL_LEQUAL, 0, 0xFF);
1136                         else if (stateId == 1)
1137                                 gl.stencilFunc(GL_GEQUAL, 0, 0x00);
1138                         else
1139                                 DE_ASSERT(false);
1140                 })
1141         )
1142
1143         ADD_TESTCASE(stencil_op, "Change stencil op.",
1144                 true,
1145                 false,
1146                 MACRO_BLOCK({
1147                         requireCoordBuffers(1);
1148                         requireTextures(1);
1149                         requirePrograms(1);
1150
1151                         gl.useProgram(m_programs[0]->getProgram());
1152                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1153                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1154                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1155
1156                         gl.enableVertexAttribArray(coordLoc);
1157                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1158                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1159                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1160                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1161                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1162
1163                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1164                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1165
1166                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1167                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1168
1169                         gl.uniform1i(samplerLoc, 0);
1170                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1171
1172                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1173                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1174
1175                         gl.enable(GL_STENCIL_TEST);
1176                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1177
1178                         gl.stencilFunc(GL_LEQUAL, 0, 0);
1179                         GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
1180
1181                         gl.clearStencil(0);
1182                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
1183
1184                         gl.clear(GL_STENCIL_BUFFER_BIT);
1185                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
1186                 }),
1187                 MACRO_BLOCK({
1188                         if (stateId == 0)
1189                                 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
1190                         else if (stateId == 1)
1191                                 gl.stencilOp(GL_REPLACE, GL_KEEP, GL_KEEP);
1192                         else
1193                                 DE_ASSERT(false);
1194                 })
1195         )
1196
1197         ADD_TESTCASE(bind_array_buffer, "Change array buffer and refresh vertex attrib pointer.",
1198                 true,
1199                 false,
1200                 MACRO_BLOCK({
1201                         requireCoordBuffers(2);
1202                         requireTextures(1);
1203                         requirePrograms(1);
1204
1205                         gl.bindAttribLocation(m_programs[0]->getProgram(), 0, "a_coord");
1206                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
1207                         gl.linkProgram(m_programs[0]->getProgram());
1208                         GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
1209
1210                         gl.useProgram(m_programs[0]->getProgram());
1211                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1212
1213                         gl.enableVertexAttribArray(0);
1214                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1215                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1216                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1217                         gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1218                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1219
1220                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1221                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1222
1223                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1224                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1225
1226                         gl.uniform1i(samplerLoc, 0);
1227                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1228
1229                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1230                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1231                 }),
1232                 MACRO_BLOCK({
1233                         if (stateId == 0)
1234                         {
1235                                 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1236                                 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1237                         }
1238                         else if (stateId == 1)
1239                         {
1240                                 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[1]);
1241                                 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1242                         }
1243                         else
1244                                 DE_ASSERT(false);
1245                 })
1246         )
1247
1248         ADD_TESTCASE(element_array_buffer, "Change element array buffer.",
1249                 false,
1250                 true,
1251                 MACRO_BLOCK({
1252                         requireCoordBuffers(1);
1253                         requireIndexBuffers(2);
1254                         requireTextures(1);
1255                         requirePrograms(1);
1256
1257                         gl.useProgram(m_programs[0]->getProgram());
1258                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1259                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1260                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1261
1262                         gl.enableVertexAttribArray(coordLoc);
1263                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1264                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1265                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1266                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1267                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1268
1269                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1270                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1271
1272                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1273                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1274
1275                         gl.uniform1i(samplerLoc, 0);
1276                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1277
1278                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1279                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1280
1281                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
1282                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1283                 }),
1284                 MACRO_BLOCK({
1285                         if (stateId == 0)
1286                                 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
1287                         else if (stateId == 1)
1288                                 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[1]);
1289                         else
1290                                 DE_ASSERT(false);
1291                 })
1292         )
1293
1294         ADD_TESTCASE(bind_texture, "Change texture binding.",
1295                 true,
1296                 false,
1297                 MACRO_BLOCK({
1298                         requireCoordBuffers(1);
1299                         requireTextures(2);
1300                         requirePrograms(1);
1301
1302                         gl.useProgram(m_programs[0]->getProgram());
1303                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1304                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1305                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1306
1307                         gl.enableVertexAttribArray(coordLoc);
1308                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1309                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1310                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1311                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1312                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1313
1314                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1315                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1316
1317                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1318                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1319
1320                         gl.uniform1i(samplerLoc, 0);
1321                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1322
1323                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1324                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1325                 }),
1326                 MACRO_BLOCK({
1327                         if (stateId == 0)
1328                                 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1329                         else if (stateId == 1)
1330                                 gl.bindTexture(GL_TEXTURE_2D, m_textures[1]);
1331                         else
1332                                 DE_ASSERT(false);
1333                 })
1334         )
1335
1336         ADD_TESTCASE(use_program, "Change used program.",
1337                 true,
1338                 false,
1339                 MACRO_BLOCK({
1340                         requireCoordBuffers(1);
1341                         requireTextures(1);
1342                         requirePrograms(2);
1343
1344                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1345                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1346
1347                         gl.enableVertexAttribArray(coordLoc);
1348                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1349                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1350                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1351                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1352                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1353
1354                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1355                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1356
1357                         {
1358                                 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1359                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1360                                 gl.useProgram(m_programs[0]->getProgram());
1361                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1362                                 gl.uniform1i(samplerLoc, 0);
1363                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1364                         }
1365
1366                         {
1367                                 GLint samplerLoc = gl.getUniformLocation(m_programs[1]->getProgram(), "u_sampler");
1368                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1369                                 gl.useProgram(m_programs[1]->getProgram());
1370                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1371                                 gl.uniform1i(samplerLoc, 0);
1372                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1373                         }
1374
1375                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1376                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1377                 }),
1378                 MACRO_BLOCK({
1379                         if (stateId == 0)
1380                                 gl.useProgram(m_programs[0]->getProgram());
1381                         else if (stateId == 1)
1382                                 gl.useProgram(m_programs[1]->getProgram());
1383                         else
1384                                 DE_ASSERT(false);
1385                 })
1386         )
1387
1388         ADD_TESTCASE(tex_parameter_min_filter, "Change texture parameter min filter.",
1389                 true,
1390                 false,
1391                 MACRO_BLOCK({
1392                         requireCoordBuffers(1);
1393                         requireTextures(1);
1394                         requirePrograms(1);
1395
1396                         gl.useProgram(m_programs[0]->getProgram());
1397                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1398                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1399                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1400
1401                         gl.enableVertexAttribArray(coordLoc);
1402                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1403                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1404                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1405                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1406                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1407
1408                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1409                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1410
1411                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1412                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1413
1414                         gl.uniform1i(samplerLoc, 0);
1415                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1416
1417                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1418                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1419                 }),
1420                 MACRO_BLOCK({
1421                         if (stateId == 0)
1422                                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1423                         else if (stateId == 1)
1424                                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1425                         else
1426                                 DE_ASSERT(false);
1427                 })
1428         )
1429
1430         ADD_TESTCASE(tex_parameter_mag_filter, "Change texture parameter mag filter.",
1431                 true,
1432                 false,
1433                 MACRO_BLOCK({
1434                         requireCoordBuffers(1);
1435                         requireTextures(1);
1436                         requirePrograms(1);
1437
1438                         gl.useProgram(m_programs[0]->getProgram());
1439                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1440                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1441                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1442
1443                         gl.enableVertexAttribArray(coordLoc);
1444                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1445                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1446                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1447                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1448                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1449
1450                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1451                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1452
1453                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1454                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1455
1456                         gl.uniform1i(samplerLoc, 0);
1457                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1458
1459                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1460                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1461                 }),
1462                 MACRO_BLOCK({
1463                         if (stateId == 0)
1464                                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1465                         else if (stateId == 1)
1466                                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1467                         else
1468                                 DE_ASSERT(false);
1469                 })
1470         )
1471
1472         ADD_TESTCASE(tex_parameter_wrap, "Change texture parameter wrap filter.",
1473                 true,
1474                 false,
1475                 MACRO_BLOCK({
1476                         requireCoordBuffers(1);
1477                         requireTextures(1);
1478                         requirePrograms(1);
1479
1480                         gl.useProgram(m_programs[0]->getProgram());
1481                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1482                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1483                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1484
1485                         gl.enableVertexAttribArray(coordLoc);
1486                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1487                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1488                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1489                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1490                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1491
1492                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1493                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1494
1495                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1496                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1497
1498                         gl.uniform1i(samplerLoc, 0);
1499                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1500
1501                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1502                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1503                 }),
1504                 MACRO_BLOCK({
1505                         if (stateId == 0)
1506                                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1507                         else if (stateId == 1)
1508                                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1509                         else
1510                                 DE_ASSERT(false);
1511                 })
1512         )
1513
1514         ADD_TESTCASE(bind_framebuffer, "Change framebuffer.",
1515                 true,
1516                 false,
1517                 MACRO_BLOCK({
1518                         requireCoordBuffers(1);
1519                         requireTextures(1);
1520                         requireFramebuffers(2);
1521                         requirePrograms(1);
1522
1523                         gl.useProgram(m_programs[0]->getProgram());
1524                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1525                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1526                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1527
1528                         gl.enableVertexAttribArray(coordLoc);
1529                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1530                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1531                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1532                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1533                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1534
1535                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1536                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1537
1538                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1539                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1540
1541                         gl.uniform1i(samplerLoc, 0);
1542                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1543
1544                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1545                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1546
1547                         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
1548                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer()");
1549                 }),
1550                 MACRO_BLOCK({
1551                         if (stateId == 0)
1552                                 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
1553                         else if (stateId == 1)
1554                                 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[1]);
1555                         else
1556                                 DE_ASSERT(false);
1557                 })
1558         )
1559
1560         ADD_TESTCASE(blend_color, "Change blend color.",
1561                 true,
1562                 false,
1563                 MACRO_BLOCK({
1564                         requireCoordBuffers(1);
1565                         requireTextures(1);
1566                         requirePrograms(1);
1567
1568                         gl.useProgram(m_programs[0]->getProgram());
1569                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1570                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1571                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1572
1573                         gl.enableVertexAttribArray(coordLoc);
1574                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1575                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1576                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1577                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1578                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1579
1580                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1581                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1582
1583                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1584                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1585
1586                         gl.uniform1i(samplerLoc, 0);
1587                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1588
1589                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1590                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1591
1592                         gl.enable(GL_BLEND);
1593                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1594
1595                         gl.blendFunc(GL_CONSTANT_COLOR, GL_CONSTANT_COLOR);
1596                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBlendFunc()");
1597                 }),
1598                 MACRO_BLOCK({
1599                         if (stateId == 0)
1600                                 gl.blendColor(0.25f, 0.25f, 0.25f, 0.25f);
1601                         else if (stateId == 1)
1602                                 gl.blendColor(0.75f, 0.75f, 0.75f, 0.75f);
1603                         else
1604                                 DE_ASSERT(false);
1605                 })
1606         )
1607
1608         ADD_TESTCASE(sampler, "Change sampler binding.",
1609                 true,
1610                 false,
1611                 MACRO_BLOCK({
1612                         requireCoordBuffers(1);
1613                         requireTextures(1);
1614                         requirePrograms(1);
1615                         requireSamplers(2);
1616
1617                         gl.useProgram(m_programs[0]->getProgram());
1618                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1619                         GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1620                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1621
1622                         gl.enableVertexAttribArray(coordLoc);
1623                         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1624                         gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1625                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1626                         gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1627                         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1628
1629                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1630                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1631
1632                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1633                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1634
1635                         gl.uniform1i(samplerLoc, 0);
1636                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1637
1638                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1639                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1640
1641                         for (int ndx = 0; ndx < 2; ndx++)
1642                         {
1643                                 gl.bindSampler(0, m_samplers[ndx]);
1644                                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, ndx == 0 ? GL_NEAREST : GL_LINEAR);
1645                                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, ndx == 0 ? GL_LINEAR  : GL_NEAREST);
1646                                 GLU_EXPECT_NO_ERROR(gl.getError(), "Sampler setup");
1647                         }
1648                 }),
1649                 MACRO_BLOCK({
1650                         DE_ASSERT(de::inBounds(stateId, 0, 2));
1651                         gl.bindSampler(0, m_samplers[stateId]);
1652                 })
1653         )
1654
1655         ADD_TESTCASE(bind_vertex_array, "Change vertex array binding.",
1656                 true,
1657                 false,
1658                 MACRO_BLOCK({
1659                         requireCoordBuffers(2);
1660                         requireTextures(1);
1661                         requirePrograms(1);
1662                         requireVertexArrays(2);
1663
1664                         gl.bindAttribLocation(m_programs[0]->getProgram(), 0, "a_coord");
1665                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
1666                         gl.linkProgram(m_programs[0]->getProgram());
1667                         GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
1668
1669                         gl.useProgram(m_programs[0]->getProgram());
1670                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1671
1672                         for (int ndx = 0; ndx < 2; ndx++)
1673                         {
1674                                 gl.bindVertexArray(m_vertexArrays[ndx]);
1675                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray()");
1676                                 gl.enableVertexAttribArray(0);
1677                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1678                                 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[ndx]);
1679                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1680                                 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1681                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1682                         }
1683
1684                         GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1685                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1686
1687                         gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1688                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1689
1690                         gl.uniform1i(samplerLoc, 0);
1691                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1692
1693                         gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1694                         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1695                 }),
1696                 MACRO_BLOCK({
1697                         DE_ASSERT(de::inRange(stateId, 0, 2));
1698                         gl.bindVertexArray(m_vertexArrays[stateId]);
1699                 })
1700         )
1701 }
1702
1703 } // Performance
1704 } // gles3
1705 } // deqp