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 (&currentValueData)[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 &currentValueData,
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 &currentValueData,
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 &currentValueData,
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 &currentValueData,
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, &param);
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, &param);
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, &param);
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, &param);
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