queryutils.cpp | Explore in Territory

//
// Copyright 2016 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// queryutils.cpp: Utilities for querying values from GL objects

#include "libANGLE/queryutils.h"

#include <algorithm>

#include "common/utilities.h"

#include "libANGLE/Buffer.h"
#include "libANGLE/Config.h"
#include "libANGLE/Context.h"
#include "libANGLE/Display.h"
#include "libANGLE/EGLSync.h"
#include "libANGLE/Fence.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/GLES1State.h"
#include "libANGLE/MemoryObject.h"
#include "libANGLE/Program.h"
#include "libANGLE/Renderbuffer.h"
#include "libANGLE/Sampler.h"
#include "libANGLE/Shader.h"
#include "libANGLE/Surface.h"
#include "libANGLE/Texture.h"
#include "libANGLE/Uniform.h"
#include "libANGLE/VertexAttribute.h"
#include "libANGLE/queryconversions.h"

namespace gl
{

namespace
{

template <bool isPureInteger>
ColorGeneric ConvertToColor(const GLfloat *params)
{ … }

template <bool isPureInteger>
ColorGeneric ConvertToColor(const GLint *params)
{ … }

template <bool isPureInteger>
ColorGeneric ConvertToColor(const GLuint *params)
{ … }

template <bool isPureInteger>
void ConvertFromColor(const ColorGeneric &color, GLfloat *outParams)
{ … }

template <bool isPureInteger>
void ConvertFromColor(const ColorGeneric &color, GLint *outParams)
{ … }

template <bool isPureInteger>
void ConvertFromColor(const ColorGeneric &color, GLuint *outParams)
{ … }

template <typename ParamType>
void QueryTexLevelParameterBase(const Texture *texture,
                                TextureTarget target,
                                GLint level,
                                GLenum pname,
                                ParamType *params)
{ … }

// This function is needed to handle fixed_point data.
// It can be used when some pname need special conversion from int/float/bool to fixed_point.
template <bool isGLfixed, typename QueryT, typename ParamType>
QueryT CastFromSpecialValue(GLenum pname, const ParamType param)
{ … }

template <bool isPureInteger, bool isGLfixed, typename ParamType>
void QueryTexParameterBase(const Context *context,
                           const Texture *texture,
                           GLenum pname,
                           ParamType *params)
{ … }

// this function is needed to handle OES_FIXED_POINT.
// Some pname values can take in GLfixed values and may need to be converted
template <bool isGLfixed, typename ReturnType, typename ParamType>
ReturnType ConvertTexParam(GLenum pname, const ParamType param)
{ … }

template <bool isPureInteger, bool isGLfixed, typename ParamType>
void SetTexParameterBase(Context *context, Texture *texture, GLenum pname, const ParamType *params)
{ … }

template <bool isPureInteger, typename ParamType>
void QuerySamplerParameterBase(const Sampler *sampler, GLenum pname, ParamType *params)
{ … }

template <bool isPureInteger, typename ParamType>
void SetSamplerParameterBase(Context *context,
                             Sampler *sampler,
                             GLenum pname,
                             const ParamType *params)
{ … }

// Warning: you should ensure binding really matches attrib.bindingIndex before using this function.
template <typename ParamType, typename CurrentDataType, size_t CurrentValueCount>
void QueryVertexAttribBase(const VertexAttribute &attrib,
                           const VertexBinding &binding,
                           const CurrentDataType (&currentValueData)[CurrentValueCount],
                           GLenum pname,
                           ParamType *params)
{ … }

template <typename ParamType>
void QueryBufferParameterBase(const Buffer *buffer, GLenum pname, ParamType *params)
{ … }

template <typename T>
GLint GetCommonVariableProperty(const T &var, GLenum prop)
{ … }

GLint GetInputResourceProperty(const Program *program, GLuint index, GLenum prop)
{ … }

GLint GetOutputResourceProperty(const Program *program, GLuint index, const GLenum prop)
{ … }

GLint GetTransformFeedbackVaryingResourceProperty(const Program *program,
                                                  GLuint index,
                                                  const GLenum prop)
{ … }

GLint QueryProgramInterfaceActiveResources(const Program *program, GLenum programInterface)
{ … }

template <typename T, typename M>
GLint FindMaxSize(const std::vector<T> &resources, M member)
{ … }

GLint FindMaxNameLength(const std::vector<std::string> &names)
{ … }

GLint QueryProgramInterfaceMaxNameLength(const Program *program, GLenum programInterface)
{ … }

GLint QueryProgramInterfaceMaxNumActiveVariables(const Program *program, GLenum programInterface)
{ … }

GLenum GetUniformPropertyEnum(GLenum prop)
{ … }

GLenum GetUniformBlockPropertyEnum(GLenum prop)
{ … }

template <typename ShaderVariableT>
void GetShaderVariableBufferResourceProperty(const ShaderVariableT &buffer,
                                             GLenum pname,
                                             GLint *params,
                                             GLsizei bufSize,
                                             GLsizei *outputPosition)

{ … }

void GetInterfaceBlockResourceProperty(const InterfaceBlock &block,
                                       GLenum pname,
                                       GLint *params,
                                       GLsizei bufSize,
                                       GLsizei *outputPosition)
{ … }

void GetUniformBlockResourceProperty(const Program *program,
                                     GLuint blockIndex,
                                     GLenum pname,
                                     GLint *params,
                                     GLsizei bufSize,
                                     GLsizei *outputPosition)

{ … }

void GetShaderStorageBlockResourceProperty(const Program *program,
                                           GLuint blockIndex,
                                           GLenum pname,
                                           GLint *params,
                                           GLsizei bufSize,
                                           GLsizei *outputPosition)

{ … }

void GetAtomicCounterBufferResourceProperty(const Program *program,
                                            GLuint index,
                                            GLenum pname,
                                            GLint *params,
                                            GLsizei bufSize,
                                            GLsizei *outputPosition)

{ … }

bool IsTextureEnvEnumParameter(TextureEnvParameter pname)
{ … }

void GetShaderProgramId(ProgramPipeline *programPipeline, ShaderType shaderType, GLint *params)
{ … }

}  // namespace

void QueryFramebufferAttachmentParameteriv(const Context *context,
                                           const Framebuffer *framebuffer,
                                           GLenum attachment,
                                           GLenum pname,
                                           GLint *params)
{ … }

void QueryBufferParameteriv(const Buffer *buffer, GLenum pname, GLint *params)
{ … }

void QueryBufferParameteri64v(const Buffer *buffer, GLenum pname, GLint64 *params)
{ … }

void QueryBufferPointerv(const Buffer *buffer, GLenum pname, void **params)
{ … }

void QueryProgramiv(Context *context, Program *program, GLenum pname, GLint *params)
{ … }

void QueryRenderbufferiv(const Context *context,
                         const Renderbuffer *renderbuffer,
                         GLenum pname,
                         GLint *params)
{ … }

void QueryShaderiv(const Context *context, Shader *shader, GLenum pname, GLint *params)
{ … }

void QueryTexLevelParameterfv(const Texture *texture,
                              TextureTarget target,
                              GLint level,
                              GLenum pname,
                              GLfloat *params)
{ … }

void QueryTexLevelParameteriv(const Texture *texture,
                              TextureTarget target,
                              GLint level,
                              GLenum pname,
                              GLint *params)
{ … }

void QueryTexParameterfv(const Context *context,
                         const Texture *texture,
                         GLenum pname,
                         GLfloat *params)
{ … }

void QueryTexParameterxv(const Context *context,
                         const Texture *texture,
                         GLenum pname,
                         GLfixed *params)
{ … }

void QueryTexParameteriv(const Context *context,
                         const Texture *texture,
                         GLenum pname,
                         GLint *params)
{ … }

void QueryTexParameterIiv(const Context *context,
                          const Texture *texture,
                          GLenum pname,
                          GLint *params)
{ … }

void QueryTexParameterIuiv(const Context *context,
                           const Texture *texture,
                           GLenum pname,
                           GLuint *params)
{ … }

void QuerySamplerParameterfv(const Sampler *sampler, GLenum pname, GLfloat *params)
{ … }

void QuerySamplerParameteriv(const Sampler *sampler, GLenum pname, GLint *params)
{ … }

void QuerySamplerParameterIiv(const Sampler *sampler, GLenum pname, GLint *params)
{ … }

void QuerySamplerParameterIuiv(const Sampler *sampler, GLenum pname, GLuint *params)
{ … }

void QueryVertexAttribfv(const VertexAttribute &attrib,
                         const VertexBinding &binding,
                         const VertexAttribCurrentValueData &currentValueData,
                         GLenum pname,
                         GLfloat *params)
{ … }

void QueryVertexAttribiv(const VertexAttribute &attrib,
                         const VertexBinding &binding,
                         const VertexAttribCurrentValueData &currentValueData,
                         GLenum pname,
                         GLint *params)
{ … }

void QueryVertexAttribPointerv(const VertexAttribute &attrib, GLenum pname, void **pointer)
{ … }

void QueryVertexAttribIiv(const VertexAttribute &attrib,
                          const VertexBinding &binding,
                          const VertexAttribCurrentValueData &currentValueData,
                          GLenum pname,
                          GLint *params)
{ … }

void QueryVertexAttribIuiv(const VertexAttribute &attrib,
                           const VertexBinding &binding,
                           const VertexAttribCurrentValueData &currentValueData,
                           GLenum pname,
                           GLuint *params)
{ … }

void QueryActiveUniformBlockiv(const Program *program,
                               UniformBlockIndex uniformBlockIndex,
                               GLenum pname,
                               GLint *params)
{ … }

void QueryInternalFormativ(const TextureCaps &format, GLenum pname, GLsizei bufSize, GLint *params)
{ … }

void QueryFramebufferParameteriv(const Framebuffer *framebuffer, GLenum pname, GLint *params)
{ … }

angle::Result QuerySynciv(const Context *context,
                          const Sync *sync,
                          GLenum pname,
                          GLsizei bufSize,
                          GLsizei *length,
                          GLint *values)
{ … }

void SetTexParameterx(Context *context, Texture *texture, GLenum pname, GLfixed param)
{ … }

void SetTexParameterxv(Context *context, Texture *texture, GLenum pname, const GLfixed *params)
{ … }

void SetTexParameterf(Context *context, Texture *texture, GLenum pname, GLfloat param)
{ … }

void SetTexParameterfv(Context *context, Texture *texture, GLenum pname, const GLfloat *params)
{ … }

void SetTexParameteri(Context *context, Texture *texture, GLenum pname, GLint param)
{ … }

void SetTexParameteriv(Context *context, Texture *texture, GLenum pname, const GLint *params)
{ … }

void SetTexParameterIiv(Context *context, Texture *texture, GLenum pname, const GLint *params)
{ … }

void SetTexParameterIuiv(Context *context, Texture *texture, GLenum pname, const GLuint *params)
{ … }

void SetSamplerParameterf(Context *context, Sampler *sampler, GLenum pname, GLfloat param)
{ … }

void SetSamplerParameterfv(Context *context, Sampler *sampler, GLenum pname, const GLfloat *params)
{ … }

void SetSamplerParameteri(Context *context, Sampler *sampler, GLenum pname, GLint param)
{ … }

void SetSamplerParameteriv(Context *context, Sampler *sampler, GLenum pname, const GLint *params)
{ … }

void SetSamplerParameterIiv(Context *context, Sampler *sampler, GLenum pname, const GLint *params)
{ … }

void SetSamplerParameterIuiv(Context *context, Sampler *sampler, GLenum pname, const GLuint *params)
{ … }

void SetFramebufferParameteri(const Context *context,
                              Framebuffer *framebuffer,
                              GLenum pname,
                              GLint param)
{ … }

void SetProgramParameteri(const Context *context, Program *program, GLenum pname, GLint value)
{ … }

GLint GetUniformResourceProperty(const Program *program, GLuint index, const GLenum prop)
{ … }

GLint GetBufferVariableResourceProperty(const Program *program, GLuint index, const GLenum prop)
{ … }

GLuint QueryProgramResourceIndex(const Program *program,
                                 GLenum programInterface,
                                 const GLchar *name)
{ … }

void QueryProgramResourceName(const Context *context,
                              const Program *program,
                              GLenum programInterface,
                              GLuint index,
                              GLsizei bufSize,
                              GLsizei *length,
                              GLchar *name)
{ … }

GLint QueryProgramResourceLocation(const Program *program,
                                   GLenum programInterface,
                                   const GLchar *name)
{ … }

void QueryProgramResourceiv(const Program *program,
                            GLenum programInterface,
                            UniformBlockIndex index,
                            GLsizei propCount,
                            const GLenum *props,
                            GLsizei bufSize,
                            GLsizei *length,
                            GLint *params)
{ … }

void QueryProgramInterfaceiv(const Program *program,
                             GLenum programInterface,
                             GLenum pname,
                             GLint *params)
{ … }

angle::Result SetMemoryObjectParameteriv(const Context *context,
                                         MemoryObject *memoryObject,
                                         GLenum pname,
                                         const GLint *params)
{ … }

void QueryMemoryObjectParameteriv(const MemoryObject *memoryObject, GLenum pname, GLint *params)
{ … }

ClientVertexArrayType ParamToVertexArrayType(GLenum param)
{ … }

void SetLightModelParameters(GLES1State *state, GLenum pname, const GLfloat *params)
{ … }

void GetLightModelParameters(const GLES1State *state, GLenum pname, GLfloat *params)
{ … }

bool IsLightModelTwoSided(const GLES1State *state)
{ … }

void SetLightParameters(GLES1State *state,
                        GLenum light,
                        LightParameter pname,
                        const GLfloat *params)
{ … }

void GetLightParameters(const GLES1State *state,
                        GLenum light,
                        LightParameter pname,
                        GLfloat *params)
{ … }

void SetMaterialParameters(GLES1State *state,
                           GLenum face,
                           MaterialParameter pname,
                           const GLfloat *params)
{ … }

void GetMaterialParameters(const GLES1State *state,
                           GLenum face,
                           MaterialParameter pname,
                           GLfloat *params)
{ … }

unsigned int GetLightModelParameterCount(GLenum pname)
{ … }

unsigned int GetLightParameterCount(LightParameter pname)
{ … }

unsigned int GetMaterialParameterCount(MaterialParameter pname)
{ … }

void SetFogParameters(GLES1State *state, GLenum pname, const GLfloat *params)
{ … }

void GetFogParameters(const GLES1State *state, GLenum pname, GLfloat *params)
{ … }

unsigned int GetFogParameterCount(GLenum pname)
{ … }

unsigned int GetTextureEnvParameterCount(TextureEnvParameter pname)
{ … }

void ConvertTextureEnvFromInt(TextureEnvParameter pname, const GLint *input, GLfloat *output)
{ … }

void ConvertTextureEnvFromFixed(TextureEnvParameter pname, const GLfixed *input, GLfloat *output)
{ … }

void ConvertTextureEnvToInt(TextureEnvParameter pname, const GLfloat *input, GLint *output)
{ … }

void ConvertTextureEnvToFixed(TextureEnvParameter pname, const GLfloat *input, GLfixed *output)
{ … }

void SetTextureEnv(unsigned int unit,
                   GLES1State *state,
                   TextureEnvTarget target,
                   TextureEnvParameter pname,
                   const GLfloat *params)
{ … }

void GetTextureEnv(unsigned int unit,
                   const GLES1State *state,
                   TextureEnvTarget target,
                   TextureEnvParameter pname,
                   GLfloat *params)
{ … }

unsigned int GetPointParameterCount(PointParameter pname)
{ … }

void SetPointParameter(GLES1State *state, PointParameter pname, const GLfloat *params)
{ … }

void GetPointParameter(const GLES1State *state, PointParameter pname, GLfloat *params)
{ … }

void SetPointSize(GLES1State *state, GLfloat size)
{ … }

void GetPointSize(const GLES1State *state, GLfloat *sizeOut)
{ … }

unsigned int GetTexParameterCount(GLenum pname)
{ … }

bool GetQueryParameterInfo(const State &glState,
                           GLenum pname,
                           GLenum *type,
                           unsigned int *numParams)
{ … }

void QueryProgramPipelineiv(const Context *context,
                            ProgramPipeline *programPipeline,
                            GLenum pname,
                            GLint *params)
{ … }

}  // namespace gl

namespace egl
{

void QueryConfigAttrib(const Config *config, EGLint attribute, EGLint *value)
{ … }

void QueryContextAttrib(const gl::Context *context, EGLint attribute, EGLint *value)
{ … }

egl::Error QuerySurfaceAttrib(const Display *display,
                              const gl::Context *context,
                              Surface *surface,
                              EGLint attribute,
                              EGLint *value)
{ … }

egl::Error QuerySurfaceAttrib64KHR(const Display *display,
                                   const gl::Context *context,
                                   Surface *surface,
                                   EGLint attribute,
                                   EGLAttribKHR *value)
{ … }

egl::Error SetSurfaceAttrib(Surface *surface, EGLint attribute, EGLint value)
{ … }

Error GetSyncAttrib(Display *display, SyncID sync, EGLint attribute, EGLint *value)
{ … }
}  // namespace egl
chromium/third_party/angle/src/libANGLE/queryutils.cpp
