1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.0 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief State change performance tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es3pStateChangeTests.hpp"
25 #include "glsStateChangePerfTestCases.hpp"
26 #include "gluShaderProgram.hpp"
27 #include "glwFunctions.hpp"
28 #include "glwEnums.hpp"
29
30 namespace deqp
31 {
32 namespace gles3
33 {
34 namespace Performance
35 {
36
37 using namespace glw; // GL types
38
39 namespace
40 {
41
42 enum
43 {
44 VIEWPORT_WIDTH = 24,
45 VIEWPORT_HEIGHT = 24
46 };
47
48 class StateChangeCase : public gls::StateChangePerformanceCase
49 {
50 public:
51 StateChangeCase(Context &context, int drawCallCount, int triangleCount, bool drawArrays, bool useIndexBuffer,
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(rasterizer_discard, "Enable/Disable RASTERIZER_DISCARD.", 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 MACRO_BLOCK({
434 if (stateId == 0)
435 gl.enable(GL_RASTERIZER_DISCARD);
436 else if (stateId == 1)
437 gl.disable(GL_RASTERIZER_DISCARD);
438 else
439 DE_ASSERT(false);
440 }))
441
442 ADD_TESTCASE(primitive_restart_fixed_index, "Enable/Disable PRIMITIVE_RESTART_FIXED_INDEX.", true, false,
443 MACRO_BLOCK({
444 requireCoordBuffers(1);
445 requireTextures(1);
446 requirePrograms(1);
447
448 gl.useProgram(m_programs[0]->getProgram());
449 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
450 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
451 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
452
453 gl.enableVertexAttribArray(coordLoc);
454 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
455 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
456 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
457 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
458 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
459
460 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
461 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
462
463 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
464 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
465
466 gl.uniform1i(samplerLoc, 0);
467 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
468
469 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
470 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
471 }),
472 MACRO_BLOCK({
473 if (stateId == 0)
474 gl.enable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
475 else if (stateId == 1)
476 gl.disable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
477 else
478 DE_ASSERT(false);
479 }))
480
481 ADD_TESTCASE(depth_func, "Change depth func.", true, false, MACRO_BLOCK({
482 requireCoordBuffers(1);
483 requireTextures(1);
484 requirePrograms(1);
485
486 gl.useProgram(m_programs[0]->getProgram());
487 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
488 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
489 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
490
491 gl.enableVertexAttribArray(coordLoc);
492 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
493 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
494 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
495 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
496 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
497
498 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
499 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
500
501 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
502 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
503
504 gl.uniform1i(samplerLoc, 0);
505 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
506
507 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
508 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
509
510 gl.enable(GL_DEPTH_TEST);
511 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
512 }),
513 MACRO_BLOCK({
514 if (stateId == 0)
515 gl.depthFunc(GL_GEQUAL);
516 else if (stateId == 1)
517 gl.depthFunc(GL_LEQUAL);
518 else
519 DE_ASSERT(false);
520 }))
521
522 ADD_TESTCASE(depth_mask, "Toggle depth mask.", true, false, MACRO_BLOCK({
523 requireCoordBuffers(1);
524 requireTextures(1);
525 requirePrograms(1);
526
527 gl.useProgram(m_programs[0]->getProgram());
528 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
529 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
530 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
531
532 gl.enableVertexAttribArray(coordLoc);
533 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
534 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
535 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
536 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
537 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
538
539 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
540 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
541
542 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
543 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
544
545 gl.uniform1i(samplerLoc, 0);
546 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
547
548 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
549 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
550
551 gl.enable(GL_DEPTH_TEST);
552 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
553
554 gl.depthFunc(GL_LEQUAL);
555 GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthFunc()");
556 }),
557 MACRO_BLOCK({
558 if (stateId == 0)
559 gl.depthMask(GL_FALSE);
560 else if (stateId == 1)
561 gl.depthMask(GL_TRUE);
562 else
563 DE_ASSERT(false);
564 }))
565
566 ADD_TESTCASE(depth_rangef, "Change depth range.", true, false, MACRO_BLOCK({
567 requireCoordBuffers(1);
568 requireTextures(1);
569 requirePrograms(1);
570
571 gl.useProgram(m_programs[0]->getProgram());
572 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
573 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
574 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
575
576 gl.enableVertexAttribArray(coordLoc);
577 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
578 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
579 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
580 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
581 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
582
583 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
584 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
585
586 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
587 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
588
589 gl.uniform1i(samplerLoc, 0);
590 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
591
592 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
593 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
594 }),
595 MACRO_BLOCK({
596 if (stateId == 0)
597 gl.depthRangef(0.0f, 1.0f);
598 else if (stateId == 1)
599 gl.depthRangef(0.25f, 0.75f);
600 else
601 DE_ASSERT(false);
602 }))
603
604 ADD_TESTCASE(blend_equation, "Change blend equation.", true, false, MACRO_BLOCK({
605 requireCoordBuffers(1);
606 requireTextures(1);
607 requirePrograms(1);
608
609 gl.useProgram(m_programs[0]->getProgram());
610 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
611 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
612 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
613
614 gl.enableVertexAttribArray(coordLoc);
615 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
616 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
617 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
618 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
619 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
620
621 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
622 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
623
624 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
625 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
626
627 gl.uniform1i(samplerLoc, 0);
628 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
629
630 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
631 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
632
633 gl.enable(GL_BLEND);
634 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
635 }),
636 MACRO_BLOCK({
637 if (stateId == 0)
638 gl.blendEquation(GL_FUNC_SUBTRACT);
639 else if (stateId == 1)
640 gl.blendEquation(GL_FUNC_ADD);
641 else
642 DE_ASSERT(false);
643 }))
644
645 ADD_TESTCASE(blend_func, "Change blend function.", true, false, MACRO_BLOCK({
646 requireCoordBuffers(1);
647 requireTextures(1);
648 requirePrograms(1);
649
650 gl.useProgram(m_programs[0]->getProgram());
651 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
652 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
653 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
654
655 gl.enableVertexAttribArray(coordLoc);
656 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
657 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
658 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
659 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
660 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
661
662 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
663 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
664
665 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
666 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
667
668 gl.uniform1i(samplerLoc, 0);
669 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
670
671 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
672 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
673
674 gl.enable(GL_BLEND);
675 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
676 }),
677 MACRO_BLOCK({
678 if (stateId == 0)
679 gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
680 else if (stateId == 1)
681 gl.blendFunc(GL_ONE, GL_ONE);
682 else
683 DE_ASSERT(false);
684 }))
685
686 ADD_TESTCASE(polygon_offset, "Change polygon offset.", true, false, MACRO_BLOCK({
687 requireCoordBuffers(1);
688 requireTextures(1);
689 requirePrograms(1);
690
691 gl.useProgram(m_programs[0]->getProgram());
692 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
693 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
694 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
695
696 gl.enableVertexAttribArray(coordLoc);
697 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
698 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
699 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
700 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
701 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
702
703 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
704 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
705
706 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
707 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
708
709 gl.uniform1i(samplerLoc, 0);
710 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
711
712 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
713 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
714
715 gl.enable(GL_POLYGON_OFFSET_FILL);
716 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
717 }),
718 MACRO_BLOCK({
719 if (stateId == 0)
720 gl.polygonOffset(0.0f, 0.0f);
721 else if (stateId == 1)
722 gl.polygonOffset(0.1f, 0.1f);
723 else
724 DE_ASSERT(false);
725 }))
726
727 ADD_TESTCASE(sample_coverage, "Sample coverage.", true, false, MACRO_BLOCK({
728 requireCoordBuffers(1);
729 requireTextures(1);
730 requirePrograms(1);
731
732 gl.useProgram(m_programs[0]->getProgram());
733 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
734 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
735 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
736
737 gl.enableVertexAttribArray(coordLoc);
738 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
739 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
740 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
741 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
742 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
743
744 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
745 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
746
747 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
748 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
749
750 gl.uniform1i(samplerLoc, 0);
751 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
752
753 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
754 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
755 }),
756 MACRO_BLOCK({
757 if (stateId == 0)
758 gl.sampleCoverage(0.25f, GL_TRUE);
759 else if (stateId == 1)
760 gl.sampleCoverage(0.75f, GL_FALSE);
761 else
762 DE_ASSERT(false);
763 }))
764
765 ADD_TESTCASE(viewport, "Change viewport.", true, false, MACRO_BLOCK({
766 requireCoordBuffers(1);
767 requireTextures(1);
768 requirePrograms(1);
769
770 gl.useProgram(m_programs[0]->getProgram());
771 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
772 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
773 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
774
775 gl.enableVertexAttribArray(coordLoc);
776 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
777 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
778 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
779 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
780 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
781
782 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
783 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
784
785 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
786 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
787
788 gl.uniform1i(samplerLoc, 0);
789 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
790
791 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
792 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
793 }),
794 MACRO_BLOCK({
795 if (stateId == 0)
796 gl.viewport(10, 11, 5, 6);
797 else if (stateId == 1)
798 gl.viewport(2, 3, 17, 14);
799 else
800 DE_ASSERT(false);
801 }))
802
803 ADD_TESTCASE(scissor, "Change scissor box.", true, false, MACRO_BLOCK({
804 requireCoordBuffers(1);
805 requireTextures(1);
806 requirePrograms(1);
807
808 gl.useProgram(m_programs[0]->getProgram());
809 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
810 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
811 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
812
813 gl.enableVertexAttribArray(coordLoc);
814 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
815 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
816 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
817 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
818 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
819
820 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
821 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
822
823 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
824 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
825
826 gl.uniform1i(samplerLoc, 0);
827 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
828
829 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
830 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
831
832 gl.enable(GL_SCISSOR_TEST);
833 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
834 }),
835 MACRO_BLOCK({
836 if (stateId == 0)
837 gl.scissor(17, 13, 5, 8);
838 else if (stateId == 1)
839 gl.scissor(7, 3, 13, 13);
840 else
841 DE_ASSERT(false);
842 }))
843
844 ADD_TESTCASE(color_mask, "Change color mask.", true, false, MACRO_BLOCK({
845 requireCoordBuffers(1);
846 requireTextures(1);
847 requirePrograms(1);
848
849 gl.useProgram(m_programs[0]->getProgram());
850 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
851 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
852 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
853
854 gl.enableVertexAttribArray(coordLoc);
855 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
856 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
857 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
858 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
859 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
860
861 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
862 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
863
864 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
865 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
866
867 gl.uniform1i(samplerLoc, 0);
868 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
869
870 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
871 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
872 }),
873 MACRO_BLOCK({
874 if (stateId == 0)
875 gl.colorMask(GL_TRUE, GL_FALSE, GL_TRUE, GL_FALSE);
876 else if (stateId == 1)
877 gl.colorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE);
878 else
879 DE_ASSERT(false);
880 }))
881
882 ADD_TESTCASE(cull_face, "Change culling mode.", true, false, MACRO_BLOCK({
883 requireCoordBuffers(1);
884 requireTextures(1);
885 requirePrograms(1);
886
887 gl.useProgram(m_programs[0]->getProgram());
888 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
889 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
890 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
891
892 gl.enableVertexAttribArray(coordLoc);
893 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
894 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
895 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
896 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
897 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
898
899 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
900 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
901
902 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
903 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
904
905 gl.uniform1i(samplerLoc, 0);
906 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
907
908 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
909 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
910
911 gl.enable(GL_CULL_FACE);
912 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
913 }),
914 MACRO_BLOCK({
915 if (stateId == 0)
916 gl.cullFace(GL_FRONT);
917 else if (stateId == 1)
918 gl.cullFace(GL_BACK);
919 else
920 DE_ASSERT(false);
921 }))
922
923 ADD_TESTCASE(front_face, "Change front face.", true, false, MACRO_BLOCK({
924 requireCoordBuffers(1);
925 requireTextures(1);
926 requirePrograms(1);
927
928 gl.useProgram(m_programs[0]->getProgram());
929 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
930 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
931 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
932
933 gl.enableVertexAttribArray(coordLoc);
934 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
935 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
936 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
937 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
938 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
939
940 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
941 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
942
943 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
944 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
945
946 gl.uniform1i(samplerLoc, 0);
947 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
948
949 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
950 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
951
952 gl.enable(GL_CULL_FACE);
953 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
954 }),
955 MACRO_BLOCK({
956 if (stateId == 0)
957 gl.frontFace(GL_CCW);
958 else if (stateId == 1)
959 gl.frontFace(GL_CW);
960 else
961 DE_ASSERT(false);
962 }))
963
964 ADD_TESTCASE(stencil_mask, "Change stencil mask.", true, false, MACRO_BLOCK({
965 requireCoordBuffers(1);
966 requireTextures(1);
967 requirePrograms(1);
968
969 gl.useProgram(m_programs[0]->getProgram());
970 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
971 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
972 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
973
974 gl.enableVertexAttribArray(coordLoc);
975 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
976 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
977 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
978 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
979 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
980
981 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
982 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
983
984 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
985 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
986
987 gl.uniform1i(samplerLoc, 0);
988 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
989
990 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
991 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
992
993 gl.enable(GL_STENCIL_TEST);
994 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
995
996 gl.stencilFunc(GL_LEQUAL, 0, 0);
997 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
998
999 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
1000 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
1001
1002 gl.clearStencil(0);
1003 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
1004 gl.clear(GL_STENCIL_BUFFER_BIT);
1005 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
1006 }),
1007 MACRO_BLOCK({
1008 if (stateId == 0)
1009 gl.stencilMask(0xDD);
1010 else if (stateId == 1)
1011 gl.stencilMask(~0xDD);
1012 else
1013 DE_ASSERT(false);
1014 }))
1015
1016 ADD_TESTCASE(stencil_func, "Change stencil func.", true, false, MACRO_BLOCK({
1017 requireCoordBuffers(1);
1018 requireTextures(1);
1019 requirePrograms(1);
1020
1021 gl.useProgram(m_programs[0]->getProgram());
1022 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1023 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1024 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1025
1026 gl.enableVertexAttribArray(coordLoc);
1027 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1028 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1029 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1030 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1031 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1032
1033 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1034 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1035
1036 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1037 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1038
1039 gl.uniform1i(samplerLoc, 0);
1040 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1041
1042 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1043 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1044
1045 gl.enable(GL_STENCIL_TEST);
1046 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1047
1048 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
1049 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilOp()");
1050 gl.clearStencil(0);
1051 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
1052 gl.clear(GL_STENCIL_BUFFER_BIT);
1053 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
1054 }),
1055 MACRO_BLOCK({
1056 if (stateId == 0)
1057 gl.stencilFunc(GL_LEQUAL, 0, 0xFF);
1058 else if (stateId == 1)
1059 gl.stencilFunc(GL_GEQUAL, 0, 0x00);
1060 else
1061 DE_ASSERT(false);
1062 }))
1063
1064 ADD_TESTCASE(stencil_op, "Change stencil op.", true, false, MACRO_BLOCK({
1065 requireCoordBuffers(1);
1066 requireTextures(1);
1067 requirePrograms(1);
1068
1069 gl.useProgram(m_programs[0]->getProgram());
1070 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1071 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1072 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1073
1074 gl.enableVertexAttribArray(coordLoc);
1075 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1076 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1077 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1078 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1079 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1080
1081 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1082 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1083
1084 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1085 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1086
1087 gl.uniform1i(samplerLoc, 0);
1088 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1089
1090 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1091 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1092
1093 gl.enable(GL_STENCIL_TEST);
1094 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1095
1096 gl.stencilFunc(GL_LEQUAL, 0, 0);
1097 GLU_EXPECT_NO_ERROR(gl.getError(), "glStencilFunc()");
1098
1099 gl.clearStencil(0);
1100 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearStencil()");
1101
1102 gl.clear(GL_STENCIL_BUFFER_BIT);
1103 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear()");
1104 }),
1105 MACRO_BLOCK({
1106 if (stateId == 0)
1107 gl.stencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
1108 else if (stateId == 1)
1109 gl.stencilOp(GL_REPLACE, GL_KEEP, GL_KEEP);
1110 else
1111 DE_ASSERT(false);
1112 }))
1113
1114 ADD_TESTCASE(bind_array_buffer, "Change array buffer and refresh vertex attrib pointer.", true, false, MACRO_BLOCK({
1115 requireCoordBuffers(2);
1116 requireTextures(1);
1117 requirePrograms(1);
1118
1119 gl.bindAttribLocation(m_programs[0]->getProgram(), 0, "a_coord");
1120 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
1121 gl.linkProgram(m_programs[0]->getProgram());
1122 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
1123
1124 gl.useProgram(m_programs[0]->getProgram());
1125 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1126
1127 gl.enableVertexAttribArray(0);
1128 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1129 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1130 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1131 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1132 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1133
1134 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1135 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1136
1137 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1138 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1139
1140 gl.uniform1i(samplerLoc, 0);
1141 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1142
1143 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1144 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1145 }),
1146 MACRO_BLOCK({
1147 if (stateId == 0)
1148 {
1149 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1150 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1151 }
1152 else if (stateId == 1)
1153 {
1154 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[1]);
1155 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1156 }
1157 else
1158 DE_ASSERT(false);
1159 }))
1160
1161 ADD_TESTCASE(element_array_buffer, "Change element array buffer.", false, true, MACRO_BLOCK({
1162 requireCoordBuffers(1);
1163 requireIndexBuffers(2);
1164 requireTextures(1);
1165 requirePrograms(1);
1166
1167 gl.useProgram(m_programs[0]->getProgram());
1168 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
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 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1180 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1181
1182 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1183 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1184
1185 gl.uniform1i(samplerLoc, 0);
1186 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1187
1188 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1189 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1190
1191 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
1192 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1193 }),
1194 MACRO_BLOCK({
1195 if (stateId == 0)
1196 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[0]);
1197 else if (stateId == 1)
1198 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffers[1]);
1199 else
1200 DE_ASSERT(false);
1201 }))
1202
1203 ADD_TESTCASE(bind_texture, "Change texture binding.", true, false, MACRO_BLOCK({
1204 requireCoordBuffers(1);
1205 requireTextures(2);
1206 requirePrograms(1);
1207
1208 gl.useProgram(m_programs[0]->getProgram());
1209 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1210 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1211 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1212
1213 gl.enableVertexAttribArray(coordLoc);
1214 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1215 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1216 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1217 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1218 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1219
1220 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1221 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1222
1223 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1224 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1225
1226 gl.uniform1i(samplerLoc, 0);
1227 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1228
1229 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1230 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1231 }),
1232 MACRO_BLOCK({
1233 if (stateId == 0)
1234 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1235 else if (stateId == 1)
1236 gl.bindTexture(GL_TEXTURE_2D, m_textures[1]);
1237 else
1238 DE_ASSERT(false);
1239 }))
1240
1241 ADD_TESTCASE(use_program, "Change used program.", true, false, MACRO_BLOCK({
1242 requireCoordBuffers(1);
1243 requireTextures(1);
1244 requirePrograms(2);
1245
1246 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1247 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1248
1249 gl.enableVertexAttribArray(coordLoc);
1250 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1251 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1252 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1253 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1254 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1255
1256 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1257 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1258
1259 {
1260 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1261 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1262 gl.useProgram(m_programs[0]->getProgram());
1263 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1264 gl.uniform1i(samplerLoc, 0);
1265 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1266 }
1267
1268 {
1269 GLint samplerLoc = gl.getUniformLocation(m_programs[1]->getProgram(), "u_sampler");
1270 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1271 gl.useProgram(m_programs[1]->getProgram());
1272 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1273 gl.uniform1i(samplerLoc, 0);
1274 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1275 }
1276
1277 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1278 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1279 }),
1280 MACRO_BLOCK({
1281 if (stateId == 0)
1282 gl.useProgram(m_programs[0]->getProgram());
1283 else if (stateId == 1)
1284 gl.useProgram(m_programs[1]->getProgram());
1285 else
1286 DE_ASSERT(false);
1287 }))
1288
1289 ADD_TESTCASE(tex_parameter_min_filter, "Change texture parameter min filter.", true, false, MACRO_BLOCK({
1290 requireCoordBuffers(1);
1291 requireTextures(1);
1292 requirePrograms(1);
1293
1294 gl.useProgram(m_programs[0]->getProgram());
1295 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1296 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1297 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1298
1299 gl.enableVertexAttribArray(coordLoc);
1300 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1301 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1302 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1303 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1304 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1305
1306 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1307 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1308
1309 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1310 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1311
1312 gl.uniform1i(samplerLoc, 0);
1313 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1314
1315 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1316 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1317 }),
1318 MACRO_BLOCK({
1319 if (stateId == 0)
1320 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1321 else if (stateId == 1)
1322 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1323 else
1324 DE_ASSERT(false);
1325 }))
1326
1327 ADD_TESTCASE(tex_parameter_mag_filter, "Change texture parameter mag filter.", true, false, MACRO_BLOCK({
1328 requireCoordBuffers(1);
1329 requireTextures(1);
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 MACRO_BLOCK({
1357 if (stateId == 0)
1358 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1359 else if (stateId == 1)
1360 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1361 else
1362 DE_ASSERT(false);
1363 }))
1364
1365 ADD_TESTCASE(tex_parameter_wrap, "Change texture parameter wrap filter.", true, false, MACRO_BLOCK({
1366 requireCoordBuffers(1);
1367 requireTextures(1);
1368 requirePrograms(1);
1369
1370 gl.useProgram(m_programs[0]->getProgram());
1371 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1372 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1373 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1374
1375 gl.enableVertexAttribArray(coordLoc);
1376 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1377 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1378 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1379 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1380 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1381
1382 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1383 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1384
1385 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1386 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1387
1388 gl.uniform1i(samplerLoc, 0);
1389 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1390
1391 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1392 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1393 }),
1394 MACRO_BLOCK({
1395 if (stateId == 0)
1396 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1397 else if (stateId == 1)
1398 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1399 else
1400 DE_ASSERT(false);
1401 }))
1402
1403 ADD_TESTCASE(bind_framebuffer, "Change framebuffer.", true, false, MACRO_BLOCK({
1404 requireCoordBuffers(1);
1405 requireTextures(1);
1406 requireFramebuffers(2);
1407 requirePrograms(1);
1408
1409 gl.useProgram(m_programs[0]->getProgram());
1410 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1411 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1412 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1413
1414 gl.enableVertexAttribArray(coordLoc);
1415 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1416 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1417 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1418 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1419 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1420
1421 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1422 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1423
1424 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1425 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1426
1427 gl.uniform1i(samplerLoc, 0);
1428 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1429
1430 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1431 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1432
1433 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
1434 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer()");
1435 }),
1436 MACRO_BLOCK({
1437 if (stateId == 0)
1438 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[0]);
1439 else if (stateId == 1)
1440 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffers[1]);
1441 else
1442 DE_ASSERT(false);
1443 }))
1444
1445 ADD_TESTCASE(blend_color, "Change blend color.", true, false, MACRO_BLOCK({
1446 requireCoordBuffers(1);
1447 requireTextures(1);
1448 requirePrograms(1);
1449
1450 gl.useProgram(m_programs[0]->getProgram());
1451 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1452 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1453 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1454
1455 gl.enableVertexAttribArray(coordLoc);
1456 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1457 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1458 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1459 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1460 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1461
1462 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1463 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1464
1465 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1466 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1467
1468 gl.uniform1i(samplerLoc, 0);
1469 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1470
1471 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1472 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1473
1474 gl.enable(GL_BLEND);
1475 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable()");
1476
1477 gl.blendFunc(GL_CONSTANT_COLOR, GL_CONSTANT_COLOR);
1478 GLU_EXPECT_NO_ERROR(gl.getError(), "glBlendFunc()");
1479 }),
1480 MACRO_BLOCK({
1481 if (stateId == 0)
1482 gl.blendColor(0.25f, 0.25f, 0.25f, 0.25f);
1483 else if (stateId == 1)
1484 gl.blendColor(0.75f, 0.75f, 0.75f, 0.75f);
1485 else
1486 DE_ASSERT(false);
1487 }))
1488
1489 ADD_TESTCASE(sampler, "Change sampler binding.", true, false, MACRO_BLOCK({
1490 requireCoordBuffers(1);
1491 requireTextures(1);
1492 requirePrograms(1);
1493 requireSamplers(2);
1494
1495 gl.useProgram(m_programs[0]->getProgram());
1496 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1497 GLint coordLoc = gl.getAttribLocation(m_programs[0]->getProgram(), "a_coord");
1498 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");
1499
1500 gl.enableVertexAttribArray(coordLoc);
1501 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1502 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[0]);
1503 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1504 gl.vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1505 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1506
1507 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1508 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1509
1510 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1511 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1512
1513 gl.uniform1i(samplerLoc, 0);
1514 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1515
1516 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1517 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1518
1519 for (int ndx = 0; ndx < 2; ndx++)
1520 {
1521 gl.bindSampler(0, m_samplers[ndx]);
1522 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, ndx == 0 ? GL_NEAREST : GL_LINEAR);
1523 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, ndx == 0 ? GL_LINEAR : GL_NEAREST);
1524 GLU_EXPECT_NO_ERROR(gl.getError(), "Sampler setup");
1525 }
1526 }),
1527 MACRO_BLOCK({
1528 DE_ASSERT(de::inBounds(stateId, 0, 2));
1529 gl.bindSampler(0, m_samplers[stateId]);
1530 }))
1531
1532 ADD_TESTCASE(bind_vertex_array, "Change vertex array binding.", true, false, MACRO_BLOCK({
1533 requireCoordBuffers(2);
1534 requireTextures(1);
1535 requirePrograms(1);
1536 requireVertexArrays(2);
1537
1538 gl.bindAttribLocation(m_programs[0]->getProgram(), 0, "a_coord");
1539 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
1540 gl.linkProgram(m_programs[0]->getProgram());
1541 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
1542
1543 gl.useProgram(m_programs[0]->getProgram());
1544 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
1545
1546 for (int ndx = 0; ndx < 2; ndx++)
1547 {
1548 gl.bindVertexArray(m_vertexArrays[ndx]);
1549 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray()");
1550 gl.enableVertexAttribArray(0);
1551 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray()");
1552 gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffers[ndx]);
1553 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
1554 gl.vertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
1555 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer()");
1556 }
1557
1558 GLint samplerLoc = gl.getUniformLocation(m_programs[0]->getProgram(), "u_sampler");
1559 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1560
1561 gl.bindTexture(GL_TEXTURE_2D, m_textures[0]);
1562 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
1563
1564 gl.uniform1i(samplerLoc, 0);
1565 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i()");
1566
1567 gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1568 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport()");
1569 }),
1570 MACRO_BLOCK({
1571 DE_ASSERT(de::inRange(stateId, 0, 2));
1572 gl.bindVertexArray(m_vertexArrays[stateId]);
1573 }))
1574 }
1575
1576 } // namespace Performance
1577 } // namespace gles3
1578 } // namespace deqp
1579