1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.1 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2015 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 Indexed state query tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "es31fIndexedStateQueryTests.hpp"
25 #include "tcuTestLog.hpp"
26 #include "tcuFormatUtil.hpp"
27 #include "gluRenderContext.hpp"
28 #include "gluCallLogWrapper.hpp"
29 #include "gluStrUtil.hpp"
30 #include "gluContextInfo.hpp"
31 #include "gluObjectWrapper.hpp"
32 #include "glwFunctions.hpp"
33 #include "glwEnums.hpp"
34 #include "glsStateQueryUtil.hpp"
35 #include "deRandom.hpp"
36 #include "deStringUtil.hpp"
37
38 namespace deqp
39 {
40 namespace gles31
41 {
42 namespace Functional
43 {
44 namespace
45 {
46
47 using namespace gls::StateQueryUtil;
48
getVerifierSuffix(QueryType type)49 static const char* getVerifierSuffix (QueryType type)
50 {
51 switch (type)
52 {
53 case QUERY_INDEXED_BOOLEAN: return "getbooleani_v";
54 case QUERY_INDEXED_INTEGER: return "getintegeri_v";
55 case QUERY_INDEXED_INTEGER64: return "getinteger64i_v";
56 case QUERY_INDEXED_BOOLEAN_VEC4: return "getbooleani_v";
57 case QUERY_INDEXED_INTEGER_VEC4: return "getintegeri_v";
58 case QUERY_INDEXED_INTEGER64_VEC4: return "getinteger64i_v";
59 case QUERY_INDEXED_ISENABLED: return "isenabledi";
60 default:
61 DE_ASSERT(DE_FALSE);
62 return DE_NULL;
63 }
64 }
65
isExtensionSupported(Context & context,std::string extensionName)66 void isExtensionSupported (Context& context, std::string extensionName)
67 {
68 if (extensionName == "GL_EXT_draw_buffers_indexed" || extensionName == "GL_KHR_blend_equation_advanced")
69 {
70 if (!contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !context.getContextInfo().isExtensionSupported(extensionName.c_str()))
71 TCU_THROW(NotSupportedError, (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
72 }
73 else if (!context.getContextInfo().isExtensionSupported(extensionName.c_str()))
74 TCU_THROW(NotSupportedError, (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
75 }
76
77 class SampleMaskCase : public TestCase
78 {
79 public:
80 SampleMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType);
81
82 private:
83 void init (void);
84 IterateResult iterate (void);
85
86 const QueryType m_verifierType;
87 int m_maxSampleMaskWords;
88 };
89
SampleMaskCase(Context & context,const char * name,const char * desc,QueryType verifierType)90 SampleMaskCase::SampleMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType)
91 : TestCase (context, name, desc)
92 , m_verifierType (verifierType)
93 , m_maxSampleMaskWords (-1)
94 {
95 }
96
init(void)97 void SampleMaskCase::init (void)
98 {
99 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
100
101 gl.getIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &m_maxSampleMaskWords);
102 GLU_EXPECT_NO_ERROR(gl.getError(), "query sample mask words");
103
104 // mask word count ok?
105 if (m_maxSampleMaskWords <= 0)
106 throw tcu::TestError("Minimum value of GL_MAX_SAMPLE_MASK_WORDS is 1. Got " + de::toString(m_maxSampleMaskWords));
107
108 m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_SAMPLE_MASK_WORDS = " << m_maxSampleMaskWords << tcu::TestLog::EndMessage;
109 }
110
iterate(void)111 SampleMaskCase::IterateResult SampleMaskCase::iterate (void)
112 {
113 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
114 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
115
116 gl.enableLogging(true);
117
118 // initial values
119 {
120 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values");
121
122 for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx)
123 verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, -1, m_verifierType);
124 }
125
126 // fixed values
127 {
128 const tcu::ScopedLogSection section(m_testCtx.getLog(), "fixed", "Fixed values");
129
130 for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx)
131 {
132 gl.glSampleMaski(ndx, 0);
133 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski");
134
135 verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, 0, m_verifierType);
136 }
137 }
138
139 // random masks
140 {
141 const int numRandomTest = 20;
142 const tcu::ScopedLogSection section (m_testCtx.getLog(), "random", "Random values");
143 de::Random rnd (0x4312);
144
145 for (int testNdx = 0; testNdx < numRandomTest; ++testNdx)
146 {
147 const glw::GLint maskIndex = (glw::GLint)(rnd.getUint32() % m_maxSampleMaskWords);
148 glw::GLint mask = (glw::GLint)(rnd.getUint32());
149
150 gl.glSampleMaski(maskIndex, mask);
151 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski");
152
153 verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, maskIndex, mask, m_verifierType);
154 }
155 }
156
157 result.setTestContextResult(m_testCtx);
158 return STOP;
159 }
160
161 class MinValueIndexed3Case : public TestCase
162 {
163 public:
164 MinValueIndexed3Case (Context& context, const char* name, const char* desc, glw::GLenum target, const tcu::IVec3& ref, QueryType verifierType);
165
166 private:
167 IterateResult iterate (void);
168
169 const glw::GLenum m_target;
170 const tcu::IVec3 m_ref;
171 const QueryType m_verifierType;
172 };
173
MinValueIndexed3Case(Context & context,const char * name,const char * desc,glw::GLenum target,const tcu::IVec3 & ref,QueryType verifierType)174 MinValueIndexed3Case::MinValueIndexed3Case (Context& context, const char* name, const char* desc, glw::GLenum target, const tcu::IVec3& ref, QueryType verifierType)
175 : TestCase (context, name, desc)
176 , m_target (target)
177 , m_ref (ref)
178 , m_verifierType (verifierType)
179 {
180 }
181
iterate(void)182 MinValueIndexed3Case::IterateResult MinValueIndexed3Case::iterate (void)
183 {
184 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
185 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
186
187 gl.enableLogging(true);
188
189 for (int ndx = 0; ndx < 3; ++ndx)
190 {
191 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Element", "Element " + de::toString(ndx));
192
193 verifyStateIndexedIntegerMin(result, gl, m_target, ndx, m_ref[ndx], m_verifierType);
194 }
195
196 result.setTestContextResult(m_testCtx);
197 return STOP;
198 }
199
200 class BufferBindingCase : public TestCase
201 {
202 public:
203 BufferBindingCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);
204
205 private:
206 IterateResult iterate (void);
207
208 const glw::GLenum m_queryTarget;
209 const glw::GLenum m_bufferTarget;
210 const glw::GLenum m_numBindingsTarget;
211 const QueryType m_verifierType;
212 };
213
BufferBindingCase(Context & context,const char * name,const char * desc,glw::GLenum queryTarget,glw::GLenum bufferTarget,glw::GLenum numBindingsTarget,QueryType verifierType)214 BufferBindingCase::BufferBindingCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
215 : TestCase (context, name, desc)
216 , m_queryTarget (queryTarget)
217 , m_bufferTarget (bufferTarget)
218 , m_numBindingsTarget (numBindingsTarget)
219 , m_verifierType (verifierType)
220 {
221 }
222
iterate(void)223 BufferBindingCase::IterateResult BufferBindingCase::iterate (void)
224 {
225 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
226 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
227 int maxBindings = -1;
228
229 gl.enableLogging(true);
230
231 gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
232 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
233
234 {
235 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
236
237 for (int ndx = 0; ndx < maxBindings; ++ndx)
238 verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
239 }
240
241 {
242 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
243 glu::Buffer bufferA (m_context.getRenderContext());
244 glu::Buffer bufferB (m_context.getRenderContext());
245 const int ndxA = 0;
246 const int ndxB = maxBindings / 2;
247
248 {
249 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");
250
251 gl.glBindBuffer(m_bufferTarget, *bufferA);
252 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBuffer");
253
254 verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
255 }
256 {
257 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");
258
259 gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
260 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferBase");
261
262 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType);
263 }
264 {
265 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");
266
267 gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8);
268 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferRange");
269
270 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, *bufferB, m_verifierType);
271 }
272 if (ndxA != ndxB)
273 {
274 const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");
275
276 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType);
277 }
278 }
279
280 result.setTestContextResult(m_testCtx);
281 return STOP;
282 }
283
284 class BufferStartCase : public TestCase
285 {
286 public:
287 BufferStartCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);
288
289 private:
290 IterateResult iterate (void);
291
292 const glw::GLenum m_queryTarget;
293 const glw::GLenum m_bufferTarget;
294 const glw::GLenum m_numBindingsTarget;
295 const QueryType m_verifierType;
296 };
297
BufferStartCase(Context & context,const char * name,const char * desc,glw::GLenum queryTarget,glw::GLenum bufferTarget,glw::GLenum numBindingsTarget,QueryType verifierType)298 BufferStartCase::BufferStartCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
299 : TestCase (context, name, desc)
300 , m_queryTarget (queryTarget)
301 , m_bufferTarget (bufferTarget)
302 , m_numBindingsTarget (numBindingsTarget)
303 , m_verifierType (verifierType)
304 {
305 }
306
iterate(void)307 BufferStartCase::IterateResult BufferStartCase::iterate (void)
308 {
309 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
310 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
311 int maxBindings = -1;
312
313 gl.enableLogging(true);
314
315 gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
316 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
317
318 {
319 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
320
321 for (int ndx = 0; ndx < maxBindings; ++ndx)
322 verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
323 }
324
325
326 {
327 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
328 glu::Buffer bufferA (m_context.getRenderContext());
329 glu::Buffer bufferB (m_context.getRenderContext());
330 const int ndxA = 0;
331 const int ndxB = maxBindings / 2;
332 int offset = -1;
333
334 if (m_bufferTarget == GL_ATOMIC_COUNTER_BUFFER)
335 offset = 4;
336 else if (m_bufferTarget == GL_SHADER_STORAGE_BUFFER)
337 {
338 gl.glGetIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &offset);
339 GLU_EXPECT_NO_ERROR(gl.glGetError(), "get align");
340 }
341 else
342 DE_ASSERT(false);
343
344 TCU_CHECK(offset >= 0);
345
346 {
347 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");
348
349 gl.glBindBuffer(m_bufferTarget, *bufferA);
350 gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ);
351 gl.glBindBuffer(m_bufferTarget, *bufferB);
352 gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ);
353 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs");
354
355 verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
356 }
357 {
358 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");
359
360 gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
361 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
362
363 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
364 }
365 {
366 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");
367
368 gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, offset, 8);
369 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
370
371 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, offset, m_verifierType);
372 }
373 if (ndxA != ndxB)
374 {
375 const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");
376
377 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
378 }
379 }
380
381 result.setTestContextResult(m_testCtx);
382 return STOP;
383 }
384
385 class BufferSizeCase : public TestCase
386 {
387 public:
388 BufferSizeCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);
389
390 private:
391 IterateResult iterate (void);
392
393 const glw::GLenum m_queryTarget;
394 const glw::GLenum m_bufferTarget;
395 const glw::GLenum m_numBindingsTarget;
396 const QueryType m_verifierType;
397 };
398
BufferSizeCase(Context & context,const char * name,const char * desc,glw::GLenum queryTarget,glw::GLenum bufferTarget,glw::GLenum numBindingsTarget,QueryType verifierType)399 BufferSizeCase::BufferSizeCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
400 : TestCase (context, name, desc)
401 , m_queryTarget (queryTarget)
402 , m_bufferTarget (bufferTarget)
403 , m_numBindingsTarget (numBindingsTarget)
404 , m_verifierType (verifierType)
405 {
406 }
407
iterate(void)408 BufferSizeCase::IterateResult BufferSizeCase::iterate (void)
409 {
410 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
411 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
412 int maxBindings = -1;
413
414 gl.enableLogging(true);
415
416 gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
417 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
418
419 {
420 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
421
422 for (int ndx = 0; ndx < maxBindings; ++ndx)
423 verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
424 }
425
426 {
427 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
428 glu::Buffer bufferA (m_context.getRenderContext());
429 glu::Buffer bufferB (m_context.getRenderContext());
430 const int ndxA = 0;
431 const int ndxB = maxBindings / 2;
432
433 {
434 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");
435
436 gl.glBindBuffer(m_bufferTarget, *bufferA);
437 gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ);
438 gl.glBindBuffer(m_bufferTarget, *bufferB);
439 gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ);
440 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs");
441
442 verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
443 }
444 {
445 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");
446
447 gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
448 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
449
450 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
451 }
452 {
453 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");
454
455 gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8);
456 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
457
458 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, 8, m_verifierType);
459 }
460 if (ndxA != ndxB)
461 {
462 const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");
463
464 verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
465 }
466 }
467
468 result.setTestContextResult(m_testCtx);
469 return STOP;
470 }
471
472 class ImageBindingNameCase : public TestCase
473 {
474 public:
475 ImageBindingNameCase (Context& context, const char* name, const char* desc, QueryType verifierType);
476
477 private:
478 IterateResult iterate (void);
479
480 const QueryType m_verifierType;
481 };
482
ImageBindingNameCase(Context & context,const char * name,const char * desc,QueryType verifierType)483 ImageBindingNameCase::ImageBindingNameCase (Context& context, const char* name, const char* desc, QueryType verifierType)
484 : TestCase (context, name, desc)
485 , m_verifierType (verifierType)
486 {
487 }
488
iterate(void)489 ImageBindingNameCase::IterateResult ImageBindingNameCase::iterate (void)
490 {
491 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
492 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
493 int maxImages = -1;
494
495 gl.enableLogging(true);
496
497 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
498 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
499
500 {
501 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
502
503 for (int ndx = 0; ndx < maxImages; ++ndx)
504 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndx, 0, m_verifierType);
505 }
506
507 {
508 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
509 glu::Texture textureA (m_context.getRenderContext());
510 glu::Texture textureB (m_context.getRenderContext());
511 const int ndxA = 0;
512 const int ndxB = maxImages / 2;
513
514 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
515 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
516 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
517
518 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
519 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
520
521 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
522 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
523 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
524
525 gl.glBindImageTexture(ndxB, *textureB, 0, GL_FALSE, 2, GL_READ_ONLY, GL_RGBA8UI);
526 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
527
528 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxA, *textureA, m_verifierType);
529 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxB, *textureB, m_verifierType);
530 }
531
532 result.setTestContextResult(m_testCtx);
533 return STOP;
534 }
535
536 class ImageBindingLevelCase : public TestCase
537 {
538 public:
539 ImageBindingLevelCase (Context& context, const char* name, const char* desc, QueryType verifierType);
540
541 private:
542 IterateResult iterate (void);
543
544 const QueryType m_verifierType;
545 };
546
ImageBindingLevelCase(Context & context,const char * name,const char * desc,QueryType verifierType)547 ImageBindingLevelCase::ImageBindingLevelCase (Context& context, const char* name, const char* desc, QueryType verifierType)
548 : TestCase (context, name, desc)
549 , m_verifierType (verifierType)
550 {
551 }
552
iterate(void)553 ImageBindingLevelCase::IterateResult ImageBindingLevelCase::iterate (void)
554 {
555 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
556 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
557 int maxImages = -1;
558
559 gl.enableLogging(true);
560
561 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
562 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
563
564 {
565 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
566
567 for (int ndx = 0; ndx < maxImages; ++ndx)
568 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndx, 0, m_verifierType);
569 }
570
571 {
572 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
573 glu::Texture textureA (m_context.getRenderContext());
574 glu::Texture textureB (m_context.getRenderContext());
575 const int ndxA = 0;
576 const int ndxB = maxImages / 2;
577
578 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
579 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
580 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
581
582 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
583 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
584
585 gl.glBindTexture(GL_TEXTURE_2D, *textureB);
586 gl.glTexStorage2D(GL_TEXTURE_2D, 3, GL_RGBA8, 32, 32);
587 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
588
589 gl.glBindImageTexture(ndxB, *textureB, 2, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
590 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
591
592 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxA, 0, m_verifierType);
593 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxB, 2, m_verifierType);
594 }
595
596 result.setTestContextResult(m_testCtx);
597 return STOP;
598 }
599
600 class ImageBindingLayeredCase : public TestCase
601 {
602 public:
603 ImageBindingLayeredCase (Context& context, const char* name, const char* desc, QueryType verifierType);
604
605 private:
606 IterateResult iterate (void);
607
608 const QueryType m_verifierType;
609 };
610
ImageBindingLayeredCase(Context & context,const char * name,const char * desc,QueryType verifierType)611 ImageBindingLayeredCase::ImageBindingLayeredCase (Context& context, const char* name, const char* desc, QueryType verifierType)
612 : TestCase (context, name, desc)
613 , m_verifierType (verifierType)
614 {
615 }
616
iterate(void)617 ImageBindingLayeredCase::IterateResult ImageBindingLayeredCase::iterate (void)
618 {
619 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
620 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
621 int maxImages = -1;
622
623 gl.enableLogging(true);
624
625 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
626 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
627
628 {
629 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
630
631 for (int ndx = 0; ndx < maxImages; ++ndx)
632 verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndx, false, m_verifierType);
633 }
634
635 {
636 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
637 glu::Texture textureA (m_context.getRenderContext());
638 glu::Texture textureB (m_context.getRenderContext());
639 const int ndxA = 0;
640 const int ndxB = maxImages / 2;
641
642 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
643 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
644 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
645
646 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
647 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
648
649 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
650 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
651 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
652
653 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI);
654 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
655
656 verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxA, false, m_verifierType);
657 verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxB, true, m_verifierType);
658 }
659
660 result.setTestContextResult(m_testCtx);
661 return STOP;
662 }
663
664 class ImageBindingLayerCase : public TestCase
665 {
666 public:
667 ImageBindingLayerCase (Context& context, const char* name, const char* desc, QueryType verifierType);
668
669 private:
670 IterateResult iterate (void);
671
672 const QueryType m_verifierType;
673 };
674
ImageBindingLayerCase(Context & context,const char * name,const char * desc,QueryType verifierType)675 ImageBindingLayerCase::ImageBindingLayerCase (Context& context, const char* name, const char* desc, QueryType verifierType)
676 : TestCase (context, name, desc)
677 , m_verifierType (verifierType)
678 {
679 }
680
iterate(void)681 ImageBindingLayerCase::IterateResult ImageBindingLayerCase::iterate (void)
682 {
683 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
684 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
685 int maxImages = -1;
686
687 gl.enableLogging(true);
688
689 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
690 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
691
692 {
693 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
694
695 for (int ndx = 0; ndx < maxImages; ++ndx)
696 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndx, 0, m_verifierType);
697 }
698
699 {
700 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
701 glu::Texture textureA (m_context.getRenderContext());
702 glu::Texture textureB (m_context.getRenderContext());
703 const int ndxA = 0;
704 const int ndxB = maxImages / 2;
705
706 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
707 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
708 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
709
710 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
711 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
712
713 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
714 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
715 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
716
717 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI);
718 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
719
720 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxA, 0, m_verifierType);
721 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxB, 2, m_verifierType);
722 }
723
724 result.setTestContextResult(m_testCtx);
725 return STOP;
726 }
727
728 class ImageBindingAccessCase : public TestCase
729 {
730 public:
731 ImageBindingAccessCase (Context& context, const char* name, const char* desc, QueryType verifierType);
732
733 private:
734 IterateResult iterate (void);
735
736 const QueryType m_verifierType;
737 };
738
ImageBindingAccessCase(Context & context,const char * name,const char * desc,QueryType verifierType)739 ImageBindingAccessCase::ImageBindingAccessCase (Context& context, const char* name, const char* desc, QueryType verifierType)
740 : TestCase (context, name, desc)
741 , m_verifierType (verifierType)
742 {
743 }
744
iterate(void)745 ImageBindingAccessCase::IterateResult ImageBindingAccessCase::iterate (void)
746 {
747 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
748 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
749 int maxImages = -1;
750
751 gl.enableLogging(true);
752
753 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
754 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
755
756 {
757 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
758
759 for (int ndx = 0; ndx < maxImages; ++ndx)
760 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndx, GL_READ_ONLY, m_verifierType);
761 }
762
763 {
764 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
765 glu::Texture textureA (m_context.getRenderContext());
766 glu::Texture textureB (m_context.getRenderContext());
767 const int ndxA = 0;
768 const int ndxB = maxImages / 2;
769
770 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
771 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
772 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
773
774 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
775 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
776
777 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
778 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
779 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
780
781 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_RGBA8UI);
782 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
783
784 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxA, GL_READ_ONLY, m_verifierType);
785 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxB, GL_READ_WRITE, m_verifierType);
786 }
787
788 result.setTestContextResult(m_testCtx);
789 return STOP;
790 }
791
792 class ImageBindingFormatCase : public TestCase
793 {
794 public:
795 ImageBindingFormatCase (Context& context, const char* name, const char* desc, QueryType verifierType);
796
797 private:
798 IterateResult iterate (void);
799
800 const QueryType m_verifierType;
801 };
802
ImageBindingFormatCase(Context & context,const char * name,const char * desc,QueryType verifierType)803 ImageBindingFormatCase::ImageBindingFormatCase (Context& context, const char* name, const char* desc, QueryType verifierType)
804 : TestCase (context, name, desc)
805 , m_verifierType (verifierType)
806 {
807 }
808
iterate(void)809 ImageBindingFormatCase::IterateResult ImageBindingFormatCase::iterate (void)
810 {
811 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
812 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
813 int maxImages = -1;
814
815 gl.enableLogging(true);
816
817 gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
818 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
819
820 {
821 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
822
823 for (int ndx = 0; ndx < maxImages; ++ndx)
824 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndx, GL_R32UI, m_verifierType);
825 }
826
827 {
828 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
829 glu::Texture textureA (m_context.getRenderContext());
830 glu::Texture textureB (m_context.getRenderContext());
831 const int ndxA = 0;
832 const int ndxB = maxImages / 2;
833
834 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
835 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
836 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
837
838 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
839 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
840
841 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
842 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_R32F, 32, 32, 4);
843 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
844
845 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_R32F);
846 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
847
848 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxA, GL_RGBA8UI, m_verifierType);
849 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxB, GL_R32F, m_verifierType);
850 }
851
852 result.setTestContextResult(m_testCtx);
853 return STOP;
854 }
855
856 class EnableBlendCase : public TestCase
857 {
858 public:
859 EnableBlendCase (Context& context, const char* name, const char* desc, QueryType verifierType);
860
861 void init (void);
862 private:
863 IterateResult iterate (void);
864
865 const QueryType m_verifierType;
866 };
867
EnableBlendCase(Context & context,const char * name,const char * desc,QueryType verifierType)868 EnableBlendCase::EnableBlendCase (Context& context, const char* name, const char* desc, QueryType verifierType)
869 : TestCase (context, name, desc)
870 , m_verifierType (verifierType)
871 {
872 }
873
init(void)874 void EnableBlendCase::init (void)
875 {
876 isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
877 }
878
iterate(void)879 EnableBlendCase::IterateResult EnableBlendCase::iterate (void)
880 {
881 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
882 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
883 deInt32 maxDrawBuffers = 0;
884
885 gl.enableLogging(true);
886
887 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
888 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
889
890 {
891 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
892
893 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
894 verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, false, m_verifierType);
895 }
896 {
897 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
898
899 gl.glEnable(GL_BLEND);
900
901 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
902 verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, true, m_verifierType);
903
904 }
905 {
906 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
907
908 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
909 {
910 if (ndx % 2 == 0)
911 gl.glEnablei(GL_BLEND, ndx);
912 else
913 gl.glDisablei(GL_BLEND, ndx);
914 }
915
916 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
917 verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, (ndx % 2 == 0), m_verifierType);
918 }
919 {
920 const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
921
922 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
923 {
924 if (ndx % 2 == 0)
925 gl.glEnablei(GL_BLEND, ndx);
926 else
927 gl.glDisablei(GL_BLEND, ndx);
928 }
929
930 gl.glEnable(GL_BLEND);
931
932 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
933 verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, true, m_verifierType);
934 }
935
936 result.setTestContextResult(m_testCtx);
937 return STOP;
938 }
939
940 class ColorMaskCase : public TestCase
941 {
942 public:
943 ColorMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType);
944
945 void init (void);
946 private:
947 IterateResult iterate (void);
948
949 const QueryType m_verifierType;
950 };
951
ColorMaskCase(Context & context,const char * name,const char * desc,QueryType verifierType)952 ColorMaskCase::ColorMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType)
953 : TestCase (context, name, desc)
954 , m_verifierType (verifierType)
955 {
956 }
957
init(void)958 void ColorMaskCase::init (void)
959 {
960 isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
961 }
962
iterate(void)963 ColorMaskCase::IterateResult ColorMaskCase::iterate (void)
964 {
965 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
966 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
967 deInt32 maxDrawBuffers = 0;
968
969 gl.enableLogging(true);
970
971 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
972 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
973
974 {
975 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
976
977 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
978 verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(true), m_verifierType);
979 }
980 {
981 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
982
983 gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);
984
985 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
986 verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false), m_verifierType);
987 }
988 {
989 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
990
991 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
992 gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE), (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE));
993
994 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
995 verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, (ndx % 2 == 0 ? tcu::BVec4(true, false, true, false) : tcu::BVec4(false, true, false, true)), m_verifierType);
996 }
997 {
998 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
999
1000 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1001 gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE), (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE));
1002
1003 gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);
1004
1005 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1006 verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false), m_verifierType);
1007 }
1008
1009 result.setTestContextResult(m_testCtx);
1010 return STOP;
1011 }
1012
1013 class BlendFuncCase : public TestCase
1014 {
1015 public:
1016 BlendFuncCase (Context& context, const char* name, const char* desc, QueryType verifierType);
1017
1018 void init (void);
1019 private:
1020 IterateResult iterate (void);
1021
1022 const QueryType m_verifierType;
1023 };
1024
BlendFuncCase(Context & context,const char * name,const char * desc,QueryType verifierType)1025 BlendFuncCase::BlendFuncCase (Context& context, const char* name, const char* desc, QueryType verifierType)
1026 : TestCase (context, name, desc)
1027 , m_verifierType (verifierType)
1028 {
1029 }
1030
init(void)1031 void BlendFuncCase::init (void)
1032 {
1033 isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
1034 }
1035
iterate(void)1036 BlendFuncCase::IterateResult BlendFuncCase::iterate (void)
1037 {
1038 const deUint32 blendFuncs[] =
1039 {
1040 GL_ZERO,
1041 GL_ONE,
1042 GL_SRC_COLOR,
1043 GL_ONE_MINUS_SRC_COLOR,
1044 GL_DST_COLOR,
1045 GL_ONE_MINUS_DST_COLOR,
1046 GL_SRC_ALPHA,
1047 GL_ONE_MINUS_SRC_ALPHA,
1048 GL_DST_ALPHA,
1049 GL_ONE_MINUS_DST_ALPHA,
1050 GL_CONSTANT_COLOR,
1051 GL_ONE_MINUS_CONSTANT_COLOR,
1052 GL_CONSTANT_ALPHA,
1053 GL_ONE_MINUS_CONSTANT_ALPHA,
1054 GL_SRC_ALPHA_SATURATE
1055 };
1056
1057 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
1058 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
1059 deInt32 maxDrawBuffers = 0;
1060
1061 gl.enableLogging(true);
1062
1063 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
1064 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
1065
1066 {
1067 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
1068
1069 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1070 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_ONE, m_verifierType);
1071
1072 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1073 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ZERO, m_verifierType);
1074
1075 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1076 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_ONE, m_verifierType);
1077
1078 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1079 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ZERO, m_verifierType);
1080 }
1081 {
1082 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
1083
1084 gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
1085
1086 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1087 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType);
1088
1089 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1090 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType);
1091
1092 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1093 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType);
1094
1095 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1096 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType);
1097 }
1098 {
1099 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommonSeparate", "After setting common separate");
1100
1101 gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);
1102
1103 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1104 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType);
1105
1106 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1107 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType);
1108
1109 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1110 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType);
1111
1112 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1113 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType);
1114 }
1115 {
1116 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
1117
1118 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1119 gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
1120
1121 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1122 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1123
1124 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1125 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1126
1127 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1128 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1129
1130 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1131 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1132 }
1133 {
1134 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexedSeparate", "After setting indexed separate");
1135
1136 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1137 gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1138 blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1139 blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1140 blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
1141
1142 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1143 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1144
1145 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1146 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1147
1148 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1149 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1150
1151 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1152 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1153
1154 }
1155 {
1156 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
1157
1158 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1159 gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
1160
1161 gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
1162
1163 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1164 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType);
1165
1166 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1167 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType);
1168
1169 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1170 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType);
1171
1172 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1173 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType);
1174 }
1175 {
1176 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate", "After resetting indexed with common separate");
1177
1178 gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);
1179
1180 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1181 gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1182 blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1183 blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1184 blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
1185
1186 gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);
1187
1188 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1189 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType);
1190
1191 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1192 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType);
1193
1194 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1195 verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType);
1196
1197 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1198 verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType);
1199 }
1200
1201 result.setTestContextResult(m_testCtx);
1202 return STOP;
1203 }
1204
1205 class BlendEquationCase : public TestCase
1206 {
1207 public:
1208 BlendEquationCase (Context& context, const char* name, const char* desc, QueryType verifierType);
1209
1210 void init (void);
1211 private:
1212 IterateResult iterate (void);
1213
1214 const QueryType m_verifierType;
1215 };
1216
BlendEquationCase(Context & context,const char * name,const char * desc,QueryType verifierType)1217 BlendEquationCase::BlendEquationCase (Context& context, const char* name, const char* desc, QueryType verifierType)
1218 : TestCase (context, name, desc)
1219 , m_verifierType (verifierType)
1220 {
1221 }
1222
init(void)1223 void BlendEquationCase::init (void)
1224 {
1225 isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
1226 }
1227
iterate(void)1228 BlendEquationCase::IterateResult BlendEquationCase::iterate (void)
1229 {
1230 const deUint32 blendEquations[] =
1231 {
1232 GL_FUNC_ADD,
1233 GL_FUNC_SUBTRACT,
1234 GL_FUNC_REVERSE_SUBTRACT,
1235 GL_MIN,
1236 GL_MAX
1237 };
1238
1239 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
1240 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
1241 deInt32 maxDrawBuffers = 0;
1242
1243 gl.enableLogging(true);
1244
1245 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
1246 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
1247
1248 {
1249 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
1250
1251 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1252 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_ADD, m_verifierType);
1253
1254 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1255 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_ADD, m_verifierType);
1256 }
1257 {
1258 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
1259
1260 gl.glBlendEquation(GL_FUNC_SUBTRACT);
1261
1262 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1263 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1264
1265 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1266 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1267 }
1268 {
1269 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommonSeparate", "After setting common separate");
1270
1271 gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT);
1272
1273 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1274 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType);
1275
1276 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1277 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1278 }
1279 {
1280 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
1281
1282 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1283 gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]);
1284
1285 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1286 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
1287
1288 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1289 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
1290 }
1291 {
1292 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexedSeparate", "After setting indexed separate");
1293
1294 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1295 gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
1296
1297 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1298 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
1299
1300 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1301 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
1302 }
1303 {
1304 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
1305
1306 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1307 gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]);
1308
1309 gl.glBlendEquation(GL_FUNC_SUBTRACT);
1310
1311 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1312 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1313
1314 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1315 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1316 }
1317 {
1318 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate", "After resetting indexed with common separate");
1319
1320 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1321 gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
1322
1323 gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT);
1324
1325 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1326 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType);
1327
1328 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1329 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1330 }
1331
1332 result.setTestContextResult(m_testCtx);
1333 return STOP;
1334 }
1335
1336 class BlendEquationAdvancedCase : public TestCase
1337 {
1338 public:
1339 BlendEquationAdvancedCase (Context& context, const char* name, const char* desc, QueryType verifierType);
1340
1341 void init (void);
1342 private:
1343 IterateResult iterate (void);
1344
1345 const QueryType m_verifierType;
1346 };
1347
BlendEquationAdvancedCase(Context & context,const char * name,const char * desc,QueryType verifierType)1348 BlendEquationAdvancedCase::BlendEquationAdvancedCase (Context& context, const char* name, const char* desc, QueryType verifierType)
1349 : TestCase (context, name, desc)
1350 , m_verifierType (verifierType)
1351 {
1352 }
1353
init(void)1354 void BlendEquationAdvancedCase::init (void)
1355 {
1356 isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
1357 isExtensionSupported(m_context, "GL_KHR_blend_equation_advanced");
1358 }
1359
iterate(void)1360 BlendEquationAdvancedCase::IterateResult BlendEquationAdvancedCase::iterate (void)
1361 {
1362 const deUint32 blendEquations[] =
1363 {
1364 GL_FUNC_ADD,
1365 GL_FUNC_SUBTRACT,
1366 GL_FUNC_REVERSE_SUBTRACT,
1367 GL_MIN,
1368 GL_MAX
1369 };
1370
1371 const deUint32 blendEquationAdvanced[] =
1372 {
1373 GL_MULTIPLY,
1374 GL_SCREEN,
1375 GL_OVERLAY,
1376 GL_DARKEN,
1377 GL_LIGHTEN,
1378 GL_COLORDODGE,
1379 GL_COLORBURN,
1380 GL_HARDLIGHT,
1381 GL_SOFTLIGHT,
1382 GL_DIFFERENCE,
1383 GL_EXCLUSION,
1384 GL_HSL_HUE,
1385 GL_HSL_SATURATION,
1386 GL_HSL_COLOR,
1387 GL_HSL_LUMINOSITY
1388 };
1389
1390 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
1391 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
1392 deInt32 maxDrawBuffers = 0;
1393
1394 gl.enableLogging(true);
1395
1396 gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
1397 GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
1398
1399 {
1400 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
1401
1402 gl.glBlendEquation(GL_SCREEN);
1403
1404 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1405 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_SCREEN, m_verifierType);
1406
1407 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1408 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_SCREEN, m_verifierType);
1409 }
1410 {
1411 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
1412
1413 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1414 gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]);
1415
1416 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1417 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)], m_verifierType);
1418
1419 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1420 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)], m_verifierType);
1421 }
1422 {
1423 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
1424
1425 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1426 gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]);
1427
1428 gl.glBlendEquation(GL_MULTIPLY);
1429
1430 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1431 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_MULTIPLY, m_verifierType);
1432
1433 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1434 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_MULTIPLY, m_verifierType);
1435 }
1436 {
1437 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedSeparateWithCommon", "After resetting indexed separate with common");
1438
1439 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1440 gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
1441
1442 gl.glBlendEquation(GL_LIGHTEN);
1443
1444 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1445 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_LIGHTEN, m_verifierType);
1446
1447 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1448 verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_LIGHTEN, m_verifierType);
1449 }
1450
1451 result.setTestContextResult(m_testCtx);
1452 return STOP;
1453 }
1454
1455 } // anonymous
1456
IndexedStateQueryTests(Context & context)1457 IndexedStateQueryTests::IndexedStateQueryTests (Context& context)
1458 : TestCaseGroup(context, "indexed", "Indexed state queries")
1459 {
1460 }
1461
~IndexedStateQueryTests(void)1462 IndexedStateQueryTests::~IndexedStateQueryTests (void)
1463 {
1464 }
1465
init(void)1466 void IndexedStateQueryTests::init (void)
1467 {
1468 static const QueryType verifiers[] = { QUERY_INDEXED_BOOLEAN, QUERY_INDEXED_INTEGER, QUERY_INDEXED_INTEGER64 };
1469 static const QueryType vec4Verifiers[] = { QUERY_INDEXED_BOOLEAN_VEC4, QUERY_INDEXED_INTEGER_VEC4, QUERY_INDEXED_INTEGER64_VEC4 };
1470
1471 #define FOR_EACH_VERIFIER(X) \
1472 for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
1473 { \
1474 const QueryType verifier = verifiers[verifierNdx]; \
1475 const char* verifierSuffix = getVerifierSuffix(verifier); \
1476 this->addChild(X); \
1477 }
1478
1479 #define FOR_EACH_VEC4_VERIFIER(X) \
1480 for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(vec4Verifiers); ++verifierNdx) \
1481 { \
1482 const QueryType verifier = vec4Verifiers[verifierNdx]; \
1483 const char* verifierSuffix = getVerifierSuffix(verifier); \
1484 this->addChild(X); \
1485 }
1486
1487 FOR_EACH_VERIFIER(new SampleMaskCase (m_context, (std::string() + "sample_mask_value_" + verifierSuffix).c_str(), "Test SAMPLE_MASK_VALUE", verifier))
1488
1489 FOR_EACH_VERIFIER(new MinValueIndexed3Case (m_context, (std::string() + "max_compute_work_group_count_" + verifierSuffix).c_str(), "Test MAX_COMPUTE_WORK_GROUP_COUNT", GL_MAX_COMPUTE_WORK_GROUP_COUNT, tcu::IVec3(65535,65535,65535), verifier))
1490 FOR_EACH_VERIFIER(new MinValueIndexed3Case (m_context, (std::string() + "max_compute_work_group_size_" + verifierSuffix).c_str(), "Test MAX_COMPUTE_WORK_GROUP_SIZE", GL_MAX_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(128, 128, 64), verifier))
1491
1492 FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "atomic_counter_buffer_binding_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_BINDING", GL_ATOMIC_COUNTER_BUFFER_BINDING, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
1493 FOR_EACH_VERIFIER(new BufferStartCase (m_context, (std::string() + "atomic_counter_buffer_start_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_START", GL_ATOMIC_COUNTER_BUFFER_START, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
1494 FOR_EACH_VERIFIER(new BufferSizeCase (m_context, (std::string() + "atomic_counter_buffer_size_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_SIZE", GL_ATOMIC_COUNTER_BUFFER_SIZE, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
1495
1496 FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "shader_storage_buffer_binding_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_BINDING", GL_SHADER_STORAGE_BUFFER_BINDING, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
1497 FOR_EACH_VERIFIER(new BufferStartCase (m_context, (std::string() + "shader_storage_buffer_start_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_START", GL_SHADER_STORAGE_BUFFER_START, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
1498 FOR_EACH_VERIFIER(new BufferSizeCase (m_context, (std::string() + "shader_storage_buffer_size_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_SIZE", GL_SHADER_STORAGE_BUFFER_SIZE, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
1499
1500 FOR_EACH_VERIFIER(new ImageBindingNameCase (m_context, (std::string() + "image_binding_name_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_NAME", verifier))
1501 FOR_EACH_VERIFIER(new ImageBindingLevelCase (m_context, (std::string() + "image_binding_level_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LEVEL", verifier))
1502 FOR_EACH_VERIFIER(new ImageBindingLayeredCase (m_context, (std::string() + "image_binding_layered_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LAYERED", verifier))
1503 FOR_EACH_VERIFIER(new ImageBindingLayerCase (m_context, (std::string() + "image_binding_layer_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LAYER", verifier))
1504 FOR_EACH_VERIFIER(new ImageBindingAccessCase (m_context, (std::string() + "image_binding_access_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_ACCESS", verifier))
1505 FOR_EACH_VERIFIER(new ImageBindingFormatCase (m_context, (std::string() + "image_binding_format_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_FORMAT", verifier))
1506
1507 {
1508 const QueryType verifier = QUERY_INDEXED_ISENABLED;
1509 const char* verifierSuffix = getVerifierSuffix(verifier);
1510 this->addChild(new EnableBlendCase (m_context, (std::string() + "blend_" + verifierSuffix).c_str(), "BLEND", verifier));
1511 }
1512 FOR_EACH_VEC4_VERIFIER(new ColorMaskCase (m_context, (std::string() + "color_mask_" + verifierSuffix).c_str(), "COLOR_WRITEMASK", verifier))
1513 FOR_EACH_VERIFIER(new BlendFuncCase (m_context, (std::string() + "blend_func_" + verifierSuffix).c_str(), "BLEND_SRC and BLEND_DST", verifier))
1514 FOR_EACH_VERIFIER(new BlendEquationCase (m_context, (std::string() + "blend_equation_" + verifierSuffix).c_str(), "BLEND_EQUATION_RGB and BLEND_DST", verifier))
1515 FOR_EACH_VERIFIER(new BlendEquationAdvancedCase (m_context, (std::string() + "blend_equation_advanced_" + verifierSuffix).c_str(), "BLEND_EQUATION_RGB and BLEND_DST", verifier))
1516
1517 #undef FOR_EACH_VEC4_VERIFIER
1518 #undef FOR_EACH_VERIFIER
1519 }
1520
1521 } // Functional
1522 } // gles31
1523 } // deqp
1524