1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 2.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 "es2pStateChangeTests.hpp"
25 #include "glsStateChangePerfTestCases.hpp"
26 #include "gluShaderProgram.hpp"
27 #include "glwFunctions.hpp"
28 #include "glwEnums.hpp"
29
30 namespace deqp
31 {
32 namespace gles2
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
StateChangeCase(Context & context,int drawCallCount,int triangleCount,bool drawArrays,bool useIndexBuffer,const char * name,const char * description)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
~StateChangeCase(void)70 StateChangeCase::~StateChangeCase (void)
71 {
72 }
73
renderTest(const glw::Functions & gl)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
renderReference(const glw::Functions & gl)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
StateChangeTests(Context & context)101 StateChangeTests::StateChangeTests (Context& context)
102 : TestCaseGroup(context, "state_change_draw", "Test state change perfomance with draw calls.")
103 {
104 }
105
~StateChangeTests(void)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
init(void)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(depth_func, "Change depth func.",
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 gl.enable(GL_DEPTH_TEST);
452 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
453 }),
454 MACRO_BLOCK({
455 if (stateId == 0)
456 gl.depthFunc(GL_GEQUAL);
457 else if (stateId == 1)
458 gl.depthFunc(GL_LEQUAL);
459 else
460 DE_ASSERT(false);
461 })
462 )
463
464
465 ADD_TESTCASE(depth_mask, "Toggle depth mask.",
466 true,
467 false,
468 MACRO_BLOCK({
469 requireCoordBuffers(1);
470 requireTextures(1);
471 requirePrograms(1);
472
473 gl.useProgram(m_programs[0]->getProgram());
474 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
475 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
476 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
477
478 gl.enableVertexAttribArray(coordLoc);
479 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
480 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
481 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
482 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
483 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
484
485 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
486 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
487
488 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
489 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
490
491 gl.uniform1i(samplerLoc, 0);
492 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
493
494 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
495 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
496
497 gl.enable(GL_DEPTH_TEST);
498 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
499
500 gl.depthFunc(GL_LEQUAL);
501 GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthFunc()");
502 }),
503 MACRO_BLOCK({
504 if (stateId == 0)
505 gl.depthMask(GL_FALSE);
506 else if (stateId == 1)
507 gl.depthMask(GL_TRUE);
508 else
509 DE_ASSERT(false);
510 })
511 )
512
513 ADD_TESTCASE(depth_rangef, "Change depth range.",
514 true,
515 false,
516 MACRO_BLOCK({
517 requireCoordBuffers(1);
518 requireTextures(1);
519 requirePrograms(1);
520
521 gl.useProgram(m_programs[0]->getProgram());
522 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
523 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
524 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
525
526 gl.enableVertexAttribArray(coordLoc);
527 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
528 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
529 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
530 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
531 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
532
533 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
534 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
535
536 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
537 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
538
539 gl.uniform1i(samplerLoc, 0);
540 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
541
542 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
543 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
544 }),
545 MACRO_BLOCK({
546 if (stateId == 0)
547 gl.depthRangef(0.0f, 1.0f);
548 else if (stateId == 1)
549 gl.depthRangef(0.25f, 0.75f);
550 else
551 DE_ASSERT(false);
552 })
553 )
554
555 ADD_TESTCASE(blend_equation, "Change blend equation.",
556 true,
557 false,
558 MACRO_BLOCK({
559 requireCoordBuffers(1);
560 requireTextures(1);
561 requirePrograms(1);
562
563 gl.useProgram(m_programs[0]->getProgram());
564 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
565 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
566 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
567
568 gl.enableVertexAttribArray(coordLoc);
569 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
570 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
571 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
572 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
573 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
574
575 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
576 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
577
578 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
579 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
580
581 gl.uniform1i(samplerLoc, 0);
582 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
583
584 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
585 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
586
587 gl.enable(GL_BLEND);
588 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
589 }),
590 MACRO_BLOCK({
591 if (stateId == 0)
592 gl.blendEquation(GL_FUNC_SUBTRACT);
593 else if (stateId == 1)
594 gl.blendEquation(GL_FUNC_ADD);
595 else
596 DE_ASSERT(false);
597 })
598 )
599
600 ADD_TESTCASE(blend_func, "Change blend function.",
601 true,
602 false,
603 MACRO_BLOCK({
604 requireCoordBuffers(1);
605 requireTextures(1);
606 requirePrograms(1);
607
608 gl.useProgram(m_programs[0]->getProgram());
609 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
610 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
611 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
612
613 gl.enableVertexAttribArray(coordLoc);
614 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
615 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
616 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
617 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
618 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
619
620 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
621 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
622
623 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
624 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
625
626 gl.uniform1i(samplerLoc, 0);
627 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
628
629 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
630 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
631
632 gl.enable(GL_BLEND);
633 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
634 }),
635 MACRO_BLOCK({
636 if (stateId == 0)
637 gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
638 else if (stateId == 1)
639 gl.blendFunc(GL_ONE, GL_ONE);
640 else
641 DE_ASSERT(false);
642 })
643 )
644
645 ADD_TESTCASE(polygon_offset, "Change polygon offset.",
646 true,
647 false,
648 MACRO_BLOCK({
649 requireCoordBuffers(1);
650 requireTextures(1);
651 requirePrograms(1);
652
653 gl.useProgram(m_programs[0]->getProgram());
654 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
655 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
656 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
657
658 gl.enableVertexAttribArray(coordLoc);
659 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
660 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
661 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
662 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
663 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
664
665 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
666 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
667
668 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
669 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
670
671 gl.uniform1i(samplerLoc, 0);
672 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
673
674 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
675 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
676
677 gl.enable(GL_POLYGON_OFFSET_FILL);
678 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
679 }),
680 MACRO_BLOCK({
681 if (stateId == 0)
682 gl.polygonOffset(0.0f, 0.0f);
683 else if (stateId == 1)
684 gl.polygonOffset(0.1f, 0.1f);
685 else
686 DE_ASSERT(false);
687 })
688 )
689
690 ADD_TESTCASE(sample_coverage, "Sample coverage.",
691 true,
692 false,
693 MACRO_BLOCK({
694 requireCoordBuffers(1);
695 requireTextures(1);
696 requirePrograms(1);
697
698 gl.useProgram(m_programs[0]->getProgram());
699 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
700 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
701 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
702
703 gl.enableVertexAttribArray(coordLoc);
704 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
705 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
706 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
707 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
708 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
709
710 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
711 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
712
713 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
714 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
715
716 gl.uniform1i(samplerLoc, 0);
717 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
718
719 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
720 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
721 }),
722 MACRO_BLOCK({
723 if (stateId == 0)
724 gl.sampleCoverage(0.25f, GL_TRUE);
725 else if (stateId == 1)
726 gl.sampleCoverage(0.75f, GL_FALSE);
727 else
728 DE_ASSERT(false);
729 })
730 )
731
732 ADD_TESTCASE(viewport, "Change viewport.",
733 true,
734 false,
735 MACRO_BLOCK({
736 requireCoordBuffers(1);
737 requireTextures(1);
738 requirePrograms(1);
739
740 gl.useProgram(m_programs[0]->getProgram());
741 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
742 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
743 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
744
745 gl.enableVertexAttribArray(coordLoc);
746 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
747 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
748 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
749 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
750 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
751
752 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
753 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
754
755 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
756 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
757
758 gl.uniform1i(samplerLoc, 0);
759 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
760
761 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
762 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
763 }),
764 MACRO_BLOCK({
765 if (stateId == 0)
766 gl.viewport(10, 11, 5, 6);
767 else if (stateId == 1)
768 gl.viewport(2, 3, 17, 14);
769 else
770 DE_ASSERT(false);
771 })
772 )
773
774 ADD_TESTCASE(scissor, "Change scissor box.",
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 gl.enable(GL_SCISSOR_TEST);
807 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
808 }),
809 MACRO_BLOCK({
810 if (stateId == 0)
811 gl.scissor(17, 13, 5, 8);
812 else if (stateId == 1)
813 gl.scissor(7, 3, 13, 13);
814 else
815 DE_ASSERT(false);
816 })
817 )
818
819 ADD_TESTCASE(color_mask, "Change color mask.",
820 true,
821 false,
822 MACRO_BLOCK({
823 requireCoordBuffers(1);
824 requireTextures(1);
825 requirePrograms(1);
826
827 gl.useProgram(m_programs[0]->getProgram());
828 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
829 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
830 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
831
832 gl.enableVertexAttribArray(coordLoc);
833 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
834 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
835 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
836 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
837 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
838
839 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
840 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
841
842 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
843 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
844
845 gl.uniform1i(samplerLoc, 0);
846 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
847
848 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
849 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
850 }),
851 MACRO_BLOCK({
852 if (stateId == 0)
853 gl.colorMask(GL_TRUE, GL_FALSE, GL_TRUE, GL_FALSE);
854 else if (stateId == 1)
855 gl.colorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE);
856 else
857 DE_ASSERT(false);
858 })
859 )
860
861 ADD_TESTCASE(cull_face, "Change culling mode.",
862 true,
863 false,
864 MACRO_BLOCK({
865 requireCoordBuffers(1);
866 requireTextures(1);
867 requirePrograms(1);
868
869 gl.useProgram(m_programs[0]->getProgram());
870 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
871 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
872 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
873
874 gl.enableVertexAttribArray(coordLoc);
875 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
876 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
877 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
878 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
879 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
880
881 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
882 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
883
884 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
885 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
886
887 gl.uniform1i(samplerLoc, 0);
888 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
889
890 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
891 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
892
893 gl.enable(GL_CULL_FACE);
894 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
895 }),
896 MACRO_BLOCK({
897 if (stateId == 0)
898 gl.cullFace(GL_FRONT);
899 else if (stateId == 1)
900 gl.cullFace(GL_BACK);
901 else
902 DE_ASSERT(false);
903 })
904 )
905
906 ADD_TESTCASE(front_face, "Change front face.",
907 true,
908 false,
909 MACRO_BLOCK({
910 requireCoordBuffers(1);
911 requireTextures(1);
912 requirePrograms(1);
913
914 gl.useProgram(m_programs[0]->getProgram());
915 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
916 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
917 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
918
919 gl.enableVertexAttribArray(coordLoc);
920 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
921 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
922 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
923 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
924 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
925
926 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
927 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
928
929 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
930 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
931
932 gl.uniform1i(samplerLoc, 0);
933 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
934
935 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
936 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
937
938 gl.enable(GL_CULL_FACE);
939 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
940 }),
941 MACRO_BLOCK({
942 if (stateId == 0)
943 gl.frontFace(GL_CCW);
944 else if (stateId == 1)
945 gl.frontFace(GL_CW);
946 else
947 DE_ASSERT(false);
948 })
949 )
950
951 ADD_TESTCASE(stencil_mask, "Change stencil mask.",
952 true,
953 false,
954 MACRO_BLOCK({
955 requireCoordBuffers(1);
956 requireTextures(1);
957 requirePrograms(1);
958
959 gl.useProgram(m_programs[0]->getProgram());
960 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
961 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
962 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
963
964 gl.enableVertexAttribArray(coordLoc);
965 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
966 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
967 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
968 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
969 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
970
971 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
972 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
973
974 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
975 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
976
977 gl.uniform1i(samplerLoc, 0);
978 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
979
980 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
981 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
982
983 gl.enable(GL_STENCIL_TEST);
984 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
985
986 gl.stencilFunc(GL_LEQUAL, 0, 0);
987 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
988
989 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
990 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
991
992 gl.clearStencil(0);
993 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
994 gl.clear(GL_STENCIL_BUFFER_BIT);
995 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
996 }),
997 MACRO_BLOCK({
998 if (stateId == 0)
999 gl.stencilMask(0xDD);
1000 else if (stateId == 1)
1001 gl.stencilMask(~0xDD);
1002 else
1003 DE_ASSERT(false);
1004 })
1005 )
1006
1007 ADD_TESTCASE(stencil_func, "Change stencil func.",
1008 true,
1009 false,
1010 MACRO_BLOCK({
1011 requireCoordBuffers(1);
1012 requireTextures(1);
1013 requirePrograms(1);
1014
1015 gl.useProgram(m_programs[0]->getProgram());
1016 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1017 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1018 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1019
1020 gl.enableVertexAttribArray(coordLoc);
1021 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1022 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1023 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1024 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1025 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1026
1027 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1028 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1029
1030 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1031 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1032
1033 gl.uniform1i(samplerLoc, 0);
1034 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1035
1036 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1037 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1038
1039 gl.enable(GL_STENCIL_TEST);
1040 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1041
1042 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
1043 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
1044 gl.clearStencil(0);
1045 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
1046 gl.clear(GL_STENCIL_BUFFER_BIT);
1047 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
1048 }),
1049 MACRO_BLOCK({
1050 if (stateId == 0)
1051 gl.stencilFunc(GL_LEQUAL, 0, 0xFF);
1052 else if (stateId == 1)
1053 gl.stencilFunc(GL_GEQUAL, 0, 0x00);
1054 else
1055 DE_ASSERT(false);
1056 })
1057 )
1058
1059 ADD_TESTCASE(stencil_op, "Change stencil op.",
1060 true,
1061 false,
1062 MACRO_BLOCK({
1063 requireCoordBuffers(1);
1064 requireTextures(1);
1065 requirePrograms(1);
1066
1067 gl.useProgram(m_programs[0]->getProgram());
1068 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1069 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1070 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1071
1072 gl.enableVertexAttribArray(coordLoc);
1073 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1074 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1075 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1076 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1077 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1078
1079 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1080 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1081
1082 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1083 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1084
1085 gl.uniform1i(samplerLoc, 0);
1086 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1087
1088 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1089 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1090
1091 gl.enable(GL_STENCIL_TEST);
1092 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1093
1094 gl.stencilFunc(GL_LEQUAL, 0, 0);
1095 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
1096
1097 gl.clearStencil(0);
1098 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
1099
1100 gl.clear(GL_STENCIL_BUFFER_BIT);
1101 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
1102 }),
1103 MACRO_BLOCK({
1104 if (stateId == 0)
1105 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
1106 else if (stateId == 1)
1107 gl.stencilOp(GL_REPLACE, GL_KEEP, GL_KEEP);
1108 else
1109 DE_ASSERT(false);
1110 })
1111 )
1112
1113 ADD_TESTCASE(bind_array_buffer, "Change array buffer and refresh vertex attrib pointer.",
1114 true,
1115 false,
1116 MACRO_BLOCK({
1117 requireCoordBuffers(2);
1118 requireTextures(1);
1119 requirePrograms(1);
1120
1121 gl.bindAttribLocation(m_programs[0]->getProgram(), 0, "a_coord");
1122 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
1123 gl.linkProgram(m_programs[0]->getProgram());
1124 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
1125
1126 gl.useProgram(m_programs[0]->getProgram());
1127 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1128
1129 gl.enableVertexAttribArray(0);
1130 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1131 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1132 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1133 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1134 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1135
1136 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1137 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1138
1139 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1140 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1141
1142 gl.uniform1i(samplerLoc, 0);
1143 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1144
1145 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1146 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1147 }),
1148 MACRO_BLOCK({
1149 if (stateId == 0)
1150 {
1151 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1152 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1153 }
1154 else if (stateId == 1)
1155 {
1156 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[1]);
1157 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1158 }
1159 else
1160 DE_ASSERT(false);
1161 })
1162 )
1163
1164 ADD_TESTCASE(element_array_buffer, "Change element array buffer.",
1165 false,
1166 true,
1167 MACRO_BLOCK({
1168 requireCoordBuffers(1);
1169 requireIndexBuffers(2);
1170 requireTextures(1);
1171 requirePrograms(1);
1172
1173 gl.useProgram(m_programs[0]->getProgram());
1174 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1175 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1176 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1177
1178 gl.enableVertexAttribArray(coordLoc);
1179 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1180 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1181 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1182 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1183 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1184
1185 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1186 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1187
1188 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1189 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1190
1191 gl.uniform1i(samplerLoc, 0);
1192 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1193
1194 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1195 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1196
1197 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
1198 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1199 }),
1200 MACRO_BLOCK({
1201 if (stateId == 0)
1202 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
1203 else if (stateId == 1)
1204 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[1]);
1205 else
1206 DE_ASSERT(false);
1207 })
1208 )
1209
1210 ADD_TESTCASE(bind_texture, "Change texture binding.",
1211 true,
1212 false,
1213 MACRO_BLOCK({
1214 requireCoordBuffers(1);
1215 requireTextures(2);
1216 requirePrograms(1);
1217
1218 gl.useProgram(m_programs[0]->getProgram());
1219 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1220 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1221 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1222
1223 gl.enableVertexAttribArray(coordLoc);
1224 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1225 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1226 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1227 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1228 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1229
1230 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1231 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1232
1233 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1234 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1235
1236 gl.uniform1i(samplerLoc, 0);
1237 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1238
1239 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1240 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1241 }),
1242 MACRO_BLOCK({
1243 if (stateId == 0)
1244 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1245 else if (stateId == 1)
1246 gl.bindTexture(GL_TEXTURE_2D, m_textures[1]);
1247 else
1248 DE_ASSERT(false);
1249 })
1250 )
1251
1252 ADD_TESTCASE(use_program, "Change used program.",
1253 true,
1254 false,
1255 MACRO_BLOCK({
1256 requireCoordBuffers(1);
1257 requireTextures(1);
1258 requirePrograms(2);
1259
1260 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1261 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1262
1263 gl.enableVertexAttribArray(coordLoc);
1264 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1265 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1266 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1267 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1268 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1269
1270 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1271 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1272
1273 {
1274 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1275 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1276 gl.useProgram(m_programs[0]->getProgram());
1277 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1278 gl.uniform1i(samplerLoc, 0);
1279 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1280 }
1281
1282 {
1283 GLint samplerLoc = gl.getUniformLocation(m_programs[1]->getProgram(), "u_sampler");
1284 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1285 gl.useProgram(m_programs[1]->getProgram());
1286 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1287 gl.uniform1i(samplerLoc, 0);
1288 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1289 }
1290
1291 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1292 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1293 }),
1294 MACRO_BLOCK({
1295 if (stateId == 0)
1296 gl.useProgram(m_programs[0]->getProgram());
1297 else if (stateId == 1)
1298 gl.useProgram(m_programs[1]->getProgram());
1299 else
1300 DE_ASSERT(false);
1301 })
1302 )
1303
1304 ADD_TESTCASE(tex_parameter_min_filter, "Change texture parameter min filter.",
1305 true,
1306 false,
1307 MACRO_BLOCK({
1308 requireCoordBuffers(1);
1309 requireTextures(1);
1310 requirePrograms(1);
1311
1312 gl.useProgram(m_programs[0]->getProgram());
1313 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1314 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1315 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1316
1317 gl.enableVertexAttribArray(coordLoc);
1318 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1319 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1320 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1321 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1322 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1323
1324 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1325 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1326
1327 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1328 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1329
1330 gl.uniform1i(samplerLoc, 0);
1331 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1332
1333 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1334 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1335 }),
1336 MACRO_BLOCK({
1337 if (stateId == 0)
1338 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1339 else if (stateId == 1)
1340 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1341 else
1342 DE_ASSERT(false);
1343 })
1344 )
1345
1346 ADD_TESTCASE(tex_parameter_mag_filter, "Change texture parameter mag filter.",
1347 true,
1348 false,
1349 MACRO_BLOCK({
1350 requireCoordBuffers(1);
1351 requireTextures(1);
1352 requirePrograms(1);
1353
1354 gl.useProgram(m_programs[0]->getProgram());
1355 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1356 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1357 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1358
1359 gl.enableVertexAttribArray(coordLoc);
1360 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1361 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1362 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1363 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1364 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1365
1366 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1367 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1368
1369 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1370 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1371
1372 gl.uniform1i(samplerLoc, 0);
1373 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
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.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1381 else if (stateId == 1)
1382 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1383 else
1384 DE_ASSERT(false);
1385 })
1386 )
1387
1388 ADD_TESTCASE(tex_parameter_wrap, "Change texture parameter wrap 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_WRAP_S, GL_REPEAT);
1423 else if (stateId == 1)
1424 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1425 else
1426 DE_ASSERT(false);
1427 })
1428 )
1429
1430 ADD_TESTCASE(bind_framebuffer, "Change framebuffer.",
1431 true,
1432 false,
1433 MACRO_BLOCK({
1434 requireCoordBuffers(1);
1435 requireTextures(1);
1436 requireFramebuffers(2);
1437 requirePrograms(1);
1438
1439 gl.useProgram(m_programs[0]->getProgram());
1440 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1441 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1442 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1443
1444 gl.enableVertexAttribArray(coordLoc);
1445 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1446 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1447 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1448 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1449 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1450
1451 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1452 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1453
1454 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1455 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1456
1457 gl.uniform1i(samplerLoc, 0);
1458 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1459
1460 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1461 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1462
1463 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
1464 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer()");
1465 }),
1466 MACRO_BLOCK({
1467 if (stateId == 0)
1468 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
1469 else if (stateId == 1)
1470 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[1]);
1471 else
1472 DE_ASSERT(false);
1473 })
1474 )
1475
1476 ADD_TESTCASE(blend_color, "Change blend color.",
1477 true,
1478 false,
1479 MACRO_BLOCK({
1480 requireCoordBuffers(1);
1481 requireTextures(1);
1482 requirePrograms(1);
1483
1484 gl.useProgram(m_programs[0]->getProgram());
1485 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1486 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1487 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1488
1489 gl.enableVertexAttribArray(coordLoc);
1490 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1491 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1492 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1493 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1494 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1495
1496 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1497 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1498
1499 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1500 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1501
1502 gl.uniform1i(samplerLoc, 0);
1503 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1504
1505 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1506 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1507
1508 gl.enable(GL_BLEND);
1509 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1510
1511 gl.blendFunc(GL_CONSTANT_COLOR, GL_CONSTANT_COLOR);
1512 GLU_EXPECT_NO_ERROR(gl.getError(), "glBlendFunc()");
1513 }),
1514 MACRO_BLOCK({
1515 if (stateId == 0)
1516 gl.blendColor(0.25f, 0.25f, 0.25f, 0.25f);
1517 else if (stateId == 1)
1518 gl.blendColor(0.75f, 0.75f, 0.75f, 0.75f);
1519 else
1520 DE_ASSERT(false);
1521 })
1522 )
1523 }
1524
1525 } // Performance
1526 } // gles2
1527 } // deqp
1528