1 //
2 // Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 // queryutils.cpp: Utilities for querying values from GL objects
8
9 #include "libANGLE/queryutils.h"
10
11 #include "common/utilities.h"
12
13 #include "libANGLE/Buffer.h"
14 #include "libANGLE/Framebuffer.h"
15 #include "libANGLE/Program.h"
16 #include "libANGLE/Renderbuffer.h"
17 #include "libANGLE/Sampler.h"
18 #include "libANGLE/Shader.h"
19 #include "libANGLE/Texture.h"
20 #include "libANGLE/Uniform.h"
21 #include "libANGLE/VertexAttribute.h"
22
23 namespace gl
24 {
25
26 namespace
27 {
28 template <typename ParamType>
QueryTexParameterBase(const Texture * texture,GLenum pname,ParamType * params)29 void QueryTexParameterBase(const Texture *texture, GLenum pname, ParamType *params)
30 {
31 ASSERT(texture != nullptr);
32
33 switch (pname)
34 {
35 case GL_TEXTURE_MAG_FILTER:
36 *params = ConvertFromGLenum<ParamType>(texture->getMagFilter());
37 break;
38 case GL_TEXTURE_MIN_FILTER:
39 *params = ConvertFromGLenum<ParamType>(texture->getMinFilter());
40 break;
41 case GL_TEXTURE_WRAP_S:
42 *params = ConvertFromGLenum<ParamType>(texture->getWrapS());
43 break;
44 case GL_TEXTURE_WRAP_T:
45 *params = ConvertFromGLenum<ParamType>(texture->getWrapT());
46 break;
47 case GL_TEXTURE_WRAP_R:
48 *params = ConvertFromGLenum<ParamType>(texture->getWrapR());
49 break;
50 case GL_TEXTURE_IMMUTABLE_FORMAT:
51 *params = ConvertFromGLboolean<ParamType>(texture->getImmutableFormat());
52 break;
53 case GL_TEXTURE_IMMUTABLE_LEVELS:
54 *params = ConvertFromGLuint<ParamType>(texture->getImmutableLevels());
55 break;
56 case GL_TEXTURE_USAGE_ANGLE:
57 *params = ConvertFromGLenum<ParamType>(texture->getUsage());
58 break;
59 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
60 *params = ConvertFromGLfloat<ParamType>(texture->getMaxAnisotropy());
61 break;
62 case GL_TEXTURE_SWIZZLE_R:
63 *params = ConvertFromGLenum<ParamType>(texture->getSwizzleRed());
64 break;
65 case GL_TEXTURE_SWIZZLE_G:
66 *params = ConvertFromGLenum<ParamType>(texture->getSwizzleGreen());
67 break;
68 case GL_TEXTURE_SWIZZLE_B:
69 *params = ConvertFromGLenum<ParamType>(texture->getSwizzleBlue());
70 break;
71 case GL_TEXTURE_SWIZZLE_A:
72 *params = ConvertFromGLenum<ParamType>(texture->getSwizzleAlpha());
73 break;
74 case GL_TEXTURE_BASE_LEVEL:
75 *params = ConvertFromGLuint<ParamType>(texture->getBaseLevel());
76 break;
77 case GL_TEXTURE_MAX_LEVEL:
78 *params = ConvertFromGLuint<ParamType>(texture->getMaxLevel());
79 break;
80 case GL_TEXTURE_MIN_LOD:
81 *params = ConvertFromGLfloat<ParamType>(texture->getSamplerState().minLod);
82 break;
83 case GL_TEXTURE_MAX_LOD:
84 *params = ConvertFromGLfloat<ParamType>(texture->getSamplerState().maxLod);
85 break;
86 case GL_TEXTURE_COMPARE_MODE:
87 *params = ConvertFromGLenum<ParamType>(texture->getCompareMode());
88 break;
89 case GL_TEXTURE_COMPARE_FUNC:
90 *params = ConvertFromGLenum<ParamType>(texture->getCompareFunc());
91 break;
92 case GL_TEXTURE_SRGB_DECODE_EXT:
93 *params = ConvertFromGLenum<ParamType>(texture->getSRGBDecode());
94 break;
95 default:
96 UNREACHABLE();
97 break;
98 }
99 }
100
101 template <typename ParamType>
SetTexParameterBase(Texture * texture,GLenum pname,const ParamType * params)102 void SetTexParameterBase(Texture *texture, GLenum pname, const ParamType *params)
103 {
104 ASSERT(texture != nullptr);
105
106 switch (pname)
107 {
108 case GL_TEXTURE_WRAP_S:
109 texture->setWrapS(ConvertToGLenum(params[0]));
110 break;
111 case GL_TEXTURE_WRAP_T:
112 texture->setWrapT(ConvertToGLenum(params[0]));
113 break;
114 case GL_TEXTURE_WRAP_R:
115 texture->setWrapR(ConvertToGLenum(params[0]));
116 break;
117 case GL_TEXTURE_MIN_FILTER:
118 texture->setMinFilter(ConvertToGLenum(params[0]));
119 break;
120 case GL_TEXTURE_MAG_FILTER:
121 texture->setMagFilter(ConvertToGLenum(params[0]));
122 break;
123 case GL_TEXTURE_USAGE_ANGLE:
124 texture->setUsage(ConvertToGLenum(params[0]));
125 break;
126 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
127 texture->setMaxAnisotropy(ConvertToGLfloat(params[0]));
128 break;
129 case GL_TEXTURE_COMPARE_MODE:
130 texture->setCompareMode(ConvertToGLenum(params[0]));
131 break;
132 case GL_TEXTURE_COMPARE_FUNC:
133 texture->setCompareFunc(ConvertToGLenum(params[0]));
134 break;
135 case GL_TEXTURE_SWIZZLE_R:
136 texture->setSwizzleRed(ConvertToGLenum(params[0]));
137 break;
138 case GL_TEXTURE_SWIZZLE_G:
139 texture->setSwizzleGreen(ConvertToGLenum(params[0]));
140 break;
141 case GL_TEXTURE_SWIZZLE_B:
142 texture->setSwizzleBlue(ConvertToGLenum(params[0]));
143 break;
144 case GL_TEXTURE_SWIZZLE_A:
145 texture->setSwizzleAlpha(ConvertToGLenum(params[0]));
146 break;
147 case GL_TEXTURE_BASE_LEVEL:
148 texture->setBaseLevel(ConvertToGLuint(params[0]));
149 break;
150 case GL_TEXTURE_MAX_LEVEL:
151 texture->setMaxLevel(ConvertToGLuint(params[0]));
152 break;
153 case GL_TEXTURE_MIN_LOD:
154 texture->setMinLod(ConvertToGLfloat(params[0]));
155 break;
156 case GL_TEXTURE_MAX_LOD:
157 texture->setMaxLod(ConvertToGLfloat(params[0]));
158 break;
159 case GL_TEXTURE_SRGB_DECODE_EXT:
160 texture->setSRGBDecode(ConvertToGLenum(params[0]));
161 break;
162 default:
163 UNREACHABLE();
164 break;
165 }
166 }
167
168 template <typename ParamType>
QuerySamplerParameterBase(const Sampler * sampler,GLenum pname,ParamType * params)169 void QuerySamplerParameterBase(const Sampler *sampler, GLenum pname, ParamType *params)
170 {
171 switch (pname)
172 {
173 case GL_TEXTURE_MIN_FILTER:
174 *params = ConvertFromGLenum<ParamType>(sampler->getMinFilter());
175 break;
176 case GL_TEXTURE_MAG_FILTER:
177 *params = ConvertFromGLenum<ParamType>(sampler->getMagFilter());
178 break;
179 case GL_TEXTURE_WRAP_S:
180 *params = ConvertFromGLenum<ParamType>(sampler->getWrapS());
181 break;
182 case GL_TEXTURE_WRAP_T:
183 *params = ConvertFromGLenum<ParamType>(sampler->getWrapT());
184 break;
185 case GL_TEXTURE_WRAP_R:
186 *params = ConvertFromGLenum<ParamType>(sampler->getWrapR());
187 break;
188 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
189 *params = ConvertFromGLfloat<ParamType>(sampler->getMaxAnisotropy());
190 break;
191 case GL_TEXTURE_MIN_LOD:
192 *params = ConvertFromGLfloat<ParamType>(sampler->getMinLod());
193 break;
194 case GL_TEXTURE_MAX_LOD:
195 *params = ConvertFromGLfloat<ParamType>(sampler->getMaxLod());
196 break;
197 case GL_TEXTURE_COMPARE_MODE:
198 *params = ConvertFromGLenum<ParamType>(sampler->getCompareMode());
199 break;
200 case GL_TEXTURE_COMPARE_FUNC:
201 *params = ConvertFromGLenum<ParamType>(sampler->getCompareFunc());
202 break;
203 case GL_TEXTURE_SRGB_DECODE_EXT:
204 *params = ConvertFromGLenum<ParamType>(sampler->getSRGBDecode());
205 break;
206 default:
207 UNREACHABLE();
208 break;
209 }
210 }
211
212 template <typename ParamType>
SetSamplerParameterBase(Sampler * sampler,GLenum pname,const ParamType * params)213 void SetSamplerParameterBase(Sampler *sampler, GLenum pname, const ParamType *params)
214 {
215 switch (pname)
216 {
217 case GL_TEXTURE_WRAP_S:
218 sampler->setWrapS(ConvertToGLenum(params[0]));
219 break;
220 case GL_TEXTURE_WRAP_T:
221 sampler->setWrapT(ConvertToGLenum(params[0]));
222 break;
223 case GL_TEXTURE_WRAP_R:
224 sampler->setWrapR(ConvertToGLenum(params[0]));
225 break;
226 case GL_TEXTURE_MIN_FILTER:
227 sampler->setMinFilter(ConvertToGLenum(params[0]));
228 break;
229 case GL_TEXTURE_MAG_FILTER:
230 sampler->setMagFilter(ConvertToGLenum(params[0]));
231 break;
232 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
233 sampler->setMaxAnisotropy(ConvertToGLfloat(params[0]));
234 break;
235 case GL_TEXTURE_COMPARE_MODE:
236 sampler->setCompareMode(ConvertToGLenum(params[0]));
237 break;
238 case GL_TEXTURE_COMPARE_FUNC:
239 sampler->setCompareFunc(ConvertToGLenum(params[0]));
240 break;
241 case GL_TEXTURE_MIN_LOD:
242 sampler->setMinLod(ConvertToGLfloat(params[0]));
243 break;
244 case GL_TEXTURE_MAX_LOD:
245 sampler->setMaxLod(ConvertToGLfloat(params[0]));
246 break;
247 case GL_TEXTURE_SRGB_DECODE_EXT:
248 sampler->setSRGBDecode(ConvertToGLenum(params[0]));
249 break;
250 default:
251 UNREACHABLE();
252 break;
253 }
254 }
255
256 template <typename ParamType, typename CurrentDataType>
257 ParamType ConvertCurrentValue(CurrentDataType currentValue)
258 {
259 return static_cast<ParamType>(currentValue);
260 }
261
262 template <>
ConvertCurrentValue(GLfloat currentValue)263 GLint ConvertCurrentValue(GLfloat currentValue)
264 {
265 return iround<GLint>(currentValue);
266 }
267
268 template <typename ParamType, typename CurrentDataType, size_t CurrentValueCount>
QueryVertexAttribBase(const VertexAttribute & attrib,const CurrentDataType (& currentValueData)[CurrentValueCount],GLenum pname,ParamType * params)269 void QueryVertexAttribBase(const VertexAttribute &attrib,
270 const CurrentDataType (¤tValueData)[CurrentValueCount],
271 GLenum pname,
272 ParamType *params)
273 {
274 switch (pname)
275 {
276 case GL_CURRENT_VERTEX_ATTRIB:
277 for (size_t i = 0; i < CurrentValueCount; ++i)
278 {
279 params[i] = ConvertCurrentValue<ParamType>(currentValueData[i]);
280 }
281 break;
282 case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
283 *params = ConvertFromGLboolean<ParamType>(attrib.enabled);
284 break;
285 case GL_VERTEX_ATTRIB_ARRAY_SIZE:
286 *params = ConvertFromGLuint<ParamType>(attrib.size);
287 break;
288 case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
289 *params = ConvertFromGLuint<ParamType>(attrib.stride);
290 break;
291 case GL_VERTEX_ATTRIB_ARRAY_TYPE:
292 *params = ConvertFromGLenum<ParamType>(attrib.type);
293 break;
294 case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
295 *params = ConvertFromGLboolean<ParamType>(attrib.normalized);
296 break;
297 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
298 *params = ConvertFromGLuint<ParamType>(attrib.buffer.id());
299 break;
300 case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
301 *params = ConvertFromGLuint<ParamType>(attrib.divisor);
302 break;
303 case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
304 *params = ConvertFromGLboolean<ParamType>(attrib.pureInteger);
305 break;
306 default:
307 UNREACHABLE();
308 break;
309 }
310 }
311
312 template <typename ParamType>
QueryBufferParameterBase(const Buffer * buffer,GLenum pname,ParamType * params)313 void QueryBufferParameterBase(const Buffer *buffer, GLenum pname, ParamType *params)
314 {
315 ASSERT(buffer != nullptr);
316
317 switch (pname)
318 {
319 case GL_BUFFER_USAGE:
320 *params = ConvertFromGLenum<ParamType>(buffer->getUsage());
321 break;
322 case GL_BUFFER_SIZE:
323 *params = ConvertFromGLint64<ParamType>(buffer->getSize());
324 break;
325 case GL_BUFFER_ACCESS_FLAGS:
326 *params = ConvertFromGLuint<ParamType>(buffer->getAccessFlags());
327 break;
328 case GL_BUFFER_ACCESS_OES:
329 *params = ConvertFromGLenum<ParamType>(buffer->getAccess());
330 break;
331 case GL_BUFFER_MAPPED:
332 *params = ConvertFromGLboolean<ParamType>(buffer->isMapped());
333 break;
334 case GL_BUFFER_MAP_OFFSET:
335 *params = ConvertFromGLint64<ParamType>(buffer->getMapOffset());
336 break;
337 case GL_BUFFER_MAP_LENGTH:
338 *params = ConvertFromGLint64<ParamType>(buffer->getMapLength());
339 break;
340 default:
341 UNREACHABLE();
342 break;
343 }
344 }
345
346 } // anonymous namespace
347
QueryFramebufferAttachmentParameteriv(const Framebuffer * framebuffer,GLenum attachment,GLenum pname,GLint * params)348 void QueryFramebufferAttachmentParameteriv(const Framebuffer *framebuffer,
349 GLenum attachment,
350 GLenum pname,
351 GLint *params)
352 {
353 ASSERT(framebuffer);
354
355 const FramebufferAttachment *attachmentObject = framebuffer->getAttachment(attachment);
356 if (attachmentObject == nullptr)
357 {
358 // ES 2.0.25 spec pg 127 states that if the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
359 // is NONE, then querying any other pname will generate INVALID_ENUM.
360
361 // ES 3.0.2 spec pg 235 states that if the attachment type is none,
362 // GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME will return zero and be an
363 // INVALID_OPERATION for all other pnames
364
365 switch (pname)
366 {
367 case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
368 *params = GL_NONE;
369 break;
370
371 case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
372 *params = 0;
373 break;
374
375 default:
376 UNREACHABLE();
377 break;
378 }
379
380 return;
381 }
382
383 switch (pname)
384 {
385 case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
386 *params = attachmentObject->type();
387 break;
388
389 case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
390 *params = attachmentObject->id();
391 break;
392
393 case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
394 *params = attachmentObject->mipLevel();
395 break;
396
397 case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
398 *params = attachmentObject->cubeMapFace();
399 break;
400
401 case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
402 *params = attachmentObject->getRedSize();
403 break;
404
405 case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
406 *params = attachmentObject->getGreenSize();
407 break;
408
409 case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
410 *params = attachmentObject->getBlueSize();
411 break;
412
413 case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
414 *params = attachmentObject->getAlphaSize();
415 break;
416
417 case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
418 *params = attachmentObject->getDepthSize();
419 break;
420
421 case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
422 *params = attachmentObject->getStencilSize();
423 break;
424
425 case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
426 *params = attachmentObject->getComponentType();
427 break;
428
429 case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
430 *params = attachmentObject->getColorEncoding();
431 break;
432
433 case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
434 *params = attachmentObject->layer();
435 break;
436
437 default:
438 UNREACHABLE();
439 break;
440 }
441 }
442
QueryBufferParameteriv(const Buffer * buffer,GLenum pname,GLint * params)443 void QueryBufferParameteriv(const Buffer *buffer, GLenum pname, GLint *params)
444 {
445 QueryBufferParameterBase(buffer, pname, params);
446 }
447
QueryBufferParameteri64v(const Buffer * buffer,GLenum pname,GLint64 * params)448 void QueryBufferParameteri64v(const Buffer *buffer, GLenum pname, GLint64 *params)
449 {
450 QueryBufferParameterBase(buffer, pname, params);
451 }
452
QueryBufferPointerv(const Buffer * buffer,GLenum pname,void ** params)453 void QueryBufferPointerv(const Buffer *buffer, GLenum pname, void **params)
454 {
455 switch (pname)
456 {
457 case GL_BUFFER_MAP_POINTER:
458 *params = buffer->getMapPointer();
459 break;
460
461 default:
462 UNREACHABLE();
463 break;
464 }
465 }
466
QueryProgramiv(const Program * program,GLenum pname,GLint * params)467 void QueryProgramiv(const Program *program, GLenum pname, GLint *params)
468 {
469 ASSERT(program != nullptr);
470
471 switch (pname)
472 {
473 case GL_DELETE_STATUS:
474 *params = program->isFlaggedForDeletion();
475 return;
476 case GL_LINK_STATUS:
477 *params = program->isLinked();
478 return;
479 case GL_VALIDATE_STATUS:
480 *params = program->isValidated();
481 return;
482 case GL_INFO_LOG_LENGTH:
483 *params = program->getInfoLogLength();
484 return;
485 case GL_ATTACHED_SHADERS:
486 *params = program->getAttachedShadersCount();
487 return;
488 case GL_ACTIVE_ATTRIBUTES:
489 *params = program->getActiveAttributeCount();
490 return;
491 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
492 *params = program->getActiveAttributeMaxLength();
493 return;
494 case GL_ACTIVE_UNIFORMS:
495 *params = program->getActiveUniformCount();
496 return;
497 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
498 *params = program->getActiveUniformMaxLength();
499 return;
500 case GL_PROGRAM_BINARY_LENGTH_OES:
501 *params = program->getBinaryLength();
502 return;
503 case GL_ACTIVE_UNIFORM_BLOCKS:
504 *params = program->getActiveUniformBlockCount();
505 return;
506 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH:
507 *params = program->getActiveUniformBlockMaxLength();
508 break;
509 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
510 *params = program->getTransformFeedbackBufferMode();
511 break;
512 case GL_TRANSFORM_FEEDBACK_VARYINGS:
513 *params = program->getTransformFeedbackVaryingCount();
514 break;
515 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
516 *params = program->getTransformFeedbackVaryingMaxLength();
517 break;
518 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
519 *params = program->getBinaryRetrievableHint();
520 break;
521 default:
522 UNREACHABLE();
523 break;
524 }
525 }
526
QueryRenderbufferiv(const Renderbuffer * renderbuffer,GLenum pname,GLint * params)527 void QueryRenderbufferiv(const Renderbuffer *renderbuffer, GLenum pname, GLint *params)
528 {
529 ASSERT(renderbuffer != nullptr);
530
531 switch (pname)
532 {
533 case GL_RENDERBUFFER_WIDTH:
534 *params = renderbuffer->getWidth();
535 break;
536 case GL_RENDERBUFFER_HEIGHT:
537 *params = renderbuffer->getHeight();
538 break;
539 case GL_RENDERBUFFER_INTERNAL_FORMAT:
540 *params = renderbuffer->getFormat().info->internalFormat;
541 break;
542 case GL_RENDERBUFFER_RED_SIZE:
543 *params = renderbuffer->getRedSize();
544 break;
545 case GL_RENDERBUFFER_GREEN_SIZE:
546 *params = renderbuffer->getGreenSize();
547 break;
548 case GL_RENDERBUFFER_BLUE_SIZE:
549 *params = renderbuffer->getBlueSize();
550 break;
551 case GL_RENDERBUFFER_ALPHA_SIZE:
552 *params = renderbuffer->getAlphaSize();
553 break;
554 case GL_RENDERBUFFER_DEPTH_SIZE:
555 *params = renderbuffer->getDepthSize();
556 break;
557 case GL_RENDERBUFFER_STENCIL_SIZE:
558 *params = renderbuffer->getStencilSize();
559 break;
560 case GL_RENDERBUFFER_SAMPLES_ANGLE:
561 *params = renderbuffer->getSamples();
562 break;
563 default:
564 UNREACHABLE();
565 break;
566 }
567 }
568
QueryShaderiv(const Shader * shader,GLenum pname,GLint * params)569 void QueryShaderiv(const Shader *shader, GLenum pname, GLint *params)
570 {
571 ASSERT(shader != nullptr);
572
573 switch (pname)
574 {
575 case GL_SHADER_TYPE:
576 *params = shader->getType();
577 return;
578 case GL_DELETE_STATUS:
579 *params = shader->isFlaggedForDeletion();
580 return;
581 case GL_COMPILE_STATUS:
582 *params = shader->isCompiled() ? GL_TRUE : GL_FALSE;
583 return;
584 case GL_INFO_LOG_LENGTH:
585 *params = shader->getInfoLogLength();
586 return;
587 case GL_SHADER_SOURCE_LENGTH:
588 *params = shader->getSourceLength();
589 return;
590 case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
591 *params = shader->getTranslatedSourceWithDebugInfoLength();
592 return;
593 default:
594 UNREACHABLE();
595 break;
596 }
597 }
598
QueryTexParameterfv(const Texture * texture,GLenum pname,GLfloat * params)599 void QueryTexParameterfv(const Texture *texture, GLenum pname, GLfloat *params)
600 {
601 QueryTexParameterBase(texture, pname, params);
602 }
603
QueryTexParameteriv(const Texture * texture,GLenum pname,GLint * params)604 void QueryTexParameteriv(const Texture *texture, GLenum pname, GLint *params)
605 {
606 QueryTexParameterBase(texture, pname, params);
607 }
608
QuerySamplerParameterfv(const Sampler * sampler,GLenum pname,GLfloat * params)609 void QuerySamplerParameterfv(const Sampler *sampler, GLenum pname, GLfloat *params)
610 {
611 QuerySamplerParameterBase(sampler, pname, params);
612 }
613
QuerySamplerParameteriv(const Sampler * sampler,GLenum pname,GLint * params)614 void QuerySamplerParameteriv(const Sampler *sampler, GLenum pname, GLint *params)
615 {
616 QuerySamplerParameterBase(sampler, pname, params);
617 }
618
QueryVertexAttribfv(const VertexAttribute & attrib,const VertexAttribCurrentValueData & currentValueData,GLenum pname,GLfloat * params)619 void QueryVertexAttribfv(const VertexAttribute &attrib,
620 const VertexAttribCurrentValueData ¤tValueData,
621 GLenum pname,
622 GLfloat *params)
623 {
624 QueryVertexAttribBase(attrib, currentValueData.FloatValues, pname, params);
625 }
626
QueryVertexAttribiv(const VertexAttribute & attrib,const VertexAttribCurrentValueData & currentValueData,GLenum pname,GLint * params)627 void QueryVertexAttribiv(const VertexAttribute &attrib,
628 const VertexAttribCurrentValueData ¤tValueData,
629 GLenum pname,
630 GLint *params)
631 {
632 QueryVertexAttribBase(attrib, currentValueData.FloatValues, pname, params);
633 }
634
QueryVertexAttribPointerv(const VertexAttribute & attrib,GLenum pname,GLvoid ** pointer)635 void QueryVertexAttribPointerv(const VertexAttribute &attrib, GLenum pname, GLvoid **pointer)
636 {
637 switch (pname)
638 {
639 case GL_VERTEX_ATTRIB_ARRAY_POINTER:
640 *pointer = const_cast<GLvoid *>(attrib.pointer);
641 break;
642
643 default:
644 UNREACHABLE();
645 break;
646 }
647 }
648
QueryVertexAttribIiv(const VertexAttribute & attrib,const VertexAttribCurrentValueData & currentValueData,GLenum pname,GLint * params)649 void QueryVertexAttribIiv(const VertexAttribute &attrib,
650 const VertexAttribCurrentValueData ¤tValueData,
651 GLenum pname,
652 GLint *params)
653 {
654 QueryVertexAttribBase(attrib, currentValueData.IntValues, pname, params);
655 }
656
QueryVertexAttribIuiv(const VertexAttribute & attrib,const VertexAttribCurrentValueData & currentValueData,GLenum pname,GLuint * params)657 void QueryVertexAttribIuiv(const VertexAttribute &attrib,
658 const VertexAttribCurrentValueData ¤tValueData,
659 GLenum pname,
660 GLuint *params)
661 {
662 QueryVertexAttribBase(attrib, currentValueData.UnsignedIntValues, pname, params);
663 }
664
QueryActiveUniformBlockiv(const Program * program,GLuint uniformBlockIndex,GLenum pname,GLint * params)665 void QueryActiveUniformBlockiv(const Program *program,
666 GLuint uniformBlockIndex,
667 GLenum pname,
668 GLint *params)
669 {
670 const UniformBlock &uniformBlock = program->getUniformBlockByIndex(uniformBlockIndex);
671 switch (pname)
672 {
673 case GL_UNIFORM_BLOCK_BINDING:
674 *params = ConvertToGLint(program->getUniformBlockBinding(uniformBlockIndex));
675 break;
676 case GL_UNIFORM_BLOCK_DATA_SIZE:
677 *params = ConvertToGLint(uniformBlock.dataSize);
678 break;
679 case GL_UNIFORM_BLOCK_NAME_LENGTH:
680 *params = ConvertToGLint(uniformBlock.nameWithArrayIndex().size() + 1);
681 break;
682 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
683 *params = ConvertToGLint(uniformBlock.memberUniformIndexes.size());
684 break;
685 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
686 for (size_t blockMemberIndex = 0;
687 blockMemberIndex < uniformBlock.memberUniformIndexes.size(); blockMemberIndex++)
688 {
689 params[blockMemberIndex] =
690 ConvertToGLint(uniformBlock.memberUniformIndexes[blockMemberIndex]);
691 }
692 break;
693 case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
694 *params = ConvertToGLint(uniformBlock.vertexStaticUse);
695 break;
696 case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
697 *params = ConvertToGLint(uniformBlock.fragmentStaticUse);
698 break;
699 default:
700 UNREACHABLE();
701 break;
702 }
703 }
704
QueryInternalFormativ(const TextureCaps & format,GLenum pname,GLsizei bufSize,GLint * params)705 void QueryInternalFormativ(const TextureCaps &format, GLenum pname, GLsizei bufSize, GLint *params)
706 {
707 switch (pname)
708 {
709 case GL_NUM_SAMPLE_COUNTS:
710 if (bufSize != 0)
711 {
712 *params = static_cast<GLint>(format.sampleCounts.size());
713 }
714 break;
715
716 case GL_SAMPLES:
717 {
718 size_t returnCount = std::min<size_t>(bufSize, format.sampleCounts.size());
719 auto sampleReverseIt = format.sampleCounts.rbegin();
720 for (size_t sampleIndex = 0; sampleIndex < returnCount; ++sampleIndex)
721 {
722 params[sampleIndex] = *sampleReverseIt++;
723 }
724 }
725 break;
726
727 default:
728 UNREACHABLE();
729 break;
730 }
731 }
732
SetTexParameterf(Texture * texture,GLenum pname,GLfloat param)733 void SetTexParameterf(Texture *texture, GLenum pname, GLfloat param)
734 {
735 SetTexParameterBase(texture, pname, ¶m);
736 }
737
SetTexParameterfv(Texture * texture,GLenum pname,const GLfloat * params)738 void SetTexParameterfv(Texture *texture, GLenum pname, const GLfloat *params)
739 {
740 SetTexParameterBase(texture, pname, params);
741 }
742
SetTexParameteri(Texture * texture,GLenum pname,GLint param)743 void SetTexParameteri(Texture *texture, GLenum pname, GLint param)
744 {
745 SetTexParameterBase(texture, pname, ¶m);
746 }
747
SetTexParameteriv(Texture * texture,GLenum pname,const GLint * params)748 void SetTexParameteriv(Texture *texture, GLenum pname, const GLint *params)
749 {
750 SetTexParameterBase(texture, pname, params);
751 }
752
SetSamplerParameterf(Sampler * sampler,GLenum pname,GLfloat param)753 void SetSamplerParameterf(Sampler *sampler, GLenum pname, GLfloat param)
754 {
755 SetSamplerParameterBase(sampler, pname, ¶m);
756 }
757
SetSamplerParameterfv(Sampler * sampler,GLenum pname,const GLfloat * params)758 void SetSamplerParameterfv(Sampler *sampler, GLenum pname, const GLfloat *params)
759 {
760 SetSamplerParameterBase(sampler, pname, params);
761 }
762
SetSamplerParameteri(Sampler * sampler,GLenum pname,GLint param)763 void SetSamplerParameteri(Sampler *sampler, GLenum pname, GLint param)
764 {
765 SetSamplerParameterBase(sampler, pname, ¶m);
766 }
767
SetSamplerParameteriv(Sampler * sampler,GLenum pname,const GLint * params)768 void SetSamplerParameteriv(Sampler *sampler, GLenum pname, const GLint *params)
769 {
770 SetSamplerParameterBase(sampler, pname, params);
771 }
772 }
773