1 /*-------------------------------------------------------------------------
2 * OpenGL Conformance Test Suite
3 * -----------------------------
4 *
5 * Copyright (c) 2014-2016 The Khronos Group Inc.
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
22 */ /*-------------------------------------------------------------------*/
23
24 /*!
25 * \file esextcTextureBorderClampParameterTextureBorderColor.cpp
26 * \brief Verify that GL_TEXTURE_BORDER_COLOR_EXT state is correctly retrieved
27 * by glGetSamplerParameter*() and glGetTexParameter*() functions. (Test 6)
28 */ /*-------------------------------------------------------------------*/
29
30 #include "esextcTextureBorderClampParameterTextureBorderColor.hpp"
31 #include "gluContextInfo.hpp"
32 #include "gluDefs.hpp"
33 #include "glwEnums.hpp"
34 #include "glwFunctions.hpp"
35 #include "tcuTestLog.hpp"
36 #include <vector>
37
38 namespace glcts
39 {
40
41 /* Max number of elements in buffers allocated by the test */
42 const glw::GLuint TextureBorderClampParameterTextureBorderColor::m_buffer_length = 4;
43 /* Index of texture unit used in the test */
44 const glw::GLuint TextureBorderClampParameterTextureBorderColor::m_texture_unit_index = 0;
45
46 /** Constructor
47 *
48 * @param context Test context
49 * @param name Test case's name
50 * @param description Test case's description
51 **/
TextureBorderClampParameterTextureBorderColor(Context & context,const ExtParameters & extParams,const char * name,const char * description)52 TextureBorderClampParameterTextureBorderColor::TextureBorderClampParameterTextureBorderColor(
53 Context& context, const ExtParameters& extParams, const char* name, const char* description)
54 : TextureBorderClampBase(context, extParams, name, description), m_sampler_id(0), m_to_id(0)
55 {
56 /* Left blank on purpose */
57 }
58
59 /** Deinitializes GLES objects created during the test. */
deinit(void)60 void TextureBorderClampParameterTextureBorderColor::deinit(void)
61 {
62 /* Get GL entry points */
63 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
64
65 for (glw::GLuint i = 0; i < m_texture_targets.size(); ++i)
66 {
67 gl.bindTexture(m_texture_targets[i], 0);
68
69 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding texture object!");
70 }
71
72 gl.bindSampler(m_texture_unit_index, 0);
73 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding sampler object to texture unit!");
74
75 if (m_to_id != 0)
76 {
77 gl.deleteTextures(1, &m_to_id);
78
79 m_to_id = 0;
80 }
81
82 if (m_sampler_id != 0)
83 {
84 gl.deleteSamplers(1, &m_sampler_id);
85
86 m_sampler_id = 0;
87 }
88
89 /* Deinitialize base class */
90 TestCaseBase::deinit();
91 }
92
93 /** Initializes GLES objects used during the test. */
initTest(void)94 void TextureBorderClampParameterTextureBorderColor::initTest(void)
95 {
96 /* Check whether GL_EXT_texture_border_clamp is supported */
97 if (!m_is_texture_border_clamp_supported)
98 {
99 throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__);
100 }
101
102 /* Fill array with texture targets used in the test */
103 m_texture_targets.push_back(GL_TEXTURE_2D);
104 m_texture_targets.push_back(GL_TEXTURE_2D_ARRAY);
105 m_texture_targets.push_back(GL_TEXTURE_3D);
106 m_texture_targets.push_back(GL_TEXTURE_CUBE_MAP);
107
108 /* Also consider GL_TEXTURE_CUBE_MAP_ARRAY_EXT, but only if
109 * GL_EXT_texture_cube_map_array is supported
110 */
111 if (m_is_texture_cube_map_array_supported)
112 {
113 m_texture_targets.push_back(GL_TEXTURE_CUBE_MAP_ARRAY);
114 }
115 }
116
117 /** Executes the test.
118 *
119 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
120 *
121 * Note the function throws exception should an error occur!
122 *
123 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
124 **/
iterate(void)125 tcu::TestNode::IterateResult TextureBorderClampParameterTextureBorderColor::iterate(void)
126 {
127 initTest();
128
129 /* Get GL entry points */
130 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
131 glw::GLboolean test_passed = true;
132
133 /* Iterate through all texture targets */
134 for (glw::GLuint i = 0; i < m_texture_targets.size(); ++i)
135 {
136 gl.genTextures(1, &m_to_id);
137 GLU_EXPECT_NO_ERROR(gl.getError(), "Error generating a texture object!");
138
139 gl.bindTexture(m_texture_targets[i], m_to_id);
140 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding a texture object!");
141
142 gl.genSamplers(1, &m_sampler_id);
143 GLU_EXPECT_NO_ERROR(gl.getError(), "Error generating a sampler object!");
144
145 gl.bindSampler(m_texture_unit_index, m_sampler_id);
146 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding a sampler object to a texture unit!");
147
148 /* Verify default border color is set to (0.0, 0.0, 0.0, 0.0) and (0, 0, 0, 0) */
149 std::vector<glw::GLfloat> data_fp_zeros(m_buffer_length);
150
151 data_fp_zeros[0] = 0.0f;
152 data_fp_zeros[1] = 0.0f;
153 data_fp_zeros[2] = 0.0f;
154 data_fp_zeros[3] = 0.0f;
155
156 std::vector<glw::GLint> data_int_zeros(m_buffer_length);
157
158 data_int_zeros[0] = 0;
159 data_int_zeros[1] = 0;
160 data_int_zeros[2] = 0;
161 data_int_zeros[3] = 0;
162
163 std::vector<glw::GLuint> data_uint_zeros(m_buffer_length);
164
165 data_uint_zeros[0] = 0;
166 data_uint_zeros[1] = 0;
167 data_uint_zeros[2] = 0;
168 data_uint_zeros[3] = 0;
169
170 if (!verifyGLGetTexParameterfvResult(m_texture_targets[i], &data_fp_zeros[0]))
171 {
172 test_passed = false;
173 }
174
175 if (!verifyGLGetTexParameterivResult(m_texture_targets[i], &data_int_zeros[0]))
176 {
177 test_passed = false;
178 }
179
180 if (!verifyGLGetTexParameterIivResult(m_texture_targets[i], &data_int_zeros[0]))
181 {
182 test_passed = false;
183 }
184
185 if (!verifyGLGetTexParameterIuivResult(m_texture_targets[i], &data_uint_zeros[0]))
186 {
187 test_passed = false;
188 }
189
190 /* Verify setting signed integer border color of (-1, -2, 3, 4) using
191 * glSamplerParameterIivEXT() / glTexParameterIivEXT() call affects the values
192 * later reported by glGetSamplerParameterIivEXT() and glGetTexParameterIivEXT().
193 * These values should match.
194 */
195 std::vector<glw::GLint> data_int(m_buffer_length);
196
197 data_int[0] = -1;
198 data_int[1] = -2;
199 data_int[2] = 3;
200 data_int[3] = 4;
201
202 gl.texParameterIiv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int[0]);
203 GLU_EXPECT_NO_ERROR(gl.getError(),
204 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterIivEXT()");
205
206 if (!verifyGLGetTexParameterIivResult(m_texture_targets[i], &data_int[0]))
207 {
208 test_passed = false;
209 }
210
211 if (!verifyGLGetSamplerParameterIivResult(m_sampler_id, m_texture_targets[i], &data_int_zeros[0]))
212 {
213 test_passed = false;
214 }
215
216 gl.texParameterIiv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int_zeros[0]);
217 GLU_EXPECT_NO_ERROR(gl.getError(),
218 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterIivEXT()");
219
220 gl.samplerParameterIiv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int[0]);
221 GLU_EXPECT_NO_ERROR(gl.getError(),
222 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterIivEXT()");
223
224 if (!verifyGLGetTexParameterIivResult(m_texture_targets[i], &data_int_zeros[0]))
225 {
226 test_passed = false;
227 }
228
229 if (!verifyGLGetSamplerParameterIivResult(m_sampler_id, m_texture_targets[i], &data_int[0]))
230 {
231 test_passed = false;
232 }
233
234 gl.samplerParameterIiv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int_zeros[0]);
235 GLU_EXPECT_NO_ERROR(gl.getError(),
236 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterIivEXT()");
237
238 /* Verify setting unsigned integer border color of (1, 2, 3, 4) using
239 * glSamplerParameterIuivEXT() / glTexParameterIuivEXT() call affects the values
240 * later reported by glGetSamplerParameterIuivEXT() and glGetTexParameterIuivEXT().
241 * These values should match.
242 */
243 std::vector<glw::GLuint> data_uint(m_buffer_length);
244
245 data_uint[0] = 1;
246 data_uint[1] = 2;
247 data_uint[2] = 3;
248 data_uint[3] = 4;
249
250 gl.texParameterIuiv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_uint[0]);
251 GLU_EXPECT_NO_ERROR(gl.getError(),
252 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterIuivEXT()");
253
254 if (!verifyGLGetTexParameterIuivResult(m_texture_targets[i], &data_uint[0]))
255 {
256 test_passed = false;
257 }
258
259 if (!verifyGLGetSamplerParameterIuivResult(m_sampler_id, m_texture_targets[i], &data_uint_zeros[0]))
260 {
261 test_passed = false;
262 }
263
264 gl.texParameterIuiv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_uint_zeros[0]);
265 GLU_EXPECT_NO_ERROR(gl.getError(),
266 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterIuivEXT()");
267
268 gl.samplerParameterIuiv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_uint[0]);
269 GLU_EXPECT_NO_ERROR(gl.getError(),
270 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterIuivEXT()");
271
272 if (!verifyGLGetTexParameterIuivResult(m_texture_targets[i], &data_uint_zeros[0]))
273 {
274 test_passed = false;
275 }
276
277 if (!verifyGLGetSamplerParameterIuivResult(m_sampler_id, m_texture_targets[i], &data_uint[0]))
278 {
279 test_passed = false;
280 }
281
282 gl.samplerParameterIuiv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_uint_zeros[0]);
283 GLU_EXPECT_NO_ERROR(gl.getError(),
284 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterIuivEXT()");
285
286 /* Verify setting floating-point border color of (0.1, 0.2, 0.3, 0.4)
287 * affects the values later reported by glGetSamplerParameterfv() /
288 * glGetTexParameterfv(). These values should match.
289 */
290 std::vector<glw::GLfloat> data_fp(m_buffer_length);
291
292 data_fp[0] = 0.1f;
293 data_fp[1] = 0.2f;
294 data_fp[2] = 0.3f;
295 data_fp[3] = 0.4f;
296
297 gl.texParameterfv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_fp[0]);
298 GLU_EXPECT_NO_ERROR(gl.getError(),
299 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterfv()");
300
301 if (!verifyGLGetTexParameterfvResult(m_texture_targets[i], &data_fp[0]))
302 {
303 test_passed = false;
304 }
305
306 if (!verifyGLGetSamplerParameterfvResult(m_sampler_id, m_texture_targets[i], &data_fp_zeros[0]))
307 {
308 test_passed = false;
309 }
310
311 gl.texParameterfv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_fp_zeros[0]);
312 GLU_EXPECT_NO_ERROR(gl.getError(),
313 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterfv()");
314
315 gl.samplerParameterfv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_fp[0]);
316 GLU_EXPECT_NO_ERROR(gl.getError(),
317 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterfv()");
318
319 if (!verifyGLGetTexParameterfvResult(m_texture_targets[i], &data_fp_zeros[0]))
320 {
321 test_passed = false;
322 }
323
324 if (!verifyGLGetSamplerParameterfvResult(m_sampler_id, m_texture_targets[i], &data_fp[0]))
325 {
326 test_passed = false;
327 }
328
329 gl.samplerParameterfv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_fp_zeros[0]);
330 GLU_EXPECT_NO_ERROR(gl.getError(),
331 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterfv()");
332
333 /* Verify setting integer border color of
334 * (0, 1, 2, 4) using glSamplerParameteriv()
335 * / glTexParameteriv() affects the values later reported by
336 * glGetSamplerParameteriv() / glGetTexParameteriv(). The returned values
337 * should correspond to the outcome of equation 2.2 from ES3.0.2 spec
338 * applied to each component.
339 */
340 data_int[0] = 0;
341 data_int[1] = 1;
342 data_int[2] = 2;
343 data_int[3] = 4;
344
345 gl.texParameteriv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int[0]);
346 GLU_EXPECT_NO_ERROR(gl.getError(),
347 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameteriv()");
348
349 if (!verifyGLGetTexParameterivResult(m_texture_targets[i], &data_int[0]))
350 {
351 test_passed = false;
352 }
353
354 if (!verifyGLGetSamplerParameterivResult(m_sampler_id, m_texture_targets[i], &data_int_zeros[0]))
355 {
356 test_passed = false;
357 }
358
359 gl.texParameteriv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int_zeros[0]);
360 GLU_EXPECT_NO_ERROR(gl.getError(),
361 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameteriv()");
362
363 gl.samplerParameteriv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int[0]);
364 GLU_EXPECT_NO_ERROR(gl.getError(),
365 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameteriv()");
366
367 if (!verifyGLGetTexParameterivResult(m_texture_targets[i], &data_int_zeros[0]))
368 {
369 test_passed = false;
370 }
371
372 if (!verifyGLGetSamplerParameterivResult(m_sampler_id, m_texture_targets[i], &data_int[0]))
373 {
374 test_passed = false;
375 }
376
377 gl.samplerParameteriv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int_zeros[0]);
378 GLU_EXPECT_NO_ERROR(gl.getError(),
379 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameteriv()");
380
381 /* Deinitialize the texture object */
382 gl.bindTexture(m_texture_targets[i], 0);
383 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding texture object!");
384
385 gl.deleteTextures(1, &m_to_id);
386 m_to_id = 0;
387
388 gl.bindSampler(m_texture_unit_index, 0);
389 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding sampler object to texture unit!");
390
391 gl.deleteSamplers(1, &m_sampler_id);
392 m_sampler_id = 0;
393 }
394
395 /* Has the test passed? */
396 if (test_passed)
397 {
398 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
399 }
400 else
401 {
402 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
403 }
404
405 return STOP;
406 }
407
408 /** Check if glGetSamplerParameterfv() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
409 *
410 * @param sampler_id ID of sampler object;
411 * @param target texture target to do the call for;
412 * @param expected_data pointer to buffer with expected data
413 * @return true if both buffers are a match.
414 */
verifyGLGetSamplerParameterfvResult(glw::GLuint sampler_id,glw::GLenum target,const glw::GLfloat * expected_data)415 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetSamplerParameterfvResult(
416 glw::GLuint sampler_id, glw::GLenum target, const glw::GLfloat* expected_data)
417 {
418 std::vector<glw::GLfloat> buffer(m_buffer_length);
419 std::stringstream expectedDataStream;
420 std::stringstream returnedDataStream;
421 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
422
423 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLfloat));
424
425 gl.getSamplerParameterfv(sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
426 GLU_EXPECT_NO_ERROR(gl.getError(), "Error gettnig parameter for sampler.");
427
428 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
429 {
430 if (expected_data[i] != buffer[i])
431 {
432 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
433 {
434 expectedDataStream << expected_data[j] << ",";
435 returnedDataStream << buffer[j] << ",";
436 }
437
438 getTestContext().getLog() << tcu::TestLog::Message
439 << "Wrong value encountered when calling glGetSamplerParameterfv() with "
440 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
441 << " texture target:" << getTexTargetString(target) << "\n"
442 << " expected values:[" << expectedDataStream.str() << "]"
443 << " result values:[" << returnedDataStream.str() << "]\n"
444 << tcu::TestLog::EndMessage;
445
446 return false;
447 }
448 }
449
450 return true;
451 }
452
453 /** Check if glGetSamplerParameteriv() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
454 *
455 * @param sampler_id ID of sampler object;
456 * @param target texture target to do the call for;
457 * @param expected_data pointer to buffer with expected data
458 * @return true if both buffers are a match.
459 */
verifyGLGetSamplerParameterivResult(glw::GLuint sampler_id,glw::GLenum target,const glw::GLint * expected_data)460 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetSamplerParameterivResult(glw::GLuint sampler_id,
461 glw::GLenum target,
462 const glw::GLint* expected_data)
463 {
464 std::vector<glw::GLint> buffer(m_buffer_length);
465 std::stringstream expectedDataStream;
466 std::stringstream returnedDataStream;
467 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
468
469 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLint));
470
471 gl.getSamplerParameteriv(sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
472 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for sampler.");
473
474 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
475 {
476 if (expected_data[i] != buffer[i])
477 {
478 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
479 {
480 expectedDataStream << expected_data[j] << ",";
481 returnedDataStream << buffer[j] << ",";
482 }
483 getTestContext().getLog() << tcu::TestLog::Message
484 << "Wrong value encountered when calling glGetSamplerParameteriv() with "
485 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
486 << " texture target:" << getTexTargetString(target) << "\n"
487 << " expected values:[" << expectedDataStream.str() << "]"
488 << " result values:[" << returnedDataStream.str() << "]\n"
489 << tcu::TestLog::EndMessage;
490 return false;
491 }
492 }
493
494 return true;
495 }
496
497 /** Check if glGetSamplerParameterIivEXT() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
498 *
499 * @param sampler_id ID of sampler object;
500 * @param target texture target to do the call for;
501 * @param expected_data pointer to buffer with expected data
502 * @return true if both buffers are a match.
503 */
verifyGLGetSamplerParameterIivResult(glw::GLuint sampler_id,glw::GLenum target,const glw::GLint * expected_data)504 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetSamplerParameterIivResult(
505 glw::GLuint sampler_id, glw::GLenum target, const glw::GLint* expected_data)
506 {
507 std::vector<glw::GLint> buffer(m_buffer_length);
508 std::stringstream expectedDataStream;
509 std::stringstream returnedDataStream;
510 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
511
512 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLint));
513
514 gl.getSamplerParameterIiv(sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
515 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for sampler.");
516
517 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
518 {
519 if (expected_data[i] != buffer[i])
520 {
521 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
522 {
523 expectedDataStream << expected_data[j] << ",";
524 returnedDataStream << buffer[j] << ",";
525 }
526 getTestContext().getLog() << tcu::TestLog::Message
527 << "Wrong value encountered when calling glGetSamplerParameterIivEXT() with "
528 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
529 << " texture target:" << getTexTargetString(target) << "\n"
530 << " expected values:[" << expectedDataStream.str() << "]"
531 << " result values:[" << returnedDataStream.str() << "]\n"
532 << tcu::TestLog::EndMessage;
533 return false;
534 }
535 }
536 return true;
537 }
538
539 /** Check if glGetSamplerParameterIuivEXT() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
540 *
541 * @param sampler_id ID of sampler object;
542 * @param target texture target to do the call for;
543 * @param expected_data pointer to buffer with expected data
544 * @return true if both buffers are a match.
545 */
verifyGLGetSamplerParameterIuivResult(glw::GLuint sampler_id,glw::GLenum target,const glw::GLuint * expected_data)546 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetSamplerParameterIuivResult(
547 glw::GLuint sampler_id, glw::GLenum target, const glw::GLuint* expected_data)
548 {
549 std::vector<glw::GLuint> buffer(m_buffer_length);
550 std::stringstream expectedDataStream;
551 std::stringstream returnedDataStream;
552 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
553
554 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLuint));
555
556 gl.getSamplerParameterIuiv(sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
557 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for sampler.");
558
559 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
560 {
561 if (expected_data[i] != buffer[i])
562 {
563 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
564 {
565 expectedDataStream << expected_data[j] << ",";
566 returnedDataStream << buffer[j] << ",";
567 }
568 getTestContext().getLog() << tcu::TestLog::Message
569 << "Wrong value encountered when calling glGetSamplerParameterIuivEXT() with "
570 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
571 << " texture target:" << getTexTargetString(target) << "\n"
572 << " expected values:[" << expectedDataStream.str() << "]"
573 << " result values:[" << returnedDataStream.str() << "]\n"
574 << tcu::TestLog::EndMessage;
575 return false;
576 }
577 }
578 return true;
579 }
580
581 /** Check if glGetTexParameterfv() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
582 *
583 * @param target texture target to do the call for;
584 * @param expected_data pointer to buffer with expected data
585 * @return true if both buffers are a match.
586 */
verifyGLGetTexParameterfvResult(glw::GLenum target,const glw::GLfloat * expected_data)587 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetTexParameterfvResult(glw::GLenum target,
588 const glw::GLfloat* expected_data)
589 {
590 std::vector<glw::GLfloat> buffer(m_buffer_length);
591 std::stringstream expectedDataStream;
592 std::stringstream returnedDataStream;
593 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
594
595 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLfloat));
596
597 gl.getTexParameterfv(target, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
598 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for texture.");
599
600 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
601 {
602 if (de::abs(expected_data[i] - buffer[i]) > TestCaseBase::m_epsilon_float)
603 {
604 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
605 {
606 expectedDataStream << expected_data[j] << ",";
607 returnedDataStream << buffer[j] << ",";
608 }
609 getTestContext().getLog()
610 << tcu::TestLog::Message
611 << "Wrong value encountered when calling glGetTexParameterfv() with GL_TEXTURE_BORDER_COLOR_EXT pname;"
612 << " texture target:" << getTexTargetString(target) << "\n"
613 << " expected values:[" << expectedDataStream.str() << "]"
614 << " result values:[" << returnedDataStream.str() << "]\n"
615 << tcu::TestLog::EndMessage;
616 return false;
617 }
618 }
619 return true;
620 }
621
622 /** Check if glGetTexParameteriv() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
623 *
624 * @param target texture target to do the call for;
625 * @param expected_data pointer to buffer with expected data
626 * @return true if both buffers are a match.
627 */
verifyGLGetTexParameterivResult(glw::GLenum target,const glw::GLint * expected_data)628 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetTexParameterivResult(glw::GLenum target,
629 const glw::GLint* expected_data)
630 {
631 std::vector<glw::GLint> buffer(m_buffer_length);
632 std::stringstream expectedDataStream;
633 std::stringstream returnedDataStream;
634 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
635
636 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLint));
637
638 gl.getTexParameteriv(target, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
639 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for texture.");
640
641 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
642 {
643 if (expected_data[i] != buffer[i])
644 {
645 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
646 {
647 expectedDataStream << expected_data[j] << ",";
648 returnedDataStream << buffer[j] << ",";
649 }
650 getTestContext().getLog()
651 << tcu::TestLog::Message
652 << "Wrong value encountered when calling glGetTexParameteriv() with GL_TEXTURE_BORDER_COLOR_EXT pname;"
653 << " texture target:" << getTexTargetString(target) << "\n"
654 << " expected values:[" << expectedDataStream.str() << "]"
655 << " result values:[" << returnedDataStream.str() << "]\n"
656 << tcu::TestLog::EndMessage;
657
658 return false;
659 }
660 }
661 return true;
662 }
663
664 /** Check if glGetTexParameterIivEXT() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
665 *
666 * @param target texture target to do the call for;
667 * @param expected_data pointer to buffer with expected data
668 * @return true if both buffers are a match.
669 */
verifyGLGetTexParameterIivResult(glw::GLenum target,const glw::GLint * expected_data)670 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetTexParameterIivResult(glw::GLenum target,
671 const glw::GLint* expected_data)
672 {
673 std::vector<glw::GLint> buffer(m_buffer_length);
674 std::stringstream expectedDataStream;
675 std::stringstream returnedDataStream;
676 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
677
678 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLint));
679
680 gl.getTexParameterIiv(target, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
681 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for texture.");
682
683 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
684 {
685 if (expected_data[i] != buffer[i])
686 {
687 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
688 {
689 expectedDataStream << expected_data[j] << ",";
690 returnedDataStream << buffer[j] << ",";
691 }
692 getTestContext().getLog() << tcu::TestLog::Message
693 << "Wrong value encountered when calling glGetTexParameterIivEXT() with "
694 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
695 << " texture target:" << getTexTargetString(target) << "\n"
696 << " expected values:[" << expectedDataStream.str() << "]"
697 << " result values:[" << returnedDataStream.str() << "]\n"
698 << tcu::TestLog::EndMessage;
699
700 return false;
701 }
702 }
703 return true;
704 }
705
706 /** Check if glGetTexParameterIuivEXT() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
707 *
708 * @param target texture target to do the call for;
709 * @param expected_data pointer to buffer with expected data
710 * @return true if both buffers are a match.
711 */
verifyGLGetTexParameterIuivResult(glw::GLenum target,const glw::GLuint * expected_data)712 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetTexParameterIuivResult(glw::GLenum target,
713 const glw::GLuint* expected_data)
714 {
715 std::vector<glw::GLuint> buffer(m_buffer_length);
716 std::stringstream expectedDataStream;
717 std::stringstream returnedDataStream;
718 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
719
720 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLuint));
721
722 gl.getTexParameterIuiv(target, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
723 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for texture.");
724
725 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
726 {
727 if (expected_data[i] != buffer[i])
728 {
729 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
730 {
731 expectedDataStream << expected_data[j] << ",";
732 returnedDataStream << buffer[j] << ",";
733 }
734 getTestContext().getLog() << tcu::TestLog::Message
735 << "Wrong value encountered when calling glGetTexParameterIuivEXT() with "
736 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
737 << " texture target:" << getTexTargetString(target) << "\n"
738 << " expected values:[" << expectedDataStream.str() << "]"
739 << " result values:[" << returnedDataStream.str() << "]\n"
740 << tcu::TestLog::EndMessage;
741
742 return false;
743 }
744 }
745 return true;
746 }
747
748 } // namespace glcts
749