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,
52 const char *name, const char *description);
53 ~StateChangeCase(void);
54
55 protected:
56 virtual void renderTest(const glw::Functions &gl);
57 virtual void renderReference(const glw::Functions &gl);
58
59 virtual void changeState(const glw::Functions &gl, int stateId) = 0;
60 };
61
StateChangeCase(Context & context,int drawCallCount,int triangleCount,bool drawArrays,bool useIndexBuffer,const char * name,const char * description)62 StateChangeCase::StateChangeCase(Context &context, int drawCallCount, int triangleCount, bool drawArrays,
63 bool useIndexBuffer, const char *name, const char *description)
64 : gls::StateChangePerformanceCase(context.getTestContext(), context.getRenderContext(), name, description,
65 (useIndexBuffer ? DRAWTYPE_INDEXED_BUFFER :
66 drawArrays ? DRAWTYPE_NOT_INDEXED :
67 DRAWTYPE_INDEXED_USER_PTR),
68 drawCallCount, triangleCount)
69 {
70 DE_ASSERT(!useIndexBuffer || !drawArrays);
71 }
72
~StateChangeCase(void)73 StateChangeCase::~StateChangeCase(void)
74 {
75 }
76
renderTest(const glw::Functions & gl)77 void StateChangeCase::renderTest(const glw::Functions &gl)
78 {
79 for (int callNdx = 0; callNdx < m_callCount; callNdx++)
80 {
81 changeState(gl, 0);
82 callDraw(gl);
83
84 changeState(gl, 1);
85 callDraw(gl);
86 }
87 }
88
renderReference(const glw::Functions & gl)89 void StateChangeCase::renderReference(const glw::Functions &gl)
90 {
91 changeState(gl, 0);
92
93 for (int callNdx = 0; callNdx < m_callCount; callNdx++)
94 callDraw(gl);
95
96 changeState(gl, 1);
97
98 for (int callNdx = 0; callNdx < m_callCount; callNdx++)
99 callDraw(gl);
100 }
101
102 } // namespace
103
StateChangeTests(Context & context)104 StateChangeTests::StateChangeTests(Context &context)
105 : TestCaseGroup(context, "state_change_draw", "Test state change perfomance with draw calls.")
106 {
107 }
108
~StateChangeTests(void)109 StateChangeTests::~StateChangeTests(void)
110 {
111 }
112
113 #define MACRO_BLOCK(...) __VA_ARGS__
114
115 #define ADD_TESTCASE(NAME, DESC, DRAWARRAYS, INDEXBUFFER, INIT_FUNC, CHANGE_FUNC) \
116 do \
117 { \
118 class StateChangeCase_##NAME : public StateChangeCase \
119 { \
120 public: \
121 StateChangeCase_##NAME(Context &context, int drawCallCount, int triangleCount, const char *name, \
122 const char *description) \
123 : StateChangeCase(context, drawCallCount, triangleCount, (DRAWARRAYS), (INDEXBUFFER), name, \
124 description) \
125 { \
126 } \
127 virtual void setupInitialState(const glw::Functions &gl) \
128 { \
129 INIT_FUNC \
130 } \
131 virtual void changeState(const glw::Functions &gl, int stateId) \
132 { \
133 CHANGE_FUNC \
134 } \
135 }; \
136 manySmallCallsGroup->addChild(new StateChangeCase_##NAME(m_context, 1000, 2, #NAME, (DESC))); \
137 fewBigCallsGroup->addChild(new StateChangeCase_##NAME(m_context, 10, 200, #NAME, (DESC))); \
138 } while (0);
139
init(void)140 void StateChangeTests::init(void)
141 {
142 tcu::TestCaseGroup *const manySmallCallsGroup =
143 new tcu::TestCaseGroup(m_testCtx, "many_small_calls", "1000 calls, 2 triangles in each");
144 tcu::TestCaseGroup *const fewBigCallsGroup =
145 new tcu::TestCaseGroup(m_testCtx, "few_big_calls", "10 calls, 200 triangles in each");
146
147 addChild(manySmallCallsGroup);
148 addChild(fewBigCallsGroup);
149
150 ADD_TESTCASE(blend, "Enable/Disable blending.", true, false, MACRO_BLOCK({
151 requireCoordBuffers(1);
152 requireTextures(1);
153 requirePrograms(1);
154
155 gl.useProgram(m_programs[0]->getProgram());
156 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
157 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
158 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
159
160 gl.enableVertexAttribArray(coordLoc);
161 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
162 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
163 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
164 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
165 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
166
167 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
168 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
169
170 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
171 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
172
173 gl.uniform1i(samplerLoc, 0);
174 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
175
176 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
177 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
178 }),
179 MACRO_BLOCK({
180 if (stateId == 0)
181 gl.enable(GL_BLEND);
182 else if (stateId == 1)
183 gl.disable(GL_BLEND);
184 else
185 DE_ASSERT(false);
186 }))
187
188 ADD_TESTCASE(depth_test, "Enable/Disable depth test.", true, false, MACRO_BLOCK({
189 requireCoordBuffers(1);
190 requireTextures(1);
191 requirePrograms(1);
192
193 gl.useProgram(m_programs[0]->getProgram());
194 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
195
196 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
197 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
198
199 gl.enableVertexAttribArray(coordLoc);
200 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
201
202 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
203 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
204 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
205 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
206
207 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
208 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
209
210 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
211 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
212
213 gl.uniform1i(samplerLoc, 0);
214 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
215
216 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
217 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
218
219 gl.depthFunc(GL_LEQUAL);
220 GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthFunc()");
221 }),
222 MACRO_BLOCK({
223 if (stateId == 0)
224 gl.enable(GL_DEPTH_TEST);
225 else if (stateId == 1)
226 gl.disable(GL_DEPTH_TEST);
227 else
228 DE_ASSERT(false);
229 }))
230
231 ADD_TESTCASE(stencil_test, "Enable/Disable stencil test.", true, false, MACRO_BLOCK({
232 requireCoordBuffers(1);
233 requireTextures(1);
234 requirePrograms(1);
235
236 gl.useProgram(m_programs[0]->getProgram());
237 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
238 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
239 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
240
241 gl.enableVertexAttribArray(coordLoc);
242 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
243 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
244 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
245 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
246 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
247
248 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
249 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
250
251 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
252 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
253
254 gl.uniform1i(samplerLoc, 0);
255 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
256
257 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
258 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
259
260 gl.stencilFunc(GL_LEQUAL, 0, 0);
261 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
262
263 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
264 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
265
266 gl.clearStencil(0);
267 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
268 gl.clear(GL_STENCIL_BUFFER_BIT);
269
270 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
271 }),
272 MACRO_BLOCK({
273 if (stateId == 0)
274 gl.enable(GL_STENCIL_TEST);
275 else if (stateId == 1)
276 gl.disable(GL_STENCIL_TEST);
277 else
278 DE_ASSERT(false);
279 }))
280
281 ADD_TESTCASE(scissor_test, "Enable/Disable scissor test.", true, false, MACRO_BLOCK({
282 requireCoordBuffers(1);
283 requireTextures(1);
284 requirePrograms(1);
285
286 gl.useProgram(m_programs[0]->getProgram());
287 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
288 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
289 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
290
291 gl.enableVertexAttribArray(coordLoc);
292 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
293 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
294 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
295 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
296 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
297
298 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
299 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
300
301 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
302 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
303
304 gl.uniform1i(samplerLoc, 0);
305 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
306
307 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
308 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
309
310 gl.scissor(2, 3, 12, 13);
311 GLU_EXPECT_NO_ERROR(gl.getError(), "glScissor()");
312 }),
313 MACRO_BLOCK({
314 if (stateId == 0)
315 gl.enable(GL_SCISSOR_TEST);
316 else if (stateId == 1)
317 gl.disable(GL_SCISSOR_TEST);
318 else
319 DE_ASSERT(false);
320 }))
321
322 ADD_TESTCASE(dither, "Enable/Disable dithering.", true, false, MACRO_BLOCK({
323 requireCoordBuffers(1);
324 requireTextures(1);
325 requirePrograms(1);
326
327 gl.useProgram(m_programs[0]->getProgram());
328 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
329 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
330 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
331
332 gl.enableVertexAttribArray(coordLoc);
333 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
334 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
335 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
336 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
337 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
338
339 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
340 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
341
342 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
343 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
344
345 gl.uniform1i(samplerLoc, 0);
346 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
347
348 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
349 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
350 }),
351 MACRO_BLOCK({
352 if (stateId == 0)
353 gl.enable(GL_DITHER);
354 else if (stateId == 1)
355 gl.disable(GL_DITHER);
356 else
357 DE_ASSERT(false);
358 }))
359
360 ADD_TESTCASE(culling, "Enable/Disable culling.", true, false, MACRO_BLOCK({
361 requireCoordBuffers(1);
362 requireTextures(1);
363 requirePrograms(1);
364
365 gl.useProgram(m_programs[0]->getProgram());
366 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
367 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
368 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
369
370 gl.enableVertexAttribArray(coordLoc);
371 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
372 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
373 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
374 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
375 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
376
377 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
378 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
379
380 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
381 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
382
383 gl.uniform1i(samplerLoc, 0);
384 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
385
386 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
387 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
388
389 gl.frontFace(GL_CW);
390 GLU_EXPECT_NO_ERROR(gl.getError(), "glFrontFace()");
391
392 gl.cullFace(GL_FRONT);
393 GLU_EXPECT_NO_ERROR(gl.getError(), "glCullFace()");
394 }),
395 MACRO_BLOCK({
396 if (stateId == 0)
397 gl.enable(GL_CULL_FACE);
398 else if (stateId == 1)
399 gl.disable(GL_CULL_FACE);
400 else
401 DE_ASSERT(false);
402 }))
403
404 ADD_TESTCASE(depth_func, "Change depth func.", true, false, MACRO_BLOCK({
405 requireCoordBuffers(1);
406 requireTextures(1);
407 requirePrograms(1);
408
409 gl.useProgram(m_programs[0]->getProgram());
410 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
411 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
412 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
413
414 gl.enableVertexAttribArray(coordLoc);
415 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
416 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
417 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
418 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
419 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
420
421 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
422 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
423
424 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
425 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
426
427 gl.uniform1i(samplerLoc, 0);
428 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
429
430 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
431 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
432
433 gl.enable(GL_DEPTH_TEST);
434 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
435 }),
436 MACRO_BLOCK({
437 if (stateId == 0)
438 gl.depthFunc(GL_GEQUAL);
439 else if (stateId == 1)
440 gl.depthFunc(GL_LEQUAL);
441 else
442 DE_ASSERT(false);
443 }))
444
445 ADD_TESTCASE(depth_mask, "Toggle depth mask.", true, false, MACRO_BLOCK({
446 requireCoordBuffers(1);
447 requireTextures(1);
448 requirePrograms(1);
449
450 gl.useProgram(m_programs[0]->getProgram());
451 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
452 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
453 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
454
455 gl.enableVertexAttribArray(coordLoc);
456 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
457 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
458 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
459 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
460 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
461
462 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
463 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
464
465 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
466 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
467
468 gl.uniform1i(samplerLoc, 0);
469 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
470
471 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
472 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
473
474 gl.enable(GL_DEPTH_TEST);
475 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
476
477 gl.depthFunc(GL_LEQUAL);
478 GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthFunc()");
479 }),
480 MACRO_BLOCK({
481 if (stateId == 0)
482 gl.depthMask(GL_FALSE);
483 else if (stateId == 1)
484 gl.depthMask(GL_TRUE);
485 else
486 DE_ASSERT(false);
487 }))
488
489 ADD_TESTCASE(depth_rangef, "Change depth range.", true, false, MACRO_BLOCK({
490 requireCoordBuffers(1);
491 requireTextures(1);
492 requirePrograms(1);
493
494 gl.useProgram(m_programs[0]->getProgram());
495 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
496 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
497 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
498
499 gl.enableVertexAttribArray(coordLoc);
500 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
501 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
502 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
503 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
504 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
505
506 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
507 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
508
509 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
510 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
511
512 gl.uniform1i(samplerLoc, 0);
513 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
514
515 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
516 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
517 }),
518 MACRO_BLOCK({
519 if (stateId == 0)
520 gl.depthRangef(0.0f, 1.0f);
521 else if (stateId == 1)
522 gl.depthRangef(0.25f, 0.75f);
523 else
524 DE_ASSERT(false);
525 }))
526
527 ADD_TESTCASE(blend_equation, "Change blend equation.", true, false, MACRO_BLOCK({
528 requireCoordBuffers(1);
529 requireTextures(1);
530 requirePrograms(1);
531
532 gl.useProgram(m_programs[0]->getProgram());
533 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
534 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
535 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
536
537 gl.enableVertexAttribArray(coordLoc);
538 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
539 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
540 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
541 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
542 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
543
544 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
545 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
546
547 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
548 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
549
550 gl.uniform1i(samplerLoc, 0);
551 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
552
553 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
554 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
555
556 gl.enable(GL_BLEND);
557 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
558 }),
559 MACRO_BLOCK({
560 if (stateId == 0)
561 gl.blendEquation(GL_FUNC_SUBTRACT);
562 else if (stateId == 1)
563 gl.blendEquation(GL_FUNC_ADD);
564 else
565 DE_ASSERT(false);
566 }))
567
568 ADD_TESTCASE(blend_func, "Change blend function.", true, false, MACRO_BLOCK({
569 requireCoordBuffers(1);
570 requireTextures(1);
571 requirePrograms(1);
572
573 gl.useProgram(m_programs[0]->getProgram());
574 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
575 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
576 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
577
578 gl.enableVertexAttribArray(coordLoc);
579 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
580 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
581 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
582 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
583 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
584
585 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
586 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
587
588 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
589 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
590
591 gl.uniform1i(samplerLoc, 0);
592 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
593
594 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
595 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
596
597 gl.enable(GL_BLEND);
598 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
599 }),
600 MACRO_BLOCK({
601 if (stateId == 0)
602 gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
603 else if (stateId == 1)
604 gl.blendFunc(GL_ONE, GL_ONE);
605 else
606 DE_ASSERT(false);
607 }))
608
609 ADD_TESTCASE(polygon_offset, "Change polygon offset.", true, false, MACRO_BLOCK({
610 requireCoordBuffers(1);
611 requireTextures(1);
612 requirePrograms(1);
613
614 gl.useProgram(m_programs[0]->getProgram());
615 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
616 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
617 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
618
619 gl.enableVertexAttribArray(coordLoc);
620 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
621 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
622 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
623 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
624 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
625
626 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
627 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
628
629 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
630 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
631
632 gl.uniform1i(samplerLoc, 0);
633 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
634
635 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
636 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
637
638 gl.enable(GL_POLYGON_OFFSET_FILL);
639 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
640 }),
641 MACRO_BLOCK({
642 if (stateId == 0)
643 gl.polygonOffset(0.0f, 0.0f);
644 else if (stateId == 1)
645 gl.polygonOffset(0.1f, 0.1f);
646 else
647 DE_ASSERT(false);
648 }))
649
650 ADD_TESTCASE(sample_coverage, "Sample coverage.", true, false, MACRO_BLOCK({
651 requireCoordBuffers(1);
652 requireTextures(1);
653 requirePrograms(1);
654
655 gl.useProgram(m_programs[0]->getProgram());
656 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
657 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
658 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
659
660 gl.enableVertexAttribArray(coordLoc);
661 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
662 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
663 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
664 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
665 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
666
667 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
668 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
669
670 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
671 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
672
673 gl.uniform1i(samplerLoc, 0);
674 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
675
676 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
677 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
678 }),
679 MACRO_BLOCK({
680 if (stateId == 0)
681 gl.sampleCoverage(0.25f, GL_TRUE);
682 else if (stateId == 1)
683 gl.sampleCoverage(0.75f, GL_FALSE);
684 else
685 DE_ASSERT(false);
686 }))
687
688 ADD_TESTCASE(viewport, "Change viewport.", true, false, MACRO_BLOCK({
689 requireCoordBuffers(1);
690 requireTextures(1);
691 requirePrograms(1);
692
693 gl.useProgram(m_programs[0]->getProgram());
694 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
695 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
696 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
697
698 gl.enableVertexAttribArray(coordLoc);
699 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
700 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
701 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
702 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
703 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
704
705 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
706 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
707
708 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
709 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
710
711 gl.uniform1i(samplerLoc, 0);
712 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
713
714 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
715 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
716 }),
717 MACRO_BLOCK({
718 if (stateId == 0)
719 gl.viewport(10, 11, 5, 6);
720 else if (stateId == 1)
721 gl.viewport(2, 3, 17, 14);
722 else
723 DE_ASSERT(false);
724 }))
725
726 ADD_TESTCASE(scissor, "Change scissor box.", true, false, MACRO_BLOCK({
727 requireCoordBuffers(1);
728 requireTextures(1);
729 requirePrograms(1);
730
731 gl.useProgram(m_programs[0]->getProgram());
732 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
733 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
734 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
735
736 gl.enableVertexAttribArray(coordLoc);
737 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
738 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
739 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
740 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
741 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
742
743 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
744 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
745
746 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
747 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
748
749 gl.uniform1i(samplerLoc, 0);
750 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
751
752 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
753 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
754
755 gl.enable(GL_SCISSOR_TEST);
756 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
757 }),
758 MACRO_BLOCK({
759 if (stateId == 0)
760 gl.scissor(17, 13, 5, 8);
761 else if (stateId == 1)
762 gl.scissor(7, 3, 13, 13);
763 else
764 DE_ASSERT(false);
765 }))
766
767 ADD_TESTCASE(color_mask, "Change color mask.", true, false, MACRO_BLOCK({
768 requireCoordBuffers(1);
769 requireTextures(1);
770 requirePrograms(1);
771
772 gl.useProgram(m_programs[0]->getProgram());
773 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
774 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
775 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
776
777 gl.enableVertexAttribArray(coordLoc);
778 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
779 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
780 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
781 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
782 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
783
784 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
785 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
786
787 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
788 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
789
790 gl.uniform1i(samplerLoc, 0);
791 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
792
793 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
794 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
795 }),
796 MACRO_BLOCK({
797 if (stateId == 0)
798 gl.colorMask(GL_TRUE, GL_FALSE, GL_TRUE, GL_FALSE);
799 else if (stateId == 1)
800 gl.colorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE);
801 else
802 DE_ASSERT(false);
803 }))
804
805 ADD_TESTCASE(cull_face, "Change culling mode.", true, false, MACRO_BLOCK({
806 requireCoordBuffers(1);
807 requireTextures(1);
808 requirePrograms(1);
809
810 gl.useProgram(m_programs[0]->getProgram());
811 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
812 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
813 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
814
815 gl.enableVertexAttribArray(coordLoc);
816 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
817 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
818 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
819 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
820 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
821
822 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
823 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
824
825 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
826 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
827
828 gl.uniform1i(samplerLoc, 0);
829 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
830
831 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
832 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
833
834 gl.enable(GL_CULL_FACE);
835 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
836 }),
837 MACRO_BLOCK({
838 if (stateId == 0)
839 gl.cullFace(GL_FRONT);
840 else if (stateId == 1)
841 gl.cullFace(GL_BACK);
842 else
843 DE_ASSERT(false);
844 }))
845
846 ADD_TESTCASE(front_face, "Change front face.", true, false, MACRO_BLOCK({
847 requireCoordBuffers(1);
848 requireTextures(1);
849 requirePrograms(1);
850
851 gl.useProgram(m_programs[0]->getProgram());
852 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
853 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
854 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
855
856 gl.enableVertexAttribArray(coordLoc);
857 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
858 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
859 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
860 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
861 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
862
863 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
864 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
865
866 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
867 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
868
869 gl.uniform1i(samplerLoc, 0);
870 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
871
872 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
873 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
874
875 gl.enable(GL_CULL_FACE);
876 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
877 }),
878 MACRO_BLOCK({
879 if (stateId == 0)
880 gl.frontFace(GL_CCW);
881 else if (stateId == 1)
882 gl.frontFace(GL_CW);
883 else
884 DE_ASSERT(false);
885 }))
886
887 ADD_TESTCASE(stencil_mask, "Change stencil mask.", true, false, MACRO_BLOCK({
888 requireCoordBuffers(1);
889 requireTextures(1);
890 requirePrograms(1);
891
892 gl.useProgram(m_programs[0]->getProgram());
893 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
894 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
895 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
896
897 gl.enableVertexAttribArray(coordLoc);
898 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
899 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
900 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
901 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
902 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
903
904 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
905 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
906
907 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
908 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
909
910 gl.uniform1i(samplerLoc, 0);
911 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
912
913 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
914 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
915
916 gl.enable(GL_STENCIL_TEST);
917 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
918
919 gl.stencilFunc(GL_LEQUAL, 0, 0);
920 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
921
922 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
923 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
924
925 gl.clearStencil(0);
926 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
927 gl.clear(GL_STENCIL_BUFFER_BIT);
928 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
929 }),
930 MACRO_BLOCK({
931 if (stateId == 0)
932 gl.stencilMask(0xDD);
933 else if (stateId == 1)
934 gl.stencilMask(~0xDD);
935 else
936 DE_ASSERT(false);
937 }))
938
939 ADD_TESTCASE(stencil_func, "Change stencil func.", true, false, MACRO_BLOCK({
940 requireCoordBuffers(1);
941 requireTextures(1);
942 requirePrograms(1);
943
944 gl.useProgram(m_programs[0]->getProgram());
945 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
946 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
947 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
948
949 gl.enableVertexAttribArray(coordLoc);
950 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
951 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
952 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
953 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
954 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
955
956 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
957 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
958
959 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
960 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
961
962 gl.uniform1i(samplerLoc, 0);
963 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
964
965 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
966 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
967
968 gl.enable(GL_STENCIL_TEST);
969 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
970
971 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
972 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
973 gl.clearStencil(0);
974 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
975 gl.clear(GL_STENCIL_BUFFER_BIT);
976 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
977 }),
978 MACRO_BLOCK({
979 if (stateId == 0)
980 gl.stencilFunc(GL_LEQUAL, 0, 0xFF);
981 else if (stateId == 1)
982 gl.stencilFunc(GL_GEQUAL, 0, 0x00);
983 else
984 DE_ASSERT(false);
985 }))
986
987 ADD_TESTCASE(stencil_op, "Change stencil op.", true, false, MACRO_BLOCK({
988 requireCoordBuffers(1);
989 requireTextures(1);
990 requirePrograms(1);
991
992 gl.useProgram(m_programs[0]->getProgram());
993 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
994 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
995 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
996
997 gl.enableVertexAttribArray(coordLoc);
998 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
999 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1000 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1001 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1002 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1003
1004 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1005 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1006
1007 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1008 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1009
1010 gl.uniform1i(samplerLoc, 0);
1011 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1012
1013 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1014 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1015
1016 gl.enable(GL_STENCIL_TEST);
1017 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1018
1019 gl.stencilFunc(GL_LEQUAL, 0, 0);
1020 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
1021
1022 gl.clearStencil(0);
1023 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
1024
1025 gl.clear(GL_STENCIL_BUFFER_BIT);
1026 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
1027 }),
1028 MACRO_BLOCK({
1029 if (stateId == 0)
1030 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
1031 else if (stateId == 1)
1032 gl.stencilOp(GL_REPLACE, GL_KEEP, GL_KEEP);
1033 else
1034 DE_ASSERT(false);
1035 }))
1036
1037 ADD_TESTCASE(bind_array_buffer, "Change array buffer and refresh vertex attrib pointer.", true, false, MACRO_BLOCK({
1038 requireCoordBuffers(2);
1039 requireTextures(1);
1040 requirePrograms(1);
1041
1042 gl.bindAttribLocation(m_programs[0]->getProgram(), 0, "a_coord");
1043 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
1044 gl.linkProgram(m_programs[0]->getProgram());
1045 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
1046
1047 gl.useProgram(m_programs[0]->getProgram());
1048 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1049
1050 gl.enableVertexAttribArray(0);
1051 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1052 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1053 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1054 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1055 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1056
1057 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1058 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1059
1060 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1061 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1062
1063 gl.uniform1i(samplerLoc, 0);
1064 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1065
1066 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1067 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1068 }),
1069 MACRO_BLOCK({
1070 if (stateId == 0)
1071 {
1072 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1073 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1074 }
1075 else if (stateId == 1)
1076 {
1077 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[1]);
1078 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1079 }
1080 else
1081 DE_ASSERT(false);
1082 }))
1083
1084 ADD_TESTCASE(element_array_buffer, "Change element array buffer.", false, true, MACRO_BLOCK({
1085 requireCoordBuffers(1);
1086 requireIndexBuffers(2);
1087 requireTextures(1);
1088 requirePrograms(1);
1089
1090 gl.useProgram(m_programs[0]->getProgram());
1091 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1092 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1093 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1094
1095 gl.enableVertexAttribArray(coordLoc);
1096 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1097 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1098 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1099 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1100 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1101
1102 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1103 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1104
1105 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1106 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1107
1108 gl.uniform1i(samplerLoc, 0);
1109 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1110
1111 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1112 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1113
1114 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
1115 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1116 }),
1117 MACRO_BLOCK({
1118 if (stateId == 0)
1119 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
1120 else if (stateId == 1)
1121 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[1]);
1122 else
1123 DE_ASSERT(false);
1124 }))
1125
1126 ADD_TESTCASE(bind_texture, "Change texture binding.", true, false, MACRO_BLOCK({
1127 requireCoordBuffers(1);
1128 requireTextures(2);
1129 requirePrograms(1);
1130
1131 gl.useProgram(m_programs[0]->getProgram());
1132 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1133 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1134 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1135
1136 gl.enableVertexAttribArray(coordLoc);
1137 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1138 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1139 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1140 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1141 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1142
1143 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1144 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1145
1146 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1147 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1148
1149 gl.uniform1i(samplerLoc, 0);
1150 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1151
1152 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1153 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1154 }),
1155 MACRO_BLOCK({
1156 if (stateId == 0)
1157 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1158 else if (stateId == 1)
1159 gl.bindTexture(GL_TEXTURE_2D, m_textures[1]);
1160 else
1161 DE_ASSERT(false);
1162 }))
1163
1164 ADD_TESTCASE(use_program, "Change used program.", true, false, MACRO_BLOCK({
1165 requireCoordBuffers(1);
1166 requireTextures(1);
1167 requirePrograms(2);
1168
1169 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1170 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1171
1172 gl.enableVertexAttribArray(coordLoc);
1173 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1174 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1175 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1176 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1177 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1178
1179 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1180 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1181
1182 {
1183 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1184 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1185 gl.useProgram(m_programs[0]->getProgram());
1186 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1187 gl.uniform1i(samplerLoc, 0);
1188 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1189 }
1190
1191 {
1192 GLint samplerLoc = gl.getUniformLocation(m_programs[1]->getProgram(), "u_sampler");
1193 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1194 gl.useProgram(m_programs[1]->getProgram());
1195 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1196 gl.uniform1i(samplerLoc, 0);
1197 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1198 }
1199
1200 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1201 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1202 }),
1203 MACRO_BLOCK({
1204 if (stateId == 0)
1205 gl.useProgram(m_programs[0]->getProgram());
1206 else if (stateId == 1)
1207 gl.useProgram(m_programs[1]->getProgram());
1208 else
1209 DE_ASSERT(false);
1210 }))
1211
1212 ADD_TESTCASE(tex_parameter_min_filter, "Change texture parameter min filter.", true, false, MACRO_BLOCK({
1213 requireCoordBuffers(1);
1214 requireTextures(1);
1215 requirePrograms(1);
1216
1217 gl.useProgram(m_programs[0]->getProgram());
1218 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1219 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1220 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1221
1222 gl.enableVertexAttribArray(coordLoc);
1223 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1224 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1225 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1226 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1227 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1228
1229 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1230 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1231
1232 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1233 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1234
1235 gl.uniform1i(samplerLoc, 0);
1236 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1237
1238 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1239 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1240 }),
1241 MACRO_BLOCK({
1242 if (stateId == 0)
1243 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1244 else if (stateId == 1)
1245 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1246 else
1247 DE_ASSERT(false);
1248 }))
1249
1250 ADD_TESTCASE(tex_parameter_mag_filter, "Change texture parameter mag filter.", true, false, MACRO_BLOCK({
1251 requireCoordBuffers(1);
1252 requireTextures(1);
1253 requirePrograms(1);
1254
1255 gl.useProgram(m_programs[0]->getProgram());
1256 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1257 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1258 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1259
1260 gl.enableVertexAttribArray(coordLoc);
1261 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1262 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1263 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1264 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1265 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1266
1267 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1268 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1269
1270 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1271 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1272
1273 gl.uniform1i(samplerLoc, 0);
1274 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1275
1276 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1277 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1278 }),
1279 MACRO_BLOCK({
1280 if (stateId == 0)
1281 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1282 else if (stateId == 1)
1283 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1284 else
1285 DE_ASSERT(false);
1286 }))
1287
1288 ADD_TESTCASE(tex_parameter_wrap, "Change texture parameter wrap filter.", true, false, MACRO_BLOCK({
1289 requireCoordBuffers(1);
1290 requireTextures(1);
1291 requirePrograms(1);
1292
1293 gl.useProgram(m_programs[0]->getProgram());
1294 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1295 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1296 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1297
1298 gl.enableVertexAttribArray(coordLoc);
1299 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1300 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1301 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1302 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1303 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1304
1305 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1306 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1307
1308 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1309 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1310
1311 gl.uniform1i(samplerLoc, 0);
1312 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1313
1314 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1315 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1316 }),
1317 MACRO_BLOCK({
1318 if (stateId == 0)
1319 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1320 else if (stateId == 1)
1321 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1322 else
1323 DE_ASSERT(false);
1324 }))
1325
1326 ADD_TESTCASE(bind_framebuffer, "Change framebuffer.", true, false, MACRO_BLOCK({
1327 requireCoordBuffers(1);
1328 requireTextures(1);
1329 requireFramebuffers(2);
1330 requirePrograms(1);
1331
1332 gl.useProgram(m_programs[0]->getProgram());
1333 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1334 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1335 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1336
1337 gl.enableVertexAttribArray(coordLoc);
1338 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1339 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1340 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1341 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1342 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1343
1344 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1345 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1346
1347 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1348 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1349
1350 gl.uniform1i(samplerLoc, 0);
1351 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1352
1353 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1354 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1355
1356 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
1357 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer()");
1358 }),
1359 MACRO_BLOCK({
1360 if (stateId == 0)
1361 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
1362 else if (stateId == 1)
1363 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[1]);
1364 else
1365 DE_ASSERT(false);
1366 }))
1367
1368 ADD_TESTCASE(blend_color, "Change blend color.", true, false, MACRO_BLOCK({
1369 requireCoordBuffers(1);
1370 requireTextures(1);
1371 requirePrograms(1);
1372
1373 gl.useProgram(m_programs[0]->getProgram());
1374 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1375 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1376 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1377
1378 gl.enableVertexAttribArray(coordLoc);
1379 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1380 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1381 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1382 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1383 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1384
1385 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1386 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1387
1388 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1389 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1390
1391 gl.uniform1i(samplerLoc, 0);
1392 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1393
1394 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1395 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1396
1397 gl.enable(GL_BLEND);
1398 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1399
1400 gl.blendFunc(GL_CONSTANT_COLOR, GL_CONSTANT_COLOR);
1401 GLU_EXPECT_NO_ERROR(gl.getError(), "glBlendFunc()");
1402 }),
1403 MACRO_BLOCK({
1404 if (stateId == 0)
1405 gl.blendColor(0.25f, 0.25f, 0.25f, 0.25f);
1406 else if (stateId == 1)
1407 gl.blendColor(0.75f, 0.75f, 0.75f, 0.75f);
1408 else
1409 DE_ASSERT(false);
1410 }))
1411 }
1412
1413 } // namespace Performance
1414 } // namespace gles2
1415 } // namespace deqp
1416